@taqueria/protocol 0.56.15 → 0.57.8

package/taqueria-protocol-types.d.js

@@ -0,0 +1,3523 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, 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: () => from46[key], enumerable: !(desc = __getOwnPropDesc(from46, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// taqueria-protocol-types.d.ts
+var taqueria_protocol_types_d_exports = {};
+__export(taqueria_protocol_types_d_exports, {
+  Alias: () => Alias_exports,
+  Config: () => Config_exports,
+  EconomicalProtocolHash: () => EconomicalProtocolHash_exports,
+  Environment: () => Environment_exports,
+  EphemeralState: () => EphemeralState_exports,
+  HumanReadableIdentifier: () => HumanReadableIdentifier_exports,
+  InstalledPlugin: () => InstalledPlugin_exports,
+  LoadedConfig: () => LoadedConfig_exports,
+  MetadataConfig: () => MetadataConfig_exports,
+  NetworkConfig: () => NetworkConfig_exports,
+  Operation: () => Operation_exports,
+  Option: () => Option_exports,
+  ParsedOperation: () => ParsedOperation_exports,
+  ParsedTemplate: () => ParsedTemplate_exports,
+  PersistentState: () => PersistentState_exports,
+  PluginActionName: () => PluginActionName_exports,
+  PluginInfo: () => PluginInfo_exports,
+  PluginJsonResponse: () => PluginJsonResponse_exports,
+  PluginResponseEncoding: () => PluginResponseEncoding_exports,
+  PluginSchema: () => PluginSchema_exports,
+  PositionalArg: () => PositionalArg_exports,
+  RequestArgs: () => RequestArgs_exports,
+  SHA256: () => SHA256_exports,
+  SandboxAccountConfig: () => SandboxAccountConfig_exports,
+  SandboxConfig: () => SandboxConfig_exports,
+  SanitizedAbsPath: () => SanitizedAbsPath_exports,
+  SanitizedArgs: () => SanitizedArgs_exports,
+  SanitizedPath: () => SanitizedPath_exports,
+  ScaffoldConfig: () => ScaffoldConfig_exports,
+  TaqError: () => TaqError_exports,
+  Task: () => Task_exports,
+  Template: () => Template_exports,
+  Url: () => Url_exports,
+  Verb: () => Verb_exports,
+  VersionNumber: () => VersionNumber_exports,
+  i18n: () => i18n_exports
+});
+module.exports = __toCommonJS(taqueria_protocol_types_d_exports);
+
+// Alias.ts
+var Alias_exports = {};
+__export(Alias_exports, {
+  create: () => create2,
+  from: () => from,
+  internalSchema: () => internalSchema,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas
+});
+
+// TaqError.ts
+var TaqError_exports = {};
+__export(TaqError_exports, {
+  E_TaqError: () => E_TaqError,
+  create: () => create,
+  toFutureParseErr: () => toFutureParseErr,
+  toFutureParseUnknownErr: () => toFutureParseUnknownErr,
+  toParseErr: () => toParseErr,
+  toParseUnknownErr: () => toParseUnknownErr
+});
+var import_fluture = require("fluture");
+var E_TaqError = class extends Error {
+  constructor(taqErr) {
+    super(taqErr.msg);
+    this.context = taqErr.context;
+    this.kind = taqErr.kind;
+    this.name = this.kind;
+    this.previous = taqErr.previous;
+  }
+};
+var toFutureParseErr = (previous, msg, context) => (0, import_fluture.reject)(toParseErr(previous, msg, context)).pipe((0, import_fluture.map)((val) => val));
+var toParseErr = (previous, msg, context) => create({
+  kind: "E_PARSE",
+  msg,
+  context,
+  previous
+});
+var toParseUnknownErr = (previous, msg, context) => create({
+  kind: "E_PARSE_UNKNOWN",
+  msg,
+  context,
+  previous
+});
+var toFutureParseUnknownErr = (previous, msg, context) => (0, import_fluture.reject)(toParseUnknownErr(previous, msg, context)).pipe((0, import_fluture.map)((val) => val));
+var create = (err) => err;
+
+// out/types/Alias.ts
+var import_fluture2 = require("fluture");
+var import_zod2 = require("zod");
+
+// out/types-zod.ts
+var import_zod = require("zod");
+var nonEmptyStringSchema = import_zod.z.string().min(1);
+var singleCharSchema = nonEmptyStringSchema.regex(/^[A-Za-z]$/);
+var verbSchema = nonEmptyStringSchema.regex(/^[A-Za-z\-\ ]+/);
+var aliasSchema = import_zod.z.union([verbSchema, singleCharSchema]);
+var humanReadableIdentifierSchema = nonEmptyStringSchema.regex(
+  /^[A-Za-z]+[A-Za-z0-9-_ ]*$/
+);
+var sanitizedAbsPathSchema = nonEmptyStringSchema;
+var sanitizedPathSchema = nonEmptyStringSchema;
+var settingsSchema = import_zod.z.object({
+  consent: import_zod.z.union([
+    import_zod.z.literal("opt_in"),
+    import_zod.z.literal("opt_out"),
+    import_zod.z.literal("unspecified")
+  ])
+});
+var timestampSchema = import_zod.z.number().min(1651846877);
+var tzSchema = nonEmptyStringSchema.min(1).regex(/^\d([\d_]+\d)?$/);
+var versionNumberSchema = nonEmptyStringSchema.min(1).regex(/^\d+\.\d+(\.\d+)*$/);
+var urlSchema = nonEmptyStringSchema.url();
+var commandSchema = nonEmptyStringSchema.regex(
+  /^([A-Za-z-_ ]+ ?)((\[.+\] ?)|(\<.+\>) ?)*$/
+);
+var optionSchema = import_zod.z.object({
+  shortFlag: singleCharSchema.optional(),
+  flag: verbSchema,
+  description: nonEmptyStringSchema,
+  defaultValue: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]).optional(),
+  type: import_zod.z.union([
+    import_zod.z.literal("string"),
+    import_zod.z.literal("number"),
+    import_zod.z.literal("boolean"),
+    import_zod.z.literal("count")
+  ]).optional(),
+  required: import_zod.z.boolean().optional(),
+  boolean: import_zod.z.boolean().optional(),
+  choices: import_zod.z.array(nonEmptyStringSchema).optional()
+});
+var positionalArgSchema = import_zod.z.object({
+  placeholder: humanReadableIdentifierSchema,
+  description: nonEmptyStringSchema,
+  defaultValue: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]).optional(),
+  type: import_zod.z.union([import_zod.z.literal("string"), import_zod.z.literal("number"), import_zod.z.literal("boolean")]).optional(),
+  required: import_zod.z.boolean().optional()
+});
+var installedPluginSchema = import_zod.z.object({
+  type: import_zod.z.union([import_zod.z.literal("npm"), import_zod.z.literal("binary"), import_zod.z.literal("deno")]),
+  name: nonEmptyStringSchema
+});
+var pluginResponseEncodingSchema = import_zod.z.union([import_zod.z.literal("none"), import_zod.z.literal("json"), import_zod.z.literal("application/json")]).default("none");
+var taskSchema = import_zod.z.object({
+  task: verbSchema,
+  command: commandSchema,
+  aliases: import_zod.z.array(aliasSchema).optional(),
+  description: nonEmptyStringSchema.min(3).optional(),
+  example: nonEmptyStringSchema.optional(),
+  hidden: import_zod.z.boolean().optional(),
+  encoding: pluginResponseEncodingSchema.optional(),
+  handler: import_zod.z.union([import_zod.z.literal("proxy"), nonEmptyStringSchema]),
+  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(),
+  version: import_zod.z.string(),
+  kind: import_zod.z.union([import_zod.z.literal("required"), import_zod.z.literal("optional")])
+});
+var runtimeDependencyReportSchema = runtimeDependencySchema.extend(
+  {
+    met: import_zod.z.boolean()
+  }
+);
+var pluginDependenciesResponseSchema = import_zod.z.object({
+  report: import_zod.z.array(runtimeDependencyReportSchema)
+});
+var pluginJsonResponseSchema = import_zod.z.union([
+  import_zod.z.object({
+    data: import_zod.z.unknown().optional(),
+    messages: import_zod.z.object({
+      header: import_zod.z.string().optional(),
+      footer: import_zod.z.string().optional()
+    }).optional(),
+    render: import_zod.z.union([import_zod.z.literal("none"), import_zod.z.literal("table"), import_zod.z.literal("string")]).default("none")
+  }),
+  import_zod.z.void()
+]);
+var pluginProxyResponseSchema = import_zod.z.union([
+  import_zod.z.void(),
+  pluginJsonResponseSchema
+]);
+var buildNumberSchema = import_zod.z.number();
+var sanitizedArgsSchema = import_zod.z.object({
+  _: import_zod.z.array(import_zod.z.string()),
+  projectDir: sanitizedPathSchema,
+  maxConcurrency: import_zod.z.number(),
+  debug: import_zod.z.boolean(),
+  disableState: import_zod.z.boolean(),
+  logPluginRequests: import_zod.z.boolean(),
+  fromVsCode: import_zod.z.boolean(),
+  version: import_zod.z.boolean(),
+  build: import_zod.z.boolean(),
+  help: import_zod.z.boolean(),
+  yes: import_zod.z.boolean(),
+  plugin: nonEmptyStringSchema.optional(),
+  env: nonEmptyStringSchema,
+  quickstart: nonEmptyStringSchema,
+  setBuild: import_zod.z.union([nonEmptyStringSchema, buildNumberSchema]),
+  setVersion: nonEmptyStringSchema
+}).passthrough();
+var pluginActionNameSchema = import_zod.z.union([
+  import_zod.z.literal("proxy"),
+  import_zod.z.literal("pluginInfo"),
+  import_zod.z.literal("checkRuntimeDependencies"),
+  import_zod.z.literal("installRuntimeDependencies"),
+  import_zod.z.literal("runPostInstall"),
+  import_zod.z.literal("proxyTemplate")
+]);
+var economicalProtocolHashSchema = import_zod.z.string();
+var publicKeyHashSchema = import_zod.z.string().regex(/^tz\d[A-Za-z0-9]{33}$/);
+var sha256Schema = import_zod.z.string().regex(/^[A-Fa-f0-9]{64}$/);
+var contractSchema = import_zod.z.object({
+  sourceFile: nonEmptyStringSchema,
+  hash: sha256Schema
+});
+var faucetSchema = import_zod.z.object({
+  pkh: publicKeyHashSchema,
+  mnemonic: import_zod.z.array(import_zod.z.string()),
+  email: import_zod.z.string().email(),
+  password: import_zod.z.string(),
+  amount: import_zod.z.string().regex(/^\d+$/),
+  activation_code: import_zod.z.string()
+});
+var tzKtConfigPostgresqlPortSchema = import_zod.z.number().default(5432);
+var tzKtConfigApiPortSchema = import_zod.z.number().default(5e3);
+var tzKtConfigSchema = import_zod.z.object({
+  disableAutostartWithSandbox: import_zod.z.boolean().optional(),
+  postgresqlPort: tzKtConfigPostgresqlPortSchema.optional(),
+  apiPort: tzKtConfigApiPortSchema.optional()
+});
+var persistedOperationSchema = import_zod.z.object({
+  hash: sha256Schema,
+  time: timestampSchema,
+  output: import_zod.z.unknown().optional()
+});
+var persistedTaskSchema = import_zod.z.object({
+  task: verbSchema,
+  plugin: nonEmptyStringSchema,
+  time: timestampSchema,
+  output: import_zod.z.unknown().optional()
+});
+var provisionerIDSchema = import_zod.z.string().min(1).regex(
+  /^[A-Za-z0-9]+[A-Za-z0-9-_]+\.[A-Za-z0-9]+[A-Za-z0-9-_]+\.[A-Za-z0-9]+[A-Za-z0-9-_]+$/
+);
+var provisionerSchema = import_zod.z.object({
+  id: provisionerIDSchema,
+  plugin: nonEmptyStringSchema,
+  operation: import_zod.z.union([nonEmptyStringSchema, import_zod.z.literal("custom")]),
+  command: import_zod.z.string().optional(),
+  label: import_zod.z.string().optional(),
+  depends_on: import_zod.z.array(provisionerIDSchema).optional()
+});
+var provisionsSchema = import_zod.z.array(provisionerSchema);
+var environmentSchema = import_zod.z.object({
+  networks: import_zod.z.array(nonEmptyStringSchema),
+  sandboxes: import_zod.z.array(nonEmptyStringSchema),
+  storage: import_zod.z.record(nonEmptyStringSchema).optional(),
+  aliases: import_zod.z.record(import_zod.z.record(nonEmptyStringSchema)).optional()
+});
+var environmentNameSchema = nonEmptyStringSchema.min(
+  1,
+  "Default environment must reference the name of an existing environment."
+);
+var humanLanguageSchema = import_zod.z.union([import_zod.z.literal("en"), import_zod.z.literal("fr")]).default("en");
+var configContractsDirSchema = import_zod.z.string().min(1).default("contracts");
+var configArtifactsDirSchema = import_zod.z.string().min(1).default("artifacts");
+var currencyAmountV2Schema = import_zod.z.object({
+  amount: import_zod.z.string(),
+  units: import_zod.z.string()
+});
+var metadataConfigSchema = import_zod.z.object({
+  name: import_zod.z.string().optional(),
+  projectDescription: import_zod.z.string().optional(),
+  authors: import_zod.z.array(import_zod.z.string()).optional(),
+  license: import_zod.z.string().optional(),
+  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(),
+  privateKey: nonEmptyStringSchema.optional(),
+  mnemonic: nonEmptyStringSchema.optional()
+});
+var sandboxAccountConfigSchema = import_zod.z.object({
+  encryptedKey: nonEmptyStringSchema,
+  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 persistentStateSchema = import_zod.z.object({
+  operations: import_zod.z.record(persistedOperationSchema),
+  tasks: import_zod.z.record(persistedTaskSchema)
+});
+var networkConfigSchema = import_zod.z.object({
+  label: humanReadableIdentifierSchema,
+  rpcUrl: urlSchema,
+  accounts: import_zod.z.record(networkAccountConfigSchema).optional(),
+  faucet: faucetSchema.optional()
+});
+var configFileV1Schema = import_zod.z.object({
+  language: humanLanguageSchema.optional(),
+  plugins: import_zod.z.array(installedPluginSchema).optional(),
+  contractsDir: configContractsDirSchema.optional(),
+  artifactsDir: configArtifactsDirSchema.optional(),
+  network: import_zod.z.record(networkConfigSchema).optional(),
+  sandbox: import_zod.z.record(sandboxConfigSchema).optional(),
+  environment: import_zod.z.record(import_zod.z.union([environmentSchema, environmentNameSchema])).optional(),
+  accounts: import_zod.z.record(tzSchema).optional(),
+  contracts: import_zod.z.record(contractSchema).optional(),
+  metadata: metadataConfigSchema.optional()
+});
+var configFileV2Schema = import_zod.z.object({
+  version: versionV2Schema,
+  language: humanLanguageSchema.optional(),
+  metadata: metadataConfigSchema.optional(),
+  artifactsDir: configArtifactsDirSchema.optional(),
+  contractsDir: configContractsDirSchema.optional(),
+  accounts: import_zod.z.record(configAccountSchema).optional(),
+  contracts: import_zod.z.record(contractSchema).optional(),
+  environmentDefault: environmentNameSchema.optional(),
+  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]))
+  }
+);
+var loadedConfigSchema = configSchema.extend(
+  {
+    projectDir: sanitizedAbsPathSchema,
+    configFile: sanitizedAbsPathSchema,
+    hash: sha256Schema
+  }
+);
+var requestArgsSchema = sanitizedArgsSchema.omit({ quickstart: true }).extend(
+  {
+    taqRun: pluginActionNameSchema,
+    config: loadedConfigSchema
+  }
+).passthrough();
+var proxyTemplateArgsSchema = requestArgsSchema.extend(
+  {
+    template: nonEmptyStringSchema
+  }
+).passthrough();
+var operationSchema = import_zod.z.object({
+  operation: verbSchema,
+  command: commandSchema,
+  description: nonEmptyStringSchema.optional(),
+  positionals: import_zod.z.array(positionalArgSchema).optional(),
+  options: import_zod.z.array(optionSchema).optional(),
+  handler: import_zod.z.function().args(persistentStateSchema).returns(import_zod.z.function().args(requestArgsSchema).returns(import_zod.z.void())).optional()
+});
+var parsedOperationSchema = operationSchema.omit({ handler: true });
+var templateHandlerSchema = import_zod.z.union([
+  nonEmptyStringSchema,
+  import_zod.z.function().args(requestArgsSchema).returns(
+    import_zod.z.union([pluginJsonResponseSchema, import_zod.z.promise(pluginJsonResponseSchema)])
+  ),
+  import_zod.z.promise(import_zod.z.void())
+]);
+var templateSchema = import_zod.z.object({
+  template: verbSchema,
+  command: commandSchema,
+  description: nonEmptyStringSchema,
+  hidden: import_zod.z.boolean().optional(),
+  options: import_zod.z.array(optionSchema).optional(),
+  positionals: import_zod.z.array(positionalArgSchema).optional(),
+  handler: templateHandlerSchema,
+  encoding: pluginResponseEncodingSchema.optional()
+});
+var parsedTemplateSchema = templateSchema.omit({ handler: true }).extend(
+  {
+    handler: import_zod.z.string()
+  }
+);
+var pluginSchemaSchema = pluginSchemaBaseSchema.extend(
+  {
+    operations: import_zod.z.array(operationSchema).optional(),
+    templates: import_zod.z.array(templateSchema).optional(),
+    proxy: import_zod.z.function().args(requestArgsSchema).returns(import_zod.z.promise(pluginProxyResponseSchema)).optional(),
+    checkRuntimeDependencies: import_zod.z.function().args(requestArgsSchema).returns(import_zod.z.promise(pluginDependenciesResponseSchema)).optional(),
+    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(),
+  tasks: import_zod.z.record(installedPluginSchema.and(taskSchema)),
+  operations: import_zod.z.record(installedPluginSchema.and(parsedOperationSchema)),
+  templates: import_zod.z.record(installedPluginSchema.and(parsedTemplateSchema)),
+  plugins: import_zod.z.array(pluginInfoSchema)
+});
+
+// out/types/Alias.ts
+var from = (input) => {
+  try {
+    return aliasSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod2.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Alias is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Alias.");
+  }
+};
+var create2 = (input) => from(input);
+var of = (input) => {
+  try {
+    return (0, import_fluture2.resolve)(from(input));
+  } catch (err) {
+    return (0, import_fluture2.reject)(err);
+  }
+};
+var make = (input) => of(input);
+var schemas = {
+  rawSchema: aliasSchema,
+  schema: aliasSchema.transform((val) => val)
+};
+var rawSchema = schemas.rawSchema;
+var internalSchema = aliasSchema;
+
+// Config.ts
+var Config_exports = {};
+__export(Config_exports, {
+  create: () => create3,
+  from: () => from2,
+  internalSchema: () => internalSchema2,
+  make: () => make2,
+  of: () => of2,
+  rawSchema: () => rawSchema2,
+  schemas: () => schemas2
+});
+
+// out/types/Config.ts
+var import_fluture3 = require("fluture");
+var import_zod3 = require("zod");
+var from2 = (input) => {
+  try {
+    return configSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod3.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:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Config.");
+  }
+};
+var create3 = (input) => from2(input);
+var of2 = (input) => {
+  try {
+    return (0, import_fluture3.resolve)(from2(input));
+  } catch (err) {
+    return (0, import_fluture3.reject)(err);
+  }
+};
+var make2 = (input) => of2(input);
+var schemas2 = {
+  rawSchema: configSchema,
+  schema: configSchema.transform((val) => val)
+};
+var rawSchema2 = schemas2.rawSchema;
+var internalSchema2 = configSchema;
+
+// EconomicalProtocolHash.ts
+var EconomicalProtocolHash_exports = {};
+__export(EconomicalProtocolHash_exports, {
+  create: () => create4,
+  from: () => from3,
+  internalSchema: () => internalSchema3,
+  make: () => make3,
+  of: () => of3,
+  rawSchema: () => rawSchema3,
+  schemas: () => schemas3
+});
+
+// out/types/EconomicalProtocolHash.ts
+var import_fluture4 = require("fluture");
+var import_zod4 = require("zod");
+var from3 = (input) => {
+  try {
+    return economicalProtocolHashSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod4.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["EconomicalProtocolHash is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a EconomicalProtocolHash.");
+  }
+};
+var create4 = (input) => from3(input);
+var of3 = (input) => {
+  try {
+    return (0, import_fluture4.resolve)(from3(input));
+  } catch (err) {
+    return (0, import_fluture4.reject)(err);
+  }
+};
+var make3 = (input) => of3(input);
+var schemas3 = {
+  rawSchema: economicalProtocolHashSchema,
+  schema: economicalProtocolHashSchema.transform((val) => val)
+};
+var rawSchema3 = schemas3.rawSchema;
+var internalSchema3 = economicalProtocolHashSchema;
+
+// Environment.ts
+var Environment_exports = {};
+__export(Environment_exports, {
+  create: () => create5,
+  from: () => from4,
+  internalSchema: () => internalSchema4,
+  make: () => make4,
+  of: () => of4,
+  rawSchema: () => rawSchema4,
+  schemas: () => schemas4
+});
+
+// out/types/Environment.ts
+var import_fluture5 = require("fluture");
+var import_zod5 = require("zod");
+var from4 = (input) => {
+  try {
+    return environmentSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod5.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["Environment is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Environment.");
+  }
+};
+var create5 = (input) => from4(input);
+var of4 = (input) => {
+  try {
+    return (0, import_fluture5.resolve)(from4(input));
+  } catch (err) {
+    return (0, import_fluture5.reject)(err);
+  }
+};
+var make4 = (input) => of4(input);
+var schemas4 = {
+  rawSchema: environmentSchema,
+  schema: environmentSchema.transform((val) => val)
+};
+var rawSchema4 = schemas4.rawSchema;
+var internalSchema4 = environmentSchema;
+
+// EphemeralState.ts
+var EphemeralState_exports = {};
+__export(EphemeralState_exports, {
+  create: () => create54,
+  factory: () => factory7,
+  generatedSchemas: () => generatedSchemas6,
+  getTasks: () => getTasks,
+  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
+});
+
+// out/types/Command.ts
+var import_fluture6 = require("fluture");
+var import_zod6 = require("zod");
+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);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Command.");
+  }
+};
+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;
+
+// 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 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 create7 = (input) => from6(input);
+var of6 = (input) => {
+  try {
+    return (0, import_fluture7.resolve)(from6(input));
+  } catch (err) {
+    return (0, import_fluture7.reject)(err);
+  }
+};
+var make6 = (input) => of6(input);
+var schemas6 = {
+  rawSchema: configFileV2Schema,
+  schema: configFileV2Schema.transform((val) => val)
+};
+var rawSchema6 = schemas6.rawSchema;
+var internalSchema6 = configFileV2Schema;
+
+// Contract.ts
+var Contract_exports = {};
+__export(Contract_exports, {
+  create: () => create8,
+  from: () => from7,
+  internalSchema: () => internalSchema7,
+  make: () => make7,
+  of: () => of7,
+  rawSchema: () => rawSchema7,
+  schemas: () => schemas7
+});
+
+// out/types/Contract.ts
+var import_fluture8 = require("fluture");
+var import_zod8 = require("zod");
+var from7 = (input) => {
+  try {
+    return contractSchema.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];
+        },
+        ["Contract is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Contract.");
+  }
+};
+var create8 = (input) => from7(input);
+var of7 = (input) => {
+  try {
+    return (0, import_fluture8.resolve)(from7(input));
+  } catch (err) {
+    return (0, import_fluture8.reject)(err);
+  }
+};
+var make7 = (input) => of7(input);
+var schemas7 = {
+  rawSchema: contractSchema,
+  schema: contractSchema.transform((val) => val)
+};
+var rawSchema7 = schemas7.rawSchema;
+var internalSchema7 = contractSchema;
+
+// Faucet.ts
+var Faucet_exports = {};
+__export(Faucet_exports, {
+  create: () => create9,
+  from: () => from8,
+  internalSchema: () => internalSchema8,
+  make: () => make8,
+  of: () => of8,
+  rawSchema: () => rawSchema8,
+  schemas: () => schemas8
+});
+
+// out/types/Faucet.ts
+var import_fluture9 = require("fluture");
+var import_zod9 = require("zod");
+var from8 = (input) => {
+  try {
+    return faucetSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["Faucet is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Faucet.");
+  }
+};
+var create9 = (input) => from8(input);
+var of8 = (input) => {
+  try {
+    return (0, import_fluture9.resolve)(from8(input));
+  } catch (err) {
+    return (0, import_fluture9.reject)(err);
+  }
+};
+var make8 = (input) => of8(input);
+var schemas8 = {
+  rawSchema: faucetSchema,
+  schema: faucetSchema.transform((val) => val)
+};
+var rawSchema8 = schemas8.rawSchema;
+var internalSchema8 = faucetSchema;
+
+// HumanReadableIdentifier.ts
+var HumanReadableIdentifier_exports = {};
+__export(HumanReadableIdentifier_exports, {
+  create: () => create10,
+  from: () => from9,
+  internalSchema: () => internalSchema9,
+  make: () => make9,
+  of: () => of9,
+  rawSchema: () => rawSchema9,
+  schemas: () => schemas9
+});
+
+// out/types/HumanReadableIdentifier.ts
+var import_fluture10 = require("fluture");
+var import_zod10 = require("zod");
+var from9 = (input) => {
+  try {
+    return humanReadableIdentifierSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["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 create10 = (input) => from9(input);
+var of9 = (input) => {
+  try {
+    return (0, import_fluture10.resolve)(from9(input));
+  } catch (err) {
+    return (0, import_fluture10.reject)(err);
+  }
+};
+var make9 = (input) => of9(input);
+var schemas9 = {
+  rawSchema: humanReadableIdentifierSchema,
+  schema: humanReadableIdentifierSchema.transform((val) => val)
+};
+var rawSchema9 = schemas9.rawSchema;
+var internalSchema9 = humanReadableIdentifierSchema;
+
+// InstalledPlugin.ts
+var InstalledPlugin_exports = {};
+__export(InstalledPlugin_exports, {
+  create: () => create11,
+  from: () => from10,
+  internalSchema: () => internalSchema10,
+  make: () => make10,
+  of: () => of10,
+  rawSchema: () => rawSchema10,
+  schemas: () => schemas10
+});
+
+// out/types/InstalledPlugin.ts
+var import_fluture11 = require("fluture");
+var import_zod11 = require("zod");
+var from10 = (input) => {
+  try {
+    return installedPluginSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["InstalledPlugin is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a InstalledPlugin.");
+  }
+};
+var create11 = (input) => from10(input);
+var of10 = (input) => {
+  try {
+    return (0, import_fluture11.resolve)(from10(input));
+  } catch (err) {
+    return (0, import_fluture11.reject)(err);
+  }
+};
+var make10 = (input) => of10(input);
+var schemas10 = {
+  rawSchema: installedPluginSchema,
+  schema: installedPluginSchema.transform((val) => val)
+};
+var rawSchema10 = schemas10.rawSchema;
+var internalSchema10 = installedPluginSchema;
+
+// LoadedConfig.ts
+var LoadedConfig_exports = {};
+__export(LoadedConfig_exports, {
+  create: () => create12,
+  from: () => from11,
+  internalSchema: () => internalSchema11,
+  make: () => make11,
+  of: () => of11,
+  rawSchema: () => rawSchema11,
+  schemas: () => schemas11
+});
+
+// out/types/LoadedConfig.ts
+var import_fluture12 = require("fluture");
+var import_zod12 = require("zod");
+var from11 = (input) => {
+  try {
+    return loadedConfigSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["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 LoadedConfig.");
+  }
+};
+var create12 = (input) => from11(input);
+var of11 = (input) => {
+  try {
+    return (0, import_fluture12.resolve)(from11(input));
+  } catch (err) {
+    return (0, import_fluture12.reject)(err);
+  }
+};
+var make11 = (input) => of11(input);
+var schemas11 = {
+  rawSchema: loadedConfigSchema,
+  schema: loadedConfigSchema.transform((val) => val)
+};
+var rawSchema11 = schemas11.rawSchema;
+var internalSchema11 = loadedConfigSchema;
+
+// MetadataConfig.ts
+var MetadataConfig_exports = {};
+__export(MetadataConfig_exports, {
+  create: () => create13,
+  from: () => from12,
+  internalSchema: () => internalSchema12,
+  make: () => make12,
+  of: () => of12,
+  rawSchema: () => rawSchema12,
+  schemas: () => schemas12
+});
+
+// out/types/MetadataConfig.ts
+var import_fluture13 = require("fluture");
+var import_zod13 = require("zod");
+var from12 = (input) => {
+  try {
+    return metadataConfigSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["MetadataConfig is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a MetadataConfig.");
+  }
+};
+var create13 = (input) => from12(input);
+var of12 = (input) => {
+  try {
+    return (0, import_fluture13.resolve)(from12(input));
+  } catch (err) {
+    return (0, import_fluture13.reject)(err);
+  }
+};
+var make12 = (input) => of12(input);
+var schemas12 = {
+  rawSchema: metadataConfigSchema,
+  schema: metadataConfigSchema.transform((val) => val)
+};
+var rawSchema12 = schemas12.rawSchema;
+var internalSchema12 = metadataConfigSchema;
+
+// NetworkAccountConfig.ts
+var NetworkAccountConfig_exports = {};
+__export(NetworkAccountConfig_exports, {
+  create: () => create14,
+  from: () => from13,
+  internalSchema: () => internalSchema13,
+  make: () => make13,
+  of: () => of13,
+  rawSchema: () => rawSchema13,
+  schemas: () => schemas13
+});
+
+// out/types/NetworkAccountConfig.ts
+var import_fluture14 = require("fluture");
+var import_zod14 = require("zod");
+var from13 = (input) => {
+  try {
+    return networkAccountConfigSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["NetworkAccountConfig is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a NetworkAccountConfig.");
+  }
+};
+var create14 = (input) => from13(input);
+var of13 = (input) => {
+  try {
+    return (0, import_fluture14.resolve)(from13(input));
+  } catch (err) {
+    return (0, import_fluture14.reject)(err);
+  }
+};
+var make13 = (input) => of13(input);
+var schemas13 = {
+  rawSchema: networkAccountConfigSchema,
+  schema: networkAccountConfigSchema.transform((val) => val)
+};
+var rawSchema13 = schemas13.rawSchema;
+var internalSchema13 = networkAccountConfigSchema;
+
+// NetworkConfig.ts
+var NetworkConfig_exports = {};
+__export(NetworkConfig_exports, {
+  create: () => create15,
+  from: () => from14,
+  internalSchema: () => internalSchema14,
+  make: () => make14,
+  of: () => of14,
+  rawSchema: () => rawSchema14,
+  schemas: () => schemas14
+});
+
+// out/types/NetworkConfig.ts
+var import_fluture15 = require("fluture");
+var import_zod15 = require("zod");
+var from14 = (input) => {
+  try {
+    return networkConfigSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["NetworkConfig is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a NetworkConfig.");
+  }
+};
+var create15 = (input) => from14(input);
+var of14 = (input) => {
+  try {
+    return (0, import_fluture15.resolve)(from14(input));
+  } catch (err) {
+    return (0, import_fluture15.reject)(err);
+  }
+};
+var make14 = (input) => of14(input);
+var schemas14 = {
+  rawSchema: networkConfigSchema,
+  schema: networkConfigSchema.transform((val) => val)
+};
+var rawSchema14 = schemas14.rawSchema;
+var internalSchema14 = networkConfigSchema;
+
+// NonEmptyString.ts
+var NonEmptyString_exports = {};
+__export(NonEmptyString_exports, {
+  create: () => create16,
+  from: () => from15,
+  internalSchema: () => internalSchema15,
+  make: () => make15,
+  of: () => of15,
+  rawSchema: () => rawSchema15,
+  schemas: () => schemas15
+});
+
+// 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 create16 = (input) => from15(input);
+var of15 = (input) => {
+  try {
+    return (0, import_fluture16.resolve)(from15(input));
+  } catch (err) {
+    return (0, import_fluture16.reject)(err);
+  }
+};
+var make15 = (input) => of15(input);
+var schemas15 = {
+  rawSchema: nonEmptyStringSchema,
+  schema: nonEmptyStringSchema.transform((val) => val)
+};
+var rawSchema15 = schemas15.rawSchema;
+var internalSchema15 = nonEmptyStringSchema;
+
+// 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: operationSchema,
+  schema: operationSchema.transform((val) => val)
+};
+var rawSchema16 = schemas16.rawSchema;
+var internalSchema16 = operationSchema;
+
+// Option.ts
+var Option_exports = {};
+__export(Option_exports, {
+  create: () => create18,
+  from: () => from17,
+  internalSchema: () => internalSchema17,
+  make: () => make17,
+  of: () => of17,
+  rawSchema: () => rawSchema17,
+  schemas: () => schemas17
+});
+
+// out/types/Option.ts
+var import_fluture18 = require("fluture");
+var import_zod18 = require("zod");
+var from17 = (input) => {
+  try {
+    return optionSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["Option is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Option.");
+  }
+};
+var create18 = (input) => from17(input);
+var of17 = (input) => {
+  try {
+    return (0, import_fluture18.resolve)(from17(input));
+  } catch (err) {
+    return (0, import_fluture18.reject)(err);
+  }
+};
+var make17 = (input) => of17(input);
+var schemas17 = {
+  rawSchema: optionSchema,
+  schema: optionSchema.transform((val) => val)
+};
+var rawSchema17 = schemas17.rawSchema;
+var internalSchema17 = optionSchema;
+
+// ParsedOperation.ts
+var ParsedOperation_exports = {};
+__export(ParsedOperation_exports, {
+  create: () => create19,
+  from: () => from18,
+  internalSchema: () => internalSchema18,
+  make: () => make18,
+  of: () => of18,
+  rawSchema: () => rawSchema18,
+  schemas: () => schemas18
+});
+
+// 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 = {
+  rawSchema: parsedOperationSchema,
+  schema: parsedOperationSchema.transform((val) => val)
+};
+var rawSchema18 = schemas18.rawSchema;
+var internalSchema18 = parsedOperationSchema;
+
+// ParsedTemplate.ts
+var ParsedTemplate_exports = {};
+__export(ParsedTemplate_exports, {
+  create: () => create20,
+  from: () => from19,
+  internalSchema: () => internalSchema19,
+  make: () => make19,
+  of: () => of19,
+  rawSchema: () => rawSchema19,
+  schemas: () => schemas19
+});
+
+// out/types/ParsedTemplate.ts
+var import_fluture20 = require("fluture");
+var import_zod20 = require("zod");
+var from19 = (input) => {
+  try {
+    return parsedTemplateSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["ParsedTemplate is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a ParsedTemplate.");
+  }
+};
+var create20 = (input) => from19(input);
+var of19 = (input) => {
+  try {
+    return (0, import_fluture20.resolve)(from19(input));
+  } catch (err) {
+    return (0, import_fluture20.reject)(err);
+  }
+};
+var make19 = (input) => of19(input);
+var schemas19 = {
+  rawSchema: parsedTemplateSchema,
+  schema: parsedTemplateSchema.transform((val) => val)
+};
+var rawSchema19 = schemas19.rawSchema;
+var internalSchema19 = parsedTemplateSchema;
+
+// PluginActionName.ts
+var PluginActionName_exports = {};
+__export(PluginActionName_exports, {
+  create: () => create21,
+  from: () => from20,
+  internalSchema: () => internalSchema20,
+  make: () => make20,
+  of: () => of20,
+  rawSchema: () => rawSchema20,
+  schemas: () => schemas20
+});
+
+// out/types/PluginActionName.ts
+var import_fluture21 = require("fluture");
+var import_zod21 = require("zod");
+var from20 = (input) => {
+  try {
+    return pluginActionNameSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["PluginActionName is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginActionName.");
+  }
+};
+var create21 = (input) => from20(input);
+var of20 = (input) => {
+  try {
+    return (0, import_fluture21.resolve)(from20(input));
+  } catch (err) {
+    return (0, import_fluture21.reject)(err);
+  }
+};
+var make20 = (input) => of20(input);
+var schemas20 = {
+  rawSchema: pluginActionNameSchema,
+  schema: pluginActionNameSchema.transform((val) => val)
+};
+var rawSchema20 = schemas20.rawSchema;
+var internalSchema20 = pluginActionNameSchema;
+
+// PluginDependenciesResponse.ts
+var PluginDependenciesResponse_exports = {};
+__export(PluginDependenciesResponse_exports, {
+  create: () => create22,
+  from: () => from21,
+  internalSchema: () => internalSchema21,
+  make: () => make21,
+  of: () => of21,
+  rawSchema: () => rawSchema21,
+  schemas: () => schemas21
+});
+
+// out/types/PluginDependenciesResponse.ts
+var import_fluture22 = require("fluture");
+var import_zod22 = require("zod");
+var from21 = (input) => {
+  try {
+    return pluginDependenciesResponseSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["PluginDependenciesResponse is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginDependenciesResponse.");
+  }
+};
+var create22 = (input) => from21(input);
+var of21 = (input) => {
+  try {
+    return (0, import_fluture22.resolve)(from21(input));
+  } catch (err) {
+    return (0, import_fluture22.reject)(err);
+  }
+};
+var make21 = (input) => of21(input);
+var schemas21 = {
+  rawSchema: pluginDependenciesResponseSchema,
+  schema: pluginDependenciesResponseSchema.transform((val) => val)
+};
+var rawSchema21 = schemas21.rawSchema;
+var internalSchema21 = pluginDependenciesResponseSchema;
+
+// PluginJsonResponse.ts
+var PluginJsonResponse_exports = {};
+__export(PluginJsonResponse_exports, {
+  create: () => create23,
+  from: () => from22,
+  internalSchema: () => internalSchema22,
+  make: () => make22,
+  of: () => of22,
+  rawSchema: () => rawSchema22,
+  schemas: () => schemas22
+});
+
+// out/types/PluginJsonResponse.ts
+var import_fluture23 = require("fluture");
+var import_zod23 = require("zod");
+var from22 = (input) => {
+  try {
+    return pluginJsonResponseSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod23.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["PluginJsonResponse is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginJsonResponse.");
+  }
+};
+var create23 = (input) => from22(input);
+var of22 = (input) => {
+  try {
+    return (0, import_fluture23.resolve)(from22(input));
+  } catch (err) {
+    return (0, import_fluture23.reject)(err);
+  }
+};
+var make22 = (input) => of22(input);
+var schemas22 = {
+  rawSchema: pluginJsonResponseSchema,
+  schema: pluginJsonResponseSchema.transform((val) => val)
+};
+var rawSchema22 = schemas22.rawSchema;
+var internalSchema22 = pluginJsonResponseSchema;
+
+// PluginProxyResponse.ts
+var PluginProxyResponse_exports = {};
+__export(PluginProxyResponse_exports, {
+  create: () => create24,
+  from: () => from23,
+  internalSchema: () => internalSchema23,
+  make: () => make23,
+  of: () => of23,
+  rawSchema: () => rawSchema23,
+  schemas: () => schemas23
+});
+
+// out/types/PluginProxyResponse.ts
+var import_fluture24 = require("fluture");
+var import_zod24 = require("zod");
+var from23 = (input) => {
+  try {
+    return pluginProxyResponseSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["PluginProxyResponse is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginProxyResponse.");
+  }
+};
+var create24 = (input) => from23(input);
+var of23 = (input) => {
+  try {
+    return (0, import_fluture24.resolve)(from23(input));
+  } catch (err) {
+    return (0, import_fluture24.reject)(err);
+  }
+};
+var make23 = (input) => of23(input);
+var schemas23 = {
+  rawSchema: pluginProxyResponseSchema,
+  schema: pluginProxyResponseSchema.transform((val) => val)
+};
+var rawSchema23 = schemas23.rawSchema;
+var internalSchema23 = pluginProxyResponseSchema;
+
+// PluginResponseEncoding.ts
+var PluginResponseEncoding_exports = {};
+__export(PluginResponseEncoding_exports, {
+  create: () => create25,
+  from: () => from24,
+  internalSchema: () => internalSchema24,
+  make: () => make24,
+  of: () => of24,
+  rawSchema: () => rawSchema24,
+  schemas: () => schemas24
+});
+
+// out/types/PluginResponseEncoding.ts
+var import_fluture25 = require("fluture");
+var import_zod25 = require("zod");
+var from24 = (input) => {
+  try {
+    return pluginResponseEncodingSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["PluginResponseEncoding is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginResponseEncoding.");
+  }
+};
+var create25 = (input) => from24(input);
+var of24 = (input) => {
+  try {
+    return (0, import_fluture25.resolve)(from24(input));
+  } catch (err) {
+    return (0, import_fluture25.reject)(err);
+  }
+};
+var make24 = (input) => of24(input);
+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: () => create26,
+  from: () => from25,
+  internalSchema: () => internalSchema25,
+  make: () => make25,
+  of: () => of25,
+  rawSchema: () => rawSchema25,
+  schemas: () => schemas25
+});
+
+// out/types/PositionalArg.ts
+var import_fluture26 = require("fluture");
+var import_zod26 = require("zod");
+var from25 = (input) => {
+  try {
+    return positionalArgSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod26.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path2 = issue.path.join(" \u2192 ");
+          const msg = path2 + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["PositionalArg is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PositionalArg.");
+  }
+};
+var create26 = (input) => from25(input);
+var of25 = (input) => {
+  try {
+    return (0, import_fluture26.resolve)(from25(input));
+  } catch (err) {
+    return (0, import_fluture26.reject)(err);
+  }
+};
+var make25 = (input) => of25(input);
+var schemas25 = {
+  rawSchema: positionalArgSchema,
+  schema: positionalArgSchema.transform((val) => val)
+};
+var rawSchema25 = schemas25.rawSchema;
+var internalSchema25 = positionalArgSchema;
+
+// Provisioner.ts
+var Provisioner_exports = {};
+__export(Provisioner_exports, {
+  create: () => create27,
+  from: () => from26,
+  internalSchema: () => internalSchema26,
+  make: () => make26,
+  of: () => of26,
+  rawSchema: () => rawSchema26,
+  schemas: () => schemas26
+});
+
+// out/types/Provisioner.ts
+var import_fluture27 = require("fluture");
+var import_zod27 = require("zod");
+var from26 = (input) => {
+  try {
+    return provisionerSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["Provisioner is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Provisioner.");
+  }
+};
+var create27 = (input) => from26(input);
+var of26 = (input) => {
+  try {
+    return (0, import_fluture27.resolve)(from26(input));
+  } catch (err) {
+    return (0, import_fluture27.reject)(err);
+  }
+};
+var make26 = (input) => of26(input);
+var schemas26 = {
+  rawSchema: provisionerSchema,
+  schema: provisionerSchema.transform((val) => val)
+};
+var rawSchema26 = schemas26.rawSchema;
+var internalSchema26 = provisionerSchema;
+
+// ProvisionerID.ts
+var ProvisionerID_exports = {};
+__export(ProvisionerID_exports, {
+  create: () => create28,
+  from: () => from27,
+  internalSchema: () => internalSchema27,
+  make: () => make27,
+  of: () => of27,
+  rawSchema: () => rawSchema27,
+  schemas: () => schemas27
+});
+
+// out/types/ProvisionerID.ts
+var import_fluture28 = require("fluture");
+var import_zod28 = require("zod");
+var from27 = (input) => {
+  try {
+    return provisionerIDSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["ProvisionerID is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a ProvisionerID.");
+  }
+};
+var create28 = (input) => from27(input);
+var of27 = (input) => {
+  try {
+    return (0, import_fluture28.resolve)(from27(input));
+  } catch (err) {
+    return (0, import_fluture28.reject)(err);
+  }
+};
+var make27 = (input) => of27(input);
+var schemas27 = {
+  rawSchema: provisionerIDSchema,
+  schema: provisionerIDSchema.transform((val) => val)
+};
+var rawSchema27 = schemas27.rawSchema;
+var internalSchema27 = provisionerIDSchema;
+
+// Provisions.ts
+var Provisions_exports = {};
+__export(Provisions_exports, {
+  create: () => create29,
+  from: () => from28,
+  internalSchema: () => internalSchema28,
+  make: () => make28,
+  of: () => of28,
+  rawSchema: () => rawSchema28,
+  schemas: () => schemas28
+});
+
+// out/types/Provisions.ts
+var import_fluture29 = require("fluture");
+var import_zod29 = require("zod");
+var from28 = (input) => {
+  try {
+    return provisionsSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["Provisions is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a Provisions.");
+  }
+};
+var create29 = (input) => from28(input);
+var of28 = (input) => {
+  try {
+    return (0, import_fluture29.resolve)(from28(input));
+  } catch (err) {
+    return (0, import_fluture29.reject)(err);
+  }
+};
+var make28 = (input) => of28(input);
+var schemas28 = {
+  rawSchema: provisionsSchema,
+  schema: provisionsSchema.transform((val) => val)
+};
+var rawSchema28 = schemas28.rawSchema;
+var internalSchema28 = provisionsSchema;
+
+// ProxyTaskArgs.ts
+var ProxyTaskArgs_exports = {};
+__export(ProxyTaskArgs_exports, {
+  create: () => create30,
+  from: () => from29,
+  internalSchema: () => internalSchema29,
+  make: () => make29,
+  of: () => of29,
+  rawSchema: () => rawSchema29,
+  schemas: () => schemas29
+});
+
+// out/types/ProxyTaskArgs.ts
+var import_fluture30 = require("fluture");
+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 create30 = (input) => from29(input);
+var of29 = (input) => {
+  try {
+    return (0, import_fluture30.resolve)(from29(input));
+  } catch (err) {
+    return (0, import_fluture30.reject)(err);
+  }
+};
+var make29 = (input) => of29(input);
+var schemas29 = {
+  rawSchema: proxyTaskArgsSchema,
+  schema: proxyTaskArgsSchema.transform((val) => val)
+};
+var rawSchema29 = schemas29.rawSchema;
+var internalSchema29 = proxyTaskArgsSchema;
+
+// ProxyTemplateArgs.ts
+var ProxyTemplateArgs_exports = {};
+__export(ProxyTemplateArgs_exports, {
+  create: () => create31,
+  from: () => from30,
+  internalSchema: () => internalSchema30,
+  make: () => make30,
+  of: () => of30,
+  rawSchema: () => rawSchema30,
+  schemas: () => schemas30
+});
+
+// out/types/ProxyTemplateArgs.ts
+var import_fluture31 = require("fluture");
+var import_zod31 = require("zod");
+var from30 = (input) => {
+  try {
+    return proxyTemplateArgsSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["ProxyTemplateArgs is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a ProxyTemplateArgs.");
+  }
+};
+var create31 = (input) => from30(input);
+var of30 = (input) => {
+  try {
+    return (0, import_fluture31.resolve)(from30(input));
+  } catch (err) {
+    return (0, import_fluture31.reject)(err);
+  }
+};
+var make30 = (input) => of30(input);
+var schemas30 = {
+  rawSchema: proxyTemplateArgsSchema,
+  schema: proxyTemplateArgsSchema.transform((val) => val)
+};
+var rawSchema30 = schemas30.rawSchema;
+var internalSchema30 = proxyTemplateArgsSchema;
+
+// PublicKeyHash.ts
+var PublicKeyHash_exports = {};
+__export(PublicKeyHash_exports, {
+  create: () => create32,
+  from: () => from31,
+  internalSchema: () => internalSchema31,
+  make: () => make31,
+  of: () => of31,
+  rawSchema: () => rawSchema31,
+  schemas: () => schemas31
+});
+
+// out/types/PublicKeyHash.ts
+var import_fluture32 = require("fluture");
+var import_zod32 = require("zod");
+var from31 = (input) => {
+  try {
+    return publicKeyHashSchema.parse(input);
+  } catch (previous) {
+    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];
+        },
+        ["PublicKeyHash is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a PublicKeyHash.");
+  }
+};
+var create32 = (input) => from31(input);
+var of31 = (input) => {
+  try {
+    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 schemas33 = {
+  rawSchema: sandboxAccountConfigSchema,
+  schema: sandboxAccountConfigSchema.transform((val) => val)
+};
+var rawSchema33 = schemas33.rawSchema;
+var internalSchema33 = sandboxAccountConfigSchema;
+
+// 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/SanitizedPath.ts
+var import_fluture37 = require("fluture");
+var import_zod38 = require("zod");
+var from35 = (input) => {
+  try {
+    return sanitizedPathSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod38.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:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw toParseErr(previous, validationErr);
+    }
+    throw toParseUnknownErr(previous, "There was a problem trying to parse a SanitizedPath.");
+  }
+};
+var create37 = (input) => from35(input);
+var of36 = (input) => {
+  try {
+    return (0, import_fluture37.resolve)(from35(input));
+  } catch (err) {
+    return (0, import_fluture37.reject)(err);
+  }
+};
+var make36 = (input) => of36(input);
+var schemas36 = {
+  rawSchema: sanitizedPathSchema,
+  schema: sanitizedPathSchema.transform((val) => val)
+};
+var rawSchema36 = schemas36.rawSchema;
+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.d.js.map