@nocobase/plugin-flow-engine 2.1.0-alpha.1 → 2.1.0-alpha.11

package/dist/server/flow-schema-service.js

@@ -0,0 +1,963 @@
+/**
+ * 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 flow_schema_service_exports = {};
+__export(flow_schema_service_exports, {
+  FlowSchemaService: () => FlowSchemaService
+});
+module.exports = __toCommonJS(flow_schema_service_exports);
+var import_ajv = __toESM(require("ajv"));
+var import_utils = require("@nocobase/utils");
+var import_server = require("@nocobase/flow-engine/server");
+const MODEL_SHELL_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  required: ["uid", "use"],
+  properties: {
+    uid: { type: "string" },
+    use: { type: "string" },
+    async: { type: "boolean" },
+    parentId: { type: "string" },
+    subKey: { type: "string" },
+    subType: { type: "string", enum: ["object", "array"] },
+    sortIndex: { type: "number" },
+    stepParams: { type: "object" },
+    flowRegistry: { type: "object" },
+    subModels: { type: "object" }
+  },
+  additionalProperties: true
+};
+const MODEL_SHELL_OBJECT_LOCATOR_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  required: ["parentId", "subKey", "subType", "use"],
+  properties: {
+    uid: { type: "string" },
+    use: { type: "string" },
+    async: { type: "boolean" },
+    parentId: { type: "string" },
+    subKey: { type: "string" },
+    subType: { const: "object" },
+    sortIndex: { type: "number" },
+    stepParams: { type: "object" },
+    flowRegistry: { type: "object" },
+    subModels: { type: "object" }
+  },
+  additionalProperties: true
+};
+const MODEL_SHELL_CREATE_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  required: ["use"],
+  properties: {
+    uid: { type: "string" },
+    use: { type: "string" },
+    async: { type: "boolean" },
+    parentId: { type: "string" },
+    subKey: { type: "string" },
+    subType: { type: "string", enum: ["object", "array"] },
+    sortIndex: { type: "number" },
+    stepParams: { type: "object" },
+    flowRegistry: { type: "object" },
+    subModels: { type: "object" }
+  },
+  additionalProperties: true
+};
+const FLOW_EVENT_PHASES = ["beforeAllFlows", "afterAllFlows", "beforeFlow", "afterFlow", "beforeStep", "afterStep"];
+const FLOW_DEFINITION_SHELL_SCHEMA = {
+  type: "object",
+  properties: {
+    key: { type: "string" },
+    title: { type: "string" },
+    manual: { type: "boolean" },
+    sort: { type: "number" },
+    steps: { type: "object" }
+  },
+  required: ["steps"],
+  additionalProperties: true
+};
+function stableStringify(input) {
+  if (Array.isArray(input)) {
+    return `[${input.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  if (input && typeof input === "object") {
+    const entries = Object.entries(input).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${JSON.stringify(key)}:${stableStringify(value)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(input) ?? "null";
+}
+function slotAllowsUnknownUses(slot) {
+  return !!(slot == null ? void 0 : slot.schema);
+}
+function readModelUse(value) {
+  return String(value && typeof value === "object" ? value.use || "" : "").trim();
+}
+function readFieldBindingUse(value) {
+  var _a, _b;
+  return String(((_b = (_a = value == null ? void 0 : value.stepParams) == null ? void 0 : _a.fieldBinding) == null ? void 0 : _b.use) || "").trim();
+}
+class FlowSchemaService {
+  registry = new import_server.FlowSchemaRegistry();
+  ajv = new import_ajv.default({
+    allErrors: true
+  });
+  validatorCache = /* @__PURE__ */ new Map();
+  app;
+  constructor() {
+    this.registry.registerModel("FlowModel", {
+      title: "FlowModel",
+      coverage: {
+        status: "manual",
+        source: "official",
+        strict: false
+      },
+      exposure: "internal",
+      abstract: true,
+      allowDirectUse: false
+    });
+  }
+  registerModels(models) {
+    this.registry.registerModels(models);
+  }
+  registerActions(actions) {
+    this.registry.registerActions(actions);
+  }
+  registerActionContributions(contributions) {
+    this.registry.registerActionContributions(contributions);
+  }
+  registerModelContributions(contributions) {
+    this.registry.registerModelContributions(contributions);
+  }
+  registerInventory(inventory, source) {
+    this.registry.registerInventory(inventory, source);
+  }
+  registerFieldBindingContexts(contributions) {
+    this.registry.registerFieldBindingContexts(contributions);
+  }
+  registerFieldBindings(contributions, source) {
+    this.registry.registerFieldBindings(contributions, source);
+  }
+  setApp(app) {
+    this.app = app;
+  }
+  readDocumentFromRegistry(use, clone = true) {
+    const registry = this.registry;
+    if (!clone && typeof registry.getModelDocumentRef === "function") {
+      return registry.getModelDocumentRef(use);
+    }
+    return this.registry.getModelDocument(use);
+  }
+  getDocument(use, options = {}) {
+    if (!this.registry.hasQueryableModel(use)) {
+      return void 0;
+    }
+    return this.readDocumentFromRegistry(use, options.clone !== false);
+  }
+  getDocuments(uses, options = {}) {
+    if (!Array.isArray(uses) || uses.length === 0) {
+      return [];
+    }
+    return uses.filter((use) => this.registry.hasQueryableModel(use)).map((use) => this.readDocumentFromRegistry(use, options.clone !== false));
+  }
+  projectDocument(document) {
+    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
+    };
+  }
+  getPublicDocument(use, options = {}) {
+    if (!this.registry.hasQueryableModel(use)) {
+      return void 0;
+    }
+    const detail = options.detail === "full" ? "full" : "compact";
+    const registry = this.registry;
+    if (!options.clone && typeof registry.getPublicModelDocumentRef === "function") {
+      return registry.getPublicModelDocumentRef(use, { detail });
+    }
+    if (typeof registry.getPublicModelDocument === "function") {
+      return registry.getPublicModelDocument(use, { detail });
+    }
+    const document = this.readDocumentFromRegistry(use, options.clone !== false);
+    return document ? this.projectDocument(document) : void 0;
+  }
+  getPublicDocuments(uses, options = {}) {
+    if (!Array.isArray(uses) || uses.length === 0) {
+      return [];
+    }
+    return uses.filter((use) => this.registry.hasQueryableModel(use)).map((use) => this.getPublicDocument(use, options)).filter(Boolean);
+  }
+  getBundle(uses) {
+    return this.registry.getSchemaBundle(uses);
+  }
+  collectRuntimeFieldBindingUses(slot, parentNode, slotKey) {
+    const parentUse = String((parentNode == null ? void 0 : parentNode.use) || "").trim();
+    const fieldBindingContext = String((slot == null ? void 0 : slot.fieldBindingContext) || "").trim();
+    if (!fieldBindingContext) {
+      return {
+        allowedUses: this.registry.resolveSlotAllowedUses(parentUse, String(slotKey || ""), slot)
+      };
+    }
+    const metadata = this.resolveFieldBindingMetadata(parentNode);
+    const candidates = this.registry.resolveFieldBindingCandidates(fieldBindingContext, metadata || {});
+    const allowedUses = candidates.map((candidate) => candidate.use);
+    return {
+      allowedUses: allowedUses.length > 0 ? allowedUses : this.registry.resolveSlotAllowedUses(parentUse, String(slotKey || ""), slot),
+      metadata
+    };
+  }
+  resolveFieldBindingMetadata(parentNode) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    const init = (_b = (_a = parentNode == null ? void 0 : parentNode.stepParams) == null ? void 0 : _a.fieldSettings) == null ? void 0 : _b.init;
+    const dataSourceKey = String((init == null ? void 0 : init.dataSourceKey) || "main").trim() || "main";
+    const collectionName = String((init == null ? void 0 : init.collectionName) || "").trim();
+    const fieldPath = String((init == null ? void 0 : init.fieldPath) || "").trim();
+    if (!collectionName || !fieldPath) {
+      return void 0;
+    }
+    const dataSource = ((_e = (_d = (_c = this.app) == null ? void 0 : _c.dataSourceManager) == null ? void 0 : _d.get) == null ? void 0 : _e.call(_d, dataSourceKey)) || ((_h = (_g = (_f = this.app) == null ? void 0 : _f.dataSourceManager) == null ? void 0 : _g.getDataSource) == null ? void 0 : _h.call(_g, dataSourceKey));
+    const database = ((_i = dataSource == null ? void 0 : dataSource.collectionManager) == null ? void 0 : _i.db) || (dataSourceKey === "main" ? (_j = this.app) == null ? void 0 : _j.db : void 0);
+    const field = (_k = database == null ? void 0 : database.getFieldByPath) == null ? void 0 : _k.call(database, `${collectionName}.${fieldPath}`);
+    if (!field) {
+      return void 0;
+    }
+    const targetCollection = field.targetCollection || (field.target ? (_l = database == null ? void 0 : database.getCollection) == null ? void 0 : _l.call(database, field.target) : void 0);
+    const association = typeof field.isAssociationField === "function" ? !!field.isAssociationField() : !!field.target || !!targetCollection;
+    return {
+      interface: typeof field.interface === "string" ? field.interface : void 0,
+      fieldType: typeof field.dataType === "string" ? field.dataType : typeof field.type === "string" ? field.type : void 0,
+      association,
+      targetCollectionTemplate: typeof (targetCollection == null ? void 0 : targetCollection.template) === "string" ? targetCollection.template : void 0
+    };
+  }
+  validateModelTree(input, options = {}) {
+    return this.validateNormalizedModelTree(
+      this.normalizeModelTree(input, [], {
+        allowRootObjectLocator: options.allowRootObjectLocator
+      }),
+      options
+    );
+  }
+  validateNormalizedModelTree(input, options = {}) {
+    const issues = [];
+    this.validateModelNode(input, "#", issues, options, []);
+    return issues;
+  }
+  normalizeModelTree(input, contextChain = [], options = {}, isRoot = true) {
+    if (!input || typeof input !== "object") {
+      return input;
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => this.normalizeModelTree(item, contextChain, options, false));
+    }
+    return this.normalizeModelNodeInput(input, contextChain, options, isRoot);
+  }
+  assignImplicitUids(input, options = {}, isRoot = true) {
+    if (!input || typeof input !== "object") {
+      return input;
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => this.assignImplicitUids(item, options, false));
+    }
+    const normalizedNode = { ...input };
+    const declaredUid = String((input == null ? void 0 : input.uid) || "").trim();
+    const isRootObjectLocator = isRoot && options.allowRootObjectLocator && !declaredUid && String((input == null ? void 0 : input.parentId) || "").trim() && String((input == null ? void 0 : input.subKey) || "").trim() && (input == null ? void 0 : input.subType) === "object";
+    if (!declaredUid && !isRootObjectLocator) {
+      normalizedNode.uid = (0, import_utils.uid)();
+    }
+    const subModels = input == null ? void 0 : input.subModels;
+    if (!subModels || typeof subModels !== "object" || Array.isArray(subModels)) {
+      return normalizedNode;
+    }
+    normalizedNode.subModels = Object.fromEntries(
+      Object.entries(subModels).map(([slotKey, slotValue]) => [
+        slotKey,
+        Array.isArray(slotValue) ? slotValue.map((item) => this.assignImplicitUids(item, options, false)) : this.assignImplicitUids(slotValue, options, false)
+      ])
+    );
+    return normalizedNode;
+  }
+  normalizeModelNodeInput(node, contextChain, options, isRoot) {
+    var _a;
+    if (!node || typeof node !== "object" || Array.isArray(node)) {
+      return node;
+    }
+    const normalizedNode = { ...node };
+    const declaredUid = String((node == null ? void 0 : node.uid) || "").trim();
+    const isRootObjectLocator = isRoot && options.allowRootObjectLocator && !declaredUid && String((node == null ? void 0 : node.parentId) || "").trim() && String((node == null ? void 0 : node.subKey) || "").trim() && (node == null ? void 0 : node.subType) === "object";
+    if (options.assignImplicitUids && !declaredUid && !isRootObjectLocator) {
+      normalizedNode.uid = (0, import_utils.uid)();
+    }
+    const declaredUse = readModelUse(node);
+    const bindingUse = readFieldBindingUse(node);
+    const effectiveUse = bindingUse || declaredUse;
+    const isFieldBindingTransition = !!bindingUse && bindingUse !== declaredUse;
+    if (effectiveUse && declaredUse !== effectiveUse) {
+      normalizedNode.use = effectiveUse;
+    }
+    const subModels = node == null ? void 0 : node.subModels;
+    if (!subModels || typeof subModels !== "object" || Array.isArray(subModels)) {
+      return normalizedNode;
+    }
+    const slots = effectiveUse ? ((_a = this.registry.resolveModelSchema(effectiveUse, contextChain)) == null ? void 0 : _a.subModelSlots) || {} : {};
+    const hasKnownSlots = Object.keys(slots).length > 0;
+    const normalizedSubModels = {};
+    for (const [slotKey, slotValue] of Object.entries(subModels)) {
+      const slotSchema = slots[slotKey];
+      if (isFieldBindingTransition && hasKnownSlots && !slotSchema) {
+        continue;
+      }
+      if (Array.isArray(slotValue)) {
+        normalizedSubModels[slotKey] = slotValue.map(
+          (item) => this.normalizeChildModelInput(effectiveUse, slotKey, item, contextChain, options)
+        );
+        continue;
+      }
+      normalizedSubModels[slotKey] = this.normalizeChildModelInput(
+        effectiveUse,
+        slotKey,
+        slotValue,
+        contextChain,
+        options
+      );
+    }
+    normalizedNode.subModels = normalizedSubModels;
+    return normalizedNode;
+  }
+  normalizeChildModelInput(parentUse, slotKey, value, contextChain, options) {
+    if (!value || typeof value !== "object") {
+      return value;
+    }
+    const childUse = readFieldBindingUse(value) || readModelUse(value);
+    const nextContext = childUse ? [
+      ...contextChain,
+      {
+        parentUse,
+        slotKey,
+        childUse
+      }
+    ] : contextChain;
+    return this.normalizeModelTree(value, nextContext, options, false);
+  }
+  validateModelNode(node, jsonPointer, issues, options = {}, contextChain = []) {
+    var _a;
+    const nodeUid = String((node == null ? void 0 : node.uid) || "").trim();
+    const isExistingNode = !!nodeUid && !!((_a = options.existingNodeUids) == null ? void 0 : _a.has(nodeUid));
+    const modelUse = String((node == null ? void 0 : node.use) || "").trim();
+    const resolved = this.registry.resolveModelSchema(modelUse, contextChain);
+    const schemaHash = this.registry.getModelSchemaHash(modelUse, contextChain);
+    const missingUid = !String((node == null ? void 0 : node.uid) || "").trim();
+    const strict = resolved.coverage.strict ?? false;
+    if (!isExistingNode) {
+      const shellSchema = jsonPointer === "#" && options.allowRootObjectLocator && missingUid ? MODEL_SHELL_OBJECT_LOCATOR_SCHEMA : options.allowRootObjectLocator && missingUid ? MODEL_SHELL_CREATE_SCHEMA : MODEL_SHELL_SCHEMA;
+      const shellOk = this.validateSchema(shellSchema, node);
+      if (!shellOk.valid) {
+        this.pushAjvIssues(shellOk.errors, issues, {
+          level: "error",
+          jsonPointer,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          section: "model",
+          schemaHash
+        });
+        return;
+      }
+      if (!this.registry.isDirectUseAllowed(modelUse)) {
+        issues.push({
+          level: "error",
+          jsonPointer: `${jsonPointer}/use`,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          section: "model",
+          keyword: "unsupported-model-use",
+          message: `Model use "${node == null ? void 0 : node.use}" is base/abstract and cannot be submitted directly.`,
+          suggestedUses: this.registry.getSuggestedUses(modelUse),
+          schemaHash
+        });
+        return;
+      }
+      if (!this.registry.getModel(node.use) && resolved.coverage.status === "unresolved") {
+        issues.push({
+          level: "warning",
+          jsonPointer,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          section: "model",
+          keyword: "unresolved-model",
+          message: `No schema registered for model use "${node == null ? void 0 : node.use}".`,
+          suggestedUses: this.registry.listModelUses({ directUseOnly: true }).slice(0, 20),
+          schemaHash
+        });
+      }
+      if (typeof (node == null ? void 0 : node.stepParams) !== "undefined") {
+        this.validateSchemaSection({
+          issues,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          jsonPointer: `${jsonPointer}/stepParams`,
+          schema: this.registry.buildStaticStepParamsSchema(modelUse, contextChain),
+          value: (node == null ? void 0 : node.stepParams) || {},
+          section: "stepParams",
+          strict,
+          schemaHash
+        });
+      }
+      if (typeof (node == null ? void 0 : node.flowRegistry) !== "undefined") {
+        this.validateSchemaSection({
+          issues,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          jsonPointer: `${jsonPointer}/flowRegistry`,
+          schema: this.registry.buildStaticFlowRegistrySchema(modelUse, contextChain),
+          value: (node == null ? void 0 : node.flowRegistry) || {},
+          section: "flowRegistry",
+          strict,
+          schemaHash
+        });
+      }
+      this.validateFlowRegistry(node, jsonPointer, issues, strict, schemaHash, contextChain);
+      this.validateStepParams(node, jsonPointer, issues, strict, schemaHash, contextChain);
+    }
+    this.validateSubModels(node, jsonPointer, issues, strict, schemaHash, options, contextChain);
+  }
+  validateFlowRegistry(node, jsonPointer, issues, strict, schemaHash, _contextChain = []) {
+    const flowRegistry = node == null ? void 0 : node.flowRegistry;
+    if (!flowRegistry) return;
+    if (typeof flowRegistry !== "object" || Array.isArray(flowRegistry)) {
+      issues.push({
+        level: "error",
+        jsonPointer: `${jsonPointer}/flowRegistry`,
+        modelUid: node == null ? void 0 : node.uid,
+        modelUse: node == null ? void 0 : node.use,
+        section: "flowRegistry",
+        keyword: "type",
+        message: "flowRegistry must be an object.",
+        expectedType: "object",
+        schemaHash
+      });
+      return;
+    }
+    for (const [flowKey, flowDef] of Object.entries(flowRegistry)) {
+      const flowPointer = `${jsonPointer}/flowRegistry/${this.escapeJsonPointer(flowKey)}`;
+      if (!flowDef || typeof flowDef !== "object" || Array.isArray(flowDef)) {
+        issues.push({
+          level: "error",
+          jsonPointer: flowPointer,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          section: "flowRegistry",
+          keyword: "type",
+          message: "flowRegistry item must be an object.",
+          expectedType: "object",
+          schemaHash
+        });
+        continue;
+      }
+      this.validateSchemaSection({
+        issues,
+        modelUid: node == null ? void 0 : node.uid,
+        modelUse: node == null ? void 0 : node.use,
+        jsonPointer: flowPointer,
+        schema: FLOW_DEFINITION_SHELL_SCHEMA,
+        value: flowDef,
+        section: "flowRegistry",
+        strict: true,
+        schemaHash
+      });
+      this.validateFlowOn(flowDef.on, `${flowPointer}/on`, node, issues, strict, schemaHash);
+      const steps = flowDef.steps;
+      if (!steps || typeof steps !== "object" || Array.isArray(steps)) {
+        issues.push({
+          level: "error",
+          jsonPointer: `${flowPointer}/steps`,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          section: "flowRegistry",
+          keyword: "type",
+          message: "flowRegistry.steps must be an object.",
+          expectedType: "object",
+          schemaHash
+        });
+        continue;
+      }
+      for (const [stepKey, stepDef] of Object.entries(steps)) {
+        const stepPointer = `${flowPointer}/steps/${this.escapeJsonPointer(stepKey)}`;
+        if (!stepDef || typeof stepDef !== "object" || Array.isArray(stepDef)) {
+          issues.push({
+            level: "error",
+            jsonPointer: stepPointer,
+            modelUid: node == null ? void 0 : node.uid,
+            modelUse: node == null ? void 0 : node.use,
+            section: "flowRegistry",
+            keyword: "type",
+            message: "step definition must be an object.",
+            expectedType: "object",
+            schemaHash
+          });
+          continue;
+        }
+        const stepSchema = this.registry.buildStepDefinitionSchema(stepDef);
+        this.validateSchemaSection({
+          issues,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          jsonPointer: stepPointer,
+          schema: stepSchema,
+          value: stepDef,
+          section: "flowRegistry",
+          strict: true,
+          schemaHash
+        });
+        if (stepDef.use && !this.registry.getAction(stepDef.use)) {
+          issues.push({
+            level: strict ? "error" : "warning",
+            jsonPointer: `${stepPointer}/use`,
+            modelUid: node == null ? void 0 : node.uid,
+            modelUse: node == null ? void 0 : node.use,
+            section: "flowRegistry",
+            keyword: "unresolved-action",
+            message: `step use "${stepDef.use}" has no registered params schema.`,
+            suggestedUses: this.registry.listActionNames().slice(0, 20),
+            schemaHash
+          });
+        }
+      }
+    }
+  }
+  validateStepParams(node, jsonPointer, issues, strict, schemaHash, contextChain = []) {
+    var _a, _b;
+    const stepParams = node == null ? void 0 : node.stepParams;
+    if (!stepParams) return;
+    if (typeof stepParams !== "object" || Array.isArray(stepParams)) {
+      issues.push({
+        level: "error",
+        jsonPointer: `${jsonPointer}/stepParams`,
+        modelUid: node == null ? void 0 : node.uid,
+        modelUse: node == null ? void 0 : node.use,
+        section: "stepParams",
+        keyword: "type",
+        message: "stepParams must be an object.",
+        expectedType: "object",
+        schemaHash
+      });
+      return;
+    }
+    const staticSchema = this.registry.buildStaticStepParamsSchema(node.use, contextChain);
+    const staticFlows = staticSchema.properties || {};
+    const staticFlowRegistrySchema = this.registry.buildStaticFlowRegistrySchema(node.use, contextChain);
+    const staticFlowRegistry = staticFlowRegistrySchema.properties || {};
+    const dynamicFlows = (node == null ? void 0 : node.flowRegistry) || {};
+    const shouldValidateAsFlowMap = Object.keys(staticFlowRegistry).length > 0 || Object.keys(dynamicFlows).length > 0;
+    if (!shouldValidateAsFlowMap) {
+      return;
+    }
+    for (const [flowKey, flowValue] of Object.entries(stepParams)) {
+      const flowPointer = `${jsonPointer}/stepParams/${this.escapeJsonPointer(flowKey)}`;
+      if (!flowValue || typeof flowValue !== "object" || Array.isArray(flowValue)) {
+        issues.push({
+          level: "error",
+          jsonPointer: flowPointer,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          section: "stepParams",
+          keyword: "type",
+          message: "stepParams flow item must be an object.",
+          expectedType: "object",
+          schemaHash
+        });
+        continue;
+      }
+      if (!staticFlows[flowKey] && !dynamicFlows[flowKey]) {
+        issues.push({
+          level: strict ? "error" : "warning",
+          jsonPointer: flowPointer,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          section: "stepParams",
+          keyword: "unknown-flow",
+          message: `Unknown stepParams flow "${flowKey}" for model "${node.use}".`,
+          allowedValues: [.../* @__PURE__ */ new Set([...Object.keys(staticFlows), ...Object.keys(dynamicFlows)])],
+          schemaHash
+        });
+      }
+      const staticSteps = ((_a = staticFlows[flowKey]) == null ? void 0 : _a.properties) || {};
+      const dynamicSteps = ((_b = dynamicFlows[flowKey]) == null ? void 0 : _b.steps) || {};
+      const knownStepKeys = /* @__PURE__ */ new Set([...Object.keys(staticSteps), ...Object.keys(dynamicSteps)]);
+      for (const [stepKey, stepValue] of Object.entries(flowValue)) {
+        const stepPointer = `${flowPointer}/${this.escapeJsonPointer(stepKey)}`;
+        const dynamicStep = dynamicSteps[stepKey];
+        const schema = staticSteps[stepKey] || (dynamicStep ? this.registry.resolveStepParamsSchema(dynamicStep, `${node == null ? void 0 : node.use}.${flowKey}.${stepKey}`).schema : void 0);
+        if (!schema) {
+          issues.push({
+            level: strict ? "error" : "warning",
+            jsonPointer: stepPointer,
+            modelUid: node == null ? void 0 : node.uid,
+            modelUse: node == null ? void 0 : node.use,
+            section: "stepParams",
+            keyword: knownStepKeys.has(stepKey) ? "missing-schema" : "unknown-step",
+            message: knownStepKeys.has(stepKey) ? `No params schema resolved for ${flowKey}.${stepKey}.` : `Unknown stepParams target ${flowKey}.${stepKey}.`,
+            allowedValues: [...knownStepKeys],
+            schemaHash
+          });
+          continue;
+        }
+        this.validateSchemaSection({
+          issues,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          jsonPointer: stepPointer,
+          schema,
+          value: stepValue,
+          section: "stepParams",
+          strict,
+          schemaHash
+        });
+      }
+    }
+  }
+  validateSubModels(node, jsonPointer, issues, strict, schemaHash, validationOptions = {}, contextChain = []) {
+    var _a, _b;
+    const subModels = node == null ? void 0 : node.subModels;
+    const slots = ((_a = this.registry.resolveModelSchema(String(node.use || ""), contextChain)) == null ? void 0 : _a.subModelSlots) || {};
+    const nodeUid = String((node == null ? void 0 : node.uid) || "").trim();
+    const isExistingNode = !!nodeUid && !!((_b = validationOptions.existingNodeUids) == null ? void 0 : _b.has(nodeUid));
+    const allowPartialRequiredSlots = isExistingNode || !!validationOptions.allowRootObjectLocator && jsonPointer !== "#" && !nodeUid;
+    if (typeof subModels === "undefined" || subModels === null) {
+      this.validateRequiredSubModelSlots({
+        node,
+        subModels: void 0,
+        slots,
+        jsonPointer,
+        issues,
+        strict,
+        schemaHash,
+        allowPartialRequiredSlots
+      });
+      return;
+    }
+    if (typeof subModels !== "object" || Array.isArray(subModels)) {
+      issues.push({
+        level: "error",
+        jsonPointer: `${jsonPointer}/subModels`,
+        modelUid: node == null ? void 0 : node.uid,
+        modelUse: node == null ? void 0 : node.use,
+        section: "subModels",
+        keyword: "type",
+        message: "subModels must be an object.",
+        expectedType: "object",
+        schemaHash
+      });
+      return;
+    }
+    this.validateRequiredSubModelSlots({
+      node,
+      subModels,
+      slots,
+      jsonPointer,
+      issues,
+      strict,
+      schemaHash,
+      allowPartialRequiredSlots
+    });
+    for (const [slotKey, slotValue] of Object.entries(subModels)) {
+      const slotPointer = `${jsonPointer}/subModels/${this.escapeJsonPointer(slotKey)}`;
+      const slotSchema = slots[slotKey];
+      if (!slotSchema) {
+        issues.push({
+          level: strict ? "error" : "warning",
+          jsonPointer: slotPointer,
+          modelUid: node == null ? void 0 : node.uid,
+          modelUse: node == null ? void 0 : node.use,
+          section: "subModels",
+          keyword: "unknown-slot",
+          message: `Unknown subModels slot "${slotKey}" for model "${node.use}".`,
+          allowedValues: Object.keys(slots),
+          schemaHash
+        });
+      }
+      if (Array.isArray(slotValue)) {
+        if (slotSchema && slotSchema.type !== "array") {
+          issues.push({
+            level: strict ? "error" : "warning",
+            jsonPointer: slotPointer,
+            modelUid: node == null ? void 0 : node.uid,
+            modelUse: node == null ? void 0 : node.use,
+            section: "subModels",
+            keyword: "type",
+            message: `Slot "${slotKey}" expects ${slotSchema.type}, received array.`,
+            expectedType: slotSchema.type,
+            suggestedUses: this.registry.resolveSlotAllowedUses(String((node == null ? void 0 : node.use) || ""), slotKey, slotSchema),
+            schemaHash
+          });
+        }
+        if (!allowPartialRequiredSlots && (slotSchema == null ? void 0 : slotSchema.type) === "array" && typeof slotSchema.minItems === "number" && slotValue.length < slotSchema.minItems) {
+          issues.push({
+            level: strict ? "error" : "warning",
+            jsonPointer: slotPointer,
+            modelUid: node == null ? void 0 : node.uid,
+            modelUse: node == null ? void 0 : node.use,
+            section: "subModels",
+            keyword: "minItems",
+            message: `Slot "${slotKey}" requires at least ${slotSchema.minItems} item(s).`,
+            schemaHash
+          });
+        }
+        slotValue.forEach((item, index) => {
+          const itemPointer = `${slotPointer}/${index}`;
+          const nextContext = this.validateSubModelChildUse({
+            parentNode: node,
+            slotKey,
+            slotSchema,
+            value: item,
+            jsonPointer: itemPointer,
+            issues,
+            strict,
+            schemaHash,
+            contextChain
+          });
+          this.validateModelNode(item, itemPointer, issues, validationOptions, nextContext);
+        });
+      } else {
+        if (slotSchema && slotSchema.type !== "object") {
+          issues.push({
+            level: strict ? "error" : "warning",
+            jsonPointer: slotPointer,
+            modelUid: node == null ? void 0 : node.uid,
+            modelUse: node == null ? void 0 : node.use,
+            section: "subModels",
+            keyword: "type",
+            message: `Slot "${slotKey}" expects ${slotSchema.type}, received object.`,
+            expectedType: slotSchema.type,
+            suggestedUses: this.registry.resolveSlotAllowedUses(String((node == null ? void 0 : node.use) || ""), slotKey, slotSchema),
+            schemaHash
+          });
+        }
+        const nextContext = this.validateSubModelChildUse({
+          parentNode: node,
+          slotKey,
+          slotSchema,
+          value: slotValue,
+          jsonPointer: slotPointer,
+          issues,
+          strict,
+          schemaHash,
+          contextChain
+        });
+        this.validateModelNode(slotValue, slotPointer, issues, validationOptions, nextContext);
+      }
+    }
+  }
+  validateRequiredSubModelSlots(options) {
+    var _a, _b, _c;
+    if (options.allowPartialRequiredSlots) {
+      return;
+    }
+    for (const [slotKey, slotSchema] of Object.entries(options.slots)) {
+      if (!(slotSchema == null ? void 0 : slotSchema.required)) {
+        continue;
+      }
+      if (typeof options.subModels !== "object" || options.subModels === null || !(slotKey in options.subModels)) {
+        options.issues.push({
+          level: options.strict ? "error" : "warning",
+          jsonPointer: `${options.jsonPointer}/subModels/${this.escapeJsonPointer(slotKey)}`,
+          modelUid: (_a = options.node) == null ? void 0 : _a.uid,
+          modelUse: (_b = options.node) == null ? void 0 : _b.use,
+          section: "subModels",
+          keyword: "required",
+          message: `Required subModels slot "${slotKey}" is missing.`,
+          suggestedUses: this.registry.resolveSlotAllowedUses(String(((_c = options.node) == null ? void 0 : _c.use) || ""), slotKey, slotSchema),
+          schemaHash: options.schemaHash
+        });
+      }
+    }
+  }
+  validateSubModelChildUse(options) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const childUse = String(((_a = options == null ? void 0 : options.value) == null ? void 0 : _a.use) || "").trim();
+    const fieldBinding = this.collectRuntimeFieldBindingUses(options.slotSchema, options.parentNode, options.slotKey);
+    const allowedUses = fieldBinding.allowedUses || [];
+    const allowUnknownUses = !!options.slotSchema && !options.slotSchema.fieldBindingContext && slotAllowsUnknownUses(options.slotSchema);
+    if (childUse && allowedUses.length > 0 && !allowedUses.includes(childUse) && !allowUnknownUses) {
+      options.issues.push({
+        level: options.strict ? "error" : "warning",
+        jsonPointer: `${options.jsonPointer}/use`,
+        modelUid: (_b = options.parentNode) == null ? void 0 : _b.uid,
+        modelUse: (_c = options.parentNode) == null ? void 0 : _c.use,
+        section: "subModels",
+        keyword: "invalid-use",
+        message: `Slot "${options.slotKey}" does not allow child use "${childUse}".`,
+        allowedValues: allowedUses,
+        suggestedUses: allowedUses,
+        fieldInterface: (_d = fieldBinding.metadata) == null ? void 0 : _d.interface,
+        fieldType: (_e = fieldBinding.metadata) == null ? void 0 : _e.fieldType,
+        targetCollectionTemplate: (_f = fieldBinding.metadata) == null ? void 0 : _f.targetCollectionTemplate,
+        schemaHash: options.schemaHash
+      });
+    }
+    if (!childUse) {
+      return options.contextChain;
+    }
+    return [
+      ...options.contextChain,
+      {
+        parentUse: String(((_g = options.parentNode) == null ? void 0 : _g.use) || ""),
+        slotKey: options.slotKey,
+        childUse
+      }
+    ];
+  }
+  validateFlowOn(on, jsonPointer, node, issues, strict, schemaHash) {
+    if (on === void 0 || on === null) return;
+    if (typeof on === "string") return;
+    if (typeof on !== "object" || Array.isArray(on)) {
+      issues.push({
+        level: "error",
+        jsonPointer,
+        modelUid: node == null ? void 0 : node.uid,
+        modelUse: node == null ? void 0 : node.use,
+        section: "flowRegistry",
+        keyword: "type",
+        message: "flow.on must be a string or object.",
+        expectedType: ["string", "object"],
+        schemaHash
+      });
+      return;
+    }
+    if (!on.eventName || typeof on.eventName !== "string") {
+      issues.push({
+        level: "error",
+        jsonPointer,
+        modelUid: node == null ? void 0 : node.uid,
+        modelUse: node == null ? void 0 : node.use,
+        section: "flowRegistry",
+        keyword: "required",
+        message: "flow.on.eventName is required.",
+        schemaHash
+      });
+    }
+    if (on.phase && !FLOW_EVENT_PHASES.includes(on.phase)) {
+      issues.push({
+        level: "error",
+        jsonPointer: `${jsonPointer}/phase`,
+        modelUid: node == null ? void 0 : node.uid,
+        modelUse: node == null ? void 0 : node.use,
+        section: "flowRegistry",
+        keyword: "enum",
+        message: `Invalid flow phase "${on.phase}".`,
+        allowedValues: FLOW_EVENT_PHASES,
+        schemaHash
+      });
+    }
+    if (["beforeFlow", "afterFlow", "beforeStep", "afterStep"].includes(on.phase) && !on.flowKey) {
+      issues.push({
+        level: strict ? "error" : "warning",
+        jsonPointer: `${jsonPointer}/flowKey`,
+        modelUid: node == null ? void 0 : node.uid,
+        modelUse: node == null ? void 0 : node.use,
+        section: "flowRegistry",
+        keyword: "required",
+        message: `flow.on.flowKey is required when phase is "${on.phase}".`,
+        schemaHash
+      });
+    }
+    if (["beforeStep", "afterStep"].includes(on.phase) && !on.stepKey) {
+      issues.push({
+        level: strict ? "error" : "warning",
+        jsonPointer: `${jsonPointer}/stepKey`,
+        modelUid: node == null ? void 0 : node.uid,
+        modelUse: node == null ? void 0 : node.use,
+        section: "flowRegistry",
+        keyword: "required",
+        message: `flow.on.stepKey is required when phase is "${on.phase}".`,
+        schemaHash
+      });
+    }
+  }
+  validateSchemaSection(options) {
+    const result = this.validateSchema(options.schema, options.value);
+    if (!result.valid) {
+      this.pushAjvIssues(result.errors, options.issues, {
+        level: options.strict ? "error" : "warning",
+        jsonPointer: options.jsonPointer,
+        modelUid: options.modelUid,
+        modelUse: options.modelUse,
+        section: options.section,
+        schemaHash: options.schemaHash
+      });
+    }
+  }
+  validateSchema(schema, value) {
+    const cacheKey = stableStringify(schema);
+    let validator = this.validatorCache.get(cacheKey);
+    if (!validator) {
+      validator = this.ajv.compile(schema);
+      this.validatorCache.set(cacheKey, validator);
+    }
+    const valid = validator(value);
+    return {
+      valid,
+      errors: validator.errors || []
+    };
+  }
+  pushAjvIssues(errors, issues, base) {
+    for (const error of errors || []) {
+      const legacyDataPath = error.dataPath;
+      const errorPath = error.instancePath || legacyDataPath || "";
+      const params = error.params || {};
+      issues.push({
+        ...base,
+        jsonPointer: `${base.jsonPointer}${errorPath}` || base.jsonPointer,
+        keyword: error.keyword,
+        message: error.message || "Invalid payload.",
+        expectedType: error.keyword === "type" ? params.type : void 0,
+        allowedValues: error.keyword === "enum" ? params.allowedValues : error.keyword === "const" ? [params.allowedValue] : void 0
+      });
+    }
+  }
+  escapeJsonPointer(value) {
+    return String(value).replace(/~/g, "~0").replace(/\//g, "~1");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlowSchemaService
+});