@openfin/workspace-platform 24.1.5 → 24.1.6-alpha.5c686d8c

package/client-api/src/internal/providers.d.ts

@@ -1,3 +1,4 @@
+import { PlatformError } from '../../../common/src/errors';
 import { ProviderType } from '../../../common/src/api/provider';
 /**
  * Error thrown when attempting to use a provider that is not registered.
@@ -7,7 +8,7 @@ import { ProviderType } from '../../../common/src/api/provider';
  * // Error: Dock Provider. Dock Provider with id my-dock-id is not currently registered.
  * ```
  */
-export declare class ProviderNotRegisteredError extends Error {
+export declare class ProviderNotRegisteredError extends PlatformError {
     constructor(providerType: ProviderType, id?: string);
 }
 /**
@@ -19,7 +20,7 @@ export declare class ProviderNotRegisteredError extends Error {
  * // Error: Home Provider. Home Provider with id my-home-id is already registered.
  * ```
  */
-export declare class ProviderAlreadyRegisteredError extends Error {
+export declare class ProviderAlreadyRegisteredError extends PlatformError {
     constructor(providerType: ProviderType, id?: string);
 }
 /**
@@ -31,7 +32,7 @@ export declare class ProviderAlreadyRegisteredError extends Error {
  * // Error: Failed to get Storefront Provider. Storefront Provider with id unknown-id is not currently registered.
  * ```
  */
-export declare class FailedToGetProviderError extends Error {
+export declare class FailedToGetProviderError extends PlatformError {
     constructor(providerType: ProviderType, id?: string);
 }
 /**

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

@@ -23,6 +23,14 @@ export declare const getThemeStorageController: () => ThemeStorageController;
  * @param allowFailure Whether to suppress rejections and continue anyway. Recommended for most use cases.
  */
 export declare const waitForFirstThemeSync: (allowFailure?: boolean) => Promise<void>;
+/**
+ * Whether `initialiseThemeController` has run in this module instance. Callers that gate on
+ * `waitForFirstThemeSync` must check this first: `firstThemeSync` is module-level state, so a
+ * separately-bundled copy of this module (e.g. `@openfin/enterprise-api`, which bundles its own
+ * copy alongside the customer's `@openfin/workspace-platform`) has a promise that nothing will
+ * ever settle — awaiting it would hang forever.
+ */
+export declare const isThemeControllerInitialised: () => boolean;
 /**
  * Creates and initialises the Theme Storage Controller singleton.
  *

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,13 +26,21 @@ 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 storageFactory?;
     private isLegacySinglePaletteTheme;
@@ -56,6 +67,12 @@ export declare class ThemeStorageController {
     /**
      * Synchronize the current palette and scheme with workspace's storage instance if
      * storage based theming is enabled.
+     *
+     * 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`.
      */
     synchronizeWorkspaceStorage: () => Promise<void>;
     /**
@@ -87,7 +104,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/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;
@@ -13,5 +13,9 @@ export declare const dispatchThemeToWorkspaceProvider: (themeData: {
 export declare const setSelectedScheme: (schemeType: ColorSchemeOptionType) => Promise<void>;
 export declare const getSelectedScheme: () => ColorSchemeOptionType | null | undefined;
 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/init/override-callback/commands.d.ts

@@ -0,0 +1,6 @@
+import type OpenFin from '@openfin/core';
+export declare const KEYBOARD_COMMANDS: {
+    readonly NEW_TAB: "workspace.newTab";
+    readonly FIND_IN_PAGE: "findInPage.show";
+};
+export declare const getKeyboardCommands: (superGetKeyboardCommands: () => OpenFin.ShortcutOverride[]) => OpenFin.ShortcutOverride[];

package/client-api-platform/src/init/override-callback/snapshot.page-tab-groups.test.d.ts

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

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/init/view-tab-new-tab-shortcut-usage.d.ts

@@ -0,0 +1,2 @@
+export declare const registerViewTabNewTabShortcutUsageTracking: () => void;
+export declare const unregisterViewTabNewTabShortcutUsageTracking: () => void;

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

@@ -12,7 +12,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';
@@ -155,7 +155,11 @@ export declare enum PageTabContextMenuOptionType {
     Rename = "Rename",
     Save = "Save",
     SaveAs = "Save As",
-    NewPage = "New Page",// Enterprise
+    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
     DeletePage = "Delete Page",// Enterprise
     SaveWorkspaceAs = "SaveWorkspaceAs",// Enterprise
     Refresh = "Refresh",// Enterprise

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/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

@@ -291,9 +291,23 @@ 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: CustomThemes | GeneratedPalettes;
+    theme: GeneratedPalettes | CustomThemes;
     defaultScheme: ColorSchemeOptionType;
     themePaletteSheet: string;
 }>;

package/common/src/errors/AppError.d.ts

@@ -0,0 +1,37 @@
+/**
+ * AppError — base class for all application errors.
+ *
+ * Use a subclass (NetworkError, PlatformError, etc.) — never instantiate AppError directly
+ * in production code. The class identity (`error.name`) is the category; `context` carries
+ * the specifics; `cause` chains the underlying error.
+ *
+ * `instanceof` is the supported way to branch on error type. `toJSON()` is what the
+ * existing logger's safeStringify uses to produce structured output, so logging an
+ * AppError preserves the full chain automatically.
+ */
+export interface ErrorContext {
+    [key: string]: unknown;
+}
+export interface SerializedError {
+    name: string;
+    message: string;
+    context: ErrorContext;
+    stack?: string;
+    cause?: SerializedError;
+    timestamp: string;
+}
+export interface AppErrorOptions {
+    cause?: unknown;
+    context?: ErrorContext;
+}
+export declare class AppError extends Error {
+    readonly context: ErrorContext;
+    readonly timestamp: Date;
+    constructor(message: string, options?: AppErrorOptions);
+    serialize(): SerializedError;
+    /**
+     * Called automatically by JSON.stringify so `safeStringify({ error })` in the logger
+     * produces the full structured form without any logger changes.
+     */
+    toJSON(): SerializedError;
+}

package/common/src/errors/errors.d.ts

@@ -0,0 +1,23 @@
+import { AppError, AppErrorOptions } from './AppError';
+/** Put `{ url, status, method, timeoutMs }` in context as relevant. */
+export declare class NetworkError extends AppError {
+}
+/** Put `{ field, received, expected }` in context. */
+export declare class ValidationError extends AppError {
+}
+/** Put `{ status, scope, userId }` in context as available. */
+export declare class AuthError extends AppError {
+}
+/** OpenFin / runtime / channel / provider failures. Put `{ providerId, channelName, identity }` in context. */
+export declare class PlatformError extends AppError {
+}
+/** Read/write failures against persistent storage. Put `{ key, operation }` in context. */
+export declare class StorageError extends AppError {
+}
+/** Bad or missing configuration discovered at runtime. Put `{ configKey, env }` in context. */
+export declare class ConfigError extends AppError {
+}
+/** Catch-all. Prefer creating via `toAppError(unknown)` rather than directly. */
+export declare class UnknownError extends AppError {
+}
+export type { AppErrorOptions };

package/common/src/errors/index.d.ts

@@ -0,0 +1,6 @@
+export { AppError } from './AppError';
+export type { AppErrorOptions, ErrorContext, SerializedError } from './AppError';
+export { NetworkError, ValidationError, AuthError, PlatformError, StorageError, ConfigError, UnknownError } from './errors';
+export { toAppError } from './toAppError';
+export { ok, err, isOk, isErr, unwrap, mapResult } from './result';
+export type { Ok, Err, Result } from './result';

package/common/src/errors/result.d.ts

@@ -0,0 +1,23 @@
+import { AppError } from './AppError';
+/**
+ * Result<T, E> — opt-in alternative to throwing for operations whose callers
+ * genuinely need to branch on success vs failure (e.g., a save that has a clear
+ * fallback path). Don't blanket-replace throws — invariant violations and
+ * programmer errors should still throw.
+ */
+export type Ok<T> = {
+    readonly ok: true;
+    readonly value: T;
+};
+export type Err<E extends AppError = AppError> = {
+    readonly ok: false;
+    readonly error: E;
+};
+export type Result<T, E extends AppError = AppError> = Ok<T> | Err<E>;
+export declare const ok: <T>(value: T) => Ok<T>;
+export declare const err: <E extends AppError>(error: E) => Err<E>;
+export declare const isOk: <T, E extends AppError>(r: Result<T, E>) => r is Ok<T>;
+export declare const isErr: <T, E extends AppError>(r: Result<T, E>) => r is Err<E>;
+/** Throw on Err, return value on Ok. Use sparingly — defeats the type-level branch. */
+export declare const unwrap: <T, E extends AppError>(r: Result<T, E>) => T;
+export declare const mapResult: <T, U, E extends AppError>(r: Result<T, E>, fn: (value: T) => U) => Result<U, E>;

package/common/src/errors/toAppError.d.ts

@@ -0,0 +1,14 @@
+import { AppError } from './AppError';
+/**
+ * Narrow `unknown` (the type of a catch variable when `useUnknownInCatchVariables` is on)
+ * to an AppError. Pass through existing AppErrors unchanged; wrap raw Errors and other
+ * values in UnknownError, preserving the original via `cause`.
+ *
+ * @example
+ * try {
+ *   await doThing();
+ * } catch (e) {
+ *   throw toAppError(e);
+ * }
+ */
+export declare const toAppError: (caught: unknown, fallbackMessage?: string) => AppError;

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

package/common/src/utils/menu-window-provider.d.ts

@@ -5,7 +5,7 @@ type MenuEventTypes = {
     'response': [ModalResponseEvent];
     'ready': [OpenFin.Identity];
     'update': [string, Partial<OpenFin.Bounds>, string];
-    'modal-opened': [string];
+    'modal-opened': [name: string, parentName: string];
     'modal-closed': [string];
     'search-menu-opening': [string];
     'search-menu-closed': [string];

package/common/src/utils/popup-window.d.ts

@@ -113,12 +113,31 @@ export type RenameSupertabChannelMessage = BasePopupMenuChannelMessage & {
         pageId: string;
     };
 };
+/**
+ * A row in the tab search list. {@link showPin} / {@link showUnpin} are optional; when omitted, no row action.
+ */
+export type TabSearchListItem = {
+    id: string;
+    title: string;
+    /** When true, show a control to pin (move to the user page group). Core UI + ungrouped only. */
+    showPin?: boolean;
+    /** When true, show a control to unpin (leave the user page group). */
+    showUnpin?: boolean;
+    /**
+     * When true, show a non-interactive lock (workspace / platform locked); ungrouped pages only.
+     * Mutually exclusive with {@link showPin} in the browser; does not replace {@link showUnpin}.
+     */
+    showPlatformLocked?: boolean;
+};
 export type TabSearchModalContent = {
     variant: 'page' | 'view';
-    tabs: {
-        title: string;
-        id: string;
-    }[];
+    tabs: TabSearchListItem[];
+};
+/** Channel action: browser → tab-search popup; refreshes list rows after pin/unpin while open. */
+export declare const TAB_SEARCH_CHANNEL_ACTION_UPDATE_TABS: "update-tabs";
+export type TabSearchUpdateTabsMessage = {
+    requestId: string;
+    tabs: TabSearchListItem[];
 };
 export type TabSearchChannelMessage = BasePopupMenuChannelMessage & {
     type: PopupWindowMenuType.TabSearch;

package/common/src/utils/usage-register.d.ts

@@ -15,7 +15,13 @@ export declare enum ComponentName {
     Storefront = "Storefront",
     Platform = "Platform",
     Theming = "Theming",
-    Microflow = "Microflow"
+    Microflow = "Microflow",
+    SuppressWorkspaceSwitched = "SuppressWorkspaceSwitched",
+    SuppressWorkspaceSaved = "SuppressWorkspaceSaved",
+    AllowDuplicatePageTitles = "AllowDuplicatePageTitles",
+    PagePinning = "PagePinning",
+    ViewTabNewTabShortcut = "ViewTabNewTabShortcut",
+    SupertabHideShowTabs = "PRODM-318: Supertab Hide/Show Tab Headers"
 }
 export declare const registerBrowserUsage: (status: RegisterUsageStatus) => void;
 export declare const registerHomeUsage: (status: RegisterUsageStatus) => void;
@@ -25,6 +31,12 @@ export declare const registerNotificationUsage: (status: RegisterUsageStatus) =>
 export declare const registerPlatformUsage: (status: RegisterUsageStatus) => void;
 export declare const registerThemingUsage: (status: RegisterUsageStatus) => void;
 export declare const registerMicroflowUsage: (microflowName: string, status: RegisterUsageStatus) => void;
+export declare const registerSuppressWorkspaceSwitchedUsage: (status: RegisterUsageStatus) => void;
+export declare const registerSuppressWorkspaceSavedUsage: (status: RegisterUsageStatus) => void;
+export declare const registerAllowDuplicatePageTitlesUsage: (status: RegisterUsageStatus) => void;
+export declare const registerPagePinningUsage: (status: RegisterUsageStatus) => void;
+export declare const registerViewTabNewTabShortcutUsage: (status: RegisterUsageStatus) => void;
+export declare const registerSupertabHideShowTabsUsage: () => void;
 export type AnalyticsSource = 'Browser' | 'Dock' | 'Home' | 'Notification' | 'Store' | 'Platform' | 'Theming' | 'Interop';
 /**
  * Event for analytics