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

package/dist/index-mea5bc45.js

@@ -0,0 +1,418 @@
+import {
+  ensureGeneratedDirectory,
+  getGeneratedArtifactPaths
+} from "./index-aabgympv.js";
+import {
+  preparePreviewScopedResourcesForDeploy
+} from "./index-k6vq6kkt.js";
+import {
+  getDependencies
+} from "./index-1xpj0m4r.js";
+import {
+  bundleWorkerEntry
+} from "./index-9fbtk7gv.js";
+import {
+  detectViteProject
+} from "./index-y1d8za14.js";
+import {
+  logLine
+} from "./index-stgn34cr.js";
+import {
+  resolvePackageSpecifier
+} from "./index-82f1z98k.js";
+import {
+  prepareComposedWorkerEntrypoint,
+  resolveEffectiveViteProject,
+  writeGeneratedViteConfig
+} from "./index-74198nxd.js";
+import {
+  compileConfig,
+  isolateViteBuildOutputPaths,
+  rebaseWranglerConfigPaths,
+  writeWranglerConfig
+} from "./index-pnbs1b8k.js";
+import {
+  loadConfig,
+  resolveConfigResources,
+  resolveMaterializedConfigResources
+} from "./index-6psz1h4c.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/cli/deploy-strategy.ts
+function normalizeBranchScope(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+function shouldIncludePreviewCrons(config) {
+  return config.previews?.includeCrons === true;
+}
+function omitQueueConsumers(config) {
+  if (!config.bindings?.queues?.consumers?.length) {
+    return config;
+  }
+  const nextBindings = {
+    ...config.bindings
+  };
+  const nextQueues = {
+    ...nextBindings.queues
+  };
+  delete nextQueues.consumers;
+  if (!nextQueues.producers || Object.keys(nextQueues.producers).length === 0) {
+    delete nextBindings.queues;
+  } else {
+    nextBindings.queues = nextQueues;
+  }
+  return {
+    ...config,
+    bindings: nextBindings
+  };
+}
+function omitCronTriggers(config) {
+  if (!config.triggers?.crons?.length) {
+    return config;
+  }
+  const nextTriggers = {
+    ...config.triggers
+  };
+  delete nextTriggers.crons;
+  if (Object.keys(nextTriggers).length === 0) {
+    const { triggers: _triggers, ...rest } = config;
+    return rest;
+  }
+  return {
+    ...config,
+    triggers: nextTriggers
+  };
+}
+function applyDeploymentStrategy(config, options = {}) {
+  const branchScope = normalizeBranchScope(options.previewBranch) ?? normalizeBranchScope(options.branchName);
+  const isBranchScopedPreviewDeploy = !options.preview && options.environment === "preview" && Boolean(branchScope);
+  if (!isBranchScopedPreviewDeploy) {
+    return {
+      config,
+      strategy: "default",
+      omittedResources: []
+    };
+  }
+  const omittedResources = [];
+  let nextConfig = config;
+  if (nextConfig.bindings?.queues?.consumers?.length) {
+    nextConfig = omitQueueConsumers(nextConfig);
+    omittedResources.push("queue-consumers");
+  }
+  if (!shouldIncludePreviewCrons(nextConfig) && nextConfig.triggers?.crons?.length) {
+    nextConfig = omitCronTriggers(nextConfig);
+    omittedResources.push("cron-triggers");
+  }
+  return {
+    config: nextConfig,
+    strategy: "branch-scoped-preview",
+    branchScope,
+    omittedResources
+  };
+}
+function describeDeploymentStrategy(result) {
+  if (result.strategy !== "branch-scoped-preview" || result.omittedResources.length === 0) {
+    return;
+  }
+  const labels = result.omittedResources.map((resource) => {
+    return resource === "queue-consumers" ? "queue consumers" : "cron triggers";
+  });
+  const formattedLabels = labels.length === 2 ? `${labels[0]} and ${labels[1]}` : labels[0];
+  const scopeSuffix = result.branchScope ? ` (${result.branchScope})` : "";
+  return `Branch-scoped preview deploy detected${scopeSuffix}; omitting shared ${formattedLabels} from the deployed Wrangler config to avoid singleton Cloudflare resource conflicts.`;
+}
+
+// src/cli/commands/build-artifacts.ts
+import { dirname, relative, resolve } from "pathe";
+function summarizePreviewScopedResourceNames(resources) {
+  const segments = [
+    resources.kv.length > 0 ? `KV ${resources.kv.length}` : null,
+    resources.d1.length > 0 ? `D1 ${resources.d1.length}` : null,
+    resources.r2.length > 0 ? `R2 ${resources.r2.length}` : null,
+    resources.queues.length > 0 ? `Queues ${resources.queues.length}` : null,
+    resources.vectorize.length > 0 ? `Vectorize ${resources.vectorize.length}` : null,
+    resources.hyperdrive.length > 0 ? `Hyperdrive ${resources.hyperdrive.length}` : null,
+    resources.analyticsEngine.length > 0 ? `Analytics ${resources.analyticsEngine.length}` : null,
+    resources.browser.length > 0 ? `Browser ${resources.browser.length}` : null
+  ].filter((segment) => segment !== null);
+  return segments.length > 0 ? segments.join(" · ") : null;
+}
+function getBuildArtifactPaths(cwd) {
+  return getGeneratedArtifactPaths(cwd);
+}
+function isNestedPath(parentPath, candidatePath) {
+  const normalizedParentPath = parentPath.replace(/\\/g, "/");
+  const normalizedCandidatePath = candidatePath.replace(/\\/g, "/");
+  return normalizedCandidatePath.startsWith(`${normalizedParentPath}/`);
+}
+function isolateViteBuildOutputPaths2(cwd, wranglerConfig) {
+  return isolateViteBuildOutputPaths(cwd, wranglerConfig);
+}
+function getViteBuildCleanupTargets(cwd, wranglerConfig) {
+  const targets = [];
+  const assetsDirectory = wranglerConfig.assets?.directory;
+  const mainEntry = wranglerConfig.main;
+  if (assetsDirectory) {
+    targets.push(resolve(cwd, assetsDirectory));
+  }
+  if (mainEntry) {
+    const mainEntryPath = resolve(cwd, mainEntry);
+    const isCoveredByAssetsDirectory = targets.some((targetPath) => {
+      return mainEntryPath === targetPath || isNestedPath(targetPath, mainEntryPath);
+    });
+    if (!isCoveredByAssetsDirectory) {
+      targets.push(mainEntryPath);
+    }
+  }
+  return targets;
+}
+function shouldRetryCleanup(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const errorCode = error.code;
+  return errorCode === "EBUSY" || errorCode === "EPERM" || errorCode === "ENOTEMPTY";
+}
+async function getCleanupFileSystem() {
+  return await import("node:fs/promises");
+}
+async function pathExists(cleanupFs, targetPath) {
+  try {
+    await cleanupFs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createDeferredCleanupPath(targetPath, uniqueSuffix) {
+  const suffix = uniqueSuffix ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  return `${targetPath}.devflare-stale-${suffix}`;
+}
+async function tryMoveLockedPathAside(targetPath, logger, cleanupFs) {
+  if (!await pathExists(cleanupFs, targetPath)) {
+    return true;
+  }
+  const deferredCleanupPath = createDeferredCleanupPath(targetPath);
+  try {
+    await cleanupFs.rename(targetPath, deferredCleanupPath);
+  } catch {
+    return false;
+  }
+  logger.warn(`Moved locked build output aside to ${deferredCleanupPath} after repeated cleanup failures; continuing build`);
+  try {
+    await cleanupFs.rm(deferredCleanupPath, {
+      recursive: true,
+      force: true
+    });
+  } catch (error) {
+    const cleanupErrorCode = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "an unknown error";
+    logger.warn(`Deferred cleanup for ${deferredCleanupPath} is still blocked by ${cleanupErrorCode}; you can remove it manually later`);
+  }
+  return true;
+}
+async function removePathWithRetries(targetPath, logger, attempts = 5, cleanupFs) {
+  const fs = cleanupFs ?? await getCleanupFileSystem();
+  let lastError;
+  for (let attempt = 1;attempt <= attempts; attempt++) {
+    try {
+      await fs.rm(targetPath, {
+        recursive: true,
+        force: true
+      });
+      return;
+    } catch (error) {
+      lastError = error;
+      if (!shouldRetryCleanup(error) || attempt === attempts) {
+        break;
+      }
+      logger.warn(`Retrying cleanup for ${targetPath} after ${error.code} (${attempt}/${attempts})`);
+      await new Promise((resolveRetry) => setTimeout(resolveRetry, attempt * 100));
+    }
+  }
+  if (shouldRetryCleanup(lastError) && await tryMoveLockedPathAside(targetPath, logger, fs)) {
+    return;
+  }
+  if (shouldRetryCleanup(lastError)) {
+    const cleanupErrorCode = lastError instanceof Error && "code" in lastError && typeof lastError.code === "string" ? lastError.code : "an unknown error";
+    logger.warn(`Continuing build without pre-clean for ${targetPath} because cleanup is still blocked by ${cleanupErrorCode}`);
+    return;
+  }
+  throw lastError;
+}
+async function cleanupViteBuildOutputs(cwd, wranglerConfig, logger) {
+  const cleanupTargets = getViteBuildCleanupTargets(cwd, wranglerConfig);
+  for (const cleanupTarget of cleanupTargets) {
+    await removePathWithRetries(cleanupTarget, logger);
+  }
+}
+async function writeDeployRedirect(cwd, generatedConfigPath) {
+  const fs = await import("node:fs/promises");
+  const paths = getBuildArtifactPaths(cwd);
+  await ensureGeneratedDirectory(paths.deployDir);
+  const configPath = relative(paths.deployDir, generatedConfigPath).replace(/\\/g, "/");
+  await fs.writeFile(paths.deployRedirectPath, `${JSON.stringify({ configPath }, null, "\t")}
+`, "utf-8");
+}
+async function readDeployRedirect(cwd) {
+  const fs = await import("node:fs/promises");
+  const paths = getBuildArtifactPaths(cwd);
+  try {
+    const rawConfig = await fs.readFile(paths.deployRedirectPath, "utf-8");
+    const parsed = JSON.parse(rawConfig);
+    if (typeof parsed.configPath !== "string" || parsed.configPath.length === 0) {
+      return null;
+    }
+    return resolve(dirname(paths.deployRedirectPath), parsed.configPath);
+  } catch {
+    return null;
+  }
+}
+async function writeGeneratedDeployWranglerConfig(cwd, wranglerConfig, options = {}) {
+  const paths = getBuildArtifactPaths(cwd);
+  await ensureGeneratedDirectory(paths.buildDir, true);
+  const buildConfig = rebaseWranglerConfigPaths(cwd, paths.buildDir, wranglerConfig);
+  if (options.main) {
+    buildConfig.main = options.main;
+  }
+  await writeWranglerConfig(paths.buildDir, buildConfig, "wrangler.jsonc");
+  return paths.buildWranglerConfigPath;
+}
+async function writeGeneratedDevWranglerConfig(cwd, wranglerConfig) {
+  const paths = getGeneratedArtifactPaths(cwd);
+  await ensureGeneratedDirectory(paths.devflareDir, true);
+  const devConfig = rebaseWranglerConfigPaths(cwd, paths.devflareDir, wranglerConfig);
+  await writeWranglerConfig(paths.devflareDir, devConfig, "wrangler.jsonc");
+  return paths.devWranglerConfigPath;
+}
+async function buildWorkerOnlyDeployArtifact(cwd, wranglerConfig, config, logger) {
+  if (!wranglerConfig.main) {
+    return await writeGeneratedDeployWranglerConfig(cwd, wranglerConfig);
+  }
+  const paths = getBuildArtifactPaths(cwd);
+  const bundledMainEntryPath = await bundleWorkerEntry({
+    cwd,
+    inputFile: resolve(cwd, wranglerConfig.main),
+    outFile: paths.buildWorkerPath,
+    rolldownOptions: config.rolldown?.options,
+    sourcemap: config.rolldown?.sourcemap,
+    minify: config.rolldown?.minify,
+    logger
+  });
+  logLine(logger, `Generated deploy artifact: ${relative(cwd, bundledMainEntryPath).replace(/\\/g, "/")}`);
+  return await writeGeneratedDeployWranglerConfig(cwd, wranglerConfig, {
+    main: "./worker.js"
+  });
+}
+async function resolveLocalViteExecutable(cwd, fs) {
+  const viteExecutablePath = resolvePackageSpecifier("vite/bin/vite.js", cwd);
+  try {
+    await fs.access(viteExecutablePath);
+  } catch {
+    throw new Error(`Could not resolve a local Vite CLI entrypoint from ${cwd}. Install vite in this package before running a Vite-backed Devflare build.`);
+  }
+  return viteExecutablePath;
+}
+async function prepareBuildArtifacts(parsed, logger, options) {
+  const cwd = options.cwd || process.cwd();
+  const configPath = parsed.options.config;
+  const environment = parsed.options.env;
+  const rawConfig = await loadConfig({ cwd, configFile: configPath });
+  const shouldPreparePreviewScopedResources = parsed.command === "deploy" && environment === "preview";
+  const previewScopedResources = shouldPreparePreviewScopedResources ? await preparePreviewScopedResourcesForDeploy(rawConfig, { environment }) : null;
+  const config = previewScopedResources ? await resolveMaterializedConfigResources(previewScopedResources.config, {
+    accountId: previewScopedResources.accountId,
+    cloudflare: previewScopedResources.resourceResolutionCloudflare
+  }) : await resolveConfigResources(rawConfig, { environment });
+  const createdPreviewResourcesSummary = previewScopedResources ? summarizePreviewScopedResourceNames(previewScopedResources.created) : null;
+  if (createdPreviewResourcesSummary) {
+    logLine(logger, `Provisioned preview-scoped resources: ${createdPreviewResourcesSummary}`);
+  }
+  const existingPreviewResourcesSummary = previewScopedResources ? summarizePreviewScopedResourceNames(previewScopedResources.existing) : null;
+  if (existingPreviewResourcesSummary) {
+    logLine(logger, `Reused preview-scoped resources: ${existingPreviewResourcesSummary}`);
+  }
+  for (const warning of previewScopedResources?.warnings ?? []) {
+    logger.warn(warning);
+  }
+  logLine(logger, `Building: ${config.name}`);
+  const composedMainEntry = await prepareComposedWorkerEntrypoint(cwd, config, environment);
+  const deps = await getDependencies();
+  const viteProject = resolveEffectiveViteProject(await detectViteProject(cwd, deps.fs), config, environment);
+  const deploymentStrategy = applyDeploymentStrategy(config, {
+    environment,
+    preview: parsed.options.preview === true,
+    branchName: parsed.options["branch-name"],
+    previewBranch: process.env.DEVFLARE_PREVIEW_BRANCH
+  });
+  const deploymentStrategyMessage = describeDeploymentStrategy(deploymentStrategy);
+  if (deploymentStrategyMessage) {
+    logLine(logger, deploymentStrategyMessage);
+  }
+  const devWranglerConfig = viteProject.shouldStartVite ? isolateViteBuildOutputPaths2(cwd, compileConfig(config)) : compileConfig(config);
+  const deployWranglerConfig = viteProject.shouldStartVite ? isolateViteBuildOutputPaths2(cwd, compileConfig(deploymentStrategy.config)) : compileConfig(deploymentStrategy.config);
+  if (viteProject.shouldStartVite) {
+    if (composedMainEntry) {
+      deployWranglerConfig.main = composedMainEntry;
+      logLine(logger, `Generated composed worker entry: ${composedMainEntry}`);
+    }
+  } else if (composedMainEntry) {
+    const bundledMainEntryPath = await bundleWorkerEntry({
+      cwd,
+      inputFile: resolve(cwd, composedMainEntry),
+      outFile: resolve(cwd, ".devflare", "worker-entrypoints", "main.js"),
+      rolldownOptions: config.rolldown?.options,
+      sourcemap: config.rolldown?.sourcemap,
+      minify: config.rolldown?.minify,
+      logger
+    });
+    const bundledMainPath = relative(cwd, bundledMainEntryPath).replace(/\\/g, "/");
+    devWranglerConfig.main = bundledMainPath;
+    deployWranglerConfig.main = bundledMainPath;
+    logLine(logger, `Generated bundled worker entry: ${bundledMainPath}`);
+  }
+  const generatedDevConfigPath = await writeGeneratedDevWranglerConfig(cwd, devWranglerConfig);
+  logger.debug(`Generated dev Wrangler config: ${relative(cwd, generatedDevConfigPath).replace(/\\/g, "/")}`);
+  let deployConfigPath;
+  if (viteProject.shouldStartVite) {
+    const generatedViteConfigPath = await writeGeneratedViteConfig({
+      cwd,
+      configPath,
+      environment,
+      localConfigPath: viteProject.viteConfigPath
+    });
+    const viteExecutablePath = await resolveLocalViteExecutable(cwd, deps.fs);
+    await cleanupViteBuildOutputs(cwd, devWranglerConfig, logger);
+    logLine(logger, "Running vite build...");
+    const buildProc = await deps.exec.exec(viteExecutablePath, ["build", "--config", generatedViteConfigPath], {
+      cwd,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        DEVFLARE_BUILD: "true"
+      }
+    });
+    if (buildProc.exitCode !== 0) {
+      throw new Error("Build failed");
+    }
+    const existingDeployConfigPath = await readDeployRedirect(cwd);
+    const generatedDeployConfigPath = deployWranglerConfig.main && deployWranglerConfig.main !== devWranglerConfig.main ? await buildWorkerOnlyDeployArtifact(cwd, deployWranglerConfig, config, logger) : await writeGeneratedDeployWranglerConfig(cwd, deployWranglerConfig);
+    deployConfigPath = existingDeployConfigPath && existingDeployConfigPath !== generatedDeployConfigPath ? existingDeployConfigPath : generatedDeployConfigPath;
+  } else {
+    logLine(logger, "Skipping Vite build (no effective Vite config found for this package)");
+    deployConfigPath = await buildWorkerOnlyDeployArtifact(cwd, deployWranglerConfig, config, logger);
+  }
+  await writeDeployRedirect(cwd, deployConfigPath);
+  logLine(logger, `Generated deploy Wrangler config: ${relative(cwd, deployConfigPath).replace(/\\/g, "/")}`);
+  logLine(logger, `Generated deploy redirect: ${relative(cwd, getBuildArtifactPaths(cwd).deployRedirectPath).replace(/\\/g, "/")}`);
+  return {
+    config,
+    wranglerConfig: deployWranglerConfig,
+    deployConfigPath,
+    viteProject
+  };
+}
+
+export { applyDeploymentStrategy, describeDeploymentStrategy, prepareBuildArtifacts };

package/dist/index-mqekt778.js

@@ -0,0 +1,185 @@
+import {
+  resolveConfigForEnvironment
+} from "./index-yzddwp02.js";
+
+// src/cli/commands/previews-support/family.ts
+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 comparePreviewScopeRows(left, right) {
+  const leftTime = left.updatedAt?.getTime() ?? 0;
+  const rightTime = right.updatedAt?.getTime() ?? 0;
+  if (rightTime !== leftTime) {
+    return rightTime - leftTime;
+  }
+  return left.scope.localeCompare(right.scope);
+}
+function collectConfiguredWorkerFamilies(config, environment) {
+  const resolvedConfig = resolveConfigForEnvironment(config, environment);
+  const families = new Map;
+  families.set(resolvedConfig.name, {
+    baseName: resolvedConfig.name,
+    roleLabel: "primary",
+    role: "primary"
+  });
+  for (const [bindingName, binding] of Object.entries(resolvedConfig.bindings?.services ?? {})) {
+    const existing = families.get(binding.service);
+    if (existing) {
+      continue;
+    }
+    families.set(binding.service, {
+      baseName: binding.service,
+      roleLabel: bindingName,
+      role: "service"
+    });
+  }
+  return Array.from(families.values()).sort(compareConfiguredWorkerFamilies);
+}
+function getWorkerUrl(workerName, workersSubdomain) {
+  if (!workersSubdomain) {
+    return;
+  }
+  return `https://${workerName}.${workersSubdomain}.workers.dev`;
+}
+function getWorkerScopeSuffix(workerName, baseName) {
+  if (!workerName.startsWith(`${baseName}-`)) {
+    return;
+  }
+  const suffix = workerName.slice(baseName.length + 1).trim();
+  return suffix || undefined;
+}
+function buildStableWorkerRowsFromLiveWorkers(families, workers, workersSubdomain) {
+  const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+  return families.map((family) => {
+    const worker = workersByName.get(family.baseName);
+    const status = worker ? "active" : "missing";
+    return {
+      workerName: family.baseName,
+      role: family.roleLabel,
+      status,
+      updatedAt: worker?.modifiedOn,
+      url: worker ? getWorkerUrl(family.baseName, workersSubdomain) : undefined
+    };
+  });
+}
+function getDedicatedPreviewFamilyNamesFromWorkers(families, workers) {
+  const familyNames = new Set;
+  const workerNames = workers.map((worker) => worker.name);
+  for (const family of families) {
+    if (family.role === "primary") {
+      familyNames.add(family.baseName);
+      continue;
+    }
+    if (workerNames.some((workerName) => Boolean(getWorkerScopeSuffix(workerName, family.baseName)))) {
+      familyNames.add(family.baseName);
+    }
+  }
+  return familyNames;
+}
+function buildPreviewScopeRowsFromLiveWorkers(families, workers, workersSubdomain) {
+  const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+  const previewFamilyNames = getDedicatedPreviewFamilyNamesFromWorkers(families, workers);
+  const expectedFamilies = families.filter((family) => previewFamilyNames.has(family.baseName));
+  const workerCandidatesByScope = buildPreviewWorkerCandidatesByScope(families, workers);
+  return Array.from(workerCandidatesByScope.keys()).map((scope) => {
+    const resolvedFamilies = expectedFamilies.map((family) => ({
+      family,
+      worker: workersByName.get(`${family.baseName}-${scope}`)
+    }));
+    const presentFamilies = resolvedFamilies.filter((entry) => entry.worker);
+    const updatedAt = presentFamilies.reduce((latest, entry) => {
+      const currentDate = entry.worker?.modifiedOn;
+      if (!currentDate) {
+        return latest;
+      }
+      if (!latest || currentDate.getTime() > latest.getTime()) {
+        return currentDate;
+      }
+      return latest;
+    }, undefined);
+    const primaryEntry = resolvedFamilies.find((entry) => entry.family.role === "primary");
+    const entryWorker = primaryEntry?.worker ?? presentFamilies[0]?.worker;
+    const missingLabels = resolvedFamilies.filter((entry) => !entry.worker).map((entry) => entry.family.role === "primary" ? "primary" : entry.family.roleLabel);
+    const notes = [];
+    if (missingLabels.length > 0) {
+      notes.push(`missing ${missingLabels.join(", ")}`);
+    }
+    const strategy = "dedicated workers";
+    const status = presentFamilies.length === resolvedFamilies.length ? "ready" : "partial";
+    return {
+      scope,
+      strategy,
+      workersLabel: `${presentFamilies.length}/${resolvedFamilies.length}`,
+      status,
+      updatedAt,
+      notes: notes.length > 0 ? notes.join(" · ") : undefined,
+      entryUrl: entryWorker ? getWorkerUrl(entryWorker.name, workersSubdomain) : undefined
+    };
+  }).sort(comparePreviewScopeRows);
+}
+function buildPreviewWorkerCandidatesByScope(families, workers) {
+  const candidates = new Map;
+  for (const worker of workers) {
+    for (const family of families) {
+      const scope = getWorkerScopeSuffix(worker.name, family.baseName);
+      if (!scope) {
+        continue;
+      }
+      const names = candidates.get(scope) ?? new Set;
+      names.add(worker.name);
+      candidates.set(scope, names);
+    }
+  }
+  return new Map(Array.from(candidates.entries()).map(([scope, workerNames]) => {
+    return [scope, Array.from(workerNames).sort((left, right) => left.localeCompare(right))];
+  }));
+}
+function orderPreviewWorkerNamesForDeletion(workerNames, scope, families) {
+  const familyPriority = new Map;
+  for (const family of families) {
+    familyPriority.set(family.baseName, {
+      priority: family.role === "primary" ? 0 : 1,
+      roleLabel: family.roleLabel
+    });
+  }
+  const resolveFamilyForWorker = (workerName) => {
+    for (const family of families) {
+      if (getWorkerScopeSuffix(workerName, family.baseName) === scope) {
+        const resolved = familyPriority.get(family.baseName);
+        if (resolved) {
+          return {
+            priority: resolved.priority,
+            roleLabel: resolved.roleLabel,
+            baseName: family.baseName
+          };
+        }
+      }
+    }
+    return {
+      priority: 2,
+      roleLabel: workerName
+    };
+  };
+  return [...workerNames].sort((left, right) => {
+    const leftFamily = resolveFamilyForWorker(left);
+    const rightFamily = resolveFamilyForWorker(right);
+    if (leftFamily.priority !== rightFamily.priority) {
+      return leftFamily.priority - rightFamily.priority;
+    }
+    if (leftFamily.roleLabel !== rightFamily.roleLabel) {
+      return leftFamily.roleLabel.localeCompare(rightFamily.roleLabel);
+    }
+    if (leftFamily.baseName && rightFamily.baseName && leftFamily.baseName !== rightFamily.baseName) {
+      return leftFamily.baseName.localeCompare(rightFamily.baseName);
+    }
+    return left.localeCompare(right);
+  });
+}
+
+export { collectConfiguredWorkerFamilies, buildStableWorkerRowsFromLiveWorkers, buildPreviewScopeRowsFromLiveWorkers, buildPreviewWorkerCandidatesByScope, orderPreviewWorkerNamesForDeletion };

package/dist/index-na3mnm1k.js

@@ -0,0 +1,74 @@
+import {
+  loadConfig,
+  resolveConfigPath
+} from "./index-0apbm26n.js";
+import {
+  getEffectiveAccountId,
+  getPrimaryAccount,
+  getWorkspaceAccountId
+} from "./index-jb75kwa4.js";
+
+// src/cli/command-utils.ts
+function asOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function resolveNamedSelection(options) {
+  if (options.explicitValue) {
+    return {
+      value: options.explicitValue,
+      source: "option"
+    };
+  }
+  if (options.fallbackValue) {
+    return {
+      value: options.fallbackValue,
+      source: "arg"
+    };
+  }
+  if (options.configuredValue) {
+    return {
+      value: options.configuredValue,
+      source: "config"
+    };
+  }
+  return {
+    value: undefined,
+    source: "none"
+  };
+}
+async function getConfiguredAccountId(cwd) {
+  const workspaceAccountId = getWorkspaceAccountId();
+  if (workspaceAccountId) {
+    return workspaceAccountId;
+  }
+  const envAccountId = process.env.CLOUDFLARE_ACCOUNT_ID?.trim();
+  if (envAccountId) {
+    return envAccountId;
+  }
+  const configPath = await resolveConfigPath(cwd);
+  if (!configPath) {
+    return;
+  }
+  try {
+    const config = await loadConfig({ cwd });
+    return config.accountId;
+  } catch {
+    return;
+  }
+}
+async function resolveCloudflareAccountId(options) {
+  if (options.explicitAccountId) {
+    return options.explicitAccountId;
+  }
+  if (options.configuredAccountId) {
+    return options.configuredAccountId;
+  }
+  const primaryAccount = await getPrimaryAccount(options.apiOptions);
+  if (!primaryAccount) {
+    return;
+  }
+  const effective = await getEffectiveAccountId(primaryAccount.id);
+  return effective.accountId;
+}
+
+export { asOptionalString, resolveNamedSelection, getConfiguredAccountId, resolveCloudflareAccountId };