@taqueria/protocol 0.56.15 → 0.57.8

package/taqueria-protocol-types.js

@@ -9,11 +9,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from28, except, desc) => {
-  if (from28 && typeof from28 === "object" || typeof from28 === "function") {
-    for (let key of __getOwnPropNames(from28))
+var __copyProps = (to, from46, except, desc) => {
+  if (from46 && typeof from46 === "object" || typeof from46 === "function") {
+    for (let key of __getOwnPropNames(from46))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from28[key], enumerable: !(desc = __getOwnPropDesc(from28, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from46[key], enumerable: !(desc = __getOwnPropDesc(from46, key)) || desc.enumerable });
   }
   return to;
 };
@@ -185,6 +185,14 @@ var taskSchema = import_zod.z.object({
   options: import_zod.z.array(optionSchema).optional(),
   positionals: import_zod.z.array(positionalArgSchema).optional()
 });
+var pluginSchemaBaseSchema = import_zod.z.object({
+  name: nonEmptyStringSchema,
+  version: versionNumberSchema,
+  schema: versionNumberSchema,
+  alias: aliasSchema,
+  tasks: import_zod.z.array(taskSchema).optional(),
+  postInstall: import_zod.z.string().optional()
+});
 var runtimeDependencySchema = import_zod.z.object({
   name: humanReadableIdentifierSchema,
   path: import_zod.z.string(),
@@ -311,10 +319,23 @@ var metadataConfigSchema = import_zod.z.object({
   homepage: import_zod.z.string().optional()
 });
 var versionV2Schema = import_zod.z.string().regex(/^v2$/);
+var configAccountSchema = import_zod.z.object({
+  balance: currencyAmountV2Schema
+});
 var sandboxAccountSchema = import_zod.z.object({
   type: import_zod.z.string().optional()
 }).passthrough();
 var sandboxAccountsSchema = import_zod.z.record(sandboxAccountSchema);
+var configEnvironmentFileV2Schema = import_zod.z.object({
+  type: import_zod.z.string().optional(),
+  accounts: sandboxAccountsSchema.optional(),
+  accountDefault: import_zod.z.any().optional(),
+  contracts: import_zod.z.record(
+    import_zod.z.object({
+      address: import_zod.z.string().optional()
+    })
+  ).optional()
+}).passthrough();
 var networkAccountConfigSchema = import_zod.z.object({
   publicKey: nonEmptyStringSchema.optional(),
   publicKeyHash: publicKeyHashSchema.optional(),
@@ -326,39 +347,28 @@ var sandboxAccountConfigSchema = import_zod.z.object({
   publicKeyHash: publicKeyHashSchema,
   secretKey: nonEmptyStringSchema
 });
+var sandboxConfigSchema = import_zod.z.object({
+  label: nonEmptyStringSchema,
+  rpcUrl: urlSchema,
+  protocol: economicalProtocolHashSchema.optional(),
+  plugin: verbSchema.optional(),
+  accounts: import_zod.z.record(import_zod.z.union([sandboxAccountConfigSchema, nonEmptyStringSchema])).optional(),
+  tzkt: tzKtConfigSchema.optional(),
+  annotations: import_zod.z.record(import_zod.z.unknown()).optional()
+});
 var scaffoldConfigSchema = import_zod.z.object({
   postInit: import_zod.z.string().optional()
 });
-var pluginSchemaBaseSchema = import_zod.z.object({
-  name: nonEmptyStringSchema,
-  version: versionNumberSchema,
-  schema: versionNumberSchema,
-  alias: aliasSchema,
-  tasks: import_zod.z.array(taskSchema).optional(),
-  postInstall: import_zod.z.string().optional()
-});
 var persistentStateSchema = import_zod.z.object({
   operations: import_zod.z.record(persistedOperationSchema),
   tasks: import_zod.z.record(persistedTaskSchema)
 });
-var configAccountSchema = import_zod.z.object({
-  balance: currencyAmountV2Schema
-});
 var networkConfigSchema = import_zod.z.object({
   label: humanReadableIdentifierSchema,
   rpcUrl: urlSchema,
   accounts: import_zod.z.record(networkAccountConfigSchema).optional(),
   faucet: faucetSchema.optional()
 });
-var sandboxConfigSchema = import_zod.z.object({
-  label: nonEmptyStringSchema,
-  rpcUrl: urlSchema,
-  protocol: economicalProtocolHashSchema.optional(),
-  plugin: verbSchema.optional(),
-  accounts: import_zod.z.record(import_zod.z.union([sandboxAccountConfigSchema, nonEmptyStringSchema])).optional(),
-  tzkt: tzKtConfigSchema.optional(),
-  annotations: import_zod.z.record(import_zod.z.unknown()).optional()
-});
 var configFileV1Schema = import_zod.z.object({
   language: humanLanguageSchema.optional(),
   plugins: import_zod.z.array(installedPluginSchema).optional(),
@@ -371,28 +381,6 @@ var configFileV1Schema = import_zod.z.object({
   contracts: import_zod.z.record(contractSchema).optional(),
   metadata: metadataConfigSchema.optional()
 });
-var configEnvironmentFileV2Schema = import_zod.z.object({
-  type: import_zod.z.string().optional(),
-  accounts: sandboxAccountsSchema.optional(),
-  accountDefault: import_zod.z.any().optional(),
-  contracts: import_zod.z.record(
-    import_zod.z.object({
-      address: import_zod.z.string().optional()
-    })
-  ).optional()
-}).passthrough();
-var configSchema = import_zod.z.object({
-  language: humanLanguageSchema.optional(),
-  metadata: metadataConfigSchema.optional(),
-  artifactsDir: configArtifactsDirSchema.optional(),
-  contractsDir: configContractsDirSchema.optional(),
-  contracts: import_zod.z.record(contractSchema).optional(),
-  plugins: import_zod.z.array(installedPluginSchema).optional(),
-  accounts: import_zod.z.record(tzSchema).optional(),
-  environment: import_zod.z.record(import_zod.z.union([environmentSchema, environmentNameSchema])),
-  network: import_zod.z.record(networkConfigSchema).optional(),
-  sandbox: import_zod.z.record(sandboxConfigSchema).optional()
-});
 var configFileV2Schema = import_zod.z.object({
   version: versionV2Schema,
   language: humanLanguageSchema.optional(),
@@ -405,6 +393,18 @@ var configFileV2Schema = import_zod.z.object({
   environments: import_zod.z.record(configEnvironmentFileV2Schema).optional(),
   plugins: import_zod.z.array(installedPluginSchema).optional()
 });
+var configSchema = import_zod.z.object({
+  language: humanLanguageSchema.optional(),
+  metadata: metadataConfigSchema.optional(),
+  artifactsDir: configArtifactsDirSchema.optional(),
+  contractsDir: configContractsDirSchema.optional(),
+  contracts: import_zod.z.record(contractSchema).optional(),
+  plugins: import_zod.z.array(installedPluginSchema).optional(),
+  accounts: import_zod.z.record(tzSchema).optional(),
+  environment: import_zod.z.record(import_zod.z.union([environmentSchema, environmentNameSchema])),
+  network: import_zod.z.record(networkConfigSchema).optional(),
+  sandbox: import_zod.z.record(sandboxConfigSchema).optional()
+});
 var parsedConfigSchema = configSchema.omit({ sandbox: true }).extend(
   {
     sandbox: import_zod.z.record(import_zod.z.union([sandboxConfigSchema, nonEmptyStringSchema]))
@@ -423,11 +423,6 @@ var requestArgsSchema = sanitizedArgsSchema.omit({ quickstart: true }).extend(
     config: loadedConfigSchema
   }
 ).passthrough();
-var proxyTaskArgsSchema = requestArgsSchema.extend(
-  {
-    task: nonEmptyStringSchema
-  }
-).passthrough();
 var proxyTemplateArgsSchema = requestArgsSchema.extend(
   {
     template: nonEmptyStringSchema
@@ -464,12 +459,6 @@ var parsedTemplateSchema = templateSchema.omit({ handler: true }).extend(
     handler: import_zod.z.string()
   }
 );
-var pluginInfoSchema = pluginSchemaBaseSchema.extend(
-  {
-    operations: import_zod.z.array(parsedOperationSchema).optional(),
-    templates: import_zod.z.array(parsedTemplateSchema).optional()
-  }
-);
 var pluginSchemaSchema = pluginSchemaBaseSchema.extend(
   {
     operations: import_zod.z.array(operationSchema).optional(),
@@ -479,6 +468,17 @@ var pluginSchemaSchema = pluginSchemaBaseSchema.extend(
     installRuntimeDependencies: import_zod.z.function().args(requestArgsSchema).returns(import_zod.z.promise(pluginDependenciesResponseSchema)).optional()
   }
 );
+var proxyTaskArgsSchema = requestArgsSchema.extend(
+  {
+    task: nonEmptyStringSchema
+  }
+).passthrough();
+var pluginInfoSchema = pluginSchemaBaseSchema.extend(
+  {
+    operations: import_zod.z.array(parsedOperationSchema).optional(),
+    templates: import_zod.z.array(parsedTemplateSchema).optional()
+  }
+);
 var ephemeralStateSchema = import_zod.z.object({
   build: import_zod.z.string(),
   configHash: import_zod.z.string(),
@@ -677,1219 +677,888 @@ var internalSchema4 = environmentSchema;
 // EphemeralState.ts
 var EphemeralState_exports = {};
 __export(EphemeralState_exports, {
-  create: () => create6,
-  factory: () => factory,
-  generatedSchemas: () => generatedSchemas,
+  create: () => create54,
+  factory: () => factory7,
+  generatedSchemas: () => generatedSchemas6,
   getTasks: () => getTasks,
-  make: () => make5,
+  make: () => make52,
   mapOperationsToPlugins: () => mapOperationsToPlugins,
   mapTasksToPlugins: () => mapTasksToPlugins,
   mapTemplatesToPlugins: () => mapTemplatesToPlugins,
+  of: () => of52,
+  schemas: () => schemas52
+});
+
+// Command.ts
+var Command_exports = {};
+__export(Command_exports, {
+  create: () => create6,
+  from: () => from5,
+  internalSchema: () => internalSchema5,
+  make: () => make5,
   of: () => of5,
+  rawSchema: () => rawSchema5,
   schemas: () => schemas5
 });
-var import_protocol = require("@taqueria/protocol");
 
-// Base.ts
+// out/types/Command.ts
 var import_fluture6 = require("fluture");
 var import_zod6 = require("zod");
-var createSchema = (params) => {
-  var _a, _b;
-  const { rawSchema: rawSchema37, isStringLike } = params;
-  const internalSchema32 = (_a = params.internalSchema) != null ? _a : params.rawSchema;
-  const noop = (val) => val;
-  const transformer = (_b = params.transformer) != null ? _b : noop;
-  const schema = isStringLike ? internalSchema32.transform(
-    (val) => transformer(val)
-  ) : internalSchema32.transform(
-    (val) => transformer(val)
-  );
-  return {
-    rawSchema: rawSchema37,
-    internalSchema: internalSchema32,
-    schema
-  };
-};
-var createType = (params) => {
-  const schemas37 = createSchema(params);
-  const { parseErrMsg, unknownErrMsg } = params;
-  const internalOf = (input) => {
-    try {
-      return (0, import_fluture6.resolve)(schemas37.schema.parse(input));
-    } catch (previous) {
-      const parseMsg = typeof parseErrMsg === "string" ? parseErrMsg : parseErrMsg(input, previous);
-      const unknownMsg = typeof unknownErrMsg === "string" ? unknownErrMsg : unknownErrMsg(input);
-      if (previous instanceof import_zod6.ZodError) {
-        return toFutureParseErr(previous, parseMsg, input);
-      }
-      return toFutureParseUnknownErr(previous, unknownMsg, input);
+var from5 = (input) => {
+  try {
+    return commandSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod6.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Command is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
     }
-  };
-  const of35 = internalOf;
-  const make35 = (input) => internalOf(input);
-  const create37 = (input) => schemas37.schema.parse(input);
-  const from28 = (input) => schemas37.schema.parse(input);
-  const factory8 = {
-    make: make35,
-    of: of35,
-    create: create37,
-    from: from28
-  };
-  return {
-    schemas: schemas37,
-    factory: factory8
-  };
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Command.");
+  }
 };
-var Base_default = createType;
+var create6 = (input) => from5(input);
+var of5 = (input) => {
+  try {
+    return (0, import_fluture6.resolve)(from5(input));
+  } catch (err) {
+    return (0, import_fluture6.reject)(err);
+  }
+};
+var make5 = (input) => of5(input);
+var schemas5 = {
+  rawSchema: commandSchema,
+  schema: commandSchema.transform((val) => val)
+};
+var rawSchema5 = schemas5.rawSchema;
+var internalSchema5 = commandSchema;
 
-// EphemeralState.ts
+// ConfigFileV2.ts
+var ConfigFileV2_exports = {};
+__export(ConfigFileV2_exports, {
+  create: () => create7,
+  from: () => from6,
+  internalSchema: () => internalSchema6,
+  make: () => make6,
+  of: () => of6,
+  rawSchema: () => rawSchema6,
+  schemas: () => schemas6
+});
+
+// out/types/ConfigFileV2.ts
 var import_fluture7 = require("fluture");
 var import_zod7 = require("zod");
-var eager = (f) => (0, import_fluture7.promise)(
-  (0, import_fluture7.mapRej)((err) => new E_TaqError(err))(f)
-);
-var taskToPluginMap = import_zod7.z.record(
-  import_zod7.z.union([
-    import_protocol.InstalledPlugin.schemas.schema,
-    import_protocol.Task.schemas.schema
-  ], { description: "Task/Plugin Mapping" })
-);
-var operationToPluginMap = import_zod7.z.record(
-  import_zod7.z.union([
-    import_protocol.InstalledPlugin.schemas.schema,
-    import_protocol.ParsedOperation.schemas.schema
-  ], { description: "Operation/Plugin Mapping" })
-);
-var templateToPluginMap = import_zod7.z.record(
-  import_zod7.z.union([
-    import_protocol.InstalledPlugin.schemas.schema,
-    import_protocol.ParsedTemplate.schemas.schema
-  ])
-);
-var rawSchema5 = import_zod7.z.object({
-  build: import_zod7.z.string({ description: "cache.build" }),
-  configHash: import_zod7.z.string({ description: "cache.configHash" }),
-  tasks: taskToPluginMap,
-  operations: operationToPluginMap,
-  templates: templateToPluginMap,
-  plugins: import_zod7.z.array(import_protocol.PluginInfo.schemas.schema, { description: "cache.plugins" })
-}).describe("Ephemeral State");
-var { schemas: generatedSchemas, factory } = Base_default({
-  rawSchema: rawSchema5,
-  parseErrMsg: (value) => `${value} is not a valid representation of ephemeral state`,
-  unknownErrMsg: "Something went wrong when parsing the ephemeral state"
-});
-var { create: create6, of: of5, make: make5 } = factory;
-var schemas5 = {
-  ...generatedSchemas,
-  schema: generatedSchemas.schema.transform((val) => val)
+var from6 = (input) => {
+  try {
+    return configFileV2Schema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod7.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["ConfigFileV2 is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a ConfigFileV2.");
+  }
 };
-var getTaskCounts = (pluginInfo) => {
-  return pluginInfo.reduce(
-    (retval, pluginInfo2) => pluginInfo2.tasks === void 0 ? {} : pluginInfo2.tasks.reduce(
-      (retval2, task) => {
-        const taskName = task.task;
-        const providers = retval2[taskName] ? [...retval2[taskName], pluginInfo2] : [pluginInfo2];
-        const mapping = {};
-        mapping[taskName] = providers.filter((provider) => provider !== void 0);
-        return { ...retval2, ...mapping };
-      },
-      retval
-    ),
-    {}
-  );
+var create7 = (input) => from6(input);
+var of6 = (input) => {
+  try {
+    return (0, import_fluture7.resolve)(from6(input));
+  } catch (err) {
+    return (0, import_fluture7.reject)(err);
+  }
 };
-var getTemplateCounts = (pluginInfo) => {
-  return pluginInfo.reduce(
-    (retval, pluginInfo2) => !pluginInfo2.templates ? retval : pluginInfo2.templates.reduce(
-      (retval2, template) => {
-        const templateName = template.template;
-        const providers = retval2[templateName] ? [...retval2[templateName], pluginInfo2] : [pluginInfo2];
-        const mapping = {};
-        mapping[templateName] = providers.filter((provider) => provider !== void 0);
-        return { ...retval2, ...mapping };
-      },
-      retval
-    ),
-    {}
-  );
-};
-var getOperationCounts = (pluginInfo) => {
-  return pluginInfo.reduce(
-    (retval, pluginInfo2) => pluginInfo2.operations === void 0 ? retval : pluginInfo2.operations.reduce(
-      (retval2, operation) => {
-        const operationName = operation.operation;
-        const providers = retval2[operationName] ? [...retval2[operationName], pluginInfo2] : [pluginInfo2];
-        const mapping = {};
-        mapping[operationName] = providers.filter((provider) => provider !== void 0);
-        return { ...retval2, ...mapping };
-      },
-      retval
-    ),
-    {}
-  );
-};
-var toChoices = (plugins) => plugins.reduce(
-  (retval, pluginInfo) => {
-    return [...retval, pluginInfo.name, pluginInfo.alias];
-  },
-  []
-);
-var isComposite = (name, counts) => counts[name] && counts[name].length > 1;
-var getInstalledPlugin = (config, name) => {
-  var _a;
-  return (_a = config.plugins) == null ? void 0 : _a.find(
-    (plugin) => [`taqueria-plugin-${name}`, name].includes(plugin.name)
-  );
-};
-var mapTasksToPlugins = (config, pluginInfo, i18n) => {
-  const taskCounts = getTaskCounts(pluginInfo);
-  return (0, import_fluture7.attemptP)(
-    async () => await pluginInfo.reduce(
-      async (retval, pluginInfo2) => !pluginInfo2.tasks ? Promise.resolve({}) : await pluginInfo2.tasks.reduce(
-        async (retval2, { task, hidden }) => {
-          if (isComposite(task, taskCounts)) {
-            const command = await eager(import_protocol.Command.make(task));
-            const compositeTask = await eager(import_protocol.Task.make({
-              task,
-              command,
-              description: await eager(import_protocol.NonEmptyString.make(i18n.__("providedByMany"))),
-              hidden,
-              options: [
-                await eager(import_protocol.Option.make({
-                  flag: await eager(import_protocol.Verb.make("plugin")),
-                  description: await eager(
-                    import_protocol.NonEmptyString.make("Specify which plugin should be used to execute this task")
-                  ),
-                  choices: toChoices(taskCounts[task]),
-                  required: true
-                }))
-              ],
-              handler: "proxy"
-            }));
-            return { ...await retval2, [task]: compositeTask };
-          }
-          const installedPlugin = getInstalledPlugin(config, pluginInfo2.name);
-          return installedPlugin ? { ...await retval2, [task]: installedPlugin } : retval2;
-        },
-        retval
-      ),
-      Promise.resolve({})
-    )
-  ).pipe((0, import_fluture7.mapRej)((rej) => rej));
-};
-var mapOperationsToPlugins = (config, pluginInfo, i18n) => {
-  const opCounts = getOperationCounts(pluginInfo);
-  return (0, import_fluture7.attemptP)(
-    async () => await pluginInfo.reduce(
-      async (retval, pluginInfo2) => !pluginInfo2.operations ? Promise.resolve({}) : await pluginInfo2.operations.reduce(
-        async (retval2, { operation }) => {
-          if (isComposite(operation, opCounts)) {
-            const command = await eager(import_protocol.Command.make(operation));
-            const compositeOp = await eager(import_protocol.ParsedOperation.make({
-              operation,
-              command,
-              description: await eager(import_protocol.NonEmptyString.make(i18n.__("providedByMany"))),
-              options: [
-                await eager(import_protocol.Option.make({
-                  flag: await eager(import_protocol.Verb.make("plugin")),
-                  description: await eager(
-                    import_protocol.NonEmptyString.make("Specify which plugin should be used to execute this operation")
-                  ),
-                  choices: toChoices(opCounts[operation]),
-                  required: true
-                }))
-              ]
-            }));
-            return { ...await retval2, [operation]: compositeOp };
-          }
-          const installedPlugin = getInstalledPlugin(config, pluginInfo2.name);
-          return installedPlugin ? { ...await retval2, [operation]: installedPlugin } : retval2;
-        },
-        retval
-      ),
-      Promise.resolve({})
-    )
-  ).pipe((0, import_fluture7.mapRej)((rej) => rej));
-};
-var mapTemplatesToPlugins = (config, pluginInfo, i18n) => {
-  const tmplCounts = getTemplateCounts(pluginInfo);
-  return (0, import_fluture7.attemptP)(
-    async () => await pluginInfo.reduce(
-      async (retval, pluginInfo2) => !pluginInfo2.templates ? Promise.resolve({}) : await pluginInfo2.templates.reduce(
-        async (retval2, { template, hidden }) => {
-          if (isComposite(template, tmplCounts)) {
-            const command = await eager(import_protocol.Command.make(template));
-            const description = await eager(import_protocol.NonEmptyString.of(i18n.__("providedByMany")));
-            const compositeTmpl = await eager(import_protocol.ParsedTemplate.make({
-              template,
-              command,
-              description,
-              options: [
-                await eager(import_protocol.Option.make({
-                  flag: await eager(import_protocol.Verb.make("plugin")),
-                  description: await eager(
-                    import_protocol.NonEmptyString.make("Specify which plugin should be used to execute this task")
-                  ),
-                  choices: toChoices(tmplCounts[template]),
-                  required: true
-                }))
-              ],
-              handler: "proxy",
-              encoding: import_protocol.PluginResponseEncoding.create("none")
-            }));
-            return { ...await retval2, [template]: compositeTmpl };
-          }
-          const installedPlugin = getInstalledPlugin(config, pluginInfo2.name);
-          return installedPlugin ? { ...await retval2, [template]: installedPlugin } : retval2;
-        },
-        retval
-      ),
-      Promise.resolve({})
-    )
-  ).pipe((0, import_fluture7.mapRej)((rej) => rej));
-};
-var getTasks = (pluginInfo) => pluginInfo.reduce(
-  (retval, pluginInfo2) => {
-    var _a;
-    return [...retval, ...(_a = pluginInfo2.tasks) != null ? _a : []];
-  },
-  []
-);
-
-// HumanReadableIdentifier.ts
-var HumanReadableIdentifier_exports = {};
-__export(HumanReadableIdentifier_exports, {
-  create: () => create7,
-  from: () => from5,
-  internalSchema: () => internalSchema5,
-  make: () => make6,
-  of: () => of6,
-  rawSchema: () => rawSchema6,
-  schemas: () => schemas6
-});
-
-// out/types/HumanReadableIdentifier.ts
-var import_fluture8 = require("fluture");
-var import_zod8 = require("zod");
-var from5 = (input) => {
-  try {
-    return humanReadableIdentifierSchema.parse(input);
-  } catch (previous) {
-    if (previous instanceof import_zod8.ZodError) {
-      const msgs = previous.errors.reduce(
-        (retval, issue) => {
-          const path2 = issue.path.join(" \u2192 ");
-          const msg = path2 + ": " + issue.message;
-          return [...retval, msg];
-        },
-        ["HumanReadableIdentifier is invalid:"]
-      );
-      const validationErr = msgs.join("\n") + "\n";
-      throw toParseErr(previous, validationErr);
-    }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a HumanReadableIdentifier.");
-  }
-};
-var create7 = (input) => from5(input);
-var of6 = (input) => {
-  try {
-    return (0, import_fluture8.resolve)(from5(input));
-  } catch (err) {
-    return (0, import_fluture8.reject)(err);
-  }
-};
-var make6 = (input) => of6(input);
-var schemas6 = {
-  rawSchema: humanReadableIdentifierSchema,
-  schema: humanReadableIdentifierSchema.transform((val) => val)
+var make6 = (input) => of6(input);
+var schemas6 = {
+  rawSchema: configFileV2Schema,
+  schema: configFileV2Schema.transform((val) => val)
 };
 var rawSchema6 = schemas6.rawSchema;
-var internalSchema5 = humanReadableIdentifierSchema;
-
-// i18n.ts
-var i18n_exports = {};
-__export(i18n_exports, {
-  default: () => i18n_default
-});
-var import_i18next = __toESM(require("i18next"));
-var i18n_default = async () => {
-  const i18n = {
-    ...await import_i18next.default.init({
-      lng: "en",
-      debug: false,
-      resources: {
-        // TODO: Move to separate language files
-        en: {
-          translation: {
-            "appName": "Taqueria",
-            "appDesc": "Taqueria is an integrated environment for compiling, testing, and deploying Tezos software.",
-            "versionDesc": "Display the version number of the Taqueria program",
-            "betaWarning": "Please be advised that Taqueria is currently in BETA.",
-            "configDirDesc": "Config directory (default ./.taq)",
-            "initDesc": "Initialize a new project",
-            "optInDesc": "Opt-in to sharing anonymous usage analytics",
-            "optOutDesc": "Opt-out of sharing anonymous usage analytics",
-            "initPathDesc": "Path to your project directory",
-            "workflowDesc": "Select a workflow to initialize your Taqueria project. Choices are (ligo|smartpy|archetype|michelson)",
-            "scaffoldDesc": `Generate a new project using pre-made scaffold. Recommended for creating a new project.`,
-            "scaffoldUrlDesc": "Alias or Url for the scaffold project",
-            "scaffoldProjectDirDesc": "Path where to create the new project. This must be a new directory.",
-            "scaffoldDoneMsg": "The project was created using the scaffold.",
-            "installDesc": "Install a plugin",
-            "pluginInstalled": "Plugin installed successfully",
-            "pluginUninstalled": "Plugin uninstalled successfully",
-            "uninstallDesc": "Uninstall a plugin",
-            "pluginNameDesc": "The name of the plugin",
-            "promptForTask": "Please specify which task you would like to execute. If you're starting a new project, please run 'init'.\n",
-            "pluginKindDesc": "Kind of plugin (NPM, Binary)",
-            "pluginAlreadyInstalled": "That plugin is already installed.",
-            "pluginOptionDesc": "Use the task from this plugin",
-            "bootstrapMsg": "Project taq'ified!",
-            "maxConcurrencyDesc": "Set the maximum concurrency limit used internally",
-            "providedByMany": "Provided by more than one plugin. The option --plugin is required.",
-            "pluginDesc": "Specify what plugin should execute this command. Use this when more than one plugin provide a task of the same name.",
-            "listNetworks": "List known networks",
-            "envDesc": "Specify an environment configuration",
-            "disableStateDesc": "Does not use the saved state.json file. State is computed for each execution.",
-            "logPluginCallsDesc": "Logs any execution calls to a plugin to the console",
-            "npmInitRequired": "This project isn't a valid NPM project. Please run: npm init",
-            "testFromVsCode": "An internal command used by VS Code to test for the taq binary",
-            "fromVsCode": "An internal flag used to indicate that taq is executed via vscode",
-            "buildDesc": "Display build information about the current version",
-            "pluginOption": "Use to specify what plugin you'd like when running this task.",
-            "yesOptionDesc": 'Select "yes" to any prompt',
-            "templateNotFound": "Template not found. Perhaps you need to install a plugin?",
-            "createDesc": "Create files from pre-existing templates",
-            "templateDesc": "Name of the template to use"
-          }
-        }
-      }
-    }),
-    __: import_i18next.default.t
-  };
-  return i18n;
-};
+var internalSchema6 = configFileV2Schema;
 
-// InstalledPlugin.ts
-var InstalledPlugin_exports = {};
-__export(InstalledPlugin_exports, {
+// Contract.ts
+var Contract_exports = {};
+__export(Contract_exports, {
   create: () => create8,
-  from: () => from6,
-  internalSchema: () => internalSchema6,
+  from: () => from7,
+  internalSchema: () => internalSchema7,
   make: () => make7,
   of: () => of7,
   rawSchema: () => rawSchema7,
   schemas: () => schemas7
 });
 
-// out/types/InstalledPlugin.ts
-var import_fluture9 = require("fluture");
-var import_zod9 = require("zod");
-var from6 = (input) => {
+// out/types/Contract.ts
+var import_fluture8 = require("fluture");
+var import_zod8 = require("zod");
+var from7 = (input) => {
   try {
-    return installedPluginSchema.parse(input);
+    return contractSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod9.ZodError) {
+    if (previous instanceof import_zod8.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["InstalledPlugin is invalid:"]
+        ["Contract is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a InstalledPlugin.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Contract.");
   }
 };
-var create8 = (input) => from6(input);
+var create8 = (input) => from7(input);
 var of7 = (input) => {
   try {
-    return (0, import_fluture9.resolve)(from6(input));
+    return (0, import_fluture8.resolve)(from7(input));
   } catch (err) {
-    return (0, import_fluture9.reject)(err);
+    return (0, import_fluture8.reject)(err);
   }
 };
 var make7 = (input) => of7(input);
 var schemas7 = {
-  rawSchema: installedPluginSchema,
-  schema: installedPluginSchema.transform((val) => val)
+  rawSchema: contractSchema,
+  schema: contractSchema.transform((val) => val)
 };
 var rawSchema7 = schemas7.rawSchema;
-var internalSchema6 = installedPluginSchema;
+var internalSchema7 = contractSchema;
 
-// LoadedConfig.ts
-var LoadedConfig_exports = {};
-__export(LoadedConfig_exports, {
+// Faucet.ts
+var Faucet_exports = {};
+__export(Faucet_exports, {
   create: () => create9,
-  from: () => from7,
-  internalSchema: () => internalSchema7,
+  from: () => from8,
+  internalSchema: () => internalSchema8,
   make: () => make8,
   of: () => of8,
   rawSchema: () => rawSchema8,
   schemas: () => schemas8
 });
 
-// out/types/LoadedConfig.ts
-var import_fluture10 = require("fluture");
-var import_zod10 = require("zod");
-var from7 = (input) => {
+// out/types/Faucet.ts
+var import_fluture9 = require("fluture");
+var import_zod9 = require("zod");
+var from8 = (input) => {
   try {
-    return loadedConfigSchema.parse(input);
+    return faucetSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod10.ZodError) {
+    if (previous instanceof import_zod9.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["Your .taq/config.json is invalid:"]
+        ["Faucet is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a LoadedConfig.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Faucet.");
   }
 };
-var create9 = (input) => from7(input);
+var create9 = (input) => from8(input);
 var of8 = (input) => {
   try {
-    return (0, import_fluture10.resolve)(from7(input));
+    return (0, import_fluture9.resolve)(from8(input));
   } catch (err) {
-    return (0, import_fluture10.reject)(err);
+    return (0, import_fluture9.reject)(err);
   }
 };
 var make8 = (input) => of8(input);
 var schemas8 = {
-  rawSchema: loadedConfigSchema,
-  schema: loadedConfigSchema.transform((val) => val)
+  rawSchema: faucetSchema,
+  schema: faucetSchema.transform((val) => val)
 };
 var rawSchema8 = schemas8.rawSchema;
-var internalSchema7 = loadedConfigSchema;
+var internalSchema8 = faucetSchema;
 
-// MetadataConfig.ts
-var MetadataConfig_exports = {};
-__export(MetadataConfig_exports, {
+// HumanReadableIdentifier.ts
+var HumanReadableIdentifier_exports = {};
+__export(HumanReadableIdentifier_exports, {
   create: () => create10,
-  from: () => from8,
-  internalSchema: () => internalSchema8,
+  from: () => from9,
+  internalSchema: () => internalSchema9,
   make: () => make9,
   of: () => of9,
   rawSchema: () => rawSchema9,
   schemas: () => schemas9
 });
 
-// out/types/MetadataConfig.ts
-var import_fluture11 = require("fluture");
-var import_zod11 = require("zod");
-var from8 = (input) => {
+// out/types/HumanReadableIdentifier.ts
+var import_fluture10 = require("fluture");
+var import_zod10 = require("zod");
+var from9 = (input) => {
   try {
-    return metadataConfigSchema.parse(input);
+    return humanReadableIdentifierSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod11.ZodError) {
+    if (previous instanceof import_zod10.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["MetadataConfig is invalid:"]
+        ["HumanReadableIdentifier is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a MetadataConfig.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a HumanReadableIdentifier.");
   }
 };
-var create10 = (input) => from8(input);
+var create10 = (input) => from9(input);
 var of9 = (input) => {
   try {
-    return (0, import_fluture11.resolve)(from8(input));
+    return (0, import_fluture10.resolve)(from9(input));
   } catch (err) {
-    return (0, import_fluture11.reject)(err);
+    return (0, import_fluture10.reject)(err);
   }
 };
 var make9 = (input) => of9(input);
 var schemas9 = {
-  rawSchema: metadataConfigSchema,
-  schema: metadataConfigSchema.transform((val) => val)
+  rawSchema: humanReadableIdentifierSchema,
+  schema: humanReadableIdentifierSchema.transform((val) => val)
 };
 var rawSchema9 = schemas9.rawSchema;
-var internalSchema8 = metadataConfigSchema;
+var internalSchema9 = humanReadableIdentifierSchema;
 
-// NetworkConfig.ts
-var NetworkConfig_exports = {};
-__export(NetworkConfig_exports, {
+// InstalledPlugin.ts
+var InstalledPlugin_exports = {};
+__export(InstalledPlugin_exports, {
   create: () => create11,
-  from: () => from9,
-  internalSchema: () => internalSchema9,
+  from: () => from10,
+  internalSchema: () => internalSchema10,
   make: () => make10,
   of: () => of10,
   rawSchema: () => rawSchema10,
   schemas: () => schemas10
 });
 
-// out/types/NetworkConfig.ts
-var import_fluture12 = require("fluture");
-var import_zod12 = require("zod");
-var from9 = (input) => {
+// out/types/InstalledPlugin.ts
+var import_fluture11 = require("fluture");
+var import_zod11 = require("zod");
+var from10 = (input) => {
   try {
-    return networkConfigSchema.parse(input);
+    return installedPluginSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod12.ZodError) {
+    if (previous instanceof import_zod11.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["NetworkConfig is invalid:"]
+        ["InstalledPlugin is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a NetworkConfig.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a InstalledPlugin.");
   }
 };
-var create11 = (input) => from9(input);
+var create11 = (input) => from10(input);
 var of10 = (input) => {
   try {
-    return (0, import_fluture12.resolve)(from9(input));
+    return (0, import_fluture11.resolve)(from10(input));
   } catch (err) {
-    return (0, import_fluture12.reject)(err);
+    return (0, import_fluture11.reject)(err);
   }
 };
 var make10 = (input) => of10(input);
 var schemas10 = {
-  rawSchema: networkConfigSchema,
-  schema: networkConfigSchema.transform((val) => val)
+  rawSchema: installedPluginSchema,
+  schema: installedPluginSchema.transform((val) => val)
 };
 var rawSchema10 = schemas10.rawSchema;
-var internalSchema9 = networkConfigSchema;
+var internalSchema10 = installedPluginSchema;
 
-// Operation.ts
-var Operation_exports = {};
-__export(Operation_exports, {
+// LoadedConfig.ts
+var LoadedConfig_exports = {};
+__export(LoadedConfig_exports, {
   create: () => create12,
-  from: () => from10,
-  internalSchema: () => internalSchema10,
+  from: () => from11,
+  internalSchema: () => internalSchema11,
   make: () => make11,
   of: () => of11,
   rawSchema: () => rawSchema11,
   schemas: () => schemas11
 });
 
-// out/types/Operation.ts
-var import_fluture13 = require("fluture");
-var import_zod13 = require("zod");
-var from10 = (input) => {
+// out/types/LoadedConfig.ts
+var import_fluture12 = require("fluture");
+var import_zod12 = require("zod");
+var from11 = (input) => {
   try {
-    return operationSchema.parse(input);
+    return loadedConfigSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod13.ZodError) {
+    if (previous instanceof import_zod12.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["Operation is invalid:"]
+        ["Your .taq/config.json is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a Operation.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a LoadedConfig.");
   }
 };
-var create12 = (input) => from10(input);
+var create12 = (input) => from11(input);
 var of11 = (input) => {
   try {
-    return (0, import_fluture13.resolve)(from10(input));
+    return (0, import_fluture12.resolve)(from11(input));
   } catch (err) {
-    return (0, import_fluture13.reject)(err);
+    return (0, import_fluture12.reject)(err);
   }
 };
 var make11 = (input) => of11(input);
 var schemas11 = {
-  rawSchema: operationSchema,
-  schema: operationSchema.transform((val) => val)
+  rawSchema: loadedConfigSchema,
+  schema: loadedConfigSchema.transform((val) => val)
 };
 var rawSchema11 = schemas11.rawSchema;
-var internalSchema10 = operationSchema;
+var internalSchema11 = loadedConfigSchema;
 
-// Option.ts
-var Option_exports = {};
-__export(Option_exports, {
+// MetadataConfig.ts
+var MetadataConfig_exports = {};
+__export(MetadataConfig_exports, {
   create: () => create13,
-  from: () => from11,
-  internalSchema: () => internalSchema11,
+  from: () => from12,
+  internalSchema: () => internalSchema12,
   make: () => make12,
   of: () => of12,
   rawSchema: () => rawSchema12,
   schemas: () => schemas12
 });
 
-// out/types/Option.ts
-var import_fluture14 = require("fluture");
-var import_zod14 = require("zod");
-var from11 = (input) => {
+// out/types/MetadataConfig.ts
+var import_fluture13 = require("fluture");
+var import_zod13 = require("zod");
+var from12 = (input) => {
   try {
-    return optionSchema.parse(input);
+    return metadataConfigSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod14.ZodError) {
+    if (previous instanceof import_zod13.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["Option is invalid:"]
+        ["MetadataConfig is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a Option.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a MetadataConfig.");
   }
 };
-var create13 = (input) => from11(input);
+var create13 = (input) => from12(input);
 var of12 = (input) => {
   try {
-    return (0, import_fluture14.resolve)(from11(input));
+    return (0, import_fluture13.resolve)(from12(input));
   } catch (err) {
-    return (0, import_fluture14.reject)(err);
+    return (0, import_fluture13.reject)(err);
   }
 };
 var make12 = (input) => of12(input);
 var schemas12 = {
-  rawSchema: optionSchema,
-  schema: optionSchema.transform((val) => val)
+  rawSchema: metadataConfigSchema,
+  schema: metadataConfigSchema.transform((val) => val)
 };
 var rawSchema12 = schemas12.rawSchema;
-var internalSchema11 = optionSchema;
+var internalSchema12 = metadataConfigSchema;
 
-// ParsedOperation.ts
-var ParsedOperation_exports = {};
-__export(ParsedOperation_exports, {
+// NetworkAccountConfig.ts
+var NetworkAccountConfig_exports = {};
+__export(NetworkAccountConfig_exports, {
   create: () => create14,
-  from: () => from12,
-  internalSchema: () => internalSchema12,
+  from: () => from13,
+  internalSchema: () => internalSchema13,
   make: () => make13,
   of: () => of13,
   rawSchema: () => rawSchema13,
   schemas: () => schemas13
 });
 
-// out/types/ParsedOperation.ts
-var import_fluture15 = require("fluture");
-var import_zod15 = require("zod");
-var from12 = (input) => {
+// out/types/NetworkAccountConfig.ts
+var import_fluture14 = require("fluture");
+var import_zod14 = require("zod");
+var from13 = (input) => {
   try {
-    return parsedOperationSchema.parse(input);
+    return networkAccountConfigSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod15.ZodError) {
+    if (previous instanceof import_zod14.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["ParsedOperation is invalid:"]
+        ["NetworkAccountConfig is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a ParsedOperation.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a NetworkAccountConfig.");
   }
 };
-var create14 = (input) => from12(input);
+var create14 = (input) => from13(input);
 var of13 = (input) => {
   try {
-    return (0, import_fluture15.resolve)(from12(input));
+    return (0, import_fluture14.resolve)(from13(input));
   } catch (err) {
-    return (0, import_fluture15.reject)(err);
+    return (0, import_fluture14.reject)(err);
   }
 };
 var make13 = (input) => of13(input);
 var schemas13 = {
-  rawSchema: parsedOperationSchema,
-  schema: parsedOperationSchema.transform((val) => val)
+  rawSchema: networkAccountConfigSchema,
+  schema: networkAccountConfigSchema.transform((val) => val)
 };
 var rawSchema13 = schemas13.rawSchema;
-var internalSchema12 = parsedOperationSchema;
+var internalSchema13 = networkAccountConfigSchema;
 
-// ParsedTemplate.ts
-var ParsedTemplate_exports = {};
-__export(ParsedTemplate_exports, {
+// NetworkConfig.ts
+var NetworkConfig_exports = {};
+__export(NetworkConfig_exports, {
   create: () => create15,
-  from: () => from13,
-  internalSchema: () => internalSchema13,
+  from: () => from14,
+  internalSchema: () => internalSchema14,
   make: () => make14,
   of: () => of14,
   rawSchema: () => rawSchema14,
   schemas: () => schemas14
 });
 
-// out/types/ParsedTemplate.ts
-var import_fluture16 = require("fluture");
-var import_zod16 = require("zod");
-var from13 = (input) => {
+// out/types/NetworkConfig.ts
+var import_fluture15 = require("fluture");
+var import_zod15 = require("zod");
+var from14 = (input) => {
   try {
-    return parsedTemplateSchema.parse(input);
+    return networkConfigSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod16.ZodError) {
+    if (previous instanceof import_zod15.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["ParsedTemplate is invalid:"]
+        ["NetworkConfig is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a ParsedTemplate.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a NetworkConfig.");
   }
 };
-var create15 = (input) => from13(input);
+var create15 = (input) => from14(input);
 var of14 = (input) => {
   try {
-    return (0, import_fluture16.resolve)(from13(input));
+    return (0, import_fluture15.resolve)(from14(input));
   } catch (err) {
-    return (0, import_fluture16.reject)(err);
+    return (0, import_fluture15.reject)(err);
   }
 };
 var make14 = (input) => of14(input);
 var schemas14 = {
-  rawSchema: parsedTemplateSchema,
-  schema: parsedTemplateSchema.transform((val) => val)
+  rawSchema: networkConfigSchema,
+  schema: networkConfigSchema.transform((val) => val)
 };
 var rawSchema14 = schemas14.rawSchema;
-var internalSchema13 = parsedTemplateSchema;
-
-// PersistentState.ts
-var PersistentState_exports = {};
-__export(PersistentState_exports, {
-  create: () => create18,
-  factory: () => factory3,
-  generatedSchemas: () => generatedSchemas3,
-  internalSchema: () => internalSchema16,
-  make: () => make17,
-  of: () => of17,
-  rawSchema: () => rawSchema18,
-  schemas: () => schemas18
-});
+var internalSchema14 = networkConfigSchema;
 
-// SHA256.ts
-var SHA256_exports = {};
-__export(SHA256_exports, {
-  Crypto: () => Crypto,
+// NonEmptyString.ts
+var NonEmptyString_exports = {};
+__export(NonEmptyString_exports, {
   create: () => create16,
-  internalSchema: () => internalSchema14,
+  from: () => from15,
+  internalSchema: () => internalSchema15,
   make: () => make15,
   of: () => of15,
   rawSchema: () => rawSchema15,
-  schemas: () => schemas15,
-  toSHA256: () => toSHA256
+  schemas: () => schemas15
 });
-var import_fluture17 = require("fluture");
-var import_rambda = require("rambda");
-var import_zod17 = require("zod");
-var eager2 = (f) => (0, import_fluture17.promise)(
-  (0, import_fluture17.mapRej)((err) => new E_TaqError(err))(f)
-);
-var Crypto = class {
-  constructor() {
-    this.subtle = {
-      digest(_method, _data) {
-        return new ArrayBuffer(50);
-      }
-    };
+
+// out/types/NonEmptyString.ts
+var import_fluture16 = require("fluture");
+var import_zod16 = require("zod");
+var from15 = (input) => {
+  try {
+    return nonEmptyStringSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod16.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["NonEmptyString is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a NonEmptyString.");
   }
 };
-var getSubtleCrypto = async () => {
-  if ((0, import_rambda.has)("SubtleCrypto", globalThis)) {
-    return Promise.resolve(crypto.subtle);
+var create16 = (input) => from15(input);
+var of15 = (input) => {
+  try {
+    return (0, import_fluture16.resolve)(from15(input));
+  } catch (err) {
+    return (0, import_fluture16.reject)(err);
   }
-  const { Crypto: Crypto2 } = await import("@peculiar/webcrypto");
-  const webcrypto = new Crypto2();
-  return Promise.resolve(webcrypto.subtle);
-};
-var rawSchema15 = import_zod17.z.string({ description: "SHA256" }).length(64);
-var { schemas: generatedSchemas2, factory: factory2 } = Base_default({
-  isStringLike: true,
-  rawSchema: rawSchema15,
-  parseErrMsg: (value) => `${value} is an invalid SHA256 hash`,
-  unknownErrMsg: (value) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`
-});
-var toSHA256 = async (value) => {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(value);
-  const hash = await (await getSubtleCrypto()).digest("SHA-256", data);
-  const hashArray = Array.from(new Uint8Array(hash));
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  return eager2(factory2.make(hashHex));
 };
-var internalSchema14 = generatedSchemas2.schema;
-var { create: create16, of: of15, make: make15 } = factory2;
+var make15 = (input) => of15(input);
 var schemas15 = {
-  ...generatedSchemas2,
-  schema: generatedSchemas2.schema.transform((val) => val)
+  rawSchema: nonEmptyStringSchema,
+  schema: nonEmptyStringSchema.transform((val) => val)
 };
+var rawSchema15 = schemas15.rawSchema;
+var internalSchema15 = nonEmptyStringSchema;
 
-// out/types/Timestamp.ts
-var import_fluture18 = require("fluture");
-var import_zod18 = require("zod");
+// Operation.ts
+var Operation_exports = {};
+__export(Operation_exports, {
+  create: () => create17,
+  from: () => from16,
+  internalSchema: () => internalSchema16,
+  make: () => make16,
+  of: () => of16,
+  rawSchema: () => rawSchema16,
+  schemas: () => schemas16
+});
+
+// out/types/Operation.ts
+var import_fluture17 = require("fluture");
+var import_zod17 = require("zod");
+var from16 = (input) => {
+  try {
+    return operationSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod17.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Operation is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Operation.");
+  }
+};
+var create17 = (input) => from16(input);
+var of16 = (input) => {
+  try {
+    return (0, import_fluture17.resolve)(from16(input));
+  } catch (err) {
+    return (0, import_fluture17.reject)(err);
+  }
+};
+var make16 = (input) => of16(input);
 var schemas16 = {
-  rawSchema: timestampSchema,
-  schema: timestampSchema.transform((val) => val)
+  rawSchema: operationSchema,
+  schema: operationSchema.transform((val) => val)
 };
 var rawSchema16 = schemas16.rawSchema;
+var internalSchema16 = operationSchema;
 
-// Verb.ts
-var Verb_exports = {};
-__export(Verb_exports, {
-  create: () => create17,
-  from: () => from14,
-  internalSchema: () => internalSchema15,
-  make: () => make16,
-  of: () => of16,
+// Option.ts
+var Option_exports = {};
+__export(Option_exports, {
+  create: () => create18,
+  from: () => from17,
+  internalSchema: () => internalSchema17,
+  make: () => make17,
+  of: () => of17,
   rawSchema: () => rawSchema17,
   schemas: () => schemas17
 });
 
-// out/types/Verb.ts
-var import_fluture19 = require("fluture");
-var import_zod19 = require("zod");
-var from14 = (input) => {
+// out/types/Option.ts
+var import_fluture18 = require("fluture");
+var import_zod18 = require("zod");
+var from17 = (input) => {
   try {
-    return verbSchema.parse(input);
+    return optionSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod19.ZodError) {
+    if (previous instanceof import_zod18.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["Verb is invalid:"]
+        ["Option is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a Verb.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Option.");
   }
 };
-var create17 = (input) => from14(input);
-var of16 = (input) => {
+var create18 = (input) => from17(input);
+var of17 = (input) => {
   try {
-    return (0, import_fluture19.resolve)(from14(input));
+    return (0, import_fluture18.resolve)(from17(input));
   } catch (err) {
-    return (0, import_fluture19.reject)(err);
+    return (0, import_fluture18.reject)(err);
   }
 };
-var make16 = (input) => of16(input);
+var make17 = (input) => of17(input);
 var schemas17 = {
-  rawSchema: verbSchema,
-  schema: verbSchema.transform((val) => val)
+  rawSchema: optionSchema,
+  schema: optionSchema.transform((val) => val)
 };
 var rawSchema17 = schemas17.rawSchema;
-var internalSchema15 = verbSchema;
+var internalSchema17 = optionSchema;
 
-// PersistentState.ts
-var import_zod20 = require("zod");
-var rawOpSchema = import_zod20.z.object({
-  hash: rawSchema15.describe("state.op.hash"),
-  time: rawSchema16.describe("state.op.time"),
-  output: import_zod20.z.unknown().describe("state.op.output")
-}).describe("Persistent State Operation");
-var rawTaskSchema = import_zod20.z.object({
-  task: schemas17.rawSchema,
-  plugin: import_zod20.z.string().min(1),
-  time: rawSchema16.describe("state.task.time"),
-  output: import_zod20.z.unknown().describe("state.task.output")
-});
-var internalOpSchema = import_zod20.z.object({
-  hash: schemas15.schema.describe("state.op.hash"),
-  time: schemas16.schema.describe("state.op.time"),
-  output: import_zod20.z.unknown().describe("state.op.output")
-});
-var internalTaskSchema = import_zod20.z.object({
-  task: schemas17.schema,
-  plugin: import_zod20.z.string().min(1),
-  time: schemas16.schema.describe("state.task.time"),
-  output: import_zod20.z.unknown().describe("state.op.output")
-});
-var rawSchema18 = import_zod20.z.object({
-  operations: import_zod20.z.record(rawOpSchema),
-  tasks: import_zod20.z.record(rawTaskSchema)
-});
-var internalSchema16 = import_zod20.z.object({
-  operations: import_zod20.z.record(internalOpSchema),
-  tasks: import_zod20.z.record(internalTaskSchema)
-}).transform((val) => ({
-  operations: val.operations,
-  tasks: val.tasks
-}));
-var { schemas: generatedSchemas3, factory: factory3 } = Base_default({
-  rawSchema: rawSchema18,
-  parseErrMsg: `The persistent state is invalid`,
-  unknownErrMsg: `Something went wrong trying to parse the persistent state`
+// ParsedOperation.ts
+var ParsedOperation_exports = {};
+__export(ParsedOperation_exports, {
+  create: () => create19,
+  from: () => from18,
+  internalSchema: () => internalSchema18,
+  make: () => make18,
+  of: () => of18,
+  rawSchema: () => rawSchema18,
+  schemas: () => schemas18
 });
-var { create: create18, of: of17, make: make17 } = factory3;
+
+// out/types/ParsedOperation.ts
+var import_fluture19 = require("fluture");
+var import_zod19 = require("zod");
+var from18 = (input) => {
+  try {
+    return parsedOperationSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod19.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["ParsedOperation is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a ParsedOperation.");
+  }
+};
+var create19 = (input) => from18(input);
+var of18 = (input) => {
+  try {
+    return (0, import_fluture19.resolve)(from18(input));
+  } catch (err) {
+    return (0, import_fluture19.reject)(err);
+  }
+};
+var make18 = (input) => of18(input);
 var schemas18 = {
-  ...generatedSchemas3,
-  schema: generatedSchemas3.schema.transform((val) => val)
+  rawSchema: parsedOperationSchema,
+  schema: parsedOperationSchema.transform((val) => val)
 };
+var rawSchema18 = schemas18.rawSchema;
+var internalSchema18 = parsedOperationSchema;
 
-// PluginActionName.ts
-var PluginActionName_exports = {};
-__export(PluginActionName_exports, {
-  create: () => create19,
-  from: () => from15,
-  internalSchema: () => internalSchema17,
-  make: () => make18,
-  of: () => of18,
+// ParsedTemplate.ts
+var ParsedTemplate_exports = {};
+__export(ParsedTemplate_exports, {
+  create: () => create20,
+  from: () => from19,
+  internalSchema: () => internalSchema19,
+  make: () => make19,
+  of: () => of19,
   rawSchema: () => rawSchema19,
   schemas: () => schemas19
 });
 
-// out/types/PluginActionName.ts
+// out/types/ParsedTemplate.ts
 var import_fluture20 = require("fluture");
-var import_zod21 = require("zod");
-var from15 = (input) => {
+var import_zod20 = require("zod");
+var from19 = (input) => {
   try {
-    return pluginActionNameSchema.parse(input);
+    return parsedTemplateSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod21.ZodError) {
+    if (previous instanceof import_zod20.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["PluginActionName is invalid:"]
+        ["ParsedTemplate is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginActionName.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a ParsedTemplate.");
   }
 };
-var create19 = (input) => from15(input);
-var of18 = (input) => {
+var create20 = (input) => from19(input);
+var of19 = (input) => {
   try {
-    return (0, import_fluture20.resolve)(from15(input));
+    return (0, import_fluture20.resolve)(from19(input));
   } catch (err) {
     return (0, import_fluture20.reject)(err);
   }
 };
-var make18 = (input) => of18(input);
+var make19 = (input) => of19(input);
 var schemas19 = {
-  rawSchema: pluginActionNameSchema,
-  schema: pluginActionNameSchema.transform((val) => val)
+  rawSchema: parsedTemplateSchema,
+  schema: parsedTemplateSchema.transform((val) => val)
 };
 var rawSchema19 = schemas19.rawSchema;
-var internalSchema17 = pluginActionNameSchema;
+var internalSchema19 = parsedTemplateSchema;
 
-// PluginInfo.ts
-var PluginInfo_exports = {};
-__export(PluginInfo_exports, {
-  create: () => create22,
-  factory: () => factory4,
+// PluginActionName.ts
+var PluginActionName_exports = {};
+__export(PluginActionName_exports, {
+  create: () => create21,
+  from: () => from20,
   internalSchema: () => internalSchema20,
-  make: () => make21,
-  of: () => of21,
-  rawSchema: () => rawSchema22,
-  schemas: () => schemas22
-});
-
-// Task.ts
-var Task_exports = {};
-__export(Task_exports, {
-  create: () => create20,
-  from: () => from16,
-  internalSchema: () => internalSchema18,
-  make: () => make19,
-  of: () => of19,
+  make: () => make20,
+  of: () => of20,
   rawSchema: () => rawSchema20,
   schemas: () => schemas20
 });
 
-// out/types/Task.ts
+// out/types/PluginActionName.ts
 var import_fluture21 = require("fluture");
-var import_zod22 = require("zod");
-var from16 = (input) => {
+var import_zod21 = require("zod");
+var from20 = (input) => {
   try {
-    return taskSchema.parse(input);
+    return pluginActionNameSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod22.ZodError) {
+    if (previous instanceof import_zod21.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["Task is invalid:"]
+        ["PluginActionName is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a Task.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginActionName.");
   }
 };
-var create20 = (input) => from16(input);
-var of19 = (input) => {
+var create21 = (input) => from20(input);
+var of20 = (input) => {
   try {
-    return (0, import_fluture21.resolve)(from16(input));
+    return (0, import_fluture21.resolve)(from20(input));
   } catch (err) {
     return (0, import_fluture21.reject)(err);
   }
 };
-var make19 = (input) => of19(input);
+var make20 = (input) => of20(input);
 var schemas20 = {
-  rawSchema: taskSchema,
-  schema: taskSchema.transform((val) => val)
+  rawSchema: pluginActionNameSchema,
+  schema: pluginActionNameSchema.transform((val) => val)
 };
 var rawSchema20 = schemas20.rawSchema;
-var internalSchema18 = taskSchema;
+var internalSchema20 = pluginActionNameSchema;
 
-// VersionNumber.ts
-var VersionNumber_exports = {};
-__export(VersionNumber_exports, {
-  create: () => create21,
-  from: () => from17,
-  internalSchema: () => internalSchema19,
-  make: () => make20,
-  of: () => of20,
+// PluginDependenciesResponse.ts
+var PluginDependenciesResponse_exports = {};
+__export(PluginDependenciesResponse_exports, {
+  create: () => create22,
+  from: () => from21,
+  internalSchema: () => internalSchema21,
+  make: () => make21,
+  of: () => of21,
   rawSchema: () => rawSchema21,
   schemas: () => schemas21
 });
 
-// out/types/VersionNumber.ts
+// out/types/PluginDependenciesResponse.ts
 var import_fluture22 = require("fluture");
-var import_zod23 = require("zod");
-var from17 = (input) => {
+var import_zod22 = require("zod");
+var from21 = (input) => {
   try {
-    return versionNumberSchema.parse(input);
+    return pluginDependenciesResponseSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod23.ZodError) {
+    if (previous instanceof import_zod22.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["VersionNumber is invalid:"]
+        ["PluginDependenciesResponse is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a VersionNumber.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginDependenciesResponse.");
   }
 };
-var create21 = (input) => from17(input);
-var of20 = (input) => {
+var create22 = (input) => from21(input);
+var of21 = (input) => {
   try {
-    return (0, import_fluture22.resolve)(from17(input));
+    return (0, import_fluture22.resolve)(from21(input));
   } catch (err) {
     return (0, import_fluture22.reject)(err);
   }
 };
-var make20 = (input) => of20(input);
+var make21 = (input) => of21(input);
 var schemas21 = {
-  rawSchema: versionNumberSchema,
-  schema: versionNumberSchema.transform((val) => val)
+  rawSchema: pluginDependenciesResponseSchema,
+  schema: pluginDependenciesResponseSchema.transform((val) => val)
 };
 var rawSchema21 = schemas21.rawSchema;
-var internalSchema19 = versionNumberSchema;
-
-// PluginInfo.ts
-var import_zod24 = require("zod");
-var rawSchema22 = import_zod24.z.object({
-  name: import_zod24.z.string({ description: "Plugin Name" }).min(1),
-  version: rawSchema21.describe("Plugin Version #"),
-  schema: rawSchema21.describe("Plugin Schema Version #"),
-  alias: rawSchema.describe("Plugin Alias"),
-  postInstall: import_zod24.z.string().optional(),
-  tasks: import_zod24.z.preprocess(
-    (val) => val != null ? val : [],
-    import_zod24.z.array(
-      schemas20.schema.describe("Plugin Task"),
-      { description: "Plugin Tasks" }
-    )
-  ).optional(),
-  operations: import_zod24.z.preprocess(
-    (val) => val != null ? val : [],
-    import_zod24.z.array(
-      schemas13.schema.describe("Plugin Operation"),
-      { description: "Plugin Operations" }
-    )
-  ).optional(),
-  templates: import_zod24.z.preprocess(
-    (val) => val != null ? val : [],
-    import_zod24.z.array(
-      schemas14.schema.describe("Plugin Template")
-    )
-  ).optional()
-});
-var internalSchema20 = rawSchema22.extend({
-  version: schemas21.schema.describe("Plugin Version #"),
-  schema: schemas21.schema.describe("Plugin Schema Version #"),
-  alias: schemas.schema.describe("Plugin Alias"),
-  tasks: import_zod24.z.preprocess(
-    (val) => val != null ? val : [],
-    import_zod24.z.array(
-      schemas20.schema.describe("Plugin Task"),
-      { description: "Plugin Tasks" }
-    )
-  ).optional(),
-  operations: import_zod24.z.preprocess(
-    (val) => val != null ? val : [],
-    import_zod24.z.array(
-      schemas13.schema.describe("Plugin Operation"),
-      { description: "Plugin Operations" }
-    )
-  ).optional(),
-  templates: import_zod24.z.preprocess(
-    (val) => val != null ? val : [],
-    import_zod24.z.array(
-      schemas14.schema.describe("Plugin Template")
-    )
-  ).optional()
-}).describe("Plugin Schema");
-var { schemas: schemas22, factory: factory4 } = Base_default({
-  rawSchema: rawSchema22,
-  internalSchema: internalSchema20,
-  parseErrMsg: "The schema returned from the plugin is invalid",
-  unknownErrMsg: "Something went wrong parsing the schema from a plugin"
-});
-var { create: create22, of: of21, make: make21 } = factory4;
+var internalSchema21 = pluginDependenciesResponseSchema;
 
 // PluginJsonResponse.ts
 var PluginJsonResponse_exports = {};
 __export(PluginJsonResponse_exports, {
   create: () => create23,
-  from: () => from18,
-  internalSchema: () => internalSchema21,
+  from: () => from22,
+  internalSchema: () => internalSchema22,
   make: () => make22,
   of: () => of22,
-  rawSchema: () => rawSchema23,
-  schemas: () => schemas23
+  rawSchema: () => rawSchema22,
+  schemas: () => schemas22
 });
 
 // out/types/PluginJsonResponse.ts
 var import_fluture23 = require("fluture");
-var import_zod25 = require("zod");
-var from18 = (input) => {
+var import_zod23 = require("zod");
+var from22 = (input) => {
   try {
     return pluginJsonResponseSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod25.ZodError) {
+    if (previous instanceof import_zod23.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
@@ -1904,204 +1573,142 @@ var from18 = (input) => {
     throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginJsonResponse.");
   }
 };
-var create23 = (input) => from18(input);
+var create23 = (input) => from22(input);
 var of22 = (input) => {
   try {
-    return (0, import_fluture23.resolve)(from18(input));
+    return (0, import_fluture23.resolve)(from22(input));
   } catch (err) {
     return (0, import_fluture23.reject)(err);
   }
 };
 var make22 = (input) => of22(input);
-var schemas23 = {
+var schemas22 = {
   rawSchema: pluginJsonResponseSchema,
   schema: pluginJsonResponseSchema.transform((val) => val)
 };
-var rawSchema23 = schemas23.rawSchema;
-var internalSchema21 = pluginJsonResponseSchema;
+var rawSchema22 = schemas22.rawSchema;
+var internalSchema22 = pluginJsonResponseSchema;
 
-// PluginResponseEncoding.ts
-var PluginResponseEncoding_exports = {};
-__export(PluginResponseEncoding_exports, {
+// PluginProxyResponse.ts
+var PluginProxyResponse_exports = {};
+__export(PluginProxyResponse_exports, {
   create: () => create24,
-  from: () => from19,
-  internalSchema: () => internalSchema22,
+  from: () => from23,
+  internalSchema: () => internalSchema23,
   make: () => make23,
   of: () => of23,
-  rawSchema: () => rawSchema24,
-  schemas: () => schemas24
+  rawSchema: () => rawSchema23,
+  schemas: () => schemas23
 });
 
-// out/types/PluginResponseEncoding.ts
+// out/types/PluginProxyResponse.ts
 var import_fluture24 = require("fluture");
-var import_zod26 = require("zod");
-var from19 = (input) => {
+var import_zod24 = require("zod");
+var from23 = (input) => {
   try {
-    return pluginResponseEncodingSchema.parse(input);
+    return pluginProxyResponseSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod26.ZodError) {
+    if (previous instanceof import_zod24.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["PluginResponseEncoding is invalid:"]
+        ["PluginProxyResponse is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginResponseEncoding.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginProxyResponse.");
   }
 };
-var create24 = (input) => from19(input);
+var create24 = (input) => from23(input);
 var of23 = (input) => {
   try {
-    return (0, import_fluture24.resolve)(from19(input));
+    return (0, import_fluture24.resolve)(from23(input));
   } catch (err) {
     return (0, import_fluture24.reject)(err);
   }
 };
 var make23 = (input) => of23(input);
-var schemas24 = {
-  rawSchema: pluginResponseEncodingSchema,
-  schema: pluginResponseEncodingSchema.transform((val) => val)
+var schemas23 = {
+  rawSchema: pluginProxyResponseSchema,
+  schema: pluginProxyResponseSchema.transform((val) => val)
 };
-var rawSchema24 = schemas24.rawSchema;
-var internalSchema22 = pluginResponseEncodingSchema;
-
-// PluginSchema.ts
-var PluginSchema_exports = {};
-__export(PluginSchema_exports, {
-  create: () => create27,
-  factory: () => factory5,
-  generatedSchemas: () => generatedSchemas4,
-  make: () => make25,
-  of: () => of25,
-  rawSchema: () => rawSchema26,
-  schemas: () => schemas26
-});
+var rawSchema23 = schemas23.rawSchema;
+var internalSchema23 = pluginProxyResponseSchema;
 
-// Template.ts
-var Template_exports = {};
-__export(Template_exports, {
-  create: () => create26,
-  from: () => from20,
-  internalSchema: () => internalSchema23,
+// PluginResponseEncoding.ts
+var PluginResponseEncoding_exports = {};
+__export(PluginResponseEncoding_exports, {
+  create: () => create25,
+  from: () => from24,
+  internalSchema: () => internalSchema24,
   make: () => make24,
   of: () => of24,
-  rawSchema: () => rawSchema25,
-  schemas: () => schemas25
+  rawSchema: () => rawSchema24,
+  schemas: () => schemas24
 });
 
-// out/types/Template.ts
+// out/types/PluginResponseEncoding.ts
 var import_fluture25 = require("fluture");
-var import_zod27 = require("zod");
-var from20 = (input) => {
+var import_zod25 = require("zod");
+var from24 = (input) => {
   try {
-    return templateSchema.parse(input);
+    return pluginResponseEncodingSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod27.ZodError) {
+    if (previous instanceof import_zod25.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["Template is invalid:"]
+        ["PluginResponseEncoding is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a Template.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginResponseEncoding.");
   }
 };
-var create25 = (input) => from20(input);
+var create25 = (input) => from24(input);
 var of24 = (input) => {
   try {
-    return (0, import_fluture25.resolve)(from20(input));
+    return (0, import_fluture25.resolve)(from24(input));
   } catch (err) {
     return (0, import_fluture25.reject)(err);
   }
 };
 var make24 = (input) => of24(input);
-var schemas25 = {
-  rawSchema: templateSchema,
-  schema: templateSchema.transform((val) => val)
-};
-var rawSchema25 = schemas25.rawSchema;
-var internalSchema23 = templateSchema;
-
-// Template.ts
-function create26(args) {
-  return create25(args);
-}
-
-// PluginSchema.ts
-var import_zod28 = require("zod");
-var internalSchema24 = internalSchema20.extend({
-  operations: import_zod28.z.preprocess(
-    (val) => val != null ? val : [],
-    import_zod28.z.array(
-      schemas11.schema,
-      { description: "ParsedOperations" }
-    ).optional()
-  ),
-  templates: import_zod28.z.preprocess(
-    (val) => val != null ? val : [],
-    import_zod28.z.array(
-      schemas25.schema
-    ).optional()
-  )
-}).passthrough().describe("ParsedPluginInfo");
-var rawSchema26 = rawSchema22.extend({
-  name: rawSchema.optional(),
-  operations: import_zod28.z.preprocess(
-    (val) => val != null ? val : [],
-    import_zod28.z.array(
-      rawSchema11,
-      { description: "ParsedOperation" }
-    )
-  ).optional(),
-  templates: import_zod28.z.preprocess(
-    (val) => val != null ? val : [],
-    import_zod28.z.array(
-      schemas25.schema
-    ).optional()
-  )
-}).passthrough().describe("ParsedPluginInfo");
-var { schemas: generatedSchemas4, factory: factory5 } = Base_default({
-  rawSchema: rawSchema26,
-  internalSchema: internalSchema24,
-  parseErrMsg: (value) => `The following plugin info gave us trouble when parsing the following plugin information: ${value}`,
-  unknownErrMsg: "Something went wrong trying to parse the plugin information"
-});
-var { create: create27, of: of25, make: make25 } = factory5;
-var schemas26 = {
-  ...generatedSchemas4,
-  schema: generatedSchemas4.schema.transform((val) => val)
+var schemas24 = {
+  rawSchema: pluginResponseEncodingSchema,
+  schema: pluginResponseEncodingSchema.transform((val) => val)
 };
+var rawSchema24 = schemas24.rawSchema;
+var internalSchema24 = pluginResponseEncodingSchema;
 
 // PositionalArg.ts
 var PositionalArg_exports = {};
 __export(PositionalArg_exports, {
-  create: () => create28,
-  from: () => from21,
+  create: () => create26,
+  from: () => from25,
   internalSchema: () => internalSchema25,
-  make: () => make26,
-  of: () => of26,
-  rawSchema: () => rawSchema27,
-  schemas: () => schemas27
+  make: () => make25,
+  of: () => of25,
+  rawSchema: () => rawSchema25,
+  schemas: () => schemas25
 });
 
 // out/types/PositionalArg.ts
 var import_fluture26 = require("fluture");
-var import_zod29 = require("zod");
-var from21 = (input) => {
+var import_zod26 = require("zod");
+var from25 = (input) => {
   try {
     return positionalArgSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod29.ZodError) {
+    if (previous instanceof import_zod26.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
@@ -2116,502 +1723,571 @@ var from21 = (input) => {
     throw toParseUnknownErr(previous, "There was a problem trying to parse a PositionalArg.");
   }
 };
-var create28 = (input) => from21(input);
-var of26 = (input) => {
+var create26 = (input) => from25(input);
+var of25 = (input) => {
   try {
-    return (0, import_fluture26.resolve)(from21(input));
+    return (0, import_fluture26.resolve)(from25(input));
   } catch (err) {
     return (0, import_fluture26.reject)(err);
   }
 };
-var make26 = (input) => of26(input);
-var schemas27 = {
+var make25 = (input) => of25(input);
+var schemas25 = {
   rawSchema: positionalArgSchema,
   schema: positionalArgSchema.transform((val) => val)
 };
-var rawSchema27 = schemas27.rawSchema;
+var rawSchema25 = schemas25.rawSchema;
 var internalSchema25 = positionalArgSchema;
 
-// RequestArgs.ts
-var RequestArgs_exports = {};
-__export(RequestArgs_exports, {
-  create: () => create29,
-  from: () => from22,
+// Provisioner.ts
+var Provisioner_exports = {};
+__export(Provisioner_exports, {
+  create: () => create27,
+  from: () => from26,
   internalSchema: () => internalSchema26,
-  make: () => make27,
-  of: () => of27,
-  rawSchema: () => rawSchema28,
-  schemas: () => schemas28
+  make: () => make26,
+  of: () => of26,
+  rawSchema: () => rawSchema26,
+  schemas: () => schemas26
 });
 
-// out/types/RequestArgs.ts
+// out/types/Provisioner.ts
 var import_fluture27 = require("fluture");
-var import_zod30 = require("zod");
-var from22 = (input) => {
+var import_zod27 = require("zod");
+var from26 = (input) => {
   try {
-    return requestArgsSchema.parse(input);
+    return provisionerSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod30.ZodError) {
+    if (previous instanceof import_zod27.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["RequestArgs is invalid:"]
+        ["Provisioner is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a RequestArgs.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Provisioner.");
   }
 };
-var create29 = (input) => from22(input);
-var of27 = (input) => {
+var create27 = (input) => from26(input);
+var of26 = (input) => {
   try {
-    return (0, import_fluture27.resolve)(from22(input));
+    return (0, import_fluture27.resolve)(from26(input));
   } catch (err) {
     return (0, import_fluture27.reject)(err);
   }
 };
-var make27 = (input) => of27(input);
-var schemas28 = {
-  rawSchema: requestArgsSchema,
-  schema: requestArgsSchema.transform((val) => val)
+var make26 = (input) => of26(input);
+var schemas26 = {
+  rawSchema: provisionerSchema,
+  schema: provisionerSchema.transform((val) => val)
 };
-var rawSchema28 = schemas28.rawSchema;
-var internalSchema26 = requestArgsSchema;
+var rawSchema26 = schemas26.rawSchema;
+var internalSchema26 = provisionerSchema;
 
-// SandboxAccountConfig.ts
-var SandboxAccountConfig_exports = {};
-__export(SandboxAccountConfig_exports, {
-  create: () => create30,
-  from: () => from23,
+// ProvisionerID.ts
+var ProvisionerID_exports = {};
+__export(ProvisionerID_exports, {
+  create: () => create28,
+  from: () => from27,
   internalSchema: () => internalSchema27,
-  make: () => make28,
-  of: () => of28,
-  rawSchema: () => rawSchema29,
-  schemas: () => schemas29
+  make: () => make27,
+  of: () => of27,
+  rawSchema: () => rawSchema27,
+  schemas: () => schemas27
 });
 
-// out/types/SandboxAccountConfig.ts
+// out/types/ProvisionerID.ts
 var import_fluture28 = require("fluture");
-var import_zod31 = require("zod");
-var from23 = (input) => {
+var import_zod28 = require("zod");
+var from27 = (input) => {
   try {
-    return sandboxAccountConfigSchema.parse(input);
+    return provisionerIDSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod31.ZodError) {
+    if (previous instanceof import_zod28.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["SandboxAccountConfig is invalid:"]
+        ["ProvisionerID is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a SandboxAccountConfig.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a ProvisionerID.");
   }
 };
-var create30 = (input) => from23(input);
-var of28 = (input) => {
+var create28 = (input) => from27(input);
+var of27 = (input) => {
   try {
-    return (0, import_fluture28.resolve)(from23(input));
+    return (0, import_fluture28.resolve)(from27(input));
   } catch (err) {
     return (0, import_fluture28.reject)(err);
   }
 };
-var make28 = (input) => of28(input);
-var schemas29 = {
-  rawSchema: sandboxAccountConfigSchema,
-  schema: sandboxAccountConfigSchema.transform((val) => val)
+var make27 = (input) => of27(input);
+var schemas27 = {
+  rawSchema: provisionerIDSchema,
+  schema: provisionerIDSchema.transform((val) => val)
 };
-var rawSchema29 = schemas29.rawSchema;
-var internalSchema27 = sandboxAccountConfigSchema;
+var rawSchema27 = schemas27.rawSchema;
+var internalSchema27 = provisionerIDSchema;
 
-// SandboxConfig.ts
-var SandboxConfig_exports = {};
-__export(SandboxConfig_exports, {
-  create: () => create31,
-  from: () => from24,
+// Provisions.ts
+var Provisions_exports = {};
+__export(Provisions_exports, {
+  create: () => create29,
+  from: () => from28,
   internalSchema: () => internalSchema28,
-  make: () => make29,
-  of: () => of29,
-  rawSchema: () => rawSchema30,
-  schemas: () => schemas30
+  make: () => make28,
+  of: () => of28,
+  rawSchema: () => rawSchema28,
+  schemas: () => schemas28
 });
 
-// out/types/SandboxConfig.ts
+// out/types/Provisions.ts
 var import_fluture29 = require("fluture");
-var import_zod32 = require("zod");
-var from24 = (input) => {
+var import_zod29 = require("zod");
+var from28 = (input) => {
   try {
-    return sandboxConfigSchema.parse(input);
+    return provisionsSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod32.ZodError) {
+    if (previous instanceof import_zod29.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["SandboxConfig is invalid:"]
+        ["Provisions is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a SandboxConfig.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Provisions.");
   }
 };
-var create31 = (input) => from24(input);
-var of29 = (input) => {
+var create29 = (input) => from28(input);
+var of28 = (input) => {
   try {
-    return (0, import_fluture29.resolve)(from24(input));
+    return (0, import_fluture29.resolve)(from28(input));
   } catch (err) {
     return (0, import_fluture29.reject)(err);
   }
 };
-var make29 = (input) => of29(input);
-var schemas30 = {
-  rawSchema: sandboxConfigSchema,
-  schema: sandboxConfigSchema.transform((val) => val)
-};
-var rawSchema30 = schemas30.rawSchema;
-var internalSchema28 = sandboxConfigSchema;
-
-// SanitizedAbsPath.ts
-var SanitizedAbsPath_exports = {};
-__export(SanitizedAbsPath_exports, {
-  create: () => create32,
-  factory: () => factory6,
-  generatedSchemas: () => generatedSchemas5,
-  make: () => make30,
-  of: () => of30,
-  rawSchema: () => rawSchema31,
-  schemas: () => schemas31
-});
-var path = __toESM(require("path"));
-var import_zod33 = require("zod");
-var rawSchema31 = import_zod33.z.string({ description: "SanitizedAbsPath" }).min(1);
-var { schemas: generatedSchemas5, factory: factory6 } = Base_default({
-  isStringLike: true,
-  rawSchema: rawSchema31,
-  transformer: (value) => path.resolve(value),
-  parseErrMsg: (value) => `${value} is an invalid absolute path`,
-  unknownErrMsg: (value) => `Something went wrong trying to parse the absolute path, ${value}`
-});
-var { create: create32, make: make30, of: of30 } = factory6;
-var schemas31 = {
-  ...generatedSchemas5,
-  schema: generatedSchemas5.schema.transform((val) => val)
+var make28 = (input) => of28(input);
+var schemas28 = {
+  rawSchema: provisionsSchema,
+  schema: provisionsSchema.transform((val) => val)
 };
+var rawSchema28 = schemas28.rawSchema;
+var internalSchema28 = provisionsSchema;
 
-// SanitizedArgs.ts
-var SanitizedArgs_exports = {};
-__export(SanitizedArgs_exports, {
-  create: () => create33,
-  createCreateTaskArgs: () => createCreateTaskArgs,
-  createInstallTaskArgs: () => createInstallTaskArgs,
-  createProvisionTaskArgs: () => createProvisionTaskArgs,
-  createScaffoldTaskArgs: () => createScaffoldTaskArgs,
-  createSetEnvTaskArgs: () => createSetEnvTaskArgs,
-  createTaskArgs: () => createTaskArgs,
-  createUninstallTaskArgs: () => createUninstallTaskArgs,
-  factory: () => factory7,
-  generatedSchemas: () => generatedSchemas6,
-  initRawSchema: () => initRawSchema,
-  installTaskArgs: () => installTaskArgs,
-  make: () => make31,
-  makeCreateTaskArgs: () => makeCreateTaskArgs,
-  makeInstallTaskArgs: () => makeInstallTaskArgs,
-  makeProvisionTaskArgs: () => makeProvisionTaskArgs,
-  makeScaffoldTaskArgs: () => makeScaffoldTaskArgs,
-  makeSetEnvTaskArgs: () => makeSetEnvTaskArgs,
-  makeUninstallTaskArgs: () => makeUninstallTaskArgs,
-  managePluginRawSchema: () => managePluginRawSchema,
-  of: () => of31,
-  ofCreateTaskArgs: () => ofCreateTaskArgs,
-  ofInstallTaskArgs: () => ofInstallTaskArgs,
-  ofProvisionTaskArgs: () => ofProvisionTaskArgs,
-  ofScaffoldTaskArgs: () => ofScaffoldTaskArgs,
-  ofSetEnvTaskArgs: () => ofSetEnvTaskArgs,
-  ofUninstallTaskArgs: () => ofUninstallTaskArgs,
-  provisionRawSchema: () => provisionRawSchema,
-  provisionTaskArgs: () => provisionTaskArgs,
-  rawSchema: () => rawSchema33,
-  scaffoldRawSchema: () => scaffoldRawSchema,
-  scaffoldTaskArgs: () => scaffoldTaskArgs,
-  schemas: () => schemas33,
-  setEnvRawSchema: () => setEnvRawSchema,
-  setEnvTaskArgs: () => setEnvTaskArgs,
-  templateRawSchema: () => templateRawSchema,
-  uninstallTaskArgs: () => uninstallTaskArgs
+// ProxyTaskArgs.ts
+var ProxyTaskArgs_exports = {};
+__export(ProxyTaskArgs_exports, {
+  create: () => create30,
+  from: () => from29,
+  internalSchema: () => internalSchema29,
+  make: () => make29,
+  of: () => of29,
+  rawSchema: () => rawSchema29,
+  schemas: () => schemas29
 });
 
-// out/types/NonEmptyString.ts
+// out/types/ProxyTaskArgs.ts
 var import_fluture30 = require("fluture");
-var import_zod34 = require("zod");
-var schemas32 = {
-  rawSchema: nonEmptyStringSchema,
-  schema: nonEmptyStringSchema.transform((val) => val)
+var import_zod30 = require("zod");
+var from29 = (input) => {
+  try {
+    return proxyTaskArgsSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod30.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["ProxyTaskArgs is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a ProxyTaskArgs.");
+  }
 };
-var rawSchema32 = schemas32.rawSchema;
-
-// SanitizedArgs.ts
-var import_zod35 = require("zod");
-var rawSchema33 = import_zod35.z.object({
-  _: import_zod35.z.array(import_zod35.z.union([import_zod35.z.string().min(1), import_zod35.z.number()])),
-  projectDir: schemas31.schema,
-  maxConcurrency: import_zod35.z.preprocess(
-    (val) => typeof val === "string" ? parseInt(val) : Number(val),
-    import_zod35.z.number().int().min(1).default(10)
-  ),
-  debug: import_zod35.z.preprocess(
-    (val) => Boolean(val),
-    import_zod35.z.boolean().default(false)
-  ),
-  disableState: import_zod35.z.preprocess(
-    (val) => Boolean(val),
-    import_zod35.z.boolean().default(false)
-  ),
-  logPluginRequests: import_zod35.z.preprocess(
-    (val) => Boolean(val),
-    import_zod35.z.boolean().default(false)
-  ),
-  fromVsCode: import_zod35.z.preprocess(
-    (val) => Boolean(val),
-    import_zod35.z.boolean().default(false)
-  ),
-  version: import_zod35.z.preprocess(
-    (val) => Boolean(val),
-    import_zod35.z.boolean().optional()
-  ),
-  build: import_zod35.z.preprocess(
-    (val) => Boolean(val),
-    import_zod35.z.boolean().optional()
-  ),
-  help: import_zod35.z.preprocess(
-    (val) => Boolean(val),
-    import_zod35.z.boolean().optional()
-  ),
-  yes: import_zod35.z.preprocess(
-    (val) => Boolean(val),
-    import_zod35.z.boolean().optional()
-  ),
-  plugin: schemas32.schema.optional(),
-  env: import_zod35.z.string().optional(),
-  quickstart: import_zod35.z.string().min(1).optional(),
-  setBuild: import_zod35.z.preprocess(
-    (val) => String(val),
-    import_zod35.z.string().min(3)
-  ),
-  setVersion: import_zod35.z.string().min(3),
-  pluginName: import_zod35.z.string().min(1).optional()
-}, { description: "Sanitizied Args" }).passthrough();
-var scaffoldRawSchema = rawSchema33.extend({
-  scaffoldProjectDir: import_zod35.z.string().min(1).transform((val) => val),
-  scaffoldUrl: import_zod35.z.string().min(1).url().transform((val) => val),
-  branch: import_zod35.z.string().min(1).optional()
-});
-var initRawSchema = rawSchema33.extend({
-  workflow: import_zod35.z.string().refine((val) => val === "ligo" || val === "smartpy" || val === "archetype" || val === "michelson").optional()
-});
-var provisionRawSchema = rawSchema33.extend({
-  operation: import_zod35.z.string().min(1).describe("Operation name"),
-  name: import_zod35.z.string().min(1).regex(
-    /^[a-z0-9]+[a-z0-9-_]$/,
-    "Provisioner name must consist of one or more letters/numbers and may not start with an underscore or dash."
-  ).describe("Provisioner name").optional()
-}).passthrough();
-var templateRawSchema = rawSchema33.extend({
-  template: import_zod35.z.string().min(1)
-}).passthrough();
-var managePluginRawSchema = rawSchema33.omit({ pluginName: true }).extend({
-  pluginName: import_zod35.z.string().min(1)
-});
-var setEnvRawSchema = rawSchema33.extend({
-  defaultEnvironment: import_zod35.z.string().min(1)
-});
-var { schemas: generatedSchemas6, factory: factory7 } = Base_default({
-  rawSchema: rawSchema33,
-  parseErrMsg: "The arguments provided are invalid",
-  unknownErrMsg: "Something went wrong parsing the command-line arguments"
-});
-var { create: create33, of: of31, make: make31 } = factory7;
-var schemas33 = {
-  ...generatedSchemas6,
-  schema: generatedSchemas6.schema.transform((val) => val)
+var create30 = (input) => from29(input);
+var of29 = (input) => {
+  try {
+    return (0, import_fluture30.resolve)(from29(input));
+  } catch (err) {
+    return (0, import_fluture30.reject)(err);
+  }
 };
-var scaffoldTaskArgs = Base_default({
-  rawSchema: scaffoldRawSchema,
-  parseErrMsg: "The arguments provided are invalid for the scaffold task",
-  unknownErrMsg: "Something went wrong parsing the arguments for the scaffold task"
-});
-var provisionTaskArgs = Base_default({
-  rawSchema: provisionRawSchema,
-  parseErrMsg: "The arguments provided are invalid for the provision task",
-  unknownErrMsg: "Something went wrong parsing the arguments for the provision task"
-});
-var installTaskArgs = Base_default({
-  rawSchema: managePluginRawSchema,
-  parseErrMsg: "The arguments provided are invalid for the install task",
-  unknownErrMsg: "Something went wrong parsing the arguments for the install task"
-});
-var uninstallTaskArgs = Base_default({
-  rawSchema: managePluginRawSchema,
-  parseErrMsg: "The arguments provided are invalid for the uninstall task",
-  unknownErrMsg: "Something went wrong parsing the arguments for the uninstall task"
-});
-var setEnvTaskArgs = Base_default({
-  rawSchema: setEnvRawSchema,
-  parseErrMsg: "The arguments provided are invalid for the set-environment task",
-  unknownErrMsg: "Something went wrong parsing the arguments for the set-environment task"
-});
-var createTaskArgs = Base_default({
-  rawSchema: templateRawSchema,
-  parseErrMsg: "The arguments provided are invalid for the create task",
-  unknownErrMsg: "Something went wrong parsing the arguments for the create task"
-});
-var createScaffoldTaskArgs = scaffoldTaskArgs.factory.from;
-var makeScaffoldTaskArgs = scaffoldTaskArgs.factory.make;
-var ofScaffoldTaskArgs = scaffoldTaskArgs.factory.of;
-var createProvisionTaskArgs = provisionTaskArgs.factory.create;
-var makeProvisionTaskArgs = provisionTaskArgs.factory.make;
-var ofProvisionTaskArgs = provisionTaskArgs.factory.of;
-var createInstallTaskArgs = installTaskArgs.factory.create;
-var makeInstallTaskArgs = installTaskArgs.factory.make;
-var ofInstallTaskArgs = installTaskArgs.factory.of;
-var createUninstallTaskArgs = uninstallTaskArgs.factory.create;
-var makeUninstallTaskArgs = uninstallTaskArgs.factory.make;
-var ofUninstallTaskArgs = uninstallTaskArgs.factory.of;
-var createSetEnvTaskArgs = setEnvTaskArgs.factory.create;
-var makeSetEnvTaskArgs = setEnvTaskArgs.factory.make;
-var ofSetEnvTaskArgs = setEnvTaskArgs.factory.of;
-var createCreateTaskArgs = createTaskArgs.factory.create;
-var makeCreateTaskArgs = createTaskArgs.factory.make;
-var ofCreateTaskArgs = createTaskArgs.factory.of;
+var make29 = (input) => of29(input);
+var schemas29 = {
+  rawSchema: proxyTaskArgsSchema,
+  schema: proxyTaskArgsSchema.transform((val) => val)
+};
+var rawSchema29 = schemas29.rawSchema;
+var internalSchema29 = proxyTaskArgsSchema;
 
-// SanitizedPath.ts
-var SanitizedPath_exports = {};
-__export(SanitizedPath_exports, {
-  create: () => create34,
-  from: () => from25,
-  internalSchema: () => internalSchema29,
-  make: () => make32,
-  of: () => of32,
-  rawSchema: () => rawSchema34,
-  schemas: () => schemas34
+// ProxyTemplateArgs.ts
+var ProxyTemplateArgs_exports = {};
+__export(ProxyTemplateArgs_exports, {
+  create: () => create31,
+  from: () => from30,
+  internalSchema: () => internalSchema30,
+  make: () => make30,
+  of: () => of30,
+  rawSchema: () => rawSchema30,
+  schemas: () => schemas30
 });
 
-// out/types/SanitizedPath.ts
+// out/types/ProxyTemplateArgs.ts
 var import_fluture31 = require("fluture");
-var import_zod36 = require("zod");
-var from25 = (input) => {
+var import_zod31 = require("zod");
+var from30 = (input) => {
   try {
-    return sanitizedPathSchema.parse(input);
+    return proxyTemplateArgsSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod36.ZodError) {
+    if (previous instanceof import_zod31.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["SanitizedPath is invalid:"]
+        ["ProxyTemplateArgs is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a SanitizedPath.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a ProxyTemplateArgs.");
   }
 };
-var create34 = (input) => from25(input);
-var of32 = (input) => {
+var create31 = (input) => from30(input);
+var of30 = (input) => {
   try {
-    return (0, import_fluture31.resolve)(from25(input));
+    return (0, import_fluture31.resolve)(from30(input));
   } catch (err) {
     return (0, import_fluture31.reject)(err);
   }
 };
-var make32 = (input) => of32(input);
-var schemas34 = {
-  rawSchema: sanitizedPathSchema,
-  schema: sanitizedPathSchema.transform((val) => val)
+var make30 = (input) => of30(input);
+var schemas30 = {
+  rawSchema: proxyTemplateArgsSchema,
+  schema: proxyTemplateArgsSchema.transform((val) => val)
 };
-var rawSchema34 = schemas34.rawSchema;
-var internalSchema29 = sanitizedPathSchema;
+var rawSchema30 = schemas30.rawSchema;
+var internalSchema30 = proxyTemplateArgsSchema;
 
-// ScaffoldConfig.ts
-var ScaffoldConfig_exports = {};
-__export(ScaffoldConfig_exports, {
-  create: () => create35,
-  from: () => from26,
-  internalSchema: () => internalSchema30,
-  make: () => make33,
-  of: () => of33,
-  rawSchema: () => rawSchema35,
-  schemas: () => schemas35
+// PublicKeyHash.ts
+var PublicKeyHash_exports = {};
+__export(PublicKeyHash_exports, {
+  create: () => create32,
+  from: () => from31,
+  internalSchema: () => internalSchema31,
+  make: () => make31,
+  of: () => of31,
+  rawSchema: () => rawSchema31,
+  schemas: () => schemas31
 });
 
-// out/types/ScaffoldConfig.ts
+// out/types/PublicKeyHash.ts
 var import_fluture32 = require("fluture");
-var import_zod37 = require("zod");
-var from26 = (input) => {
+var import_zod32 = require("zod");
+var from31 = (input) => {
   try {
-    return scaffoldConfigSchema.parse(input);
+    return publicKeyHashSchema.parse(input);
   } catch (previous) {
-    if (previous instanceof import_zod37.ZodError) {
+    if (previous instanceof import_zod32.ZodError) {
       const msgs = previous.errors.reduce(
         (retval, issue) => {
           const path2 = issue.path.join(" \u2192 ");
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["ScaffoldConfig is invalid:"]
+        ["PublicKeyHash is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a ScaffoldConfig.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PublicKeyHash.");
   }
 };
-var create35 = (input) => from26(input);
-var of33 = (input) => {
+var create32 = (input) => from31(input);
+var of31 = (input) => {
   try {
-    return (0, import_fluture32.resolve)(from26(input));
+    return (0, import_fluture32.resolve)(from31(input));
   } catch (err) {
     return (0, import_fluture32.reject)(err);
   }
 };
+var make31 = (input) => of31(input);
+var schemas31 = {
+  rawSchema: publicKeyHashSchema,
+  schema: publicKeyHashSchema.transform((val) => val)
+};
+var rawSchema31 = schemas31.rawSchema;
+var internalSchema31 = publicKeyHashSchema;
+
+// RequestArgs.ts
+var RequestArgs_exports = {};
+__export(RequestArgs_exports, {
+  create: () => create33,
+  from: () => from32,
+  internalSchema: () => internalSchema32,
+  make: () => make32,
+  of: () => of32,
+  rawSchema: () => rawSchema32,
+  schemas: () => schemas32
+});
+
+// out/types/RequestArgs.ts
+var import_fluture33 = require("fluture");
+var import_zod33 = require("zod");
+var from32 = (input) => {
+  try {
+    return requestArgsSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod33.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["RequestArgs is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a RequestArgs.");
+  }
+};
+var create33 = (input) => from32(input);
+var of32 = (input) => {
+  try {
+    return (0, import_fluture33.resolve)(from32(input));
+  } catch (err) {
+    return (0, import_fluture33.reject)(err);
+  }
+};
+var make32 = (input) => of32(input);
+var schemas32 = {
+  rawSchema: requestArgsSchema,
+  schema: requestArgsSchema.transform((val) => val)
+};
+var rawSchema32 = schemas32.rawSchema;
+var internalSchema32 = requestArgsSchema;
+
+// SandboxAccountConfig.ts
+var SandboxAccountConfig_exports = {};
+__export(SandboxAccountConfig_exports, {
+  create: () => create34,
+  from: () => from33,
+  internalSchema: () => internalSchema33,
+  make: () => make33,
+  of: () => of33,
+  rawSchema: () => rawSchema33,
+  schemas: () => schemas33
+});
+
+// out/types/SandboxAccountConfig.ts
+var import_fluture34 = require("fluture");
+var import_zod34 = require("zod");
+var from33 = (input) => {
+  try {
+    return sandboxAccountConfigSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod34.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["SandboxAccountConfig is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a SandboxAccountConfig.");
+  }
+};
+var create34 = (input) => from33(input);
+var of33 = (input) => {
+  try {
+    return (0, import_fluture34.resolve)(from33(input));
+  } catch (err) {
+    return (0, import_fluture34.reject)(err);
+  }
+};
 var make33 = (input) => of33(input);
-var schemas35 = {
-  rawSchema: scaffoldConfigSchema,
-  schema: scaffoldConfigSchema.transform((val) => val)
+var schemas33 = {
+  rawSchema: sandboxAccountConfigSchema,
+  schema: sandboxAccountConfigSchema.transform((val) => val)
 };
-var rawSchema35 = schemas35.rawSchema;
-var internalSchema30 = scaffoldConfigSchema;
+var rawSchema33 = schemas33.rawSchema;
+var internalSchema33 = sandboxAccountConfigSchema;
 
-// Url.ts
-var Url_exports = {};
-__export(Url_exports, {
-  create: () => create36,
-  from: () => from27,
-  internalSchema: () => internalSchema31,
+// SandboxConfig.ts
+var SandboxConfig_exports = {};
+__export(SandboxConfig_exports, {
+  create: () => create35,
+  from: () => from34,
+  internalSchema: () => internalSchema34,
   make: () => make34,
   of: () => of34,
+  rawSchema: () => rawSchema34,
+  schemas: () => schemas34
+});
+
+// out/types/SandboxConfig.ts
+var import_fluture35 = require("fluture");
+var import_zod35 = require("zod");
+var from34 = (input) => {
+  try {
+    return sandboxConfigSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod35.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["SandboxConfig is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a SandboxConfig.");
+  }
+};
+var create35 = (input) => from34(input);
+var of34 = (input) => {
+  try {
+    return (0, import_fluture35.resolve)(from34(input));
+  } catch (err) {
+    return (0, import_fluture35.reject)(err);
+  }
+};
+var make34 = (input) => of34(input);
+var schemas34 = {
+  rawSchema: sandboxConfigSchema,
+  schema: sandboxConfigSchema.transform((val) => val)
+};
+var rawSchema34 = schemas34.rawSchema;
+var internalSchema34 = sandboxConfigSchema;
+
+// SanitizedAbsPath.ts
+var SanitizedAbsPath_exports = {};
+__export(SanitizedAbsPath_exports, {
+  create: () => create36,
+  factory: () => factory,
+  generatedSchemas: () => generatedSchemas,
+  make: () => make35,
+  of: () => of35,
+  rawSchema: () => rawSchema35,
+  schemas: () => schemas35
+});
+
+// Base.ts
+var import_fluture36 = require("fluture");
+var import_zod36 = require("zod");
+var createSchema = (params) => {
+  var _a, _b;
+  const { rawSchema: rawSchema53, isStringLike } = params;
+  const internalSchema50 = (_a = params.internalSchema) != null ? _a : params.rawSchema;
+  const noop = (val) => val;
+  const transformer = (_b = params.transformer) != null ? _b : noop;
+  const schema = isStringLike ? internalSchema50.transform(
+    (val) => transformer(val)
+  ) : internalSchema50.transform(
+    (val) => transformer(val)
+  );
+  return {
+    rawSchema: rawSchema53,
+    internalSchema: internalSchema50,
+    schema
+  };
+};
+var createType = (params) => {
+  const schemas53 = createSchema(params);
+  const { parseErrMsg, unknownErrMsg } = params;
+  const internalOf = (input) => {
+    try {
+      return (0, import_fluture36.resolve)(schemas53.schema.parse(input));
+    } catch (previous) {
+      const parseMsg = typeof parseErrMsg === "string" ? parseErrMsg : parseErrMsg(input, previous);
+      const unknownMsg = typeof unknownErrMsg === "string" ? unknownErrMsg : unknownErrMsg(input);
+      if (previous instanceof import_zod36.ZodError) {
+        return toFutureParseErr(previous, parseMsg, input);
+      }
+      return toFutureParseUnknownErr(previous, unknownMsg, input);
+    }
+  };
+  const of53 = internalOf;
+  const make53 = (input) => internalOf(input);
+  const create55 = (input) => schemas53.schema.parse(input);
+  const from46 = (input) => schemas53.schema.parse(input);
+  const factory8 = {
+    make: make53,
+    of: of53,
+    create: create55,
+    from: from46
+  };
+  return {
+    schemas: schemas53,
+    factory: factory8
+  };
+};
+var Base_default = createType;
+
+// SanitizedAbsPath.ts
+var path = __toESM(require("path"));
+var import_zod37 = require("zod");
+var rawSchema35 = import_zod37.z.string({ description: "SanitizedAbsPath" }).min(1);
+var { schemas: generatedSchemas, factory } = Base_default({
+  isStringLike: true,
+  rawSchema: rawSchema35,
+  transformer: (value) => path.resolve(value),
+  parseErrMsg: (value) => `${value} is an invalid absolute path`,
+  unknownErrMsg: (value) => `Something went wrong trying to parse the absolute path, ${value}`
+});
+var { create: create36, make: make35, of: of35 } = factory;
+var schemas35 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+
+// SanitizedPath.ts
+var SanitizedPath_exports = {};
+__export(SanitizedPath_exports, {
+  create: () => create37,
+  from: () => from35,
+  internalSchema: () => internalSchema35,
+  make: () => make36,
+  of: () => of36,
   rawSchema: () => rawSchema36,
   schemas: () => schemas36
 });
 
-// out/types/Url.ts
-var import_fluture33 = require("fluture");
+// out/types/SanitizedPath.ts
+var import_fluture37 = require("fluture");
 var import_zod38 = require("zod");
-var from27 = (input) => {
+var from35 = (input) => {
   try {
-    return urlSchema.parse(input);
+    return sanitizedPathSchema.parse(input);
   } catch (previous) {
     if (previous instanceof import_zod38.ZodError) {
       const msgs = previous.errors.reduce(
@@ -2620,27 +2296,1228 @@ var from27 = (input) => {
           const msg = path2 + ": " + issue.message;
           return [...retval, msg];
         },
-        ["Url is invalid:"]
+        ["SanitizedPath is invalid:"]
       );
       const validationErr = msgs.join("\n") + "\n";
       throw toParseErr(previous, validationErr);
     }
-    throw toParseUnknownErr(previous, "There was a problem trying to parse a Url.");
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a SanitizedPath.");
   }
 };
-var create36 = (input) => from27(input);
-var of34 = (input) => {
+var create37 = (input) => from35(input);
+var of36 = (input) => {
   try {
-    return (0, import_fluture33.resolve)(from27(input));
+    return (0, import_fluture37.resolve)(from35(input));
   } catch (err) {
-    return (0, import_fluture33.reject)(err);
+    return (0, import_fluture37.reject)(err);
   }
 };
-var make34 = (input) => of34(input);
+var make36 = (input) => of36(input);
 var schemas36 = {
-  rawSchema: urlSchema,
-  schema: urlSchema.transform((val) => val)
+  rawSchema: sanitizedPathSchema,
+  schema: sanitizedPathSchema.transform((val) => val)
 };
 var rawSchema36 = schemas36.rawSchema;
-var internalSchema31 = urlSchema;
+var internalSchema35 = sanitizedPathSchema;
+
+// ScaffoldConfig.ts
+var ScaffoldConfig_exports = {};
+__export(ScaffoldConfig_exports, {
+  create: () => create38,
+  from: () => from36,
+  internalSchema: () => internalSchema36,
+  make: () => make37,
+  of: () => of37,
+  rawSchema: () => rawSchema37,
+  schemas: () => schemas37
+});
+
+// out/types/ScaffoldConfig.ts
+var import_fluture38 = require("fluture");
+var import_zod39 = require("zod");
+var from36 = (input) => {
+  try {
+    return scaffoldConfigSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod39.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["ScaffoldConfig is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a ScaffoldConfig.");
+  }
+};
+var create38 = (input) => from36(input);
+var of37 = (input) => {
+  try {
+    return (0, import_fluture38.resolve)(from36(input));
+  } catch (err) {
+    return (0, import_fluture38.reject)(err);
+  }
+};
+var make37 = (input) => of37(input);
+var schemas37 = {
+  rawSchema: scaffoldConfigSchema,
+  schema: scaffoldConfigSchema.transform((val) => val)
+};
+var rawSchema37 = schemas37.rawSchema;
+var internalSchema36 = scaffoldConfigSchema;
+
+// Settings.ts
+var Settings_exports = {};
+__export(Settings_exports, {
+  create: () => create39,
+  from: () => from37,
+  internalSchema: () => internalSchema37,
+  make: () => make38,
+  of: () => of38,
+  rawSchema: () => rawSchema38,
+  schemas: () => schemas38
+});
+
+// out/types/Settings.ts
+var import_fluture39 = require("fluture");
+var import_zod40 = require("zod");
+var from37 = (input) => {
+  try {
+    return settingsSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod40.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Settings is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Settings.");
+  }
+};
+var create39 = (input) => from37(input);
+var of38 = (input) => {
+  try {
+    return (0, import_fluture39.resolve)(from37(input));
+  } catch (err) {
+    return (0, import_fluture39.reject)(err);
+  }
+};
+var make38 = (input) => of38(input);
+var schemas38 = {
+  rawSchema: settingsSchema,
+  schema: settingsSchema.transform((val) => val)
+};
+var rawSchema38 = schemas38.rawSchema;
+var internalSchema37 = settingsSchema;
+
+// SingleChar.ts
+var SingleChar_exports = {};
+__export(SingleChar_exports, {
+  create: () => create40,
+  from: () => from38,
+  internalSchema: () => internalSchema38,
+  make: () => make39,
+  of: () => of39,
+  rawSchema: () => rawSchema39,
+  schemas: () => schemas39
+});
+
+// out/types/SingleChar.ts
+var import_fluture40 = require("fluture");
+var import_zod41 = require("zod");
+var from38 = (input) => {
+  try {
+    return singleCharSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod41.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["SingleChar is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a SingleChar.");
+  }
+};
+var create40 = (input) => from38(input);
+var of39 = (input) => {
+  try {
+    return (0, import_fluture40.resolve)(from38(input));
+  } catch (err) {
+    return (0, import_fluture40.reject)(err);
+  }
+};
+var make39 = (input) => of39(input);
+var schemas39 = {
+  rawSchema: singleCharSchema,
+  schema: singleCharSchema.transform((val) => val)
+};
+var rawSchema39 = schemas39.rawSchema;
+var internalSchema38 = singleCharSchema;
+
+// Task.ts
+var Task_exports = {};
+__export(Task_exports, {
+  create: () => create41,
+  from: () => from39,
+  internalSchema: () => internalSchema39,
+  make: () => make40,
+  of: () => of40,
+  rawSchema: () => rawSchema40,
+  schemas: () => schemas40
+});
+
+// out/types/Task.ts
+var import_fluture41 = require("fluture");
+var import_zod42 = require("zod");
+var from39 = (input) => {
+  try {
+    return taskSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod42.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Task is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Task.");
+  }
+};
+var create41 = (input) => from39(input);
+var of40 = (input) => {
+  try {
+    return (0, import_fluture41.resolve)(from39(input));
+  } catch (err) {
+    return (0, import_fluture41.reject)(err);
+  }
+};
+var make40 = (input) => of40(input);
+var schemas40 = {
+  rawSchema: taskSchema,
+  schema: taskSchema.transform((val) => val)
+};
+var rawSchema40 = schemas40.rawSchema;
+var internalSchema39 = taskSchema;
+
+// Template.ts
+var Template_exports = {};
+__export(Template_exports, {
+  create: () => create43,
+  from: () => from40,
+  internalSchema: () => internalSchema40,
+  make: () => make41,
+  of: () => of41,
+  rawSchema: () => rawSchema41,
+  schemas: () => schemas41
+});
+
+// out/types/Template.ts
+var import_fluture42 = require("fluture");
+var import_zod43 = require("zod");
+var from40 = (input) => {
+  try {
+    return templateSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod43.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Template is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Template.");
+  }
+};
+var create42 = (input) => from40(input);
+var of41 = (input) => {
+  try {
+    return (0, import_fluture42.resolve)(from40(input));
+  } catch (err) {
+    return (0, import_fluture42.reject)(err);
+  }
+};
+var make41 = (input) => of41(input);
+var schemas41 = {
+  rawSchema: templateSchema,
+  schema: templateSchema.transform((val) => val)
+};
+var rawSchema41 = schemas41.rawSchema;
+var internalSchema40 = templateSchema;
+
+// Template.ts
+function create43(args) {
+  return create42(args);
+}
+
+// Timestamp.ts
+var Timestamp_exports = {};
+__export(Timestamp_exports, {
+  create: () => create44,
+  from: () => from41,
+  internalSchema: () => internalSchema41,
+  make: () => make42,
+  of: () => of42,
+  rawSchema: () => rawSchema42,
+  schemas: () => schemas42
+});
+
+// out/types/Timestamp.ts
+var import_fluture43 = require("fluture");
+var import_zod44 = require("zod");
+var from41 = (input) => {
+  try {
+    return timestampSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod44.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Timestamp is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Timestamp.");
+  }
+};
+var create44 = (input) => from41(input);
+var of42 = (input) => {
+  try {
+    return (0, import_fluture43.resolve)(from41(input));
+  } catch (err) {
+    return (0, import_fluture43.reject)(err);
+  }
+};
+var make42 = (input) => of42(input);
+var schemas42 = {
+  rawSchema: timestampSchema,
+  schema: timestampSchema.transform((val) => val)
+};
+var rawSchema42 = schemas42.rawSchema;
+var internalSchema41 = timestampSchema;
+
+// Tz.ts
+var Tz_exports = {};
+__export(Tz_exports, {
+  create: () => create45,
+  from: () => from42,
+  internalSchema: () => internalSchema42,
+  make: () => make43,
+  of: () => of43,
+  rawSchema: () => rawSchema43,
+  schemas: () => schemas43
+});
+
+// out/types/Tz.ts
+var import_fluture44 = require("fluture");
+var import_zod45 = require("zod");
+var from42 = (input) => {
+  try {
+    return tzSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod45.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Tz is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Tz.");
+  }
+};
+var create45 = (input) => from42(input);
+var of43 = (input) => {
+  try {
+    return (0, import_fluture44.resolve)(from42(input));
+  } catch (err) {
+    return (0, import_fluture44.reject)(err);
+  }
+};
+var make43 = (input) => of43(input);
+var schemas43 = {
+  rawSchema: tzSchema,
+  schema: tzSchema.transform((val) => val)
+};
+var rawSchema43 = schemas43.rawSchema;
+var internalSchema42 = tzSchema;
+
+// Url.ts
+var Url_exports = {};
+__export(Url_exports, {
+  create: () => create46,
+  from: () => from43,
+  internalSchema: () => internalSchema43,
+  make: () => make44,
+  of: () => of44,
+  rawSchema: () => rawSchema44,
+  schemas: () => schemas44
+});
+
+// out/types/Url.ts
+var import_fluture45 = require("fluture");
+var import_zod46 = require("zod");
+var from43 = (input) => {
+  try {
+    return urlSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod46.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Url is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Url.");
+  }
+};
+var create46 = (input) => from43(input);
+var of44 = (input) => {
+  try {
+    return (0, import_fluture45.resolve)(from43(input));
+  } catch (err) {
+    return (0, import_fluture45.reject)(err);
+  }
+};
+var make44 = (input) => of44(input);
+var schemas44 = {
+  rawSchema: urlSchema,
+  schema: urlSchema.transform((val) => val)
+};
+var rawSchema44 = schemas44.rawSchema;
+var internalSchema43 = urlSchema;
+
+// Verb.ts
+var Verb_exports = {};
+__export(Verb_exports, {
+  create: () => create47,
+  from: () => from44,
+  internalSchema: () => internalSchema44,
+  make: () => make45,
+  of: () => of45,
+  rawSchema: () => rawSchema45,
+  schemas: () => schemas45
+});
+
+// out/types/Verb.ts
+var import_fluture46 = require("fluture");
+var import_zod47 = require("zod");
+var from44 = (input) => {
+  try {
+    return verbSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod47.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Verb is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Verb.");
+  }
+};
+var create47 = (input) => from44(input);
+var of45 = (input) => {
+  try {
+    return (0, import_fluture46.resolve)(from44(input));
+  } catch (err) {
+    return (0, import_fluture46.reject)(err);
+  }
+};
+var make45 = (input) => of45(input);
+var schemas45 = {
+  rawSchema: verbSchema,
+  schema: verbSchema.transform((val) => val)
+};
+var rawSchema45 = schemas45.rawSchema;
+var internalSchema44 = verbSchema;
+
+// VersionNumber.ts
+var VersionNumber_exports = {};
+__export(VersionNumber_exports, {
+  create: () => create48,
+  from: () => from45,
+  internalSchema: () => internalSchema45,
+  make: () => make46,
+  of: () => of46,
+  rawSchema: () => rawSchema46,
+  schemas: () => schemas46
+});
+
+// out/types/VersionNumber.ts
+var import_fluture47 = require("fluture");
+var import_zod48 = require("zod");
+var from45 = (input) => {
+  try {
+    return versionNumberSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod48.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["VersionNumber is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a VersionNumber.");
+  }
+};
+var create48 = (input) => from45(input);
+var of46 = (input) => {
+  try {
+    return (0, import_fluture47.resolve)(from45(input));
+  } catch (err) {
+    return (0, import_fluture47.reject)(err);
+  }
+};
+var make46 = (input) => of46(input);
+var schemas46 = {
+  rawSchema: versionNumberSchema,
+  schema: versionNumberSchema.transform((val) => val)
+};
+var rawSchema46 = schemas46.rawSchema;
+var internalSchema45 = versionNumberSchema;
+
+// PluginInfo.ts
+var PluginInfo_exports = {};
+__export(PluginInfo_exports, {
+  create: () => create49,
+  factory: () => factory2,
+  internalSchema: () => internalSchema46,
+  make: () => make47,
+  of: () => of47,
+  rawSchema: () => rawSchema47,
+  schemas: () => schemas47
+});
+var import_zod49 = require("zod");
+var rawSchema47 = import_zod49.z.object({
+  name: import_zod49.z.string({ description: "Plugin Name" }).min(1),
+  version: rawSchema46.describe("Plugin Version #"),
+  schema: rawSchema46.describe("Plugin Schema Version #"),
+  alias: rawSchema.describe("Plugin Alias"),
+  postInstall: import_zod49.z.string().optional(),
+  tasks: import_zod49.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod49.z.array(
+      schemas40.schema.describe("Plugin Task"),
+      { description: "Plugin Tasks" }
+    )
+  ).optional(),
+  operations: import_zod49.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod49.z.array(
+      schemas18.schema.describe("Plugin Operation"),
+      { description: "Plugin Operations" }
+    )
+  ).optional(),
+  templates: import_zod49.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod49.z.array(
+      schemas19.schema.describe("Plugin Template")
+    )
+  ).optional()
+});
+var internalSchema46 = rawSchema47.extend({
+  version: schemas46.schema.describe("Plugin Version #"),
+  schema: schemas46.schema.describe("Plugin Schema Version #"),
+  alias: schemas.schema.describe("Plugin Alias"),
+  tasks: import_zod49.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod49.z.array(
+      schemas40.schema.describe("Plugin Task"),
+      { description: "Plugin Tasks" }
+    )
+  ).optional(),
+  operations: import_zod49.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod49.z.array(
+      schemas18.schema.describe("Plugin Operation"),
+      { description: "Plugin Operations" }
+    )
+  ).optional(),
+  templates: import_zod49.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod49.z.array(
+      schemas19.schema.describe("Plugin Template")
+    )
+  ).optional()
+}).describe("Plugin Schema");
+var { schemas: schemas47, factory: factory2 } = Base_default({
+  rawSchema: rawSchema47,
+  internalSchema: internalSchema46,
+  parseErrMsg: "The schema returned from the plugin is invalid",
+  unknownErrMsg: "Something went wrong parsing the schema from a plugin"
+});
+var { create: create49, of: of47, make: make47 } = factory2;
+
+// i18n.ts
+var i18n_exports = {};
+__export(i18n_exports, {
+  default: () => i18n_default
+});
+var import_i18next = __toESM(require("i18next"));
+var i18n_default = async () => {
+  const i18n = {
+    ...await import_i18next.default.init({
+      lng: "en",
+      debug: false,
+      resources: {
+        // TODO: Move to separate language files
+        en: {
+          translation: {
+            "appName": "Taqueria",
+            "appDesc": "Taqueria is an integrated environment for compiling, testing, and deploying Tezos software.",
+            "versionDesc": "Display the version number of the Taqueria program",
+            "betaWarning": "Please be advised that Taqueria is currently in BETA.",
+            "configDirDesc": "Config directory (default ./.taq)",
+            "initDesc": "Initialize a new project",
+            "optInDesc": "Opt-in to sharing anonymous usage analytics",
+            "optOutDesc": "Opt-out of sharing anonymous usage analytics",
+            "initPathDesc": "Path to your project directory",
+            "workflowDesc": "Select a workflow to initialize your Taqueria project. Choices are (ligo|smartpy|archetype|michelson)",
+            "scaffoldDesc": `Generate a new project using pre-made scaffold. Recommended for creating a new project.`,
+            "scaffoldUrlDesc": "Alias or Url for the scaffold project",
+            "scaffoldProjectDirDesc": "Path where to create the new project. This must be a new directory.",
+            "scaffoldDoneMsg": "The project was created using the scaffold.",
+            "installDesc": "Install a plugin",
+            "pluginInstalled": "Plugin installed successfully",
+            "pluginUninstalled": "Plugin uninstalled successfully",
+            "uninstallDesc": "Uninstall a plugin",
+            "pluginNameDesc": "The name of the plugin",
+            "promptForTask": "Please specify which task you would like to execute. If you're starting a new project, please run 'init'.\n",
+            "pluginKindDesc": "Kind of plugin (NPM, Binary)",
+            "pluginAlreadyInstalled": "That plugin is already installed.",
+            "pluginOptionDesc": "Use the task from this plugin",
+            "bootstrapMsg": "Project taq'ified!",
+            "maxConcurrencyDesc": "Set the maximum concurrency limit used internally",
+            "providedByMany": "Provided by more than one plugin. The option --plugin is required.",
+            "pluginDesc": "Specify what plugin should execute this command. Use this when more than one plugin provide a task of the same name.",
+            "listNetworks": "List known networks",
+            "envDesc": "Specify an environment configuration",
+            "disableStateDesc": "Does not use the saved state.json file. State is computed for each execution.",
+            "logPluginCallsDesc": "Logs any execution calls to a plugin to the console",
+            "npmInitRequired": "This project isn't a valid NPM project. Please run: npm init",
+            "testFromVsCode": "An internal command used by VS Code to test for the taq binary",
+            "fromVsCode": "An internal flag used to indicate that taq is executed via vscode",
+            "buildDesc": "Display build information about the current version",
+            "pluginOption": "Use to specify what plugin you'd like when running this task.",
+            "yesOptionDesc": 'Select "yes" to any prompt',
+            "templateNotFound": "Template not found. Perhaps you need to install a plugin?",
+            "createDesc": "Create files from pre-existing templates",
+            "templateDesc": "Name of the template to use"
+          }
+        }
+      }
+    }),
+    __: import_i18next.default.t
+  };
+  return i18n;
+};
+
+// PersistentState.ts
+var PersistentState_exports = {};
+__export(PersistentState_exports, {
+  create: () => create51,
+  factory: () => factory4,
+  generatedSchemas: () => generatedSchemas3,
+  internalSchema: () => internalSchema48,
+  make: () => make49,
+  of: () => of49,
+  rawSchema: () => rawSchema49,
+  schemas: () => schemas49
+});
+
+// SHA256.ts
+var SHA256_exports = {};
+__export(SHA256_exports, {
+  Crypto: () => Crypto,
+  create: () => create50,
+  internalSchema: () => internalSchema47,
+  make: () => make48,
+  of: () => of48,
+  rawSchema: () => rawSchema48,
+  schemas: () => schemas48,
+  toSHA256: () => toSHA256
+});
+var import_fluture48 = require("fluture");
+var import_rambda = require("rambda");
+var import_zod50 = require("zod");
+var eager = (f) => (0, import_fluture48.promise)(
+  (0, import_fluture48.mapRej)((err) => new E_TaqError(err))(f)
+);
+var Crypto = class {
+  constructor() {
+    this.subtle = {
+      digest(_method, _data) {
+        return new ArrayBuffer(50);
+      }
+    };
+  }
+};
+var getSubtleCrypto = async () => {
+  if ((0, import_rambda.has)("SubtleCrypto", globalThis)) {
+    return Promise.resolve(crypto.subtle);
+  }
+  const { Crypto: Crypto2 } = await import("@peculiar/webcrypto");
+  const webcrypto = new Crypto2();
+  return Promise.resolve(webcrypto.subtle);
+};
+var rawSchema48 = import_zod50.z.string({ description: "SHA256" }).length(64);
+var { schemas: generatedSchemas2, factory: factory3 } = Base_default({
+  isStringLike: true,
+  rawSchema: rawSchema48,
+  parseErrMsg: (value) => `${value} is an invalid SHA256 hash`,
+  unknownErrMsg: (value) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`
+});
+var toSHA256 = async (value) => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hash = await (await getSubtleCrypto()).digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hash));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return eager(factory3.make(hashHex));
+};
+var internalSchema47 = generatedSchemas2.schema;
+var { create: create50, of: of48, make: make48 } = factory3;
+var schemas48 = {
+  ...generatedSchemas2,
+  schema: generatedSchemas2.schema.transform((val) => val)
+};
+
+// PersistentState.ts
+var import_zod51 = require("zod");
+var rawOpSchema = import_zod51.z.object({
+  hash: rawSchema48.describe("state.op.hash"),
+  time: rawSchema42.describe("state.op.time"),
+  output: import_zod51.z.unknown().describe("state.op.output")
+}).describe("Persistent State Operation");
+var rawTaskSchema = import_zod51.z.object({
+  task: schemas45.rawSchema,
+  plugin: import_zod51.z.string().min(1),
+  time: rawSchema42.describe("state.task.time"),
+  output: import_zod51.z.unknown().describe("state.task.output")
+});
+var internalOpSchema = import_zod51.z.object({
+  hash: schemas48.schema.describe("state.op.hash"),
+  time: schemas42.schema.describe("state.op.time"),
+  output: import_zod51.z.unknown().describe("state.op.output")
+});
+var internalTaskSchema = import_zod51.z.object({
+  task: schemas45.schema,
+  plugin: import_zod51.z.string().min(1),
+  time: schemas42.schema.describe("state.task.time"),
+  output: import_zod51.z.unknown().describe("state.op.output")
+});
+var rawSchema49 = import_zod51.z.object({
+  operations: import_zod51.z.record(rawOpSchema),
+  tasks: import_zod51.z.record(rawTaskSchema)
+});
+var internalSchema48 = import_zod51.z.object({
+  operations: import_zod51.z.record(internalOpSchema),
+  tasks: import_zod51.z.record(internalTaskSchema)
+}).transform((val) => ({
+  operations: val.operations,
+  tasks: val.tasks
+}));
+var { schemas: generatedSchemas3, factory: factory4 } = Base_default({
+  rawSchema: rawSchema49,
+  parseErrMsg: `The persistent state is invalid`,
+  unknownErrMsg: `Something went wrong trying to parse the persistent state`
+});
+var { create: create51, of: of49, make: make49 } = factory4;
+var schemas49 = {
+  ...generatedSchemas3,
+  schema: generatedSchemas3.schema.transform((val) => val)
+};
+
+// PluginSchema.ts
+var PluginSchema_exports = {};
+__export(PluginSchema_exports, {
+  create: () => create52,
+  factory: () => factory5,
+  generatedSchemas: () => generatedSchemas4,
+  make: () => make50,
+  of: () => of50,
+  rawSchema: () => rawSchema50,
+  schemas: () => schemas50
+});
+var import_zod52 = require("zod");
+var internalSchema49 = internalSchema46.extend({
+  operations: import_zod52.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod52.z.array(
+      schemas16.schema,
+      { description: "ParsedOperations" }
+    ).optional()
+  ),
+  templates: import_zod52.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod52.z.array(
+      schemas41.schema
+    ).optional()
+  )
+}).passthrough().describe("ParsedPluginInfo");
+var rawSchema50 = rawSchema47.extend({
+  name: rawSchema.optional(),
+  operations: import_zod52.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod52.z.array(
+      rawSchema16,
+      { description: "ParsedOperation" }
+    )
+  ).optional(),
+  templates: import_zod52.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod52.z.array(
+      schemas41.schema
+    ).optional()
+  )
+}).passthrough().describe("ParsedPluginInfo");
+var { schemas: generatedSchemas4, factory: factory5 } = Base_default({
+  rawSchema: rawSchema50,
+  internalSchema: internalSchema49,
+  parseErrMsg: (value) => `The following plugin info gave us trouble when parsing the following plugin information: ${value}`,
+  unknownErrMsg: "Something went wrong trying to parse the plugin information"
+});
+var { create: create52, of: of50, make: make50 } = factory5;
+var schemas50 = {
+  ...generatedSchemas4,
+  schema: generatedSchemas4.schema.transform((val) => val)
+};
+
+// SanitizedArgs.ts
+var SanitizedArgs_exports = {};
+__export(SanitizedArgs_exports, {
+  create: () => create53,
+  createCreateTaskArgs: () => createCreateTaskArgs,
+  createInstallTaskArgs: () => createInstallTaskArgs,
+  createProvisionTaskArgs: () => createProvisionTaskArgs,
+  createScaffoldTaskArgs: () => createScaffoldTaskArgs,
+  createSetEnvTaskArgs: () => createSetEnvTaskArgs,
+  createTaskArgs: () => createTaskArgs,
+  createUninstallTaskArgs: () => createUninstallTaskArgs,
+  factory: () => factory6,
+  generatedSchemas: () => generatedSchemas5,
+  initRawSchema: () => initRawSchema,
+  installTaskArgs: () => installTaskArgs,
+  make: () => make51,
+  makeCreateTaskArgs: () => makeCreateTaskArgs,
+  makeInstallTaskArgs: () => makeInstallTaskArgs,
+  makeProvisionTaskArgs: () => makeProvisionTaskArgs,
+  makeScaffoldTaskArgs: () => makeScaffoldTaskArgs,
+  makeSetEnvTaskArgs: () => makeSetEnvTaskArgs,
+  makeUninstallTaskArgs: () => makeUninstallTaskArgs,
+  managePluginRawSchema: () => managePluginRawSchema,
+  of: () => of51,
+  ofCreateTaskArgs: () => ofCreateTaskArgs,
+  ofInstallTaskArgs: () => ofInstallTaskArgs,
+  ofProvisionTaskArgs: () => ofProvisionTaskArgs,
+  ofScaffoldTaskArgs: () => ofScaffoldTaskArgs,
+  ofSetEnvTaskArgs: () => ofSetEnvTaskArgs,
+  ofUninstallTaskArgs: () => ofUninstallTaskArgs,
+  provisionRawSchema: () => provisionRawSchema,
+  provisionTaskArgs: () => provisionTaskArgs,
+  rawSchema: () => rawSchema51,
+  scaffoldRawSchema: () => scaffoldRawSchema,
+  scaffoldTaskArgs: () => scaffoldTaskArgs,
+  schemas: () => schemas51,
+  setEnvRawSchema: () => setEnvRawSchema,
+  setEnvTaskArgs: () => setEnvTaskArgs,
+  templateRawSchema: () => templateRawSchema,
+  uninstallTaskArgs: () => uninstallTaskArgs
+});
+var import_zod53 = require("zod");
+var rawSchema51 = import_zod53.z.object({
+  _: import_zod53.z.array(import_zod53.z.union([import_zod53.z.string().min(1), import_zod53.z.number()])),
+  projectDir: schemas35.schema,
+  maxConcurrency: import_zod53.z.preprocess(
+    (val) => typeof val === "string" ? parseInt(val) : Number(val),
+    import_zod53.z.number().int().min(1).default(10)
+  ),
+  debug: import_zod53.z.preprocess(
+    (val) => Boolean(val),
+    import_zod53.z.boolean().default(false)
+  ),
+  disableState: import_zod53.z.preprocess(
+    (val) => Boolean(val),
+    import_zod53.z.boolean().default(false)
+  ),
+  logPluginRequests: import_zod53.z.preprocess(
+    (val) => Boolean(val),
+    import_zod53.z.boolean().default(false)
+  ),
+  fromVsCode: import_zod53.z.preprocess(
+    (val) => Boolean(val),
+    import_zod53.z.boolean().default(false)
+  ),
+  version: import_zod53.z.preprocess(
+    (val) => Boolean(val),
+    import_zod53.z.boolean().optional()
+  ),
+  build: import_zod53.z.preprocess(
+    (val) => Boolean(val),
+    import_zod53.z.boolean().optional()
+  ),
+  help: import_zod53.z.preprocess(
+    (val) => Boolean(val),
+    import_zod53.z.boolean().optional()
+  ),
+  yes: import_zod53.z.preprocess(
+    (val) => Boolean(val),
+    import_zod53.z.boolean().optional()
+  ),
+  plugin: schemas15.schema.optional(),
+  env: import_zod53.z.string().optional(),
+  quickstart: import_zod53.z.string().min(1).optional(),
+  setBuild: import_zod53.z.preprocess(
+    (val) => String(val),
+    import_zod53.z.string().min(3)
+  ),
+  setVersion: import_zod53.z.string().min(3),
+  pluginName: import_zod53.z.string().min(1).optional()
+}, { description: "Sanitizied Args" }).passthrough();
+var scaffoldRawSchema = rawSchema51.extend({
+  scaffoldProjectDir: import_zod53.z.string().min(1).transform((val) => val),
+  scaffoldUrl: import_zod53.z.string().min(1).url().transform((val) => val),
+  branch: import_zod53.z.string().min(1).optional()
+});
+var initRawSchema = rawSchema51.extend({
+  workflow: import_zod53.z.string().refine((val) => val === "ligo" || val === "smartpy" || val === "archetype" || val === "michelson").optional()
+});
+var provisionRawSchema = rawSchema51.extend({
+  operation: import_zod53.z.string().min(1).describe("Operation name"),
+  name: import_zod53.z.string().min(1).regex(
+    /^[a-z0-9]+[a-z0-9-_]$/,
+    "Provisioner name must consist of one or more letters/numbers and may not start with an underscore or dash."
+  ).describe("Provisioner name").optional()
+}).passthrough();
+var templateRawSchema = rawSchema51.extend({
+  template: import_zod53.z.string().min(1)
+}).passthrough();
+var managePluginRawSchema = rawSchema51.omit({ pluginName: true }).extend({
+  pluginName: import_zod53.z.string().min(1)
+});
+var setEnvRawSchema = rawSchema51.extend({
+  defaultEnvironment: import_zod53.z.string().min(1)
+});
+var { schemas: generatedSchemas5, factory: factory6 } = Base_default({
+  rawSchema: rawSchema51,
+  parseErrMsg: "The arguments provided are invalid",
+  unknownErrMsg: "Something went wrong parsing the command-line arguments"
+});
+var { create: create53, of: of51, make: make51 } = factory6;
+var schemas51 = {
+  ...generatedSchemas5,
+  schema: generatedSchemas5.schema.transform((val) => val)
+};
+var scaffoldTaskArgs = Base_default({
+  rawSchema: scaffoldRawSchema,
+  parseErrMsg: "The arguments provided are invalid for the scaffold task",
+  unknownErrMsg: "Something went wrong parsing the arguments for the scaffold task"
+});
+var provisionTaskArgs = Base_default({
+  rawSchema: provisionRawSchema,
+  parseErrMsg: "The arguments provided are invalid for the provision task",
+  unknownErrMsg: "Something went wrong parsing the arguments for the provision task"
+});
+var installTaskArgs = Base_default({
+  rawSchema: managePluginRawSchema,
+  parseErrMsg: "The arguments provided are invalid for the install task",
+  unknownErrMsg: "Something went wrong parsing the arguments for the install task"
+});
+var uninstallTaskArgs = Base_default({
+  rawSchema: managePluginRawSchema,
+  parseErrMsg: "The arguments provided are invalid for the uninstall task",
+  unknownErrMsg: "Something went wrong parsing the arguments for the uninstall task"
+});
+var setEnvTaskArgs = Base_default({
+  rawSchema: setEnvRawSchema,
+  parseErrMsg: "The arguments provided are invalid for the set-environment task",
+  unknownErrMsg: "Something went wrong parsing the arguments for the set-environment task"
+});
+var createTaskArgs = Base_default({
+  rawSchema: templateRawSchema,
+  parseErrMsg: "The arguments provided are invalid for the create task",
+  unknownErrMsg: "Something went wrong parsing the arguments for the create task"
+});
+var createScaffoldTaskArgs = scaffoldTaskArgs.factory.from;
+var makeScaffoldTaskArgs = scaffoldTaskArgs.factory.make;
+var ofScaffoldTaskArgs = scaffoldTaskArgs.factory.of;
+var createProvisionTaskArgs = provisionTaskArgs.factory.create;
+var makeProvisionTaskArgs = provisionTaskArgs.factory.make;
+var ofProvisionTaskArgs = provisionTaskArgs.factory.of;
+var createInstallTaskArgs = installTaskArgs.factory.create;
+var makeInstallTaskArgs = installTaskArgs.factory.make;
+var ofInstallTaskArgs = installTaskArgs.factory.of;
+var createUninstallTaskArgs = uninstallTaskArgs.factory.create;
+var makeUninstallTaskArgs = uninstallTaskArgs.factory.make;
+var ofUninstallTaskArgs = uninstallTaskArgs.factory.of;
+var createSetEnvTaskArgs = setEnvTaskArgs.factory.create;
+var makeSetEnvTaskArgs = setEnvTaskArgs.factory.make;
+var ofSetEnvTaskArgs = setEnvTaskArgs.factory.of;
+var createCreateTaskArgs = createTaskArgs.factory.create;
+var makeCreateTaskArgs = createTaskArgs.factory.make;
+var ofCreateTaskArgs = createTaskArgs.factory.of;
+
+// EphemeralState.ts
+var import_fluture49 = require("fluture");
+var import_zod54 = require("zod");
+var eager2 = (f) => (0, import_fluture49.promise)(
+  (0, import_fluture49.mapRej)((err) => new E_TaqError(err))(f)
+);
+var taskToPluginMap = import_zod54.z.record(
+  import_zod54.z.union([
+    InstalledPlugin_exports.schemas.schema,
+    Task_exports.schemas.schema
+  ], { description: "Task/Plugin Mapping" })
+);
+var operationToPluginMap = import_zod54.z.record(
+  import_zod54.z.union([
+    InstalledPlugin_exports.schemas.schema,
+    ParsedOperation_exports.schemas.schema
+  ], { description: "Operation/Plugin Mapping" })
+);
+var templateToPluginMap = import_zod54.z.record(
+  import_zod54.z.union([
+    InstalledPlugin_exports.schemas.schema,
+    ParsedTemplate_exports.schemas.schema
+  ])
+);
+var rawSchema52 = import_zod54.z.object({
+  build: import_zod54.z.string({ description: "cache.build" }),
+  configHash: import_zod54.z.string({ description: "cache.configHash" }),
+  tasks: taskToPluginMap,
+  operations: operationToPluginMap,
+  templates: templateToPluginMap,
+  plugins: import_zod54.z.array(PluginInfo_exports.schemas.schema, { description: "cache.plugins" })
+}).describe("Ephemeral State");
+var { schemas: generatedSchemas6, factory: factory7 } = Base_default({
+  rawSchema: rawSchema52,
+  parseErrMsg: (value) => `${value} is not a valid representation of ephemeral state`,
+  unknownErrMsg: "Something went wrong when parsing the ephemeral state"
+});
+var { create: create54, of: of52, make: make52 } = factory7;
+var schemas52 = {
+  ...generatedSchemas6,
+  schema: generatedSchemas6.schema.transform((val) => val)
+};
+var getTaskCounts = (pluginInfo) => {
+  return pluginInfo.reduce(
+    (retval, pluginInfo2) => pluginInfo2.tasks === void 0 ? {} : pluginInfo2.tasks.reduce(
+      (retval2, task) => {
+        const taskName = task.task;
+        const providers = retval2[taskName] ? [...retval2[taskName], pluginInfo2] : [pluginInfo2];
+        const mapping = {};
+        mapping[taskName] = providers.filter((provider) => provider !== void 0);
+        return { ...retval2, ...mapping };
+      },
+      retval
+    ),
+    {}
+  );
+};
+var getTemplateCounts = (pluginInfo) => {
+  return pluginInfo.reduce(
+    (retval, pluginInfo2) => !pluginInfo2.templates ? retval : pluginInfo2.templates.reduce(
+      (retval2, template) => {
+        const templateName = template.template;
+        const providers = retval2[templateName] ? [...retval2[templateName], pluginInfo2] : [pluginInfo2];
+        const mapping = {};
+        mapping[templateName] = providers.filter((provider) => provider !== void 0);
+        return { ...retval2, ...mapping };
+      },
+      retval
+    ),
+    {}
+  );
+};
+var getOperationCounts = (pluginInfo) => {
+  return pluginInfo.reduce(
+    (retval, pluginInfo2) => pluginInfo2.operations === void 0 ? retval : pluginInfo2.operations.reduce(
+      (retval2, operation) => {
+        const operationName = operation.operation;
+        const providers = retval2[operationName] ? [...retval2[operationName], pluginInfo2] : [pluginInfo2];
+        const mapping = {};
+        mapping[operationName] = providers.filter((provider) => provider !== void 0);
+        return { ...retval2, ...mapping };
+      },
+      retval
+    ),
+    {}
+  );
+};
+var toChoices = (plugins) => plugins.reduce(
+  (retval, pluginInfo) => {
+    return [...retval, pluginInfo.name, pluginInfo.alias];
+  },
+  []
+);
+var isComposite = (name, counts) => counts[name] && counts[name].length > 1;
+var getInstalledPlugin = (config, name) => {
+  var _a;
+  return (_a = config.plugins) == null ? void 0 : _a.find(
+    (plugin) => [`taqueria-plugin-${name}`, name].includes(plugin.name)
+  );
+};
+var mapTasksToPlugins = (config, pluginInfo, i18n) => {
+  const taskCounts = getTaskCounts(pluginInfo);
+  return (0, import_fluture49.attemptP)(
+    async () => await pluginInfo.reduce(
+      async (retval, pluginInfo2) => !pluginInfo2.tasks ? Promise.resolve({}) : await pluginInfo2.tasks.reduce(
+        async (retval2, { task, hidden }) => {
+          if (isComposite(task, taskCounts)) {
+            const command = await eager2(Command_exports.make(task));
+            const compositeTask = await eager2(Task_exports.make({
+              task,
+              command,
+              description: await eager2(NonEmptyString_exports.make(i18n.__("providedByMany"))),
+              hidden,
+              options: [
+                await eager2(Option_exports.make({
+                  flag: await eager2(Verb_exports.make("plugin")),
+                  description: await eager2(
+                    NonEmptyString_exports.make("Specify which plugin should be used to execute this task")
+                  ),
+                  choices: toChoices(taskCounts[task]),
+                  required: true
+                }))
+              ],
+              handler: "proxy"
+            }));
+            return { ...await retval2, [task]: compositeTask };
+          }
+          const installedPlugin = getInstalledPlugin(config, pluginInfo2.name);
+          return installedPlugin ? { ...await retval2, [task]: installedPlugin } : retval2;
+        },
+        retval
+      ),
+      Promise.resolve({})
+    )
+  ).pipe((0, import_fluture49.mapRej)((rej) => rej));
+};
+var mapOperationsToPlugins = (config, pluginInfo, i18n) => {
+  const opCounts = getOperationCounts(pluginInfo);
+  return (0, import_fluture49.attemptP)(
+    async () => await pluginInfo.reduce(
+      async (retval, pluginInfo2) => !pluginInfo2.operations ? Promise.resolve({}) : await pluginInfo2.operations.reduce(
+        async (retval2, { operation }) => {
+          if (isComposite(operation, opCounts)) {
+            const command = await eager2(Command_exports.make(operation));
+            const compositeOp = await eager2(ParsedOperation_exports.make({
+              operation,
+              command,
+              description: await eager2(NonEmptyString_exports.make(i18n.__("providedByMany"))),
+              options: [
+                await eager2(Option_exports.make({
+                  flag: await eager2(Verb_exports.make("plugin")),
+                  description: await eager2(
+                    NonEmptyString_exports.make("Specify which plugin should be used to execute this operation")
+                  ),
+                  choices: toChoices(opCounts[operation]),
+                  required: true
+                }))
+              ]
+            }));
+            return { ...await retval2, [operation]: compositeOp };
+          }
+          const installedPlugin = getInstalledPlugin(config, pluginInfo2.name);
+          return installedPlugin ? { ...await retval2, [operation]: installedPlugin } : retval2;
+        },
+        retval
+      ),
+      Promise.resolve({})
+    )
+  ).pipe((0, import_fluture49.mapRej)((rej) => rej));
+};
+var mapTemplatesToPlugins = (config, pluginInfo, i18n) => {
+  const tmplCounts = getTemplateCounts(pluginInfo);
+  return (0, import_fluture49.attemptP)(
+    async () => await pluginInfo.reduce(
+      async (retval, pluginInfo2) => !pluginInfo2.templates ? Promise.resolve({}) : await pluginInfo2.templates.reduce(
+        async (retval2, { template, hidden }) => {
+          if (isComposite(template, tmplCounts)) {
+            const command = await eager2(Command_exports.make(template));
+            const description = await eager2(NonEmptyString_exports.of(i18n.__("providedByMany")));
+            const compositeTmpl = await eager2(ParsedTemplate_exports.make({
+              template,
+              command,
+              description,
+              options: [
+                await eager2(Option_exports.make({
+                  flag: await eager2(Verb_exports.make("plugin")),
+                  description: await eager2(
+                    NonEmptyString_exports.make("Specify which plugin should be used to execute this task")
+                  ),
+                  choices: toChoices(tmplCounts[template]),
+                  required: true
+                }))
+              ],
+              handler: "proxy",
+              encoding: PluginResponseEncoding_exports.create("none")
+            }));
+            return { ...await retval2, [template]: compositeTmpl };
+          }
+          const installedPlugin = getInstalledPlugin(config, pluginInfo2.name);
+          return installedPlugin ? { ...await retval2, [template]: installedPlugin } : retval2;
+        },
+        retval
+      ),
+      Promise.resolve({})
+    )
+  ).pipe((0, import_fluture49.mapRej)((rej) => rej));
+};
+var getTasks = (pluginInfo) => pluginInfo.reduce(
+  (retval, pluginInfo2) => {
+    var _a;
+    return [...retval, ...(_a = pluginInfo2.tasks) != null ? _a : []];
+  },
+  []
+);
 //# sourceMappingURL=taqueria-protocol-types.js.map