@nocobase/plugin-flow-engine 2.1.0-beta.9 → 2.2.0-alpha.1

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

@@ -0,0 +1,2185 @@
+/**
+ * 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_data_block_rules = require("../data-block-rules");
+var import_public_data_surface_default_filter = require("../public-data-surface-default-filter");
+var import_public_compatibility = require("../public-compatibility");
+var import_defaults = require("./defaults");
+var import_hidden_popup_contract = require("../hidden-popup-contract");
+var import_service_helpers = require("../service-helpers");
+var import_template_reference = require("../template-reference");
+var import_field_grid_layout = require("../field-grid-layout");
+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",
+  "comments",
+  "recordHistory",
+  "actionPanel",
+  "jsBlock",
+  "tree"
+];
+const APPLY_BLUEPRINT_BLOCK_ALLOWED_KEYS = [
+  "key",
+  "type",
+  "title",
+  "description",
+  "height",
+  "heightMode",
+  "collection",
+  "dataSourceKey",
+  "associationPathName",
+  "binding",
+  "associationField",
+  "resource",
+  "template",
+  "settings",
+  "fields",
+  "fieldGroups",
+  "fieldsLayout",
+  "defaultFilter",
+  "actions",
+  "recordActions",
+  "script",
+  "chart",
+  "pageSize",
+  "sort",
+  "sorting",
+  "titleField",
+  "colorField",
+  "startField",
+  "endField"
+];
+const APPLY_BLUEPRINT_FIELD_ALLOWED_KEYS = [
+  "key",
+  "field",
+  "associationPathName",
+  "renderer",
+  "type",
+  "fieldType",
+  "fields",
+  "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_COMPOSE_MODES = /* @__PURE__ */ new Set(["replace", "append"]);
+const APPLY_BLUEPRINT_POPUP_DISPLAY_MODE_ALIASES = {
+  modal: "dialog",
+  page: "embed"
+};
+const APPLY_BLUEPRINT_POPUP_DISPLAY_MODES = /* @__PURE__ */ new Set(["drawer", "dialog", "embed", "page", "modal"]);
+const APPLY_BLUEPRINT_CALENDAR_FIELD_BINDING_KEYS = ["titleField", "colorField", "startField", "endField"];
+const APPLY_BLUEPRINT_POPUP_PAGE_MODE_BLOCK_THRESHOLD = 3;
+const APPLY_BLUEPRINT_POPUP_PAGE_MODE_FIELD_THRESHOLD = 20;
+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", "comments"]);
+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", "addChild", "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";
+const AI_EMPLOYEE_ACTION_TYPE = "aiEmployee";
+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 normalizeApplyBlueprintCalendarPopupSettings(settings, blockContext, defaultsMetadata) {
+  return (0, import_hidden_popup_contract.normalizeBlockHiddenPopupSettings)(
+    settings,
+    blockContext,
+    ["quickCreatePopup", "eventPopup"],
+    defaultsMetadata,
+    import_errors.throwBadRequest
+  );
+}
+function normalizeApplyBlueprintKanbanPopupSettings(settings, blockContext, defaultsMetadata) {
+  return (0, import_hidden_popup_contract.normalizeBlockHiddenPopupSettings)(
+    settings,
+    blockContext,
+    ["quickCreatePopup", "cardPopup"],
+    defaultsMetadata,
+    import_errors.throwBadRequest
+  );
+}
+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; use actions[] for calendar block actions or 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; use actions[] for kanban block actions`
+    );
+  }
+}
+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) => {
+    if (import_lodash.default.isUndefined(assetKey)) {
+      return;
+    }
+    if (typeof assetKey !== "string") {
+      if (bucket === "scripts") {
+        (0, import_errors.throwBadRequest)(`${context}.script must be a string asset key; use settings.code for inline JS code`);
+      }
+      return;
+    }
+    const normalizedKey = (0, import_private_utils.readOptionalString)(assetKey);
+    if (!normalizedKey) {
+      if (bucket === "scripts") {
+        (0, import_errors.throwBadRequest)(`${context}.script must be a non-empty string asset key; use settings.code for inline JS code`);
+      }
+      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}`);
+    }
+    if (bucket === "scripts" && !(0, import_private_utils.readOptionalString)(asset.code)) {
+      (0, import_errors.throwBadRequest)(
+        `${context}.script references script asset '${normalizedKey}' without non-empty code; use settings.code for inline JS code`
+      );
+    }
+    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 normalizeApplyBlueprintPopupMode(value, context) {
+  const rawMode = (0, import_private_utils.readOptionalString)(value);
+  if (!rawMode) {
+    return {};
+  }
+  if (APPLY_BLUEPRINT_POPUP_COMPOSE_MODES.has(rawMode)) {
+    return {
+      composeMode: rawMode
+    };
+  }
+  if (APPLY_BLUEPRINT_POPUP_DISPLAY_MODES.has(rawMode)) {
+    return {
+      displayMode: APPLY_BLUEPRINT_POPUP_DISPLAY_MODE_ALIASES[rawMode] || rawMode
+    };
+  }
+  (0, import_errors.throwBadRequest)(`${context}.mode must be 'replace', 'append', 'drawer', 'dialog' or 'page'`);
+}
+function countApplyBlueprintPopupDirectEffectiveFields(blocks) {
+  return blocks.reduce((count, block) => {
+    if (!import_lodash.default.isPlainObject(block) || (0, import_private_utils.readOptionalString)(block.type) === "filterForm") {
+      return count;
+    }
+    const fields = Object.prototype.hasOwnProperty.call(block, "fieldGroups") ? import_lodash.default.castArray(block.fieldGroups || []).flatMap((group) => import_lodash.default.castArray((group == null ? void 0 : group.fields) || [])) : import_lodash.default.castArray(block.fields || []);
+    return count + fields.filter((field) => {
+      if (import_lodash.default.isPlainObject(field)) {
+        const type = String(field.type || "").trim();
+        return type !== "divider" && type !== "jsitem" && type !== "jscolumn";
+      }
+      return !!String(field || "").trim();
+    }).length;
+  }, 0);
+}
+function countApplyBlueprintPopupNonFilterBlocks(blocks) {
+  return blocks.filter((block) => import_lodash.default.isPlainObject(block) && (0, import_private_utils.readOptionalString)(block.type) !== "filterForm").length;
+}
+function shouldDefaultApplyBlueprintPopupDisplayPage(popup, popupBlocks, options) {
+  if ((0, import_template_reference.hasFlowSurfaceTemplateReference)(popup.template)) {
+    return false;
+  }
+  if (Object.prototype.hasOwnProperty.call(popup, "mode")) {
+    return false;
+  }
+  if ((options.popupDepth || 1) !== 1) {
+    return false;
+  }
+  if (!popupBlocks.length) {
+    return false;
+  }
+  return countApplyBlueprintPopupNonFilterBlocks(popupBlocks) > APPLY_BLUEPRINT_POPUP_PAGE_MODE_BLOCK_THRESHOLD || countApplyBlueprintPopupDirectEffectiveFields(popupBlocks) > APPLY_BLUEPRINT_POPUP_PAGE_MODE_FIELD_THRESHOLD;
+}
+const MAX_AUTO_TEMPLATE_NAME_LENGTH = 80;
+const MAX_AUTO_TEMPLATE_DESCRIPTION_LENGTH = 240;
+const MAX_HEADER_TEXT = 60;
+const CJK_TEXT_PATTERN = /[\u3400-\u9fff\uf900-\ufaff]/;
+function normalizeMetadataText(value) {
+  return typeof value === "string" ? value.trim() : String(value || "").trim();
+}
+function trimAutoTemplateLabel(value, maxLength = MAX_AUTO_TEMPLATE_NAME_LENGTH) {
+  const source = normalizeMetadataText(value);
+  if (!source) {
+    return "";
+  }
+  if (source.length <= maxLength) {
+    return source;
+  }
+  if (maxLength <= 3) {
+    return source.slice(0, maxLength);
+  }
+  return `${source.slice(0, maxLength - 3)}...`;
+}
+function getApplyBlueprintCollectionLabel(block) {
+  var _a, _b, _c, _d;
+  return normalizeMetadataText(block == null ? void 0 : block.collection) || normalizeMetadataText((_a = block == null ? void 0 : block.resourceInit) == null ? void 0 : _a.collectionName) || normalizeMetadataText((_b = block == null ? void 0 : block.resourceInit) == null ? void 0 : _b.collection) || normalizeMetadataText((_c = block == null ? void 0 : block.resource) == null ? void 0 : _c.collectionName) || normalizeMetadataText((_d = block == null ? void 0 : block.resource) == null ? void 0 : _d.collection) || "";
+}
+function getApplyBlueprintAssociationLabel(block) {
+  var _a, _b, _c;
+  return normalizeMetadataText(block == null ? void 0 : block.associationName) || normalizeMetadataText((_a = block == null ? void 0 : block.resourceInit) == null ? void 0 : _a.associationName) || normalizeMetadataText((_b = block == null ? void 0 : block.resource) == null ? void 0 : _b.associationName) || normalizeMetadataText(block == null ? void 0 : block.associationField) || normalizeMetadataText((_c = block == null ? void 0 : block.resource) == null ? void 0 : _c.associationField) || "";
+}
+function buildApplyBlueprintBlockHeader(block) {
+  return normalizeMetadataText(block == null ? void 0 : block.title) || getApplyBlueprintCollectionLabel(block) || normalizeMetadataText(block == null ? void 0 : block.key) || normalizeMetadataText(block == null ? void 0 : block.type);
+}
+function inferPopupTemplateMetadataLocale(popup, options) {
+  var _a, _b;
+  const candidates = [
+    popup.title,
+    options.triggerLabel,
+    (_a = options.hostBlock) == null ? void 0 : _a.title,
+    (_b = options.hostBlock) == null ? void 0 : _b.key,
+    getApplyBlueprintCollectionLabel(options.hostBlock),
+    ...import_lodash.default.castArray(popup.blocks || []).flatMap((block) => [
+      block == null ? void 0 : block.title,
+      block == null ? void 0 : block.key,
+      block == null ? void 0 : block.type,
+      getApplyBlueprintCollectionLabel(block)
+    ])
+  ];
+  return candidates.some((value) => CJK_TEXT_PATTERN.test(normalizeMetadataText(value))) ? "zh" : "en";
+}
+function getPopupTemplateTriggerLabel(kind, locale) {
+  const normalizedKind = String(kind || "").trim();
+  if (locale === "zh") {
+    if (normalizedKind === "field") {
+      return "\u5B57\u6BB5";
+    }
+    if (normalizedKind === "recordAction") {
+      return "\u8BB0\u5F55\u64CD\u4F5C";
+    }
+    if (normalizedKind === "action") {
+      return "\u64CD\u4F5C";
+    }
+    return "\u5F39\u7A97";
+  }
+  if (normalizedKind === "field") {
+    return "field";
+  }
+  if (normalizedKind === "recordAction") {
+    return "record action";
+  }
+  if (normalizedKind === "action") {
+    return "action";
+  }
+  return "popup";
+}
+function describePopupTemplateTrigger(kind, label, locale) {
+  const kindLabel = getPopupTemplateTriggerLabel(kind, locale);
+  const normalizedLabel = normalizeMetadataText(label);
+  if (!normalizedLabel) {
+    return kindLabel;
+  }
+  return locale === "zh" ? `${kindLabel}\u201C${normalizedLabel}\u201D` : `${kindLabel} "${normalizedLabel}"`;
+}
+function describePopupTemplateHost(block, locale) {
+  return normalizeMetadataText(block == null ? void 0 : block.title) || getApplyBlueprintCollectionLabel(block) || normalizeMetadataText(block == null ? void 0 : block.key) || normalizeMetadataText(block == null ? void 0 : block.type) || (locale === "zh" ? "\u5F53\u524D\u533A\u5757" : "current block");
+}
+function summarizePopupTemplateBlocks(blocks, locale) {
+  const labels = import_lodash.default.uniq(
+    import_lodash.default.castArray(blocks || []).map((block) => trimAutoTemplateLabel(buildApplyBlueprintBlockHeader(block), MAX_HEADER_TEXT)).filter(Boolean)
+  ).slice(0, 3);
+  if (!labels.length) {
+    return locale === "zh" ? "\u672C\u5730 popup \u5185\u5BB9" : "local popup content";
+  }
+  return labels.join(locale === "zh" ? "\u3001" : ", ");
+}
+function inferPopupTemplateMetadataScene(popup, options) {
+  var _a;
+  const requestedDefaultType = normalizeMetadataText(popup.defaultType);
+  if (requestedDefaultType === "view" || requestedDefaultType === "edit") {
+    return requestedDefaultType;
+  }
+  const ownerActionType = normalizeMetadataText(options.ownerActionType);
+  if (ownerActionType === "edit") {
+    return "edit";
+  }
+  if (ownerActionType === "addNew" || ownerActionType === "addChild") {
+    return "addNew";
+  }
+  if (ownerActionType === "view") {
+    return "view";
+  }
+  const firstBlockType = normalizeMetadataText((_a = import_lodash.default.castArray(popup.blocks || [])[0]) == null ? void 0 : _a.type);
+  if (firstBlockType === "details") {
+    return "view";
+  }
+  if (firstBlockType === "editForm") {
+    return "edit";
+  }
+  if (firstBlockType === "createForm") {
+    return "addNew";
+  }
+  return "generic";
+}
+function describePopupTemplateMatchContext(popup, options, locale) {
+  const popupBlocks = import_lodash.default.castArray(popup.blocks || []);
+  const firstResourceBlock = popupBlocks.find(
+    (block) => getApplyBlueprintCollectionLabel(block) || getApplyBlueprintAssociationLabel(block)
+  );
+  const collectionLabel = getApplyBlueprintCollectionLabel(firstResourceBlock) || getApplyBlueprintCollectionLabel(options.hostBlock);
+  const associationLabel = normalizeMetadataText(options.associationName) || getApplyBlueprintAssociationLabel(firstResourceBlock) || getApplyBlueprintAssociationLabel(options.hostBlock);
+  const scene = inferPopupTemplateMetadataScene(popup, options);
+  const parts = locale === "zh" ? [`\u573A\u666F\uFF1A${scene}`] : [`Scene: ${scene}`];
+  if (collectionLabel) {
+    parts.push(locale === "zh" ? `\u6570\u636E\u8868\uFF1A${collectionLabel}` : `collection: ${collectionLabel}`);
+  }
+  if (associationLabel) {
+    parts.push(locale === "zh" ? `\u5173\u7CFB\uFF1A${associationLabel}` : `association: ${associationLabel}`);
+  }
+  return parts.join(locale === "zh" ? "\uFF1B" : "; ");
+}
+function buildApplyBlueprintAutoSaveTemplateMetadata(popup, options) {
+  const locale = inferPopupTemplateMetadataLocale(popup, options);
+  const popupTitle = normalizeMetadataText(popup.title);
+  const hostLabel = describePopupTemplateHost(options.hostBlock, locale);
+  const triggerLabel = describePopupTemplateTrigger(options.triggerKind, options.triggerLabel, locale);
+  const contentLabel = summarizePopupTemplateBlocks(popup.blocks, locale);
+  const matchContextLabel = describePopupTemplateMatchContext(popup, options, locale);
+  const associationName = normalizeMetadataText(options.associationName);
+  const directName = popupTitle ? locale === "zh" ? `${popupTitle}\u5F39\u7A97\u6A21\u677F` : `${popupTitle} popup template` : locale === "zh" ? `${hostLabel} ${triggerLabel} \u5F39\u7A97\u6A21\u677F` : `${hostLabel} ${triggerLabel} popup template`;
+  const relationBaseName = popupTitle || `${hostLabel} ${triggerLabel}`;
+  const name = associationName ? `${relationBaseName}(${associationName})` : directName;
+  const contextLabel = associationName ? locale === "zh" ? `\u4E0A\u4E0B\u6587\uFF1A\u5173\u8054 ${associationName}` : `context: relation ${associationName}` : locale === "zh" ? "\u4E0A\u4E0B\u6587\uFF1A\u76F4\u63A5/\u5F53\u524D\u8BB0\u5F55" : "context: direct/current record";
+  const description = locale === "zh" ? `\u590D\u7528\u5F39\u7A97\u6A21\u677F\u3002${matchContextLabel}\uFF1B\u5BBF\u4E3B\uFF1A${hostLabel}\uFF1B\u89E6\u53D1\u5668\uFF1A${triggerLabel}\uFF1B${contextLabel}\uFF1B\u5185\u5BB9\uFF1A${contentLabel}\u3002` : `Reusable popup template. ${matchContextLabel}; host: ${hostLabel}; trigger: ${triggerLabel}; ${contextLabel}; content: ${contentLabel}.`;
+  return {
+    name: trimAutoTemplateLabel(name, MAX_AUTO_TEMPLATE_NAME_LENGTH),
+    description: trimAutoTemplateLabel(description, MAX_AUTO_TEMPLATE_DESCRIPTION_LENGTH)
+  };
+}
+function buildPopupOpenViewContext(options) {
+  const associationName = normalizeMetadataText(options.associationName);
+  if (!associationName) {
+    return {};
+  }
+  return (0, import_service_utils.buildDefinedPayload)({
+    dataSourceKey: normalizeMetadataText(options.dataSourceKey) || void 0,
+    collectionName: normalizeMetadataText(options.surfaceCollectionName) || void 0,
+    associationName
+  });
+}
+function normalizeApplyBlueprintCalendarCompatSettings(block, settings) {
+  if ((0, import_private_utils.readOptionalString)(block.type) !== "calendar") {
+    return settings;
+  }
+  let nextSettings = settings;
+  const ensureNextSettings = () => {
+    if (nextSettings === settings) {
+      nextSettings = import_lodash.default.cloneDeep(settings || {});
+    }
+    return nextSettings;
+  };
+  for (const key of APPLY_BLUEPRINT_CALENDAR_FIELD_BINDING_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(block, key) && !Object.prototype.hasOwnProperty.call(nextSettings, key)) {
+      ensureNextSettings()[key] = block[key];
+    }
+  }
+  if (Object.prototype.hasOwnProperty.call(nextSettings, "quickCreateEnabled") && !Object.prototype.hasOwnProperty.call(nextSettings, "quickCreateEvent")) {
+    ensureNextSettings().quickCreateEvent = nextSettings.quickCreateEnabled;
+  }
+  if (nextSettings !== settings) {
+    delete nextSettings.quickCreateEnabled;
+  }
+  return nextSettings;
+}
+function isApplyBlueprintCompatibleTreeTableDragSortFieldMeta(field) {
+  var _a;
+  if (String((0, import_service_helpers.getFieldInterface)(field) || (0, import_service_helpers.getFieldType)(field) || "").trim() !== "sort") {
+    return false;
+  }
+  return !String((0, import_service_helpers.getFieldTarget)(field) || "").trim() && !String((field == null ? void 0 : field.scopeKey) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.scopeKey) || "").trim();
+}
+function getApplyBlueprintCompatibleTreeTableDragSortFieldName(collection) {
+  return (0, import_service_helpers.getFieldName)((0, import_service_helpers.getCollectionFields)(collection).find(isApplyBlueprintCompatibleTreeTableDragSortFieldMeta));
+}
+function isApplyBlueprintCompatibleTreeTableDragSortField(collection, fieldName) {
+  const field = (0, import_service_helpers.getCollectionFields)(collection).find((candidate) => (0, import_service_helpers.getFieldName)(candidate) === fieldName);
+  return !!field && isApplyBlueprintCompatibleTreeTableDragSortFieldMeta(field);
+}
+function normalizeApplyBlueprintTreeTableDragSortBy(block, settings, getCollection) {
+  if ((0, import_private_utils.readOptionalString)(block.type) !== "table" || (settings == null ? void 0 : settings.treeTable) !== true || !Object.prototype.hasOwnProperty.call(settings || {}, "dragSortBy")) {
+    return settings;
+  }
+  const collection = resolveBlueprintBlockCollection(block, getCollection);
+  if (!collection) {
+    return settings;
+  }
+  const currentFieldName = (0, import_private_utils.readOptionalString)(settings.dragSortBy);
+  if (currentFieldName && isApplyBlueprintCompatibleTreeTableDragSortField(collection, currentFieldName)) {
+    return settings;
+  }
+  const nextSettings = import_lodash.default.cloneDeep(settings || {});
+  const replacementFieldName = getApplyBlueprintCompatibleTreeTableDragSortFieldName(collection);
+  if (replacementFieldName) {
+    nextSettings.dragSortBy = replacementFieldName;
+  } else {
+    delete nextSettings.dragSortBy;
+  }
+  return nextSettings;
+}
+function isApplyBlueprintTreeTableBlock(blockType, settings, template, block, getCollection) {
+  return blockType === "table" && (settings == null ? void 0 : settings.treeTable) === true && !(0, import_template_reference.hasFlowSurfaceTemplateDocument)(template) && canInjectTreeTableAddChildDefault(block, getCollection);
+}
+function getTreeTableFirstFieldPath(fields) {
+  const firstField = fields.find((field) => {
+    if (typeof field === "string") {
+      return !!field.trim();
+    }
+    return import_lodash.default.isPlainObject(field) && !!(0, import_private_utils.readOptionalString)(field.field);
+  });
+  if (typeof firstField === "string") {
+    return firstField.trim();
+  }
+  return (0, import_private_utils.readOptionalString)(firstField == null ? void 0 : firstField.field);
+}
+function isUnreadableTreeTableFirstColumnName(fieldPath) {
+  const normalizedFieldPath = String(fieldPath || "").trim();
+  if (!normalizedFieldPath || normalizedFieldPath.includes(".")) {
+    return false;
+  }
+  const normalizedLowerFieldPath = normalizedFieldPath.toLowerCase();
+  return ["id", "uid", "uuid", "parentid"].includes(normalizedLowerFieldPath) || /(?:Id|ID|Uid|UID)$/.test(normalizedFieldPath) || normalizedLowerFieldPath.endsWith("_id") || normalizedLowerFieldPath.endsWith("_uid");
+}
+function isUnreadableTreeTableFirstColumnField(field) {
+  var _a, _b;
+  return !!(field == null ? void 0 : field.primaryKey) || !!((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.primaryKey) || !!(field == null ? void 0 : field.foreignKey) || !!((_b = field == null ? void 0 : field.options) == null ? void 0 : _b.foreignKey) || isApplyBlueprintAssociationField(field) || isUnreadableTreeTableFirstColumnName((0, import_service_helpers.getFieldName)(field));
+}
+function isReadableTreeTableFirstColumnField(fieldPath, collection) {
+  if (!fieldPath || fieldPath.includes(".")) {
+    return false;
+  }
+  const field = collection ? (0, import_service_helpers.resolveFieldFromCollection)(collection, fieldPath) : void 0;
+  return !!field && !!(0, import_service_helpers.getFieldInterface)(field) && !isUnreadableTreeTableFirstColumnName(fieldPath) && !isUnreadableTreeTableFirstColumnField(field);
+}
+function reorderApplyBlueprintTreeTableExplicitFields(input) {
+  if (!Object.prototype.hasOwnProperty.call(input.block, "fields") || !isApplyBlueprintTreeTableBlock(input.blockType, input.settings, input.template, input.block, input.getCollection)) {
+    return input.fields;
+  }
+  const firstFieldPath = getTreeTableFirstFieldPath(input.fields);
+  if (firstFieldPath && isReadableTreeTableFirstColumnField(firstFieldPath, input.collection)) {
+    return input.fields;
+  }
+  const readableIndex = input.fields.findIndex(
+    (field) => isReadableTreeTableFirstColumnField(getTreeTableFirstFieldPath([field]), input.collection)
+  );
+  if (readableIndex >= 0) {
+    const nextFields = input.fields.slice();
+    const [readableField] = nextFields.splice(readableIndex, 1);
+    nextFields.unshift(readableField);
+    return nextFields;
+  }
+  (0, import_errors.throwBadRequest)(
+    `${input.context}.fields[0] tree table explicit fields must include at least one direct readable non-association field; do not rely on applyBlueprint to inject a title/name fallback`
+  );
+}
+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, resourceContext, blockType) {
+  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 && !(0, import_public_data_surface_default_filter.isFlowSurfacePublicDataSurfaceBlockType)(blockType || "")) {
+    return void 0;
+  }
+  const inheritedCollectionName = (0, import_private_utils.readOptionalString)(resourceContext == null ? void 0 : resourceContext.surfaceCollectionName);
+  if (!collectionName && !inheritedCollectionName) {
+    return void 0;
+  }
+  return (0, import_service_utils.buildDefinedPayload)({
+    binding: !collectionName && inheritedCollectionName ? "otherRecords" : void 0,
+    dataSourceKey: (0, import_private_utils.readOptionalString)(block.dataSourceKey) || (0, import_private_utils.readOptionalString)(resourceContext == null ? void 0 : resourceContext.dataSourceKey) || "main",
+    collectionName: collectionName || inheritedCollectionName,
+    associationPathName: (0, import_private_utils.readOptionalString)(block.associationPathName)
+  });
+}
+const APPLY_BLUEPRINT_ASSOCIATION_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "belongsto",
+  "hasone",
+  "hasmany",
+  "belongstomany",
+  "belongstoarray",
+  "onetoone"
+]);
+const APPLY_BLUEPRINT_ASSOCIATION_FIELD_INTERFACES = /* @__PURE__ */ new Set([
+  "m2o",
+  "o2m",
+  "m2m",
+  "o2o",
+  "mbm",
+  "obo",
+  "oho",
+  "manytoone",
+  "onetomany",
+  "manytomany"
+]);
+function getApplyBlueprintAssociationFieldRoot(value) {
+  return String(value || "").split(".").map((segment) => segment.trim()).filter(Boolean)[0];
+}
+function isApplyBlueprintAssociationField(field) {
+  if (!field) {
+    return false;
+  }
+  if ((0, import_service_helpers.getFieldTarget)(field)) {
+    return true;
+  }
+  const fieldType = String((0, import_service_helpers.getFieldType)(field) || "").toLowerCase();
+  if (APPLY_BLUEPRINT_ASSOCIATION_FIELD_TYPES.has(fieldType)) {
+    return true;
+  }
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").toLowerCase();
+  return APPLY_BLUEPRINT_ASSOCIATION_FIELD_INTERFACES.has(fieldInterface);
+}
+function resolveApplyBlueprintAssociationFieldFromPath(collection, fieldPath) {
+  const normalizedFieldPath = normalizeMetadataText(fieldPath);
+  if (!collection || !normalizedFieldPath) {
+    return { field: void 0, associationPath: "" };
+  }
+  const field = (0, import_service_helpers.resolveFieldFromCollection)(collection, normalizedFieldPath);
+  if (isApplyBlueprintAssociationField(field)) {
+    return { field, associationPath: normalizedFieldPath };
+  }
+  const parentPath = normalizedFieldPath.includes(".") ? normalizedFieldPath.split(".").filter(Boolean).slice(0, -1).join(".") : "";
+  if (!parentPath) {
+    return { field, associationPath: normalizedFieldPath };
+  }
+  const parentField = (0, import_service_helpers.resolveFieldFromCollection)(collection, parentPath);
+  return { field: parentField, associationPath: parentPath };
+}
+function resolveApplyBlueprintAssociationContext(input) {
+  var _a;
+  const sourceCollectionName = normalizeMetadataText(input.sourceCollectionName);
+  const associationFieldPath = normalizeMetadataText(input.associationField);
+  if (!sourceCollectionName || !associationFieldPath) {
+    return void 0;
+  }
+  const dataSourceKey = normalizeMetadataText(input.dataSourceKey) || "main";
+  const sourceCollection = (_a = input.getCollection) == null ? void 0 : _a.call(input, dataSourceKey, sourceCollectionName);
+  const { field, associationPath } = resolveApplyBlueprintAssociationFieldFromPath(
+    sourceCollection,
+    associationFieldPath
+  );
+  if (input.requireAssociationField && !isApplyBlueprintAssociationField(field)) {
+    return void 0;
+  }
+  const targetCollection = (0, import_service_helpers.resolveFieldTargetCollection)(field, dataSourceKey, input.getCollection);
+  const targetCollectionName = normalizeMetadataText(input.targetCollectionName) || normalizeMetadataText((0, import_service_helpers.getCollectionName)(targetCollection)) || normalizeMetadataText((0, import_service_helpers.getFieldTarget)(field));
+  return {
+    dataSourceKey,
+    surfaceCollectionName: targetCollectionName || void 0,
+    associationName: (associationPath.includes(".") ? `${sourceCollectionName}.${associationPath}` : void 0) || (0, import_service_helpers.resolveAssociationNameFromField)(field, sourceCollection) || `${sourceCollectionName}.${associationPath || associationFieldPath}`
+  };
+}
+function getApplyBlueprintBlockResourceObject(block) {
+  return import_lodash.default.isPlainObject(block == null ? void 0 : block.resource) ? block.resource : void 0;
+}
+function getApplyBlueprintBlockBinding(block) {
+  const resource = getApplyBlueprintBlockResourceObject(block);
+  return normalizeMetadataText(block == null ? void 0 : block.binding) || normalizeMetadataText(resource == null ? void 0 : resource.binding);
+}
+function getApplyBlueprintBlockDataSourceKey(block, parentContext) {
+  const resource = getApplyBlueprintBlockResourceObject(block);
+  return normalizeMetadataText(block == null ? void 0 : block.dataSourceKey) || normalizeMetadataText(resource == null ? void 0 : resource.dataSourceKey) || (parentContext == null ? void 0 : parentContext.dataSourceKey) || "main";
+}
+function getApplyBlueprintBlockDirectCollection(block) {
+  const resource = getApplyBlueprintBlockResourceObject(block);
+  return normalizeMetadataText(block == null ? void 0 : block.collection) || normalizeMetadataText(resource == null ? void 0 : resource.collectionName);
+}
+function getApplyBlueprintBlockExplicitAssociationName(block) {
+  const resource = getApplyBlueprintBlockResourceObject(block);
+  return normalizeMetadataText(block == null ? void 0 : block.associationName) || normalizeMetadataText(resource == null ? void 0 : resource.associationName);
+}
+function getApplyBlueprintBlockAssociationField(block, context) {
+  const resource = getApplyBlueprintBlockResourceObject(block);
+  return normalizeMetadataText(resource == null ? void 0 : resource.associationField) || normalizeMetadataText(block.associationField) || readAssociationFieldFromSingleSegmentPath(resource == null ? void 0 : resource.associationPathName, `${context}.resource`) || readAssociationFieldFromSingleSegmentPath(block.associationPathName, context);
+}
+function resolveApplyBlueprintBlockResourceContext(block, parentContext, getCollection, context) {
+  const dataSourceKey = getApplyBlueprintBlockDataSourceKey(block, parentContext);
+  const directCollectionName = getApplyBlueprintBlockDirectCollection(block);
+  const explicitAssociationName = getApplyBlueprintBlockExplicitAssociationName(block);
+  if (explicitAssociationName) {
+    return {
+      dataSourceKey,
+      surfaceCollectionName: directCollectionName || (parentContext == null ? void 0 : parentContext.surfaceCollectionName),
+      associationName: explicitAssociationName
+    };
+  }
+  const resource = getApplyBlueprintBlockResourceObject(block);
+  const normalizedAssociatedRecords = getApplyBlueprintBlockBinding(block) ? normalizeAssociatedRecordsBindingFromAssociationPath(
+    resource || block,
+    resource ? `${context}.resource` : context
+  ) : null;
+  const binding = ((normalizedAssociatedRecords == null ? void 0 : normalizedAssociatedRecords.binding) || getApplyBlueprintBlockBinding(block)).toLowerCase();
+  if (binding === "associatedrecords") {
+    const associationField = (normalizedAssociatedRecords == null ? void 0 : normalizedAssociatedRecords.associationField) || getApplyBlueprintBlockAssociationField(block, context);
+    const associatedContext = resolveApplyBlueprintAssociationContext({
+      dataSourceKey,
+      sourceCollectionName: parentContext == null ? void 0 : parentContext.surfaceCollectionName,
+      associationField,
+      targetCollectionName: directCollectionName,
+      getCollection
+    });
+    return {
+      dataSourceKey,
+      surfaceCollectionName: directCollectionName || (associatedContext == null ? void 0 : associatedContext.surfaceCollectionName) || (parentContext == null ? void 0 : parentContext.surfaceCollectionName),
+      associationName: (parentContext == null ? void 0 : parentContext.associationName) || (associatedContext == null ? void 0 : associatedContext.associationName)
+    };
+  }
+  return {
+    dataSourceKey,
+    surfaceCollectionName: directCollectionName || (parentContext == null ? void 0 : parentContext.surfaceCollectionName),
+    associationName: parentContext == null ? void 0 : parentContext.associationName
+  };
+}
+function resolveApplyBlueprintFieldAssociationContext(input) {
+  return resolveApplyBlueprintAssociationContext({
+    dataSourceKey: input.parentContext.dataSourceKey,
+    sourceCollectionName: input.parentContext.surfaceCollectionName,
+    associationField: input.fieldPath,
+    getCollection: input.getCollection,
+    requireAssociationField: true
+  });
+}
+function getApplyBlueprintFieldAssociationPath(input) {
+  const associationPathName = (0, import_private_utils.readOptionalString)(input.associationPathName);
+  const fieldPath = (0, import_private_utils.readOptionalString)(input.field);
+  if (!associationPathName) {
+    return fieldPath;
+  }
+  if (!fieldPath || fieldPath === associationPathName || fieldPath.startsWith(`${associationPathName}.`)) {
+    return associationPathName;
+  }
+  return `${associationPathName}.${fieldPath}`;
+}
+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 buildAutoCompiledFieldsLayout(fields, blockType, collection) {
+  return (0, import_field_grid_layout.buildFlowSurfaceAutoFieldGridLayout)(
+    fields.map((field) => ({
+      key: (0, import_private_utils.readOptionalString)(field == null ? void 0 : field.key),
+      type: (0, import_private_utils.readOptionalString)(field == null ? void 0 : field.type),
+      fieldPath: (0, import_private_utils.readOptionalString)(field == null ? void 0 : field.fieldPath),
+      associationPathName: (0, import_private_utils.readOptionalString)(field == null ? void 0 : field.associationPathName),
+      fieldInterface: (0, import_field_grid_layout.resolveFlowSurfaceFieldGridFieldInterface)({
+        collection,
+        fieldPath: (0, import_private_utils.readOptionalString)(field == null ? void 0 : field.fieldPath),
+        associationPathName: (0, import_private_utils.readOptionalString)(field == null ? void 0 : field.associationPathName)
+      })
+    })),
+    blockType
+  );
+}
+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 buildAutoFieldGroupFieldPathsFromCollection(collection) {
+  const fields = (0, import_service_helpers.getCollectionFields)(collection);
+  const associationForeignKeys = new Set(
+    fields.filter((field) => (0, import_service_helpers.getFieldType)(field) === "belongsTo").map((field) => {
+      var _a;
+      return String((field == null ? void 0 : field.foreignKey) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.foreignKey) || "").trim();
+    }).filter(Boolean)
+  );
+  return fields.filter((field) => {
+    var _a, _b;
+    const name = (0, import_service_helpers.getFieldName)(field);
+    if (!name || name === "id") {
+      return false;
+    }
+    if (associationForeignKeys.has(name)) {
+      return false;
+    }
+    if ((field == null ? void 0 : field.hidden) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.hidden)) {
+      return false;
+    }
+    if (typeof (field == null ? void 0 : field.isAssociationField) === "function" && field.isAssociationField()) {
+      return false;
+    }
+    const type = String((field == null ? void 0 : field.type) || ((_b = field == null ? void 0 : field.options) == null ? void 0 : _b.type) || "").trim();
+    return !["belongsTo", "hasOne", "hasMany", "belongsToMany", "json", "password"].includes(type);
+  }).map((field) => (0, import_service_helpers.getFieldName)(field)).filter((name) => !!name);
+}
+function buildAutoFieldGroupsFromCollection(block, getCollection) {
+  const blockType = (0, import_private_utils.readOptionalString)(block.type);
+  if (!APPLY_BLUEPRINT_FIELD_GROUP_BLOCK_TYPES.has(blockType || "")) {
+    return void 0;
+  }
+  const collection = resolveBlueprintBlockCollection(block, getCollection);
+  const fields = buildAutoFieldGroupFieldPathsFromCollection(collection);
+  if (!fields.length) {
+    return void 0;
+  }
+  return [
+    {
+      key: "main",
+      title: "Main",
+      fields
+    }
+  ];
+}
+function resolveBlockFieldInputs(block, context, getCollection) {
+  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) {
+    if (!hasFields) {
+      const autoFieldGroups = buildAutoFieldGroupsFromCollection(block, getCollection);
+      if (autoFieldGroups == null ? void 0 : autoFieldGroups.length) {
+        return compileFieldGroups(autoFieldGroups, `${context}.fieldGroups`);
+      }
+    }
+    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 attachDefaultActionPopupMetadata(popup, actionType, metadata) {
+  const defaultPopup = actionType === "addChild" && import_lodash.default.isUndefined(popup) ? {} : popup;
+  return attachCompiledPopupDefaults(defaultPopup, metadata);
+}
+function isFieldClickToOpenEnabled(settings) {
+  if (!import_lodash.default.isPlainObject(settings) || !Object.prototype.hasOwnProperty.call(settings, "clickToOpen")) {
+    return false;
+  }
+  const value = settings.clickToOpen;
+  return value === true || import_lodash.default.isPlainObject(value) && value.clickToOpen === true;
+}
+function buildGeneratedDefaultFieldPopup() {
+  return {
+    tryTemplate: true,
+    defaultType: "view"
+  };
+}
+function hasNestedDefaultPopupMetadata(value) {
+  if (Array.isArray(value)) {
+    return value.some((item) => hasNestedDefaultPopupMetadata(item));
+  }
+  if (!import_lodash.default.isPlainObject(value)) {
+    return false;
+  }
+  const popup = value.popup;
+  if (import_lodash.default.isPlainObject(popup) && Object.prototype.hasOwnProperty.call(popup, import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY)) {
+    return true;
+  }
+  return Object.entries(value).some(([key, item]) => key !== "popup" && hasNestedDefaultPopupMetadata(item));
+}
+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 popupMode = normalizeApplyBlueprintPopupMode(popup.mode, context);
+  const template = ensureOptionalTemplate(popup.template, `${context}.template`);
+  const hasTemplateReference = (0, import_template_reference.hasFlowSurfaceTemplateReference)(template);
+  const hasTemplateDocument = (0, import_template_reference.hasFlowSurfaceTemplateDocument)(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 && hasTemplateReference) {
+    (0, import_errors.throwBadRequest)(`${context}.saveAsTemplate cannot be combined with ${context}.template`);
+  }
+  if (hasTemplateReference) {
+    const openViewContext2 = buildPopupOpenViewContext(options);
+    const openView2 = (0, import_service_utils.buildDefinedPayload)({
+      ...openViewContext2,
+      ...popupMode.displayMode ? { mode: popupMode.displayMode } : {}
+    });
+    return {
+      popup: (0, import_service_utils.buildDefinedPayload)({
+        template,
+        ...Object.keys(openView2).length ? { openView: openView2 } : {}
+      }),
+      popupTitle
+    };
+  }
+  const rawPopupBlocks = readOptionalItems(popup.blocks, `${context}.blocks`);
+  const popupBlocks = options.ownerActionType === "edit" && rawPopupBlocks.length ? normalizeEditPopupBlocks(rawPopupBlocks, context) : rawPopupBlocks;
+  const isMultiBlockEditPopup = options.ownerActionType === "edit" && popupBlocks.length > 1;
+  const compiledBlocks = popupBlocks.length ? compileBlocks(
+    popupBlocks,
+    scopePrefix,
+    assets,
+    `${context}.blocks`,
+    defaults,
+    collectReferencedBlockKeys(popup.layout, `${context}.layout`),
+    options.getCollection,
+    {
+      mode: options.mode,
+      popupDepth: (options.popupDepth || 1) + 1,
+      dataSourceKey: options.dataSourceKey,
+      surfaceCollectionName: options.surfaceCollectionName,
+      associationName: options.associationName
+    }
+  ) : { blocks: [], blockKeysByLocalKey: /* @__PURE__ */ new Map() };
+  const hasNestedDefaultPopup = hasNestedDefaultPopupMetadata(compiledBlocks.blocks);
+  const willAutoTryTemplate = import_lodash.default.isUndefined(popup.tryTemplate) && options.mode === "create" && !hasTemplateDocument && popupBlocks.length > 0 && !isMultiBlockEditPopup && !hasNestedDefaultPopup;
+  if (saveAsTemplate && !popupBlocks.length && tryTemplate !== true && !willAutoTryTemplate) {
+    (0, import_errors.throwBadRequest)(`${context}.saveAsTemplate requires explicit popup.blocks`);
+  }
+  const layout = popupBlocks.length || popup.layout ? compileLayout(
+    popup.layout || autoLayoutFromBlockKeys(compiledBlocks.blocks.map((block) => block.key)),
+    compiledBlocks.blockKeysByLocalKey,
+    `${context}.layout`
+  ) : void 0;
+  const autoSaveAsTemplate = import_lodash.default.isUndefined(saveAsTemplate) && options.mode === "create" && !hasTemplateDocument && popupBlocks.length > 0 && !isMultiBlockEditPopup && !hasNestedDefaultPopup ? buildApplyBlueprintAutoSaveTemplateMetadata(popup, options) : void 0;
+  const effectiveTryTemplate = willAutoTryTemplate ? true : tryTemplate;
+  const displayMode = popupMode.displayMode || (shouldDefaultApplyBlueprintPopupDisplayPage(popup, popupBlocks, options) ? "embed" : popupBlocks.length && (options.popupDepth || 1) > 1 ? "drawer" : void 0);
+  const openViewContext = buildPopupOpenViewContext(options);
+  const openView = (0, import_service_utils.buildDefinedPayload)({
+    ...openViewContext,
+    ...displayMode ? { mode: displayMode } : {}
+  });
+  const compiledPopup = (0, import_service_utils.buildDefinedPayload)({
+    mode: popupMode.composeMode || (popupBlocks.length || layout ? "replace" : void 0),
+    template: hasTemplateDocument ? template : void 0,
+    ...Object.keys(openView).length ? { openView } : {},
+    ...!import_lodash.default.isUndefined(effectiveTryTemplate) ? { tryTemplate: effectiveTryTemplate } : {},
+    ...defaultType ? { defaultType } : {},
+    ...saveAsTemplate || autoSaveAsTemplate ? { saveAsTemplate: saveAsTemplate || autoSaveAsTemplate } : {},
+    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 collectTreeConnectTargetKeys(settings, context) {
+  if (!import_lodash.default.isPlainObject(settings == null ? void 0 : settings.connectFields)) {
+    return [];
+  }
+  if (import_lodash.default.isUndefined(settings.connectFields.targets)) {
+    return [];
+  }
+  if (!Array.isArray(settings.connectFields.targets)) {
+    (0, import_errors.throwBadRequest)(`${context}.settings.connectFields.targets must be an array`);
+  }
+  const seenTargets = /* @__PURE__ */ new Set();
+  return settings.connectFields.targets.map((target, targetIndex) => {
+    if (!import_lodash.default.isPlainObject(target)) {
+      (0, import_errors.throwBadRequest)(`${context}.settings.connectFields.targets[${targetIndex}] must be an object`);
+    }
+    if (import_lodash.default.isUndefined(target.target) || target.target === null || target.target === "") {
+      return "";
+    }
+    if (typeof target.target !== "string") {
+      (0, import_errors.throwBadRequest)(`${context}.settings.connectFields.targets[${targetIndex}].target must be a string block key`);
+    }
+    const normalizedTarget = (0, import_service_utils.normalizeFlowSurfaceComposeKey)(
+      target.target,
+      `${context}.settings.connectFields.targets[${targetIndex}].target`
+    );
+    if (seenTargets.has(normalizedTarget)) {
+      (0, import_errors.throwBadRequest)(
+        `${context}.settings.connectFields.targets[${targetIndex}].target duplicate target '${normalizedTarget}' in tree connectFields`
+      );
+    }
+    seenTargets.add(normalizedTarget);
+    return normalizedTarget;
+  }).filter(Boolean);
+}
+function collectAIEmployeeWorkContextTargetKeys(value, context) {
+  if (import_lodash.default.isUndefined(value) || value === null) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    (0, import_errors.throwBadRequest)(`${context} must be an array`);
+  }
+  return value.map((item, index) => {
+    if (!import_lodash.default.isPlainObject(item)) {
+      (0, import_errors.throwBadRequest)(`${context}[${index}] must be an object`);
+    }
+    if (!Object.prototype.hasOwnProperty.call(item, "target")) {
+      return "";
+    }
+    if (typeof item.target !== "string") {
+      (0, import_errors.throwBadRequest)(`${context}[${index}].target must be 'self' or a string block key`);
+    }
+    const normalizedTarget = item.target.trim();
+    if (!normalizedTarget || normalizedTarget === "self") {
+      return "";
+    }
+    return (0, import_service_utils.normalizeFlowSurfaceComposeKey)(normalizedTarget, `${context}[${index}].target`);
+  }).filter(Boolean);
+}
+function collectAIEmployeeActionSettingsTargetKeys(settings, context) {
+  if (!import_lodash.default.isPlainObject(settings)) {
+    return [];
+  }
+  const targets = [];
+  if (Object.prototype.hasOwnProperty.call(settings, "workContext")) {
+    targets.push(...collectAIEmployeeWorkContextTargetKeys(settings.workContext, `${context}.workContext`));
+  }
+  if (Object.prototype.hasOwnProperty.call(settings, "tasks")) {
+    if (!Array.isArray(settings.tasks)) {
+      (0, import_errors.throwBadRequest)(`${context}.tasks must be an array`);
+    }
+    settings.tasks.forEach((task, taskIndex) => {
+      if (!import_lodash.default.isPlainObject(task)) {
+        (0, import_errors.throwBadRequest)(`${context}.tasks[${taskIndex}] must be an object`);
+      }
+      if (import_lodash.default.isPlainObject(task.message) && Object.prototype.hasOwnProperty.call(task.message, "workContext")) {
+        targets.push(
+          ...collectAIEmployeeWorkContextTargetKeys(
+            task.message.workContext,
+            `${context}.tasks[${taskIndex}].message.workContext`
+          )
+        );
+      }
+    });
+  }
+  return targets;
+}
+function compileTreeConnectSettingsTargets(settings, localBlockKeys, context) {
+  if (!import_lodash.default.isPlainObject(settings == null ? void 0 : settings.connectFields) || !Array.isArray(settings.connectFields.targets)) {
+    return settings;
+  }
+  const nextSettings = import_lodash.default.cloneDeep(settings);
+  nextSettings.connectFields.targets = nextSettings.connectFields.targets.map((target, targetIndex) => {
+    if (!import_lodash.default.isPlainObject(target) || import_lodash.default.isUndefined(target.target) || target.target === null || target.target === "") {
+      return target;
+    }
+    return {
+      ...target,
+      target: resolveTargetBlockKey(
+        target.target,
+        localBlockKeys,
+        `${context}.settings.connectFields.targets[${targetIndex}].target`
+      )
+    };
+  });
+  return nextSettings;
+}
+function compileAIEmployeeWorkContextTargets(value, localBlockKeys, context) {
+  if (import_lodash.default.isUndefined(value) || value === null) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    (0, import_errors.throwBadRequest)(`${context} must be an array`);
+  }
+  return value.map((item, index) => {
+    if (!import_lodash.default.isPlainObject(item)) {
+      (0, import_errors.throwBadRequest)(`${context}[${index}] must be an object`);
+    }
+    if (!Object.prototype.hasOwnProperty.call(item, "target")) {
+      return item;
+    }
+    if (typeof item.target !== "string") {
+      (0, import_errors.throwBadRequest)(`${context}[${index}].target must be 'self' or a string block key`);
+    }
+    const normalizedTarget = item.target.trim();
+    if (!normalizedTarget || normalizedTarget === "self") {
+      return item;
+    }
+    return {
+      ...item,
+      target: resolveTargetBlockKey(item.target, localBlockKeys, `${context}[${index}].target`)
+    };
+  });
+}
+function compileAIEmployeeActionSettingsTargets(settings, localBlockKeys, context) {
+  if (!import_lodash.default.isPlainObject(settings)) {
+    return settings;
+  }
+  let nextSettings = settings;
+  if (Object.prototype.hasOwnProperty.call(settings, "workContext")) {
+    nextSettings = nextSettings === settings ? import_lodash.default.cloneDeep(settings) : nextSettings;
+    nextSettings.workContext = compileAIEmployeeWorkContextTargets(
+      settings.workContext,
+      localBlockKeys,
+      `${context}.settings.workContext`
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(settings, "tasks")) {
+    if (!Array.isArray(settings.tasks)) {
+      (0, import_errors.throwBadRequest)(`${context}.settings.tasks must be an array`);
+    }
+    nextSettings = nextSettings === settings ? import_lodash.default.cloneDeep(settings) : nextSettings;
+    nextSettings.tasks = settings.tasks.map((task, taskIndex) => {
+      if (!import_lodash.default.isPlainObject(task)) {
+        (0, import_errors.throwBadRequest)(`${context}.settings.tasks[${taskIndex}] must be an object`);
+      }
+      if (!import_lodash.default.isPlainObject(task.message) || !Object.prototype.hasOwnProperty.call(task.message, "workContext")) {
+        return task;
+      }
+      return {
+        ...task,
+        message: {
+          ...task.message,
+          workContext: compileAIEmployeeWorkContextTargets(
+            task.message.workContext,
+            localBlockKeys,
+            `${context}.settings.tasks[${taskIndex}].message.workContext`
+          )
+        }
+      };
+    });
+  }
+  return nextSettings;
+}
+function compileField(input, index, scopePrefix, assets, localBlockKeys, context, popupDefaultsMetadata, defaults, getCollection, popupOptions = {}) {
+  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`);
+  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 parentResourceContext = {
+    dataSourceKey: popupOptions.dataSourceKey,
+    surfaceCollectionName: popupOptions.surfaceCollectionName,
+    associationName: popupOptions.associationName
+  };
+  const fieldAssociationContext = resolveApplyBlueprintFieldAssociationContext({
+    fieldPath: getApplyBlueprintFieldAssociationPath(input),
+    parentContext: parentResourceContext,
+    getCollection
+  });
+  const shouldAutoCompleteClickPopup = import_lodash.default.isUndefined(input.popup) && isFieldClickToOpenEnabled(settings);
+  const popupInput = shouldAutoCompleteClickPopup ? buildGeneratedDefaultFieldPopup() : input.popup;
+  const shouldAutoRelationFieldPopup = import_lodash.default.isUndefined(input.popup) && !!fieldPath && !syntheticType;
+  const popupResult = compilePopup(popupInput, `${key}.popup`, assets, `${context}[${index}].popup`, defaults, {
+    getCollection,
+    mode: popupOptions.mode,
+    popupDepth: popupOptions.popupDepth,
+    triggerKind: "field",
+    triggerLabel: input.label || input.field || input.key,
+    hostBlock: popupOptions.hostBlock,
+    dataSourceKey: (fieldAssociationContext == null ? void 0 : fieldAssociationContext.dataSourceKey) || popupOptions.dataSourceKey,
+    surfaceCollectionName: (fieldAssociationContext == null ? void 0 : fieldAssociationContext.surfaceCollectionName) || popupOptions.surfaceCollectionName,
+    associationName: popupOptions.associationName || (fieldAssociationContext == null ? void 0 : fieldAssociationContext.associationName)
+  });
+  settings = resolvePopupTitleSettings(settings, popupResult.popupTitle);
+  const popup = shouldAttachDefaultPopupMetadata(popupInput, 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,
+    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,
+    __autoPopupForRelationField: shouldAutoRelationFieldPopup ? true : void 0,
+    ...shouldAutoRelationFieldPopup && popupDefaultsMetadata ? { [import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]: import_lodash.default.cloneDeep(popupDefaultsMetadata) } : {}
+  });
+}
+function compileAction(input, index, scopePrefix, assets, localBlockKeys, context, popupDefaultsMetadata, defaults, getCollection, options = {}) {
+  var _a, _b, _c, _d, _e, _f;
+  const buildActionKey = (localKey2, isExplicit, keyContext) => {
+    const key2 = (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, localKey2), keyContext);
+    const avoidKeys = options.avoidKeys;
+    if (!(avoidKeys == null ? void 0 : avoidKeys.has(key2))) {
+      return key2;
+    }
+    if (isExplicit) {
+      (0, import_errors.throwBadRequest)(`${keyContext} '${key2}' duplicates an action key in the same block`);
+    }
+    const prefix = options.generatedConflictPrefix ? (0, import_service_utils.normalizeFlowSurfaceComposeKey)(options.generatedConflictPrefix, keyContext) : void 0;
+    const baseLocalKey = prefix ? `${prefix}_${localKey2}` : localKey2;
+    let candidate = (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, baseLocalKey), keyContext);
+    let suffix = 2;
+    while (avoidKeys.has(candidate)) {
+      candidate = (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, `${baseLocalKey}_${suffix}`), keyContext);
+      suffix += 1;
+    }
+    return candidate;
+  };
+  if (typeof input === "string") {
+    const type2 = (0, import_private_utils.assertNonEmptyString)(input, `${context}[${index}]`);
+    const localKey2 = (0, import_private_utils.normalizeBlueprintLocalKey)(void 0, `${type2}_${index + 1}`, `${context}[${index}]`);
+    const defaultPopup = APPLY_BLUEPRINT_DEFAULT_POPUP_ACTION_TYPES.has(type2) ? attachDefaultActionPopupMetadata(void 0, type2, popupDefaultsMetadata) : void 0;
+    return {
+      key: buildActionKey(localKey2, false, `${context}[${index}]`),
+      type: type2,
+      ...defaultPopup ? { popup: defaultPopup } : {}
+    };
+  }
+  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 hasExplicitKey = (0, import_private_utils.readOptionalString)(input.key);
+  const localKey = (0, import_private_utils.normalizeBlueprintLocalKey)(input.key, `${type}_${index + 1}`, `${context}[${index}].key`);
+  const key = buildActionKey(localKey, !!hasExplicitKey, `${context}[${index}].key`);
+  let settings = resolveAssetSettings(input.settings, input, assets, `${context}[${index}]`);
+  if (type !== AI_EMPLOYEE_ACTION_TYPE && (0, import_private_utils.readOptionalString)(input.title) && import_lodash.default.isUndefined(settings.title)) {
+    settings.title = (0, import_private_utils.readOptionalString)(input.title);
+  }
+  if (type === AI_EMPLOYEE_ACTION_TYPE) {
+    settings = compileAIEmployeeActionSettingsTargets(settings, localBlockKeys, `${context}[${index}]`);
+  }
+  const popupResult = compilePopup(input.popup, `${key}.popup`, assets, `${context}[${index}].popup`, defaults, {
+    ownerActionType: type,
+    getCollection,
+    mode: (_a = options.popupOptions) == null ? void 0 : _a.mode,
+    popupDepth: (_b = options.popupOptions) == null ? void 0 : _b.popupDepth,
+    triggerKind: options.triggerKind,
+    triggerLabel: input.title || input.key || input.type,
+    hostBlock: (_c = options.popupOptions) == null ? void 0 : _c.hostBlock,
+    dataSourceKey: (_d = options.popupOptions) == null ? void 0 : _d.dataSourceKey,
+    surfaceCollectionName: (_e = options.popupOptions) == null ? void 0 : _e.surfaceCollectionName,
+    associationName: (_f = options.popupOptions) == null ? void 0 : _f.associationName
+  });
+  settings = resolvePopupTitleSettings(settings, popupResult.popupTitle);
+  const popup = shouldAttachDefaultPopupMetadata(input.popup, type) ? attachDefaultActionPopupMetadata(popupResult.popup, type, 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, popupOptions = {}) {
+  const descriptorPopup = descriptor.popup ? import_lodash.default.cloneDeep(descriptor.popup) : void 0;
+  let popup = descriptorPopup;
+  const openViewContext = buildPopupOpenViewContext(popupOptions);
+  if (popup && Object.keys(openViewContext).length) {
+    popup = {
+      ...popup,
+      openView: (0, import_service_utils.buildDefinedPayload)({
+        ...openViewContext,
+        ...import_lodash.default.isPlainObject(popup.openView) ? popup.openView : {}
+      })
+    };
+  }
+  popup = shouldAttachDefaultPopupMetadata(popup, descriptor.type) ? attachCompiledPopupDefaults(popup, popupDefaultsMetadata) : void 0;
+  const localKey = descriptor.type === "submit" ? "submitAction" : `${descriptor.type}_default_${index + 1}`;
+  return (0, import_service_utils.buildDefinedPayload)({
+    key: (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, localKey), `${context}[${index}]`),
+    type: descriptor.type,
+    popup
+  });
+}
+function shouldStripSingleScopeApplyBlueprintDataBlockTitle(block, rawBlocks) {
+  if (!(0, import_data_block_rules.isFlowSurfaceNonTemplateTitleCleanupDataBlock)(block)) {
+    return false;
+  }
+  return (0, import_data_block_rules.countFlowSurfaceNonTemplateTitleCleanupDataBlocks)(rawBlocks) === 1;
+}
+function isTreeCollection(collection) {
+  var _a;
+  return (collection == null ? void 0 : collection.template) === "tree" || ((_a = collection == null ? void 0 : collection.options) == null ? void 0 : _a.template) === "tree" || (collection == null ? void 0 : collection.tree) === true;
+}
+function resolveTreeChildrenFieldName(collection) {
+  const field = (0, import_service_helpers.getCollectionFields)(collection).find(
+    (candidate) => {
+      var _a;
+      return (candidate == null ? void 0 : candidate.treeChildren) === true || ((_a = candidate == null ? void 0 : candidate.options) == null ? void 0 : _a.treeChildren) === true;
+    }
+  );
+  return (0, import_service_helpers.getFieldName)(field);
+}
+function canInjectTreeTableAddChildDefault(block, getCollection) {
+  if (!getCollection) {
+    return false;
+  }
+  const resource = import_lodash.default.isPlainObject(block.resource) ? block.resource : void 0;
+  const dataSourceKey = (0, import_private_utils.readOptionalString)(block.dataSourceKey) || (0, import_private_utils.readOptionalString)(resource == null ? void 0 : resource.dataSourceKey) || "main";
+  const collectionName = (0, import_private_utils.readOptionalString)(block.collection) || (0, import_private_utils.readOptionalString)(resource == null ? void 0 : resource.collectionName);
+  if (!collectionName) {
+    return false;
+  }
+  const collection = getCollection(dataSourceKey, collectionName);
+  if (!collection) {
+    return false;
+  }
+  if (!isTreeCollection(collection)) {
+    return false;
+  }
+  return !!resolveTreeChildrenFieldName(collection);
+}
+function resolveBlueprintBlockCollection(block, getCollection) {
+  if (!getCollection) {
+    return null;
+  }
+  const resource = import_lodash.default.isPlainObject(block.resource) ? block.resource : void 0;
+  const dataSourceKey = (0, import_private_utils.readOptionalString)(block.dataSourceKey) || (0, import_private_utils.readOptionalString)(resource == null ? void 0 : resource.dataSourceKey) || "main";
+  const collectionName = (0, import_private_utils.readOptionalString)(block.collection) || (0, import_private_utils.readOptionalString)(resource == null ? void 0 : resource.collectionName);
+  if (!collectionName) {
+    return null;
+  }
+  return getCollection(dataSourceKey, collectionName);
+}
+function hasExplicitAddChildRecordAction(recordActions) {
+  return recordActions.some((action) => {
+    if (typeof action === "string") {
+      return action.trim() === "addChild";
+    }
+    return (0, import_private_utils.readOptionalString)(action == null ? void 0 : action.type) === "addChild";
+  });
+}
+function buildTreeTableAddChildDefaultAction(scopePrefix, context, index, popupDefaultsMetadata, popupOptions = {}) {
+  const descriptorPopup = {
+    tryTemplate: true,
+    [import_default_block_actions.FLOW_SURFACE_INTERNAL_AUTO_SAVE_DEFAULT_POPUP_TEMPLATE_KEY]: true
+  };
+  return compileInjectedDefaultAction(
+    {
+      type: "addChild",
+      scope: "recordActions",
+      popup: descriptorPopup
+    },
+    scopePrefix,
+    context,
+    index,
+    popupDefaultsMetadata,
+    popupOptions
+  );
+}
+function compileBlocks(input, scopePrefix, assets, context, defaults, requiredExplicitBlockKeys = /* @__PURE__ */ new Set(), getCollection, options = {}) {
+  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}]`, getCollection);
+    collectTreeConnectTargetKeys(block.settings, `${context}[${index}]`).forEach((targetKey) => {
+      referencedBlockKeys.add(targetKey);
+    });
+    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`)
+      );
+    });
+    const collectActionTargets = (items, slot) => {
+      items.forEach((action, actionIndex) => {
+        if (readApplyBlueprintActionType(action) !== AI_EMPLOYEE_ACTION_TYPE || !import_lodash.default.isPlainObject(action)) {
+          return;
+        }
+        collectAIEmployeeActionSettingsTargetKeys(
+          action.settings,
+          `${context}[${index}].${slot}[${actionIndex}]`
+        ).forEach((targetKey) => referencedBlockKeys.add(targetKey));
+      });
+    };
+    collectActionTargets(readOptionalItems(block.actions, `${context}[${index}].actions`), "actions");
+    collectActionTargets(readOptionalItems(block.recordActions, `${context}[${index}].recordActions`), "recordActions");
+  });
+  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 blockType = (0, import_private_utils.readOptionalString)(block.type);
+    const parentResourceContext = {
+      dataSourceKey: options.dataSourceKey,
+      surfaceCollectionName: options.surfaceCollectionName,
+      associationName: options.associationName
+    };
+    const blockResourceContext = resolveApplyBlueprintBlockResourceContext(
+      block,
+      parentResourceContext,
+      getCollection,
+      blockContext
+    );
+    const stripSingleScopeTitle = shouldStripSingleScopeApplyBlueprintDataBlockTitle(block, rawBlocks);
+    let settings = resolveAssetSettings(block.settings, block, assets, blockContext);
+    settings = normalizeApplyBlueprintCalendarCompatSettings(block, settings);
+    if (!stripSingleScopeTitle && (0, import_private_utils.readOptionalString)(block.title) && import_lodash.default.isUndefined(settings.title)) {
+      settings.title = (0, import_private_utils.readOptionalString)(block.title);
+    }
+    if (stripSingleScopeTitle && Object.prototype.hasOwnProperty.call(settings, "title")) {
+      delete settings.title;
+    }
+    if ((0, import_private_utils.readOptionalString)(block.description) && import_lodash.default.isUndefined(settings.description)) {
+      settings.description = (0, import_private_utils.readOptionalString)(block.description);
+    }
+    if (!import_lodash.default.isUndefined(block.height) && import_lodash.default.isUndefined(settings.height)) {
+      settings.height = block.height;
+    }
+    if (!import_lodash.default.isUndefined(block.heightMode) && import_lodash.default.isUndefined(settings.heightMode)) {
+      settings.heightMode = block.heightMode;
+    }
+    settings = (0, import_public_compatibility.normalizeFlowSurfacePublicSortingAlias)({
+      context: `${blockContext}.settings`,
+      type: blockType,
+      settings
+    });
+    settings = normalizeApplyBlueprintTreeTableDragSortBy(block, settings, getCollection);
+    if (blockType === "calendar") {
+      settings = normalizeApplyBlueprintCalendarPopupSettings(settings, blockContext, popupDefaultsMetadata);
+    } else if (blockType === "kanban") {
+      settings = normalizeApplyBlueprintKanbanPopupSettings(settings, blockContext, popupDefaultsMetadata);
+    }
+    const template = ensureOptionalTemplate(block.template, `${blockContext}.template`);
+    const isTemplateBackedBlock = (0, import_template_reference.hasFlowSurfaceTemplateReference)(template);
+    const explicitBlockDefaultFilter = (0, import_public_data_surface_default_filter.normalizeFlowSurfacePublicBlockDefaultFilter)(
+      "applyBlueprint",
+      block.defaultFilter,
+      {
+        blockType,
+        template,
+        path: blockContext
+      }
+    );
+    const blockDefaultFilter = !import_lodash.default.isUndefined(explicitBlockDefaultFilter) ? explicitBlockDefaultFilter : buildApplyBlueprintDefaultFilter(block, blockType, template, getCollection);
+    const effectiveBlockDefaultFilter = !import_lodash.default.isUndefined(blockDefaultFilter) ? (0, import_public_data_surface_default_filter.clampFlowSurfaceDefaultFilterToCandidateLimit)(blockDefaultFilter) : void 0;
+    if (!import_lodash.default.isUndefined(effectiveBlockDefaultFilter)) {
+      (0, import_public_data_surface_default_filter.assertFlowSurfaceConcreteDefaultFilterItem)("applyBlueprint", effectiveBlockDefaultFilter, {
+        path: blockContext
+      });
+    }
+    const rawFieldInputs = resolveBlockFieldInputs(block, blockContext, getCollection);
+    const fieldGridCollection = getCollection && blockResourceContext.surfaceCollectionName ? getCollection(blockResourceContext.dataSourceKey || "main", blockResourceContext.surfaceCollectionName) : null;
+    const fieldInputs = reorderApplyBlueprintTreeTableExplicitFields({
+      blockType,
+      settings,
+      template,
+      block,
+      fields: rawFieldInputs,
+      collection: fieldGridCollection,
+      getCollection,
+      context: blockContext
+    });
+    const fields = fieldInputs.map(
+      (field, fieldIndex) => compileField(
+        field,
+        fieldIndex,
+        key,
+        assets,
+        blockKeysByLocalKey,
+        `${blockContext}.fields`,
+        popupDefaultsMetadata,
+        defaults,
+        getCollection,
+        {
+          mode: options.mode,
+          popupDepth: options.popupDepth || 1,
+          hostBlock: block,
+          dataSourceKey: blockResourceContext.dataSourceKey,
+          surfaceCollectionName: blockResourceContext.surfaceCollectionName,
+          associationName: blockResourceContext.associationName
+        }
+      )
+    );
+    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), fieldGridCollection);
+    const { actions, recordActions } = splitApplyBlueprintBlockActionsByScope(block, blockContext);
+    const explicitActions = actions.map(
+      (action, actionIndex) => compileAction(
+        action,
+        actionIndex,
+        key,
+        assets,
+        blockKeysByLocalKey,
+        `${blockContext}.actions`,
+        popupDefaultsMetadata,
+        defaults,
+        getCollection,
+        {
+          popupOptions: {
+            mode: options.mode,
+            popupDepth: options.popupDepth || 1,
+            hostBlock: block,
+            dataSourceKey: blockResourceContext.dataSourceKey,
+            surfaceCollectionName: blockResourceContext.surfaceCollectionName,
+            associationName: blockResourceContext.associationName
+          },
+          triggerKind: "action"
+        }
+      )
+    );
+    const explicitActionKeys = new Set(explicitActions.map((action) => action.key).filter(Boolean));
+    const explicitRecordActions = recordActions.map(
+      (action, actionIndex) => compileAction(
+        action,
+        actionIndex,
+        key,
+        assets,
+        blockKeysByLocalKey,
+        `${blockContext}.recordActions`,
+        popupDefaultsMetadata,
+        defaults,
+        getCollection,
+        {
+          avoidKeys: explicitActionKeys,
+          generatedConflictPrefix: "record",
+          popupOptions: {
+            mode: options.mode,
+            popupDepth: options.popupDepth || 1,
+            hostBlock: block,
+            dataSourceKey: blockResourceContext.dataSourceKey,
+            surfaceCollectionName: blockResourceContext.surfaceCollectionName,
+            associationName: blockResourceContext.associationName
+          },
+          triggerKind: "recordAction"
+        }
+      )
+    );
+    const shouldInjectAddChild = isApplyBlueprintTreeTableBlock(blockType, settings, template, block, getCollection);
+    const injectedActionIndexes = {
+      actions: explicitActions.length,
+      recordActions: explicitRecordActions.length
+    };
+    const mergedActions = (0, import_default_block_actions.mergeFlowSurfaceDefaultBlockActions)({
+      blockType,
+      template,
+      actions: explicitActions,
+      recordActions: explicitRecordActions,
+      mergeRecordActionDefaults: !shouldInjectAddChild,
+      createAction: (descriptor) => compileInjectedDefaultAction(
+        descriptor,
+        key,
+        `${blockContext}.${descriptor.scope}`,
+        injectedActionIndexes[descriptor.scope]++,
+        popupDefaultsMetadata,
+        {
+          mode: options.mode,
+          popupDepth: options.popupDepth || 1,
+          hostBlock: block,
+          dataSourceKey: blockResourceContext.dataSourceKey,
+          surfaceCollectionName: blockResourceContext.surfaceCollectionName,
+          associationName: blockResourceContext.associationName
+        }
+      )
+    });
+    const finalRecordActions = blockType === "table" && shouldInjectAddChild && !hasExplicitAddChildRecordAction(mergedActions.recordActions) ? [
+      ...mergedActions.recordActions,
+      buildTreeTableAddChildDefaultAction(
+        key,
+        `${blockContext}.recordActions`,
+        injectedActionIndexes.recordActions++,
+        popupDefaultsMetadata,
+        {
+          mode: options.mode,
+          popupDepth: options.popupDepth || 1,
+          hostBlock: block,
+          dataSourceKey: blockResourceContext.dataSourceKey,
+          surfaceCollectionName: blockResourceContext.surfaceCollectionName,
+          associationName: blockResourceContext.associationName
+        }
+      )
+    ] : mergedActions.recordActions;
+    const actionsWithDefaultFilter = (0, import_public_data_surface_default_filter.backfillFlowSurfaceFilterActionDefaultFilter)(
+      mergedActions.actions,
+      effectiveBlockDefaultFilter
+    );
+    return (0, import_service_utils.buildDefinedPayload)({
+      key,
+      type: isTemplateBackedBlock ? void 0 : blockType,
+      resource: isTemplateBackedBlock ? void 0 : buildBlockResource(block, blockContext, blockResourceContext, blockType),
+      template,
+      defaultFilter: !isTemplateBackedBlock ? effectiveBlockDefaultFilter : void 0,
+      settings: Object.keys(settings).length ? compileTreeConnectSettingsTargets(settings, blockKeysByLocalKey, blockContext) : void 0,
+      fields: isTemplateBackedBlock || blockType === "calendar" || blockType === "tree" ? void 0 : fields,
+      fieldsLayout: isTemplateBackedBlock || blockType === "calendar" || blockType === "kanban" || blockType === "tree" ? void 0 : fieldsLayout,
+      actions: isTemplateBackedBlock || blockType === "tree" ? void 0 : actionsWithDefaultFilter,
+      recordActions: isTemplateBackedBlock || blockType === "calendar" || blockType === "kanban" || blockType === "tree" ? void 0 : finalRecordActions
+    });
+  });
+  return {
+    blocks,
+    blockKeysByLocalKey
+  };
+}
+function buildApplyBlueprintDefaultFilter(block, blockType, template, getCollection) {
+  if (!blockType || !(0, import_public_data_surface_default_filter.isFlowSurfacePublicDataSurfaceBlockType)(blockType) || (0, import_template_reference.hasFlowSurfaceTemplateDocument)(template) || !getCollection) {
+    return void 0;
+  }
+  const collection = resolveBlueprintBlockCollection(block, getCollection);
+  return (0, import_public_data_surface_default_filter.buildFlowSurfaceDefaultFilterFromCollection)(collection);
+}
+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),
+    options.getCollection,
+    {
+      mode: document.mode
+    }
+  );
+  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,
+    defaults: document.defaults
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectReferencedBlockKeys,
+  compileTabComposeValues
+});