@base44-preview/cli 0.1.18-pr.639.a559cb8 → 0.1.20-pr.641.75be65a

package/dist/cli/index.js

@@ -31177,7 +31177,7 @@ function cleanDoc(doc) {
   return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc));
 }
 function replaceEndOfLine(doc, replacement = literalline) {
-  return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join28(replacement, currentDoc.split(`
+  return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join30(replacement, currentDoc.split(`
 `)) : currentDoc);
 }
 function canBreakFn(doc) {
@@ -31257,7 +31257,7 @@ function indentIfBreak(contents, options) {
     negate: options.negate
   };
 }
-function join28(separator, docs) {
+function join30(separator, docs) {
   assertDoc(separator);
   assertDocArray(docs);
   const parts = [];
@@ -31968,7 +31968,7 @@ var init_doc = __esm(() => {
   MODE_FLAT = Symbol("MODE_FLAT");
   DOC_FILL_PRINTED_LENGTH = Symbol("DOC_FILL_PRINTED_LENGTH");
   builders = {
-    join: join28,
+    join: join30,
     line,
     softline,
     hardline,
@@ -119090,7 +119090,7 @@ import path52 from "path";
 import * as path42 from "path";
 import * as fs26 from "fs/promises";
 import * as path22 from "path";
-import process22 from "process";
+import process23 from "process";
 import * as path32 from "path";
 import process32 from "process";
 import path92 from "path";
@@ -119622,7 +119622,7 @@ function partition2(array2, predicate) {
   return result;
 }
 async function findInDirectory(nameOrNames, { typeCheck, cwd, allowSymlinks = true, filter: filter2 }) {
-  const directory = toAbsolutePath(cwd) ?? process22.cwd();
+  const directory = toAbsolutePath(cwd) ?? process23.cwd();
   const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
   for (const name of names) {
     const fileOrDirectory = path22.join(directory, name);
@@ -146002,10 +146002,10 @@ __export(exports_supports_color, {
   createSupportsColor: () => createSupportsColor2,
   default: () => supports_color_default2
 });
-import process21 from "node:process";
+import process24 from "node:process";
 import os9 from "node:os";
 import tty4 from "node:tty";
-function hasFlag2(flag, argv = globalThis.Deno ? globalThis.Deno.args : process21.argv) {
+function hasFlag2(flag, argv = globalThis.Deno ? globalThis.Deno.args : process24.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
   const position = argv.indexOf(prefix + flag);
   const terminatorPosition = argv.indexOf("--");
@@ -146068,7 +146068,7 @@ function _supportsColor2(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
   if (env3.TERM === "dumb") {
     return min;
   }
-  if (process21.platform === "win32") {
+  if (process24.platform === "win32") {
     const osRelease = os9.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
@@ -146130,7 +146130,7 @@ function createSupportsColor2(stream, options = {}) {
 }
 var env3, flagForceColor2, supportsColor2, supports_color_default2;
 var init_supports_color = __esm(() => {
-  ({ env: env3 } = process21);
+  ({ env: env3 } = process24);
   if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false") || hasFlag2("color=never")) {
     flagForceColor2 = 0;
   } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
@@ -228670,6 +228670,20 @@ function isCLIError(error) {
 function isUserError(error) {
   return error instanceof UserError;
 }
+var STEP = Symbol.for("base44.commandStep");
+async function tagStep(step, run) {
+  try {
+    return await run();
+  } catch (error) {
+    if (error !== null && typeof error === "object" && !(STEP in error) && Object.isExtensible(error)) {
+      Object.defineProperty(error, STEP, { value: step, enumerable: false });
+    }
+    throw error;
+  }
+}
+function stepOf(error) {
+  return error !== null && typeof error === "object" && STEP in error ? error[STEP] : undefined;
+}
 
 // src/core/utils/fs.ts
 async function pathExists(path) {
@@ -228796,7 +228810,7 @@ function normalizeBase44Env() {
 loadProjectEnvFiles();
 
 // src/cli/index.ts
-import { dirname as dirname28, join as join37 } from "node:path";
+import { dirname as dirname29, join as join39 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -236449,7 +236463,7 @@ async function initAppContext(options = {}) {
     if (!id) {
       throw new InvalidInputError("App id cannot be empty.");
     }
-    cache2 = { id };
+    cache2 = { id, projectRoot: projectRoot?.root };
     return cache2;
   }
   if (cache2) {
@@ -239251,7 +239265,7 @@ import { join as join13 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.1.18",
+  version: "0.1.20",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -239605,11 +239619,325 @@ async function createArchive(pathToArchive, targetArchivePath) {
 import { readFile as readFile3 } from "node:fs/promises";
 import { join as join18 } from "node:path";
 
+// src/core/site/modules.ts
+import { stat } from "node:fs/promises";
+import { relative as relative5, resolve as resolve3, sep } from "node:path";
+var MAX_TOTAL_MODULE_BYTES = 40 * 1024 * 1024;
+var MODULE_IGNORE = ["wrangler.json", ".dev.vars"];
+var RULE_TYPE_TO_MODULE_TYPE = {
+  ESModule: "esm",
+  CompiledWasm: "wasm",
+  Text: "text",
+  Data: "data"
+};
+function toPosix(path) {
+  return path.split(sep).join("/");
+}
+async function collectModules(config) {
+  const entryPath = resolve3(config.configDir, config.main);
+  if (!await pathExists(entryPath)) {
+    throw new InvalidInputError(`Worker entry module does not exist: ${entryPath} (from "main" in ${config.configPath})`, {
+      hints: [{ message: "Rebuild the project to regenerate the artifact" }]
+    });
+  }
+  const modulesByName = new Map;
+  const entryName = toPosix(relative5(config.configDir, entryPath));
+  modulesByName.set(entryName, {
+    name: entryName,
+    absolutePath: entryPath,
+    size: 0,
+    type: "esm"
+  });
+  const ignore = [...MODULE_IGNORE];
+  if (config.assetsDirectory?.startsWith(config.configDir + sep)) {
+    ignore.push(`${toPosix(relative5(config.configDir, config.assetsDirectory))}/**`);
+  }
+  for (const rule of config.rules) {
+    const type = RULE_TYPE_TO_MODULE_TYPE[rule.type];
+    if (!type) {
+      throw new InvalidInputError(`Unsupported module rule type "${rule.type}" in ${config.configPath}. Supported: ${Object.keys(RULE_TYPE_TO_MODULE_TYPE).join(", ")}.`);
+    }
+    const matches = await globby(rule.globs, {
+      cwd: config.configDir,
+      onlyFiles: true,
+      dot: true,
+      ignore
+    });
+    for (const match of matches.sort()) {
+      if (!modulesByName.has(match)) {
+        modulesByName.set(match, {
+          name: match,
+          absolutePath: resolve3(config.configDir, match),
+          size: 0,
+          type
+        });
+      }
+    }
+  }
+  if (config.uploadSourceMaps) {
+    const maps = await globby("**/*.map", {
+      cwd: config.configDir,
+      onlyFiles: true,
+      dot: true,
+      ignore
+    });
+    for (const map of maps.sort()) {
+      addSourcemap(modulesByName, config.configDir, map);
+    }
+  } else {
+    for (const name of [...modulesByName.keys()]) {
+      const mapName = `${name}.map`;
+      if (await pathExists(resolve3(config.configDir, mapName))) {
+        addSourcemap(modulesByName, config.configDir, mapName);
+      }
+    }
+  }
+  const modules = [...modulesByName.values()];
+  let totalBytes = 0;
+  for (const module of modules) {
+    module.size = (await stat(module.absolutePath)).size;
+    totalBytes += module.size;
+  }
+  if (totalBytes > MAX_TOTAL_MODULE_BYTES) {
+    throw new InvalidInputError(`Worker modules total ${totalBytes} bytes, which exceeds the 40 MB limit for a Base44 deploy.`);
+  }
+  return modules;
+}
+function addSourcemap(modulesByName, configDir, name) {
+  if (modulesByName.has(name))
+    return;
+  modulesByName.set(name, {
+    name,
+    absolutePath: resolve3(configDir, name),
+    size: 0,
+    type: "sourcemap"
+  });
+}
+
+// src/core/site/wrangler-config.ts
+import { dirname as dirname12, join as join16, resolve as resolve4 } from "node:path";
+var WRANGLER_REDIRECT_PATH = join16(".wrangler", "deploy", "config.json");
+var RedirectConfigSchema = looseObject({
+  configPath: string2().min(1)
+});
+var WranglerConfigSchema = looseObject({
+  main: string2().min(1, "wrangler config is missing a 'main' entry module"),
+  no_bundle: boolean2().optional(),
+  rules: array(looseObject({ type: string2(), globs: array(string2()) })).optional(),
+  assets: looseObject({
+    directory: string2().optional(),
+    html_handling: string2().optional(),
+    not_found_handling: string2().optional(),
+    run_worker_first: union([boolean2(), array(string2())]).optional(),
+    headers: string2().optional(),
+    redirects: string2().optional()
+  }).optional(),
+  compatibility_date: string2().optional(),
+  compatibility_flags: array(string2()).optional(),
+  vars: record(string2(), unknown()).optional(),
+  upload_source_maps: boolean2().optional()
+});
+async function detectFullStackArtifact(projectRoot) {
+  const redirectPath = join16(projectRoot, WRANGLER_REDIRECT_PATH);
+  return await pathExists(redirectPath) ? redirectPath : null;
+}
+async function resolveWranglerConfig(redirectPath) {
+  const configPath = await resolveRedirectedConfigPath(redirectPath);
+  const parsed = await readJsonFile(configPath);
+  const result = WranglerConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ConfigInvalidError(`Invalid wrangler config: ${prettifyError(result.error)}`, configPath);
+  }
+  const config = result.data;
+  if (config.no_bundle !== true) {
+    throw new InvalidInputError("This framework's output requires bundling; not yet supported. Base44 only deploys pre-bundled Workers output (no_bundle: true).");
+  }
+  const configDir = dirname12(configPath);
+  const assetsDirectory = config.assets?.directory ? resolve4(configDir, config.assets.directory) : null;
+  return {
+    configPath,
+    configDir,
+    main: config.main,
+    assetsDirectory,
+    assetsConfig: config.assets ? toResolvedAssetsConfig(config.assets) : null,
+    compatibilityDate: config.compatibility_date ?? null,
+    compatibilityFlags: config.compatibility_flags ?? [],
+    rules: (config.rules ?? []).map((rule) => ({
+      type: rule.type,
+      globs: rule.globs
+    })),
+    uploadSourceMaps: config.upload_source_maps ?? false
+  };
+}
+async function resolveRedirectedConfigPath(redirectPath) {
+  const parsed = await readJsonFile(redirectPath);
+  const result = RedirectConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ConfigInvalidError(`Invalid deploy redirect file: ${prettifyError(result.error)}`, redirectPath);
+  }
+  const configPath = resolve4(dirname12(redirectPath), result.data.configPath);
+  if (!await pathExists(configPath)) {
+    throw new ConfigInvalidError(`Wrangler config referenced by ${redirectPath} does not exist: ${configPath}`, redirectPath, {
+      hints: [{ message: "Rebuild the project to regenerate the artifact" }]
+    });
+  }
+  return configPath;
+}
+function toResolvedAssetsConfig(assets) {
+  return {
+    htmlHandling: assets.html_handling,
+    notFoundHandling: assets.not_found_handling,
+    runWorkerFirst: assets.run_worker_first,
+    headers: assets.headers,
+    redirects: assets.redirects
+  };
+}
+
+// src/core/site/full-stack.ts
+async function resolveFullStackBuild(projectRoot) {
+  const redirectPath = await detectFullStackArtifact(projectRoot);
+  if (!redirectPath) {
+    return null;
+  }
+  const config = await resolveWranglerConfig(redirectPath);
+  return {
+    config,
+    modules: await collectModules(config),
+    assetsDir: config.assetsDirectory && await pathExists(config.assetsDirectory) ? config.assetsDirectory : null
+  };
+}
+
 // src/core/site/manifest.ts
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { stat } from "node:fs/promises";
-import { basename as basename5, extname, join as join16 } from "node:path";
+import { stat as stat2 } from "node:fs/promises";
+import { basename as basename5, extname, join as join17 } from "node:path";
+
+// ../../node_modules/p-map/index.js
+async function pMap(iterable, mapper, {
+  concurrency = Number.POSITIVE_INFINITY,
+  stopOnError = true,
+  signal
+} = {}) {
+  return new Promise((resolve_, reject_) => {
+    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+      throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
+    }
+    if (typeof mapper !== "function") {
+      throw new TypeError("Mapper function is required");
+    }
+    if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) {
+      throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+    }
+    const result = [];
+    const errors = [];
+    const skippedIndexesMap = new Map;
+    let isRejected = false;
+    let isResolved = false;
+    let isIterableDone = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
+    const iterator = iterable[Symbol.iterator] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+    const signalListener = () => {
+      reject(signal.reason);
+    };
+    const cleanup = () => {
+      signal?.removeEventListener("abort", signalListener);
+    };
+    const resolve = (value) => {
+      resolve_(value);
+      cleanup();
+    };
+    const reject = (reason) => {
+      isRejected = true;
+      isResolved = true;
+      reject_(reason);
+      cleanup();
+    };
+    if (signal) {
+      if (signal.aborted) {
+        reject(signal.reason);
+        return;
+      }
+      signal.addEventListener("abort", signalListener, { once: true });
+    }
+    const next = async () => {
+      if (isResolved) {
+        return;
+      }
+      const nextItem = await iterator.next();
+      const index = currentIndex;
+      currentIndex++;
+      if (nextItem.done) {
+        isIterableDone = true;
+        if (resolvingCount === 0 && !isResolved) {
+          if (!stopOnError && errors.length > 0) {
+            reject(new AggregateError(errors));
+            return;
+          }
+          isResolved = true;
+          if (skippedIndexesMap.size === 0) {
+            resolve(result);
+            return;
+          }
+          const pureResult = [];
+          for (const [index, value] of result.entries()) {
+            if (skippedIndexesMap.get(index) === pMapSkip) {
+              continue;
+            }
+            pureResult.push(value);
+          }
+          resolve(pureResult);
+        }
+        return;
+      }
+      resolvingCount++;
+      (async () => {
+        try {
+          const element = await nextItem.value;
+          if (isResolved) {
+            return;
+          }
+          const value = await mapper(element, index);
+          if (value === pMapSkip) {
+            skippedIndexesMap.set(index, value);
+          }
+          result[index] = value;
+          resolvingCount--;
+          await next();
+        } catch (error) {
+          if (stopOnError) {
+            reject(error);
+          } else {
+            errors.push(error);
+            resolvingCount--;
+            try {
+              await next();
+            } catch (error) {
+              reject(error);
+            }
+          }
+        }
+      })();
+    };
+    (async () => {
+      for (let index = 0;index < concurrency; index++) {
+        try {
+          await next();
+        } catch (error) {
+          reject(error);
+          break;
+        }
+        if (isIterableDone || isRejected) {
+          break;
+        }
+      }
+    })();
+  });
+}
+var pMapSkip = Symbol("skip");
+
+// src/core/site/manifest.ts
 var MAX_ASSET_COUNT = 1e5;
 var ASSETS_IGNORE_FILE = ".assetsignore";
 var ALWAYS_IGNORED = new Set([
@@ -239650,30 +239978,42 @@ var MIME_TYPES = {
 function getAssetContentType(filePath) {
   return MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
-async function hashAssetFile(appId, absolutePath) {
-  const hash = createHash("sha256").update(Buffer.from(appId, "utf8"));
+async function walkBuildOutput(outputDir) {
+  const found = await globby("**/*", {
+    cwd: outputDir,
+    dot: true,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignoreFiles: [ASSETS_IGNORE_FILE]
+  });
+  return found.filter((path) => !ALWAYS_IGNORED.has(basename5(path))).sort();
+}
+var STAT_CONCURRENCY = 32;
+async function describeBuildOutput(outputDir) {
+  const relativePaths = await walkBuildOutput(outputDir);
+  return await pMap(relativePaths, async (path) => {
+    const absolutePath = join17(outputDir, ...path.split("/"));
+    return { path, absolutePath, size: (await stat2(absolutePath)).size };
+  }, { concurrency: STAT_CONCURRENCY });
+}
+async function hashFileInto(hash, absolutePath) {
   for await (const chunk of createReadStream(absolutePath)) {
     hash.update(chunk);
   }
+  return hash;
+}
+async function hashAssetFile(appId, absolutePath) {
+  const hash = await hashFileInto(createHash("sha256").update(Buffer.from(appId, "utf8")), absolutePath);
   return hash.digest("hex").slice(0, 32);
 }
 async function buildAssetManifest(assetsDir, appId) {
   const manifest = {};
   const filesByHash = new Map;
-  const found = await globby("**/*", {
-    cwd: assetsDir,
-    dot: true,
-    onlyFiles: true,
-    followSymbolicLinks: false,
-    ignoreFiles: [ASSETS_IGNORE_FILE]
-  });
-  const relativeFilePaths = found.filter((path) => !ALWAYS_IGNORED.has(basename5(path)));
-  if (relativeFilePaths.length > MAX_ASSET_COUNT) {
-    throw new InvalidInputError(`Too many static assets: found ${relativeFilePaths.length}, the limit is ${MAX_ASSET_COUNT} files.`);
+  const files = await describeBuildOutput(assetsDir);
+  if (files.length > MAX_ASSET_COUNT) {
+    throw new InvalidInputError(`Too many static assets: found ${files.length}, the limit is ${MAX_ASSET_COUNT} files.`);
   }
-  for (const relativePath of relativeFilePaths.sort()) {
-    const absolutePath = join16(assetsDir, ...relativePath.split("/"));
-    const { size } = await stat(absolutePath);
+  for (const { path: relativePath, absolutePath, size } of files) {
     const hash = await hashAssetFile(appId, absolutePath);
     manifest[`/${relativePath}`] = { hash, size };
     if (!filesByHash.has(hash)) {
@@ -239688,229 +240028,8 @@ async function buildAssetManifest(assetsDir, appId) {
   return { manifest, filesByHash };
 }
 
-// src/core/site/modules.ts
-import { stat as stat2 } from "node:fs/promises";
-import { relative as relative5, resolve as resolve3, sep } from "node:path";
-var MAX_TOTAL_MODULE_BYTES = 40 * 1024 * 1024;
-var MODULE_IGNORE = ["wrangler.json", ".dev.vars"];
-var RULE_TYPE_TO_MODULE_TYPE = {
-  ESModule: "esm",
-  CompiledWasm: "wasm",
-  Text: "text",
-  Data: "data"
-};
-function toPosix(path) {
-  return path.split(sep).join("/");
-}
-async function collectModules(config) {
-  const entryPath = resolve3(config.configDir, config.main);
-  if (!await pathExists(entryPath)) {
-    throw new InvalidInputError(`Worker entry module does not exist: ${entryPath} (from "main" in ${config.configPath})`, {
-      hints: [{ message: "Rebuild the project to regenerate the artifact" }]
-    });
-  }
-  const modulesByName = new Map;
-  const entryName = toPosix(relative5(config.configDir, entryPath));
-  modulesByName.set(entryName, {
-    name: entryName,
-    absolutePath: entryPath,
-    size: 0,
-    type: "esm"
-  });
-  const ignore = [...MODULE_IGNORE];
-  if (config.assetsDirectory?.startsWith(config.configDir + sep)) {
-    ignore.push(`${toPosix(relative5(config.configDir, config.assetsDirectory))}/**`);
-  }
-  for (const rule of config.rules) {
-    const type = RULE_TYPE_TO_MODULE_TYPE[rule.type];
-    if (!type) {
-      throw new InvalidInputError(`Unsupported module rule type "${rule.type}" in ${config.configPath}. Supported: ${Object.keys(RULE_TYPE_TO_MODULE_TYPE).join(", ")}.`);
-    }
-    const matches = await globby(rule.globs, {
-      cwd: config.configDir,
-      onlyFiles: true,
-      dot: true,
-      ignore
-    });
-    for (const match of matches.sort()) {
-      if (!modulesByName.has(match)) {
-        modulesByName.set(match, {
-          name: match,
-          absolutePath: resolve3(config.configDir, match),
-          size: 0,
-          type
-        });
-      }
-    }
-  }
-  if (config.uploadSourceMaps) {
-    const maps = await globby("**/*.map", {
-      cwd: config.configDir,
-      onlyFiles: true,
-      dot: true,
-      ignore
-    });
-    for (const map of maps.sort()) {
-      addSourcemap(modulesByName, config.configDir, map);
-    }
-  } else {
-    for (const name of [...modulesByName.keys()]) {
-      const mapName = `${name}.map`;
-      if (await pathExists(resolve3(config.configDir, mapName))) {
-        addSourcemap(modulesByName, config.configDir, mapName);
-      }
-    }
-  }
-  const modules = [...modulesByName.values()];
-  let totalBytes = 0;
-  for (const module of modules) {
-    module.size = (await stat2(module.absolutePath)).size;
-    totalBytes += module.size;
-  }
-  if (totalBytes > MAX_TOTAL_MODULE_BYTES) {
-    throw new InvalidInputError(`Worker modules total ${totalBytes} bytes, which exceeds the 40 MB limit for a Base44 deploy.`);
-  }
-  return modules;
-}
-function addSourcemap(modulesByName, configDir, name) {
-  if (modulesByName.has(name))
-    return;
-  modulesByName.set(name, {
-    name,
-    absolutePath: resolve3(configDir, name),
-    size: 0,
-    type: "sourcemap"
-  });
-}
-
 // src/core/site/upload.ts
 import { readFile as readFile2 } from "node:fs/promises";
-
-// ../../node_modules/p-map/index.js
-async function pMap(iterable, mapper, {
-  concurrency = Number.POSITIVE_INFINITY,
-  stopOnError = true,
-  signal
-} = {}) {
-  return new Promise((resolve_, reject_) => {
-    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
-      throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
-    }
-    if (typeof mapper !== "function") {
-      throw new TypeError("Mapper function is required");
-    }
-    if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) {
-      throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
-    }
-    const result = [];
-    const errors = [];
-    const skippedIndexesMap = new Map;
-    let isRejected = false;
-    let isResolved = false;
-    let isIterableDone = false;
-    let resolvingCount = 0;
-    let currentIndex = 0;
-    const iterator = iterable[Symbol.iterator] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
-    const signalListener = () => {
-      reject(signal.reason);
-    };
-    const cleanup = () => {
-      signal?.removeEventListener("abort", signalListener);
-    };
-    const resolve = (value) => {
-      resolve_(value);
-      cleanup();
-    };
-    const reject = (reason) => {
-      isRejected = true;
-      isResolved = true;
-      reject_(reason);
-      cleanup();
-    };
-    if (signal) {
-      if (signal.aborted) {
-        reject(signal.reason);
-        return;
-      }
-      signal.addEventListener("abort", signalListener, { once: true });
-    }
-    const next = async () => {
-      if (isResolved) {
-        return;
-      }
-      const nextItem = await iterator.next();
-      const index = currentIndex;
-      currentIndex++;
-      if (nextItem.done) {
-        isIterableDone = true;
-        if (resolvingCount === 0 && !isResolved) {
-          if (!stopOnError && errors.length > 0) {
-            reject(new AggregateError(errors));
-            return;
-          }
-          isResolved = true;
-          if (skippedIndexesMap.size === 0) {
-            resolve(result);
-            return;
-          }
-          const pureResult = [];
-          for (const [index, value] of result.entries()) {
-            if (skippedIndexesMap.get(index) === pMapSkip) {
-              continue;
-            }
-            pureResult.push(value);
-          }
-          resolve(pureResult);
-        }
-        return;
-      }
-      resolvingCount++;
-      (async () => {
-        try {
-          const element = await nextItem.value;
-          if (isResolved) {
-            return;
-          }
-          const value = await mapper(element, index);
-          if (value === pMapSkip) {
-            skippedIndexesMap.set(index, value);
-          }
-          result[index] = value;
-          resolvingCount--;
-          await next();
-        } catch (error) {
-          if (stopOnError) {
-            reject(error);
-          } else {
-            errors.push(error);
-            resolvingCount--;
-            try {
-              await next();
-            } catch (error) {
-              reject(error);
-            }
-          }
-        }
-      })();
-    };
-    (async () => {
-      for (let index = 0;index < concurrency; index++) {
-        try {
-          await next();
-        } catch (error) {
-          reject(error);
-          break;
-        }
-        if (isIterableDone || isRejected) {
-          break;
-        }
-      }
-    })();
-  });
-}
-var pMapSkip = Symbol("skip");
-
-// src/core/site/upload.ts
 var DEFAULT_UPLOAD_CONCURRENCY = 3;
 var MAX_UPLOAD_CONCURRENCY = 50;
 var MAX_UPLOAD_ATTEMPTS = 3;
@@ -240009,11 +240128,17 @@ async function uploadPresignedAsset(upload, assets) {
   if (!file) {
     throw new InternalError(`Server requested upload of unknown asset path: ${upload.path}`);
   }
-  const content = await readFile2(file.absolutePath);
+  await putPresigned(upload, file.absolutePath);
+}
+async function putPresigned(upload, absolutePath) {
+  const content = await readFile2(absolutePath);
   try {
     await distribution_default.put(upload.url, {
       body: new Uint8Array(content),
-      headers: { "Content-Type": upload.contentType },
+      headers: {
+        "Content-Type": upload.contentType,
+        ...upload.checksumSha256 ? { "x-amz-checksum-sha256": upload.checksumSha256 } : {}
+      },
       timeout: 120000,
       retry: UPLOAD_RETRY
     });
@@ -240022,85 +240147,6 @@ async function uploadPresignedAsset(upload, assets) {
   }
 }
 
-// src/core/site/wrangler-config.ts
-import { dirname as dirname12, join as join17, resolve as resolve4 } from "node:path";
-var WRANGLER_REDIRECT_PATH = join17(".wrangler", "deploy", "config.json");
-var RedirectConfigSchema = looseObject({
-  configPath: string2().min(1)
-});
-var WranglerConfigSchema = looseObject({
-  main: string2().min(1, "wrangler config is missing a 'main' entry module"),
-  no_bundle: boolean2().optional(),
-  rules: array(looseObject({ type: string2(), globs: array(string2()) })).optional(),
-  assets: looseObject({
-    directory: string2().optional(),
-    html_handling: string2().optional(),
-    not_found_handling: string2().optional(),
-    run_worker_first: union([boolean2(), array(string2())]).optional(),
-    headers: string2().optional(),
-    redirects: string2().optional()
-  }).optional(),
-  compatibility_date: string2().optional(),
-  compatibility_flags: array(string2()).optional(),
-  vars: record(string2(), unknown()).optional(),
-  upload_source_maps: boolean2().optional()
-});
-async function detectFullStackArtifact(projectRoot) {
-  const redirectPath = join17(projectRoot, WRANGLER_REDIRECT_PATH);
-  return await pathExists(redirectPath) ? redirectPath : null;
-}
-async function resolveWranglerConfig(redirectPath) {
-  const configPath = await resolveRedirectedConfigPath(redirectPath);
-  const parsed = await readJsonFile(configPath);
-  const result = WranglerConfigSchema.safeParse(parsed);
-  if (!result.success) {
-    throw new ConfigInvalidError(`Invalid wrangler config: ${prettifyError(result.error)}`, configPath);
-  }
-  const config = result.data;
-  if (config.no_bundle !== true) {
-    throw new InvalidInputError("This framework's output requires bundling; not yet supported. Base44 only deploys pre-bundled Workers output (no_bundle: true).");
-  }
-  const configDir = dirname12(configPath);
-  const assetsDirectory = config.assets?.directory ? resolve4(configDir, config.assets.directory) : null;
-  return {
-    configPath,
-    configDir,
-    main: config.main,
-    assetsDirectory,
-    assetsConfig: config.assets ? toResolvedAssetsConfig(config.assets) : null,
-    compatibilityDate: config.compatibility_date ?? null,
-    compatibilityFlags: config.compatibility_flags ?? [],
-    rules: (config.rules ?? []).map((rule) => ({
-      type: rule.type,
-      globs: rule.globs
-    })),
-    uploadSourceMaps: config.upload_source_maps ?? false
-  };
-}
-async function resolveRedirectedConfigPath(redirectPath) {
-  const parsed = await readJsonFile(redirectPath);
-  const result = RedirectConfigSchema.safeParse(parsed);
-  if (!result.success) {
-    throw new ConfigInvalidError(`Invalid deploy redirect file: ${prettifyError(result.error)}`, redirectPath);
-  }
-  const configPath = resolve4(dirname12(redirectPath), result.data.configPath);
-  if (!await pathExists(configPath)) {
-    throw new ConfigInvalidError(`Wrangler config referenced by ${redirectPath} does not exist: ${configPath}`, redirectPath, {
-      hints: [{ message: "Rebuild the project to regenerate the artifact" }]
-    });
-  }
-  return configPath;
-}
-function toResolvedAssetsConfig(assets) {
-  return {
-    htmlHandling: assets.html_handling,
-    notFoundHandling: assets.not_found_handling,
-    runWorkerFirst: assets.run_worker_first,
-    headers: assets.headers,
-    redirects: assets.redirects
-  };
-}
-
 // src/core/site/deployment.ts
 var NO_ASSETS = { manifest: {}, filesByHash: new Map };
 var DEPLOYMENTS_API_ENV = "BASE44_DEPLOYMENTS_API";
@@ -240108,9 +240154,6 @@ function deploymentsApiEnabled(env = process.env) {
   const value = env[DEPLOYMENTS_API_ENV];
   return value === "1" || value === "true";
 }
-async function hasWorkerBuild(projectRoot) {
-  return await detectFullStackArtifact(projectRoot) !== null;
-}
 async function deployToDeployments(options) {
   const { projectRoot, outputDir, gitHash, concurrency, progress } = options;
   const worker = await resolveWorkerBuild(projectRoot, progress);
@@ -240133,12 +240176,11 @@ async function deployToDeployments(options) {
   return { deploymentId: finalized.deploymentId, gitHash };
 }
 async function resolveWorkerBuild(projectRoot, progress) {
-  const redirectPath = await detectFullStackArtifact(projectRoot);
-  if (!redirectPath) {
+  const built = await resolveFullStackBuild(projectRoot);
+  if (!built) {
     return null;
   }
-  const config = await resolveWranglerConfig(redirectPath);
-  const assetsDir = config.assetsDirectory && await pathExists(config.assetsDirectory) ? config.assetsDirectory : null;
+  const { config, modules, assetsDir } = built;
   return {
     config: {
       main: config.main,
@@ -240146,7 +240188,7 @@ async function resolveWorkerBuild(projectRoot, progress) {
       compatibility_flags: config.compatibilityFlags,
       assets: buildAssetsConfig(config.assetsConfig, progress)
     },
-    modules: await collectModules(config),
+    modules,
     assetsDir
   };
 }
@@ -246699,6 +246741,13 @@ async function resolveGitHash(projectRoot, explicit) {
   }
   return hash;
 }
+async function resolveProvenanceCommit(projectRoot, explicit) {
+  if (explicit) {
+    return await resolveGitHash(projectRoot, explicit);
+  }
+  const hash = await gitHead(projectRoot);
+  return hash && isGitCommitHash(hash) ? hash : undefined;
+}
 async function gitHead(projectRoot) {
   try {
     const { stdout } = await execa("git", ["rev-parse", "HEAD"], {
@@ -246710,7 +246759,7 @@ async function gitHead(projectRoot) {
   }
 }
 // src/core/project/deploy.ts
-function hasResourcesToDeploy(projectData, options = {}) {
+function hasResourcesToDeploy(projectData) {
   const {
     project,
     entities,
@@ -246721,7 +246770,7 @@ function hasResourcesToDeploy(projectData, options = {}) {
     connectors,
     authConfig
   } = projectData;
-  const hasSite = Boolean(project.site?.outputDirectory) || Boolean(options.workerBuild);
+  const hasSite = Boolean(project.site?.outputDirectory);
   const hasEntities = entities.length > 0;
   const hasFunctions = functions.length > 0;
   const hasActors = actors.length > 0;
@@ -246743,7 +246792,6 @@ async function deployAll(projectData, options) {
     connectors,
     authConfig
   } = projectData;
-  const workerGitHash = await hasWorkerBuild(project.root) ? await resolveGitHash(project.root) : null;
   await setAppVisibility(project.visibility);
   if (project.visibility) {
     options?.onVisibilitySet?.(project.visibility);
@@ -246781,24 +246829,56 @@ async function deployAll(projectData, options) {
   await authConfigResource.push(authConfig);
   const skipConnectorSync = connectors.length === 0 && hasWorkspaceApiKeyAuth();
   const connectorResults = skipConnectorSync ? [] : (await pushConnectors(connectors)).results;
-  const outputDir = project.site?.outputDirectory ? resolve5(project.root, project.site.outputDirectory) : null;
-  if (workerGitHash) {
-    const { deploymentId } = await deployToDeployments({
-      projectRoot: project.root,
-      outputDir,
-      gitHash: workerGitHash
-    });
-    return {
-      deployment: { deploymentId, gitHash: workerGitHash },
-      connectorResults
-    };
-  }
-  if (outputDir) {
+  if (project.site?.outputDirectory) {
+    const outputDir = resolve5(project.root, project.site.outputDirectory);
     const { appUrl } = await deploySite(outputDir);
     return { appUrl, connectorResults };
   }
   return { connectorResults };
 }
+// src/core/project/target.ts
+import { dirname as dirname13, join as join19, resolve as resolve6 } from "node:path";
+var DEFAULT_BUILD_COMMAND = "npm run build";
+var DEFAULT_OUTPUT_DIRECTORY = "dist";
+async function resolveBuildTarget(projectRoot, overrides = {}) {
+  const project = await readSettingsIfPresent(projectRoot);
+  const root = project?.root ?? projectRoot ?? process.cwd();
+  return {
+    root,
+    configDir: project ? dirname13(project.configPath) : join19(root, PROJECT_SUBDIR),
+    buildCommand: project ? project.site?.buildCommand : DEFAULT_BUILD_COMMAND,
+    outputDir: outputDirectory(project, root, overrides.outputDir),
+    entitiesDir: project?.entitiesDir ?? "entities",
+    agentsDir: project?.agentsDir ?? "agents"
+  };
+}
+function outputDirectory(project, root, override) {
+  const configured = override ?? (project ? project.site?.outputDirectory : DEFAULT_OUTPUT_DIRECTORY);
+  return configured ? resolve6(root, configured) : null;
+}
+function requireOutputDir(target) {
+  if (target.outputDir === null) {
+    throw new ConfigNotFoundError("No site configuration found.", {
+      hints: [
+        {
+          message: `Add 'site.outputDirectory' to your config.jsonc (e.g., "site": { "outputDirectory": "dist" })`
+        },
+        { message: `Or pass --output-dir <dir>, relative to ${target.root}` }
+      ]
+    });
+  }
+  return target.outputDir;
+}
+async function readSettingsIfPresent(projectRoot) {
+  try {
+    return await readProjectSettings(projectRoot);
+  } catch (error) {
+    if (error instanceof ConfigNotFoundError) {
+      return null;
+    }
+    throw error;
+  }
+}
 // src/core/clients/base44-client.ts
 var retriedRequests = new WeakSet;
 async function captureRequestBody(request, options) {
@@ -247080,6 +247160,12 @@ async function ensureAppContext(ctx, options = {}) {
   ctx.app = appContext;
   ctx.errorReporter.setContext({ appId: appContext.id });
 }
+function requireApp(ctx) {
+  if (!ctx.app) {
+    throw new InternalError("This command read an app context it never resolved — it is declared with requireAppContext: false.");
+  }
+  return ctx.app;
+}
 
 // src/cli/utils/version-check.ts
 async function checkForUpgrade() {
@@ -247263,6 +247349,10 @@ function writeJsonError(error) {
   const envelope = {
     error: error instanceof Error ? error.message : String(error)
   };
+  const step = stepOf(error);
+  if (step !== undefined) {
+    envelope.step = step;
+  }
   if (isCLIError(error)) {
     envelope.code = error.code;
     if (error.details.length > 0) {
@@ -247632,7 +247722,7 @@ function getActorsCommand() {
 }
 
 // src/cli/commands/agent-skills/pull.ts
-import { dirname as dirname13, join as join19 } from "node:path";
+import { dirname as dirname14, join as join20 } from "node:path";
 // src/core/utils/dependencies.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 function verifyDenoInstalled(context) {
@@ -247721,7 +247811,7 @@ async function pullAction({
   runTask
 }) {
   const { project } = await readProjectConfig();
-  const dir = join19(dirname13(project.configPath), project.agentSkillsDir);
+  const dir = join20(dirname14(project.configPath), project.agentSkillsDir);
   const remote = await runTask("Fetching agent skills from Base44", () => fetchAgentSkills(), {
     successMessage: "Agent skills fetched successfully",
     errorMessage: "Failed to fetch agent skills"
@@ -247777,14 +247867,14 @@ function getAgentSkillsCommand() {
 }
 
 // src/cli/commands/agents/pull.ts
-import { dirname as dirname14, join as join20 } from "node:path";
+import { dirname as dirname15, join as join21 } from "node:path";
 async function pullAgentsAction({
   log,
   runTask
 }) {
   const { project } = await readProjectConfig();
-  const configDir = dirname14(project.configPath);
-  const agentsDir = join20(configDir, project.agentsDir);
+  const configDir = dirname15(project.configPath);
+  const agentsDir = join21(configDir, project.agentsDir);
   const remoteAgents = await runTask("Fetching agents from Base44", async () => {
     return await fetchAgents();
   }, {
@@ -247854,12 +247944,12 @@ function getAgentsCommand() {
 }
 
 // src/cli/commands/auth/password-login.ts
-import { dirname as dirname15, join as join21 } from "node:path";
+import { dirname as dirname16, join as join22 } from "node:path";
 async function passwordLoginAction({ log, runTask }, action) {
   const shouldEnable = action === "enable";
   const { project } = await readProjectConfig();
-  const configDir = dirname15(project.configPath);
-  const authDir = join21(configDir, project.authDir);
+  const configDir = dirname16(project.configPath);
+  const authDir = join22(configDir, project.authDir);
   const updated = await runTask("Updating local auth config", async () => {
     const current = await readAuthConfig(authDir) ?? DEFAULT_AUTH_CONFIG;
     const merged = { ...current, enableUsernamePassword: shouldEnable };
@@ -247879,14 +247969,14 @@ function getPasswordLoginCommand() {
 }
 
 // src/cli/commands/auth/pull.ts
-import { dirname as dirname16, join as join22 } from "node:path";
+import { dirname as dirname17, join as join23 } from "node:path";
 async function pullAuthAction({
   log,
   runTask
 }) {
   const { project } = await readProjectConfig();
-  const configDir = dirname16(project.configPath);
-  const authDir = join22(configDir, project.authDir);
+  const configDir = dirname17(project.configPath);
+  const authDir = join23(configDir, project.authDir);
   const remoteConfig = await runTask("Fetching auth config from Base44", async () => {
     return await pullAuthConfig();
   }, {
@@ -247950,7 +248040,7 @@ function getAuthPushCommand() {
 }
 
 // src/cli/commands/auth/social-login.ts
-import { dirname as dirname17, join as join23, resolve as resolve6 } from "node:path";
+import { dirname as dirname18, join as join24, resolve as resolve7 } from "node:path";
 var PROVIDER_LABELS = {
   google: "Google",
   microsoft: "Microsoft",
@@ -247990,7 +248080,7 @@ async function socialLoginAction({ log, isNonInteractive, runTask }, provider, a
   let clientSecret;
   if (useCustomOAuth && oauth && oauthCli && hasSecretOptions(options)) {
     if (options.envFile) {
-      const secrets = await parseEnvFile(resolve6(options.envFile));
+      const secrets = await parseEnvFile(resolve7(options.envFile));
       const value = secrets[oauthCli.envVar];
       if (!value) {
         throw new InvalidInputError(`Key "${oauthCli.envVar}" not found in ${options.envFile}.`);
@@ -248020,8 +248110,8 @@ async function socialLoginAction({ log, isNonInteractive, runTask }, provider, a
     }
   }
   const { project } = await readProjectConfig();
-  const configDir = dirname17(project.configPath);
-  const authDir = join23(configDir, project.authDir);
+  const configDir = dirname18(project.configPath);
+  const authDir = join24(configDir, project.authDir);
   const { config: updated } = await runTask("Updating local auth config", async () => updateSocialLoginConfig(authDir, provider, shouldEnable, useCustomOAuth && options.clientId ? { clientId: options.clientId } : undefined));
   if (clientSecret) {
     await runTask("Saving client secret", async () => pushCustomOAuthSecret(provider, clientSecret));
@@ -248046,7 +248136,7 @@ function getSocialLoginCommand() {
 }
 
 // src/cli/commands/auth/sso.ts
-import { dirname as dirname18, join as join24, resolve as resolve7 } from "node:path";
+import { dirname as dirname19, join as join25, resolve as resolve8 } from "node:path";
 var SSOConfigFileSchema = object({
   provider: _enum(Object.values(KNOWN_SSO_PROVIDERS)),
   clientId: string2(),
@@ -248062,7 +248152,7 @@ var SSOConfigFileSchema = object({
   ssoName: string2().optional()
 });
 async function loadSSOConfigFile(filePath) {
-  const resolved = resolve7(filePath);
+  const resolved = resolve8(filePath);
   const raw = await readJsonFile(resolved);
   const result = SSOConfigFileSchema.safeParse(raw);
   if (!result.success) {
@@ -248150,7 +248240,7 @@ async function ssoEnableAction({ isNonInteractive, runTask }, options) {
   }
   let clientSecret;
   if (merged.envFile && !merged.clientSecret) {
-    const secrets = await parseEnvFile(resolve7(merged.envFile));
+    const secrets = await parseEnvFile(resolve8(merged.envFile));
     const value = secrets.sso_client_secret;
     if (!value) {
       throw new InvalidInputError(`Key "sso_client_secret" not found in ${merged.envFile}.`);
@@ -248209,8 +248299,8 @@ async function ssoEnableAction({ isNonInteractive, runTask }, options) {
     throw error;
   }
   const { project } = await readProjectConfig();
-  const configDir = dirname18(project.configPath);
-  const authDir = join24(configDir, project.authDir);
+  const configDir = dirname19(project.configPath);
+  const authDir = join25(configDir, project.authDir);
   await runTask("Updating local auth config", async () => updateSSOConfig(authDir, provider, true));
   await runTask("Saving SSO credentials", async () => pushSSOSecrets(secrets));
   return {
@@ -248225,8 +248315,8 @@ async function ssoDisableAction({ log, runTask }, options) {
     throw new InvalidInputError("Configuration options cannot be used with disable. To disable SSO: base44 auth sso disable");
   }
   const { project } = await readProjectConfig();
-  const configDir = dirname18(project.configPath);
-  const authDir = join24(configDir, project.authDir);
+  const configDir = dirname19(project.configPath);
+  const authDir = join25(configDir, project.authDir);
   const updated = await runTask("Updating local auth config", async () => updateSSOConfig(authDir, null, false));
   await runTask("Removing SSO credentials", async () => deleteSSOSecrets());
   if (!hasAnyLoginMethod(updated)) {
@@ -249108,13 +249198,13 @@ function getConnectorsListAvailableCommand() {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname19, join as join25, resolve as resolve8 } from "node:path";
+import { dirname as dirname20, join as join26, resolve as resolve9 } from "node:path";
 async function resolveConnectorsDir(options) {
   if (!getAppContext().projectRoot) {
-    return resolve8(options.dir ?? "connectors");
+    return resolve9(options.dir ?? "connectors");
   }
   const { project } = await readProjectConfig();
-  return join25(dirname19(project.configPath), project.connectorsDir);
+  return join26(dirname20(project.configPath), project.connectorsDir);
 }
 async function pullConnectorsAction({ log, runTask, jsonMode }, options) {
   const connectorsDir = await resolveConnectorsDir(options);
@@ -249155,10 +249245,10 @@ function getConnectorsPullCommand() {
 }
 
 // src/cli/commands/connectors/push.ts
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 async function readConnectorsToPush(options) {
   if (!getAppContext().projectRoot) {
-    return readAllConnectors(resolve9(options.dir ?? "connectors"));
+    return readAllConnectors(resolve10(options.dir ?? "connectors"));
   }
   const { connectors } = await readProjectConfig();
   return connectors;
@@ -249501,11 +249591,11 @@ function getListCommand() {
 }
 
 // src/cli/commands/functions/pull.ts
-import { dirname as dirname20, join as join26 } from "node:path";
+import { dirname as dirname21, join as join27 } from "node:path";
 async function pullFunctionsAction({ log, runTask }, name) {
   const { project, functions } = await readProjectConfig();
-  const configDir = dirname20(project.configPath);
-  const functionsDir = join26(configDir, project.functionsDir);
+  const configDir = dirname21(project.configPath);
+  const functionsDir = join27(configDir, project.functionsDir);
   const pluginFunctionNames = new Set(functions.filter((fn) => fn.source.type === "plugin").map((fn) => fn.name));
   const remoteFunctions = await runTask("Fetching functions from Base44", async () => {
     const { functions } = await listDeployedFunctions();
@@ -249608,14 +249698,11 @@ async function maybeAskToBuild(isNonInteractive, buildCommand) {
 
 // src/cli/commands/project/build.ts
 async function buildAction(ctx) {
-  const { app } = ctx;
-  if (!app?.projectRoot) {
-    throw new ConfigInvalidError("base44 build requires a linked local project. Run it from a project with base44/.app.jsonc.");
-  }
-  const { project } = await readProjectConfig(app.projectRoot);
+  const app = requireApp(ctx);
+  const target = await resolveBuildTarget(app.projectRoot);
   await runSiteBuild(ctx, {
-    root: project.root,
-    buildCommand: project.site?.buildCommand,
+    root: target.root,
+    buildCommand: target.buildCommand,
     appId: app.id
   });
   return {
@@ -249623,15 +249710,15 @@ async function buildAction(ctx) {
   };
 }
 function getBuildCommand() {
-  return new Base44Command("build").description("Build the site with the Base44 app id injected").action(buildAction);
+  return new Base44Command("build", { requireAuth: false }).description("Build the site with the Base44 app id injected").action(buildAction);
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename6, resolve as resolve10 } from "node:path";
+import { basename as basename6, resolve as resolve11 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 var DEFAULT_TEMPLATE_ID = "backend-only";
 async function getTemplateById(templateId) {
   const templates = await listTemplates();
@@ -249694,7 +249781,7 @@ async function completeProjectSetup({
           env: { VITE_BASE44_APP_ID: projectId }
         })`${buildCommand}`;
         updateMessage("Deploying site...");
-        return await deploySite(join27(resolvedPath, outputDirectory));
+        return await deploySite(join28(resolvedPath, outputDirectory));
       }, {
         successMessage: theme.colors.base44Orange("Site deployed successfully"),
         errorMessage: "Failed to deploy site"
@@ -249823,7 +249910,7 @@ async function createInteractive(options, ctx) {
   }, ctx);
 }
 async function createNonInteractive(options, ctx) {
-  ctx.log.info(`Creating a new project at ${resolve10(options.path)}`);
+  ctx.log.info(`Creating a new project at ${resolve11(options.path)}`);
   const template = await getTemplateById(options.template ?? DEFAULT_TEMPLATE_ID);
   return await executeCreate({
     template,
@@ -249847,7 +249934,7 @@ async function executeCreate({
 }, ctx) {
   const { log, runTask } = ctx;
   const name = rawName.trim();
-  const resolvedPath = resolve10(projectPath);
+  const resolvedPath = resolve11(projectPath);
   const organizationId = await resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive);
   const { projectId } = await runTask("Setting up your project...", async () => {
     return await createProjectFiles({
@@ -249904,8 +249991,7 @@ async function deployAction(ctx, options = {}) {
     throw new InvalidInputError("--yes is required in non-interactive mode");
   }
   const projectData = await readProjectConfig(options.projectRoot);
-  const workerBuild = await hasWorkerBuild(projectData.project.root);
-  if (!hasResourcesToDeploy(projectData, { workerBuild })) {
+  if (!hasResourcesToDeploy(projectData)) {
     return {
       outroMessage: "No resources found to deploy"
     };
@@ -249941,9 +250027,7 @@ async function deployAction(ctx, options = {}) {
   if (project.visibility) {
     summaryLines.push(`  - Visibility: ${project.visibility}`);
   }
-  if (workerBuild) {
-    summaryLines.push("  - Site");
-  } else if (project.site?.outputDirectory) {
+  if (project.site?.outputDirectory) {
     summaryLines.push(`  - Site from ${project.site.outputDirectory}`);
   }
   if (!options.yes) {
@@ -249998,10 +250082,6 @@ ${summaryLines.join(`
   if (result.appUrl) {
     log.message(`${theme.styles.header("App URL")}: ${theme.colors.links(result.appUrl)}`);
   }
-  if (result.deployment) {
-    const { deploymentId, gitHash } = result.deployment;
-    log.message(`${theme.styles.header("Deployment")}: ${deploymentId} (commit ${gitHash.slice(0, 12)})`);
-  }
   return { outroMessage: "App deployed successfully" };
 }
 function getDeployCommand3() {
@@ -250495,7 +250575,7 @@ function getLogsCommand() {
 }
 
 // src/cli/commands/project/scaffold.ts
-import { basename as basename7, resolve as resolve11 } from "node:path";
+import { basename as basename7, resolve as resolve12 } from "node:path";
 function resolveAppId(options) {
   const appId = options.appId;
   if (!appId) {
@@ -250511,7 +250591,7 @@ function resolveAppId(options) {
 async function scaffoldAction(ctx, name, options, command) {
   const { log, runTask } = ctx;
   const appId = resolveAppId(command.optsWithGlobals());
-  const resolvedPath = resolve11("./");
+  const resolvedPath = resolve12("./");
   const projectName = (name ?? basename7(resolvedPath)).trim();
   const template = await getTemplateById("backend-only");
   log.info(`Scaffolding project at ${resolvedPath}`);
@@ -250559,6 +250639,315 @@ function getVisibilityCommand() {
   ])).action(setVisibility);
 }
 
+// src/core/version/schema.ts
+var DeclareVersionResponseSchema = object({
+  session_id: string2(),
+  uploads: array(object({
+    path: string2(),
+    url: string2(),
+    content_type: string2(),
+    content_length: number2(),
+    checksum_sha256: string2()
+  }))
+}).transform((data) => ({
+  sessionId: data.session_id,
+  uploads: data.uploads.map((upload) => ({
+    path: upload.path,
+    url: upload.url,
+    contentType: upload.content_type,
+    contentLength: upload.content_length,
+    checksumSha256: upload.checksum_sha256
+  }))
+}));
+var CreateVersionResponseSchema = object({
+  version_id: string2(),
+  manifest_hash: string2()
+}).transform((data) => ({
+  versionId: data.version_id,
+  manifestHash: data.manifest_hash
+}));
+var EnvironmentResponseSchema = object({
+  name: string2(),
+  version_id: string2(),
+  manifest_hash: string2(),
+  deployment_id: string2()
+}).transform((data) => ({
+  name: data.name,
+  versionId: data.version_id,
+  manifestHash: data.manifest_hash,
+  deploymentId: data.deployment_id
+}));
+
+// src/core/version/api.ts
+var DEFAULT_VERSION_UPLOAD_CONCURRENCY = 8;
+var MAX_VERSION_UPLOAD_CONCURRENCY = 16;
+function declaredFile({ path, size, digest }) {
+  return { path, size, digest };
+}
+function declaredModule(module) {
+  return { ...declaredFile(module), type: module.type };
+}
+function declaredServingConfig(config) {
+  const stated = {
+    html_handling: config?.htmlHandling ?? null,
+    not_found_handling: config?.notFoundHandling ?? null,
+    run_worker_first: config?.runWorkerFirst ?? null,
+    headers: config?.headers ?? null,
+    redirects: config?.redirects ?? null
+  };
+  return Object.values(stated).every((v) => v === null) ? null : stated;
+}
+async function post(path, json, doing) {
+  try {
+    return await getAppClient().post(path, { json, timeout: 180000 });
+  } catch (error) {
+    throw await ApiError.fromHttpError(error, doing);
+  }
+}
+var KEYED_RETRY = {
+  limit: 3,
+  methods: ["patch"],
+  statusCodes: [408, 500, 502, 503, 504],
+  retryOnTimeout: true
+};
+async function patch(path, json, doing, retry) {
+  try {
+    return await getAppClient().patch(path, {
+      json,
+      timeout: 180000,
+      ...retry ? { retry } : {}
+    });
+  } catch (error) {
+    throw await ApiError.fromHttpError(error, doing);
+  }
+}
+function parse10(schema, body, what) {
+  const result = schema.safeParse(body);
+  if (!result.success) {
+    throw new SchemaValidationError(`Invalid ${what} response from server`, result.error);
+  }
+  return result.data;
+}
+async function createVersion(artifacts, options = {}) {
+  const declared = parse10(DeclareVersionResponseSchema, await (await post("versions", {
+    assets: artifacts.assets.map(declaredFile),
+    ...artifacts.siteWorker ? {
+      site_worker: {
+        main: artifacts.siteWorker.main,
+        modules: artifacts.siteWorker.modules.map(declaredModule),
+        compatibility_date: artifacts.siteWorker.compatibilityDate,
+        compatibility_flags: artifacts.siteWorker.compatibilityFlags,
+        serving_config: declaredServingConfig(artifacts.siteWorker.servingConfig)
+      }
+    } : {},
+    entities: artifacts.entities,
+    agents: artifacts.agents,
+    source_commit: options.sourceCommit
+  }, "declaring a version")).json(), "declare");
+  const declaredFiles = [
+    ...artifacts.assets,
+    ...artifacts.siteWorker?.modules ?? []
+  ];
+  options.progress?.onDeclared?.({ fileCount: declaredFiles.length });
+  if (declared.uploads.length !== declaredFiles.length) {
+    throw new InternalError(`Declared ${declaredFiles.length} files but the server signed ${declared.uploads.length} upload URLs.`);
+  }
+  const drifted = declared.uploads.findIndex((upload, index) => upload.path !== declaredFiles[index].path);
+  if (drifted !== -1) {
+    throw new InternalError(`Upload ${drifted} is signed for ${declared.uploads[drifted].path}, but that slot declared ${declaredFiles[drifted].path}.`);
+  }
+  let uploadedFiles = 0;
+  await pMap(declared.uploads, async (upload, index) => {
+    await putPresigned(upload, declaredFiles[index].absolutePath);
+    uploadedFiles++;
+    options.progress?.onUpload?.({
+      uploadedFiles,
+      totalFiles: declared.uploads.length
+    });
+  }, { concurrency: options.concurrency ?? DEFAULT_VERSION_UPLOAD_CONCURRENCY });
+  return parse10(CreateVersionResponseSchema, await (await post(`versions/${encodeURIComponent(declared.sessionId)}/finalize`, {}, "creating a version")).json(), "create version");
+}
+async function setEnvironmentVersion(environment, versionId, options = {}) {
+  return parse10(EnvironmentResponseSchema, await (await patch(`environments/${encodeURIComponent(environment)}`, {
+    version_id: versionId,
+    ...options.idempotencyKey ? { idempotency_key: options.idempotencyKey } : {}
+  }, "setting the environment's version", options.idempotencyKey ? KEYED_RETRY : undefined)).json(), "environment");
+}
+// src/core/version/artifacts.ts
+import { createHash as createHash2 } from "node:crypto";
+import { join as join29, resolve as resolve13 } from "node:path";
+var MAX_FILE_COUNT = 50000;
+var HASH_CONCURRENCY = 32;
+var ENTRY2 = "index.html";
+async function digestFile(absolutePath) {
+  const hash = await hashFileInto(createHash2("sha256"), absolutePath);
+  return `sha256:${hash.digest("hex")}`;
+}
+async function collectBuildOutput(outputDir, options = {}) {
+  const found = await describeBuildOutput(outputDir);
+  if (found.length > MAX_FILE_COUNT) {
+    throw new InvalidInputError(`Too many files: found ${found.length}, the limit is ${MAX_FILE_COUNT}.`);
+  }
+  if (options.entryFile) {
+    if (found.length === 0) {
+      throw new InvalidInputError(`No files found in ${outputDir}. Build the site before creating a version.`, {
+        hints: [
+          { message: "Run 'base44 build' first", command: "base44 build" }
+        ]
+      });
+    }
+    if (!found.some((f) => f.path === options.entryFile)) {
+      throw new InvalidInputError(`${outputDir} has no ${options.entryFile}, so nothing could enter the site.`);
+    }
+  }
+  return await pMap(found, async (file) => ({ ...file, digest: await digestFile(file.absolutePath) }), { concurrency: HASH_CONCURRENCY });
+}
+async function describeSiteWorker(built) {
+  const { config, modules } = built;
+  const entry = resolve13(config.configDir, config.main);
+  const main = modules.find((m) => m.absolutePath === entry)?.name;
+  if (!main) {
+    throw new InvalidInputError(`The Worker's entry module ${config.main} is not among the ${modules.length} modules collected from ${config.configDir}.`);
+  }
+  return {
+    main,
+    modules: await pMap(modules, async ({ name, absolutePath, size, type }) => ({
+      path: name,
+      absolutePath,
+      size,
+      digest: await digestFile(absolutePath),
+      type
+    }), { concurrency: HASH_CONCURRENCY }),
+    compatibilityDate: config.compatibilityDate,
+    compatibilityFlags: config.compatibilityFlags,
+    servingConfig: config.assetsConfig
+  };
+}
+async function readRawResources(dir) {
+  if (!await pathExists(dir)) {
+    return {};
+  }
+  const files = await globby(`**/*.${CONFIG_FILE_EXTENSION_GLOB}`, {
+    cwd: dir,
+    onlyFiles: true,
+    followSymbolicLinks: false
+  });
+  const payloads = {};
+  for (const relativePath of files.sort()) {
+    const name = relativePath.replace(/\.jsonc?$/, "");
+    payloads[name] = await readJsonFile(join29(dir, ...relativePath.split("/")));
+  }
+  return payloads;
+}
+async function collectResources(configDir, dirs) {
+  const [entities, agents] = await Promise.all([
+    readRawResources(join29(configDir, dirs.entitiesDir)),
+    readRawResources(join29(configDir, dirs.agentsDir))
+  ]);
+  return { entities, agents };
+}
+async function collectArtifacts(target) {
+  const built = await resolveFullStackBuild(target.root);
+  const siteWorker = built ? await describeSiteWorker(built) : null;
+  return {
+    assets: built ? built.assetsDir ? await collectBuildOutput(built.assetsDir) : [] : await collectBuildOutput(requireOutputDir(target), {
+      entryFile: ENTRY2
+    }),
+    ...siteWorker ? { siteWorker } : {},
+    ...await collectResources(target.configDir, target)
+  };
+}
+// src/core/version/gate.ts
+var VERSIONS_API_ENV = "BASE44_VERSIONS_API";
+function versionsApiEnabled(env = process.env) {
+  const value = env[VERSIONS_API_ENV];
+  return value === "1" || value === "true";
+}
+// src/core/version/publish.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+var DEFAULT_ENVIRONMENT = "production";
+async function tagStep2(step, run) {
+  return await tagStep(step, run);
+}
+async function publishVersion(artifacts, options = {}) {
+  const version = await tagStep2("create_version", () => createVersion(artifacts, {
+    sourceCommit: options.sourceCommit,
+    concurrency: options.concurrency,
+    progress: options.progress
+  }));
+  const environment = await tagStep2("deploy", () => setEnvironmentVersion(options.target ?? DEFAULT_ENVIRONMENT, version.versionId, {
+    idempotencyKey: randomUUID4()
+  }));
+  return {
+    environment: environment.name,
+    versionId: environment.versionId,
+    manifestHash: environment.manifestHash,
+    deploymentId: environment.deploymentId
+  };
+}
+// src/cli/commands/versions/options.ts
+function outputDirOption() {
+  return new Option2("--output-dir <dir>", "Build output directory (defaults to the project's, else dist)");
+}
+function targetOption() {
+  return new Option2("--target <name>", "Environment to serve the version at");
+}
+function gitHashOption() {
+  return new Option2("--git-hash <hash>", "Commit the build came from (defaults to the checkout's HEAD)").argParser((value) => {
+    if (!isGitCommitHash(value)) {
+      throw new InvalidArgumentError2("Expected a git commit hash (7-64 hex chars).");
+    }
+    return value;
+  });
+}
+function concurrencyOption() {
+  return new Option2("--concurrency <n>", "Parallel file uploads").default(DEFAULT_VERSION_UPLOAD_CONCURRENCY).argParser((value) => {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_VERSION_UPLOAD_CONCURRENCY) {
+      throw new InvalidArgumentError2(`Expected a whole number between 1 and ${MAX_VERSION_UPLOAD_CONCURRENCY}.`);
+    }
+    return parsed;
+  });
+}
+
+// src/cli/commands/publish.ts
+async function publishAction(ctx, options) {
+  const { runTask, log, jsonMode } = ctx;
+  const app = requireApp(ctx);
+  const target = await tagStep2("create_version", () => resolveBuildTarget(app.projectRoot, { outputDir: options.outputDir }));
+  if (options.build !== false) {
+    await tagStep2("build", () => runSiteBuild(ctx, {
+      root: target.root,
+      buildCommand: target.buildCommand,
+      appId: app.id
+    }));
+  }
+  const gitHash = await resolveProvenanceCommit(target.root, options.gitHash);
+  const result = await runTask("Publishing...", async (updateMessage) => {
+    const artifacts = await tagStep2("create_version", () => collectArtifacts(target));
+    return await publishVersion(artifacts, {
+      sourceCommit: gitHash,
+      target: options.target,
+      concurrency: options.concurrency,
+      progress: {
+        onDeclared: ({ fileCount }) => updateMessage(`Uploading ${fileCount} files`),
+        onUpload: ({ uploadedFiles, totalFiles }) => updateMessage(`Uploaded ${uploadedFiles} of ${totalFiles} files`)
+      }
+    });
+  }, { successMessage: "Published", errorMessage: "Publish failed" });
+  if (!jsonMode) {
+    log.message(theme.styles.dim(`version ${result.versionId}`));
+  }
+  return {
+    outroMessage: `${result.environment} now serves ${result.versionId}`,
+    stdout: jsonMode ? `${JSON.stringify(result, null, 2)}
+` : undefined
+  };
+}
+function getPublishCommand() {
+  return new Base44Command("publish").description("Build the app, record it as a version, and serve that version").option("--no-build", "Publish the existing build output without rebuilding").addOption(outputDirOption()).addOption(targetOption()).addOption(gitHashOption()).addOption(concurrencyOption()).action(publishAction);
+}
+
 // src/core/resources/sandbox/schema.ts
 var FileErrorSchema = object({
   code: string2(),
@@ -250944,7 +251333,7 @@ function getSecretsListCommand() {
 }
 
 // src/cli/commands/secrets/set.ts
-import { resolve as resolve12 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 function parseEntries(entries) {
   const secrets = {};
   for (const entry of entries) {
@@ -250975,7 +251364,7 @@ async function setSecretsAction({ log, runTask }, entries, options) {
   validateInput(entries, options);
   let secrets;
   if (options.envFile) {
-    secrets = await parseEnvFile(resolve12(options.envFile));
+    secrets = await parseEnvFile(resolve14(options.envFile));
     if (Object.keys(secrets).length === 0) {
       throw new InvalidInputError("The env file contains no valid KEY=VALUE entries.");
     }
@@ -251004,7 +251393,7 @@ function getSecretsCommand() {
 }
 
 // src/cli/commands/site/deploy.ts
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 async function deployAction2(ctx, options) {
   const { isNonInteractive } = ctx;
   if (isNonInteractive && !options.yes) {
@@ -251012,17 +251401,16 @@ async function deployAction2(ctx, options) {
   }
   const project = await readProjectSettings();
   await maybeBuildBeforeDeploy(ctx, project, options.build);
-  const workerBuild = await hasWorkerBuild(project.root);
   if (!options.yes) {
     const outputDirectory = project.site?.outputDirectory;
     const shouldDeploy = await Re({
-      message: outputDirectory && !workerBuild ? `Deploy site from ${outputDirectory}?` : "Deploy site?"
+      message: outputDirectory ? `Deploy site from ${outputDirectory}?` : "Deploy site?"
     });
     if (Ct(shouldDeploy) || !shouldDeploy) {
       return { outroMessage: "Deployment cancelled" };
     }
   }
-  return workerBuild || deploymentsApiEnabled() ? await deployToDeploymentsApi(ctx, project, options) : await deployTarball(ctx, project);
+  return deploymentsApiEnabled() ? await deployToDeploymentsApi(ctx, project, options) : await deployTarball(ctx, project);
 }
 async function deployToDeploymentsApi(ctx, project, options) {
   const { runTask, log, jsonMode } = ctx;
@@ -251083,7 +251471,7 @@ async function deployTarball({ runTask }, project) {
 }
 function siteOutputDir(project) {
   const outputDirectory = project.site?.outputDirectory;
-  return outputDirectory ? resolve13(project.root, outputDirectory) : null;
+  return outputDirectory ? resolve15(project.root, outputDirectory) : null;
 }
 function getSiteDeployCommand() {
   const command = new Base44Command("deploy").description("Deploy built site files to Base44 hosting").option("-y, --yes", "Skip confirmation prompt").option("--build", "Build the site before deploying (skips the prompt)").option("--no-build", "Deploy without building (skips the prompt)");
@@ -251107,6 +251495,229 @@ function parseConcurrency(value) {
   return parsed;
 }
 
+// src/cli/dev/createDevLogger.ts
+var colorByType = {
+  error: theme.styles.error,
+  warn: theme.styles.warn,
+  log: (input) => input
+};
+var stringify = (item) => {
+  if (typeof item === "string") {
+    return item;
+  }
+  if (item instanceof Error) {
+    return item.toString();
+  }
+  try {
+    return JSON.stringify(item, null, 2) ?? String(item);
+  } catch {
+    return String(item);
+  }
+};
+function createDevLogger(label, labelColor = theme.styles.dim) {
+  const prefix = label ? `${labelColor(`[${label}]`)} ` : "";
+  const print = (type, ...args) => {
+    const colorize = colorByType[type];
+    console[type](prefix + args.map((item) => colorize(stringify(item))).join(" "));
+  };
+  return {
+    log: (...args) => print("log", ...args),
+    error: (msg, err) => {
+      print("error", msg);
+      if (err) {
+        print("error", err);
+      }
+    },
+    warn: (...args) => print("warn", ...args)
+  };
+}
+
+// src/cli/dev/dev-server/serve-runner.ts
+import { spawn as spawn2 } from "node:child_process";
+import process21 from "node:process";
+
+class ServeRunner {
+  command;
+  cwd;
+  env;
+  logger;
+  child;
+  stopping = false;
+  stopPromise;
+  exitListeners = [];
+  constructor(options) {
+    this.command = options.command;
+    this.cwd = options.cwd;
+    this.env = options.env;
+    this.logger = options.logger;
+  }
+  start() {
+    if (this.child) {
+      return;
+    }
+    const stdin = process21.platform === "win32" ? "ignore" : "inherit";
+    const child = spawn2(this.command, {
+      cwd: this.cwd,
+      shell: true,
+      detached: process21.platform !== "win32",
+      env: { ...process21.env, ...this.env },
+      stdio: [stdin, "pipe", "pipe"],
+      windowsHide: true
+    });
+    this.child = child;
+    this.setupHandlers(child);
+  }
+  onExit(listener) {
+    this.exitListeners.push(listener);
+  }
+  async stop() {
+    if (this.stopPromise) {
+      return this.stopPromise;
+    }
+    this.stopPromise = this.stopChild();
+    return this.stopPromise;
+  }
+  async stopChild() {
+    const child = this.child;
+    if (!child || child.exitCode !== null) {
+      return;
+    }
+    this.stopping = true;
+    const exited = new Promise((resolve) => child.once("exit", () => resolve()));
+    if (process21.platform === "win32" && child.pid) {
+      const taskkill = spawn2("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      await new Promise((resolve) => {
+        taskkill.once("exit", () => resolve());
+        taskkill.once("error", () => resolve());
+      });
+    } else if (child.pid) {
+      try {
+        process21.kill(-child.pid, "SIGTERM");
+      } catch {
+        child.kill();
+      }
+    }
+    await exited;
+  }
+  setupHandlers(child) {
+    child.stdout?.on("data", (data) => this.emitLines(data, "log"));
+    child.stderr?.on("data", (data) => this.emitLines(data, "error"));
+    child.on("error", (error) => {
+      this.logger.error("Frontend dev server failed to start:", error);
+      this.notifyExit(null);
+    });
+    child.on("exit", (code) => {
+      if (this.stopping) {
+        return;
+      }
+      this.logger.error(`Frontend dev server exited with code ${code}`);
+      this.notifyExit(code);
+    });
+  }
+  notifyExit(code) {
+    for (const listener of this.exitListeners) {
+      listener(code);
+    }
+  }
+  emitLines(data, type) {
+    const lines = data.toString().trimEnd().split(`
+`);
+    for (const line of lines) {
+      if (type === "error") {
+        this.logger.error(line);
+      } else {
+        this.logger.log(line);
+      }
+    }
+  }
+}
+
+// src/cli/dev/serve-command-runner.ts
+function createServeCommandRunner({
+  serveCommand,
+  projectRoot,
+  appId,
+  appBaseUrl
+}) {
+  return new ServeRunner({
+    command: serveCommand,
+    cwd: projectRoot,
+    env: {
+      VITE_BASE44_APP_ID: appId,
+      ...appBaseUrl ? { VITE_BASE44_APP_BASE_URL: appBaseUrl } : {}
+    },
+    logger: createDevLogger("frontend", theme.colors.base44Orange)
+  });
+}
+
+// src/cli/dev/stop-runner-on-signals.ts
+import process22 from "node:process";
+function stopRunnerOnProcessSignals(runner) {
+  const stop = () => void runner.stop();
+  process22.on("SIGINT", stop);
+  process22.on("SIGTERM", stop);
+}
+
+// src/cli/commands/site/dev.ts
+var DEFAULT_SERVE_COMMAND = "npm run dev";
+async function siteDevAction(ctx) {
+  const { app } = ctx;
+  if (!app?.projectRoot) {
+    throw new ConfigInvalidError("base44 site dev requires a linked local project. Run it from a project with base44/.app.jsonc.");
+  }
+  const { project } = await readProjectConfig(app.projectRoot);
+  const site = project.site;
+  if (!site) {
+    throw new InvalidInputError(`This project has no 'site' block in base44/config.jsonc, so there is no frontend to serve. Add one naming its serveCommand; site dev falls back to "npm run dev".`);
+  }
+  const command = site.serveCommand ?? DEFAULT_SERVE_COMMAND;
+  const runner = createServeCommandRunner({
+    serveCommand: command,
+    projectRoot: project.root,
+    appId: app.id
+  });
+  stopRunnerOnProcessSignals(runner);
+  runner.onExit((code) => process.exit(code ?? 1));
+  runner.start();
+  return { outroMessage: `Frontend dev server running '${command}'` };
+}
+function getSiteDevCommand() {
+  return new Base44Command("dev", { requireAuth: false }).description("Run the site's dev server, with no local backend").action(siteDevAction);
+}
+
+// src/cli/commands/site/install.ts
+async function installAction({
+  runTask
+}) {
+  const { project } = await readProjectConfig();
+  const installCommand = project.site?.installCommand;
+  if (!installCommand) {
+    throw new ConfigNotFoundError("No site install command found.", {
+      hints: [
+        {
+          message: `Add a 'site' block to your config.jsonc (e.g., "site": { "installCommand": "npm ci" }). Inside one, installCommand defaults to "npm install".`
+        }
+      ]
+    });
+  }
+  await runTask("Installing site dependencies...", () => execa({ cwd: project.root, shell: true })`${installCommand}`, {
+    successMessage: "Dependencies installed",
+    errorMessage: "Install failed"
+  });
+  return {
+    outroMessage: `Installed with ${theme.styles.bold(installCommand)}`
+  };
+}
+function getSiteInstallCommand() {
+  return new Base44Command("install", {
+    requireAuth: false,
+    requireAppContext: false
+  }).description("Install the site's dependencies with its configured command").action(installAction);
+}
+
 // src/cli/commands/site/open.ts
 async function openAction({
   isNonInteractive
@@ -251123,7 +251734,7 @@ function getSiteOpenCommand() {
 
 // src/cli/commands/site/index.ts
 function getSiteCommand() {
-  return new Command2("site").description("Manage app site (frontend app)").addCommand(getSiteDeployCommand()).addCommand(getSiteOpenCommand());
+  return new Command2("site").description("Manage app site (frontend app)").addCommand(getSiteDeployCommand()).addCommand(getSiteDevCommand()).addCommand(getSiteInstallCommand()).addCommand(getSiteOpenCommand());
 }
 
 // src/core/types/generator.ts
@@ -251215,10 +251826,10 @@ function toPascalCase(name) {
   return name.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
 }
 // src/core/types/update-project.ts
-import { join as join30 } from "node:path";
+import { join as join33 } from "node:path";
 var TYPES_INCLUDE_PATH = `${PROJECT_SUBDIR}/${TYPES_OUTPUT_SUBDIR}/*.d.ts`;
 async function updateProjectConfig(projectRoot) {
-  const tsconfigPath = join30(projectRoot, "tsconfig.json");
+  const tsconfigPath = join33(projectRoot, "tsconfig.json");
   if (!await pathExists(tsconfigPath)) {
     return false;
   }
@@ -251267,6 +251878,59 @@ function getTypesCommand() {
   return new Command2("types").description("Manage TypeScript type generation").addCommand(getTypesGenerateCommand());
 }
 
+// src/cli/commands/versions/create.ts
+async function createAction2(ctx, options) {
+  const { runTask, jsonMode } = ctx;
+  const target = await resolveBuildTarget(requireApp(ctx).projectRoot, {
+    outputDir: options.outputDir
+  });
+  const gitHash = await resolveProvenanceCommit(target.root, options.gitHash);
+  const version = await runTask("Creating version...", async (updateMessage) => await createVersion(await collectArtifacts(target), {
+    sourceCommit: gitHash,
+    concurrency: options.concurrency,
+    progress: {
+      onDeclared: ({ fileCount }) => updateMessage(`Uploading ${fileCount} files`),
+      onUpload: ({ uploadedFiles, totalFiles }) => updateMessage(`Uploaded ${uploadedFiles} of ${totalFiles} files`)
+    }
+  }), {
+    successMessage: "Version created",
+    errorMessage: "Create version failed"
+  });
+  return {
+    outroMessage: `Version ${version.versionId} (${version.manifestHash})`,
+    stdout: jsonMode ? `${JSON.stringify(version, null, 2)}
+` : undefined
+  };
+}
+function getVersionCreateCommand() {
+  return new Base44Command("create").description("Record the built output as a version, without deploying it").addOption(outputDirOption()).addOption(gitHashOption()).addOption(concurrencyOption()).action(createAction2);
+}
+
+// src/cli/commands/versions/deploy.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+async function deployAction3({ runTask, jsonMode }, versionId, options) {
+  const environment = options.target ?? DEFAULT_ENVIRONMENT;
+  const result = await runTask(`Pointing ${environment} at ${versionId}...`, async () => await setEnvironmentVersion(environment, versionId, {
+    idempotencyKey: randomUUID5()
+  }), {
+    successMessage: "Environment updated",
+    errorMessage: "Could not update the environment"
+  });
+  return {
+    outroMessage: `${result.name} now serves ${result.versionId}`,
+    stdout: jsonMode ? `${JSON.stringify(result, null, 2)}
+` : undefined
+  };
+}
+function getVersionDeployCommand() {
+  return new Base44Command("deploy").description("Point an environment at an already-recorded version (also the rollback)").argument("<version-id>", "The version to serve").addOption(targetOption()).action(deployAction3);
+}
+
+// src/cli/commands/versions/index.ts
+function getVersionsCommand() {
+  return new Command2("versions").description("Record app versions and serve them").addCommand(getVersionCreateCommand()).addCommand(getVersionDeployCommand());
+}
+
 // src/core/resources/workflow/schema.ts
 var WorkflowRunStatusSchema = _enum([
   "running",
@@ -251643,47 +252307,10 @@ function getWorkspaceCommand() {
   return new Command2("workspace").description("List workspaces, inspect one, and move apps between them").addCommand(getWorkspaceListCommand()).addCommand(getWorkspaceGetCommand()).addCommand(getWorkspaceMoveCommand());
 }
 
-// src/cli/dev/createDevLogger.ts
-var colorByType = {
-  error: theme.styles.error,
-  warn: theme.styles.warn,
-  log: (input) => input
-};
-var stringify = (item) => {
-  if (typeof item === "string") {
-    return item;
-  }
-  if (item instanceof Error) {
-    return item.toString();
-  }
-  try {
-    return JSON.stringify(item, null, 2) ?? String(item);
-  } catch {
-    return String(item);
-  }
-};
-function createDevLogger(label, labelColor = theme.styles.dim) {
-  const prefix = label ? `${labelColor(`[${label}]`)} ` : "";
-  const print = (type, ...args) => {
-    const colorize = colorByType[type];
-    console[type](prefix + args.map((item) => colorize(stringify(item))).join(" "));
-  };
-  return {
-    log: (...args) => print("log", ...args),
-    error: (msg, err) => {
-      print("error", msg);
-      if (err) {
-        print("error", err);
-      }
-    },
-    warn: (...args) => print("warn", ...args)
-  };
-}
-
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
 var import_express6 = __toESM(require_express(), 1);
-import { dirname as dirname26, join as join36 } from "node:path";
+import { dirname as dirname27, join as join38 } from "node:path";
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -251812,8 +252439,8 @@ var $dir = async (options) => dirWithOptions(options);
 var $tmpName = promisify11(tmp.tmpName);
 
 // src/cli/dev/dev-server/function-manager.ts
-import { spawn as spawn2 } from "node:child_process";
-import { dirname as dirname23, join as join31 } from "node:path";
+import { spawn as spawn3 } from "node:child_process";
+import { dirname as dirname24, join as join34 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/cli/dev/dev-server/base-function-manager.ts
@@ -251910,7 +252537,7 @@ class FunctionManager extends BaseFunctionManager {
   async stopFunction(_name, { process: proc }) {
     const exited = new Promise((r) => proc.once("exit", () => r()));
     if (process.platform === "win32" && proc.pid) {
-      spawn2("taskkill", ["/pid", String(proc.pid), "/T", "/F"]);
+      spawn3("taskkill", ["/pid", String(proc.pid), "/T", "/F"]);
     } else {
       proc.kill();
     }
@@ -251918,8 +252545,8 @@ class FunctionManager extends BaseFunctionManager {
   }
   spawnFunction(func, port) {
     this.logger.log(`Spawning function "${func.name}" on port ${port}`);
-    const importMapPath = join31(dirname23(this.wrapperPath), "import-map.json");
-    const process2 = spawn2("deno", ["run", "--allow-all", "--import-map", importMapPath, this.wrapperPath], {
+    const importMapPath = join34(dirname24(this.wrapperPath), "import-map.json");
+    const process2 = spawn3("deno", ["run", "--allow-all", "--import-map", importMapPath, this.wrapperPath], {
       env: {
         ...globalThis.process.env,
         FUNCTION_PATH: pathToFileURL(func.entryPath).href,
@@ -251992,7 +252619,7 @@ class FunctionManager extends BaseFunctionManager {
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { isBuiltin } from "node:module";
 import { homedir as homedir3 } from "node:os";
-import { join as join33 } from "node:path";
+import { join as join35 } from "node:path";
 import { pathToFileURL as pathToFileURL6 } from "node:url";
 var depsPromise;
 function loadDeps() {
@@ -252113,9 +252740,9 @@ export default {
 };
 `;
 function ensureBundlerConfig() {
-  const dir = join33(homedir3(), ".base44", "function-bundler");
+  const dir = join35(homedir3(), ".base44", "function-bundler");
   mkdirSync2(dir, { recursive: true });
-  const configPath = join33(dir, "deno.json");
+  const configPath = join35(dir, "deno.json");
   writeFileSync2(configPath, `${JSON.stringify({ nodeModulesDir: "auto" }, null, 2)}
 `);
   return configPath;
@@ -253496,11 +254123,11 @@ async function createEntityRoutes(db, logger, broadcast) {
 // src/cli/dev/dev-server/routes/integrations.ts
 var import_express5 = __toESM(require_express(), 1);
 var import_multer = __toESM(require_multer(), 1);
-import { createHash as createHash2, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID6 } from "node:crypto";
 import fs28 from "node:fs";
 import path18 from "node:path";
 function createFileToken(fileUri) {
-  return createHash2("sha256").update(fileUri).digest("hex");
+  return createHash3("sha256").update(fileUri).digest("hex");
 }
 function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
   const router = import_express5.Router({ mergeParams: true });
@@ -253513,14 +254140,14 @@ function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
     destination: mediaFilesDir,
     filename: (_req, file, cb) => {
       const ext = path18.extname(file.originalname);
-      cb(null, `${randomUUID4()}${ext}`);
+      cb(null, `${randomUUID6()}${ext}`);
     }
   });
   const privateStorage = import_multer.default.diskStorage({
     destination: privateFilesDir,
     filename: (_req, file, cb) => {
       const ext = path18.extname(file.originalname);
-      cb(null, `${randomUUID4()}${ext}`);
+      cb(null, `${randomUUID6()}${ext}`);
     }
   });
   const upload = import_multer.default({ storage, limits: { fileSize: MAX_FILE_SIZE } });
@@ -255382,8 +256009,8 @@ async function createDevServer(options) {
     broadcastEntityEvent(io, appId, entityName, event);
   };
   const base44ConfigWatcher = new WatchBase44({
-    functions: join36(dirname26(project.configPath), project.functionsDir),
-    entities: join36(dirname26(project.configPath), project.entitiesDir)
+    functions: join38(dirname27(project.configPath), project.functionsDir),
+    entities: join38(dirname27(project.configPath), project.entitiesDir)
   }, devLogger);
   base44ConfigWatcher.on("change", async (name) => {
     try {
@@ -255449,127 +256076,6 @@ async function createDevServer(options) {
   return { port, server, shutdown };
 }
 
-// src/cli/dev/dev-server/serve-runner.ts
-import { spawn as spawn3 } from "node:child_process";
-import process23 from "node:process";
-
-class ServeRunner {
-  command;
-  cwd;
-  env;
-  logger;
-  child;
-  stopping = false;
-  stopPromise;
-  exitListeners = [];
-  constructor(options) {
-    this.command = options.command;
-    this.cwd = options.cwd;
-    this.env = options.env;
-    this.logger = options.logger;
-  }
-  start() {
-    if (this.child) {
-      return;
-    }
-    const stdin = process23.platform === "win32" ? "ignore" : "inherit";
-    const child = spawn3(this.command, {
-      cwd: this.cwd,
-      shell: true,
-      detached: process23.platform !== "win32",
-      env: { ...process23.env, ...this.env },
-      stdio: [stdin, "pipe", "pipe"],
-      windowsHide: true
-    });
-    this.child = child;
-    this.setupHandlers(child);
-  }
-  onExit(listener) {
-    this.exitListeners.push(listener);
-  }
-  async stop() {
-    if (this.stopPromise) {
-      return this.stopPromise;
-    }
-    this.stopPromise = this.stopChild();
-    return this.stopPromise;
-  }
-  async stopChild() {
-    const child = this.child;
-    if (!child || child.exitCode !== null) {
-      return;
-    }
-    this.stopping = true;
-    const exited = new Promise((resolve) => child.once("exit", () => resolve()));
-    if (process23.platform === "win32" && child.pid) {
-      const taskkill = spawn3("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
-        stdio: "ignore",
-        windowsHide: true
-      });
-      await new Promise((resolve) => {
-        taskkill.once("exit", () => resolve());
-        taskkill.once("error", () => resolve());
-      });
-    } else if (child.pid) {
-      try {
-        process23.kill(-child.pid, "SIGTERM");
-      } catch {
-        child.kill();
-      }
-    }
-    await exited;
-  }
-  setupHandlers(child) {
-    child.stdout?.on("data", (data) => this.emitLines(data, "log"));
-    child.stderr?.on("data", (data) => this.emitLines(data, "error"));
-    child.on("error", (error) => {
-      this.logger.error("Frontend dev server failed to start:", error);
-      this.notifyExit(null);
-    });
-    child.on("exit", (code) => {
-      if (this.stopping) {
-        return;
-      }
-      this.logger.error(`Frontend dev server exited with code ${code}`);
-      this.notifyExit(code);
-    });
-  }
-  notifyExit(code) {
-    for (const listener of this.exitListeners) {
-      listener(code);
-    }
-  }
-  emitLines(data, type) {
-    const lines = data.toString().trimEnd().split(`
-`);
-    for (const line of lines) {
-      if (type === "error") {
-        this.logger.error(line);
-      } else {
-        this.logger.log(line);
-      }
-    }
-  }
-}
-
-// src/cli/dev/serve-command-runner.ts
-function createServeCommandRunner({
-  serveCommand,
-  projectRoot,
-  appId,
-  appBaseUrl
-}) {
-  return new ServeRunner({
-    command: serveCommand,
-    cwd: projectRoot,
-    env: {
-      VITE_BASE44_APP_ID: appId,
-      VITE_BASE44_APP_BASE_URL: appBaseUrl
-    },
-    logger: createDevLogger("frontend", theme.colors.base44Orange)
-  });
-}
-
 // src/cli/commands/dev.ts
 function localServerUrl(port) {
   return `http://localhost:${port}`;
@@ -255595,11 +256101,6 @@ async function resolveConfiguredSite(app) {
   const serveCommand = project.site?.serveCommand;
   return serveCommand ? { serveCommand, projectRoot: project.root } : undefined;
 }
-function stopRunnerOnProcessSignals(runner) {
-  const stop = () => void runner.stop();
-  process.on("SIGINT", stop);
-  process.on("SIGTERM", stop);
-}
 function startServeCommand(runner, backend) {
   stopRunnerOnProcessSignals(runner);
   runner.onExit(() => {
@@ -255780,7 +256281,7 @@ Examples:
 }
 
 // src/cli/commands/project/eject.ts
-import { resolve as resolve17 } from "node:path";
+import { resolve as resolve19 } from "node:path";
 var import_kebabCase2 = __toESM(require_kebabCase(), 1);
 async function eject(ctx, options, command) {
   const { log, runTask, isNonInteractive } = ctx;
@@ -255844,7 +256345,7 @@ async function eject(ctx, options, command) {
     Ne("Operation cancelled.");
     throw new CLIExitError(0);
   }
-  const resolvedPath = resolve17(selectedPath);
+  const resolvedPath = resolve19(selectedPath);
   await runTask("Downloading your project's code...", async (updateMessage) => {
     await createProjectFilesForExistingProject({
       projectId,
@@ -255933,6 +256434,10 @@ function createProgram(context) {
   program.addCommand(getBranchesCommand());
   program.addCommand(getAuthCommand());
   program.addCommand(getSiteCommand());
+  if (versionsApiEnabled()) {
+    program.addCommand(getPublishCommand());
+    program.addCommand(getVersionsCommand());
+  }
   program.addCommand(getTypesCommand());
   program.addCommand(getExecCommand());
   program.addCommand(getDevCommand());
@@ -255945,7 +256450,7 @@ var import_detect_agent = __toESM(require_dist5(), 1);
 import { release, type } from "node:os";
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname27, posix, sep as sep2 } from "path";
+import { dirname as dirname28, posix, sep as sep2 } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -255954,7 +256459,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname27(process.argv[1]) : process.cwd(), isWindows = sep2 === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname28(process.argv[1]) : process.cwd(), isWindows = sep2 === "\\") {
   const normalizedBase = isWindows ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -259943,9 +260448,9 @@ function addCommandInfoToErrorReporter(program, errorReporter) {
   });
 }
 // src/cli/index.ts
-var __dirname4 = dirname28(fileURLToPath6(import.meta.url));
+var __dirname4 = dirname29(fileURLToPath6(import.meta.url));
 async function runCLI(options) {
-  ensureNpmAssets(join37(__dirname4, "../assets"));
+  ensureNpmAssets(join39(__dirname4, "../assets"));
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
   const jsonMode = process.argv.includes("--json");
@@ -259984,4 +260489,4 @@ export {
   runCLI
 };
 
-//# debugId=752874D903B2231464756E2164756E21
+//# debugId=8A4CA9C1B29637E164756E2164756E21