devflare 1.0.0-next.16 → 1.0.0-next.18

package/dist/index-0mantew0.js

@@ -0,0 +1,513 @@
+import {
+  ensureGeneratedDirectory,
+  getGeneratedArtifactPaths
+} from "./index-aabgympv.js";
+import {
+  getDependencies
+} from "./index-z9gy8w6b.js";
+import {
+  bundleWorkerEntry
+} from "./index-g3qtxkms.js";
+import {
+  detectViteProject
+} from "./index-gn5wy09x.js";
+import {
+  getPackageVersion
+} from "./index-6h8xbs75.js";
+import {
+  logLine
+} from "./index-stgn34cr.js";
+import {
+  resolvePackageSpecifier
+} from "./index-t4fhcx1n.js";
+import {
+  prepareComposedWorkerEntrypoint,
+  resolveEffectiveViteProject,
+  writeGeneratedViteConfig
+} from "./index-2a2g4fwp.js";
+import {
+  compileBuildConfig,
+  isolateViteBuildOutputPaths,
+  rebaseWranglerConfigPaths,
+  writeWranglerConfig
+} from "./index-ys5q9ch9.js";
+import {
+  loadConfig,
+  resolveConfigForEnvironment
+} from "./index-xy1jvt4w.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: "preview-scope",
+    branchScope,
+    omittedResources
+  };
+}
+function describeDeploymentStrategy(result) {
+  if (result.strategy !== "preview-scope" || 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 `Named preview-scope deploy detected${scopeSuffix}; omitting shared ${formattedLabels} from the deployed Wrangler config to avoid singleton Cloudflare resource conflicts.`;
+}
+
+// src/cli/build-manifest.ts
+import { createHash } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "pathe";
+var BUILD_MANIFEST_VERSION = 1;
+var BUILD_MANIFEST_FILENAME = "manifest.json";
+function hashSourceConfig(config) {
+  const normalized = JSON.stringify(config, (key, value) => {
+    if (key === "accountId")
+      return;
+    if (value === null || value === undefined)
+      return;
+    return value;
+  });
+  return createHash("sha256").update(normalized).digest("hex");
+}
+function summarizeBindings(config) {
+  const bindings = config.bindings ?? {};
+  return {
+    kv: Object.keys(bindings.kv ?? {}).sort(),
+    d1: Object.keys(bindings.d1 ?? {}).sort(),
+    r2: Object.keys(bindings.r2 ?? {}).sort(),
+    queues: Object.keys(bindings.queues ?? {}).sort(),
+    hyperdrive: Object.keys(bindings.hyperdrive ?? {}).sort(),
+    vectorize: Object.keys(bindings.vectorize ?? {}).sort(),
+    services: Object.keys(bindings.services ?? {}).sort()
+  };
+}
+function createBuildManifest(config, options) {
+  return {
+    manifestVersion: BUILD_MANIFEST_VERSION,
+    devflareVersion: options.devflareVersion,
+    createdAt: new Date().toISOString(),
+    sourceConfigHash: hashSourceConfig(config),
+    intendedTarget: options.intendedTarget,
+    bindingsSnapshot: summarizeBindings(config)
+  };
+}
+async function writeBuildManifest(buildDir, manifest) {
+  const manifestPath = resolve(buildDir, BUILD_MANIFEST_FILENAME);
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, "\t")}
+`, "utf-8");
+  return manifestPath;
+}
+async function readBuildManifest(buildDir) {
+  const manifestPath = resolve(buildDir, BUILD_MANIFEST_FILENAME);
+  try {
+    const raw = await readFile(manifestPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.manifestVersion !== "number")
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function targetsEqual(a, b) {
+  return a.environment === b.environment && a.preview === b.preview && a.previewScope === b.previewScope && a.branchName === b.branchName;
+}
+function compareManifests(previous, current) {
+  const prevBindings = new Set(Object.entries(previous.bindingsSnapshot).flatMap(([k, v]) => v.map((n) => `${k}:${n}`)));
+  const currBindings = new Set(Object.entries(current.bindingsSnapshot).flatMap(([k, v]) => v.map((n) => `${k}:${n}`)));
+  const bindingsAdded = [...currBindings].filter((b) => !prevBindings.has(b));
+  const bindingsRemoved = [...prevBindings].filter((b) => !currBindings.has(b));
+  return {
+    configChanged: previous.sourceConfigHash !== current.sourceConfigHash,
+    versionChanged: previous.devflareVersion !== current.devflareVersion,
+    targetChanged: !targetsEqual(previous.intendedTarget, current.intendedTarget),
+    previousVersion: previous.devflareVersion,
+    currentVersion: current.devflareVersion,
+    previousTarget: previous.intendedTarget,
+    currentTarget: current.intendedTarget,
+    bindingsAdded,
+    bindingsRemoved
+  };
+}
+function formatDriftWarning(drift) {
+  const lines = [];
+  if (drift.versionChanged) {
+    lines.push(`devflare version differs (built with ${drift.previousVersion}, deploying with ${drift.currentVersion})`);
+  }
+  if (drift.targetChanged) {
+    lines.push(`deployment target differs (built for ${formatTarget(drift.previousTarget)}, ` + `deploying as ${formatTarget(drift.currentTarget)})`);
+  }
+  if (drift.configChanged) {
+    lines.push("source config changed since build (devflare.config.ts hash differs)");
+  }
+  if (drift.bindingsAdded.length > 0) {
+    lines.push(`bindings added since build: ${drift.bindingsAdded.join(", ")}`);
+  }
+  if (drift.bindingsRemoved.length > 0) {
+    lines.push(`bindings removed since build: ${drift.bindingsRemoved.join(", ")}`);
+  }
+  if (lines.length === 0)
+    return null;
+  return [
+    "Build artefact drift detected:",
+    ...lines.map((line) => `  - ${line}`),
+    "Re-run `devflare build` to refresh the artefact, or pass --force to deploy anyway."
+  ].join(`
+`);
+}
+function formatTarget(t) {
+  const parts = [];
+  if (t.environment)
+    parts.push(`env=${t.environment}`);
+  parts.push(t.preview ? "preview" : "production");
+  if (t.previewScope)
+    parts.push(`scope=${t.previewScope}`);
+  if (t.branchName)
+    parts.push(`branch=${t.branchName}`);
+  return parts.join(" ");
+}
+
+// src/cli/commands/build-artifacts.ts
+import { dirname, relative, resolve as resolve2 } from "pathe";
+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(resolve2(cwd, assetsDirectory));
+  }
+  if (mainEntry) {
+    const mainEntryPath = resolve2(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 resolve2(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: resolve2(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 config = resolveConfigForEnvironment(rawConfig, environment);
+  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, compileBuildConfig(config)) : compileBuildConfig(config);
+  const deployWranglerConfig = viteProject.shouldStartVite ? isolateViteBuildOutputPaths2(cwd, compileBuildConfig(deploymentStrategy.config)) : compileBuildConfig(deploymentStrategy.config);
+  if (viteProject.shouldStartVite) {
+    if (composedMainEntry) {
+      deployWranglerConfig.main = relative(cwd, composedMainEntry);
+      logLine(logger, `Generated composed worker entry: ${deployWranglerConfig.main}`);
+    }
+  } else if (composedMainEntry) {
+    const bundledMainEntryPath = await bundleWorkerEntry({
+      cwd,
+      inputFile: composedMainEntry,
+      outFile: resolve2(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}`);
+  }
+  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);
+  }
+  const generatedDevConfigPath = await writeGeneratedDevWranglerConfig(cwd, devWranglerConfig);
+  logger.debug(`Generated dev Wrangler config: ${relative(cwd, generatedDevConfigPath).replace(/\\/g, "/")}`);
+  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, "/")}`);
+  const manifest = createBuildManifest(rawConfig, {
+    devflareVersion: await getPackageVersion(),
+    intendedTarget: {
+      environment,
+      preview: parsed.options.preview === true,
+      previewScope: typeof parsed.options.preview === "string" ? parsed.options.preview : undefined,
+      branchName: parsed.options["branch-name"]
+    }
+  });
+  const manifestPath = await writeBuildManifest(getBuildArtifactPaths(cwd).buildDir, manifest);
+  logger.debug(`Generated build manifest: ${relative(cwd, manifestPath).replace(/\\/g, "/")}`);
+  return {
+    config,
+    wranglerConfig: deployWranglerConfig,
+    deployConfigPath,
+    viteProject
+  };
+}
+
+export { applyDeploymentStrategy, describeDeploymentStrategy, createBuildManifest, readBuildManifest, compareManifests, formatDriftWarning, prepareBuildArtifacts };

package/dist/{index-p03n4qet.js → index-0mezg6ar.js}

@@ -441,8 +441,8 @@ var CORE_HELP_PAGES = [
       "devflare build [--config <path>] [--env <name>] [--debug]"
     ],
     description: [
-      "Resolves your Devflare config, applies environment overrides, and generates the Wrangler-facing artifacts used by deploy flows.",
-      "This is the safest way to inspect what Devflare will hand to Wrangler before you actually deploy."
+      "Resolves your Devflare config locally, applies environment overrides, and generates the build artifacts used by deploy flows.",
+      "Build preserves named bindings instead of provisioning Cloudflare resources, so it is the safest way to inspect what Devflare will hand to deploy before you actually ship."
     ],
     options: [
       entry("--config <path>", "Use a specific devflare config file"),
@@ -455,24 +455,26 @@ var CORE_HELP_PAGES = [
     ],
     notes: [
       "Build currently writes `.devflare/wrangler.jsonc`, `.devflare/build/wrangler.jsonc`, and `.wrangler/deploy/config.json`.",
-      "`devflare deploy` runs the same artifact preparation step automatically before invoking Wrangler."
+      "Build does not query or provision Cloudflare account resources on its own; name-based bindings stay as names in the generated artifacts until deploy time.",
+      "`devflare deploy` runs the same artifact preparation step automatically before invoking Wrangler, unless you provide `--build <path>` to reuse an existing build artifact."
     ]
   },
   {
     path: ["deploy"],
     summary: "Deploy explicitly to Cloudflare production or preview targets",
     usage: [
-      "devflare deploy --prod [--config <path>] [--message <text>] [--tag <text>] [--debug]",
-      "devflare deploy --production [--config <path>] [--message <text>] [--tag <text>] [--debug]",
-      "devflare deploy --preview <name> [--config <path>] [--message <text>] [--tag <text>]",
-      "devflare deploy --preview [--config <path>] [--branch-name <branch>] [--message <text>] [--tag <text>]",
+      "devflare deploy --prod [--config <path>] [--build <path>] [--message <text>] [--tag <text>] [--debug]",
+      "devflare deploy --production [--config <path>] [--build <path>] [--message <text>] [--tag <text>] [--debug]",
+      "devflare deploy --preview <name> [--config <path>] [--build <path>] [--message <text>] [--tag <text>]",
+      "devflare deploy --preview [--config <path>] [--build <path>] [--branch-name <branch>] [--message <text>] [--tag <text>]",
       "devflare deploy --prod --dry-run [--config <path>]",
       "devflare deploy --preview <name> --dry-run [--config <path>]",
       "devflare deploy --preview --dry-run [--config <path>]"
     ],
     description: [
       "Deploy requires an explicit target: production via `--prod` / `--production`, or preview via `--preview`.",
-      "Named preview deploys such as `--preview next` or `--preview pr-1` target `config.env.preview`, provision preview-scoped resources automatically, and deploy dedicated preview-scope Workers when your config is wired for them. Bare `--preview` keeps the same-worker preview upload flow and can still use `--branch-name` or CI/git metadata for preview-aware naming."
+      "Named preview deploys such as `--preview next` or `--preview pr-1` target `config.env.preview`, provision preview-scoped resources automatically, and deploy dedicated preview-scope Workers when your config is wired for them. Bare `--preview` keeps the same-worker preview upload flow and can still use `--branch-name` or CI/git metadata for preview-aware naming.",
+      "Production and named preview deploys also provision missing deploy-time resources such as KV namespaces, D1 databases, R2 buckets, and Queues when Devflare has enough information to create them."
     ],
     options: [
       entry("--prod", "Deploy to the production environment explicitly"),
@@ -480,6 +482,7 @@ var CORE_HELP_PAGES = [
       entry("--preview", "Deploy a same-worker preview upload"),
       entry("--preview <name>", "Deploy a named preview scope such as `next` or `pr-1`"),
       entry("--config <path>", "Use a specific devflare config file"),
+      entry("--build <path>", "Reuse an existing build artifact such as `.devflare/build` or `.wrangler/deploy/config.json` instead of rebuilding"),
       entry("--env <name>", "Usually unnecessary because the explicit target already pins production vs preview. If you pass it, it must match that target"),
       entry("--dry-run", "Print the synthesized Wrangler config and skip the actual deployment"),
       entry("--branch-name <branch>", "Provide explicit branch metadata for preview-aware naming when your workflow needs it"),
@@ -489,6 +492,7 @@ var CORE_HELP_PAGES = [
     ],
     examples: [
       entry("devflare deploy --prod", "Deploy explicitly to production"),
+      entry("devflare deploy --prod --build .devflare/build", "Deploy a previously built artifact without rebuilding the package"),
       entry('devflare deploy --production --message "Release"', "Deploy to production with an explicit deployment message"),
       entry("devflare deploy --preview next", "Deploy the named `next` preview scope and provision preview-scoped resources automatically"),
       entry("devflare deploy --preview pr-1", "Deploy the named `pr-1` preview scope directly"),
@@ -499,6 +503,7 @@ var CORE_HELP_PAGES = [
       "`devflare deploy` without an explicit target is rejected from the CLI so production and preview destinations stay unmistakable.",
       "`--prod` / `--production` clear preview-scope environment overrides such as `DEVFLARE_PREVIEW_BRANCH` so production deploys stay pointed at stable Worker names.",
       "Named preview deploys automatically provision preview-scoped resources before building and deploying.",
+      "When a build artifact still contains name-based bindings, deploy resolves or provisions the concrete Cloudflare resources and rewrites the generated Wrangler config with the IDs Wrangler requires.",
       "Plain `--preview` still uses Cloudflare preview uploads, so it cannot be the first-ever upload for a brand-new Worker, preview URLs remain limited for Workers that implement Durable Objects, and preview uploads do not apply Durable Object migrations."
     ]
   },
@@ -1301,58 +1306,58 @@ async function runCli(argv, options = {}) {
   }
 }
 async function runInit(parsed, logger, options) {
-  const { runInitCommand } = await import("./init-r4hnxan3.js");
+  const { runInitCommand } = await import("./init-wfh63bfz.js");
   return runInitCommand(parsed, logger, options);
 }
 async function runDev(parsed, logger, options) {
-  const { runDevCommand } = await import("./dev-7ef5e2j1.js");
+  const { runDevCommand } = await import("./dev-wjh8gdd1.js");
   return runDevCommand(parsed, logger, options);
 }
 async function runBuild(parsed, logger, options) {
-  const { runBuildCommand } = await import("./build-p3r3117t.js");
+  const { runBuildCommand } = await import("./build-9em4ymqn.js");
   return runBuildCommand(parsed, logger, options);
 }
 async function runDeploy(parsed, logger, options) {
-  const { runDeployCommand } = await import("./deploy-ykpcjkc2.js");
+  const { runDeployCommand } = await import("./deploy-30ph1rrd.js");
   return runDeployCommand(parsed, logger, {
     ...options,
     requireExplicitDeployTarget: true
   });
 }
 async function runTypes(parsed, logger, options) {
-  const { runTypesCommand } = await import("./types-p0gckpn6.js");
+  const { runTypesCommand } = await import("./types-5t5y7a5n.js");
   return runTypesCommand(parsed, logger, options);
 }
 async function runDoctor(parsed, logger, options) {
-  const { runDoctorCommand } = await import("./doctor-fmjj65mc.js");
+  const { runDoctorCommand } = await import("./doctor-3mqavqg3.js");
   return runDoctorCommand(parsed, logger, options);
 }
 async function runConfig(parsed, logger, options) {
-  const { runConfigCommand } = await import("./config-hwdqjse7.js");
+  const { runConfigCommand } = await import("./config-pnz2e8s3.js");
   return runConfigCommand(parsed, logger, options);
 }
 async function runAccount(parsed, logger, options) {
-  const { runAccountCommand } = await import("./account-fw8nafav.js");
+  const { runAccountCommand } = await import("./account-gnzhz1c9.js");
   return runAccountCommand(parsed, logger, options);
 }
 async function runLogin(parsed, logger, options) {
-  const { runLoginCommand } = await import("./login-5bsxxpvc.js");
+  const { runLoginCommand } = await import("./login-pmqh94ws.js");
   return runLoginCommand(parsed, logger, options);
 }
 async function runPreviews(parsed, logger, options) {
-  const { runPreviewsCommand } = await import("./previews-d487qde5.js");
+  const { runPreviewsCommand } = await import("./previews-sdte4984.js");
   return runPreviewsCommand(parsed, logger, options);
 }
 async function runProductions(parsed, logger, options) {
-  const { runProductionsCommand } = await import("./productions-x9p0pym1.js");
+  const { runProductionsCommand } = await import("./productions-5c58yafp.js");
   return runProductionsCommand(parsed, logger, options);
 }
 async function runWorker(parsed, logger, options) {
-  const { runWorkerCommand } = await import("./worker-y9ha6g44.js");
+  const { runWorkerCommand } = await import("./worker-wv4jdneg.js");
   return runWorkerCommand(parsed, logger, options);
 }
 async function runToken(parsed, logger, options) {
-  const { runTokenCommand } = await import("./token-kedhcret.js");
+  const { runTokenCommand } = await import("./token-47kcz18j.js");
   return runTokenCommand(parsed, logger, options);
 }
 async function runAI() {

package/dist/{index-mqekt778.js → index-0tk2rs0q.js}

@@ -1,6 +1,6 @@
 import {
   resolveConfigForEnvironment
-} from "./index-yzddwp02.js";
+} from "./index-m2d74gqg.js";
 
 // src/cli/commands/previews-support/family.ts
 function compareConfiguredWorkerFamilies(left, right) {

package/dist/{index-h18pxvzs.js → index-124e9t4t.js}

@@ -229,4 +229,4 @@ function wrapEnvSendEmailBindings(env) {
   return wrapped;
 }
 
-export { normalizeSendEmailMessage, createLocalSendEmailBinding, setLocalSendEmailBindings, clearLocalSendEmailBindings, wrapEnvSendEmailBindings };
+export { createEmailMessageRaw, normalizeSendEmailMessage, wrapSendEmailBinding, createLocalSendEmailBinding, setLocalSendEmailBindings, clearLocalSendEmailBindings, wrapEnvSendEmailBindings };