@base44-preview/cli 0.1.14-pr.626.999301d → 0.1.15-pr.623.32ad346

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" ? join29(replacement, currentDoc.split(`
+  return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join28(replacement, currentDoc.split(`
 `)) : currentDoc);
 }
 function canBreakFn(doc) {
@@ -31257,7 +31257,7 @@ function indentIfBreak(contents, options) {
     negate: options.negate
   };
 }
-function join29(separator, docs) {
+function join28(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: join29,
+    join: join28,
     line,
     softline,
     hardline,
@@ -228634,6 +228634,10 @@ class InternalError extends SystemError {
   }
 }
 
+class ResourceDeploymentError extends SystemError {
+  code = "RESOURCE_DEPLOYMENT_FAILED";
+}
+
 class TypeGenerationError extends SystemError {
   code = "TYPE_GENERATION_ERROR";
   constructor(message, entityName, cause) {
@@ -228779,7 +228783,7 @@ function normalizeBase44Env() {
 loadProjectEnvFiles();
 
 // src/cli/index.ts
-import { dirname as dirname27, join as join38 } from "node:path";
+import { dirname as dirname28, join as join37 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -229905,8 +229909,10 @@ var {
   Help: Help2
 } = exports_commander;
 
-// src/cli/commands/agent-skills/pull.ts
-import { dirname as dirname11, join as join18 } from "node:path";
+// src/cli/commands/functions/parseNames.ts
+function parseNames(args) {
+  return args.flatMap((arg) => arg.split(",")).map((n) => n.trim()).filter(Boolean);
+}
 // ../../node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
@@ -230720,6 +230726,7 @@ var ProjectConfigSchema = object({
   site: SiteConfigSchema.optional(),
   entitiesDir: string2().optional().default("entities"),
   functionsDir: string2().optional().default("functions"),
+  actorsDir: string2().optional().default("actors"),
   agentsDir: string2().optional().default("agents"),
   agentSkillsDir: string2().optional().default("agent-skills"),
   connectorsDir: string2().optional().default("connectors"),
@@ -236672,7 +236679,7 @@ async function getSiteUrl() {
   return result.data.url;
 }
 // src/core/project/config.ts
-import { dirname as dirname8, join as join11 } from "node:path";
+import { dirname as dirname10, join as join12 } from "node:path";
 
 // src/core/project/plugins.ts
 import { createRequire as createRequire2 } from "node:module";
@@ -236710,6 +236717,159 @@ function markPluginEntities(entities, pluginNamespace) {
   }));
 }
 
+// src/core/resources/actor/schema.ts
+var RESERVED_NAMES = new Set(("await break case catch class const continue debugger default delete do else " + "enum export extends false finally for function if import in instanceof let " + "new null return static super switch this throw true try typeof var void " + "while with yield implements interface package private protected public " + "eval arguments").split(" "));
+var ActorNameSchema = string2().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$(?![\s\S])/, "Actor names must be JavaScript identifiers of at most 128 characters (letters, digits, and underscores)").refine((name) => !RESERVED_NAMES.has(name), {
+  message: "Actor names cannot be JavaScript reserved words"
+});
+function validateActorName(name) {
+  const result = ActorNameSchema.safeParse(name);
+  if (!result.success) {
+    throw new SchemaValidationError(`Invalid actor name '${name}'`, result.error);
+  }
+}
+var ActorDefinitionSchema = object({
+  name: ActorNameSchema,
+  entry: _enum(["entry.ts", "entry.js"]),
+  entryPath: string2().min(1),
+  filePaths: array(string2()).min(1),
+  source: object({ type: literal("project") })
+});
+var ActorDeployPayloadSchema = object({
+  entry: _enum(["entry.ts", "entry.js"]),
+  files: array(object({ path: string2().min(1), content: string2() })).min(1)
+});
+var DeployActorResponseSchema = object({
+  status: _enum(["deployed", "unchanged"]),
+  warnings: array(string2()).optional().default([])
+});
+var DeleteActorResponseSchema = object({ status: literal("deleted"), handler_name: ActorNameSchema }).transform((data) => ({
+  status: data.status,
+  handlerName: data.handler_name
+}));
+
+// src/core/resources/actor/api.ts
+async function deploySingleActor(name, payload) {
+  validateActorName(name);
+  const input = ActorDeployPayloadSchema.safeParse(payload);
+  if (!input.success)
+    throw new SchemaValidationError("Invalid actor deployment", input.error);
+  let response;
+  try {
+    response = await getAppClient().put(`actors/${encodeURIComponent(name)}`, {
+      json: input.data,
+      timeout: false
+    });
+  } catch (error) {
+    throw await ApiError.fromHttpError(error, `deploying actor "${name}"`);
+  }
+  const result = DeployActorResponseSchema.safeParse(await response.json());
+  if (!result.success)
+    throw new SchemaValidationError("Invalid actor deployment response", result.error);
+  return result.data;
+}
+async function deleteSingleActor(name) {
+  validateActorName(name);
+  let response;
+  try {
+    response = await getAppClient().delete(`actors/${encodeURIComponent(name)}`, { timeout: 60000 });
+  } catch (error) {
+    throw await ApiError.fromHttpError(error, `deleting actor "${name}"`);
+  }
+  const result = DeleteActorResponseSchema.safeParse(await response.json());
+  if (!result.success)
+    throw new SchemaValidationError("Invalid actor deletion response", result.error);
+  return result.data;
+}
+// src/core/resources/actor/config.ts
+import { basename as basename3, dirname as dirname6, join as join5, relative } from "node:path";
+async function readAllActors(actorsDir) {
+  if (!await pathExists(actorsDir))
+    return [];
+  const entries = await globby(ENTRY_FILE_GLOB, {
+    cwd: actorsDir,
+    absolute: true,
+    ignore: ENTRY_IGNORE_DOT_PATHS
+  });
+  const actors = [];
+  const names = new Set;
+  for (const entryPath of entries.sort()) {
+    const actorDir = dirname6(entryPath);
+    const name = relative(actorsDir, actorDir).split(/[/\\]/).join("/");
+    if (!name) {
+      throw new InvalidInputError("entry.ts or entry.js found directly in the actors directory — it must be inside a named subfolder");
+    }
+    if (name.includes("/")) {
+      throw new InvalidInputError(`Invalid actor name '${name}' — actors cannot be nested`);
+    }
+    validateActorName(name);
+    if (names.has(name)) {
+      throw new ConfigInvalidError(`Duplicate actor name "${name}" in ${actorsDir}`, actorsDir);
+    }
+    names.add(name);
+    const filePaths = (await globby(BACKEND_FILE_GLOB, { cwd: actorDir, absolute: true })).sort();
+    const entry = basename3(entryPath) === "entry.js" ? "entry.js" : "entry.ts";
+    actors.push({
+      name,
+      entry,
+      entryPath: join5(actorDir, entry),
+      filePaths,
+      source: { type: "project" }
+    });
+  }
+  return actors;
+}
+// src/core/resources/actor/deploy.ts
+import { dirname as dirname7, relative as relative2 } from "node:path";
+function actorOperationError(name, error) {
+  return {
+    name,
+    status: "error",
+    error: error instanceof Error ? error.message : String(error),
+    ...error instanceof ApiError ? { statusCode: error.statusCode, requestId: error.requestId } : {}
+  };
+}
+function describeActorResult(result) {
+  if (result.status !== "error")
+    return `${result.name}: ${result.status}`;
+  const context = [
+    result.statusCode === undefined ? undefined : `HTTP ${result.statusCode}`,
+    result.requestId ? `request ${result.requestId}` : undefined
+  ].filter(Boolean).join(", ");
+  return `${result.name}: error — ${result.error}${context ? ` (${context})` : ""}`;
+}
+async function deployOne(actor) {
+  const start = Date.now();
+  try {
+    const actorDir = dirname7(actor.entryPath);
+    const files = await Promise.all(actor.filePaths.map(async (filePath) => ({
+      path: relative2(actorDir, filePath).split(/[/\\]/).join("/"),
+      content: await readTextFile(filePath)
+    })));
+    const response = await deploySingleActor(actor.name, {
+      entry: actor.entry,
+      files
+    });
+    return { name: actor.name, ...response, durationMs: Date.now() - start };
+  } catch (error) {
+    return actorOperationError(actor.name, error);
+  }
+}
+async function deployActorsSequentially(actors, options) {
+  const results = [];
+  for (const actor of actors) {
+    options?.onStart?.(actor.name);
+    const result = await deployOne(actor);
+    results.push(result);
+    options?.onResult?.(result);
+  }
+  return results;
+}
+// src/core/resources/actor/resource.ts
+var actorResource = {
+  readAll: readAllActors,
+  push: deployActorsSequentially
+};
 // src/core/resources/agent/schema.ts
 var EntityOperationSchema = _enum(["create", "update", "delete", "read"]);
 var EntityToolConfigSchema = object({
@@ -236788,7 +236948,7 @@ async function fetchAgents() {
   return result.data;
 }
 // src/core/resources/agent/config.ts
-import { join as join5, normalize } from "node:path";
+import { join as join6, normalize } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 async function readAgentFile(agentPath) {
   const raw = await readJsonFile(agentPath);
@@ -236833,12 +236993,12 @@ async function readAllAgents(agentsDir) {
   return [...nameToEntry.values()].map((e) => e.data);
 }
 function findAvailablePath(agentsDir, name, claimedPaths) {
-  const base = join5(agentsDir, `${name}.${CONFIG_FILE_EXTENSION}`);
+  const base = join6(agentsDir, `${name}.${CONFIG_FILE_EXTENSION}`);
   if (!claimedPaths.has(base)) {
     return base;
   }
   for (let i = 1;; i++) {
-    const candidate = join5(agentsDir, `${name}_${i}.${CONFIG_FILE_EXTENSION}`);
+    const candidate = join6(agentsDir, `${name}_${i}.${CONFIG_FILE_EXTENSION}`);
     if (!claimedPaths.has(candidate)) {
       return candidate;
     }
@@ -236953,7 +237113,7 @@ async function pushAgentSkills(skills) {
 }
 // src/core/resources/agent-skill/config.ts
 var import_front_matter = __toESM(require_front_matter(), 1);
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // ../../node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -237039,7 +237199,7 @@ async function writeAgentSkills(dir, remote) {
   const deleted = [];
   for (const skill of existing) {
     if (!remoteNames.has(skill.name)) {
-      await deleteFile(join6(dir, `${skill.name}.md`));
+      await deleteFile(join7(dir, `${skill.name}.md`));
       deleted.push(skill.name);
     }
   }
@@ -237050,7 +237210,7 @@ async function writeAgentSkills(dir, remote) {
     if (prev && prev.description === skill.description && prev.body === skill.body) {
       continue;
     }
-    await writeFile(join6(dir, `${skill.name}.md`), serializeSkillFile(skill));
+    await writeFile(join7(dir, `${skill.name}.md`), serializeSkillFile(skill));
     written.push(skill.name);
   }
   return { written, deleted };
@@ -237176,7 +237336,7 @@ async function pushAuthConfigToApi(config) {
   return result.data.authConfig;
 }
 // src/core/resources/auth-config/config.ts
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 var AUTH_CONFIG_FILENAME = `config.${CONFIG_FILE_EXTENSION}`;
 var DEFAULT_AUTH_CONFIG = {
@@ -237192,7 +237352,7 @@ var DEFAULT_AUTH_CONFIG = {
   useWorkspaceSSO: false
 };
 function getAuthConfigPath(authDir) {
-  return join7(authDir, AUTH_CONFIG_FILENAME);
+  return join8(authDir, AUTH_CONFIG_FILENAME);
 }
 async function readAuthConfig(authDir) {
   const filePath = getAuthConfigPath(authDir);
@@ -237844,7 +238004,7 @@ async function removeStripe() {
   return result.data;
 }
 // src/core/resources/connector/config.ts
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
 async function readConnectorFile(connectorPath) {
   const parsed = await readJsonFile(connectorPath);
@@ -237905,7 +238065,7 @@ async function writeConnectors(connectorsDir, remoteConnectors) {
     if (existing && isDeepStrictEqual3(existing.data, connector)) {
       continue;
     }
-    const filePath = existing?.filePath ?? join8(connectorsDir, `${connector.type}.${CONFIG_FILE_EXTENSION}`);
+    const filePath = existing?.filePath ?? join9(connectorsDir, `${connector.type}.${CONFIG_FILE_EXTENSION}`);
     await writeJsonFile(filePath, connector);
     written.push(connector.type);
   }
@@ -238511,7 +238671,7 @@ async function fetchFunctionLogs(functionName, filters = {}) {
   return result.data;
 }
 // src/core/resources/function/config.ts
-import { basename as basename3, dirname as dirname6, join as join9, relative, resolve as resolve2 } from "node:path";
+import { basename as basename4, dirname as dirname8, join as join10, relative as relative3, resolve as resolve2 } from "node:path";
 async function readSharedFiles(functionsDir) {
   const sharedDir = resolve2(functionsDir, "..", "shared");
   if (!await pathExists(sharedDir)) {
@@ -238529,8 +238689,8 @@ async function readFunctionConfig(configPath) {
 }
 async function readFunction(configPath, sharedFiles) {
   const config = await readFunctionConfig(configPath);
-  const functionDir = dirname6(configPath);
-  const entryPath = join9(functionDir, config.entry);
+  const functionDir = dirname8(configPath);
+  const entryPath = join10(functionDir, config.entry);
   if (!await pathExists(entryPath)) {
     throw new InvalidInputError(`Function entry file not found: ${entryPath} (referenced in ${configPath})`, {
       hints: [{ message: "Check the 'entry' field in your function config" }]
@@ -238562,18 +238722,18 @@ async function readAllFunctions(functionsDir) {
     absolute: true,
     ignore: ENTRY_IGNORE_DOT_PATHS
   });
-  const configFilesDirs = new Set(configFiles.map((f) => dirname6(f)));
-  const entryFilesWithoutConfig = entryFiles.filter((entryFile) => !configFilesDirs.has(dirname6(entryFile)));
+  const configFilesDirs = new Set(configFiles.map((f) => dirname8(f)));
+  const entryFilesWithoutConfig = entryFiles.filter((entryFile) => !configFilesDirs.has(dirname8(entryFile)));
   const sharedFiles = await readSharedFiles(functionsDir);
   const functionsFromConfig = await Promise.all(configFiles.map((configPath) => readFunction(configPath, sharedFiles)));
   const functionsWithoutConfig = await Promise.all(entryFilesWithoutConfig.map(async (entryFile) => {
-    const functionDir = dirname6(entryFile);
+    const functionDir = dirname8(entryFile);
     const filePaths = await globby(BACKEND_FILE_GLOB, {
       cwd: functionDir,
       absolute: true
     });
     const allFilePaths = [...new Set([...filePaths, ...sharedFiles])];
-    const name = relative(functionsDir, functionDir).split(/[/\\]/).join("/");
+    const name = relative3(functionsDir, functionDir).split(/[/\\]/).join("/");
     if (!name) {
       throw new InvalidInputError("entry.ts found directly in the functions directory — it must be inside a named subfolder", {
         hints: [
@@ -238583,7 +238743,7 @@ async function readAllFunctions(functionsDir) {
         ]
       });
     }
-    const entry = basename3(entryFile);
+    const entry = basename4(entryFile);
     const functionData = {
       name,
       entry,
@@ -238610,17 +238770,17 @@ async function readAllFunctions(functionsDir) {
   return functions;
 }
 // src/core/resources/function/deploy.ts
-import { dirname as dirname7, relative as relative2 } from "node:path";
+import { dirname as dirname9, relative as relative4 } from "node:path";
 async function loadFunctionCode(fn) {
-  const functionDir = dirname7(fn.entryPath);
+  const functionDir = dirname9(fn.entryPath);
   const resolvedFiles = await Promise.all(fn.filePaths.map(async (filePath) => {
     const content = await readTextFile(filePath);
-    const path = relative2(functionDir, filePath).split(/[/\\]/).join("/");
+    const path = relative4(functionDir, filePath).split(/[/\\]/).join("/");
     return { path, content };
   }));
   return { ...fn, files: resolvedFiles };
 }
-async function deployOne(fn) {
+async function deployOne2(fn) {
   const start = Date.now();
   try {
     const functionWithCode = await loadFunctionCode(fn);
@@ -238648,7 +238808,7 @@ async function deployFunctionsSequentially(functions, options) {
   const results = [];
   for (const fn of functions) {
     options?.onStart?.([fn.name]);
-    const result = await deployOne(fn);
+    const result = await deployOne2(fn);
     results.push(result);
     options?.onResult?.(result);
   }
@@ -238679,14 +238839,14 @@ async function pruneRemovedFunctions(localFunctionNames, options) {
   return results;
 }
 // src/core/resources/function/pull.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "node:util";
 async function writeFunctions(functionsDir, functions) {
   const written = [];
   const skipped = [];
   for (const fn of functions) {
-    const functionDir = join10(functionsDir, fn.name);
-    const configPath = join10(functionDir, "function.jsonc");
+    const functionDir = join11(functionsDir, fn.name);
+    const configPath = join11(functionDir, "function.jsonc");
     if (await isFunctionUnchanged(functionDir, fn)) {
       skipped.push(fn.name);
       continue;
@@ -238700,7 +238860,7 @@ async function writeFunctions(functionsDir, functions) {
     }
     await writeJsonFile(configPath, config);
     for (const file of fn.files) {
-      await writeFile(join10(functionDir, file.path), file.content);
+      await writeFile(join11(functionDir, file.path), file.content);
     }
     written.push(fn.name);
   }
@@ -238710,7 +238870,7 @@ async function isFunctionUnchanged(functionDir, fn) {
   if (!await pathExists(functionDir)) {
     return false;
   }
-  const configPath = join10(functionDir, "function.jsonc");
+  const configPath = join11(functionDir, "function.jsonc");
   try {
     const localConfig = await readJsonFile(configPath);
     if (localConfig.entry !== fn.entry) {
@@ -238723,7 +238883,7 @@ async function isFunctionUnchanged(functionDir, fn) {
     return false;
   }
   for (const file of fn.files) {
-    const filePath = join10(functionDir, file.path);
+    const filePath = join11(functionDir, file.path);
     if (!await pathExists(filePath)) {
       return false;
     }
@@ -238895,10 +239055,17 @@ class ProjectConfigReader {
       ...pluginResources.functions
     ];
     this.validateFunctionNames(functions, configPath);
+    const functionNames = new Set(functions.map((fn) => fn.name));
+    for (const actor of localResources.actors) {
+      if (functionNames.has(actor.name)) {
+        throw new ConfigInvalidError(`'${actor.name}' exists as both a backend function and an actor`, configPath);
+      }
+    }
     return {
       project,
       entities,
       functions,
+      actors: localResources.actors,
       agents: localResources.agents,
       agentSkills: localResources.agentSkills,
       connectors: localResources.connectors,
@@ -238926,17 +239093,34 @@ class ProjectConfigReader {
     }
     return result.data;
   }
-  async readProjectResources(configPath, project) {
-    const configDir = dirname8(configPath);
-    const [entities, functions, agents, agentSkills, connectors, authConfig] = await Promise.all([
-      entityResource.readAll(join11(configDir, project.entitiesDir)),
-      functionResource.readAll(join11(configDir, project.functionsDir)),
-      agentResource.readAll(join11(configDir, project.agentsDir)),
-      agentSkillResource.readAll(join11(configDir, project.agentSkillsDir)),
-      connectorResource.readAll(join11(configDir, project.connectorsDir)),
-      authConfigResource.readAll(join11(configDir, project.authDir))
+  async readProjectResources(configPath, project, includeActors = true) {
+    const configDir = dirname10(configPath);
+    const [
+      entities,
+      functions,
+      actors,
+      agents,
+      agentSkills,
+      connectors,
+      authConfig
+    ] = await Promise.all([
+      entityResource.readAll(join12(configDir, project.entitiesDir)),
+      functionResource.readAll(join12(configDir, project.functionsDir)),
+      includeActors ? actorResource.readAll(join12(configDir, project.actorsDir)) : Promise.resolve([]),
+      agentResource.readAll(join12(configDir, project.agentsDir)),
+      agentSkillResource.readAll(join12(configDir, project.agentSkillsDir)),
+      connectorResource.readAll(join12(configDir, project.connectorsDir)),
+      authConfigResource.readAll(join12(configDir, project.authDir))
     ]);
-    return { entities, functions, agents, agentSkills, connectors, authConfig };
+    return {
+      entities,
+      functions,
+      actors,
+      agents,
+      agentSkills,
+      connectors,
+      authConfig
+    };
   }
   assertPluginProjectDoesNotLoadPlugins(project, configPath) {
     if (project.plugin && project.plugins.length > 0) {
@@ -238957,7 +239141,7 @@ class ProjectConfigReader {
     this.pluginSourceByNamespace.set(namespace, source);
   }
   async readPluginConfig(plugin, hostConfigPath) {
-    const pluginRoot = resolvePluginRoot(plugin.source, dirname8(hostConfigPath));
+    const pluginRoot = resolvePluginRoot(plugin.source, dirname10(hostConfigPath));
     const { configPath } = await this.findConfigOrThrow(pluginRoot);
     const project = await this.readConfigFile(configPath);
     const namespace = requirePluginNamespace(project, plugin.source, configPath);
@@ -238965,10 +239149,11 @@ class ProjectConfigReader {
     return { configPath, namespace, project, source: plugin.source };
   }
   async readPluginResources(project, configPath, namespace) {
-    const resources = await this.readProjectResources(configPath, project);
+    const resources = await this.readProjectResources(configPath, project, false);
     return {
       entities: markPluginEntities(resources.entities, namespace),
       functions: namespacePluginFunctions(resources.functions, namespace),
+      actors: [],
       agents: [],
       agentSkills: [],
       connectors: [],
@@ -239007,6 +239192,7 @@ class ProjectConfigReader {
     return {
       entities,
       functions,
+      actors: [],
       agents: [],
       agentSkills: [],
       connectors: [],
@@ -239041,16 +239227,16 @@ async function readProjectSettings(projectRoot) {
 // src/core/project/template.ts
 var import_ejs = __toESM(require_ejs(), 1);
 var import_front_matter2 = __toESM(require_front_matter(), 1);
-import { dirname as dirname9, join as join13 } from "node:path";
+import { dirname as dirname11, join as join14 } from "node:path";
 
 // src/core/assets.ts
 import { cpSync, existsSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.1.14",
+  version: "0.1.15",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -239153,21 +239339,21 @@ var package_default = {
 };
 
 // src/core/assets.ts
-var ASSETS_DIR = join12(homedir2(), ".base44", "assets", package_default.version);
+var ASSETS_DIR = join13(homedir2(), ".base44", "assets", package_default.version);
 function getTemplatesDir() {
-  return join12(ASSETS_DIR, "templates");
+  return join13(ASSETS_DIR, "templates");
 }
 function getTemplatesIndexPath() {
-  return join12(ASSETS_DIR, "templates", "templates.json");
+  return join13(ASSETS_DIR, "templates", "templates.json");
 }
 function getBackendRuntimeDir() {
-  return join12(ASSETS_DIR, "backend-runtime");
+  return join13(ASSETS_DIR, "backend-runtime");
 }
 function getDenoWrapperPath() {
-  return join12(getBackendRuntimeDir(), "main.ts");
+  return join13(getBackendRuntimeDir(), "main.ts");
 }
 function getExecWrapperPath() {
-  return join12(getBackendRuntimeDir(), "exec.ts");
+  return join13(getBackendRuntimeDir(), "exec.ts");
 }
 function ensureNpmAssets(sourceDir) {
   if (existsSync(ASSETS_DIR) && existsSync(getBackendRuntimeDir()))
@@ -239189,7 +239375,7 @@ async function listTemplates() {
 }
 async function renderTemplate(template, destPath, data, options = {}) {
   const { skipExisting = false } = options;
-  const templateDir = join13(getTemplatesDir(), template.path);
+  const templateDir = join14(getTemplatesDir(), template.path);
   const files = await globby("**/*", {
     cwd: templateDir,
     dot: true,
@@ -239197,20 +239383,20 @@ async function renderTemplate(template, destPath, data, options = {}) {
   });
   const skipped = [];
   for (const file of files) {
-    const srcPath = join13(templateDir, file);
+    const srcPath = join14(templateDir, file);
     try {
       if (file.endsWith(".ejs")) {
         const rendered = await import_ejs.default.renderFile(srcPath, data);
         const { attributes, body } = import_front_matter2.default(rendered);
-        const destFile = attributes.outputFileName ? join13(dirname9(file), attributes.outputFileName) : file.replace(/\.ejs$/, "");
-        const destFilePath = join13(destPath, destFile);
+        const destFile = attributes.outputFileName ? join14(dirname11(file), attributes.outputFileName) : file.replace(/\.ejs$/, "");
+        const destFilePath = join14(destPath, destFile);
         if (skipExisting && await pathExists(destFilePath)) {
           skipped.push(destFile);
           continue;
         }
         await writeFile(destFilePath, body);
       } else {
-        const destFilePath = join13(destPath, file);
+        const destFilePath = join14(destPath, file);
         if (skipExisting && await pathExists(destFilePath)) {
           skipped.push(file);
           continue;
@@ -239364,7 +239550,7 @@ async function getSiteFilePaths(outputDir) {
 // src/core/site/deploy.ts
 import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 async function deploySite(siteOutputDir) {
   if (!await pathExists(siteOutputDir)) {
     throw new InvalidInputError(`Output directory does not exist: ${siteOutputDir}. Make sure to build your project first.`, {
@@ -239385,7 +239571,7 @@ async function deploySite(siteOutputDir) {
       ]
     });
   }
-  const archivePath = join14(tmpdir(), `base44-site-${randomUUID()}.tar.gz`);
+  const archivePath = join15(tmpdir(), `base44-site-${randomUUID()}.tar.gz`);
   try {
     await createArchive(siteOutputDir, archivePath);
     return await uploadSite(archivePath);
@@ -239402,13 +239588,13 @@ async function createArchive(pathToArchive, targetArchivePath) {
 }
 // src/core/site/deployment.ts
 import { readFile as readFile3 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 
 // src/core/site/manifest.ts
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { stat } from "node:fs/promises";
-import { basename as basename4, extname, join as join15 } from "node:path";
+import { basename as basename5, extname, join as join16 } from "node:path";
 var MAX_ASSET_COUNT = 1e5;
 var ASSETS_IGNORE_FILE = ".assetsignore";
 var ALWAYS_IGNORED = new Set([
@@ -239466,12 +239652,12 @@ async function buildAssetManifest(assetsDir, appId) {
     followSymbolicLinks: false,
     ignoreFiles: [ASSETS_IGNORE_FILE]
   });
-  const relativeFilePaths = found.filter((path) => !ALWAYS_IGNORED.has(basename4(path)));
+  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.`);
   }
   for (const relativePath of relativeFilePaths.sort()) {
-    const absolutePath = join15(assetsDir, ...relativePath.split("/"));
+    const absolutePath = join16(assetsDir, ...relativePath.split("/"));
     const { size } = await stat(absolutePath);
     const hash = await hashAssetFile(appId, absolutePath);
     manifest[`/${relativePath}`] = { hash, size };
@@ -239489,7 +239675,7 @@ async function buildAssetManifest(assetsDir, appId) {
 
 // src/core/site/modules.ts
 import { stat as stat2 } from "node:fs/promises";
-import { relative as relative3, resolve as resolve3, sep } from "node:path";
+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 = {
@@ -239509,7 +239695,7 @@ async function collectModules(config) {
     });
   }
   const modulesByName = new Map;
-  const entryName = toPosix(relative3(config.configDir, entryPath));
+  const entryName = toPosix(relative5(config.configDir, entryPath));
   modulesByName.set(entryName, {
     name: entryName,
     absolutePath: entryPath,
@@ -239518,7 +239704,7 @@ async function collectModules(config) {
   });
   const ignore = [...MODULE_IGNORE];
   if (config.assetsDirectory?.startsWith(config.configDir + sep)) {
-    ignore.push(`${toPosix(relative3(config.configDir, config.assetsDirectory))}/**`);
+    ignore.push(`${toPosix(relative5(config.configDir, config.assetsDirectory))}/**`);
   }
   for (const rule of config.rules) {
     const type = RULE_TYPE_TO_MODULE_TYPE[rule.type];
@@ -239812,10 +239998,7 @@ async function uploadPresignedAsset(upload, assets) {
   try {
     await distribution_default.put(upload.url, {
       body: new Uint8Array(content),
-      headers: {
-        "Content-Type": upload.contentType,
-        ...upload.checksumSha256 ? { "x-amz-checksum-sha256": upload.checksumSha256 } : {}
-      },
+      headers: { "Content-Type": upload.contentType },
       timeout: 120000,
       retry: UPLOAD_RETRY
     });
@@ -239825,8 +240008,8 @@ async function uploadPresignedAsset(upload, assets) {
 }
 
 // src/core/site/wrangler-config.ts
-import { dirname as dirname10, join as join16, resolve as resolve4 } from "node:path";
-var WRANGLER_REDIRECT_PATH = join16(".wrangler", "deploy", "config.json");
+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)
 });
@@ -239848,7 +240031,7 @@ var WranglerConfigSchema = looseObject({
   upload_source_maps: boolean2().optional()
 });
 async function detectFullStackArtifact(projectRoot) {
-  const redirectPath = join16(projectRoot, WRANGLER_REDIRECT_PATH);
+  const redirectPath = join17(projectRoot, WRANGLER_REDIRECT_PATH);
   return await pathExists(redirectPath) ? redirectPath : null;
 }
 async function resolveWranglerConfig(redirectPath) {
@@ -239862,7 +240045,7 @@ async function resolveWranglerConfig(redirectPath) {
   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 = dirname10(configPath);
+  const configDir = dirname12(configPath);
   const assetsDirectory = config.assets?.directory ? resolve4(configDir, config.assets.directory) : null;
   return {
     configPath,
@@ -239885,7 +240068,7 @@ async function resolveRedirectedConfigPath(redirectPath) {
   if (!result.success) {
     throw new ConfigInvalidError(`Invalid deploy redirect file: ${prettifyError(result.error)}`, redirectPath);
   }
-  const configPath = resolve4(dirname10(redirectPath), result.data.configPath);
+  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" }]
@@ -239950,7 +240133,7 @@ async function readIndexHtml(assetsDir, assets) {
   if (!assetsDir || !assets.manifest["/index.html"]) {
     throw new InvalidInputError(`No index.html found in "${assetsDir ?? "the site output directory"}" — a static site needs one at the output directory root.`);
   }
-  return new Uint8Array(await readFile3(join17(assetsDir, "index.html")));
+  return new Uint8Array(await readFile3(join18(assetsDir, "index.html")));
 }
 function buildAssetsConfig(assetsConfig, progress) {
   if (!assetsConfig)
@@ -246486,13 +246669,6 @@ 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"], {
@@ -246509,6 +246685,7 @@ function hasResourcesToDeploy(projectData) {
     project,
     entities,
     functions,
+    actors,
     agents,
     agentSkills,
     connectors,
@@ -246517,18 +246694,20 @@ function hasResourcesToDeploy(projectData) {
   const hasSite = Boolean(project.site?.outputDirectory);
   const hasEntities = entities.length > 0;
   const hasFunctions = functions.length > 0;
+  const hasActors = actors.length > 0;
   const hasAgents = agents.length > 0;
   const hasAgentSkills = agentSkills.length > 0;
   const hasConnectors = connectors.length > 0;
   const hasAuthConfig = authConfig.length > 0;
   const hasVisibility = Boolean(project.visibility);
-  return hasEntities || hasFunctions || hasAgents || hasAgentSkills || hasConnectors || hasAuthConfig || hasVisibility || hasSite;
+  return hasEntities || hasFunctions || hasActors || hasAgents || hasAgentSkills || hasConnectors || hasAuthConfig || hasVisibility || hasSite;
 }
 async function deployAll(projectData, options) {
   const {
     project,
     entities,
     functions,
+    actors,
     agents,
     agentSkills,
     connectors,
@@ -246539,10 +246718,33 @@ async function deployAll(projectData, options) {
     options?.onVisibilitySet?.(project.visibility);
   }
   await entityResource.push(entities);
-  await deployFunctionsSequentially(functions, {
+  const functionResults = await deployFunctionsSequentially(functions, {
     onStart: options?.onFunctionStart,
     onResult: options?.onFunctionResult
   });
+  const completedStages = [
+    ...project.visibility ? [`Visibility set to ${project.visibility}`] : [],
+    ...entities.length ? [`Entities synced: ${entities.length}`] : []
+  ];
+  const functionDetails = functionResults.map((result) => `Function ${result.name}: ${result.status}${result.error ? ` — ${result.error}` : ""}`);
+  if (functionResults.some((result) => result.status === "error")) {
+    throw new ResourceDeploymentError("Function deployment failed; remaining deploy stages were not run", {
+      details: [...completedStages, ...functionDetails]
+    });
+  }
+  const actorResults = await deployActorsSequentially(actors, {
+    onStart: options?.onActorStart,
+    onResult: options?.onActorResult
+  });
+  if (actorResults.some((result) => result.status === "error")) {
+    throw new ResourceDeploymentError("Actor deployment failed; remaining deploy stages were not run", {
+      details: [
+        ...completedStages,
+        ...functionDetails,
+        ...actorResults.map(describeActorResult)
+      ]
+    });
+  }
   await agentSkillResource.push(agentSkills);
   await agentResource.push(agents);
   await authConfigResource.push(authConfig);
@@ -247002,136 +247204,6 @@ async function resolveBranchName(name) {
   return matches[0].id;
 }
 
-// src/core/version/publish.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-
-// 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(),
-  deduplicated: boolean2()
-}).transform((data) => ({
-  versionId: data.version_id,
-  manifestHash: data.manifest_hash,
-  deduplicated: data.deduplicated
-}));
-var DeployVersionResponseSchema = object({
-  deployment_id: string2(),
-  manifest_hash: string2(),
-  revision: number2()
-}).transform((data) => ({
-  deploymentId: data.deployment_id,
-  manifestHash: data.manifest_hash,
-  revision: data.revision
-}));
-
-// src/core/version/api.ts
-var DEFAULT_VERSION_UPLOAD_CONCURRENCY = 8;
-var MAX_VERSION_UPLOAD_CONCURRENCY = 16;
-async function post(path, json, doing) {
-  try {
-    return await getAppClient().post(path, { json, timeout: 180000 });
-  } 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", {
-    static_bundle: artifacts.files.map(({ path, size, digest }) => ({
-      path,
-      size,
-      digest
-    })),
-    entities: artifacts.entities,
-    agents: artifacts.agents,
-    source_commit: options.sourceCommit,
-    frontend_commit: options.sourceCommit
-  }, "declaring a version")).json(), "declare");
-  options.progress?.onDeclared?.({
-    fileCount: artifacts.files.length,
-    owedFiles: declared.uploads.length
-  });
-  await uploadPresignedAssets(declared.uploads, {
-    manifest: Object.fromEntries(artifacts.files.map((file) => [
-      file.path,
-      { hash: file.digest, size: file.size }
-    ])),
-    filesByHash: new Map(artifacts.files.map((file) => [
-      file.digest,
-      {
-        absolutePath: file.absolutePath,
-        hash: file.digest,
-        size: file.size,
-        contentType: "application/octet-stream"
-      }
-    ]))
-  }, {
-    concurrency: options.concurrency ?? DEFAULT_VERSION_UPLOAD_CONCURRENCY,
-    onProgress: options.progress?.onUpload
-  });
-  return parse10(CreateVersionResponseSchema, await (await post(`versions/${encodeURIComponent(declared.sessionId)}/finalize`, {}, "creating a version")).json(), "create version");
-}
-async function deployVersion(versionId, options = {}) {
-  return parse10(DeployVersionResponseSchema, await (await post(`versions/${encodeURIComponent(versionId)}/deployments`, {
-    ...options.target ? { target: options.target } : {},
-    ...options.idempotencyKey ? { idempotency_key: options.idempotencyKey } : {}
-  }, "deploying a version")).json(), "deploy");
-}
-
-// src/core/version/publish.ts
-var STEP = Symbol.for("base44.publishStep");
-async function tagStep(step, run) {
-  try {
-    return await run();
-  } catch (error) {
-    if (error !== null && typeof error === "object" && !(STEP in 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;
-}
-async function publishVersion(artifacts, options = {}) {
-  const version = await tagStep("create_version", () => createVersion(artifacts, {
-    sourceCommit: options.sourceCommit,
-    concurrency: options.concurrency,
-    progress: options.progress
-  }));
-  const deployment = await tagStep("deploy", () => deployVersion(version.versionId, {
-    target: options.target,
-    idempotencyKey: randomUUID4()
-  }));
-  return { ...version, ...deployment };
-}
-
 // src/cli/utils/command/Base44Command.ts
 function writeJsonSuccess(result) {
   if (result.stdout) {
@@ -247149,10 +247221,6 @@ 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) {
@@ -247411,6 +247479,118 @@ function formatYaml(data, options = {}) {
   const replacer = stripEmpty ? stripEmptyReplacer : undefined;
   return $stringify(data, replacer, { indent: YAML_INDENT }).trimEnd();
 }
+// src/cli/commands/actors/delete.ts
+async function deleteActorsAction({ log, jsonMode, runTask }, rawNames) {
+  const names = [...new Set(parseNames(rawNames))];
+  if (!names.length)
+    throw new InvalidInputError("At least one actor name is required");
+  names.forEach(validateActorName);
+  const results = [];
+  for (const name of names) {
+    try {
+      await runTask(`Deleting ${name}...`, () => deleteSingleActor(name), {
+        successMessage: `${name} deleted`,
+        errorMessage: `Failed to delete ${name}`
+      });
+      results.push({ name, status: "deleted" });
+    } catch (error) {
+      if (error instanceof ApiError && error.statusCode === 404) {
+        results.push({ name, status: "not_found" });
+        log.info(`${name} not found`);
+      } else {
+        const result = actorOperationError(name, error);
+        results.push(result);
+        log.error(describeActorResult(result));
+      }
+    }
+  }
+  const summary = {
+    deleted: results.filter((result) => result.status === "deleted").length,
+    notFound: results.filter((result) => result.status === "not_found").length,
+    failed: results.filter((result) => result.status === "error").length
+  };
+  if (summary.failed)
+    throw new ResourceDeploymentError("Actor deletion failed", {
+      details: results.map(describeActorResult)
+    });
+  return {
+    outroMessage: names.length === 1 ? `Actor "${names[0]}" ${summary.deleted ? "deleted" : "not found"}` : `${summary.deleted} deleted, ${summary.notFound} not found`,
+    stdout: jsonMode ? `${JSON.stringify({ actors: results, summary })}
+` : undefined
+  };
+}
+function getDeleteCommand() {
+  return new Base44Command("delete").description("Delete deployed actors").argument("[names...]", "Actor names to delete (required)").action(deleteActorsAction);
+}
+
+// src/cli/commands/functions/formatDeployResult.ts
+function formatDuration(ms) {
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+function formatDeployResult(result, log) {
+  const label = result.name.padEnd(25);
+  if (result.status === "deployed") {
+    const timing = result.durationMs ? theme.styles.dim(` (${formatDuration(result.durationMs)})`) : "";
+    log.success(`${label} deployed${timing}`);
+  } else if (result.status === "unchanged") {
+    log.success(`${label} unchanged`);
+  } else {
+    log.error(`${label} error: ${result.error}`);
+  }
+}
+
+// src/cli/commands/actors/deploy.ts
+async function deployActorsAction({ log, jsonMode }, rawNames) {
+  const names = [...new Set(parseNames(rawNames))];
+  if (rawNames.length && !names.length)
+    throw new InvalidInputError("At least one actor name is required");
+  names.forEach(validateActorName);
+  const { actors, project } = await readProjectConfig();
+  const notFound = names.filter((name) => !actors.some((actor) => actor.name === name));
+  if (notFound.length)
+    throw new InvalidInputError(`Actor not found in project: ${notFound.join(", ")}`);
+  const selected = names.length ? actors.filter((actor) => names.includes(actor.name)) : actors;
+  let completed = 0;
+  if (selected.length)
+    log.info(`Found ${selected.length} ${selected.length === 1 ? "actor" : "actors"} to deploy`);
+  const results = await deployActorsSequentially(selected, {
+    onStart: (name) => log.step(theme.styles.dim(`[${completed + 1}/${selected.length}] Deploying ${name}...`)),
+    onResult: (result) => {
+      completed++;
+      formatDeployResult(result, log);
+      if (result.status !== "error")
+        for (const warning of result.warnings)
+          log.warn(`${result.name}: ${warning}`);
+    }
+  });
+  const summary = {
+    deployed: results.filter((result) => result.status === "deployed").length,
+    unchanged: results.filter((result) => result.status === "unchanged").length,
+    failed: results.filter((result) => result.status === "error").length
+  };
+  const message = Object.entries(summary).filter(([, count]) => count > 0).map(([status, count]) => `${count} ${status}`).join(", ");
+  if (summary.failed) {
+    throw new ResourceDeploymentError(message, {
+      details: results.map(describeActorResult)
+    });
+  }
+  return {
+    outroMessage: message || `No actors found. Create actors in the '${project.actorsDir}' directory.`,
+    stdout: jsonMode ? `${JSON.stringify({ actors: results, summary })}
+` : undefined
+  };
+}
+function getDeployCommand() {
+  return new Base44Command("deploy").description("Deploy actors to Base44").argument("[names...]", "Actor names to deploy (deploys all if omitted)").action(deployActorsAction);
+}
+
+// src/cli/commands/actors/index.ts
+function getActorsCommand() {
+  return new Command2("actors").description("Manage realtime actors").addCommand(getDeployCommand()).addCommand(getDeleteCommand());
+}
+
+// src/cli/commands/agent-skills/pull.ts
+import { dirname as dirname13, join as join19 } from "node:path";
 // src/core/utils/dependencies.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 function verifyDenoInstalled(context) {
@@ -247499,7 +247679,7 @@ async function pullAction({
   runTask
 }) {
   const { project } = await readProjectConfig();
-  const dir = join18(dirname11(project.configPath), project.agentSkillsDir);
+  const dir = join19(dirname13(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"
@@ -247555,14 +247735,14 @@ function getAgentSkillsCommand() {
 }
 
 // src/cli/commands/agents/pull.ts
-import { dirname as dirname12, join as join19 } from "node:path";
+import { dirname as dirname14, join as join20 } from "node:path";
 async function pullAgentsAction({
   log,
   runTask
 }) {
   const { project } = await readProjectConfig();
-  const configDir = dirname12(project.configPath);
-  const agentsDir = join19(configDir, project.agentsDir);
+  const configDir = dirname14(project.configPath);
+  const agentsDir = join20(configDir, project.agentsDir);
   const remoteAgents = await runTask("Fetching agents from Base44", async () => {
     return await fetchAgents();
   }, {
@@ -247632,12 +247812,12 @@ function getAgentsCommand() {
 }
 
 // src/cli/commands/auth/password-login.ts
-import { dirname as dirname13, join as join20 } from "node:path";
+import { dirname as dirname15, join as join21 } from "node:path";
 async function passwordLoginAction({ log, runTask }, action) {
   const shouldEnable = action === "enable";
   const { project } = await readProjectConfig();
-  const configDir = dirname13(project.configPath);
-  const authDir = join20(configDir, project.authDir);
+  const configDir = dirname15(project.configPath);
+  const authDir = join21(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 };
@@ -247657,14 +247837,14 @@ function getPasswordLoginCommand() {
 }
 
 // src/cli/commands/auth/pull.ts
-import { dirname as dirname14, join as join21 } from "node:path";
+import { dirname as dirname16, join as join22 } from "node:path";
 async function pullAuthAction({
   log,
   runTask
 }) {
   const { project } = await readProjectConfig();
-  const configDir = dirname14(project.configPath);
-  const authDir = join21(configDir, project.authDir);
+  const configDir = dirname16(project.configPath);
+  const authDir = join22(configDir, project.authDir);
   const remoteConfig = await runTask("Fetching auth config from Base44", async () => {
     return await pullAuthConfig();
   }, {
@@ -247728,7 +247908,7 @@ function getAuthPushCommand() {
 }
 
 // src/cli/commands/auth/social-login.ts
-import { dirname as dirname15, join as join22, resolve as resolve6 } from "node:path";
+import { dirname as dirname17, join as join23, resolve as resolve6 } from "node:path";
 var PROVIDER_LABELS = {
   google: "Google",
   microsoft: "Microsoft",
@@ -247798,8 +247978,8 @@ async function socialLoginAction({ log, isNonInteractive, runTask }, provider, a
     }
   }
   const { project } = await readProjectConfig();
-  const configDir = dirname15(project.configPath);
-  const authDir = join22(configDir, project.authDir);
+  const configDir = dirname17(project.configPath);
+  const authDir = join23(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));
@@ -247824,7 +248004,7 @@ function getSocialLoginCommand() {
 }
 
 // src/cli/commands/auth/sso.ts
-import { dirname as dirname16, join as join23, resolve as resolve7 } from "node:path";
+import { dirname as dirname18, join as join24, resolve as resolve7 } from "node:path";
 var SSOConfigFileSchema = object({
   provider: _enum(Object.values(KNOWN_SSO_PROVIDERS)),
   clientId: string2(),
@@ -247987,8 +248167,8 @@ async function ssoEnableAction({ isNonInteractive, runTask }, options) {
     throw error;
   }
   const { project } = await readProjectConfig();
-  const configDir = dirname16(project.configPath);
-  const authDir = join23(configDir, project.authDir);
+  const configDir = dirname18(project.configPath);
+  const authDir = join24(configDir, project.authDir);
   await runTask("Updating local auth config", async () => updateSSOConfig(authDir, provider, true));
   await runTask("Saving SSO credentials", async () => pushSSOSecrets(secrets));
   return {
@@ -248003,8 +248183,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 = dirname16(project.configPath);
-  const authDir = join23(configDir, project.authDir);
+  const configDir = dirname18(project.configPath);
+  const authDir = join24(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)) {
@@ -248886,13 +249066,13 @@ function getConnectorsListAvailableCommand() {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname17, join as join24, resolve as resolve8 } from "node:path";
+import { dirname as dirname19, join as join25, resolve as resolve8 } from "node:path";
 async function resolveConnectorsDir(options) {
   if (!getAppContext().projectRoot) {
     return resolve8(options.dir ?? "connectors");
   }
   const { project } = await readProjectConfig();
-  return join24(dirname17(project.configPath), project.connectorsDir);
+  return join25(dirname19(project.configPath), project.connectorsDir);
 }
 async function pullConnectorsAction({ log, runTask, jsonMode }, options) {
   const connectorsDir = await resolveConnectorsDir(options);
@@ -249147,43 +249327,22 @@ async function deleteFunctionsAction({ runTask }, names) {
     parts.push(`${errors} error${errors !== 1 ? "s" : ""}`);
   return { outroMessage: parts.join(", ") };
 }
-function parseNames(args) {
+function parseNames2(args) {
   return args.flatMap((arg) => arg.split(",")).map((n) => n.trim()).filter(Boolean);
 }
 function validateNames(command) {
-  const names = parseNames(command.args);
+  const names = parseNames2(command.args);
   if (names.length === 0) {
     command.error("At least one function name is required");
   }
 }
-function getDeleteCommand() {
+function getDeleteCommand2() {
   return new Base44Command("delete").description("Delete deployed functions").argument("<names...>", "Function names to delete").hook("preAction", validateNames).action(async (ctx, rawNames) => {
-    const names = parseNames(rawNames);
+    const names = parseNames2(rawNames);
     return deleteFunctionsAction(ctx, names);
   });
 }
 
-// src/cli/commands/functions/formatDeployResult.ts
-function formatDuration(ms) {
-  return `${(ms / 1000).toFixed(1)}s`;
-}
-function formatDeployResult(result, log) {
-  const label = result.name.padEnd(25);
-  if (result.status === "deployed") {
-    const timing = result.durationMs ? theme.styles.dim(` (${formatDuration(result.durationMs)})`) : "";
-    log.success(`${label} deployed${timing}`);
-  } else if (result.status === "unchanged") {
-    log.success(`${label} unchanged`);
-  } else {
-    log.error(`${label} error: ${result.error}`);
-  }
-}
-
-// src/cli/commands/functions/parseNames.ts
-function parseNames2(args) {
-  return args.flatMap((arg) => arg.split(",")).map((n) => n.trim()).filter(Boolean);
-}
-
 // src/cli/commands/functions/deploy.ts
 function resolveFunctionsToDeploy(names, allFunctions) {
   if (names.length === 0)
@@ -249270,9 +249429,9 @@ async function deployFunctionsAction({ log }, names, options) {
   }
   return { outroMessage: buildDeploySummary(results) };
 }
-function getDeployCommand() {
+function getDeployCommand2() {
   return new Base44Command("deploy").description("Deploy functions to Base44").argument("[names...]", "Function names to deploy (deploys all if omitted)").option("--force", "Delete remote functions not found locally").action(async (ctx, rawNames, options) => {
-    const names = parseNames2(rawNames);
+    const names = parseNames(rawNames);
     return deployFunctionsAction(ctx, names, options);
   });
 }
@@ -249300,11 +249459,11 @@ function getListCommand() {
 }
 
 // src/cli/commands/functions/pull.ts
-import { dirname as dirname18, join as join25 } from "node:path";
+import { dirname as dirname20, join as join26 } from "node:path";
 async function pullFunctionsAction({ log, runTask }, name) {
   const { project, functions } = await readProjectConfig();
-  const configDir = dirname18(project.configPath);
-  const functionsDir = join25(configDir, project.functionsDir);
+  const configDir = dirname20(project.configPath);
+  const functionsDir = join26(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();
@@ -249359,7 +249518,7 @@ function getPullCommand() {
 
 // src/cli/commands/functions/index.ts
 function getFunctionsCommand() {
-  return new Command2("functions").description("Manage backend functions").addCommand(getDeployCommand()).addCommand(getDeleteCommand()).addCommand(getListCommand()).addCommand(getPullCommand());
+  return new Command2("functions").description("Manage backend functions").addCommand(getDeployCommand2()).addCommand(getDeleteCommand2()).addCommand(getListCommand()).addCommand(getPullCommand());
 }
 
 // src/cli/commands/project/site-build.ts
@@ -249404,161 +249563,33 @@ async function maybeAskToBuild(isNonInteractive, buildCommand) {
   });
   return !Ct(answer) && answer;
 }
-// src/core/version/artifacts.ts
-import { createHash as createHash2 } from "node:crypto";
-import { createReadStream as createReadStream3 } from "node:fs";
-import { stat as stat3 } from "node:fs/promises";
-import { basename as basename5, join as join26 } from "node:path";
-var MAX_FILE_COUNT = 1e5;
-var ASSETS_IGNORE_FILE2 = ".assetsignore";
-var ALWAYS_IGNORED2 = new Set([
-  ASSETS_IGNORE_FILE2,
-  "wrangler.json",
-  ".dev.vars"
-]);
-var ENTRY2 = "index.html";
-async function digestFile(absolutePath) {
-  const hash = createHash2("sha256");
-  for await (const chunk of createReadStream3(absolutePath)) {
-    hash.update(chunk);
-  }
-  return `sha256:${hash.digest("hex")}`;
-}
-async function collectBuildOutput(outputDir) {
-  const found = await globby("**/*", {
-    cwd: outputDir,
-    dot: true,
-    onlyFiles: true,
-    followSymbolicLinks: false,
-    ignoreFiles: [ASSETS_IGNORE_FILE2]
-  });
-  const relativePaths = found.filter((path) => !ALWAYS_IGNORED2.has(basename5(path))).sort();
-  if (relativePaths.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 (relativePaths.length > MAX_FILE_COUNT) {
-    throw new InvalidInputError(`Too many files: found ${relativePaths.length}, the limit is ${MAX_FILE_COUNT}.`);
-  }
-  if (!relativePaths.includes(ENTRY2)) {
-    throw new InvalidInputError(`${outputDir} has no ${ENTRY2}, so nothing could enter the site.`);
-  }
-  return await Promise.all(relativePaths.map(async (path) => {
-    const absolutePath = join26(outputDir, ...path.split("/"));
-    const { size } = await stat3(absolutePath);
-    return {
-      path,
-      absolutePath,
-      size,
-      digest: await digestFile(absolutePath)
-    };
-  }));
-}
-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(join26(dir, ...relativePath.split("/")));
-  }
-  return payloads;
-}
-async function collectResources(configDir, dirs) {
-  const [entities, agents] = await Promise.all([
-    readRawResources(join26(configDir, dirs.entitiesDir)),
-    readRawResources(join26(configDir, dirs.agentsDir))
-  ]);
-  return { entities, agents };
-}
-// src/core/version/project.ts
-import { dirname as dirname19, join as join27, resolve as resolve10 } from "node:path";
-var DEFAULT_BUILD_COMMAND = "npm run build";
-var DEFAULT_OUTPUT_DIRECTORY = "dist";
-async function resolvePublishTarget(projectRoot, overrides = {}) {
-  const project = await readSettingsIfPresent(projectRoot);
-  const root = project?.root ?? projectRoot ?? process.cwd();
-  return {
-    root,
-    configDir: project ? dirname19(project.configPath) : join27(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 ? resolve10(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/cli/commands/project/build.ts
-async function buildAction(ctx, options) {
-  const { app, jsonMode } = ctx;
-  const target = await resolvePublishTarget(app?.projectRoot, {
-    outputDir: options.outputDir
-  });
+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);
   await runSiteBuild(ctx, {
-    root: target.root,
-    buildCommand: target.buildCommand,
-    appId: app?.id ?? ""
+    root: project.root,
+    buildCommand: project.site?.buildCommand,
+    appId: app.id
   });
-  const files = await collectBuildOutput(requireOutputDir(target));
-  const totalBytes = files.reduce((sum, file) => sum + file.size, 0);
   return {
-    outroMessage: `Built ${files.length} files (${totalBytes} bytes) with app id ${theme.styles.bold(app?.id ?? "")}`,
-    stdout: jsonMode ? `${JSON.stringify({
-      outputDir: target.outputDir,
-      files: files.map(({ path, size, digest }) => ({
-        path,
-        size,
-        digest
-      }))
-    }, null, 2)}
-` : undefined
+    outroMessage: `Site built with app id ${theme.styles.bold(app.id)}`
   };
 }
 function getBuildCommand() {
-  return new Base44Command("build", { requireAuth: false }).description("Build the site with the Base44 app id injected").option("--output-dir <dir>", "Build output directory (defaults to the project's, else dist)").action(buildAction);
+  return new Base44Command("build").description("Build the site with the Base44 app id injected").action(buildAction);
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename6, resolve as resolve11 } from "node:path";
+import { basename as basename6, resolve as resolve10 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
-import { join as join28 } from "node:path";
+import { join as join27 } from "node:path";
 var DEFAULT_TEMPLATE_ID = "backend-only";
 async function getTemplateById(templateId) {
   const templates = await listTemplates();
@@ -249621,7 +249652,7 @@ async function completeProjectSetup({
           env: { VITE_BASE44_APP_ID: projectId }
         })`${buildCommand}`;
         updateMessage("Deploying site...");
-        return await deploySite(join28(resolvedPath, outputDirectory));
+        return await deploySite(join27(resolvedPath, outputDirectory));
       }, {
         successMessage: theme.colors.base44Orange("Site deployed successfully"),
         errorMessage: "Failed to deploy site"
@@ -249750,7 +249781,7 @@ async function createInteractive(options, ctx) {
   }, ctx);
 }
 async function createNonInteractive(options, ctx) {
-  ctx.log.info(`Creating a new project at ${resolve11(options.path)}`);
+  ctx.log.info(`Creating a new project at ${resolve10(options.path)}`);
   const template = await getTemplateById(options.template ?? DEFAULT_TEMPLATE_ID);
   return await executeCreate({
     template,
@@ -249774,7 +249805,7 @@ async function executeCreate({
 }, ctx) {
   const { log, runTask } = ctx;
   const name = rawName.trim();
-  const resolvedPath = resolve11(projectPath);
+  const resolvedPath = resolve10(projectPath);
   const organizationId = await resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive);
   const { projectId } = await runTask("Setting up your project...", async () => {
     return await createProjectFiles({
@@ -249836,7 +249867,15 @@ async function deployAction(ctx, options = {}) {
       outroMessage: "No resources found to deploy"
     };
   }
-  const { project, entities, functions, agents, connectors, authConfig } = projectData;
+  const {
+    project,
+    entities,
+    functions,
+    actors,
+    agents,
+    connectors,
+    authConfig
+  } = projectData;
   const summaryLines = [];
   if (entities.length > 0) {
     summaryLines.push(`  - ${entities.length} ${entities.length === 1 ? "entity" : "entities"}`);
@@ -249844,6 +249883,9 @@ async function deployAction(ctx, options = {}) {
   if (functions.length > 0) {
     summaryLines.push(`  - ${functions.length} ${functions.length === 1 ? "function" : "functions"}`);
   }
+  if (actors.length > 0) {
+    summaryLines.push(`  - ${actors.length} ${actors.length === 1 ? "actor" : "actors"}`);
+  }
   if (agents.length > 0) {
     summaryLines.push(`  - ${agents.length} ${agents.length === 1 ? "agent" : "agents"}`);
   }
@@ -249877,6 +249919,7 @@ ${summaryLines.join(`
   await maybeBuildBeforeDeploy(ctx, project, options.build);
   let functionCompleted = 0;
   const functionTotal = functions.length;
+  let actorCompleted = 0;
   const result = await deployAll(projectData, {
     onVisibilitySet: (level) => {
       log.success(`App visibility set to ${level}`);
@@ -249888,6 +249931,16 @@ ${summaryLines.join(`
     onFunctionResult: (r) => {
       functionCompleted++;
       formatDeployResult(r, log);
+    },
+    onActorStart: (name) => {
+      log.step(theme.styles.dim(`[${actorCompleted + 1}/${actors.length}] Deploying ${name}...`));
+    },
+    onActorResult: (result) => {
+      actorCompleted++;
+      formatDeployResult(result, log);
+      if (result.status !== "error")
+        for (const warning of result.warnings)
+          log.warn(`${result.name}: ${warning}`);
     }
   });
   const connectorResults = result.connectorResults ?? [];
@@ -249902,8 +249955,8 @@ ${summaryLines.join(`
   }
   return { outroMessage: "App deployed successfully" };
 }
-function getDeployCommand2() {
-  return new Base44Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").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)").action(deployAction);
+function getDeployCommand3() {
+  return new Base44Command("deploy").description("Deploy all project resources (entities, functions, actors, agents, connectors, and site)").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)").action(deployAction);
 }
 async function handleOAuthConnectors(connectorResults, isNonInteractive, options, log) {
   const needsOAuth = filterPendingOAuth(connectorResults);
@@ -250389,11 +250442,11 @@ async function logsAction(ctx, options) {
 function getLogsCommand() {
   return new Base44Command("logs").description("Fetch function logs for this app").option("--function <names>", "Filter by function name(s), comma-separated. If omitted, fetches logs for all deployed functions").option("--since <datetime>", "Show logs from this time. ISO datetime or relative shorthand (e.g. 1h, 30m, 2d)", normalizeDatetime).option("--until <datetime>", "Show logs until this time. ISO datetime or relative shorthand (e.g. 1h, 30m, 2d)", normalizeDatetime).addOption(new Option2("--level <level>", "Filter by log level").choices([
     ...LogLevelSchema.options
-  ])).option("-n, --limit <n>", "Results per page (1-1000; the server returns at most 500)").option("-f, --follow", "Stream new logs as they arrive").addOption(new Option2("--order <order>", "Sort order").choices(["asc", "desc"])).addOption(new Option2("--env <env>", "Which deployment to read logs from: preview (current draft) or prod (published). Default: preview").choices([...LogEnvSchema.options])).action(logsAction);
+  ])).option("-n, --limit <n>", "Results per page (1-1000; the server returns at most 500)").option("-f, --follow", "Stream new logs as they arrive").addOption(new Option2("--order <order>", "Sort order").choices(["asc", "desc"])).addOption(new Option2("--env <env>", "Which deployment to read logs from: preview (current draft) or prod (published). Omit to read both.").choices([...LogEnvSchema.options])).action(logsAction);
 }
 
 // src/cli/commands/project/scaffold.ts
-import { basename as basename7, resolve as resolve12 } from "node:path";
+import { basename as basename7, resolve as resolve11 } from "node:path";
 function resolveAppId(options) {
   const appId = options.appId;
   if (!appId) {
@@ -250409,7 +250462,7 @@ function resolveAppId(options) {
 async function scaffoldAction(ctx, name, options, command) {
   const { log, runTask } = ctx;
   const appId = resolveAppId(command.optsWithGlobals());
-  const resolvedPath = resolve12("./");
+  const resolvedPath = resolve11("./");
   const projectName = (name ?? basename7(resolvedPath)).trim();
   const template = await getTemplateById("backend-only");
   log.info(`Scaffolding project at ${resolvedPath}`);
@@ -250457,62 +250510,6 @@ function getVisibilityCommand() {
   ])).action(setVisibility);
 }
 
-// src/cli/commands/publish.ts
-async function publishAction(ctx, options) {
-  const { runTask, log, jsonMode, app } = ctx;
-  const target = await resolvePublishTarget(app?.projectRoot, {
-    outputDir: options.outputDir
-  });
-  if (options.build !== false) {
-    await tagStep("build", () => runSiteBuild(ctx, {
-      root: target.root,
-      buildCommand: target.buildCommand,
-      appId: app?.id ?? ""
-    }));
-  }
-  const outputDir = requireOutputDir(target);
-  const gitHash = await resolveProvenanceCommit(target.root, options.gitHash);
-  const result = await runTask("Publishing...", async (updateMessage) => {
-    const artifacts = {
-      files: await collectBuildOutput(outputDir),
-      ...await collectResources(target.configDir, target)
-    };
-    return await publishVersion(artifacts, {
-      sourceCommit: gitHash,
-      target: options.target,
-      concurrency: options.concurrency,
-      progress: {
-        onDeclared: ({ fileCount, owedFiles }) => updateMessage(`Uploading ${owedFiles} of ${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}${result.deduplicated ? " (existing content)" : ""}`));
-  }
-  return {
-    outroMessage: `Deployment ${result.deploymentId} at revision ${result.revision}`,
-    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").option("--output-dir <dir>", "Build output directory (defaults to the project's, else dist)").option("--target <name>", "Environment to serve the version at").addOption(new Option2("--git-hash <hash>", "Commit the build came from (defaults to the checkout's HEAD)").argParser(parseGitHash)).addOption(new Option2("--concurrency <n>", "Parallel file uploads").default(DEFAULT_VERSION_UPLOAD_CONCURRENCY).argParser(parseConcurrency)).action(publishAction);
-}
-function parseGitHash(value) {
-  if (!isGitCommitHash(value)) {
-    throw new InvalidArgumentError2("Expected a git commit hash (7-64 hex chars).");
-  }
-  return value;
-}
-function parseConcurrency(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/core/resources/sandbox/schema.ts
 var FileErrorSchema = object({
   code: string2(),
@@ -250882,7 +250879,7 @@ function getSecretsListCommand() {
 }
 
 // src/cli/commands/secrets/set.ts
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve12 } from "node:path";
 function parseEntries(entries) {
   const secrets = {};
   for (const entry of entries) {
@@ -250913,7 +250910,7 @@ async function setSecretsAction({ log, runTask }, entries, options) {
   validateInput(entries, options);
   let secrets;
   if (options.envFile) {
-    secrets = await parseEnvFile(resolve13(options.envFile));
+    secrets = await parseEnvFile(resolve12(options.envFile));
     if (Object.keys(secrets).length === 0) {
       throw new InvalidInputError("The env file contains no valid KEY=VALUE entries.");
     }
@@ -250942,7 +250939,7 @@ function getSecretsCommand() {
 }
 
 // src/cli/commands/site/deploy.ts
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve13 } from "node:path";
 async function deployAction2(ctx, options) {
   const { isNonInteractive } = ctx;
   if (isNonInteractive && !options.yes) {
@@ -251020,23 +251017,23 @@ async function deployTarball({ runTask }, project) {
 }
 function siteOutputDir(project) {
   const outputDirectory = project.site?.outputDirectory;
-  return outputDirectory ? resolve14(project.root, outputDirectory) : null;
+  return outputDirectory ? resolve13(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)");
   if (deploymentsApiEnabled()) {
-    command.addOption(new Option2("--git-hash <hash>", "Commit the build came from (defaults to the checkout's HEAD)").argParser(parseGitHash2));
-    command.addOption(new Option2("--concurrency <n>", "Parallel asset uploads").default(DEFAULT_UPLOAD_CONCURRENCY).argParser(parseConcurrency2));
+    command.addOption(new Option2("--git-hash <hash>", "Commit the build came from (defaults to the checkout's HEAD)").argParser(parseGitHash));
+    command.addOption(new Option2("--concurrency <n>", "Parallel asset uploads").default(DEFAULT_UPLOAD_CONCURRENCY).argParser(parseConcurrency));
   }
   return command.action(deployAction2);
 }
-function parseGitHash2(value) {
+function parseGitHash(value) {
   if (!isGitCommitHash(value)) {
     throw new InvalidArgumentError2("Expected a git commit hash (7-64 hex chars).");
   }
   return value;
 }
-function parseConcurrency2(value) {
+function parseConcurrency(value) {
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_UPLOAD_CONCURRENCY) {
     throw new InvalidArgumentError2(`Expected a whole number between 1 and ${MAX_UPLOAD_CONCURRENCY}.`);
@@ -251074,10 +251071,12 @@ var EMPTY_TEMPLATE = import_common_tags.stripIndent`
   // Auto-generated by Base44 CLI - DO NOT EDIT
   // Regenerate with: base44 types
   //
-  // No entities, functions, agents, or connectors found in project.
-  // Add resources to base44/entities/, base44/functions/, base44/agents/, or base44/connectors/
+  // No entities, functions, actors, agents, or connectors found in project.
+  // Add resources to base44/entities/, base44/functions/, base44/actors/, base44/agents/, or base44/connectors/
   // and run \`base44 types generate\` again.
 
+  import '@base44/sdk';
+
   declare module '@base44/sdk' {
     // No types to augment - add resources and regenerate
   }
@@ -251087,8 +251086,8 @@ async function generateTypesFile(input) {
   await writeFile(getTypesOutputPath(input.projectRoot), content);
 }
 async function generateContent(input) {
-  const { entities, functions, agents, connectors } = input;
-  if (!entities.length && !functions.length && !agents.length && !connectors.length) {
+  const { entities, functions, actors, agents, connectors } = input;
+  if (!entities.length && !functions.length && !actors.length && !agents.length && !connectors.length) {
     return EMPTY_TEMPLATE;
   }
   const entityInterfaces = await Promise.all(entities.map((e) => compileEntity(e)));
@@ -251098,12 +251097,14 @@ async function generateContent(input) {
       entities.map((e) => `"${e.name}": ${toPascalCase(e.name)};`)
     ],
     ["FunctionNameRegistry", functions.map((f) => `"${f.name}": true;`)],
+    ["ActorNameRegistry", actors.map((actor) => `"${actor.name}": true;`)],
     ["AgentNameRegistry", agents.map((a) => `"${a.name}": true;`)],
     ["ConnectorTypeRegistry", connectors.map((c) => `"${c.type}": true;`)]
   ];
   const registries = registryEntries.filter(([, entries]) => entries.length > 0).map(([name, entries]) => registry2(name, entries));
   return [
     HEADER2,
+    "import '@base44/sdk';",
     entityInterfaces.join(`
 
 `),
@@ -251148,10 +251149,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 join31 } from "node:path";
+import { join as join30 } from "node:path";
 var TYPES_INCLUDE_PATH = `${PROJECT_SUBDIR}/${TYPES_OUTPUT_SUBDIR}/*.d.ts`;
 async function updateProjectConfig(projectRoot) {
-  const tsconfigPath = join31(projectRoot, "tsconfig.json");
+  const tsconfigPath = join30(projectRoot, "tsconfig.json");
   if (!await pathExists(tsconfigPath)) {
     return false;
   }
@@ -251175,12 +251176,13 @@ var TYPES_FILE_PATH = "base44/.types/types.d.ts";
 async function generateTypesAction({
   runTask
 }) {
-  const { entities, functions, agents, connectors, project } = await readProjectConfig();
+  const { entities, functions, actors, agents, connectors, project } = await readProjectConfig();
   await runTask("Generating types", async () => {
     await generateTypesFile({
       projectRoot: project.root,
       entities,
       functions,
+      actors,
       agents,
       connectors
     });
@@ -251199,69 +251201,6 @@ function getTypesCommand() {
   return new Command2("types").description("Manage TypeScript type generation").addCommand(getTypesGenerateCommand());
 }
 
-// src/cli/commands/versions/create.ts
-async function createAction2({ runTask, jsonMode, app }, options) {
-  const target = await resolvePublishTarget(app?.projectRoot, {
-    outputDir: options.outputDir
-  });
-  const gitHash = await resolveProvenanceCommit(target.root, options.gitHash);
-  const version = await runTask("Creating version...", async (updateMessage) => await createVersion({
-    files: await collectBuildOutput(requireOutputDir(target)),
-    ...await collectResources(target.configDir, target)
-  }, {
-    sourceCommit: gitHash,
-    concurrency: options.concurrency,
-    progress: {
-      onDeclared: ({ fileCount, owedFiles }) => updateMessage(`Uploading ${owedFiles} of ${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").option("--output-dir <dir>", "Build output directory (defaults to the project's, else dist)").addOption(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;
-  })).addOption(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;
-  })).action(createAction2);
-}
-
-// src/cli/commands/versions/deploy.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
-async function deployAction3({ runTask, jsonMode }, versionId, options) {
-  const deployment = await runTask(`Deploying version ${versionId}...`, async () => await deployVersion(versionId, {
-    target: options.target,
-    idempotencyKey: randomUUID5()
-  }), { successMessage: "Version deployed", errorMessage: "Deploy failed" });
-  return {
-    outroMessage: `Deployment ${deployment.deploymentId} at revision ${deployment.revision}`,
-    stdout: jsonMode ? `${JSON.stringify(deployment, null, 2)}
-` : undefined
-  };
-}
-function getVersionDeployCommand() {
-  return new Base44Command("deploy").description("Serve an already-recorded version (also how a rollback is done)").argument("<version-id>", "The version to serve").option("--target <name>", "Environment to serve the version at").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",
@@ -251678,7 +251617,7 @@ function createDevLogger(label, labelColor = theme.styles.dim) {
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
 var import_express6 = __toESM(require_express(), 1);
-import { dirname as dirname25, join as join37 } from "node:path";
+import { dirname as dirname26, join as join36 } from "node:path";
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -251808,7 +251747,7 @@ var $tmpName = promisify11(tmp.tmpName);
 
 // src/cli/dev/dev-server/function-manager.ts
 import { spawn as spawn2 } from "node:child_process";
-import { dirname as dirname22, join as join33 } from "node:path";
+import { dirname as dirname23, join as join31 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/cli/dev/dev-server/base-function-manager.ts
@@ -251913,7 +251852,7 @@ class FunctionManager extends BaseFunctionManager {
   }
   spawnFunction(func, port) {
     this.logger.log(`Spawning function "${func.name}" on port ${port}`);
-    const importMapPath = join33(dirname22(this.wrapperPath), "import-map.json");
+    const importMapPath = join31(dirname23(this.wrapperPath), "import-map.json");
     const process2 = spawn2("deno", ["run", "--allow-all", "--import-map", importMapPath, this.wrapperPath], {
       env: {
         ...globalThis.process.env,
@@ -251987,7 +251926,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 join34 } from "node:path";
+import { join as join33 } from "node:path";
 import { pathToFileURL as pathToFileURL6 } from "node:url";
 var depsPromise;
 function loadDeps() {
@@ -252108,9 +252047,9 @@ export default {
 };
 `;
 function ensureBundlerConfig() {
-  const dir = join34(homedir3(), ".base44", "function-bundler");
+  const dir = join33(homedir3(), ".base44", "function-bundler");
   mkdirSync2(dir, { recursive: true });
-  const configPath = join34(dir, "deno.json");
+  const configPath = join33(dir, "deno.json");
   writeFileSync2(configPath, `${JSON.stringify({ nodeModulesDir: "auto" }, null, 2)}
 `);
   return configPath;
@@ -253491,11 +253430,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 createHash3, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash2, randomUUID as randomUUID4 } from "node:crypto";
 import fs28 from "node:fs";
 import path18 from "node:path";
 function createFileToken(fileUri) {
-  return createHash3("sha256").update(fileUri).digest("hex");
+  return createHash2("sha256").update(fileUri).digest("hex");
 }
 function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
   const router = import_express5.Router({ mergeParams: true });
@@ -253508,14 +253447,14 @@ function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
     destination: mediaFilesDir,
     filename: (_req, file, cb) => {
       const ext = path18.extname(file.originalname);
-      cb(null, `${randomUUID6()}${ext}`);
+      cb(null, `${randomUUID4()}${ext}`);
     }
   });
   const privateStorage = import_multer.default.diskStorage({
     destination: privateFilesDir,
     filename: (_req, file, cb) => {
       const ext = path18.extname(file.originalname);
-      cb(null, `${randomUUID6()}${ext}`);
+      cb(null, `${randomUUID4()}${ext}`);
     }
   });
   const upload = import_multer.default({ storage, limits: { fileSize: MAX_FILE_SIZE } });
@@ -253580,16 +253519,16 @@ function createCustomIntegrationRoutes(remoteProxy, logger) {
 
 // src/cli/dev/dev-server/watcher.ts
 import { EventEmitter as EventEmitter4 } from "node:events";
-import { relative as relative7 } from "node:path";
+import { relative as relative9 } from "node:path";
 
 // ../../node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter3 } from "node:events";
 import { stat as statcb, Stats } from "node:fs";
-import { readdir as readdir3, stat as stat7 } from "node:fs/promises";
+import { readdir as readdir3, stat as stat6 } from "node:fs/promises";
 import * as sp3 from "node:path";
 
 // ../../node_modules/readdirp/index.js
-import { lstat as lstat2, readdir as readdir2, realpath, stat as stat5 } from "node:fs/promises";
+import { lstat as lstat2, readdir as readdir2, realpath, stat as stat4 } from "node:fs/promises";
 import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "node:path";
 import { Readable as Readable6 } from "node:stream";
 var EntryTypes = {
@@ -253671,7 +253610,7 @@ class ReaddirpStream extends Readable6 {
     const { root, type } = opts;
     this._fileFilter = normalizeFilter(opts.fileFilter);
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat2 : stat5;
+    const statMethod = opts.lstat ? lstat2 : stat4;
     if (wantBigintFsStats) {
       this._stat = (path) => statMethod(path, { bigint: true });
     } else {
@@ -253824,7 +253763,7 @@ function readdirp(root, options = {}) {
 
 // ../../node_modules/chokidar/handler.js
 import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
-import { realpath as fsrealpath, lstat as lstat3, open as open2, stat as stat6 } from "node:fs/promises";
+import { realpath as fsrealpath, lstat as lstat3, open as open2, stat as stat5 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp2 from "node:path";
 var STR_DATA = "data";
@@ -253850,7 +253789,7 @@ var EVENTS = {
 };
 var EV = EVENTS;
 var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat3, stat: stat6 };
+var statMethods = { lstat: lstat3, stat: stat5 };
 var KEY_LISTENERS = "listeners";
 var KEY_ERR = "errHandlers";
 var KEY_RAW = "rawEmitters";
@@ -254321,7 +254260,7 @@ class NodeFsHandler {
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats = await stat6(file);
+          const newStats = await stat5(file);
           if (this.fsw.closed)
             return;
           const at = newStats.atimeMs;
@@ -254993,7 +254932,7 @@ class FSWatcher extends EventEmitter3 {
       const fullPath = opts.cwd ? sp3.join(opts.cwd, path) : path;
       let stats;
       try {
-        stats = await stat7(fullPath);
+        stats = await stat6(fullPath);
       } catch (err) {}
       if (!stats || this.closed)
         return;
@@ -255265,7 +255204,7 @@ class WatchBase44 extends EventEmitter4 {
       ignoreInitial: true
     });
     watcher.on("all", import_debounce.default(async (_event, path) => {
-      this.emit("change", name, relative7(targetPath, path));
+      this.emit("change", name, relative9(targetPath, path));
     }, WATCH_DEBOUNCE_MS));
     watcher.on("error", (err) => {
       this.logger.error(`Watch handler failed for ${targetPath}`, err);
@@ -255302,6 +255241,11 @@ async function createDevServer(options) {
     next();
   });
   const devLogger = createDevLogger("backend", theme.styles.info);
+  app.use("/api/apps/:appId/actors", (_req, res) => {
+    const message = "Actors are not available in local development";
+    devLogger.error(message);
+    res.status(500).json({ error: message });
+  });
   const functionManager = await createFunctionRuntime(functions, devLogger, options.denoWrapperPath);
   const functionRoutes = createFunctionRouter(functionManager, devLogger);
   app.use("/api/apps/:appId/functions", functionRoutes);
@@ -255372,8 +255316,8 @@ async function createDevServer(options) {
     broadcastEntityEvent(io, appId, entityName, event);
   };
   const base44ConfigWatcher = new WatchBase44({
-    functions: join37(dirname25(project.configPath), project.functionsDir),
-    entities: join37(dirname25(project.configPath), project.entitiesDir)
+    functions: join36(dirname26(project.configPath), project.functionsDir),
+    entities: join36(dirname26(project.configPath), project.entitiesDir)
   }, devLogger);
   base44ConfigWatcher.on("change", async (name) => {
     try {
@@ -255770,7 +255714,7 @@ Examples:
 }
 
 // src/cli/commands/project/eject.ts
-import { resolve as resolve18 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 var import_kebabCase2 = __toESM(require_kebabCase(), 1);
 async function eject(ctx, options, command) {
   const { log, runTask, isNonInteractive } = ctx;
@@ -255834,7 +255778,7 @@ async function eject(ctx, options, command) {
     Ne("Operation cancelled.");
     throw new CLIExitError(0);
   }
-  const resolvedPath = resolve18(selectedPath);
+  const resolvedPath = resolve17(selectedPath);
   await runTask("Downloading your project's code...", async (updateMessage) => {
     await createProjectFilesForExistingProject({
       projectId,
@@ -255901,7 +255845,7 @@ function createProgram(context) {
   program.addCommand(getScaffoldCommand());
   program.addCommand(getDashboardCommand());
   program.addCommand(getBuildCommand());
-  program.addCommand(getDeployCommand2());
+  program.addCommand(getDeployCommand3());
   program.addCommand(getVisibilityCommand());
   program.addCommand(getLinkCommand());
   program.addCommand(getEjectCommand());
@@ -255911,14 +255855,13 @@ function createProgram(context) {
   program.addCommand(getAgentSkillsCommand());
   program.addCommand(getConnectorsCommand());
   program.addCommand(getFunctionsCommand());
+  program.addCommand(getActorsCommand());
   program.addCommand(getWorkflowsCommand());
   program.addCommand(getSecretsCommand());
   program.addCommand(getSandboxCommand());
   program.addCommand(getBranchesCommand());
   program.addCommand(getAuthCommand());
   program.addCommand(getSiteCommand());
-  program.addCommand(getPublishCommand());
-  program.addCommand(getVersionsCommand());
   program.addCommand(getTypesCommand());
   program.addCommand(getExecCommand());
   program.addCommand(getDevCommand());
@@ -255931,7 +255874,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 dirname26, posix, sep as sep2 } from "path";
+import { dirname as dirname27, posix, sep as sep2 } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -255940,7 +255883,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname26(process.argv[1]) : process.cwd(), isWindows = sep2 === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname27(process.argv[1]) : process.cwd(), isWindows = sep2 === "\\") {
   const normalizedBase = isWindows ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -257975,7 +257918,7 @@ class ReduceableCache {
   }
 }
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/context-lines.node.mjs
-import { createReadStream as createReadStream4 } from "node:fs";
+import { createReadStream as createReadStream3 } from "node:fs";
 import { createInterface as createInterface2 } from "node:readline";
 var LRU_FILE_CONTENTS_CACHE = new ReduceableCache(25);
 var LRU_FILE_CONTENTS_FS_READ_FAILED = new ReduceableCache(20);
@@ -258019,7 +257962,7 @@ async function addSourceContext(frames) {
 }
 function getContextLinesFromFile(path, ranges, output) {
   return new Promise((resolve) => {
-    const stream = createReadStream4(path);
+    const stream = createReadStream3(path);
     const lineReaded = createInterface2({
       input: stream
     });
@@ -259929,9 +259872,9 @@ function addCommandInfoToErrorReporter(program, errorReporter) {
   });
 }
 // src/cli/index.ts
-var __dirname4 = dirname27(fileURLToPath6(import.meta.url));
+var __dirname4 = dirname28(fileURLToPath6(import.meta.url));
 async function runCLI(options) {
-  ensureNpmAssets(join38(__dirname4, "../assets"));
+  ensureNpmAssets(join37(__dirname4, "../assets"));
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
   const jsonMode = process.argv.includes("--json");
@@ -259970,4 +259913,4 @@ export {
   runCLI
 };
 
-//# debugId=8ACC6798F4A12B0564756E2164756E21
+//# debugId=EF36A7D77029953264756E2164756E21