@hubspot/ui-extensions-dev-server 1.2.0 → 2.0.0

package/dist/lib/DevModeParentInterface.js

@@ -31,18 +31,17 @@ export class DevModeParentInterface {
     _getPlatformVersion(projectConfig) {
         const { platformVersion } = projectConfig ?? {};
         if (!platformVersion) {
-            return PLATFORM_VERSION.V20231;
+            return PLATFORM_VERSION.V20251;
         }
         switch (platformVersion) {
-            case PLATFORM_VERSION.V20231:
-                return PLATFORM_VERSION.V20231;
-            case PLATFORM_VERSION.V20232:
-                return PLATFORM_VERSION.V20232;
             case PLATFORM_VERSION.V20251:
                 return PLATFORM_VERSION.V20251;
             case PLATFORM_VERSION.V20252:
-            case PLATFORM_VERSION.UNSTABLE:
                 return PLATFORM_VERSION.V20252;
+            case PLATFORM_VERSION.V202603:
+            case PLATFORM_VERSION.V202603BETA:
+            case PLATFORM_VERSION.UNSTABLE:
+                return PLATFORM_VERSION.V202603;
             default:
                 return throwUnhandledPlatformVersionError(platformVersion);
         }

package/dist/lib/DevModeUnifiedInterface.js

@@ -30,6 +30,7 @@ class DevModeUnifiedInterface extends DevModeParentInterface {
         const appData = components[appUid];
         // Use the app data to generate the app config in the expected shape, to match old projects.
         const appConfig = {
+            unified: true,
             name: appData.config.name,
             description: appData.config?.description,
             uid: appData.uid,
@@ -39,9 +40,8 @@ class DevModeUnifiedInterface extends DevModeParentInterface {
                 },
             },
             auth: appData.config?.auth,
+            distribution: appData.config?.distribution,
             support: appData.config?.support,
-            // All unified apps are currently "public" meaning they don't support serverless and do support a proxy.
-            // The determination of what is "public" and "private" as it relates to our usage is still up in the air.
             isPublicApp: true,
             allowedUrls: appData.config?.permittedUrls
                 ? Object.values(appData.config.permittedUrls).flat()

package/dist/lib/DevServerState.d.ts

@@ -1,5 +1,6 @@
-import { AppConfig, ExtensionOutputConfig, ExtensionMetadata, Logger, PlatformVersion } from './types.ts';
-import { ServiceConfiguration, ProxyServiceConfig } from './app-functions/types.ts';
+import { AppConfig, UnifiedAppConfig, UnifiedAppDistribution, ExtensionOutputConfig, ExtensionMetadata, Logger, PlatformVersion } from './types.ts';
+import { ServiceConfiguration } from './serverless/types.ts';
+import { ProxyServiceConfig } from './proxy/types.ts';
 import { ExtensionsWebSocket } from './ExtensionsWebSocket.ts';
 type DevServerStateLocalDevUrlMapping = ProxyServiceConfig['localDevUrlMapping'] | undefined;
 interface DevServerStateArgs {
@@ -13,7 +14,7 @@ interface DevServerStateArgs {
         api: string;
         web: string;
     };
-    appConfig?: AppConfig;
+    appConfig?: AppConfig | UnifiedAppConfig;
 }
 export declare class DevServerState {
     private _expressPort;
@@ -25,7 +26,7 @@ export declare class DevServerState {
     private _portalId?;
     private _mutableState;
     logger: Logger;
-    appConfig?: AppConfig;
+    appConfig?: AppConfig | UnifiedAppConfig;
     constructor({ localDevUrlMapping, extensionConfigs, accountId, expressPort, platformVersion, logger, urls, appConfig, }: DevServerStateArgs);
     get portalId(): number | undefined;
     get expressPort(): number;
@@ -37,7 +38,16 @@ export declare class DevServerState {
     get extensionsWebSocket(): ExtensionsWebSocket | undefined;
     set extensionsWebSocket(ws: ExtensionsWebSocket);
     getExtensionsWebSocket(): ExtensionsWebSocket;
+    /**
+     * In legacy apps, there was a difference between public and private apps at the project level.
+     * In unified apps, this is no longer applied and all apps are considered "public".
+     * However, to support serverless for some 2026.03 apps we need to consider an app to be private if it has static auth and private distribution.
+     * For other unified apps we continue to mark them public (despite auth/dist settings) to maintain current behavior.
+     * @returns
+     */
     isPublicApp(): boolean;
+    get authType(): string | undefined;
+    get distribution(): UnifiedAppDistribution | undefined;
     setWebSocketSetupCallback(callback: () => void): void;
     triggerWebSocketSetup(): void;
 }

package/dist/lib/DevServerState.js

@@ -1,4 +1,6 @@
-import { OUTPUT_DIR } from "./constants.js";
+import { OUTPUT_DIR, PLATFORM_VERSION } from "./constants.js";
+import { UnifiedAppAuthTypes, UnifiedAppDistributionTypes, } from "./types.js";
+import { isUnifiedAppConfig } from "./utils.js";
 import path from 'path';
 export class DevServerState {
     _expressPort;
@@ -80,9 +82,40 @@ export class DevServerState {
         }
         return this._mutableState.extensionsWebSocket;
     }
+    /**
+     * In legacy apps, there was a difference between public and private apps at the project level.
+     * In unified apps, this is no longer applied and all apps are considered "public".
+     * However, to support serverless for some 2026.03 apps we need to consider an app to be private if it has static auth and private distribution.
+     * For other unified apps we continue to mark them public (despite auth/dist settings) to maintain current behavior.
+     * @returns
+     */
     isPublicApp() {
+        if (this.appConfig && isUnifiedAppConfig(this.appConfig)) {
+            const platformVersion = this._functionsConfig.platformVersion;
+            const is2026Version = platformVersion === PLATFORM_VERSION.V202603 ||
+                platformVersion === PLATFORM_VERSION.V202603BETA ||
+                platformVersion === PLATFORM_VERSION.UNSTABLE;
+            if (is2026Version &&
+                this.appConfig.distribution === UnifiedAppDistributionTypes.PRIVATE &&
+                this.appConfig.auth?.type === UnifiedAppAuthTypes.STATIC) {
+                return false;
+            }
+            return true;
+        }
         return !!this.appConfig?.isPublicApp;
     }
+    get authType() {
+        if (this.appConfig && isUnifiedAppConfig(this.appConfig)) {
+            return this.appConfig.auth.type;
+        }
+        return undefined;
+    }
+    get distribution() {
+        if (this.appConfig && isUnifiedAppConfig(this.appConfig)) {
+            return this.appConfig.distribution;
+        }
+        return undefined;
+    }
     setWebSocketSetupCallback(callback) {
         this._mutableState.webSocketSetupCallback = callback;
     }

package/dist/lib/__tests__/DevModeParentInterface.spec.js

@@ -104,7 +104,7 @@ describe('DevModeUnifiedInterface', () => {
                 localDevUrlMapping: localConfig.proxy,
                 extensionConfigs: [cardConfig],
                 accountId,
-                platformVersion: PLATFORM_VERSION.V20231,
+                platformVersion: PLATFORM_VERSION.V20251,
                 expressPort: EXPRESS_DEFAULT_PORT,
                 logger,
                 urls,
@@ -150,6 +150,47 @@ describe('DevModeUnifiedInterface', () => {
             expect(DevModeInterface.onUploadRequired).not.toHaveBeenCalled();
         });
     });
+    describe('_getPlatformVersion', () => {
+        it('should default to V20251 when projectConfig is undefined', () => {
+            expect(DevModeInterface._getPlatformVersion(undefined)).toBe(PLATFORM_VERSION.V20251);
+        });
+        it('should default to V20251 when platformVersion is not set', () => {
+            expect(DevModeInterface._getPlatformVersion({ name: 'test', srcDir: '/tmp' })).toBe(PLATFORM_VERSION.V20251);
+        });
+        it.each([
+            [PLATFORM_VERSION.V20251, PLATFORM_VERSION.V20251],
+            [PLATFORM_VERSION.V20252, PLATFORM_VERSION.V20252],
+            [PLATFORM_VERSION.V202603, PLATFORM_VERSION.V202603],
+        ])('should return %s as-is', (input, expected) => {
+            expect(DevModeInterface._getPlatformVersion({
+                name: 'test',
+                srcDir: '/tmp',
+                platformVersion: input,
+            })).toBe(expected);
+        });
+        it('should map V202603BETA to V202603', () => {
+            expect(DevModeInterface._getPlatformVersion({
+                name: 'test',
+                srcDir: '/tmp',
+                platformVersion: PLATFORM_VERSION.V202603BETA,
+            })).toBe(PLATFORM_VERSION.V202603);
+        });
+        it('should map UNSTABLE to V202603', () => {
+            expect(DevModeInterface._getPlatformVersion({
+                name: 'test',
+                srcDir: '/tmp',
+                platformVersion: PLATFORM_VERSION.UNSTABLE,
+            })).toBe(PLATFORM_VERSION.V202603);
+        });
+        it('should throw for an unrecognized platform version', () => {
+            expect(() => DevModeInterface._getPlatformVersion({
+                name: 'test',
+                srcDir: '/tmp',
+                // @ts-expect-error - testing unrecognized version
+                platformVersion: '9999.99',
+            })).toThrow();
+        });
+    });
     describe('cleanup', () => {
         it('should call shutdown when cleanup is invoked', async () => {
             const shutdown = vi

package/dist/lib/__tests__/DevModeUnifiedInterface.spec.js

@@ -221,6 +221,27 @@ describe('DevModeUnifiedInterface', () => {
                 ?.appConfig;
             expect(appConfig?.variables).toStrictEqual(profileData);
         });
+        it('should pass distribution from app config when provided', async () => {
+            const componentsWithDistribution = {
+                application_name: {
+                    ...unifiedAppConfig,
+                    config: {
+                        ...unifiedAppConfig.config,
+                        distribution: 'private',
+                    },
+                },
+                card_one: unifiedCardOneConfig,
+            };
+            await DevModeUnifiedInterface.setup({
+                components: componentsWithDistribution,
+                logger,
+                setActiveApp,
+                urls,
+            });
+            const appConfig = DevModeUnifiedInterface.configs?.[0]
+                ?.appConfig;
+            expect(appConfig?.distribution).toBe('private');
+        });
         it('should use empty object for variables when no profileData provided', async () => {
             await DevModeUnifiedInterface.setup({
                 components,
@@ -232,5 +253,18 @@ describe('DevModeUnifiedInterface', () => {
                 ?.appConfig;
             expect(appConfig?.variables).toStrictEqual({});
         });
+        describe('isPublicApp on appConfig', () => {
+            it('should always default isPublicApp to true for unified apps', async () => {
+                await DevModeUnifiedInterface.setup({
+                    components,
+                    logger,
+                    setActiveApp,
+                    urls,
+                });
+                const appConfig = DevModeUnifiedInterface.configs?.[0]
+                    ?.appConfig;
+                expect(appConfig?.isPublicApp).toBe(true);
+            });
+        });
     });
 });

package/dist/lib/__tests__/DevServerState.spec.js

@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { DevServerState } from "../DevServerState.js";
+import { PLATFORM_VERSION } from "../constants.js";
+import { UnifiedAppAuthTypes } from "../types.js";
+import { createMockLogger, createDevServerConfig } from "./factories.js";
+import { transformedUnifiedAppConfig } from "./fixtures/extensionConfig.js";
+describe('DevServerState', () => {
+    let logger;
+    beforeEach(() => {
+        logger = createMockLogger();
+    });
+    describe('isPublicApp', () => {
+        describe('legacy apps', () => {
+            it('should return true when appConfig.isPublicApp is true', () => {
+                const state = new DevServerState(createDevServerConfig(logger, {
+                    appConfig: {
+                        name: 'Legacy App',
+                        scopes: [],
+                        public: false,
+                        description: '',
+                        extensions: { crm: { cards: [] } },
+                        isPublicApp: true,
+                    },
+                }));
+                expect(state.isPublicApp()).toBe(true);
+            });
+            it('should return false when appConfig.isPublicApp is false', () => {
+                const state = new DevServerState(createDevServerConfig(logger, {
+                    appConfig: {
+                        name: 'Legacy App',
+                        scopes: [],
+                        public: false,
+                        description: '',
+                        extensions: { crm: { cards: [] } },
+                        isPublicApp: false,
+                    },
+                }));
+                expect(state.isPublicApp()).toBe(false);
+            });
+            it('should return false when appConfig is undefined', () => {
+                const state = new DevServerState(createDevServerConfig(logger, {
+                    appConfig: undefined,
+                }));
+                expect(state.isPublicApp()).toBe(false);
+            });
+        });
+        describe('unified apps', () => {
+            it('should return true for unified apps on V20251', () => {
+                const state = new DevServerState(createDevServerConfig(logger, {
+                    platformVersion: PLATFORM_VERSION.V20251,
+                    appConfig: transformedUnifiedAppConfig,
+                }));
+                expect(state.isPublicApp()).toBe(true);
+            });
+            it('should return true for unified apps on V20251 even with private + static auth', () => {
+                const state = new DevServerState(createDevServerConfig(logger, {
+                    platformVersion: PLATFORM_VERSION.V20251,
+                    appConfig: {
+                        ...transformedUnifiedAppConfig,
+                        distribution: 'private',
+                        auth: {
+                            type: UnifiedAppAuthTypes.STATIC,
+                            requiredScopes: [],
+                        },
+                    },
+                }));
+                expect(state.isPublicApp()).toBe(true);
+            });
+            describe('V202603', () => {
+                it('should return false when distribution is private and auth is static', () => {
+                    const state = new DevServerState(createDevServerConfig(logger, {
+                        platformVersion: PLATFORM_VERSION.V202603,
+                        appConfig: {
+                            ...transformedUnifiedAppConfig,
+                            distribution: 'private',
+                            auth: {
+                                type: UnifiedAppAuthTypes.STATIC,
+                                requiredScopes: [],
+                            },
+                        },
+                    }));
+                    expect(state.isPublicApp()).toBe(false);
+                });
+                it('should return true when distribution is marketplace', () => {
+                    const state = new DevServerState(createDevServerConfig(logger, {
+                        platformVersion: PLATFORM_VERSION.V202603,
+                        appConfig: {
+                            ...transformedUnifiedAppConfig,
+                            distribution: 'marketplace',
+                        },
+                    }));
+                    expect(state.isPublicApp()).toBe(true);
+                });
+                it('should return true when distribution is private but auth is OAUTH', () => {
+                    const state = new DevServerState(createDevServerConfig(logger, {
+                        platformVersion: PLATFORM_VERSION.V202603,
+                        appConfig: {
+                            ...transformedUnifiedAppConfig,
+                            distribution: 'private',
+                            auth: {
+                                type: UnifiedAppAuthTypes.OAUTH,
+                                requiredScopes: [],
+                            },
+                        },
+                    }));
+                    expect(state.isPublicApp()).toBe(true);
+                });
+            });
+            describe('V202603BETA', () => {
+                it('should return false when distribution is private and auth is static', () => {
+                    const state = new DevServerState(createDevServerConfig(logger, {
+                        platformVersion: PLATFORM_VERSION.V202603BETA,
+                        appConfig: {
+                            ...transformedUnifiedAppConfig,
+                            distribution: 'private',
+                            auth: {
+                                type: UnifiedAppAuthTypes.STATIC,
+                                requiredScopes: [],
+                            },
+                        },
+                    }));
+                    expect(state.isPublicApp()).toBe(false);
+                });
+            });
+            describe('UNSTABLE', () => {
+                it('should return false when distribution is private and auth is static', () => {
+                    const state = new DevServerState(createDevServerConfig(logger, {
+                        platformVersion: PLATFORM_VERSION.UNSTABLE,
+                        appConfig: {
+                            ...transformedUnifiedAppConfig,
+                            distribution: 'private',
+                            auth: {
+                                type: UnifiedAppAuthTypes.STATIC,
+                                requiredScopes: [],
+                            },
+                        },
+                    }));
+                    expect(state.isPublicApp()).toBe(false);
+                });
+                it('should return true when distribution is marketplace', () => {
+                    const state = new DevServerState(createDevServerConfig(logger, {
+                        platformVersion: PLATFORM_VERSION.UNSTABLE,
+                        appConfig: {
+                            ...transformedUnifiedAppConfig,
+                            distribution: 'marketplace',
+                        },
+                    }));
+                    expect(state.isPublicApp()).toBe(true);
+                });
+            });
+        });
+    });
+    describe('authType', () => {
+        it('should return auth type for unified apps', () => {
+            const state = new DevServerState(createDevServerConfig(logger, {
+                appConfig: transformedUnifiedAppConfig,
+            }));
+            expect(state.authType).toBe(UnifiedAppAuthTypes.OAUTH);
+        });
+        it('should return undefined for legacy apps', () => {
+            const state = new DevServerState(createDevServerConfig(logger));
+            expect(state.authType).toBeUndefined();
+        });
+    });
+    describe('distribution', () => {
+        it('should return distribution for unified apps', () => {
+            const state = new DevServerState(createDevServerConfig(logger, {
+                appConfig: {
+                    ...transformedUnifiedAppConfig,
+                    distribution: 'private',
+                },
+            }));
+            expect(state.distribution).toBe('private');
+        });
+        it('should return undefined for legacy apps', () => {
+            const state = new DevServerState(createDevServerConfig(logger));
+            expect(state.distribution).toBeUndefined();
+        });
+    });
+});

package/dist/lib/__tests__/{app-functions/errorReporter.spec.js → errorReporter.spec.js}

@@ -17,15 +17,15 @@ describe('errorReporter', () => {
     });
     describe('module initialization', () => {
         it('initializes Sentry with correct DSN on import', async () => {
-            await import('../../app-functions/errorReporter.js');
+            await import('../errorReporter.js');
             expect(mockInit).toHaveBeenCalledWith(expect.objectContaining({
                 dsn: expect.stringContaining('exceptions.hubspot.com/v2/1'),
             }));
         });
         it('includes version information in initialization', async () => {
-            await import('../../app-functions/errorReporter.js');
+            await import('../errorReporter.js');
             expect(mockInit).toHaveBeenCalledWith(expect.objectContaining({
-                release: expect.stringMatching(/@hubspot\/app-functions-dev-server@\d+\.\d+\.\d+/),
+                release: expect.stringMatching(/@hubspot\/ui-extensions-dev-server@\d+\.\d+\.\d+/),
                 initialScope: expect.objectContaining({
                     tags: expect.objectContaining({
                         devServerVersion: expect.any(String),
@@ -36,7 +36,7 @@ describe('errorReporter', () => {
     });
     describe('reportError', () => {
         beforeEach(async () => {
-            const errorReporter = await import('../../app-functions/errorReporter.js');
+            const errorReporter = await import('../errorReporter.js');
             reportError = errorReporter.reportError;
         });
         it('reports error with tags and extras', () => {
@@ -70,7 +70,7 @@ describe('errorReporter', () => {
             mockExit = vi
                 .spyOn(process, 'exit')
                 .mockImplementation(() => undefined);
-            await import('../../app-functions/errorReporter.js');
+            await import('../errorReporter.js');
         });
         afterEach(() => {
             mockExit.mockRestore();

package/dist/lib/__tests__/extensionsService.spec.js

@@ -1,17 +1,23 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import path from 'path';
-vi.mock('../utils', () => ({
-    loadManifest: vi.fn(() => {
-        return {
-            name: 'fake manifest file',
-        };
-    }),
-}));
+vi.mock('../utils', async () => {
+    const actual = await vi.importActual('../utils');
+    return {
+        ...actual,
+        loadManifest: vi.fn(() => {
+            return {
+                name: 'fake manifest file',
+            };
+        }),
+    };
+});
 import { EXTENSIONS_MESSAGE_VERSION, PLATFORM_VERSION } from "../constants.js";
 import extensionsService from "../extensionsService.js";
 import { loadManifest } from "../utils.js";
 import { DevServerState } from "../DevServerState.js";
+import { UnifiedAppAuthTypes } from "../types.js";
 import { createMockLogger, createDevServerConfig } from "./factories.js";
+import { transformedUnifiedAppConfig } from "./fixtures/extensionConfig.js";
 describe('extensionsService', () => {
     let devServerState;
     let logger;
@@ -68,7 +74,7 @@ describe('extensionsService', () => {
                 version: EXTENSIONS_MESSAGE_VERSION,
                 websocket: `ws://localhost:${expressPort}`,
                 capabilities,
-                platformVersion: PLATFORM_VERSION.V20231,
+                platformVersion: PLATFORM_VERSION.V20251,
             });
         });
         it('should return a handler that includes platform version in response', () => {
@@ -84,7 +90,7 @@ describe('extensionsService', () => {
             };
             handler({}, response);
             expect(jsonMethod).toHaveBeenCalledWith(expect.objectContaining({
-                platformVersion: PLATFORM_VERSION.V20231,
+                platformVersion: PLATFORM_VERSION.V20251,
             }));
         });
         it('should work when platform version is undefined', () => {
@@ -121,6 +127,48 @@ describe('extensionsService', () => {
             const callArgs = jsonMethod.mock.calls[0][0];
             expect(callArgs).not.toHaveProperty('platformVersion');
         });
+        it('should include authType in response for unified app configs', () => {
+            const unifiedState = new DevServerState(createDevServerConfig(logger, {
+                appConfig: transformedUnifiedAppConfig,
+            }));
+            const handler = extensionsService.generateExtensionsHandler(unifiedState);
+            const jsonMethod = vi.fn();
+            const response = {
+                status: vi.fn(() => ({ json: jsonMethod })),
+            };
+            handler({}, response);
+            expect(jsonMethod).toHaveBeenCalledWith(expect.objectContaining({
+                authType: UnifiedAppAuthTypes.OAUTH,
+            }));
+        });
+        it('should include distribution in response when present in unified app config', () => {
+            const unifiedState = new DevServerState(createDevServerConfig(logger, {
+                appConfig: {
+                    ...transformedUnifiedAppConfig,
+                    distribution: 'private',
+                },
+            }));
+            const handler = extensionsService.generateExtensionsHandler(unifiedState);
+            const jsonMethod = vi.fn();
+            const response = {
+                status: vi.fn(() => ({ json: jsonMethod })),
+            };
+            handler({}, response);
+            expect(jsonMethod).toHaveBeenCalledWith(expect.objectContaining({
+                distribution: 'private',
+            }));
+        });
+        it('should not include authType or distribution for legacy app configs', () => {
+            const handler = extensionsService.generateExtensionsHandler(devServerState);
+            const jsonMethod = vi.fn();
+            const response = {
+                status: vi.fn(() => ({ json: jsonMethod })),
+            };
+            handler({}, response);
+            const callArgs = jsonMethod.mock.calls[0][0];
+            expect(callArgs).not.toHaveProperty('authType');
+            expect(callArgs).not.toHaveProperty('distribution');
+        });
         it('should return a handler that sends error responses when something goes wrong', () => {
             const handler = extensionsService.generateExtensionsHandler(devServerState);
             const jsonMethod = vi.fn();

package/dist/lib/__tests__/factories.d.ts

@@ -9,7 +9,7 @@ export declare function createDevServerConfig(logger: Logger, overrides?: {}): {
     };
     logger: Logger;
     accountId: number;
-    platformVersion: "2023.1";
+    platformVersion: "2025.1";
     expressPort: number;
     extensionConfigs: {
         type: string;

package/dist/lib/__tests__/factories.js

@@ -24,7 +24,7 @@ export function createDevServerConfig(logger, overrides = {}) {
         urls,
         logger,
         accountId: 12345,
-        platformVersion: PLATFORM_VERSION.V20231,
+        platformVersion: PLATFORM_VERSION.V20251,
         expressPort: 1234,
         extensionConfigs: [cardConfig],
         ...overrides,

package/dist/lib/__tests__/fixtures/extensionConfig.js

@@ -63,6 +63,7 @@ export const unifiedAppConfig = {
     config: {
         description: 'Generate dope memes',
         name: 'Meme generator',
+        distribution: 'marketplace',
         auth: {
             type: UnifiedAppAuthTypes.OAUTH,
             redirectUrls: ['http://localhost:3000/oauth-callback'],
@@ -91,6 +92,7 @@ export const unifiedAppConfig = {
     },
 };
 export const transformedUnifiedAppConfig = {
+    unified: true,
     name: unifiedAppConfig.config.name,
     description: unifiedAppConfig.config.description,
     uid: unifiedAppConfig.uid,
@@ -104,6 +106,7 @@ export const transformedUnifiedAppConfig = {
         },
     },
     auth: unifiedAppConfig.config.auth,
+    distribution: 'marketplace',
     support: undefined,
     isPublicApp: true,
     allowedUrls: ['https://api.hubapi.com'],

package/dist/lib/__tests__/plugins/devBuildPlugin.spec.js

@@ -44,7 +44,7 @@ describe('devBuildPlugin', () => {
             devServerState: new DevServerState({
                 extensionConfigs: [transformedUnifiedCardOneConfig],
                 accountId: 88888,
-                platformVersion: PLATFORM_VERSION.V20232,
+                platformVersion: PLATFORM_VERSION.V20251,
                 expressPort: 1234,
                 logger,
                 urls,