dineway 0.1.8 → 0.1.11

package/dist/site-context-Bpu_Paur.mjs

@@ -0,0 +1,4122 @@
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { t as ContentRepository } from "./content-CyLkb-qH.mjs";
+import { n as decodeCursor, r as encodeCursor } from "./types-Bs6lTBBW.mjs";
+import { t as SiteActivityRepository } from "./site-activity-B8FjLIVh.mjs";
+import { t as ReviewRequestRepository } from "./review-requests-C2DIHwlJ.mjs";
+import { n as normalizeEntityAlias, t as EntityAliasRepository } from "./entity-aliases-C0v-yNET.mjs";
+import { r as isPattern } from "./patterns-K0DLqWir.mjs";
+import { a as ContextRepository, i as parseSiteBriefingScope, l as handlePluginList } from "./briefing-BrXCuMEE.mjs";
+import { t as FTSManager } from "./fts-manager-B1pTNEG_.mjs";
+import { n as SchemaRegistry } from "./registry-C-_hxLqa.mjs";
+import { a as getSiteSettingsWithDb } from "./settings-4XnpVMOS.mjs";
+import { p as normalizeUrl } from "./utils-D2in-zwy.mjs";
+import { t as sanitizeWordPressImportSlug } from "./wordpress-slugs-BevajWrC.mjs";
+import { s as searchCollection } from "./search-DM6CVti3.mjs";
+import { n as assertExperimentalSiteContextWorkflowsEnabled } from "./experimental-workflows-DldxJlqV.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+import { Role } from "@dineway-ai/auth";
+
+//#region src/database/repositories/assignments.ts
+const ASSIGNMENT_ACTOR_TYPES = [
+	"user",
+	"api_token",
+	"system"
+];
+const ASSIGNMENT_STATUSES = [
+	"pending",
+	"accepted",
+	"in_progress",
+	"blocked",
+	"completed",
+	"declined",
+	"cancelled"
+];
+const ASSIGNMENT_PRIORITIES = [
+	"low",
+	"normal",
+	"high",
+	"urgent"
+];
+var AssignmentRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async create(input) {
+		const id = ulid();
+		const now = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.insertInto("_dineway_assignments").values(toInsertableAssignment(id, input, now)).execute();
+		const assignment = await this.findById(id);
+		if (!assignment) throw new Error("Failed to create assignment");
+		return assignment;
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_assignments").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? rowToAssignment(row) : null;
+	}
+	async list(query = {}) {
+		const limit = clampLimit$3(query.limit);
+		const rows = await this.queryRows(query).execute();
+		const items = rows.slice(0, limit).map(rowToAssignment);
+		const result = { items };
+		if (rows.length > limit && items.length > 0) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+		return result;
+	}
+	async accept(id, input = {}) {
+		const value = input.acceptedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, ["pending"], {
+			status: "accepted",
+			assigned_to_actor_type: input.assignedToActorType ?? null,
+			assigned_to_actor_id: input.assignedToActorId ?? null,
+			accepted_at: value,
+			updated_at: value,
+			metadata: jsonString$1(input.metadata)
+		});
+	}
+	async start(id, input = {}) {
+		const value = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, ["accepted", "blocked"], {
+			status: "in_progress",
+			started_at: value,
+			updated_at: value,
+			metadata: jsonString$1(input.metadata)
+		});
+	}
+	async block(id, input = {}) {
+		const value = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, ["accepted", "in_progress"], {
+			status: "blocked",
+			blocked_at: value,
+			updated_at: value,
+			metadata: jsonString$1(input.metadata)
+		});
+	}
+	async complete(id, input = {}) {
+		const value = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, [
+			"pending",
+			"accepted",
+			"in_progress"
+		], {
+			status: "completed",
+			completed_at: value,
+			updated_at: value,
+			metadata: jsonString$1(input.metadata)
+		});
+	}
+	async decline(id, input = {}) {
+		const value = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, ["pending", "accepted"], {
+			status: "declined",
+			declined_at: value,
+			updated_at: value,
+			metadata: jsonString$1(input.metadata)
+		});
+	}
+	async cancel(id, input = {}) {
+		const value = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, [
+			"pending",
+			"accepted",
+			"in_progress",
+			"blocked"
+		], {
+			status: "cancelled",
+			cancelled_at: value,
+			updated_at: value,
+			metadata: jsonString$1(input.metadata)
+		});
+	}
+	async linkHitlRequest(id, relatedHitlRequestId, at = (/* @__PURE__ */ new Date()).toISOString()) {
+		const result = await this.db.updateTable("_dineway_assignments").set({
+			related_hitl_request_id: relatedHitlRequestId,
+			updated_at: at
+		}).where("id", "=", id).executeTakeFirst();
+		if (Number(result.numUpdatedRows ?? 0) === 0) return null;
+		return this.findById(id);
+	}
+	queryRows(query) {
+		const limit = clampLimit$3(query.limit);
+		let q = this.db.selectFrom("_dineway_assignments").selectAll().orderBy("created_at", "desc").orderBy("id", "desc").limit(limit + 1);
+		if (query.scope) q = q.where("scope", "=", query.scope);
+		if (query.scopes && query.scopes.length > 0) q = q.where("scope", "in", query.scopes);
+		if (query.statuses && query.statuses.length > 0) q = q.where("status", "in", query.statuses);
+		if (query.priority) q = q.where("priority", "=", query.priority);
+		if (query.assignmentType) q = q.where("assignment_type", "=", query.assignmentType);
+		if (query.assignedToActorType && query.assignedToActorId) q = q.where("assigned_to_actor_type", "=", query.assignedToActorType).where("assigned_to_actor_id", "=", query.assignedToActorId);
+		if (query.assignedByActorType && query.assignedByActorId) q = q.where("assigned_by_actor_type", "=", query.assignedByActorType).where("assigned_by_actor_id", "=", query.assignedByActorId);
+		if (query.participantActor) q = q.where((eb) => eb.or([eb.and([eb("assigned_by_actor_type", "=", query.participantActor.actorType), eb("assigned_by_actor_id", "=", query.participantActor.actorId)]), eb.and([eb("assigned_to_actor_type", "=", query.participantActor.actorType), eb("assigned_to_actor_id", "=", query.participantActor.actorId)])]));
+		if (query.since) q = q.where("updated_at", ">=", query.since);
+		if (query.cursor) {
+			const decoded = decodeCursor(query.cursor);
+			if (decoded) q = q.where((eb) => eb.or([eb("created_at", "<", decoded.orderValue), eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)])]));
+		}
+		return q;
+	}
+	async transition(id, validFrom, update) {
+		const result = await this.db.updateTable("_dineway_assignments").set(update).where("id", "=", id).where("status", "in", validFrom).executeTakeFirst();
+		if (Number(result.numUpdatedRows ?? 0) === 0) return null;
+		return this.findById(id);
+	}
+};
+function toInsertableAssignment(id, input, now) {
+	return {
+		id,
+		scope: input.scope,
+		assignment_type: input.assignmentType,
+		status: "pending",
+		priority: input.priority ?? "normal",
+		title: input.title,
+		summary: input.summary ?? null,
+		details: input.details ?? null,
+		assigned_by_actor_type: input.assignedByActorType,
+		assigned_by_actor_id: input.assignedByActorId,
+		assigned_to_actor_type: input.assignedToActorType ?? null,
+		assigned_to_actor_id: input.assignedToActorId ?? null,
+		metadata: jsonString$1(input.metadata),
+		related_handoff_snapshot_id: input.relatedHandoffSnapshotId ?? null,
+		related_hitl_request_id: input.relatedHitlRequestId ?? null,
+		due_at: input.dueAt ?? null,
+		created_at: now,
+		updated_at: now,
+		accepted_at: null,
+		started_at: null,
+		blocked_at: null,
+		completed_at: null,
+		declined_at: null,
+		cancelled_at: null
+	};
+}
+function rowToAssignment(row) {
+	return {
+		id: row.id,
+		scope: row.scope,
+		assignmentType: row.assignment_type,
+		status: row.status,
+		priority: row.priority,
+		title: row.title,
+		summary: row.summary,
+		details: row.details,
+		assignedByActorType: row.assigned_by_actor_type,
+		assignedByActorId: row.assigned_by_actor_id,
+		assignedToActorType: row.assigned_to_actor_type,
+		assignedToActorId: row.assigned_to_actor_id,
+		metadata: parseRecord$2(row.metadata),
+		relatedHandoffSnapshotId: row.related_handoff_snapshot_id,
+		relatedHitlRequestId: row.related_hitl_request_id,
+		dueAt: row.due_at,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		acceptedAt: row.accepted_at,
+		startedAt: row.started_at,
+		blockedAt: row.blocked_at,
+		completedAt: row.completed_at,
+		declinedAt: row.declined_at,
+		cancelledAt: row.cancelled_at
+	};
+}
+function jsonString$1(value) {
+	return JSON.stringify(value ?? {});
+}
+function parseRecord$2(value) {
+	if (!value) return {};
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord$5(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function isRecord$5(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clampLimit$3(limit) {
+	if (!limit || limit < 1) return 50;
+	return Math.min(limit, 100);
+}
+
+//#endregion
+//#region src/database/repositories/hitl-requests.ts
+const HITL_REQUEST_STATUSES = [
+	"pending",
+	"approved",
+	"rejected"
+];
+const HITL_REQUEST_PRIORITIES = [
+	"low",
+	"normal",
+	"high",
+	"urgent"
+];
+var HitlRequestRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async create(input) {
+		const id = ulid();
+		const now = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.insertInto("_dineway_hitl_requests").values(toInsertableHitlRequest(id, input, now)).execute();
+		const request = await this.findById(id);
+		if (!request) throw new Error("Failed to create HITL request");
+		return request;
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_hitl_requests").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? rowToHitlRequest(row) : null;
+	}
+	async list(query = {}) {
+		const limit = clampLimit$2(query.limit);
+		const rows = await this.queryRows(query).execute();
+		const items = rows.slice(0, limit).map(rowToHitlRequest);
+		const result = { items };
+		if (rows.length > limit && items.length > 0) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+		return result;
+	}
+	async resolve(id, input) {
+		const resolvedAt = input.resolvedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		const result = await this.db.updateTable("_dineway_hitl_requests").set({
+			status: input.decision,
+			resolved_by_actor_type: input.resolvedByActorType,
+			resolved_by_actor_id: input.resolvedByActorId,
+			resolved_auth_metadata: jsonStringOrNull(input.resolvedAuthMetadata),
+			review_note: input.reviewNote ?? null,
+			resolved_at: resolvedAt,
+			updated_at: resolvedAt
+		}).where("id", "=", id).where("status", "=", "pending").executeTakeFirst();
+		if (Number(result.numUpdatedRows ?? 0) === 0) return null;
+		return this.findById(id);
+	}
+	queryRows(query) {
+		const limit = clampLimit$2(query.limit);
+		let q = this.db.selectFrom("_dineway_hitl_requests").selectAll().orderBy("created_at", "desc").orderBy("id", "desc").limit(limit + 1);
+		if (query.scope) q = q.where("scope", "=", query.scope);
+		if (query.scopes && query.scopes.length > 0) q = q.where("scope", "in", query.scopes);
+		if (query.statuses && query.statuses.length > 0) q = q.where("status", "in", query.statuses);
+		if (query.priority) q = q.where("priority", "=", query.priority);
+		if (query.actionType) q = q.where("action_type", "=", query.actionType);
+		if (query.targetRefType) q = q.where("target_ref_type", "=", query.targetRefType);
+		if (query.targetRefId) q = q.where("target_ref_id", "=", query.targetRefId);
+		if (query.relatedAssignmentId) q = q.where("related_assignment_id", "=", query.relatedAssignmentId);
+		if (query.requestedByActorType && query.requestedByActorId) q = q.where("requested_by_actor_type", "=", query.requestedByActorType).where("requested_by_actor_id", "=", query.requestedByActorId);
+		if (query.participantActor) q = q.where("requested_by_actor_type", "=", query.participantActor.actorType).where("requested_by_actor_id", "=", query.participantActor.actorId);
+		if (query.since) q = q.where("updated_at", ">=", query.since);
+		if (query.cursor) {
+			const decoded = decodeCursor(query.cursor);
+			if (decoded) q = q.where((eb) => eb.or([eb("created_at", "<", decoded.orderValue), eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)])]));
+		}
+		return q;
+	}
+};
+function toInsertableHitlRequest(id, input, now) {
+	return {
+		id,
+		scope: input.scope,
+		action_type: input.actionType,
+		status: "pending",
+		priority: input.priority ?? "normal",
+		title: input.title,
+		summary: input.summary ?? null,
+		risk_reason: input.riskReason,
+		review_payload: JSON.stringify(input.reviewPayload),
+		target_ref_type: input.targetRefType,
+		target_ref_id: input.targetRefId,
+		requested_by_actor_type: input.requestedByActorType,
+		requested_by_actor_id: input.requestedByActorId,
+		requested_auth_metadata: jsonStringOrNull(input.requestedAuthMetadata),
+		resolved_by_actor_type: null,
+		resolved_by_actor_id: null,
+		resolved_auth_metadata: null,
+		review_note: null,
+		metadata: jsonString(input.metadata),
+		related_assignment_id: input.relatedAssignmentId ?? null,
+		related_handoff_snapshot_id: input.relatedHandoffSnapshotId ?? null,
+		sla_due_at: input.slaDueAt ?? null,
+		created_at: now,
+		updated_at: now,
+		resolved_at: null
+	};
+}
+function rowToHitlRequest(row) {
+	return {
+		id: row.id,
+		scope: row.scope,
+		actionType: row.action_type,
+		status: row.status,
+		priority: row.priority,
+		title: row.title,
+		summary: row.summary,
+		riskReason: row.risk_reason,
+		reviewPayload: parseRecord$1(row.review_payload),
+		targetRefType: row.target_ref_type,
+		targetRefId: row.target_ref_id,
+		requestedByActorType: row.requested_by_actor_type,
+		requestedByActorId: row.requested_by_actor_id,
+		requestedAuthMetadata: parseNullableRecord(row.requested_auth_metadata),
+		resolvedByActorType: row.resolved_by_actor_type,
+		resolvedByActorId: row.resolved_by_actor_id,
+		resolvedAuthMetadata: parseNullableRecord(row.resolved_auth_metadata),
+		reviewNote: row.review_note,
+		metadata: parseRecord$1(row.metadata),
+		relatedAssignmentId: row.related_assignment_id,
+		relatedHandoffSnapshotId: row.related_handoff_snapshot_id,
+		slaDueAt: row.sla_due_at,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		resolvedAt: row.resolved_at
+	};
+}
+function jsonString(value) {
+	return JSON.stringify(value ?? {});
+}
+function jsonStringOrNull(value) {
+	return value ? JSON.stringify(value) : null;
+}
+function parseRecord$1(value) {
+	if (!value) return {};
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord$4(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function parseNullableRecord(value) {
+	if (!value) return null;
+	return parseRecord$1(value);
+}
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clampLimit$2(limit) {
+	if (!limit || limit < 1) return 50;
+	return Math.min(limit, 100);
+}
+
+//#endregion
+//#region src/site-context/context-entry-public.ts
+function toPublicContextEntry(entry) {
+	return {
+		id: entry.id,
+		scope: entry.scope,
+		contextType: entry.contextType,
+		title: entry.title,
+		body: entry.body,
+		policyKey: entry.policyKey,
+		sourceActivityId: entry.sourceActivityId,
+		createdByActorType: entry.createdByActorType,
+		createdByActorId: entry.createdByActorId,
+		createdAuthMetadata: entry.createdAuthMetadata,
+		supersedesId: entry.supersedesId,
+		version: entry.version,
+		isCurrent: entry.isCurrent,
+		validUntil: entry.validUntil,
+		reviewedAt: entry.reviewedAt,
+		reviewedByActorType: entry.reviewedByActorType,
+		reviewedByActorId: entry.reviewedByActorId,
+		reviewNote: entry.reviewNote,
+		tags: entry.tags,
+		createdAt: entry.createdAt,
+		updatedAt: entry.updatedAt
+	};
+}
+function toPublicContextEntries(entries) {
+	return entries.map(toPublicContextEntry);
+}
+function toPublicContextEntryPage(page) {
+	return {
+		items: toPublicContextEntries(page.items),
+		nextCursor: page.nextCursor
+	};
+}
+function toPublicContextDiff(diff) {
+	return {
+		newEntries: toPublicContextEntries(diff.newEntries),
+		supersededEntries: toPublicContextEntries(diff.supersededEntries),
+		staleEntries: toPublicContextEntries(diff.staleEntries),
+		reviewedEntries: toPublicContextEntries(diff.reviewedEntries)
+	};
+}
+
+//#endregion
+//#region src/site-context/action-hash.ts
+async function buildStableActionHash(value) {
+	return sha256Hex(stableStringify(value));
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	if (isRecord$3(value)) return `{${Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
+	return JSON.stringify(value ?? null);
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function sha256Hex(value) {
+	const buffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+	return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+//#endregion
+//#region src/site-context/review-payload.ts
+var ReviewPayloadBuilder = class {
+	constructor(handlers) {
+		this.handlers = handlers;
+	}
+	async buildContentReviewPayload(input) {
+		const actionType = input.actionType ?? "content.publish";
+		const content = await this.loadContent(input.collection, input.id);
+		const compare = await this.loadCompare(input.collection, content.entryId);
+		const live = asRecord(compare.live);
+		const draft = asRecord(compare.draft) ?? content.data;
+		const hasChanges = typeof compare.hasChanges === "boolean" ? compare.hasChanges : stableStringify(live) !== stableStringify(draft);
+		const actionHash = await buildStableActionHash({
+			actionType,
+			collection: input.collection,
+			entryId: content.entryId,
+			liveRevisionId: content.liveRevisionId,
+			draftRevisionId: content.draftRevisionId,
+			reviewedRev: content.reviewedRev,
+			live,
+			draft
+		});
+		const scope = `content:${input.collection}:${content.entryId}`;
+		const summary = input.summary ?? `Review ${actionType} for ${input.collection}/${content.displayTitle ?? content.entryId}`;
+		return {
+			collection: input.collection,
+			entryId: content.entryId,
+			scope,
+			liveRevisionId: content.liveRevisionId,
+			draftRevisionId: content.draftRevisionId,
+			reviewedRev: content.reviewedRev,
+			actionType,
+			actionHash,
+			reviewPayload: {
+				kind: "content_review",
+				actionType,
+				summary,
+				target: {
+					collection: input.collection,
+					entryId: content.entryId,
+					scope,
+					liveRevisionId: content.liveRevisionId,
+					draftRevisionId: content.draftRevisionId,
+					reviewedRev: content.reviewedRev,
+					actionHash
+				},
+				content: {
+					id: content.entryId,
+					slug: content.slug,
+					status: content.status,
+					title: content.displayTitle,
+					updatedAt: content.updatedAt
+				},
+				diff: {
+					hasChanges,
+					live,
+					draft
+				}
+			}
+		};
+	}
+	async loadContent(collection, id) {
+		const result = await this.handlers.handleContentGet(collection, id);
+		if (!result.success) throw new Error(result.error?.message ?? `Content item not found: ${collection}/${id}`);
+		const payload = asRecord(result.data);
+		const item = asRecord(payload?.item);
+		if (!payload || !item) throw new Error("Content get response did not include an item");
+		const entryId = stringOrNull(item.id);
+		const reviewedRev = stringOrNull(payload._rev);
+		if (!entryId) throw new Error("Content item is missing id");
+		if (!reviewedRev) throw new Error("Content item is missing _rev for review binding");
+		const data = asRecord(item.data) ?? {};
+		const title = stringOrNull(data.title) ?? stringOrNull(item.title) ?? stringOrNull(item.slug);
+		return {
+			entryId,
+			reviewedRev,
+			liveRevisionId: stringOrNull(item.liveRevisionId),
+			draftRevisionId: stringOrNull(item.draftRevisionId),
+			slug: stringOrNull(item.slug),
+			status: stringOrNull(item.status),
+			updatedAt: stringOrNull(item.updatedAt),
+			displayTitle: title,
+			data
+		};
+	}
+	async loadCompare(collection, id) {
+		const result = await this.handlers.handleContentCompare(collection, id);
+		if (!result.success) throw new Error(result.error?.message ?? `Failed to compare content: ${collection}/${id}`);
+		return asRecord(result.data) ?? {};
+	}
+};
+function asRecord(value) {
+	return isRecord$2(value) ? value : null;
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringOrNull(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+//#endregion
+//#region src/site-context/risk-policy.ts
+var RiskPolicyEvaluator = class {
+	repository;
+	hitlRepository;
+	payloadBuilder;
+	constructor(options) {
+		this.repository = new ReviewRequestRepository(options.db);
+		this.hitlRepository = new HitlRequestRepository(options.db);
+		this.payloadBuilder = new ReviewPayloadBuilder(options.handlers);
+	}
+	requiresContentPublishReview(actor) {
+		return isTokenAuthenticatedActor(actor);
+	}
+	requiresWorkflowHitl(actor) {
+		return isTokenAuthenticatedActor(actor);
+	}
+	async evaluateContentPublishReview(input) {
+		if (!this.requiresContentPublishReview(input.actor)) return {
+			allowed: true,
+			required: false
+		};
+		if (!input.reviewRequestId) return {
+			allowed: false,
+			required: true,
+			reason: "missing_review_request",
+			message: "content.publish requires an approved review_request_id for token-authenticated actors. Submit review_request_submit, resolve it as approved, then retry publish with that id."
+		};
+		const built = await this.payloadBuilder.buildContentReviewPayload({
+			collection: input.collection,
+			id: input.id,
+			actionType: "content.publish"
+		});
+		const target = {
+			collection: built.collection,
+			entryId: built.entryId,
+			liveRevisionId: built.liveRevisionId,
+			draftRevisionId: built.draftRevisionId,
+			reviewedRev: built.reviewedRev,
+			actionType: built.actionType,
+			actionHash: built.actionHash
+		};
+		const approved = await this.repository.findApprovedForTarget(target);
+		if (approved?.id === input.reviewRequestId) return {
+			allowed: true,
+			required: true,
+			reviewRequest: approved,
+			target
+		};
+		return {
+			allowed: false,
+			required: true,
+			reason: "stale_or_unapproved_review",
+			message: "The supplied review_request_id is not approved for the current content draft/action. Submit and approve a fresh review request before publishing.",
+			target
+		};
+	}
+	async evaluateWorkflowHitl(input) {
+		if (!this.requiresWorkflowHitl(input.actor)) return {
+			allowed: true,
+			required: false
+		};
+		if (!input.hitlRequestId) return {
+			allowed: false,
+			required: true,
+			reason: "missing_hitl_request",
+			message: `${input.action.actionType} requires an approved hitl_request_id for token-authenticated actors. Resolve the generated HITL request, then retry this tool with that id.`,
+			action: input.action
+		};
+		const request = await this.hitlRepository.findById(input.hitlRequestId);
+		if (request && this.matchesApprovedWorkflowHitl(request, input.action)) return {
+			allowed: true,
+			required: true,
+			hitlRequest: request,
+			action: input.action
+		};
+		return {
+			allowed: false,
+			required: true,
+			reason: "stale_or_unapproved_hitl",
+			message: "The supplied hitl_request_id is not approved for the current action target or payload. Resolve a matching HITL request, then retry this tool with that id.",
+			action: input.action
+		};
+	}
+	matchesApprovedWorkflowHitl(request, action) {
+		return request.status === "approved" && request.scope === action.scope && request.actionType === action.actionType && request.targetRefType === action.targetRefType && request.targetRefId === action.targetRefId && extractActionHash(request.metadata) === action.actionHash;
+	}
+};
+function extractActionHash(metadata) {
+	const value = metadata.actionHash;
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isTokenAuthenticatedActor(actor) {
+	if (actor.actorType === "api_token") return true;
+	const authMethod = actor.authMetadata.auth_method;
+	return authMethod === "api_token" || authMethod === "oauth_token";
+}
+
+//#endregion
+//#region src/site-context/schema-hitl.ts
+var SchemaHitlPayloadBuilder = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async buildDeleteCollectionRequest(input) {
+		const collection = await this.requireCollection(input.slug);
+		const collectionSummary = summarizeCollection(collection);
+		const actionHash = await buildStableActionHash({
+			actionType: "schema.delete_collection",
+			scope: collectionScope(collection.slug),
+			targetRefType: "collection",
+			targetRefId: collection.slug,
+			force: input.force === true,
+			collection: collectionSummary
+		});
+		const title = `Approve deleting collection ${collection.slug}`;
+		const summary = `Delete collection ${collection.slug} (${collection.label}) and its content table` + (input.force ? " with force enabled." : ".");
+		return {
+			scope: collectionScope(collection.slug),
+			actionType: "schema.delete_collection",
+			title,
+			summary,
+			riskReason: "destructive_schema_change",
+			targetRefType: "collection",
+			targetRefId: collection.slug,
+			priority: "high",
+			actionHash,
+			metadata: {
+				actionHash,
+				force: input.force === true
+			},
+			reviewPayload: {
+				kind: "schema_delete_collection",
+				actionType: "schema.delete_collection",
+				title,
+				summary,
+				target: {
+					scope: collectionScope(collection.slug),
+					targetRefType: "collection",
+					targetRefId: collection.slug,
+					actionHash
+				},
+				collection: collectionSummary,
+				options: { force: input.force === true }
+			}
+		};
+	}
+	async buildDeleteFieldRequest(input) {
+		const collection = await this.requireCollection(input.collection);
+		const field = collection.fields.find((item) => item.slug === input.fieldSlug);
+		if (!field) throw new Error(`Field not found: ${input.collection}.${input.fieldSlug}`);
+		const fieldSummary = summarizeField(field);
+		const actionHash = await buildStableActionHash({
+			actionType: "schema.delete_field",
+			scope: collectionScope(collection.slug),
+			targetRefType: "collection_field",
+			targetRefId: `${collection.slug}:${field.slug}`,
+			collection: summarizeCollection(collection),
+			field: fieldSummary
+		});
+		const title = `Approve deleting field ${collection.slug}.${field.slug}`;
+		const summary = `Delete field ${field.slug} (${field.label}) from collection ${collection.slug}.`;
+		return {
+			scope: collectionScope(collection.slug),
+			actionType: "schema.delete_field",
+			title,
+			summary,
+			riskReason: "destructive_schema_change",
+			targetRefType: "collection_field",
+			targetRefId: `${collection.slug}:${field.slug}`,
+			priority: "high",
+			actionHash,
+			metadata: { actionHash },
+			reviewPayload: {
+				kind: "schema_delete_field",
+				actionType: "schema.delete_field",
+				title,
+				summary,
+				target: {
+					scope: collectionScope(collection.slug),
+					targetRefType: "collection_field",
+					targetRefId: `${collection.slug}:${field.slug}`,
+					actionHash
+				},
+				collection: summarizeCollection(collection),
+				field: fieldSummary
+			}
+		};
+	}
+	async requireCollection(slug) {
+		const collection = await new SchemaRegistry(this.db).getCollectionWithFields(slug);
+		if (!collection) throw new Error(`Collection not found: ${slug}`);
+		return collection;
+	}
+};
+function collectionScope(slug) {
+	return `collection:${slug}`;
+}
+function summarizeCollection(collection) {
+	return {
+		id: collection.id,
+		slug: collection.slug,
+		label: collection.label,
+		labelSingular: collection.labelSingular,
+		description: collection.description,
+		icon: collection.icon,
+		supports: collection.supports,
+		hasSeo: collection.hasSeo,
+		commentsEnabled: collection.commentsEnabled,
+		fieldCount: collection.fields.length,
+		fields: collection.fields.map((field) => summarizeField(field))
+	};
+}
+function summarizeField(field) {
+	return {
+		id: field.id,
+		slug: field.slug,
+		label: field.label,
+		type: field.type,
+		required: field.required,
+		unique: field.unique,
+		searchable: field.searchable,
+		translatable: field.translatable,
+		defaultValue: field.defaultValue ?? null,
+		validation: field.validation ?? null,
+		options: field.options ?? null
+	};
+}
+
+//#endregion
+//#region src/site-context/plugin-hitl.ts
+var PluginHitlPayloadBuilder = class {
+	async buildEnableRequest(plugin) {
+		return this.build(plugin, {
+			actionType: "plugin.enable",
+			action: "enable",
+			title: `Enable plugin ${plugin.name}`,
+			summary: `Activate plugin ${plugin.id} and re-enable its hooks, routes, and scheduled work.`,
+			riskReason: "Enabling a plugin can change site behavior, expose routes, and restart plugin automation."
+		});
+	}
+	async buildDisableRequest(plugin) {
+		return this.build(plugin, {
+			actionType: "plugin.disable",
+			action: "disable",
+			title: `Disable plugin ${plugin.name}`,
+			summary: `Deactivate plugin ${plugin.id} and stop its hooks, routes, and scheduled work.`,
+			riskReason: "Disabling a plugin can remove site functionality and interrupt scheduled or automated behavior."
+		});
+	}
+	async buildUninstallRequest(plugin, input) {
+		const reviewPayload = {
+			plugin: summarizePlugin(plugin),
+			requestedChange: {
+				action: "uninstall",
+				deleteData: input.deleteData
+			}
+		};
+		const actionHash = await buildStableActionHash({
+			actionType: "plugin.uninstall",
+			plugin: summarizePlugin(plugin),
+			requestedChange: reviewPayload.requestedChange
+		});
+		return {
+			scope: pluginScope(plugin.id),
+			actionType: "plugin.uninstall",
+			title: `Uninstall plugin ${plugin.name}`,
+			summary: `Remove plugin ${plugin.id} from the site${input.deleteData ? " and delete its stored data" : ""}.`,
+			riskReason: "Uninstalling a plugin removes site functionality and may permanently delete plugin-managed state.",
+			reviewPayload,
+			targetRefType: "plugin",
+			targetRefId: plugin.id,
+			priority: "high",
+			metadata: { actionHash },
+			actionHash
+		};
+	}
+	async buildInstallRequest(plugin) {
+		const reviewPayload = {
+			plugin: summarizeMarketplacePlugin(plugin),
+			requestedChange: {
+				action: "install",
+				version: plugin.version
+			}
+		};
+		const actionHash = await buildStableActionHash({
+			actionType: "plugin.install",
+			plugin: summarizeMarketplacePlugin(plugin),
+			requestedChange: reviewPayload.requestedChange
+		});
+		return {
+			scope: pluginScope(plugin.id),
+			actionType: "plugin.install",
+			title: `Install marketplace plugin ${plugin.name}`,
+			summary: `Install marketplace plugin ${plugin.id} at version ${plugin.version}.`,
+			riskReason: "Installing a marketplace plugin downloads remote code, adds new capabilities, and can change site behavior immediately.",
+			reviewPayload,
+			targetRefType: "plugin",
+			targetRefId: plugin.id,
+			priority: "high",
+			metadata: { actionHash },
+			actionHash
+		};
+	}
+	async buildMarketplaceUpdateRequest(plugin) {
+		const reviewPayload = {
+			plugin: summarizeMarketplacePlugin(plugin),
+			currentVersion: plugin.oldVersion,
+			requestedChange: {
+				action: "update",
+				version: plugin.version
+			},
+			capabilityChanges: {
+				added: [...plugin.capabilityChanges.added],
+				removed: [...plugin.capabilityChanges.removed]
+			},
+			routeVisibilityChanges: { newlyPublic: [...plugin.routeVisibilityChanges.newlyPublic] }
+		};
+		const actionHash = await buildStableActionHash({
+			actionType: "plugin.update",
+			plugin: summarizeMarketplacePlugin(plugin),
+			currentVersion: plugin.oldVersion,
+			requestedChange: reviewPayload.requestedChange,
+			capabilityChanges: reviewPayload.capabilityChanges,
+			routeVisibilityChanges: reviewPayload.routeVisibilityChanges
+		});
+		return {
+			scope: pluginScope(plugin.id),
+			actionType: "plugin.update",
+			title: `Update marketplace plugin ${plugin.name}`,
+			summary: `Update marketplace plugin ${plugin.id} from ${plugin.oldVersion} to ${plugin.version}.`,
+			riskReason: "Updating a marketplace plugin replaces remote code and may add capabilities or expose new public routes.",
+			reviewPayload,
+			targetRefType: "plugin",
+			targetRefId: plugin.id,
+			priority: "high",
+			metadata: { actionHash },
+			actionHash
+		};
+	}
+	async build(plugin, input) {
+		const reviewPayload = {
+			plugin: summarizePlugin(plugin),
+			requestedChange: { action: input.action }
+		};
+		const actionHash = await buildStableActionHash({
+			actionType: input.actionType,
+			plugin: summarizePlugin(plugin),
+			requestedChange: reviewPayload.requestedChange
+		});
+		return {
+			scope: pluginScope(plugin.id),
+			actionType: input.actionType,
+			title: input.title,
+			summary: input.summary,
+			riskReason: input.riskReason,
+			reviewPayload,
+			targetRefType: "plugin",
+			targetRefId: plugin.id,
+			priority: "high",
+			metadata: { actionHash },
+			actionHash
+		};
+	}
+};
+function summarizePlugin(plugin) {
+	return {
+		id: plugin.id,
+		name: plugin.name,
+		status: plugin.status,
+		source: plugin.source ?? "config",
+		version: plugin.marketplaceVersion ?? plugin.version,
+		capabilities: [...plugin.capabilities].toSorted(),
+		hasAdminPages: plugin.hasAdminPages,
+		hasDashboardWidgets: plugin.hasDashboardWidgets,
+		hasHooks: plugin.hasHooks
+	};
+}
+function summarizeMarketplacePlugin(plugin) {
+	return {
+		id: plugin.id,
+		name: plugin.name,
+		description: plugin.description,
+		authorName: plugin.authorName,
+		version: plugin.version,
+		minDinewayVersion: plugin.minDinewayVersion,
+		bundleSize: plugin.bundleSize,
+		checksum: plugin.checksum,
+		changelog: plugin.changelog,
+		capabilities: [...plugin.capabilities].toSorted(),
+		status: plugin.status,
+		auditVerdict: plugin.auditVerdict,
+		imageAuditVerdict: plugin.imageAuditVerdict,
+		publishedAt: plugin.publishedAt
+	};
+}
+function pluginScope(pluginId) {
+	return `plugin:${pluginId}`;
+}
+
+//#endregion
+//#region src/site-context/exclusive-hook-hitl.ts
+var ExclusiveHookHitlPayloadBuilder = class {
+	async buildSetSelectionRequest(input) {
+		const providers = normalizeProviders(input.providers);
+		const actionHash = await buildStableActionHash({
+			actionType: "hook.exclusive.update",
+			hookName: input.hookName,
+			currentPluginId: input.currentPluginId,
+			requestedPluginId: input.requestedPluginId,
+			providers: providers.map((provider) => provider.pluginId)
+		});
+		const title = input.requestedPluginId ? `Approve exclusive hook provider change for ${input.hookName}` : `Approve clearing exclusive hook provider for ${input.hookName}`;
+		const summary = input.requestedPluginId ? `Select ${input.requestedPluginId} as the provider for ${input.hookName}.` : `Clear the selected provider for ${input.hookName}.`;
+		return {
+			scope: "site",
+			actionType: "hook.exclusive.update",
+			title,
+			summary,
+			riskReason: "exclusive_hook_selection_change",
+			targetRefType: "exclusive_hook",
+			targetRefId: input.hookName,
+			priority: "high",
+			metadata: {
+				actionHash,
+				hookName: input.hookName,
+				currentPluginId: input.currentPluginId,
+				requestedPluginId: input.requestedPluginId,
+				providerIds: providers.map((provider) => provider.pluginId)
+			},
+			reviewPayload: {
+				kind: "exclusive_hook_update",
+				actionType: "hook.exclusive.update",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "exclusive_hook",
+					targetRefId: input.hookName,
+					actionHash
+				},
+				hookName: input.hookName,
+				currentPluginId: input.currentPluginId,
+				requestedPluginId: input.requestedPluginId,
+				providers
+			},
+			actionHash
+		};
+	}
+};
+function normalizeProviders(providers) {
+	return providers.map((provider) => ({
+		pluginId: provider.pluginId,
+		pluginName: provider.pluginName
+	})).toSorted((left, right) => left.pluginId.localeCompare(right.pluginId));
+}
+
+//#endregion
+//#region src/site-context/import-hitl.ts
+var WordPressImportHitlPayloadBuilder = class {
+	async buildPrepareRequest(input) {
+		const plan = normalizePreparePlan(input.postTypes);
+		const targetRefId = plan.postTypes.length > 0 ? plan.postTypes.map((item) => item.collection).join(",") : "site";
+		const title = "Approve WordPress schema prepare";
+		const summary = plan.postTypes.length === 1 ? `Create or update import-ready schema for collection ${plan.postTypes[0]?.collection}.` : `Create or update import-ready schema for ${plan.postTypes.length} WordPress collection mappings.`;
+		const actionHash = await buildStableActionHash({
+			actionType: "import.wordpress.prepare",
+			plan
+		});
+		return {
+			scope: "site",
+			actionType: "import.wordpress.prepare",
+			title,
+			summary,
+			riskReason: "Preparing WordPress import schema can create collections, add fields, and enable search behavior.",
+			reviewPayload: {
+				kind: "wordpress_import_prepare",
+				actionType: "import.wordpress.prepare",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "wordpress_import_plan",
+					targetRefId,
+					actionHash
+				},
+				plan
+			},
+			targetRefType: "wordpress_import_plan",
+			targetRefId,
+			priority: "high",
+			metadata: {
+				actionHash,
+				collectionCount: plan.postTypes.length
+			},
+			actionHash
+		};
+	}
+	async buildExecuteRequest(input) {
+		const fileDigest = await sha256BufferHex(input.fileBuffer);
+		const config = normalizeExecuteConfig(input.config);
+		const targetRefId = `wxr:${fileDigest}`;
+		const enabledMappings = Object.entries(config.postTypeMappings).filter(([, mapping]) => mapping.enabled);
+		const title = "Approve WordPress WXR import";
+		const summary = enabledMappings.length === 0 ? "Run a WordPress WXR import with no enabled post-type mappings." : `Run a WordPress WXR import into ${enabledMappings.length} enabled Dineway collection mappings.`;
+		const actionHash = await buildStableActionHash({
+			actionType: "import.wordpress.execute",
+			fileDigest,
+			config
+		});
+		return {
+			scope: "site",
+			actionType: "import.wordpress.execute",
+			title,
+			summary,
+			riskReason: "Running a WordPress WXR import can create or overwrite large amounts of site content in bulk.",
+			reviewPayload: {
+				kind: "wordpress_import_execute",
+				actionType: "import.wordpress.execute",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "wordpress_import_file",
+					targetRefId,
+					actionHash
+				},
+				file: {
+					name: input.fileName,
+					digest: fileDigest
+				},
+				config
+			},
+			targetRefType: "wordpress_import_file",
+			targetRefId,
+			priority: "high",
+			metadata: {
+				actionHash,
+				fileDigest,
+				fileName: input.fileName
+			},
+			actionHash
+		};
+	}
+	async buildPluginExecuteRequest(input) {
+		const source = normalizePluginExecuteSource(input.siteUrl, input.items);
+		const config = normalizeExecuteConfig(input.config);
+		const enabledMappings = Object.entries(config.postTypeMappings).filter(([, mapping]) => mapping.enabled);
+		const targetRefId = source.siteUrl;
+		const sourceFingerprint = await buildStableActionHash(source.fingerprintItems);
+		const title = "Approve WordPress plugin import";
+		const summary = enabledMappings.length === 0 ? `Run a WordPress plugin import from ${source.siteUrl} with no enabled post-type mappings.` : `Run a WordPress plugin import from ${source.siteUrl} into ${enabledMappings.length} enabled Dineway collection mappings using ${source.totalItems} reviewed remote items.`;
+		const actionHash = await buildStableActionHash({
+			actionType: "import.wordpress_plugin.execute",
+			siteUrl: source.siteUrl,
+			sourceFingerprint,
+			config
+		});
+		return {
+			scope: "site",
+			actionType: "import.wordpress_plugin.execute",
+			title,
+			summary,
+			riskReason: "Running a remote WordPress plugin import can create or overwrite large amounts of site content in bulk from a live external source.",
+			reviewPayload: {
+				kind: "wordpress_plugin_import_execute",
+				actionType: "import.wordpress_plugin.execute",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "wordpress_plugin_source",
+					targetRefId,
+					actionHash
+				},
+				source: {
+					siteUrl: source.siteUrl,
+					totalItems: source.totalItems,
+					postTypes: source.postTypes,
+					fingerprint: sourceFingerprint
+				},
+				config
+			},
+			targetRefType: "wordpress_plugin_source",
+			targetRefId,
+			priority: "high",
+			metadata: {
+				actionHash,
+				sourceFingerprint,
+				siteUrl: source.siteUrl,
+				itemCount: source.totalItems
+			},
+			actionHash
+		};
+	}
+	async buildRewriteUrlsRequest(input) {
+		const rewrite = normalizeRewriteRequest(input);
+		const targetRefId = rewrite.collections?.length ? rewrite.collections.join(",") : "all";
+		const title = "Approve WordPress URL rewrite";
+		const summary = rewrite.collections?.length ? `Rewrite imported WordPress URLs across ${rewrite.collections.length} selected collections.` : "Rewrite imported WordPress URLs across all collections.";
+		const actionHash = await buildStableActionHash({
+			actionType: "import.wordpress.rewrite_urls",
+			rewrite
+		});
+		return {
+			scope: "site",
+			actionType: "import.wordpress.rewrite_urls",
+			title,
+			summary,
+			riskReason: "Rewriting imported WordPress URLs updates existing content in bulk and can change many references at once.",
+			reviewPayload: {
+				kind: "wordpress_import_rewrite_urls",
+				actionType: "import.wordpress.rewrite_urls",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "wordpress_url_rewrite",
+					targetRefId,
+					actionHash
+				},
+				rewrite
+			},
+			targetRefType: "wordpress_url_rewrite",
+			targetRefId,
+			priority: "high",
+			metadata: {
+				actionHash,
+				urlCount: Object.keys(rewrite.urlMap).length
+			},
+			actionHash
+		};
+	}
+};
+function normalizePreparePlan(postTypes) {
+	return { postTypes: postTypes.map((postType) => ({
+		name: postType.name,
+		collection: sanitizeWordPressImportSlug(postType.collection),
+		fields: (postType.fields ?? []).map((field) => ({
+			slug: sanitizeWordPressImportSlug(field.slug),
+			label: field.label,
+			type: field.type,
+			required: field.required,
+			searchable: field.searchable ?? false
+		}))
+	})) };
+}
+function normalizeExecuteConfig(input) {
+	return {
+		postTypeMappings: Object.fromEntries(Object.entries(input.postTypeMappings).map(([postType, mapping]) => [postType, {
+			collection: sanitizeWordPressImportSlug(mapping.collection),
+			enabled: mapping.enabled
+		}])),
+		skipExisting: input.skipExisting,
+		importSections: input.importSections !== false,
+		authorMappings: input.authorMappings ?? null,
+		locale: input.locale ?? null
+	};
+}
+function normalizeRewriteRequest(input) {
+	return {
+		urlMap: input.urlMap,
+		collections: input.collections && input.collections.length > 0 ? [...new Set(input.collections.map((collection) => sanitizeWordPressImportSlug(collection)))].toSorted() : null
+	};
+}
+function normalizePluginExecuteSource(siteUrl, items) {
+	const normalizedSiteUrl = normalizeUrl(siteUrl);
+	const fingerprintItems = items.map((item) => ({
+		sourceId: String(item.sourceId),
+		postType: item.postType,
+		status: item.status,
+		slug: item.slug,
+		title: item.title,
+		content: item.content,
+		excerpt: item.excerpt ?? null,
+		featuredImage: item.featuredImage ?? null,
+		author: item.author ?? null,
+		date: normalizeItemDate(item.date),
+		locale: item.locale ?? null,
+		translationGroup: item.translationGroup ?? null
+	})).toSorted(comparePluginFingerprintItems);
+	const postTypes = summarizePluginPostTypes(fingerprintItems);
+	return {
+		siteUrl: normalizedSiteUrl,
+		totalItems: fingerprintItems.length,
+		postTypes,
+		fingerprintItems
+	};
+}
+function summarizePluginPostTypes(items) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const existing = grouped.get(item.postType) ?? {
+			count: 0,
+			statuses: /* @__PURE__ */ new Map(),
+			newestDate: null
+		};
+		existing.count += 1;
+		existing.statuses.set(item.status, (existing.statuses.get(item.status) ?? 0) + 1);
+		if (item.date && (!existing.newestDate || item.date > existing.newestDate)) existing.newestDate = item.date;
+		grouped.set(item.postType, existing);
+	}
+	return Array.from(grouped.entries(), ([postType, summary]) => ({
+		postType,
+		count: summary.count,
+		newestDate: summary.newestDate,
+		statuses: Object.fromEntries([...summary.statuses.entries()].toSorted(([left], [right]) => left.localeCompare(right)))
+	})).toSorted((left, right) => left.postType.localeCompare(right.postType));
+}
+function comparePluginFingerprintItems(left, right) {
+	return left.postType.localeCompare(right.postType) || (left.locale ?? "").localeCompare(right.locale ?? "") || left.slug.localeCompare(right.slug) || left.sourceId.localeCompare(right.sourceId);
+}
+function normalizeItemDate(value) {
+	if (!value) return null;
+	const time = value.getTime();
+	return Number.isNaN(time) ? null : value.toISOString();
+}
+async function sha256BufferHex(buffer) {
+	const digest = await crypto.subtle.digest("SHA-256", buffer);
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+//#endregion
+//#region src/site-context/settings-hitl.ts
+var SettingsHitlPayloadBuilder = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async buildUpdateSettingsRequest(input) {
+		const current = normalizeSiteSettings(await getSiteSettingsWithDb(this.db));
+		const requestedChange = normalizeSiteSettings(input);
+		const changedKeys = Object.keys(requestedChange).toSorted();
+		const seoOnly = changedKeys.length === 1 && changedKeys[0] === "seo";
+		const actionHash = await buildStableActionHash({
+			actionType: "settings.update",
+			current,
+			requestedChange
+		});
+		const title = seoOnly ? "Approve updating site SEO defaults" : "Approve updating site settings";
+		const summary = seoOnly ? "Update site-level SEO defaults and verification settings." : `Update site settings: ${formatChangedKeys(changedKeys)}.`;
+		return {
+			scope: "site",
+			actionType: "settings.update",
+			title,
+			summary,
+			riskReason: seoOnly ? "seo_strategy_change" : "site_configuration_change",
+			targetRefType: "site_settings",
+			targetRefId: "site",
+			priority: "high",
+			metadata: {
+				actionHash,
+				changedKeys,
+				touchesSeo: changedKeys.includes("seo")
+			},
+			reviewPayload: {
+				kind: "site_settings_update",
+				actionType: "settings.update",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "site_settings",
+					targetRefId: "site",
+					actionHash
+				},
+				changedKeys,
+				current,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+};
+function normalizeSiteSettings(input) {
+	return {
+		title: input.title,
+		tagline: input.tagline,
+		logo: normalizeMediaReference(input.logo),
+		favicon: normalizeMediaReference(input.favicon),
+		url: input.url,
+		postsPerPage: input.postsPerPage,
+		dateFormat: input.dateFormat,
+		timezone: input.timezone,
+		social: input.social ? {
+			twitter: input.social.twitter,
+			github: input.social.github,
+			facebook: input.social.facebook,
+			instagram: input.social.instagram,
+			linkedin: input.social.linkedin,
+			youtube: input.social.youtube
+		} : void 0,
+		seo: input.seo ? {
+			titleSeparator: input.seo.titleSeparator,
+			defaultOgImage: normalizeMediaReference(input.seo.defaultOgImage),
+			robotsTxt: input.seo.robotsTxt,
+			googleVerification: input.seo.googleVerification,
+			bingVerification: input.seo.bingVerification
+		} : void 0
+	};
+}
+function normalizeMediaReference(value) {
+	if (!value) return void 0;
+	return {
+		mediaId: value.mediaId,
+		alt: value.alt
+	};
+}
+function formatChangedKeys(keys) {
+	if (keys.length === 0) return "no fields";
+	if (keys.length === 1) return keys[0];
+	return keys.join(", ");
+}
+
+//#endregion
+//#region src/site-context/redirect-hitl.ts
+var RedirectHitlPayloadBuilder = class {
+	async buildCreateRedirectRequest(input) {
+		const requestedChange = normalizeCreateRedirect(input);
+		const actionHash = await buildStableActionHash({
+			actionType: "redirect.create",
+			requestedChange
+		});
+		const title = `Approve creating redirect ${input.source}`;
+		const summary = `Create redirect ${input.source} -> ${input.destination} (${requestedChange.type}).`;
+		return {
+			scope: "site",
+			actionType: "redirect.create",
+			title,
+			summary,
+			riskReason: "seo_redirect_change",
+			targetRefType: "redirect",
+			targetRefId: input.source,
+			priority: "high",
+			metadata: {
+				actionHash,
+				source: requestedChange.source,
+				destination: requestedChange.destination,
+				redirectType: requestedChange.type,
+				enabled: requestedChange.enabled,
+				isPattern: requestedChange.isPattern
+			},
+			reviewPayload: {
+				kind: "redirect_create",
+				actionType: "redirect.create",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "redirect",
+					targetRefId: input.source,
+					actionHash
+				},
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildUpdateRedirectRequest(input) {
+		const current = normalizeRedirect(input.redirect);
+		const requestedChange = normalizeUpdateRedirect(input);
+		const changedKeys = Object.keys(requestedChange).toSorted();
+		const actionHash = await buildStableActionHash({
+			actionType: "redirect.update",
+			current,
+			requestedChange
+		});
+		const title = `Approve updating redirect ${input.redirect.source}`;
+		const summary = `Update redirect ${input.redirect.source} -> ${input.redirect.destination}.`;
+		return {
+			scope: "site",
+			actionType: "redirect.update",
+			title,
+			summary,
+			riskReason: "seo_redirect_change",
+			targetRefType: "redirect",
+			targetRefId: input.redirect.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				redirectId: input.redirect.id,
+				source: input.redirect.source,
+				destination: input.redirect.destination,
+				changedKeys
+			},
+			reviewPayload: {
+				kind: "redirect_update",
+				actionType: "redirect.update",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "redirect",
+					targetRefId: input.redirect.id,
+					actionHash
+				},
+				changedKeys,
+				current,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildDeleteRedirectRequest(input) {
+		const current = normalizeRedirect(input.redirect);
+		const actionHash = await buildStableActionHash({
+			actionType: "redirect.delete",
+			current
+		});
+		const title = `Approve deleting redirect ${input.redirect.source}`;
+		const summary = `Delete redirect ${input.redirect.source} -> ${input.redirect.destination}.`;
+		return {
+			scope: "site",
+			actionType: "redirect.delete",
+			title,
+			summary,
+			riskReason: "seo_redirect_change",
+			targetRefType: "redirect",
+			targetRefId: input.redirect.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				redirectId: input.redirect.id,
+				source: input.redirect.source,
+				destination: input.redirect.destination
+			},
+			reviewPayload: {
+				kind: "redirect_delete",
+				actionType: "redirect.delete",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "redirect",
+					targetRefId: input.redirect.id,
+					actionHash
+				},
+				current
+			},
+			actionHash
+		};
+	}
+};
+function normalizeCreateRedirect(input) {
+	return {
+		source: input.source,
+		destination: input.destination,
+		type: input.type ?? 301,
+		enabled: input.enabled ?? true,
+		groupName: input.groupName ?? null,
+		isPattern: isPattern(input.source),
+		auto: false
+	};
+}
+function normalizeUpdateRedirect(input) {
+	const requestedChange = {};
+	if (input.source !== void 0) {
+		requestedChange.source = input.source;
+		requestedChange.isPattern = isPattern(input.source);
+	}
+	if (input.destination !== void 0) requestedChange.destination = input.destination;
+	if (input.type !== void 0) requestedChange.type = input.type;
+	if (input.enabled !== void 0) requestedChange.enabled = input.enabled;
+	if (input.groupName !== void 0) requestedChange.groupName = input.groupName;
+	return requestedChange;
+}
+function normalizeRedirect(redirect) {
+	return {
+		id: redirect.id,
+		source: redirect.source,
+		destination: redirect.destination,
+		type: redirect.type,
+		isPattern: redirect.isPattern,
+		enabled: redirect.enabled,
+		groupName: redirect.groupName,
+		auto: redirect.auto
+	};
+}
+
+//#endregion
+//#region src/site-context/menu-hitl.ts
+var MenuHitlPayloadBuilder = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async buildCreateMenuRequest(input) {
+		const requestedChange = normalizeCreateMenuInput(input);
+		const actionHash = await buildStableActionHash({
+			actionType: "menu.create",
+			requestedChange
+		});
+		const title = `Approve creating menu ${input.name}`;
+		const summary = `Create navigation menu ${input.name} (${input.label}).`;
+		return {
+			scope: "site",
+			actionType: "menu.create",
+			title,
+			summary,
+			riskReason: "navigation_restructure",
+			targetRefType: "menu",
+			targetRefId: input.name,
+			priority: "high",
+			metadata: {
+				actionHash,
+				menuName: input.name
+			},
+			reviewPayload: {
+				kind: "menu_create",
+				actionType: "menu.create",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "menu",
+					targetRefId: input.name,
+					actionHash
+				},
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildUpdateMenuRequest(input) {
+		const snapshot = await this.requireMenuSnapshot(input.name);
+		const requestedChange = normalizeUpdateMenuInput(input);
+		const current = summarizeMenuSnapshot(snapshot);
+		const actionHash = await buildStableActionHash({
+			actionType: "menu.update",
+			current,
+			requestedChange
+		});
+		const title = `Approve updating menu ${snapshot.menu.name}`;
+		const summary = requestedChange.label !== null ? `Update navigation menu ${snapshot.menu.name} label to ${requestedChange.label}.` : `Update navigation menu ${snapshot.menu.name}.`;
+		return {
+			scope: "site",
+			actionType: "menu.update",
+			title,
+			summary,
+			riskReason: "navigation_restructure",
+			targetRefType: "menu",
+			targetRefId: snapshot.menu.name,
+			priority: "high",
+			metadata: {
+				actionHash,
+				menuName: snapshot.menu.name,
+				menuId: snapshot.menu.id
+			},
+			reviewPayload: {
+				kind: "menu_update",
+				actionType: "menu.update",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "menu",
+					targetRefId: snapshot.menu.name,
+					actionHash
+				},
+				current,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildDeleteMenuRequest(input) {
+		const snapshot = await this.requireMenuSnapshot(input.name);
+		const current = summarizeMenuSnapshot(snapshot);
+		const actionHash = await buildStableActionHash({
+			actionType: "menu.delete",
+			current
+		});
+		const title = `Approve deleting menu ${snapshot.menu.name}`;
+		const summary = current.itemCount > 0 ? `Delete navigation menu ${snapshot.menu.name} and remove ${current.itemCount} menu items.` : `Delete navigation menu ${snapshot.menu.name}.`;
+		return {
+			scope: "site",
+			actionType: "menu.delete",
+			title,
+			summary,
+			riskReason: "navigation_restructure",
+			targetRefType: "menu",
+			targetRefId: snapshot.menu.name,
+			priority: "high",
+			metadata: {
+				actionHash,
+				menuName: snapshot.menu.name,
+				menuId: snapshot.menu.id
+			},
+			reviewPayload: {
+				kind: "menu_delete",
+				actionType: "menu.delete",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "menu",
+					targetRefId: snapshot.menu.name,
+					actionHash
+				},
+				current
+			},
+			actionHash
+		};
+	}
+	async buildCreateMenuItemRequest(input) {
+		const snapshot = await this.requireMenuSnapshot(input.menuName);
+		const current = summarizeMenuSnapshot(snapshot);
+		const requestedChange = normalizeCreateMenuItemInput(input);
+		const actionHash = await buildStableActionHash({
+			actionType: "menu.create_item",
+			current,
+			requestedChange
+		});
+		const title = `Approve adding item to menu ${snapshot.menu.name}`;
+		const summary = `Add navigation item ${requestedChange.label} to menu ${snapshot.menu.name}.`;
+		return {
+			scope: "site",
+			actionType: "menu.create_item",
+			title,
+			summary,
+			riskReason: "navigation_restructure",
+			targetRefType: "menu",
+			targetRefId: snapshot.menu.name,
+			priority: "high",
+			metadata: {
+				actionHash,
+				menuName: snapshot.menu.name,
+				menuId: snapshot.menu.id
+			},
+			reviewPayload: {
+				kind: "menu_create_item",
+				actionType: "menu.create_item",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "menu",
+					targetRefId: snapshot.menu.name,
+					actionHash
+				},
+				current,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildUpdateMenuItemRequest(input) {
+		const snapshot = await this.requireMenuSnapshot(input.menuName);
+		const item = requireMenuItem(snapshot, input.itemId);
+		const current = summarizeMenuSnapshot(snapshot);
+		const currentItem = summarizeMenuItem(item);
+		const requestedChange = normalizeUpdateMenuItemInput(input);
+		const actionHash = await buildStableActionHash({
+			actionType: "menu.update_item",
+			current,
+			currentItem,
+			requestedChange
+		});
+		const title = `Approve updating menu item ${item.label}`;
+		const summary = `Update navigation item ${item.id} in menu ${snapshot.menu.name}.`;
+		return {
+			scope: "site",
+			actionType: "menu.update_item",
+			title,
+			summary,
+			riskReason: "navigation_restructure",
+			targetRefType: "menu_item",
+			targetRefId: item.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				menuName: snapshot.menu.name,
+				menuId: snapshot.menu.id,
+				itemId: item.id
+			},
+			reviewPayload: {
+				kind: "menu_update_item",
+				actionType: "menu.update_item",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "menu_item",
+					targetRefId: item.id,
+					actionHash
+				},
+				current,
+				currentItem,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildDeleteMenuItemRequest(input) {
+		const snapshot = await this.requireMenuSnapshot(input.menuName);
+		const item = requireMenuItem(snapshot, input.itemId);
+		const current = summarizeMenuSnapshot(snapshot);
+		const currentItem = summarizeMenuItem(item);
+		const actionHash = await buildStableActionHash({
+			actionType: "menu.delete_item",
+			current,
+			currentItem
+		});
+		const title = `Approve deleting menu item ${item.label}`;
+		const summary = `Delete navigation item ${item.id} from menu ${snapshot.menu.name}.`;
+		return {
+			scope: "site",
+			actionType: "menu.delete_item",
+			title,
+			summary,
+			riskReason: "navigation_restructure",
+			targetRefType: "menu_item",
+			targetRefId: item.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				menuName: snapshot.menu.name,
+				menuId: snapshot.menu.id,
+				itemId: item.id
+			},
+			reviewPayload: {
+				kind: "menu_delete_item",
+				actionType: "menu.delete_item",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "menu_item",
+					targetRefId: item.id,
+					actionHash
+				},
+				current,
+				currentItem
+			},
+			actionHash
+		};
+	}
+	async buildReorderMenuItemsRequest(input) {
+		const snapshot = await this.requireMenuSnapshot(input.menuName);
+		const current = summarizeMenuSnapshot(snapshot);
+		const requestedChange = normalizeReorderMenuItemsInput(input.items);
+		const actionHash = await buildStableActionHash({
+			actionType: "menu.reorder",
+			current,
+			requestedChange
+		});
+		const title = `Approve reordering menu ${snapshot.menu.name}`;
+		const summary = requestedChange.items.length > 0 ? `Reorder ${requestedChange.items.length} navigation items in menu ${snapshot.menu.name}.` : `Reorder navigation items in menu ${snapshot.menu.name}.`;
+		return {
+			scope: "site",
+			actionType: "menu.reorder",
+			title,
+			summary,
+			riskReason: "navigation_restructure",
+			targetRefType: "menu",
+			targetRefId: snapshot.menu.name,
+			priority: "high",
+			metadata: {
+				actionHash,
+				menuName: snapshot.menu.name,
+				menuId: snapshot.menu.id,
+				itemCount: requestedChange.items.length
+			},
+			reviewPayload: {
+				kind: "menu_reorder",
+				actionType: "menu.reorder",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "menu",
+					targetRefId: snapshot.menu.name,
+					actionHash
+				},
+				current,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async requireMenuSnapshot(name) {
+		const menu = await this.db.selectFrom("_dineway_menus").selectAll().where("name", "=", name).executeTakeFirst();
+		if (!menu) throw new Error(`Menu not found: ${name}`);
+		return {
+			menu,
+			items: await this.db.selectFrom("_dineway_menu_items").selectAll().where("menu_id", "=", menu.id).orderBy("sort_order", "asc").orderBy("id", "asc").execute()
+		};
+	}
+};
+function requireMenuItem(snapshot, itemId) {
+	const item = snapshot.items.find((entry) => entry.id === itemId);
+	if (!item) throw new Error(`Menu item not found: ${itemId}`);
+	return item;
+}
+function summarizeMenuSnapshot(snapshot) {
+	return {
+		id: snapshot.menu.id,
+		name: snapshot.menu.name,
+		label: snapshot.menu.label,
+		itemCount: snapshot.items.length,
+		items: snapshot.items.map((item) => summarizeMenuItem(item))
+	};
+}
+function summarizeMenuItem(item) {
+	return {
+		id: item.id,
+		parentId: item.parent_id,
+		sortOrder: item.sort_order,
+		type: item.type,
+		referenceCollection: item.reference_collection,
+		referenceId: item.reference_id,
+		customUrl: item.custom_url,
+		label: item.label,
+		titleAttr: item.title_attr,
+		target: item.target,
+		cssClasses: item.css_classes
+	};
+}
+function normalizeCreateMenuInput(input) {
+	return {
+		name: input.name,
+		label: input.label
+	};
+}
+function normalizeUpdateMenuInput(input) {
+	return { label: input.label ?? null };
+}
+function normalizeCreateMenuItemInput(input) {
+	return {
+		type: input.type,
+		label: input.label,
+		referenceCollection: input.referenceCollection ?? null,
+		referenceId: input.referenceId ?? null,
+		customUrl: input.customUrl ?? null,
+		target: input.target ?? null,
+		titleAttr: input.titleAttr ?? null,
+		cssClasses: input.cssClasses ?? null,
+		parentId: input.parentId ?? null,
+		sortOrder: input.sortOrder ?? null
+	};
+}
+function normalizeUpdateMenuItemInput(input) {
+	return {
+		label: input.label ?? null,
+		customUrl: input.customUrl ?? null,
+		target: input.target ?? null,
+		titleAttr: input.titleAttr ?? null,
+		cssClasses: input.cssClasses ?? null,
+		parentId: input.parentId ?? null,
+		sortOrder: input.sortOrder ?? null
+	};
+}
+function normalizeReorderMenuItemsInput(items) {
+	return { items: items.map((item) => ({
+		id: item.id,
+		parentId: item.parentId,
+		sortOrder: item.sortOrder
+	})).toSorted((left, right) => left.id.localeCompare(right.id)) };
+}
+
+//#endregion
+//#region src/site-context/taxonomy-hitl.ts
+var TaxonomyHitlPayloadBuilder = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async loadTaxonomyDefinition(name) {
+		const row = await this.db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).executeTakeFirst();
+		return row ? normalizeTaxonomyDefinition(row) : null;
+	}
+	async buildCreateTaxonomyRequest(input) {
+		const requestedChange = normalizeCreateTaxonomyInput(input);
+		const actionHash = await buildStableActionHash({
+			actionType: "taxonomy.create",
+			requestedChange
+		});
+		const title = `Approve creating taxonomy ${requestedChange.name}`;
+		const summary = requestedChange.collections.length > 0 ? `Create taxonomy ${requestedChange.name} (${requestedChange.label}) for ${requestedChange.collections.join(", ")}.` : `Create taxonomy ${requestedChange.name} (${requestedChange.label}).`;
+		return {
+			scope: "site",
+			actionType: "taxonomy.create",
+			title,
+			summary,
+			riskReason: "taxonomy_structure_change",
+			targetRefType: "taxonomy",
+			targetRefId: requestedChange.name,
+			priority: "high",
+			metadata: {
+				actionHash,
+				taxonomyName: requestedChange.name,
+				hierarchical: requestedChange.hierarchical,
+				collections: requestedChange.collections
+			},
+			reviewPayload: {
+				kind: "taxonomy_create",
+				actionType: "taxonomy.create",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "taxonomy",
+					targetRefId: requestedChange.name,
+					actionHash
+				},
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildCreateTermRequest(input) {
+		const currentTaxonomy = normalizeTaxonomyDefinitionInput(input.taxonomy);
+		const requestedChange = normalizeCreateTermInput(input);
+		const actionHash = await buildStableActionHash({
+			actionType: "taxonomy.term_create",
+			currentTaxonomy,
+			requestedChange
+		});
+		const title = `Approve creating term ${requestedChange.slug} in ${input.taxonomy.name}`;
+		const summary = `Create taxonomy term ${requestedChange.label} in ${input.taxonomy.name}.`;
+		return {
+			scope: "site",
+			actionType: "taxonomy.term_create",
+			title,
+			summary,
+			riskReason: "taxonomy_structure_change",
+			targetRefType: "taxonomy_term",
+			targetRefId: taxonomyTermRefId(input.taxonomy.name, requestedChange.slug),
+			priority: "high",
+			metadata: {
+				actionHash,
+				taxonomyId: input.taxonomy.id,
+				taxonomyName: input.taxonomy.name,
+				termSlug: requestedChange.slug
+			},
+			reviewPayload: {
+				kind: "taxonomy_term_create",
+				actionType: "taxonomy.term_create",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "taxonomy_term",
+					targetRefId: taxonomyTermRefId(input.taxonomy.name, requestedChange.slug),
+					actionHash
+				},
+				currentTaxonomy,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildUpdateTermRequest(input) {
+		const currentTaxonomy = normalizeTaxonomyDefinitionInput(input.taxonomy);
+		const current = normalizeTerm(input.currentTerm);
+		const requestedChange = normalizeUpdateTermInput(input);
+		const changedKeys = Object.keys(requestedChange).toSorted();
+		const actionHash = await buildStableActionHash({
+			actionType: "taxonomy.term_update",
+			currentTaxonomy,
+			current,
+			requestedChange
+		});
+		const title = `Approve updating term ${input.currentTerm.slug} in ${input.taxonomy.name}`;
+		const summary = `Update taxonomy term ${input.currentTerm.slug} in ${input.taxonomy.name}.`;
+		return {
+			scope: "site",
+			actionType: "taxonomy.term_update",
+			title,
+			summary,
+			riskReason: "taxonomy_structure_change",
+			targetRefType: "taxonomy_term",
+			targetRefId: input.currentTerm.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				taxonomyId: input.taxonomy.id,
+				taxonomyName: input.taxonomy.name,
+				termId: input.currentTerm.id,
+				termSlug: input.currentTerm.slug,
+				changedKeys
+			},
+			reviewPayload: {
+				kind: "taxonomy_term_update",
+				actionType: "taxonomy.term_update",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "taxonomy_term",
+					targetRefId: input.currentTerm.id,
+					actionHash
+				},
+				changedKeys,
+				currentTaxonomy,
+				current,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildDeleteTermRequest(input) {
+		const currentTaxonomy = normalizeTaxonomyDefinitionInput(input.taxonomy);
+		const current = normalizeTerm(input.currentTerm);
+		const actionHash = await buildStableActionHash({
+			actionType: "taxonomy.term_delete",
+			currentTaxonomy,
+			current
+		});
+		const title = `Approve deleting term ${input.currentTerm.slug} from ${input.taxonomy.name}`;
+		const summary = `Delete taxonomy term ${input.currentTerm.slug} from ${input.taxonomy.name}.`;
+		return {
+			scope: "site",
+			actionType: "taxonomy.term_delete",
+			title,
+			summary,
+			riskReason: "taxonomy_structure_change",
+			targetRefType: "taxonomy_term",
+			targetRefId: input.currentTerm.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				taxonomyId: input.taxonomy.id,
+				taxonomyName: input.taxonomy.name,
+				termId: input.currentTerm.id,
+				termSlug: input.currentTerm.slug
+			},
+			reviewPayload: {
+				kind: "taxonomy_term_delete",
+				actionType: "taxonomy.term_delete",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "taxonomy_term",
+					targetRefId: input.currentTerm.id,
+					actionHash
+				},
+				currentTaxonomy,
+				current
+			},
+			actionHash
+		};
+	}
+};
+function normalizeTaxonomyDefinition(row) {
+	return {
+		id: row.id,
+		name: row.name,
+		label: row.label,
+		labelSingular: row.label_singular,
+		hierarchical: row.hierarchical === 1,
+		collections: normalizeCollections(row.collections ? JSON.parse(row.collections) : [])
+	};
+}
+function normalizeTaxonomyDefinitionInput(taxonomy) {
+	return {
+		id: taxonomy.id,
+		name: taxonomy.name,
+		label: taxonomy.label,
+		labelSingular: taxonomy.labelSingular,
+		hierarchical: taxonomy.hierarchical,
+		collections: normalizeCollections(taxonomy.collections)
+	};
+}
+function normalizeCreateTaxonomyInput(input) {
+	return {
+		name: input.name,
+		label: input.label,
+		hierarchical: input.hierarchical ?? false,
+		collections: normalizeCollections(input.collections ?? [])
+	};
+}
+function normalizeCreateTermInput(input) {
+	return {
+		slug: input.slug,
+		label: input.label,
+		parentId: input.parentId ?? null,
+		description: input.description ?? null
+	};
+}
+function normalizeUpdateTermInput(input) {
+	const requestedChange = {};
+	if (input.slug !== void 0) requestedChange.slug = input.slug;
+	if (input.label !== void 0) requestedChange.label = input.label;
+	if (input.parentId !== void 0) requestedChange.parentId = input.parentId;
+	if (input.description !== void 0) requestedChange.description = input.description;
+	return requestedChange;
+}
+function normalizeTerm(term) {
+	return {
+		id: term.id,
+		name: term.name,
+		slug: term.slug,
+		label: term.label,
+		parentId: term.parentId,
+		description: term.description ?? null
+	};
+}
+function normalizeCollections(collections) {
+	if (!Array.isArray(collections)) return [];
+	return [...new Set(collections.filter((value) => typeof value === "string"))].toSorted();
+}
+function taxonomyTermRefId(taxonomyName, termSlug) {
+	return `${taxonomyName}:${termSlug}`;
+}
+
+//#endregion
+//#region src/site-context/section-hitl.ts
+var SectionHitlPayloadBuilder = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async loadSectionSnapshot(slug) {
+		const row = await this.db.selectFrom("_dineway_sections").selectAll().where("slug", "=", slug).executeTakeFirst();
+		return row ? normalizeSection(row) : null;
+	}
+	async buildCreateSectionRequest(input) {
+		const requestedChange = normalizeCreateSectionInput(input);
+		const actionHash = await buildStableActionHash({
+			actionType: "section.create",
+			requestedChange
+		});
+		const title = `Approve creating section ${requestedChange.slug}`;
+		const summary = `Create reusable section ${requestedChange.slug} (${requestedChange.title}).`;
+		return {
+			scope: "site",
+			actionType: "section.create",
+			title,
+			summary,
+			riskReason: "reusable_content_change",
+			targetRefType: "section",
+			targetRefId: requestedChange.slug,
+			priority: "high",
+			metadata: {
+				actionHash,
+				sectionSlug: requestedChange.slug,
+				source: requestedChange.source,
+				themeId: requestedChange.themeId
+			},
+			reviewPayload: {
+				kind: "section_create",
+				actionType: "section.create",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "section",
+					targetRefId: requestedChange.slug,
+					actionHash
+				},
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildUpdateSectionRequest(input) {
+		const current = normalizeSectionInput(input.section);
+		const requestedChange = normalizeUpdateSectionInput(input);
+		const changedKeys = Object.keys(requestedChange).toSorted();
+		const actionHash = await buildStableActionHash({
+			actionType: "section.update",
+			current,
+			requestedChange
+		});
+		const title = `Approve updating section ${input.section.slug}`;
+		const summary = `Update reusable section ${input.section.slug}.`;
+		return {
+			scope: "site",
+			actionType: "section.update",
+			title,
+			summary,
+			riskReason: "reusable_content_change",
+			targetRefType: "section",
+			targetRefId: input.section.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				sectionId: input.section.id,
+				sectionSlug: input.section.slug,
+				source: input.section.source,
+				themeId: input.section.themeId,
+				changedKeys
+			},
+			reviewPayload: {
+				kind: "section_update",
+				actionType: "section.update",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "section",
+					targetRefId: input.section.id,
+					actionHash
+				},
+				changedKeys,
+				current,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildDeleteSectionRequest(input) {
+		const current = normalizeSectionInput(input.section);
+		const actionHash = await buildStableActionHash({
+			actionType: "section.delete",
+			current
+		});
+		const title = `Approve deleting section ${input.section.slug}`;
+		const summary = `Delete reusable section ${input.section.slug}.`;
+		return {
+			scope: "site",
+			actionType: "section.delete",
+			title,
+			summary,
+			riskReason: "reusable_content_change",
+			targetRefType: "section",
+			targetRefId: input.section.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				sectionId: input.section.id,
+				sectionSlug: input.section.slug,
+				source: input.section.source,
+				themeId: input.section.themeId
+			},
+			reviewPayload: {
+				kind: "section_delete",
+				actionType: "section.delete",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "section",
+					targetRefId: input.section.id,
+					actionHash
+				},
+				current
+			},
+			actionHash
+		};
+	}
+};
+function normalizeSection(row) {
+	return {
+		id: row.id,
+		slug: row.slug,
+		title: row.title,
+		description: row.description,
+		keywords: parseStringArray(row.keywords),
+		content: parseUnknownArray$1(row.content),
+		previewMediaId: row.preview_media_id,
+		source: row.source,
+		themeId: row.theme_id
+	};
+}
+function normalizeSectionInput(section) {
+	return {
+		id: section.id,
+		slug: section.slug,
+		title: section.title,
+		description: section.description,
+		keywords: [...section.keywords],
+		content: [...section.content],
+		previewMediaId: section.previewMediaId,
+		source: section.source,
+		themeId: section.themeId
+	};
+}
+function normalizeCreateSectionInput(input) {
+	return {
+		slug: input.slug,
+		title: input.title,
+		description: input.description ?? null,
+		keywords: input.keywords ?? [],
+		content: input.content,
+		previewMediaId: input.previewMediaId ?? null,
+		source: input.source ?? "user",
+		themeId: input.themeId ?? null
+	};
+}
+function normalizeUpdateSectionInput(input) {
+	const requestedChange = {};
+	if (input.slug !== void 0) requestedChange.slug = input.slug;
+	if (input.title !== void 0) requestedChange.title = input.title;
+	if (input.description !== void 0) requestedChange.description = input.description;
+	if (input.keywords !== void 0) requestedChange.keywords = input.keywords;
+	if (input.content !== void 0) requestedChange.content = input.content;
+	if (input.previewMediaId !== void 0) requestedChange.previewMediaId = input.previewMediaId;
+	return requestedChange;
+}
+function parseStringArray(value) {
+	if (!value) return [];
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+	} catch {
+		return [];
+	}
+}
+function parseUnknownArray$1(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed : [];
+	} catch {
+		return [];
+	}
+}
+
+//#endregion
+//#region src/site-context/widget-hitl.ts
+var WidgetHitlPayloadBuilder = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async loadWidgetAreaSnapshot(name) {
+		const area = await this.db.selectFrom("_dineway_widget_areas").selectAll().where("name", "=", name).executeTakeFirst();
+		if (!area) return null;
+		const widgets = await this.db.selectFrom("_dineway_widgets").selectAll().where("area_id", "=", area.id).orderBy("sort_order", "asc").execute();
+		return {
+			...normalizeWidgetArea(area),
+			widgets: widgets.map(normalizeWidget)
+		};
+	}
+	async buildCreateWidgetAreaRequest(input) {
+		const requestedChange = normalizeCreateWidgetAreaInput(input);
+		const actionHash = await buildStableActionHash({
+			actionType: "widget_area.create",
+			requestedChange
+		});
+		const title = `Approve creating widget area ${requestedChange.name}`;
+		const summary = `Create widget area ${requestedChange.name} (${requestedChange.label}).`;
+		return {
+			scope: "site",
+			actionType: "widget_area.create",
+			title,
+			summary,
+			riskReason: "layout_structure_change",
+			targetRefType: "widget_area",
+			targetRefId: requestedChange.name,
+			priority: "high",
+			metadata: {
+				actionHash,
+				areaName: requestedChange.name
+			},
+			reviewPayload: {
+				kind: "widget_area_create",
+				actionType: "widget_area.create",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "widget_area",
+					targetRefId: requestedChange.name,
+					actionHash
+				},
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildDeleteWidgetAreaRequest(input) {
+		const current = normalizeWidgetAreaInput(input.area);
+		const actionHash = await buildStableActionHash({
+			actionType: "widget_area.delete",
+			current
+		});
+		const title = `Approve deleting widget area ${input.area.name}`;
+		const summary = input.area.widgets.length > 0 ? `Delete widget area ${input.area.name} and remove ${input.area.widgets.length} widgets.` : `Delete widget area ${input.area.name}.`;
+		return {
+			scope: "site",
+			actionType: "widget_area.delete",
+			title,
+			summary,
+			riskReason: "layout_structure_change",
+			targetRefType: "widget_area",
+			targetRefId: input.area.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				areaId: input.area.id,
+				areaName: input.area.name,
+				widgetCount: input.area.widgets.length
+			},
+			reviewPayload: {
+				kind: "widget_area_delete",
+				actionType: "widget_area.delete",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "widget_area",
+					targetRefId: input.area.id,
+					actionHash
+				},
+				current
+			},
+			actionHash
+		};
+	}
+	async buildCreateWidgetRequest(input) {
+		const currentArea = normalizeWidgetAreaInput(input.area);
+		const requestedChange = normalizeCreateWidgetInput(input);
+		const actionHash = await buildStableActionHash({
+			actionType: "widget.create",
+			currentArea,
+			requestedChange
+		});
+		const title = `Approve adding widget to ${input.area.name}`;
+		const summary = `Add ${requestedChange.type} widget to area ${input.area.name}.`;
+		return {
+			scope: "site",
+			actionType: "widget.create",
+			title,
+			summary,
+			riskReason: "layout_structure_change",
+			targetRefType: "widget_area",
+			targetRefId: input.area.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				areaId: input.area.id,
+				areaName: input.area.name,
+				widgetType: requestedChange.type
+			},
+			reviewPayload: {
+				kind: "widget_create",
+				actionType: "widget.create",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "widget_area",
+					targetRefId: input.area.id,
+					actionHash
+				},
+				currentArea,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildUpdateWidgetRequest(input) {
+		const current = normalizeWidgetInput(input.currentWidget);
+		const requestedChange = normalizeUpdateWidgetInput(input);
+		const changedKeys = Object.keys(requestedChange).toSorted();
+		const actionHash = await buildStableActionHash({
+			actionType: "widget.update",
+			current,
+			requestedChange
+		});
+		const title = `Approve updating widget ${input.currentWidget.id}`;
+		const summary = `Update widget ${input.currentWidget.id} in area ${input.area.name}.`;
+		return {
+			scope: "site",
+			actionType: "widget.update",
+			title,
+			summary,
+			riskReason: "layout_structure_change",
+			targetRefType: "widget",
+			targetRefId: input.currentWidget.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				areaId: input.area.id,
+				areaName: input.area.name,
+				widgetId: input.currentWidget.id,
+				changedKeys
+			},
+			reviewPayload: {
+				kind: "widget_update",
+				actionType: "widget.update",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "widget",
+					targetRefId: input.currentWidget.id,
+					actionHash
+				},
+				changedKeys,
+				current,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+	async buildDeleteWidgetRequest(input) {
+		const current = normalizeWidgetInput(input.currentWidget);
+		const actionHash = await buildStableActionHash({
+			actionType: "widget.delete",
+			current
+		});
+		const title = `Approve deleting widget ${input.currentWidget.id}`;
+		const summary = `Delete widget ${input.currentWidget.id} from area ${input.area.name}.`;
+		return {
+			scope: "site",
+			actionType: "widget.delete",
+			title,
+			summary,
+			riskReason: "layout_structure_change",
+			targetRefType: "widget",
+			targetRefId: input.currentWidget.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				areaId: input.area.id,
+				areaName: input.area.name,
+				widgetId: input.currentWidget.id
+			},
+			reviewPayload: {
+				kind: "widget_delete",
+				actionType: "widget.delete",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "widget",
+					targetRefId: input.currentWidget.id,
+					actionHash
+				},
+				current
+			},
+			actionHash
+		};
+	}
+	async buildReorderWidgetsRequest(input) {
+		const currentArea = normalizeWidgetAreaInput(input.area);
+		const requestedChange = normalizeReorderWidgetsInput(input.widgetIds);
+		const actionHash = await buildStableActionHash({
+			actionType: "widget.reorder",
+			currentArea,
+			requestedChange
+		});
+		const title = `Approve reordering widgets in ${input.area.name}`;
+		const summary = `Reorder ${input.widgetIds.length} widgets in area ${input.area.name}.`;
+		return {
+			scope: "site",
+			actionType: "widget.reorder",
+			title,
+			summary,
+			riskReason: "layout_structure_change",
+			targetRefType: "widget_area",
+			targetRefId: input.area.id,
+			priority: "high",
+			metadata: {
+				actionHash,
+				areaId: input.area.id,
+				areaName: input.area.name,
+				widgetIds: [...input.widgetIds]
+			},
+			reviewPayload: {
+				kind: "widget_reorder",
+				actionType: "widget.reorder",
+				title,
+				summary,
+				target: {
+					scope: "site",
+					targetRefType: "widget_area",
+					targetRefId: input.area.id,
+					actionHash
+				},
+				currentArea,
+				requestedChange
+			},
+			actionHash
+		};
+	}
+};
+function normalizeWidgetArea(row) {
+	return {
+		id: row.id,
+		name: row.name,
+		label: row.label,
+		description: row.description
+	};
+}
+function normalizeWidget(row) {
+	return {
+		id: row.id,
+		areaId: row.area_id,
+		sortOrder: row.sort_order,
+		type: row.type,
+		title: row.title,
+		content: parseUnknownArray(row.content),
+		menuName: row.menu_name,
+		componentId: row.component_id,
+		componentProps: parseUnknownRecord(row.component_props)
+	};
+}
+function normalizeWidgetAreaInput(area) {
+	return {
+		id: area.id,
+		name: area.name,
+		label: area.label,
+		description: area.description,
+		widgets: area.widgets.map(normalizeWidgetInput)
+	};
+}
+function normalizeWidgetInput(widget) {
+	return {
+		id: widget.id,
+		areaId: widget.areaId,
+		sortOrder: widget.sortOrder,
+		type: widget.type,
+		title: widget.title,
+		content: widget.content,
+		menuName: widget.menuName,
+		componentId: widget.componentId,
+		componentProps: widget.componentProps
+	};
+}
+function normalizeCreateWidgetAreaInput(input) {
+	return {
+		name: input.name,
+		label: input.label,
+		description: input.description ?? null
+	};
+}
+function normalizeCreateWidgetInput(input) {
+	return {
+		type: input.type,
+		title: input.title ?? null,
+		content: input.content ?? null,
+		menuName: input.menuName ?? null,
+		componentId: input.componentId ?? null,
+		componentProps: input.componentProps ?? null
+	};
+}
+function normalizeUpdateWidgetInput(input) {
+	const requestedChange = {};
+	if (input.type !== void 0) requestedChange.type = input.type;
+	if (input.title !== void 0) requestedChange.title = input.title || null;
+	if (input.content !== void 0) requestedChange.content = input.content;
+	if (input.menuName !== void 0) requestedChange.menuName = input.menuName || null;
+	if (input.componentId !== void 0) requestedChange.componentId = input.componentId || null;
+	if (input.componentProps !== void 0) requestedChange.componentProps = input.componentProps;
+	return requestedChange;
+}
+function normalizeReorderWidgetsInput(widgetIds) {
+	return widgetIds.map((id, index) => ({
+		id,
+		sortOrder: index
+	}));
+}
+function parseUnknownArray(value) {
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function parseUnknownRecord(value) {
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord$1(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/site-context/entity-resolve.ts
+const ULID_PATTERN = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+const DISPLAY_FALLBACK_FIELDS = [
+	"title",
+	"name",
+	"headline",
+	"label",
+	"question"
+];
+const DISPLAY_FIELD_TYPES = new Set([
+	"string",
+	"text",
+	"url",
+	"slug",
+	"select"
+]);
+const ENTITY_TYPES = [
+	"content",
+	"collection",
+	"plugin",
+	"taxonomy",
+	"menu"
+];
+function isDisplayField(field) {
+	return DISPLAY_FIELD_TYPES.has(field.type);
+}
+function uniqueValues(values) {
+	return [...new Set(values)];
+}
+function compareOptionalIsoDesc(a, b) {
+	if (a && b) return b.localeCompare(a);
+	if (a) return -1;
+	if (b) return 1;
+	return 0;
+}
+function normalizeDisplayMatch(value) {
+	return normalizeEntityAlias(value);
+}
+function candidateIdentity(candidate) {
+	return candidate.collection ? `${candidate.entityType}:${candidate.collection}:${candidate.entityId}` : `${candidate.entityType}:${candidate.entityId}`;
+}
+function sortCandidates(candidates) {
+	return candidates.toSorted((left, right) => {
+		const reasonRank = matchReasonRank(left.matchReason) - matchReasonRank(right.matchReason);
+		if (reasonRank !== 0) return reasonRank;
+		const providerRank = (left.providerRank ?? Number.MAX_SAFE_INTEGER) - (right.providerRank ?? Number.MAX_SAFE_INTEGER);
+		if (providerRank !== 0) return providerRank;
+		const updatedAtRank = compareOptionalIsoDesc(left.updatedAt, right.updatedAt);
+		if (updatedAtRank !== 0) return updatedAtRank;
+		const createdAtRank = compareOptionalIsoDesc(left.createdAt, right.createdAt);
+		if (createdAtRank !== 0) return createdAtRank;
+		const labelRank = left.label.localeCompare(right.label);
+		if (labelRank !== 0) return labelRank;
+		const keyRank = left.entityKey.localeCompare(right.entityKey);
+		if (keyRank !== 0) return keyRank;
+		return left.entityId.localeCompare(right.entityId);
+	});
+}
+function matchReasonRank(reason) {
+	switch (reason) {
+		case "exact_id": return 0;
+		case "exact_key": return 1;
+		case "exact_slug": return 2;
+		case "alias": return 3;
+		case "display_exact": return 4;
+		case "display_partial": return 5;
+		case "search_provider": return 6;
+	}
+}
+function contentDisplayLabel(item, displayFields) {
+	for (const field of displayFields) {
+		const value = item.data[field];
+		if (typeof value === "string" && value.trim().length > 0) return value;
+	}
+	if (typeof item.data.title === "string" && item.data.title.trim().length > 0) return item.data.title;
+	if (typeof item.data.name === "string" && item.data.name.trim().length > 0) return item.data.name;
+	if (item.slug) return item.slug;
+	return item.id;
+}
+var EntityResolver = class {
+	registry;
+	contentRepository;
+	aliasRepository;
+	collectionContextCache = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		this.registry = new SchemaRegistry(options.db);
+		this.contentRepository = new ContentRepository(options.db);
+		this.aliasRepository = new EntityAliasRepository(options.db);
+	}
+	async resolve(input) {
+		const query = input.query.trim();
+		if (!query) return {
+			status: "not_found",
+			suggestion: "Provide a non-empty query."
+		};
+		const entityTypes = input.entityTypes?.length ? uniqueValues(input.entityTypes) : ENTITY_TYPES;
+		const limit = Math.min(Math.max(input.limit ?? 5, 1), 20);
+		const exactIdOrKey = await this.resolveExactIdOrKey(query, entityTypes, input.collection);
+		const idOrKeyResult = this.finalizeTier(exactIdOrKey, query, limit, entityTypes);
+		if (idOrKeyResult) return idOrKeyResult;
+		const exactSlug = await this.resolveExactSlug(query, entityTypes, input.collection);
+		const slugResult = this.finalizeTier(exactSlug, query, limit, entityTypes);
+		if (slugResult) return slugResult;
+		const alias = await this.resolveAlias(query, entityTypes, input.collection, limit);
+		const aliasResult = this.finalizeTier(alias, query, limit, entityTypes);
+		if (aliasResult) return aliasResult;
+		const displayExact = await this.resolveDisplay(query, entityTypes, input.collection, true, limit);
+		const displayExactResult = this.finalizeTier(displayExact, query, limit, entityTypes);
+		if (displayExactResult) return displayExactResult;
+		const displayPartial = await this.resolveDisplay(query, entityTypes, input.collection, false, limit);
+		const displayPartialResult = this.finalizeTier(displayPartial, query, limit, entityTypes);
+		if (displayPartialResult) return displayPartialResult;
+		const searchMatches = await this.resolveSearchProvider(query, entityTypes, input.collection, limit);
+		const searchResult = this.finalizeTier(searchMatches, query, limit, entityTypes);
+		if (searchResult) return searchResult;
+		return {
+			status: "not_found",
+			suggestion: `No ${describeEntityTypes(entityTypes)} found for "${query}". Check the ID or slug, add an alias, or use a more specific label.`
+		};
+	}
+	finalizeTier(candidates, query, limit, entityTypes) {
+		if (candidates.length === 0) return null;
+		const sorted = dedupeCandidates(candidates).slice(0, limit);
+		if (sorted.length === 1) return {
+			status: "resolved",
+			resolved: stripInternalCandidate(sorted[0])
+		};
+		return {
+			status: "ambiguous",
+			candidates: sorted.map(stripInternalCandidate),
+			suggestion: `Found ${sorted.length} ${describeEntityTypes(entityTypes)} matches for "${query}". Narrow with entity_types or collection before proceeding.`
+		};
+	}
+	async resolveExactIdOrKey(query, entityTypes, collectionHint) {
+		const candidates = [];
+		const [contentCollections, collectionContexts] = await Promise.all([entityTypes.includes("content") ? this.listContentCollections(collectionHint) : Promise.resolve([]), entityTypes.includes("collection") ? this.listAllCollectionContexts() : Promise.resolve([])]);
+		if (entityTypes.includes("content")) for (const context of contentCollections) {
+			const item = await this.contentRepository.findById(context.collection.slug, query);
+			if (!item) continue;
+			candidates.push(this.contentCandidate(item, context, 1, "exact_id"));
+		}
+		const [menus, taxonomies, plugins] = await Promise.all([
+			entityTypes.includes("menu") ? this.listMenus() : Promise.resolve([]),
+			entityTypes.includes("taxonomy") ? this.listTaxonomies() : Promise.resolve([]),
+			entityTypes.includes("plugin") ? this.listPlugins() : Promise.resolve([])
+		]);
+		if (entityTypes.includes("collection")) {
+			for (const context of collectionContexts) if (ULID_PATTERN.test(query) && context.collection.id === query) {
+				candidates.push(collectionCandidate(context.collection, 1, "exact_id"));
+				continue;
+			}
+		}
+		if (entityTypes.includes("menu")) for (const menu of menus) {
+			if (ULID_PATTERN.test(query) && menu.id === query) {
+				candidates.push(menuCandidate(menu, 1, "exact_id"));
+				continue;
+			}
+			if (menu.name === query) candidates.push(menuCandidate(menu, 1, "exact_key"));
+		}
+		if (entityTypes.includes("taxonomy")) for (const taxonomy of taxonomies) {
+			if (ULID_PATTERN.test(query) && taxonomy.id === query) {
+				candidates.push(taxonomyCandidate(taxonomy, 1, "exact_id"));
+				continue;
+			}
+			if (taxonomy.name === query) candidates.push(taxonomyCandidate(taxonomy, 1, "exact_key"));
+		}
+		if (entityTypes.includes("plugin")) {
+			for (const plugin of plugins) if (plugin.id === query) candidates.push(pluginCandidate(plugin, 1, "exact_key"));
+		}
+		return candidates;
+	}
+	async resolveExactSlug(query, entityTypes, collectionHint) {
+		const candidates = [];
+		const [contentCollections, collectionContexts] = await Promise.all([entityTypes.includes("content") ? this.listContentCollections(collectionHint) : Promise.resolve([]), entityTypes.includes("collection") ? this.listAllCollectionContexts() : Promise.resolve([])]);
+		if (entityTypes.includes("collection")) {
+			for (const context of collectionContexts) if (context.collection.slug === query) candidates.push(collectionCandidate(context.collection, 2, "exact_slug"));
+		}
+		if (entityTypes.includes("content")) for (const context of contentCollections) {
+			const item = await this.contentRepository.findBySlug(context.collection.slug, query);
+			if (!item) continue;
+			candidates.push(this.contentCandidate(item, context, 2, "exact_slug"));
+		}
+		return candidates;
+	}
+	async resolveAlias(query, entityTypes, collectionHint, limit) {
+		const matches = await this.aliasRepository.findByNormalizedAlias({
+			normalizedAlias: normalizeEntityAlias(query),
+			entityTypes,
+			collectionSlug: collectionHint,
+			limit
+		});
+		return this.hydrateAliasMatches(matches);
+	}
+	async hydrateAliasMatches(matches) {
+		const candidates = [];
+		for (const match of matches) switch (match.entityType) {
+			case "content": {
+				if (!match.collectionSlug) continue;
+				const context = await this.getCollectionContext(match.collectionSlug);
+				if (!context) continue;
+				const item = await this.contentRepository.findById(match.collectionSlug, match.entityId);
+				if (!item) continue;
+				candidates.push(this.contentCandidate(item, context, 3, "alias"));
+				break;
+			}
+			case "collection": {
+				const collection = (await this.listAllCollectionContexts()).find((item) => item.collection.id === match.entityId)?.collection;
+				if (collection) candidates.push(collectionCandidate(collection, 3, "alias"));
+				break;
+			}
+			case "menu": {
+				const menu = await this.options.db.selectFrom("_dineway_menus").selectAll().where("id", "=", match.entityId).executeTakeFirst();
+				if (menu) candidates.push(menuCandidate(menu, 3, "alias"));
+				break;
+			}
+			case "taxonomy": {
+				const taxonomy = await this.options.db.selectFrom("_dineway_taxonomy_defs").selectAll().where("id", "=", match.entityId).executeTakeFirst();
+				if (taxonomy) candidates.push(taxonomyCandidate(taxonomy, 3, "alias"));
+				break;
+			}
+			case "plugin": {
+				const plugin = (await this.listPlugins()).find((item) => item.id === match.entityId);
+				if (plugin) candidates.push(pluginCandidate(plugin, 3, "alias"));
+				break;
+			}
+		}
+		return candidates;
+	}
+	async resolveDisplay(query, entityTypes, collectionHint, exact, limit) {
+		const candidates = [];
+		const normalizedQuery = normalizeDisplayMatch(query);
+		const [contentCollections, collectionContexts, menus, taxonomies, plugins] = await Promise.all([
+			entityTypes.includes("content") ? this.listContentCollections(collectionHint) : Promise.resolve([]),
+			entityTypes.includes("collection") ? this.listAllCollectionContexts() : Promise.resolve([]),
+			entityTypes.includes("menu") ? this.listMenus() : Promise.resolve([]),
+			entityTypes.includes("taxonomy") ? this.listTaxonomies() : Promise.resolve([]),
+			entityTypes.includes("plugin") ? this.listPlugins() : Promise.resolve([])
+		]);
+		if (entityTypes.includes("collection")) {
+			for (const context of collectionContexts) if (matchesDisplayValues([context.collection.label, context.collection.labelSingular ?? ""], normalizedQuery, exact)) candidates.push(collectionCandidate(context.collection, 4, exact ? "display_exact" : "display_partial"));
+		}
+		if (entityTypes.includes("menu")) {
+			for (const menu of menus) if (matchesDisplayValues([menu.label], normalizedQuery, exact)) candidates.push(menuCandidate(menu, 4, exact ? "display_exact" : "display_partial"));
+		}
+		if (entityTypes.includes("taxonomy")) {
+			for (const taxonomy of taxonomies) if (matchesDisplayValues([taxonomy.label, taxonomy.label_singular ?? ""], normalizedQuery, exact)) candidates.push(taxonomyCandidate(taxonomy, 4, exact ? "display_exact" : "display_partial"));
+		}
+		if (entityTypes.includes("plugin")) {
+			for (const plugin of plugins) if (matchesDisplayValues([plugin.name], normalizedQuery, exact)) candidates.push(pluginCandidate(plugin, 4, exact ? "display_exact" : "display_partial"));
+		}
+		if (entityTypes.includes("content")) for (const context of contentCollections) {
+			const matches = await this.resolveContentDisplay(context, normalizedQuery, exact, limit);
+			candidates.push(...matches);
+		}
+		return candidates;
+	}
+	async resolveContentDisplay(context, normalizedQuery, exact, limit) {
+		const candidates = [];
+		const tableName = `ec_${context.collection.slug}`;
+		validateIdentifier(context.collection.slug, "content collection slug");
+		validateIdentifier(tableName, "content table name");
+		for (const fieldSlug of context.displayFields) {
+			validateIdentifier(fieldSlug, "content display field");
+			const fieldRef = sql.ref(fieldSlug);
+			const likePattern = `%${normalizedQuery}%`;
+			const result = await sql`
+				SELECT
+					id,
+					slug,
+					status,
+					locale,
+					created_at,
+					updated_at
+				FROM ${sql.ref(tableName)}
+				WHERE deleted_at IS NULL
+				AND ${exact ? sql`lower(${fieldRef}) = ${normalizedQuery}` : sql`lower(${fieldRef}) LIKE ${likePattern}`}
+				ORDER BY updated_at DESC, created_at DESC, id ASC
+				LIMIT ${limit}
+			`.execute(this.options.db);
+			for (const row of result.rows) {
+				const item = await this.contentRepository.findById(context.collection.slug, row.id);
+				if (!item) continue;
+				candidates.push(this.contentCandidate(item, context, 4, exact ? "display_exact" : "display_partial"));
+			}
+		}
+		return candidates;
+	}
+	async resolveSearchProvider(query, entityTypes, collectionHint, limit) {
+		if (!entityTypes.includes("content")) return [];
+		const candidates = [];
+		const collections = await this.listContentCollections(collectionHint);
+		for (const context of collections) {
+			if (context.searchEnabled) {
+				const results = await searchCollection(this.options.db, context.collection.slug, query, { limit });
+				let providerRank = 0;
+				for (const result of results.items) {
+					providerRank += 1;
+					const item = await this.contentRepository.findById(context.collection.slug, result.id);
+					if (!item) continue;
+					candidates.push({
+						...this.contentCandidate(item, context, 5, "search_provider"),
+						providerRank
+					});
+				}
+				continue;
+			}
+			candidates.push(...await this.resolveFallbackSearchProvider(context, query, limit));
+		}
+		return candidates;
+	}
+	async resolveFallbackSearchProvider(context, query, limit) {
+		if (context.searchFields.length === 0) return [];
+		const tableName = `ec_${context.collection.slug}`;
+		validateIdentifier(context.collection.slug, "content collection slug");
+		validateIdentifier(tableName, "content table name");
+		const trimmedQuery = query.trim().toLowerCase();
+		if (!trimmedQuery) return [];
+		const likePattern = `%${trimmedQuery}%`;
+		const searchConditions = context.searchFields.map((fieldSlug) => {
+			validateIdentifier(fieldSlug, "content search field");
+			return sql`lower(cast(${sql.ref(fieldSlug)} as text)) LIKE ${likePattern}`;
+		});
+		const result = await sql`
+			SELECT
+				id,
+				slug,
+				status,
+				locale,
+				created_at,
+				updated_at
+			FROM ${sql.ref(tableName)}
+			WHERE deleted_at IS NULL
+			AND (${sql.join(searchConditions, sql` OR `)})
+			ORDER BY updated_at DESC, created_at DESC, id ASC
+			LIMIT ${limit}
+		`.execute(this.options.db);
+		const candidates = [];
+		for (const row of result.rows) {
+			const item = await this.contentRepository.findById(context.collection.slug, row.id);
+			if (!item) continue;
+			candidates.push(this.contentCandidate(item, context, 5, "search_provider"));
+		}
+		return candidates;
+	}
+	async listAllCollectionContexts() {
+		return (await Promise.all((await this.registry.listCollections()).map((collection) => this.getCollectionContext(collection.slug)))).filter((value) => value !== null);
+	}
+	async listContentCollections(collectionHint) {
+		if (collectionHint) {
+			const context = await this.getCollectionContext(collectionHint);
+			return context ? [context] : [];
+		}
+		return this.listAllCollectionContexts();
+	}
+	async getCollectionContext(slug) {
+		let promise = this.collectionContextCache.get(slug);
+		if (!promise) {
+			promise = this.buildCollectionContext(slug);
+			this.collectionContextCache.set(slug, promise);
+		}
+		return promise;
+	}
+	async buildCollectionContext(slug) {
+		const collection = await this.registry.getCollectionWithFields(slug);
+		if (!collection) return null;
+		const ftsManager = new FTSManager(this.options.db);
+		const searchableFields = await ftsManager.getSearchableFields(slug);
+		const searchConfig = await ftsManager.getSearchConfig(slug);
+		return {
+			collection,
+			displayFields: resolveDisplayFields(collection, searchableFields, searchConfig?.weights),
+			searchFields: searchableFields,
+			searchEnabled: searchConfig?.enabled === true
+		};
+	}
+	async listMenus() {
+		return this.options.db.selectFrom("_dineway_menus").selectAll().execute();
+	}
+	async listTaxonomies() {
+		return this.options.db.selectFrom("_dineway_taxonomy_defs").selectAll().execute();
+	}
+	async listPlugins() {
+		const result = await handlePluginList(this.options.db, this.options.handlers.configuredPlugins, this.options.handlers.config.marketplace);
+		return result.success ? result.data?.items ?? [] : [];
+	}
+	contentCandidate(item, context, matchTier, matchReason) {
+		return {
+			entityType: "content",
+			entityId: item.id,
+			entityKey: item.slug ?? item.id,
+			label: contentDisplayLabel(item, context.displayFields),
+			matchTier,
+			matchReason,
+			collection: context.collection.slug,
+			slug: item.slug,
+			status: item.status,
+			locale: item.locale,
+			updatedAt: item.updatedAt,
+			createdAt: item.createdAt
+		};
+	}
+};
+function resolveDisplayFields(collection, searchableFields, weights) {
+	const fieldsBySlug = new Map(collection.fields.map((field) => [field.slug, field]));
+	const weightedFields = Object.entries(weights ?? {}).filter(([slug]) => {
+		const field = fieldsBySlug.get(slug);
+		return !!field && isDisplayField(field);
+	}).toSorted((left, right) => right[1] - left[1]).map(([slug]) => slug);
+	const configuredSearchFields = searchableFields.filter((slug) => {
+		const field = fieldsBySlug.get(slug);
+		return !!field && isDisplayField(field);
+	});
+	const fallbackFields = DISPLAY_FALLBACK_FIELDS.filter((slug) => {
+		const field = fieldsBySlug.get(slug);
+		return !!field && isDisplayField(field);
+	});
+	const remainingDisplayFields = collection.fields.filter((field) => isDisplayField(field)).map((field) => field.slug);
+	return uniqueValues([
+		...weightedFields,
+		...configuredSearchFields,
+		...fallbackFields,
+		...remainingDisplayFields
+	]);
+}
+function dedupeCandidates(candidates) {
+	const sorted = sortCandidates(candidates);
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const candidate of sorted) {
+		const identity = candidateIdentity(candidate);
+		if (seen.has(identity)) continue;
+		seen.add(identity);
+		deduped.push(candidate);
+	}
+	return deduped;
+}
+function stripInternalCandidate(candidate) {
+	const { providerRank: _providerRank, ...publicCandidate } = candidate;
+	return publicCandidate;
+}
+function collectionCandidate(collection, matchTier, matchReason) {
+	return {
+		entityType: "collection",
+		entityId: collection.id,
+		entityKey: collection.slug,
+		label: collection.labelSingular ?? collection.label,
+		matchTier,
+		matchReason,
+		slug: collection.slug,
+		updatedAt: collection.updatedAt,
+		createdAt: collection.createdAt
+	};
+}
+function menuCandidate(menu, matchTier, matchReason) {
+	return {
+		entityType: "menu",
+		entityId: menu.id,
+		entityKey: menu.name,
+		label: menu.label,
+		matchTier,
+		matchReason,
+		updatedAt: menu.updated_at,
+		createdAt: menu.created_at
+	};
+}
+function taxonomyCandidate(taxonomy, matchTier, matchReason) {
+	return {
+		entityType: "taxonomy",
+		entityId: taxonomy.id,
+		entityKey: taxonomy.name,
+		label: taxonomy.label_singular ?? taxonomy.label,
+		matchTier,
+		matchReason,
+		createdAt: taxonomy.created_at
+	};
+}
+function pluginCandidate(plugin, matchTier, matchReason) {
+	const updatedAt = plugin.activatedAt ?? plugin.installedAt ?? plugin.deactivatedAt;
+	return {
+		entityType: "plugin",
+		entityId: plugin.id,
+		entityKey: plugin.id,
+		label: plugin.name,
+		matchTier,
+		matchReason,
+		status: plugin.status,
+		updatedAt,
+		createdAt: plugin.installedAt
+	};
+}
+function matchesDisplayValues(values, normalizedQuery, exact) {
+	return values.some((value) => {
+		const normalizedValue = normalizeDisplayMatch(value);
+		return exact ? normalizedValue === normalizedQuery : normalizedValue.includes(normalizedQuery);
+	});
+}
+function describeEntityTypes(entityTypes) {
+	if (entityTypes.length === 1) return entityTypes[0];
+	if (entityTypes.length === ENTITY_TYPES.length) return "entities";
+	return entityTypes.join(", ");
+}
+
+//#endregion
+//#region src/site-context/expertise.ts
+var ActorExpertiseService = class {
+	db;
+	constructor(options) {
+		this.db = options.db;
+	}
+	async findByScope(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const parsed = parseSiteBriefingScope(input.scope);
+		const includeInherited = input.includeInherited !== false;
+		const scopes = includeInherited ? parsed.ancestors : [parsed.scope];
+		const limit = clampLimit$1(input.limit);
+		const contributions = await this.collectSignals({ scopes });
+		const experts = Array.from(aggregateByActor(contributions).values(), (entry) => accumulatorToActorSummary(entry)).toSorted(compareActorSummaries).slice(0, limit);
+		return {
+			mode: "by_scope",
+			scope: {
+				requested: input.scope,
+				resolved: parsed.scope,
+				type: parsed.type,
+				ancestors: parsed.ancestors,
+				scopes,
+				includeInherited,
+				collection: parsed.collection,
+				contentId: parsed.contentId,
+				pluginId: parsed.pluginId
+			},
+			experts
+		};
+	}
+	async findByActor(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const contributions = await this.collectSignals({
+			actorType: input.actorType,
+			actorId: input.actorId
+		});
+		const scopes = Array.from(aggregateByScope(contributions).values(), (entry) => accumulatorToScopeSummary(entry)).toSorted(compareScopeSummaries);
+		const limitedScopes = input.limit === void 0 ? scopes : scopes.slice(0, clampLimit$1(input.limit));
+		return {
+			mode: "by_actor",
+			actor: {
+				actorType: input.actorType,
+				actorId: input.actorId
+			},
+			counts: sumCounts(limitedScopes.map((item) => item.counts)),
+			scopes: limitedScopes
+		};
+	}
+	async collectSignals(query) {
+		if (query.scopes && query.scopes.length === 0) return [];
+		const [activitySignals, contextSignals, requestedReviewSignals, resolvedReviewSignals] = await Promise.all([
+			this.listActivitySignals(query),
+			this.listContextSignals(query),
+			this.listRequestedReviewSignals(query),
+			this.listResolvedReviewSignals(query)
+		]);
+		return [
+			...activitySignals,
+			...contextSignals,
+			...requestedReviewSignals,
+			...resolvedReviewSignals
+		];
+	}
+	async listActivitySignals(query) {
+		let q = this.db.selectFrom("_dineway_activity_log").select([
+			"actor_type as actorType",
+			"actor_id as actorId",
+			"scope",
+			"action_type as actionType",
+			"created_at as contributedAt"
+		]);
+		if (query.scopes) q = q.where("scope", "in", query.scopes);
+		if (query.actorType) q = q.where("actor_type", "=", query.actorType);
+		if (query.actorId) q = q.where("actor_id", "=", query.actorId);
+		return (await q.execute()).map((row) => ({
+			actorType: row.actorType,
+			actorId: row.actorId,
+			scope: row.scope,
+			type: "activity",
+			actionType: row.actionType,
+			contributedAt: row.contributedAt
+		}));
+	}
+	async listContextSignals(query) {
+		let q = this.db.selectFrom("_dineway_context_entries").select([
+			"created_by_actor_type as actorType",
+			"created_by_actor_id as actorId",
+			"scope",
+			"context_type as contextType",
+			"created_at as contributedAt"
+		]).where("is_current", "=", 1);
+		if (query.scopes) q = q.where("scope", "in", query.scopes);
+		if (query.actorType) q = q.where("created_by_actor_type", "=", query.actorType);
+		if (query.actorId) q = q.where("created_by_actor_id", "=", query.actorId);
+		return (await q.execute()).map((row) => ({
+			actorType: row.actorType,
+			actorId: row.actorId,
+			scope: row.scope,
+			type: "context",
+			contextType: row.contextType,
+			contributedAt: row.contributedAt
+		}));
+	}
+	async listRequestedReviewSignals(query) {
+		let q = this.db.selectFrom("_dineway_review_requests").select([
+			"requested_by_actor_type as actorType",
+			"requested_by_actor_id as actorId",
+			"scope",
+			"action_type as actionType",
+			"created_at as contributedAt"
+		]);
+		if (query.scopes) q = q.where("scope", "in", query.scopes);
+		if (query.actorType) q = q.where("requested_by_actor_type", "=", query.actorType);
+		if (query.actorId) q = q.where("requested_by_actor_id", "=", query.actorId);
+		return (await q.execute()).map((row) => ({
+			actorType: row.actorType,
+			actorId: row.actorId,
+			scope: row.scope,
+			type: "review",
+			actionType: row.actionType,
+			contributedAt: row.contributedAt
+		}));
+	}
+	async listResolvedReviewSignals(query) {
+		let q = this.db.selectFrom("_dineway_review_requests").select([
+			"resolved_by_actor_type as actorType",
+			"resolved_by_actor_id as actorId",
+			"scope",
+			"action_type as actionType",
+			"resolved_at as contributedAt"
+		]).where("resolved_by_actor_type", "is not", null).where("resolved_by_actor_id", "is not", null).where("resolved_at", "is not", null);
+		if (query.scopes) q = q.where("scope", "in", query.scopes);
+		if (query.actorType) q = q.where("resolved_by_actor_type", "=", query.actorType);
+		if (query.actorId) q = q.where("resolved_by_actor_id", "=", query.actorId);
+		return (await q.execute()).map((row) => ({
+			actorType: row.actorType,
+			actorId: row.actorId,
+			scope: row.scope,
+			type: "review",
+			actionType: row.actionType,
+			contributedAt: row.contributedAt
+		}));
+	}
+};
+function aggregateByActor(signals) {
+	const result = /* @__PURE__ */ new Map();
+	for (const signal of signals) {
+		const key = `${signal.actorType}:${signal.actorId}`;
+		const accumulator = result.get(key) ?? createAccumulator({
+			actorType: signal.actorType,
+			actorId: signal.actorId,
+			scope: signal.scope,
+			contributedAt: signal.contributedAt
+		});
+		applySignal(accumulator, signal);
+		result.set(key, accumulator);
+	}
+	return result;
+}
+function aggregateByScope(signals) {
+	const result = /* @__PURE__ */ new Map();
+	for (const signal of signals) {
+		const key = signal.scope;
+		const accumulator = result.get(key) ?? createAccumulator({
+			actorType: signal.actorType,
+			actorId: signal.actorId,
+			scope: signal.scope,
+			contributedAt: signal.contributedAt
+		});
+		applySignal(accumulator, signal);
+		result.set(key, accumulator);
+	}
+	return result;
+}
+function createAccumulator(input) {
+	return {
+		actorType: input.actorType,
+		actorId: input.actorId,
+		scope: input.scope,
+		lastContributedAt: input.contributedAt,
+		contextEntryCount: 0,
+		reviewRequestCount: 0,
+		activityCount: 0,
+		contextTypes: /* @__PURE__ */ new Set(),
+		actionTypes: /* @__PURE__ */ new Set(),
+		reviewActionTypes: /* @__PURE__ */ new Set(),
+		matchedScopes: new Set([input.scope])
+	};
+}
+function applySignal(accumulator, signal) {
+	accumulator.lastContributedAt = maxIsoTimestamp(accumulator.lastContributedAt, signal.contributedAt);
+	accumulator.matchedScopes.add(signal.scope);
+	switch (signal.type) {
+		case "activity":
+			accumulator.activityCount += 1;
+			if (signal.actionType) accumulator.actionTypes.add(signal.actionType);
+			return;
+		case "context":
+			accumulator.contextEntryCount += 1;
+			if (signal.contextType) accumulator.contextTypes.add(signal.contextType);
+			return;
+		case "review":
+			accumulator.reviewRequestCount += 1;
+			if (signal.actionType) accumulator.reviewActionTypes.add(signal.actionType);
+			return;
+	}
+}
+function accumulatorToActorSummary(entry) {
+	return {
+		actorType: entry.actorType,
+		actorId: entry.actorId,
+		lastContributedAt: entry.lastContributedAt,
+		counts: toCounts(entry),
+		contextTypes: [...entry.contextTypes].toSorted(),
+		actionTypes: [...entry.actionTypes].toSorted(),
+		reviewActionTypes: [...entry.reviewActionTypes].toSorted(),
+		scopes: [...entry.matchedScopes].toSorted()
+	};
+}
+function accumulatorToScopeSummary(entry) {
+	const parsed = parseSiteBriefingScope(entry.scope);
+	return {
+		scope: entry.scope,
+		scopeInfo: {
+			scope: parsed.scope,
+			type: parsed.type,
+			collection: parsed.collection,
+			contentId: parsed.contentId,
+			pluginId: parsed.pluginId
+		},
+		lastContributedAt: entry.lastContributedAt,
+		counts: toCounts(entry),
+		contextTypes: [...entry.contextTypes].toSorted(),
+		actionTypes: [...entry.actionTypes].toSorted(),
+		reviewActionTypes: [...entry.reviewActionTypes].toSorted()
+	};
+}
+function toCounts(entry) {
+	const total = entry.contextEntryCount + entry.reviewRequestCount + entry.activityCount;
+	return {
+		contextEntries: entry.contextEntryCount,
+		reviewRequests: entry.reviewRequestCount,
+		activities: entry.activityCount,
+		total
+	};
+}
+function compareActorSummaries(left, right) {
+	return compareCounts(left.counts, right.counts) || compareIsoDesc(left.lastContributedAt, right.lastContributedAt) || left.actorType.localeCompare(right.actorType) || left.actorId.localeCompare(right.actorId);
+}
+function compareScopeSummaries(left, right) {
+	return compareCounts(left.counts, right.counts) || compareIsoDesc(left.lastContributedAt, right.lastContributedAt) || left.scope.localeCompare(right.scope);
+}
+function compareCounts(left, right) {
+	return right.contextEntries - left.contextEntries || right.reviewRequests - left.reviewRequests || right.activities - left.activities || right.total - left.total;
+}
+function compareIsoDesc(left, right) {
+	return right.localeCompare(left);
+}
+function sumCounts(values) {
+	return values.reduce((accumulator, value) => ({
+		contextEntries: accumulator.contextEntries + value.contextEntries,
+		reviewRequests: accumulator.reviewRequests + value.reviewRequests,
+		activities: accumulator.activities + value.activities,
+		total: accumulator.total + value.total
+	}), {
+		contextEntries: 0,
+		reviewRequests: 0,
+		activities: 0,
+		total: 0
+	});
+}
+function maxIsoTimestamp(left, right) {
+	return left.localeCompare(right) >= 0 ? left : right;
+}
+function clampLimit$1(value) {
+	return Math.min(Math.max(1, value ?? 10), 100);
+}
+
+//#endregion
+//#region src/database/repositories/handoff-snapshots.ts
+var HandoffSnapshotRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async create(input) {
+		const id = ulid();
+		await this.db.insertInto("_dineway_handoff_snapshots").values(toInsertableHandoffSnapshot(id, input)).execute();
+		return this.findById(id).then((snapshot) => {
+			if (!snapshot) throw new Error("Failed to create handoff snapshot");
+			return snapshot;
+		});
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_handoff_snapshots").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? rowToHandoffSnapshot(row) : null;
+	}
+	async markResumed(id, resumedAt) {
+		const value = resumedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.updateTable("_dineway_handoff_snapshots").set({ resumed_at: value }).where("id", "=", id).execute();
+		return this.findById(id);
+	}
+};
+function toInsertableHandoffSnapshot(id, input) {
+	return {
+		id,
+		scope: input.scope,
+		actor_type: input.actorType,
+		actor_id: input.actorId,
+		auth_metadata: jsonOrNull(input.authMetadata),
+		objective: input.objective,
+		reasoning: input.reasoning,
+		key_findings: JSON.stringify(input.keyFindings ?? []),
+		touched_objects: JSON.stringify(input.touchedObjects ?? []),
+		pending_actions: JSON.stringify(input.pendingActions ?? []),
+		tool_evidence: JSON.stringify(input.toolEvidence ?? []),
+		confidence: input.confidence ?? null,
+		handoff_kind: input.handoffKind ?? "pause",
+		reference_type: input.referenceType ?? null,
+		reference_id: input.referenceId ?? null,
+		created_at: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		resumed_at: null
+	};
+}
+function rowToHandoffSnapshot(row) {
+	return {
+		id: row.id,
+		scope: row.scope,
+		actorType: row.actor_type,
+		actorId: row.actor_id,
+		authMetadata: parseRecord(row.auth_metadata),
+		objective: row.objective,
+		reasoning: row.reasoning,
+		keyFindings: parseArray(row.key_findings),
+		touchedObjects: parseArray(row.touched_objects),
+		pendingActions: parseArray(row.pending_actions),
+		toolEvidence: parseArray(row.tool_evidence),
+		confidence: row.confidence,
+		handoffKind: row.handoff_kind,
+		referenceType: row.reference_type,
+		referenceId: row.reference_id,
+		createdAt: row.created_at,
+		resumedAt: row.resumed_at
+	};
+}
+function jsonOrNull(value) {
+	return value ? JSON.stringify(value) : null;
+}
+function parseRecord(value) {
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function parseArray(value) {
+	if (!value) return [];
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed.filter((_item) => true) : [];
+	} catch {
+		return [];
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/site-context/handoff.ts
+const DEFAULT_ACTIVITY_LIMIT = 25;
+const DEFAULT_REVIEW_LIMIT = 25;
+const MAX_DIFF_LIMIT = 100;
+var HandoffSnapshotStore = class {
+	db;
+	now;
+	constructor(options) {
+		this.db = options.db;
+		this.now = options.now ?? /* @__PURE__ */ new Date();
+	}
+	async capture(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		parseSiteBriefingScope(input.scope);
+		return new HandoffSnapshotRepository(this.db).create(input);
+	}
+	async get(id) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		return new HandoffSnapshotRepository(this.db).findById(id);
+	}
+	async resume(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const repository = new HandoffSnapshotRepository(this.db);
+		const snapshot = await repository.findById(input.id);
+		if (!snapshot) return null;
+		const resumedAt = this.now.toISOString();
+		const resumed = await repository.markResumed(snapshot.id, resumedAt);
+		if (!resumed) return null;
+		const scope = parseSiteBriefingScope(resumed.scope);
+		const permissions = {
+			canReadContent: false,
+			...input.permissions
+		};
+		const activityLimit = clampLimit(input.activityLimit ?? DEFAULT_ACTIVITY_LIMIT);
+		const reviewLimit = clampLimit(input.reviewLimit ?? DEFAULT_REVIEW_LIMIT);
+		const [activity, context, reviewRequests] = permissions.canReadContent ? await Promise.all([
+			new SiteActivityRepository(this.db).findTimeline({
+				scopes: scope.ancestors,
+				since: resumed.createdAt,
+				limit: activityLimit
+			}),
+			new ContextRepository(this.db).diff({
+				scopes: scope.ancestors,
+				since: resumed.createdAt,
+				now: resumedAt
+			}),
+			new ReviewRequestRepository(this.db).list({
+				scopes: scope.ancestors,
+				since: resumed.createdAt,
+				limit: reviewLimit
+			})
+		]) : [
+			null,
+			null,
+			null
+		];
+		return {
+			snapshot: resumed,
+			resumedAt,
+			diff: {
+				scope: summarizeScope(scope),
+				since: resumed.createdAt,
+				activity: permissions.canReadContent ? includedSection({
+					scopes: scope.ancestors,
+					items: activity.items
+				}) : omittedSection({
+					scopes: scope.ancestors,
+					items: []
+				}, "missing content:read permission"),
+				context: permissions.canReadContent ? includedSection({
+					scopes: scope.ancestors,
+					diff: context
+				}) : omittedSection({
+					scopes: scope.ancestors,
+					diff: {
+						newEntries: [],
+						supersededEntries: [],
+						staleEntries: [],
+						reviewedEntries: []
+					}
+				}, "missing content:read permission"),
+				reviewRequests: permissions.canReadContent ? includedSection({
+					scopes: scope.ancestors,
+					items: reviewRequests.items
+				}) : omittedSection({
+					scopes: scope.ancestors,
+					items: []
+				}, "missing content:read permission")
+			}
+		};
+	}
+};
+function summarizeScope(scope) {
+	return {
+		requested: scope.scope,
+		resolved: scope.scope,
+		type: scope.type,
+		ancestors: scope.ancestors,
+		collection: scope.collection,
+		contentId: scope.contentId,
+		pluginId: scope.pluginId
+	};
+}
+function includedSection(data) {
+	return {
+		status: "included",
+		data
+	};
+}
+function omittedSection(data, reason) {
+	return {
+		status: "omitted",
+		reason,
+		data
+	};
+}
+function clampLimit(value) {
+	return Math.min(Math.max(1, Math.floor(value)), MAX_DIFF_LIMIT);
+}
+
+//#endregion
+//#region src/site-context/assignments.ts
+const ASSIGNMENT_VALID_FROM = {
+	accept: ["pending"],
+	start: ["accepted", "blocked"],
+	block: ["accepted", "in_progress"],
+	complete: [
+		"pending",
+		"accepted",
+		"in_progress"
+	],
+	decline: ["pending", "accepted"],
+	cancel: [
+		"pending",
+		"accepted",
+		"in_progress",
+		"blocked"
+	]
+};
+var AssignmentService = class {
+	repository;
+	constructor(db) {
+		this.db = db;
+		this.repository = new AssignmentRepository(db);
+	}
+	async create(actor, input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		if (input.relatedHandoffSnapshotId) {
+			const snapshot = await new HandoffSnapshotRepository(this.db).findById(input.relatedHandoffSnapshotId);
+			if (!snapshot) throw new Error(`Handoff snapshot not found: ${input.relatedHandoffSnapshotId}`);
+			if (snapshot.scope !== input.scope) throw new Error("Related handoff snapshot scope must match the assignment scope.");
+		}
+		return this.repository.create({
+			scope: input.scope,
+			assignmentType: input.assignmentType,
+			title: input.title,
+			summary: input.summary,
+			details: input.details,
+			priority: input.priority,
+			assignedByActorType: actor.actorType,
+			assignedByActorId: actor.actorId,
+			assignedToActorType: input.assignedToActorType,
+			assignedToActorId: input.assignedToActorId,
+			metadata: input.metadata,
+			relatedHandoffSnapshotId: input.relatedHandoffSnapshotId,
+			dueAt: input.dueAt,
+			createdAt: input.createdAt
+		});
+	}
+	async get(id, actor) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const assignment = await this.repository.findById(id);
+		if (!assignment) return null;
+		this.assertReadable(assignment, actor);
+		return assignment;
+	}
+	async list(actor, input = {}) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		return this.repository.list(this.buildListQuery(actor, input));
+	}
+	async accept(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const assignment = await this.loadExisting(input.id);
+		this.assertAssigneeAction("accept", assignment, input.actor);
+		this.assertValidAction("accept", assignment.status);
+		const accepted = await this.repository.accept(assignment.id, {
+			assignedToActorType: assignment.assignedToActorType ?? input.actor.actorType,
+			assignedToActorId: assignment.assignedToActorId ?? input.actor.actorId,
+			acceptedAt: input.at,
+			metadata: assignment.metadata
+		});
+		if (!accepted) throw new Error(`Failed to accept assignment ${assignment.id}.`);
+		return accepted;
+	}
+	async start(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const assignment = await this.loadExisting(input.id);
+		this.assertAssigneeAction("start", assignment, input.actor);
+		this.assertValidAction("start", assignment.status);
+		const started = await this.repository.start(assignment.id, {
+			at: input.at ?? assignment.startedAt ?? void 0,
+			metadata: assignment.metadata
+		});
+		if (!started) throw new Error(`Failed to start assignment ${assignment.id}.`);
+		return started;
+	}
+	async block(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const assignment = await this.loadExisting(input.id);
+		this.assertAssigneeAction("block", assignment, input.actor);
+		this.assertValidAction("block", assignment.status);
+		const blocked = await this.repository.block(assignment.id, {
+			at: input.at,
+			metadata: mergeReasonMetadata(assignment.metadata, "block_reason", input.reason)
+		});
+		if (!blocked) throw new Error(`Failed to block assignment ${assignment.id}.`);
+		return blocked;
+	}
+	async complete(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const assignment = await this.loadExisting(input.id);
+		this.assertAssigneeAction("complete", assignment, input.actor);
+		this.assertValidAction("complete", assignment.status);
+		const completed = await this.repository.complete(assignment.id, {
+			at: input.at,
+			metadata: mergeReasonMetadata(assignment.metadata, "completion_note", input.reason)
+		});
+		if (!completed) throw new Error(`Failed to complete assignment ${assignment.id}.`);
+		return completed;
+	}
+	async decline(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const assignment = await this.loadExisting(input.id);
+		this.assertAssigneeAction("decline", assignment, input.actor);
+		this.assertValidAction("decline", assignment.status);
+		const declined = await this.repository.decline(assignment.id, {
+			at: input.at,
+			metadata: mergeReasonMetadata(assignment.metadata, "decline_reason", input.reason)
+		});
+		if (!declined) throw new Error(`Failed to decline assignment ${assignment.id}.`);
+		return declined;
+	}
+	async cancel(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const assignment = await this.loadExisting(input.id);
+		this.assertCanceller(assignment, input.actor);
+		this.assertValidAction("cancel", assignment.status);
+		const cancelled = await this.repository.cancel(assignment.id, {
+			at: input.at,
+			metadata: mergeReasonMetadata(assignment.metadata, "cancel_reason", input.reason)
+		});
+		if (!cancelled) throw new Error(`Failed to cancel assignment ${assignment.id}.`);
+		return cancelled;
+	}
+	buildListQuery(actor, input) {
+		const query = {
+			scope: input.scope,
+			scopes: input.scopes,
+			statuses: input.statuses,
+			priority: input.priority,
+			assignmentType: input.assignmentType,
+			since: input.since,
+			limit: input.limit,
+			cursor: input.cursor
+		};
+		if (isWorkflowSupervisor(actor.userRole)) {
+			if (input.assignedToMe && !input.assignedByMe) {
+				query.assignedToActorType = actor.actorType;
+				query.assignedToActorId = actor.actorId;
+			} else if (input.assignedByMe && !input.assignedToMe) {
+				query.assignedByActorType = actor.actorType;
+				query.assignedByActorId = actor.actorId;
+			}
+			return query;
+		}
+		if (input.assignedToMe && !input.assignedByMe) {
+			query.assignedToActorType = actor.actorType;
+			query.assignedToActorId = actor.actorId;
+			return query;
+		}
+		if (input.assignedByMe && !input.assignedToMe) {
+			query.assignedByActorType = actor.actorType;
+			query.assignedByActorId = actor.actorId;
+			return query;
+		}
+		query.participantActor = {
+			actorType: actor.actorType,
+			actorId: actor.actorId
+		};
+		return query;
+	}
+	async loadExisting(id) {
+		const assignment = await this.repository.findById(id);
+		if (!assignment) throw new Error(`Assignment not found: ${id}`);
+		return assignment;
+	}
+	assertReadable(assignment, actor) {
+		if (isWorkflowSupervisor(actor.userRole)) return;
+		if (matchesActor$1(assignment.assignedByActorType, assignment.assignedByActorId, actor) || matchesActor$1(assignment.assignedToActorType, assignment.assignedToActorId, actor)) return;
+		throw new Error("Insufficient permissions to access this assignment.");
+	}
+	assertAssigneeAction(action, assignment, actor) {
+		if (isWorkflowSupervisor(actor.userRole)) return;
+		if (!assignment.assignedToActorType || !assignment.assignedToActorId) {
+			if (action === "accept") return;
+			throw new Error(`Only an assigned actor can ${action} this assignment.`);
+		}
+		if (matchesActor$1(assignment.assignedToActorType, assignment.assignedToActorId, actor)) return;
+		throw new Error(`Only the assignee can ${action} this assignment.`);
+	}
+	assertCanceller(assignment, actor) {
+		if (isWorkflowSupervisor(actor.userRole)) return;
+		if (matchesActor$1(assignment.assignedByActorType, assignment.assignedByActorId, actor)) return;
+		throw new Error("Only the assigner or an editor can cancel this assignment.");
+	}
+	assertValidAction(action, currentStatus) {
+		const blocker = validateAssignmentAction(action, currentStatus);
+		if (blocker) throw new Error(blocker);
+	}
+};
+function validateAssignmentAction(action, currentStatus) {
+	const validFrom = ASSIGNMENT_VALID_FROM[action];
+	if (validFrom.includes(currentStatus)) return null;
+	return `Cannot ${action} an assignment that is currently '${currentStatus}'. Must be: ${validFrom.join(" or ")}`;
+}
+function matchesActor$1(actorType, actorId, actor) {
+	return actorType === actor.actorType && actorId === actor.actorId;
+}
+function isWorkflowSupervisor(userRole) {
+	return userRole >= Role.EDITOR;
+}
+function mergeReasonMetadata(metadata, key, reason) {
+	if (!reason) return metadata;
+	return {
+		...metadata,
+		[key]: reason
+	};
+}
+
+//#endregion
+//#region src/site-context/hitl.ts
+const HITL_REQUEST_VALID_FROM = { resolve: ["pending"] };
+var HitlRequestService = class {
+	repository;
+	assignments;
+	constructor(db) {
+		this.db = db;
+		this.repository = new HitlRequestRepository(db);
+		this.assignments = new AssignmentRepository(db);
+	}
+	async create(actor, input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		parseSiteBriefingScope(input.scope);
+		const assignment = input.relatedAssignmentId ? await this.assignments.findById(input.relatedAssignmentId) : null;
+		if (input.relatedAssignmentId && !assignment) throw new Error(`Assignment not found: ${input.relatedAssignmentId}`);
+		if (assignment) {
+			this.assertRelatedAssignmentReadable(assignment, actor);
+			if (assignment.scope !== input.scope) throw new Error("Related assignment scope must match the HITL request scope.");
+			if (assignment.relatedHitlRequestId) throw new Error(`Assignment ${assignment.id} is already linked to HITL request ${assignment.relatedHitlRequestId}.`);
+		}
+		if (input.relatedHandoffSnapshotId) {
+			const snapshot = await new HandoffSnapshotRepository(this.db).findById(input.relatedHandoffSnapshotId);
+			if (!snapshot) throw new Error(`Handoff snapshot not found: ${input.relatedHandoffSnapshotId}`);
+			this.assertRelatedHandoffSnapshotReadable(snapshot, actor);
+			if (snapshot.scope !== input.scope) throw new Error("Related handoff snapshot scope must match the HITL request scope.");
+		}
+		const request = await this.repository.create({
+			scope: input.scope,
+			actionType: input.actionType,
+			title: input.title,
+			summary: input.summary,
+			riskReason: input.riskReason,
+			reviewPayload: input.reviewPayload,
+			targetRefType: input.targetRefType,
+			targetRefId: input.targetRefId,
+			requestedByActorType: actor.actorType,
+			requestedByActorId: actor.actorId,
+			requestedAuthMetadata: actor.authMetadata,
+			priority: input.priority,
+			metadata: input.metadata,
+			relatedAssignmentId: input.relatedAssignmentId,
+			relatedHandoffSnapshotId: input.relatedHandoffSnapshotId,
+			slaDueAt: input.slaDueAt,
+			createdAt: input.createdAt
+		});
+		if (assignment) {
+			if (!await this.assignments.linkHitlRequest(assignment.id, request.id, request.createdAt)) throw new Error(`Failed to link assignment ${assignment.id} to HITL request ${request.id}.`);
+		}
+		return request;
+	}
+	async get(id, actor) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const request = await this.repository.findById(id);
+		if (!request) return null;
+		this.assertReadable(request, actor);
+		return request;
+	}
+	async list(actor, input = {}) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		return this.repository.list(this.buildListQuery(actor, input));
+	}
+	async resolve(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const request = await this.loadExisting(input.id);
+		this.assertResolver(input.actor);
+		this.assertReadable(request, input.actor);
+		this.assertValidAction("resolve", request.status);
+		const resolved = await this.repository.resolve(request.id, {
+			decision: input.decision,
+			resolvedByActorType: input.actor.actorType,
+			resolvedByActorId: input.actor.actorId,
+			resolvedAuthMetadata: input.actor.authMetadata,
+			reviewNote: input.reviewNote,
+			resolvedAt: input.at
+		});
+		if (!resolved) throw new Error(`Failed to resolve HITL request ${request.id}.`);
+		return resolved;
+	}
+	buildListQuery(actor, input) {
+		const query = {
+			scope: input.scope,
+			scopes: input.scopes,
+			statuses: input.statuses,
+			priority: input.priority,
+			actionType: input.actionType,
+			targetRefType: input.targetRefType,
+			targetRefId: input.targetRefId,
+			relatedAssignmentId: input.relatedAssignmentId,
+			since: input.since,
+			limit: input.limit,
+			cursor: input.cursor
+		};
+		if (isHitlSupervisor(actor.userRole)) return query;
+		return {
+			...query,
+			requestedByActorType: actor.actorType,
+			requestedByActorId: actor.actorId
+		};
+	}
+	async loadExisting(id) {
+		const request = await this.repository.findById(id);
+		if (!request) throw new Error(`HITL request not found: ${id}`);
+		return request;
+	}
+	assertReadable(request, actor) {
+		if (isHitlSupervisor(actor.userRole)) return;
+		if (request.requestedByActorType === actor.actorType && request.requestedByActorId === actor.actorId) return;
+		throw new Error("Insufficient permissions to read this HITL request.");
+	}
+	assertResolver(actor) {
+		if (isHitlSupervisor(actor.userRole)) return;
+		throw new Error("HITL requests may only be resolved by an editor or admin.");
+	}
+	assertRelatedAssignmentReadable(assignment, actor) {
+		if (isHitlSupervisor(actor.userRole)) return;
+		if (matchesActor(assignment.assignedByActorType, assignment.assignedByActorId, actor) || matchesActor(assignment.assignedToActorType, assignment.assignedToActorId, actor)) return;
+		throw new Error("Insufficient permissions to link this assignment to a HITL request.");
+	}
+	assertRelatedHandoffSnapshotReadable(snapshot, actor) {
+		if (isHitlSupervisor(actor.userRole)) return;
+		if (matchesActor(snapshot.actorType, snapshot.actorId, actor)) return;
+		throw new Error("Insufficient permissions to link this handoff snapshot to a HITL request.");
+	}
+	assertValidAction(action, status) {
+		const validFrom = HITL_REQUEST_VALID_FROM[action];
+		if (!validFrom.includes(status)) throw new Error(`Cannot ${action} a HITL request in status "${status}". Valid statuses: ${validFrom.join(", ")}.`);
+	}
+};
+function isHitlSupervisor(role) {
+	return role >= Role.EDITOR;
+}
+function matchesActor(actorType, actorId, actor) {
+	return actorType === actor.actorType && actorId === actor.actorId;
+}
+
+//#endregion
+//#region src/site-context/workflow-hitl.ts
+var WorkflowHitlCoordinator = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async ensureRequest(input) {
+		assertExperimentalSiteContextWorkflowsEnabled();
+		const matching = (await new HitlRequestRepository(this.db).list({
+			scope: input.action.scope,
+			statuses: ["pending", "approved"],
+			actionType: input.action.actionType,
+			targetRefType: input.action.targetRefType,
+			targetRefId: input.action.targetRefId,
+			limit: 50
+		})).items.find((item) => {
+			const actionHash = item.metadata.actionHash;
+			return typeof actionHash === "string" && actionHash === input.action.actionHash;
+		});
+		if (matching) return {
+			created: false,
+			request: matching
+		};
+		return {
+			created: true,
+			request: await new HitlRequestService(this.db).create(input.actor, {
+				scope: input.action.scope,
+				actionType: input.action.actionType,
+				title: input.action.title,
+				summary: input.action.summary,
+				riskReason: input.action.riskReason,
+				reviewPayload: input.action.reviewPayload,
+				targetRefType: input.action.targetRefType,
+				targetRefId: input.action.targetRefId,
+				priority: input.action.priority,
+				metadata: input.action.metadata
+			})
+		};
+	}
+};
+
+//#endregion
+export { HITL_REQUEST_STATUSES as C, ASSIGNMENT_STATUSES as E, HITL_REQUEST_PRIORITIES as S, ASSIGNMENT_PRIORITIES as T, RiskPolicyEvaluator as _, ActorExpertiseService as a, toPublicContextEntry as b, SectionHitlPayloadBuilder as c, RedirectHitlPayloadBuilder as d, SettingsHitlPayloadBuilder as f, SchemaHitlPayloadBuilder as g, PluginHitlPayloadBuilder as h, HandoffSnapshotStore as i, TaxonomyHitlPayloadBuilder as l, ExclusiveHookHitlPayloadBuilder as m, HitlRequestService as n, EntityResolver as o, WordPressImportHitlPayloadBuilder as p, AssignmentService as r, WidgetHitlPayloadBuilder as s, WorkflowHitlCoordinator as t, MenuHitlPayloadBuilder as u, ReviewPayloadBuilder as v, ASSIGNMENT_ACTOR_TYPES as w, toPublicContextEntryPage as x, toPublicContextDiff as y };