devflare 1.0.0-next.5 → 1.0.0-next.51

package/dist/_chunks/preview-registry-ClAbLTHH.js

@@ -0,0 +1,1186 @@
+import { a as apiGetAll, i as apiGet, n as CloudflareAPIError, o as apiPatch, r as apiDelete } from "./api-TzdliH-6.js";
+import { p as listD1Databases, t as createD1Database, y as queryD1Database } from "./account-resources-CsmVowJp.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod/v4";
+//#region src/cloudflare/account-workers.ts
+async function listWorkers(accountId, options) {
+	return (await apiGetAll(`/accounts/${accountId}/workers/scripts`, options)).map((script) => ({
+		name: script.name ?? script.id,
+		createdOn: new Date(script.created_on),
+		modifiedOn: new Date(script.modified_on)
+	}));
+}
+async function renameWorker(accountId, workerId, newName, options) {
+	const result = await apiPatch(`/accounts/${accountId}/workers/workers/${encodeURIComponent(workerId)}`, { name: newName }, options);
+	return {
+		id: result.id,
+		name: result.name
+	};
+}
+async function deleteWorker(accountId, scriptName, options) {
+	await apiDelete(`/accounts/${accountId}/workers/scripts/${encodeURIComponent(scriptName)}`, options);
+}
+function mapWorkerVersionInfo(version) {
+	return {
+		id: version.id ?? "",
+		number: version.number,
+		metadata: {
+			authorEmail: version.metadata?.author_email,
+			authorId: version.metadata?.author_id,
+			createdOn: version.metadata?.created_on ? new Date(version.metadata.created_on) : void 0,
+			modifiedOn: version.metadata?.modified_on ? new Date(version.metadata.modified_on) : void 0,
+			hasPreview: version.metadata?.has_preview === true || version.metadata?.hasPreview === true,
+			source: version.metadata?.source
+		}
+	};
+}
+async function listWorkerVersions(accountId, scriptName, options) {
+	const versions = [];
+	const encodedScriptName = encodeURIComponent(scriptName);
+	for (let page = 1; page <= 100; page++) {
+		const items = (await apiGet(`/accounts/${accountId}/workers/scripts/${encodedScriptName}/versions?page=${page}&per_page=100`, options)).items ?? [];
+		versions.push(...items.map((item) => mapWorkerVersionInfo(item)));
+		if (items.length < 100) break;
+	}
+	return versions;
+}
+async function getWorkerVersionDetail(accountId, scriptName, versionId, options) {
+	return mapWorkerVersionInfo(await apiGet(`/accounts/${accountId}/workers/scripts/${encodeURIComponent(scriptName)}/versions/${versionId}`, options));
+}
+async function listWorkerDeployments(accountId, scriptName, options) {
+	return ((await apiGet(`/accounts/${accountId}/workers/scripts/${encodeURIComponent(scriptName)}/deployments`, options)).deployments ?? []).map((deployment) => ({
+		id: deployment.id,
+		createdOn: new Date(deployment.created_on),
+		source: deployment.source,
+		strategy: deployment.strategy,
+		versions: deployment.versions.map((version) => ({
+			percentage: version.percentage,
+			versionId: version.version_id
+		})),
+		message: deployment.annotations?.["workers/message"],
+		triggeredBy: deployment.annotations?.["workers/triggered_by"],
+		authorEmail: deployment.author_email
+	}));
+}
+async function getWorkersSubdomain(accountId, options) {
+	try {
+		return (await apiGet(`/accounts/${accountId}/workers/subdomain`, options)).subdomain || null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/cloudflare/preview-registry-types.ts
+const DEVFLARE_PREVIEW_REGISTRY_DATABASE = "devflare-registry";
+//#endregion
+//#region src/cloudflare/preview-registry-cache.ts
+const DEVFLARE_CACHE_DIR = ".devflare";
+const PREVIEW_REGISTRY_CACHE_FILE = "preview-registry.json";
+function getDevflareCacheDir() {
+	const override = process.env.DEVFLARE_CACHE_DIR?.trim();
+	if (override) return override;
+	return join(homedir(), DEVFLARE_CACHE_DIR);
+}
+function getPreviewRegistryCachePath() {
+	return join(getDevflareCacheDir(), PREVIEW_REGISTRY_CACHE_FILE);
+}
+function getPreviewRegistryCacheKey(accountId, databaseName) {
+	return `${accountId}:${databaseName}`;
+}
+function readPreviewRegistryCache() {
+	const cachePath = getPreviewRegistryCachePath();
+	if (!existsSync(cachePath)) return {};
+	try {
+		const content = readFileSync(cachePath, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+function writePreviewRegistryCache(cache) {
+	try {
+		const cacheDir = getDevflareCacheDir();
+		if (!existsSync(cacheDir)) mkdirSync(cacheDir, { recursive: true });
+		writeFileSync(getPreviewRegistryCachePath(), JSON.stringify(cache, null, "	"), "utf-8");
+	} catch {}
+}
+function getRegistryDatabaseName(databaseName) {
+	return databaseName?.trim() || "devflare-registry";
+}
+function getCachedPreviewRegistryContext(accountId, databaseName) {
+	const entry = readPreviewRegistryCache().registries?.[getPreviewRegistryCacheKey(accountId, databaseName)];
+	if (!entry?.databaseId) return null;
+	return {
+		accountId: entry.accountId,
+		databaseId: entry.databaseId,
+		databaseName: entry.databaseName,
+		created: false
+	};
+}
+function cachePreviewRegistryContext(registry) {
+	const cache = readPreviewRegistryCache();
+	const registries = cache.registries ?? {};
+	registries[getPreviewRegistryCacheKey(registry.accountId, registry.databaseName)] = {
+		accountId: registry.accountId,
+		databaseId: registry.databaseId,
+		databaseName: registry.databaseName,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	writePreviewRegistryCache({
+		...cache,
+		registries
+	});
+}
+function clearCachedPreviewRegistryContext(accountId, databaseName) {
+	const cache = readPreviewRegistryCache();
+	if (!cache.registries) return;
+	delete cache.registries[getPreviewRegistryCacheKey(accountId, databaseName)];
+	writePreviewRegistryCache(cache);
+}
+//#endregion
+//#region src/cloudflare/preview-registry-inference.ts
+function toIsoString(date) {
+	return date ? date.toISOString() : null;
+}
+function inferRecordSource(explicitSource, fallbackSource) {
+	if (explicitSource) return explicitSource;
+	if (fallbackSource === "dashboard") return "dashboard";
+	if (fallbackSource === "workers-builds") return "workers-builds";
+	if (fallbackSource === "wrangler") return process.env.GITHUB_ACTIONS === "true" ? "github-action" : "cli";
+	return "unknown";
+}
+function getPreviewRecordId(workerName, versionId) {
+	return `preview:${workerName}:${versionId}`;
+}
+function getPreviewScopeRecordId(workerName, scope) {
+	return `previewScope:${workerName}:${scope}`;
+}
+function getPreviewDeploymentId(workerName, versionId) {
+	return `preview:${workerName}:${versionId}`;
+}
+function getDeploymentRecordId(workerName, deploymentId) {
+	return `deployment:${workerName}:${deploymentId}`;
+}
+function hasRetireSelector(options) {
+	return Boolean(options.branchName || options.previewScope || options.versionId || options.commitSha);
+}
+function matchesRetireSelector(options, candidate) {
+	return options.branchName !== void 0 && candidate.branchName === options.branchName || options.previewScope !== void 0 && candidate.previewScope === options.previewScope || options.versionId !== void 0 && candidate.versionId === options.versionId || options.commitSha !== void 0 && candidate.commitSha === options.commitSha;
+}
+function getPreviewRetireCandidate(record) {
+	return {
+		branchName: record.branchName,
+		previewScope: record.scope,
+		versionId: record.versionId,
+		commitSha: record.commitSha
+	};
+}
+function matchesPreviewRetireTarget(record, options) {
+	return matchesRetireSelector(options, getPreviewRetireCandidate(record));
+}
+function matchesPreviewScopeRetireTarget(record, options) {
+	return matchesRetireSelector(options, getPreviewRetireCandidate(record));
+}
+function matchesPreviewDeploymentRetireTarget(record, options) {
+	return record.channel === "preview" && matchesRetireSelector(options, {
+		versionId: record.versionId,
+		commitSha: record.commitSha
+	});
+}
+function getExplicitPreviewSyncOverrides(options, versionId) {
+	if (versionId !== options.versionId) return {};
+	return {
+		previewScope: options.previewScope,
+		previewUrl: options.previewUrl,
+		previewScopeUrl: options.previewScopeUrl,
+		branchName: options.branchName,
+		commitSha: options.commitSha
+	};
+}
+//#endregion
+//#region src/cloudflare/preview-urls.ts
+function normalizeWorkersSubdomain(accountSubdomain) {
+	return accountSubdomain.trim().replace(/^https?:\/\//i, "").replace(/\.workers\.dev\/?$/i, "");
+}
+function formatWorkersDevUrl(workerName, accountSubdomain) {
+	return `https://${workerName}.${normalizeWorkersSubdomain(accountSubdomain)}.workers.dev`;
+}
+function formatVersionPreviewUrl(versionId, workerName, accountSubdomain) {
+	const normalizedSubdomain = normalizeWorkersSubdomain(accountSubdomain);
+	return `https://${versionId.split("-")[0] || versionId}-${workerName}.${normalizedSubdomain}.workers.dev`;
+}
+//#endregion
+//#region src/cloudflare/registry-schema.ts
+const recordIdSchema = z.string().min(1);
+const cloudflareAccountIdSchema = z.string().min(1);
+const cloudflareVersionIdSchema = z.string().uuid();
+const workerNameSchema = z.string().min(1);
+const timestampSchema = z.coerce.date();
+const urlSchema = z.string().url();
+const branchNameSchema = z.string().min(1);
+const commitShaSchema = z.string().regex(/^[a-f0-9]{7,40}$/i, { message: "Commit SHA must be 7 to 40 hexadecimal characters" });
+const previewScopeSchema = z.string().regex(/^[a-z][a-z0-9-]*$/, { message: "Preview names must start with a lowercase letter and contain only lowercase letters, numbers, and dashes" });
+const cloudflareUserIdSchema = z.union([z.string().min(1), z.number().int().nonnegative().transform((value) => String(value))]);
+const devflareAccountRecordSchema = z.object({
+	id: recordIdSchema,
+	ver: z.number().int().min(1),
+	createdAt: timestampSchema,
+	updatedAt: timestampSchema.optional(),
+	deletedAt: timestampSchema.optional(),
+	createdBy: cloudflareUserIdSchema
+}).strict();
+function createDevflareAccountRecordSchema(shape) {
+	return devflareAccountRecordSchema.extend(shape);
+}
+const devflareRecordSourceSchema = z.enum([
+	"cli",
+	"github-action",
+	"workers-builds",
+	"dashboard",
+	"unknown"
+]);
+const devflarePreviewStatusSchema = z.enum([
+	"active",
+	"superseded",
+	"orphaned",
+	"deleted"
+]);
+const devflarePreviewScopeStatusSchema = z.enum([
+	"active",
+	"reassigned",
+	"deleted"
+]);
+const devflareDeploymentChannelSchema = z.enum(["production", "preview"]);
+const devflareDeploymentStatusSchema = z.enum([
+	"active",
+	"superseded",
+	"rolled_back",
+	"deleted"
+]);
+const devflarePreviewRecordSchema = createDevflareAccountRecordSchema({
+	kind: z.literal("preview"),
+	accountId: cloudflareAccountIdSchema,
+	workerName: workerNameSchema,
+	versionId: cloudflareVersionIdSchema,
+	previewUrl: urlSchema,
+	scope: previewScopeSchema.optional(),
+	scopeUrl: urlSchema.optional(),
+	branchName: branchNameSchema.optional(),
+	commitSha: commitShaSchema.optional(),
+	deploymentId: recordIdSchema.optional(),
+	source: devflareRecordSourceSchema.default("unknown"),
+	status: devflarePreviewStatusSchema.default("active")
+}).superRefine((record, ctx) => {
+	if (record.scopeUrl && !record.scope) ctx.addIssue({
+		code: "custom",
+		path: ["scopeUrl"],
+		message: "scopeUrl requires scope to be set"
+	});
+});
+const devflarePreviewScopeRecordSchema = createDevflareAccountRecordSchema({
+	kind: z.literal("previewScope"),
+	accountId: cloudflareAccountIdSchema,
+	workerName: workerNameSchema,
+	scope: previewScopeSchema,
+	scopeUrl: urlSchema,
+	versionId: cloudflareVersionIdSchema,
+	previewId: recordIdSchema.optional(),
+	branchName: branchNameSchema.optional(),
+	commitSha: commitShaSchema.optional(),
+	source: devflareRecordSourceSchema.default("unknown"),
+	status: devflarePreviewScopeStatusSchema.default("active")
+});
+const devflareDeploymentRecordSchema = createDevflareAccountRecordSchema({
+	kind: z.literal("deployment"),
+	accountId: cloudflareAccountIdSchema,
+	workerName: workerNameSchema,
+	deploymentId: recordIdSchema,
+	channel: devflareDeploymentChannelSchema,
+	status: devflareDeploymentStatusSchema.default("active"),
+	versionId: cloudflareVersionIdSchema,
+	previewId: recordIdSchema.optional(),
+	environment: z.string().min(1).optional(),
+	url: urlSchema.optional(),
+	message: z.string().min(1).optional(),
+	commitSha: commitShaSchema.optional(),
+	source: devflareRecordSourceSchema.default("unknown")
+}).superRefine((record, ctx) => {
+	if (record.channel === "preview" && !record.previewId) ctx.addIssue({
+		code: "custom",
+		path: ["previewId"],
+		message: "Preview deployments must reference the preview record they materialize"
+	});
+	if (record.channel === "production" && record.previewId) ctx.addIssue({
+		code: "custom",
+		path: ["previewId"],
+		message: "Production deployments should not reference previewId"
+	});
+});
+const devflareAccountLayerRecordSchema = z.discriminatedUnion("kind", [
+	devflarePreviewRecordSchema,
+	devflarePreviewScopeRecordSchema,
+	devflareDeploymentRecordSchema
+]);
+//#endregion
+//#region src/cloudflare/preview-registry-shape.ts
+function markRecordDeleted(record, now, parser) {
+	return parser.parse({
+		...record,
+		updatedAt: now,
+		deletedAt: now,
+		status: "deleted"
+	});
+}
+function getVersionAuthorId(version, existingCreatedBy) {
+	return version?.metadata.authorId || existingCreatedBy || "unknown";
+}
+function createPreviewLinkedRecordBase(options) {
+	return {
+		createdAt: options.existingCreatedAt ?? options.previewRecord.createdAt,
+		updatedAt: options.now,
+		deletedAt: void 0,
+		createdBy: options.previewRecord.createdBy,
+		accountId: options.accountId,
+		workerName: options.workerName,
+		versionId: options.previewRecord.versionId,
+		previewId: options.previewRecord.id,
+		commitSha: options.previewRecord.commitSha,
+		source: options.previewRecord.source,
+		status: "active"
+	};
+}
+function buildPreviewRecord(options) {
+	const scope = options.previewScope ?? options.existing?.scope;
+	const previewUrl = options.previewUrl ?? options.existing?.previewUrl ?? (options.workersSubdomain ? formatVersionPreviewUrl(options.version.id, options.workerName, options.workersSubdomain) : void 0);
+	const scopeChanged = options.previewScope !== void 0 && options.previewScope !== options.existing?.scope;
+	const scopeUrl = options.previewScopeUrl ?? (options.previewScope !== void 0 ? options.previewUrl : void 0) ?? (!scopeChanged ? options.existing?.scopeUrl : void 0);
+	if (!previewUrl) return null;
+	return devflarePreviewRecordSchema.parse({
+		id: getPreviewRecordId(options.workerName, options.version.id),
+		kind: "preview",
+		ver: 1,
+		createdAt: options.existing?.createdAt ?? options.version.metadata.createdOn ?? options.now,
+		updatedAt: options.now,
+		deletedAt: void 0,
+		createdBy: getVersionAuthorId(options.version, options.existing?.createdBy),
+		accountId: options.accountId,
+		workerName: options.workerName,
+		versionId: options.version.id,
+		previewUrl,
+		scope,
+		scopeUrl,
+		branchName: options.branchName ?? options.existing?.branchName,
+		commitSha: options.commitSha ?? options.existing?.commitSha,
+		deploymentId: options.existing?.deploymentId,
+		source: inferRecordSource(options.source, options.version.metadata.source),
+		status: "active"
+	});
+}
+function buildPreviewScopeRecord(options) {
+	if (!options.previewRecord.scope || !options.previewRecord.scopeUrl) return null;
+	return devflarePreviewScopeRecordSchema.parse({
+		id: getPreviewScopeRecordId(options.workerName, options.previewRecord.scope),
+		kind: "previewScope",
+		ver: 1,
+		...createPreviewLinkedRecordBase({
+			accountId: options.accountId,
+			workerName: options.workerName,
+			previewRecord: options.previewRecord,
+			existingCreatedAt: options.existing?.createdAt,
+			now: options.now
+		}),
+		scope: options.previewRecord.scope,
+		scopeUrl: options.previewRecord.scopeUrl,
+		branchName: options.previewRecord.branchName
+	});
+}
+function buildPreviewDeploymentRecord(options) {
+	const deploymentId = getPreviewDeploymentId(options.workerName, options.previewRecord.versionId);
+	return devflareDeploymentRecordSchema.parse({
+		id: getDeploymentRecordId(options.workerName, deploymentId),
+		kind: "deployment",
+		ver: 1,
+		...createPreviewLinkedRecordBase({
+			accountId: options.accountId,
+			workerName: options.workerName,
+			previewRecord: options.previewRecord,
+			existingCreatedAt: options.existing?.createdAt,
+			now: options.now
+		}),
+		deploymentId,
+		channel: "preview",
+		environment: "preview",
+		url: options.previewRecord.scopeUrl ?? options.previewRecord.previewUrl,
+		message: options.existing?.message
+	});
+}
+function buildProductionDeploymentRecord(options) {
+	const versionId = options.deployment.versions[0]?.versionId;
+	if (!versionId) return null;
+	const productionUrl = options.workersSubdomain ? `https://${options.workerName}.${options.workersSubdomain}.workers.dev` : options.existing?.url;
+	return devflareDeploymentRecordSchema.parse({
+		id: getDeploymentRecordId(options.workerName, options.deployment.id),
+		kind: "deployment",
+		ver: 1,
+		createdAt: options.existing?.createdAt ?? options.deployment.createdOn,
+		updatedAt: options.now,
+		deletedAt: void 0,
+		createdBy: getVersionAuthorId(options.version, options.existing?.createdBy),
+		accountId: options.accountId,
+		workerName: options.workerName,
+		deploymentId: options.deployment.id,
+		channel: "production",
+		status: options.status,
+		versionId,
+		environment: "production",
+		url: productionUrl,
+		message: options.deploymentMessage ?? options.deployment.message ?? options.existing?.message,
+		commitSha: options.commitSha ?? options.existing?.commitSha,
+		source: inferRecordSource(options.source, options.version?.metadata.source ?? options.deployment.source)
+	});
+}
+function markPreviewRecordDeleted(record, now) {
+	return markRecordDeleted(record, now, devflarePreviewRecordSchema);
+}
+function markPreviewScopeRecordDeleted(record, now) {
+	return markRecordDeleted(record, now, devflarePreviewScopeRecordSchema);
+}
+function markDeploymentRecordDeleted(record, now) {
+	return markRecordDeleted(record, now, devflareDeploymentRecordSchema);
+}
+//#endregion
+//#region src/cloudflare/preview-registry-transport.ts
+async function getVersionInfoById(accountId, workerName, versionId, versionMap, apiOptions) {
+	const existing = versionMap.get(versionId);
+	if (existing) return existing;
+	try {
+		const version = await getWorkerVersionDetail(accountId, workerName, versionId, apiOptions);
+		versionMap.set(versionId, version);
+		return version;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/cloudflare/preview-registry-store.ts
+const REGISTRY_TABLES = [
+	{
+		name: "devflare_preview_records",
+		createStatement: `CREATE TABLE IF NOT EXISTS devflare_preview_records (
+			id TEXT PRIMARY KEY,
+			ver INTEGER NOT NULL,
+			account_id TEXT NOT NULL,
+			worker_name TEXT NOT NULL,
+			version_id TEXT NOT NULL UNIQUE,
+			preview_url TEXT NOT NULL,
+			scope TEXT,
+			scope_url TEXT,
+			branch_name TEXT,
+			commit_sha TEXT,
+			deployment_id TEXT,
+			source TEXT NOT NULL,
+			status TEXT NOT NULL,
+			created_by TEXT NOT NULL,
+			created_at TEXT NOT NULL,
+			updated_at TEXT,
+			deleted_at TEXT,
+			payload_json TEXT NOT NULL
+		)`,
+		migrationColumns: {
+			id: "id TEXT",
+			ver: "ver INTEGER NOT NULL DEFAULT 1",
+			account_id: `account_id TEXT NOT NULL DEFAULT ''`,
+			worker_name: `worker_name TEXT NOT NULL DEFAULT ''`,
+			version_id: `version_id TEXT NOT NULL DEFAULT ''`,
+			preview_url: `preview_url TEXT NOT NULL DEFAULT ''`,
+			scope: "scope TEXT",
+			scope_url: "scope_url TEXT",
+			branch_name: "branch_name TEXT",
+			commit_sha: "commit_sha TEXT",
+			deployment_id: "deployment_id TEXT",
+			source: `source TEXT NOT NULL DEFAULT ''`,
+			status: `status TEXT NOT NULL DEFAULT ''`,
+			created_by: `created_by TEXT NOT NULL DEFAULT ''`,
+			created_at: `created_at TEXT NOT NULL DEFAULT ''`,
+			updated_at: "updated_at TEXT",
+			deleted_at: "deleted_at TEXT",
+			payload_json: `payload_json TEXT NOT NULL DEFAULT '{}'`
+		},
+		indexStatements: [
+			"CREATE INDEX IF NOT EXISTS idx_devflare_preview_records_account_worker ON devflare_preview_records(account_id, worker_name)",
+			"CREATE INDEX IF NOT EXISTS idx_devflare_preview_records_status ON devflare_preview_records(status)",
+			"CREATE UNIQUE INDEX IF NOT EXISTS idx_devflare_preview_records_version_id ON devflare_preview_records(version_id)"
+		]
+	},
+	{
+		name: "devflare_preview_scope_records",
+		createStatement: `CREATE TABLE IF NOT EXISTS devflare_preview_scope_records (
+			id TEXT PRIMARY KEY,
+			ver INTEGER NOT NULL,
+			account_id TEXT NOT NULL,
+			worker_name TEXT NOT NULL,
+			scope TEXT NOT NULL,
+			scope_url TEXT NOT NULL,
+			version_id TEXT NOT NULL,
+			preview_id TEXT,
+			branch_name TEXT,
+			commit_sha TEXT,
+			source TEXT NOT NULL,
+			status TEXT NOT NULL,
+			created_by TEXT NOT NULL,
+			created_at TEXT NOT NULL,
+			updated_at TEXT,
+			deleted_at TEXT,
+			payload_json TEXT NOT NULL
+		)`,
+		migrationColumns: {
+			id: "id TEXT",
+			ver: "ver INTEGER NOT NULL DEFAULT 1",
+			account_id: `account_id TEXT NOT NULL DEFAULT ''`,
+			worker_name: `worker_name TEXT NOT NULL DEFAULT ''`,
+			scope: `scope TEXT NOT NULL DEFAULT ''`,
+			scope_url: `scope_url TEXT NOT NULL DEFAULT ''`,
+			version_id: `version_id TEXT NOT NULL DEFAULT ''`,
+			preview_id: "preview_id TEXT",
+			branch_name: "branch_name TEXT",
+			commit_sha: "commit_sha TEXT",
+			source: `source TEXT NOT NULL DEFAULT ''`,
+			status: `status TEXT NOT NULL DEFAULT ''`,
+			created_by: `created_by TEXT NOT NULL DEFAULT ''`,
+			created_at: `created_at TEXT NOT NULL DEFAULT ''`,
+			updated_at: "updated_at TEXT",
+			deleted_at: "deleted_at TEXT",
+			payload_json: `payload_json TEXT NOT NULL DEFAULT '{}'`
+		},
+		indexStatements: ["CREATE INDEX IF NOT EXISTS idx_devflare_preview_scope_records_account_worker ON devflare_preview_scope_records(account_id, worker_name)", "CREATE INDEX IF NOT EXISTS idx_devflare_preview_scope_records_scope ON devflare_preview_scope_records(scope)"]
+	},
+	{
+		name: "devflare_deployment_records",
+		createStatement: `CREATE TABLE IF NOT EXISTS devflare_deployment_records (
+			id TEXT PRIMARY KEY,
+			ver INTEGER NOT NULL,
+			account_id TEXT NOT NULL,
+			worker_name TEXT NOT NULL,
+			deployment_id TEXT NOT NULL UNIQUE,
+			channel TEXT NOT NULL,
+			status TEXT NOT NULL,
+			version_id TEXT NOT NULL,
+			preview_id TEXT,
+			environment TEXT,
+			url TEXT,
+			message TEXT,
+			commit_sha TEXT,
+			source TEXT NOT NULL,
+			created_by TEXT NOT NULL,
+			created_at TEXT NOT NULL,
+			updated_at TEXT,
+			deleted_at TEXT,
+			payload_json TEXT NOT NULL
+		)`,
+		migrationColumns: {
+			id: "id TEXT",
+			ver: "ver INTEGER NOT NULL DEFAULT 1",
+			account_id: `account_id TEXT NOT NULL DEFAULT ''`,
+			worker_name: `worker_name TEXT NOT NULL DEFAULT ''`,
+			deployment_id: `deployment_id TEXT NOT NULL DEFAULT ''`,
+			channel: `channel TEXT NOT NULL DEFAULT ''`,
+			status: `status TEXT NOT NULL DEFAULT ''`,
+			version_id: `version_id TEXT NOT NULL DEFAULT ''`,
+			preview_id: "preview_id TEXT",
+			environment: "environment TEXT",
+			url: "url TEXT",
+			message: "message TEXT",
+			commit_sha: "commit_sha TEXT",
+			source: `source TEXT NOT NULL DEFAULT ''`,
+			created_by: `created_by TEXT NOT NULL DEFAULT ''`,
+			created_at: `created_at TEXT NOT NULL DEFAULT ''`,
+			updated_at: "updated_at TEXT",
+			deleted_at: "deleted_at TEXT",
+			payload_json: `payload_json TEXT NOT NULL DEFAULT '{}'`
+		},
+		indexStatements: [
+			"CREATE INDEX IF NOT EXISTS idx_devflare_deployment_records_account_worker ON devflare_deployment_records(account_id, worker_name)",
+			"CREATE INDEX IF NOT EXISTS idx_devflare_deployment_records_channel_status ON devflare_deployment_records(channel, status)",
+			"CREATE UNIQUE INDEX IF NOT EXISTS idx_devflare_deployment_records_deployment_id ON devflare_deployment_records(deployment_id)"
+		]
+	}
+];
+const schemaEnsuredRegistryIds = /* @__PURE__ */ new Set();
+async function runQuery(registry, sql, params = [], apiOptions) {
+	return (await queryD1Database(registry.accountId, registry.databaseId, {
+		sql,
+		params
+	}, apiOptions))[0]?.results ?? [];
+}
+async function runStatement(registry, sql, params = [], apiOptions) {
+	await queryD1Database(registry.accountId, registry.databaseId, {
+		sql,
+		params
+	}, apiOptions);
+}
+function quoteSqlIdentifier(value) {
+	return `"${value.replaceAll("\"", "\"\"")}"`;
+}
+async function readTableColumnNames(registry, tableName, apiOptions) {
+	const rows = await runQuery(registry, `PRAGMA table_info(${quoteSqlIdentifier(tableName)})`, [], apiOptions);
+	return new Set(rows.map((row) => typeof row.name === "string" ? row.name : void 0).filter((value) => Boolean(value)));
+}
+async function ensureTableColumns(registry, table, apiOptions) {
+	const existingColumnNames = await readTableColumnNames(registry, table.name, apiOptions);
+	for (const [columnName, definition] of Object.entries(table.migrationColumns)) {
+		if (existingColumnNames.has(columnName)) continue;
+		await runStatement(registry, `ALTER TABLE ${quoteSqlIdentifier(table.name)} ADD COLUMN ${definition}`, [], apiOptions);
+	}
+}
+async function ensurePreviewRegistrySchema(registry, apiOptions) {
+	if (schemaEnsuredRegistryIds.has(registry.databaseId)) return;
+	for (const table of REGISTRY_TABLES) {
+		await runStatement(registry, table.createStatement, [], apiOptions);
+		await ensureTableColumns(registry, table, apiOptions);
+		for (const statement of table.indexStatements) await runStatement(registry, statement, [], apiOptions);
+	}
+	schemaEnsuredRegistryIds.add(registry.databaseId);
+}
+function clearPreviewRegistrySchemaCache(databaseId) {
+	schemaEnsuredRegistryIds.delete(databaseId);
+}
+function isMissingRegistrySchemaError(error) {
+	if (error instanceof CloudflareAPIError) {
+		const message = error.message.toLowerCase();
+		return message.includes("no such table") || message.includes("no such column");
+	}
+	if (error instanceof Error) {
+		const message = error.message.toLowerCase();
+		return message.includes("no such table") || message.includes("no such column");
+	}
+	return false;
+}
+function isUnavailableRegistryContextError(error) {
+	if (error instanceof CloudflareAPIError) {
+		const message = error.message.toLowerCase();
+		return error.code === 404 || (message.includes("database") || message.includes("d1")) && (message.includes("not found") || message.includes("does not exist") || message.includes("unknown"));
+	}
+	if (error instanceof Error) {
+		const message = error.message.toLowerCase();
+		return (message.includes("database") || message.includes("d1")) && (message.includes("not found") || message.includes("does not exist"));
+	}
+	return false;
+}
+function normalizeLegacyStoredRecordPayload(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	const { alias, aliasPreviewUrl, ...record } = value;
+	if (record.scope === void 0 && typeof alias === "string") record.scope = alias;
+	if (record.scopeUrl === void 0 && typeof aliasPreviewUrl === "string") record.scopeUrl = aliasPreviewUrl;
+	return record;
+}
+function parseStoredRecordPayload(row) {
+	return normalizeLegacyStoredRecordPayload(JSON.parse(row.payload_json));
+}
+function parseStoredPreviewRecord(row) {
+	return devflarePreviewRecordSchema.parse(parseStoredRecordPayload(row));
+}
+function parseStoredPreviewScopeRecord(row) {
+	return devflarePreviewScopeRecordSchema.parse(parseStoredRecordPayload(row));
+}
+function parseStoredDeploymentRecord(row) {
+	return devflareDeploymentRecordSchema.parse(parseStoredRecordPayload(row));
+}
+async function readPreviewRows(registry, workerName, apiOptions) {
+	return (await runQuery(registry, workerName ? "SELECT payload_json FROM devflare_preview_records WHERE account_id = ? AND worker_name = ? ORDER BY created_at DESC" : "SELECT payload_json FROM devflare_preview_records WHERE account_id = ? ORDER BY created_at DESC", workerName ? [registry.accountId, workerName] : [registry.accountId], apiOptions)).map((row) => parseStoredPreviewRecord(row));
+}
+async function readPreviewScopeRows(registry, workerName, apiOptions) {
+	return (await runQuery(registry, workerName ? "SELECT payload_json FROM devflare_preview_scope_records WHERE account_id = ? AND worker_name = ? ORDER BY created_at DESC" : "SELECT payload_json FROM devflare_preview_scope_records WHERE account_id = ? ORDER BY created_at DESC", workerName ? [registry.accountId, workerName] : [registry.accountId], apiOptions)).map((row) => parseStoredPreviewScopeRecord(row));
+}
+async function readDeploymentRows(registry, workerName, apiOptions) {
+	return (await runQuery(registry, workerName ? "SELECT payload_json FROM devflare_deployment_records WHERE account_id = ? AND worker_name = ? ORDER BY created_at DESC" : "SELECT payload_json FROM devflare_deployment_records WHERE account_id = ? ORDER BY created_at DESC", workerName ? [registry.accountId, workerName] : [registry.accountId], apiOptions)).map((row) => parseStoredDeploymentRecord(row));
+}
+async function upsertPreviewRecord(registry, record, apiOptions) {
+	const normalizedRecord = devflarePreviewRecordSchema.parse(record);
+	await runStatement(registry, `INSERT INTO devflare_preview_records (
+			id,
+			ver,
+			account_id,
+			worker_name,
+			version_id,
+			preview_url,
+			scope,
+			scope_url,
+			branch_name,
+			commit_sha,
+			deployment_id,
+			source,
+			status,
+			created_by,
+			created_at,
+			updated_at,
+			deleted_at,
+			payload_json
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT(id) DO UPDATE SET
+			ver = excluded.ver,
+			account_id = excluded.account_id,
+			worker_name = excluded.worker_name,
+			version_id = excluded.version_id,
+			preview_url = excluded.preview_url,
+			scope = excluded.scope,
+			scope_url = excluded.scope_url,
+			branch_name = excluded.branch_name,
+			commit_sha = excluded.commit_sha,
+			deployment_id = excluded.deployment_id,
+			source = excluded.source,
+			status = excluded.status,
+			created_by = excluded.created_by,
+			created_at = excluded.created_at,
+			updated_at = excluded.updated_at,
+			deleted_at = excluded.deleted_at,
+			payload_json = excluded.payload_json`, [
+		normalizedRecord.id,
+		normalizedRecord.ver,
+		normalizedRecord.accountId,
+		normalizedRecord.workerName,
+		normalizedRecord.versionId,
+		normalizedRecord.previewUrl,
+		normalizedRecord.scope ?? null,
+		normalizedRecord.scopeUrl ?? null,
+		normalizedRecord.branchName ?? null,
+		normalizedRecord.commitSha ?? null,
+		normalizedRecord.deploymentId ?? null,
+		normalizedRecord.source,
+		normalizedRecord.status,
+		normalizedRecord.createdBy,
+		normalizedRecord.createdAt.toISOString(),
+		toIsoString(normalizedRecord.updatedAt),
+		toIsoString(normalizedRecord.deletedAt),
+		JSON.stringify(normalizedRecord)
+	], apiOptions);
+}
+async function upsertPreviewScopeRecord(registry, record, apiOptions) {
+	const normalizedRecord = devflarePreviewScopeRecordSchema.parse(record);
+	await runStatement(registry, `INSERT INTO devflare_preview_scope_records (
+			id,
+			ver,
+			account_id,
+			worker_name,
+			scope,
+			scope_url,
+			version_id,
+			preview_id,
+			branch_name,
+			commit_sha,
+			source,
+			status,
+			created_by,
+			created_at,
+			updated_at,
+			deleted_at,
+			payload_json
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT(id) DO UPDATE SET
+			ver = excluded.ver,
+			account_id = excluded.account_id,
+			worker_name = excluded.worker_name,
+			scope = excluded.scope,
+			scope_url = excluded.scope_url,
+			version_id = excluded.version_id,
+			preview_id = excluded.preview_id,
+			branch_name = excluded.branch_name,
+			commit_sha = excluded.commit_sha,
+			source = excluded.source,
+			status = excluded.status,
+			created_by = excluded.created_by,
+			created_at = excluded.created_at,
+			updated_at = excluded.updated_at,
+			deleted_at = excluded.deleted_at,
+			payload_json = excluded.payload_json`, [
+		normalizedRecord.id,
+		normalizedRecord.ver,
+		normalizedRecord.accountId,
+		normalizedRecord.workerName,
+		normalizedRecord.scope,
+		normalizedRecord.scopeUrl,
+		normalizedRecord.versionId,
+		normalizedRecord.previewId ?? null,
+		normalizedRecord.branchName ?? null,
+		normalizedRecord.commitSha ?? null,
+		normalizedRecord.source,
+		normalizedRecord.status,
+		normalizedRecord.createdBy,
+		normalizedRecord.createdAt.toISOString(),
+		toIsoString(normalizedRecord.updatedAt),
+		toIsoString(normalizedRecord.deletedAt),
+		JSON.stringify(normalizedRecord)
+	], apiOptions);
+}
+async function upsertDeploymentRecord(registry, record, apiOptions) {
+	const normalizedRecord = devflareDeploymentRecordSchema.parse(record);
+	await runStatement(registry, `INSERT INTO devflare_deployment_records (
+			id,
+			ver,
+			account_id,
+			worker_name,
+			deployment_id,
+			channel,
+			status,
+			version_id,
+			preview_id,
+			environment,
+			url,
+			message,
+			commit_sha,
+			source,
+			created_by,
+			created_at,
+			updated_at,
+			deleted_at,
+			payload_json
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT(id) DO UPDATE SET
+			ver = excluded.ver,
+			account_id = excluded.account_id,
+			worker_name = excluded.worker_name,
+			deployment_id = excluded.deployment_id,
+			channel = excluded.channel,
+			status = excluded.status,
+			version_id = excluded.version_id,
+			preview_id = excluded.preview_id,
+			environment = excluded.environment,
+			url = excluded.url,
+			message = excluded.message,
+			commit_sha = excluded.commit_sha,
+			source = excluded.source,
+			created_by = excluded.created_by,
+			created_at = excluded.created_at,
+			updated_at = excluded.updated_at,
+			deleted_at = excluded.deleted_at,
+			payload_json = excluded.payload_json`, [
+		normalizedRecord.id,
+		normalizedRecord.ver,
+		normalizedRecord.accountId,
+		normalizedRecord.workerName,
+		normalizedRecord.deploymentId,
+		normalizedRecord.channel,
+		normalizedRecord.status,
+		normalizedRecord.versionId,
+		normalizedRecord.previewId ?? null,
+		normalizedRecord.environment ?? null,
+		normalizedRecord.url ?? null,
+		normalizedRecord.message ?? null,
+		normalizedRecord.commitSha ?? null,
+		normalizedRecord.source,
+		normalizedRecord.createdBy,
+		normalizedRecord.createdAt.toISOString(),
+		toIsoString(normalizedRecord.updatedAt),
+		toIsoString(normalizedRecord.deletedAt),
+		JSON.stringify(normalizedRecord)
+	], apiOptions);
+}
+//#endregion
+//#region src/cloudflare/preview-registry.ts
+async function withRegistryReadRecovery(registry, apiOptions, operation) {
+	try {
+		return {
+			registry,
+			result: await operation(registry)
+		};
+	} catch (error) {
+		if (isMissingRegistrySchemaError(error)) {
+			clearPreviewRegistrySchemaCache(registry.databaseId);
+			await ensurePreviewRegistrySchema(registry, apiOptions);
+			return {
+				registry,
+				result: await operation(registry)
+			};
+		}
+		if (!isUnavailableRegistryContextError(error)) throw error;
+		clearCachedPreviewRegistryContext(registry.accountId, registry.databaseName);
+		const refreshedRegistry = await ensurePreviewRegistry({
+			accountId: registry.accountId,
+			databaseName: registry.databaseName,
+			apiOptions,
+			skipContextCache: true
+		});
+		return {
+			registry: refreshedRegistry,
+			result: await operation(refreshedRegistry)
+		};
+	}
+}
+async function loadTrackedRegistryRows(registry, workerName, apiOptions) {
+	const [previews, scopes, deployments] = await Promise.all([
+		readPreviewRows(registry, workerName, apiOptions),
+		readPreviewScopeRows(registry, workerName, apiOptions),
+		readDeploymentRows(registry, workerName, apiOptions)
+	]);
+	return {
+		previews,
+		scopes,
+		deployments
+	};
+}
+async function applyDeletedRecords(registry, options) {
+	for (const preview of options.previews) await upsertPreviewRecord(registry, markPreviewRecordDeleted(preview, options.now), options.apiOptions);
+	for (const scope of options.scopes) await upsertPreviewScopeRecord(registry, markPreviewScopeRecordDeleted(scope, options.now), options.apiOptions);
+	for (const deployment of options.deployments) await upsertDeploymentRecord(registry, markDeploymentRecordDeleted(deployment, options.now), options.apiOptions);
+}
+async function getPreviewRegistryContext(options) {
+	const databaseName = getRegistryDatabaseName(options.databaseName);
+	if (options.skipContextCache !== true) {
+		const cached = getCachedPreviewRegistryContext(options.accountId, databaseName);
+		if (cached) return cached;
+	}
+	const existing = (await listD1Databases(options.accountId, options.apiOptions)).find((database) => database.name === databaseName);
+	if (!existing) return null;
+	const registry = {
+		accountId: options.accountId,
+		databaseId: existing.id,
+		databaseName,
+		created: false
+	};
+	cachePreviewRegistryContext(registry);
+	return registry;
+}
+async function ensurePreviewRegistry(options) {
+	let registry = await getPreviewRegistryContext(options);
+	if (!registry) {
+		const created = await createD1Database(options.accountId, getRegistryDatabaseName(options.databaseName), options.apiOptions);
+		registry = {
+			accountId: options.accountId,
+			databaseId: created.id,
+			databaseName: created.name,
+			created: true
+		};
+		cachePreviewRegistryContext(registry);
+		options.logger?.info?.(`Created Devflare preview registry D1 database: ${registry.databaseName}`);
+	}
+	if (registry.created || options.skipSchemaIfExisting !== true) await ensurePreviewRegistrySchema(registry, options.apiOptions);
+	return registry;
+}
+async function listTrackedRegistryState(options) {
+	const { result } = await withRegistryReadRecovery(options.registry, options.apiOptions, async (registry) => {
+		return loadTrackedRegistryRows(registry, options.workerName, options.apiOptions);
+	});
+	return result;
+}
+async function listTrackedPreviewRecords(options) {
+	const { registry: resolvedRegistry, result } = await withRegistryReadRecovery(await ensurePreviewRegistry({
+		accountId: options.accountId,
+		databaseName: options.databaseName,
+		apiOptions: options.apiOptions,
+		skipSchemaIfExisting: true
+	}), options.apiOptions, (activeRegistry) => readPreviewRows(activeRegistry, options.workerName, options.apiOptions));
+	return {
+		registry: resolvedRegistry,
+		records: result
+	};
+}
+async function listTrackedPreviewScopeRecords(options) {
+	const { registry: resolvedRegistry, result } = await withRegistryReadRecovery(await ensurePreviewRegistry({
+		accountId: options.accountId,
+		databaseName: options.databaseName,
+		apiOptions: options.apiOptions,
+		skipSchemaIfExisting: true
+	}), options.apiOptions, (activeRegistry) => readPreviewScopeRows(activeRegistry, options.workerName, options.apiOptions));
+	return {
+		registry: resolvedRegistry,
+		records: result
+	};
+}
+async function listTrackedDeploymentRecords(options) {
+	const { registry: resolvedRegistry, result } = await withRegistryReadRecovery(await ensurePreviewRegistry({
+		accountId: options.accountId,
+		databaseName: options.databaseName,
+		apiOptions: options.apiOptions,
+		skipSchemaIfExisting: true
+	}), options.apiOptions, (activeRegistry) => readDeploymentRows(activeRegistry, options.workerName, options.apiOptions));
+	return {
+		registry: resolvedRegistry,
+		records: result
+	};
+}
+async function reconcilePreviewRegistry(options) {
+	const now = options.now ?? /* @__PURE__ */ new Date();
+	const registry = await ensurePreviewRegistry({
+		accountId: options.accountId,
+		databaseName: options.databaseName,
+		apiOptions: options.apiOptions,
+		logger: options.logger
+	});
+	const workersSubdomain = await getWorkersSubdomain(options.accountId, options.apiOptions);
+	const liveVersions = await listWorkerVersions(options.accountId, options.workerName, options.apiOptions);
+	const liveDeployments = await listWorkerDeployments(options.accountId, options.workerName, options.apiOptions);
+	const { previews: previewRecords, scopes: scopeRecords, deployments: deploymentRecords } = await loadTrackedRegistryRows(registry, options.workerName, options.apiOptions);
+	const previewRecordByVersionId = new Map(previewRecords.map((record) => [record.versionId, record]));
+	const previewScopeRecordByScope = new Map(scopeRecords.map((record) => [record.scope, record]));
+	const deploymentRecordById = new Map(deploymentRecords.map((record) => [record.deploymentId, record]));
+	const syncedPreviews = [];
+	const syncedScopes = [];
+	const syncedDeployments = [];
+	const versionMetadataMap = new Map(liveVersions.map((version) => [version.id, version]));
+	const previewVersions = [...liveVersions.filter((candidate) => candidate.metadata.hasPreview)];
+	if (options.versionId && (options.previewUrl || options.previewScopeUrl || options.previewScope) && !previewVersions.some((version) => version.id === options.versionId)) {
+		const explicitPreviewVersion = await getVersionInfoById(options.accountId, options.workerName, options.versionId, versionMetadataMap, options.apiOptions);
+		if (explicitPreviewVersion) previewVersions.unshift({
+			...explicitPreviewVersion,
+			metadata: {
+				...explicitPreviewVersion.metadata,
+				hasPreview: true
+			}
+		});
+	}
+	for (const version of previewVersions) {
+		const previewRecord = buildPreviewRecord({
+			accountId: options.accountId,
+			workerName: options.workerName,
+			version,
+			existing: previewRecordByVersionId.get(version.id),
+			workersSubdomain,
+			...getExplicitPreviewSyncOverrides(options, version.id),
+			source: options.source,
+			now
+		});
+		if (!previewRecord) {
+			options.logger?.warn?.(`Skipping preview registry sync for ${version.id} because no preview URL could be determined.`);
+			continue;
+		}
+		await upsertPreviewRecord(registry, previewRecord, options.apiOptions);
+		syncedPreviews.push(previewRecord);
+		const scopeRecord = buildPreviewScopeRecord({
+			accountId: options.accountId,
+			workerName: options.workerName,
+			previewRecord,
+			existing: previewRecord.scope ? previewScopeRecordByScope.get(previewRecord.scope) : void 0,
+			now
+		});
+		if (scopeRecord) {
+			await upsertPreviewScopeRecord(registry, scopeRecord, options.apiOptions);
+			syncedScopes.push(scopeRecord);
+		}
+		const previewDeploymentRecord = buildPreviewDeploymentRecord({
+			accountId: options.accountId,
+			workerName: options.workerName,
+			previewRecord,
+			existing: deploymentRecordById.get(getPreviewDeploymentId(options.workerName, previewRecord.versionId)),
+			now
+		});
+		await upsertDeploymentRecord(registry, previewDeploymentRecord, options.apiOptions);
+		syncedDeployments.push(previewDeploymentRecord);
+	}
+	for (const [index, deployment] of liveDeployments.entries()) {
+		const versionId = deployment.versions[0]?.versionId;
+		const version = versionId ? await getVersionInfoById(options.accountId, options.workerName, versionId, versionMetadataMap, options.apiOptions) : void 0;
+		const deploymentRecord = buildProductionDeploymentRecord({
+			accountId: options.accountId,
+			workerName: options.workerName,
+			deployment,
+			version,
+			existing: deploymentRecordById.get(deployment.id),
+			workersSubdomain,
+			source: options.source,
+			commitSha: versionId === options.versionId ? options.commitSha : void 0,
+			deploymentMessage: index === 0 ? options.deploymentMessage : void 0,
+			status: index === 0 ? "active" : "superseded",
+			now
+		});
+		if (!deploymentRecord) continue;
+		await upsertDeploymentRecord(registry, deploymentRecord, options.apiOptions);
+		syncedDeployments.push(deploymentRecord);
+	}
+	return {
+		registry,
+		previews: syncedPreviews,
+		previewScopes: syncedScopes,
+		deployments: syncedDeployments
+	};
+}
+async function cleanupPreviewRegistry(options) {
+	const now = options.now ?? /* @__PURE__ */ new Date();
+	const registry = await ensurePreviewRegistry({
+		accountId: options.accountId,
+		databaseName: options.databaseName,
+		apiOptions: options.apiOptions,
+		logger: options.logger
+	});
+	const { previews, scopes, deployments } = await loadTrackedRegistryRows(registry, options.workerName, options.apiOptions);
+	const cutoff = /* @__PURE__ */ new Date(now.getTime() - Math.max(options.days ?? 7, 0) * 24 * 60 * 60 * 1e3);
+	const previewCandidates = previews.filter((record) => !record.deletedAt && record.createdAt <= cutoff && record.status !== "active");
+	const scopeCandidates = scopes.filter((record) => !record.deletedAt && record.createdAt <= cutoff && record.status !== "active");
+	const deploymentCandidates = deployments.filter((record) => !record.deletedAt && record.createdAt <= cutoff && record.status !== "active");
+	if (options.apply) await applyDeletedRecords(registry, {
+		previews: previewCandidates,
+		scopes: scopeCandidates,
+		deployments: deploymentCandidates,
+		now,
+		apiOptions: options.apiOptions
+	});
+	return {
+		registry,
+		previews,
+		scopes,
+		deployments,
+		candidates: {
+			previews: previewCandidates,
+			scopes: scopeCandidates,
+			deployments: deploymentCandidates
+		},
+		applied: options.apply === true
+	};
+}
+async function retirePreviewRegistry(options) {
+	if (!hasRetireSelector(options)) throw new Error("Retiring preview registry records requires at least one selector: branchName, previewScope, versionId, or commitSha.");
+	const now = options.now ?? /* @__PURE__ */ new Date();
+	const registry = await ensurePreviewRegistry({
+		accountId: options.accountId,
+		databaseName: options.databaseName,
+		apiOptions: options.apiOptions,
+		logger: options.logger
+	});
+	const { previews, scopes, deployments } = await loadTrackedRegistryRows(registry, options.workerName, options.apiOptions);
+	const directlyMatchedPreviews = previews.filter((record) => !record.deletedAt && matchesPreviewRetireTarget(record, options));
+	const directlyMatchedScopes = scopes.filter((record) => !record.deletedAt && matchesPreviewScopeRetireTarget(record, options));
+	const directlyMatchedDeployments = deployments.filter((record) => !record.deletedAt && matchesPreviewDeploymentRetireTarget(record, options));
+	const candidatePreviewIds = new Set([...directlyMatchedPreviews.map((record) => record.id), ...directlyMatchedScopes.flatMap((record) => record.previewId ? [record.previewId] : [])]);
+	const candidateVersionIds = new Set([
+		...directlyMatchedPreviews.map((record) => record.versionId),
+		...directlyMatchedScopes.map((record) => record.versionId),
+		...directlyMatchedDeployments.map((record) => record.versionId),
+		...options.versionId ? [options.versionId] : []
+	]);
+	const previewCandidates = previews.filter((record) => {
+		return !record.deletedAt && (matchesPreviewRetireTarget(record, options) || candidatePreviewIds.has(record.id) || candidateVersionIds.has(record.versionId));
+	});
+	const resolvedPreviewIds = new Set(previewCandidates.map((record) => record.id));
+	const resolvedVersionIds = new Set([...candidateVersionIds, ...previewCandidates.map((record) => record.versionId)]);
+	const scopeCandidates = scopes.filter((record) => {
+		return !record.deletedAt && (matchesPreviewScopeRetireTarget(record, options) || resolvedVersionIds.has(record.versionId) || record.previewId !== void 0 && resolvedPreviewIds.has(record.previewId));
+	});
+	for (const record of scopeCandidates) {
+		resolvedVersionIds.add(record.versionId);
+		if (record.previewId) resolvedPreviewIds.add(record.previewId);
+	}
+	const deploymentCandidates = deployments.filter((record) => {
+		return !record.deletedAt && record.channel === "preview" && (matchesPreviewDeploymentRetireTarget(record, options) || resolvedVersionIds.has(record.versionId) || record.previewId !== void 0 && resolvedPreviewIds.has(record.previewId));
+	});
+	if (options.apply) await applyDeletedRecords(registry, {
+		previews: previewCandidates,
+		scopes: scopeCandidates,
+		deployments: deploymentCandidates,
+		now,
+		apiOptions: options.apiOptions
+	});
+	return {
+		registry,
+		previews,
+		scopes,
+		deployments,
+		candidates: {
+			previews: previewCandidates,
+			scopes: scopeCandidates,
+			deployments: deploymentCandidates
+		},
+		applied: options.apply === true
+	};
+}
+//#endregion
+export { deleteWorker as C, listWorkerVersions as D, listWorkerDeployments as E, listWorkers as O, DEVFLARE_PREVIEW_REGISTRY_DATABASE as S, getWorkersSubdomain as T, devflarePreviewScopeRecordSchema as _, listTrackedPreviewRecords as a, devflareRecordSourceSchema as b, reconcilePreviewRegistry as c, devflareAccountLayerRecordSchema as d, devflareAccountRecordSchema as f, devflarePreviewRecordSchema as g, devflareDeploymentStatusSchema as h, listTrackedDeploymentRecords as i, renameWorker as k, retirePreviewRegistry as l, devflareDeploymentRecordSchema as m, ensurePreviewRegistry as n, listTrackedPreviewScopeRecords as o, devflareDeploymentChannelSchema as p, getPreviewRegistryContext as r, listTrackedRegistryState as s, cleanupPreviewRegistry as t, createDevflareAccountRecordSchema as u, devflarePreviewScopeStatusSchema as v, getWorkerVersionDetail as w, formatWorkersDevUrl as x, devflarePreviewStatusSchema as y };