@oisincoveney/pipeline 3.24.2 → 3.24.3

package/dist/argo-workflow.d.ts

@@ -1,186 +1,166 @@
 import { WorkflowExecutionPlan } from "./planning/compile.js";
 import { buildDynamicRunnerArgoWorkflowOptionsSchema, buildRunnerArgoWorkflowOptionsSchema } from "./remote/argo/model.js";
-import { z } from "zod";
 
 //#region src/argo-workflow.d.ts
-declare const runnerArgoWorkflowManifestSchema: z.ZodObject<{
-  apiVersion: z.ZodLiteral<"argoproj.io/v1alpha1">;
-  kind: z.ZodLiteral<"Workflow">;
-  metadata: z.ZodObject<{
-    annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    generateName: z.ZodOptional<z.ZodString>;
-    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    name: z.ZodOptional<z.ZodString>;
-    namespace: z.ZodString;
-  }, z.core.$strict>;
-  spec: z.ZodObject<{
-    activeDeadlineSeconds: z.ZodOptional<z.ZodNumber>;
-    entrypoint: z.ZodLiteral<"pipeline">;
-    imagePullSecrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
-      name: z.ZodString;
-    }, z.core.$strict>>>;
-    podMetadata: z.ZodOptional<z.ZodObject<{
-      labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    }, z.core.$strict>>;
-    serviceAccountName: z.ZodString;
-    onExit: z.ZodOptional<z.ZodString>;
-    templates: z.ZodArray<z.ZodObject<{
-      container: z.ZodOptional<z.ZodObject<{
-        args: z.ZodArray<z.ZodString>;
-        command: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        env: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-          name: z.ZodString;
-          value: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-          name: z.ZodString;
-          valueFrom: z.ZodObject<{
-            secretKeyRef: z.ZodObject<{
-              key: z.ZodString;
-              name: z.ZodString;
-            }, z.core.$strict>;
-          }, z.core.$strict>;
-        }, z.core.$strict>]>>>;
-        image: z.ZodString;
-        imagePullPolicy: z.ZodEnum<{
-          Always: "Always";
-          IfNotPresent: "IfNotPresent";
-          Never: "Never";
-        }>;
-        name: z.ZodOptional<z.ZodString>;
-        resources: z.ZodOptional<z.ZodObject<{
-          limits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-          requests: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        }, z.core.$strict>>;
-        volumeMounts: z.ZodArray<z.ZodObject<{
-          mountPath: z.ZodString;
-          name: z.ZodString;
-          readOnly: z.ZodOptional<z.ZodBoolean>;
-          subPath: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-      }, z.core.$strict>>;
-      dag: z.ZodOptional<z.ZodObject<{
-        tasks: z.ZodArray<z.ZodObject<{
-          arguments: z.ZodOptional<z.ZodObject<{
-            artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-              from: z.ZodOptional<z.ZodString>;
-              name: z.ZodString;
-              path: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>>;
-            parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
-              name: z.ZodString;
-              value: z.ZodString;
-            }, z.core.$strict>>>;
-          }, z.core.$strict>>;
-          dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
-          name: z.ZodString;
-          template: z.ZodString;
-          when: z.ZodOptional<z.ZodString>;
-          withParam: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-      }, z.core.$strict>>;
-      inputs: z.ZodOptional<z.ZodObject<{
-        artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-          from: z.ZodOptional<z.ZodString>;
-          name: z.ZodString;
-          path: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>>;
-        parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
-          name: z.ZodString;
-        }, z.core.$strict>>>;
-      }, z.core.$strict>>;
-      outputs: z.ZodOptional<z.ZodObject<{
-        artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-          from: z.ZodOptional<z.ZodString>;
-          name: z.ZodString;
-          path: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>>;
-        parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
-          name: z.ZodString;
-          valueFrom: z.ZodObject<{
-            path: z.ZodString;
-          }, z.core.$strict>;
-        }, z.core.$strict>>>;
-      }, z.core.$strict>>;
-      steps: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
-        arguments: z.ZodOptional<z.ZodObject<{
-          parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            value: z.ZodString;
-          }, z.core.$strict>>>;
-        }, z.core.$strict>>;
-        name: z.ZodString;
-        template: z.ZodString;
-        when: z.ZodOptional<z.ZodString>;
-        withParam: z.ZodOptional<z.ZodString>;
-      }, z.core.$strict>>>>;
-      activeDeadlineSeconds: z.ZodOptional<z.ZodNumber>;
-      name: z.ZodString;
-      retryStrategy: z.ZodOptional<z.ZodObject<{
-        expression: z.ZodOptional<z.ZodString>;
-        limit: z.ZodOptional<z.ZodString>;
-        retryPolicy: z.ZodEnum<{
-          Always: "Always";
-          OnError: "OnError";
-          OnFailure: "OnFailure";
-          OnTransientError: "OnTransientError";
-        }>;
-      }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    podGC: z.ZodOptional<z.ZodObject<{
-      deleteDelayDuration: z.ZodOptional<z.ZodString>;
-      labelSelector: z.ZodOptional<z.ZodObject<{
-        matchExpressions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-          key: z.ZodString;
-          operator: z.ZodEnum<{
-            DoesNotExist: "DoesNotExist";
-            Exists: "Exists";
-            In: "In";
-            NotIn: "NotIn";
+declare const runnerArgoWorkflowManifestSchema: import("effect/Schema").Struct<{
+  readonly apiVersion: import("effect/Schema").Literal<"argoproj.io/v1alpha1">;
+  readonly kind: import("effect/Schema").Literal<"Workflow">;
+  readonly metadata: import("effect/Schema").Struct<{
+    readonly annotations: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+    readonly generateName: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+    readonly labels: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").NonEmptyString, import("effect/Schema").NonEmptyString>>;
+    readonly name: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+    readonly namespace: import("effect/Schema").NonEmptyString;
+  }>;
+  readonly spec: import("effect/Schema").Struct<{
+    readonly activeDeadlineSeconds: import("effect/Schema").optional<import("effect/Schema").Number>;
+    readonly entrypoint: import("effect/Schema").Literal<"pipeline">;
+    readonly imagePullSecrets: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+      readonly name: import("effect/Schema").NonEmptyString;
+    }>>>>;
+    readonly onExit: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+    readonly podGC: import("effect/Schema").optional<import("effect/Schema").Struct<{
+      readonly deleteDelayDuration: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+      readonly labelSelector: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly matchExpressions: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+          readonly key: import("effect/Schema").NonEmptyString;
+          readonly operator: import("effect/Schema").Literals<readonly ["In", "NotIn", "Exists", "DoesNotExist"]>;
+          readonly values: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").String>>>;
+        }>>>>;
+        readonly matchLabels: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").NonEmptyString, import("effect/Schema").String>>;
+      }>>;
+      readonly strategy: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["OnPodCompletion", "OnPodSuccess", "OnWorkflowCompletion", "OnWorkflowSuccess"]>>;
+    }>>;
+    readonly podMetadata: import("effect/Schema").optional<import("effect/Schema").Struct<{
+      readonly labels: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").NonEmptyString, import("effect/Schema").NonEmptyString>>;
+    }>>;
+    readonly serviceAccountName: import("effect/Schema").NonEmptyString;
+    readonly templates: import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+      readonly activeDeadlineSeconds: import("effect/Schema").optional<import("effect/Schema").Number>;
+      readonly container: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly args: import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").NonEmptyString>>;
+        readonly command: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").NonEmptyString>>>;
+        readonly env: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+          readonly name: import("effect/Schema").NonEmptyString;
+          readonly value: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+          readonly name: import("effect/Schema").NonEmptyString;
+          readonly valueFrom: import("effect/Schema").Struct<{
+            readonly secretKeyRef: import("effect/Schema").Struct<{
+              readonly key: import("effect/Schema").NonEmptyString;
+              readonly name: import("effect/Schema").NonEmptyString;
+            }>;
+          }>;
+        }>]>>>>;
+        readonly image: import("effect/Schema").NonEmptyString;
+        readonly imagePullPolicy: import("effect/Schema").Literals<readonly ["Always", "IfNotPresent", "Never"]>;
+        readonly name: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+        readonly resources: import("effect/Schema").optional<import("effect/Schema").Struct<{
+          readonly limits: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+          readonly requests: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>;
+        }>>;
+        readonly volumeMounts: import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+          readonly mountPath: import("effect/Schema").NonEmptyString;
+          readonly name: import("effect/Schema").NonEmptyString;
+          readonly readOnly: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+          readonly subPath: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+        }>>>;
+      }>>;
+      readonly dag: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly tasks: import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+          readonly arguments: import("effect/Schema").optional<import("effect/Schema").Struct<{
+            readonly artifacts: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+              readonly from: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+              readonly name: import("effect/Schema").NonEmptyString;
+              readonly path: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+            }>>>>;
+            readonly parameters: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+              readonly name: import("effect/Schema").NonEmptyString;
+              readonly value: import("effect/Schema").String;
+            }>>>>;
+          }>>;
+          readonly dependencies: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").NonEmptyString>>>;
+          readonly name: import("effect/Schema").NonEmptyString;
+          readonly template: import("effect/Schema").NonEmptyString;
+          readonly when: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+          readonly withParam: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+        }>>>;
+      }>>;
+      readonly inputs: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly artifacts: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+          readonly from: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+          readonly name: import("effect/Schema").NonEmptyString;
+          readonly path: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+        }>>>>;
+        readonly parameters: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+          readonly name: import("effect/Schema").NonEmptyString;
+        }>>>>;
+      }>>;
+      readonly name: import("effect/Schema").NonEmptyString;
+      readonly outputs: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly artifacts: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+          readonly from: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+          readonly name: import("effect/Schema").NonEmptyString;
+          readonly path: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+        }>>>>;
+        readonly parameters: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+          readonly name: import("effect/Schema").NonEmptyString;
+          readonly valueFrom: import("effect/Schema").Struct<{
+            readonly path: import("effect/Schema").NonEmptyString;
           }>;
