@gooddata/sdk-ui-catalog 11.50.0-alpha.2 → 11.50.0-alpha.3

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

@@ -863,6 +863,78 @@ export declare const en_US: {
         text: string;
         crowdinContext: string;
     };
+    "analyticsCatalog.visualization.dialog.create.title": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.dialog.edit.title": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.dialog.sectionHeader": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.dialog.sectionHeader.tooltip": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.actions.openInAnalyticalDesigner": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.dialog.edit.duplicate": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.dialog.help": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.dialog.submit.error": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.create.defaultTitle": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.create.success": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.update.success": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.load.error": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.dialog.delete.title": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.dialog.delete.body": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.dialog.delete.usageWarning": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.dialog.delete.submit": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.delete.success": {
+        text: string;
+        crowdinContext: string;
+    };
+    "analyticsCatalog.visualization.delete.error": {
+        text: string;
+        crowdinContext: string;
+    };
     "analyticsCatalog.share.button": {
         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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAy4BjB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAi9BjB,CAAC"}

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

@@ -865,6 +865,78 @@ export const en_US = {
         "text": "Metric could not be deleted.",
         "crowdinContext": "Error toast shown when metric deletion fails."
     },
+    "analyticsCatalog.visualization.dialog.create.title": {
+        "text": "Create visualization",
+        "crowdinContext": "Title of the dialog for creating a new visualization as code."
+    },
+    "analyticsCatalog.visualization.dialog.edit.title": {
+        "text": "Edit visualization",
+        "crowdinContext": "Title of the dialog for editing a visualization as code."
+    },
+    "analyticsCatalog.visualization.dialog.sectionHeader": {
+        "text": "Visualization definition",
+        "crowdinContext": "Header above the as-code editor in the visualization dialog."
+    },
+    "analyticsCatalog.visualization.dialog.sectionHeader.tooltip": {
+        "text": "Define the visualization in YAML, including its type, query, and configuration.",
+        "crowdinContext": "Tooltip explaining the as-code visualization editor."
+    },
+    "analyticsCatalog.visualization.actions.openInAnalyticalDesigner": {
+        "text": "Open in Analytical Designer",
+        "crowdinContext": "Detail-panel menu action that opens the visualization in Analytical Designer (as opposed to the inline as-code editor)."
+    },
+    "analyticsCatalog.visualization.dialog.edit.duplicate": {
+        "text": "Duplicate",
+        "crowdinContext": "Button that duplicates the visualization being edited into a new visualization."
+    },
+    "analyticsCatalog.visualization.dialog.help": {
+        "text": "How to write a visualization",
+        "crowdinContext": "Help link in the visualization as-code dialog."
+    },
+    "analyticsCatalog.visualization.dialog.submit.error": {
+        "text": "The visualization could not be saved.",
+        "crowdinContext": "Generic error shown when saving a visualization fails."
+    },
+    "analyticsCatalog.visualization.create.defaultTitle": {
+        "text": "My visualization",
+        "crowdinContext": "Default placeholder title seeded into the new-visualization as-code editor before the user types their own."
+    },
+    "analyticsCatalog.visualization.create.success": {
+        "text": "Visualization created.",
+        "crowdinContext": "Toast shown after a visualization is created successfully from the Analytics Catalog."
+    },
+    "analyticsCatalog.visualization.update.success": {
+        "text": "Visualization saved.",
+        "crowdinContext": "Toast shown after a visualization is updated successfully from the Analytics Catalog."
+    },
+    "analyticsCatalog.visualization.load.error": {
+        "text": "The visualization could not be loaded.",
+        "crowdinContext": "Error toast shown when loading a visualization for editing or duplication fails."
+    },
+    "analyticsCatalog.visualization.dialog.delete.title": {
+        "text": "Delete visualization",
+        "crowdinContext": "Title of the confirmation dialog for deleting a visualization."
+    },
+    "analyticsCatalog.visualization.dialog.delete.body": {
+        "text": "Are you sure you want to delete <b>{name}</b>?",
+        "crowdinContext": "Body of the confirmation dialog for deleting a visualization. {name} is the visualization title."
+    },
+    "analyticsCatalog.visualization.dialog.delete.usageWarning": {
+        "text": "This visualization is used by {count, plural, one {# dashboard} other {# dashboards}}. Deleting it may break them.",
+        "crowdinContext": "Warning shown in the visualization delete dialog when the visualization is referenced by dashboards."
+    },
+    "analyticsCatalog.visualization.dialog.delete.submit": {
+        "text": "Delete",
+        "crowdinContext": "Submit button of the delete visualization confirmation dialog."
+    },
+    "analyticsCatalog.visualization.delete.success": {
+        "text": "Visualization deleted.",
+        "crowdinContext": "Toast shown after a visualization is deleted successfully from the Analytics Catalog."
+    },
+    "analyticsCatalog.visualization.delete.error": {
+        "text": "Visualization could not be deleted.",
+        "crowdinContext": "Error toast shown when visualization deletion fails."
+    },
     "analyticsCatalog.share.button": {
         "text": "Share",
         "crowdinContext": "Button label opening the share dialog from the catalog detail page."

package/esm/metric/gate.d.ts

@@ -1,8 +1,3 @@
-/** The flag gating the in-catalog metric editor. The single source of truth, referenced by both the
- *  gate below and `metricDescriptor.featureFlag`. */
+/** The flag gating the in-catalog metric editor, referenced by `metricDescriptor.featureFlag`. */
 export declare const METRIC_EDITOR_FEATURE_FLAG = "enableAnalyticalCatalogMetricEditor";
-/**
- * Whether the current user can create and edit metrics inline in the catalog.
- */
-export declare function useCanManageMetric(): boolean;
 //# sourceMappingURL=gate.d.ts.map

package/esm/metric/gate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../src/metric/gate.ts"],"names":[],"mappings":"AAIA;qDACqD;AACrD,eAAO,MAAM,0BAA0B,wCAAwC,CAAC;AAEhF;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C"}
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../src/metric/gate.ts"],"names":[],"mappings":"AAEA,kGAAkG;AAClG,eAAO,MAAM,0BAA0B,wCAAwC,CAAC"}

package/esm/metric/gate.js

@@ -1,11 +1,3 @@
 // (C) 2026 GoodData Corporation
-import { useCanManageAsCode } from "../asCode/gate.js";
-/** The flag gating the in-catalog metric editor. The single source of truth, referenced by both the
- *  gate below and `metricDescriptor.featureFlag`. */
+/** The flag gating the in-catalog metric editor, referenced by `metricDescriptor.featureFlag`. */
 export const METRIC_EDITOR_FEATURE_FLAG = "enableAnalyticalCatalogMetricEditor";
-/**
- * Whether the current user can create and edit metrics inline in the catalog.
- */
-export function useCanManageMetric() {
-    return useCanManageAsCode(METRIC_EDITOR_FEATURE_FLAG);
-}

package/esm/metric/metricConverter.d.ts

@@ -1,5 +1,5 @@
 import type { v1 } from "@gooddata/sdk-code-schemas";
-import type { IMeasureMetadataObject, IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
+import type { IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
 import type { MetricSchema } from "./metricSchema.js";
 /**
  * Canonical AAC metric object with an optional `id`.
@@ -27,23 +27,14 @@ export declare function definitionToMetricYaml(definition: IMeasureMetadataObjec
  */
 export declare function metricYamlToDefinition(metric: MetricSchema): IMeasureMetadataObjectDefinition;
 /**
- * Overlays the fields the as-code YAML owns onto a base measure, keeping the base's identity and the
- * fields the YAML cannot express (`metricType`, `isHiddenFromKda`, ...).
+ * The metric's `reconcile`: layers the author's parsed YAML edits over the base definition — the
+ * loaded measure on an edit, the copy source on a duplicate.
  *
- * Used wherever YAML edits are committed onto an existing measure: the update flow overlays onto the
- * loaded metric, and duplicating from the edit dialog seeds the copy from the metric being edited.
- * Duplicating from the detail panel instead needs YAML-authoritative identity — see
- * {@link mergeCopiedMetricDefinition}.
- */
-export declare function overlayMetricYamlFields(base: IMeasureMetadataObject, yamlDefinition: IMeasureMetadataObjectDefinition): IMeasureMetadataObject;
-/**
- * Builds the definition to persist when duplicating a metric, layering the author's YAML edits over
- * the copied source.
- *
- * The source carries fields the YAML cannot express (`metricType`, `isHiddenFromKda`), which survive
+ * The base carries fields the YAML cannot express (`metricType`, `isHiddenFromKda`), which survive
  * because only the YAML-owned fields are overlaid on top. Identity stays YAML-authoritative: the
- * parsed `id` wins, and its absence lets the server derive a fresh one, so the copied source's id is
- * intentionally dropped from the base first.
+ * parsed `id` wins, and its absence lets the server derive a fresh one, so the base's id is
+ * intentionally dropped first. (On an edit this is moot — validation pins the parsed id to the loaded
+ * object's — but on a duplicate it is what frees the copy from the source's identity.)
  */
-export declare function mergeCopiedMetricDefinition(copiedMetric: IMeasureMetadataObjectDefinition, yamlDefinition: IMeasureMetadataObjectDefinition): IMeasureMetadataObjectDefinition;
+export declare function reconcileMetricDefinition(base: IMeasureMetadataObjectDefinition, edited: IMeasureMetadataObjectDefinition): IMeasureMetadataObjectDefinition;
 //# sourceMappingURL=metricConverter.d.ts.map

package/esm/metric/metricConverter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metricConverter.d.ts","sourceRoot":"","sources":["../../src/metric/metricConverter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,4BAA4B,CAAC;AACrD,OAAO,KAAK,EAAE,sBAAsB,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAEpG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjE;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,gCAAgC,GAAG,UAAU,CAW/F;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,YAAY,GAAG,gCAAgC,CAY7F;AAsCD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACnC,IAAI,EAAE,sBAAsB,EAC5B,cAAc,EAAE,gCAAgC,GACjD,sBAAsB,CAKxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACvC,YAAY,EAAE,gCAAgC,EAC9C,cAAc,EAAE,gCAAgC,GACjD,gCAAgC,CAOlC"}
+{"version":3,"file":"metricConverter.d.ts","sourceRoot":"","sources":["../../src/metric/metricConverter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,4BAA4B,CAAC;AACrD,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAE5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjE;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,gCAAgC,GAAG,UAAU,CAW/F;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,YAAY,GAAG,gCAAgC,CAY7F;AAsCD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACrC,IAAI,EAAE,gCAAgC,EACtC,MAAM,EAAE,gCAAgC,GACzC,gCAAgC,CAOlC"}

package/esm/metric/metricConverter.js

@@ -68,34 +68,20 @@ function pickMetricYamlFields(definition) {
     };
 }
 /**
- * Overlays the fields the as-code YAML owns onto a base measure, keeping the base's identity and the
- * fields the YAML cannot express (`metricType`, `isHiddenFromKda`, ...).
+ * The metric's `reconcile`: layers the author's parsed YAML edits over the base definition — the
+ * loaded measure on an edit, the copy source on a duplicate.
  *
- * Used wherever YAML edits are committed onto an existing measure: the update flow overlays onto the
- * loaded metric, and duplicating from the edit dialog seeds the copy from the metric being edited.
- * Duplicating from the detail panel instead needs YAML-authoritative identity — see
- * {@link mergeCopiedMetricDefinition}.
- */
-export function overlayMetricYamlFields(base, yamlDefinition) {
-    return {
-        ...base,
-        ...pickMetricYamlFields(yamlDefinition),
-    };
-}
-/**
- * Builds the definition to persist when duplicating a metric, layering the author's YAML edits over
- * the copied source.
- *
- * The source carries fields the YAML cannot express (`metricType`, `isHiddenFromKda`), which survive
+ * The base carries fields the YAML cannot express (`metricType`, `isHiddenFromKda`), which survive
  * because only the YAML-owned fields are overlaid on top. Identity stays YAML-authoritative: the
- * parsed `id` wins, and its absence lets the server derive a fresh one, so the copied source's id is
- * intentionally dropped from the base first.
+ * parsed `id` wins, and its absence lets the server derive a fresh one, so the base's id is
+ * intentionally dropped first. (On an edit this is moot — validation pins the parsed id to the loaded
+ * object's — but on a duplicate it is what frees the copy from the source's identity.)
  */
-export function mergeCopiedMetricDefinition(copiedMetric, yamlDefinition) {
-    const { id: _copiedId, ...carriedOver } = copiedMetric;
+export function reconcileMetricDefinition(base, edited) {
+    const { id: _baseId, ...carriedOver } = base;
     return {
         ...carriedOver,
-        ...pickMetricYamlFields(yamlDefinition),
-        ...(yamlDefinition.id === undefined ? {} : { id: yamlDefinition.id }),
+        ...pickMetricYamlFields(edited),
+        ...(edited.id === undefined ? {} : { id: edited.id }),
     };
 }

package/esm/metric/metricDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metricDescriptor.d.ts","sourceRoot":"","sources":["../../src/metric/metricDescriptor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAG5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAqEnE;;GAEG;AACH,eAAO,MAAM,gBAAgB,4GAe5B,CAAC"}
+{"version":3,"file":"metricDescriptor.d.ts","sourceRoot":"","sources":["../../src/metric/metricDescriptor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAQ5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAyEnE;;GAEG;AACH,eAAO,MAAM,gBAAgB,4GAuB5B,CAAC"}

package/esm/metric/metricDescriptor.js

@@ -1,13 +1,13 @@
 // (C) 2026 GoodData Corporation
 import { useMemo } from "react";
 import { defineMessages, useIntl } from "react-intl";
-import { defineAsCodeDescriptor } from "../asCode/descriptor.js";
+import { defineAsCodeDescriptor, fixedIdentifierOf, } from "../asCode/descriptor.js";
 import { ObjectTypes } from "../objectType/constants.js";
 import { METRIC_EDITOR_FEATURE_FLAG } from "./gate.js";
 import { metricCompletions } from "./metricCompletions.js";
-import { definitionToMetricYaml, mergeCopiedMetricDefinition, metricYamlToDefinition, } from "./metricConverter.js";
+import { definitionToMetricYaml, metricYamlToDefinition, reconcileMetricDefinition, } from "./metricConverter.js";
 import { createCopiedMetric } from "./metricCopy.js";
-import { createMetricMutationAdapter } from "./metricMutationPort.js";
+import { countMetricReferences, createMetricMutationAdapter, loadMetric } from "./metricMutationPort.js";
 import { serializeMetricToYaml } from "./metricSerialization.js";
 import { validateMetricYaml } from "./metricValidation.js";
 const METRIC_DOCS_URL = "https://www.gooddata.ai/docs/cloud/api-and-sdk/vs-code-extension/structures/#metric";
@@ -22,12 +22,14 @@ const messages = defineMessages({
     sectionHeaderTooltip: { id: "analyticsCatalog.metric.dialog.sectionHeader.tooltip" },
     help: { id: "analyticsCatalog.metric.dialog.help" },
     submitError: { id: "analyticsCatalog.metric.dialog.submit.error" },
-    loadError: { id: "analyticsCatalog.metric.load.error" },
     deleteTitle: { id: "analyticsCatalog.metric.dialog.delete.title" },
     deleteBody: { id: "analyticsCatalog.metric.dialog.delete.body" },
     deleteSubmit: { id: "analyticsCatalog.metric.dialog.delete.submit" },
     deleteSuccess: { id: "analyticsCatalog.metric.delete.success" },
     deleteError: { id: "analyticsCatalog.metric.delete.error" },
+});
+const capabilityMessages = defineMessages({
+    loadError: { id: "analyticsCatalog.metric.load.error" },
     deleteUsageWarning: { id: "analyticsCatalog.metric.dialog.delete.usageWarning" },
 });
 const actionMessages = defineMessages({
@@ -48,12 +50,13 @@ function useMetricEditing() {
         syntaxErrorMessage: intl.formatMessage(errorMessages.syntax),
         // The editor works in the YAML shape, a lossy projection of the measure definition.
         serialize: (definition) => serializeMetricToYaml(definitionToMetricYaml(definition)),
-        validate: (value, options) => {
-            const result = validateMetricYaml(value, options);
+        validate: (value, context) => {
+            const result = validateMetricYaml(value, { fixedIdentifier: fixedIdentifierOf(context) });
             return result.isValid
                 ? { isValid: true, definition: result.measure }
                 : { isValid: false, error: intl.formatMessage(errorMessages[result.errorCode]) };
         },
+        reconcile: reconcileMetricDefinition,
     }), [intl]);
 }
 /**
@@ -67,8 +70,16 @@ export const metricDescriptor = defineAsCodeDescriptor({
     useEditing: useMetricEditing,
     createMutationPort: createMetricMutationAdapter,
     emptyDefinition: (defaultTitle) => metricYamlToDefinition({ type: "metric", title: defaultTitle, maql: "SELECT 1" }),
-    // No editSeed: the full measure is loaded via port.load (the item carries no MAQL).
+    seed: { load: loadMetric, loadError: capabilityMessages.loadError },
+    referenceCounted: {
+        count: countMetricReferences,
+        usageWarning: capabilityMessages.deleteUsageWarning,
+    },
+    // A copied metric derives a human-readable id that can collide on create; identity lets the dialog retry without it.
+    identity: {
+        read: (definition) => definition.id,
+        strip: ({ id: _id, ...definition }) => definition,
+    },
     toCopy: createCopiedMetric,
-    applyYamlEdits: mergeCopiedMetricDefinition,
     openAction: actionMessages.openInEditor,
 });

package/esm/metric/metricMutationPort.d.ts

@@ -3,11 +3,13 @@ import { type IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
 import type { IAsCodeMutationPort } from "../asCode/descriptor.js";
 import type { ICatalogItemMeasure } from "../catalogItem/types.js";
 /**
- * A metric loads its full measure before editing (the catalog item carries no MAQL) and always
- * supports the optional `load`/`getReferencingObjectsCount` capabilities — hence `Required`.
  * @internal
  */
-export type IMetricMutationPort = Required<IAsCodeMutationPort<IMeasureMetadataObjectDefinition, ICatalogItemMeasure>>;
+export type IMetricMutationPort = IAsCodeMutationPort<IMeasureMetadataObjectDefinition, ICatalogItemMeasure>;
+/** Fetches the full measure for editing (the catalog item carries no MAQL). @internal */
+export declare function loadMetric(backend: IAnalyticalBackend, workspace: string, item: ICatalogItemMeasure): Promise<IMeasureMetadataObjectDefinition>;
+/** Counts the insights and measures referencing a measure. @internal */
+export declare function countMetricReferences(backend: IAnalyticalBackend, workspace: string, item: ICatalogItemMeasure): Promise<number>;
 /**
  * @internal
  */

package/esm/metric/metricMutationPort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metricMutationPort.d.ts","sourceRoot":"","sources":["../../src/metric/metricMutationPort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,KAAK,gCAAgC,EAAkC,MAAM,qBAAqB,CAAC;AAE5G,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AASnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAInE;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CACtC,mBAAmB,CAAC,gCAAgC,EAAE,mBAAmB,CAAC,CAC7E,CAAC;AAEF;;GAEG;AACH,wBAAgB,2BAA2B,CACvC,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,GAClB,mBAAmB,CAoCrB"}
+{"version":3,"file":"metricMutationPort.d.ts","sourceRoot":"","sources":["../../src/metric/metricMutationPort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAEH,KAAK,gCAAgC,EAGxC,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAUnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,mBAAmB,CAAC,gCAAgC,EAAE,mBAAmB,CAAC,CAAC;AAW7G,yFAAyF;AACzF,wBAAgB,UAAU,CACtB,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,mBAAmB,GAC1B,OAAO,CAAC,gCAAgC,CAAC,CAE3C;AAED,wEAAwE;AACxE,wBAAsB,qBAAqB,CACvC,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,mBAAmB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACvC,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,GAClB,mBAAmB,CAsBrB"}

package/esm/metric/metricMutationPort.js

@@ -1,8 +1,21 @@
 // (C) 2026 GoodData Corporation
-import { idRef, isMeasureMetadataObject } from "@gooddata/sdk-model";
+import { idRef, isMeasureMetadataObject, } from "@gooddata/sdk-model";
 import { convertMeasureToCatalogItem } from "../catalogItem/converter.js";
 import { createMeasureCatalogItem, deleteMeasureCatalogItem, getMeasureCatalogItem, getMeasureReferencingObjectsCatalogItem, updateMeasureCatalogItem, } from "../catalogItem/query.js";
-import { overlayMetricYamlFields } from "./metricConverter.js";
+// `id` is definition-expressible yet server-owned: the update targets by it, so a hand-edited id must not retarget it.
+function pickMetricIdentity(measure) {
+    const { id, ref, uri, created, updated, createdBy, updatedBy, certification } = measure;
+    return { id, ref, uri, created, updated, createdBy, updatedBy, certification };
+}
+/** Fetches the full measure for editing (the catalog item carries no MAQL). @internal */
+export function loadMetric(backend, workspace, item) {
+    return getMeasureCatalogItem(backend, workspace, idRef(item.identifier, "measure"));
+}
+/** Counts the insights and measures referencing a measure. @internal */
+export async function countMetricReferences(backend, workspace, item) {
+    const referencing = await getMeasureReferencingObjectsCatalogItem(backend, workspace, idRef(item.identifier, "measure"));
+    return (referencing.insights?.length ?? 0) + (referencing.measures?.length ?? 0);
+}
 /**
  * @internal
  */
@@ -13,25 +26,19 @@ export function createMetricMutationAdapter(backend, workspace) {
             return convertMeasureToCatalogItem(savedMeasure);
         },
         async update(base, definition) {
-            // The measures endpoint is a full replace, so overlay the YAML-owned fields onto the loaded
-            // measure to carry over what the YAML cannot express (metricType, isHiddenFromKda, identity).
-            // `base` must be the persisted measure `load` returned — a bare definition (no server-managed
-            // `ref`) would silently drop those fields, so reject it loudly rather than corrupt the update.
             if (!isMeasureMetadataObject(base)) {
                 throw new Error("Metric update requires the loaded measure as base, not a bare definition.");
             }
-            const savedMeasure = await updateMeasureCatalogItem(backend, workspace, overlayMetricYamlFields(base, definition));
+            // Definition is authoritative (already reconciled); base fills only non-definition fields, and the server-identity pick wins.
+            const savedMeasure = await updateMeasureCatalogItem(backend, workspace, {
+                ...base,
+                ...definition,
+                ...pickMetricIdentity(base),
+            });
             return convertMeasureToCatalogItem(savedMeasure);
         },
         async delete(ref) {
             await deleteMeasureCatalogItem(backend, workspace, idRef(ref.identifier, "measure"));
         },
-        async load(item) {
-            return getMeasureCatalogItem(backend, workspace, idRef(item.identifier, "measure"));
-        },
-        async getReferencingObjectsCount(item) {
-            const referencing = await getMeasureReferencingObjectsCatalogItem(backend, workspace, idRef(item.identifier, "measure"));
-            return (referencing.insights?.length ?? 0) + (referencing.measures?.length ?? 0);
-        },
     };
 }

package/esm/metric/metricValidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metricValidation.d.ts","sourceRoot":"","sources":["../../src/metric/metricValidation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAO5E,MAAM,MAAM,sBAAsB,GAC5B;IACI,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,gCAAgC,CAAC;CAC7C,GACD;IACI,OAAO,EAAE,KAAK,CAAC;IACf,SAAS,EAAE,yBAAyB,CAAC;CACxC,CAAC;AAER,MAAM,MAAM,yBAAyB,GAC/B,OAAO,GACP,QAAQ,GACR,kBAAkB,GAClB,aAAa,GACb,aAAa,GACb,aAAa,CAAC;AAEpB,KAAK,yBAAyB,GAAG;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,yBAA8B,GACxC,sBAAsB,CAUxB"}
+{"version":3,"file":"metricValidation.d.ts","sourceRoot":"","sources":["../../src/metric/metricValidation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAO5E,MAAM,MAAM,sBAAsB,GAC5B;IACI,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,gCAAgC,CAAC;CAC7C,GACD;IACI,OAAO,EAAE,KAAK,CAAC;IACf,SAAS,EAAE,yBAAyB,CAAC;CACxC,CAAC;AAER,MAAM,MAAM,yBAAyB,GAC/B,OAAO,GACP,QAAQ,GACR,kBAAkB,GAClB,aAAa,GACb,aAAa,GACb,aAAa,CAAC;AAEpB,KAAK,yBAAyB,GAAG;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,yBAA8B,GACxC,sBAAsB,CAaxB"}

package/esm/metric/metricValidation.js

@@ -6,11 +6,14 @@ export function validateMetricYaml(value, options = {}) {
     const result = validateYaml(value, {
         schema: metricSchema,
         fixedIdentifier: options.fixedIdentifier,
-        classifyError: classifyMetricError,
     });
-    return result.ok
-        ? { isValid: true, measure: metricYamlToDefinition(result.data) }
-        : { isValid: false, errorCode: result.errorCode };
+    if (result.ok) {
+        return { isValid: true, measure: metricYamlToDefinition(result.data) };
+    }
+    return {
+        isValid: false,
+        errorCode: result.kind === "schema" ? classifyMetricError(result.error, result.parsed) : result.kind,
+    };
 }
 function classifyMetricError(error, parsed) {
     const maqlProvided = typeof parsed === "object" && parsed !== null && parsed.maql !== undefined;

package/esm/metric/tests/metricMutationPort.test.utils.d.ts

@@ -1,7 +1,4 @@
 import type { IMetricMutationPort } from "../metricMutationPort.js";
-/**
- * Test utility. Returns a metric mutation port with vi.fn() stubs.
- * @internal
- */
+/** @internal */
 export declare function createTestMetricMutationPort(overrides?: Partial<IMetricMutationPort>): IMetricMutationPort;
 //# sourceMappingURL=metricMutationPort.test.utils.d.ts.map

package/esm/metric/tests/metricMutationPort.test.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metricMutationPort.test.utils.d.ts","sourceRoot":"","sources":["../../../src/metric/tests/metricMutationPort.test.utils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAiBpE;;;GAGG;AACH,wBAAgB,4BAA4B,CACxC,SAAS,GAAE,OAAO,CAAC,mBAAmB,CAAM,GAC7C,mBAAmB,CAsBrB"}
+{"version":3,"file":"metricMutationPort.test.utils.d.ts","sourceRoot":"","sources":["../../../src/metric/tests/metricMutationPort.test.utils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAiBpE,gBAAgB;AAChB,wBAAgB,4BAA4B,CACxC,SAAS,GAAE,OAAO,CAAC,mBAAmB,CAAM,GAC7C,mBAAmB,CAOrB"}

package/esm/metric/tests/metricMutationPort.test.utils.js

@@ -14,30 +14,12 @@ const defaultSavedItem = {
     isEditable: true,
     format: "#,##0.00",
 };
-/**
- * Test utility. Returns a metric mutation port with vi.fn() stubs.
- * @internal
- */
+/** @internal */
 export function createTestMetricMutationPort(overrides = {}) {
     return {
         create: vi.fn().mockResolvedValue(defaultSavedItem),
         update: vi.fn().mockResolvedValue(defaultSavedItem),
         delete: vi.fn().mockResolvedValue(undefined),
-        load: vi.fn().mockResolvedValue({
-            id: "test-metric",
-            uri: "test-metric",
-            ref: { identifier: "test-metric", type: "measure" },
-            type: "measure",
-            title: "Test Metric",
-            description: "",
-            tags: [],
-            production: true,
-            deprecated: false,
-            unlisted: false,
-            expression: "SELECT 1",
-            format: "#,##0.00",
-        }),
-        getReferencingObjectsCount: vi.fn().mockResolvedValue(0),
         ...overrides,
     };
 }

package/esm/parameter/gate.d.ts

@@ -1,15 +1,11 @@
 import type { ParameterType } from "@gooddata/sdk-model";
-/** The flag gating catalog parameters. The single source of truth, referenced by the gates below and
+/** The flag gating catalog parameters, referenced by the gate below and
  *  `parameterDescriptor.featureFlag`. */
 export declare const PARAMETER_FEATURE_FLAG = "enableParameters";
 /**
  * Catalog parameter feature gate.
  */
 export declare function useIsParametersEnabled(): boolean;
-/**
- * Whether the current user can manage parameters in the catalog.
- */
-export declare function useCanManageParameter(): boolean;
 /**
  * Parameter types authorable in the catalog, gated by `enableStringParameters`.
  */

package/esm/parameter/gate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../src/parameter/gate.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKzD;yCACyC;AACzC,eAAO,MAAM,sBAAsB,qBAAqB,CAAC;AAEzD;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,aAAa,EAAE,CAM1D"}
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../src/parameter/gate.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD;yCACyC;AACzC,eAAO,MAAM,sBAAsB,qBAAqB,CAAC;AAEzD;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,aAAa,EAAE,CAM1D"}

package/esm/parameter/gate.js

@@ -1,8 +1,7 @@
 // (C) 2026 GoodData Corporation
 import { useMemo } from "react";
-import { useCanManageAsCode } from "../asCode/gate.js";
 import { useFeatureFlag } from "../permission/PermissionsContext.js";
-/** The flag gating catalog parameters. The single source of truth, referenced by the gates below and
+/** The flag gating catalog parameters, referenced by the gate below and
  *  `parameterDescriptor.featureFlag`. */
 export const PARAMETER_FEATURE_FLAG = "enableParameters";
 /**
@@ -11,12 +10,6 @@ export const PARAMETER_FEATURE_FLAG = "enableParameters";
 export function useIsParametersEnabled() {
     return useFeatureFlag(PARAMETER_FEATURE_FLAG);
 }
-/**
- * Whether the current user can manage parameters in the catalog.
- */
-export function useCanManageParameter() {
-    return useCanManageAsCode(PARAMETER_FEATURE_FLAG);
-}
 /**
  * Parameter types authorable in the catalog, gated by `enableStringParameters`.
  */

package/esm/parameter/parameterDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parameterDescriptor.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterDescriptor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAG9E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAqErE;;GAEG;AACH,eAAO,MAAM,mBAAmB,gHA2B9B,CAAC"}
+{"version":3,"file":"parameterDescriptor.d.ts","sourceRoot":"","sources":["../../src/parameter/parameterDescriptor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAQ9E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAwErE;;GAEG;AACH,eAAO,MAAM,mBAAmB,gHAiC9B,CAAC"}

package/esm/parameter/parameterDescriptor.js

@@ -1,7 +1,7 @@
 // (C) 2026 GoodData Corporation
 import { useMemo } from "react";
 import { defineMessages, useIntl } from "react-intl";
-import { defineAsCodeDescriptor } from "../asCode/descriptor.js";
+import { defineAsCodeDescriptor, fixedIdentifierOf, } from "../asCode/descriptor.js";
 import { ObjectTypes } from "../objectType/constants.js";
 import { PARAMETER_FEATURE_FLAG, useEnabledParameterTypes } from "./gate.js";
 import { createParameterCompletions } from "./parameterCompletions.js";
@@ -47,8 +47,11 @@ function useParameterEditing() {
         syntaxErrorMessage: intl.formatMessage(errorMessages.syntax),
         // Parameter YAML round-trips 1:1 to its definition, so serialization is a plain stringify.
         serialize: (definition) => serializeParameterToYaml(definition),
-        validate: (value, options) => {
-            const result = validateParameterYaml(value, { enabledTypes, ...options });
+        validate: (value, context) => {
+            const result = validateParameterYaml(value, {
+                enabledTypes,
+                fixedIdentifier: fixedIdentifierOf(context),
+            });
             return result.isValid
                 ? { isValid: true, definition: result.parameter }
                 : {
@@ -77,15 +80,21 @@ export const parameterDescriptor = defineAsCodeDescriptor({
         description: "",
         definition: { type: "NUMBER", defaultValue: 0 },
     }),
-    // No port.load: the catalog item maps field-for-field to a definition, so the editor seeds from it.
-    editSeed: (item) => ({
-        id: item.identifier,
-        type: "parameter",
-        title: item.title,
-        description: item.description,
-        tags: item.tags,
-        definition: item.definition,
-    }),
-    // Source is already a definition, so toCopy only re-derives identity; no applyYamlEdits (YAML round-trips 1:1).
+    // Item maps field-for-field to a definition, so no fetch is needed.
+    seed: {
+        editSeed: (item) => ({
+            id: item.identifier,
+            type: "parameter",
+            title: item.title,
+            description: item.description,
+            tags: item.tags,
+            definition: item.definition,
+        }),
+    },
+    // A copied parameter derives a human-readable id that can collide on create; identity lets the dialog retry without it.
+    identity: {
+        read: (definition) => definition.id,
+        strip: ({ id: _id, ...definition }) => definition,
+    },
     toCopy: createCopiedParameter,
 });