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

package/dist/previews-j9ymq4ys.js

@@ -0,0 +1,1169 @@
+import {
+  findConfigPathsUnderDirectory
+} from "./index-9az6s7ad.js";
+import {
+  buildPreviewScopeRowsFromLiveWorkers,
+  buildPreviewWorkerCandidatesByScope,
+  buildStableWorkerRowsFromLiveWorkers,
+  collectConfiguredWorkerFamilies,
+  formatOverviewStatus,
+  formatRecordDate,
+  loadTrackedPreviewScopeRows,
+  orderPreviewWorkerNamesForDeletion,
+  shouldUseColor
+} from "./index-maxpsfk8.js";
+import {
+  asOptionalString,
+  resolveCloudflareAccountId,
+  resolveNamedSelection
+} from "./index-v5nmqthy.js";
+import {
+  account
+} from "./index-sqrksgb2.js";
+import"./index-72mve6vh.js";
+import {
+  retirePreviewRegistry
+} from "./index-q4kaz181.js";
+import {
+  cleanupPreviewScopedResources
+} from "./index-k6vq6kkt.js";
+import {
+  getDependencies
+} from "./index-1xpj0m4r.js";
+import {
+  bold,
+  cyanBold,
+  dim,
+  formatTableLine,
+  green,
+  logLine,
+  whiteDim,
+  yellowBold
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
+import"./index-7g8zyws4.js";
+import"./index-rbht7m9r.js";
+import {
+  compileConfig
+} from "./index-pnbs1b8k.js";
+import {
+  ConfigNotFoundError,
+  loadConfig,
+  loadResolvedConfig,
+  resolveConfigPath
+} from "./index-6psz1h4c.js";
+import"./index-xk9djfjp.js";
+import"./index-0w826dsr.js";
+import {
+  resolvePreviewIdentifier
+} from "./index-6jef5emv.js";
+import"./index-t08te69w.js";
+import"./index-37x76zdn.js";
+
+// src/cli/preview-bindings.ts
+var WRANGLER_TEXT_COLUMNS_REGEX = /\s{2,}/;
+function normalizeCell(value) {
+  return (value ?? "").trim().replace(/\s+/g, " ");
+}
+function buildAssociationKey(type, resource) {
+  return `${normalizeCell(type).toLowerCase()}\x00${normalizeCell(resource).toLowerCase()}`;
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
+}
+function formatSendEmailResource(entry) {
+  const destination = entry.destination_address?.trim();
+  if (destination) {
+    return destination;
+  }
+  const destinations = uniqueStrings(entry.allowed_destination_addresses ?? []);
+  const senders = uniqueStrings(entry.allowed_sender_addresses ?? []);
+  const destinationLabel = destinations.length > 0 ? destinations.join(", ") : "configured destinations";
+  if (senders.length === 0) {
+    return destinationLabel;
+  }
+  return `${destinationLabel} - senders: ${senders.join(", ")}`;
+}
+function addAssociationTarget(targets, input) {
+  const type = normalizeCell(input.type);
+  const resource = normalizeCell(input.resource);
+  const key = buildAssociationKey(type, resource);
+  const existing = targets.get(key);
+  if (existing) {
+    if (input.reference) {
+      existing.referenceLabels = uniqueStrings([...existing.referenceLabels, input.reference]);
+    }
+    if (input.note) {
+      existing.notes = uniqueStrings([...existing.notes, input.note]);
+    }
+    if (!existing.queueName && input.queueName) {
+      existing.queueName = input.queueName;
+    }
+    return;
+  }
+  targets.set(key, {
+    key,
+    referenceLabels: input.reference ? [input.reference] : [],
+    type,
+    resource,
+    notes: input.note ? [input.note] : [],
+    queueName: input.queueName
+  });
+}
+function collectBindingAssociationTargets(config) {
+  const compiled = compileConfig(config);
+  const targets = new Map;
+  for (const binding of compiled.kv_namespaces ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "KV Namespace",
+      resource: binding.id
+    });
+  }
+  for (const binding of compiled.d1_databases ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "D1 Database",
+      resource: binding.database_id
+    });
+  }
+  for (const binding of compiled.r2_buckets ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "R2 Bucket",
+      resource: binding.bucket_name
+    });
+  }
+  for (const binding of compiled.durable_objects?.bindings ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.name,
+      type: "Durable Object Namespace",
+      resource: binding.class_name,
+      note: binding.script_name ? `script ${binding.script_name}` : undefined
+    });
+  }
+  for (const binding of compiled.queues?.producers ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Queue",
+      resource: binding.queue,
+      note: "producer binding",
+      queueName: binding.queue
+    });
+  }
+  for (const binding of compiled.queues?.consumers ?? []) {
+    addAssociationTarget(targets, {
+      type: "Queue",
+      resource: binding.queue,
+      note: "consumer attachment",
+      queueName: binding.queue
+    });
+    if (binding.dead_letter_queue) {
+      addAssociationTarget(targets, {
+        type: "Queue",
+        resource: binding.dead_letter_queue,
+        note: "dead letter queue",
+        queueName: binding.dead_letter_queue
+      });
+    }
+  }
+  for (const binding of compiled.services ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Worker",
+      resource: binding.entrypoint ? `${binding.service}#${binding.entrypoint}` : binding.service,
+      note: binding.environment ? `env ${binding.environment}` : undefined
+    });
+  }
+  if (compiled.ai?.binding) {
+    addAssociationTarget(targets, {
+      reference: compiled.ai.binding,
+      type: "AI",
+      resource: "Workers AI"
+    });
+  }
+  for (const binding of compiled.vectorize ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Vectorize",
+      resource: binding.index_name
+    });
+  }
+  for (const binding of compiled.hyperdrive ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Hyperdrive",
+      resource: binding.id
+    });
+  }
+  if (compiled.browser?.binding) {
+    addAssociationTarget(targets, {
+      reference: compiled.browser.binding,
+      type: "Browser",
+      resource: "Browser Rendering"
+    });
+  }
+  for (const binding of compiled.analytics_engine_datasets ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.binding,
+      type: "Analytics Engine",
+      resource: binding.dataset
+    });
+  }
+  for (const binding of compiled.send_email ?? []) {
+    addAssociationTarget(targets, {
+      reference: binding.name,
+      type: "Send Email",
+      resource: formatSendEmailResource(binding)
+    });
+  }
+  return Array.from(targets.values());
+}
+function getActiveVersionId(deployments) {
+  const sortedDeployments = [...deployments].sort((left, right) => right.createdOn.getTime() - left.createdOn.getTime());
+  for (const deployment of sortedDeployments) {
+    const version = [...deployment.versions].sort((left, right) => right.percentage - left.percentage)[0];
+    if (version?.versionId) {
+      return version.versionId;
+    }
+  }
+  return;
+}
+function extractWorkerNames(value) {
+  return Array.from(value.matchAll(/worker:([^,\s]+)/gi), (match) => match[1]);
+}
+function parseWranglerQueueInfo(output) {
+  const lines = output.split(/\r?\n/);
+  let queueName = "";
+  const producerWorkers = [];
+  const consumerWorkers = [];
+  let currentSection = null;
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trim();
+    if (!trimmed) {
+      currentSection = null;
+      continue;
+    }
+    const queueMatch = trimmed.match(/^Queue Name:\s*(.+)$/i);
+    if (queueMatch) {
+      queueName = normalizeCell(queueMatch[1]);
+      currentSection = null;
+      continue;
+    }
+    const producerMatch = trimmed.match(/^Producers:\s*(.*)$/i);
+    if (producerMatch) {
+      producerWorkers.push(...extractWorkerNames(producerMatch[1]));
+      currentSection = producerMatch[1] ? null : "producers";
+      continue;
+    }
+    const consumerMatch = trimmed.match(/^Consumers:\s*(.*)$/i);
+    if (consumerMatch) {
+      consumerWorkers.push(...extractWorkerNames(consumerMatch[1]));
+      currentSection = consumerMatch[1] ? null : "consumers";
+      continue;
+    }
+    if (!currentSection) {
+      continue;
+    }
+    const extractedWorkers = extractWorkerNames(trimmed);
+    if (currentSection === "producers") {
+      producerWorkers.push(...extractedWorkers);
+    } else {
+      consumerWorkers.push(...extractedWorkers);
+    }
+  }
+  if (!queueName) {
+    return null;
+  }
+  return {
+    queueName,
+    producerWorkers: uniqueStrings(producerWorkers),
+    consumerWorkers: uniqueStrings(consumerWorkers)
+  };
+}
+function parseWranglerVersionBindings(output) {
+  const lines = output.split(/\r?\n/);
+  const bindings = [];
+  let inBindingTable = false;
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (/^(binding\s+type|type)\s{2,}/i.test(rawLine) || /^(binding\s+type|type)$/i.test(trimmed)) {
+      inBindingTable = true;
+      continue;
+    }
+    if (!inBindingTable) {
+      continue;
+    }
+    if (/^-+$/.test(trimmed)) {
+      continue;
+    }
+    const segments = trimmed.split(WRANGLER_TEXT_COLUMNS_REGEX).filter(Boolean);
+    if (segments.length < 2) {
+      continue;
+    }
+    if (segments[0].endsWith(":")) {
+      break;
+    }
+    const [type, bindingName, ...resourceParts] = segments;
+    if (!type || !bindingName) {
+      continue;
+    }
+    bindings.push({
+      type: normalizeCell(type),
+      bindingName: normalizeCell(bindingName),
+      resource: normalizeCell(resourceParts.join("  "))
+    });
+  }
+  return bindings;
+}
+async function inspectWorkerBindings(exec, options) {
+  const output = await runWranglerInspectionCommand(exec, ["wrangler", "versions", "view", options.versionId, "--name", options.workerName], options, "Wrangler versions view failed");
+  return parseWranglerVersionBindings(output);
+}
+async function runWranglerInspectionCommand(exec, args, options, failureMessage) {
+  const result = await exec.exec("bunx", args, {
+    cwd: options.cwd,
+    env: {
+      ...process.env,
+      CLOUDFLARE_ACCOUNT_ID: options.accountId,
+      FORCE_COLOR: process.env.FORCE_COLOR ?? "0"
+    }
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || result.stdout || failureMessage);
+  }
+  return `${result.stdout}
+${result.stderr}`;
+}
+async function inspectQueueAssociation(exec, options) {
+  const output = await runWranglerInspectionCommand(exec, ["wrangler", "queues", "info", options.queueName], options, "Wrangler queues info failed");
+  return parseWranglerQueueInfo(output);
+}
+function formatReference(target) {
+  return target.referenceLabels.length > 0 ? target.referenceLabels.join(", ") : "—";
+}
+function formatResource(target) {
+  return target.resource || "—";
+}
+function buildRowNotes(target, queueAssociation) {
+  const notes = [...target.notes];
+  if (queueAssociation) {
+    notes.push(`producers ${queueAssociation.producerWorkers.length}`);
+    notes.push(`consumers ${queueAssociation.consumerWorkers.length}`);
+  }
+  return uniqueStrings(notes);
+}
+async function inspectBindingAssociations(options) {
+  const targets = collectBindingAssociationTargets(options.config);
+  const warnings = [];
+  const bindingUsage = new Map;
+  const scannedWorkers = [];
+  const queueTargets = uniqueStrings(targets.map((target) => target.queueName).filter((queueName) => typeof queueName === "string" && queueName.length > 0));
+  const queueAssociations = new Map;
+  const workers = await account.workers(options.accountId, options.apiOptions);
+  for (const worker of workers) {
+    let versionId;
+    try {
+      const deployments = await account.workerDeployments(options.accountId, worker.name, options.apiOptions);
+      versionId = getActiveVersionId(deployments);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push(`Could not resolve active deployment for ${worker.name}: ${message}`);
+      continue;
+    }
+    if (!versionId) {
+      continue;
+    }
+    scannedWorkers.push(worker.name);
+    try {
+      const bindings = await inspectWorkerBindings(options.exec, {
+        accountId: options.accountId,
+        workerName: worker.name,
+        versionId,
+        cwd: options.cwd
+      });
+      for (const binding of bindings) {
+        const key = buildAssociationKey(binding.type, binding.resource);
+        const connectedWorkers = bindingUsage.get(key) ?? new Set;
+        connectedWorkers.add(worker.name);
+        bindingUsage.set(key, connectedWorkers);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push(`Could not inspect bindings for ${worker.name}: ${message}`);
+    }
+  }
+  for (const queueName of queueTargets) {
+    try {
+      const queueAssociation = await inspectQueueAssociation(options.exec, {
+        accountId: options.accountId,
+        queueName,
+        cwd: options.cwd
+      });
+      if (queueAssociation) {
+        queueAssociations.set(queueName, queueAssociation);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push(`Could not inspect queue ${queueName}: ${message}`);
+    }
+  }
+  const rows = targets.map((target) => {
+    const queueAssociation = target.queueName ? queueAssociations.get(target.queueName) : undefined;
+    const directlyConnectedWorkers = Array.from(bindingUsage.get(target.key) ?? []);
+    const connectedWorkers = uniqueStrings([
+      ...directlyConnectedWorkers,
+      ...queueAssociation?.producerWorkers ?? [],
+      ...queueAssociation?.consumerWorkers ?? []
+    ]).sort((left, right) => left.localeCompare(right));
+    return {
+      reference: formatReference(target),
+      type: target.type,
+      resource: formatResource(target),
+      workerCount: connectedWorkers.length,
+      connectedWorkers,
+      notes: buildRowNotes(target, queueAssociation),
+      producerWorkers: queueAssociation?.producerWorkers,
+      consumerWorkers: queueAssociation?.consumerWorkers
+    };
+  });
+  return {
+    workerName: options.workerName ?? options.config.name,
+    rows,
+    targets: targets.length,
+    scannedWorkers,
+    warnings
+  };
+}
+
+// src/cli/commands/previews-support/cleanup.ts
+function comparePreviewCleanupScopeNames(left, right) {
+  if (left === "preview" && right !== "preview") {
+    return 1;
+  }
+  if (left !== "preview" && right === "preview") {
+    return -1;
+  }
+  return left.localeCompare(right);
+}
+function buildPreviewCleanupTarget(scope, scopeRows, workerCandidatesByScope, environment) {
+  const strategies = new Set;
+  const workerNames = [...workerCandidatesByScope.get(scope) ?? []];
+  for (const row of scopeRows) {
+    if (row.scope === scope) {
+      strategies.add(row.strategy);
+    }
+  }
+  if (workerNames.length > 0) {
+    strategies.add("dedicated workers");
+  }
+  if (scope === "preview" && environment === "preview") {
+    strategies.add("default preview scope");
+  }
+  return {
+    scope,
+    strategies: Array.from(strategies),
+    workerNames
+  };
+}
+function buildPreviewCleanupTargets(scopeRows, workerCandidatesByScope, environment) {
+  const scopeNames = new Set;
+  for (const row of scopeRows) {
+    scopeNames.add(row.scope);
+  }
+  for (const scope of workerCandidatesByScope.keys()) {
+    scopeNames.add(scope);
+  }
+  if (environment === "preview") {
+    scopeNames.add("preview");
+  }
+  return Array.from(scopeNames).sort(comparePreviewCleanupScopeNames).map((scope) => buildPreviewCleanupTarget(scope, scopeRows, workerCandidatesByScope, environment));
+}
+function getPreviewCleanupResourceCandidateCount(result) {
+  return result.candidates.kv.length + result.candidates.d1.length + result.candidates.r2.length + result.candidates.queues.length + result.candidates.vectorize.length + result.candidates.hyperdrive.length;
+}
+function buildPreviewCleanupResourceSummary(result) {
+  return [
+    result.candidates.kv.length > 0 ? `KV ${result.candidates.kv.length}` : null,
+    result.candidates.d1.length > 0 ? `D1 ${result.candidates.d1.length}` : null,
+    result.candidates.r2.length > 0 ? `R2 ${result.candidates.r2.length}` : null,
+    result.candidates.queues.length > 0 ? `Queues ${result.candidates.queues.length}` : null,
+    result.candidates.vectorize.length > 0 ? `Vectorize ${result.candidates.vectorize.length}` : null,
+    result.candidates.hyperdrive.length > 0 ? `Hyperdrive ${result.candidates.hyperdrive.length}` : null
+  ].filter((segment) => segment !== null);
+}
+function logResolvedPreviewScopes(logger, targets, theme) {
+  if (targets.length === 0) {
+    logLine(logger, `${dim("preview scopes", theme)} ${dim("none discovered (--all)", theme)}`);
+    logLine(logger);
+    return;
+  }
+  logLine(logger, `${dim("preview scopes", theme)} ${green(targets.map((target) => target.scope).join(", "), theme)} ${dim("(--all)", theme)}`);
+  logLine(logger);
+}
+function logPreviewCleanupScopeBreakdown(logger, executions, theme) {
+  const scopedExecutions = executions.filter((execution) => execution.target);
+  if (scopedExecutions.length === 0) {
+    return;
+  }
+  logLine(logger, `${dim("scope breakdown", theme)}`);
+  for (const execution of scopedExecutions) {
+    const target = execution.target;
+    const strategies = target.strategies.length > 0 ? dim(`(${target.strategies.join(" + ")})`, theme) : "";
+    const summary = [
+      target.workerNames.length > 0 ? `Workers ${target.workerNames.length}` : null,
+      ...buildPreviewCleanupResourceSummary(execution.result)
+    ].filter((segment) => segment !== null);
+    logLine(logger, `  ${green(target.scope, theme)} ${strategies} ${dim("—", theme)} ${summary.length > 0 ? summary.join(" · ") : dim("none", theme)}`);
+  }
+  logLine(logger);
+}
+async function retireDeletedPreviewWorkers(accountId, databaseName, scope, workerNames) {
+  const registry = await account.getPreviewRegistryContext({
+    accountId,
+    databaseName,
+    apiOptions: { timeout: 1e4 },
+    skipContextCache: true
+  });
+  if (!registry) {
+    return;
+  }
+  for (const workerName of workerNames) {
+    await retirePreviewRegistry({
+      accountId,
+      workerName,
+      databaseName,
+      apiOptions: { timeout: 1e4 },
+      branchName: scope,
+      previewAlias: scope,
+      apply: true
+    });
+  }
+}
+function showNoPreviewCleanupCandidatesHint(logger, selection, includeAll, theme) {
+  if (includeAll) {
+    logger.warn("No preview-only resources or dedicated preview Worker scripts were discovered across the resolved preview scopes. This usually means those previews were already cleaned up or the remaining previews only share stable Workers and shared account resources.");
+    return;
+  }
+  if (!selection?.identifier) {
+    return;
+  }
+  if (selection.source === "environment") {
+    logger.warn(`No preview-only resources or dedicated preview Worker scripts matched the default "${selection.identifier}" scope. If your previews use branch-style scopes such as "next" or "pr-1", rerun with --scope <name>, use --all, or set DEVFLARE_PREVIEW_BRANCH, DEVFLARE_PREVIEW_PR, or DEVFLARE_PREVIEW_IDENTIFIER.`);
+    return;
+  }
+  logger.warn(`No preview-only resources or dedicated preview Worker scripts matched the resolved "${selection.identifier}" scope. This usually means that scope was already cleaned up or the preview shares stable Workers without preview.scope() resources of its own.`);
+}
+
+// src/cli/commands/previews-support/render.ts
+function logWorkerFamilyHeader(logger, families, theme) {
+  const primaryFamily = families.find((family) => family.role === "primary") ?? families[0];
+  const relatedFamilies = families.filter((family) => family.role !== "primary");
+  logLine(logger, `${dim("worker family", theme)} ${green(primaryFamily?.baseName ?? "unknown", theme)}`);
+  if (relatedFamilies.length > 0) {
+    logLine(logger, `${dim("related workers", theme)} ${whiteDim(String(relatedFamilies.length), theme)}`);
+  }
+  logLine(logger);
+}
+function logSection(logger, title, records, columns, theme) {
+  for (const line of buildSectionLines(title, records, columns, theme)) {
+    logLine(logger, line);
+  }
+}
+function logLiveWorkerFamilyOverview(logger, families, workers, workersSubdomain, theme) {
+  const stableRows = buildStableWorkerRowsFromLiveWorkers(families, workers, workersSubdomain);
+  const previewScopeRows = buildPreviewScopeRowsFromLiveWorkers(families, workers, workersSubdomain);
+  logWorkerFamilyHeader(logger, families, theme);
+  logSection(logger, "Stable workers", stableRows, buildStableWorkerColumns(theme), theme);
+  logLine(logger);
+  if (previewScopeRows.length === 0) {
+    logLine(logger, dim("No dedicated preview scopes found for this worker family.", theme));
+  } else {
+    logSection(logger, "Preview scopes", previewScopeRows, buildPreviewScopeColumns(theme), theme);
+  }
+}
+function buildStableWorkerColumns(theme) {
+  return [
+    {
+      label: "Worker",
+      width: 34,
+      value: (row) => row.workerName
+    },
+    {
+      label: "Role",
+      width: 20,
+      value: (row) => row.role
+    },
+    {
+      label: "Status",
+      width: 8,
+      value: (row) => formatOverviewStatus(row.status, theme)
+    },
+    {
+      label: "Updated",
+      width: 19,
+      value: (row) => whiteDim(formatRecordDate(row.updatedAt), theme)
+    },
+    {
+      label: "URL",
+      value: (row) => row.url ?? "N/A"
+    }
+  ];
+}
+function buildPreviewScopeColumns(theme) {
+  return [
+    {
+      label: "Scope",
+      width: 18,
+      value: (row) => row.scope
+    },
+    {
+      label: "Strategy",
+      width: 18,
+      value: (row) => row.strategy
+    },
+    {
+      label: "Workers",
+      width: 7,
+      value: (row) => row.workersLabel
+    },
+    {
+      label: "Status",
+      width: 10,
+      value: (row) => formatOverviewStatus(row.status, theme)
+    },
+    {
+      label: "Updated",
+      width: 19,
+      value: (row) => whiteDim(formatRecordDate(row.updatedAt), theme)
+    },
+    {
+      label: "Notes",
+      width: 30,
+      value: (row) => row.notes ?? dim("—", theme)
+    },
+    {
+      label: "Entry URL",
+      value: (row) => row.entryUrl ?? "N/A"
+    }
+  ];
+}
+function buildSectionLines(title, records, columns, theme) {
+  if (records.length === 0) {
+    return [];
+  }
+  const widths = columns.map((column) => column.width);
+  const coloredTitle = title === "Previews" || title === "Preview scopes" ? cyanBold(title, theme) : title === "Aliases" || title === "Stable workers" ? bold(title, theme) : yellowBold(title, theme);
+  return [
+    `${coloredTitle} ${dim(`(${records.length})`, theme)}`,
+    formatTableLine(columns.map((column) => dim(column.label, theme)), widths),
+    ...records.map((record) => formatTableLine(columns.map((column) => column.value(record)), widths))
+  ];
+}
+function showWorkerFamilyOverviewFromLiveWorkers(families, workers, workersSubdomain, logger, theme) {
+  logLine(logger);
+  logLiveWorkerFamilyOverview(logger, families, workers, workersSubdomain, theme);
+  logLine(logger);
+  logLine(logger, dim("Preview scopes are derived from live worker names and the current config family.", theme));
+  logLine(logger, dim("Use `devflare previews cleanup --scope <name>` to delete one scope or `--all` to clean every discovered scope.", theme));
+  logLine(logger);
+}
+function showWorkspaceWorkerFamilyOverviewFromLiveWorkers(familyGroups, workers, workersSubdomain, logger, theme) {
+  logLine(logger);
+  logLine(logger, `${dim("configured worker families", theme)} ${whiteDim(String(familyGroups.length), theme)}`);
+  logLine(logger);
+  for (const [index, families] of familyGroups.entries()) {
+    if (index > 0) {
+      logLine(logger);
+    }
+    logLiveWorkerFamilyOverview(logger, families, workers, workersSubdomain, theme);
+  }
+  logLine(logger);
+  logLine(logger, dim("Preview scopes are derived from live worker names and each discovered config family.", theme));
+  logLine(logger, dim("Run inside a configured package or pass `--config <path>` to narrow the summary or clean one family.", theme));
+  logLine(logger);
+}
+function buildBindingAssociationColumns(theme) {
+  return [
+    {
+      label: "Reference",
+      width: 24,
+      value: (row) => row.reference
+    },
+    {
+      label: "Type",
+      width: 24,
+      value: (row) => row.type
+    },
+    {
+      label: "Resource",
+      width: 36,
+      value: (row) => row.resource
+    },
+    {
+      label: "Workers",
+      width: 7,
+      value: (row) => String(row.workerCount)
+    },
+    {
+      label: "Notes",
+      width: 28,
+      value: (row) => row.notes.length > 0 ? row.notes.join(" · ") : dim("—", theme)
+    },
+    {
+      label: "Connected workers",
+      value: (row) => row.connectedWorkers.length > 0 ? row.connectedWorkers.join(", ") : dim("—", theme)
+    }
+  ];
+}
+function showBindingAssociations(logger, inspection, theme) {
+  logLine(logger);
+  logLine(logger, `${dim("worker family", theme)} ${green(inspection.workerName, theme)}`);
+  logLine(logger, `${dim("resolved targets", theme)} ${whiteDim(String(inspection.targets), theme)}`);
+  logLine(logger, `${dim("active deployments scanned", theme)} ${whiteDim(String(inspection.scannedWorkers.length), theme)}`);
+  if (inspection.rows.length === 0) {
+    logLine(logger);
+    logLine(logger, dim("No binding or resource targets were resolved from the current config.", theme));
+    logLine(logger);
+    return;
+  }
+  logLine(logger);
+  logSection(logger, "Bindings", inspection.rows, buildBindingAssociationColumns(theme), theme);
+  if (inspection.warnings.length > 0) {
+    logLine(logger);
+    for (const warning of inspection.warnings) {
+      logger.warn(warning);
+    }
+  }
+  logLine(logger);
+}
+
+// src/cli/commands/previews-support/types.ts
+var PREVIEW_SUBCOMMANDS = ["list", "bindings", "cleanup"];
+
+// src/cli/commands/previews.ts
+var CLI_API_OPTIONS = {
+  timeout: 1e4
+};
+function compareConfiguredWorkerFamilies(left, right) {
+  if (left.role === "primary" && right.role !== "primary") {
+    return -1;
+  }
+  if (left.role !== "primary" && right.role === "primary") {
+    return 1;
+  }
+  return left.baseName.localeCompare(right.baseName);
+}
+function sortConfiguredWorkerFamilies(families) {
+  return [...families].sort(compareConfiguredWorkerFamilies);
+}
+function resolvePrimaryWorkerFamilyName(families) {
+  return families.find((family) => family.role === "primary")?.baseName ?? families[0]?.baseName;
+}
+function shouldReplaceConfiguredWorkerFamily(existing, candidate) {
+  return !existing || candidate.role === "primary" && existing.role !== "primary";
+}
+function mergeConfiguredWorkerFamilies(existing, candidates) {
+  const merged = new Map(existing.map((family) => [family.baseName, family]));
+  for (const candidate of candidates) {
+    if (shouldReplaceConfiguredWorkerFamily(merged.get(candidate.baseName), candidate)) {
+      merged.set(candidate.baseName, candidate);
+    }
+  }
+  return sortConfiguredWorkerFamilies(Array.from(merged.values()));
+}
+function comparePreviewConfiguredFamilyGroups(left, right) {
+  const leftName = resolvePrimaryWorkerFamilyName(left.families) ?? left.configPath ?? "";
+  const rightName = resolvePrimaryWorkerFamilyName(right.families) ?? right.configPath ?? "";
+  return leftName.localeCompare(rightName);
+}
+function upsertPreviewConfiguredFamilyGroup(groups, candidate) {
+  const primaryFamilyName = resolvePrimaryWorkerFamilyName(candidate.families);
+  const groupKey = primaryFamilyName ?? candidate.configPath ?? `group-${groups.size}`;
+  const existing = groups.get(groupKey);
+  if (!existing) {
+    groups.set(groupKey, {
+      ...candidate,
+      families: sortConfiguredWorkerFamilies(candidate.families)
+    });
+    return;
+  }
+  groups.set(groupKey, {
+    accountId: existing.accountId ?? candidate.accountId,
+    configPath: existing.configPath ?? candidate.configPath,
+    families: mergeConfiguredWorkerFamilies(existing.families, candidate.families)
+  });
+}
+async function discoverPreviewListConfigs(cwd, configFile, environment) {
+  const groups = new Map;
+  const accountIds = new Set;
+  const loadAndCollect = async (candidateConfigFile) => {
+    try {
+      const config = await loadConfig({ cwd, configFile: candidateConfigFile });
+      const families = collectConfiguredWorkerFamilies(config, environment);
+      const accountId = config.accountId?.trim() || undefined;
+      if (accountId) {
+        accountIds.add(accountId);
+      }
+      upsertPreviewConfiguredFamilyGroup(groups, {
+        accountId,
+        configPath: candidateConfigFile,
+        families
+      });
+      return true;
+    } catch (error) {
+      if (error instanceof ConfigNotFoundError) {
+        return false;
+      }
+      throw error;
+    }
+  };
+  if (configFile) {
+    await loadAndCollect(configFile);
+  } else {
+    const directConfigPath = await resolveConfigPath(cwd);
+    const loadedDirectly = directConfigPath ? await loadAndCollect() : false;
+    if (!loadedDirectly) {
+      const configPaths = await findConfigPathsUnderDirectory(cwd);
+      for (const configPath of configPaths) {
+        await loadAndCollect(configPath);
+      }
+    }
+  }
+  return {
+    accountIds: Array.from(accountIds).sort((left, right) => left.localeCompare(right)),
+    familyGroups: Array.from(groups.values()).sort(comparePreviewConfiguredFamilyGroups)
+  };
+}
+function isPreviewSubcommand(value) {
+  return PREVIEW_SUBCOMMANDS.includes(value);
+}
+function resolvePreviewScopeSelection(parsed, environment) {
+  const explicitScope = asOptionalString(parsed.options.scope) || asOptionalString(parsed.options.identifier);
+  if (explicitScope) {
+    return {
+      identifier: resolvePreviewIdentifier({ identifier: explicitScope }).identifier,
+      source: "scope-option"
+    };
+  }
+  const resolved = resolvePreviewIdentifier({
+    environment,
+    env: process.env
+  });
+  return {
+    identifier: resolved.identifier,
+    source: resolved.source
+  };
+}
+function formatPreviewScopeSource(source) {
+  switch (source) {
+    case "scope-option":
+      return "--scope";
+    case "identifier":
+      return "explicit identifier";
+    case "env-identifier":
+      return "DEVFLARE_PREVIEW_IDENTIFIER";
+    case "env-pr":
+      return "DEVFLARE_PREVIEW_PR";
+    case "env-branch":
+      return "DEVFLARE_PREVIEW_BRANCH";
+    case "environment":
+      return "default preview scope";
+    default:
+      return "no explicit preview scope";
+  }
+}
+function logResolvedPreviewScope(logger, selection, theme) {
+  if (!selection.identifier) {
+    return;
+  }
+  logLine(logger, `${dim("preview scope", theme)} ${green(selection.identifier, theme)} ${dim(`(${formatPreviewScopeSource(selection.source)})`, theme)}`);
+  logLine(logger);
+}
+async function loadLocalConfig(cwd, configFile, needsConfig) {
+  if (!needsConfig) {
+    return;
+  }
+  if (!configFile) {
+    const resolvedConfigPath = await resolveConfigPath(cwd);
+    if (!resolvedConfigPath) {
+      return;
+    }
+    try {
+      const config = await loadConfig({
+        cwd
+      });
+      return {
+        accountId: config.accountId,
+        name: config.name
+      };
+    } catch (error) {
+      if (error instanceof ConfigNotFoundError) {
+        return;
+      }
+      throw error;
+    }
+  }
+  try {
+    const config = await loadConfig({
+      cwd,
+      configFile
+    });
+    return {
+      accountId: config.accountId,
+      name: config.name
+    };
+  } catch (error) {
+    if (error instanceof ConfigNotFoundError) {
+      return;
+    }
+    throw error;
+  }
+}
+async function resolveAccountId(parsed, config) {
+  return resolveCloudflareAccountId({
+    explicitAccountId: asOptionalString(parsed.options.account),
+    configuredAccountId: config?.accountId,
+    apiOptions: CLI_API_OPTIONS
+  });
+}
+function resolveWorkerName(parsed, config) {
+  const selection = resolveNamedSelection({
+    explicitValue: asOptionalString(parsed.options.worker),
+    configuredValue: config?.name
+  });
+  return {
+    workerName: selection.value,
+    source: selection.source
+  };
+}
+async function resolveContext(parsed, options, subcommand) {
+  const cwd = options.cwd ?? process.cwd();
+  const configFile = asOptionalString(parsed.options.config);
+  const explicitAccountId = asOptionalString(parsed.options.account);
+  const environment = asOptionalString(parsed.options.env);
+  if (subcommand === "list") {
+    const listDiscovery = await discoverPreviewListConfigs(cwd, configFile, environment);
+    if (!explicitAccountId && listDiscovery.accountIds.length > 1) {
+      throw new Error("Multiple Cloudflare account ids were discovered across local Devflare configs. Pass --account to select one account explicitly for `devflare previews`.");
+    }
+    const accountId2 = await resolveCloudflareAccountId({
+      explicitAccountId,
+      configuredAccountId: listDiscovery.accountIds[0],
+      apiOptions: CLI_API_OPTIONS
+    });
+    if (!accountId2) {
+      throw new Error("No Cloudflare account could be resolved. Use --account or configure accountId in devflare.config.*.");
+    }
+    return {
+      accountId: accountId2,
+      workerName: undefined,
+      workerNameSource: "none",
+      config: undefined,
+      listDiscovery
+    };
+  }
+  const needsConfig = subcommand === "cleanup" || subcommand === "bindings" || !explicitAccountId;
+  const config = await loadLocalConfig(cwd, configFile, needsConfig);
+  if (needsConfig && !config) {
+    throw new Error("Preview commands now inspect and clean dedicated preview workers for the current package. Run inside a configured package or pass --config <path>.");
+  }
+  const accountId = await resolveAccountId(parsed, config);
+  const workerSelection = resolveWorkerName(parsed, config);
+  if (!accountId) {
+    throw new Error("No Cloudflare account could be resolved. Use --account or configure accountId in devflare.config.*.");
+  }
+  return {
+    accountId,
+    workerName: workerSelection.workerName,
+    workerNameSource: workerSelection.source,
+    config
+  };
+}
+async function runBindingsSubcommand(parsed, context, logger, options, environment, configFile, theme) {
+  const cwd = options.cwd ?? process.cwd();
+  const previewScope = resolvePreviewScopeSelection(parsed, environment);
+  logResolvedPreviewScope(logger, previewScope, theme);
+  const resolvedConfig = await loadResolvedConfig({
+    cwd,
+    configFile,
+    environment,
+    identifier: previewScope.identifier,
+    accountId: context.accountId
+  });
+  const deps = await getDependencies();
+  const inspection = await inspectBindingAssociations({
+    accountId: context.accountId,
+    config: resolvedConfig,
+    workerName: context.workerName ?? resolvedConfig.name,
+    cwd,
+    exec: deps.exec,
+    apiOptions: CLI_API_OPTIONS
+  });
+  showBindingAssociations(logger, inspection, theme);
+  return { exitCode: 0 };
+}
+async function runCleanupSubcommand(parsed, context, logger, options, databaseName, environment, configFile, includeAll, theme) {
+  const cwd = options.cwd ?? process.cwd();
+  const resolvedEnvironment = environment ?? "preview";
+  const explicitScope = asOptionalString(parsed.options.scope) || asOptionalString(parsed.options.identifier);
+  if (includeAll && explicitScope) {
+    logger.error("Choose either --scope <name> or --all for preview cleanup, not both.");
+    return { exitCode: 1 };
+  }
+  const previewScope = resolvePreviewScopeSelection(parsed, resolvedEnvironment);
+  const config = await loadConfig({ cwd, configFile });
+  const configuredFamilies = collectConfiguredWorkerFamilies(config, resolvedEnvironment);
+  const liveWorkers = await account.workers(context.accountId, CLI_API_OPTIONS);
+  const workerCandidatesByScope = buildPreviewWorkerCandidatesByScope(configuredFamilies, liveWorkers);
+  const trackedScopeRows = includeAll || previewScope.identifier ? await loadTrackedPreviewScopeRows(context.accountId, databaseName, configuredFamilies, CLI_API_OPTIONS) : [];
+  const cleanupTargets = includeAll ? buildPreviewCleanupTargets(trackedScopeRows, workerCandidatesByScope, resolvedEnvironment) : previewScope.identifier ? [buildPreviewCleanupTarget(previewScope.identifier, trackedScopeRows, workerCandidatesByScope, resolvedEnvironment)] : [];
+  const cleanupRuns = cleanupTargets.length > 0 ? cleanupTargets.map((target) => ({
+    scope: target.scope,
+    target
+  })) : [{
+    scope: previewScope.identifier,
+    target: undefined
+  }];
+  const applyCleanup = parsed.options.apply === true;
+  const executions = [];
+  if (includeAll) {
+    logResolvedPreviewScopes(logger, cleanupTargets, theme);
+  } else {
+    logResolvedPreviewScope(logger, previewScope, theme);
+  }
+  for (const cleanupRun of cleanupRuns) {
+    if (applyCleanup) {
+      const orderedWorkerNames = cleanupRun.target ? orderPreviewWorkerNamesForDeletion(cleanupRun.target.workerNames, cleanupRun.target.scope, configuredFamilies) : [];
+      for (const workerName of orderedWorkerNames) {
+        await account.deleteWorker(context.accountId, workerName, CLI_API_OPTIONS);
+      }
+      if (cleanupRun.target && orderedWorkerNames.length > 0) {
+        await retireDeletedPreviewWorkers(context.accountId, databaseName, cleanupRun.target.scope, orderedWorkerNames);
+      }
+    }
+    const result = await cleanupPreviewScopedResources(config, {
+      environment: resolvedEnvironment,
+      identifier: cleanupRun.scope,
+      accountId: context.accountId,
+      apply: applyCleanup
+    });
+    executions.push({
+      target: cleanupRun.target,
+      result
+    });
+  }
+  const totalWorkerCandidates = executions.reduce((sum, execution) => {
+    return sum + (execution.target?.workerNames.length ?? 0);
+  }, 0);
+  const totalKvCandidates = executions.reduce((sum, execution) => sum + execution.result.candidates.kv.length, 0);
+  const totalD1Candidates = executions.reduce((sum, execution) => sum + execution.result.candidates.d1.length, 0);
+  const totalR2Candidates = executions.reduce((sum, execution) => sum + execution.result.candidates.r2.length, 0);
+  const totalQueueCandidates = executions.reduce((sum, execution) => sum + execution.result.candidates.queues.length, 0);
+  const totalVectorizeCandidates = executions.reduce((sum, execution) => sum + execution.result.candidates.vectorize.length, 0);
+  const totalHyperdriveCandidates = executions.reduce((sum, execution) => sum + execution.result.candidates.hyperdrive.length, 0);
+  const totalResourceCandidates = executions.reduce((sum, execution) => {
+    return sum + getPreviewCleanupResourceCandidateCount(execution.result);
+  }, 0);
+  const totalCandidates = totalWorkerCandidates + totalResourceCandidates;
+  const scopeCountSuffix = includeAll || previewScope.identifier ? ` across ${cleanupRuns.length} preview scope${cleanupRuns.length === 1 ? "" : "s"}` : "";
+  logger.success(applyCleanup ? `Deleted ${totalCandidates} preview-only cleanup candidate${totalCandidates === 1 ? "" : "s"}${scopeCountSuffix}` : `Preview cleanup dry run complete with ${totalCandidates} candidate${totalCandidates === 1 ? "" : "s"}${scopeCountSuffix}`);
+  const resourceSummary = [
+    totalWorkerCandidates > 0 ? `Workers ${totalWorkerCandidates}` : null,
+    totalKvCandidates > 0 ? `KV ${totalKvCandidates}` : null,
+    totalD1Candidates > 0 ? `D1 ${totalD1Candidates}` : null,
+    totalR2Candidates > 0 ? `R2 ${totalR2Candidates}` : null,
+    totalQueueCandidates > 0 ? `Queues ${totalQueueCandidates}` : null,
+    totalVectorizeCandidates > 0 ? `Vectorize ${totalVectorizeCandidates}` : null,
+    totalHyperdriveCandidates > 0 ? `Hyperdrive ${totalHyperdriveCandidates}` : null
+  ].filter((segment) => segment !== null);
+  if (resourceSummary.length > 0) {
+    logger.info(`Candidates: ${resourceSummary.join(" · ")}`);
+  } else {
+    logger.info("Candidates: none");
+    showNoPreviewCleanupCandidatesHint(logger, previewScope, includeAll, theme);
+  }
+  if (includeAll || executions.some((execution) => Boolean(execution.target?.workerNames.length))) {
+    logPreviewCleanupScopeBreakdown(logger, executions, theme);
+  }
+  const warnings = Array.from(new Set(executions.flatMap((execution) => execution.result.warnings)));
+  for (const warning of warnings) {
+    logger.warn(warning);
+  }
+  return { exitCode: 0 };
+}
+async function runListSubcommand(context, logger, theme) {
+  const discoveredFamilyGroups = context.listDiscovery?.familyGroups ?? [];
+  if (discoveredFamilyGroups.length === 0) {
+    throw new Error("Preview listing needs a resolvable devflare config in the current package or workspace so Devflare can identify worker families.");
+  }
+  const matchingFamilyGroups = discoveredFamilyGroups.filter((group) => {
+    return !group.accountId || group.accountId === context.accountId;
+  });
+  if (matchingFamilyGroups.length === 0) {
+    throw new Error(`No configured preview worker families matched Cloudflare account ${context.accountId}. Pass --account or --config <path> to narrow the selection.`);
+  }
+  const liveWorkers = await account.workers(context.accountId, CLI_API_OPTIONS);
+  const workersSubdomain = await account.workersSubdomain(context.accountId, CLI_API_OPTIONS);
+  if (matchingFamilyGroups.length === 1) {
+    showWorkerFamilyOverviewFromLiveWorkers(matchingFamilyGroups[0].families, liveWorkers, workersSubdomain, logger, theme);
+    return { exitCode: 0 };
+  }
+  showWorkspaceWorkerFamilyOverviewFromLiveWorkers(matchingFamilyGroups.map((group) => group.families), liveWorkers, workersSubdomain, logger, theme);
+  return { exitCode: 0 };
+}
+function resolvePreviewSubcommand(rawSubcommand) {
+  if (!rawSubcommand) {
+    return;
+  }
+  if (isPreviewSubcommand(rawSubcommand)) {
+    return rawSubcommand;
+  }
+  return;
+}
+async function runPreviewsCommand(parsed, logger, options) {
+  const isAuth = await account.isAuthenticated();
+  if (!isAuth) {
+    logger.error("Not authenticated with Cloudflare");
+    logger.info("Run `devflare login` first.");
+    return { exitCode: 1 };
+  }
+  const rawSubcommand = parsed.args[0];
+  const subcommand = resolvePreviewSubcommand(rawSubcommand) ?? "list";
+  const includeAll = parsed.options.all === true;
+  const theme = {
+    useColor: shouldUseColor(parsed.options)
+  };
+  if (rawSubcommand && !resolvePreviewSubcommand(rawSubcommand)) {
+    logger.error(`Unknown previews subcommand: ${rawSubcommand}`);
+    logger.info(`Available previews subcommands: ${PREVIEW_SUBCOMMANDS.join(", ")}`);
+    return { exitCode: 1 };
+  }
+  try {
+    const context = await resolveContext(parsed, options, subcommand);
+    const databaseName = asOptionalString(parsed.options.database);
+    const environment = asOptionalString(parsed.options.env);
+    const configFile = asOptionalString(parsed.options.config);
+    switch (subcommand) {
+      case "bindings":
+        return runBindingsSubcommand(parsed, context, logger, options, environment, configFile, theme);
+      case "cleanup":
+        return runCleanupSubcommand(parsed, context, logger, options, databaseName, environment, configFile, includeAll, theme);
+      case "list":
+      default:
+        return runListSubcommand(context, logger, theme);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+      return { exitCode: 1 };
+    }
+    throw error;
+  }
+}
+export {
+  runPreviewsCommand
+};