@tinybirdco/sdk 0.0.80 → 0.0.82

package/src/api/deploy.ts

@@ -10,6 +10,19 @@ import { tinybirdFetch } from "./fetcher.js";
 const FORWARD_CLASSIC_GUIDANCE =
   "Use the Tinybird Classic CLI (`tb`) from a Tinybird Classic workspace for this operation.";
 
+/**
+ * Poll interval used while waiting for a deployment to reach `data_ready`
+ * (and, when auto-promoting, `live`). Matches the Tinybird CLI (`tb deploy`).
+ */
+const POLL_INTERVAL_MS = 5_000;
+
+/**
+ * How many consecutive `failed` status polls to tolerate before giving up.
+ * With a 5s poll interval this is ~5 minutes, matching the CLI safety valve
+ * for deployments that fail but never auto-delete.
+ */
+export const MAX_CONSECUTIVE_FAILED_POLLS = 60;
+
 /**
  * Feedback item from deployment response
  */
@@ -87,8 +100,10 @@ export interface DeploymentStatusResponse {
  *
  * Uses the /v1/deploy endpoint which accepts all resources in a single
  * multipart form request. After creating the deployment, this function:
- * 1. Polls until the deployment is ready (status === 'data_ready')
- * 2. Sets the deployment as live via /v1/deployments/{id}/set-live
+ * 1. When `auto` is true (default), sends `auto_promote=true` so the
+ *    server promotes the deployment as soon as it's ready.
+ * 2. When `wait` is true (default), polls until the deployment reaches
+ *    `data_ready` (and, if `auto` is also true, until it becomes live).
  *
  * @param config - Build configuration with API URL and token
  * @param resources - Generated resources to deploy
@@ -139,6 +154,8 @@ export interface DeploymentChanges {
 export interface DeployCallbacks {
   /** Called when deployment is created and changes are available */
   onChanges?: (changes: DeploymentChanges) => void;
+  /** Called when deployment was submitted but wait was disabled */
+  onDeploymentSubmitted?: (deploymentId: string) => void;
   /** Called when waiting for deployment to be ready */
   onWaitingForReady?: () => void;
   /** Called when deployment is ready */
@@ -158,18 +175,17 @@ export async function deployToMain(
   resources: GeneratedResources,
   options?: {
     debug?: boolean;
-    pollIntervalMs?: number;
-    maxPollAttempts?: number;
     check?: boolean;
     allowDestructiveOperations?: boolean;
+    wait?: boolean;
+    auto?: boolean;
     callbacks?: DeployCallbacks;
   }
 ): Promise<BuildApiResult> {
   const debug = options?.debug ?? !!process.env.TINYBIRD_DEBUG;
-  const pollIntervalMs = options?.pollIntervalMs ?? 1000;
-  const maxPollAttempts = options?.maxPollAttempts ?? 120; // 2 minutes max
+  const wait = options?.wait ?? true;
+  const auto = options?.auto ?? true;
   const baseUrl = config.baseUrl.replace(/\/$/, "");
-  let previousLiveDeploymentId: string | undefined;
 
   const formData = new FormData();
 
@@ -231,10 +247,6 @@ export async function deployToMain(
 
       if (deploymentsResponse.ok) {
         const deploymentsBody = (await deploymentsResponse.json()) as DeploymentsListResponse;
-        const previousLiveDeployment = deploymentsBody.deployments.find(
-          (d) => d.live || d.status === "live"
-        );
-        previousLiveDeploymentId = previousLiveDeployment?.id;
         const staleDeployments = deploymentsBody.deployments.filter(
           (d) => !d.live && d.status !== "live"
         );
@@ -264,6 +276,9 @@ export async function deployToMain(
   const urlParams = new URLSearchParams();
   if (options?.check) {
     urlParams.set("check", "true");
+  } else if (auto) {
+    // Server will auto-promote the deployment when it's ready
+    urlParams.set("auto_promote", "true");
   }
   if (options?.allowDestructiveOperations) {
     urlParams.set("allow_destructive_operations", "true");
@@ -431,18 +446,67 @@ export async function deployToMain(
     });
   }
 
-  // Step 2: Poll until deployment is ready
+  const deploymentChanges = {
+    pipes: {
+      changed: deploymentDetails.changed_pipe_names ?? [],
+      created: deploymentDetails.new_pipe_names ?? [],
+      deleted: deploymentDetails.deleted_pipe_names ?? [],
+    },
+    datasources: {
+      changed: deploymentDetails.changed_datasource_names ?? [],
+      created: deploymentDetails.new_datasource_names ?? [],
+      deleted: deploymentDetails.deleted_datasource_names ?? [],
+    },
+  };
+
+  // If we're not waiting, return as soon as the server accepted the deployment.
+  if (!wait) {
+    options?.callbacks?.onDeploymentSubmitted?.(deploymentId);
+    return {
+      success: true,
+      result: "success",
+      datasourceCount: resources.datasources.length,
+      pipeCount: resources.pipes.length,
+      connectionCount: resources.connections?.length ?? 0,
+      buildId: deploymentId,
+      ...deploymentChanges,
+    };
+  }
+
+  // Step 2: Poll until the deployment reaches a terminal state.
   let deployment = body.deployment;
-  let attempts = 0;
+  let timesSeenFailed = 0;
+  let notifiedReady = false;
+  let notifiedWaitingForPromote = false;
 
   options?.callbacks?.onWaitingForReady?.();
 
-  while (deployment.status !== "data_ready" && attempts < maxPollAttempts) {
-    await sleep(pollIntervalMs);
-    attempts++;
+  const isDone = (): boolean => {
+    if (deployment.status !== "data_ready") {
+      return false;
+    }
+    if (auto) {
+      // When auto-promoting we must also wait for the server to flip it live.
+      return deployment.live === true;
+    }
+    return true;
+  };
+
+  const buildError = (message: string): BuildApiResult => ({
+    success: false,
+    result: "failed",
+    error: message,
+    datasourceCount: resources.datasources.length,
+    pipeCount: resources.pipes.length,
+    connectionCount: resources.connections?.length ?? 0,
+    buildId: deploymentId,
+  });
+
+  while (!isDone()) {
+    await sleep(POLL_INTERVAL_MS);
 
     if (debug) {
-      console.log(`[debug] Polling deployment status (attempt ${attempts})...`);
+      console.log(`[debug] Polling deployment status...`);
     }
 
     const statusUrl = `${baseUrl}/v1/deployments/${deploymentId}`;
@@ -453,114 +517,72 @@ export async function deployToMain(
     });
 
     if (!statusResponse.ok) {
-      return {
-        success: false,
-        result: "failed",
-        error: `Failed to check deployment status: ${statusResponse.status} ${statusResponse.statusText}`,
-        datasourceCount: resources.datasources.length,
-        pipeCount: resources.pipes.length,
-        connectionCount: resources.connections?.length ?? 0,
-        buildId: deploymentId,
-      };
+      return buildError(
+        `Failed to check deployment status: ${statusResponse.status} ${statusResponse.statusText}`
+      );
     }
 
     const statusBody = (await statusResponse.json()) as DeploymentStatusResponse;
     deployment = statusBody.deployment;
 
     if (debug) {
-      console.log(`[debug] Deployment status: ${deployment.status}`);
+      console.log(
+        `[debug] Deployment status: ${deployment.status} (live=${deployment.live ?? false})`
+      );
     }
 
-    // Check for failed status
-    if (deployment.status === "failed" || deployment.status === "error") {
-      return {
-        success: false,
-        result: "failed",
-        error: `Deployment failed with status: ${deployment.status}`,
-        datasourceCount: resources.datasources.length,
-        pipeCount: resources.pipes.length,
-        connectionCount: resources.connections?.length ?? 0,
-        buildId: deploymentId,
-      };
+    if (deployment.status === "failed") {
+      timesSeenFailed++;
+      if (timesSeenFailed > MAX_CONSECUTIVE_FAILED_POLLS) {
+        return buildError(
+          "Deployment failed to create and didn't start deleting automatically after 5 minutes. " +
+            "You might need to delete it manually in the UI."
+        );
+      }
+      continue;
     }
-  }
-
-  if (deployment.status !== "data_ready") {
-    return {
-      success: false,
-      result: "failed",
-      error: `Deployment timed out after ${maxPollAttempts} attempts. Last status: ${deployment.status}`,
-      datasourceCount: resources.datasources.length,
-      pipeCount: resources.pipes.length,
-      connectionCount: resources.connections?.length ?? 0,
-      buildId: deploymentId,
-    };
-  }
 
-  options?.callbacks?.onDeploymentReady?.();
-
-  // Step 3: Set the deployment as live
-  const setLiveUrl = `${baseUrl}/v1/deployments/${deploymentId}/set-live`;
-
-  if (debug) {
-    console.log(`[debug] POST ${setLiveUrl}`);
-  }
-
-  const setLiveResponse = await tinybirdFetch(setLiveUrl, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${config.token}`,
-    },
-  });
+    if (deployment.status === "deleting" || deployment.status === "deleted") {
+      const errors = deployment.feedback
+        ?.filter((f) => f.level === "ERROR")
+        .map((f) => f.message)
+        .join("\n");
+      const errorSuffix = errors ? `\n${errors}` : "";
+      return buildError(
+        `Deployment failed and ${
+          deployment.status === "deleting" ? "is being" : "was"
+        } deleted automatically.${errorSuffix}`
+      );
+    }
 
-  if (!setLiveResponse.ok) {
-    const setLiveBody = await setLiveResponse.text();
-    return {
-      success: false,
-      result: "failed",
-      error: `Failed to set deployment as live: ${setLiveResponse.status} ${setLiveResponse.statusText}\n${setLiveBody}`,
-      datasourceCount: resources.datasources.length,
-      pipeCount: resources.pipes.length,
-      connectionCount: resources.connections?.length ?? 0,
-      buildId: deploymentId,
-    };
+    if (
+      auto &&
+      deployment.status === "data_ready" &&
+      !deployment.live &&
+      !notifiedWaitingForPromote
+    ) {
+      if (!notifiedReady) {
+        options?.callbacks?.onDeploymentReady?.();
+        notifiedReady = true;
+      }
+      options?.callbacks?.onWaitingForPromote?.();
+      notifiedWaitingForPromote = true;
+    }
   }
 
-  if (debug) {
-    console.log(`[debug] Deployment ${deploymentId} is now live`);
+  if (!notifiedReady) {
+    options?.callbacks?.onDeploymentReady?.();
+    notifiedReady = true;
   }
 
-  if (previousLiveDeploymentId && previousLiveDeploymentId !== deploymentId) {
+  if (auto) {
     if (debug) {
-      console.log(`[debug] Removing previous deployment: ${previousLiveDeploymentId}`);
-    }
-
-    const deletePreviousResponse = await tinybirdFetch(
-      `${baseUrl}/v1/deployments/${previousLiveDeploymentId}`,
-      {
-        method: "DELETE",
-        headers: {
-          Authorization: `Bearer ${config.token}`,
-        },
-      }
-    );
-
-    if (!deletePreviousResponse.ok) {
-      const deletePreviousBody = await deletePreviousResponse.text();
-      return {
-        success: false,
-        result: "failed",
-        error: `Failed to remove previous deployment: ${deletePreviousResponse.status} ${deletePreviousResponse.statusText}\n${deletePreviousBody}`,
-        datasourceCount: resources.datasources.length,
-        pipeCount: resources.pipes.length,
-        connectionCount: resources.connections?.length ?? 0,
-        buildId: deploymentId,
-      };
+      console.log(`[debug] Deployment ${deploymentId} is now live`);
     }
+    options?.callbacks?.onDeploymentPromoted?.();
+    options?.callbacks?.onDeploymentLive?.(deploymentId);
   }
 
-  options?.callbacks?.onDeploymentLive?.(deploymentId);
-
   return {
     success: true,
     result: "success",
@@ -568,16 +590,7 @@ export async function deployToMain(
     pipeCount: resources.pipes.length,
     connectionCount: resources.connections?.length ?? 0,
     buildId: deploymentId,
-    pipes: {
-      changed: deploymentDetails.changed_pipe_names ?? [],
-      created: deploymentDetails.new_pipe_names ?? [],
-      deleted: deploymentDetails.deleted_pipe_names ?? [],
-    },
-    datasources: {
-      changed: deploymentDetails.changed_datasource_names ?? [],
-      created: deploymentDetails.new_datasource_names ?? [],
-      deleted: deploymentDetails.deleted_datasource_names ?? [],
-    },
+    ...deploymentChanges,
   };
 }
 

package/src/cli/commands/build.ts

@@ -225,10 +225,9 @@ export async function runBuild(options: BuildCommandOptions = {}): Promise<Build
         console.log(`[debug] Getting/creating Tinybird branch: ${config.tinybirdBranch}`);
       }
       try {
-        const branchDataMode: BranchDataMode | undefined =
-          options.lastPartition || config.branchDataMode === "last_partition"
-            ? "last_partition"
-            : undefined;
+        const branchDataMode: BranchDataMode | undefined = options.lastPartition
+          ? "last_partition"
+          : config.branchDataMode ?? undefined;
         const branchOptions = branchDataMode
           ? { branch_data_mode: branchDataMode }
           : undefined;

package/src/cli/commands/clear.ts

@@ -149,8 +149,8 @@ async function clearCloudBranch(config: ResolvedConfig): Promise<ClearResult> {
 
     // Clear the branch (delete and recreate)
     const branchOptions: CreateBranchOptions | undefined =
-      config.devMode !== "local" && config.branchDataMode === "last_partition"
-        ? { branch_data_mode: "last_partition" }
+      config.devMode !== "local" && config.branchDataMode
+        ? { branch_data_mode: config.branchDataMode }
         : undefined;
 
     const newBranch = await clearBranch(

package/src/cli/commands/deploy.ts

@@ -19,6 +19,14 @@ export interface DeployCommandOptions {
   check?: boolean;
   /** Allow deleting existing resources in main workspace deploys */
   allowDestructiveOperations?: boolean;
+  /**
+   * Wait for the deployment to finish. Defaults to true.
+   */
+  wait?: boolean;
+  /**
+   * Auto-promote the deployment when it's ready. Defaults to true.
+   */
+  auto?: boolean;
   /** Callbacks for deploy progress */
   callbacks?: DeployCallbacks;
 }
@@ -106,6 +114,8 @@ export async function runDeploy(options: DeployCommandOptions = {}): Promise<Dep
       {
         check: options.check,
         allowDestructiveOperations: options.allowDestructiveOperations,
+        wait: options.wait,
+        auto: options.auto,
         callbacks: options.callbacks,
       }
     );

package/src/cli/commands/dev.ts

@@ -240,10 +240,9 @@ export async function runDev(
     // Use tinybirdBranch (sanitized name) for Tinybird API, gitBranch for display
     if (config.tinybirdBranch) {
       const branchName = config.tinybirdBranch; // Sanitized name for Tinybird
-      const branchDataMode: BranchDataMode | undefined =
-        options.lastPartition || config.branchDataMode === "last_partition"
-          ? "last_partition"
-          : undefined;
+      const branchDataMode: BranchDataMode | undefined = options.lastPartition
+        ? "last_partition"
+        : config.branchDataMode ?? undefined;
       const branchOptions = branchDataMode
         ? { branch_data_mode: branchDataMode }
         : undefined;

package/src/cli/commands/preview.test.ts

@@ -120,6 +120,52 @@ describe("Preview command", () => {
       );
     });
 
+    it("creates cloud preview branch without data when branch_data_mode is not set", async () => {
+      const { loadConfigAsync } = await import("../config.js");
+      const { buildFromInclude } = await import("../../generator/index.js");
+      const { getBranch, createBranch } = await import("../../api/branches.js");
+      const { deployToMain } = await import("../../api/deploy.js");
+
+      vi.mocked(loadConfigAsync).mockResolvedValue({
+        include: ["test.ts"],
+        token: "p.test-token",
+        baseUrl: "https://api.tinybird.co",
+        configPath: "/test/tinybird.config.json",
+        devMode: "branch",
+        cwd: "/test",
+        gitBranch: "feature-test",
+        tinybirdBranch: "feature_test",
+        isMainBranch: false,
+        branchDataMode: null,
+      });
+      vi.mocked(buildFromInclude).mockResolvedValue({
+        resources: { datasources: [], pipes: [], connections: [] },
+        entities: { datasources: {}, pipes: {}, connections: {}, rawDatasources: [], rawPipes: [], sourceFiles: [] },
+        stats: { datasourceCount: 0, pipeCount: 0, connectionCount: 0 },
+      });
+      vi.mocked(getBranch).mockRejectedValue(new Error("not found"));
+      vi.mocked(createBranch).mockResolvedValue({
+        id: "b1",
+        name: "tmp_ci_feature_test",
+        token: "p.branch",
+        created_at: "2024-01-01T00:00:00Z",
+      });
+      vi.mocked(deployToMain).mockResolvedValue({
+        success: true,
+        result: "success",
+        datasourceCount: 0,
+        pipeCount: 0,
+        connectionCount: 0,
+      });
+
+      await runPreview();
+      expect(createBranch).toHaveBeenCalledWith(
+        expect.any(Object),
+        "tmp_ci_feature_test",
+        undefined
+      );
+    });
+
     it("ignores config branch_data_mode in local mode", async () => {
       const { loadConfigAsync } = await import("../config.js");
       const { buildFromInclude } = await import("../../generator/index.js");

package/src/cli/commands/preview.ts

@@ -227,8 +227,8 @@ export async function runPreview(options: PreviewCommandOptions = {}): Promise<P
   try {
     const apiConfig = { baseUrl: config.baseUrl, token: config.token };
     const branchOptions: CreateBranchOptions | undefined =
-      config.branchDataMode === "last_partition"
-        ? { branch_data_mode: "last_partition" }
+      config.branchDataMode
+        ? { branch_data_mode: config.branchDataMode }
         : undefined;
 
     // Check if branch already exists and delete it for a fresh start

package/src/cli/config-types.ts

@@ -28,6 +28,9 @@ export interface TinybirdConfig {
   baseUrl?: string;
   /** Development mode: "branch" (default) or "local" */
   devMode?: DevMode;
-  /** Branch data mode applied on cloud branch creation (shared snake_case key) */
+  /**
+   * Branch data mode applied on cloud branch creation (shared snake_case key,
+   * also read by the tb CLI). Omit to create branches without data (default).
+   */
   branch_data_mode?: BranchDataMode;
 }

package/src/cli/config.test.ts

@@ -343,7 +343,23 @@ describe("Config", () => {
       expect(result.branchDataMode).toBe("last_partition");
     });
 
-    it("defaults branch_data_mode to last_partition when missing", () => {
+    it("throws when branch_data_mode is none", () => {
+      const config = {
+        include: ["lib/datasources.ts"],
+        token: "test-token",
+        branch_data_mode: "none",
+      };
+      fs.writeFileSync(
+        path.join(tempDir, "tinybird.json"),
+        JSON.stringify(config)
+      );
+
+      expect(() => loadConfig(tempDir)).toThrow(
+        "Invalid branch_data_mode 'none'. Allowed values are: last_partition."
+      );
+    });
+
+    it("defaults branch_data_mode to no data when missing", () => {
       const config = {
         include: ["lib/datasources.ts"],
         token: "test-token",
@@ -354,10 +370,10 @@ describe("Config", () => {
       );
 
       const result = loadConfig(tempDir);
-      expect(result.branchDataMode).toBe("last_partition");
+      expect(result.branchDataMode).toBeNull();
     });
 
-    it("defaults empty branch_data_mode to last_partition", () => {
+    it("defaults empty branch_data_mode to no data", () => {
       const config = {
         include: ["lib/datasources.ts"],
         token: "test-token",
@@ -369,7 +385,7 @@ describe("Config", () => {
       );
 
       const result = loadConfig(tempDir);
-      expect(result.branchDataMode).toBe("last_partition");
+      expect(result.branchDataMode).toBeNull();
     });
 
     it("throws when branch_data_mode is all_partitions", () => {

package/src/cli/config.ts

@@ -17,7 +17,6 @@ export {
 import { BRANCH_DATA_MODE_VALUES } from "./config-types.js";
 import type { BranchDataMode, DevMode, TinybirdConfig } from "./config-types.js";
 
-const DEFAULT_BRANCH_DATA_MODE: BranchDataMode = "last_partition";
 
 /**
  * Resolved configuration with all values expanded
@@ -41,7 +40,7 @@ export interface ResolvedConfig {
   isMainBranch: boolean;
   /** Development mode: "branch" or "local" */
   devMode: DevMode;
-  /** Branch data mode configured in tinybird.config.json */
+  /** Branch data mode configured in tinybird.config.json (null = create branches without data, the default) */
   branchDataMode?: BranchDataMode | null;
 }
 
@@ -212,10 +211,10 @@ function resolveBranchDataMode(raw: Record<string, unknown>): { mode: BranchData
   }
 
   const value = raw["branch_data_mode"];
-  if (value === undefined || value === null) return { mode: DEFAULT_BRANCH_DATA_MODE, explicit: false };
+  if (value === undefined || value === null) return { mode: null, explicit: false };
   if (typeof value !== "string") throw new Error("branch_data_mode must be a string.");
   const mode = value.trim().toLowerCase();
-  if (!mode) return { mode: DEFAULT_BRANCH_DATA_MODE, explicit: false };
+  if (!mode) return { mode: null, explicit: false };
   if (!BRANCH_DATA_MODE_VALUES.includes(mode as BranchDataMode)) {
     throw new Error(
       `Invalid branch_data_mode '${value}'. Allowed values are: ${BRANCH_DATA_MODE_VALUES.join(", ")}.`

package/src/cli/index.ts

@@ -482,18 +482,33 @@ function createCli(): Command {
       "--allow-destructive-operations",
       "Allow deploys that delete existing datasources, pipes, or connections"
     )
+    .option("--wait", "Wait for the deployment to finish (default)")
+    .option("--no-wait", "Return as soon as the deployment is submitted")
+    .option(
+      "--auto",
+      "Auto-promote the deployment when it's ready (default)"
+    )
+    .option(
+      "--no-auto",
+      "Do not auto-promote the deployment; leave it staged for a manual promote"
+    )
     .option("--debug", "Show debug output including API requests/responses")
     .action(async (options) => {
       if (options.debug) {
         process.env.TINYBIRD_DEBUG = "1";
       }
 
+      const wait = options.wait !== false;
+      const auto = options.auto !== false;
+
       output.highlight("Deploying to main workspace...");
 
       const result = await runDeploy({
         dryRun: options.dryRun,
         check: options.check,
         allowDestructiveOperations: options.allowDestructiveOperations,
+        wait,
+        auto,
         callbacks: {
           onChanges: (deployChanges) => {
             // Show changes table immediately after deployment is created
@@ -531,8 +546,11 @@ function createCli(): Command {
 
             output.showChangesTable(changes);
           },
+          onDeploymentSubmitted: (id) => output.showDeploymentSubmitted(id, auto),
           onWaitingForReady: () => output.showWaitingForDeployment(),
           onDeploymentReady: () => output.showDeploymentReady(),
+          onWaitingForPromote: () => output.showWaitingForPromote(),
+          onDeploymentPromoted: () => output.showDeploymentPromoted(),
           onDeploymentLive: (id) => output.showDeploymentLive(id),
           onValidating: () => output.showValidatingDeployment(),
         },

package/src/cli/output.ts

@@ -218,6 +218,30 @@ export function showDeploymentLive(deploymentId: string): void {
   success(`✓ Deployment #${deploymentId} is live!`);
 }
 
+/**
+ * Show waiting for deployment promotion message
+ */
+export function showWaitingForPromote(): void {
+  info("» Waiting for deployment to be promoted...");
+}
+
+/**
+ * Show deployment submitted message (used when --no-wait is set)
+ */
+export function showDeploymentSubmitted(deploymentId: string, autoPromote: boolean): void {
+  const autoFrag = autoPromote
+    ? " It will be auto-promoted when ready."
+    : " It won't be auto-promoted when ready.";
+  success(`✓ Deployment #${deploymentId} submitted.${autoFrag}`);
+}
+
+/**
+ * Show deployment promoted message
+ */
+export function showDeploymentPromoted(): void {
+  success("✓ Deployment promoted");
+}
+
 /**
  * Show validating deployment message
  */
@@ -424,6 +448,9 @@ export const output = {
   showNoChanges,
   showWaitingForDeployment,
   showDeploymentReady,
+  showWaitingForPromote,
+  showDeploymentPromoted,
+  showDeploymentSubmitted,
   showDeploymentLive,
   showValidatingDeployment,
   showDeploySuccess,

package/src/client/base.ts

@@ -342,8 +342,8 @@ export class TinybirdClient {
 
       const branchName = config.tinybirdBranch;
       const branchOptions: CreateBranchOptions | undefined =
-        config.devMode !== "local" && config.branchDataMode === "last_partition"
-          ? { branch_data_mode: "last_partition" }
+        config.devMode !== "local" && config.branchDataMode
+          ? { branch_data_mode: config.branchDataMode }
           : undefined;
 
       // Get or create branch (always fetch fresh to avoid stale cache issues)