@nocobase/plugin-flow-engine 2.1.0-alpha.12 → 2.1.0-alpha.13

package/dist/server/flow-schema-registry/FlowSchemaRegistry.js

@@ -0,0 +1,1424 @@
+/**
+ * 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 FlowSchemaRegistry_exports = {};
+__export(FlowSchemaRegistry_exports, {
+  FlowSchemaRegistry: () => FlowSchemaRegistry
+});
+module.exports = __toCommonJS(FlowSchemaRegistry_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_fieldBinding = require("./flow-schema-registry/fieldBinding");
+var import_modelPatches = require("./flow-schema-registry/modelPatches");
+var import_schemaInference = require("./flow-schema-registry/schemaInference");
+var import_utils = require("./flow-schema-registry/utils");
+class FlowSchemaRegistry {
+  modelSchemas = /* @__PURE__ */ new Map();
+  actionSchemas = /* @__PURE__ */ new Map();
+  fieldBindingContexts = /* @__PURE__ */ new Map();
+  fieldBindings = /* @__PURE__ */ new Map();
+  resolvedModelCache = /* @__PURE__ */ new Map();
+  modelSnapshotSchemaCache = /* @__PURE__ */ new Map();
+  compactModelSnapshotSchemaCache = /* @__PURE__ */ new Map();
+  modelSchemaHashCache = /* @__PURE__ */ new Map();
+  compactModelSchemaHashCache = /* @__PURE__ */ new Map();
+  modelDocumentCache = /* @__PURE__ */ new Map();
+  modelLocalDynamicHintsCache = /* @__PURE__ */ new Map();
+  publicModelDocumentCache = /* @__PURE__ */ new Map();
+  publicTreeRoots = /* @__PURE__ */ new Set();
+  slotUseExpansions = /* @__PURE__ */ new Map();
+  invalidateDerivedCaches() {
+    this.resolvedModelCache.clear();
+    this.modelSnapshotSchemaCache.clear();
+    this.compactModelSnapshotSchemaCache.clear();
+    this.modelSchemaHashCache.clear();
+    this.compactModelSchemaHashCache.clear();
+    this.modelDocumentCache.clear();
+    this.modelLocalDynamicHintsCache.clear();
+    this.publicModelDocumentCache.clear();
+  }
+  registerAction(action) {
+    var _a, _b, _c, _d;
+    const name = String((action == null ? void 0 : action.name) || "").trim();
+    if (!name) return;
+    const previous = this.actionSchemas.get(name);
+    const inferred = (0, import_schemaInference.inferParamsSchemaFromUiSchema)(name, action.uiSchema, `actions.${name}`);
+    const mergedSchema = (0, import_utils.mergeSchemas)(action.paramsSchema || inferred.schema, action.paramsSchemaPatch);
+    const explicit = !!action.paramsSchema || !!action.paramsSchemaPatch;
+    const coverageStatus = explicit ? inferred.schema ? "mixed" : "manual" : inferred.coverage;
+    const docs = (0, import_utils.normalizeSchemaDocs)({
+      ...previous == null ? void 0 : previous.docs,
+      ...action.schemaDocs,
+      examples: ((_a = action.schemaDocs) == null ? void 0 : _a.examples) || ((_b = previous == null ? void 0 : previous.docs) == null ? void 0 : _b.examples),
+      dynamicHints: [...((_c = previous == null ? void 0 : previous.docs) == null ? void 0 : _c.dynamicHints) || [], ...((_d = action.schemaDocs) == null ? void 0 : _d.dynamicHints) || []]
+    });
+    this.actionSchemas.set(name, {
+      name,
+      title: action.title,
+      definition: action,
+      schema: mergedSchema,
+      coverage: {
+        status: mergedSchema ? coverageStatus : "unresolved",
+        source: (previous == null ? void 0 : previous.coverage.source) || "official",
+        strict: previous == null ? void 0 : previous.coverage.strict
+      },
+      docs,
+      dynamicHints: (0, import_utils.normalizeSchemaHints)([
+        ...(previous == null ? void 0 : previous.dynamicHints) || [],
+        ...inferred.hints || [],
+        ...docs.dynamicHints || []
+      ])
+    });
+    this.invalidateDerivedCaches();
+  }
+  registerActions(actions) {
+    for (const action of Object.values(actions || {})) {
+      this.registerAction(action);
+    }
+  }
+  registerActionContribution(contribution) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const name = String((contribution == null ? void 0 : contribution.name) || "").trim();
+    if (!name) return;
+    const previous = this.actionSchemas.get(name);
+    const docs = (0, import_utils.normalizeSchemaDocs)({
+      ...previous == null ? void 0 : previous.docs,
+      ...contribution.docs,
+      examples: ((_a = contribution.docs) == null ? void 0 : _a.examples) || ((_b = previous == null ? void 0 : previous.docs) == null ? void 0 : _b.examples),
+      dynamicHints: [...((_c = previous == null ? void 0 : previous.docs) == null ? void 0 : _c.dynamicHints) || [], ...((_d = contribution.docs) == null ? void 0 : _d.dynamicHints) || []],
+      commonPatterns: ((_e = contribution.docs) == null ? void 0 : _e.commonPatterns) || ((_f = previous == null ? void 0 : previous.docs) == null ? void 0 : _f.commonPatterns),
+      antiPatterns: ((_g = contribution.docs) == null ? void 0 : _g.antiPatterns) || ((_h = previous == null ? void 0 : previous.docs) == null ? void 0 : _h.antiPatterns),
+      minimalExample: ((_i = contribution.docs) == null ? void 0 : _i.minimalExample) !== void 0 ? contribution.docs.minimalExample : (_j = previous == null ? void 0 : previous.docs) == null ? void 0 : _j.minimalExample
+    });
+    this.actionSchemas.set(name, {
+      name,
+      title: contribution.title || (previous == null ? void 0 : previous.title),
+      definition: previous == null ? void 0 : previous.definition,
+      schema: contribution.paramsSchema ? import_lodash.default.cloneDeep(contribution.paramsSchema) : previous == null ? void 0 : previous.schema,
+      docs,
+      coverage: {
+        status: contribution.paramsSchema ? "manual" : (previous == null ? void 0 : previous.coverage.status) || "unresolved",
+        source: contribution.source || (previous == null ? void 0 : previous.coverage.source) || "official",
+        strict: contribution.strict ?? (previous == null ? void 0 : previous.coverage.strict)
+      },
+      dynamicHints: (0, import_utils.normalizeSchemaHints)([...(previous == null ? void 0 : previous.dynamicHints) || [], ...docs.dynamicHints || []])
+    });
+    this.invalidateDerivedCaches();
+  }
+  registerActionContributions(contributions) {
+    const values = Array.isArray(contributions) ? contributions : Object.values(contributions || {});
+    for (const contribution of values) {
+      this.registerActionContribution(contribution);
+    }
+  }
+  registerFieldBindingContext(contribution, fallbackName) {
+    const normalized = (0, import_fieldBinding.normalizeFieldBindingContextContribution)(contribution, fallbackName);
+    if (!normalized) {
+      return;
+    }
+    const previous = this.fieldBindingContexts.get(normalized.name);
+    this.fieldBindingContexts.set(normalized.name, {
+      name: normalized.name,
+      inherits: import_lodash.default.uniq([...(previous == null ? void 0 : previous.inherits) || [], ...normalized.inherits])
+    });
+    this.invalidateDerivedCaches();
+  }
+  registerFieldBindingContexts(contributions) {
+    if (!contributions) {
+      return;
+    }
+    if (Array.isArray(contributions)) {
+      for (const contribution of contributions) {
+        this.registerFieldBindingContext(contribution);
+      }
+      return;
+    }
+    for (const [name, contribution] of Object.entries(contributions)) {
+      if (!contribution) {
+        continue;
+      }
+      this.registerFieldBindingContext(contribution, name);
+    }
+  }
+  registerFieldBinding(contribution, source = "official") {
+    const normalized = (0, import_fieldBinding.normalizeFieldBindingContribution)(contribution, source);
+    if (!normalized) {
+      return;
+    }
+    const bindings = this.fieldBindings.get(normalized.context) || [];
+    bindings.push(normalized);
+    this.fieldBindings.set(normalized.context, bindings);
+    this.invalidateDerivedCaches();
+  }
+  registerFieldBindings(contributions, source = "official") {
+    if (!contributions) {
+      return;
+    }
+    if (Array.isArray(contributions)) {
+      for (const contribution of contributions) {
+        this.registerFieldBinding(contribution, source);
+      }
+      return;
+    }
+    for (const [context, contribution] of Object.entries(contributions)) {
+      if (!contribution) {
+        continue;
+      }
+      const items = Array.isArray(contribution) ? contribution : [contribution];
+      for (const item of items) {
+        this.registerFieldBinding(
+          {
+            ...item,
+            context: item.context || context
+          },
+          source
+        );
+      }
+    }
+  }
+  registerModel(use, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const name = String(use || "").trim();
+    if (!name) return;
+    const previous = this.modelSchemas.get(name);
+    this.modelSchemas.set(name, {
+      use: name,
+      title: options.title || (previous == null ? void 0 : previous.title),
+      modelClass: options.modelClass || (previous == null ? void 0 : previous.modelClass),
+      stepParamsSchema: options.stepParamsSchema || (previous == null ? void 0 : previous.stepParamsSchema),
+      flowRegistrySchema: options.flowRegistrySchema || (previous == null ? void 0 : previous.flowRegistrySchema),
+      subModelSlots: (0, import_modelPatches.normalizeSubModelSlots)(options.subModelSlots || (previous == null ? void 0 : previous.subModelSlots)),
+      flowRegistrySchemaPatch: options.flowRegistrySchemaPatch || (previous == null ? void 0 : previous.flowRegistrySchemaPatch),
+      examples: options.examples || (previous == null ? void 0 : previous.examples) || [],
+      docs: (0, import_utils.normalizeSchemaDocs)({
+        ...previous == null ? void 0 : previous.docs,
+        ...options.docs,
+        examples: ((_a = options.docs) == null ? void 0 : _a.examples) || ((_b = previous == null ? void 0 : previous.docs) == null ? void 0 : _b.examples),
+        dynamicHints: [...((_c = previous == null ? void 0 : previous.docs) == null ? void 0 : _c.dynamicHints) || [], ...((_d = options.docs) == null ? void 0 : _d.dynamicHints) || []],
+        commonPatterns: ((_e = options.docs) == null ? void 0 : _e.commonPatterns) || ((_f = previous == null ? void 0 : previous.docs) == null ? void 0 : _f.commonPatterns),
+        antiPatterns: ((_g = options.docs) == null ? void 0 : _g.antiPatterns) || ((_h = previous == null ? void 0 : previous.docs) == null ? void 0 : _h.antiPatterns),
+        minimalExample: ((_i = options.docs) == null ? void 0 : _i.minimalExample) !== void 0 ? options.docs.minimalExample : (_j = previous == null ? void 0 : previous.docs) == null ? void 0 : _j.minimalExample
+      }),
+      skeleton: options.skeleton !== void 0 ? import_lodash.default.cloneDeep(options.skeleton) : previous == null ? void 0 : previous.skeleton,
+      dynamicHints: (0, import_utils.normalizeSchemaHints)([...(previous == null ? void 0 : previous.dynamicHints) || [], ...options.dynamicHints || []]),
+      coverage: options.coverage || (previous == null ? void 0 : previous.coverage) || { status: "unresolved", source: "third-party" },
+      exposure: options.exposure ?? (previous == null ? void 0 : previous.exposure) ?? "public",
+      abstract: options.abstract ?? (previous == null ? void 0 : previous.abstract) ?? false,
+      allowDirectUse: options.allowDirectUse ?? (previous == null ? void 0 : previous.allowDirectUse) ?? true,
+      suggestedUses: (0, import_utils.normalizeStringArray)(options.suggestedUses || (previous == null ? void 0 : previous.suggestedUses))
+    });
+    this.invalidateDerivedCaches();
+  }
+  registerModelContribution(contribution) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const use = String((contribution == null ? void 0 : contribution.use) || "").trim();
+    if (!use) return;
+    const previous = this.modelSchemas.get(use);
+    const hasSchemaContribution = !!contribution.stepParamsSchema || !!contribution.flowRegistrySchema || !!contribution.flowRegistrySchemaPatch || !!contribution.subModelSlots;
+    const docs = (0, import_utils.normalizeSchemaDocs)({
+      ...previous == null ? void 0 : previous.docs,
+      ...contribution.docs,
+      examples: contribution.examples || ((_a = contribution.docs) == null ? void 0 : _a.examples) || ((_b = previous == null ? void 0 : previous.docs) == null ? void 0 : _b.examples),
+      dynamicHints: [...((_c = previous == null ? void 0 : previous.docs) == null ? void 0 : _c.dynamicHints) || [], ...((_d = contribution.docs) == null ? void 0 : _d.dynamicHints) || []],
+      commonPatterns: ((_e = contribution.docs) == null ? void 0 : _e.commonPatterns) || ((_f = previous == null ? void 0 : previous.docs) == null ? void 0 : _f.commonPatterns),
+      antiPatterns: ((_g = contribution.docs) == null ? void 0 : _g.antiPatterns) || ((_h = previous == null ? void 0 : previous.docs) == null ? void 0 : _h.antiPatterns),
+      minimalExample: ((_i = contribution.docs) == null ? void 0 : _i.minimalExample) !== void 0 ? contribution.docs.minimalExample : (_j = previous == null ? void 0 : previous.docs) == null ? void 0 : _j.minimalExample
+    });
+    this.registerModel(use, {
+      title: contribution.title,
+      stepParamsSchema: contribution.stepParamsSchema ? import_lodash.default.cloneDeep(contribution.stepParamsSchema) : void 0,
+      flowRegistrySchema: contribution.flowRegistrySchema ? import_lodash.default.cloneDeep(contribution.flowRegistrySchema) : void 0,
+      subModelSlots: contribution.subModelSlots ? (0, import_modelPatches.normalizeSubModelSlots)(contribution.subModelSlots) : void 0,
+      flowRegistrySchemaPatch: contribution.flowRegistrySchemaPatch ? import_lodash.default.cloneDeep(contribution.flowRegistrySchemaPatch) : void 0,
+      examples: contribution.examples || docs.examples || [],
+      docs,
+      skeleton: contribution.skeleton,
+      dynamicHints: [...contribution.dynamicHints || [], ...docs.dynamicHints || []],
+      coverage: hasSchemaContribution ? {
+        status: (previous == null ? void 0 : previous.coverage.status) === "auto" ? "mixed" : "manual",
+        source: contribution.source || (previous == null ? void 0 : previous.coverage.source) || "official",
+        strict: contribution.strict ?? (previous == null ? void 0 : previous.coverage.strict)
+      } : (previous == null ? void 0 : previous.coverage) || {
+        status: "unresolved",
+        source: contribution.source || "official",
+        strict: contribution.strict
+      },
+      exposure: contribution.exposure,
+      abstract: contribution.abstract,
+      allowDirectUse: contribution.allowDirectUse,
+      suggestedUses: contribution.suggestedUses
+    });
+  }
+  registerModelContributions(contributions) {
+    const values = Array.isArray(contributions) ? contributions : Object.values(contributions || {});
+    for (const contribution of values) {
+      this.registerModelContribution(contribution);
+    }
+  }
+  registerModelClass(use, modelClass) {
+    var _a, _b;
+    const meta = modelClass.meta || {};
+    const schemaMeta = meta.schema || {};
+    const inferredSlots = this.inferSubModelSlotsFromModelClass(use, modelClass);
+    const inferredHints = this.collectModelDynamicHints(use, modelClass, meta);
+    const hasManual = !!schemaMeta.stepParamsSchema || !!schemaMeta.flowRegistrySchema || !!schemaMeta.subModelSlots || !!schemaMeta.flowRegistrySchemaPatch;
+    const hasAuto = !!Object.keys(inferredSlots).length;
+    this.registerModel(use, {
+      modelClass,
+      title: (0, import_utils.toSchemaTitle)(meta.label, use),
+      stepParamsSchema: schemaMeta.stepParamsSchema,
+      flowRegistrySchema: schemaMeta.flowRegistrySchema,
+      subModelSlots: Object.keys(schemaMeta.subModelSlots || {}).length ? schemaMeta.subModelSlots : inferredSlots,
+      flowRegistrySchemaPatch: schemaMeta.flowRegistrySchemaPatch,
+      examples: schemaMeta.examples || ((_a = schemaMeta.docs) == null ? void 0 : _a.examples) || [],
+      docs: schemaMeta.docs,
+      skeleton: schemaMeta.skeleton,
+      dynamicHints: [...schemaMeta.dynamicHints || [], ...((_b = schemaMeta.docs) == null ? void 0 : _b.dynamicHints) || [], ...inferredHints],
+      coverage: {
+        status: hasManual && hasAuto ? "mixed" : hasManual ? "manual" : hasAuto ? "auto" : "unresolved",
+        source: schemaMeta.source || "official",
+        strict: schemaMeta.strict
+      },
+      exposure: schemaMeta.exposure,
+      abstract: schemaMeta.abstract,
+      allowDirectUse: schemaMeta.allowDirectUse,
+      suggestedUses: schemaMeta.suggestedUses
+    });
+  }
+  registerModels(models) {
+    for (const [use, modelClass] of Object.entries(models || {})) {
+      if (modelClass) {
+        this.registerModelClass(use, modelClass);
+      }
+    }
+  }
+  registerInventory(inventory, _source) {
+    if (!inventory) {
+      return;
+    }
+    for (const use of (0, import_utils.normalizeStringArray)(inventory.publicTreeRoots)) {
+      this.publicTreeRoots.add(use);
+    }
+    for (const item of inventory.slotUseExpansions || []) {
+      const parentUse = String((item == null ? void 0 : item.parentUse) || "").trim();
+      const slotKey = String((item == null ? void 0 : item.slotKey) || "").trim();
+      const uses = (0, import_utils.normalizeStringArray)(item == null ? void 0 : item.uses);
+      if (!parentUse || !slotKey || uses.length === 0) {
+        continue;
+      }
+      const key = this.createSlotUseExpansionKey(parentUse, slotKey);
+      this.slotUseExpansions.set(key, import_lodash.default.uniq([...this.slotUseExpansions.get(key) || [], ...uses]));
+    }
+    this.invalidateDerivedCaches();
+  }
+  resolveFieldBindingCandidates(context, options = {}) {
+    const contextChain = this.resolveFieldBindingContextChain(context);
+    const entries = contextChain.flatMap(
+      (contextName, contextIndex) => (this.fieldBindings.get(contextName) || []).map((binding, bindingIndex) => ({
+        binding,
+        contextIndex,
+        bindingIndex
+      }))
+    );
+    const candidates = entries.filter(({ binding }) => (0, import_fieldBinding.matchesFieldBinding)(binding, options)).filter(({ binding }) => this.hasQueryableModel(binding.use)).sort((a, b) => {
+      if (a.binding.isDefault !== b.binding.isDefault) {
+        return a.binding.isDefault ? -1 : 1;
+      }
+      const aOrder = typeof a.binding.order === "number" ? a.binding.order : Number.MAX_SAFE_INTEGER;
+      const bOrder = typeof b.binding.order === "number" ? b.binding.order : Number.MAX_SAFE_INTEGER;
+      if (aOrder !== bOrder) {
+        return aOrder - bOrder;
+      }
+      if (a.contextIndex !== b.contextIndex) {
+        return a.contextIndex - b.contextIndex;
+      }
+      return a.bindingIndex - b.bindingIndex;
+    }).map(({ binding }) => ({
+      use: binding.use,
+      defaultProps: binding.defaultProps === void 0 ? void 0 : import_lodash.default.cloneDeep(binding.defaultProps),
+      compatibility: (0, import_fieldBinding.buildFieldModelCompatibility)(binding)
+    }));
+    return import_lodash.default.uniqBy(candidates, (candidate) => `${candidate.use}:${(0, import_utils.stableStringify)(candidate.compatibility)}`);
+  }
+  getAction(name) {
+    return this.actionSchemas.get(name);
+  }
+  listActionNames() {
+    return Array.from(this.actionSchemas.keys()).sort();
+  }
+  getModel(use) {
+    return this.modelSchemas.get(use);
+  }
+  resolveFieldBindingContextChain(context, visited = /* @__PURE__ */ new Set()) {
+    var _a;
+    const name = String(context || "").trim();
+    if (!name || visited.has(name)) {
+      return [];
+    }
+    visited.add(name);
+    const chain = [name];
+    const inherits = ((_a = this.fieldBindingContexts.get(name)) == null ? void 0 : _a.inherits) || [];
+    for (const inheritedContext of inherits) {
+      for (const item of this.resolveFieldBindingContextChain(inheritedContext, visited)) {
+        if (!chain.includes(item)) {
+          chain.push(item);
+        }
+      }
+    }
+    return chain;
+  }
+  resolveModelSchemaRef(use, contextChain = []) {
+    const name = String(use || "").trim();
+    const cacheKey = `${name}::${(0, import_utils.stableStringify)(contextChain)}`;
+    const cached = this.resolvedModelCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const registered = this.modelSchemas.get(name);
+    const resolved = {
+      use: name,
+      title: (registered == null ? void 0 : registered.title) || name,
+      modelClass: registered == null ? void 0 : registered.modelClass,
+      stepParamsSchema: (registered == null ? void 0 : registered.stepParamsSchema) ? import_lodash.default.cloneDeep(registered.stepParamsSchema) : this.buildInferredStepParamsSchema(name),
+      flowRegistrySchema: (registered == null ? void 0 : registered.flowRegistrySchema) ? import_lodash.default.cloneDeep(registered.flowRegistrySchema) : this.buildInferredFlowRegistrySchema(name),
+      subModelSlots: (0, import_modelPatches.normalizeSubModelSlots)(registered == null ? void 0 : registered.subModelSlots),
+      flowRegistrySchemaPatch: (registered == null ? void 0 : registered.flowRegistrySchemaPatch) ? import_lodash.default.cloneDeep(registered.flowRegistrySchemaPatch) : void 0,
+      examples: import_lodash.default.cloneDeep((registered == null ? void 0 : registered.examples) || []),
+      docs: (0, import_utils.normalizeSchemaDocs)(registered == null ? void 0 : registered.docs),
+      skeleton: (registered == null ? void 0 : registered.skeleton) === void 0 ? void 0 : import_lodash.default.cloneDeep(registered.skeleton),
+      dynamicHints: (0, import_utils.normalizeSchemaHints)(registered == null ? void 0 : registered.dynamicHints),
+      coverage: (registered == null ? void 0 : registered.coverage) || { status: "unresolved", source: "third-party" },
+      exposure: (registered == null ? void 0 : registered.exposure) || "public",
+      abstract: (registered == null ? void 0 : registered.abstract) ?? false,
+      allowDirectUse: (registered == null ? void 0 : registered.allowDirectUse) ?? true,
+      suggestedUses: (0, import_utils.normalizeStringArray)(registered == null ? void 0 : registered.suggestedUses)
+    };
+    for (const contribution of this.collectContextPatches(name, contextChain)) {
+      (0, import_modelPatches.applyModelSchemaPatch)(resolved, contribution.patch, contribution.source, contribution.strict);
+    }
+    const frozen = (0, import_utils.deepFreezePlainGraph)(resolved);
+    this.resolvedModelCache.set(cacheKey, frozen);
+    return frozen;
+  }
+  resolveModelSchema(use, contextChain = []) {
+    return import_lodash.default.cloneDeep(this.resolveModelSchemaRef(use, contextChain));
+  }
+  isPublicModel(model) {
+    return ((model == null ? void 0 : model.exposure) || "public") === "public";
+  }
+  isQueryableModel(model) {
+    return !!model && model.abstract !== true;
+  }
+  getSuggestedUses(use) {
+    var _a;
+    const model = this.modelSchemas.get(String(use || "").trim());
+    if ((_a = model == null ? void 0 : model.suggestedUses) == null ? void 0 : _a.length) {
+      return (0, import_utils.normalizeStringArray)(model.suggestedUses);
+    }
+    return this.listModelUses({ directUseOnly: true }).filter((item) => item !== use).slice(0, 20);
+  }
+  hasQueryableModel(use) {
+    const model = this.modelSchemas.get(String(use || "").trim());
+    return this.isQueryableModel(model);
+  }
+  isDirectUseAllowed(use) {
+    const model = this.modelSchemas.get(String(use || "").trim());
+    return model ? this.isQueryableModel(model) && model.allowDirectUse !== false : true;
+  }
+  listPublicTreeRoots() {
+    return Array.from(this.publicTreeRoots).sort();
+  }
+  listModelUses(options = {}) {
+    const { publicOnly = false, directUseOnly = false, queryableOnly = false } = options;
+    return Array.from(this.modelSchemas.values()).filter((model) => !publicOnly || this.isPublicModel(model) && this.isQueryableModel(model)).filter((model) => !queryableOnly || this.isQueryableModel(model)).filter((model) => !directUseOnly || this.isQueryableModel(model) && model.allowDirectUse !== false).map((model) => model.use).sort();
+  }
+  getSchemaBundle(uses) {
+    return {
+      items: (Array.isArray(uses) && uses.length > 0 ? uses.filter((use) => this.hasQueryableModel(use)) : []).map(
+        (use) => this.buildBundleNode(use, [], /* @__PURE__ */ new Set())
+      )
+    };
+  }
+  getModelDocument(use, contextChain = []) {
+    return import_lodash.default.cloneDeep(this.getModelDocumentRef(use, contextChain));
+  }
+  getModelDocumentRef(use, contextChain = []) {
+    const cacheKey = this.createContextVisitKey(use, contextChain);
+    const cached = this.modelDocumentCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const document = this.buildModelDocument(use, contextChain, /* @__PURE__ */ new Set());
+    const frozen = (0, import_utils.deepFreezePlainGraph)(document);
+    this.modelDocumentCache.set(cacheKey, frozen);
+    return frozen;
+  }
+  getPublicModelDocument(use, options = {}) {
+    return import_lodash.default.cloneDeep(this.getPublicModelDocumentRef(use, options));
+  }
+  getPublicModelDocumentRef(use, options = {}) {
+    const detail = options.detail === "full" ? "full" : "compact";
+    const contextChain = options.contextChain || [];
+    const cacheKey = `${detail}::${this.createContextVisitKey(use, contextChain)}`;
+    const cached = this.publicModelDocumentCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const document = detail === "full" ? this.buildFullPublicModelDocument(use, contextChain) : this.buildCompactPublicModelDocument(use, contextChain);
+    const frozen = (0, import_utils.deepFreezePlainGraph)(document);
+    this.publicModelDocumentCache.set(cacheKey, frozen);
+    return frozen;
+  }
+  buildFullPublicModelDocument(use, contextChain) {
+    const document = this.getModelDocumentRef(use, contextChain);
+    return {
+      use: document.use,
+      title: document.title,
+      jsonSchema: document.jsonSchema,
+      dynamicHints: document.dynamicHints,
+      minimalExample: document.minimalExample,
+      commonPatterns: document.commonPatterns,
+      antiPatterns: document.antiPatterns,
+      hash: document.hash,
+      source: document.source
+    };
+  }
+  buildCompactPublicModelDocument(use, contextChain) {
+    var _a, _b, _c, _d;
+    const resolved = this.resolveModelSchemaRef(use, contextChain);
+    const jsonSchema = this.buildCompactModelSnapshotSchemaRef(use, contextChain);
+    const minimalExample = import_lodash.default.cloneDeep(
+      ((_a = resolved == null ? void 0 : resolved.docs) == null ? void 0 : _a.minimalExample) ?? ((_b = resolved == null ? void 0 : resolved.examples) == null ? void 0 : _b[0]) ?? (resolved == null ? void 0 : resolved.skeleton) ?? (0, import_utils.buildSkeletonFromSchema)(jsonSchema)
+    );
+    return {
+      use,
+      title: (resolved == null ? void 0 : resolved.title) || use,
+      jsonSchema,
+      dynamicHints: [...this.getModelLocalDynamicHintsRef(use, contextChain)],
+      minimalExample,
+      commonPatterns: import_lodash.default.cloneDeep(((_c = resolved == null ? void 0 : resolved.docs) == null ? void 0 : _c.commonPatterns) || []),
+      antiPatterns: import_lodash.default.cloneDeep(((_d = resolved == null ? void 0 : resolved.docs) == null ? void 0 : _d.antiPatterns) || []),
+      hash: this.getCompactModelSchemaHash(use, contextChain),
+      source: ((resolved == null ? void 0 : resolved.coverage) || { source: "third-party" }).source
+    };
+  }
+  getModelLocalDynamicHintsRef(use, contextChain = []) {
+    const cacheKey = this.createContextVisitKey(use, contextChain);
+    const cached = this.modelLocalDynamicHintsCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const hints = this.buildModelLocalDynamicHints(use, contextChain);
+    const frozen = (0, import_utils.deepFreezePlainGraph)(hints);
+    this.modelLocalDynamicHintsCache.set(cacheKey, frozen);
+    return frozen;
+  }
+  buildModelLocalDynamicHints(use, contextChain) {
+    const resolved = this.resolveModelSchemaRef(use, contextChain);
+    const baseCoverage = resolved.coverage || { status: "unresolved", source: "third-party" };
+    const flowDiagnostics = this.collectFlowSchemaDiagnostics(use);
+    const slotHints = Object.entries((resolved == null ? void 0 : resolved.subModelSlots) || {}).map(([slotKey, slot]) => {
+      const allowedUses = this.resolveSlotAllowedUses(use, slotKey, slot);
+      return (0, import_utils.createFlowHint)(
+        {
+          kind: slot.dynamic || slot.fieldBindingContext ? "dynamic-children" : "manual-schema-required",
+          path: `${use}.subModels.${slotKey}`,
+          message: slot.description || `${use}.subModels.${slotKey} accepts ${slot.type}${allowedUses.length ? `: ${allowedUses.join(", ")}` : ""}.`
+        },
+        {
+          slotRules: {
+            slotKey,
+            type: slot.type,
+            allowedUses
+          }
+        }
+      );
+    });
+    const coverage = this.buildDocumentCoverage(baseCoverage, flowDiagnostics.statuses);
+    return (0, import_utils.normalizeSchemaHints)([
+      ...(resolved == null ? void 0 : resolved.dynamicHints) || [],
+      ...slotHints,
+      ...flowDiagnostics.hints,
+      ...coverage.status === "unresolved" ? [
+        (0, import_utils.createFlowHint)(
+          {
+            kind: "unresolved-model",
+            path: use,
+            message: `${use} has no registered server-safe schema contribution yet.`
+          },
+          {
+            unresolvedReason: "missing-model-contribution",
+            recommendedFallback: { use }
+          }
+        )
+      ] : []
+    ]);
+  }
+  getModelSchemaHash(use, contextChain = []) {
+    const cacheKey = this.createContextVisitKey(use, contextChain);
+    const cached = this.modelSchemaHashCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const hash = (0, import_utils.hashString)((0, import_utils.stableStringify)(this.buildModelSnapshotSchemaRef(use, contextChain)));
+    this.modelSchemaHashCache.set(cacheKey, hash);
+    return hash;
+  }
+  getCompactModelSchemaHash(use, contextChain = []) {
+    const cacheKey = this.createContextVisitKey(use, contextChain);
+    const cached = this.compactModelSchemaHashCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const hash = (0, import_utils.hashString)((0, import_utils.stableStringify)(this.buildCompactModelSnapshotSchemaRef(use, contextChain)));
+    this.compactModelSchemaHashCache.set(cacheKey, hash);
+    return hash;
+  }
+  createSlotUseExpansionKey(parentUse, slotKey) {
+    return `${parentUse}::${slotKey}`;
+  }
+  getSlotUseExpansionUses(parentUse, slotKey) {
+    return this.slotUseExpansions.get(this.createSlotUseExpansionKey(parentUse, slotKey)) || [];
+  }
+  resolveSlotAllowedUses(parentUse, slotKey, slot) {
+    if (!slot) {
+      return [];
+    }
+    if (slot.fieldBindingContext) {
+      return import_lodash.default.uniq(this.resolveFieldBindingCandidates(slot.fieldBindingContext).map((candidate) => candidate.use));
+    }
+    return import_lodash.default.uniq([...(0, import_utils.collectAllowedUses)(slot), ...this.getSlotUseExpansionUses(parentUse, slotKey)]);
+  }
+  buildModelDocument(use, contextChain, visited) {
+    var _a, _b, _c, _d;
+    const resolved = this.resolveModelSchemaRef(use, contextChain);
+    const baseCoverage = resolved.coverage || { status: "unresolved", source: "third-party" };
+    const flowDiagnostics = this.collectFlowSchemaDiagnostics(use);
+    const coverage = this.buildDocumentCoverage(baseCoverage, flowDiagnostics.statuses);
+    const dynamicHints = (0, import_utils.normalizeSchemaHints)([
+      ...this.getModelLocalDynamicHintsRef(use, contextChain),
+      ...this.collectNestedDocumentHints(use, contextChain, visited)
+    ]);
+    const jsonSchema = this.buildModelSnapshotSchemaRef(use, contextChain);
+    const skeleton = import_lodash.default.cloneDeep((resolved == null ? void 0 : resolved.skeleton) ?? (0, import_utils.buildSkeletonFromSchema)(jsonSchema));
+    const minimalExample = import_lodash.default.cloneDeep(((_a = resolved == null ? void 0 : resolved.docs) == null ? void 0 : _a.minimalExample) ?? ((_b = resolved == null ? void 0 : resolved.examples) == null ? void 0 : _b[0]) ?? skeleton);
+    const hash = this.getModelSchemaHash(use, contextChain);
+    return {
+      use,
+      title: (resolved == null ? void 0 : resolved.title) || use,
+      jsonSchema,
+      coverage,
+      dynamicHints,
+      examples: (resolved == null ? void 0 : resolved.examples) || [],
+      minimalExample,
+      commonPatterns: import_lodash.default.cloneDeep(((_c = resolved == null ? void 0 : resolved.docs) == null ? void 0 : _c.commonPatterns) || []),
+      antiPatterns: import_lodash.default.cloneDeep(((_d = resolved == null ? void 0 : resolved.docs) == null ? void 0 : _d.antiPatterns) || []),
+      skeleton,
+      hash,
+      source: coverage.source
+    };
+  }
+  buildBundleNode(use, contextChain, visited, compatibility) {
+    const resolved = this.resolveModelSchemaRef(use, contextChain);
+    const visitKey = this.createContextVisitKey(use, contextChain);
+    const node = {
+      use,
+      title: (resolved == null ? void 0 : resolved.title) || use
+    };
+    if (compatibility) {
+      node.compatibility = import_lodash.default.cloneDeep(compatibility);
+    }
+    if (visited.has(visitKey) || this.isContextCycle(use, contextChain)) {
+      return node;
+    }
+    visited.add(visitKey);
+    try {
+      const subModelCatalog = this.buildBundleSubModelCatalog(use, resolved == null ? void 0 : resolved.subModelSlots, contextChain, visited);
+      if (subModelCatalog && Object.keys(subModelCatalog).length > 0) {
+        node.subModelCatalog = subModelCatalog;
+      }
+      return node;
+    } finally {
+      visited.delete(visitKey);
+    }
+  }
+  buildBundleSubModelCatalog(parentUse, slots, contextChain, visited) {
+    if (!slots || Object.keys(slots).length === 0) {
+      return void 0;
+    }
+    const entries = Object.entries(slots).map(([slotKey, slot]) => {
+      const edgeBase = {
+        parentUse,
+        slotKey
+      };
+      const fieldBindingCandidates = slot.fieldBindingContext ? this.resolveFieldBindingCandidates(slot.fieldBindingContext) : [];
+      const allowedUses = fieldBindingCandidates.length > 0 ? import_lodash.default.uniq(fieldBindingCandidates.map((item) => item.use)) : this.resolveSlotAllowedUses(parentUse, slotKey, slot);
+      const catalog = {
+        type: slot.type,
+        candidates: fieldBindingCandidates.length > 0 ? fieldBindingCandidates.map(
+          (candidate) => this.buildBundleNode(
+            candidate.use,
+            [
+              ...contextChain,
+              {
+                ...edgeBase,
+                childUse: candidate.use
+              }
+            ],
+            visited,
+            candidate.compatibility
+          )
+        ) : allowedUses.map(
+          (childUse) => this.buildBundleNode(
+            childUse,
+            [
+              ...contextChain,
+              {
+                ...edgeBase,
+                childUse
+              }
+            ],
+            visited
+          )
+        )
+      };
+      if (slot.required !== void 0) {
+        catalog.required = slot.required;
+      }
+      if (slot.type === "array" && typeof slot.minItems === "number") {
+        catalog.minItems = slot.minItems;
+      }
+      if (allowedUses.length === 0) {
+        catalog.open = true;
+      }
+      return [slotKey, catalog];
+    });
+    return entries.length ? Object.fromEntries(entries) : void 0;
+  }
+  createContextVisitKey(use, contextChain) {
+    return `${use}::${(0, import_utils.stableStringify)(contextChain)}`;
+  }
+  isContextCycle(use, contextChain) {
+    if (!contextChain.length) {
+      return false;
+    }
+    const ancestorUses = [contextChain[0].parentUse, ...contextChain.slice(0, -1).map((edge) => edge.childUse)];
+    return ancestorUses.includes(use);
+  }
+  buildModelSnapshotSchema(use, contextChain = []) {
+    return import_lodash.default.cloneDeep(this.buildModelSnapshotSchemaRef(use, contextChain));
+  }
+  buildCompactModelSnapshotSchema(use, contextChain = []) {
+    return import_lodash.default.cloneDeep(this.buildCompactModelSnapshotSchemaRef(use, contextChain));
+  }
+  buildModelSnapshotSchemaRef(use, contextChain = []) {
+    const cacheKey = this.createContextVisitKey(use, contextChain);
+    const cached = this.modelSnapshotSchemaCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const schema = this.buildModelSnapshotSchemaInternal(use, contextChain, /* @__PURE__ */ new Set());
+    const frozen = (0, import_utils.deepFreezePlainGraph)(schema);
+    this.modelSnapshotSchemaCache.set(cacheKey, frozen);
+    return frozen;
+  }
+  buildCompactModelSnapshotSchemaRef(use, contextChain = []) {
+    const cacheKey = this.createContextVisitKey(use, contextChain);
+    const cached = this.compactModelSnapshotSchemaCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const schema = this.buildCompactModelSnapshotSchemaInternal(use, contextChain);
+    const frozen = (0, import_utils.deepFreezePlainGraph)(schema);
+    this.compactModelSnapshotSchemaCache.set(cacheKey, frozen);
+    return frozen;
+  }
+  buildCompactModelSnapshotSchemaInternal(use, contextChain) {
+    const resolved = this.resolveModelSchemaRef(use, contextChain);
+    const subModelsSchema = this.buildCompactSubModelsSchemaFromSlots(use, resolved == null ? void 0 : resolved.subModelSlots, contextChain);
+    return this.buildSnapshotShellSchema(use, resolved, subModelsSchema);
+  }
+  buildModelSnapshotSchemaInternal(use, contextChain, visited) {
+    const resolved = this.resolveModelSchemaRef(use, contextChain);
+    const visitKey = this.createContextVisitKey(use, contextChain);
+    if (visited.has(visitKey) || this.isContextCycle(use, contextChain)) {
+      return this.buildTruncatedSnapshotSchema(use, resolved);
+    }
+    visited.add(visitKey);
+    try {
+      return this.buildSnapshotSchemaFromResolved(use, resolved, contextChain, visited);
+    } finally {
+      visited.delete(visitKey);
+    }
+  }
+  buildSnapshotSchemaFromResolved(use, resolved, contextChain, visited) {
+    const subModelsSchema = this.buildSubModelsSchemaFromSlots(
+      use || "",
+      resolved == null ? void 0 : resolved.subModelSlots,
+      contextChain,
+      visited
+    );
+    return this.buildSnapshotShellSchema(use, resolved, subModelsSchema);
+  }
+  buildSnapshotShellSchema(use, resolved, subModelsSchema) {
+    const flowRegistrySchema = (resolved == null ? void 0 : resolved.flowRegistrySchema) || { type: "object", additionalProperties: true };
+    const stepParamsSchema = (resolved == null ? void 0 : resolved.stepParamsSchema) || { type: "object", additionalProperties: true };
+    return {
+      $schema: import_utils.JSON_SCHEMA_DRAFT_07,
+      type: "object",
+      properties: {
+        uid: { type: "string" },
+        use: use ? { const: use } : { type: "string" },
+        async: { type: "boolean" },
+        parentId: { type: "string" },
+        subKey: { type: "string" },
+        subType: { type: "string", enum: ["object", "array"] },
+        sortIndex: { type: "number" },
+        stepParams: stepParamsSchema,
+        flowRegistry: (0, import_utils.mergeSchemas)(flowRegistrySchema, resolved == null ? void 0 : resolved.flowRegistrySchemaPatch) || {
+          type: "object",
+          additionalProperties: true
+        },
+        subModels: subModelsSchema
+      },
+      required: ["uid", "use"],
+      additionalProperties: true
+    };
+  }
+  buildTruncatedSnapshotSchema(use, resolved) {
+    return this.buildSnapshotShellSchema(use, resolved, {
+      type: "object",
+      additionalProperties: true
+    });
+  }
+  buildStaticFlowRegistrySchema(use, contextChain = []) {
+    const resolved = this.resolveModelSchemaRef(use, contextChain);
+    const schema = (0, import_utils.mergeSchemas)(resolved == null ? void 0 : resolved.flowRegistrySchema, resolved == null ? void 0 : resolved.flowRegistrySchemaPatch);
+    if (schema) {
+      return import_lodash.default.cloneDeep(schema);
+    }
+    return { type: "object", additionalProperties: true };
+  }
+  buildStaticStepParamsSchema(use, contextChain = []) {
+    const resolved = this.resolveModelSchemaRef(use, contextChain);
+    if (resolved == null ? void 0 : resolved.stepParamsSchema) {
+      return import_lodash.default.cloneDeep(resolved.stepParamsSchema);
+    }
+    return { type: "object", additionalProperties: true };
+  }
+  buildSubModelsSchema(use, contextChain = []) {
+    const resolved = this.resolveModelSchemaRef(use, contextChain);
+    return this.buildSubModelsSchemaFromSlots(use, resolved == null ? void 0 : resolved.subModelSlots, contextChain, /* @__PURE__ */ new Set());
+  }
+  buildCompactSubModelsSchemaFromSlots(parentUse, slots, contextChain = []) {
+    if (!slots || Object.keys(slots).length === 0) {
+      return { type: "object", additionalProperties: true };
+    }
+    const properties = {};
+    const required = [];
+    for (const [slotKey, slot] of Object.entries(slots)) {
+      const itemSchema = this.buildCompactSlotTargetSchema(parentUse, slotKey, slot, contextChain);
+      properties[slotKey] = slot.type === "array" ? {
+        type: "array",
+        ...typeof slot.minItems === "number" ? { minItems: slot.minItems } : {},
+        items: itemSchema
+      } : itemSchema;
+      if (slot.required) {
+        required.push(slotKey);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length ? { required } : {},
+      additionalProperties: true
+    };
+  }
+  buildSubModelsSchemaFromSlots(parentUse, slots, contextChain = [], visited) {
+    if (!slots || Object.keys(slots).length === 0) {
+      return { type: "object", additionalProperties: true };
+    }
+    const properties = {};
+    const required = [];
+    for (const [slotKey, slot] of Object.entries(slots)) {
+      const itemSchema = this.buildSlotTargetSchema(parentUse, slotKey, slot, contextChain, visited);
+      properties[slotKey] = slot.type === "array" ? {
+        type: "array",
+        ...typeof slot.minItems === "number" ? { minItems: slot.minItems } : {},
+        items: itemSchema
+      } : itemSchema;
+      if (slot.required) {
+        required.push(slotKey);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length ? { required } : {},
+      additionalProperties: true
+    };
+  }
+  buildInferredFlowRegistrySchema(use) {
+    var _a, _b;
+    const registered = this.modelSchemas.get(use);
+    const modelClass = registered == null ? void 0 : registered.modelClass;
+    const flowsMap = (_b = (_a = modelClass == null ? void 0 : modelClass.globalFlowRegistry) == null ? void 0 : _a.getFlows) == null ? void 0 : _b.call(_a);
+    if (!(flowsMap == null ? void 0 : flowsMap.size)) {
+      return void 0;
+    }
+    const properties = {};
+    for (const [flowKey, flowDef] of flowsMap.entries()) {
+      const stepProperties = {};
+      const steps = (flowDef == null ? void 0 : flowDef.steps) || {};
+      for (const [stepKey, stepDef] of Object.entries(steps)) {
+        stepProperties[stepKey] = this.buildStepDefinitionSchema(stepDef);
+      }
+      properties[flowKey] = {
+        type: "object",
+        properties: {
+          key: { type: "string" },
+          title: { type: "string" },
+          manual: { type: "boolean" },
+          sort: { type: "number" },
+          on: this.buildFlowOnSchema(),
+          steps: {
+            type: "object",
+            properties: stepProperties,
+            additionalProperties: false
+          }
+        },
+        additionalProperties: true
+      };
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: true
+    };
+  }
+  buildInferredStepParamsSchema(use) {
+    var _a, _b;
+    const registered = this.modelSchemas.get(use);
+    const modelClass = registered == null ? void 0 : registered.modelClass;
+    const flowsMap = (_b = (_a = modelClass == null ? void 0 : modelClass.globalFlowRegistry) == null ? void 0 : _a.getFlows) == null ? void 0 : _b.call(_a);
+    if (!(flowsMap == null ? void 0 : flowsMap.size)) {
+      return void 0;
+    }
+    const properties = {};
+    for (const [flowKey, flowDef] of flowsMap.entries()) {
+      const stepProperties = {};
+      const steps = (flowDef == null ? void 0 : flowDef.steps) || {};
+      for (const [stepKey, stepDef] of Object.entries(steps)) {
+        const resolved = this.resolveStepParamsSchema(stepDef, `${use}.${flowKey}.${stepKey}`);
+        stepProperties[stepKey] = resolved.schema || { type: "object", additionalProperties: true };
+      }
+      properties[flowKey] = {
+        type: "object",
+        properties: stepProperties,
+        additionalProperties: false
+      };
+    }
+    return {
+      type: "object",
+      properties,
+      additionalProperties: true
+    };
+  }
+  buildFlowOnSchema() {
+    return {
+      anyOf: [
+        { type: "string" },
+        {
+          type: "object",
+          properties: {
+            eventName: { type: "string" },
+            defaultParams: { type: "object", additionalProperties: true },
+            phase: {
+              type: "string",
+              enum: ["beforeAllFlows", "afterAllFlows", "beforeFlow", "afterFlow", "beforeStep", "afterStep"]
+            },
+            flowKey: { type: "string" },
+            stepKey: { type: "string" }
+          },
+          required: ["eventName"],
+          additionalProperties: true
+        }
+      ]
+    };
+  }
+  buildStepDefinitionSchema(step) {
+    return {
+      type: "object",
+      properties: {
+        key: { type: "string" },
+        flowKey: { type: "string" },
+        title: { type: "string" },
+        use: { type: "string" },
+        sort: { type: "number" },
+        preset: { type: "boolean" },
+        isAwait: { type: "boolean" },
+        manual: { type: "boolean" },
+        on: this.buildFlowOnSchema(),
+        defaultParams: { type: ["object", "array", "string", "number", "boolean", "null"] },
+        paramsSchemaOverride: { type: "object", additionalProperties: true }
+      },
+      additionalProperties: true
+    };
+  }
+  resolveStepParamsSchema(step, path) {
+    var _a, _b, _c, _d;
+    if (step.paramsSchemaOverride) {
+      return {
+        schema: import_lodash.default.cloneDeep(step.paramsSchemaOverride),
+        hints: (0, import_utils.normalizeSchemaHints)((_a = step.schemaDocs) == null ? void 0 : _a.dynamicHints),
+        coverage: "manual"
+      };
+    }
+    if (step.use) {
+      const action = this.getAction(step.use);
+      if (action == null ? void 0 : action.schema) {
+        return {
+          schema: import_lodash.default.cloneDeep(action.schema),
+          hints: (0, import_utils.normalizeSchemaHints)([...action.dynamicHints || [], ...((_b = step.schemaDocs) == null ? void 0 : _b.dynamicHints) || []]),
+          coverage: action.coverage.status === "auto" || action.coverage.status === "manual" ? action.coverage.status : action.coverage.status === "unresolved" ? "unresolved" : "mixed"
+        };
+      }
+      return {
+        schema: { type: "object", additionalProperties: true },
+        hints: [
+          (0, import_utils.createFlowHint)(
+            {
+              kind: "unresolved-action",
+              path,
+              message: `${path} references unresolved action "${step.use}".`
+            },
+            {
+              unresolvedReason: "missing-action-contribution",
+              recommendedFallback: { use: step.use, params: {} }
+            }
+          ),
+          ...((_c = step.schemaDocs) == null ? void 0 : _c.dynamicHints) || []
+        ],
+        coverage: "unresolved"
+      };
+    }
+    const inferred = (0, import_schemaInference.inferParamsSchemaFromUiSchema)(path, step.uiSchema, path);
+    return {
+      schema: (0, import_utils.mergeSchemas)(inferred.schema, step.paramsSchemaPatch),
+      hints: (0, import_utils.normalizeSchemaHints)([...inferred.hints || [], ...((_d = step.schemaDocs) == null ? void 0 : _d.dynamicHints) || []]),
+      coverage: step.paramsSchemaPatch ? "mixed" : inferred.coverage
+    };
+  }
+  buildSlotTargetSchema(parentUse, slotKey, slot, contextChain, visited) {
+    var _a, _b;
+    if (slot.fieldBindingContext) {
+      const candidateUses = import_lodash.default.uniq(
+        this.resolveFieldBindingCandidates(slot.fieldBindingContext).map((item) => item.use)
+      );
+      if (candidateUses.length > 0) {
+        const candidateSchemas = candidateUses.map(
+          (use) => this.buildModelSnapshotSchemaInternal(
+            use,
+            [
+              ...contextChain,
+              {
+                parentUse,
+                slotKey,
+                childUse: use
+              }
+            ],
+            visited
+          )
+        );
+        if (slot.schema) {
+          return {
+            anyOf: [...candidateSchemas, import_lodash.default.cloneDeep(slot.schema)]
+          };
+        }
+        return candidateSchemas.length === 1 ? candidateSchemas[0] : { oneOf: candidateSchemas };
+      }
+    }
+    const allowedUses = this.resolveSlotAllowedUses(parentUse, slotKey, slot);
+    if (allowedUses.length > 0) {
+      const knownSchemas = allowedUses.map(
+        (use) => this.buildModelSnapshotSchemaInternal(
+          use,
+          [
+            ...contextChain,
+            {
+              parentUse,
+              slotKey,
+              childUse: use
+            }
+          ],
+          visited
+        )
+      );
+      if (slot.schema) {
+        return {
+          anyOf: [...knownSchemas, import_lodash.default.cloneDeep(slot.schema)]
+        };
+      }
+      if (knownSchemas.length === 1) {
+        return knownSchemas[0];
+      }
+      return {
+        oneOf: knownSchemas
+      };
+    }
+    if (slot.childSchemaPatch || ((_a = slot.descendantSchemaPatches) == null ? void 0 : _a.length)) {
+      return this.buildAnonymousSlotSnapshotSchema(parentUse, slotKey, slot, contextChain, visited);
+    }
+    if (slot.schema && !slot.childSchemaPatch && !((_b = slot.descendantSchemaPatches) == null ? void 0 : _b.length)) {
+      return import_lodash.default.cloneDeep(slot.schema);
+    }
+    return { type: "object", additionalProperties: true };
+  }
+  buildCompactSlotTargetSchema(parentUse, slotKey, slot, contextChain) {
+    var _a, _b;
+    if (slot.fieldBindingContext) {
+      const candidateUses = import_lodash.default.uniq(
+        this.resolveFieldBindingCandidates(slot.fieldBindingContext).map((item) => item.use)
+      );
+      if (candidateUses.length > 0) {
+        const candidateSchemas = candidateUses.map(
+          (use) => this.buildCompactSlotCandidateSchema(use, [
+            ...contextChain,
+            {
+              parentUse,
+              slotKey,
+              childUse: use
+            }
+          ])
+        );
+        if (slot.schema) {
+          return {
+            anyOf: [...candidateSchemas, import_lodash.default.cloneDeep(slot.schema)]
+          };
+        }
+        return candidateSchemas.length === 1 ? candidateSchemas[0] : { oneOf: candidateSchemas };
+      }
+    }
+    const allowedUses = this.resolveSlotAllowedUses(parentUse, slotKey, slot);
+    if (allowedUses.length > 0) {
+      const knownSchemas = allowedUses.map(
+        (use) => this.buildCompactSlotCandidateSchema(use, [
+          ...contextChain,
+          {
+            parentUse,
+            slotKey,
+            childUse: use
+          }
+        ])
+      );
+      if (slot.schema) {
+        return {
+          anyOf: [...knownSchemas, import_lodash.default.cloneDeep(slot.schema)]
+        };
+      }
+      return knownSchemas.length === 1 ? knownSchemas[0] : { oneOf: knownSchemas };
+    }
+    if (slot.childSchemaPatch || ((_a = slot.descendantSchemaPatches) == null ? void 0 : _a.length)) {
+      return this.buildCompactAnonymousSlotSnapshotSchema(parentUse, slotKey, slot);
+    }
+    if (slot.schema && !slot.childSchemaPatch && !((_b = slot.descendantSchemaPatches) == null ? void 0 : _b.length)) {
+      return import_lodash.default.cloneDeep(slot.schema);
+    }
+    return { type: "object", additionalProperties: true };
+  }
+  buildCompactSlotCandidateSchema(use, contextChain) {
+    const resolved = this.resolveModelSchemaRef(use, contextChain);
+    return this.buildTruncatedSnapshotSchema(use, resolved);
+  }
+  buildCompactAnonymousSlotSnapshotSchema(parentUse, slotKey, slot) {
+    const anonymousResolved = this.createAnonymousResolvedSchema(parentUse, slotKey, slot);
+    return this.buildTruncatedSnapshotSchema(void 0, anonymousResolved);
+  }
+  buildAnonymousSlotSnapshotSchema(parentUse, slotKey, slot, contextChain, visited) {
+    const anonymousResolved = this.createAnonymousResolvedSchema(parentUse, slotKey, slot);
+    return this.buildSnapshotSchemaFromResolved(
+      "",
+      anonymousResolved,
+      [
+        ...contextChain,
+        {
+          parentUse,
+          slotKey,
+          childUse: ""
+        }
+      ],
+      visited
+    );
+  }
+  createAnonymousResolvedSchema(parentUse, slotKey, slot) {
+    const anonymousResolved = {
+      use: "",
+      title: slot.description || `${parentUse || "AnonymousModel"}.${slotKey}`,
+      examples: [],
+      docs: (0, import_utils.normalizeSchemaDocs)(),
+      dynamicHints: [],
+      coverage: {
+        status: "unresolved",
+        source: "third-party"
+      },
+      exposure: "internal",
+      abstract: false,
+      allowDirectUse: true,
+      suggestedUses: []
+    };
+    const directPatch = (0, import_modelPatches.resolveChildSchemaPatch)(slot, "");
+    if (directPatch) {
+      (0, import_modelPatches.applyModelSchemaPatch)(anonymousResolved, directPatch, "third-party");
+    }
+    return anonymousResolved;
+  }
+  collectNestedDocumentHints(use, contextChain, visited) {
+    const visitKey = this.createContextVisitKey(use, contextChain);
+    if (visited.has(visitKey) || this.isContextCycle(use, contextChain)) {
+      return [];
+    }
+    visited.add(visitKey);
+    try {
+      const resolved = this.resolveModelSchemaRef(use, contextChain);
+      const hints = [];
+      for (const [slotKey, slot] of Object.entries(resolved.subModelSlots || {})) {
+        const childUses = this.resolveSlotAllowedUses(use, slotKey, slot);
+        for (const childUse of childUses) {
+          const childContext = [
+            ...contextChain,
+            {
+              parentUse: use,
+              slotKey,
+              childUse
+            }
+          ];
+          const childDocument = this.buildModelDocument(childUse, childContext, visited);
+          const basePath = `${use}.subModels.${slotKey}`;
+          hints.push(...childDocument.dynamicHints.map((hint) => this.prefixNestedHint(hint, basePath, childUse)));
+        }
+      }
+      return (0, import_utils.normalizeSchemaHints)(hints);
+    } finally {
+      visited.delete(visitKey);
+    }
+  }
+  prefixNestedHint(hint, basePath, childUse) {
+    if (!hint.path) {
+      return {
+        ...hint,
+        path: basePath
+      };
+    }
+    if (hint.path === childUse) {
+      return {
+        ...hint,
+        path: basePath
+      };
+    }
+    if (hint.path.startsWith(`${childUse}.`)) {
+      return {
+        ...hint,
+        path: `${basePath}.${hint.path.slice(childUse.length + 1)}`
+      };
+    }
+    return {
+      ...hint,
+      path: `${basePath}.${hint.path}`
+    };
+  }
+  collectContextPatches(use, contextChain) {
+    var _a;
+    if (!contextChain.length) {
+      return [];
+    }
+    const contributions = [];
+    const targetEdgeIndex = contextChain.length - 1;
+    for (let index = 0; index < contextChain.length; index++) {
+      const edge = contextChain[index];
+      const parentContext = contextChain.slice(0, index);
+      const parentResolved = this.resolveModelSchemaRef(edge.parentUse, parentContext);
+      const slot = (_a = parentResolved.subModelSlots) == null ? void 0 : _a[edge.slotKey];
+      if (!slot) {
+        continue;
+      }
+      const remainingEdges = contextChain.slice(index + 1);
+      for (const patch of slot.descendantSchemaPatches || []) {
+        if ((0, import_modelPatches.matchesDescendantSchemaPatch)(patch, remainingEdges)) {
+          contributions.push({
+            patch: patch.patch,
+            source: parentResolved.coverage.source,
+            strict: parentResolved.coverage.strict
+          });
+        }
+      }
+      if (index === targetEdgeIndex) {
+        const directPatch = (0, import_modelPatches.resolveChildSchemaPatch)(slot, use);
+        if (directPatch) {
+          contributions.push({
+            patch: directPatch,
+            source: parentResolved.coverage.source,
+            strict: parentResolved.coverage.strict
+          });
+        }
+      }
+    }
+    return contributions;
+  }
+  collectModelDynamicHints(use, modelClass, meta) {
+    const hints = [];
+    if (typeof meta.children === "function") {
+      hints.push(
+        (0, import_utils.createFlowHint)(
+          {
+            kind: "dynamic-children",
+            path: `${use}.meta.children`,
+            message: `${use} uses function-based children and only static slot hints are available.`
+          },
+          {
+            unresolvedReason: "function-children"
+          }
+        )
+      );
+    }
+    if (typeof meta.createModelOptions === "function") {
+      hints.push(
+        (0, import_utils.createFlowHint)(
+          {
+            kind: "dynamic-children",
+            path: `${use}.meta.createModelOptions`,
+            message: `${use} uses function-based createModelOptions and may need manual sub-model slot schema.`
+          },
+          {
+            unresolvedReason: "function-create-model-options"
+          }
+        )
+      );
+    }
+    if (typeof modelClass.defineChildren === "function") {
+      hints.push(
+        (0, import_utils.createFlowHint)(
+          {
+            kind: "dynamic-children",
+            path: `${use}.defineChildren`,
+            message: `${use} defines dynamic children. Schema generation only keeps static baseline.`
+          },
+          {
+            unresolvedReason: "runtime-define-children"
+          }
+        )
+      );
+    }
+    return hints;
+  }
+  collectFlowSchemaDiagnostics(use) {
+    var _a, _b, _c;
+    const registered = this.modelSchemas.get(use);
+    const modelClass = registered == null ? void 0 : registered.modelClass;
+    const flowsMap = (_b = (_a = modelClass == null ? void 0 : modelClass.globalFlowRegistry) == null ? void 0 : _a.getFlows) == null ? void 0 : _b.call(_a);
+    if (!(flowsMap == null ? void 0 : flowsMap.size)) {
+      return {
+        hints: [],
+        statuses: []
+      };
+    }
+    const hints = [];
+    const statuses = [];
+    for (const [flowKey, flowDef] of flowsMap.entries()) {
+      for (const [stepKey, stepDef] of Object.entries((flowDef == null ? void 0 : flowDef.steps) || {})) {
+        const resolved = this.resolveStepParamsSchema(stepDef, `${use}.${flowKey}.${stepKey}`);
+        if ((_c = resolved.hints) == null ? void 0 : _c.length) {
+          hints.push(...resolved.hints);
+        }
+        statuses.push(resolved.coverage);
+      }
+    }
+    return {
+      hints: (0, import_utils.normalizeSchemaHints)(hints),
+      statuses
+    };
+  }
+  buildDocumentCoverage(base, stepStatuses) {
+    const statuses = new Set([base.status, ...stepStatuses].filter(Boolean));
+    let status = base.status;
+    if (statuses.size > 1) {
+      statuses.delete("unresolved");
+      if (statuses.size === 0) {
+        status = "unresolved";
+      } else {
+        status = "mixed";
+      }
+    } else if (statuses.size === 1) {
+      status = Array.from(statuses)[0] || "unresolved";
+    }
+    return {
+      ...base,
+      status
+    };
+  }
+  inferSubModelSlotsFromModelClass(use, modelClass) {
+    const meta = (modelClass.meta || {}).schema;
+    if (meta == null ? void 0 : meta.subModelSlots) {
+      return import_lodash.default.cloneDeep(meta.subModelSlots);
+    }
+    const createModelOptions = (modelClass.meta || {}).createModelOptions;
+    if (!import_lodash.default.isPlainObject(createModelOptions) || !import_lodash.default.isPlainObject(createModelOptions.subModels)) {
+      return {};
+    }
+    const slots = {};
+    for (const [slotKey, slotValue] of Object.entries(createModelOptions.subModels || {})) {
+      if (Array.isArray(slotValue)) {
+        const first = slotValue[0];
+        slots[slotKey] = {
+          type: "array",
+          ...typeof (first == null ? void 0 : first.use) === "string" ? { use: first.use } : {}
+        };
+      } else if (import_lodash.default.isPlainObject(slotValue)) {
+        slots[slotKey] = {
+          type: "object",
+          ...slotValue.use ? { use: slotValue.use } : {}
+        };
+      } else {
+        slots[slotKey] = {
+          type: "object"
+        };
+      }
+    }
+    return slots;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowSchemaRegistry
+});