@mastra/server 1.56.0-alpha.2 → 1.56.0-alpha.4

package/dist/server/server-adapter/routes/workflows.d.ts

@@ -26,7 +26,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
         metadata?: Record<string, unknown> | undefined;
     }>;
     stepGraph: {
-        type: "step" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach";
+        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
     }[];
     name?: string | undefined;
     description?: string | undefined;
@@ -36,6 +36,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     stateSchema?: string | undefined;
     options?: Record<string, never> | undefined;
     isProcessorWorkflow?: boolean | undefined;
+    origin?: "code" | "stored" | undefined;
 }>, "json", import(".").RouteSchemas<undefined, import("zod").ZodObject<{
     partial: import("zod").ZodOptional<import("zod").ZodString>;
 }, import("zod/v4/core").$strip>, undefined, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -69,6 +70,9 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     stepGraph: import("zod").ZodArray<import("zod").ZodObject<{
         type: import("zod").ZodEnum<{
             step: "step";
+            agent: "agent";
+            tool: "tool";
+            mapping: "mapping";
             sleep: "sleep";
             sleepUntil: "sleepUntil";
             waitForEvent: "waitForEvent";
@@ -76,6 +80,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
             conditional: "conditional";
             loop: "loop";
             foreach: "foreach";
+            workflow: "workflow";
         }>;
     }, import("zod/v4/core").$strip>>;
     inputSchema: import("zod").ZodOptional<import("zod").ZodString>;
@@ -83,6 +88,10 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     stateSchema: import("zod").ZodOptional<import("zod").ZodString>;
     options: import("zod").ZodOptional<import("zod").ZodObject<{}, import("zod/v4/core").$strip>>;
     isProcessorWorkflow: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    origin: import("zod").ZodOptional<import("zod").ZodEnum<{
+        code: "code";
+        stored: "stored";
+    }>>;
 }, import("zod/v4/core").$strip>>>, "GET", "/workflows">, import(".").ServerRoute<{
     workflowId: string;
 }, {
@@ -111,7 +120,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
         metadata?: Record<string, unknown> | undefined;
     }>;
     stepGraph: {
-        type: "step" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach";
+        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
     }[];
     name?: string | undefined;
     description?: string | undefined;
@@ -121,6 +130,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     stateSchema?: string | undefined;
     options?: Record<string, never> | undefined;
     isProcessorWorkflow?: boolean | undefined;
