emdash 0.36.0 → 0.38.0

package/dist/registry-BiO5WwPq.mjs

@@ -1,2716 +0,0 @@
-import { i as validateStorageCollectionName, n as validateJsonFieldName, r as validatePluginIdentifier } from "./validate-BpwoDOgt.mjs";
-import { l as jsonExtractExpr, s as isPostgres } from "./dialect-helpers-BSbfaO3F.mjs";
-import { t as PluginStateRepository } from "./state-BJfU9Uzw.mjs";
-import { a as reconcileManifestAccess, i as pluginManifestSchema, r as normalizeManifestRoute } from "./manifest-schema-CUYPfCEH.mjs";
-import { a as normalizeCapabilities, r as declaredAccessToCapabilities } from "./types-D6OcIp2P.mjs";
-import { t as EmDashStorageError } from "./types-BXUmsINL.mjs";
-import { r as resolveAndValidateExternalUrlTarget, t as SsrfError } from "./ssrf-DqebVE34.mjs";
-import { sql } from "kysely";
-import { createGzipDecoder, unpackTar } from "modern-tar";
-import { ClientResponseError, ClientValidationError } from "@atcute/client";
-import { checkEnvCompatibility, findSkippedEnvConstraints } from "@emdash-cms/registry-client/env";
-import { evaluateRegistryReleaseWithdrawal } from "@emdash-cms/registry-client/withdrawal";
-import { NSID } from "@emdash-cms/registry-lexicons";
-import { fetchReleaseArtifact } from "@emdash-cms/registry-verification/artifact";
-import { isDid } from "@atcute/lexicons/syntax";
-
-//#region src/plugins/marketplace.ts
-/**
-* MarketplaceClient — HTTP client for the EmDash Plugin Marketplace
-*
-* Used by the install/update/proxy endpoints in EmDash core to communicate
-* with the marketplace Worker. The marketplace is a distribution channel,
-* not a runtime dependency — bundles are copied to site-local R2 at install time.
-*/
-const TRAILING_SLASHES$1 = /\/+$/;
-const LEADING_DOT_SLASH = /^\.\//;
-var MarketplaceError = class extends Error {
-	constructor(message, status, code) {
-		super(message);
-		this.status = status;
-		this.code = code;
-		this.name = "MarketplaceError";
-	}
-};
-var MarketplaceUnavailableError = class extends MarketplaceError {
-	constructor(cause) {
-		super("Plugin marketplace is unavailable", void 0, "MARKETPLACE_UNAVAILABLE");
-		if (cause) this.cause = cause;
-	}
-};
-var MarketplaceClientImpl = class {
-	baseUrl;
-	siteOrigin;
-	constructor(baseUrl, siteOrigin) {
-		this.baseUrl = baseUrl.replace(TRAILING_SLASHES$1, "");
-		this.siteOrigin = siteOrigin;
-	}
-	async search(query, opts) {
-		const params = new URLSearchParams();
-		if (query) params.set("q", query);
-		if (opts?.category) params.set("category", opts.category);
-		if (opts?.capability) params.set("capability", opts.capability);
-		if (opts?.sort) params.set("sort", opts.sort);
-		if (opts?.cursor) params.set("cursor", opts.cursor);
-		if (opts?.limit) params.set("limit", String(opts.limit));
-		const qs = params.toString();
-		const url = `${this.baseUrl}/api/v1/plugins${qs ? `?${qs}` : ""}`;
-		return await this.fetchJson(url);
-	}
-	async getPlugin(id) {
-		const url = `${this.baseUrl}/api/v1/plugins/${encodeURIComponent(id)}`;
-		return this.fetchJson(url);
-	}
-	async getVersions(id) {
-		const url = `${this.baseUrl}/api/v1/plugins/${encodeURIComponent(id)}/versions`;
-		return (await this.fetchJson(url)).items;
-	}
-	async downloadBundle(id, version) {
-		const bundleUrl = `${this.baseUrl}/api/v1/plugins/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/bundle`;
-		const marketplaceOrigin = new URL(this.baseUrl).origin;
-		const MAX_REDIRECTS = 5;
-		let response;
-		try {
-			let currentUrl = bundleUrl;
-			response = await fetch(currentUrl, { redirect: "manual" });
-			for (let i = 0; i < MAX_REDIRECTS; i++) {
-				if (response.status < 300 || response.status >= 400) break;
-				const location = response.headers.get("location");
-				if (!location) break;
-				const target = new URL(location, currentUrl);
-				if (target.origin !== marketplaceOrigin) throw new MarketplaceError(`Bundle download redirected to untrusted host: ${target.origin}`, response.status, "BUNDLE_REDIRECT_UNTRUSTED");
-				currentUrl = target.href;
-				response = await fetch(currentUrl, { redirect: "manual" });
-			}
-			if (response.status >= 300 && response.status < 400) throw new MarketplaceError(`Bundle download exceeded maximum redirects (${MAX_REDIRECTS})`, response.status, "BUNDLE_TOO_MANY_REDIRECTS");
-		} catch (err) {
-			if (err instanceof MarketplaceError) throw err;
-			throw new MarketplaceUnavailableError(err);
-		}
-		if (!response.ok) throw new MarketplaceError(`Failed to download bundle: ${response.status} ${response.statusText}`, response.status, "BUNDLE_DOWNLOAD_FAILED");
-		const tarballBytes = new Uint8Array(await response.arrayBuffer());
-		try {
-			return await extractBundle(tarballBytes);
-		} catch (err) {
-			if (err instanceof MarketplaceError) throw err;
-			throw new MarketplaceError("Failed to extract plugin bundle", void 0, "BUNDLE_EXTRACT_FAILED");
-		}
-	}
-	async reportInstall(id, version) {
-		const siteHash = await generateSiteHash(this.siteOrigin);
-		const url = `${this.baseUrl}/api/v1/plugins/${encodeURIComponent(id)}/installs`;
-		try {
-			await fetch(url, {
-				method: "POST",
-				headers: { "Content-Type": "application/json" },
-				body: JSON.stringify({
-					siteHash,
-					version
-				})
-			});
-		} catch {}
-	}
-	async searchThemes(query, opts) {
-		const params = new URLSearchParams();
-		if (query) params.set("q", query);
-		if (opts?.keyword) params.set("keyword", opts.keyword);
-		if (opts?.sort) params.set("sort", opts.sort);
-		if (opts?.cursor) params.set("cursor", opts.cursor);
-		if (opts?.limit) params.set("limit", String(opts.limit));
-		const qs = params.toString();
-		const url = `${this.baseUrl}/api/v1/themes${qs ? `?${qs}` : ""}`;
-		return this.fetchJson(url);
-	}
-	async getTheme(id) {
-		const url = `${this.baseUrl}/api/v1/themes/${encodeURIComponent(id)}`;
-		return this.fetchJson(url);
-	}
-	async fetchJson(url) {
-		let response;
-		try {
-			response = await fetch(url, { headers: { Accept: "application/json" } });
-		} catch (err) {
-			throw new MarketplaceUnavailableError(err);
-		}
-		if (!response.ok) {
-			let errorMessage = `Marketplace request failed: ${response.status}`;
-			try {
-				const body = await response.json();
-				if (body.error) errorMessage = body.error;
-			} catch {}
-			throw new MarketplaceError(errorMessage, response.status);
-		}
-		return await response.json();
-	}
-};
-/**
-* Extract manifest + code files from a tarball.
-*
-* The tarball is a gzipped tar archive containing:
-* - manifest.json
-* - backend.js
-* - admin.js (optional)
-*
-* We use a minimal tar parser since we only need to read a few small files.
-*/
-/**
-* Exported so the experimental registry install handler can reuse the
-* same parse / validate / hash primitive. Despite the file name, this
-* function predates the marketplace-vs-registry split and is generic
-* over plugin bundle tarballs regardless of distribution channel.
-*/
-const MAX_DECOMPRESSED_BUNDLE_BYTES = 256 * 1024;
-const MAX_BUNDLE_TAR_ENTRIES = 32;
-async function extractBundle(tarballBytes) {
-	const reader = new ReadableStream({ start(controller) {
-		controller.enqueue(tarballBytes);
-		controller.close();
-	} }).pipeThrough(createGzipDecoder()).getReader();
-	const chunks = [];
-	let total = 0;
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		if (!value) continue;
-		total += value.byteLength;
-		if (total > MAX_DECOMPRESSED_BUNDLE_BYTES) {
-			try {
-				await reader.cancel();
-			} catch {}
-			throw new MarketplaceError(`Bundle decompressed size exceeds limit (${MAX_DECOMPRESSED_BUNDLE_BYTES} bytes)`, void 0, "INVALID_BUNDLE");
-		}
-		chunks.push(value);
-	}
-	const decompressedBytes = new Uint8Array(total);
-	{
-		let offset = 0;
-		for (const chunk of chunks) {
-			decompressedBytes.set(chunk, offset);
-			offset += chunk.byteLength;
-		}
-	}
-	const entries = await unpackTar(new ReadableStream({ start(controller) {
-		controller.enqueue(decompressedBytes);
-		controller.close();
-	} }));
-	if (entries.length > MAX_BUNDLE_TAR_ENTRIES) throw new MarketplaceError(`Bundle has too many tar entries (${entries.length} > ${MAX_BUNDLE_TAR_ENTRIES})`, void 0, "INVALID_BUNDLE");
-	const decoder = new TextDecoder();
-	const files = /* @__PURE__ */ new Map();
-	for (const entry of entries) if (entry.data && entry.header.type === "file") {
-		const name = entry.header.name.replace(LEADING_DOT_SLASH, "");
-		files.set(name, decoder.decode(entry.data));
-	}
-	const manifestJson = files.get("manifest.json");
-	const backendCode = files.get("backend.js");
-	if (!manifestJson) throw new MarketplaceError("Invalid bundle: missing manifest.json", void 0, "INVALID_BUNDLE");
-	if (!backendCode) throw new MarketplaceError("Invalid bundle: missing backend.js", void 0, "INVALID_BUNDLE");
-	let manifest;
-	try {
-		const parsed = JSON.parse(manifestJson);
-		const result = pluginManifestSchema.safeParse(parsed);
-		if (!result.success) throw new MarketplaceError("Invalid bundle: manifest.json failed validation", void 0, "INVALID_BUNDLE");
-		manifest = reconcileManifestAccess(result.data);
-	} catch (err) {
-		if (err instanceof MarketplaceError) throw err;
-		throw new MarketplaceError("Invalid bundle: malformed manifest.json", void 0, "INVALID_BUNDLE");
-	}
-	const hashBuffer = await crypto.subtle.digest("SHA-256", tarballBytes);
-	const hashArray = new Uint8Array(hashBuffer);
-	const checksum = Array.from(hashArray, (b) => b.toString(16).padStart(2, "0")).join("");
-	return {
-		manifest,
-		backendCode,
-		adminCode: files.get("admin.js"),
-		checksum
-	};
-}
-/**
-* Generate a stable non-identifying site hash from the site origin.
-* The same origin always produces the same hash, so the marketplace
-* installs table deduplicates correctly per (plugin_id, site_hash).
-*/
-async function generateSiteHash(siteOrigin) {
-	const seed = siteOrigin ? `emdash-site:${siteOrigin}` : `emdash-anonymous`;
-	try {
-		const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(seed));
-		const arr = new Uint8Array(hash);
-		return Array.from(arr.slice(0, 8), (b) => b.toString(16).padStart(2, "0")).join("");
-	} catch {
-		let h = 2166136261;
-		for (let i = 0; i < seed.length; i++) {
-			h ^= seed.charCodeAt(i);
-			h = Math.imul(h, 16777619);
-		}
-		const h2 = h ^ h >>> 16;
-		return (h >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
-	}
-}
-/**
-* Create a MarketplaceClient for the given marketplace URL.
-*
-* @param baseUrl - The marketplace API base URL (e.g. "https://marketplace.emdashcms.com")
-* @param siteOrigin - The origin of the EmDash site (e.g. "https://myblog.example.com").
-*   Used to generate a stable, non-identifying site hash for install deduplication.
-*/
-function createMarketplaceClient(baseUrl, siteOrigin) {
-	return new MarketplaceClientImpl(baseUrl, siteOrigin);
-}
-
-//#endregion
-//#region src/plugins/storage-indexes.ts
-/**
-* Generate a deterministic index name.
-* Unique indexes use a `uidx_` prefix to avoid collisions with regular indexes on the same fields.
-*/
-function generateIndexName(pluginId, collection, fields, options) {
-	return `${options?.unique ? "uidx" : "idx"}_plugin_${pluginId}_${collection}_${fields.join("_")}`.substring(0, 128);
-}
-/**
-* Generate a Kysely sql expression for creating an expression index.
-*
-* Validates all inputs before interpolation. The collection uses the
-* permissive manifest-key rules rather than SQL-identifier rules — it is
-* stored as opaque text and only reaches SQL inside the generated index
-* name — so kebab-case collections index like any other.
-*/
-function generateCreateIndexSql(db, pluginId, collection, fields, options) {
-	validatePluginIdentifier(pluginId, "plugin ID");
-	validateStorageCollectionName(collection, "collection name");
-	for (const field of fields) validateJsonFieldName(field, "index field name");
-	const indexName = generateIndexName(pluginId, collection, fields, options);
-	const expressions = fields.map((field) => {
-		if (isPostgres(db)) return `(${jsonExtractExpr(db, "data", field)})`;
-		return jsonExtractExpr(db, "data", field);
-	}).join(", ");
-	const createKeyword = options?.unique ? "CREATE UNIQUE INDEX" : "CREATE INDEX";
-	return sql`${sql.raw(createKeyword)} IF NOT EXISTS ${sql.ref(indexName)}
-		ON _plugin_storage(plugin_id, collection, ${sql.raw(expressions)})
-	`;
-}
-/**
-* Generate a Kysely sql expression for dropping an index.
-*
-* Uses sql.ref() for safe identifier quoting.
-*/
-function generateDropIndexSql(indexName) {
-	return sql`DROP INDEX IF EXISTS ${sql.ref(indexName)}`;
-}
-/**
-* Normalize index declarations to arrays of field arrays
-*/
-function normalizeIndexes(indexes) {
-	return indexes.map((index) => Array.isArray(index) ? index : [index]);
-}
-/**
-* Create all declared indexes for a plugin collection
-*/
-async function createStorageIndexes(db, pluginId, collection, indexes, options) {
-	const normalized = normalizeIndexes(indexes);
-	const uniqueNormalized = options?.uniqueIndexes ? normalizeIndexes(options.uniqueIndexes) : [];
-	const uniqueSet = new Set(uniqueNormalized.map((f) => f.join(",")));
-	const allEntries = [...normalized.filter((f) => !uniqueSet.has(f.join(","))).map((fields) => ({
-		fields,
-		unique: false
-	})), ...uniqueNormalized.map((fields) => ({
-		fields,
-		unique: true
-	}))];
-	const created = [];
-	const errors = [];
-	for (const entry of allEntries) {
-		const { fields } = entry;
-		const indexName = generateIndexName(pluginId, collection, fields, { unique: entry.unique });
-		try {
-			await generateCreateIndexSql(db, pluginId, collection, fields, { unique: entry.unique }).execute(db);
-			await db.insertInto("_plugin_indexes").values({
-				plugin_id: pluginId,
-				collection,
-				index_name: indexName,
-				fields: JSON.stringify(fields)
-			}).onConflict((oc) => oc.columns([
-				"plugin_id",
-				"collection",
-				"index_name"
-			]).doUpdateSet({ fields: JSON.stringify(fields) })).execute();
-			created.push(indexName);
-		} catch (error) {
-			errors.push({
-				index: indexName,
-				error: error instanceof Error ? error.message : String(error)
-			});
-		}
-	}
-	return {
-		created,
-		errors
-	};
-}
-/**
-* Remove indexes that are no longer declared
-*/
-async function removeOrphanedIndexes(db, pluginId, collection, currentIndexes, options) {
-	const normalized = normalizeIndexes(currentIndexes);
-	const uniqueNormalized = options?.uniqueIndexes ? normalizeIndexes(options.uniqueIndexes) : [];
-	const uniqueSet = new Set(uniqueNormalized.map((f) => f.join(",")));
-	const currentIndexNames = /* @__PURE__ */ new Set();
-	for (const fields of normalized) if (!uniqueSet.has(fields.join(","))) currentIndexNames.add(generateIndexName(pluginId, collection, fields));
-	for (const fields of uniqueNormalized) currentIndexNames.add(generateIndexName(pluginId, collection, fields, { unique: true }));
-	const existingIndexes = await db.selectFrom("_plugin_indexes").select(["index_name"]).where("plugin_id", "=", pluginId).where("collection", "=", collection).execute();
-	const removed = [];
-	const errors = [];
-	for (const { index_name } of existingIndexes) if (!currentIndexNames.has(index_name)) try {
-		await generateDropIndexSql(index_name).execute(db);
-		await db.deleteFrom("_plugin_indexes").where("plugin_id", "=", pluginId).where("collection", "=", collection).where("index_name", "=", index_name).execute();
-		removed.push(index_name);
-	} catch (error) {
-		errors.push({
-			index: index_name,
-			error: error instanceof Error ? error.message : String(error)
-		});
-	}
-	return {
-		removed,
-		errors
-	};
-}
-/**
-* Sync indexes for a plugin collection (create new, remove old)
-*/
-async function syncStorageIndexes(db, pluginId, collection, indexes, options) {
-	const [createResult, removeResult] = await Promise.all([createStorageIndexes(db, pluginId, collection, indexes, options), removeOrphanedIndexes(db, pluginId, collection, indexes, options)]);
-	return {
-		created: createResult.created,
-		removed: removeResult.removed,
-		errors: [...createResult.errors, ...removeResult.errors]
-	};
-}
-/**
-* Materialize the storage indexes a set of plugins declare in their
-* manifests. Failures are logged per collection and never thrown — a missing
-* index affects query performance, not correctness, so it must not fail an
-* install or a scheduler tick.
-*/
-async function syncDeclaredStorageIndexes(db, plugins) {
-	for (const plugin of plugins) for (const [collection, config] of Object.entries(plugin.storage ?? {})) try {
-		const result = await syncStorageIndexes(db, plugin.id, collection, config.indexes, { uniqueIndexes: config.uniqueIndexes });
-		for (const failure of result.errors) console.error(`[plugins] Failed to sync storage index ${failure.index} for ${plugin.id}/${collection}: ${failure.error}`);
-	} catch (error) {
-		console.error(`[plugins] Failed to sync storage indexes for ${plugin.id}/${collection}:`, error);
-	}
-}
-/**
-* Remove all indexes for a plugin
-*/
-async function removeAllPluginIndexes(db, pluginId) {
-	const existingIndexes = await db.selectFrom("_plugin_indexes").select(["index_name", "collection"]).where("plugin_id", "=", pluginId).execute();
-	const removed = [];
-	const errors = [];
-	for (const { index_name } of existingIndexes) try {
-		await generateDropIndexSql(index_name).execute(db);
-		removed.push(index_name);
-	} catch (error) {
-		errors.push({
-			index: index_name,
-			error: error instanceof Error ? error.message : String(error)
-		});
-	}
-	await db.deleteFrom("_plugin_indexes").where("plugin_id", "=", pluginId).execute();
-	return {
-		removed,
-		errors
-	};
-}
-
-//#endregion
-//#region src/api/handlers/marketplace.ts
-/** Semver-like pattern: digits, dots, hyphens, plus signs (e.g. 1.0.0, 1.0.0-beta.1) */
-const VERSION_PATTERN = /^[a-z0-9][a-z0-9._+-]*$/i;
-function validateVersion(version) {
-	if (version.includes("..")) throw new Error("Invalid version format");
-	if (!VERSION_PATTERN.test(version)) throw new Error("Invalid version format");
-}
-function getClient(marketplaceUrl, siteOrigin) {
-	if (!marketplaceUrl) return null;
-	return createMarketplaceClient(marketplaceUrl, siteOrigin);
-}
-function diffCapabilities(oldCaps, newCaps) {
-	const oldNorm = normalizeCapabilities(oldCaps);
-	const newNorm = normalizeCapabilities(newCaps);
-	const oldSet = new Set(oldNorm);
-	const newSet = new Set(newNorm);
-	return {
-		added: newNorm.filter((c) => !oldSet.has(c)),
-		removed: oldNorm.filter((c) => !newSet.has(c))
-	};
-}
-/**
-* Diff route visibility between two manifests.
-* Returns routes that changed from private to public (newly exposed).
-*/
-function diffRouteVisibility(oldManifest, newManifest) {
-	const oldPublicRoutes = /* @__PURE__ */ new Set();
-	if (oldManifest) for (const entry of oldManifest.routes) {
-		const normalized = normalizeManifestRoute(entry);
-		if (normalized.public === true) oldPublicRoutes.add(normalized.name);
-	}
-	const newlyPublic = [];
-	for (const entry of newManifest.routes) {
-		const normalized = normalizeManifestRoute(entry);
-		if (normalized.public === true && !oldPublicRoutes.has(normalized.name)) newlyPublic.push(normalized.name);
-	}
-	return { newlyPublic };
-}
-async function resolveVersionMetadata(client, pluginId, pluginDetail, version) {
-	if (pluginDetail.latestVersion?.version === version) return {
-		version: pluginDetail.latestVersion.version,
-		minEmDashVersion: pluginDetail.latestVersion.minEmDashVersion,
-		bundleSize: pluginDetail.latestVersion.bundleSize,
-		checksum: pluginDetail.latestVersion.checksum,
-		changelog: pluginDetail.latestVersion.changelog,
-		capabilities: pluginDetail.latestVersion.capabilities,
-		status: pluginDetail.latestVersion.status,
-		auditVerdict: pluginDetail.latestVersion.audit?.verdict ?? null,
-		imageAuditVerdict: pluginDetail.latestVersion.imageAudit?.verdict ?? null,
-		publishedAt: pluginDetail.latestVersion.publishedAt
-	};
-	return (await client.getVersions(pluginId)).find((v) => v.version === version) ?? null;
-}
-function validateBundleIdentity(bundle, pluginId, version) {
-	if (bundle.manifest.id !== pluginId) return {
-		success: false,
-		error: {
-			code: "MANIFEST_MISMATCH",
-			message: `Bundle manifest ID (${bundle.manifest.id}) does not match requested plugin (${pluginId})`
-		}
-	};
-	if (bundle.manifest.version !== version) return {
-		success: false,
-		error: {
-			code: "MANIFEST_VERSION_MISMATCH",
-			message: `Bundle manifest version (${bundle.manifest.version}) does not match requested version (${version})`
-		}
-	};
-	return null;
-}
-function bundlePrefix(source, pluginId, version) {
-	return `${source}/${pluginId}/${version}`;
-}
-async function storeBundleInR2(storage, pluginId, version, bundle, source = "marketplace") {
-	validatePluginIdentifier(pluginId, "plugin ID");
-	validateVersion(version);
-	const prefix = bundlePrefix(source, pluginId, version);
-	await storage.upload({
-		key: `${prefix}/manifest.json`,
-		body: new TextEncoder().encode(JSON.stringify(bundle.manifest)),
-		contentType: "application/json"
-	});
-	await storage.upload({
-		key: `${prefix}/backend.js`,
-		body: new TextEncoder().encode(bundle.backendCode),
-		contentType: "application/javascript"
-	});
-	if (bundle.adminCode) await storage.upload({
-		key: `${prefix}/admin.js`,
-		body: new TextEncoder().encode(bundle.adminCode),
-		contentType: "application/javascript"
-	});
-}
-/** Read a ReadableStream to string */
-async function streamToText(stream) {
-	return new Response(stream).text();
-}
-/**
-* Load a plugin bundle from site-local R2 storage.
-*
-* `source` selects the R2 key prefix: marketplace plugins are stored
-* under `marketplace/<id>/<version>/`, registry plugins under
-* `registry/<id>/<version>/`. Defaults to `"marketplace"` for
-* backwards compatibility with pre-registry call sites.
-*/
-async function loadBundleFromR2(storage, pluginId, version, source = "marketplace") {
-	validatePluginIdentifier(pluginId, "plugin ID");
-	validateVersion(version);
-	const prefix = bundlePrefix(source, pluginId, version);
-	try {
-		const manifestResult = await storage.download(`${prefix}/manifest.json`);
-		const backendResult = await storage.download(`${prefix}/backend.js`);
-		const manifestText = await streamToText(manifestResult.body);
-		const backendCode = await streamToText(backendResult.body);
-		const parsed = JSON.parse(manifestText);
-		const result = pluginManifestSchema.safeParse(parsed);
-		if (!result.success) return null;
-		const manifest = reconcileManifestAccess(result.data);
-		let adminCode;
-		try {
-			adminCode = await streamToText((await storage.download(`${prefix}/admin.js`)).body);
-		} catch {}
-		return {
-			manifest,
-			backendCode,
-			adminCode
-		};
-	} catch {
-		return null;
-	}
-}
-/** Delete a plugin bundle from site-local R2 storage */
-async function deleteBundleFromR2(storage, pluginId, version, source = "marketplace") {
-	validatePluginIdentifier(pluginId, "plugin ID");
-	validateVersion(version);
-	const prefix = bundlePrefix(source, pluginId, version);
-	for (const file of [
-		"manifest.json",
-		"backend.js",
-		"admin.js"
-	]) try {
-		await storage.delete(`${prefix}/${file}`);
-	} catch {}
-}
-async function handleMarketplaceInstall(db, storage, sandboxRunner, marketplaceUrl, pluginId, opts) {
-	const client = getClient(marketplaceUrl, opts?.siteOrigin);
-	if (!client) return {
-		success: false,
-		error: {
-			code: "MARKETPLACE_NOT_CONFIGURED",
-			message: "Marketplace is not configured"
-		}
-	};
-	if (!storage) return {
-		success: false,
-		error: {
-			code: "STORAGE_NOT_CONFIGURED",
-			message: "Storage is required for marketplace plugin installation"
-		}
-	};
-	if (!opts?.sandboxBypassed && (!sandboxRunner || !sandboxRunner.isAvailable())) return {
-		success: false,
-		error: {
-			code: "SANDBOX_NOT_AVAILABLE",
-			message: "Sandbox runner is required for marketplace plugins"
-		}
-	};
-	try {
-		const stateRepo = new PluginStateRepository(db);
-		const existing = await stateRepo.get(pluginId);
-		if (existing && existing.source === "marketplace") return {
-			success: false,
-			error: {
-				code: "ALREADY_INSTALLED",
-				message: `Plugin ${pluginId} is already installed`
-			}
-		};
-		if (opts?.configuredPluginIds?.has(pluginId)) return {
-			success: false,
-			error: {
-				code: "PLUGIN_ID_CONFLICT",
-				message: `Cannot install marketplace plugin "${pluginId}" — a configured plugin with the same ID already exists`
-			}
-		};
-		const pluginDetail = await client.getPlugin(pluginId);
-		const version = opts?.version ?? pluginDetail.latestVersion?.version;
-		if (!version) return {
-			success: false,
-			error: {
-				code: "NO_VERSION",
-				message: `No published versions found for plugin ${pluginId}`
-			}
-		};
-		const versionMetadata = await resolveVersionMetadata(client, pluginId, pluginDetail, version);
-		if (!versionMetadata) return {
-			success: false,
-			error: {
-				code: "NO_VERSION",
-				message: `Version ${version} was not found for plugin ${pluginId}`
-			}
-		};
-		if (versionMetadata.auditVerdict === "fail" || versionMetadata.auditVerdict === "warn") return {
-			success: false,
-			error: {
-				code: "AUDIT_FAILED",
-				message: versionMetadata.auditVerdict === "fail" ? "Plugin failed security audit and cannot be installed" : "Plugin audit was inconclusive and cannot be installed until reviewed"
-			}
-		};
-		const bundle = await client.downloadBundle(pluginId, version);
-		if (versionMetadata.checksum && bundle.checksum !== versionMetadata.checksum) return {
-			success: false,
-			error: {
-				code: "CHECKSUM_MISMATCH",
-				message: "Bundle checksum does not match marketplace record. Download may be corrupted."
-			}
-		};
-		const bundleIdentityError = validateBundleIdentity(bundle, pluginId, version);
-		if (bundleIdentityError) return bundleIdentityError;
-		if ((bundle.manifest.mcp?.tools.length ?? 0) > 0 && !opts?.confirmMcpTools) return {
-			success: false,
-			error: {
-				code: "MCP_TOOL_CONSENT_REQUIRED",
-				message: "Plugin MCP tools require explicit consent",
-				details: { mcpTools: bundle.manifest.mcp?.tools.map(({ inputSchema: _, outputSchema: __, ...tool }) => tool) }
-			}
-		};
-		await storeBundleInR2(storage, pluginId, version, bundle);
-		await stateRepo.upsert(pluginId, version, "active", {
-			source: "marketplace",
-			marketplaceVersion: version,
-			displayName: pluginDetail.name,
-			description: pluginDetail.description ?? void 0
-		});
-		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
-		client.reportInstall(pluginId, version).catch(() => {});
-		return {
-			success: true,
-			data: {
-				pluginId,
-				version,
-				capabilities: bundle.manifest.capabilities
-			}
-		};
-	} catch (err) {
-		if (err instanceof MarketplaceUnavailableError) return {
-			success: false,
-			error: {
-				code: "MARKETPLACE_UNAVAILABLE",
-				message: "Plugin marketplace is currently unavailable"
-			}
-		};
-		if (err instanceof MarketplaceError) return {
-			success: false,
-			error: {
-				code: err.code ?? "MARKETPLACE_ERROR",
-				message: err.message
-			}
-		};
-		if (err instanceof EmDashStorageError) return {
-			success: false,
-			error: {
-				code: err.code ?? "STORAGE_ERROR",
-				message: "Storage error while installing plugin"
-			}
-		};
-		if (err && typeof err === "object" && "code" in err) {
-			const code = err.code;
-			if (typeof code === "string" && code.trim()) return {
-				success: false,
-				error: {
-					code,
-					message: "Failed to install plugin from marketplace"
-				}
-			};
-		}
-		console.error("Failed to install marketplace plugin:", err);
-		return {
-			success: false,
-			error: {
-				code: "INSTALL_FAILED",
-				message: "Failed to install plugin from marketplace"
-			}
-		};
-	}
-}
-async function handleMarketplaceUpdate(db, storage, sandboxRunner, marketplaceUrl, pluginId, opts) {
-	const client = getClient(marketplaceUrl);
-	if (!client) return {
-		success: false,
-		error: {
-			code: "MARKETPLACE_NOT_CONFIGURED",
-			message: "Marketplace is not configured"
-		}
-	};
-	if (!storage) return {
-		success: false,
-		error: {
-			code: "STORAGE_NOT_CONFIGURED",
-			message: "Storage is required"
-		}
-	};
-	if (!opts?.sandboxBypassed && (!sandboxRunner || !sandboxRunner.isAvailable())) return {
-		success: false,
-		error: {
-			code: "SANDBOX_NOT_AVAILABLE",
-			message: "Sandbox runner is required"
-		}
-	};
-	try {
-		const stateRepo = new PluginStateRepository(db);
-		const existing = await stateRepo.get(pluginId);
-		if (!existing || existing.source !== "marketplace") return {
-			success: false,
-			error: {
-				code: "NOT_FOUND",
-				message: `No marketplace plugin found: ${pluginId}`
-			}
-		};
-		const oldVersion = existing.marketplaceVersion ?? existing.version;
-		const pluginDetail = await client.getPlugin(pluginId);
-		const newVersion = opts?.version ?? pluginDetail.latestVersion?.version;
-		if (!newVersion) return {
-			success: false,
-			error: {
-				code: "NO_VERSION",
-				message: "No newer version available"
-			}
-		};
-		if (newVersion === oldVersion) return {
-			success: false,
-			error: {
-				code: "ALREADY_UP_TO_DATE",
-				message: "Plugin is already up to date"
-			}
-		};
-		const versionMetadata = await resolveVersionMetadata(client, pluginId, pluginDetail, newVersion);
-		if (!versionMetadata) return {
-			success: false,
-			error: {
-				code: "NO_VERSION",
-				message: `Version ${newVersion} was not found for plugin ${pluginId}`
-			}
-		};
-		const bundle = await client.downloadBundle(pluginId, newVersion);
-		if (versionMetadata.checksum && bundle.checksum !== versionMetadata.checksum) return {
-			success: false,
-			error: {
-				code: "CHECKSUM_MISMATCH",
-				message: "Bundle checksum does not match marketplace record. Download may be corrupted."
-			}
-		};
-		const bundleIdentityError = validateBundleIdentity(bundle, pluginId, newVersion);
-		if (bundleIdentityError) return bundleIdentityError;
-		const oldBundle = await loadBundleFromR2(storage, pluginId, oldVersion);
-		const capabilityChanges = diffCapabilities(oldBundle?.manifest.capabilities ?? [], bundle.manifest.capabilities);
-		if (capabilityChanges.added.length > 0 && !opts?.confirmCapabilityChanges) return {
-			success: false,
-			error: {
-				code: "CAPABILITY_ESCALATION",
-				message: "Plugin update requires new capabilities",
-				details: { capabilityChanges }
-			}
-		};
-		const routeVisibilityChanges = diffRouteVisibility(oldBundle?.manifest, bundle.manifest);
-		const hasNewPublicRoutes = routeVisibilityChanges.newlyPublic.length > 0;
-		if (hasNewPublicRoutes && !opts?.confirmRouteVisibilityChanges) return {
-			success: false,
-			error: {
-				code: "ROUTE_VISIBILITY_ESCALATION",
-				message: "Plugin update exposes new public (unauthenticated) routes",
-				details: {
-					routeVisibilityChanges,
-					capabilityChanges
-				}
-			}
-		};
-		const oldMcpTools = [...oldBundle?.manifest.mcp?.tools ?? []].toSorted((a, b) => a.name.localeCompare(b.name));
-		const newMcpTools = [...bundle.manifest.mcp?.tools ?? []].toSorted((a, b) => a.name.localeCompare(b.name));
-		if (JSON.stringify(oldMcpTools) !== JSON.stringify(newMcpTools) && !opts?.confirmMcpTools) return {
-			success: false,
-			error: {
-				code: "MCP_TOOL_CONSENT_REQUIRED",
-				message: "Plugin update changes its MCP tools",
-				details: { mcpTools: newMcpTools.map(({ inputSchema: _, outputSchema: __, ...tool }) => tool) }
-			}
-		};
-		await storeBundleInR2(storage, pluginId, newVersion, bundle);
-		await stateRepo.upsert(pluginId, newVersion, "active", {
-			source: "marketplace",
-			marketplaceVersion: newVersion,
-			displayName: pluginDetail.name,
-			description: pluginDetail.description ?? void 0,
-			mcpToolsEnabled: false,
-			mcpToolsConsent: null
-		});
-		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
-		deleteBundleFromR2(storage, pluginId, oldVersion).catch(() => {});
-		return {
-			success: true,
-			data: {
-				pluginId,
-				oldVersion,
-				newVersion,
-				capabilityChanges,
-				routeVisibilityChanges: hasNewPublicRoutes ? routeVisibilityChanges : void 0
-			}
-		};
-	} catch (err) {
-		if (err instanceof MarketplaceUnavailableError) return {
-			success: false,
-			error: {
-				code: "MARKETPLACE_UNAVAILABLE",
-				message: "Marketplace is unavailable"
-			}
-		};
-		if (err instanceof MarketplaceError) return {
-			success: false,
-			error: {
-				code: err.code ?? "MARKETPLACE_ERROR",
-				message: err.message
-			}
-		};
-		console.error("Failed to update marketplace plugin:", err);
-		return {
-			success: false,
-			error: {
-				code: "UPDATE_FAILED",
-				message: "Failed to update plugin"
-			}
-		};
-	}
-}
-async function handleMarketplaceUninstall(db, storage, pluginId, opts) {
-	try {
-		const stateRepo = new PluginStateRepository(db);
-		const existing = await stateRepo.get(pluginId);
-		if (!existing || existing.source !== "marketplace") return {
-			success: false,
-			error: {
-				code: "NOT_FOUND",
-				message: `No marketplace plugin found: ${pluginId}`
-			}
-		};
-		const version = existing.marketplaceVersion ?? existing.version;
-		if (storage) await deleteBundleFromR2(storage, pluginId, version);
-		let dataDeleted = false;
-		if (opts?.deleteData) try {
-			await db.deleteFrom("_plugin_storage").where("plugin_id", "=", pluginId).execute();
-			dataDeleted = true;
-		} catch {}
-		try {
-			await removeAllPluginIndexes(db, pluginId);
-		} catch {}
-		await stateRepo.delete(pluginId);
-		return {
-			success: true,
-			data: {
-				pluginId,
-				dataDeleted
-			}
-		};
-	} catch (err) {
-		console.error("Failed to uninstall marketplace plugin:", err);
-		return {
-			success: false,
-			error: {
-				code: "UNINSTALL_FAILED",
-				message: "Failed to uninstall plugin"
-			}
-		};
-	}
-}
-async function handleMarketplaceUpdateCheck(db, marketplaceUrl) {
-	const client = getClient(marketplaceUrl);
-	if (!client) return {
-		success: false,
-		error: {
-			code: "MARKETPLACE_NOT_CONFIGURED",
-			message: "Marketplace is not configured"
-		}
-	};
-	try {
-		const marketplacePlugins = await new PluginStateRepository(db).getMarketplacePlugins();
-		const items = [];
-		for (const plugin of marketplacePlugins) try {
-			const detail = await client.getPlugin(plugin.pluginId);
-			const latest = detail.latestVersion?.version;
-			const installed = plugin.marketplaceVersion ?? plugin.version;
-			if (!latest) continue;
-			const hasUpdate = latest !== installed;
-			let capabilityChanges;
-			let hasCapabilityChanges = false;
-			if (hasUpdate && detail.latestVersion) {
-				capabilityChanges = diffCapabilities(detail.capabilities ?? [], detail.latestVersion.capabilities ?? []);
-				hasCapabilityChanges = capabilityChanges.added.length > 0 || capabilityChanges.removed.length > 0;
-			}
-			items.push({
-				pluginId: plugin.pluginId,
-				installed,
-				latest: latest ?? installed,
-				hasUpdate,
-				hasCapabilityChanges,
-				capabilityChanges: hasCapabilityChanges ? capabilityChanges : void 0,
-				hasRouteVisibilityChanges: false
-			});
-		} catch (err) {
-			console.warn(`Failed to check updates for ${plugin.pluginId}:`, err);
-		}
-		return {
-			success: true,
-			data: { items }
-		};
-	} catch (err) {
-		if (err instanceof MarketplaceUnavailableError) return {
-			success: false,
-			error: {
-				code: "MARKETPLACE_UNAVAILABLE",
-				message: "Marketplace is unavailable"
-			}
-		};
-		console.error("Failed to check marketplace updates:", err);
-		return {
-			success: false,
-			error: {
-				code: "UPDATE_CHECK_FAILED",
-				message: "Failed to check for updates"
-			}
-		};
-	}
-}
-async function handleMarketplaceSearch(marketplaceUrl, query, opts) {
-	const client = getClient(marketplaceUrl);
-	if (!client) return {
-		success: false,
-		error: {
-			code: "MARKETPLACE_NOT_CONFIGURED",
-			message: "Marketplace is not configured"
-		}
-	};
-	try {
-		return {
-			success: true,
-			data: await client.search(query, opts)
-		};
-	} catch (err) {
-		if (err instanceof MarketplaceUnavailableError) return {
-			success: false,
-			error: {
-				code: "MARKETPLACE_UNAVAILABLE",
-				message: "Marketplace is unavailable"
-			}
-		};
-		console.error("Failed to search marketplace:", err);
-		return {
-			success: false,
-			error: {
-				code: "SEARCH_FAILED",
-				message: "Failed to search marketplace"
-			}
-		};
-	}
-}
-async function handleMarketplaceGetPlugin(marketplaceUrl, pluginId) {
-	const client = getClient(marketplaceUrl);
-	if (!client) return {
-		success: false,
-		error: {
-			code: "MARKETPLACE_NOT_CONFIGURED",
-			message: "Marketplace is not configured"
-		}
-	};
-	try {
-		return {
-			success: true,
-			data: await client.getPlugin(pluginId)
-		};
-	} catch (err) {
-		if (err instanceof MarketplaceError && err.status === 404) return {
-			success: false,
-			error: {
-				code: "NOT_FOUND",
-				message: `Plugin not found: ${pluginId}`
-			}
-		};
-		if (err instanceof MarketplaceUnavailableError) return {
-			success: false,
-			error: {
-				code: "MARKETPLACE_UNAVAILABLE",
-				message: "Marketplace is unavailable"
-			}
-		};
-		console.error("Failed to get marketplace plugin:", err);
-		return {
-			success: false,
-			error: {
-				code: "GET_PLUGIN_FAILED",
-				message: "Failed to get plugin details"
-			}
-		};
-	}
-}
-async function handleThemeSearch(marketplaceUrl, query, opts) {
-	const client = getClient(marketplaceUrl);
-	if (!client) return {
-		success: false,
-		error: {
-			code: "MARKETPLACE_NOT_CONFIGURED",
-			message: "Marketplace is not configured"
-		}
-	};
-	try {
-		return {
-			success: true,
-			data: await client.searchThemes(query, opts)
-		};
-	} catch (err) {
-		if (err instanceof MarketplaceUnavailableError) return {
-			success: false,
-			error: {
-				code: "MARKETPLACE_UNAVAILABLE",
-				message: "Marketplace is unavailable"
-			}
-		};
-		console.error("Failed to search themes:", err);
-		return {
-			success: false,
-			error: {
-				code: "THEME_SEARCH_FAILED",
-				message: "Failed to search themes"
-			}
-		};
-	}
-}
-async function handleThemeGetDetail(marketplaceUrl, themeId) {
-	const client = getClient(marketplaceUrl);
-	if (!client) return {
-		success: false,
-		error: {
-			code: "MARKETPLACE_NOT_CONFIGURED",
-			message: "Marketplace is not configured"
-		}
-	};
-	try {
-		return {
-			success: true,
-			data: await client.getTheme(themeId)
-		};
-	} catch (err) {
-		if (err instanceof MarketplaceError && err.status === 404) return {
-			success: false,
-			error: {
-				code: "NOT_FOUND",
-				message: `Theme not found: ${themeId}`
-			}
-		};
-		if (err instanceof MarketplaceUnavailableError) return {
-			success: false,
-			error: {
-				code: "MARKETPLACE_UNAVAILABLE",
-				message: "Marketplace is unavailable"
-			}
-		};
-		console.error("Failed to get marketplace theme:", err);
-		return {
-			success: false,
-			error: {
-				code: "GET_THEME_FAILED",
-				message: "Failed to get theme details"
-			}
-		};
-	}
-}
-
-//#endregion
-//#region src/registry/artifact-fetch.ts
-const TRAILING_DOT$1 = /\.+$/;
-const HEADER_END = new Uint8Array([
-	13,
-	10,
-	13,
-	10
-]);
-const CRLF = new Uint8Array([13, 10]);
-const STATUS_LINE_RE = /^HTTP\/1\.[01] ([2-5][0-9]{2})(?: .*)?$/;
-const HEADER_NAME_RE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-const FOLDED_HEADER_RE = /^[ \t]/;
-const CONTENT_LENGTH_RE = /^(0|[1-9][0-9]*)$/;
-const CHUNK_SIZE_RE = /^[0-9A-Fa-f]+$/;
-const MAX_HEADER_BYTES = 32 * 1024;
-const LOCALHOST_HOSTNAMES = new Set([
-	"localhost",
-	"localhost.localdomain",
-	"ip6-localhost",
-	"ip6-loopback"
-]);
-let defaultTransport = null;
-function isLocalhostHostname(hostname) {
-	const normalized = hostname.toLowerCase().replace(TRAILING_DOT$1, "");
-	return LOCALHOST_HOSTNAMES.has(normalized) || normalized.endsWith(".localhost") || normalized === "127.0.0.1" || normalized === "::1" || normalized === "[::1]" || normalized.startsWith("::ffff:127.") || normalized.startsWith("::ffff:7f00:");
-}
-async function resolveSafeArtifactTarget(urlString) {
-	let url;
-	try {
-		url = new URL(urlString);
-	} catch {
-		throw new Error(`Invalid artifact URL: ${urlString}`);
-	}
-	if (url.protocol !== "https:" && url.protocol !== "http:") throw new Error(`Artifact URL protocol not allowed: ${url.protocol}`);
-	if (url.username || url.password) throw new Error("Artifact URL must not contain embedded credentials");
-	const hostname = stripIpv6Brackets(url.hostname.toLowerCase().replace(TRAILING_DOT$1, ""));
-	const localhost = isLocalhostHostname(hostname);
-	if (!import.meta.env.DEV) {
-		if (url.protocol === "http:") throw new Error("Artifact URL must use https");
-		if (localhost) throw new Error(`Artifact URL points to localhost: ${hostname}`);
-	} else if (url.protocol === "http:" && !localhost) throw new Error("Artifact URL must use https (http allowed only for localhost in dev)");
-	if (localhost) return {
-		url,
-		addresses: []
-	};
-	try {
-		return await resolveAndValidateExternalUrlTarget(url.href);
-	} catch (error) {
-		if (error instanceof SsrfError) throw new Error(`Artifact URL rejected: ${error.message}`, { cause: error });
-		throw error;
-	}
-}
-async function fetchRegistryArtifactUrl(urlString, options) {
-	if (!Number.isSafeInteger(options.maxResponseBytes) || options.maxResponseBytes < 0) throw new TypeError("Registry artifact response limit is invalid");
-	const target = await resolveSafeArtifactTarget(urlString);
-	if (target.addresses.length === 0) return globalThis.fetch(target.url, {
-		redirect: "manual",
-		signal: options.signal
-	});
-	const result = await (defaultTransport ?? await createRuntimeRegistryArtifactTransport()).fetch({
-		url: target.url,
-		allowedAddresses: target.addresses,
-		signal: options.signal,
-		maxResponseBytes: options.maxResponseBytes
-	});
-	if (!target.addresses.includes(result.connectedAddress)) {
-		await result.response.body?.cancel().catch(() => void 0);
-		throw new Error("Registry artifact transport connected outside the validated address set");
-	}
-	return result.response;
-}
-async function createRuntimeRegistryArtifactTransport() {
-	try {
-		const connect = objectProperty(await import("cloudflare:sockets"), "connect");
-		if (!isWorkerSocketConnect(connect)) throw new TypeError("Workers socket binding is invalid");
-		return createWorkersRegistryArtifactTransport(connect);
-	} catch {
-		return createNodeRegistryArtifactTransport();
-	}
-}
-function createWorkersRegistryArtifactTransport(connect) {
-	return { async fetch(input) {
-		let lastError;
-		for (const address of input.allowedAddresses) {
-			if (input.signal.aborted) throw new Error("Registry artifact request was aborted");
-			let socket;
-			let tls;
-			try {
-				socket = connect({
-					hostname: address,
-					port: parseHttpsPort(input.url)
-				}, {
-					secureTransport: "starttls",
-					allowHalfOpen: false
-				});
-				await abortable(socket.opened, input.signal, () => socket?.close());
-				tls = socket.startTls({ expectedServerHostname: stripIpv6Brackets(input.url.hostname) });
-				await abortable(tls.opened, input.signal, () => tls?.close());
-				const writer = tls.writable.getWriter();
-				try {
-					await abortable(writer.write(buildHttpRequest(input.url)), input.signal, () => tls?.close());
-				} finally {
-					writer.releaseLock();
-				}
-				const bytes = await readWorkerSocketResponse(tls, input.maxResponseBytes + MAX_HEADER_BYTES, input.signal);
-				await tls.close().catch(() => void 0);
-				return {
-					response: parsedResponseToWebResponse(parsePinnedHttpResponse(bytes, input.maxResponseBytes)),
-					connectedAddress: address
-				};
-			} catch (error) {
-				await Promise.all([tls?.close().catch(() => void 0), socket?.close().catch(() => void 0)]);
-				if (input.signal.aborted) throw error;
-				lastError = error;
-			}
-		}
-		throw new Error("Registry artifact transport could not connect to an approved address", { cause: lastError });
-	} };
-}
-async function createNodeRegistryArtifactTransport() {
-	const { request } = await import("node:https");
-	return { async fetch(input) {
-		let lastError;
-		for (const address of input.allowedAddresses) try {
-			return {
-				response: await new Promise((resolve, reject) => {
-					const chunks = [];
-					let total = 0;
-					const req = request({
-						protocol: "https:",
-						hostname: stripIpv6Brackets(input.url.hostname),
-						port: parseHttpsPort(input.url),
-						path: `${input.url.pathname}${input.url.search}`,
-						method: "GET",
-						agent: false,
-						headers: {
-							Host: input.url.host,
-							Connection: "close",
-							"Accept-Encoding": "identity"
-						},
-						lookup: (_hostname, _options, callback) => {
-							callback(null, address, address.includes(":") ? 6 : 4);
-						},
-						signal: input.signal
-					}, (upstream) => {
-						const contentEncoding = upstream.headers["content-encoding"];
-						if (contentEncoding && contentEncoding.toLowerCase() !== "identity") {
-							upstream.destroy(/* @__PURE__ */ new Error("Registry artifact response content encoding is unsupported"));
-							return;
-						}
-						upstream.on("data", (chunk) => {
-							total += chunk.byteLength;
-							if (total > input.maxResponseBytes) {
-								upstream.destroy(/* @__PURE__ */ new RangeError("Registry artifact response exceeds its byte limit"));
-								return;
-							}
-							chunks.push(new Uint8Array(chunk));
-						});
-						upstream.once("error", reject);
-						upstream.once("end", () => {
-							const bytes = concatBytes(chunks, total);
-							const headers = new Headers();
-							for (let index = 0; index < upstream.rawHeaders.length; index += 2) headers.append(upstream.rawHeaders[index], upstream.rawHeaders[index + 1]);
-							resolve(parsedResponseToWebResponse({
-								status: upstream.statusCode ?? 502,
-								headers,
-								body: bytes
-							}));
-						});
-					});
-					req.once("error", reject);
-					req.end();
-				}),
-				connectedAddress: address
-			};
-		} catch (error) {
-			if (input.signal.aborted) throw error;
-			lastError = error;
-		}
-		throw new Error("Registry artifact transport could not connect to an approved address", { cause: lastError });
-	} };
-}
-function parsePinnedHttpResponse(bytes, maxResponseBytes) {
-	const headerEnd = findSequence(bytes, HEADER_END, 0);
-	if (headerEnd === -1 || headerEnd > MAX_HEADER_BYTES) throw new Error("Registry artifact response headers are invalid or too large");
-	const lines = new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, headerEnd)).split("\r\n");
-	const statusMatch = STATUS_LINE_RE.exec(lines.shift() ?? "");
-	if (!statusMatch) throw new Error("Registry artifact response status line is invalid");
-	const headers = new Headers();
-	const rawHeaders = /* @__PURE__ */ new Map();
-	for (const line of lines) {
-		if (FOLDED_HEADER_RE.test(line)) throw new Error("Registry artifact response uses folded headers");
-		const separator = line.indexOf(":");
-		if (separator < 1) throw new Error("Registry artifact response header is invalid");
-		const name = line.slice(0, separator);
-		const value = line.slice(separator + 1).trim();
-		if (!HEADER_NAME_RE.test(name) || containsInvalidHeaderValue(value)) throw new Error("Registry artifact response header is invalid");
-		const normalized = name.toLowerCase();
-		const values = rawHeaders.get(normalized) ?? [];
-		values.push(value);
-		rawHeaders.set(normalized, values);
-		headers.append(name, value);
-	}
-	const contentEncoding = rawHeaders.get("content-encoding");
-	if (contentEncoding && (contentEncoding.length !== 1 || contentEncoding[0]?.toLowerCase() !== "identity")) throw new Error("Registry artifact response content encoding is unsupported");
-	const contentLength = rawHeaders.get("content-length");
-	const transferEncoding = rawHeaders.get("transfer-encoding");
-	if (contentLength && transferEncoding) throw new Error("Registry artifact response framing is ambiguous");
-	const bodyBytes = bytes.subarray(headerEnd + HEADER_END.length);
-	let body;
-	if (transferEncoding) {
-		if (transferEncoding.length !== 1 || transferEncoding[0]?.toLowerCase() !== "chunked") throw new Error("Registry artifact response transfer encoding is unsupported");
-		body = decodeChunkedBody(bodyBytes, maxResponseBytes);
-	} else if (contentLength) {
-		if (contentLength.length !== 1 || !CONTENT_LENGTH_RE.test(contentLength[0])) throw new Error("Registry artifact response content length is invalid");
-		const length = Number(contentLength[0]);
-		if (!Number.isSafeInteger(length) || length !== bodyBytes.byteLength) throw new Error("Registry artifact response body length does not match its framing");
-		body = new Uint8Array(bodyBytes);
-	} else body = new Uint8Array(bodyBytes);
-	if (body.byteLength > maxResponseBytes) throw new RangeError("Registry artifact response exceeds its byte limit");
-	return {
-		status: Number(statusMatch[1]),
-		headers,
-		body
-	};
-}
-function parsedResponseToWebResponse(parsed) {
-	const bodyAllowed = ![
-		204,
-		205,
-		304
-	].includes(parsed.status);
-	let body = null;
-	if (bodyAllowed) {
-		body = new ArrayBuffer(parsed.body.byteLength);
-		new Uint8Array(body).set(parsed.body);
-	}
-	return new Response(body, {
-		status: parsed.status,
-		headers: parsed.headers
-	});
-}
-function buildHttpRequest(url) {
-	return new TextEncoder().encode([
-		`GET ${url.pathname}${url.search} HTTP/1.1`,
-		`Host: ${url.host}`,
-		"Connection: close",
-		"Accept-Encoding: identity",
-		"",
-		""
-	].join("\r\n"));
-}
-async function readWorkerSocketResponse(socket, maximumBytes, signal) {
-	const reader = socket.readable.getReader();
-	const chunks = [];
-	let total = 0;
-	try {
-		for (;;) {
-			const next = await abortable(reader.read(), signal, () => socket.close());
-			if (next.done) break;
-			total += next.value.byteLength;
-			if (total > maximumBytes) throw new RangeError("Registry artifact response exceeds its byte limit");
-			chunks.push(next.value);
-		}
-	} finally {
-		reader.releaseLock();
-	}
-	return concatBytes(chunks, total);
-}
-function decodeChunkedBody(bytes, maximumBytes) {
-	const chunks = [];
-	let offset = 0;
-	let total = 0;
-	for (;;) {
-		const lineEnd = findSequence(bytes, CRLF, offset);
-		if (lineEnd === -1 || lineEnd - offset > 128) throw new Error("Registry artifact chunk size line is invalid");
-		const sizeText = new TextDecoder().decode(bytes.subarray(offset, lineEnd)).split(";", 1)[0];
-		if (!sizeText || !CHUNK_SIZE_RE.test(sizeText)) throw new Error("Registry artifact chunk size is invalid");
-		const size = Number.parseInt(sizeText, 16);
-		if (!Number.isSafeInteger(size)) throw new Error("Registry artifact chunk size is invalid");
-		offset = lineEnd + CRLF.length;
-		if (size === 0) {
-			if (offset + CRLF.length !== bytes.length || bytes[offset] !== 13 || bytes[offset + 1] !== 10) throw new Error("Registry artifact chunk trailer is invalid");
-			break;
-		}
-		if (offset + size + CRLF.length > bytes.length) throw new Error("Registry artifact chunk body is truncated");
-		if (bytes[offset + size] !== 13 || bytes[offset + size + 1] !== 10) throw new Error("Registry artifact chunk delimiter is invalid");
-		total += size;
-		if (total > maximumBytes) throw new RangeError("Registry artifact response exceeds its byte limit");
-		chunks.push(new Uint8Array(bytes.subarray(offset, offset + size)));
-		offset += size + CRLF.length;
-	}
-	return concatBytes(chunks, total);
-}
-function findSequence(bytes, sequence, start) {
-	outer: for (let offset = start; offset <= bytes.length - sequence.length; offset += 1) {
-		for (let index = 0; index < sequence.length; index += 1) if (bytes[offset + index] !== sequence[index]) continue outer;
-		return offset;
-	}
-	return -1;
-}
-function concatBytes(chunks, total) {
-	const bytes = new Uint8Array(total);
-	let offset = 0;
-	for (const chunk of chunks) {
-		bytes.set(chunk, offset);
-		offset += chunk.byteLength;
-	}
-	return bytes;
-}
-function containsInvalidHeaderValue(value) {
-	for (const character of value) {
-		const code = character.codePointAt(0);
-		if (code === 0 || code === 10 || code === 13) return true;
-	}
-	return false;
-}
-function parseHttpsPort(url) {
-	const port = url.port === "" ? 443 : Number(url.port);
-	if (!Number.isSafeInteger(port) || port < 1 || port > 65535) throw new TypeError("Registry artifact HTTPS port is invalid");
-	return port;
-}
-function stripIpv6Brackets(hostname) {
-	return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
-}
-function objectProperty(value, key) {
-	if (typeof value !== "object" || value === null) return void 0;
-	return Object.getOwnPropertyDescriptor(value, key)?.value;
-}
-function isWorkerSocketConnect(value) {
-	return typeof value === "function";
-}
-async function abortable(operation, signal, onAbort) {
-	if (signal.aborted) throw new Error("Registry artifact request was aborted");
-	let abort;
-	const aborted = new Promise((_resolve, reject) => {
-		abort = () => {
-			onAbort();
-			reject(/* @__PURE__ */ new Error("Registry artifact request was aborted"));
-		};
-		signal.addEventListener("abort", abort, { once: true });
-	});
-	try {
-		return await Promise.race([operation, aborted]);
-	} finally {
-		if (abort) signal.removeEventListener("abort", abort);
-	}
-}
-
-//#endregion
-//#region src/registry/config.ts
-/**
-* Helpers for normalizing the experimental registry integration option
-* (`config.experimental.registry` in `astro.config.mjs`) into the shape
-* exposed on the admin manifest.
-*
-* The integration option accepts a human-friendly duration string for
-* `policy.minimumReleaseAge` (`"48h"`, `"7d"`); the manifest exposes
-* seconds so the browser doesn't need a duration parser.
-*/
-/**
-* Canonicalize a capabilities list for set-style comparison.
-*
-* Capabilities (the legacy declared-access shape used by the current
-* sandbox enforcer) are conceptually a *set*: order, duplicates, and
-* non-string entries don't carry meaning. The install handler's drift
-* check compares the admin's acknowledged set against the bundle
-* manifest's set; both sides pass through this canonicalizer first so
-* an aggregator-supplied array with unstable order or junk entries
-* can't cause a spurious drift rejection.
-*
-* Filters non-strings, deduplicates, and sorts lexically. Named to
-* avoid shadowing `@emdash-cms/plugin-types`'s existing
-* `normalizeCapabilities` (which dedupes + applies the deprecated →
-* current alias map but does not filter junk or sort).
-*
-* Exported so the same shape is produced by the browser before sending
-* the `acknowledgedDeclaredAccess` payload and by the server before
-* comparing against the bundle.
-*/
-function canonicalCapabilitiesForDriftCheck(value) {
-	if (!Array.isArray(value)) return [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const entry of value) if (typeof entry === "string" && entry.length > 0) seen.add(entry);
-	return [...seen].toSorted();
-}
-/**
-* Returns whether a `(publisher_did, slug)` pair is on the
-* minimum-release-age exemption list. Exported so the same matcher is
-* used by the browser policy filter and the server-side install
-* enforcement.
-*
-* Matching is DID-only. Handles are aggregator-supplied envelope data
-* (mutable, controlled by an attacker who compromises the aggregator)
-* and cannot be used as a trust input -- a compromised aggregator
-* could claim any handle for any package and bypass the holdback. DIDs
-* are part of the AT URI of the package record and are independently
-* resolvable, so even a compromised aggregator can't lie about the
-* publisher DID without also breaking checksum verification downstream.
-*
-* Entries from config are already lowercased at manifest-build time.
-* Runtime values are lowercased here at compare time.
-*/
-function releaseExemptFromMinimumAge(exclude, publisherDid, slug) {
-	if (!exclude || exclude.length === 0) return false;
-	const didLower = publisherDid.toLowerCase();
-	const fullDid = `${didLower}/${slug.toLowerCase()}`;
-	for (const entry of exclude) {
-		if (entry === didLower) return true;
-		if (entry === fullDid) return true;
-	}
-	return false;
-}
-const DURATION_PATTERN = /^(\d+)(s|m|h|d|w)$/;
-/** Trailing slashes on the aggregator URL, stripped during normalization. */
-const TRAILING_SLASHES = /\/+$/;
-/** Trailing dot on a hostname, stripped before URL host comparisons. */
-const TRAILING_DOT = /\.$/;
-const REGISTRY_PACKAGE_SLUG_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
-/**
-* Parse a duration string or raw second count into a non-negative
-* integer count of seconds. Throws on unrecognised input so config
-* mistakes fail at startup rather than silently disabling the policy.
-*/
-function parseDurationSeconds(duration) {
-	if (typeof duration === "number") {
-		if (!Number.isFinite(duration) || duration < 0) throw new Error(`Invalid duration: ${duration} (must be a non-negative finite number)`);
-		return Math.floor(duration);
-	}
-	const match = duration.match(DURATION_PATTERN);
-	if (!match) throw new Error(`Invalid duration format: "${duration}". Use a duration string like "48h", "7d", "30m", or a number of seconds.`);
-	const value = parseInt(match[1], 10);
-	const unit = match[2];
-	switch (unit) {
-		case "s": return value;
-		case "m": return value * 60;
-		case "h": return value * 60 * 60;
-		case "d": return value * 24 * 60 * 60;
-		case "w": return value * 7 * 24 * 60 * 60;
-		default: throw new Error(`Unknown duration unit: ${unit}`);
-	}
-}
-/**
-* Validate that `aggregatorUrl` is a safe outbound target for the
-* registry's XRPC calls. Same posture as artifact downloads: HTTPS
-* required in production; `http://localhost` allowed only in dev.
-*
-* The aggregator's responses are the trust source for release records,
-* checksums, labels, artifact cache descriptors, and `indexedAt` (until full MST
-* verification lands). Allowing plain HTTP here would let a network
-* attacker swap a release record and point the artifact URL at their
-* own HTTPS bundle, defeating the checksum trust chain because the
-* attacker controls the unsigned transport that supplied the checksum.
-*/
-function validateAggregatorUrl(aggregatorUrl) {
-	let parsed;
-	try {
-		parsed = new URL(aggregatorUrl);
-	} catch {
-		throw new Error(`registry.aggregatorUrl is not a valid URL: ${aggregatorUrl}`);
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`registry.aggregatorUrl must use http or https: ${aggregatorUrl}`);
-	if (parsed.username || parsed.password) throw new Error("registry.aggregatorUrl must not contain embedded credentials (user:pass@)");
-	const rawHostname = parsed.hostname.toLowerCase().replace(TRAILING_DOT, "");
-	const hostname = rawHostname.startsWith("[") && rawHostname.endsWith("]") ? rawHostname.slice(1, -1) : rawHostname;
-	const isLocalhost = hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname === "::1" || hostname.startsWith("::ffff:127.") || hostname.startsWith("::ffff:7f00:");
-	if (!import.meta.env.DEV) {
-		if (parsed.protocol === "http:") throw new Error(`registry.aggregatorUrl must use https in production: ${aggregatorUrl}`);
-		if (isLocalhost) throw new Error(`registry.aggregatorUrl points at localhost; allowed only in dev: ${aggregatorUrl}`);
-	} else if (parsed.protocol === "http:" && !isLocalhost) throw new Error(`registry.aggregatorUrl must use https (http allowed only for localhost in dev): ${aggregatorUrl}`);
-	return parsed;
-}
-/**
-* Expand the `RegistryConfigInput` shorthand into the full
-* `RegistryConfig` object shape.
-*
-* Users can pass a bare aggregator URL string for the common case
-* (`experimental.registry: "https://registry.emdashcms.com"`); the
-* normalizer handles either form transparently.
-*
-* Returns `undefined` for `undefined` input so callers can chain with
-* optional chaining.
-*/
-function coerceRegistryConfig(input) {
-	if (input === void 0) return void 0;
-	if (typeof input === "string") return { aggregatorUrl: input };
-	return input;
-}
-/**
-* Normalize the user-supplied `RegistryConfigInput` into the shape that
-* ships to the admin browser via the manifest endpoint.
-*
-* Accepts either the shorthand string form
-* (`"https://registry.emdashcms.com"`) or the full `RegistryConfig`
-* object. Returns `null` when `input` is undefined so callers can
-* spread the result directly into the manifest object.
-*
-* Throws if the aggregator URL is malformed, points at a forbidden host,
-* or `policy.minimumReleaseAge` is unparseable. These surface at
-* runtime startup as 500s from the manifest endpoint -- intended,
-* because the alternative is silently disabling the registry on
-* misconfigured sites.
-*
-* TODO: switch to a Zod schema for richer per-field error messages and
-* to surface misconfigurations to the admin UI as a banner instead of
-* a manifest 500.
-*/
-function normalizeRegistryConfig(input) {
-	const config = coerceRegistryConfig(input);
-	if (!config) return null;
-	const aggregatorUrl = config.aggregatorUrl?.trim();
-	if (!aggregatorUrl) throw new Error("registry.aggregatorUrl is required when registry is configured");
-	validateAggregatorUrl(aggregatorUrl);
-	const out = { aggregatorUrl: aggregatorUrl.replace(TRAILING_SLASHES, "") };
-	if (config.acceptLabelers) out.acceptLabelers = config.acceptLabelers;
-	const policy = {};
-	let hasPolicy = false;
-	if (config.policy?.minimumReleaseAge !== void 0) {
-		policy.minimumReleaseAgeSeconds = parseDurationSeconds(config.policy.minimumReleaseAge);
-		hasPolicy = true;
-	}
-	if (config.policy?.minimumReleaseAgeExclude !== void 0) {
-		const list = config.policy.minimumReleaseAgeExclude.map((entry) => {
-			const trimmed = entry.trim();
-			if (!trimmed) throw new Error("registry.policy.minimumReleaseAgeExclude entries cannot be empty");
-			const lower = trimmed.toLowerCase();
-			const [did, slug, ...extra] = lower.split("/");
-			if (!did || !isDid(did) || extra.length > 0 || slug !== void 0 && !REGISTRY_PACKAGE_SLUG_PATTERN.test(slug)) throw new Error(`registry.policy.minimumReleaseAgeExclude entry must be a DID or <did>/<slug>: ${trimmed}`);
-			return lower;
-		});
-		if (list.length > 0) {
-			policy.minimumReleaseAgeExclude = list;
-			hasPolicy = true;
-		}
-	}
-	if (hasPolicy) out.policy = policy;
-	return out;
-}
-
-//#endregion
-//#region src/registry/plugin-id.ts
-/**
-* Plugin identifier helpers for the experimental decentralized plugin
-* registry.
-*
-* Registry plugins are addressed by `(publisher_did, slug)`, but the
-* EmDash runtime threads a single `pluginId: string` through every
-* install primitive (R2 storage keys, `PluginStateRepository`,
-* `syncMarketplacePlugins`, sandbox cache keys). Rather than refactor
-* everything to carry a composite identifier, we normalize the registry
-* tuple to an opaque content-addressed id that satisfies the existing
-* `validatePluginIdentifier` shape (`/^[a-z][a-z0-9_-]*$/`).
-*
-* The normalized id is:
-*
-*   `r_` + base32-encoded SHA-256(publisher_did + "\n" + slug), truncated.
-*
-* Properties:
-*
-*   - Deterministic. The same `(publisher, slug)` always produces the
-*     same id, so re-resolving an installed plugin's metadata against
-*     the aggregator is a straightforward lookup keyed by the columns
-*     stored alongside `plugin_id` in `plugin_states`.
-*   - Collision-resistant. 80 bits of truncated hash; a 50% birthday
-*     collision happens around 2^40 distinct plugins, well beyond what
-*     this registry will ever index.
-*   - R2-safe. Lowercase alphanumerics + underscore (no hyphens), no
-*     `:` or `/`. Existing sandbox cache keys (`${pluginId}:${version}`)
-*     keep working because the id contains no `:`.
-*   - Syntactically distinct from typical marketplace plugin ids: the
-*     `r_` prefix plus exactly 16 base32 characters is unlikely to be
-*     chosen as a marketplace id. Not formally guaranteed by the
-*     validator -- marketplace ids may begin with `r_` and contain
-*     hyphens -- so the install handler also performs an explicit
-*     pre-existing-row check at the derived id and rejects any cross-
-*     source collision (`PLUGIN_ID_COLLISION`).
-*
-* Reverse lookup (id → publisher + slug) requires the `plugin_states`
-* row -- the hash is one-way. That's intentional: any code path that
-* needs the human-meaningful pair already has the state row in hand.
-*/
-/** Length (in base32 characters) of the truncated hash portion of the id. */
-const HASH_LENGTH = 16;
-/** Total expected length of a registry plugin id. */
-const REGISTRY_PLUGIN_ID_LENGTH = 2 + HASH_LENGTH;
-const BASE32_ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
-/**
-* RFC 4648 base32 encoding without padding, lowercase. Implemented inline
-* rather than depending on a multibase library because (a) we only need
-* lowercase base32 here, (b) we need it to run identically in workerd,
-* Node, and the browser, and (c) the implementation is fewer lines than
-* the import statement would be.
-*/
-function base32Encode(bytes) {
-	let bits = 0;
-	let value = 0;
-	let out = "";
-	for (const byte of bytes) {
-		value = value << 8 | byte;
-		bits += 8;
-		while (bits >= 5) {
-			bits -= 5;
-			out += BASE32_ALPHABET[value >>> bits & 31];
-		}
-	}
-	if (bits > 0) out += BASE32_ALPHABET[value << 5 - bits & 31];
-	return out;
-}
-/**
-* Derive the normalized plugin id for a registry-published plugin.
-*
-* Throws if either input is empty or whitespace-only -- a missing DID
-* or slug is always a programming error in the install path, not a
-* recoverable runtime condition.
-*/
-async function makeRegistryPluginId(publisherDid, slug) {
-	const did = publisherDid.trim();
-	const s = slug.trim();
-	if (!did) throw new Error("makeRegistryPluginId: publisherDid is required");
-	if (!s) throw new Error("makeRegistryPluginId: slug is required");
-	const input = `${did}\n${s}`;
-	const hashBuffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
-	return `r_${base32Encode(new Uint8Array(hashBuffer)).slice(0, HASH_LENGTH)}`;
-}
-
-//#endregion
-//#region src/api/handlers/registry.ts
-/**
-* Registry plugin install handler.
-*
-* Installs a plugin published to the experimental decentralized plugin
-* registry described in RFC 0001. The install flow:
-*
-*   1. Resolve `(handle, slug)` to a publisher DID via the configured
-*      aggregator's `resolvePackage` XRPC.
-*   2. Look up the requested release (or the policy-filtered latest one)
-*      via `getLatestRelease` / `listReleases`.
-*   3. Require the aggregator's approved listing projection, then apply the
-*      independent release-age and environment policies.
-*   4. Fetch the bundle artifact through an advertised record-scoped cache,
-*      the publisher PDS, or the publisher-declared URL.
-*   5. Verify the artifact's multibase checksum against the signed
-*      release record's `artifacts.package.checksum`.
-*   6. Extract `manifest.json` + `backend.js` + optional `admin.js` from
-*      the gzipped tar bundle.
-*   7. Store the extracted files in site-local R2 under the
-*      `registry/<plugin-id>/<version>/` prefix.
-*   8. Write a `plugin_states` row with `source = "registry"` and the
-*      `(publisher_did, slug)` pair so updates can be resolved later.
-*   9. Sync the runtime so the plugin becomes active immediately.
-*
-* Known gaps (tracked separately):
-*
-*   - The aggregator-supplied records are not yet cryptographically
-*     verified against the publisher's MST signature. The signed bytes
-*     and CIDs are passed through verbatim per the lexicon, but full
-*     PDS-direct verification with proof traversal is follow-up work.
-*     The artifact checksum is verified end-to-end against the value
-*     in the (aggregator-relayed) release record, which is the actual
-*     trust boundary for the bytes that end up in the sandbox.
-*   - Listing approval controls whether metadata is eligible for discovery.
-*     It is never treated as approval of plugin code: checksum, bundle,
-*     manifest, access, consent, sandbox, and environment gates remain
-*     independent below.
-*/
-const RELEASE_EXTENSION_NSID = "com.emdashcms.experimental.package.releaseExtension";
-/**
-* Whether two `declaredAccess` blocks grant exactly the same enforced access --
-* the same capabilities AND the same host allow-list. Both are lowered through
-* the canonical converter so that constraint content (`allowedHosts`), not just
-* the capability set, is part of the comparison. The capability-set consent
-* gate is blind to host scope; this is what keeps a bundle from being installed
-* with a wider (or simply different) host allow-list than its published record
-* advertised and the user consented to.
-*/
-function enforcedAccessEqual(a, b) {
-	const aa = declaredAccessToCapabilities(a);
-	const bb = declaredAccessToCapabilities(b);
-	return JSON.stringify(aa.capabilities.toSorted()) === JSON.stringify(bb.capabilities.toSorted()) && JSON.stringify(aa.allowedHosts.toSorted()) === JSON.stringify(bb.allowedHosts.toSorted());
-}
-/** Matches a bare 64-character lowercase/uppercase hex SHA-256 digest. */
-const SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/i;
-/** Compute the SHA-256 of `bytes` as a lowercase hex string. */
-async function sha256Hex(bytes) {
-	const buf = await crypto.subtle.digest("SHA-256", bytes);
-	const arr = new Uint8Array(buf);
-	return Array.from(arr, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-/** multihash code for sha2-256 (single-byte varint). */
-const MULTIHASH_SHA256_CODE = 18;
-/** sha2-256 digest length in bytes (single-byte varint). */
-const MULTIHASH_SHA256_LENGTH = 32;
-/**
-* Compute the multibase-multihash sha2-256 checksum of `bytes`, in the
-* same `b<base32>` shape the registry CLI publishes
-* (`packages/plugin-cli/src/multihash.ts`). Returns a 56-character
-* string starting with `b`.
-*
-* The trust contract is: if both sides produce the same string for
-* the same bytes, the bytes are unchanged. We don't decode the
-* publisher-supplied checksum -- we just re-encode our own and compare,
-* which is equivalent and avoids needing a base32 decoder.
-*/
-async function sha256MultibaseMultihash(bytes) {
-	const digestBuf = await crypto.subtle.digest("SHA-256", bytes);
-	const digest = new Uint8Array(digestBuf);
-	const multihash = new Uint8Array(2 + digest.length);
-	multihash[0] = MULTIHASH_SHA256_CODE;
-	multihash[1] = MULTIHASH_SHA256_LENGTH;
-	multihash.set(digest, 2);
-	const { toBase32 } = await import("@atcute/multibase");
-	return `b${toBase32(multihash)}`;
-}
-/**
-* Verify that a checksum string from a release record's
-* `artifact.checksum` field corresponds to the SHA-256 of the given
-* bytes.
-*
-* Accepts two formats:
-*
-*   - Bare lowercase/uppercase hex SHA-256 (64 chars). Convenience for
-*     publishers / tools that emit hex rather than multibase.
-*   - Multibase-multihash with the `b` (base32) prefix and sha2-256.
-*     This is the format RFC 0001 mandates and the registry CLI emits
-*     (see `packages/plugin-cli/src/multihash.ts`).
-*
-* Hash functions other than sha2-256 are out of scope for this
-* initial release; the install fails closed.
-*/
-async function verifyChecksum(bytes, checksum) {
-	if (SHA256_HEX_PATTERN.test(checksum)) {
-		const actual = await sha256Hex(bytes);
-		return checksum.toLowerCase() === actual;
-	}
-	if (checksum.length === 56 && checksum.startsWith("b")) return (await sha256MultibaseMultihash(bytes)).toLowerCase() === checksum.toLowerCase();
-	return false;
-}
-/**
-* Bytes-per-artifact cap on the gzipped tarball we'll download before
-* decompression. RFC 0001 caps a sandboxed plugin bundle at 256 KiB
-* decompressed (see `MAX_BUNDLE_SIZE` in cli/commands/bundle-utils.ts);
-* gzip on a mix of JSON manifest + JS code typically gives 0.3-0.6
-* ratio, so compressed bundles are well under 200 KiB in practice.
-* 512 KiB leaves margin for unusual file mixes that compress poorly
-* while still rejecting anything that's obviously not a legitimate
-* plugin bundle.
-*/
-const MAX_ARTIFACT_BYTES = 512 * 1024;
-/**
-* Maximum number of HTTP redirects followed during artifact download.
-* Each hop is independently URL-validated, so a malicious server cannot
-* redirect through a series of allowed-looking origins to reach a
-* forbidden one.
-*/
-const MAX_REDIRECTS = 5;
-/**
-* Wall-clock cap on any single artifact fetch attempt (per URL).
-* Defends against slow-loris artifact sources that accept the connection but
-* never finish sending headers or body.
-*/
-const ARTIFACT_FETCH_TIMEOUT_MS = 15e3;
-/**
-* Total wall-clock budget for the artifact-download phase across all
-* advertised caches, the publisher PDS, and the declared URL. Even with the
-* per-URL timeout, unavailable sources could otherwise tie up the install request for
-* minutes; this caps total time at a budget interactive admins can
-* tolerate. Tuned so a fast happy path takes <1s of budget per
-* attempt and a worst case still completes in under a minute.
-*/
-const ARTIFACT_TOTAL_BUDGET_MS = 45e3;
-/**
-* Per-request timeout applied to every aggregator XRPC call
-* (`resolvePackage`, `getLatestRelease`, `listReleases`). Matches the
-* per-URL artifact-fetch cap. Without this, a slow-loris aggregator
-* can stall the install before the artifact phase even starts.
-*/
-const AGGREGATOR_REQUEST_TIMEOUT_MS = 15e3;
-/**
-* Total wall-clock budget for the aggregator-discovery phase
-* (resolve + selected-release lookup). Mirrors the artifact-download
-* budget. Worst case with the pinned-version path's 20-page cap is
-* 20 + 1 calls; capping the total ensures any one stalled call
-* still bounds the whole phase.
-*/
-const AGGREGATOR_TOTAL_BUDGET_MS = 3e4;
-/** Build a fetch function that enforces a per-request and per-budget timeout. */
-function timedFetch(totalDeadline) {
-	return (input, init) => {
-		const now = Date.now();
-		const remaining = Math.max(0, totalDeadline - now);
-		if (remaining === 0) return Promise.reject(/* @__PURE__ */ new Error("Aggregator request budget exhausted"));
-		const timeout = Math.min(AGGREGATOR_REQUEST_TIMEOUT_MS, remaining);
-		const controller = new AbortController();
-		const timer = setTimeout(() => controller.abort(), timeout);
-		const callerSignal = init?.signal;
-		if (callerSignal) if (callerSignal.aborted) controller.abort(callerSignal.reason);
-		else callerSignal.addEventListener("abort", () => controller.abort(callerSignal.reason));
-		return fetch(input, {
-			...init,
-			signal: controller.signal
-		}).finally(() => {
-			clearTimeout(timer);
-		});
-	};
-}
-async function fetchArtifact(artifactCaches, artifact, record, auth) {
-	const result = await fetchReleaseArtifact({
-		artifact,
-		record,
-		artifactCaches,
-		...auth === void 0 ? {} : { auth }
-	}, {
-		fetch: async (url, init) => {
-			if (!init.signal) throw new Error("Registry artifact fetch requires an abort signal");
-			return fetchRegistryArtifactUrl(url.href, {
-				signal: init.signal,
-				maxResponseBytes: MAX_ARTIFACT_BYTES
-			});
-		},
-		resolveHostname: async (hostname) => (await resolveAndValidateExternalUrlTarget(`https://${hostname}`)).addresses,
-		allowHttpLocalhost: import.meta.env.DEV,
-		headerTimeoutMs: ARTIFACT_FETCH_TIMEOUT_MS,
-		totalTimeoutMs: ARTIFACT_TOTAL_BUDGET_MS,
-		maxBytes: MAX_ARTIFACT_BYTES,
-		maxRedirects: MAX_REDIRECTS
-	});
-	if (!result.success) throw new Error(`Artifact retrieval failed (${result.error.code}): ${result.error.message}`);
-	return result.value.bytes;
-}
-/**
-* Gate a release's `requires` constraints against the running host
-* environment. `requires` is the lexicon-`unknown` value off the signed
-* release record — never trust its shape; `checkEnvCompatibility` guards it.
-*
-* Returns `null` when every advertised constraint is satisfied (or there are
-* none), or a structured `ENV_INCOMPATIBLE` error naming the unsatisfied
-* constraints and the host versions. The error carries the guarded `requires`
-* and `host` maps so the admin can render the same mismatch the UI gate shows.
-*/
-function assertEnvCompatible(requires, hostEnv) {
-	for (const skipped of findSkippedEnvConstraints(requires, hostEnv)) console.warn(`[registry] env compatibility constraint skipped: ${skipped.key} requires ${skipped.required} but host version is ${skipped.reason}`);
-	const mismatches = checkEnvCompatibility(requires, hostEnv);
-	if (mismatches.length === 0) return null;
-	const guarded = {};
-	for (const m of mismatches) guarded[m.key] = m.required;
-	return {
-		code: "ENV_INCOMPATIBLE",
-		message: `This release is not compatible with the current environment: ${mismatches.map((m) => `${m.key} requires ${m.required} but host is ${m.host}`).join("; ")}.`,
-		details: {
-			requires: guarded,
-			host: hostEnv
-		}
-	};
-}
-async function handleRegistryInstall(db, storage, sandboxRunner, registryConfigInput, input, opts) {
-	const registryConfig = coerceRegistryConfig(registryConfigInput);
-	if (!registryConfig) return {
-		success: false,
-		error: {
-			code: "REGISTRY_NOT_CONFIGURED",
-			message: "Registry is not configured"
-		}
-	};
-	if (!storage) return {
-		success: false,
-		error: {
-			code: "STORAGE_NOT_CONFIGURED",
-			message: "Storage is required for registry plugin installation"
-		}
-	};
-	if (!sandboxRunner || !sandboxRunner.isAvailable()) return {
-		success: false,
-		error: {
-			code: "SANDBOX_NOT_AVAILABLE",
-			message: "Sandbox runner is required for registry plugins"
-		}
-	};
-	try {
-		validateAggregatorUrl(registryConfig.aggregatorUrl);
-	} catch (err) {
-		return {
-			success: false,
-			error: {
-				code: "REGISTRY_NOT_CONFIGURED",
-				message: err instanceof Error ? err.message : "Invalid aggregator URL"
-			}
-		};
-	}
-	const { did, slug, version: requestedVersion } = input;
-	const { DiscoveryClient, registryLabelerPolicy } = await import("@emdash-cms/registry-client/discovery");
-	const aggregatorDeadline = Date.now() + AGGREGATOR_TOTAL_BUDGET_MS;
-	const discovery = new DiscoveryClient({
-		aggregatorUrl: registryConfig.aggregatorUrl,
-		acceptLabelers: registryConfig.acceptLabelers,
-		labelerPolicy: registryLabelerPolicy(registryConfig.acceptLabelers),
-		fetch: timedFetch(aggregatorDeadline)
-	});
-	if (!did.startsWith("did:") || did.split(":").length < 3) return {
-		success: false,
-		error: {
-			code: "INVALID_DID",
-			message: "DID must be a valid atproto DID (e.g. did:plc:abc123)"
-		}
-	};
-	try {
-		const publisherDid = did;
-		const packageView = await discovery.getPackage({
-			did: publisherDid,
-			slug
-		});
-		const MAX_LIST_PAGES = 20;
-		const releaseView = await (async () => {
-			if (!requestedVersion) return discovery.getLatestRelease({
-				did: publisherDid,
-				package: slug
-			});
-			let cursor;
-			const seenCursors = /* @__PURE__ */ new Set();
-			for (let page = 0; page < MAX_LIST_PAGES; page++) {
-				if (cursor !== void 0) {
-					if (seenCursors.has(cursor)) break;
-					seenCursors.add(cursor);
-				}
-				const result = await discovery.listReleases({
-					did: publisherDid,
-					package: slug,
-					cursor,
-					limit: 50
-				});
-				for (const r of result.releases) if (r.version === requestedVersion) return r;
-				if (!result.cursor) break;
-				cursor = result.cursor;
-			}
-		})();
-		if (!releaseView) return {
-			success: false,
-			error: {
-				code: "NO_RELEASE",
-				message: requestedVersion ? `Version ${requestedVersion} not found for ${publisherDid}/${slug}` : `No installable release found for ${publisherDid}/${slug}`
-			}
-		};
-		const signedRelease = releaseView.release;
-		if (packageView.did !== publisherDid || packageView.slug !== slug) return {
-			success: false,
-			error: {
-				code: "AGGREGATOR_IDENTITY_MISMATCH",
-				message: "Aggregator returned a package view for a different publisher or slug."
-			}
-		};
-		if (releaseView.did !== publisherDid || releaseView.package !== slug || signedRelease?.package !== slug || requestedVersion !== void 0 && releaseView.version !== requestedVersion || signedRelease?.version !== releaseView.version) return {
-			success: false,
-			error: {
-				code: "AGGREGATOR_IDENTITY_MISMATCH",
-				message: "Aggregator returned a release view that does not match the requested package or version."
-			}
-		};
-		const version = releaseView.version;
-		if (evaluateRegistryReleaseWithdrawal(releaseView, discovery.labelerPolicy).withdrawn) return {
-			success: false,
-			error: {
-				code: "RELEASE_YANKED",
-				message: "This release has been withdrawn"
-			}
-		};
-		if (opts?.hostEnv) {
-			const envError = assertEnvCompatible(releaseView.release?.requires, opts.hostEnv);
-			if (envError) return {
-				success: false,
-				error: envError
-			};
-		}
-		const minimumReleaseAge = registryConfig.policy?.minimumReleaseAge;
-		let minimumReleaseAgeSeconds = 0;
-		if (minimumReleaseAge !== void 0) try {
-			minimumReleaseAgeSeconds = parseDurationSeconds(minimumReleaseAge);
-		} catch (err) {
-			return {
-				success: false,
-				error: {
-					code: "REGISTRY_POLICY_INVALID",
-					message: err instanceof Error ? err.message : "Invalid minimumReleaseAge value in registry config"
-				}
-			};
-		}
-		if (minimumReleaseAgeSeconds > 0) {
-			const exclude = registryConfig.policy?.minimumReleaseAgeExclude?.map((e) => e.trim().toLowerCase());
-			if (!releaseExemptFromMinimumAge(exclude, publisherDid, slug)) {
-				const indexedAt = Date.parse(releaseView.indexedAt);
-				if (!Number.isFinite(indexedAt)) return {
-					success: false,
-					error: {
-						code: "RELEASE_TIMESTAMP_INVALID",
-						message: "Release record is missing a valid indexed-at timestamp; cannot evaluate minimum release age policy."
-					}
-				};
-				const ageSeconds = (Date.now() - indexedAt) / 1e3;
-				if (ageSeconds < minimumReleaseAgeSeconds) {
-					const remaining = Math.ceil(minimumReleaseAgeSeconds - ageSeconds);
-					return {
-						success: false,
-						error: {
-							code: "RELEASE_TOO_NEW",
-							message: `This release does not meet the configured minimum release age of ${minimumReleaseAgeSeconds}s. It will be installable in ~${remaining}s.`
-						}
-					};
-				}
-			}
-		}
-		const pluginId = await makeRegistryPluginId(publisherDid, slug);
-		if (opts?.configuredPluginIds?.has(pluginId)) return {
-			success: false,
-			error: {
-				code: "PLUGIN_ID_CONFLICT",
-				message: "A configured plugin with the same derived id already exists"
-			}
-		};
-		const stateRepo = new PluginStateRepository(db);
-		const existing = await stateRepo.get(pluginId);
-		if (existing) {
-			if (existing.source === "registry") return {
-				success: false,
-				error: {
-					code: "ALREADY_INSTALLED",
-					message: `Plugin ${publisherDid}/${slug} is already installed`
-				}
-			};
-			return {
-				success: false,
-				error: {
-					code: "PLUGIN_ID_COLLISION",
-					message: `A non-registry plugin already exists at the derived id ${pluginId}. Uninstall it before installing this registry plugin.`
-				}
-			};
-		}
-		const release = releaseView.release;
-		const packageArtifact = release?.artifacts?.package;
-		const declaredChecksum = packageArtifact?.checksum;
-		if (!packageArtifact || !declaredChecksum) return {
-			success: false,
-			error: {
-				code: "INVALID_RELEASE",
-				message: "Release record is missing its package artifact or checksum"
-			}
-		};
-		const artifactBytes = await fetchArtifact(releaseView.artifactCaches ?? [], packageArtifact, {
-			did: publisherDid,
-			collection: NSID.packageRelease,
-			rkey: `${slug}:${version}`,
-			cid: releaseView.cid
-		}, release.auth);
-		if (!await verifyChecksum(artifactBytes, declaredChecksum)) return {
-			success: false,
-			error: {
-				code: "CHECKSUM_MISMATCH",
-				message: "Artifact bytes do not match the release record's checksum, or the checksum encoding is unsupported."
-			}
-		};
-		let bundle;
-		try {
-			bundle = await extractBundle(artifactBytes);
-		} catch (err) {
-			return {
-				success: false,
-				error: {
-					code: "INVALID_BUNDLE",
-					message: err instanceof Error ? err.message : "Failed to extract plugin bundle"
-				}
-			};
-		}
-		if (bundle.manifest.version !== version) return {
-			success: false,
-			error: {
-				code: "MANIFEST_VERSION_MISMATCH",
-				message: `Bundle manifest version (${bundle.manifest.version}) does not match release version (${version})`
-			}
-		};
-		if (bundle.manifest.id !== slug) return {
-			success: false,
-			error: {
-				code: "MANIFEST_ID_MISMATCH",
-				message: `Bundle manifest id (${bundle.manifest.id}) does not match registry slug (${slug})`
-			}
-		};
-		bundle.manifest = {
-			...bundle.manifest,
-			id: pluginId
-		};
-		const recordExt = (release?.extensions)?.[RELEASE_EXTENSION_NSID];
-		if (!enforcedAccessEqual(recordExt?.declaredAccess ?? {}, bundle.manifest.declaredAccess ?? {})) return {
-			success: false,
-			error: {
-				code: "DECLARED_ACCESS_DRIFT",
-				message: "The plugin bundle declares different permissions than its published record. Installation refused."
-			}
-		};
-		const actualCapabilities = canonicalCapabilitiesForDriftCheck(bundle.manifest.capabilities);
-		if (actualCapabilities.length > 0) {
-			if (input.acknowledgedDeclaredAccess === void 0) return {
-				success: false,
-				error: {
-					code: "DECLARED_ACCESS_REQUIRED",
-					message: "This plugin declares capabilities that require consent. Re-open the install dialog to review and acknowledge them."
-				}
-			};
-			const acknowledged = canonicalCapabilitiesForDriftCheck(input.acknowledgedDeclaredAccess);
-			if (acknowledged.length !== actualCapabilities.length || acknowledged.some((cap, i) => cap !== actualCapabilities[i])) return {
-				success: false,
-				error: {
-					code: "DECLARED_ACCESS_DRIFT",
-					message: "Plugin manifest has changed since you consented. Re-open the install dialog to review the new permissions."
-				}
-			};
-		}
-		const actualMcpTools = (bundle.manifest.mcp?.tools ?? []).map(({ inputSchema: _, outputSchema: __, ...tool }) => tool);
-		if (actualMcpTools.length > 0) {
-			if (JSON.stringify(input.acknowledgedMcpTools) !== JSON.stringify(actualMcpTools)) return {
-				success: false,
-				error: {
-					code: "MCP_TOOL_CONSENT_REQUIRED",
-					message: "Plugin MCP tools require explicit consent",
-					details: { mcpTools: actualMcpTools }
-				}
-			};
-		}
-		await storeBundleInR2(storage, pluginId, version, bundle, "registry");
-		const profile = packageView.profile;
-		try {
-			await stateRepo.upsert(pluginId, version, "active", {
-				source: "registry",
-				displayName: profile?.name ?? slug,
-				description: profile?.description ?? void 0,
-				registryPublisherDid: publisherDid,
-				registrySlug: slug
-			});
-		} catch (stateErr) {
-			let lostRace = false;
-			try {
-				const winner = await stateRepo.get(pluginId);
-				lostRace = winner !== void 0 && winner !== null;
-			} catch (probeErr) {
-				console.warn(`[registry-install] Failed to probe state row for ${pluginId} after state-write failure; treating as orphan:`, probeErr);
-			}
-			if (!lostRace) try {
-				await deleteBundleFromR2(storage, pluginId, version, "registry");
-			} catch (cleanupErr) {
-				console.warn(`[registry-install] Failed to clean up R2 bundle for ${pluginId}@${version} after state-row write failure:`, cleanupErr);
-			}
-			throw stateErr;
-		}
-		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
-		return {
-			success: true,
-			data: {
-				pluginId,
-				publisherDid,
-				slug,
-				version,
-				capabilities: bundle.manifest.capabilities
-			}
-		};
-	} catch (err) {
-		if (err instanceof ClientValidationError) return {
-			success: false,
-			error: {
-				code: "AGGREGATOR_RESPONSE_INVALID",
-				message: `Aggregator returned a response that does not conform to its lexicon (${err.target})`
-			}
-		};
-		if (err instanceof ClientResponseError) {
-			if (err.error === "ListingUnavailable") return {
-				success: false,
-				error: {
-					code: "LISTING_UNAVAILABLE",
-					message: "This plugin is unavailable under the active registry policy"
-				}
-			};
-			return {
-				success: false,
-				error: {
-					code: err.status === 404 ? "AGGREGATOR_NOT_FOUND" : "AGGREGATOR_HTTP_ERROR",
-					message: `Aggregator returned ${err.status}: ${err.error}`
-				}
-			};
-		}
-		if (err instanceof EmDashStorageError) return {
-			success: false,
-			error: {
-				code: err.code ?? "STORAGE_ERROR",
-				message: "Storage error while installing plugin"
-			}
-		};
-		console.error("[registry-install] Failed:", err);
-		return {
-			success: false,
-			error: {
-				code: "INSTALL_FAILED",
-				message: err instanceof Error ? err.message : "Failed to install plugin from registry"
-			}
-		};
-	}
-}
-/**
-* Uninstall a registry-source plugin. Deletes the R2 bundle under
-* `registry/<pluginId>/<version>/`, optionally drops the plugin's
-* `_plugin_storage` rows, and removes the `_plugin_state` row. The
-* sandbox runtime is reconciled by the route's `syncRegistryPlugins`
-* call after this returns.
-*
-* Refuses to uninstall plugins whose `source` is not `"registry"` to
-* avoid trashing a marketplace/config plugin that happens to share the
-* pluginId namespace.
-*/
-async function handleRegistryUninstall(db, storage, pluginId, opts) {
-	try {
-		const stateRepo = new PluginStateRepository(db);
-		const existing = await stateRepo.get(pluginId);
-		if (!existing || existing.source !== "registry") return {
-			success: false,
-			error: {
-				code: "NOT_FOUND",
-				message: `No registry plugin found: ${pluginId}`
-			}
-		};
-		const version = existing.version;
-		let dataDeleted = false;
-		if (opts?.deleteData) {
-			await db.deleteFrom("_plugin_storage").where("plugin_id", "=", pluginId).execute();
-			dataDeleted = true;
-		}
-		if (storage) await deleteBundleFromR2(storage, pluginId, version, "registry");
-		try {
-			await removeAllPluginIndexes(db, pluginId);
-		} catch {}
-		await stateRepo.delete(pluginId);
-		return {
-			success: true,
-			data: {
-				pluginId,
-				dataDeleted
-			}
-		};
-	} catch (err) {
-		console.error("[registry-uninstall] Failed:", err);
-		return {
-			success: false,
-			error: {
-				code: "UNINSTALL_FAILED",
-				message: "Failed to uninstall plugin"
-			}
-		};
-	}
-}
-/**
-* Update a registry-source plugin to a newer release. Mirrors
-* `handleMarketplaceUpdate`: resolves the target version via the aggregator,
-* re-runs the artifact fetch / checksum / extract pipeline, diffs capabilities
-* and route visibility against the currently installed bundle, and gates
-* escalations behind `confirmCapabilityChanges` / `confirmRouteVisibilityChanges`
-* so the admin re-consents to widened permissions.
-*
-* Refuses non-registry sources. Refuses when the stored state row is missing
-* the `(publisherDid, slug)` it needs to resolve against the aggregator.
-*/
-async function handleRegistryUpdate(db, storage, sandboxRunner, registryConfigInput, pluginId, opts) {
-	const registryConfig = coerceRegistryConfig(registryConfigInput);
-	if (!registryConfig) return {
-		success: false,
-		error: {
-			code: "REGISTRY_NOT_CONFIGURED",
-			message: "Registry is not configured"
-		}
-	};
-	if (!storage) return {
-		success: false,
-		error: {
-			code: "STORAGE_NOT_CONFIGURED",
-			message: "Storage is required for registry plugin updates"
-		}
-	};
-	if (!sandboxRunner || !sandboxRunner.isAvailable()) return {
-		success: false,
-		error: {
-			code: "SANDBOX_NOT_AVAILABLE",
-			message: "Sandbox runner is required"
-		}
-	};
-	try {
-		validateAggregatorUrl(registryConfig.aggregatorUrl);
-	} catch (err) {
-		return {
-			success: false,
-			error: {
-				code: "REGISTRY_NOT_CONFIGURED",
-				message: err instanceof Error ? err.message : "Invalid aggregator URL"
-			}
-		};
-	}
-	try {
-		const stateRepo = new PluginStateRepository(db);
-		const existing = await stateRepo.get(pluginId);
-		if (!existing || existing.source !== "registry") return {
-			success: false,
-			error: {
-				code: "NOT_FOUND",
-				message: `No registry plugin found: ${pluginId}`
-			}
-		};
-		if (!existing.registryPublisherDid || !existing.registrySlug) return {
-			success: false,
-			error: {
-				code: "INVALID_STATE",
-				message: `Registry plugin ${pluginId} is missing publisher DID or slug in state`
-			}
-		};
-		const oldVersion = existing.version;
-		const publisherDid = existing.registryPublisherDid;
-		const slug = existing.registrySlug;
-		const { DiscoveryClient, registryLabelerPolicy } = await import("@emdash-cms/registry-client/discovery");
-		const aggregatorDeadline = Date.now() + AGGREGATOR_TOTAL_BUDGET_MS;
-		const discovery = new DiscoveryClient({
-			aggregatorUrl: registryConfig.aggregatorUrl,
-			acceptLabelers: registryConfig.acceptLabelers,
-			labelerPolicy: registryLabelerPolicy(registryConfig.acceptLabelers),
-			fetch: timedFetch(aggregatorDeadline)
-		});
-		const MAX_LIST_PAGES = 20;
-		const releaseView = await (async () => {
-			if (!opts?.version) return discovery.getLatestRelease({
-				did: publisherDid,
-				package: slug
-			});
-			let cursor;
-			const seenCursors = /* @__PURE__ */ new Set();
-			for (let page = 0; page < MAX_LIST_PAGES; page++) {
-				if (cursor !== void 0) {
-					if (seenCursors.has(cursor)) break;
-					seenCursors.add(cursor);
-				}
-				const result = await discovery.listReleases({
-					did: publisherDid,
-					package: slug,
-					cursor,
-					limit: 50
-				});
-				for (const r of result.releases) if (r.version === opts.version) return r;
-				if (!result.cursor) break;
-				cursor = result.cursor;
-			}
-		})();
-		if (!releaseView) return {
-			success: false,
-			error: {
-				code: "NO_VERSION",
-				message: opts?.version ? `Version ${opts.version} not found for ${publisherDid}/${slug}` : `No installable release found for ${publisherDid}/${slug}`
-			}
-		};
-		const signedRelease = releaseView.release;
-		if (releaseView.did !== publisherDid || releaseView.package !== slug || signedRelease?.package !== slug || opts?.version !== void 0 && releaseView.version !== opts.version || signedRelease?.version !== releaseView.version) return {
-			success: false,
-			error: {
-				code: "AGGREGATOR_IDENTITY_MISMATCH",
-				message: "Aggregator returned a release view that does not match the requested package or version."
-			}
-		};
-		const newVersion = releaseView.version;
-		if (evaluateRegistryReleaseWithdrawal(releaseView, discovery.labelerPolicy).withdrawn) return {
-			success: false,
-			error: {
-				code: "YANKED",
-				message: "Release has been withdrawn"
-			}
-		};
-		if (newVersion === oldVersion) return {
-			success: false,
-			error: {
-				code: "ALREADY_UP_TO_DATE",
-				message: "Plugin is already at the requested version"
-			}
-		};
-		if (opts?.hostEnv) {
-			const envError = assertEnvCompatible(signedRelease.requires, opts.hostEnv);
-			if (envError) return {
-				success: false,
-				error: envError
-			};
-		}
-		const packageArtifact = signedRelease.artifacts?.package;
-		const declaredChecksum = packageArtifact?.checksum;
-		if (!packageArtifact || !declaredChecksum) return {
-			success: false,
-			error: {
-				code: "INVALID_RELEASE",
-				message: "Release record is missing its package artifact or checksum"
-			}
-		};
-		const artifactBytes = await fetchArtifact(releaseView.artifactCaches ?? [], packageArtifact, {
-			did: publisherDid,
-			collection: NSID.packageRelease,
-			rkey: `${slug}:${newVersion}`,
-			cid: releaseView.cid
-		}, signedRelease.auth);
-		if (!await verifyChecksum(artifactBytes, declaredChecksum)) return {
-			success: false,
-			error: {
-				code: "CHECKSUM_MISMATCH",
-				message: "Artifact bytes do not match the release's published checksum"
-			}
-		};
-		const bundle = await extractBundle(artifactBytes);
-		if (bundle.manifest.version !== newVersion) return {
-			success: false,
-			error: {
-				code: "BUNDLE_VERSION_MISMATCH",
-				message: `Bundle manifest version (${bundle.manifest.version}) does not match release version (${newVersion})`
-			}
-		};
-		if (bundle.manifest.id !== slug) return {
-			success: false,
-			error: {
-				code: "BUNDLE_IDENTITY_MISMATCH",
-				message: `Bundle manifest id (${bundle.manifest.id}) does not match registry slug (${slug})`
-			}
-		};
-		bundle.manifest = {
-			...bundle.manifest,
-			id: pluginId
-		};
-		const recordExt = (signedRelease?.extensions)?.[RELEASE_EXTENSION_NSID];
-		if (!enforcedAccessEqual(recordExt?.declaredAccess ?? {}, bundle.manifest.declaredAccess ?? {})) return {
-			success: false,
-			error: {
-				code: "DECLARED_ACCESS_DRIFT",
-				message: "The plugin bundle declares different permissions than its published record. Update refused."
-			}
-		};
-		const oldBundle = await loadBundleFromR2(storage, pluginId, oldVersion, "registry");
-		const capabilityChanges = diffCapabilities(oldBundle?.manifest.capabilities ?? [], bundle.manifest.capabilities);
-		if (capabilityChanges.added.length > 0 && !opts?.confirmCapabilityChanges) return {
-			success: false,
-			error: {
-				code: "CAPABILITY_ESCALATION",
-				message: "Plugin update requires new capabilities",
-				details: { capabilityChanges }
-			}
-		};
-		const routeVisibilityChanges = diffRouteVisibility(oldBundle?.manifest, bundle.manifest);
-		const hasNewPublicRoutes = routeVisibilityChanges.newlyPublic.length > 0;
-		if (hasNewPublicRoutes && !opts?.confirmRouteVisibilityChanges) return {
-			success: false,
-			error: {
-				code: "ROUTE_VISIBILITY_ESCALATION",
-				message: "Plugin update exposes new public (unauthenticated) routes",
-				details: {
-					routeVisibilityChanges,
-					capabilityChanges
-				}
-			}
-		};
-		const oldMcpTools = [...oldBundle?.manifest.mcp?.tools ?? []].toSorted((a, b) => a.name.localeCompare(b.name));
-		const newMcpTools = [...bundle.manifest.mcp?.tools ?? []].toSorted((a, b) => a.name.localeCompare(b.name));
-		if (JSON.stringify(oldMcpTools) !== JSON.stringify(newMcpTools) && !opts?.confirmMcpTools) return {
-			success: false,
-			error: {
-				code: "MCP_TOOL_CONSENT_REQUIRED",
-				message: "Plugin update changes its MCP tools",
-				details: { mcpTools: newMcpTools.map(({ inputSchema: _, outputSchema: __, ...tool }) => tool) }
-			}
-		};
-		await storeBundleInR2(storage, pluginId, newVersion, bundle, "registry");
-		await stateRepo.upsert(pluginId, newVersion, "active", {
-			source: "registry",
-			registryPublisherDid: publisherDid,
-			registrySlug: slug,
-			displayName: existing.displayName ?? slug,
-			description: existing.description ?? void 0,
-			mcpToolsEnabled: false,
-			mcpToolsConsent: null
-		});
-		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
-		deleteBundleFromR2(storage, pluginId, oldVersion, "registry").catch(() => {});
-		return {
-			success: true,
-			data: {
-				pluginId,
-				oldVersion,
-				newVersion,
-				capabilityChanges,
-				routeVisibilityChanges: hasNewPublicRoutes ? routeVisibilityChanges : void 0
-			}
-		};
-	} catch (err) {
-		if (err instanceof ClientValidationError) return {
-			success: false,
-			error: {
-				code: "AGGREGATOR_RESPONSE_INVALID",
-				message: `Aggregator returned a response that does not conform to its lexicon (${err.target})`
-			}
-		};
-		if (err instanceof ClientResponseError) {
-			if (err.error === "ListingUnavailable") return {
-				success: false,
-				error: {
-					code: "LISTING_UNAVAILABLE",
-					message: "This plugin is unavailable under the active registry policy"
-				}
-			};
-			return {
-				success: false,
-				error: {
-					code: err.status === 404 ? "AGGREGATOR_NOT_FOUND" : "AGGREGATOR_HTTP_ERROR",
-					message: `Aggregator returned ${err.status}: ${err.error}`
-				}
-			};
-		}
-		if (err instanceof EmDashStorageError) return {
-			success: false,
-			error: {
-				code: err.code ?? "STORAGE_ERROR",
-				message: "Storage error while updating plugin"
-			}
-		};
-		console.error("[registry-update] Failed:", err);
-		return {
-			success: false,
-			error: {
-				code: "UPDATE_FAILED",
-				message: err instanceof Error ? err.message : "Failed to update plugin"
-			}
-		};
-	}
-}
-/**
-* Bulk update check across every installed registry plugin. Queries the
-* aggregator for each plugin's latest release and reports `hasUpdate`
-* based on the version comparison. Plugins whose aggregator lookup fails
-* (unreachable, delisted, malformed) are skipped silently — one bad
-* publisher must not blank the whole admin Updates list.
-*/
-async function handleRegistryUpdateCheck(db, registryConfigInput) {
-	const registryConfig = coerceRegistryConfig(registryConfigInput);
-	if (!registryConfig) return {
-		success: false,
-		error: {
-			code: "REGISTRY_NOT_CONFIGURED",
-			message: "Registry is not configured"
-		}
-	};
-	try {
-		const registryPlugins = await new PluginStateRepository(db).getRegistryPlugins();
-		if (registryPlugins.length === 0) return {
-			success: true,
-			data: { items: [] }
-		};
-		const { DiscoveryClient, registryLabelerPolicy } = await import("@emdash-cms/registry-client/discovery");
-		const aggregatorDeadline = Date.now() + AGGREGATOR_TOTAL_BUDGET_MS;
-		const discovery = new DiscoveryClient({
-			aggregatorUrl: registryConfig.aggregatorUrl,
-			acceptLabelers: registryConfig.acceptLabelers,
-			labelerPolicy: registryLabelerPolicy(registryConfig.acceptLabelers),
-			fetch: timedFetch(aggregatorDeadline)
-		});
-		const items = [];
-		for (const plugin of registryPlugins) {
-			if (!plugin.registryPublisherDid || !plugin.registrySlug) continue;
-			try {
-				const releaseView = await discovery.getLatestRelease({
-					did: plugin.registryPublisherDid,
-					package: plugin.registrySlug
-				});
-				if (evaluateRegistryReleaseWithdrawal(releaseView, discovery.labelerPolicy).withdrawn) continue;
-				const latest = releaseView.version;
-				if (!latest) continue;
-				const installed = plugin.version;
-				items.push({
-					pluginId: plugin.pluginId,
-					installed,
-					latest,
-					hasUpdate: latest !== installed,
-					hasCapabilityChanges: false,
-					hasRouteVisibilityChanges: false
-				});
-			} catch (err) {
-				console.warn(`[registry-update-check] Skipped ${plugin.pluginId}:`, err);
-			}
-		}
-		return {
-			success: true,
-			data: { items }
-		};
-	} catch (err) {
-		if (err instanceof ClientValidationError) return {
-			success: false,
-			error: {
-				code: "AGGREGATOR_RESPONSE_INVALID",
-				message: `Aggregator returned a response that does not conform to its lexicon (${err.target})`
-			}
-		};
-		if (err instanceof ClientResponseError) return {
-			success: false,
-			error: {
-				code: err.status === 404 ? "AGGREGATOR_NOT_FOUND" : "AGGREGATOR_HTTP_ERROR",
-				message: `Aggregator returned ${err.status}: ${err.error}`
-			}
-		};
-		console.error("[registry-update-check] Failed:", err);
-		return {
-			success: false,
-			error: {
-				code: "UPDATE_CHECK_FAILED",
-				message: "Failed to check for registry updates"
-			}
-		};
-	}
-}
-
-//#endregion
-export { handleThemeSearch as _, verifyChecksum as a, validateAggregatorUrl as c, handleMarketplaceInstall as d, handleMarketplaceSearch as f, handleThemeGetDetail as g, handleMarketplaceUpdateCheck as h, handleRegistryUpdateCheck as i, fetchRegistryArtifactUrl as l, handleMarketplaceUpdate as m, handleRegistryUninstall as n, coerceRegistryConfig as o, handleMarketplaceUninstall as p, handleRegistryUpdate as r, normalizeRegistryConfig as s, handleRegistryInstall as t, handleMarketplaceGetPlugin as u, loadBundleFromR2 as v, syncDeclaredStorageIndexes as y };
-//# sourceMappingURL=registry-BiO5WwPq.mjs.map