@nocobase/plugin-flow-engine 2.1.0-beta.2 → 2.1.0-beta.21

package/dist/server/flow-surfaces/blueprint/compile-blocks.js

@@ -0,0 +1,1074 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compile_blocks_exports = {};
+__export(compile_blocks_exports, {
+  collectReferencedBlockKeys: () => collectReferencedBlockKeys,
+  compileTabComposeValues: () => compileTabComposeValues
+});
+module.exports = __toCommonJS(compile_blocks_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_service_utils = require("../service-utils");
+var import_default_block_actions = require("../default-block-actions");
+var import_public_data_surface_default_filter = require("../public-data-surface-default-filter");
+var import_defaults = require("./defaults");
+var import_private_utils = require("./private-utils");
+var import_field_type_resolver = require("../field-type-resolver");
+const APPLY_BLUEPRINT_BLOCK_TYPE_ENUM = [
+  "table",
+  "calendar",
+  "kanban",
+  "createForm",
+  "editForm",
+  "details",
+  "filterForm",
+  "list",
+  "gridCard",
+  "markdown",
+  "iframe",
+  "chart",
+  "actionPanel",
+  "jsBlock",
+  "tree"
+];
+const APPLY_BLUEPRINT_BLOCK_ALLOWED_KEYS = [
+  "key",
+  "type",
+  "title",
+  "collection",
+  "dataSourceKey",
+  "associationPathName",
+  "binding",
+  "associationField",
+  "resource",
+  "template",
+  "settings",
+  "fields",
+  "fieldGroups",
+  "fieldsLayout",
+  "defaultFilter",
+  "actions",
+  "recordActions",
+  "script",
+  "chart"
+];
+const APPLY_BLUEPRINT_FIELD_ALLOWED_KEYS = [
+  "key",
+  "field",
+  "associationPathName",
+  "renderer",
+  "type",
+  "fieldType",
+  "fields",
+  "selectorFields",
+  "titleField",
+  "openMode",
+  "popupSize",
+  "pageSize",
+  "showIndex",
+  "label",
+  "target",
+  "settings",
+  "popup",
+  "script",
+  "chart"
+];
+const APPLY_BLUEPRINT_FIELD_GROUP_ALLOWED_KEYS = ["key", "title", "fields"];
+const APPLY_BLUEPRINT_ACTION_ALLOWED_KEYS = ["key", "type", "title", "settings", "popup", "script", "chart"];
+const APPLY_BLUEPRINT_POPUP_ALLOWED_KEYS = [
+  "title",
+  "mode",
+  "template",
+  "tryTemplate",
+  "defaultType",
+  "saveAsTemplate",
+  "blocks",
+  "layout"
+];
+const APPLY_BLUEPRINT_POPUP_SAVE_AS_TEMPLATE_ALLOWED_KEYS = ["name", "description", "local"];
+const APPLY_BLUEPRINT_LAYOUT_ALLOWED_KEYS = ["rows"];
+const APPLY_BLUEPRINT_LAYOUT_CELL_ALLOWED_KEYS = ["key", "span"];
+const APPLY_BLUEPRINT_BLOCK_RESOURCE_ALLOWED_KEYS = [
+  "binding",
+  "dataSourceKey",
+  "collectionName",
+  "associationField",
+  "associationName",
+  "associationPathName",
+  "sourceId",
+  "filterByTk"
+];
+const APPLY_BLUEPRINT_BLOCK_RESOURCE_RAW_ONLY_KEYS = [
+  "associationName",
+  "associationPathName",
+  "sourceId",
+  "filterByTk"
+];
+const APPLY_BLUEPRINT_BLOCK_RESOURCE_SHORTHAND_KEYS = [
+  "collection",
+  "dataSourceKey",
+  "associationPathName",
+  "binding",
+  "associationField"
+];
+const APPLY_BLUEPRINT_RECORD_CAPABLE_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "details", "list", "gridCard"]);
+const APPLY_BLUEPRINT_FIELD_GRID_BLOCK_TYPES = /* @__PURE__ */ new Set(["createForm", "editForm", "details", "filterForm"]);
+const APPLY_BLUEPRINT_FIELD_GROUP_BLOCK_TYPES = /* @__PURE__ */ new Set(["createForm", "editForm", "details"]);
+const APPLY_BLUEPRINT_AUTO_PROMOTED_RECORD_ACTION_TYPES = /* @__PURE__ */ new Set([
+  "view",
+  "edit",
+  "delete",
+  "updateRecord",
+  "duplicate"
+]);
+const APPLY_BLUEPRINT_DEFAULT_POPUP_ACTION_TYPES = /* @__PURE__ */ new Set(["addNew", "view", "edit"]);
+const APPLY_BLUEPRINT_BLOCK_TYPES = new Set(APPLY_BLUEPRINT_BLOCK_TYPE_ENUM);
+const APPLY_BLUEPRINT_ADD_CHILD_RECORD_ACTION_ERROR = "type 'addChild' must be authored under recordActions and is only valid when the live target catalog.recordActions exposes it for a tree collection table with treeTable enabled";
+function assertNoBlockLevelLayout(input, context) {
+  if (Object.prototype.hasOwnProperty.call(input, "layout")) {
+    (0, import_errors.throwBadRequest)(`${context}.layout is not supported; layout is only allowed on tabs[] and popup`);
+  }
+}
+function assertApplyBlueprintFieldsLayoutHost(block, context) {
+  if (!Object.prototype.hasOwnProperty.call(block, "fieldsLayout")) {
+    return;
+  }
+  if ((0, import_private_utils.readOptionalString)(block.type) === "kanban") {
+    (0, import_errors.throwBadRequest)(`${context}.fieldsLayout is not supported on kanban main blocks; use fields[] only`);
+  }
+  if (APPLY_BLUEPRINT_FIELD_GRID_BLOCK_TYPES.has((0, import_private_utils.readOptionalString)(block.type) || "")) {
+    return;
+  }
+  (0, import_errors.throwBadRequest)(`${context}.fieldsLayout is only supported on createForm, editForm, details or filterForm`);
+}
+function assertApplyBlueprintCalendarMainContent(block, context) {
+  if ((0, import_private_utils.readOptionalString)(block.type) !== "calendar") {
+    return;
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "fields")) {
+    (0, import_errors.throwBadRequest)(
+      `${context}.fields is not supported on calendar main blocks; add event fields under the quick-create or event-view popup host instead`
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "fieldGroups")) {
+    (0, import_errors.throwBadRequest)(
+      `${context}.fieldGroups is not supported on calendar main blocks; add grouped fields under the quick-create or event-view popup host instead`
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "recordActions")) {
+    (0, import_errors.throwBadRequest)(
+      `${context}.recordActions is not supported on calendar main blocks; configure event actions inside the event-view popup host instead`
+    );
+  }
+}
+function assertApplyBlueprintKanbanMainContent(block, context) {
+  if ((0, import_private_utils.readOptionalString)(block.type) !== "kanban") {
+    return;
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "fieldGroups")) {
+    (0, import_errors.throwBadRequest)(`${context}.fieldGroups is not supported on kanban main blocks; use fields instead`);
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "recordActions")) {
+    (0, import_errors.throwBadRequest)(`${context}.recordActions is not supported on kanban main blocks in v1`);
+  }
+}
+function assertApplyBlueprintTreeMainContent(block, context) {
+  if ((0, import_private_utils.readOptionalString)(block.type) !== "tree") {
+    return;
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "fields")) {
+    (0, import_errors.throwBadRequest)(`${context}.fields is not supported on tree blocks`);
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "fieldGroups")) {
+    (0, import_errors.throwBadRequest)(`${context}.fieldGroups is not supported on tree blocks`);
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "actions")) {
+    (0, import_errors.throwBadRequest)(`${context}.actions is not supported on tree blocks`);
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "recordActions")) {
+    (0, import_errors.throwBadRequest)(`${context}.recordActions is not supported on tree blocks`);
+  }
+}
+function assertApplyBlueprintBlockType(type, context) {
+  if (!type) {
+    return;
+  }
+  if (type === "form") {
+    (0, import_errors.throwBadRequest)(`${context}.type 'form' is unsupported in applyBlueprint; use 'editForm' or 'createForm'`);
+  }
+  if (!APPLY_BLUEPRINT_BLOCK_TYPES.has(type)) {
+    (0, import_errors.throwBadRequest)(
+      `${context}.type '${type}' is unsupported in applyBlueprint; supported types: ${APPLY_BLUEPRINT_BLOCK_TYPE_ENUM.join(
+        ", "
+      )}`
+    );
+  }
+}
+function normalizeEditPopupBlocks(input, context) {
+  input.forEach((block, index) => {
+    const blockType = (0, import_private_utils.readOptionalString)(block == null ? void 0 : block.type);
+    if (blockType === "form") {
+      (0, import_errors.throwBadRequest)(`${context}.blocks[${index}].type 'form' is unsupported in applyBlueprint; use 'editForm'`);
+    }
+  });
+  const editFormBlocks = input.filter((block) => (0, import_private_utils.readOptionalString)(block == null ? void 0 : block.type) === "editForm");
+  if (!editFormBlocks.length) {
+    (0, import_errors.throwBadRequest)(`${context} custom edit popup must contain exactly one editForm block`);
+  }
+  if (editFormBlocks.length > 1) {
+    (0, import_errors.throwBadRequest)(`${context} custom edit popup must contain exactly one editForm block`);
+  }
+  return input.map((block, index) => {
+    const blockType = (0, import_private_utils.readOptionalString)(block == null ? void 0 : block.type);
+    if (blockType !== "editForm") {
+      return block;
+    }
+    if (!import_lodash.default.isPlainObject(block)) {
+      return block;
+    }
+    if (!import_lodash.default.isUndefined(block.resource)) {
+      if (import_lodash.default.isPlainObject(block.resource)) {
+        const binding = "binding" in block.resource ? (0, import_private_utils.readOptionalString)(block.resource.binding) : void 0;
+        if (!binding) {
+          (0, import_errors.throwBadRequest)(
+            `${context}.blocks[${index}].resource must use binding='currentRecord' or be omitted in a custom edit popup`
+          );
+        }
+        if (binding !== "currentRecord") {
+          (0, import_errors.throwBadRequest)(
+            `${context}.blocks[${index}].resource.binding must be 'currentRecord' in a custom edit popup`
+          );
+        }
+      }
+      return block;
+    }
+    const shorthandBinding = (0, import_private_utils.readOptionalString)(block.binding);
+    if (!import_lodash.default.isUndefined(shorthandBinding)) {
+      if (shorthandBinding !== "currentRecord") {
+        (0, import_errors.throwBadRequest)(`${context}.blocks[${index}].binding must be 'currentRecord' in a custom edit popup`);
+      }
+      return block;
+    }
+    const hasRawShorthandResource = !import_lodash.default.isUndefined(block.collection) || !import_lodash.default.isUndefined(block.dataSourceKey) || !import_lodash.default.isUndefined(block.associationPathName) || !import_lodash.default.isUndefined(block.associationField);
+    if (hasRawShorthandResource) {
+      (0, import_errors.throwBadRequest)(
+        `${context}.blocks[${index}] must use binding='currentRecord' or omit resource entirely in a custom edit popup`
+      );
+    }
+    return {
+      ...block,
+      resource: {
+        binding: "currentRecord"
+      }
+    };
+  });
+}
+function readAssociationFieldFromSingleSegmentPath(value, context) {
+  const associationPathName = (0, import_private_utils.readOptionalString)(value);
+  if (!associationPathName) {
+    return void 0;
+  }
+  const segments = associationPathName.split(".").map((segment) => segment.trim()).filter(Boolean);
+  if (!segments.length) {
+    (0, import_errors.throwBadRequest)(`${context}.associationPathName must be a non-empty association field path`);
+  }
+  if (segments.length > 1) {
+    (0, import_errors.throwBadRequest)(
+      `${context}.associationPathName '${associationPathName}' must be a single association field name when used with ${context}.binding; prefer ${context}.associationField for popup relation tables`
+    );
+  }
+  return segments[0];
+}
+function normalizeAssociatedRecordsBindingFromAssociationPath(input, context) {
+  const binding = (0, import_private_utils.readOptionalString)(input.binding);
+  const associationLeaf = readAssociationFieldFromSingleSegmentPath(input.associationPathName, context);
+  if (!binding || !associationLeaf) {
+    return null;
+  }
+  if (binding !== "currentRecord" && binding !== "associatedRecords") {
+    (0, import_errors.throwBadRequest)(
+      `${context} cannot mix ${context}.binding='${binding}' with ${context}.associationPathName; use associatedRecords + associationField on popup collection blocks`
+    );
+  }
+  const associationField = (0, import_private_utils.readOptionalString)(input.associationField);
+  if (associationField && associationField !== associationLeaf) {
+    (0, import_errors.throwBadRequest)(
+      `${context}.associationField '${associationField}' conflicts with ${context}.associationPathName '${(0, import_private_utils.readOptionalString)(
+        input.associationPathName
+      )}'`
+    );
+  }
+  return {
+    binding: "associatedRecords",
+    associationField: associationField || associationLeaf
+  };
+}
+function readApplyBlueprintActionType(input) {
+  if (typeof input === "string") {
+    return (0, import_private_utils.readString)(input);
+  }
+  if (import_lodash.default.isPlainObject(input)) {
+    return (0, import_private_utils.readOptionalString)(input.type);
+  }
+  return void 0;
+}
+function splitApplyBlueprintBlockActionsByScope(block, context) {
+  const rawActions = readOptionalItems(block.actions, `${context}.actions`);
+  const rawRecordActions = readOptionalItems(block.recordActions, `${context}.recordActions`);
+  const blockType = (0, import_private_utils.readOptionalString)(block.type);
+  if (!blockType || !APPLY_BLUEPRINT_RECORD_CAPABLE_BLOCK_TYPES.has(blockType)) {
+    return {
+      actions: rawActions,
+      recordActions: rawRecordActions
+    };
+  }
+  const promotedRecordActions = [];
+  const remainingActions = [];
+  rawActions.forEach((action, index) => {
+    const actionType = readApplyBlueprintActionType(action);
+    if (actionType === "addChild") {
+      (0, import_errors.throwBadRequest)(`${context}.actions[${index}] ${APPLY_BLUEPRINT_ADD_CHILD_RECORD_ACTION_ERROR}`);
+    }
+    if (actionType && APPLY_BLUEPRINT_AUTO_PROMOTED_RECORD_ACTION_TYPES.has(actionType)) {
+      promotedRecordActions.push(action);
+      return;
+    }
+    remainingActions.push(action);
+  });
+  return {
+    actions: remainingActions,
+    recordActions: [...rawRecordActions, ...promotedRecordActions]
+  };
+}
+function resolveAssetSettings(settings, spec, assets, context) {
+  const nextSettings = (0, import_private_utils.cloneOptionalPlainObject)(settings, `${context}.settings`) || {};
+  const mergeAsset = (bucket, assetKey) => {
+    const normalizedKey = (0, import_private_utils.readOptionalString)(assetKey);
+    if (!normalizedKey) {
+      return;
+    }
+    const registry = assets[bucket] || {};
+    const asset = registry[normalizedKey];
+    if (!import_lodash.default.isPlainObject(asset)) {
+      (0, import_errors.throwBadRequest)(`${context} ${bucket.slice(0, -1)} asset '${normalizedKey}' is not defined in assets.${bucket}`);
+    }
+    import_lodash.default.merge(nextSettings, import_lodash.default.cloneDeep(asset));
+  };
+  mergeAsset("charts", spec.chart);
+  mergeAsset("scripts", spec.script);
+  return nextSettings;
+}
+function readOptionalItems(value, context) {
+  return (0, import_private_utils.readOptionalArray)(value, context) || [];
+}
+function ensureOptionalTemplate(value, context) {
+  return (0, import_private_utils.cloneOptionalPlainObject)(value, context);
+}
+function resolvePopupTitleSettings(settings, title) {
+  if (!title) {
+    return settings;
+  }
+  const nextSettings = import_lodash.default.cloneDeep(settings || {});
+  if (import_lodash.default.isUndefined(import_lodash.default.get(nextSettings, ["openView", "title"]))) {
+    import_lodash.default.set(nextSettings, ["openView", "title"], title);
+  }
+  return nextSettings;
+}
+function normalizeBlockResourceObject(input, context) {
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, context, APPLY_BLUEPRINT_BLOCK_RESOURCE_ALLOWED_KEYS);
+  const hasBinding = Object.prototype.hasOwnProperty.call(input, "binding");
+  if (hasBinding) {
+    const normalizedAssociatedRecords = normalizeAssociatedRecordsBindingFromAssociationPath(input, context);
+    const mixedRawKeys = APPLY_BLUEPRINT_BLOCK_RESOURCE_RAW_ONLY_KEYS.filter(
+      (key) => Object.prototype.hasOwnProperty.call(input, key) && !(normalizedAssociatedRecords && key === "associationPathName")
+    );
+    if (mixedRawKeys.length) {
+      (0, import_errors.throwBadRequest)(
+        `${context} cannot mix binding with ${mixedRawKeys.map((key) => `${context}.${key}`).join(", ")}`
+      );
+    }
+    return (0, import_service_utils.buildDefinedPayload)({
+      binding: (normalizedAssociatedRecords == null ? void 0 : normalizedAssociatedRecords.binding) || (0, import_private_utils.assertNonEmptyString)(input.binding, `${context}.binding`),
+      dataSourceKey: (0, import_private_utils.readOptionalString)(input.dataSourceKey),
+      collectionName: (0, import_private_utils.readOptionalString)(input.collectionName),
+      associationField: (normalizedAssociatedRecords == null ? void 0 : normalizedAssociatedRecords.associationField) || (0, import_private_utils.readOptionalString)(input.associationField)
+    });
+  }
+  if (Object.prototype.hasOwnProperty.call(input, "associationField")) {
+    (0, import_errors.throwBadRequest)(`${context}.associationField only works when ${context}.binding is provided`);
+  }
+  const collectionName = (0, import_private_utils.readOptionalString)(input.collectionName);
+  const normalized = (0, import_service_utils.buildDefinedPayload)({
+    dataSourceKey: (0, import_private_utils.readOptionalString)(input.dataSourceKey) || (collectionName ? "main" : void 0),
+    collectionName,
+    associationName: (0, import_private_utils.readOptionalString)(input.associationName),
+    associationPathName: (0, import_private_utils.readOptionalString)(input.associationPathName),
+    sourceId: input.sourceId,
+    filterByTk: input.filterByTk
+  });
+  if (!Object.keys(normalized).length) {
+    (0, import_errors.throwBadRequest)(`${context} cannot be empty`);
+  }
+  return normalized;
+}
+function buildBlockResource(block, context) {
+  if (!import_lodash.default.isUndefined(block.resource)) {
+    if (!import_lodash.default.isPlainObject(block.resource)) {
+      (0, import_errors.throwBadRequest)(`${context}.resource must be an object`);
+    }
+    const mixedShorthandKeys = APPLY_BLUEPRINT_BLOCK_RESOURCE_SHORTHAND_KEYS.filter(
+      (key) => Object.prototype.hasOwnProperty.call(block, key)
+    );
+    if (mixedShorthandKeys.length) {
+      (0, import_errors.throwBadRequest)(
+        `${context} cannot mix resource with ${mixedShorthandKeys.map((key) => `${context}.${key}`).join(", ")}`
+      );
+    }
+    return normalizeBlockResourceObject(block.resource, `${context}.resource`);
+  }
+  const binding = (0, import_private_utils.readOptionalString)(block.binding);
+  if (binding) {
+    const normalizedAssociatedRecords = normalizeAssociatedRecordsBindingFromAssociationPath(
+      block,
+      context
+    );
+    if (Object.prototype.hasOwnProperty.call(block, "associationPathName") && !normalizedAssociatedRecords) {
+      (0, import_errors.throwBadRequest)(`${context} cannot mix ${context}.binding with ${context}.associationPathName`);
+    }
+    return (0, import_service_utils.buildDefinedPayload)({
+      binding: (normalizedAssociatedRecords == null ? void 0 : normalizedAssociatedRecords.binding) || binding,
+      dataSourceKey: (0, import_private_utils.readOptionalString)(block.dataSourceKey),
+      collectionName: (0, import_private_utils.readOptionalString)(block.collection),
+      associationField: (normalizedAssociatedRecords == null ? void 0 : normalizedAssociatedRecords.associationField) || (0, import_private_utils.readOptionalString)(block.associationField)
+    });
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "associationField")) {
+    (0, import_errors.throwBadRequest)(`${context}.associationField only works when ${context}.binding is provided`);
+  }
+  const collectionName = (0, import_private_utils.readOptionalString)(block.collection);
+  if (!collectionName) {
+    return void 0;
+  }
+  return (0, import_service_utils.buildDefinedPayload)({
+    dataSourceKey: (0, import_private_utils.readOptionalString)(block.dataSourceKey) || "main",
+    collectionName,
+    associationPathName: (0, import_private_utils.readOptionalString)(block.associationPathName)
+  });
+}
+function ensureLayoutRows(layout, context) {
+  if (import_lodash.default.isUndefined(layout)) {
+    return void 0;
+  }
+  if (!import_lodash.default.isPlainObject(layout)) {
+    (0, import_errors.throwBadRequest)(`${context} must be an object`);
+  }
+  (0, import_private_utils.assertOnlyAllowedKeys)(layout, context, APPLY_BLUEPRINT_LAYOUT_ALLOWED_KEYS);
+  if (!Array.isArray(layout.rows) || !layout.rows.length) {
+    (0, import_errors.throwBadRequest)(`${context}.rows must be a non-empty array`);
+  }
+  return layout.rows.map((row, rowIndex) => {
+    if (!Array.isArray(row) || !row.length) {
+      (0, import_errors.throwBadRequest)(`${context}.rows[${rowIndex}] must be a non-empty array`);
+    }
+    row.forEach((item, itemIndex) => {
+      if (typeof item === "string") {
+        return;
+      }
+      if (!import_lodash.default.isPlainObject(item)) {
+        (0, import_errors.throwBadRequest)(`${context}.rows[${rowIndex}][${itemIndex}] must be a string or object`);
+      }
+      (0, import_private_utils.assertOnlyAllowedKeys)(
+        item,
+        `${context}.rows[${rowIndex}][${itemIndex}]`,
+        APPLY_BLUEPRINT_LAYOUT_CELL_ALLOWED_KEYS
+      );
+    });
+    return row;
+  });
+}
+function autoLayoutFromBlockKeys(blockKeys) {
+  return {
+    rows: blockKeys.map((key) => [key])
+  };
+}
+function collectReferencedBlockKeys(layout, context) {
+  const referenced = /* @__PURE__ */ new Set();
+  const rows = ensureLayoutRows(layout, context) || [];
+  rows.forEach((row, rowIndex) => {
+    row.forEach((cell, itemIndex) => {
+      if (typeof cell === "string") {
+        const key2 = (0, import_private_utils.readString)(cell);
+        if (key2) {
+          referenced.add(key2);
+        }
+        return;
+      }
+      const key = (0, import_private_utils.assertNonEmptyString)(cell.key, `${context}.rows[${rowIndex}][${itemIndex}].key`);
+      if (key) {
+        referenced.add(key);
+      }
+    });
+  });
+  return referenced;
+}
+function compileLayout(layout, blockKeysByLocalKey, context) {
+  return compileScopedLayout(layout, blockKeysByLocalKey, context, "block");
+}
+function resolveScopedLayoutKey(rawKey, keysByLocalKey, context, kind) {
+  const resolved = keysByLocalKey.get(rawKey) || [...keysByLocalKey.values()].find((value) => value === rawKey);
+  if (!resolved) {
+    (0, import_errors.throwBadRequest)(`${context} references unknown ${kind} '${rawKey}'`);
+  }
+  return resolved;
+}
+function compileScopedLayout(layout, keysByLocalKey, context, kind) {
+  const rows = ensureLayoutRows(layout, context);
+  if (!rows) {
+    return void 0;
+  }
+  return {
+    rows: rows.map((row, rowIndex) => {
+      return row.map((item, itemIndex) => {
+        const cellContext = `${context}.rows[${rowIndex}][${itemIndex}]`;
+        if (typeof item === "string") {
+          const itemKey = (0, import_private_utils.readString)(item);
+          return resolveScopedLayoutKey(itemKey, keysByLocalKey, cellContext, kind);
+        }
+        const rawKey = (0, import_private_utils.assertNonEmptyString)(item.key, `${cellContext}.key`);
+        const resolved = resolveScopedLayoutKey(rawKey, keysByLocalKey, cellContext, kind);
+        return (0, import_service_utils.buildDefinedPayload)({
+          key: resolved,
+          span: import_lodash.default.isUndefined(item.span) ? void 0 : import_lodash.default.isNumber(item.span) ? item.span : (0, import_errors.throwBadRequest)(`${cellContext}.span must be a number`)
+        });
+      });
+    })
+  };
+}
+function buildCompactFieldLayoutRow(keys, blockType) {
+  const normalizedKeys = keys.filter(Boolean);
+  if (!normalizedKeys.length) {
+    return [];
+  }
+  if (blockType === "filterForm") {
+    const span = normalizedKeys.length === 1 ? 24 : normalizedKeys.length === 2 ? 12 : 8;
+    return normalizedKeys.map((key) => ({ key, span }));
+  }
+  if (normalizedKeys.length === 1) {
+    return [{ key: normalizedKeys[0], span: 24 }];
+  }
+  return normalizedKeys.map((key) => ({ key, span: 12 }));
+}
+function buildAutoCompiledFieldsLayout(fields, blockType) {
+  if (!APPLY_BLUEPRINT_FIELD_GRID_BLOCK_TYPES.has(blockType || "") || !fields.length) {
+    return void 0;
+  }
+  const rows = [];
+  const chunkSize = blockType === "filterForm" ? 3 : 2;
+  let pendingKeys = [];
+  const flushPending = () => {
+    if (!pendingKeys.length) {
+      return;
+    }
+    rows.push(buildCompactFieldLayoutRow(pendingKeys, blockType));
+    pendingKeys = [];
+  };
+  fields.forEach((field) => {
+    const key = (0, import_private_utils.readOptionalString)(field == null ? void 0 : field.key);
+    if (!key) {
+      return;
+    }
+    if ((0, import_private_utils.readOptionalString)(field == null ? void 0 : field.type) === "divider") {
+      flushPending();
+      rows.push([{ key, span: 24 }]);
+      return;
+    }
+    pendingKeys.push(key);
+    if (pendingKeys.length >= chunkSize) {
+      flushPending();
+    }
+  });
+  flushPending();
+  return rows.length ? { rows } : void 0;
+}
+function compileFieldGroups(fieldGroups, context) {
+  const expanded = [];
+  fieldGroups.forEach((group, groupIndex) => {
+    const groupContext = `${context}[${groupIndex}]`;
+    if (!import_lodash.default.isPlainObject(group)) {
+      (0, import_errors.throwBadRequest)(`${groupContext} must be an object`);
+    }
+    (0, import_private_utils.assertOnlyAllowedKeys)(group, groupContext, APPLY_BLUEPRINT_FIELD_GROUP_ALLOWED_KEYS);
+    const title = (0, import_private_utils.assertNonEmptyString)(group.title, `${groupContext}.title`);
+    const groupFields = readOptionalItems(group.fields, `${groupContext}.fields`);
+    if (!groupFields.length) {
+      (0, import_errors.throwBadRequest)(`${groupContext}.fields must be a non-empty array`);
+    }
+    const groupLocalKey = (0, import_private_utils.normalizeBlueprintLocalKey)(
+      group.key,
+      title || `group_${groupIndex + 1}`,
+      `${groupContext}.key`
+    );
+    expanded.push({
+      key: `${groupLocalKey}_divider`,
+      type: "divider",
+      settings: {
+        label: title,
+        orientation: "left"
+      }
+    });
+    expanded.push(...groupFields);
+  });
+  return expanded;
+}
+function resolveBlockFieldInputs(block, context) {
+  const hasFields = Object.prototype.hasOwnProperty.call(block, "fields");
+  const hasFieldGroups = Object.prototype.hasOwnProperty.call(block, "fieldGroups");
+  if (hasFields && hasFieldGroups) {
+    (0, import_errors.throwBadRequest)(`${context} cannot mix fields with fieldGroups`);
+  }
+  if (!hasFieldGroups) {
+    return readOptionalItems(block.fields, `${context}.fields`);
+  }
+  const blockType = (0, import_private_utils.readOptionalString)(block.type);
+  if (!APPLY_BLUEPRINT_FIELD_GROUP_BLOCK_TYPES.has(blockType || "")) {
+    (0, import_errors.throwBadRequest)(`${context}.fieldGroups is only supported on createForm, editForm or details`);
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "fieldsLayout")) {
+    (0, import_errors.throwBadRequest)(`${context}.fieldsLayout cannot be combined with ${context}.fieldGroups`);
+  }
+  const fieldGroups = (0, import_private_utils.readOptionalArray)(
+    block.fieldGroups,
+    `${context}.fieldGroups`
+  );
+  if (!(fieldGroups == null ? void 0 : fieldGroups.length)) {
+    (0, import_errors.throwBadRequest)(`${context}.fieldGroups must be a non-empty array`);
+  }
+  return compileFieldGroups(fieldGroups, `${context}.fieldGroups`);
+}
+function resolveApplyBlueprintFieldLocalKey(input, index, context) {
+  if (typeof input === "string") {
+    return (0, import_private_utils.assertNonEmptyString)(input, `${context}[${index}]`);
+  }
+  if (!import_lodash.default.isPlainObject(input)) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] must be a string or object`);
+  }
+  const fieldPath = (0, import_private_utils.readOptionalString)(input.field);
+  const syntheticType = (0, import_private_utils.readOptionalString)(input.type);
+  if (!fieldPath && !syntheticType) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] requires field or type`);
+  }
+  if (fieldPath && syntheticType) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] cannot mix field with synthetic type`);
+  }
+  return (0, import_private_utils.normalizeBlueprintLocalKey)(
+    input.key,
+    fieldPath || (syntheticType ? `${syntheticType}_${index + 1}` : `field_${index + 1}`),
+    `${context}[${index}].key`
+  );
+}
+function buildCompiledFieldKeyMap(inputs, compiledFields, context) {
+  const fieldKeysByLocalKey = /* @__PURE__ */ new Map();
+  inputs.forEach((input, index) => {
+    var _a;
+    const localKey = resolveApplyBlueprintFieldLocalKey(input, index, context);
+    const compiledKey = (0, import_private_utils.readOptionalString)((_a = compiledFields[index]) == null ? void 0 : _a.key);
+    if (!compiledKey) {
+      (0, import_errors.throwBadRequest)(`${context}[${index}] key '${localKey}' is missing after field key compilation`);
+    }
+    if (fieldKeysByLocalKey.has(localKey)) {
+      (0, import_errors.throwBadRequest)(`${context}[${index}] key '${localKey}' is duplicated`);
+    }
+    fieldKeysByLocalKey.set(localKey, compiledKey);
+  });
+  return fieldKeysByLocalKey;
+}
+function shouldAttachDefaultPopupMetadata(popup, itemType, options = {}) {
+  return !import_lodash.default.isUndefined(popup) || options.autoRelationField || APPLY_BLUEPRINT_DEFAULT_POPUP_ACTION_TYPES.has(itemType || "");
+}
+function attachCompiledPopupDefaults(popup, metadata) {
+  return (0, import_defaults.attachFlowSurfaceApplyBlueprintPopupDefaults)(popup, metadata);
+}
+function compilePopup(popup, scopePrefix, assets, context, defaults, options = {}) {
+  if (import_lodash.default.isUndefined(popup)) {
+    return {};
+  }
+  if (!import_lodash.default.isPlainObject(popup)) {
+    (0, import_errors.throwBadRequest)(`${context} must be an object`);
+  }
+  (0, import_private_utils.assertOnlyAllowedKeys)(popup, context, APPLY_BLUEPRINT_POPUP_ALLOWED_KEYS);
+  const popupTitle = (0, import_private_utils.readOptionalString)(popup.title);
+  const template = ensureOptionalTemplate(popup.template, `${context}.template`);
+  const tryTemplate = import_lodash.default.isUndefined(popup.tryTemplate) ? void 0 : import_lodash.default.isBoolean(popup.tryTemplate) ? popup.tryTemplate : (0, import_errors.throwBadRequest)(`${context}.tryTemplate must be a boolean`);
+  const defaultType = import_lodash.default.isUndefined(popup.defaultType) ? void 0 : popup.defaultType === "view" || popup.defaultType === "edit" ? popup.defaultType : (0, import_errors.throwBadRequest)(`${context}.defaultType must be 'view' or 'edit'`);
+  const saveAsTemplate = import_lodash.default.isUndefined(popup.saveAsTemplate) ? void 0 : import_lodash.default.isPlainObject(popup.saveAsTemplate) ? ((0, import_private_utils.assertOnlyAllowedKeys)(
+    popup.saveAsTemplate,
+    `${context}.saveAsTemplate`,
+    APPLY_BLUEPRINT_POPUP_SAVE_AS_TEMPLATE_ALLOWED_KEYS
+  ), {
+    name: (0, import_private_utils.assertNonEmptyString)(popup.saveAsTemplate.name, `${context}.saveAsTemplate.name`),
+    description: (0, import_private_utils.assertNonEmptyString)(popup.saveAsTemplate.description, `${context}.saveAsTemplate.description`),
+    local: (0, import_private_utils.readOptionalString)(popup.saveAsTemplate.local)
+  }) : (0, import_errors.throwBadRequest)(`${context}.saveAsTemplate must be an object`);
+  if (saveAsTemplate && template) {
+    (0, import_errors.throwBadRequest)(`${context}.saveAsTemplate cannot be combined with ${context}.template`);
+  }
+  if (template) {
+    return {
+      popup: {
+        template
+      },
+      popupTitle
+    };
+  }
+  const rawPopupBlocks = readOptionalItems(popup.blocks, `${context}.blocks`);
+  const popupBlocks = options.ownerActionType === "edit" && rawPopupBlocks.length ? normalizeEditPopupBlocks(rawPopupBlocks, context) : rawPopupBlocks;
+  if (saveAsTemplate && !popupBlocks.length && tryTemplate !== true) {
+    (0, import_errors.throwBadRequest)(`${context}.saveAsTemplate requires explicit popup.blocks`);
+  }
+  const compiledBlocks = popupBlocks.length ? compileBlocks(
+    popupBlocks,
+    scopePrefix,
+    assets,
+    `${context}.blocks`,
+    defaults,
+    collectReferencedBlockKeys(popup.layout, `${context}.layout`)
+  ) : { blocks: [], blockKeysByLocalKey: /* @__PURE__ */ new Map() };
+  const layout = popupBlocks.length || popup.layout ? compileLayout(
+    popup.layout || autoLayoutFromBlockKeys(compiledBlocks.blocks.map((block) => block.key)),
+    compiledBlocks.blockKeysByLocalKey,
+    `${context}.layout`
+  ) : void 0;
+  const popupMode = (0, import_private_utils.readOptionalString)(popup.mode);
+  if (popupMode && popupMode !== "replace" && popupMode !== "append") {
+    (0, import_errors.throwBadRequest)(`${context}.mode must be 'replace' or 'append'`);
+  }
+  const compiledPopup = (0, import_service_utils.buildDefinedPayload)({
+    mode: popupMode || (popupBlocks.length || template || layout ? "replace" : void 0),
+    template,
+    ...tryTemplate ? { tryTemplate: true } : {},
+    ...defaultType ? { defaultType } : {},
+    ...saveAsTemplate ? { saveAsTemplate } : {},
+    blocks: compiledBlocks.blocks.length ? compiledBlocks.blocks : void 0,
+    layout
+  });
+  return {
+    popup: Object.keys(compiledPopup).length ? compiledPopup : {},
+    popupTitle
+  };
+}
+function resolveTargetBlockKey(value, localBlockKeys, context) {
+  if (import_lodash.default.isUndefined(value) || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const normalized = (0, import_private_utils.readString)(value);
+    return localBlockKeys.get(normalized) || normalized;
+  }
+  (0, import_errors.throwBadRequest)(`${context} must be a string block key`);
+}
+function compileField(input, index, scopePrefix, assets, localBlockKeys, context, popupDefaultsMetadata, defaults) {
+  if (typeof input === "string") {
+    const fieldPath2 = (0, import_private_utils.assertNonEmptyString)(input, `${context}[${index}]`);
+    return {
+      key: (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, fieldPath2), `${context}[${index}]`),
+      fieldPath: fieldPath2,
+      __autoPopupForRelationField: true,
+      ...popupDefaultsMetadata ? { [import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]: import_lodash.default.cloneDeep(popupDefaultsMetadata) } : {}
+    };
+  }
+  if (!import_lodash.default.isPlainObject(input)) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] must be a string or object`);
+  }
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, `${context}[${index}]`, APPLY_BLUEPRINT_FIELD_ALLOWED_KEYS);
+  (0, import_field_type_resolver.assertNoInternalFieldKeys)(input, `${context}[${index}]`);
+  (0, import_field_type_resolver.assertNoInternalFieldKeys)(input.settings, `${context}[${index}].settings`);
+  const fieldPath = (0, import_private_utils.readOptionalString)(input.field);
+  const syntheticType = (0, import_private_utils.readOptionalString)(input.type);
+  const fieldType = (0, import_field_type_resolver.normalizePublicFieldType)(input.fieldType, `${context}[${index}]`);
+  const fields = (0, import_field_type_resolver.normalizePublicFieldNameList)(input.fields, `${context}[${index}].fields`);
+  const selectorFields = (0, import_field_type_resolver.normalizePublicFieldNameList)(
+    input.selectorFields,
+    `${context}[${index}].selectorFields`
+  );
+  if (!fieldPath && !syntheticType) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] requires field or type`);
+  }
+  if (fieldPath && syntheticType) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] cannot mix field with synthetic type`);
+  }
+  const localKey = (0, import_private_utils.normalizeBlueprintLocalKey)(
+    input.key,
+    fieldPath || (syntheticType ? `${syntheticType}_${index + 1}` : `field_${index + 1}`),
+    `${context}[${index}].key`
+  );
+  const key = (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, localKey), `${context}[${index}]`);
+  let settings = resolveAssetSettings(input.settings, input, assets, `${context}[${index}]`);
+  if ((0, import_private_utils.readOptionalString)(input.label) && import_lodash.default.isUndefined(settings.label)) {
+    settings.label = (0, import_private_utils.readOptionalString)(input.label);
+  }
+  const popupResult = compilePopup(input.popup, `${key}.popup`, assets, `${context}[${index}].popup`, defaults);
+  settings = resolvePopupTitleSettings(settings, popupResult.popupTitle);
+  const popup = shouldAttachDefaultPopupMetadata(input.popup, void 0) ? attachCompiledPopupDefaults(popupResult.popup, popupDefaultsMetadata) : popupResult.popup;
+  return (0, import_service_utils.buildDefinedPayload)({
+    key,
+    fieldPath,
+    associationPathName: (0, import_private_utils.readOptionalString)(input.associationPathName),
+    renderer: (0, import_private_utils.readOptionalString)(input.renderer),
+    type: syntheticType,
+    fieldType,
+    fields,
+    selectorFields,
+    titleField: (0, import_private_utils.readOptionalString)(input.titleField),
+    openMode: (0, import_private_utils.readOptionalString)(input.openMode),
+    popupSize: (0, import_private_utils.readOptionalString)(input.popupSize),
+    pageSize: input.pageSize,
+    showIndex: input.showIndex,
+    target: resolveTargetBlockKey(input.target, localBlockKeys, `${context}[${index}].target`),
+    settings: Object.keys(settings).length ? settings : void 0,
+    popup
+  });
+}
+function compileAction(input, index, scopePrefix, assets, context, popupDefaultsMetadata, defaults) {
+  if (typeof input === "string") {
+    const type2 = (0, import_private_utils.assertNonEmptyString)(input, `${context}[${index}]`);
+    return {
+      key: (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, `${type2}_${index + 1}`), `${context}[${index}]`),
+      type: type2,
+      ...APPLY_BLUEPRINT_DEFAULT_POPUP_ACTION_TYPES.has(type2) ? { popup: attachCompiledPopupDefaults(void 0, popupDefaultsMetadata) } : {}
+    };
+  }
+  if (!import_lodash.default.isPlainObject(input)) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] must be a string or object`);
+  }
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, `${context}[${index}]`, APPLY_BLUEPRINT_ACTION_ALLOWED_KEYS);
+  const type = (0, import_private_utils.assertNonEmptyString)(input.type, `${context}[${index}].type`);
+  const localKey = (0, import_private_utils.normalizeBlueprintLocalKey)(input.key, `${type}_${index + 1}`, `${context}[${index}].key`);
+  const key = (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, localKey), `${context}[${index}]`);
+  let settings = resolveAssetSettings(input.settings, input, assets, `${context}[${index}]`);
+  if ((0, import_private_utils.readOptionalString)(input.title) && import_lodash.default.isUndefined(settings.title)) {
+    settings.title = (0, import_private_utils.readOptionalString)(input.title);
+  }
+  const popupResult = compilePopup(input.popup, `${key}.popup`, assets, `${context}[${index}].popup`, defaults, {
+    ownerActionType: type
+  });
+  settings = resolvePopupTitleSettings(settings, popupResult.popupTitle);
+  const popup = shouldAttachDefaultPopupMetadata(input.popup, type) ? attachCompiledPopupDefaults(popupResult.popup, popupDefaultsMetadata) : popupResult.popup;
+  return (0, import_service_utils.buildDefinedPayload)({
+    key,
+    type,
+    settings: Object.keys(settings).length ? settings : void 0,
+    popup
+  });
+}
+function compileInjectedDefaultAction(descriptor, scopePrefix, context, index, popupDefaultsMetadata) {
+  const descriptorPopup = descriptor.popup ? import_lodash.default.cloneDeep(descriptor.popup) : void 0;
+  const popup = shouldAttachDefaultPopupMetadata(descriptorPopup, descriptor.type) ? attachCompiledPopupDefaults(descriptorPopup, popupDefaultsMetadata) : void 0;
+  return (0, import_service_utils.buildDefinedPayload)({
+    key: (0, import_service_utils.normalizeFlowSurfaceComposeKey)(
+      (0, import_private_utils.buildScopedKey)(scopePrefix, `${descriptor.type}_default_${index + 1}`),
+      `${context}[${index}]`
+    ),
+    type: descriptor.type,
+    popup
+  });
+}
+function compileBlocks(input, scopePrefix, assets, context, defaults, requiredExplicitBlockKeys = /* @__PURE__ */ new Set()) {
+  const blockKeysByLocalKey = /* @__PURE__ */ new Map();
+  const referencedBlockKeys = new Set(requiredExplicitBlockKeys);
+  const rawBlocks = import_lodash.default.castArray(input || []);
+  const popupDefaultsMetadata = (0, import_defaults.buildFlowSurfaceApplyBlueprintPopupDefaultsMetadata)(defaults);
+  rawBlocks.forEach((block, index) => {
+    if (!import_lodash.default.isPlainObject(block)) {
+      (0, import_errors.throwBadRequest)(`${context}[${index}] must be an object`);
+    }
+    assertApplyBlueprintCalendarMainContent(block, `${context}[${index}]`);
+    assertApplyBlueprintKanbanMainContent(block, `${context}[${index}]`);
+    assertApplyBlueprintTreeMainContent(block, `${context}[${index}]`);
+    const fields = resolveBlockFieldInputs(block, `${context}[${index}]`);
+    fields.forEach((field, fieldIndex) => {
+      if (typeof (field == null ? void 0 : field.target) !== "string" || !field.target.trim()) {
+        return;
+      }
+      referencedBlockKeys.add(
+        (0, import_service_utils.normalizeFlowSurfaceComposeKey)(field.target, `${context}[${index}].fields[${fieldIndex}].target`)
+      );
+    });
+  });
+  rawBlocks.forEach((block, index) => {
+    if (!import_lodash.default.isPlainObject(block)) {
+      (0, import_errors.throwBadRequest)(`${context}[${index}] must be an object`);
+    }
+    assertNoBlockLevelLayout(block, `${context}[${index}]`);
+    assertApplyBlueprintFieldsLayoutHost(block, `${context}[${index}]`);
+    (0, import_private_utils.assertOnlyAllowedKeys)(block, `${context}[${index}]`, APPLY_BLUEPRINT_BLOCK_ALLOWED_KEYS);
+    assertApplyBlueprintBlockType((0, import_private_utils.readOptionalString)(block.type), `${context}[${index}]`);
+    assertApplyBlueprintCalendarMainContent(block, `${context}[${index}]`);
+    assertApplyBlueprintKanbanMainContent(block, `${context}[${index}]`);
+    assertApplyBlueprintTreeMainContent(block, `${context}[${index}]`);
+    const explicitKey = (0, import_private_utils.readString)(block.key);
+    const fallback = block.type ? `${block.type}_${index + 1}` : `block_${index + 1}`;
+    const localKey = (0, import_private_utils.normalizeBlueprintLocalKey)(block.key, fallback, `${context}[${index}].key`);
+    if (!explicitKey && referencedBlockKeys.has(localKey)) {
+      (0, import_errors.throwBadRequest)(
+        `${context}[${index}] must provide key explicitly because it is referenced by layout or field.target`
+      );
+    }
+    if (blockKeysByLocalKey.has(localKey)) {
+      (0, import_errors.throwBadRequest)(`${context}[${index}] key '${localKey}' is duplicated`);
+    }
+    const key = (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, localKey), `${context}[${index}]`);
+    blockKeysByLocalKey.set(localKey, key);
+  });
+  const blocks = rawBlocks.map((block, index) => {
+    const blockContext = `${context}[${index}]`;
+    const localKey = (0, import_private_utils.normalizeBlueprintLocalKey)(
+      block.key,
+      block.type ? `${block.type}_${index + 1}` : `block_${index + 1}`,
+      `${blockContext}.key`
+    );
+    const key = blockKeysByLocalKey.get(localKey);
+    if (!key) {
+      (0, import_errors.throwBadRequest)(`${blockContext} key '${localKey}' is missing after block key compilation`);
+    }
+    const settings = resolveAssetSettings(block.settings, block, assets, blockContext);
+    if ((0, import_private_utils.readOptionalString)(block.title) && import_lodash.default.isUndefined(settings.title)) {
+      settings.title = (0, import_private_utils.readOptionalString)(block.title);
+    }
+    const blockType = (0, import_private_utils.readOptionalString)(block.type);
+    const template = ensureOptionalTemplate(block.template, `${blockContext}.template`);
+    const blockDefaultFilter = (0, import_public_data_surface_default_filter.normalizeFlowSurfacePublicBlockDefaultFilter)("applyBlueprint", block.defaultFilter, {
+      blockType,
+      template,
+      path: blockContext
+    });
+    if (!import_lodash.default.isUndefined(blockDefaultFilter)) {
+      (0, import_public_data_surface_default_filter.assertFlowSurfaceConcreteDefaultFilterItem)("applyBlueprint", blockDefaultFilter, {
+        path: blockContext
+      });
+    }
+    const fieldInputs = resolveBlockFieldInputs(block, blockContext);
+    const fields = fieldInputs.map(
+      (field, fieldIndex) => compileField(
+        field,
+        fieldIndex,
+        key,
+        assets,
+        blockKeysByLocalKey,
+        `${blockContext}.fields`,
+        popupDefaultsMetadata,
+        defaults
+      )
+    );
+    const fieldsLayout = Object.prototype.hasOwnProperty.call(block, "fieldsLayout") ? compileScopedLayout(
+      import_lodash.default.isUndefined(block.fieldsLayout) ? void 0 : import_lodash.default.isPlainObject(block.fieldsLayout) ? block.fieldsLayout : (0, import_errors.throwBadRequest)(`${blockContext}.fieldsLayout must be an object`),
+      buildCompiledFieldKeyMap(fieldInputs, fields, `${blockContext}.fields`),
+      `${blockContext}.fieldsLayout`,
+      "field"
+    ) : buildAutoCompiledFieldsLayout(fields, (0, import_private_utils.readOptionalString)(block.type));
+    const { actions, recordActions } = splitApplyBlueprintBlockActionsByScope(block, blockContext);
+    const explicitActions = actions.map(
+      (action, actionIndex) => compileAction(action, actionIndex, key, assets, `${blockContext}.actions`, popupDefaultsMetadata, defaults)
+    );
+    const explicitRecordActions = recordActions.map(
+      (action, actionIndex) => compileAction(action, actionIndex, key, assets, `${blockContext}.recordActions`, popupDefaultsMetadata, defaults)
+    );
+    const injectedActionIndexes = {
+      actions: explicitActions.length,
+      recordActions: explicitRecordActions.length
+    };
+    const mergedActions = (0, import_default_block_actions.mergeFlowSurfaceDefaultBlockActions)({
+      blockType,
+      template,
+      actions: explicitActions,
+      recordActions: explicitRecordActions,
+      createAction: (descriptor) => compileInjectedDefaultAction(
+        descriptor,
+        key,
+        `${blockContext}.${descriptor.scope}`,
+        injectedActionIndexes[descriptor.scope]++,
+        popupDefaultsMetadata
+      )
+    });
+    const actionsWithDefaultFilter = (0, import_public_data_surface_default_filter.backfillFlowSurfaceFilterActionDefaultFilter)(
+      mergedActions.actions,
+      blockDefaultFilter
+    );
+    return (0, import_service_utils.buildDefinedPayload)({
+      key,
+      type: blockType,
+      resource: buildBlockResource(block, blockContext),
+      template,
+      settings: Object.keys(settings).length ? settings : void 0,
+      fields: blockType === "calendar" || blockType === "tree" ? void 0 : fields,
+      fieldsLayout: blockType === "calendar" || blockType === "kanban" || blockType === "tree" ? void 0 : fieldsLayout,
+      actions: blockType === "tree" ? void 0 : actionsWithDefaultFilter,
+      recordActions: blockType === "calendar" || blockType === "kanban" || blockType === "tree" ? void 0 : mergedActions.recordActions
+    });
+  });
+  return {
+    blocks,
+    blockKeysByLocalKey
+  };
+}
+function compileTabComposeValues(tab, document, tabIndex, options) {
+  const tabPublicPath = (0, import_private_utils.buildApplyBlueprintTabPublicPath)(tabIndex);
+  const blocksPath = `${tabPublicPath}.blocks`;
+  const layoutPath = `${tabPublicPath}.layout`;
+  const compiledBlocks = compileBlocks(
+    tab.blocks,
+    tab.key,
+    document.assets,
+    blocksPath,
+    document.defaults,
+    collectReferencedBlockKeys(tab.layout, layoutPath)
+  );
+  const layout = compileLayout(
+    tab.layout || autoLayoutFromBlockKeys(compiledBlocks.blocks.map((block) => block.key)),
+    compiledBlocks.blockKeysByLocalKey,
+    layoutPath
+  );
+  return (0, import_service_utils.buildDefinedPayload)({
+    mode: options.mode,
+    blocks: compiledBlocks.blocks,
+    layout
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectReferencedBlockKeys,
+  compileTabComposeValues
+});