-          values: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>>;
-        matchLabels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-      }, z.core.$strict>>;
-      strategy: z.ZodOptional<z.ZodEnum<{
-        OnPodCompletion: "OnPodCompletion";
-        OnPodSuccess: "OnPodSuccess";
-        OnWorkflowCompletion: "OnWorkflowCompletion";
-        OnWorkflowSuccess: "OnWorkflowSuccess";
+        }>>>>;
+      }>>;
+      readonly retryStrategy: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly expression: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+        readonly limit: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+        readonly retryPolicy: import("effect/Schema").Literals<readonly ["Always", "OnError", "OnFailure", "OnTransientError"]>;
+      }>>;
+      readonly steps: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly arguments: import("effect/Schema").optional<import("effect/Schema").Struct<{
+          readonly parameters: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly name: import("effect/Schema").NonEmptyString;
+            readonly value: import("effect/Schema").String;
+          }>>>>;
+        }>>;
+        readonly name: import("effect/Schema").NonEmptyString;
+        readonly template: import("effect/Schema").NonEmptyString;
+        readonly when: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+        readonly withParam: import("effect/Schema").optional<import("effect/Schema").NonEmptyString>;
+      }>>>>>>;
+    }>>>;
+    readonly ttlStrategy: import("effect/Schema").optional<import("effect/Schema").Struct<{
+      readonly secondsAfterCompletion: import("effect/Schema").optional<import("effect/Schema").Number>;
+      readonly secondsAfterFailure: import("effect/Schema").optional<import("effect/Schema").Number>;
+      readonly secondsAfterSuccess: import("effect/Schema").optional<import("effect/Schema").Number>;
+    }>>;
+    readonly volumes: import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+      readonly configMap: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly items: import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+          readonly key: import("effect/Schema").NonEmptyString;
+          readonly path: import("effect/Schema").NonEmptyString;
+        }>>>;
+        readonly name: import("effect/Schema").NonEmptyString;
+      }>>;
+      readonly name: import("effect/Schema").NonEmptyString;
+      readonly secret: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly defaultMode: import("effect/Schema").optional<import("effect/Schema").Number>;
+        readonly items: import("effect/Schema").optional<import("effect/Schema").mutable<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+          readonly key: import("effect/Schema").NonEmptyString;
+          readonly path: import("effect/Schema").NonEmptyString;
+        }>>>>;
+        readonly optional: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+        readonly secretName: import("effect/Schema").NonEmptyString;
       }>>;
