@openfin/workspace 24.0.13 → 24.0.15

package/client-api/src/notifications.d.ts

@@ -2,6 +2,11 @@ import * as Notifications from '@openfin/notifications';
 import type { NotificationsPlatform, NotificationsRegisterOptions } from './shapes/notifications';
 export * from '@openfin/notifications';
 export * from './shapes/notifications';
+/**
+ * Notifications Center <= 2.13 expects a legacy NotificationsThemeSet object.
+ * Versions >= 2.14 supports detailed theming.
+ */
+export declare const isLegacyNotifications: (version: string) => boolean;
 /**
  * @deprecated Use `register` with {@link NotificationsRegisterOptions | options?: NotificationsRegisterOptions} argument instead.
  */

package/client-api/src/notifications.test.d.ts

@@ -0,0 +1 @@
+export {};

package/client-api-platform/src/api/app-directory.d.ts

@@ -7,7 +7,7 @@ import type { LaunchAppRequest, SearchSitesRequest, SearchSitesResponse, Site }
  * @param app the app directory entry.
  * @param opts launch options.
  */
-export declare function launchApp({ app, target }: LaunchAppRequest): Promise<void | OpenFin.Identity | OpenFin.View | OpenFin.Platform | OpenFin.Application>;
+export declare function launchApp({ app, target }: LaunchAppRequest): Promise<void | OpenFin.View | OpenFin.Identity | OpenFin.Platform | OpenFin.Application>;
 export declare const enterpriseAppDirectoryChannelClient: () => Promise<OpenFin.ChannelClient>;
 export declare function getResults(payload: {
     req: SearchSitesRequest;

package/client-api-platform/src/api/controllers/storage-proxies/channel-storage-proxy.d.ts

@@ -0,0 +1,19 @@
+import { StorageProxy } from '../../../../../client-api-platform/src/api/utils';
+/**
+ * Channel Storage Proxy allows population of storage keys in a different origin, assuming that origin has set up
+ * a storage proxy on the specified URL.
+ *
+ * This is useful for writing to the localStorage of workspace when the provider is on a different origin.
+ */
+export declare class ChannelStorageProxy implements StorageProxy {
+    #private;
+    constructor(url: string);
+    get isDestroyed(): boolean;
+    /**
+     * Sets a key in the proxied storage partition.
+     * @param key Key to set
+     * @param value Value.
+     */
+    setItem(key: string, value: string): Promise<void>;
+    destroy(): Promise<void>;
+}

package/client-api-platform/src/api/controllers/storage-proxies/local-storage-proxy.d.ts

@@ -0,0 +1,12 @@
+import { StorageProxy } from '../../../../../client-api-platform/src/api/utils';
+/**
+ * LocalStorage backed StorageProxy, for use in same origin scenarios (i.e. when the provider and workspace UI are guaranteed
+ * to share a storage partition).
+ */
+export declare class LocalStorageProxy implements StorageProxy {
+    #private;
+    constructor(storage: Pick<Storage, 'setItem'>);
+    setItem(key: string, value: string): Promise<void>;
+    destroy(): Promise<void>;
+    get isDestroyed(): boolean;
+}

package/client-api-platform/src/api/controllers/theme-storage-controller-store.d.ts

@@ -17,3 +17,20 @@ export declare const initialiseStoragePalettes: (customThemes: CustomThemes | un
     notificationIndicatorColors: NotificationIndicatorColorsParsed | null;
 };
 export declare const getThemeStorageController: () => ThemeStorageController;
+/**
+ * Resolves when the first theme sync completes. Use this to ensure that we do not launch UI such as browser until this has completed.
+ *
+ * @param allowFailure Whether to suppress rejections and continue anyway. Recommended for most use cases.
+ */
+export declare const waitForFirstThemeSync: (allowFailure?: boolean) => Promise<void>;
+/**
+ * Creates and initialises the Theme Storage Controller singleton.
+ *
+ * Triggers the first theme sync, but does not await it. To ensure dependent UI can guarantee the theme palette is synced,
+ * you can call `await waitForFirstThemeSync` (e.g. in the createWindow provider override).
+ *
+ * @param isEnterprise Whether in enterprise mode (allows using local storage proxy directly).
+ * @param baseUrl Base url of the hosted workspace UI.
+ * @param syncTimeout How long `waitForFirstThemeSync` should wait before rejecting.
+ */
+export declare const initialiseThemeController: (isEnterprise: boolean, baseUrl: string, syncTimeout: number) => void;

package/client-api-platform/src/api/controllers/theme-storage-controller.d.ts

@@ -1,6 +1,9 @@
-import { GeneratedPalettes } from '../../../../common/src/api/theming';
 import { StorageProxy } from '../../../../client-api-platform/src/api/utils';
 import { ColorSchemeOptionType, CustomPaletteSet } from '../../../../client-api-platform/src/shapes';
+/**
+ * Converts a string => (string | number) dictionary into a set of css vars.
+ */
+export declare const getVars: (vars: Record<string, string | number>) => string;
 /**
  * Palette extensions can be used to add new variables to the palette set.
  *
@@ -23,38 +26,38 @@ export type Palettes = {
     light: string;
     dark: string;
 };
+/**
+ * Generates `--workspace-palette-*` CSS variable strings from a CustomPaletteSet.
+ * Used to produce legacy CSS vars for backwards compatibility with workspace apps
+ * that still consume the legacy theme system.
+ */
+export declare const generateLegacyCSSVars: (palettes: LegacyPalettes, isWindows: boolean) => {
+    light: string;
+    dark: string;
+};
 export declare class ThemeStorageController {
+    #private;
     private providerStorage;
     private darkPaletteVars?;
     private lightPaletteVars?;
     private themePaletteSheet?;
-    private generatedPalettes?;
     private workspaceStorage?;
-    private recreateFactory?;
+    private storageFactory?;
     private isLegacySinglePaletteTheme;
     constructor(providerStorage: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>);
     /**
-     * Set the current Storage Proxy to enable Workspace Storage properties to be populated.
-     */
-    setWorkspaceStorageProxy: (proxy: StorageProxy) => void;
-    /**
-     * Set a factory to recreate the storage proxy if it was destroyed (e.g. when a new browser
-     * window is opened after the last one closed with preventQuitOnLastWindowClosed true).
-     * Called once at platform init; avoids createWindow needing URL/env dependencies.
+     * Sets the storage factory. This can only be done once, and will throw for subsequent calls.
+     *
+     * All storage writes will be pending until the factory is created.
+     * @param factory
      */
-    setRecreateFactory: (factory: () => Promise<StorageProxy>) => void;
+    setStorageFactory: (factory: () => StorageProxy) => void;
     /**
      * Close the storage proxy window and clear the reference. Called when the last browser window
      * closes so the platform can quit (storage proxy would otherwise keep the process alive).
-     * Clears the reference before awaiting destroy() to avoid a race with ensureWorkspaceStorageProxy.
+     * Clears the reference before awaiting destroy() to avoid a race with getOrCreateStorageProxy.
      */
     destroyWorkspaceStorageProxy: () => Promise<void>;
-    /**
-     * Ensure the workspace storage proxy exists, recreating via the factory set at init if it was
-     * previously destroyed. No-op if no factory was set (e.g. in tests). Call before using
-     * workspace storage (e.g. when creating a browser window).
-     */
-    ensureWorkspaceStorageProxy: () => Promise<void>;
     /**
      * Check if there's an explicit user preference stored in localStorage.
      * A user preference is indicated by the presence of a SelectedColorScheme key. Which is something assigned if you click on the Appearance dropdown.
@@ -63,11 +66,15 @@ export declare class ThemeStorageController {
     private hasUserPreference;
     /**
      * Synchronize the current palette and scheme with workspace's storage instance if
-     * storage based theming is enabled. Only syncs when user has explicitly selected a scheme.
+     * storage based theming is enabled.
      *
-     * Wrapped in try/catch so it does not throw
+     * Workspace storage is consumed by workspace apps still on the legacy theme system
+     * whose theme-loader does NOT set `data-scheme` on the document. To maintain
+     * backwards compatibility the sheet written here uses the legacy format: for an
+     * explicit light/dark scheme only that scheme's vars are placed inside `:root{}`,
+     * while "system" uses `@media (prefers-color-scheme)` queries with `:root`.
      */
-    trySynchronizeWorkspaceStorage: () => Promise<void>;
+    synchronizeWorkspaceStorage: () => Promise<void>;
     /**
      * Set the current Palette to be used by workspace. This palette will be converted into
      * css vars and combined into a single stylesheet. This stylesheet is exposed in localstorage
@@ -99,7 +106,6 @@ export declare class ThemeStorageController {
      * @param scheme The default scheme specified in the palette
      */
     setThemeDefaultScheme(scheme: ColorSchemeOptionType): void;
-    setGeneratedPalettes(generatedPalettes: GeneratedPalettes): void;
     /**
      * Write the theme palette sheet to both in-memory state and providerStorage (namespaced localStorage)
      * immediately. This ensures the theme is available for themeLoader on same-origin pages

package/client-api-platform/src/api/pages/index.d.ts

@@ -26,10 +26,15 @@ export declare const getActivePageIdForWindow: (identity: OpenFin.Identity) => P
  *
  * If the name is not unique, it will append a number to the end of the name.
  *
+ * When `BrowserInitConfig.allowDuplicatePageTitles` is `true`, this function
+ * short-circuits and returns the supplied name (or the default title) as-is,
+ * without appending a numeric suffix.
+ *
  * @param initialName The initial name to test
- * @returns string: a unique page name
+ * @param allowDuplicatePageTitles Whether duplicate page titles are permitted
+ * @returns string: a unique page name (or the input unchanged when duplicates are allowed)
  */
-export declare function getUniquePageTitle(initialName?: string): Promise<string>;
+export declare function getUniquePageTitle(initialName?: string, allowDuplicatePageTitles?: boolean): Promise<string>;
 export declare function handleSaveModalOnPageClose({ page }: HandleSaveModalOnPageClosePayload): Promise<SaveModalOnPageCloseResult>;
 /**
  * Default implementation of shouldPageClose. If enableBeforeUnload isn't set to true, always returns True (proceed with close).

package/client-api-platform/src/api/theming.d.ts

@@ -1,6 +1,6 @@
 import type OpenFin from '@openfin/core';
-import type { BaseThemeOptions, CustomTheme, GenerateThemeParams } from '../../../common/src/api/theming';
-import { ColorSchemeOptionType, ThemeApi } from '../../../client-api-platform/src/shapes';
+import type { GeneratedPalettes, NotificationIndicatorColorsParsed } from '../../../common/src/api/theming';
+import { ColorSchemeOptionType, LegacyNotificationsThemeSet, ThemeApi } from '../../../client-api-platform/src/shapes';
 export declare const getThemingApi: (identity: OpenFin.ApplicationIdentity) => ThemeApi;
 export declare const dispatchThemeToWorkspaceProvider: (themeData: {
     themePaletteSheet: string;
@@ -15,5 +15,9 @@ export declare const getSelectedScheme: () => ColorSchemeOptionType | null | und
 /** @internal */
 export declare const getIsLegacySinglePaletteTheme: () => boolean;
 export declare const getThemePaletteSheet: () => string | undefined;
-export declare const mapLegacyThemeToCustomTheme: (legacyTheme: CustomTheme) => GenerateThemeParams;
-export declare const mapLegacyBrandIcons: (legacyBrand: BaseThemeOptions["brand"]) => GenerateThemeParams[1];
+export { assignIfDefined, mapGeneratedPalettesToLegacyPalettes, mapLegacyBrandIcons, mapLegacyThemeToCustomTheme } from '../../../common/src/api/theme-migration';
+/**
+ * Builds a legacy NotificationsThemeSet from generated palettes and indicator colors.
+ * Used by the provider-side handler to serve old Notification Center versions (<=2.13).
+ */
+export declare const buildLegacyNotificationsTheme: (generatedPalettes: GeneratedPalettes, notificationIndicatorColors: NotificationIndicatorColorsParsed | null) => Promise<LegacyNotificationsThemeSet | null>;

package/client-api-platform/src/api/utils.d.ts

@@ -2,11 +2,6 @@ export declare const listenForStoreClose: () => void;
 export type StorageProxy = {
     setItem: (data: string, value: string) => Promise<void>;
     destroy: () => Promise<void>;
+    isDestroyed: boolean;
 };
-export declare const createStorageProxy: (url: string, isEnterprise: boolean) => Promise<StorageProxy>;
-/**
- * Ensure the workspace storage proxy window exists. Recreates it if it was previously destroyed
- * (e.g. when the last browser window closed with preventQuitOnLastWindowClosed true and a new
- * browser window is now being created). Uses the factory registered at init; no-op in tests.
- */
-export declare const ensureWorkspaceStorageProxy: () => Promise<void>;
+export declare const getStorageFactory: (isEnterprise: boolean, baseUrl: string) => (() => StorageProxy);

package/client-api-platform/src/init/index.d.ts

@@ -1,5 +1,6 @@
 import OpenFin from '@openfin/core';
 import { WorkspacePlatformInitConfig } from '../../../client-api-platform/src/shapes';
+export declare const MAX_FIRST_THEME_SYNC_WAIT = 3000;
 /**
  * Initilaize a Workspace Platform.
  *
@@ -35,4 +36,4 @@ import { WorkspacePlatformInitConfig } from '../../../client-api-platform/src/sh
  * ```
  * @param options options for configuring the platform.
  */
-export declare const init: ({ theme, customActions, language, ...rest }: WorkspacePlatformInitConfig) => Promise<OpenFin.Platform>;
+export declare const init: (config: WorkspacePlatformInitConfig) => Promise<OpenFin.Platform>;

package/client-api-platform/src/init/override-callback/browser-defaults.d.ts

@@ -4,4 +4,4 @@ import { BrowserInitConfig } from '../../../../client-api-platform/src/shapes';
 /**
  * Applies default options to the creation of browser windows.
  */
-export declare function applyBrowserDefaults(options: OpenFin.PlatformWindowCreationOptions, initOptions: Pick<BrowserInitConfig, 'defaultWindowOptions' | 'defaultPageOptions' | 'defaultViewOptions' | 'browserIconSize'> | undefined, themeData?: PreloadedThemeData): Promise<OpenFin.PlatformWindowCreationOptions>;
+export declare function applyBrowserDefaults(options: OpenFin.PlatformWindowCreationOptions, initOptions: Pick<BrowserInitConfig, 'defaultWindowOptions' | 'defaultPageOptions' | 'defaultViewOptions' | 'browserIconSize' | 'allowDuplicatePageTitles'> | undefined, themeData?: PreloadedThemeData): Promise<OpenFin.PlatformWindowCreationOptions>;

package/client-api-platform/src/init/override-callback/page-defaults.d.ts

@@ -1,4 +1,4 @@
 import OpenFin from '@openfin/core';
 import type { AttachedPage, AttachedPageInternal } from '../../../../common/src/api/pages/shapes';
 import { BrowserInitConfig } from '../..';
-export declare const applyPageDefaults: (pages: AttachedPage[], initOptions?: Pick<BrowserInitConfig, "defaultPageOptions" | "defaultViewOptions" | "defaultWindowOptions">, overrideOptions?: OpenFin.PlatformWindowCreationOptions) => Promise<AttachedPageInternal[]>;
+export declare const applyPageDefaults: (pages: AttachedPage[], initOptions?: Pick<BrowserInitConfig, "defaultPageOptions" | "defaultViewOptions" | "defaultWindowOptions" | "allowDuplicatePageTitles">, overrideOptions?: OpenFin.PlatformWindowCreationOptions) => Promise<AttachedPageInternal[]>;

package/client-api-platform/src/init/panels.d.ts

@@ -4,5 +4,12 @@ export declare function convertPanelViewOpts(panels: PanelConfig[], updatePageRe
     identity: OpenFin.Identity;
     pageId: string;
 }): Promise<ExtendedPanelConfig[]>;
-export declare function createPanelViewsForPages(pages: AttachedPage[]): Promise<void>;
+/**
+ * Creates panel views for all pages in parallel. Returns a promise that callers
+ * may optionally await. In the initial window creation path the return value is
+ * intentionally ignored (fire-and-forget) so panel creation doesn't block
+ * `super.createWindow`. In the `attachPagesToWindow` path the promise is awaited
+ * so views exist before the browser dispatches `attachPanelViews`.
+ */
+export declare function createPanelViewsForPages(pages: AttachedPage[]): Promise<PromiseSettledResult<unknown>[]> | undefined;
 export declare function createPanelViews(panels: PanelConfig[]): Promise<(void | OpenFin.View)[]>;

package/client-api-platform/src/init/theming.d.ts

@@ -1,9 +1,10 @@
 import { GeneratedPalettes, NotificationIndicatorColorsParsed } from '../../../common/src/api/theming';
-import { CustomThemes } from '../shapes';
+import { CustomThemes, LegacyNotificationsThemeSet } from '../shapes';
 export declare const getThemes: () => CustomThemes | null;
 export declare const getGeneratedPalettes: () => GeneratedPalettes;
 export declare const getThemePaletteSheet: () => string;
 export declare const getNotificationIndicatorColorsInternal: () => NotificationIndicatorColorsParsed;
+export declare const getLegacyNotificationsThemeInternal: () => Promise<LegacyNotificationsThemeSet | null>;
 export declare const isThemePreInitialised: () => boolean;
 /**
  * initTheming()

package/client-api-platform/src/shapes.d.ts

@@ -1,6 +1,7 @@
 import type OpenFin from '@openfin/core';
 import type { IconProps, IconType, Languages } from '@openfin/ui-library';
 import type { ModalResponseEvent } from '../../common/src/utils/menu-window-provider';
+import type { WorkspaceIndicatorConfig } from '../../common/src/utils/indicators/workspace-indicators';
 import type { AnalyticsEvent, AnalyticsEventInternal } from '../../common/src/utils/usage-register';
 import type { BaseCustomDropdownItem, CustomActionSpecifier, CustomButtonConfig } from '../../common/src/api/action';
 import type { Resource } from '../../common/src/api/i18next';
@@ -16,7 +17,7 @@ export * from '../../dock3/src/shapes';
 export { AppManifestType } from '../../client-api/src/shapes';
 export type { App, AppIntent, Image } from '../../client-api/src/shapes';
 export type { CustomActionSpecifier, CustomButtonConfig } from '../../common/src/api/action';
-export type { AttachedPage, Page, PageLayout, PageLayoutDetails, PageWithUpdatableRuntimeAttribs, PanelConfigHorizontal, PanelConfigVertical, PanelConfig, ExtendedPanelConfig, CopyPagePayload, HandleSaveModalOnPageClosePayload, SaveModalOnPageCloseResult, SetActivePageForWindowPayload, ShouldPageClosePayload, ShouldPageCloseResult, ViewsPreventingUnloadPayload } from '../../common/src/api/pages/shapes';
+export type { AttachedPage, Page, PagePinnedState, PageLayout, PageLayoutDetails, PageWithUpdatableRuntimeAttribs, PanelConfigHorizontal, PanelConfigVertical, PanelConfig, ExtendedPanelConfig, CopyPagePayload, HandleSaveModalOnPageClosePayload, SaveModalOnPageCloseResult, SetActivePageForWindowPayload, ShouldPageClosePayload, ShouldPageCloseResult, ViewsPreventingUnloadPayload } from '../../common/src/api/pages/shapes';
 export { PanelPosition } from '../../common/src/api/pages/shapes';
 export type { CustomThemes, CustomThemeOptions, ThemeOptions, CustomThemeOptionsWithScheme, CustomPaletteSet, BaseThemeOptions, ThemeExtension, WorkspaceThemeSet, NotificationIndicatorColorsSet, NotificationIndicatorColorsSetDarkScheme, NotificationIndicatorColorsSetLightScheme, NotificationIndicatorColorsWithScheme } from '../../common/src/api/theming';
 export type { AnalyticsEvent } from '../../common/src/utils/usage-register';
@@ -160,6 +161,14 @@ export declare enum PageTabContextMenuOptionType {
     Save = "Save",
     SaveAs = "Save As",
     NewPage = "New Page",
+    /** Workspace Browser: pin a normal tab (sets `pinned: 'user'`). */
+    Pin = "Pin",
+    /** Workspace Browser: unpin a user-pinned tab (clears `pinned`). */
+    Unpin = "Unpin",
+    /** Enterprise Browser: toggle Golden Layout view tab headers (multi-view Supertabs).
+     * @internal
+     */
+    ShowHideTabs = "ShowHideTabs",// Enterprise
     DeletePage = "Delete Page",// Enterprise
     SaveWorkspaceAs = "SaveWorkspaceAs",// Enterprise
     Refresh = "Refresh",// Enterprise
@@ -848,6 +857,13 @@ export interface BrowserWorkspacePlatformWindowOptions {
      * When true, disables the ability to close pages in the window. False by default.
      */
     preventPageClose?: boolean;
+    /**
+     * When true, disables the find in page feature for the window.
+     * The find in page view will not be created and no find in page logic will run.
+     * This option must be set at window creation time and cannot be changed dynamically.
+     * False by default.
+     */
+    disableFindInPage?: boolean;
     /**
      * Taskbar Icon for the Browser Window. If light and dark icon are defined, then the taskbar icon will change when the scheme changes.
      */
@@ -1874,6 +1890,33 @@ export interface ThemeApi {
      * @returns the notification indicator colors.
      */
     getNotificationIndicatorColorsInternal(): Promise<NotificationIndicatorColorsParsed | null>;
+    /**
+     * @internal
+     * Build a legacy NotificationsThemeSet from the current generated palettes.
+     * Used for backwards compatibility with older Notification Center versions
+     * that do not support detailed theming.
+     */
+    getLegacyNotificationsThemeInternal(): Promise<LegacyNotificationsThemeSet | null>;
+}
+/**
+ * @internal
+ * Legacy theme format expected by Notification Center <= 2.13.
+ * Each scheme contains a styled-components DefaultTheme-compatible object
+ * with optional embedded notification indicator colors.
+ */
+export interface LegacyNotificationsThemeSet {
+    light: Record<string, unknown> & {
+        notificationIndicatorColors?: Record<string, {
+            background: string;
+            foreground: string;
+        }>;
+    };
+    dark: Record<string, unknown> & {
+        notificationIndicatorColors?: Record<string, {
+            background: string;
+            foreground: string;
+        }>;
+    };
 }
 /**
  * Controller for a Workspace Platform.
@@ -3011,6 +3054,32 @@ export interface BrowserInitConfig {
      * @internal
      */
     aiPanelOptions?: AiPanelOptions;
+    /**
+     * When true, allows multiple pages to share the same title across browser
+     * windows. No numeric suffixes are appended and attach/add operations
+     * will not reject on title collision. `pageId` remains the unique
+     * identifier for all page operations.
+     *
+     * Defaults to `false` (current unique-title behavior preserved).
+     */
+    allowDuplicatePageTitles?: boolean;
+    /**
+     * Opt-in suppression flags for workspace success indicators.
+     * Both flags default to `false`; existing platforms see no behaviour change.
+     *
+     * @example
+     * ```ts
+     * await WorkspacePlatform.init({
+     *   browser: {
+     *     indicators: {
+     *       suppressWorkspaceSwitched: true,
+     *       suppressWorkspaceSaved: true,
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    indicators?: WorkspaceIndicatorConfig;
 }
 interface WorkspaceMetadata {
     APIVersion: string;

package/common/src/api/pages/enterprise-shapes.d.ts

@@ -1,5 +1,6 @@
 import { OpenFin } from '@openfin/core';
 import { ExtendedPanelConfig, PageLayout, PanelConfig } from '../../../../client-api-platform/src/index';
+import type { PagePinnedState } from '../../../../common/src/api/pages/shapes';
 export interface Page {
     /** A UI friendly title for the page. */
     title: string;
@@ -21,6 +22,9 @@ export interface Page {
     layout: PageLayout;
     /** True if the page is locked. */
     isLocked?: boolean;
+    /** Not used by enterprise — page pinning is a workspace-only feature. Declared here because
+     *  shared code (page-tab-context-menu.ts) casts to AttachedPageInternal and accesses this field. */
+    pinned?: PagePinnedState;
     /** Used to manipulate behaviour of a close button on a page tab. If `undefined`, then close button is visible and actionable.
      * If either property true, this page tab's context menu will disable its 'Close Page' option.
      */

package/common/src/api/pages/shapes.d.ts

@@ -12,6 +12,8 @@ export interface PageLayoutDetails {
 export type PageLayout = OpenFin.LayoutOptions & {
     layoutDetails?: PageLayoutDetails;
 };
+/** The pinned state of a page tab. `'platform'` = developer-locked; `'user'` = end-user pinned. */
+export type PagePinnedState = 'platform' | 'user';
 /**
  * Provides configuration options for a set of Workspace Views. An array of Page objects is a required option of the {@link workspacePlatform}
  * property of the {@link BrowserCreateWindowRequest} interface.
@@ -62,6 +64,8 @@ export interface Page {
     layout: PageLayout;
     /** True if the page is locked. */
     isLocked?: boolean;
+    /** Pinned state: `'platform'` (developer-locked), `'user'` (end-user pinned), or omitted (normal). */
+    pinned?: PagePinnedState;
     /** Used to manipulate behaviour of a close button on a page tab. If `undefined`, then close button is visible and actionable.
      * If either property true, this page tab's context menu will disable its 'Close Page' option.
      */
@@ -124,17 +128,21 @@ export interface ReorderPagesForWindowPayload {
     /** The ordered ids of the attached pages. */
     pageIds: string[];
 }
+/** Page fields for update payloads. `null` signals "clear this field" over IPC (null survives JSON serialization, undefined does not). */
+type PageUpdateNullableOverrides = {
+    pinned?: PagePinnedState | null;
+};
 export interface UpdatePageForWindowPayload {
     /** The OF window identity the pages to change the order of. */
     identity: OpenFin.Identity;
     /** The id of the attached page to update. */
     pageId: string;
     /** The partial updated state of the page. */
-    page: Partial<PageWithUpdatableRuntimeAttribs>;
+    page: Omit<Partial<PageWithUpdatableRuntimeAttribs>, 'pinned'> & PageUpdateNullableOverrides;
 }
 export interface ExtendedUpdatePageForWindowPayload extends UpdatePageForWindowPayload {
     /** The partial updated state of the page. */
-    page: Partial<AttachedPage>;
+    page: Omit<Partial<AttachedPage>, 'pinned'> & PageUpdateNullableOverrides;
 }
 export interface AttachPagesToWindowPayload {
     /** The OF window identity to attach the pages to. */

package/common/src/api/protocol/workspace-platform.d.ts

@@ -99,7 +99,9 @@ export declare enum WorkspacePlatformChannelAction {
     ShowApplyAndPublishModalInternal = "showApplyAndPublishModalInternal",// Enterprise
     GetNotificationIndicatorColorsInternal = "getNotificationIndicatorColorsInternal",// Custom Notification Indicators Colors
     /** @internal */
-    GetIsLegacySinglePaletteTheme = "getIsLegacySinglePaletteTheme"
+    GetIsLegacySinglePaletteTheme = "getIsLegacySinglePaletteTheme",
+    /** @internal */
+    GetLegacyNotificationsThemeInternal = "getLegacyNotificationsThemeInternal"
 }
 export type PlatFormSupportedFeatures = boolean | {
     isWorkspacePlatform: boolean;

package/common/src/api/theme-migration.d.ts

@@ -0,0 +1,46 @@
+import type { BaseThemeOptions, CustomPaletteSet, CustomTheme, CustomThemes, GeneratedPalettes, GenerateThemeParams } from './theming';
+export declare const assignIfDefined: (target: Record<string, unknown>, key: string, value: unknown) => void;
+/**
+ * Maps a legacy palette-based theme to theme-engine seed + overrides.
+ *
+ * Legacy themes use `palette` (single scheme) or `palettes` (light/dark) with
+ * explicit color values. This function translates those values into the dotted
+ * token paths that `generateTheme` expects.
+ *
+ * Mapping reference: https://www.figma.com/design/bUbUpAHJl8xGEtFbpYZ5z3/Theme?node-id=0-1&p=f&m=dev
+ */
+export declare const mapLegacyThemeToCustomTheme: (legacyTheme: CustomTheme) => GenerateThemeParams;
+/**
+ * Reverse of mapLegacyThemeToCustomTheme.
+ * Takes the resolved token maps from a generated theme and maps them back to the
+ * legacy CustomPaletteSet shape so that workspace apps still on the legacy theme
+ * system can consume them.
+ */
+export declare const mapGeneratedPalettesToLegacyPalettes: (generatedPalettes: GeneratedPalettes) => {
+    light: CustomPaletteSet;
+    dark: CustomPaletteSet;
+};
+export declare const mapLegacyBrandIcons: (legacyBrand: BaseThemeOptions["brand"]) => GenerateThemeParams[1];
+/**
+ * Converts legacy CustomThemes (from old workspace platforms v23.0.22 and earlier)
+ * into GeneratedPalettes with toCSS() methods and a ready-to-inject palette sheet.
+ *
+ * This is the backward-compatibility bridge: when a new workspace app (home, dock,
+ * storefront) discovers it's running against a legacy platform — detected by
+ * `getGeneratedPalettes()` throwing because the channel action doesn't exist —
+ * it calls `getThemes()` to retrieve the old-format themes and runs them through
+ * this function to produce the same output the new pipeline expects.
+ *
+ * The conversion mirrors `initialiseStoragePalettes` in client-api-platform but
+ * omits storage controller side-effects (setPalettes, setThemePaletteSheet) since
+ * those belong to the platform init path, not the workspace app consumption path.
+ *
+ * Theme shape discrimination:
+ * - `palette`: single palette applied to both schemes (legacy single-scheme theme)
+ * - `palettes`: explicit light/dark palettes (legacy dual-scheme theme)
+ * - `seed`: already a token-based theme (should not reach this path, but handled for safety)
+ */
+export declare const convertLegacyThemesToGeneratedPalettes: (themes: CustomThemes | null | undefined) => {
+    generatedPalettes: GeneratedPalettes;
+    themePaletteSheet: string;
+};

package/common/src/api/theming.d.ts

@@ -316,7 +316,21 @@ export declare const OpenFinDarkTheme: {
 };
 export declare const DefaultOpenFinTheme: CustomThemes;
 export declare const parseNotificationIndicatorColors: (customTheme: CustomTheme) => NotificationIndicatorColorsParsed;
-export declare const constructThemePaletteSheet: (themes: GeneratedPalettes) => string;
+/**
+ * Builds a CSS stylesheet that exposes theme tokens as custom properties.
+ *
+ * The sheet is written to provider storage and consumed by same-origin pages
+ * via an adopted stylesheet. It uses `data-scheme` selectors for dark/system
+ * switching, which the new theme-loader sets on the document element.
+ *
+ * @param legacyVars Optional `--workspace-palette-*` CSS variable strings to
+ *   merge alongside the new `--color-role-*` variables. When provided, apps on
+ *   the legacy theme system that read these variables will receive correct values.
+ */
+export declare const constructThemePaletteSheet: (themes: GeneratedPalettes, legacyVars?: {
+    light: string;
+    dark: string;
+}) => string;
 export declare const getComputedPlatformTheme: (platformIdentity: OpenFin.Identity) => Promise<{
     theme: GeneratedPalettes | CustomThemes;
     defaultScheme: ColorSchemeOptionType;

package/common/src/utils/indicators/showIndicator.d.ts

@@ -50,6 +50,13 @@ export declare function showSuccess(payload: ShowSuccessPayload): Promise<void>;
  */
 export declare function showInfo(payload: ShowInfoPayload): Promise<void>;
 /**
- * Creates a window centered on monitor containing a success indicator for switching workspaces
+ * Creates a window centered on monitor containing a success indicator for switching workspaces.
+ * No-ops when `suppressWorkspaceSwitched` has been set via `BrowserInitConfig.indicators`.
  */
 export declare function showSwitchWorkspaceSuccess(): Promise<void>;
+/**
+ * Creates a success indicator for workspace save and save-as operations.
+ * No-ops when `suppressWorkspaceSaved` has been set via `BrowserInitConfig.indicators`.
+ * Rename operations are intentionally unaffected — use `showSuccess` directly for those.
+ */
+export declare const showWorkspaceSavedSuccess: (payload: ShowSuccessPayload) => Promise<void>;

package/common/src/utils/indicators/workspace-indicators.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Configuration for suppressing workspace success indicators.
+ */
+export interface WorkspaceIndicatorConfig {
+    /** Suppress the "Workspace Switched" indicator on all applyWorkspace calls. @default false */
+    suppressWorkspaceSwitched?: boolean;
+    /** Suppress the "Workspace Saved" indicator on regular workspace save only. Save-as and rename are unaffected. @default false */
+    suppressWorkspaceSaved?: boolean;
+}
+export declare const initWorkspaceIndicators: (config?: WorkspaceIndicatorConfig) => void;
+export declare const getSuppressWorkspaceSwitched: () => boolean;
+/** Returns true when the "Workspace Saved" indicator should be suppressed (save only; save-as and rename are unaffected). */
+export declare const getSuppressWorkspaceSaved: () => boolean;

package/common/src/utils/layout.d.ts

@@ -1,4 +1,5 @@
 import type OpenFin from '@openfin/core';
+import type { PagePinnedState } from '../../../common/src/api/pages/shapes';
 import { WindowIdentity } from '../../../common/src/utils/window';
 import { AttachedPage, PageLayout } from '../../../client-api-platform/src/shapes';
 export type LayoutDOMEventType = 
@@ -91,12 +92,6 @@ export declare const generateViewNameAndIdentifierNameIfNotExists: <T extends {
  */
 export declare const cloneLayoutAndConvertViewOptions: (layout: PageLayout, initViewOptions?: Partial<OpenFin.ViewOptions>) => Promise<PageLayout>;
 export declare const cloneViewComponentWithoutName: (componentState: any) => any;
-/**
- * Deep clones a layout and removes view names.
- * @param layout The Layout to be cloned
- * @returns A copy of the layout with names removed
- */
-export declare const cloneLayoutAndRemoveNames: (layout: PageLayout) => any;
 /**
  * Deep clones a layout and removes generated view names.
  * @param layout The Layout to be cloned
@@ -121,6 +116,14 @@ export declare const cleanupLayoutObservers: (layoutName: string) => void;
  * Initialize the layout for the current OF window.
  */
 export declare const initLayoutListeners: () => Promise<void>;
+/**
+ * Returns true when a page's in-page layout should be locked.
+ * This applies for user-locked pages (`isLocked`) and platform-pinned pages (`pinned === 'platform'`).
+ */
+export declare const isPageLayoutLocked: (page: {
+    isLocked?: boolean;
+    pinned?: PagePinnedState;
+}) => boolean;
 /**
  * Deep clones a layout and changes its settings to make it "locked".
  * @param layout The Layout to be locked