+    origin?: "code" | "stored" | undefined;
 }, "json", import(".").RouteSchemas<import("zod").ZodObject<{
     workflowId: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
@@ -154,6 +164,9 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     stepGraph: import("zod").ZodArray<import("zod").ZodObject<{
         type: import("zod").ZodEnum<{
             step: "step";
+            agent: "agent";
+            tool: "tool";
+            mapping: "mapping";
             sleep: "sleep";
             sleepUntil: "sleepUntil";
             waitForEvent: "waitForEvent";
@@ -161,6 +174,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
             conditional: "conditional";
             loop: "loop";
             foreach: "foreach";
+            workflow: "workflow";
         }>;
     }, import("zod/v4/core").$strip>>;
     inputSchema: import("zod").ZodOptional<import("zod").ZodString>;
@@ -168,6 +182,10 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     stateSchema: import("zod").ZodOptional<import("zod").ZodString>;
     options: import("zod").ZodOptional<import("zod").ZodObject<{}, import("zod/v4/core").$strip>>;
     isProcessorWorkflow: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    origin: import("zod").ZodOptional<import("zod").ZodEnum<{
+        code: "code";
+        stored: "stored";
+    }>>;
 }, import("zod/v4/core").$strip>>, "GET", "/workflows/:workflowId">, import(".").ServerRoute<import(".").InferParams<import("zod").ZodObject<{
     workflowId: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
@@ -257,7 +275,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     steps?: Record<string, unknown> | undefined;
     activeStepsPath?: Record<string, number[]> | undefined;
     serializedStepGraph?: {
-        type: "step" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach";
+        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
     }[] | undefined;
 }, "json", import(".").RouteSchemas<import("zod").ZodObject<{
     workflowId: import("zod").ZodString;
@@ -296,6 +314,9 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     serializedStepGraph: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
         type: import("zod").ZodEnum<{
             step: "step";
+            agent: "agent";
+            tool: "tool";
+            mapping: "mapping";
             sleep: "sleep";
             sleepUntil: "sleepUntil";
             waitForEvent: "waitForEvent";
@@ -303,6 +324,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
             conditional: "conditional";
             loop: "loop";
             foreach: "foreach";
+            workflow: "workflow";
         }>;
     }, import("zod/v4/core").$strip>>>;
 }, import("zod/v4/core").$strip>>, "GET", "/workflows/:workflowId/runs/:runId">, import(".").ServerRoute<{
@@ -439,7 +461,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     steps?: Record<string, unknown> | undefined;
     activeStepsPath?: Record<string, number[]> | undefined;
     serializedStepGraph?: {
-        type: "step" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach";
+        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
     }[] | undefined;
 }, "json", import(".").RouteSchemas<import("zod").ZodObject<{
     workflowId: import("zod").ZodString;
@@ -483,6 +505,9 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     serializedStepGraph: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
         type: import("zod").ZodEnum<{
             step: "step";
+            agent: "agent";
+            tool: "tool";
+            mapping: "mapping";
             sleep: "sleep";
             sleepUntil: "sleepUntil";
             waitForEvent: "waitForEvent";
@@ -490,6 +515,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
             conditional: "conditional";
             loop: "loop";
             foreach: "foreach";
+            workflow: "workflow";
         }>;
     }, import("zod/v4/core").$strip>>>;
 }, import("zod/v4/core").$strip>>, "POST", "/workflows/:workflowId/start-async">, import(".").ServerRoute<import(".").InferParams<import("zod").ZodObject<{
@@ -572,7 +598,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     steps?: Record<string, unknown> | undefined;
     activeStepsPath?: Record<string, number[]> | undefined;
     serializedStepGraph?: {
-        type: "step" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach";
+        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
     }[] | undefined;
 }, "json", import(".").RouteSchemas<import("zod").ZodObject<{
     workflowId: import("zod").ZodString;
@@ -616,6 +642,9 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     serializedStepGraph: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
         type: import("zod").ZodEnum<{
             step: "step";
+            agent: "agent";
+            tool: "tool";
+            mapping: "mapping";
             sleep: "sleep";
             sleepUntil: "sleepUntil";
             waitForEvent: "waitForEvent";
@@ -623,6 +652,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
             conditional: "conditional";
             loop: "loop";
             foreach: "foreach";
+            workflow: "workflow";
         }>;
     }, import("zod/v4/core").$strip>>>;
 }, import("zod/v4/core").$strip>>, "POST", "/workflows/:workflowId/resume-async">, import(".").ServerRoute<import(".").InferParams<import("zod").ZodObject<{
@@ -798,7 +828,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     steps?: Record<string, unknown> | undefined;
     activeStepsPath?: Record<string, number[]> | undefined;
     serializedStepGraph?: {
-        type: "step" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach";
+        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
     }[] | undefined;
 }, "json", import(".").RouteSchemas<import("zod").ZodObject<{
     workflowId: import("zod").ZodString;
@@ -845,6 +875,9 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     serializedStepGraph: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
         type: import("zod").ZodEnum<{
             step: "step";
+            agent: "agent";
+            tool: "tool";
+            mapping: "mapping";
             sleep: "sleep";
             sleepUntil: "sleepUntil";
             waitForEvent: "waitForEvent";
@@ -852,6 +885,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
             conditional: "conditional";
             loop: "loop";
             foreach: "foreach";
+            workflow: "workflow";
         }>;
     }, import("zod/v4/core").$strip>>>;
 }, import("zod/v4/core").$strip>>, "POST", "/workflows/:workflowId/time-travel-async">, import(".").ServerRoute<import(".").InferParams<import("zod").ZodObject<{
@@ -956,7 +990,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     steps?: Record<string, unknown> | undefined;
     activeStepsPath?: Record<string, number[]> | undefined;
     serializedStepGraph?: {
-        type: "step" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach";
+        type: "step" | "agent" | "tool" | "mapping" | "sleep" | "sleepUntil" | "waitForEvent" | "parallel" | "conditional" | "loop" | "foreach" | "workflow";
     }[] | undefined;
 }, "json", import(".").RouteSchemas<import("zod").ZodObject<{
     workflowId: import("zod").ZodString;
@@ -996,6 +1030,9 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
     serializedStepGraph: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
         type: import("zod").ZodEnum<{
             step: "step";
+            agent: "agent";
+            tool: "tool";
+            mapping: "mapping";
             sleep: "sleep";
             sleepUntil: "sleepUntil";
             waitForEvent: "waitForEvent";
@@ -1003,6 +1040,7 @@ export declare const WORKFLOWS_ROUTES: readonly [import(".").ServerRoute<{
             conditional: "conditional";
             loop: "loop";
             foreach: "foreach";
+            workflow: "workflow";
         }>;
     }, import("zod/v4/core").$strip>>>;
 }, import("zod/v4/core").$strip>>, "POST", "/workflows/:workflowId/restart-async">, import(".").ServerRoute<{

package/dist/server/server-adapter/routes/workflows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/workflows.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAyBnB,CAAC"}
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/workflows.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAyBnB,CAAC"}

package/dist/server/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/server/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAqB,QAAQ,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAoBxF;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgBvD;AAID,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC3C,CAAC;AAEF,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,EACjC,cAAc,EAAE,cAAc,GAAG,SAAS,GACzC,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAqB1C;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,KAAK,EAAE,mBAAmB,GAAG,SAAS,GACrC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CASrC;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,EAC/C,KAAK,EAAE,mBAAmB,GAAG,SAAS,GACrC,IAAI,CAQN;AAiED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,GAAE,OAAe,GAAG,YAAY,CAmD1F;AAED;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAgC;IAElE;;OAEG;IACH,MAAM,CAAC,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAItE;;OAEG;IACH,MAAM,CAAC,0BAA0B,CAC/B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACnC,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GAC3D,IAAI;IAiBP;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAI5D;;OAEG;IACH,MAAM,CAAC,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;IAIlD;;OAEG;IACH,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAGzD;;OAEG;IACH,MAAM,CAAC,OAAO,IAAI,IAAI;IAKtB;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAI1D;;OAEG;IACH,MAAM,CAAC,wBAAwB,IAAI,MAAM,EAAE;CAG5C;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAK5C;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAwB1E"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/server/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAqB,QAAQ,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAoBxF;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgBvD;AAID,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC3C,CAAC;AAEF,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,EACjC,cAAc,EAAE,cAAc,GAAG,SAAS,GACzC,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAqB1C;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,KAAK,EAAE,mBAAmB,GAAG,SAAS,GACrC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CASrC;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,EAC/C,KAAK,EAAE,mBAAmB,GAAG,SAAS,GACrC,IAAI,CAQN;AAiED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,GAAE,OAAe,GAAG,YAAY,CAqD1F;AAED;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAgC;IAElE;;OAEG;IACH,MAAM,CAAC,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAItE;;OAEG;IACH,MAAM,CAAC,0BAA0B,CAC/B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACnC,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GAC3D,IAAI;IAiBP;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAI5D;;OAEG;IACH,MAAM,CAAC,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC;IAIlD;;OAEG;IACH,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAGzD;;OAEG;IACH,MAAM,CAAC,OAAO,IAAI,IAAI;IAKtB;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAI1D;;OAEG;IACH,MAAM,CAAC,wBAAwB,IAAI,MAAM,EAAE;CAG5C;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAK5C;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAwB1E"}

package/dist/stored-workflows-B3zZJg8e.js

@@ -0,0 +1,338 @@
+import { n as __exportAll } from "./rolldown-runtime-DuvcJU0W.js";
+import { t as HTTPException } from "./http-exception-CyfxZB6W.js";
+import { n as createRoute } from "./route-builder-CXe0EI1P.js";
+import { handleError } from "./server/handlers/error.js";
+import { z } from "zod/v4";
+//#region src/server/schemas/stored-workflows.ts
+const stepOptionsSchema = z.object({
+	retries: z.number().int().nonnegative().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+}).optional();
+const literalScalar = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+const pathOrLiteral = z.union([z.object({ path: z.string().min(1) }).strict(), z.object({ literal: literalScalar }).strict()]);
+const predicateSchema = z.lazy(() => z.union([
+	z.object({
+		op: z.enum([
+			"eq",
+			"ne",
+			"lt",
+			"lte",
+			"gt",
+			"gte"
+		]),
+		left: pathOrLiteral,
+		right: pathOrLiteral
+	}).strict(),
+	z.object({
+		op: z.enum(["in", "notIn"]),
+		value: pathOrLiteral,
+		set: z.array(literalScalar).min(1)
+	}).strict(),
+	z.object({
+		op: z.enum(["exists", "notExists"]),
+		path: z.string().min(1)
+	}).strict(),
+	z.object({
+		op: z.enum(["truthy", "falsy"]),
+		value: pathOrLiteral
+	}).strict(),
+	z.object({
+		op: z.enum(["and", "or"]),
+		args: z.array(predicateSchema).min(1)
+	}).strict(),
+	z.object({
+		op: z.literal("not"),
+		arg: predicateSchema
+	}).strict()
+]));
+const agentEntrySchema = z.object({
+	type: z.literal("agent"),
+	id: z.string(),
+	agentId: z.string(),
+	description: z.string().optional(),
+	outputSchema: z.record(z.string(), z.unknown()).optional(),
+	options: stepOptionsSchema
+});
+const toolEntrySchema = z.object({
+	type: z.literal("tool"),
+	id: z.string(),
+	toolId: z.string(),
+	description: z.string().optional(),
+	options: stepOptionsSchema
+});
+const mappingEntrySchema = z.object({
+	type: z.literal("mapping"),
+	id: z.string(),
+	mapConfig: z.string()
+});
+const workflowEntrySchema = z.object({
+	type: z.literal("workflow"),
+	id: z.string(),
+	workflowId: z.string(),
+	description: z.string().optional()
+});
+const singleStepEntrySchema = z.discriminatedUnion("type", [
+	agentEntrySchema,
+	toolEntrySchema,
+	mappingEntrySchema,
+	workflowEntrySchema
+]);
+const foreachInnerStepSchema = z.discriminatedUnion("type", [
+	agentEntrySchema,
+	toolEntrySchema,
+	workflowEntrySchema
+]);
+const graphEntrySchema = z.discriminatedUnion("type", [
+	agentEntrySchema,
+	toolEntrySchema,
+	mappingEntrySchema,
+	workflowEntrySchema,
+	z.object({
+		type: z.literal("parallel"),
+		steps: z.array(singleStepEntrySchema)
+	}),
+	z.object({
+		type: z.literal("foreach"),
+		step: foreachInnerStepSchema,
+		opts: z.object({ concurrency: z.number().int().positive() }).optional()
+	}),
+	z.object({
+		type: z.literal("sleep"),
+		id: z.string(),
+		duration: z.number()
+	}),
+	z.object({
+		type: z.literal("sleepUntil"),
+		id: z.string(),
+		date: z.string()
+	}),
+	z.object({
+		type: z.literal("conditional"),
+		steps: z.array(singleStepEntrySchema),
+		predicates: z.array(predicateSchema)
+	}).refine((entry) => entry.predicates.length === entry.steps.length, {
+		message: "conditional entries must have exactly one predicate per branch (`predicates` and `steps` must be the same length)",
+		path: ["predicates"]
+	}),
+	z.object({
+		type: z.literal("loop"),
+		step: singleStepEntrySchema,
+		loopType: z.enum(["dowhile", "dountil"]),
+		predicate: predicateSchema
+	})
+]);
+const storedWorkflowIdPathParams = z.object({ storedWorkflowId: z.string().describe("Unique identifier for the stored workflow definition") });
+const listStoredWorkflowsQuerySchema = z.object({
+	status: z.enum(["active", "archived"]).optional().describe("Filter stored workflows by status (defaults to active when omitted by the handler)"),
+	authorId: z.string().optional().describe("Filter stored workflows by author identifier")
+});
+/**
+* One static workflow definition on the wire. Matches the input shape of
+* `mastra.addStoredWorkflow()`.
+*/
+const storedWorkflowDefinitionBodySchema = z.object({
+	id: z.string().describe("Workflow id — kebab-case, descriptive"),
+	description: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	inputSchema: z.record(z.string(), z.unknown()).describe("JSON Schema (Draft 2020-12) for the workflow input"),
+	outputSchema: z.record(z.string(), z.unknown()).describe("JSON Schema (Draft 2020-12) for the workflow output"),
+	stateSchema: z.record(z.string(), z.unknown()).optional(),
+	requestContextSchema: z.record(z.string(), z.unknown()).optional(),
+	graph: z.array(graphEntrySchema).describe("Static workflow graph — ordered array of serialized step entries with all refs as ids.")
+});
+/**
+* Body for `POST /stored/workflows` — upsert a static workflow definition,
+* optionally together with the helper workflows it nests.
+*/
+const upsertStoredWorkflowBodySchema = storedWorkflowDefinitionBodySchema.extend({ dependencies: z.array(storedWorkflowDefinitionBodySchema).optional().describe("Helper workflow definitions this workflow nests. Saved with it as one unit — the whole set is validated together, hydrated in derived dependency order, and rejected together, so a failed save never leaves orphaned helpers behind. Each helper becomes an ordinary stored workflow in its own right.") });
+/**
+* Shape returned for any single stored workflow row.
+*/
+const storedWorkflowResponseSchema = z.object({
+	id: z.string(),
+	description: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	inputSchema: z.unknown(),
+	outputSchema: z.unknown(),
+	stateSchema: z.unknown().optional(),
+	requestContextSchema: z.unknown().optional(),
+	graph: z.array(z.unknown()),
+	status: z.enum(["active", "archived"]),
+	source: z.literal("storage"),
+	authorId: z.string().optional(),
+	createdAt: z.union([z.date(), z.string()]),
+	updatedAt: z.union([z.date(), z.string()])
+});
+const listStoredWorkflowsResponseSchema = z.object({
+	workflows: z.array(storedWorkflowResponseSchema),
+	total: z.number()
+});
+const getStoredWorkflowResponseSchema = storedWorkflowResponseSchema;
+const upsertStoredWorkflowResponseSchema = z.object({
+	ok: z.literal(true),
+	id: z.string(),
+	dependencyIds: z.array(z.string()).optional().describe("Ids of the helper workflows saved alongside this one. Present only when dependencies were supplied.")
+});
+const deleteStoredWorkflowResponseSchema = z.object({
+	success: z.literal(true),
+	message: z.string()
+});
+//#endregion
+//#region src/server/handlers/stored-workflows.ts
+var stored_workflows_exports = /* @__PURE__ */ __exportAll({
+	DELETE_STORED_WORKFLOW_ROUTE: () => DELETE_STORED_WORKFLOW_ROUTE,
+	GET_STORED_WORKFLOW_ROUTE: () => GET_STORED_WORKFLOW_ROUTE,
+	LIST_STORED_WORKFLOWS_ROUTE: () => LIST_STORED_WORKFLOWS_ROUTE,
+	UPSERT_STORED_WORKFLOW_ROUTE: () => UPSERT_STORED_WORKFLOW_ROUTE
+});
+/**
+* GET /stored/workflows — list stored static workflow definitions.
+*
+* Mirrors `LIST_STORED_AGENTS_ROUTE` but without favorites/visibility/authorship
+* scoping (which the workflow-definitions domain doesn't carry in v1).
+*/
+const LIST_STORED_WORKFLOWS_ROUTE = createRoute({
+	method: "GET",
+	path: "/stored/workflows",
+	responseType: "json",
+	queryParamSchema: listStoredWorkflowsQuerySchema,
+	responseSchema: listStoredWorkflowsResponseSchema,
+	summary: "List stored workflow definitions",
+	description: "Returns workflow definitions persisted to storage. Filterable by status and authorId.",
+	tags: ["Stored Workflows"],
+	requiresAuth: true,
+	requiresPermission: "stored-workflows:read",
+	handler: async ({ mastra, status, authorId }) => {
+		try {
+			const storage = mastra.getStorage();
+			if (!storage) throw new HTTPException(500, { message: "Storage is not configured" });
+			const store = await storage.getStore("workflowDefinitions");
+			if (!store) throw new HTTPException(500, { message: "workflowDefinitions storage domain is not available" });
+			const result = await store.list({
+				status: status ?? "active",
+				authorId
+			});
+			return {
+				workflows: result.definitions,
+				total: result.total
+			};
+		} catch (error) {
+			return handleError(error, "Error listing stored workflows");
+		}
+	}
+});
+/**
+* GET /stored/workflows/:storedWorkflowId — get one stored workflow.
+*/
+const GET_STORED_WORKFLOW_ROUTE = createRoute({
+	method: "GET",
+	path: "/stored/workflows/:storedWorkflowId",
+	responseType: "json",
+	pathParamSchema: storedWorkflowIdPathParams,
+	responseSchema: getStoredWorkflowResponseSchema,
+	summary: "Get a stored workflow definition by id",
+	description: "Returns a single workflow definition persisted to storage.",
+	tags: ["Stored Workflows"],
+	requiresAuth: true,
+	requiresPermission: "stored-workflows:read",
+	handler: async ({ mastra, storedWorkflowId }) => {
+		try {
+			const storage = mastra.getStorage();
+			if (!storage) throw new HTTPException(500, { message: "Storage is not configured" });
+			const store = await storage.getStore("workflowDefinitions");
+			if (!store) throw new HTTPException(500, { message: "workflowDefinitions storage domain is not available" });
+			const def = await store.get(storedWorkflowId);
+			if (!def) throw new HTTPException(404, { message: `Stored workflow "${storedWorkflowId}" not found` });
+			return def;
+		} catch (error) {
+			return handleError(error, "Error getting stored workflow");
+		}
+	}
+});
+/**
+* POST /stored/workflows — upsert a static workflow definition and live-register
+* it on the Mastra instance.
+*
+* Calls `mastra.addStoredWorkflow(def)` which persists the row + rehydrates a
+* runnable workflow + registers it via `mastra.addWorkflow(workflow, id)`.
+* After this returns, `GET /workflows/:id` and `POST /workflows/:id/run` work
+* immediately — no server restart needed.
+*/
+const UPSERT_STORED_WORKFLOW_ROUTE = createRoute({
+	method: "POST",
+	path: "/stored/workflows",
+	responseType: "json",
+	bodySchema: upsertStoredWorkflowBodySchema,
+	responseSchema: upsertStoredWorkflowResponseSchema,
+	summary: "Upsert a stored workflow definition and live-register it",
+	description: "Persists a static workflow definition and live-registers it on the running Mastra instance. Idempotent — same id updates in place.",
+	tags: ["Stored Workflows"],
+	requiresAuth: true,
+	requiresPermission: "stored-workflows:write",
+	handler: async ({ mastra, id, description, metadata, inputSchema, outputSchema, stateSchema, requestContextSchema, graph, dependencies }) => {
+		try {
+			const def = {
+				id,
+				description,
+				metadata,
+				inputSchema,
+				outputSchema,
+				stateSchema,
+				requestContextSchema,
+				graph
+			};
+			const bundle = [...dependencies ?? [], def];
+			await mastra.addStoredWorkflows(bundle);
+			return {
+				ok: true,
+				id: def.id,
+				...dependencies?.length ? { dependencyIds: dependencies.map((dependency) => dependency.id) } : {}
+			};
+		} catch (error) {
+			return handleError(error, "Error upserting stored workflow");
+		}
+	}
+});
+/**
+* DELETE /stored/workflows/:storedWorkflowId — delete a stored workflow.
+*
+* Removes the row from storage AND un-registers the live Workflow instance so
+* a subsequent POST with the same id starts from a clean slate. Idempotent.
+*/
+const DELETE_STORED_WORKFLOW_ROUTE = createRoute({
+	method: "DELETE",
+	path: "/stored/workflows/:storedWorkflowId",
+	responseType: "json",
+	pathParamSchema: storedWorkflowIdPathParams,
+	responseSchema: deleteStoredWorkflowResponseSchema,
+	summary: "Delete a stored workflow definition",
+	description: "Removes a stored workflow definition and unregisters the live workflow instance. Idempotent.",
+	tags: ["Stored Workflows"],
+	requiresAuth: true,
+	requiresPermission: "stored-workflows:write",
+	handler: async ({ mastra, storedWorkflowId }) => {
+		try {
+			const storage = mastra.getStorage();
+			if (!storage) throw new HTTPException(500, { message: "Storage is not configured" });
+			const store = await storage.getStore("workflowDefinitions");
+			if (!store) throw new HTTPException(500, { message: "workflowDefinitions storage domain is not available" });
+			await store.delete(storedWorkflowId);
+			mastra.removeWorkflow(storedWorkflowId);
+			return {
+				success: true,
+				message: `Workflow ${storedWorkflowId} deleted`
+			};
+		} catch (error) {
+			return handleError(error, "Error deleting stored workflow");
+		}
+	}
+});
+//#endregion
+export { stored_workflows_exports as a, UPSERT_STORED_WORKFLOW_ROUTE as i, GET_STORED_WORKFLOW_ROUTE as n, LIST_STORED_WORKFLOWS_ROUTE as r, DELETE_STORED_WORKFLOW_ROUTE as t };
+
+//# sourceMappingURL=stored-workflows-B3zZJg8e.js.map

package/dist/stored-workflows-B3zZJg8e.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-workflows-B3zZJg8e.js","names":[],"sources":["../src/server/schemas/stored-workflows.ts","../src/server/handlers/stored-workflows.ts"],"sourcesContent":["import { z } from 'zod/v4';\n\n// ============================================================================\n// Serialized graph — discriminated union mirroring core's SerializedStepFlowEntry.\n// Duplicated locally rather than imported from @mastra/core/workflows because\n// this file's peer-dependency floor predates that export. Structurally\n// compatible with `Mastra.addStoredWorkflow`'s input; the handler casts once\n// to bridge the remaining wire-vs-runtime divergences (sleepUntil.date as\n// ISO string, fluent-builder-only debug labels) that the core rehydrator\n// handles at runtime.\n// ============================================================================\n\nconst stepOptionsSchema = z\n  .object({\n    retries: z.number().int().nonnegative().optional(),\n    metadata: z.record(z.string(), z.unknown()).optional(),\n  })\n  .optional();\n\n// ----------------------------------------------------------------------------\n// Predicate DSL — declarative condition for `conditional` / `loop` entries.\n// Mirrors `Predicate` in `@mastra/core/workflows/predicate`; duplicated\n// locally for the same peer-floor reason as the graph schema above.\n// ----------------------------------------------------------------------------\nconst literalScalar = z.union([z.string(), z.number(), z.boolean(), z.null()]);\nconst pathOrLiteral: z.ZodType = z.union([\n  z.object({ path: z.string().min(1) }).strict(),\n  z.object({ literal: literalScalar }).strict(),\n]);\nconst predicateSchema: z.ZodType = z.lazy(() =>\n  z.union([\n    z\n      .object({\n        op: z.enum(['eq', 'ne', 'lt', 'lte', 'gt', 'gte']),\n        left: pathOrLiteral,\n        right: pathOrLiteral,\n      })\n      .strict(),\n    z\n      .object({\n        op: z.enum(['in', 'notIn']),\n        value: pathOrLiteral,\n        set: z.array(literalScalar).min(1),\n      })\n      .strict(),\n    z.object({ op: z.enum(['exists', 'notExists']), path: z.string().min(1) }).strict(),\n    z.object({ op: z.enum(['truthy', 'falsy']), value: pathOrLiteral }).strict(),\n    z.object({ op: z.enum(['and', 'or']), args: z.array(predicateSchema).min(1) }).strict(),\n    z.object({ op: z.literal('not'), arg: predicateSchema }).strict(),\n  ]),\n);\n\nconst agentEntrySchema = z.object({\n  type: z.literal('agent'),\n  id: z.string(),\n  agentId: z.string(),\n  description: z.string().optional(),\n  outputSchema: z.record(z.string(), z.unknown()).optional(),\n  options: stepOptionsSchema,\n});\n\nconst toolEntrySchema = z.object({\n  type: z.literal('tool'),\n  id: z.string(),\n  toolId: z.string(),\n  description: z.string().optional(),\n  options: stepOptionsSchema,\n});\n\nconst mappingEntrySchema = z.object({\n  type: z.literal('mapping'),\n  id: z.string(),\n  mapConfig: z.string(),\n});\n\nconst workflowEntrySchema = z.object({\n  type: z.literal('workflow'),\n  id: z.string(),\n  workflowId: z.string(),\n  description: z.string().optional(),\n});\n\nconst singleStepEntrySchema = z.discriminatedUnion('type', [\n  agentEntrySchema,\n  toolEntrySchema,\n  mappingEntrySchema,\n  workflowEntrySchema,\n]);\n\nconst foreachInnerStepSchema = z.discriminatedUnion('type', [agentEntrySchema, toolEntrySchema, workflowEntrySchema]);\n\nconst graphEntrySchema = z.discriminatedUnion('type', [\n  agentEntrySchema,\n  toolEntrySchema,\n  mappingEntrySchema,\n  workflowEntrySchema,\n  z.object({\n    type: z.literal('parallel'),\n    steps: z.array(singleStepEntrySchema),\n  }),\n  z.object({\n    type: z.literal('foreach'),\n    step: foreachInnerStepSchema,\n    opts: z.object({ concurrency: z.number().int().positive() }).optional(),\n  }),\n  z.object({\n    type: z.literal('sleep'),\n    id: z.string(),\n    duration: z.number(),\n  }),\n  z.object({\n    type: z.literal('sleepUntil'),\n    id: z.string(),\n    date: z.string(),\n  }),\n  z\n    .object({\n      // Declarative-only conditional. Inbound stored workflows must ship a\n      // `predicates` array aligned with `steps`; closure-based branches are not\n      // accepted over the wire (they'd be arbitrary JS strings we can't\n      // safely rehydrate).\n      type: z.literal('conditional'),\n      steps: z.array(singleStepEntrySchema),\n      predicates: z.array(predicateSchema),\n    })\n    .refine(entry => entry.predicates.length === entry.steps.length, {\n      message:\n        'conditional entries must have exactly one predicate per branch (`predicates` and `steps` must be the same length)',\n      path: ['predicates'],\n    }),\n  z.object({\n    // Declarative-only loop. Same rationale as `conditional`.\n    type: z.literal('loop'),\n    step: singleStepEntrySchema,\n    loopType: z.enum(['dowhile', 'dountil']),\n    predicate: predicateSchema,\n  }),\n]);\n\n// ============================================================================\n// Path params\n// ============================================================================\n\nexport const storedWorkflowIdPathParams = z.object({\n  storedWorkflowId: z.string().describe('Unique identifier for the stored workflow definition'),\n});\n\n// ============================================================================\n// Query params\n// ============================================================================\n\nexport const listStoredWorkflowsQuerySchema = z.object({\n  status: z\n    .enum(['active', 'archived'])\n    .optional()\n    .describe('Filter stored workflows by status (defaults to active when omitted by the handler)'),\n  authorId: z.string().optional().describe('Filter stored workflows by author identifier'),\n});\n\n// ============================================================================\n// Body schemas\n// ============================================================================\n\n/**\n * One static workflow definition on the wire. Matches the input shape of\n * `mastra.addStoredWorkflow()`.\n */\nexport const storedWorkflowDefinitionBodySchema = z.object({\n  id: z.string().describe('Workflow id — kebab-case, descriptive'),\n  description: z.string().optional(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n  // Schemas are loose object bags by design: different JSON Schema producers\n  // emit slightly different shapes and core's `JsonSchema` type is\n  // `Record<string, any>`. Using `z.record` here aligns with that shape so\n  // no cast is needed at the handler boundary.\n  inputSchema: z.record(z.string(), z.unknown()).describe('JSON Schema (Draft 2020-12) for the workflow input'),\n  outputSchema: z.record(z.string(), z.unknown()).describe('JSON Schema (Draft 2020-12) for the workflow output'),\n  stateSchema: z.record(z.string(), z.unknown()).optional(),\n  requestContextSchema: z.record(z.string(), z.unknown()).optional(),\n  graph: z\n    .array(graphEntrySchema)\n    .describe('Static workflow graph — ordered array of serialized step entries with all refs as ids.'),\n});\n\n/**\n * Body for `POST /stored/workflows` — upsert a static workflow definition,\n * optionally together with the helper workflows it nests.\n */\nexport const upsertStoredWorkflowBodySchema = storedWorkflowDefinitionBodySchema.extend({\n  // Deliberately a FLAT list rather than a recursive tree: helpers are peers\n  // of each other, hydration order is derived from the graphs, and a\n  // self-referential Zod schema would not survive OpenAPI generation.\n  dependencies: z\n    .array(storedWorkflowDefinitionBodySchema)\n    .optional()\n    .describe(\n      'Helper workflow definitions this workflow nests. Saved with it as one unit — the whole set is validated together, ' +\n        'hydrated in derived dependency order, and rejected together, so a failed save never leaves orphaned helpers behind. ' +\n        'Each helper becomes an ordinary stored workflow in its own right.',\n    ),\n});\n\n// ============================================================================\n// Response schemas\n// ============================================================================\n\n/**\n * Shape returned for any single stored workflow row.\n */\nexport const storedWorkflowResponseSchema = z.object({\n  id: z.string(),\n  description: z.string().optional(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n  inputSchema: z.unknown(),\n  outputSchema: z.unknown(),\n  stateSchema: z.unknown().optional(),\n  requestContextSchema: z.unknown().optional(),\n  graph: z.array(z.unknown()),\n  status: z.enum(['active', 'archived']),\n  source: z.literal('storage'),\n  authorId: z.string().optional(),\n  createdAt: z.union([z.date(), z.string()]),\n  updatedAt: z.union([z.date(), z.string()]),\n});\n\nexport const listStoredWorkflowsResponseSchema = z.object({\n  workflows: z.array(storedWorkflowResponseSchema),\n  total: z.number(),\n});\n\nexport const getStoredWorkflowResponseSchema = storedWorkflowResponseSchema;\n\nexport const upsertStoredWorkflowResponseSchema = z.object({\n  ok: z.literal(true),\n  id: z.string(),\n  dependencyIds: z\n    .array(z.string())\n    .optional()\n    .describe('Ids of the helper workflows saved alongside this one. Present only when dependencies were supplied.'),\n});\n\nexport const deleteStoredWorkflowResponseSchema = z.object({\n  success: z.literal(true),\n  message: z.string(),\n});\n","import type { Mastra } from '@mastra/core/mastra';\n\nimport { HTTPException } from '../http-exception';\nimport {\n  storedWorkflowIdPathParams,\n  listStoredWorkflowsQuerySchema,\n  upsertStoredWorkflowBodySchema,\n  listStoredWorkflowsResponseSchema,\n  getStoredWorkflowResponseSchema,\n  upsertStoredWorkflowResponseSchema,\n  deleteStoredWorkflowResponseSchema,\n} from '../schemas/stored-workflows';\nimport { createRoute } from '../server-adapter/routes/route-builder';\n\nimport { handleError } from './error';\n\n/**\n * GET /stored/workflows — list stored static workflow definitions.\n *\n * Mirrors `LIST_STORED_AGENTS_ROUTE` but without favorites/visibility/authorship\n * scoping (which the workflow-definitions domain doesn't carry in v1).\n */\nexport const LIST_STORED_WORKFLOWS_ROUTE = createRoute({\n  method: 'GET',\n  path: '/stored/workflows',\n  responseType: 'json',\n  queryParamSchema: listStoredWorkflowsQuerySchema,\n  responseSchema: listStoredWorkflowsResponseSchema,\n  summary: 'List stored workflow definitions',\n  description: 'Returns workflow definitions persisted to storage. Filterable by status and authorId.',\n  tags: ['Stored Workflows'],\n  requiresAuth: true,\n  requiresPermission: 'stored-workflows:read',\n  handler: async ({ mastra, status, authorId }) => {\n    try {\n      const storage = mastra.getStorage();\n      if (!storage) throw new HTTPException(500, { message: 'Storage is not configured' });\n\n      const store = await storage.getStore('workflowDefinitions');\n      if (!store) throw new HTTPException(500, { message: 'workflowDefinitions storage domain is not available' });\n\n      const result = await store.list({ status: status ?? 'active', authorId });\n      return { workflows: result.definitions, total: result.total };\n    } catch (error) {\n      return handleError(error, 'Error listing stored workflows');\n    }\n  },\n});\n\n/**\n * GET /stored/workflows/:storedWorkflowId — get one stored workflow.\n */\nexport const GET_STORED_WORKFLOW_ROUTE = createRoute({\n  method: 'GET',\n  path: '/stored/workflows/:storedWorkflowId',\n  responseType: 'json',\n  pathParamSchema: storedWorkflowIdPathParams,\n  responseSchema: getStoredWorkflowResponseSchema,\n  summary: 'Get a stored workflow definition by id',\n  description: 'Returns a single workflow definition persisted to storage.',\n  tags: ['Stored Workflows'],\n  requiresAuth: true,\n  requiresPermission: 'stored-workflows:read',\n  handler: async ({ mastra, storedWorkflowId }) => {\n    try {\n      const storage = mastra.getStorage();\n      if (!storage) throw new HTTPException(500, { message: 'Storage is not configured' });\n\n      const store = await storage.getStore('workflowDefinitions');\n      if (!store) throw new HTTPException(500, { message: 'workflowDefinitions storage domain is not available' });\n\n      const def = await store.get(storedWorkflowId);\n      if (!def) throw new HTTPException(404, { message: `Stored workflow \"${storedWorkflowId}\" not found` });\n      return def;\n    } catch (error) {\n      return handleError(error, 'Error getting stored workflow');\n    }\n  },\n});\n\n/**\n * POST /stored/workflows — upsert a static workflow definition and live-register\n * it on the Mastra instance.\n *\n * Calls `mastra.addStoredWorkflow(def)` which persists the row + rehydrates a\n * runnable workflow + registers it via `mastra.addWorkflow(workflow, id)`.\n * After this returns, `GET /workflows/:id` and `POST /workflows/:id/run` work\n * immediately — no server restart needed.\n */\nexport const UPSERT_STORED_WORKFLOW_ROUTE = createRoute({\n  method: 'POST',\n  path: '/stored/workflows',\n  responseType: 'json',\n  bodySchema: upsertStoredWorkflowBodySchema,\n  responseSchema: upsertStoredWorkflowResponseSchema,\n  summary: 'Upsert a stored workflow definition and live-register it',\n  description:\n    'Persists a static workflow definition and live-registers it on the running Mastra instance. Idempotent — same id updates in place.',\n  tags: ['Stored Workflows'],\n  requiresAuth: true,\n  requiresPermission: 'stored-workflows:write',\n  handler: async ({\n    mastra,\n    id,\n    description,\n    metadata,\n    inputSchema,\n    outputSchema,\n    stateSchema,\n    requestContextSchema,\n    graph,\n    dependencies,\n  }) => {\n    try {\n      // Pick the body fields explicitly — handler args also carry server\n      // context (requestContext, abortSignal, ...) which must not leak into\n      // the stored definition.\n      const def = { id, description, metadata, inputSchema, outputSchema, stateSchema, requestContextSchema, graph };\n      // Helpers are saved with the root as one unit so a nested workflow that\n      // does not exist yet resolves, and so a rejected root can never leave\n      // its helpers behind as orphans. Order within the bundle is derived\n      // from the graphs, not from the order the client sent them in.\n      const bundle = [...(dependencies ?? []), def];\n      // The Zod schema output is structurally compatible with\n      // StoredWorkflowGraph but TS can't prove every arm:\n      //   - sleepUntil.date is an ISO string on the wire, Date on the\n      //     runtime type; the rehydrator parses it via `new Date(...)`.\n      //   - conditional/loop's `serializedConditions`/`serializedCondition`\n      //     debug labels are emitted by the fluent builder at rehydration\n      //     time; clients don't send them.\n      // `addStoredWorkflows` runs a full registry pre-flight before\n      // rehydration; the cast documents this boundary.\n      await mastra.addStoredWorkflows(bundle as Parameters<Mastra['addStoredWorkflows']>[0]);\n      return {\n        ok: true as const,\n        id: def.id,\n        ...(dependencies?.length ? { dependencyIds: dependencies.map(dependency => dependency.id) } : {}),\n      };\n    } catch (error) {\n      return handleError(error, 'Error upserting stored workflow');\n    }\n  },\n});\n\n/**\n * DELETE /stored/workflows/:storedWorkflowId — delete a stored workflow.\n *\n * Removes the row from storage AND un-registers the live Workflow instance so\n * a subsequent POST with the same id starts from a clean slate. Idempotent.\n */\nexport const DELETE_STORED_WORKFLOW_ROUTE = createRoute({\n  method: 'DELETE',\n  path: '/stored/workflows/:storedWorkflowId',\n  responseType: 'json',\n  pathParamSchema: storedWorkflowIdPathParams,\n  responseSchema: deleteStoredWorkflowResponseSchema,\n  summary: 'Delete a stored workflow definition',\n  description: 'Removes a stored workflow definition and unregisters the live workflow instance. Idempotent.',\n  tags: ['Stored Workflows'],\n  requiresAuth: true,\n  requiresPermission: 'stored-workflows:write',\n  handler: async ({ mastra, storedWorkflowId }) => {\n    try {\n      const storage = mastra.getStorage();\n      if (!storage) throw new HTTPException(500, { message: 'Storage is not configured' });\n\n      const store = await storage.getStore('workflowDefinitions');\n      if (!store) throw new HTTPException(500, { message: 'workflowDefinitions storage domain is not available' });\n\n      await store.delete(storedWorkflowId);\n      (mastra as Mastra).removeWorkflow(storedWorkflowId);\n      return { success: true as const, message: `Workflow ${storedWorkflowId} deleted` };\n    } catch (error) {\n      return handleError(error, 'Error deleting stored workflow');\n    }\n  },\n});\n"],"mappings":";;;;;;AAYA,MAAM,oBAAoB,EACvB,OAAO;CACN,SAAS,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS;CACjD,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS;AACvD,CAAC,CAAC,CACD,SAAS;AAOZ,MAAM,gBAAgB,EAAE,MAAM;CAAC,EAAE,OAAO;CAAG,EAAE,OAAO;CAAG,EAAE,QAAQ;CAAG,EAAE,KAAK;AAAC,CAAC;AAC7E,MAAM,gBAA2B,EAAE,MAAM,CACvC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,GAC7C,EAAE,OAAO,EAAE,SAAS,cAAc,CAAC,CAAC,CAAC,OAAO,CAC9C,CAAC;AACD,MAAM,kBAA6B,EAAE,WACnC,EAAE,MAAM;CACN,EACG,OAAO;EACN,IAAI,EAAE,KAAK;GAAC;GAAM;GAAM;GAAM;GAAO;GAAM;EAAK,CAAC;EACjD,MAAM;EACN,OAAO;CACT,CAAC,CAAC,CACD,OAAO;CACV,EACG,OAAO;EACN,IAAI,EAAE,KAAK,CAAC,MAAM,OAAO,CAAC;EAC1B,OAAO;EACP,KAAK,EAAE,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC;CACnC,CAAC,CAAC,CACD,OAAO;CACV,EAAE,OAAO;EAAE,IAAI,EAAE,KAAK,CAAC,UAAU,WAAW,CAAC;EAAG,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CAAE,CAAC,CAAC,CAAC,OAAO;CAClF,EAAE,OAAO;EAAE,IAAI,EAAE,KAAK,CAAC,UAAU,OAAO,CAAC;EAAG,OAAO;CAAc,CAAC,CAAC,CAAC,OAAO;CAC3E,EAAE,OAAO;EAAE,IAAI,EAAE,KAAK,CAAC,OAAO,IAAI,CAAC;EAAG,MAAM,EAAE,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC;CAAE,CAAC,CAAC,CAAC,OAAO;CACtF,EAAE,OAAO;EAAE,IAAI,EAAE,QAAQ,KAAK;EAAG,KAAK;CAAgB,CAAC,CAAC,CAAC,OAAO;AAClE,CAAC,CACH;AAEA,MAAM,mBAAmB,EAAE,OAAO;CAChC,MAAM,EAAE,QAAQ,OAAO;CACvB,IAAI,EAAE,OAAO;CACb,SAAS,EAAE,OAAO;CAClB,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;CACjC,cAAc,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS;CACzD,SAAS;AACX,CAAC;AAED,MAAM,kBAAkB,EAAE,OAAO;CAC/B,MAAM,EAAE,QAAQ,MAAM;CACtB,IAAI,EAAE,OAAO;CACb,QAAQ,EAAE,OAAO;CACjB,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;CACjC,SAAS;AACX,CAAC;AAED,MAAM,qBAAqB,EAAE,OAAO;CAClC,MAAM,EAAE,QAAQ,SAAS;CACzB,IAAI,EAAE,OAAO;CACb,WAAW,EAAE,OAAO;AACtB,CAAC;AAED,MAAM,sBAAsB,EAAE,OAAO;CACnC,MAAM,EAAE,QAAQ,UAAU;CAC1B,IAAI,EAAE,OAAO;CACb,YAAY,EAAE,OAAO;CACrB,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;AACnC,CAAC;AAED,MAAM,wBAAwB,EAAE,mBAAmB,QAAQ;CACzD;CACA;CACA;CACA;AACF,CAAC;AAED,MAAM,yBAAyB,EAAE,mBAAmB,QAAQ;CAAC;CAAkB;CAAiB;AAAmB,CAAC;AAEpH,MAAM,mBAAmB,EAAE,mBAAmB,QAAQ;CACpD;CACA;CACA;CACA;CACA,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,UAAU;EAC1B,OAAO,EAAE,MAAM,qBAAqB;CACtC,CAAC;CACD,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,SAAS;EACzB,MAAM;EACN,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,SAAS;CACxE,CAAC;CACD,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,OAAO;EACvB,IAAI,EAAE,OAAO;EACb,UAAU,EAAE,OAAO;CACrB,CAAC;CACD,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,YAAY;EAC5B,IAAI,EAAE,OAAO;EACb,MAAM,EAAE,OAAO;CACjB,CAAC;CACD,EACG,OAAO;EAKN,MAAM,EAAE,QAAQ,aAAa;EAC7B,OAAO,EAAE,MAAM,qBAAqB;EACpC,YAAY,EAAE,MAAM,eAAe;CACrC,CAAC,CAAC,CACD,QAAO,UAAS,MAAM,WAAW,WAAW,MAAM,MAAM,QAAQ;EAC/D,SACE;EACF,MAAM,CAAC,YAAY;CACrB,CAAC;CACH,EAAE,OAAO;EAEP,MAAM,EAAE,QAAQ,MAAM;EACtB,MAAM;EACN,UAAU,EAAE,KAAK,CAAC,WAAW,SAAS,CAAC;EACvC,WAAW;CACb,CAAC;AACH,CAAC;AAMD,MAAa,6BAA6B,EAAE,OAAO,EACjD,kBAAkB,EAAE,OAAO,CAAC,CAAC,SAAS,sDAAsD,EAC9F,CAAC;AAMD,MAAa,iCAAiC,EAAE,OAAO;CACrD,QAAQ,EACL,KAAK,CAAC,UAAU,UAAU,CAAC,CAAC,CAC5B,SAAS,CAAC,CACV,SAAS,oFAAoF;CAChG,UAAU,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,8CAA8C;AACzF,CAAC;;;;;AAUD,MAAa,qCAAqC,EAAE,OAAO;CACzD,IAAI,EAAE,OAAO,CAAC,CAAC,SAAS,uCAAuC;CAC/D,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;CACjC,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS;CAKrD,aAAa,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS,oDAAoD;CAC5G,cAAc,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS,qDAAqD;CAC9G,aAAa,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS;CACxD,sBAAsB,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS;CACjE,OAAO,EACJ,MAAM,gBAAgB,CAAC,CACvB,SAAS,wFAAwF;AACtG,CAAC;;;;;AAMD,MAAa,iCAAiC,mCAAmC,OAAO,EAItF,cAAc,EACX,MAAM,kCAAkC,CAAC,CACzC,SAAS,CAAC,CACV,SACC,ySAGF,EACJ,CAAC;;;;AASD,MAAa,+BAA+B,EAAE,OAAO;CACnD,IAAI,EAAE,OAAO;CACb,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;CACjC,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS;CACrD,aAAa,EAAE,QAAQ;CACvB,cAAc,EAAE,QAAQ;CACxB,aAAa,EAAE,QAAQ,CAAC,CAAC,SAAS;CAClC,sBAAsB,EAAE,QAAQ,CAAC,CAAC,SAAS;CAC3C,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC;CAC1B,QAAQ,EAAE,KAAK,CAAC,UAAU,UAAU,CAAC;CACrC,QAAQ,EAAE,QAAQ,SAAS;CAC3B,UAAU,EAAE,OAAO,CAAC,CAAC,SAAS;CAC9B,WAAW,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,EAAE,OAAO,CAAC,CAAC;CACzC,WAAW,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,EAAE,OAAO,CAAC,CAAC;AAC3C,CAAC;AAED,MAAa,oCAAoC,EAAE,OAAO;CACxD,WAAW,EAAE,MAAM,4BAA4B;CAC/C,OAAO,EAAE,OAAO;AAClB,CAAC;AAED,MAAa,kCAAkC;AAE/C,MAAa,qCAAqC,EAAE,OAAO;CACzD,IAAI,EAAE,QAAQ,IAAI;CAClB,IAAI,EAAE,OAAO;CACb,eAAe,EACZ,MAAM,EAAE,OAAO,CAAC,CAAC,CACjB,SAAS,CAAC,CACV,SAAS,qGAAqG;AACnH,CAAC;AAED,MAAa,qCAAqC,EAAE,OAAO;CACzD,SAAS,EAAE,QAAQ,IAAI;CACvB,SAAS,EAAE,OAAO;AACpB,CAAC;;;;;;;;;;;;;;;AC9ND,MAAa,8BAA8B,YAAY;CACrD,QAAQ;CACR,MAAM;CACN,cAAc;CACd,kBAAkB;CAClB,gBAAgB;CAChB,SAAS;CACT,aAAa;CACb,MAAM,CAAC,kBAAkB;CACzB,cAAc;CACd,oBAAoB;CACpB,SAAS,OAAO,EAAE,QAAQ,QAAQ,eAAe;EAC/C,IAAI;GACF,MAAM,UAAU,OAAO,WAAW;GAClC,IAAI,CAAC,SAAS,MAAM,IAAI,cAAc,KAAK,EAAE,SAAS,4BAA4B,CAAC;GAEnF,MAAM,QAAQ,MAAM,QAAQ,SAAS,qBAAqB;GAC1D,IAAI,CAAC,OAAO,MAAM,IAAI,cAAc,KAAK,EAAE,SAAS,sDAAsD,CAAC;GAE3G,MAAM,SAAS,MAAM,MAAM,KAAK;IAAE,QAAQ,UAAU;IAAU;GAAS,CAAC;GACxE,OAAO;IAAE,WAAW,OAAO;IAAa,OAAO,OAAO;GAAM;EAC9D,SAAS,OAAO;GACd,OAAO,YAAY,OAAO,gCAAgC;EAC5D;CACF;AACF,CAAC;;;;AAKD,MAAa,4BAA4B,YAAY;CACnD,QAAQ;CACR,MAAM;CACN,cAAc;CACd,iBAAiB;CACjB,gBAAgB;CAChB,SAAS;CACT,aAAa;CACb,MAAM,CAAC,kBAAkB;CACzB,cAAc;CACd,oBAAoB;CACpB,SAAS,OAAO,EAAE,QAAQ,uBAAuB;EAC/C,IAAI;GACF,MAAM,UAAU,OAAO,WAAW;GAClC,IAAI,CAAC,SAAS,MAAM,IAAI,cAAc,KAAK,EAAE,SAAS,4BAA4B,CAAC;GAEnF,MAAM,QAAQ,MAAM,QAAQ,SAAS,qBAAqB;GAC1D,IAAI,CAAC,OAAO,MAAM,IAAI,cAAc,KAAK,EAAE,SAAS,sDAAsD,CAAC;GAE3G,MAAM,MAAM,MAAM,MAAM,IAAI,gBAAgB;GAC5C,IAAI,CAAC,KAAK,MAAM,IAAI,cAAc,KAAK,EAAE,SAAS,oBAAoB,iBAAiB,aAAa,CAAC;GACrG,OAAO;EACT,SAAS,OAAO;GACd,OAAO,YAAY,OAAO,+BAA+B;EAC3D;CACF;AACF,CAAC;;;;;;;;;;AAWD,MAAa,+BAA+B,YAAY;CACtD,QAAQ;CACR,MAAM;CACN,cAAc;CACd,YAAY;CACZ,gBAAgB;CAChB,SAAS;CACT,aACE;CACF,MAAM,CAAC,kBAAkB;CACzB,cAAc;CACd,oBAAoB;CACpB,SAAS,OAAO,EACd,QACA,IACA,aACA,UACA,aACA,cACA,aACA,sBACA,OACA,mBACI;EACJ,IAAI;GAIF,MAAM,MAAM;IAAE;IAAI;IAAa;IAAU;IAAa;IAAc;IAAa;IAAsB;GAAM;GAK7G,MAAM,SAAS,CAAC,GAAI,gBAAgB,CAAC,GAAI,GAAG;GAU5C,MAAM,OAAO,mBAAmB,MAAqD;GACrF,OAAO;IACL,IAAI;IACJ,IAAI,IAAI;IACR,GAAI,cAAc,SAAS,EAAE,eAAe,aAAa,KAAI,eAAc,WAAW,EAAE,EAAE,IAAI,CAAC;GACjG;EACF,SAAS,OAAO;GACd,OAAO,YAAY,OAAO,iCAAiC;EAC7D;CACF;AACF,CAAC;;;;;;;AAQD,MAAa,+BAA+B,YAAY;CACtD,QAAQ;CACR,MAAM;CACN,cAAc;CACd,iBAAiB;CACjB,gBAAgB;CAChB,SAAS;CACT,aAAa;CACb,MAAM,CAAC,kBAAkB;CACzB,cAAc;CACd,oBAAoB;CACpB,SAAS,OAAO,EAAE,QAAQ,uBAAuB;EAC/C,IAAI;GACF,MAAM,UAAU,OAAO,WAAW;GAClC,IAAI,CAAC,SAAS,MAAM,IAAI,cAAc,KAAK,EAAE,SAAS,4BAA4B,CAAC;GAEnF,MAAM,QAAQ,MAAM,QAAQ,SAAS,qBAAqB;GAC1D,IAAI,CAAC,OAAO,MAAM,IAAI,cAAc,KAAK,EAAE,SAAS,sDAAsD,CAAC;GAE3G,MAAM,MAAM,OAAO,gBAAgB;GACnC,OAAmB,eAAe,gBAAgB;GAClD,OAAO;IAAE,SAAS;IAAe,SAAS,YAAY,iBAAiB;GAAU;EACnF,SAAS,OAAO;GACd,OAAO,YAAY,OAAO,gCAAgC;EAC5D;CACF;AACF,CAAC"}