@embeddable.com/sdk-core 4.3.3 → 4.4.0-next.1

package/lib/push.d.ts

@@ -3,6 +3,7 @@ import { ResolvedEmbeddableConfig } from "./defineConfig";
 export declare const CUBE_FILES: RegExp;
 export declare const CLIENT_CONTEXT_FILES: RegExp;
 export declare const SECURITY_CONTEXT_FILES: RegExp;
+export declare const EMBEDDABLE_FILES: RegExp;
 declare const _default: () => Promise<void>;
 export default _default;
 export declare function buildArchive(config: ResolvedEmbeddableConfig): Promise<Ora>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embeddable.com/sdk-core",
-  "version": "4.3.3",
+  "version": "4.4.0-next.1",
   "description": "Core Embeddable SDK module responsible for web-components bundling and publishing.",
   "keywords": [
     "embeddable",

package/src/defineConfig.test.ts

@@ -89,6 +89,7 @@ describe("defineConfig", () => {
         "previewBaseUrl": "previewBaseUrl",
         "pushBaseUrl": "pushBaseUrl",
         "pushComponents": true,
+        "pushEmbeddables": true,
         "pushModels": true,
         "region": "legacy-US",
         "rollbarAccessToken": "rollbarAccessToken",

package/src/defineConfig.ts

@@ -19,6 +19,7 @@ export type EmbeddableConfig = {
   })[];
   pushModels?: boolean;
   pushComponents?: boolean;
+  pushEmbeddables?: boolean;
   pushBaseUrl?: string;
   audienceUrl?: string;
   authDomain?: string;
@@ -83,6 +84,7 @@ export type ResolvedEmbeddableConfig = {
   };
   pushModels: boolean;
   pushComponents: boolean;
+  pushEmbeddables: boolean;
   pushBaseUrl: string;
   audienceUrl: string;
   previewBaseUrl: string;
@@ -107,9 +109,14 @@ export type ResolvedEmbeddableConfig = {
       buildName: string;
       componentsEntryPointFilename: string;
     };
+    pluginFlags?: PluginFlags;
   };
 };
 
+export type PluginFlags = {
+  supportsOnComponentReadyHook: boolean;
+}
+
 const REGION_CONFIGS = {
   EU: {
     pushBaseUrl: "https://api.eu.embeddable.com",
@@ -152,6 +159,7 @@ export const embeddableConfigSchema = z
     ).optional(),
     pushModels: z.boolean().optional(),
     pushComponents: z.boolean().optional(),
+    pushEmbeddables: z.boolean().optional(),
     pushBaseUrl: z.string().optional(),
     audienceUrl: z.string().optional(),
     authDomain: z.string().optional(),
@@ -202,6 +210,7 @@ export default (config: EmbeddableConfig) => {
     pushModels = true,
     starterEmbeddables,
     pushComponents = true,
+    pushEmbeddables = true,
     pushBaseUrl,
     audienceUrl,
     authDomain,
@@ -308,6 +317,7 @@ export default (config: EmbeddableConfig) => {
     starterEmbeddables,
     pushModels,
     pushComponents,
+    pushEmbeddables,
     pushBaseUrl: pushBaseUrl ?? regionConfig.pushBaseUrl,
     audienceUrl: audienceUrl ?? regionConfig.audienceUrl,
     previewBaseUrl: previewBaseUrl ?? regionConfig.previewBaseUrl,

package/src/dev.test.ts

@@ -29,7 +29,8 @@ import { logError } from "./logger";
 import { ResolvedEmbeddableConfig } from "./defineConfig";
 import { RollupWatcher } from "rollup";
 import ora from "ora";
-import { archive } from "./push";
+import { archive, EMBEDDABLE_FILES } from "./push";
+import fg from "fast-glob";
 import { selectWorkspace } from "./workspaceUtils";
 import serveStatic from "serve-static";
 import { createNodeSys } from "@stencil/core/sys/node";
@@ -107,6 +108,8 @@ vi.mock("serve-static", () => ({
   default: vi.fn(() => vi.fn()),
 }));
 
+vi.mock("fast-glob", () => ({ default: vi.fn() }));
+
 vi.mock("./dev", async (importOriginal) => {
   const actual = await importOriginal<typeof dev>();
   return {
@@ -221,6 +224,8 @@ describe("dev command", () => {
       ["mock-model.json", "/mock/root/models/mock-model.json"],
     ]);
 
+    vi.mocked(fg).mockResolvedValue([]);
+
     // Mock fs functions
     vi.mocked(fs.readFile).mockResolvedValue("default content");
     vi.mocked(fs.appendFile).mockResolvedValue(undefined);
@@ -417,6 +422,49 @@ describe("dev command", () => {
         isDev: true,
       });
     });
+
+    it("should include embeddable files in archive when pushEmbeddables is true", async () => {
+      const embeddableConfig = {
+        ...mockConfig,
+        pushEmbeddables: true,
+        client: { ...mockConfig.client, srcDir: "/mock/src" },
+      } as unknown as ResolvedEmbeddableConfig;
+
+      vi.mocked(findFiles).mockImplementation(async (_dir, pattern) => {
+        if (pattern === EMBEDDABLE_FILES) {
+          return [["dashboard.embeddable.yaml", "/mock/src/dashboard.embeddable.yaml"]];
+        }
+        return [["mock-model.json", "/mock/root/models/mock-model.json"]];
+      });
+
+      await sendBuildChanges(embeddableConfig);
+
+      expect(findFiles).toHaveBeenCalledWith("/mock/src", EMBEDDABLE_FILES);
+      expect(archive).toHaveBeenCalledWith(
+        expect.objectContaining({
+          filesList: expect.arrayContaining([
+            ["dashboard.embeddable.yaml", "/mock/src/dashboard.embeddable.yaml"],
+          ]),
+        }),
+      );
+    });
+
+    it("should not call findFiles with EMBEDDABLE_FILES when pushEmbeddables is false", async () => {
+      const embeddableConfig = {
+        ...mockConfig,
+        pushEmbeddables: false,
+        client: { ...mockConfig.client, srcDir: "/mock/src" },
+      } as unknown as ResolvedEmbeddableConfig;
+
+      vi.mocked(findFiles).mockClear();
+
+      await sendBuildChanges(embeddableConfig);
+
+      const embeddableFilesCall = vi.mocked(findFiles).mock.calls.find(
+        (call) => call[1] === EMBEDDABLE_FILES,
+      );
+      expect(embeddableFilesCall).toBeUndefined();
+    });
   });
 
   describe("sendBuildChanges error handling", () => {
@@ -439,7 +487,7 @@ describe("dev command", () => {
       await sendBuildChanges(mockConfig as unknown as ResolvedEmbeddableConfig);
 
       expect(ora().fail).toHaveBeenCalledWith(
-        `Data models and/or security context synchronization failed with error: ${error.message}`,
+        `Data models and/or security context and/or embeddables synchronization failed with error: ${error.message}`,
       );
       expect(mockWss.clients[0].send).toHaveBeenCalledWith(
         JSON.stringify({ type: "dataModelsAndOrSecurityContextUpdateError", error: error.message }),
@@ -447,6 +495,77 @@ describe("dev command", () => {
     });
   });
 
+  describe("cubeSecurityContextAndClientContextWatcher (pushEmbeddables)", () => {
+    it("should call fg with embeddable pattern and pass results to chokidar.watch when pushEmbeddables is true", async () => {
+      const mockEmbeddableFiles = [
+        "/mock/src/dashboard.embeddable.yaml",
+        "/mock/src/report.embeddable.yml",
+      ];
+
+      vi.mocked(fg).mockImplementation(async (pattern: any) => {
+        if (pattern === "**/*.embeddable.{yaml,yml}") {
+          return mockEmbeddableFiles as any;
+        }
+        return [];
+      });
+
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...mockConfig,
+        pushEmbeddables: true,
+        client: { ...mockConfig.client, srcDir: "/mock/src" },
+      } as unknown as ResolvedEmbeddableConfig);
+
+      await dev();
+      await listenMock.mock.calls[0][1]();
+
+      expect(vi.mocked(fg)).toHaveBeenCalledWith(
+        "**/*.embeddable.{yaml,yml}",
+        expect.objectContaining({ cwd: "/mock/src", absolute: true }),
+      );
+
+      expect(chokidar.watch).toHaveBeenCalledWith(
+        expect.arrayContaining(mockEmbeddableFiles),
+        expect.anything(),
+      );
+    });
+
+    it("should not call fg with embeddable pattern when pushEmbeddables is false", async () => {
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...mockConfig,
+        pushEmbeddables: false,
+        client: { ...mockConfig.client, srcDir: "/mock/src" },
+      } as unknown as ResolvedEmbeddableConfig);
+
+      vi.mocked(fg).mockClear();
+
+      await dev();
+      await listenMock.mock.calls[0][1]();
+
+      const embeddableCall = vi.mocked(fg).mock.calls.find(
+        (call) => call[0] === "**/*.embeddable.{yaml,yml}",
+      );
+      expect(embeddableCall).toBeUndefined();
+    });
+
+    it("should not call fg with embeddable pattern when pushEmbeddables is undefined", async () => {
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...mockConfig,
+        // pushEmbeddables not set → undefined → falsy
+        client: { ...mockConfig.client, srcDir: "/mock/src" },
+      } as unknown as ResolvedEmbeddableConfig);
+
+      vi.mocked(fg).mockClear();
+
+      await dev();
+      await listenMock.mock.calls[0][1]();
+
+      const embeddableCall = vi.mocked(fg).mock.calls.find(
+        (call) => call[0] === "**/*.embeddable.{yaml,yml}",
+      );
+      expect(embeddableCall).toBeUndefined();
+    });
+  });
+
   describe("Plugin build coordination", () => {
     it("should handle configs with no plugins when pushComponents is true", async () => {
       vi.mocked(provideConfig).mockResolvedValue({
@@ -984,6 +1103,34 @@ describe("dev command", () => {
 
       process.argv = originalArgv;
     });
+
+    it("should include pushEmbeddables in the dev-workspace request body when true", async () => {
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...mockConfig,
+        pushEmbeddables: true,
+      } as unknown as ResolvedEmbeddableConfig);
+
+      await dev();
+
+      const devWorkspaceCall = vi.mocked(axios.post).mock.calls.find(
+        (call) => String(call[0]).includes("dev-workspace"),
+      );
+      expect(devWorkspaceCall?.[1]).toMatchObject({ pushEmbeddables: true });
+    });
+
+    it("should include pushEmbeddables in the dev-workspace request body when false", async () => {
+      vi.mocked(provideConfig).mockResolvedValue({
+        ...mockConfig,
+        pushEmbeddables: false,
+      } as unknown as ResolvedEmbeddableConfig);
+
+      await dev();
+
+      const devWorkspaceCall = vi.mocked(axios.post).mock.calls.find(
+        (call) => String(call[0]).includes("dev-workspace"),
+      );
+      expect(devWorkspaceCall?.[1]).toMatchObject({ pushEmbeddables: false });
+    });
   });
 
   describe("addToGitignore", () => {

package/src/dev.ts

@@ -28,6 +28,7 @@ import {
   sendBuild,
   SECURITY_CONTEXT_FILES,
   CLIENT_CONTEXT_FILES,
+  EMBEDDABLE_FILES,
 } from "./push";
 import validate from "./validate";
 import { checkNodeVersion } from "./utils";
@@ -494,6 +495,14 @@ const cubeSecurityContextAndClientContextWatcher = async (
     filesToWatch = [...filesToWatch, ...cubeFiles, ...securityContextFiles];
   }
 
+  if (ctx.pushEmbeddables) {
+    const embeddableFiles = await fg("**/*.embeddable.{yaml,yml}", {
+      cwd: ctx.client.srcDir,
+      absolute: true,
+    });
+    filesToWatch = [...filesToWatch, ...embeddableFiles];
+  }
+
   const fsWatcher = chokidar.watch(filesToWatch, chokidarWatchOptions);
 
   fsWatcher.on("all", () => sendBuildChanges(ctx));
@@ -526,7 +535,7 @@ export const sendBuildChanges = async (ctx: ResolvedEmbeddableConfig) => {
   sendMessage("dataModelsAndOrSecurityContextUpdateStart");
 
   const sending = ora(
-    "Synchronising data models and/or security contexts...",
+    "Synchronising data models and/or security contexts and/or embeddables...",
   ).start();
 
   let filesList: [string, string][] = [];
@@ -567,6 +576,21 @@ export const sendBuildChanges = async (ctx: ResolvedEmbeddableConfig) => {
     filesList = [...filesList, ...cubeAndSecurityContextFileList];
   }
 
+  if (ctx.pushEmbeddables) {
+    const embeddableFilesList = await findFiles(
+      ctx.client.srcDir,
+      EMBEDDABLE_FILES,
+    );
+
+    filesList = [
+      ...filesList,
+      ...embeddableFilesList.map((entry): [string, string] => [
+        path.basename(entry[1]),
+        entry[1],
+      ]),
+    ];
+  }
+
   try {
     const token = await getToken();
     await archive({
@@ -578,12 +602,12 @@ export const sendBuildChanges = async (ctx: ResolvedEmbeddableConfig) => {
   } catch (e: any) {
     const errorMessage = e.response?.data?.errorMessage ?? e.message ?? "Unknown error";
     sending.fail(
-      `Data models and/or security context synchronization failed with error: ${errorMessage}`,
+      `Data models and/or security context and/or embeddables synchronization failed with error: ${errorMessage}`,
     );
     return sendMessage("dataModelsAndOrSecurityContextUpdateError", { error: errorMessage });
   }
 
-  sending.succeed(`Data models and/or security context synchronized`);
+  sending.succeed(`Data models and/or security context and/or embeddables synchronized`);
   sendMessage("dataModelsAndOrSecurityContextUpdateSuccess");
 };
 
@@ -637,6 +661,7 @@ const getPreviewWorkspace = async (
         instanceUrl,
         pushModels: ctx.pushModels,
         pushComponents: ctx.pushComponents,
+        pushEmbeddables: ctx.pushEmbeddables,
       },
       {
         headers: {

package/src/generate.test.ts

@@ -254,9 +254,9 @@ describe("generateDTS", () => {
       "embeddable-wrapper.esm.js",
     ] as any);
     vi.mocked(path.resolve).mockImplementation((...args) => args.join("/"));
-    // Template contains both tokens so we can verify replacement
+    // Template contains all tokens so we can verify replacement
     vi.mocked(fs.readFile).mockResolvedValue(
-      "replace-this-with-component-name {{RENDER_IMPORT}}",
+      "replace-this-with-component-name {{RENDER_IMPORT}} {{PLUGIN_FLAGS}}",
     );
     vi.mocked(loadConfig).mockResolvedValue({ config: {} } as any);
     vi.mocked(createCompiler).mockResolvedValue({
@@ -290,6 +290,19 @@ describe("generateDTS", () => {
     );
   });
 
+  it("should replace {{PLUGIN_FLAGS}} token with empty pluginFlags", async () => {
+    await generateDTS(config as unknown as ResolvedEmbeddableConfig);
+
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      "componentDir/component.tsx",
+      expect.stringContaining("const pluginFlags: Partial<PluginFlags> = {}"),
+    );
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      "componentDir/component.tsx",
+      expect.not.stringContaining("{{PLUGIN_FLAGS}}"),
+    );
+  });
+
   it("should call loadConfig with devMode=false and sourceMap=false", async () => {
     await generateDTS(config as unknown as ResolvedEmbeddableConfig);
 
@@ -333,7 +346,7 @@ describe("injectBundleRender cross-platform paths", () => {
 
   beforeEach(() => {
     vi.mocked(path.resolve).mockImplementation((...args) => args.join("/"));
-    vi.mocked(fs.readFile).mockResolvedValue("{{RENDER_IMPORT}}");
+    vi.mocked(fs.readFile).mockResolvedValue("{{RENDER_IMPORT}}\n{{PLUGIN_FLAGS}}");
   });
 
   it("should use forward slashes in import when path.relative returns unix path", async () => {
@@ -363,6 +376,55 @@ describe("injectBundleRender cross-platform paths", () => {
       expect.stringContaining("import render from '../../buildDir/buildName/render.js'"),
     );
   });
+
+  it("should inject pluginFlags from config into component.tsx", async () => {
+    vi.mocked(path.relative).mockReturnValue("../../buildDir/buildName");
+    const ctxWithPluginFlags = {
+      ...ctxWithFileName,
+      "sdk-react": {
+        ...ctxWithFileName["sdk-react"],
+        pluginFlags: { supportsOnComponentReadyHook: true },
+      },
+    };
+
+    await injectBundleRender(
+      ctxWithPluginFlags as unknown as ResolvedEmbeddableConfig,
+      "sdk-react",
+    );
+
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.stringContaining('const pluginFlags: Partial<PluginFlags> = {"supportsOnComponentReadyHook":true}'),
+    );
+  });
+
+  it("should inject empty pluginFlags when not present in config", async () => {
+    vi.mocked(path.relative).mockReturnValue("../../buildDir/buildName");
+
+    await injectBundleRender(
+      ctxWithFileName as unknown as ResolvedEmbeddableConfig,
+      "sdk-react",
+    );
+
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.stringContaining("const pluginFlags: Partial<PluginFlags> = {}"),
+    );
+  });
+
+  it("should not leave {{PLUGIN_FLAGS}} token in output", async () => {
+    vi.mocked(path.relative).mockReturnValue("../../buildDir/buildName");
+
+    await injectBundleRender(
+      ctxWithFileName as unknown as ResolvedEmbeddableConfig,
+      "sdk-react",
+    );
+
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.not.stringContaining("{{PLUGIN_FLAGS}}"),
+    );
+  });
 });
 
 describe("injectCSS cross-platform paths", () => {

package/src/generate.ts

@@ -18,6 +18,7 @@ import type { Logger } from "@stencil/core/internal";
 
 const STYLE_IMPORTS_TOKEN = "{{STYLES_IMPORT}}";
 const RENDER_IMPORT_TOKEN = "{{RENDER_IMPORT}}";
+const PLUGIN_FLAGS_TOKEN = "{{PLUGIN_FLAGS}}";
 
 // stencil doesn't support dynamic component tag name, so we need to replace it manually
 const COMPONENT_TAG_TOKEN = "replace-this-with-component-name";
@@ -166,6 +167,8 @@ export async function injectBundleRender(
     )
     .replaceAll("\\", "/");
   const importStr = `import render from '${importFilePath}/${ctx[pluginName].outputOptions.fileName}';`;
+  const pluginFlags = ctx[pluginName].pluginFlags ?? {};
+  const pluginFlagsStr = `const pluginFlags: Partial<PluginFlags> = ${JSON.stringify(pluginFlags)}`;
 
   let content = await fs.readFile(
     path.resolve(ctx.core.templatesDir, "component.tsx.template"),
@@ -178,7 +181,7 @@ export async function injectBundleRender(
 
   await fs.writeFile(
     path.resolve(ctx.client.componentDir, "component.tsx"),
-    content.replace(RENDER_IMPORT_TOKEN, importStr),
+    content.replace(RENDER_IMPORT_TOKEN, importStr).replace(PLUGIN_FLAGS_TOKEN, pluginFlagsStr),
   );
 }
 
@@ -199,7 +202,7 @@ async function injectBundleRenderStub(
   content = content.replace(COMPONENT_TAG_TOKEN, "embeddable-component");
   await fs.writeFile(
     path.resolve(ctx.client.componentDir, "component.tsx"),
-    content.replace(RENDER_IMPORT_TOKEN, stubStr),
+    content.replace(RENDER_IMPORT_TOKEN, stubStr).replace(PLUGIN_FLAGS_TOKEN, "const pluginFlags: Partial<PluginFlags> = {}"),
   );
 }
 

package/src/index.ts

@@ -4,4 +4,4 @@ export { default as push } from "./push";
 export { default as dev } from "./dev";
 export { default as defineConfig } from "./defineConfig";
 export { default as buildPackage } from "./buildPackage";
-export type { ResolvedEmbeddableConfig } from "./defineConfig";
+export type { ResolvedEmbeddableConfig, PluginFlags } from "./defineConfig";

package/src/push.test.ts

@@ -1,4 +1,4 @@
-import push, { buildArchive } from "./push";
+import push, { buildArchive, EMBEDDABLE_FILES, sendBuild, sendBuildByApiKey } from "./push";
 import provideConfig from "./provideConfig";
 import { fileFromPath } from "formdata-node/file-from-path";
 import * as path from "path";
@@ -222,18 +222,19 @@ describe("push", () => {
   });
 
   describe("push configuration", () => {
-    it("should fail if both pushModels and pushComponents are disabled", async () => {
+    it("should fail if pushModels, pushComponents, and pushEmbeddables are all disabled", async () => {
       vi.spyOn(console, "error").mockImplementation(() => undefined);
       vi.mocked(provideConfig).mockResolvedValue({
         ...config,
         pushModels: false,
         pushComponents: false,
+        pushEmbeddables: false,
       } as ResolvedEmbeddableConfig);
 
       await push();
 
       expect(startMock.fail).toHaveBeenCalledWith(
-        "Cannot push: both pushModels and pushComponents are disabled"
+        "Cannot push: pushModels, pushComponents, and pushEmbeddables are all disabled"
       );
       expect(process.exit).toHaveBeenCalledWith(1);
     });
@@ -633,5 +634,164 @@ describe("push", () => {
       expect(findFiles).toHaveBeenCalledWith("/src", expect.any(RegExp));
       expect(findFiles).toHaveBeenCalledWith("/src", expect.any(RegExp));
     });
+
+    it("should include embeddable files when pushEmbeddables is true", async () => {
+      vi.mocked(findFiles)
+        .mockResolvedValueOnce([]) // cube files
+        .mockResolvedValueOnce([]) // security context files
+        .mockResolvedValueOnce([]) // client context files
+        .mockResolvedValueOnce([
+          ["dashboard.embeddable.yaml", "/src/dashboard.embeddable.yaml"],
+          ["report.embeddable.yml", "/src/report.embeddable.yml"],
+        ]); // embeddable files
+
+      const testConfig = {
+        ...config,
+        pushModels: true,
+        pushComponents: true,
+        pushEmbeddables: true,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      expect(findFiles).toHaveBeenCalledWith("/src", EMBEDDABLE_FILES);
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
+        "/src/dashboard.embeddable.yaml",
+        "dashboard.embeddable.yaml",
+        expect.objectContaining({ compress: true }),
+      );
+      expect(mockZipLocal.addFile).toHaveBeenCalledWith(
+        "/src/report.embeddable.yml",
+        "report.embeddable.yml",
+        expect.objectContaining({ compress: true }),
+      );
+    });
+
+    it("should not search for embeddable files when pushEmbeddables is false", async () => {
+      // Reset call history to avoid interference from previous tests
+      vi.mocked(findFiles).mockClear();
+
+      const testConfig = {
+        ...config,
+        pushModels: true,
+        pushComponents: true,
+        pushEmbeddables: false,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      // findFiles should have been called for models and components but NOT for embeddable files
+      const embeddableFilesCall = vi
+        .mocked(findFiles)
+        .mock.calls.find((call) => call[1] === EMBEDDABLE_FILES);
+      expect(embeddableFilesCall).toBeUndefined();
+    });
+
+    it("should exit when all three push flags are disabled", async () => {
+      vi.spyOn(process, "exit").mockImplementation(() => null as never);
+
+      const testConfig = {
+        ...config,
+        pushModels: false,
+        pushComponents: false,
+        pushEmbeddables: false,
+        client: {
+          ...config.client,
+          srcDir: "/src",
+        },
+      } as ResolvedEmbeddableConfig;
+
+      await buildArchive(testConfig);
+
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe("EMBEDDABLE_FILES", () => {
+    it("should match .embeddable.yaml files", () => {
+      expect(EMBEDDABLE_FILES.test("my-dashboard.embeddable.yaml")).toBe(true);
+      expect(EMBEDDABLE_FILES.test("src/dashboards/sales.embeddable.yaml")).toBe(
+        true,
+      );
+    });
+
+    it("should match .embeddable.yml files", () => {
+      expect(EMBEDDABLE_FILES.test("my-dashboard.embeddable.yml")).toBe(true);
+      expect(EMBEDDABLE_FILES.test("src/widgets/chart.embeddable.yml")).toBe(
+        true,
+      );
+    });
+
+    it("should not match unrelated yaml files", () => {
+      expect(EMBEDDABLE_FILES.test("config.yaml")).toBe(false);
+      expect(EMBEDDABLE_FILES.test("my-dashboard.cc.yaml")).toBe(false);
+      expect(EMBEDDABLE_FILES.test("my-dashboard.sc.yaml")).toBe(false);
+    });
+
+    it("should not match cube files", () => {
+      expect(EMBEDDABLE_FILES.test("my-model.cube.yaml")).toBe(false);
+      expect(EMBEDDABLE_FILES.test("my-model.cube.yml")).toBe(false);
+    });
+
+    it("should not match non-yaml extensions", () => {
+      expect(EMBEDDABLE_FILES.test("my-dashboard.embeddable.json")).toBe(false);
+      expect(EMBEDDABLE_FILES.test("my-dashboard.embeddable.ts")).toBe(false);
+    });
+  });
+
+  describe.each([
+    {
+      label: "sendBuild",
+      endpoint: "**/bundle/:workspaceId/upload",
+      invoke: (testConfig: ResolvedEmbeddableConfig) =>
+        sendBuild(testConfig, { workspaceId: "test-workspace", token: "test-token" }),
+    },
+    {
+      label: "sendBuildByApiKey",
+      endpoint: "**/bundle/upload",
+      invoke: (testConfig: ResolvedEmbeddableConfig) =>
+        sendBuildByApiKey(testConfig, { apiKey: "test-api-key", email: "test@example.com" }),
+    },
+  ])("$label", ({ endpoint, invoke }) => {
+    async function captureMetadata(pushEmbeddables: boolean) {
+      let capturedMetadata: Record<string, any> | undefined;
+
+      server.use(
+        http.post(endpoint, async ({ request }) => {
+          const formData = await request.formData();
+          const requestBlob = formData.get("request") as Blob;
+          capturedMetadata = JSON.parse(await requestBlob.text());
+          return HttpResponse.json({ bundleId: "mocked-bundle-id" });
+        }),
+      );
+
+      const testConfig = {
+        ...config,
+        pushEmbeddables,
+        region: "us",
+        starterEmbeddables: {},
+      } as unknown as ResolvedEmbeddableConfig;
+
+      await invoke(testConfig);
+      return capturedMetadata;
+    }
+
+    it("should include pushEmbeddables in form data metadata when true", async () => {
+      const metadata = await captureMetadata(true);
+      expect(metadata?.pushEmbeddables).toBe(true);
+    });
+
+    it("should include pushEmbeddables in form data metadata when false", async () => {
+      const metadata = await captureMetadata(false);
+      expect(metadata?.pushEmbeddables).toBe(false);
+    });
   });
 });