-    }, z.core.$strict>>;
-    ttlStrategy: z.ZodOptional<z.ZodObject<{
-      secondsAfterCompletion: z.ZodOptional<z.ZodNumber>;
-      secondsAfterFailure: z.ZodOptional<z.ZodNumber>;
-      secondsAfterSuccess: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>;
-    volumes: z.ZodArray<z.ZodObject<{
-      configMap: z.ZodOptional<z.ZodObject<{
-        items: z.ZodArray<z.ZodObject<{
-          key: z.ZodString;
-          path: z.ZodString;
-        }, z.core.$strict>>;
-        name: z.ZodString;
-      }, z.core.$strict>>;
-      name: z.ZodString;
-      secret: z.ZodOptional<z.ZodObject<{
-        defaultMode: z.ZodOptional<z.ZodNumber>;
-        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
-          key: z.ZodString;
-          path: z.ZodString;
-        }, z.core.$strict>>>;
-        optional: z.ZodOptional<z.ZodBoolean>;
-        secretName: z.ZodString;
-      }, z.core.$strict>>;
-    }, z.core.$strict>>;
-  }, z.core.$strict>;
-}, z.core.$strict>;
-type ArgoWorkflowManifest = z.infer<typeof runnerArgoWorkflowManifestSchema>;
-type BuildRunnerArgoWorkflowOptions = z.input<typeof buildRunnerArgoWorkflowOptionsSchema> & {
+    }>>>;
+  }>;
+}>;
+type ArgoWorkflowManifest = typeof runnerArgoWorkflowManifestSchema.Type;
+type BuildRunnerArgoWorkflowOptions = typeof buildRunnerArgoWorkflowOptionsSchema.Encoded & {
   plan: WorkflowExecutionPlan;
 };
