@nocobase/flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/lib/executor/FlowExecutor.js

@@ -46,14 +46,46 @@ var import_flowEngine = require("../flowEngine");
 var import_utils = require("../utils");
 var import_exceptions = require("../utils/exceptions");
 var import_setupRuntimeContextSteps = require("../utils/setupRuntimeContextSteps");
+var import_createEphemeralContext = require("../utils/createEphemeralContext");
 const _FlowExecutor = class _FlowExecutor {
   constructor(engine) {
     this.engine = engine;
   }
+  async emitModelEventIf(eventName, topic, payload) {
+    if (!eventName) return;
+    await this.engine.emitter.emitAsync(`model:event:${eventName}:${topic}`, payload);
+  }
+  /** Cache wrapper for applyFlow cache lifecycle */
+  async withApplyFlowCache(cacheKey, executor) {
+    if (!cacheKey || !this.engine) return await executor();
+    const cachedEntry = this.engine.applyFlowCache.get(cacheKey);
+    if (cachedEntry) {
+      if (cachedEntry.status === "resolved") return cachedEntry.data;
+      if (cachedEntry.status === "rejected") throw cachedEntry.error;
+      if (cachedEntry.status === "pending") return await cachedEntry.promise;
+    }
+    const promise = executor().then((result) => {
+      this.engine.applyFlowCache.set(cacheKey, {
+        status: "resolved",
+        data: result,
+        promise: Promise.resolve(result)
+      });
+      return result;
+    }).catch((err) => {
+      this.engine.applyFlowCache.set(cacheKey, {
+        status: "rejected",
+        error: err,
+        promise: Promise.reject(err)
+      });
+      throw err;
+    });
+    this.engine.applyFlowCache.set(cacheKey, { status: "pending", promise });
+    return await promise;
+  }
   /**
    * Execute a single flow on model.
    */
-  async runFlow(model, flowKey, inputArgs, runId) {
+  async runFlow(model, flowKey, inputArgs, runId, eventName) {
     var _a;
     const flow = model.getFlow(flowKey);
     if (!flow) {
@@ -77,34 +109,48 @@ const _FlowExecutor = class _FlowExecutor {
     let eventStep = model.getEvent(typeof flow.on === "string" ? flow.on : (_a = flow.on) == null ? void 0 : _a.eventName);
     if (eventStep) {
       eventStep = { ...eventStep };
-      eventStep.defaultParams = { ...import_lodash.default.get(flow, "on.defaultParams", {}), ...eventStep.defaultParams };
+      eventStep.defaultParams = {
+        ...import_lodash.default.get(flow, "on.defaultParams", {}),
+        ...eventStep.defaultParams
+      };
     }
     const stepDefs = eventStep ? { eventStep, ...flow.steps } : flow.steps;
     (0, import_setupRuntimeContextSteps.setupRuntimeContextSteps)(flowContext, stepDefs, model, flowKey);
     const stepsRuntime = flowContext.steps;
-    for (const stepKey in stepDefs) {
-      if (!Object.prototype.hasOwnProperty.call(stepDefs, stepKey)) continue;
-      const step = stepDefs[stepKey];
+    const flowEventBasePayload = {
+      uid: model.uid,
+      model,
+      runId: flowContext.runId,
+      inputArgs,
+      flowKey
+    };
+    await this.emitModelEventIf(eventName, `flow:${flowKey}:start`, flowEventBasePayload);
+    for (const [stepKey, step] of Object.entries(stepDefs)) {
       let handler;
       let combinedParams = {};
-      let actionDefinition;
       let useRawParams = step.useRawParams;
+      let runtimeCtx;
       if (step.use) {
-        actionDefinition = model.getAction(step.use);
+        const actionDefinition = model.getAction(step.use);
         if (!actionDefinition) {
           flowContext.logger.error(
             `BaseModel.applyFlow: Action '${step.use}' not found for step '${stepKey}' in flow '${flowKey}'. Skipping.`
           );
           continue;
         }
+        runtimeCtx = await (0, import_createEphemeralContext.createEphemeralContext)(flowContext, {
+          ...actionDefinition,
+          ...step
+        });
         handler = step.handler || actionDefinition.handler;
         useRawParams = useRawParams ?? actionDefinition.useRawParams;
-        const actionDefaultParams = await (0, import_utils.resolveDefaultParams)(actionDefinition.defaultParams, flowContext);
-        const stepDefaultParams = await (0, import_utils.resolveDefaultParams)(step.defaultParams, flowContext);
+        const actionDefaultParams = await (0, import_utils.resolveDefaultParams)(actionDefinition.defaultParams, runtimeCtx);
+        const stepDefaultParams = await (0, import_utils.resolveDefaultParams)(step.defaultParams, runtimeCtx);
         combinedParams = { ...actionDefaultParams, ...stepDefaultParams };
       } else if (step.handler) {
+        runtimeCtx = await (0, import_createEphemeralContext.createEphemeralContext)(flowContext, step);
         handler = step.handler;
-        const stepDefaultParams = await (0, import_utils.resolveDefaultParams)(step.defaultParams, flowContext);
+        const stepDefaultParams = await (0, import_utils.resolveDefaultParams)(step.defaultParams, runtimeCtx);
         combinedParams = { ...stepDefaultParams };
       } else {
         flowContext.logger.error(
@@ -117,10 +163,10 @@ const _FlowExecutor = class _FlowExecutor {
         combinedParams = { ...combinedParams, ...modelStepParams };
       }
       if (typeof useRawParams === "function") {
-        useRawParams = await useRawParams(flowContext);
+        useRawParams = await useRawParams(runtimeCtx);
       }
       if (!useRawParams) {
-        combinedParams = await flowContext.resolveJsonTemplate(combinedParams);
+        combinedParams = await runtimeCtx.resolveJsonTemplate(combinedParams);
       }
       try {
         if (!handler) {
@@ -129,20 +175,56 @@ const _FlowExecutor = class _FlowExecutor {
           );
           continue;
         }
-        const currentStepResult = handler(flowContext, combinedParams);
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:start`, {
+          ...flowEventBasePayload,
+          stepKey
+        });
+        const currentStepResult = handler(runtimeCtx, combinedParams);
         const isAwait = step.isAwait !== false;
         lastResult = isAwait ? await currentStepResult : currentStepResult;
         stepResults[stepKey] = lastResult;
         stepsRuntime[stepKey].result = stepResults[stepKey];
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+          ...flowEventBasePayload,
+          result: lastResult,
+          stepKey
+        });
       } catch (error) {
+        if (!(error instanceof import_utils.FlowExitException) && !(error instanceof import_exceptions.FlowExitAllException)) {
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:error`, {
+            ...flowEventBasePayload,
+            error,
+            stepKey
+          });
+        }
         if (error instanceof import_utils.FlowExitException) {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+            ...flowEventBasePayload,
+            stepKey
+          });
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+            ...flowEventBasePayload,
+            result: stepResults
+          });
           return Promise.resolve(stepResults);
         }
         if (error instanceof import_exceptions.FlowExitAllException) {
           flowContext.logger.info(`[FlowEngine] ${error.message}`);
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:step:${stepKey}:end`, {
+            ...flowEventBasePayload,
+            stepKey
+          });
+          await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+            ...flowEventBasePayload,
+            result: error
+          });
           return Promise.resolve(error);
         }
+        await this.emitModelEventIf(eventName, `flow:${flowKey}:error`, {
+          ...flowEventBasePayload,
+          error
+        });
         flowContext.logger.error(
           { err: error },
           `BaseModel.applyFlow: Error executing step '${stepKey}' in flow '${flowKey}':`
@@ -150,108 +232,229 @@ const _FlowExecutor = class _FlowExecutor {
         return Promise.reject(error);
       }
     }
+    await this.emitModelEventIf(eventName, `flow:${flowKey}:end`, {
+      ...flowEventBasePayload,
+      result: stepResults
+    });
     return Promise.resolve(stepResults);
   }
   /**
-   * Execute all auto-apply flows for model.
+   * Dispatch an event to flows bound via flow.on and execute them.
    */
-  async runAutoFlows(model, inputArgs, useCache = true) {
-    const autoApplyFlows = model.getAutoFlows();
-    if (autoApplyFlows.length === 0) {
-      model.context.logger.warn(`FlowModel: No auto-apply flows found for model '${model.uid}'`);
-      return [];
-    }
-    const cacheKey = useCache ? import_flowEngine.FlowEngine.generateApplyFlowCacheKey(model.getAutoFlowCacheScope(), "all", model.uid) : null;
-    if (cacheKey && this.engine) {
-      const cachedEntry = this.engine.applyFlowCache.get(cacheKey);
-      if (cachedEntry) {
-        if (cachedEntry.status === "resolved") {
-          model.context.logger.debug(`[FlowEngine.applyAutoFlows] Using cached result for model: ${model.uid}`);
-          return cachedEntry.data;
-        }
-        if (cachedEntry.status === "rejected") throw cachedEntry.error;
-        if (cachedEntry.status === "pending") return await cachedEntry.promise;
+  async dispatchEvent(model, eventName, inputArgs, options) {
+    var _a, _b, _c, _d;
+    const isBeforeRender = eventName === "beforeRender";
+    const sequential = !!(options == null ? void 0 : options.sequential);
+    const useCache = !!(options == null ? void 0 : options.useCache);
+    const throwOnError = isBeforeRender;
+    const runId = `${model.uid}-${eventName}-${Date.now()}`;
+    const logger = model.context.logger;
+    const eventBasePayload = {
+      uid: model.uid,
+      model,
+      runId,
+      inputArgs
+    };
+    try {
+      await this.emitModelEventIf(eventName, "start", eventBasePayload);
+      await ((_a = model.onDispatchEventStart) == null ? void 0 : _a.call(model, eventName, options, inputArgs));
+    } catch (err) {
+      if (isBeforeRender && err instanceof import_utils.FlowExitException) {
+        logger.debug(`[FlowModel.dispatchEvent] ${err.message}`);
+        return [];
       }
-    }
-    const executeAutoFlows = /* @__PURE__ */ __name(async () => {
-      const results = [];
-      const runId = `${model.uid}-autoFlow-${Date.now()}-${Math.floor(Math.random() * 1e3)}`;
-      const logger = model.context.logger.child({ module: "flow-engine", component: "FlowExecutor", runId });
-      logger.debug(
-        `[FlowExecutor] runAutoFlows: uid=${model.uid}, isFork=${(model == null ? void 0 : model.isFork) === true}, useCache=${useCache}, runId=${runId}, flows=${autoApplyFlows.map((f) => f.key).join(",")}`
-      );
       try {
-        if (autoApplyFlows.length === 0) {
-          logger.warn(`FlowModel: No auto-apply flows found for model '${model.uid}'`);
-        } else {
-          for (const flow of autoApplyFlows) {
-            try {
-              logger.debug(`[FlowExecutor] runFlow: uid=${model.uid}, flowKey=${flow.key}`);
-              const result = await this.runFlow(model, flow.key, inputArgs, runId);
-              if (result instanceof import_exceptions.FlowExitAllException) {
-                logger.debug(`[FlowEngine.applyAutoFlows] ${result.message}`);
-                break;
-              }
-              results.push(result);
-            } catch (error) {
-              logger.error({ err: error }, `FlowModel.applyAutoFlows: Error executing auto-apply flow '${flow.key}':`);
-              throw error;
-            }
-          }
-        }
-        return results;
-      } catch (error) {
-        if (error instanceof import_utils.FlowExitException) {
-          logger.debug(`[FlowEngine.applyAutoFlows] ${error.message}`);
-          return results;
-        }
-        throw error;
+        await ((_b = model.onDispatchEventError) == null ? void 0 : _b.call(model, eventName, options, inputArgs, err));
+      } finally {
+        logger.error({ err }, `BaseModel.dispatchEvent: Start hook error for event '${eventName}'`);
       }
-    }, "executeAutoFlows");
-    if (!cacheKey || !this.engine) {
-      return await executeAutoFlows();
+      if (throwOnError) throw err;
+      return;
     }
-    const promise = executeAutoFlows().then((result) => {
-      this.engine.applyFlowCache.set(cacheKey, {
-        status: "resolved",
-        data: result,
-        promise: Promise.resolve(result)
-      });
-      return result;
-    }).catch((err) => {
-      this.engine.applyFlowCache.set(cacheKey, {
-        status: "rejected",
-        error: err,
-        promise: Promise.reject(err)
-      });
-      throw err;
-    });
-    this.engine.applyFlowCache.set(cacheKey, { status: "pending", promise });
-    return await promise;
-  }
-  /**
-   * Dispatch an event to flows bound via flow.on and execute them.
-   */
-  async dispatchEvent(model, eventName, inputArgs) {
-    const flows = Array.from(model.getFlows().values()).filter((flow) => {
+    const flows = isBeforeRender ? model.getEventFlows("beforeRender") : Array.from(model.getFlows().values()).filter((flow) => {
       const on = flow.on;
       if (!on) return false;
       if (typeof on === "string") return on === eventName;
       if (typeof on === "object") return on.eventName === eventName;
       return false;
     });
-    const runId = `${model.uid}-${eventName}-${Date.now()}`;
-    const logger = model.context.logger;
-    const promises = flows.map((flow) => {
-      logger.debug(`BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}'.`);
-      return this.runFlow(model, flow.key, inputArgs, runId).catch((error) => {
-        logger.error(
-          { err: error },
-          `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}':`
+    const isRouterReplayClick = eventName === "click" && (inputArgs == null ? void 0 : inputArgs.triggerByRouter) === true;
+    const flowsToRun = isRouterReplayClick ? flows.filter((flow) => {
+      var _a2;
+      const reg = flow["flowRegistry"];
+      const type = (_a2 = reg == null ? void 0 : reg.constructor) == null ? void 0 : _a2._type;
+      return type !== "instance";
+    }) : flows;
+    const scheduledCancels = [];
+    const execute = /* @__PURE__ */ __name(async () => {
+      if (sequential) {
+        const flowsWithIndex = flowsToRun.map((f, i) => ({ f, i }));
+        const ordered = flowsWithIndex.slice().sort((a, b) => {
+          var _a2, _b2;
+          const regA = a.f["flowRegistry"];
+          const regB = b.f["flowRegistry"];
+          const typeA = (_a2 = regA == null ? void 0 : regA.constructor) == null ? void 0 : _a2._type;
+          const typeB = (_b2 = regB == null ? void 0 : regB.constructor) == null ? void 0 : _b2._type;
+          const groupA = typeA === "instance" ? 0 : 1;
+          const groupB = typeB === "instance" ? 0 : 1;
+          if (groupA !== groupB) return groupA - groupB;
+          const sa = a.f.sort ?? 0;
+          const sb = b.f.sort ?? 0;
+          if (sa !== sb) return sa - sb;
+          return a.i - b.i;
+        }).map((x) => x.f);
+        const results2 = [];
+        const staticFlowsByKey = new Map(
+          ordered.filter((f) => {
+            var _a2;
+            const reg = f["flowRegistry"];
+            const type = (_a2 = reg == null ? void 0 : reg.constructor) == null ? void 0 : _a2._type;
+            return type !== "instance";
+          }).map((f) => [f.key, f])
         );
+        const scheduled = /* @__PURE__ */ new Set();
+        const scheduleGroups = /* @__PURE__ */ new Map();
+        ordered.forEach((flow, indexInOrdered) => {
+          var _a2;
+          const on = flow.on;
+          const onObj = typeof on === "object" ? on : void 0;
+          if (!onObj) return;
+          const phase = onObj.phase;
+          const flowKey = onObj.flowKey;
+          const stepKey = onObj.stepKey;
+          if (!phase || phase === "beforeAllFlows") return;
+          let whenKey = null;
+          if (phase === "afterAllFlows") {
+            whenKey = `event:${eventName}:end`;
+          } else if (phase === "beforeFlow" || phase === "afterFlow") {
+            if (!flowKey) {
+              whenKey = `event:${eventName}:end`;
+            } else {
+              const anchorFlow = staticFlowsByKey.get(String(flowKey));
+              if (anchorFlow) {
+                const anchorPhase = phase === "beforeFlow" ? "start" : "end";
+                whenKey = `event:${eventName}:flow:${String(flowKey)}:${anchorPhase}`;
+              } else {
+                whenKey = `event:${eventName}:end`;
+              }
+            }
+          } else if (phase === "beforeStep" || phase === "afterStep") {
+            if (!flowKey || !stepKey) {
+              whenKey = `event:${eventName}:end`;
+            } else {
+              const anchorFlow = staticFlowsByKey.get(String(flowKey));
+              const anchorStepExists = !!((_a2 = anchorFlow == null ? void 0 : anchorFlow.hasStep) == null ? void 0 : _a2.call(anchorFlow, String(stepKey)));
+              if (anchorFlow && anchorStepExists) {
+                const anchorPhase = phase === "beforeStep" ? "start" : "end";
+                whenKey = `event:${eventName}:flow:${String(flowKey)}:step:${String(stepKey)}:${anchorPhase}`;
+              } else {
+                whenKey = `event:${eventName}:end`;
+              }
+            }
+          } else {
+            return;
+          }
+          if (!whenKey) return;
+          scheduled.add(flow.key);
+          const list = scheduleGroups.get(whenKey) || [];
+          list.push({ flow, order: indexInOrdered });
+          scheduleGroups.set(whenKey, list);
+        });
+        for (const [whenKey, list] of scheduleGroups.entries()) {
+          const sorted = list.slice().sort((a, b) => {
+            const sa = a.flow.sort ?? 0;
+            const sb = b.flow.sort ?? 0;
+            if (sa !== sb) return sa - sb;
+            return a.order - b.order;
+          });
+          for (const it of sorted) {
+            const cancel = model.scheduleModelOperation(
+              model.uid,
+              async (m) => {
+                const res = await this.runFlow(m, it.flow.key, inputArgs, runId, eventName);
+                results2.push(res);
+              },
+              { when: whenKey }
+            );
+            scheduledCancels.push(cancel);
+          }
+        }
+        for (const flow of ordered) {
+          if (scheduled.has(flow.key)) continue;
+          try {
+            logger.debug(
+              `BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}' (sequential).`
+            );
+            const result = await this.runFlow(model, flow.key, inputArgs, runId, eventName);
+            if (result instanceof import_exceptions.FlowExitAllException) {
+              logger.debug(`[FlowEngine.dispatchEvent] ${result.message}`);
+              break;
+            }
+            results2.push(result);
+          } catch (error) {
+            logger.error(
+              { err: error },
+              `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}' (sequential):`
+            );
+            throw error;
+          }
+        }
+        return results2;
+      }
+      const results = await Promise.all(
+        flowsToRun.map(async (flow) => {
+          logger.debug(`BaseModel '${model.uid}' dispatching event '${eventName}' to flow '${flow.key}'.`);
+          try {
+            return await this.runFlow(model, flow.key, inputArgs, runId, eventName);
+          } catch (error) {
+            logger.error(
+              { err: error },
+              `BaseModel.dispatchEvent: Error executing event-triggered flow '${flow.key}' for event '${eventName}':`
+            );
+            if (throwOnError) throw error;
+            return void 0;
+          }
+        })
+      );
+      return results.filter((x) => x !== void 0);
+    }, "execute");
+    const argsKey = useCache ? JSON.stringify(inputArgs ?? {}) : "";
+    const cacheKey = useCache ? import_flowEngine.FlowEngine.generateApplyFlowCacheKey(
+      `event:${model.getFlowCacheScope(eventName)}:${argsKey}`,
+      eventName,
+      model.uid
+    ) : null;
+    try {
+      const result = await this.withApplyFlowCache(cacheKey, execute);
+      try {
+        await ((_c = model.onDispatchEventEnd) == null ? void 0 : _c.call(model, eventName, options, inputArgs, result));
+      } catch (hookErr) {
+        logger.error({ err: hookErr }, `BaseModel.dispatchEvent: End hook error for event '${eventName}'`);
+      }
+      await this.emitModelEventIf(eventName, "end", {
+        ...eventBasePayload,
+        result
       });
-    });
-    await Promise.all(promises);
+      return result;
+    } catch (error) {
+      try {
+        await ((_d = model.onDispatchEventError) == null ? void 0 : _d.call(model, eventName, options, inputArgs, error));
+      } catch (_2) {
+      }
+      model.context.logger.error(
+        { err: error },
+        `BaseModel.dispatchEvent: Error executing event '${eventName}' for model '${model.uid}':`
+      );
+      await this.emitModelEventIf(eventName, "error", {
+        ...eventBasePayload,
+        error
+      });
+      if (throwOnError) throw error;
+    } finally {
+      for (const cancel of scheduledCancels) {
+        cancel();
+      }
+    }
   }
 };
 __name(_FlowExecutor, "FlowExecutor");

package/lib/flow-registry/GlobalFlowRegistry.d.ts

@@ -12,6 +12,7 @@ import { BaseFlowRegistry } from './BaseFlowRegistry';
 type FlowKey = string;
 export declare class GlobalFlowRegistry extends BaseFlowRegistry {
     protected target: ModelConstructor;
+    static readonly _type: "global";
     constructor(target: ModelConstructor);
     removeFlow(flowKey: FlowKey): void;
     getFlow(flowKey: FlowKey): FlowDefinition | undefined;

package/lib/flow-registry/GlobalFlowRegistry.js

@@ -11,6 +11,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -25,6 +26,7 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var GlobalFlowRegistry_exports = {};
 __export(GlobalFlowRegistry_exports, {
   GlobalFlowRegistry: () => GlobalFlowRegistry
@@ -88,6 +90,7 @@ const _GlobalFlowRegistry = class _GlobalFlowRegistry extends import_BaseFlowReg
   }
 };
 __name(_GlobalFlowRegistry, "GlobalFlowRegistry");
+__publicField(_GlobalFlowRegistry, "_type", "global");
 let GlobalFlowRegistry = _GlobalFlowRegistry;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/flow-registry/InstanceFlowRegistry.d.ts

@@ -12,6 +12,7 @@ import { BaseFlowRegistry } from './BaseFlowRegistry';
 type FlowKey = string;
 export declare class InstanceFlowRegistry extends BaseFlowRegistry {
     protected model: FlowModel;
+    static readonly _type: "instance";
     constructor(model: FlowModel);
     save(): Promise<void>;
     saveFlow(flow: FlowDefinition): Promise<void>;

package/lib/flow-registry/InstanceFlowRegistry.js

@@ -11,6 +11,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -25,6 +26,7 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var InstanceFlowRegistry_exports = {};
 __export(InstanceFlowRegistry_exports, {
   InstanceFlowRegistry: () => InstanceFlowRegistry
@@ -52,6 +54,7 @@ const _InstanceFlowRegistry = class _InstanceFlowRegistry extends import_BaseFlo
   }
 };
 __name(_InstanceFlowRegistry, "InstanceFlowRegistry");
+__publicField(_InstanceFlowRegistry, "_type", "instance");
 let InstanceFlowRegistry = _InstanceFlowRegistry;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {