@happyvertical/smrt-content 0.43.8 → 0.43.10

package/dist/server.js

@@ -0,0 +1,874 @@
+import { v as buildContentQuerySchema, w as Content, x as executeContentQuery } from "./chunks/content-query-4w62u5_0.js";
+import { MAX_DATA_QUERY_PAGE_LIMIT, createDataQueryFingerprint, normalizeDataQueryRequest, startRestServer } from "@happyvertical/smrt-core";
+import { createHash } from "node:crypto";
+import "@happyvertical/smrt-facts";
+import { PrincipalToolNotAllowedError } from "@happyvertical/smrt-agents";
+import { createDataSurfaceActionAdapter, isBoundedDataSurfaceJsonValue } from "@happyvertical/smrt-agents/server";
+//#region src/server/content-list-actions.ts
+var CONTENT_LIST_WORKFLOW_IDS = [
+	"move-to-trash",
+	"mark-draft",
+	"submit-review",
+	"publish",
+	"archive",
+	"restore",
+	"automated-review",
+	"format-body",
+	"categorize",
+	"optimize"
+];
+var ALL_SELECTION_SCOPES = [
+	"current-page",
+	"explicit-ids",
+	"all-matching"
+];
+var NO_INPUT = {
+	type: "object",
+	additionalProperties: false
+};
+var OPTIONAL_REVIEW_INPUT = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		kind: {
+			type: "string",
+			enum: [
+				"facts",
+				"safety",
+				"custom"
+			]
+		},
+		policyKey: {
+			type: "string",
+			maxLength: 128
+		}
+	}
+};
+var CONTENT_UPDATE_OPERATION = {
+	id: "contents:update",
+	collection: "contents",
+	action: "update"
+};
+var CONTENT_READ_OPERATION = {
+	id: "contents:read",
+	collection: "contents",
+	action: "read"
+};
+var PUBLICATION_OPERATIONS = [
+	CONTENT_READ_OPERATION,
+	CONTENT_UPDATE_OPERATION,
+	...[
+		{
+			id: "content-governance-assignments:read",
+			collection: "contentgovernanceassignments",
+			action: "read"
+		},
+		{
+			id: "content-governance-policies:read",
+			collection: "contentgovernancepolicies",
+			action: "read"
+		},
+		{
+			id: "content-governance-profiles:read",
+			collection: "contentgovernanceprofiles",
+			action: "read"
+		}
+	],
+	{
+		id: "content-references:read",
+		collection: "contentreferences",
+		action: "read"
+	},
+	{
+		id: "content-assets:read",
+		collection: "contentassets",
+		action: "read"
+	},
+	{
+		id: "assets:read",
+		collection: "assets",
+		action: "read"
+	},
+	{
+		id: "facts:read",
+		collection: "facts",
+		action: "read"
+	},
+	{
+		id: "fact-contents:read",
+		collection: "factcontents",
+		action: "read"
+	},
+	{
+		id: "fact-sources:read",
+		collection: "factsources",
+		action: "read"
+	},
+	{
+		id: "content-reviews:read",
+		collection: "contentreviews",
+		action: "read"
+	},
+	{
+		id: "content-corrections:read",
+		collection: "contentcorrections",
+		action: "read"
+	},
+	{
+		id: "content-versions:read",
+		collection: "contentversions",
+		action: "read"
+	},
+	{
+		id: "content-versions:create",
+		collection: "contentversions",
+		action: "create"
+	}
+];
+var AUTOMATED_REVIEW_OPERATIONS = [
+	...PUBLICATION_OPERATIONS,
+	{
+		id: "prompt-overrides:read",
+		collection: "promptoverrides",
+		action: "read"
+	},
+	{
+		id: "content-reviews:create",
+		collection: "contentreviews",
+		action: "create"
+	}
+];
+var CONTENT_LIST_WORKFLOWS = Object.freeze([
+	workflow("move-to-trash", "Move to trash", {
+		description: "Soft-delete eligible content into the trash lifecycle.",
+		sensitivity: "sensitive",
+		eligibility: ["content is not already deleted"],
+		consequences: ["Content leaves active views and becomes restorable from trash."]
+	}),
+	workflow("mark-draft", "Mark draft", {
+		description: "Return eligible active content to draft.",
+		eligibility: ["content is not deleted", "content is not already draft"],
+		consequences: ["Published content is no longer public."]
+	}),
+	workflow("submit-review", "Submit for review", {
+		description: "Move eligible draft content into editorial review.",
+		eligibility: ["content is draft"],
+		consequences: ["Content enters the review queue."]
+	}),
+	workflow("publish", "Publish", {
+		description: "Publish content that passes current governance readiness.",
+		sensitivity: "sensitive",
+		eligibility: ["content is draft, review, or archived", "publication readiness passes"],
+		consequences: ["Content becomes public and may create a publication snapshot."],
+		permissionRequirements: {
+			tool: "content.workflow.publish",
+			operations: [...PUBLICATION_OPERATIONS]
+		}
+	}),
+	workflow("archive", "Archive", {
+		description: "Remove eligible content from active publication workflows.",
+		eligibility: ["content is not deleted", "content is not already archived"],
+		consequences: ["Published content is no longer public."]
+	}),
+	workflow("restore", "Restore", {
+		description: "Restore deleted content to an explicit eligible status.",
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: ["status"],
+			properties: { status: { enum: [
+				"draft",
+				"review",
+				"published"
+			] } }
+		},
+		eligibility: [
+			"content is deleted",
+			"requested destination is valid",
+			"publish readiness passes when publishing"
+		],
+		consequences: ["Content leaves trash.", "Publishing makes content public."],
+		permissionRequirements: {
+			tool: "content.workflow.restore",
+			operations: [...PUBLICATION_OPERATIONS]
+		}
+	}),
+	workflow("automated-review", "Automated review", {
+		description: "Run the configured content governance review.",
+		execution: "background",
+		inputSchema: OPTIONAL_REVIEW_INPUT,
+		eligibility: ["content is not deleted", "content governance is configured"],
+		consequences: ["Creates a review result and may create a review version."],
+		permissionRequirements: {
+			tool: "content.workflow.automated-review",
+			operations: [...AUTOMATED_REVIEW_OPERATIONS]
+		}
+	}),
+	workflow("format-body", "Format body", {
+		description: "Run the application-owned body-formatting workflow.",
+		execution: "background",
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			properties: { format: { enum: ["markdown", "html"] } }
+		},
+		eligibility: ["content is not deleted", "a formatting handler is configured"],
+		consequences: ["The persisted content body may change."],
+		permissionRequirements: {
+			tool: "content.workflow.format-body",
+			operations: [...PUBLICATION_OPERATIONS]
+		}
+	}),
+	workflow("categorize", "Categorize", {
+		description: "Assign one required hierarchical category path.",
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: ["category"],
+			properties: { category: {
+				type: "string",
+				minLength: 1,
+				maxLength: 256
+			} }
+		},
+		eligibility: ["content is not deleted", "category is non-empty"],
+		consequences: ["The content category changes."],
+		permissionRequirements: {
+			tool: "content.workflow.categorize",
+			operations: [...PUBLICATION_OPERATIONS]
+		}
+	}),
+	workflow("optimize", "Optimize / complete", {
+		description: "Run the application-owned content optimization workflow.",
+		execution: "background",
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			properties: { instructions: {
+				type: "string",
+				maxLength: 4096
+			} }
+		},
+		eligibility: ["content is draft or review", "an optimization handler is configured"],
+		consequences: ["Content fields may be revised or completed."]
+	})
+]);
+function workflow(id, label, options) {
+	return {
+		id,
+		label,
+		description: options.description,
+		selectionScopes: options.selectionScopes ?? [...ALL_SELECTION_SCOPES],
+		sensitivity: options.sensitivity ?? "public",
+		confirmation: options.confirmation ?? "required",
+		execution: options.execution ?? "foreground",
+		inputSchema: options.inputSchema ?? NO_INPUT,
+		eligibility: options.eligibility,
+		permissionRequirements: options.permissionRequirements ?? {
+			tool: `content.workflow.${id}`,
+			operations: [CONTENT_READ_OPERATION, CONTENT_UPDATE_OPERATION]
+		},
+		consequences: options.consequences,
+		partialResult: {
+			statuses: [
+				"accepted",
+				"skipped",
+				"failed"
+			],
+			preservesFailedSelection: true
+		}
+	};
+}
+var UnsupportedContentListWorkflowStorageError = class extends Error {
+	code = "UNSUPPORTED_CONTENT_LIST_WORKFLOW_STORAGE";
+	constructor(storage) {
+		super(`ContentList workflows do not support ${storage.adapterType} with immediate write-back because exported files are not transactionally rolled back. Use PostgreSQL, SQLite, ordinary DuckDB, or a non-immediate write strategy.`);
+		this.name = "UnsupportedContentListWorkflowStorageError";
+	}
+};
+function assertContentListWorkflowStorageSupported(storage) {
+	const adapterType = storage?.adapterType;
+	const writeStrategy = storage?.writeStrategy;
+	if (adapterType !== "sqlite" && adapterType !== "postgres" && adapterType !== "duckdb" && adapterType !== "json") throw new TypeError("ContentList workflow storage adapterType must be sqlite, postgres, duckdb, or json.");
+	if (writeStrategy !== void 0 && writeStrategy !== "immediate" && writeStrategy !== "manual" && writeStrategy !== "none") throw new TypeError("ContentList workflow storage writeStrategy must be immediate, manual, or none.");
+	const effectiveStrategy = adapterType === "json" ? writeStrategy ?? "immediate" : writeStrategy;
+	if ((adapterType === "json" || adapterType === "duckdb") && effectiveStrategy === "immediate") throw new UnsupportedContentListWorkflowStorageError({
+		adapterType,
+		writeStrategy: effectiveStrategy
+	});
+}
+var REQUIRED_QUERY_FIELDS = [
+	"id",
+	"title",
+	"status",
+	"updated_at"
+];
+var DEFAULT_MAX_SELECTION_SIZE = 200;
+var DEFAULT_REPRESENTATIVE_LIMIT = 5;
+var ContentListActionError = class extends Error {
+	constructor(reason) {
+		super(reason);
+		this.reason = reason;
+	}
+	reason;
+};
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isPermissionDenied(error) {
+	if (!(error instanceof Error) || error.name !== "OperationPermissionError") return false;
+	const decision = error.decision;
+	return isRecord(decision) && decision.reason === "permission_denied";
+}
+function isWorkflowId(value) {
+	return CONTENT_LIST_WORKFLOW_IDS.includes(value);
+}
+function payloadRecord(value) {
+	return isRecord(value) ? value : {};
+}
+function validPayload(workflowId, payload) {
+	if (payload !== void 0 && !isRecord(payload)) return false;
+	const value = payloadRecord(payload);
+	const keys = Object.keys(value);
+	switch (workflowId) {
+		case "restore": return keys.length === 1 && typeof value.status === "string" && [
+			"draft",
+			"review",
+			"published"
+		].includes(value.status);
+		case "categorize": return keys.length === 1 && typeof value.category === "string" && value.category.trim().length > 0 && value.category.length <= 256;
+		case "automated-review": return keys.every((key) => ["kind", "policyKey"].includes(key)) && (value.kind === void 0 || typeof value.kind === "string" && [
+			"facts",
+			"safety",
+			"custom"
+		].includes(value.kind) && value.kind.length > 0 && value.kind.length <= 64) && (value.policyKey === void 0 || typeof value.policyKey === "string" && value.policyKey.length > 0 && value.policyKey.length <= 128);
+		case "format-body": return keys.every((key) => key === "format") && (value.format === void 0 || value.format === "markdown" || value.format === "html");
+		case "optimize": return keys.every((key) => key === "instructions") && (value.instructions === void 0 || typeof value.instructions === "string" && value.instructions.length <= 4096);
+		default: return keys.length === 0;
+	}
+}
+function actionResult(request, ok, reason) {
+	const candidate = isRecord(request) ? request : {};
+	const identityCandidate = isRecord(candidate.identity) ? candidate.identity : {};
+	const identity = typeof identityCandidate.surfaceId === "string" && [
+		"table",
+		"list",
+		"report",
+		"custom"
+	].includes(String(identityCandidate.kind)) ? identityCandidate : {
+		surfaceId: "content-list",
+		kind: "table"
+	};
+	return {
+		version: 1,
+		requestId: typeof candidate.requestId === "string" ? candidate.requestId : "invalid-request",
+		identity,
+		actionId: typeof candidate.actionId === "string" ? candidate.actionId : "invalid",
+		phase: candidate.phase === "apply" ? "apply" : "preview",
+		ok,
+		...reason ? { reason } : {}
+	};
+}
+function validateTarget(request) {
+	if (!isRecord(request) || !isWorkflowId(request.actionId) || !isRecord(request.target) || !isRecord(request.selection)) return "invalid_request";
+	if (Object.keys(request.target).some((key) => key !== "query" && key !== "expectedCount")) return "invalid_request";
+	const expectedCount = request.target.expectedCount;
+	if (typeof expectedCount !== "number" || !Number.isSafeInteger(expectedCount) || expectedCount < 0) return "invalid_request";
+	if (request.selection.scope !== "explicit-ids" && !isRecord(request.target.query)) return "invalid_request";
+	if (request.target.query !== void 0 && !isBoundedDataSurfaceJsonValue(request.target.query)) return "invalid_request";
+}
+function statusOf(content) {
+	return String(content.status ?? "").toLowerCase();
+}
+async function publishReady(content) {
+	const governance = await content.resolveGovernance();
+	if (!governance.isGoverned || !governance.enforcePublishReadiness) return true;
+	if (!governance.publicationProfileKey) return false;
+	return (await content.evaluateReviewProfile(governance.publicationProfileKey)).ready;
+}
+async function eligibility(workflowId, content, payload, handlers) {
+	const status = statusOf(content);
+	if (workflowId === "restore") {
+		if (status !== "deleted") return {
+			eligible: false,
+			reason: "not_deleted"
+		};
+		if (payloadRecord(payload).status === "published" && !await publishReady(content)) return {
+			eligible: false,
+			reason: "publish_readiness_failed"
+		};
+		return { eligible: true };
+	}
+	if (status === "deleted") return {
+		eligible: false,
+		reason: "deleted"
+	};
+	switch (workflowId) {
+		case "move-to-trash": return { eligible: true };
+		case "mark-draft": return status === "draft" ? {
+			eligible: false,
+			reason: "already_draft"
+		} : { eligible: true };
+		case "submit-review": return status === "draft" ? { eligible: true } : {
+			eligible: false,
+			reason: "requires_draft"
+		};
+		case "publish":
+			if (![
+				"draft",
+				"review",
+				"archived"
+			].includes(status)) return {
+				eligible: false,
+				reason: "invalid_status"
+			};
+			return await publishReady(content) ? { eligible: true } : {
+				eligible: false,
+				reason: "publish_readiness_failed"
+			};
+		case "archive": return status === "archived" ? {
+			eligible: false,
+			reason: "already_archived"
+		} : { eligible: true };
+		case "automated-review": {
+			const governance = await content.resolveGovernance();
+			if (!governance.isGoverned) return {
+				eligible: false,
+				reason: "governance_unavailable"
+			};
+			const input = payloadRecord(payload);
+			const policy = typeof input.policyKey === "string" ? governance.reviewPolicies.find((entry) => entry.key === input.policyKey) : void 0;
+			if (typeof input.policyKey === "string" && !policy) return {
+				eligible: false,
+				reason: "review_policy_unavailable"
+			};
+			if (typeof input.kind === "string" && policy && policy.kind !== input.kind) return {
+				eligible: false,
+				reason: "review_kind_mismatch"
+			};
+			return { eligible: true };
+		}
+		case "format-body": return handlers.formatBody ? { eligible: true } : {
+			eligible: false,
+			reason: "handler_unavailable"
+		};
+		case "categorize": return { eligible: true };
+		case "optimize":
+			if (!handlers.optimize) return {
+				eligible: false,
+				reason: "handler_unavailable"
+			};
+			return ["draft", "review"].includes(status) ? { eligible: true } : {
+				eligible: false,
+				reason: "requires_draft_or_review"
+			};
+	}
+}
+async function applyWorkflow(workflowId, content, expectedUpdatedAt, payload, run, handlers) {
+	const input = payloadRecord(payload);
+	const save = async () => {
+		await content.withTransaction((bound) => bound.save({ expectedUpdatedAt }));
+	};
+	const mutationDraft = () => ({
+		contentId: String(content.id),
+		tenantId: content.tenantId,
+		type: content.type,
+		variant: content.variant,
+		status: content.status,
+		state: content.state,
+		fileKey: content.fileKey,
+		author: content.author,
+		name: content.name,
+		title: content.title,
+		description: content.description,
+		body: content.body,
+		bodyFormat: content.bodyFormat,
+		publish_date: content.publish_date,
+		url: content.url,
+		source: content.source,
+		original_url: content.original_url,
+		language: content.language,
+		tags: [...content.tags ?? []],
+		category: content.category,
+		metadata: structuredClone(content.metadata ?? {}),
+		thumbnailAssetId: content.thumbnailAssetId
+	});
+	const applyDraft = (draft) => {
+		content.fileKey = draft.fileKey;
+		content.author = draft.author;
+		content.name = draft.name;
+		content.title = draft.title;
+		content.description = draft.description;
+		content.body = draft.body;
+		content.bodyFormat = draft.bodyFormat;
+		content.publish_date = draft.publish_date;
+		content.url = draft.url;
+		content.source = draft.source;
+		content.original_url = draft.original_url;
+		content.language = draft.language;
+		content.tags = [...draft.tags];
+		content.category = draft.category;
+		content.metadata = structuredClone(draft.metadata);
+		content.thumbnailAssetId = draft.thumbnailAssetId;
+	};
+	const runHandler = async (handler) => {
+		const draft = mutationDraft();
+		await handler(draft, payload, run);
+		applyDraft(draft);
+		await save();
+	};
+	switch (workflowId) {
+		case "move-to-trash":
+			content.status = "deleted";
+			await save();
+			return;
+		case "mark-draft":
+			content.status = "draft";
+			await save();
+			return;
+		case "submit-review":
+			content.status = "review";
+			await save();
+			return;
+		case "publish":
+			content.status = "published";
+			await save();
+			return;
+		case "archive":
+			content.status = "archived";
+			await save();
+			return;
+		case "restore":
+			content.status = input.status;
+			await save();
+			return;
+		case "automated-review":
+			await content.runReviewAction({
+				expectedUpdatedAt,
+				...typeof input.kind === "string" ? { kind: input.kind } : {},
+				...typeof input.policyKey === "string" ? { policyKey: input.policyKey } : {}
+			});
+			return;
+		case "format-body":
+			if (!handlers.formatBody) throw new Error("format handler unavailable");
+			await runHandler(handlers.formatBody);
+			return;
+		case "categorize":
+			content.category = String(input.category).trim();
+			await save();
+			return;
+		case "optimize":
+			if (!handlers.optimize) throw new Error("optimize handler unavailable");
+			await runHandler(handlers.optimize);
+			return;
+	}
+}
+function revisionFingerprint(rows) {
+	const canonical = rows.map((row) => `${String(row.id)}\0${String(row.updated_at ?? "")}`).sort();
+	return createHash("sha256").update(canonical.join("
")).digest("base64url");
+}
+function representativeLabels(rows, limit) {
+	return rows.slice(0, limit).map((row) => {
+		return (typeof row.title === "string" ? row.title.trim() : "") || String(row.id);
+	});
+}
+async function resolveQuerySelection(request, collection, scope, maxSelectionSize, representativeLimit, revision) {
+	const schema = await buildContentQuerySchema();
+	const selection = request.selection;
+	const rows = [];
+	let queryFingerprint;
+	if (selection.scope === "explicit-ids") {
+		const ids = [...new Set(selection.rowIds.map((rowId) => String(rowId)))];
+		if (ids.length > maxSelectionSize) throw new ContentListActionError("limit_exceeded");
+		queryFingerprint = `explicit:${revisionFingerprint(ids.map((id) => ({ id })))}`;
+		for (let start = 0; start < ids.length; start += 100) {
+			const chunk = ids.slice(start, start + 100);
+			const result = await executeContentQuery(collection, {
+				version: 1,
+				requestId: `content-action-explicit-${start}`,
+				mode: "rows",
+				projection: [...REQUIRED_QUERY_FIELDS],
+				filter: {
+					kind: "condition",
+					field: "id",
+					operator: "in",
+					value: chunk
+				},
+				sort: [{
+					field: "id",
+					direction: "asc"
+				}],
+				page: {
+					kind: "offset",
+					offset: 0,
+					limit: Math.max(1, chunk.length)
+				}
+			}, { scope });
+			rows.push(...result.rows);
+		}
+		queryFingerprint = `${queryFingerprint}:${revisionFingerprint(rows)}`;
+	} else {
+		const input = request.target.query;
+		if (!input) throw new ContentListActionError("invalid_target");
+		const normalized = normalizeDataQueryRequest(input, schema);
+		const allMatchingPageLimit = Math.min(maxSelectionSize, MAX_DATA_QUERY_PAGE_LIMIT);
+		const querySchema = selection.scope === "all-matching" ? {
+			...schema,
+			defaultPageLimit: Math.min(schema.defaultPageLimit ?? 200, allMatchingPageLimit),
+			maxPageLimit: allMatchingPageLimit
+		} : schema;
+		if (normalized.mode !== "rows") throw new ContentListActionError("invalid_target");
+		for (const field of REQUIRED_QUERY_FIELDS) if (!normalized.projection?.includes(field)) throw new ContentListActionError("missing_action_projection");
+		const baseFingerprint = createDataQueryFingerprint(normalized, schema);
+		if (selection.scope === "all-matching" && selection.queryFingerprint !== baseFingerprint) throw new ContentListActionError("stale_query_fingerprint");
+		const pageLimit = selection.scope === "current-page" ? normalized.page?.limit ?? 200 : allMatchingPageLimit;
+		const offset = selection.scope === "current-page" && normalized.page?.kind === "offset" ? normalized.page.offset : 0;
+		const result = await executeContentQuery(collection, {
+			...normalized,
+			requestId: `${normalized.requestId}-action-${offset}`.slice(0, 128),
+			page: {
+				kind: "offset",
+				offset,
+				limit: Math.max(1, pageLimit)
+			}
+		}, {
+			scope,
+			schema: querySchema
+		});
+		if (result.total.kind !== "exact") throw new ContentListActionError("count_unavailable");
+		if (selection.scope === "all-matching" && result.total.value > pageLimit) throw new ContentListActionError("limit_exceeded");
+		rows.push(...result.rows);
+		if (selection.scope === "all-matching" && rows.length !== result.total.value) throw new ContentListActionError("matching_count_drifted");
+		if (selection.scope === "all-matching") {
+			if (new Set(rows.map((row) => String(row.id))).size !== rows.length) throw new ContentListActionError("matching_count_drifted");
+		}
+		queryFingerprint = `${baseFingerprint}:${revisionFingerprint(rows)}`;
+	}
+	if (request.target.expectedCount !== rows.length) throw new ContentListActionError("matching_count_drifted");
+	return {
+		revision,
+		queryFingerprint,
+		rowIds: rows.map((row) => row.id),
+		rows,
+		representativeLabels: representativeLabels(rows, representativeLimit),
+		scope: selection.scope
+	};
+}
+function defaultDescriptor(maxSelectionSize) {
+	return {
+		version: 1,
+		identity: {
+			surfaceId: "content-list",
+			kind: "table"
+		},
+		schemaVersion: 2,
+		label: "Contents",
+		rowKey: "id",
+		columns: [
+			{
+				id: "id",
+				label: "Content id",
+				fieldName: "id",
+				role: "row-key",
+				capabilities: ["read", "project"]
+			},
+			{
+				id: "title",
+				label: "Title",
+				fieldName: "title",
+				capabilities: ["read", "project"]
+			},
+			{
+				id: "status",
+				label: "Status",
+				fieldName: "status",
+				role: "status",
+				capabilities: ["read", "project"]
+			}
+		],
+		query: {
+			modes: ["rows", "count"],
+			projectableColumnIds: [
+				"id",
+				"title",
+				"status"
+			]
+		},
+		controls: [],
+		actions: CONTENT_LIST_WORKFLOWS.map((entry) => ({
+			id: entry.id,
+			label: entry.label,
+			description: entry.description,
+			sensitivity: entry.sensitivity,
+			selectionScopes: [...entry.selectionScopes],
+			requiresConfirmation: entry.confirmation === "required"
+		})),
+		limits: {
+			maxQueryRows: 200,
+			maxQueryBytes: 1e6,
+			maxSelectionSize
+		}
+	};
+}
+function createContentListActionAdapter(options) {
+	assertContentListWorkflowStorageSupported(options.workflowStorage);
+	const handlers = options.handlers ?? {};
+	const maxSelectionSize = options.maxSelectionSize ?? options.descriptor?.limits.maxSelectionSize ?? DEFAULT_MAX_SELECTION_SIZE;
+	if (!Number.isSafeInteger(maxSelectionSize) || maxSelectionSize < 1 || maxSelectionSize > MAX_DATA_QUERY_PAGE_LIMIT) throw new Error(`ContentList maxSelectionSize must be an integer between 1 and ${MAX_DATA_QUERY_PAGE_LIMIT} so all-matching membership resolves in one bounded query`);
+	const representativeLimit = options.representativeLimit ?? DEFAULT_REPRESENTATIVE_LIMIT;
+	const descriptor = options.descriptor ?? defaultDescriptor(maxSelectionSize);
+	if (descriptor.limits.maxSelectionSize !== maxSelectionSize) throw new Error("ContentList descriptor maxSelectionSize must match the server selection cap");
+	const resolvedByRequest = /* @__PURE__ */ new WeakMap();
+	const contentByRequest = /* @__PURE__ */ new WeakMap();
+	async function loadContent(invocation, rowId) {
+		const key = String(rowId);
+		let byRow = contentByRequest.get(invocation.request);
+		if (!byRow) {
+			byRow = /* @__PURE__ */ new Map();
+			contentByRequest.set(invocation.request, byRow);
+		}
+		let pending = byRow.get(key);
+		if (!pending) {
+			pending = (async () => {
+				const content = await (await options.collection(invocation.run)).get({ id: key });
+				if (!content) return null;
+				const expected = resolvedByRequest.get(invocation.request)?.rows.find((row) => String(row.id) === key);
+				const revisionValue = (value) => value instanceof Date ? value.toISOString() : String(value ?? "");
+				if (!expected || revisionValue(content.updated_at) !== revisionValue(expected.updated_at)) throw new ContentListActionError("row_revision_drifted");
+				return content;
+			})();
+			byRow.set(key, pending);
+		}
+		return pending;
+	}
+	const mapActionError = (error) => error instanceof ContentListActionError ? error.reason : isRecord(error) && error.code === "RUNTIME_REVISION_CONFLICT" ? "row_revision_drifted" : isPermissionDenied(error) || error instanceof PrincipalToolNotAllowedError ? "denied" : void 0;
+	const definitions = Object.fromEntries(CONTENT_LIST_WORKFLOWS.map((entry) => [entry.id, {
+		descriptor: {
+			id: entry.id,
+			label: entry.label,
+			description: entry.description,
+			sensitivity: entry.sensitivity,
+			selectionScopes: [...entry.selectionScopes],
+			requiresConfirmation: entry.confirmation === "required"
+		},
+		inputSchema: entry.inputSchema,
+		validatePayload: (payload) => validPayload(entry.id, payload) ? { valid: true } : {
+			valid: false,
+			reason: "invalid_payload"
+		},
+		confirmation: entry.confirmation,
+		execution: entry.execution,
+		tool: entry.permissionRequirements.tool,
+		operation: entry.permissionRequirements.operations[0] ?? CONTENT_READ_OPERATION,
+		authorize: async (invocation) => {
+			const operations = entry.id === "restore" && payloadRecord(invocation.request.payload).status !== "published" ? entry.permissionRequirements.operations.slice(0, 2) : entry.permissionRequirements.operations;
+			for (const operation of operations.slice(1)) try {
+				await invocation.run.assertOperation(operation.collection, operation.action);
+			} catch (error) {
+				if (isPermissionDenied(error)) return false;
+				throw error;
+			}
+			return options.authorize?.(entry.id, invocation.run) ?? true;
+		},
+		eligible: async (invocation, rowId) => {
+			const content = await loadContent(invocation, rowId);
+			if (!content) return {
+				eligible: false,
+				reason: "not_found_or_denied"
+			};
+			return eligibility(entry.id, content, invocation.request.payload, handlers);
+		},
+		apply: async (invocation, rowId) => {
+			const content = await loadContent(invocation, rowId);
+			if (!content) throw new Error("content not found");
+			const expectedUpdatedAt = content.updated_at;
+			if (!(expectedUpdatedAt instanceof Date) && typeof expectedUpdatedAt !== "string") throw new ContentListActionError("row_revision_drifted");
+			await applyWorkflow(entry.id, content, expectedUpdatedAt, invocation.request.payload, invocation.run, handlers);
+			return null;
+		}
+	}]));
+	const generic = createDataSurfaceActionAdapter({
+		state: options.state,
+		backgroundQueue: options.backgroundQueue,
+		tokenTtlMs: options.tokenTtlMs,
+		runAsPrincipal: options.runAsPrincipal,
+		resolveDeferredPrincipal: options.resolveDeferredPrincipal,
+		requestFingerprintExtension: (request) => request.target,
+		mapError: mapActionError,
+		resolveSurface: async (run) => ({
+			descriptor,
+			revision: await (options.revision?.(run, descriptor.identity) ?? 0),
+			actions: definitions
+		}),
+		resolveSelection: async (invocation, selection) => {
+			const request = invocation.request;
+			const collection = await options.collection(invocation.run);
+			const scope = await options.scope?.(invocation.run);
+			const revision = await (options.revision?.(invocation.run, descriptor.identity) ?? 0);
+			const resolved = await resolveQuerySelection({
+				...request,
+				selection
+			}, collection, scope, maxSelectionSize, representativeLimit, revision);
+			resolvedByRequest.set(request, resolved);
+			return resolved;
+		}
+	});
+	async function invoke(phase, request, context) {
+		const invalid = validateTarget(request);
+		if (invalid) return actionResult(request, false, invalid);
+		try {
+			const result = await generic[phase](request, context);
+			if (phase !== "preview" || !result.ok) return result;
+			const resolved = resolvedByRequest.get(request);
+			const workflow2 = CONTENT_LIST_WORKFLOWS.find((entry) => entry.id === request.actionId);
+			return {
+				...result,
+				details: {
+					...result.details ?? {},
+					resolvedScope: resolved?.scope ?? request.selection.scope,
+					representativeLabels: resolved?.representativeLabels ?? [],
+					ineligible: Array.isArray(result.details?.outcomes) ? result.details.outcomes.filter((entry) => isRecord(entry) && entry.status === "skipped") : [],
+					consequences: workflow2?.consequences ?? [],
+					sensitivity: workflow2?.sensitivity ?? "public",
+					execution: workflow2?.execution ?? "foreground"
+				}
+			};
+		} catch (error) {
+			return actionResult(request, false, mapActionError(error) ?? "execution_failed");
+		} finally {
+			resolvedByRequest.delete(request);
+		}
+	}
+	return {
+		preview: (request, context) => invoke("preview", request, context),
+		apply: (request, context) => invoke("apply", request, context)
+	};
+}
+//#endregion
+//#region src/server.ts
+async function startServer() {
+	console.log("🚀 Starting SMRT Content Server...");
+	const shutdown = await startRestServer([Content], {}, {
+		port: 3100,
+		hostname: "localhost",
+		basePath: "/api/v1",
+		enableCors: true
+	});
+	console.log("✅ Server ready!");
+	console.log("📡 REST API: http://localhost:3100/api/v1");
+	console.log("📚 Endpoints:");
+	console.log("   GET    /api/v1/contents - List contents");
+	console.log("   POST   /api/v1/contents - Create content");
+	console.log("   GET    /api/v1/contents/:id - Get content");
+	console.log("   PUT    /api/v1/contents/:id - Update content");
+	console.log("   DELETE /api/v1/contents/:id - Delete content");
+	console.log("\n💡 Try these endpoints:");
+	console.log("   curl http://localhost:3100/api/v1/contents");
+	console.log(`   curl -X POST http://localhost:3100/api/v1/contents -H "Content-Type: application/json" -d '{"title":"Test Content","body":"Test body content"}'`);
+	return { shutdown };
+}
+if (import.meta.url === `file://${process.argv[1]}`) startServer().catch(console.error);
+//#endregion
+export { CONTENT_LIST_WORKFLOWS, CONTENT_LIST_WORKFLOW_IDS, UnsupportedContentListWorkflowStorageError, assertContentListWorkflowStorageSupported, createContentListActionAdapter, startServer };
+
+//# sourceMappingURL=server.js.map