-type BuildDynamicRunnerArgoWorkflowOptions = z.input<typeof buildDynamicRunnerArgoWorkflowOptionsSchema>;
-declare function buildRunnerArgoWorkflowManifest(rawOptions: BuildRunnerArgoWorkflowOptions): ArgoWorkflowManifest;
-declare function buildDynamicRunnerArgoWorkflowManifest(rawOptions: BuildDynamicRunnerArgoWorkflowOptions): ArgoWorkflowManifest;
-declare function stringifyRunnerArgoWorkflow(workflow: ArgoWorkflowManifest): string;
+type BuildDynamicRunnerArgoWorkflowOptions = typeof buildDynamicRunnerArgoWorkflowOptionsSchema.Encoded;
+declare const stringifyRunnerArgoWorkflow: (workflow: ArgoWorkflowManifest) => string;
+declare const buildRunnerArgoWorkflowManifest: (rawOptions: BuildRunnerArgoWorkflowOptions) => ArgoWorkflowManifest;
+declare const buildDynamicRunnerArgoWorkflowManifest: (rawOptions: BuildDynamicRunnerArgoWorkflowOptions) => ArgoWorkflowManifest;
 //#endregion
 export { ArgoWorkflowManifest, BuildDynamicRunnerArgoWorkflowOptions, BuildRunnerArgoWorkflowOptions, buildDynamicRunnerArgoWorkflowManifest, buildRunnerArgoWorkflowManifest, runnerArgoWorkflowManifestSchema, stringifyRunnerArgoWorkflow };

package/dist/argo-workflow.js

@@ -1,3 +1,4 @@
+import { parseStrictWithSchema, parseWithSchema } from "./schema-boundary.js";
 import { compileArgoExecutionGraph } from "./argo-graph.js";
 import { RUNNER_WORKFLOW_ENTRYPOINT, RUNNER_WORKFLOW_START_TASK } from "./remote/argo/policy.js";
 import { buildDynamicRunnerArgoWorkflowOptionsSchema, buildRunnerArgoWorkflowOptionsSchema, createRunnerArgoWorkflowManifestSchema } from "./remote/argo/model.js";
