devflare 1.0.0-next.14 → 1.0.0-next.16

package/dist/index-q4kaz181.js

@@ -0,0 +1,1207 @@
+import {
+  createD1Database,
+  getWorkerVersionDetail,
+  getWorkersSubdomain,
+  listD1Databases,
+  listWorkerDeployments,
+  listWorkerVersions,
+  queryD1Database
+} from "./index-xk9djfjp.js";
+import {
+  CloudflareAPIError
+} from "./index-0w826dsr.js";
+
+// src/cli/preview.ts
+function normalizeWorkersSubdomain(accountSubdomain) {
+  return accountSubdomain.trim().replace(/^https?:\/\//i, "").replace(/\.workers\.dev\/?$/i, "");
+}
+function formatPreviewAliasUrl(alias, workerName, accountSubdomain) {
+  const normalizedSubdomain = normalizeWorkersSubdomain(accountSubdomain);
+  return `https://${alias}-${workerName}.${normalizedSubdomain}.workers.dev`;
+}
+function formatWorkersDevUrl(workerName, accountSubdomain) {
+  const normalizedSubdomain = normalizeWorkersSubdomain(accountSubdomain);
+  return `https://${workerName}.${normalizedSubdomain}.workers.dev`;
+}
+function formatVersionPreviewUrl(versionId, workerName, accountSubdomain) {
+  const normalizedSubdomain = normalizeWorkersSubdomain(accountSubdomain);
+  const versionPrefix = versionId.split("-")[0] || versionId;
+  return `https://${versionPrefix}-${workerName}.${normalizedSubdomain}.workers.dev`;
+}
+function matchNamedValue(output, patterns) {
+  for (const pattern of patterns) {
+    const match = output.match(pattern);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  return;
+}
+function appendUniqueUrls(target, value) {
+  if (typeof value === "string") {
+    if (value.startsWith("http://") || value.startsWith("https://")) {
+      target.push(value);
+    }
+    return;
+  }
+  if (!Array.isArray(value)) {
+    return;
+  }
+  for (const item of value) {
+    appendUniqueUrls(target, item);
+  }
+}
+function parseWranglerStructuredOutput(output) {
+  const records = output.replace(/\r/g, "").split(`
+`).map((line) => line.trim()).filter(Boolean).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((record) => record !== null);
+  const urls = [];
+  let versionId;
+  let previewUrl;
+  for (const record of records) {
+    if (!versionId && typeof record.version_id === "string" && record.version_id.trim()) {
+      versionId = record.version_id.trim();
+    }
+    appendUniqueUrls(urls, record.targets);
+    appendUniqueUrls(urls, record.preview_urls);
+    appendUniqueUrls(urls, record.urls);
+    appendUniqueUrls(urls, record.url);
+    if (!previewUrl && typeof record.preview_url === "string" && record.preview_url.trim()) {
+      previewUrl = record.preview_url.trim();
+    }
+  }
+  const uniqueUrls = [...new Set(urls)];
+  if (!previewUrl) {
+    previewUrl = uniqueUrls.find((url) => url.includes("workers.dev"));
+  }
+  return {
+    versionId,
+    previewUrl,
+    urls: uniqueUrls
+  };
+}
+function mergeParsedWranglerDeployOutputs(...outputs) {
+  const urls = [...new Set(outputs.flatMap((output) => output.urls))];
+  return {
+    versionId: outputs.map((output) => output.versionId).find((value) => Boolean(value)),
+    previewUrl: outputs.map((output) => output.previewUrl).find((value) => Boolean(value)) ?? urls.find((url) => url.includes("workers.dev")),
+    urls
+  };
+}
+function parseWranglerDeployOutput(output) {
+  const normalizedOutput = output.replace(/\r/g, "");
+  const urls = [...new Set(normalizedOutput.match(/https?:\/\/[^\s'"`]+/g) ?? [])];
+  const previewUrl = matchNamedValue(normalizedOutput, [
+    /Preview URL:\s*(https?:\/\/\S+)/i,
+    /Version Preview URL:\s*(https?:\/\/\S+)/i
+  ]) ?? urls.find((url) => url.includes("workers.dev"));
+  const versionId = matchNamedValue(normalizedOutput, [
+    /Worker Version ID:\s*([A-Za-z0-9_-]+)/i,
+    /Version ID:\s*([A-Za-z0-9_-]+)/i,
+    /version(?:_id| id)?\s*[:=]\s*([A-Za-z0-9_-]+)/i,
+    /"id"\s*:\s*"([A-Za-z0-9_-]+)"/i
+  ]);
+  return {
+    versionId,
+    previewUrl,
+    urls
+  };
+}
+
+// src/cloudflare/preview-registry-types.ts
+var DEVFLARE_PREVIEW_REGISTRY_DATABASE = "devflare-registry";
+
+// src/cloudflare/registry-schema.ts
+import { z } from "zod/v4";
+var recordIdSchema = z.string().min(1);
+var cloudflareAccountIdSchema = z.string().min(1);
+var cloudflareVersionIdSchema = z.string().uuid();
+var workerNameSchema = z.string().min(1);
+var timestampSchema = z.coerce.date();
+var urlSchema = z.string().url();
+var branchNameSchema = z.string().min(1);
+var commitShaSchema = z.string().regex(/^[a-f0-9]{7,40}$/i, {
+  message: "Commit SHA must be 7 to 40 hexadecimal characters"
+});
+var previewAliasSchema = 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"
+});
+var cloudflareUserIdSchema = z.union([
+  z.string().min(1),
+  z.number().int().nonnegative().transform((value) => String(value))
+]);
+var 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);
+}
+var devflareRecordSourceSchema = z.enum([
+  "cli",
+  "github-action",
+  "workers-builds",
+  "dashboard",
+  "unknown"
+]);
+var devflarePreviewStatusSchema = z.enum([
+  "active",
+  "superseded",
+  "orphaned",
+  "deleted"
+]);
+var devflarePreviewAliasStatusSchema = z.enum([
+  "active",
+  "reassigned",
+  "deleted"
+]);
+var devflareDeploymentChannelSchema = z.enum([
+  "production",
+  "preview"
+]);
+var devflareDeploymentStatusSchema = z.enum([
+  "active",
+  "superseded",
+  "rolled_back",
+  "deleted"
+]);
+var devflarePreviewRecordSchema = createDevflareAccountRecordSchema({
+  kind: z.literal("preview"),
+  accountId: cloudflareAccountIdSchema,
+  workerName: workerNameSchema,
+  versionId: cloudflareVersionIdSchema,
+  previewUrl: urlSchema,
+  alias: previewAliasSchema.optional(),
+  aliasPreviewUrl: urlSchema.optional(),
+  branchName: branchNameSchema.optional(),
+  commitSha: commitShaSchema.optional(),
+  deploymentId: recordIdSchema.optional(),
+  source: devflareRecordSourceSchema.default("unknown"),
+  status: devflarePreviewStatusSchema.default("active")
+}).superRefine((record, ctx) => {
+  if (record.aliasPreviewUrl && !record.alias) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["aliasPreviewUrl"],
+      message: "aliasPreviewUrl requires alias to be set"
+    });
+  }
+});
+var devflarePreviewAliasRecordSchema = createDevflareAccountRecordSchema({
+  kind: z.literal("previewAlias"),
+  accountId: cloudflareAccountIdSchema,
+  workerName: workerNameSchema,
+  alias: previewAliasSchema,
+  aliasPreviewUrl: urlSchema,
+  versionId: cloudflareVersionIdSchema,
+  previewId: recordIdSchema.optional(),
+  branchName: branchNameSchema.optional(),
+  commitSha: commitShaSchema.optional(),
+  source: devflareRecordSourceSchema.default("unknown"),
+  status: devflarePreviewAliasStatusSchema.default("active")
+});
+var 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"
+    });
+  }
+});
+var devflareAccountLayerRecordSchema = z.discriminatedUnion("kind", [
+  devflarePreviewRecordSchema,
+  devflarePreviewAliasRecordSchema,
+  devflareDeploymentRecordSchema
+]);
+
+// src/cloudflare/preview-registry-cache.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEVFLARE_CACHE_DIR = ".devflare";
+var 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, "\t"), "utf-8");
+  } catch {}
+}
+function getRegistryDatabaseName(databaseName) {
+  return databaseName?.trim() || DEVFLARE_PREVIEW_REGISTRY_DATABASE;
+}
+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: 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);
+}
+
+// src/cloudflare/preview-registry-records.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 getPreviewAliasRecordId(workerName, alias) {
+  return `previewAlias:${workerName}:${alias}`;
+}
+function getPreviewDeploymentId(workerName, versionId) {
+  return `preview:${workerName}:${versionId}`;
+}
+function getDeploymentRecordId(workerName, deploymentId) {
+  return `deployment:${workerName}:${deploymentId}`;
+}
+function hasRetireSelector(options) {
+  return Boolean(options.branchName || options.previewAlias || options.versionId || options.commitSha);
+}
+function matchesRetireSelector(options, candidate) {
+  return options.branchName !== undefined && candidate.branchName === options.branchName || options.previewAlias !== undefined && candidate.previewAlias === options.previewAlias || options.versionId !== undefined && candidate.versionId === options.versionId || options.commitSha !== undefined && candidate.commitSha === options.commitSha;
+}
+function getPreviewRetireCandidate(record) {
+  return {
+    branchName: record.branchName,
+    previewAlias: record.alias,
+    versionId: record.versionId,
+    commitSha: record.commitSha
+  };
+}
+function matchesPreviewRetireTarget(record, options) {
+  return matchesRetireSelector(options, getPreviewRetireCandidate(record));
+}
+function matchesPreviewAliasRetireTarget(record, options) {
+  return matchesRetireSelector(options, getPreviewRetireCandidate(record));
+}
+function matchesPreviewDeploymentRetireTarget(record, options) {
+  return record.channel === "preview" && matchesRetireSelector(options, {
+    versionId: record.versionId,
+    commitSha: record.commitSha
+  });
+}
+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: undefined,
+    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 alias = options.previewAlias ?? options.existing?.alias;
+  const previewUrl = options.previewUrl ?? options.existing?.previewUrl ?? (options.workersSubdomain ? formatVersionPreviewUrl(options.version.id, options.workerName, options.workersSubdomain) : undefined);
+  const aliasPreviewUrl = options.previewAliasUrl ?? options.existing?.aliasPreviewUrl ?? (alias && options.workersSubdomain ? formatPreviewAliasUrl(alias, options.workerName, options.workersSubdomain) : undefined);
+  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: undefined,
+    createdBy: getVersionAuthorId(options.version, options.existing?.createdBy),
+    accountId: options.accountId,
+    workerName: options.workerName,
+    versionId: options.version.id,
+    previewUrl,
+    alias,
+    aliasPreviewUrl,
+    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 buildPreviewAliasRecord(options) {
+  if (!options.previewRecord.alias || !options.previewRecord.aliasPreviewUrl) {
+    return null;
+  }
+  return devflarePreviewAliasRecordSchema.parse({
+    id: getPreviewAliasRecordId(options.workerName, options.previewRecord.alias),
+    kind: "previewAlias",
+    ver: 1,
+    ...createPreviewLinkedRecordBase({
+      accountId: options.accountId,
+      workerName: options.workerName,
+      previewRecord: options.previewRecord,
+      existingCreatedAt: options.existing?.createdAt,
+      now: options.now
+    }),
+    alias: options.previewRecord.alias,
+    aliasPreviewUrl: options.previewRecord.aliasPreviewUrl,
+    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.aliasPreviewUrl ?? 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: undefined,
+    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)
+  });
+}
+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;
+  }
+}
+function markPreviewRecordDeleted(record, now) {
+  return markRecordDeleted(record, now, devflarePreviewRecordSchema);
+}
+function markPreviewAliasRecordDeleted(record, now) {
+  return markRecordDeleted(record, now, devflarePreviewAliasRecordSchema);
+}
+function markDeploymentRecordDeleted(record, now) {
+  return markRecordDeleted(record, now, devflareDeploymentRecordSchema);
+}
+function getExplicitPreviewSyncOverrides(options, versionId) {
+  if (versionId !== options.versionId) {
+    return {};
+  }
+  return {
+    previewAlias: options.previewAlias,
+    previewUrl: options.previewUrl,
+    previewAliasUrl: options.previewAliasUrl,
+    branchName: options.branchName,
+    commitSha: options.commitSha
+  };
+}
+
+// src/cloudflare/preview-registry-store.ts
+var REGISTRY_SCHEMA_STATEMENTS = [
+  `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,
+		alias TEXT,
+		alias_preview_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
+	)`,
+  "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 TABLE IF NOT EXISTS devflare_preview_alias_records (
+		id TEXT PRIMARY KEY,
+		ver INTEGER NOT NULL,
+		account_id TEXT NOT NULL,
+		worker_name TEXT NOT NULL,
+		alias TEXT NOT NULL,
+		alias_preview_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
+	)`,
+  "CREATE INDEX IF NOT EXISTS idx_devflare_preview_alias_records_account_worker ON devflare_preview_alias_records(account_id, worker_name)",
+  "CREATE INDEX IF NOT EXISTS idx_devflare_preview_alias_records_alias ON devflare_preview_alias_records(alias)",
+  `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
+	)`,
+  "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)"
+];
+var schemaEnsuredRegistryIds = new Set;
+async function runQuery(registry, sql, params = [], apiOptions) {
+  const results = await queryD1Database(registry.accountId, registry.databaseId, {
+    sql,
+    params
+  }, apiOptions);
+  return results[0]?.results ?? [];
+}
+async function runStatement(registry, sql, params = [], apiOptions) {
+  await queryD1Database(registry.accountId, registry.databaseId, {
+    sql,
+    params
+  }, apiOptions);
+}
+async function ensurePreviewRegistrySchema(registry, apiOptions) {
+  if (schemaEnsuredRegistryIds.has(registry.databaseId)) {
+    return;
+  }
+  for (const statement of REGISTRY_SCHEMA_STATEMENTS) {
+    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 parseStoredPreviewRecord(row) {
+  return devflarePreviewRecordSchema.parse(JSON.parse(row.payload_json));
+}
+function parseStoredPreviewAliasRecord(row) {
+  return devflarePreviewAliasRecordSchema.parse(JSON.parse(row.payload_json));
+}
+function parseStoredDeploymentRecord(row) {
+  return devflareDeploymentRecordSchema.parse(JSON.parse(row.payload_json));
+}
+async function readPreviewRows(registry, workerName, apiOptions) {
+  const sql = 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";
+  const params = workerName ? [registry.accountId, workerName] : [registry.accountId];
+  const rows = await runQuery(registry, sql, params, apiOptions);
+  return rows.map((row) => parseStoredPreviewRecord(row));
+}
+async function readPreviewAliasRows(registry, workerName, apiOptions) {
+  const sql = workerName ? "SELECT payload_json FROM devflare_preview_alias_records WHERE account_id = ? AND worker_name = ? ORDER BY created_at DESC" : "SELECT payload_json FROM devflare_preview_alias_records WHERE account_id = ? ORDER BY created_at DESC";
+  const params = workerName ? [registry.accountId, workerName] : [registry.accountId];
+  const rows = await runQuery(registry, sql, params, apiOptions);
+  return rows.map((row) => parseStoredPreviewAliasRecord(row));
+}
+async function readDeploymentRows(registry, workerName, apiOptions) {
+  const sql = 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";
+  const params = workerName ? [registry.accountId, workerName] : [registry.accountId];
+  const rows = await runQuery(registry, sql, params, apiOptions);
+  return rows.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,
+			alias,
+			alias_preview_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,
+			alias = excluded.alias,
+			alias_preview_url = excluded.alias_preview_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.alias ?? null,
+    normalizedRecord.aliasPreviewUrl ?? 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 upsertPreviewAliasRecord(registry, record, apiOptions) {
+  const normalizedRecord = devflarePreviewAliasRecordSchema.parse(record);
+  await runStatement(registry, `INSERT INTO devflare_preview_alias_records (
+			id,
+			ver,
+			account_id,
+			worker_name,
+			alias,
+			alias_preview_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,
+			alias = excluded.alias,
+			alias_preview_url = excluded.alias_preview_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.alias,
+    normalizedRecord.aliasPreviewUrl,
+    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);
+}
+
+// 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, aliases, deployments] = await Promise.all([
+    readPreviewRows(registry, workerName, apiOptions),
+    readPreviewAliasRows(registry, workerName, apiOptions),
+    readDeploymentRows(registry, workerName, apiOptions)
+  ]);
+  return {
+    previews,
+    aliases,
+    deployments
+  };
+}
+async function applyDeletedRecords(registry, options) {
+  for (const preview of options.previews) {
+    await upsertPreviewRecord(registry, markPreviewRecordDeleted(preview, options.now), options.apiOptions);
+  }
+  for (const alias of options.aliases) {
+    await upsertPreviewAliasRecord(registry, markPreviewAliasRecordDeleted(alias, 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 databases = await listD1Databases(options.accountId, options.apiOptions);
+  const existing = databases.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) {
+  const existingContext = await getPreviewRegistryContext(options);
+  let registry = existingContext;
+  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 = await ensurePreviewRegistry({
+    accountId: options.accountId,
+    databaseName: options.databaseName,
+    apiOptions: options.apiOptions,
+    skipSchemaIfExisting: true
+  });
+  const { registry: resolvedRegistry, result } = await withRegistryReadRecovery(registry, options.apiOptions, (activeRegistry) => readPreviewRows(activeRegistry, options.workerName, options.apiOptions));
+  return {
+    registry: resolvedRegistry,
+    records: result
+  };
+}
+async function listTrackedPreviewAliasRecords(options) {
+  const registry = await ensurePreviewRegistry({
+    accountId: options.accountId,
+    databaseName: options.databaseName,
+    apiOptions: options.apiOptions,
+    skipSchemaIfExisting: true
+  });
+  const { registry: resolvedRegistry, result } = await withRegistryReadRecovery(registry, options.apiOptions, (activeRegistry) => readPreviewAliasRows(activeRegistry, options.workerName, options.apiOptions));
+  return {
+    registry: resolvedRegistry,
+    records: result
+  };
+}
+async function listTrackedDeploymentRecords(options) {
+  const registry = await ensurePreviewRegistry({
+    accountId: options.accountId,
+    databaseName: options.databaseName,
+    apiOptions: options.apiOptions,
+    skipSchemaIfExisting: true
+  });
+  const { registry: resolvedRegistry, result } = await withRegistryReadRecovery(registry, options.apiOptions, (activeRegistry) => readDeploymentRows(activeRegistry, options.workerName, options.apiOptions));
+  return {
+    registry: resolvedRegistry,
+    records: result
+  };
+}
+async function reconcilePreviewRegistry(options) {
+  const now = options.now ?? 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, aliases: aliasRecords, deployments: deploymentRecords } = await loadTrackedRegistryRows(registry, options.workerName, options.apiOptions);
+  const previewRecordByVersionId = new Map(previewRecords.map((record) => [record.versionId, record]));
+  const previewAliasRecordByAlias = new Map(aliasRecords.map((record) => [record.alias, record]));
+  const deploymentRecordById = new Map(deploymentRecords.map((record) => [record.deploymentId, record]));
+  const syncedPreviews = [];
+  const syncedAliases = [];
+  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.previewAliasUrl || options.previewAlias) && !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 aliasRecord = buildPreviewAliasRecord({
+      accountId: options.accountId,
+      workerName: options.workerName,
+      previewRecord,
+      existing: previewRecord.alias ? previewAliasRecordByAlias.get(previewRecord.alias) : undefined,
+      now
+    });
+    if (aliasRecord) {
+      await upsertPreviewAliasRecord(registry, aliasRecord, options.apiOptions);
+      syncedAliases.push(aliasRecord);
+    }
+    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) : undefined;
+    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 : undefined,
+      deploymentMessage: index === 0 ? options.deploymentMessage : undefined,
+      status: index === 0 ? "active" : "superseded",
+      now
+    });
+    if (!deploymentRecord) {
+      continue;
+    }
+    await upsertDeploymentRecord(registry, deploymentRecord, options.apiOptions);
+    syncedDeployments.push(deploymentRecord);
+  }
+  return {
+    registry,
+    previews: syncedPreviews,
+    previewAliases: syncedAliases,
+    deployments: syncedDeployments
+  };
+}
+async function cleanupPreviewRegistry(options) {
+  const now = options.now ?? new Date;
+  const registry = await ensurePreviewRegistry({
+    accountId: options.accountId,
+    databaseName: options.databaseName,
+    apiOptions: options.apiOptions,
+    logger: options.logger
+  });
+  const { previews, aliases, deployments } = await loadTrackedRegistryRows(registry, options.workerName, options.apiOptions);
+  const cutoff = new Date(now.getTime() - Math.max(options.days ?? 7, 0) * 24 * 60 * 60 * 1000);
+  const previewCandidates = previews.filter((record) => !record.deletedAt && record.createdAt <= cutoff && record.status !== "active");
+  const aliasCandidates = aliases.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,
+      aliases: aliasCandidates,
+      deployments: deploymentCandidates,
+      now,
+      apiOptions: options.apiOptions
+    });
+  }
+  return {
+    registry,
+    previews,
+    aliases,
+    deployments,
+    candidates: {
+      previews: previewCandidates,
+      aliases: aliasCandidates,
+      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, previewAlias, versionId, or commitSha.");
+  }
+  const now = options.now ?? new Date;
+  const registry = await ensurePreviewRegistry({
+    accountId: options.accountId,
+    databaseName: options.databaseName,
+    apiOptions: options.apiOptions,
+    logger: options.logger
+  });
+  const { previews, aliases, deployments } = await loadTrackedRegistryRows(registry, options.workerName, options.apiOptions);
+  const directlyMatchedPreviews = previews.filter((record) => !record.deletedAt && matchesPreviewRetireTarget(record, options));
+  const directlyMatchedAliases = aliases.filter((record) => !record.deletedAt && matchesPreviewAliasRetireTarget(record, options));
+  const directlyMatchedDeployments = deployments.filter((record) => !record.deletedAt && matchesPreviewDeploymentRetireTarget(record, options));
+  const candidatePreviewIds = new Set([
+    ...directlyMatchedPreviews.map((record) => record.id),
+    ...directlyMatchedAliases.flatMap((record) => record.previewId ? [record.previewId] : [])
+  ]);
+  const candidateVersionIds = new Set([
+    ...directlyMatchedPreviews.map((record) => record.versionId),
+    ...directlyMatchedAliases.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 aliasCandidates = aliases.filter((record) => {
+    return !record.deletedAt && (matchesPreviewAliasRetireTarget(record, options) || resolvedVersionIds.has(record.versionId) || record.previewId !== undefined && resolvedPreviewIds.has(record.previewId));
+  });
+  for (const record of aliasCandidates) {
+    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 !== undefined && resolvedPreviewIds.has(record.previewId));
+  });
+  if (options.apply) {
+    await applyDeletedRecords(registry, {
+      previews: previewCandidates,
+      aliases: aliasCandidates,
+      deployments: deploymentCandidates,
+      now,
+      apiOptions: options.apiOptions
+    });
+  }
+  return {
+    registry,
+    previews,
+    aliases,
+    deployments,
+    candidates: {
+      previews: previewCandidates,
+      aliases: aliasCandidates,
+      deployments: deploymentCandidates
+    },
+    applied: options.apply === true
+  };
+}
+
+export { formatWorkersDevUrl, parseWranglerStructuredOutput, mergeParsedWranglerDeployOutputs, parseWranglerDeployOutput, DEVFLARE_PREVIEW_REGISTRY_DATABASE, devflareAccountRecordSchema, createDevflareAccountRecordSchema, devflareRecordSourceSchema, devflarePreviewStatusSchema, devflarePreviewAliasStatusSchema, devflareDeploymentChannelSchema, devflareDeploymentStatusSchema, devflarePreviewRecordSchema, devflarePreviewAliasRecordSchema, devflareDeploymentRecordSchema, devflareAccountLayerRecordSchema, getPreviewRegistryContext, ensurePreviewRegistry, listTrackedRegistryState, listTrackedPreviewRecords, listTrackedPreviewAliasRecords, listTrackedDeploymentRecords, reconcilePreviewRegistry, cleanupPreviewRegistry, retirePreviewRegistry };