@gooddata/sdk-ui-catalog 11.51.0-alpha.1 → 11.51.0-alpha.2

package/esm/catalogDetail/share/CatalogDetailAccessRow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CatalogDetailAccessRow.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogDetailAccessRow.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAYjE;;GAEG;AACH,MAAM,WAAW,4BAA4B;IACzC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,4BAA4B,2CA+CvF"}
+{"version":3,"file":"CatalogDetailAccessRow.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogDetailAccessRow.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAYjE;;GAEG;AACH,MAAM,WAAW,4BAA4B;IACzC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB;AASD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,4BAA4B,2CA8CvF"}

package/esm/catalogDetail/share/CatalogDetailAccessRow.js

@@ -5,6 +5,12 @@ import { UiIcon } from "@gooddata/sdk-ui-kit";
 import { catalogDetailAccessRow, catalogDetailAccessRowSharedLink, catalogDetailAccessRowState, } from "../../automation/testIds.js";
 import { CatalogDetailContentRow } from "../CatalogDetailContentRow.js";
 import { shareMessages } from "./messages.js";
+// Chip copy for each workspace-wide access level.
+const WORKSPACE_ACCESS_ROW_MESSAGE = {
+    EDIT: shareMessages.accessRowWorkspaceEdit,
+    SHARE: shareMessages.accessRowWorkspaceShare,
+    VIEW: shareMessages.accessRowWorkspaceView,
+};
 /**
  * Inline metadata row showing the current access state. Composed of two chips:
  *
@@ -17,11 +23,9 @@ import { shareMessages } from "./messages.js";
 export function CatalogDetailAccessRow({ summary, onOpen }) {
     const intl = useIntl();
     const { generalAccess, workspaceLevel, granteeCount } = summary;
-    const stateText = generalAccess === "RESTRICTED"
-        ? intl.formatMessage(shareMessages.accessRowRestricted)
-        : workspaceLevel === "SHARE"
-            ? intl.formatMessage(shareMessages.accessRowWorkspaceShare)
-            : intl.formatMessage(shareMessages.accessRowWorkspaceView);
+    const stateText = intl.formatMessage(generalAccess === "RESTRICTED"
+        ? shareMessages.accessRowRestricted
+        : WORKSPACE_ACCESS_ROW_MESSAGE[workspaceLevel]);
     const stateIcon = generalAccess === "RESTRICTED" ? "lock" : "building";
     return (_jsx(CatalogDetailContentRow, { title: _jsx(FormattedMessage, { ...shareMessages.accessRowLabel }), content: _jsxs("div", { className: "gd-analytics-catalog-detail__access-row", "data-testid": catalogDetailAccessRow, children: [
                 _jsxs("span", { className: "gd-analytics-catalog-detail__access-row__chip", "data-testid": catalogDetailAccessRowState, children: [

package/esm/catalogDetail/share/CatalogDetailLabels.d.ts

@@ -1,9 +1,9 @@
-import type { IObjectShareLabel } from "@gooddata/sdk-ui-ext";
+import { type IObjectShareLabel } from "@gooddata/sdk-ui-ext";
 /**
  * @internal
  */
 export interface ICatalogDetailLabelsProps {
-    /** Labels of the attribute, primary first is not required — sorted here. */
+    /** Labels of the attribute, already in display order (primary first, then alphabetical). */
     labels: IObjectShareLabel[];
 }
 /**

package/esm/catalogDetail/share/CatalogDetailLabels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CatalogDetailLabels.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogDetailLabels.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAW9D;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,8EAA4E;IAC5E,MAAM,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,MAAM,EAAE,EAAE,yBAAyB,kDA6DxE"}
+{"version":3,"file":"CatalogDetailLabels.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogDetailLabels.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,sBAAsB,CAAC;AAWnF;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC,4FAA4F;IAC5F,MAAM,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,MAAM,EAAE,EAAE,yBAAyB,kDA6DxE"}

package/esm/catalogDetail/share/CatalogDetailLabels.js

@@ -2,6 +2,7 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 // (C) 2026 GoodData Corporation
 import { useMemo } from "react";
 import { useIntl } from "react-intl";
+import { sortShareableLabels } from "@gooddata/sdk-ui-ext";
 import { UiLabelsList, UiPopover } from "@gooddata/sdk-ui-kit";
 import { catalogDetailLabels, catalogDetailLabelsList, catalogDetailLabelsTrigger, } from "../../automation/testIds.js";
 import { labelsMessages } from "./messages.js";
@@ -14,8 +15,11 @@ import { labelsMessages } from "./messages.js";
  */
 export function CatalogDetailLabels({ labels }) {
     const intl = useIntl();
-    // Primary label leads the summary and the list; the rest follow in source order.
-    const ordered = useMemo(() => [...labels].sort((a, b) => Number(b.isPrimary) - Number(a.isPrimary)), [labels]);
+    // Deterministic display order (primary first, then alphabetical) via the
+    // shared helper — the same order the share dialog's label-access checklist
+    // uses, so the two lists never disagree. Sorting here as well keeps the
+    // component robust to an unsorted input.
+    const ordered = useMemo(() => sortShareableLabels(labels), [labels]);
     const items = useMemo(() => ordered.map((label) => ({
         id: label.id,
         label: label.title,

package/esm/catalogDetail/share/CatalogItemAccessRow.d.ts

@@ -1,8 +1,10 @@
 /**
  * Inline access row for the metadata tab, wired to the share context. Renders the
- * current access summary, or a placeholder while it loads (the row stays because
- * Share is still reachable for the object), or nothing when sharing is unavailable.
- * Self-subscribing so it re-renders on access edits without re-rendering the tab.
+ * current access summary, a placeholder while it loads, or an error note when the
+ * summary fetch failed (the row stays in both cases because Share is still
+ * reachable for the object — opening the dialog fetches again and fills the
+ * summary in). Renders nothing when sharing is unavailable. Self-subscribing so
+ * it re-renders on access edits without re-rendering the tab.
  *
  * @internal
  */

package/esm/catalogDetail/share/CatalogItemAccessRow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CatalogItemAccessRow.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogItemAccessRow.tsx"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,mDAqBnC"}
+{"version":3,"file":"CatalogItemAccessRow.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogItemAccessRow.tsx"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,mDA2BnC"}

package/esm/catalogDetail/share/CatalogItemAccessRow.js

@@ -5,26 +5,28 @@ import { UiSkeleton } from "@gooddata/sdk-ui-kit";
 import { CatalogDetailContentRow } from "../CatalogDetailContentRow.js";
 import { CatalogDetailAccessRow } from "./CatalogDetailAccessRow.js";
 import { useCatalogItemShareActions, useCatalogItemShareState } from "./CatalogItemShareProvider.js";
+import { shareMessages } from "./messages.js";
 /**
  * Inline access row for the metadata tab, wired to the share context. Renders the
- * current access summary, or a placeholder while it loads (the row stays because
- * Share is still reachable for the object), or nothing when sharing is unavailable.
- * Self-subscribing so it re-renders on access edits without re-rendering the tab.
+ * current access summary, a placeholder while it loads, or an error note when the
+ * summary fetch failed (the row stays in both cases because Share is still
+ * reachable for the object — opening the dialog fetches again and fills the
+ * summary in). Renders nothing when sharing is unavailable. Self-subscribing so
+ * it re-renders on access edits without re-rendering the tab.
  *
  * @internal
  */
 export function CatalogItemAccessRow() {
-    const { active, controller } = useCatalogItemShareState();
+    const { active, summary, summaryError } = useCatalogItemShareState();
     const { open } = useCatalogItemShareActions();
-    if (!active || !controller) {
+    if (!active) {
         return null;
     }
-    const summary = controller.state.summary;
     if (summary) {
         return _jsx(CatalogDetailAccessRow, { summary: summary, onOpen: open });
     }
-    // Summary not available yet — still loading. A definitive not-permissionable
-    // load failure makes the provider inactive (the row is gone via the guard
-    // above), so this placeholder only covers the genuine loading window.
-    return (_jsx(CatalogDetailContentRow, { title: _jsx(FormattedMessage, { id: "analyticsCatalog.share.access.row.label" }), content: _jsx(UiSkeleton, { itemWidth: 200, itemHeight: 20 }) }));
+    return (_jsx(CatalogDetailContentRow, { title: _jsx(FormattedMessage, { ...shareMessages.accessRowLabel }), content: summaryError ? (
+        // role="alert": the error replaces the skeleton after an async
+        // failure — it must be announced, not just inserted.
+        _jsx("span", { role: "alert", children: _jsx(FormattedMessage, { ...shareMessages.accessRowError }) })) : (_jsx(UiSkeleton, { itemWidth: 200, itemHeight: 20 })) }));
 }

package/esm/catalogDetail/share/CatalogItemShareDialog.d.ts

@@ -1,8 +1,8 @@
 /**
- * Lazy boundary for the catalog item's share dialog. Renders nothing until the
- * dialog is first opened; from then on it stays mounted (so close/reopen is
- * instant) and the dialog's own `isOpen` drives visibility. No-ops when sharing
- * is unavailable.
+ * Lazy boundary for the catalog item's share dialog. Mounted only while the dialog
+ * is open — one mount is one dialog session, and unmounting (close or navigation)
+ * discards the session's transient state. Reopening remounts the component; the
+ * chunk itself stays cached by the browser after the first open.
  *
  * @internal
  */

package/esm/catalogDetail/share/CatalogItemShareDialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CatalogItemShareDialog.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogItemShareDialog.tsx"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,mDAkBrC"}
+{"version":3,"file":"CatalogItemShareDialog.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogItemShareDialog.tsx"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,mDAYrC"}

package/esm/catalogDetail/share/CatalogItemShareDialog.js

@@ -1,28 +1,22 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 // (C) 2026 GoodData Corporation
-import { Suspense, lazy, useState } from "react";
+import { Suspense, lazy } from "react";
 import { useCatalogItemShareState } from "./CatalogItemShareProvider.js";
 // Code-split the dialog (and the heavy kit dialog chrome it pulls from
 // @gooddata/sdk-ui-ext) into its own chunk, loaded on first open rather than with
 // the catalog bundle. The always-visible inline access row stays in the main chunk.
 const CatalogItemShareDialogInner = lazy(() => import("./CatalogItemShareDialogInner.js").then((m) => ({ default: m.CatalogItemShareDialogInner })));
 /**
- * Lazy boundary for the catalog item's share dialog. Renders nothing until the
- * dialog is first opened; from then on it stays mounted (so close/reopen is
- * instant) and the dialog's own `isOpen` drives visibility. No-ops when sharing
- * is unavailable.
+ * Lazy boundary for the catalog item's share dialog. Mounted only while the dialog
+ * is open — one mount is one dialog session, and unmounting (close or navigation)
+ * discards the session's transient state. Reopening remounts the component; the
+ * chunk itself stays cached by the browser after the first open.
  *
  * @internal
  */
 export function CatalogItemShareDialog() {
     const { active, isOpen } = useCatalogItemShareState();
-    // Latch: once opened, keep the lazy dialog mounted so reopening doesn't reload
-    // the chunk or lose the dialog's transient state.
-    const [everOpened, setEverOpened] = useState(false);
-    if (isOpen && !everOpened) {
-        setEverOpened(true);
-    }
-    if (!active || !everOpened) {
+    if (!active || !isOpen) {
         return null;
     }
     return (_jsx(Suspense, { fallback: null, children: _jsx(CatalogItemShareDialogInner, {}) }));

package/esm/catalogDetail/share/CatalogItemShareDialogInner.d.ts

@@ -1,10 +1,11 @@
 /**
  * The connected share dialog, split into its own module so it (and the heavy kit
  * dialog chrome it pulls from `@gooddata/sdk-ui-ext`) is code-split out of the main
- * catalog chunk and loaded only when the dialog is first opened. Reads the shared
- * controller from context so it and the inline access row use one access-list fetch.
+ * catalog chunk and loaded only when the dialog is first opened. Mounted per dialog
+ * session (see {@link CatalogItemShareDialog}); it reports summary changes back to
+ * the provider so the inline access row stays in sync without a refetch.
  *
  * @internal
  */
-export declare function CatalogItemShareDialogInner(): import("react/jsx-runtime").JSX.Element | null;
+export declare function CatalogItemShareDialogInner(): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=CatalogItemShareDialogInner.d.ts.map

package/esm/catalogDetail/share/CatalogItemShareDialogInner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CatalogItemShareDialogInner.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogItemShareDialogInner.tsx"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,mDAkB1C"}
+{"version":3,"file":"CatalogItemShareDialogInner.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogItemShareDialogInner.tsx"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,4CAgB1C"}

package/esm/catalogDetail/share/CatalogItemShareDialogInner.js

@@ -5,16 +5,14 @@ import { useCatalogItemShareActions, useCatalogItemShareState } from "./CatalogI
 /**
  * The connected share dialog, split into its own module so it (and the heavy kit
  * dialog chrome it pulls from `@gooddata/sdk-ui-ext`) is code-split out of the main
- * catalog chunk and loaded only when the dialog is first opened. Reads the shared
- * controller from context so it and the inline access row use one access-list fetch.
+ * catalog chunk and loaded only when the dialog is first opened. Mounted per dialog
+ * session (see {@link CatalogItemShareDialog}); it reports summary changes back to
+ * the provider so the inline access row stays in sync without a refetch.
  *
  * @internal
  */
 export function CatalogItemShareDialogInner() {
-    const { controller, target, objectTitle, isOpen, labelsLoading } = useCatalogItemShareState();
-    const { close } = useCatalogItemShareActions();
-    if (!controller) {
-        return null;
-    }
-    return (_jsx(ObjectShareDialog, { target: target, objectTitle: objectTitle, isOpen: isOpen, onClose: close, labelsLoading: labelsLoading, controller: controller }));
+    const { target, objectTitle, labels } = useCatalogItemShareState();
+    const { close, onSummaryChange } = useCatalogItemShareActions();
+    return (_jsx(ObjectShareDialog, { target: target, objectTitle: objectTitle, isOpen: true, onClose: close, labels: labels.labels, labelsError: labels.error, labelsLoading: labels.loading, onSummaryChange: onSummaryChange }));
 }

package/esm/catalogDetail/share/CatalogItemShareProvider.d.ts

@@ -1,32 +1,45 @@
 import { type ReactNode } from "react";
 import type { IObjectPermissionsObject } from "@gooddata/sdk-backend-spi";
-import { type IObjectShareController } from "@gooddata/sdk-ui-ext";
+import { type IObjectAccessSummary } from "@gooddata/sdk-ui-ext";
 import type { ShareableCatalogItem } from "./types.js";
 import type { IShareableLabels } from "./useShareableLabels.js";
 /**
- * Live share state for the catalog item. Consumed by the inline access row and the
- * share dialog, which re-render as the controller's state changes. `active` is false
- * when the item can't be shared (flag off / not a shareable kind), so consumers can
- * render nothing without conditional hooks.
+ * Page-level share state for the catalog item: the latest known access summary and
+ * the dialog-open flag. `active` is false when the item can't be shared (flag off /
+ * not a shareable kind / permissions unavailable), so consumers can render nothing
+ * without conditional hooks.
  */
 interface ICatalogItemShareState {
     active: boolean;
-    controller: IObjectShareController | undefined;
+    /**
+     * Latest known access summary — seeded by the page-level fetch, then kept in
+     * sync by the open dialog's `onSummaryChange`. Undefined while loading.
+     */
+    summary: IObjectAccessSummary | undefined;
+    /**
+     * Whether the page-level summary fetch failed transiently (a definitive
+     * not-permissionable failure turns the whole feature inactive instead).
+     * Sharing stays offered — opening the dialog runs its own fetch, whose
+     * `onSummaryChange` report then fills the summary in.
+     */
+    summaryError: boolean;
     target: IObjectPermissionsObject | undefined;
     objectTitle: string;
-    /** Whether the share dialog is open. */
+    /** Whether the share dialog is open (and should be mounted). */
     isOpen: boolean;
-    /** Whether the item's labels are still loading (passed to the dialog). */
-    labelsLoading: boolean;
+    /** The item's labels bundle, forwarded to the dialog. */
+    labels: IShareableLabels;
 }
 /**
- * Stable open/close actions for the share dialog. Split from the state so an
- * actions-only consumer (the Share button) never re-renders on a state tick.
+ * Stable share actions. Split from the state so an actions-only consumer (the
+ * Share button) never re-renders on a state tick.
  */
 interface ICatalogItemShareActions {
     active: boolean;
     open: () => void;
     close: () => void;
+    /** The dialog reports summary changes here, keeping the inline row in sync without refetching. */
+    onSummaryChange: (summary: IObjectAccessSummary) => void;
 }
 /**
  * @internal
@@ -41,28 +54,30 @@ export interface ICatalogItemShareProviderProps {
     children: ReactNode;
 }
 /**
- * Owns the share controller, its single access-list fetch and the dialog open
- * state for one catalog item, and exposes them through two contexts (state +
- * actions). Because it renders `children` and the live state is read only by the
- * leaf components that need it (access row, dialog), the surrounding detail
- * subtree — header, tabs, status — does not re-render as access is edited.
+ * Owns the PAGE state of sharing for one catalog item: the initial access-summary
+ * fetch (the inline access row is visible before the dialog ever opens, so the page
+ * fetches its own summary) and the dialog-open flag. The dialog itself is a separate,
+ * session-scoped component — mounted only while open, owning its own controller and
+ * fetch — that reports summary changes back through `onSummaryChange`, so the row
+ * stays in sync with edits without a refetch.
  *
- * No-ops cleanly when the item can't be shared: the contexts then carry an
- * inactive value and the hooks below report `active: false`.
+ * No-ops cleanly when the item can't be shared: the contexts then carry an inactive
+ * value and the hooks below report `active: false`.
  *
  * @internal
  */
 export declare function CatalogItemShareProvider({ shareableItem, target, labels, children }: ICatalogItemShareProviderProps): import("react/jsx-runtime").JSX.Element;
 /**
- * Live share state (controller, summary, open flag) for the current catalog item.
+ * Page share state (summary, open flag, dialog inputs) for the current catalog item.
  * Reports `active: false` when sharing is unavailable.
  *
  * @internal
  */
 export declare function useCatalogItemShareState(): ICatalogItemShareState;
 /**
- * Stable share actions (open/close the dialog) for the current catalog item.
- * Reading this instead of the state keeps a consumer from re-rendering on state ticks.
+ * Stable share actions (open/close the dialog, receive summary updates) for the
+ * current catalog item. Reading this instead of the state keeps a consumer from
+ * re-rendering on state ticks.
  *
  * @internal
  */

package/esm/catalogDetail/share/CatalogItemShareProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CatalogItemShareProvider.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogItemShareProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAA6D,MAAM,OAAO,CAAC;AAElG,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,EAAE,KAAK,sBAAsB,EAAkB,MAAM,sBAAsB,CAAC;AAEnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;GAKG;AACH,UAAU,sBAAsB;IAC5B,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAC/C,MAAM,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,MAAM,EAAE,OAAO,CAAC;IAChB,0EAA0E;IAC1E,aAAa,EAAE,OAAO,CAAC;CAC1B;AAED;;;GAGG;AACH,UAAU,wBAAwB;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,IAAI,CAAC;CACrB;AAiBD;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC3C,+FAA+F;IAC/F,aAAa,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAChD,sDAAsD;IACtD,MAAM,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAC7C,mFAAmF;IACnF,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,SAAS,CAAC;CACvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,EACrC,aAAa,EACb,MAAM,EACN,MAAM,EACN,QAAQ,EACX,EAAE,8BAA8B,2CA4DhC;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,sBAAsB,CAEjE;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,IAAI,wBAAwB,CAErE"}
+{"version":3,"file":"CatalogItemShareProvider.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/CatalogItemShareProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAA6D,MAAM,OAAO,CAAC;AAElG,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAG1E,OAAO,EACH,KAAK,oBAAoB,EAG5B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;GAKG;AACH,UAAU,sBAAsB;IAC5B,MAAM,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAC1C;;;;;OAKG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB,MAAM,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,MAAM,EAAE,OAAO,CAAC;IAChB,yDAAyD;IACzD,MAAM,EAAE,gBAAgB,CAAC;CAC5B;AAED;;;GAGG;AACH,UAAU,wBAAwB;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,kGAAkG;IAClG,eAAe,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAC;CAC5D;AAyBD;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC3C,+FAA+F;IAC/F,aAAa,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAChD,sDAAsD;IACtD,MAAM,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAC7C,mFAAmF;IACnF,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,SAAS,CAAC;CACvB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,EACrC,aAAa,EACb,MAAM,EACN,MAAM,EACN,QAAQ,EACX,EAAE,8BAA8B,2CA2FhC;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,IAAI,sBAAsB,CAEjE;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,IAAI,wBAAwB,CAErE"}

package/esm/catalogDetail/share/CatalogItemShareProvider.js

@@ -1,79 +1,111 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 // (C) 2026 GoodData Corporation
 import { createContext, useCallback, useContext, useMemo, useState } from "react";
-import { useObjectShare } from "@gooddata/sdk-ui-ext";
+import { useBackendStrict, useCancelablePromise, useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { accessListToSummary, isPermissionsNotAvailable, } from "@gooddata/sdk-ui-ext";
+const NO_LABELS = { labels: [], loading: false, error: false };
 const INACTIVE_STATE = {
     active: false,
-    controller: undefined,
+    summary: undefined,
+    summaryError: false,
     target: undefined,
     objectTitle: "",
     isOpen: false,
-    labelsLoading: false,
+    labels: NO_LABELS,
 };
 const noop = () => { };
-const INACTIVE_ACTIONS = { active: false, open: noop, close: noop };
+const INACTIVE_ACTIONS = {
+    active: false,
+    open: noop,
+    close: noop,
+    onSummaryChange: noop,
+};
 const ShareStateContext = createContext(INACTIVE_STATE);
 const ShareActionsContext = createContext(INACTIVE_ACTIONS);
 /**
- * Owns the share controller, its single access-list fetch and the dialog open
- * state for one catalog item, and exposes them through two contexts (state +
- * actions). Because it renders `children` and the live state is read only by the
- * leaf components that need it (access row, dialog), the surrounding detail
- * subtree — header, tabs, status — does not re-render as access is edited.
+ * Owns the PAGE state of sharing for one catalog item: the initial access-summary
+ * fetch (the inline access row is visible before the dialog ever opens, so the page
+ * fetches its own summary) and the dialog-open flag. The dialog itself is a separate,
+ * session-scoped component — mounted only while open, owning its own controller and
+ * fetch — that reports summary changes back through `onSummaryChange`, so the row
+ * stays in sync with edits without a refetch.
  *
- * No-ops cleanly when the item can't be shared: the contexts then carry an
- * inactive value and the hooks below report `active: false`.
+ * No-ops cleanly when the item can't be shared: the contexts then carry an inactive
+ * value and the hooks below report `active: false`.
  *
  * @internal
  */
 export function CatalogItemShareProvider({ shareableItem, target, labels, children, }) {
-    // One controller drives both the dialog and the inline access row; the row reads
-    // `state.summary`, so a save inside the dialog refreshes it too. labelsLoading/
-    // labelsError keep the controller label-unresolved while labels are pending.
-    const [isOpen, setIsOpen] = useState(false);
-    const controller = useObjectShare(target, {
-        labels: labels.labels,
-        labelsError: labels.error,
-        labelsLoading: labels.loading,
-        isOpen,
-    });
-    // The detail view is reused as the user navigates between objects, so close an
-    // open dialog when the shareable target changes (or becomes non-shareable) —
-    // otherwise it would linger open on the next object. Reset during render (React's
-    // "adjust state on prop change" idiom) rather than in an effect.
-    const targetKey = shareableItem?.identifier;
-    const [openForKey, setOpenForKey] = useState(undefined);
-    if (isOpen && openForKey !== targetKey) {
-        setIsOpen(false);
+    const backend = useBackendStrict();
+    const workspace = useWorkspaceStrict();
+    // The page-session boundary: everything below (summary, open flag, the fetch) is
+    // scoped to this key. Workspace and kind are part of it — the same identifier can
+    // reappear under another workspace (or as another object kind), and the previous
+    // summary/dialog must not survive into it.
+    const itemKey = shareableItem
+        ? `${workspace}:${shareableItem.type}:${shareableItem.identifier}`
+        : undefined;
+    const [summary, setSummary] = useState(undefined);
+    // Which item's dialog is open. Navigating to another item changes `itemKey`, so
+    // `isOpen` turns false and the dialog unmounts.
+    const [dialogFor, setDialogFor] = useState(undefined);
+    // Both the summary and the open flag belong to one item under one backend —
+    // drop them when either changes. Item change: the new item shows its loading
+    // skeleton instead of the previous item's access, and navigating BACK to an
+    // item whose dialog was open must not reopen it (a lingering `dialogFor`
+    // would match the returning key). Backend change (compared by reference —
+    // an instance has no string identity to fold into `itemKey`): the previous
+    // backend's summary must not survive into the new one, and clearing
+    // `dialogFor` unmounts the dialog session, discarding its edit overlay and
+    // staged state with it.
+    const [seenScope, setSeenScope] = useState({ backend, itemKey });
+    if (seenScope.backend !== backend || seenScope.itemKey !== itemKey) {
+        setSeenScope({ backend, itemKey });
+        setSummary(undefined);
+        setDialogFor(undefined);
     }
-    const open = useCallback(() => {
-        setOpenForKey(targetKey);
-        setIsOpen(true);
-    }, [targetKey]);
-    const close = useCallback(() => setIsOpen(false), []);
+    // The page-level summary fetch runs only while the summary is UNKNOWN: once
+    // anything seeds it — this fetch, or the dialog's `onSummaryChange` report (the
+    // dialog session fetches on its own) — the promise clears, so an open dialog
+    // never runs alongside a page fetch and a close never refetches. The item-change
+    // reset above clears the summary, which re-arms the fetch. The `prev ??` seed
+    // guard covers the resolve-vs-cancel race.
+    const summaryUnknown = summary === undefined;
+    const { status, error } = useCancelablePromise({
+        promise: target && summaryUnknown
+            ? () => backend.workspace(workspace).objectPermissions().getAccessList(target)
+            : undefined,
+        onSuccess: (list) => setSummary((prev) => prev ?? accessListToSummary(list)),
+        onError: () => { },
+    }, [backend, workspace, itemKey, summaryUnknown]);
     // Sharing is offered only while the access list is reachable. The permissions
     // endpoint is manage-gated, so a user who can only view/analyze the object gets
-    // a 404 (surfaced as `accessUnavailable`); we then hide both the Share button and
-    // the inline access row — there is nothing they can act on, and the row would
-    // otherwise load forever. A transient load error does not set the flag, so a flaky
-    // fetch doesn't strip the UI. The access list loads optimistically, so the row and
-    // button show until the 404 lands, then disappear.
-    const active = Boolean(shareableItem) && !controller.state.accessUnavailable;
+    // a 404; we then hide both the Share button and the inline access row — there is
+    // nothing they can act on. A transient load error does not set the flag, so a
+    // flaky fetch doesn't strip the UI — it is reported as `summaryError` instead,
+    // so the access row can show an error rather than load forever.
+    const accessUnavailable = status === "error" && isPermissionsNotAvailable(error);
+    const active = Boolean(shareableItem) && !accessUnavailable;
+    const summaryError = status === "error" && !accessUnavailable;
+    const isOpen = dialogFor !== undefined && dialogFor === itemKey;
+    const open = useCallback(() => setDialogFor(itemKey), [itemKey]);
+    const close = useCallback(() => setDialogFor(undefined), []);
     const state = useMemo(() => active && shareableItem
         ? {
             active: true,
-            controller,
+            summary,
+            summaryError,
             target,
             objectTitle: shareableItem.title,
             isOpen,
-            labelsLoading: labels.loading,
+            labels,
         }
-        : INACTIVE_STATE, [active, shareableItem, controller, target, isOpen, labels.loading]);
-    const actions = useMemo(() => (active ? { active: true, open, close } : INACTIVE_ACTIONS), [active, open, close]);
+        : INACTIVE_STATE, [active, shareableItem, summary, summaryError, target, isOpen, labels]);
+    const actions = useMemo(() => (active ? { active: true, open, close, onSummaryChange: setSummary } : INACTIVE_ACTIONS), [active, open, close]);
     return (_jsx(ShareActionsContext.Provider, { value: actions, children: _jsx(ShareStateContext.Provider, { value: state, children: children }) }));
 }
 /**
- * Live share state (controller, summary, open flag) for the current catalog item.
+ * Page share state (summary, open flag, dialog inputs) for the current catalog item.
  * Reports `active: false` when sharing is unavailable.
  *
  * @internal
@@ -82,8 +114,9 @@ export function useCatalogItemShareState() {
     return useContext(ShareStateContext);
 }
 /**
- * Stable share actions (open/close the dialog) for the current catalog item.
- * Reading this instead of the state keeps a consumer from re-rendering on state ticks.
+ * Stable share actions (open/close the dialog, receive summary updates) for the
+ * current catalog item. Reading this instead of the state keeps a consumer from
+ * re-rendering on state ticks.
  *
  * @internal
  */

package/esm/catalogDetail/share/messages.d.ts

@@ -10,6 +10,9 @@ export declare const shareMessages: {
     accessRowLabel: {
         id: string;
     };
+    accessRowError: {
+        id: string;
+    };
     accessRowRestricted: {
         id: string;
     };
@@ -19,6 +22,9 @@ export declare const shareMessages: {
     accessRowWorkspaceShare: {
         id: string;
     };
+    accessRowWorkspaceEdit: {
+        id: string;
+    };
     accessRowSharedWith: {
         id: string;
     };

package/esm/catalogDetail/share/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/messages.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;CAOxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAKzB,CAAC"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/messages.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;CASxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAKzB,CAAC"}

package/esm/catalogDetail/share/messages.js

@@ -8,9 +8,11 @@ import { defineMessages } from "react-intl";
 export const shareMessages = defineMessages({
     shareButton: { id: "analyticsCatalog.share.button" },
     accessRowLabel: { id: "analyticsCatalog.share.access.row.label" },
+    accessRowError: { id: "analyticsCatalog.share.access.row.error" },
     accessRowRestricted: { id: "analyticsCatalog.share.access.row.restricted" },
     accessRowWorkspaceView: { id: "analyticsCatalog.share.access.row.workspace.view" },
     accessRowWorkspaceShare: { id: "analyticsCatalog.share.access.row.workspace.share" },
+    accessRowWorkspaceEdit: { id: "analyticsCatalog.share.access.row.workspace.edit" },
     accessRowSharedWith: { id: "analyticsCatalog.share.access.row.sharedWith" },
 });
 /**

package/esm/catalogDetail/share/useShareableLabels.d.ts

@@ -1,4 +1,4 @@
-import type { IObjectShareLabel } from "@gooddata/sdk-ui-ext";
+import { type IObjectShareLabel } from "@gooddata/sdk-ui-ext";
 import type { ShareableCatalogItem } from "./types.js";
 /**
  * @internal

package/esm/catalogDetail/share/useShareableLabels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useShareableLabels.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/useShareableLabels.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,8EAA8E;IAC9E,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,oBAAoB,GAAG,SAAS,GAAG,gBAAgB,CAsC3F"}
+{"version":3,"file":"useShareableLabels.d.ts","sourceRoot":"","sources":["../../../src/catalogDetail/share/useShareableLabels.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,sBAAsB,CAAC;AAEnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,8EAA8E;IAC9E,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,oBAAoB,GAAG,SAAS,GAAG,gBAAgB,CA2C3F"}

package/esm/catalogDetail/share/useShareableLabels.js

@@ -2,6 +2,7 @@
 import { useMemo } from "react";
 import { objRefToString } from "@gooddata/sdk-model";
 import { useBackendStrict, useCancelablePromise, useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { sortShareableLabels } from "@gooddata/sdk-ui-ext";
 /**
  * Loads the labels (display forms) of a shareable attribute so the share dialog
  * can scope a grantee's access per label. Facts and measures have no labels —
@@ -23,13 +24,17 @@ export function useShareableLabels(item) {
                 .getAttribute({ identifier: attributeRef, type: "attribute" })
             : undefined,
     }, [backend, workspace, attributeRef]);
-    const labels = useMemo(() => (result?.displayForms ?? []).map((df) => ({
+    const labels = useMemo(() => 
+    // Sort once at the source so the detail-page labels popup and the share
+    // dialog's label-access checklist — both fed from here — share one
+    // deterministic order (primary first, then alphabetical).
+    sortShareableLabels((result?.displayForms ?? []).map((df) => ({
         ref: df.ref,
         id: objRefToString(df.ref),
         title: df.title,
         isPrimary: df.isPrimary === true,
         isDefault: df.isDefault === true,
-    })), [result]);
+    }))), [result]);
     // Facts and measures have no fetch, so they never "load". An attribute loads
     // until its fetch settles (success or error).
     const loading = attributeRef !== undefined && status !== "success" && status !== "error";

package/esm/localization/bundles/en-US.localization-bundle.d.ts

@@ -943,6 +943,10 @@ export declare const en_US: {
         text: string;
         crowdinContext: string;
     };
+    "analyticsCatalog.share.access.row.error": {
+        text: string;
+        crowdinContext: string;
+    };
     "analyticsCatalog.share.access.row.restricted": {
         text: string;
         crowdinContext: string;
@@ -955,6 +959,10 @@ export declare const en_US: {
         text: string;
         crowdinContext: string;
     };
+    "analyticsCatalog.share.access.row.workspace.edit": {
+        text: string;
+        crowdinContext: string;
+    };
     "analyticsCatalog.share.access.row.sharedWith": {
         text: string;
         crowdinContext: string;

package/esm/localization/bundles/en-US.localization-bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en-US.localization-bundle.d.ts","sourceRoot":"","sources":["../../../src/localization/bundles/en-US.localization-bundle.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAi9BjB,CAAC"}
+{"version":3,"file":"en-US.localization-bundle.d.ts","sourceRoot":"","sources":["../../../src/localization/bundles/en-US.localization-bundle.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAy9BjB,CAAC"}

package/esm/localization/bundles/en-US.localization-bundle.js

@@ -945,6 +945,10 @@ export const en_US = {
         "text": "Access",
         "crowdinContext": "Label for the row in the catalog detail metadata grid that shows the current sharing state of the object."
     },
+    "analyticsCatalog.share.access.row.error": {
+        "text": "Couldn't load access.",
+        "crowdinContext": "Shown in the catalog detail Access row when loading the access summary failed; opening the Share dialog retries the load."
+    },
     "analyticsCatalog.share.access.row.restricted": {
         "text": "Restricted",
         "crowdinContext": "State chip text shown when the object's access is restricted to explicitly listed grantees only."
@@ -957,8 +961,12 @@ export const en_US = {
         "text": "All workspace users can share",
         "crowdinContext": "State chip text shown when every workspace user has view+share access to the object."
     },
+    "analyticsCatalog.share.access.row.workspace.edit": {
+        "text": "All workspace users can edit",
+        "crowdinContext": "State chip text shown when every workspace user has edit access to the object."
+    },
     "analyticsCatalog.share.access.row.sharedWith": {
-        "text": "Shared with {count, plural, one {# user or group} other {# users or groups}}",
+        "text": "Shared with {count, plural, one {# user/group} other {# users/groups}}",
         "crowdinContext": "Clickable summary in the catalog detail Access row. Opens the share dialog. Placeholder is the count of named grantees (users and groups)."
     },
     "analyticsCatalog.labels.more": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-catalog",
-  "version": "11.51.0-alpha.1",
+  "version": "11.51.0-alpha.2",
   "description": "GoodData SDK - Analytics Catalog",
   "license": "MIT",
   "author": "GoodData Corporation",
@@ -41,15 +41,15 @@
     "tslib": "2.8.1",
     "yaml": "2.8.3",
     "zod": "4.3.6",
-    "@gooddata/sdk-backend-spi": "11.51.0-alpha.1",
-    "@gooddata/sdk-code-schemas": "11.51.0-alpha.1",
-    "@gooddata/sdk-model": "11.51.0-alpha.1",
-    "@gooddata/sdk-ui": "11.51.0-alpha.1",
-    "@gooddata/sdk-ui-ext": "11.51.0-alpha.1",
-    "@gooddata/sdk-ui-kit": "11.51.0-alpha.1",
-    "@gooddata/sdk-ui-semantic-search": "11.51.0-alpha.1",
-    "@gooddata/sdk-ui-theme-provider": "11.51.0-alpha.1",
-    "@gooddata/util": "11.51.0-alpha.1"
+    "@gooddata/sdk-backend-spi": "11.51.0-alpha.2",
+    "@gooddata/sdk-code-schemas": "11.51.0-alpha.2",
+    "@gooddata/sdk-model": "11.51.0-alpha.2",
+    "@gooddata/sdk-ui-ext": "11.51.0-alpha.2",
+    "@gooddata/sdk-ui": "11.51.0-alpha.2",
+    "@gooddata/sdk-ui-kit": "11.51.0-alpha.2",
+    "@gooddata/sdk-ui-semantic-search": "11.51.0-alpha.2",
+    "@gooddata/util": "11.51.0-alpha.2",
+    "@gooddata/sdk-ui-theme-provider": "11.51.0-alpha.2"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "^7.17.0",
@@ -89,11 +89,11 @@
     "typescript": "5.9.3",
     "vitest": "4.1.8",
     "vitest-dom": "0.1.1",
-    "@gooddata/eslint-config": "11.51.0-alpha.1",
-    "@gooddata/i18n-toolkit": "11.51.0-alpha.1",
-    "@gooddata/oxlint-config": "11.51.0-alpha.1",
-    "@gooddata/sdk-backend-mockingbird": "11.51.0-alpha.1",
-    "@gooddata/stylelint-config": "11.51.0-alpha.1"
+    "@gooddata/eslint-config": "11.51.0-alpha.2",
+    "@gooddata/i18n-toolkit": "11.51.0-alpha.2",
+    "@gooddata/oxlint-config": "11.51.0-alpha.2",
+    "@gooddata/sdk-backend-mockingbird": "11.51.0-alpha.2",
+    "@gooddata/stylelint-config": "11.51.0-alpha.2"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",