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

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

@@ -1,963 +0,0 @@
-/**
- * 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_flow_schema_registry = require("./flow-schema-registry");
-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_flow_schema_registry.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
-});