dineway 0.1.49 → 0.2.1

package/dist/mcp-reviewed-executor-Dn52L_yY.mjs

@@ -0,0 +1,558 @@
+import { o as HitlRequestRepository } from "./publication-authorization-RKiHXKtq.mjs";
+import { b as HitlRequestService } from "./site-context-B8T1kpUP.mjs";
+import { n as stableStringify } from "./stable-hash-DshcXvRE.mjs";
+import { n as buildStableActionHash } from "./review-payload-BysRWpxS.mjs";
+import { i as hasScope } from "./api-tokens-Ypaly90d.mjs";
+import { m as logSiteActivityStrict, p as logSiteActivitySafely } from "./activity-events-CJDvE2uc.mjs";
+import { ulid } from "ulidx";
+import { hasPermission } from "@dineway-ai/auth";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+
+//#region src/plugins/mcp.ts
+function createPluginMcpRegistry(plugins) {
+	const tools = [];
+	const resources = [];
+	const toolOwners = /* @__PURE__ */ new Map();
+	const resourceOwners = /* @__PURE__ */ new Map();
+	const resourceUriOwners = /* @__PURE__ */ new Map();
+	for (const plugin of plugins) {
+		for (const tool of plugin.mcp.tools) {
+			assertUniqueContribution("tool", tool.name, plugin.id, toolOwners);
+			tools.push({
+				pluginId: plugin.id,
+				pluginVersion: plugin.version,
+				tool,
+				authorizeTarget: plugin.mcp.authorizeTarget
+			});
+		}
+		for (const resource of plugin.mcp.resources) {
+			assertUniqueContribution("resource", resource.name, plugin.id, resourceOwners);
+			assertUniqueContribution("resource URI", resource.uri, plugin.id, resourceUriOwners);
+			resources.push({
+				pluginId: plugin.id,
+				pluginVersion: plugin.version,
+				resource,
+				authorizeTarget: plugin.mcp.authorizeTarget
+			});
+		}
+	}
+	return {
+		tools,
+		resources
+	};
+}
+function createActivePluginMcpRegistry(configuredPlugins, enabledPluginIds) {
+	return createPluginMcpRegistry(configuredPlugins.filter((plugin) => enabledPluginIds.has(plugin.id)));
+}
+function registerPluginMcpRegistry(server, registry, options) {
+	for (const contribution of registry.tools) {
+		const { tool } = contribution;
+		server.registerTool(tool.name, {
+			title: tool.title,
+			description: tool.description,
+			inputSchema: tool.inputSchema,
+			outputSchema: tool.kind === "query" ? tool.outputSchema : void 0,
+			annotations: {
+				readOnlyHint: tool.kind === "query",
+				destructiveHint: tool.kind === "command" && tool.reversibility === "irreversible",
+				idempotentHint: tool.kind === "query" || tool.kind === "command"
+			}
+		}, async (input, requestExtra) => {
+			if (!isRecord$1(input)) throw new McpError(ErrorCode.InvalidParams, "Plugin MCP tool input must be an object");
+			const context = options.resolveContext({
+				id: contribution.pluginId,
+				version: contribution.pluginVersion
+			}, requestExtra);
+			const target = tool.resolveTarget ? await tool.resolveTarget(input, context) : void 0;
+			await authorizeContribution(tool.authorization, target, context, contribution.authorizeTarget, options);
+			if (tool.pii.output === "sensitive") await authorizeSensitiveOutput({
+				contributionType: "tool",
+				name: tool.name,
+				target,
+				context
+			}, options);
+			const output = tool.kind === "query" ? await tool.handler(input, context) : await executeCommand(contribution, input, context, target, requestExtra, options);
+			const content = [{
+				type: "text",
+				text: JSON.stringify(output, null, 2)
+			}];
+			return tool.kind === "query" && tool.outputSchema ? {
+				content,
+				structuredContent: output
+			} : { content };
+		});
+	}
+	for (const contribution of registry.resources) {
+		const { resource } = contribution;
+		server.registerResource(resource.name, resource.uri, {
+			title: resource.title,
+			description: resource.description,
+			mimeType: resource.mimeType
+		}, async (uri, requestExtra) => {
+			const context = options.resolveContext({
+				id: contribution.pluginId,
+				version: contribution.pluginVersion
+			}, requestExtra);
+			await authorizeContribution(resource.authorization, resource.target, context, contribution.authorizeTarget, options);
+			if (resource.pii.output === "sensitive") await authorizeSensitiveOutput({
+				contributionType: "resource",
+				name: resource.name,
+				target: resource.target,
+				context
+			}, options);
+			const result = await resource.handler(uri, context);
+			return { contents: [{
+				uri: uri.href,
+				mimeType: result.mimeType ?? resource.mimeType,
+				text: result.text
+			}] };
+		});
+	}
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertUniqueContribution(kind, name, pluginId, owners) {
+	const existingOwner = owners.get(name);
+	if (existingOwner) throw new Error(`Duplicate plugin MCP ${kind} "${name}" contributed by "${existingOwner}" and "${pluginId}".`);
+	owners.set(name, pluginId);
+}
+async function authorizeContribution(authorization, target, context, pluginAuthorizer, options) {
+	if (!hasPermission({ role: context.actor.role }, authorization.permission)) throw new McpError(ErrorCode.InvalidRequest, "Insufficient permissions for this operation");
+	const tokenScopes = context.actor.tokenScopes;
+	if (tokenScopes && !authorization.anyOfTokenScopes.some((scope) => hasScope([...tokenScopes], scope))) throw new McpError(ErrorCode.InvalidRequest, `Insufficient scope: requires one of ${authorization.anyOfTokenScopes.join(", ")}`);
+	if (authorization.restaurantPermission) {
+		if (!target || !pluginAuthorizer && !options.authorizeTarget) throw new McpError(ErrorCode.InvalidRequest, "Restaurant target authorization is not configured for this MCP contribution");
+		const request = {
+			restaurantPermission: authorization.restaurantPermission,
+			target,
+			context
+		};
+		try {
+			await pluginAuthorizer?.(request);
+			await options.authorizeTarget?.(request);
+		} catch {
+			throw new McpError(ErrorCode.InvalidRequest, "Restaurant target authorization denied for this operation");
+		}
+	}
+}
+async function authorizeSensitiveOutput(request, options) {
+	if (!options.authorizeSensitiveOutput) throw new McpError(ErrorCode.InvalidRequest, "Sensitive plugin MCP output requires an explicit core authorization policy");
+	await options.authorizeSensitiveOutput(request);
+}
+async function executeCommand(contribution, input, context, target, requestExtra, options) {
+	if (contribution.tool.kind !== "command") throw new Error(`MCP contribution "${contribution.tool.name}" is not a command.`);
+	if (!options.executeCommand) throw new McpError(ErrorCode.InvalidRequest, "Plugin MCP command execution requires the core reviewed execution boundary");
+	return options.executeCommand({
+		...contribution,
+		tool: contribution.tool
+	}, input, context, {
+		target,
+		review: parseReviewMetadata(requestExtra)
+	});
+}
+function parseReviewMetadata(requestExtra) {
+	if (!isRecord$1(requestExtra) || !isRecord$1(requestExtra._meta)) return {};
+	const value = requestExtra._meta["dineway/review"];
+	if (value === void 0) return {};
+	if (!isRecord$1(value)) throw new McpError(ErrorCode.InvalidParams, "MCP metadata \"dineway/review\" must be an object");
+	return {
+		hitlRequestId: optionalNonEmptyString(value.hitl_request_id, "hitl_request_id"),
+		quickActionHash: optionalNonEmptyString(value.quick_action_hash, "quick_action_hash")
+	};
+}
+function optionalNonEmptyString(value, name) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string" || value.trim().length === 0) throw new McpError(ErrorCode.InvalidParams, `MCP review metadata ${name} must be a string`);
+	return value;
+}
+
+//#endregion
+//#region src/database/repositories/hitl-executions.ts
+var HitlExecutionRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async claim(input) {
+		const id = ulid();
+		const now = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.insertInto("_dineway_hitl_executions").values(toInsertableExecution(id, input, now)).onConflict((conflict) => conflict.doNothing()).execute();
+		const inserted = await this.findById(id);
+		if (inserted) return {
+			claimed: true,
+			execution: inserted
+		};
+		const conflicts = await this.findConflicts(input);
+		const existing = conflicts[0];
+		if (conflicts.length !== 1 || !existing || !matchesClaim(existing, input)) throw new Error("HITL execution claim conflicts with a different reviewed action.");
+		return {
+			claimed: false,
+			execution: existing
+		};
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_hitl_executions").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? rowToExecution(row) : null;
+	}
+	async markSucceeded(id, result, completedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+		return this.complete(id, "succeeded", result, null, completedAt);
+	}
+	async markFailed(id, errorCode, completedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+		return this.complete(id, "failed", null, errorCode, completedAt);
+	}
+	async markIndeterminate(id, errorCode, completedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+		return this.complete(id, "indeterminate", null, errorCode, completedAt);
+	}
+	async complete(id, status, result, errorCode, completedAt) {
+		const update = await this.db.updateTable("_dineway_hitl_executions").set({
+			status,
+			result_json: result ? JSON.stringify(result) : null,
+			error_code: errorCode,
+			updated_at: completedAt,
+			completed_at: completedAt
+		}).where("id", "=", id).where("status", "=", "claimed").executeTakeFirst();
+		if (Number(update.numUpdatedRows ?? 0) === 0) return null;
+		return this.findById(id);
+	}
+	async findConflicts(input) {
+		return (await this.db.selectFrom("_dineway_hitl_executions").selectAll().where((eb) => eb.or([
+			eb("action_hash", "=", input.actionHash),
+			eb("idempotency_key", "=", input.idempotencyKey),
+			...input.hitlRequestId ? [eb("hitl_request_id", "=", input.hitlRequestId)] : []
+		])).execute()).map(rowToExecution);
+	}
+};
+function toInsertableExecution(id, input, now) {
+	return {
+		id,
+		hitl_request_id: input.hitlRequestId ?? null,
+		plugin_id: input.pluginId,
+		tool_name: input.toolName,
+		review_mode: input.reviewMode,
+		action_hash: input.actionHash,
+		idempotency_key: input.idempotencyKey,
+		status: "claimed",
+		actor_type: input.actorType,
+		actor_id: input.actorId,
+		scope: input.scope,
+		target_ref_type: input.targetRefType,
+		target_ref_id: input.targetRefId,
+		result_json: null,
+		error_code: null,
+		created_at: now,
+		updated_at: now,
+		completed_at: null
+	};
+}
+function matchesClaim(execution, input) {
+	return execution.hitlRequestId === (input.hitlRequestId ?? null) && execution.pluginId === input.pluginId && execution.toolName === input.toolName && execution.reviewMode === input.reviewMode && execution.actionHash === input.actionHash && execution.idempotencyKey === input.idempotencyKey && execution.actorType === input.actorType && execution.actorId === input.actorId && execution.scope === input.scope && execution.targetRefType === input.targetRefType && execution.targetRefId === input.targetRefId;
+}
+function rowToExecution(row) {
+	return {
+		id: row.id,
+		hitlRequestId: row.hitl_request_id,
+		pluginId: row.plugin_id,
+		toolName: row.tool_name,
+		reviewMode: row.review_mode,
+		actionHash: row.action_hash,
+		idempotencyKey: row.idempotency_key,
+		status: row.status,
+		actorType: row.actor_type,
+		actorId: row.actor_id,
+		scope: row.scope,
+		targetRefType: row.target_ref_type,
+		targetRefId: row.target_ref_id,
+		result: parseNullableRecord(row.result_json),
+		errorCode: row.error_code,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		completedAt: row.completed_at
+	};
+}
+function parseNullableRecord(value) {
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/plugins/mcp-reviewed-executor.ts
+const REVIEW_METADATA_KEY = "dineway/review";
+var PluginMcpIndeterminateError = class extends Error {
+	constructor(message, code = "PLUGIN_COMMAND_OUTCOME_INDETERMINATE") {
+		super(message);
+		this.code = code;
+		this.name = "PluginMcpIndeterminateError";
+	}
+};
+function createReviewedPluginMcpCommandExecutor() {
+	return async (command, input, context, request) => executeReviewedPluginMcpCommand(command, input, context, request);
+}
+async function executeReviewedPluginMcpCommand(command, input, context, request) {
+	const preview = await command.tool.preview(input, context);
+	validatePreview(preview, "Command preview");
+	if (request.target && stableStringify(request.target) !== stableStringify(preview.target)) throw invalidReview("Command preview target does not match the authorized target.");
+	const redactedPreview = command.tool.redactPreview ? await command.tool.redactPreview(preview, context) : preview;
+	validatePreview(redactedPreview, "Redacted command preview");
+	if (stableStringify(redactedPreview.target) !== stableStringify(preview.target)) throw invalidReview("Command preview redaction must not change the target.");
+	const fingerprint = await command.tool.actionFingerprint(input, preview, context);
+	const actionHash = await buildStableActionHash({
+		plugin: {
+			id: command.pluginId,
+			version: command.pluginVersion
+		},
+		tool: command.tool.name,
+		actor: {
+			type: context.actor.type,
+			id: context.actor.id
+		},
+		input,
+		target: preview.target,
+		preview,
+		fingerprint
+	});
+	const idempotencyKey = `${command.tool.idempotency.namespace ?? `${command.pluginId}:${command.tool.name}`}:${actionHash}`;
+	const reviewMode = command.tool.risk.level === "strong_confirmation" ? "strong" : "quick";
+	const scope = preview.target.scope;
+	let hitlRequestId = null;
+	if (reviewMode === "strong") {
+		const review = await resolveStrongReview({
+			command,
+			context,
+			request,
+			redactedPreview,
+			actionHash,
+			idempotencyKey,
+			scope
+		});
+		if (review.response) return review.response;
+		hitlRequestId = review.hitlRequestId;
+	} else if (request.review.quickActionHash !== actionHash) return {
+		status: "confirmation_required",
+		review_mode: "quick",
+		action_hash: actionHash,
+		preview: redactedPreview,
+		message: `Retry this tool with _meta["${REVIEW_METADATA_KEY}"].quick_action_hash set to the exact action_hash.`
+	};
+	const executions = new HitlExecutionRepository(context.db);
+	const claim = await executions.claim({
+		hitlRequestId,
+		pluginId: command.pluginId,
+		toolName: command.tool.name,
+		reviewMode,
+		actionHash,
+		idempotencyKey,
+		actorType: context.actor.type,
+		actorId: context.actor.id,
+		scope,
+		targetRefType: preview.target.type,
+		targetRefId: preview.target.id
+	});
+	if (!claim.claimed) return existingExecutionResponse(claim.execution);
+	const activityInput = {
+		actionType: `plugin.mcp.${command.tool.name}`,
+		subjectType: preview.target.type,
+		subjectId: preview.target.id,
+		relatedSubjectType: "plugin",
+		relatedSubjectId: command.pluginId,
+		sourceType: "mcp_tool",
+		sourceName: command.tool.name,
+		scope,
+		summary: redactedPreview.summary,
+		detail: {
+			executionId: claim.execution.id,
+			hitlRequestId,
+			actionHash,
+			reviewMode,
+			reversibility: command.tool.reversibility,
+			target: redactedPreview.target
+		}
+	};
+	const actorLocals = toActorLocals(context);
+	try {
+		if (command.tool.audit === "strict") await logSiteActivityStrict(context.db, actorLocals, {
+			...activityInput,
+			resultStatus: "pending"
+		});
+		else await logSiteActivitySafely(context.db, actorLocals, {
+			...activityInput,
+			resultStatus: "pending"
+		});
+	} catch {
+		await executions.markFailed(claim.execution.id, "STRICT_AUDIT_WRITE_FAILED");
+		throw invalidReview("The command was not executed because its required audit record failed.");
+	}
+	try {
+		const output = await command.tool.handler(input, {
+			...context,
+			reviewedExecution: {
+				id: claim.execution.id,
+				hitlRequestId,
+				actionHash,
+				idempotencyKey
+			}
+		});
+		const storedResult = command.tool.pii.output === "sensitive" ? {
+			status: "succeeded",
+			result_omitted: true
+		} : output;
+		if (!await executions.markSucceeded(claim.execution.id, storedResult)) throw new PluginMcpIndeterminateError("The command completed but its execution result could not be persisted.", "EXECUTION_RESULT_PERSIST_FAILED");
+		await logSiteActivitySafely(context.db, actorLocals, {
+			...activityInput,
+			resultStatus: "succeeded"
+		});
+		return output;
+	} catch (error) {
+		if (error instanceof PluginMcpIndeterminateError) {
+			await executions.markIndeterminate(claim.execution.id, error.code);
+			await logSiteActivitySafely(context.db, actorLocals, {
+				...activityInput,
+				resultStatus: "blocked",
+				detail: {
+					...activityInput.detail,
+					outcome: "indeterminate"
+				}
+			});
+			throw new McpError(ErrorCode.InternalError, "Command outcome is indeterminate; manual reconciliation is required.");
+		}
+		await executions.markFailed(claim.execution.id, "PLUGIN_COMMAND_FAILED");
+		await logSiteActivitySafely(context.db, actorLocals, {
+			...activityInput,
+			resultStatus: "failed"
+		});
+		throw error;
+	}
+}
+async function resolveStrongReview(input) {
+	const repository = new HitlRequestRepository(input.context.db);
+	let request;
+	if (input.request.review.hitlRequestId) {
+		request = await repository.findById(input.request.review.hitlRequestId);
+		if (!request) throw invalidReview("The supplied HITL request does not exist.");
+		validateStrongReviewRequest(request, input);
+	} else {
+		request = await findMatchingReviewRequest(repository, input);
+		if (!request) request = await createReviewRequest(input);
+		return { response: approvalResponse(request, input.redactedPreview, input.actionHash) };
+	}
+	if (request.status === "pending") return { response: approvalResponse(request, input.redactedPreview, input.actionHash) };
+	if (request.status === "rejected") return { response: {
+		status: "approval_rejected",
+		review_mode: "strong",
+		hitl_request_id: request.id,
+		action_hash: input.actionHash
+	} };
+	if (request.resolvedByActorType !== "user" || !request.resolvedByActorId) throw invalidReview("Strong confirmation must be approved by an authenticated user.");
+	return { hitlRequestId: request.id };
+}
+async function findMatchingReviewRequest(repository, input) {
+	return (await repository.list({
+		scope: input.scope,
+		actionType: `plugin.mcp.${input.command.tool.name}`,
+		targetRefType: input.redactedPreview.target.type,
+		targetRefId: input.redactedPreview.target.id,
+		requestedByActorType: input.context.actor.type,
+		requestedByActorId: input.context.actor.id,
+		limit: 100
+	})).items.find((request) => request.metadata.actionHash === input.actionHash && request.metadata.idempotencyKey === input.idempotencyKey) ?? null;
+}
+async function createReviewRequest(input) {
+	return new HitlRequestService(input.context.db).create({
+		actorType: input.context.actor.type,
+		actorId: input.context.actor.id,
+		userRole: input.context.actor.role,
+		authMetadata: actorAuthMetadata(input.context)
+	}, {
+		scope: input.scope,
+		actionType: `plugin.mcp.${input.command.tool.name}`,
+		title: input.command.tool.title,
+		summary: input.redactedPreview.summary,
+		riskReason: input.command.tool.risk.reason,
+		reviewPayload: {
+			actionHash: input.actionHash,
+			idempotencyKey: input.idempotencyKey,
+			preview: input.redactedPreview
+		},
+		targetRefType: input.redactedPreview.target.type,
+		targetRefId: input.redactedPreview.target.id,
+		metadata: {
+			pluginId: input.command.pluginId,
+			toolName: input.command.tool.name,
+			actionHash: input.actionHash,
+			idempotencyKey: input.idempotencyKey,
+			reviewMode: "strong",
+			reversibility: input.command.tool.reversibility
+		},
+		priority: input.command.tool.reversibility === "irreversible" ? "high" : "normal"
+	});
+}
+function validateStrongReviewRequest(request, input) {
+	if (request.scope !== input.scope || request.actionType !== `plugin.mcp.${input.command.tool.name}` || request.targetRefType !== input.redactedPreview.target.type || request.targetRefId !== input.redactedPreview.target.id || request.requestedByActorType !== input.context.actor.type || request.requestedByActorId !== input.context.actor.id || request.metadata.pluginId !== input.command.pluginId || request.metadata.toolName !== input.command.tool.name || request.metadata.actionHash !== input.actionHash || request.metadata.idempotencyKey !== input.idempotencyKey || request.reviewPayload.actionHash !== input.actionHash || request.reviewPayload.idempotencyKey !== input.idempotencyKey) throw invalidReview("The supplied HITL approval is stale or belongs to another action.");
+}
+function approvalResponse(request, preview, actionHash) {
+	return {
+		status: "approval_required",
+		review_mode: "strong",
+		hitl_request_id: request.id,
+		hitl_status: request.status,
+		action_hash: actionHash,
+		preview,
+		message: `After human approval, retry this tool with _meta["${REVIEW_METADATA_KEY}"].hitl_request_id set to the HITL request id.`
+	};
+}
+function existingExecutionResponse(execution) {
+	if (execution.status === "succeeded") return execution.result ?? {
+		status: "succeeded",
+		result_omitted: true,
+		execution_id: execution.id
+	};
+	return {
+		status: execution.status === "claimed" ? "execution_in_progress" : execution.status === "indeterminate" ? "outcome_indeterminate" : "execution_failed",
+		execution_id: execution.id,
+		action_hash: execution.actionHash,
+		retry_allowed: false
+	};
+}
+function validatePreview(preview, label) {
+	if (!preview || typeof preview.summary !== "string" || preview.summary.trim().length === 0) throw invalidReview(`${label} requires a non-empty summary.`);
+	validateTarget(preview.target, label);
+}
+function validateTarget(target, label) {
+	if (!target || ![
+		"plugin",
+		"location",
+		"entity"
+	].includes(target.type) || typeof target.id !== "string" || target.id.trim().length === 0 || typeof target.scope !== "string" || target.scope.trim().length === 0 || target.locationId !== void 0 && (typeof target.locationId !== "string" || target.locationId.trim().length === 0)) throw invalidReview(`${label} contains an invalid target.`);
+}
+function actorAuthMetadata(context) {
+	return {
+		auth_method: context.actor.authMethod,
+		user_id: context.actor.userId,
+		token_scopes: context.actor.tokenScopes ?? []
+	};
+}
+function toActorLocals(context) {
+	const authToken = context.actor.authMethod === "api_token" || context.actor.authMethod === "oauth_token" ? {
+		type: context.actor.authMethod,
+		id: context.actor.authMethod === "api_token" ? context.actor.id : null
+	} : void 0;
+	return {
+		user: context.actor.userId ? { id: context.actor.userId } : null,
+		tokenScopes: context.actor.tokenScopes ? [...context.actor.tokenScopes] : void 0,
+		authToken
+	};
+}
+function invalidReview(message) {
+	return new McpError(ErrorCode.InvalidRequest, message);
+}
+
+//#endregion
+export { createActivePluginMcpRegistry as n, registerPluginMcpRegistry as r, createReviewedPluginMcpCommandExecutor as t };

package/dist/media/image-endpoint.d.mts

@@ -0,0 +1,32 @@
+//#region src/media/image-endpoint.d.ts
+/**
+ * Portable helpers shared by image-endpoint modules.
+ *
+ * Dineway wraps Astro's image endpoint so source bytes for Dineway media can be
+ * read directly from the storage adapter instead of fetched over HTTP.
+ */
+declare const ALLOWED_TRANSFORM_FORMATS: readonly ["webp", "avif", "jpeg", "png"];
+declare const DEFAULT_TRANSFORM_FORMAT: ImageTransformFormat;
+declare const MAX_TRANSFORM_DIMENSION = 4000;
+declare const IMMUTABLE_IMAGE_CACHE = "public, max-age=31536000, immutable";
+type ImageTransformFormat = (typeof ALLOWED_TRANSFORM_FORMATS)[number];
+interface ImageTransformOptions {
+  width?: number;
+  height?: number;
+  format: ImageTransformFormat;
+  quality?: number;
+}
+declare function originalMediaHeaders(contentType: string): Record<string, string>;
+declare function isSafeTransformKey(key: string): boolean;
+declare function matchInternalMediaKey(href: string | null | undefined): string | null;
+declare function isTransformFormat(value: string): value is ImageTransformFormat;
+type ParsedTransformParams = {
+  ok: true;
+  options: ImageTransformOptions;
+} | {
+  ok: false;
+  message: string;
+};
+declare function parseTransformParams(params: URLSearchParams): ParsedTransformParams;
+//#endregion
+export { ALLOWED_TRANSFORM_FORMATS, DEFAULT_TRANSFORM_FORMAT, IMMUTABLE_IMAGE_CACHE, ImageTransformFormat, ImageTransformOptions, MAX_TRANSFORM_DIMENSION, ParsedTransformParams, isSafeTransformKey, isTransformFormat, matchInternalMediaKey, originalMediaHeaders, parseTransformParams };