@@ -6,144 +7,64 @@ import { READY_NODE_IDS_PARAMETER, dynamicPreScheduleTemplate, dynamicReadyWaveS
 import { stringify } from "yaml";
 //#region src/argo-workflow.ts
 const runnerArgoWorkflowManifestSchema = createRunnerArgoWorkflowManifestSchema();
-function buildRunnerArgoWorkflowManifest(rawOptions) {
-	const options = parsedBuildOptions(rawOptions);
-	const graph = compileArgoExecutionGraph(options.plan);
-	const storage = runnerWorkflowStorage(options, graph.tasks);
-	return runnerArgoWorkflowManifestSchema.parse({
-		apiVersion: "argoproj.io/v1alpha1",
-		kind: "Workflow",
-		metadata: workflowMetadata(options),
-		spec: workflowSpec(options, graph.tasks, storage)
-	});
-}
-function buildDynamicRunnerArgoWorkflowManifest(rawOptions) {
-	const options = buildDynamicRunnerArgoWorkflowOptionsSchema.parse(rawOptions);
-	const storage = dynamicRunnerWorkflowStorage(options);
-	return runnerArgoWorkflowManifestSchema.parse({
-		apiVersion: "argoproj.io/v1alpha1",
-		kind: "Workflow",
-		metadata: dynamicWorkflowMetadata(options),
-		spec: dynamicWorkflowSpec(options, storage)
-	});
-}
-function stringifyRunnerArgoWorkflow(workflow) {
-	return stringify(runnerArgoWorkflowManifestSchema.parse(workflow));
-}
-function parsedBuildOptions(rawOptions) {
+const stringifyRunnerArgoWorkflow = (workflow) => stringify(parseWithSchema(runnerArgoWorkflowManifestSchema, workflow, { onExcessProperty: "preserve" }));
+const parsedBuildOptions = (rawOptions) => {
 	const { plan, ...schemaOptions } = rawOptions;
 	return {
-		...buildRunnerArgoWorkflowOptionsSchema.parse(schemaOptions),
+		...parseStrictWithSchema(buildRunnerArgoWorkflowOptionsSchema, schemaOptions),
 		plan
 	};
-}
-function workflowMetadata(options) {
-	return {
-		annotations: compactRecord(options.annotations),
-		...options.name ? { name: options.name } : {},
-		...options.generateName ? { generateName: options.generateName } : {},
-		labels: compactRecord({
-			"pipeline.oisin.dev/source": "argo-workflow",
-			"pipeline.oisin.dev/workflow": options.plan.workflowId,
-			...options.labels
-		}),
-		namespace: options.namespace
-	};
-}
-function dynamicWorkflowMetadata(options) {
-	return {
-		annotations: compactRecord(options.annotations),
-		...options.name ? { name: options.name } : {},
-		...options.generateName ? { generateName: options.generateName } : {},
-		labels: compactRecord({
-			"pipeline.oisin.dev/source": "argo-workflow",
-			"pipeline.oisin.dev/workflow": options.workflowId,
-			...options.labels
-		}),
-		namespace: options.namespace
-	};
-}
-function workflowSpec(options, tasks, storage) {
-	return {
-		...options.activeDeadlineSeconds ? { activeDeadlineSeconds: options.activeDeadlineSeconds } : {},
-		entrypoint: RUNNER_WORKFLOW_ENTRYPOINT,
-		...options.imagePullSecretName ? { imagePullSecrets: [{ name: options.imagePullSecretName }] } : {},
-		serviceAccountName: options.serviceAccountName,
-		onExit: "pipeline-finalizer",
-		templates: workflowTemplates(options, tasks, storage.volumeMounts),
-		...options.ttlStrategy ? { ttlStrategy: options.ttlStrategy } : {},
-		volumes: storage.volumes
-	};
-}
-function dynamicWorkflowSpec(options, storage) {
-	return {
-		...options.activeDeadlineSeconds ? { activeDeadlineSeconds: options.activeDeadlineSeconds } : {},
-		entrypoint: RUNNER_WORKFLOW_ENTRYPOINT,
-		...options.imagePullSecretName ? { imagePullSecrets: [{ name: options.imagePullSecretName }] } : {},
-		serviceAccountName: options.serviceAccountName,
-		onExit: "pipeline-finalizer",
-		templates: dynamicWorkflowTemplates(options, storage.volumeMounts),
-		...options.ttlStrategy ? { ttlStrategy: options.ttlStrategy } : {},
-		volumes: storage.volumes
-	};
-}
-function workflowTemplates(options, tasks, volumeMounts) {
-	return [
-		workflowDagTemplate(tasks),
-		runnerLifecycleTemplate(options, volumeMounts),
-		...tasks.map((task) => runnerCommandTemplate(task, options, volumeMounts)),
-		runnerFinalizerTemplate(options, volumeMounts)
-	];
-}
-function dynamicWorkflowTemplates(options, volumeMounts) {
-	return [
-		dynamicWorkflowEntrypointTemplate(),
-		dynamicDrainTemplate(),
-		dynamicPreScheduleTemplate("pre-research", options, volumeMounts),
-		dynamicPreScheduleTemplate("pre-planning", options, volumeMounts),
-		dynamicPreScheduleTemplate("generate-schedule", options, volumeMounts),
-		dynamicReadyWaveSelectorTemplate(options, volumeMounts),
-		dynamicRunnerCommandTemplate(options, volumeMounts),
-		dynamicRunnerFinalizerTemplate(options, volumeMounts)
-	];
-}
-function workflowDagTemplate(tasks) {
-	return {
-		dag: { tasks: [{
-			name: RUNNER_WORKFLOW_START_TASK,
-			template: RUNNER_WORKFLOW_START_TASK
-		}, ...tasks.map((task) => ({
-			dependencies: [RUNNER_WORKFLOW_START_TASK, ...task.dependencies],
-			name: task.taskName,
-			template: task.templateName
-		}))] },
-		name: RUNNER_WORKFLOW_ENTRYPOINT
-	};
-}
-function dynamicWorkflowEntrypointTemplate() {
-	return {
-		name: RUNNER_WORKFLOW_ENTRYPOINT,
-		steps: [
-			[{
-				name: "pre-research",
-				template: "pre-research"
-			}],
-			[{
-				name: "pre-planning",
-				template: "pre-planning"
-			}],
-			[{
-				name: "generate-schedule",
-				template: "generate-schedule"
-			}],
-			[{
-				name: "drain-ready-waves",
-				template: "drain-ready-waves"
-			}]
-		]
-	};
-}
-function dynamicDrainTemplate() {
+};
+const workflowDagTemplate = (tasks) => ({
+	dag: { tasks: [{
+		name: RUNNER_WORKFLOW_START_TASK,
+		template: RUNNER_WORKFLOW_START_TASK
+	}, ...tasks.map((task) => ({
+		dependencies: [RUNNER_WORKFLOW_START_TASK, ...task.dependencies],
+		name: task.taskName,
+		template: task.templateName
+	}))] },
+	name: RUNNER_WORKFLOW_ENTRYPOINT
+});
+const workflowTemplates = (options, tasks, volumeMounts) => [
+	workflowDagTemplate(tasks),
+	runnerLifecycleTemplate(options, volumeMounts),
+	...tasks.map((task) => runnerCommandTemplate(task, options, volumeMounts)),
+	runnerFinalizerTemplate(options, volumeMounts)
+];
+const workflowSpecBase = (options, storage, templates) => ({
+	...options.activeDeadlineSeconds === void 0 ? {} : { activeDeadlineSeconds: options.activeDeadlineSeconds },
+	entrypoint: RUNNER_WORKFLOW_ENTRYPOINT,
+	...options.imagePullSecretName !== void 0 && options.imagePullSecretName.length > 0 ? { imagePullSecrets: [{ name: options.imagePullSecretName }] } : {},
+	onExit: "pipeline-finalizer",
+	serviceAccountName: options.serviceAccountName,
+	templates,
+	...options.ttlStrategy ? { ttlStrategy: options.ttlStrategy } : {},
+	volumes: storage.volumes
+});
+const workflowSpec = (options, tasks, storage) => workflowSpecBase(options, storage, workflowTemplates(options, tasks, storage.volumeMounts));
+const dynamicWorkflowEntrypointTemplate = () => ({
+	name: RUNNER_WORKFLOW_ENTRYPOINT,
+	steps: [
+		[{
+			name: "pre-research",
+			template: "pre-research"
+		}],
+		[{
+			name: "pre-planning",
+			template: "pre-planning"
+		}],
+		[{
+			name: "generate-schedule",
+			template: "generate-schedule"
+		}],
+		[{
+			name: "drain-ready-waves",
+			template: "drain-ready-waves"
+		}]
+	]
+});
+const dynamicDrainTemplate = () => {
 	const readyExpression = `{{steps.select-ready-wave.outputs.parameters.${READY_NODE_IDS_PARAMETER}}} != []`;
 	return {
 		name: "drain-ready-waves",
@@ -169,9 +90,46 @@ function dynamicDrainTemplate() {
 			}]
 		]
 	};
-}
-function compactRecord(input) {
-	return Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== void 0));
-}
+};
+const dynamicWorkflowTemplates = (options, volumeMounts) => [
+	dynamicWorkflowEntrypointTemplate(),
+	dynamicDrainTemplate(),
+	dynamicPreScheduleTemplate("pre-research", options, volumeMounts),
+	dynamicPreScheduleTemplate("pre-planning", options, volumeMounts),
+	dynamicPreScheduleTemplate("generate-schedule", options, volumeMounts),
+	dynamicReadyWaveSelectorTemplate(options, volumeMounts),
+	dynamicRunnerCommandTemplate(options, volumeMounts),
+	dynamicRunnerFinalizerTemplate(options, volumeMounts)
+];
+const dynamicWorkflowSpec = (options, storage) => workflowSpecBase(options, storage, dynamicWorkflowTemplates(options, storage.volumeMounts));
+const compactRecord = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== void 0));
+const workflowMetadata = (options, workflowId) => ({
+	annotations: compactRecord(options.annotations),
+	...options.name !== void 0 && options.name.length > 0 ? { name: options.name } : {},
+	...options.generateName !== void 0 && options.generateName.length > 0 ? { generateName: options.generateName } : {},
+	labels: compactRecord({
+		"pipeline.oisin.dev/source": "argo-workflow",
+		"pipeline.oisin.dev/workflow": workflowId,
+		...options.labels
+	}),
+	namespace: options.namespace
+});
+const runnerArgoWorkflowManifest = (options, workflowId, spec) => parseStrictWithSchema(runnerArgoWorkflowManifestSchema, {
+	apiVersion: "argoproj.io/v1alpha1",
+	kind: "Workflow",
+	metadata: workflowMetadata(options, workflowId),
+	spec
+});
+const buildRunnerArgoWorkflowManifest = (rawOptions) => {
+	const options = parsedBuildOptions(rawOptions);
+	const graph = compileArgoExecutionGraph(options.plan);
+	const storage = runnerWorkflowStorage(options, graph.tasks);
+	return runnerArgoWorkflowManifest(options, options.plan.workflowId, workflowSpec(options, graph.tasks, storage));
+};
+const buildDynamicRunnerArgoWorkflowManifest = (rawOptions) => {
+	const options = parseStrictWithSchema(buildDynamicRunnerArgoWorkflowOptionsSchema, rawOptions);
+	const storage = dynamicRunnerWorkflowStorage(options);
+	return runnerArgoWorkflowManifest(options, options.workflowId, dynamicWorkflowSpec(options, storage));
+};
 //#endregion
 export { buildDynamicRunnerArgoWorkflowManifest, buildRunnerArgoWorkflowManifest, runnerArgoWorkflowManifestSchema, stringifyRunnerArgoWorkflow };

package/dist/backlog.js

@@ -1,13 +1,14 @@
+import { Option } from "effect";
 //#region src/backlog.ts
 /**
 * `backlog task create` (with `--plain`) prints `Task <PREFIX>-<id> - <title>`
 * on the second non-blank line. We accept custom all-caps Backlog prefixes and
 * subtask ids like `PIPE-3.1`.
 */
-const TASK_ID_RE = /^Task\s+([A-Z]+-[\w.]+)\b/m;
-function parseBacklogTaskId(stdout) {
+const TASK_ID_RE = /^Task\s+([A-Z]+-[\w.]+)\b/mu;
+const parseBacklogTaskId = (stdout) => {
 	const m = TASK_ID_RE.exec(stdout);
-	return m ? m[1] : null;
-}
+	return m === null ? Option.none() : Option.some(m[1]);
+};
 //#endregion
 export { parseBacklogTaskId };