@taqueria/protocol 0.28.0 → 0.28.2

package/SanitizedArgs.js

@@ -26,7 +26,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // SanitizedArgs.ts
 var SanitizedArgs_exports = {};
 __export(SanitizedArgs_exports, {
-  create: () => create,
+  create: () => create3,
   createCreateTaskArgs: () => createCreateTaskArgs,
   createInstallTaskArgs: () => createInstallTaskArgs,
   createProvisionTaskArgs: () => createProvisionTaskArgs,
@@ -34,11 +34,11 @@ __export(SanitizedArgs_exports, {
   createSetEnvTaskArgs: () => createSetEnvTaskArgs,
   createTaskArgs: () => createTaskArgs,
   createUninstallTaskArgs: () => createUninstallTaskArgs,
-  factory: () => factory,
-  generatedSchemas: () => generatedSchemas,
+  factory: () => factory2,
+  generatedSchemas: () => generatedSchemas2,
   initRawSchema: () => initRawSchema,
   installTaskArgs: () => installTaskArgs,
-  make: () => make,
+  make: () => make2,
   makeCreateTaskArgs: () => makeCreateTaskArgs,
   makeInstallTaskArgs: () => makeInstallTaskArgs,
   makeProvisionTaskArgs: () => makeProvisionTaskArgs,
@@ -46,7 +46,7 @@ __export(SanitizedArgs_exports, {
   makeSetEnvTaskArgs: () => makeSetEnvTaskArgs,
   makeUninstallTaskArgs: () => makeUninstallTaskArgs,
   managePluginRawSchema: () => managePluginRawSchema,
-  of: () => of,
+  of: () => of2,
   ofCreateTaskArgs: () => ofCreateTaskArgs,
   ofInstallTaskArgs: () => ofInstallTaskArgs,
   ofProvisionTaskArgs: () => ofProvisionTaskArgs,
@@ -55,7 +55,7 @@ __export(SanitizedArgs_exports, {
   ofUninstallTaskArgs: () => ofUninstallTaskArgs,
   provisionRawSchema: () => provisionRawSchema,
   provisionTaskArgs: () => provisionTaskArgs,
-  rawSchema: () => rawSchema,
+  rawSchema: () => rawSchema3,
   scaffoldRawSchema: () => scaffoldRawSchema,
   scaffoldTaskArgs: () => scaffoldTaskArgs,
   schemas: () => schemas3,
@@ -65,119 +65,570 @@ __export(SanitizedArgs_exports, {
   uninstallTaskArgs: () => uninstallTaskArgs
 });
 module.exports = __toCommonJS(SanitizedArgs_exports);
-var import_Base = __toESM(require("@taqueria/protocol/Base"));
-var NonEmptyString = __toESM(require("@taqueria/protocol/NonEmptyString"));
-var SanitizedAbsPath = __toESM(require("@taqueria/protocol/SanitizedAbsPath"));
+
+// TaqError.ts
+var import_fluture = require("fluture");
+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;
+
+// Base.ts
+var import_fluture2 = require("fluture");
 var import_zod = require("zod");
-var rawSchema = import_zod.z.object({
-  _: import_zod.z.array(import_zod.z.union([import_zod.z.string().min(1), import_zod.z.number()])),
-  projectDir: SanitizedAbsPath.schemas.schema,
-  maxConcurrency: import_zod.z.preprocess(
+var createSchema = (params) => {
+  var _a, _b;
+  const { rawSchema: rawSchema4, isStringLike } = params;
+  const internalSchema = (_a = params.internalSchema) != null ? _a : params.rawSchema;
+  const noop = (val) => val;
+  const transformer = (_b = params.transformer) != null ? _b : noop;
+  const schema = isStringLike ? internalSchema.transform(
+    (val) => transformer(val)
+  ) : internalSchema.transform(
+    (val) => transformer(val)
+  );
+  return {
+    rawSchema: rawSchema4,
+    internalSchema,
+    schema
+  };
+};
+var createType = (params) => {
+  const schemas4 = createSchema(params);
+  const { parseErrMsg, unknownErrMsg } = params;
+  const internalOf = (input) => {
+    try {
+      return (0, import_fluture2.resolve)(schemas4.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_zod.ZodError) {
+        return toFutureParseErr(previous, parseMsg, input);
+      }
+      return toFutureParseUnknownErr(previous, unknownMsg, input);
+    }
+  };
+  const of3 = internalOf;
+  const make3 = (input) => internalOf(input);
+  const create4 = (input) => schemas4.schema.parse(input);
+  const from = (input) => schemas4.schema.parse(input);
+  const factory3 = {
+    make: make3,
+    of: of3,
+    create: create4,
+    from
+  };
+  return {
+    schemas: schemas4,
+    factory: factory3
+  };
+};
+var Base_default = createType;
+
+// out/types/NonEmptyString.ts
+var import_fluture3 = require("fluture");
+var import_zod3 = require("zod");
+
+// out/types-zod.ts
+var import_zod2 = require("zod");
+var nonEmptyStringSchema = import_zod2.z.string().min(1);
+var singleCharSchema = nonEmptyStringSchema.regex(/^[A-Za-z]$/);
+var verbSchema = nonEmptyStringSchema.regex(/^[A-Za-z\-\ ]+/);
+var aliasSchema = import_zod2.z.union([verbSchema, singleCharSchema]);
+var humanReadableIdentifierSchema = nonEmptyStringSchema.regex(
+  /^[A-Za-z]+[A-Za-z0-9-_ ]*$/
+);
+var sanitizedAbsPathSchema = nonEmptyStringSchema;
+var sanitizedPathSchema = nonEmptyStringSchema;
+var settingsSchema = import_zod2.z.object({
+  consent: import_zod2.z.union([
+    import_zod2.z.literal("opt_in"),
+    import_zod2.z.literal("opt_out"),
+    import_zod2.z.literal("unspecified")
+  ])
+});
+var timestampSchema = import_zod2.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;
+var optionSchema = import_zod2.z.object({
+  shortFlag: singleCharSchema.optional(),
+  flag: verbSchema,
+  description: nonEmptyStringSchema,
+  defaultValue: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean()]).optional(),
+  type: import_zod2.z.union([import_zod2.z.literal("string"), import_zod2.z.literal("number"), import_zod2.z.literal("boolean")]).optional(),
+  required: import_zod2.z.boolean().optional(),
+  boolean: import_zod2.z.boolean().optional(),
+  choices: import_zod2.z.array(nonEmptyStringSchema).optional()
+});
+var positionalArgSchema = import_zod2.z.object({
+  placeholder: humanReadableIdentifierSchema,
+  description: nonEmptyStringSchema,
+  defaultValue: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean()]).optional(),
+  type: import_zod2.z.union([import_zod2.z.literal("string"), import_zod2.z.literal("number"), import_zod2.z.literal("boolean")]).optional(),
+  required: import_zod2.z.boolean().optional()
+});
+var installedPluginSchema = import_zod2.z.object({
+  type: import_zod2.z.union([import_zod2.z.literal("npm"), import_zod2.z.literal("binary"), import_zod2.z.literal("deno")]),
+  name: nonEmptyStringSchema
+});
+var runtimeDependencySchema = import_zod2.z.object({
+  name: humanReadableIdentifierSchema,
+  path: import_zod2.z.string(),
+  version: import_zod2.z.string(),
+  kind: import_zod2.z.union([import_zod2.z.literal("required"), import_zod2.z.literal("optional")])
+});
+var runtimeDependencyReportSchema = runtimeDependencySchema.extend(
+  {
+    met: import_zod2.z.boolean()
+  }
+);
+var pluginDependenciesResponseSchema = import_zod2.z.object({
+  report: import_zod2.z.array(runtimeDependencyReportSchema)
+});
+var pluginJsonResponseSchema = import_zod2.z.union([
+  import_zod2.z.object({
+    data: import_zod2.z.unknown().optional(),
+    render: import_zod2.z.union([import_zod2.z.literal("none"), import_zod2.z.literal("table"), import_zod2.z.literal("string")]).default("none")
+  }),
+  import_zod2.z.void()
+]);
+var pluginProxyResponseSchema = import_zod2.z.union([
+  import_zod2.z.void(),
+  pluginJsonResponseSchema
+]);
+var pluginResponseEncodingSchema = import_zod2.z.union([import_zod2.z.literal("none"), import_zod2.z.literal("json"), import_zod2.z.literal("application/json")]).default("none");
+var buildNumberSchema = import_zod2.z.number();
+var sanitizedArgsSchema = import_zod2.z.object({
+  _: import_zod2.z.array(import_zod2.z.string()),
+  projectDir: sanitizedPathSchema,
+  maxConcurrency: import_zod2.z.number(),
+  debug: import_zod2.z.boolean(),
+  disableState: import_zod2.z.boolean(),
+  logPluginRequests: import_zod2.z.boolean(),
+  fromVsCode: import_zod2.z.boolean(),
+  version: import_zod2.z.boolean(),
+  build: import_zod2.z.boolean(),
+  help: import_zod2.z.boolean(),
+  yes: import_zod2.z.boolean(),
+  plugin: nonEmptyStringSchema.optional(),
+  env: nonEmptyStringSchema,
+  quickstart: nonEmptyStringSchema,
+  setBuild: import_zod2.z.union([nonEmptyStringSchema, buildNumberSchema]),
+  setVersion: nonEmptyStringSchema
+}).passthrough();
+var pluginActionNameSchema = import_zod2.z.union([
+  import_zod2.z.literal("proxy"),
+  import_zod2.z.literal("pluginInfo"),
+  import_zod2.z.literal("checkRuntimeDependencies"),
+  import_zod2.z.literal("installRuntimeDependencies"),
+  import_zod2.z.literal("proxyTemplate")
+]);
+var economicalProtocolHashSchema = import_zod2.z.string();
+var publicKeyHashSchema = import_zod2.z.string().regex(/^tz\d[A-Za-z0-9]{33}$/);
+var sha256Schema = import_zod2.z.string().regex(/^[A-Fa-f0-9]{64}$/);
+var contractSchema = import_zod2.z.object({
+  sourceFile: nonEmptyStringSchema,
+  hash: sha256Schema
+});
+var faucetSchema = import_zod2.z.object({
+  pkh: publicKeyHashSchema,
+  mnemonic: import_zod2.z.array(import_zod2.z.string()),
+  email: import_zod2.z.string().email(),
+  password: import_zod2.z.string(),
+  amount: import_zod2.z.string().regex(/^\d+$/),
+  activation_code: import_zod2.z.string()
+});
+var tzKtConfigPostgresqlPortSchema = import_zod2.z.number().default(5432);
+var tzKtConfigApiPortSchema = import_zod2.z.number().default(5e3);
+var tzKtConfigSchema = import_zod2.z.object({
+  disableAutostartWithSandbox: import_zod2.z.boolean().optional(),
+  postgresqlPort: tzKtConfigPostgresqlPortSchema.optional(),
+  apiPort: tzKtConfigApiPortSchema.optional()
+});
+var persistedTaskSchema = import_zod2.z.object({
+  task: verbSchema,
+  plugin: nonEmptyStringSchema,
+  time: timestampSchema,
+  output: import_zod2.z.unknown().optional()
+});
+var persistedOperationSchema = import_zod2.z.object({
+  hash: sha256Schema,
+  time: timestampSchema,
+  output: import_zod2.z.unknown().optional()
+});
+var provisionerIDSchema = import_zod2.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_zod2.z.object({
+  id: provisionerIDSchema,
+  plugin: nonEmptyStringSchema,
+  operation: import_zod2.z.union([nonEmptyStringSchema, import_zod2.z.literal("custom")]),
+  command: import_zod2.z.string().optional(),
+  label: import_zod2.z.string().optional(),
+  depends_on: import_zod2.z.array(provisionerIDSchema).optional()
+});
+var provisionsSchema = import_zod2.z.array(provisionerSchema);
+var environmentSchema = import_zod2.z.object({
+  networks: import_zod2.z.array(nonEmptyStringSchema),
+  sandboxes: import_zod2.z.array(nonEmptyStringSchema),
+  storage: import_zod2.z.record(nonEmptyStringSchema).optional(),
+  aliases: import_zod2.z.record(import_zod2.z.record(nonEmptyStringSchema)).optional()
+});
+var environmentNameSchema = nonEmptyStringSchema.min(
+  1,
+  "Default environment must reference the name of an existing environment."
+);
+var humanLanguageSchema = import_zod2.z.union([import_zod2.z.literal("en"), import_zod2.z.literal("fr")]).default("en");
+var configContractsDirSchema = import_zod2.z.string().min(1).default("contracts");
+var configArtifactsDirSchema = import_zod2.z.string().min(1).default("artifacts");
+var currencyAmountV2Schema = import_zod2.z.object({
+  amount: import_zod2.z.string(),
+  units: import_zod2.z.string()
+});
+var versionV2Schema = import_zod2.z.string().regex(/^v2$/);
+var sandboxAccountSchema = import_zod2.z.object({
+  type: import_zod2.z.string().optional()
+}).passthrough();
+var sandboxAccountsSchema = import_zod2.z.record(sandboxAccountSchema);
+var configEnvironmentFileV2Schema = import_zod2.z.object({
+  type: import_zod2.z.string().optional(),
+  accounts: sandboxAccountsSchema.optional(),
+  accountDefault: import_zod2.z.any().optional(),
+  contracts: import_zod2.z.record(
+    import_zod2.z.object({
+      address: import_zod2.z.string().optional()
+    })
+  ).optional()
+}).passthrough();
+var metadataConfigSchema = import_zod2.z.object({
+  name: import_zod2.z.string().optional(),
+  projectDescription: import_zod2.z.string().optional(),
+  authors: import_zod2.z.array(import_zod2.z.string()).optional(),
+  license: import_zod2.z.string().optional(),
+  homepage: import_zod2.z.string().optional()
+});
+var networkAccountConfigSchema = import_zod2.z.object({
+  publicKey: nonEmptyStringSchema.optional(),
+  publicKeyHash: publicKeyHashSchema.optional(),
+  privateKey: nonEmptyStringSchema.optional(),
+  mnemonic: nonEmptyStringSchema.optional()
+});
+var sandboxAccountConfigSchema = import_zod2.z.object({
+  encryptedKey: nonEmptyStringSchema,
+  publicKeyHash: publicKeyHashSchema,
+  secretKey: nonEmptyStringSchema
+});
+var sandboxConfigSchema = import_zod2.z.object({
+  label: nonEmptyStringSchema,
+  rpcUrl: urlSchema,
+  protocol: economicalProtocolHashSchema.optional(),
+  plugin: verbSchema.optional(),
+  accounts: import_zod2.z.record(import_zod2.z.union([sandboxAccountConfigSchema, nonEmptyStringSchema])).optional(),
+  tzkt: tzKtConfigSchema.optional(),
+  annotations: import_zod2.z.record(import_zod2.z.unknown()).optional()
+});
+var scaffoldConfigSchema = import_zod2.z.object({
+  postInit: import_zod2.z.string().optional()
+});
+var taskSchema = import_zod2.z.object({
+  task: verbSchema,
+  command: commandSchema,
+  aliases: import_zod2.z.array(aliasSchema).optional(),
+  description: nonEmptyStringSchema.min(3).optional(),
+  example: nonEmptyStringSchema.optional(),
+  hidden: import_zod2.z.boolean().optional(),
+  encoding: pluginResponseEncodingSchema.optional(),
+  handler: import_zod2.z.union([import_zod2.z.literal("proxy"), nonEmptyStringSchema]),
+  options: import_zod2.z.array(optionSchema).optional(),
+  positionals: import_zod2.z.array(positionalArgSchema).optional()
+});
+var persistentStateSchema = import_zod2.z.object({
+  operations: import_zod2.z.record(persistedOperationSchema),
+  tasks: import_zod2.z.record(persistedTaskSchema)
+});
+var configAccountSchema = import_zod2.z.object({
+  balance: currencyAmountV2Schema
+});
+var configFileV2Schema = import_zod2.z.object({
+  version: versionV2Schema,
+  language: humanLanguageSchema.optional(),
+  metadata: metadataConfigSchema.optional(),
+  artifactsDir: configArtifactsDirSchema.optional(),
+  contractsDir: configContractsDirSchema.optional(),
+  accounts: import_zod2.z.record(configAccountSchema).optional(),
+  contracts: import_zod2.z.record(contractSchema).optional(),
+  environmentDefault: environmentNameSchema.optional(),
+  environments: import_zod2.z.record(configEnvironmentFileV2Schema).optional(),
+  plugins: import_zod2.z.array(installedPluginSchema).optional()
+});
+var networkConfigSchema = import_zod2.z.object({
+  label: humanReadableIdentifierSchema,
+  rpcUrl: urlSchema,
+  accounts: import_zod2.z.record(networkAccountConfigSchema).optional(),
+  faucet: faucetSchema.optional()
+});
+var pluginSchemaBaseSchema = import_zod2.z.object({
+  name: nonEmptyStringSchema,
+  version: versionNumberSchema,
+  schema: versionNumberSchema,
+  alias: aliasSchema,
+  tasks: import_zod2.z.array(taskSchema).optional()
+});
+var configSchema = import_zod2.z.object({
+  language: humanLanguageSchema.optional(),
+  metadata: metadataConfigSchema.optional(),
+  artifactsDir: configArtifactsDirSchema.optional(),
+  contractsDir: configContractsDirSchema.optional(),
+  contracts: import_zod2.z.record(contractSchema).optional(),
+  plugins: import_zod2.z.array(installedPluginSchema).optional(),
+  accounts: import_zod2.z.record(tzSchema).optional(),
+  environment: import_zod2.z.record(import_zod2.z.union([environmentSchema, environmentNameSchema])),
+  network: import_zod2.z.record(networkConfigSchema).optional(),
+  sandbox: import_zod2.z.record(sandboxConfigSchema).optional()
+});
+var configFileV1Schema = import_zod2.z.object({
+  language: humanLanguageSchema.optional(),
+  plugins: import_zod2.z.array(installedPluginSchema).optional(),
+  contractsDir: configContractsDirSchema.optional(),
+  artifactsDir: configArtifactsDirSchema.optional(),
+  network: import_zod2.z.record(networkConfigSchema).optional(),
+  sandbox: import_zod2.z.record(sandboxConfigSchema).optional(),
+  environment: import_zod2.z.record(import_zod2.z.union([environmentSchema, environmentNameSchema])).optional(),
+  accounts: import_zod2.z.record(tzSchema).optional(),
+  contracts: import_zod2.z.record(contractSchema).optional(),
+  metadata: metadataConfigSchema.optional()
+});
+var loadedConfigSchema = configSchema.extend(
+  {
+    projectDir: sanitizedAbsPathSchema,
+    configFile: sanitizedAbsPathSchema,
+    hash: sha256Schema
+  }
+);
+var parsedConfigSchema = configSchema.omit({ sandbox: true }).extend(
+  {
+    sandbox: import_zod2.z.record(import_zod2.z.union([sandboxConfigSchema, nonEmptyStringSchema]))
+  }
+);
+var requestArgsSchema = sanitizedArgsSchema.omit({ quickstart: true }).extend(
+  {
+    taqRun: pluginActionNameSchema,
+    config: loadedConfigSchema
+  }
+).passthrough();
+var proxyTaskArgsSchema = requestArgsSchema.extend(
+  {
+    task: nonEmptyStringSchema
+  }
+).passthrough();
+var proxyTemplateArgsSchema = requestArgsSchema.extend(
+  {
+    template: nonEmptyStringSchema
+  }
+).passthrough();
+var operationSchema = import_zod2.z.object({
+  operation: verbSchema,
+  command: commandSchema,
+  description: nonEmptyStringSchema.optional(),
+  positionals: import_zod2.z.array(positionalArgSchema).optional(),
+  options: import_zod2.z.array(optionSchema).optional(),
+  handler: import_zod2.z.function().args(persistentStateSchema).returns(import_zod2.z.function().args(requestArgsSchema).returns(import_zod2.z.void())).optional()
+});
+var parsedOperationSchema = operationSchema.omit({ handler: true });
+var templateHandlerSchema = import_zod2.z.union([
+  nonEmptyStringSchema,
+  import_zod2.z.function().args(requestArgsSchema).returns(
+    import_zod2.z.union([pluginJsonResponseSchema, import_zod2.z.promise(pluginJsonResponseSchema)])
+  ),
+  import_zod2.z.promise(import_zod2.z.void())
+]);
+var templateSchema = import_zod2.z.object({
+  template: verbSchema,
+  command: commandSchema,
+  description: nonEmptyStringSchema,
+  hidden: import_zod2.z.boolean().optional(),
+  options: import_zod2.z.array(optionSchema).optional(),
+  positionals: import_zod2.z.array(positionalArgSchema).optional(),
+  handler: templateHandlerSchema,
+  encoding: pluginResponseEncodingSchema.optional()
+});
+var parsedTemplateSchema = templateSchema.omit({ handler: true }).extend(
+  {
+    handler: import_zod2.z.string()
+  }
+);
+var pluginInfoSchema = pluginSchemaBaseSchema.extend(
+  {
+    operations: import_zod2.z.array(parsedOperationSchema).optional(),
+    templates: import_zod2.z.array(parsedTemplateSchema).optional()
+  }
+);
+var pluginSchemaSchema = pluginSchemaBaseSchema.extend(
+  {
+    operations: import_zod2.z.array(operationSchema).optional(),
+    templates: import_zod2.z.array(templateSchema).optional(),
+    proxy: import_zod2.z.function().args(requestArgsSchema).returns(import_zod2.z.promise(pluginProxyResponseSchema)).optional(),
+    checkRuntimeDependencies: import_zod2.z.function().args(requestArgsSchema).returns(import_zod2.z.promise(pluginDependenciesResponseSchema)).optional(),
+    installRuntimeDependencies: import_zod2.z.function().args(requestArgsSchema).returns(import_zod2.z.promise(pluginDependenciesResponseSchema)).optional()
+  }
+);
+var ephemeralStateSchema = import_zod2.z.object({
+  build: import_zod2.z.string(),
+  configHash: import_zod2.z.string(),
+  tasks: import_zod2.z.record(installedPluginSchema.and(taskSchema)),
+  operations: import_zod2.z.record(installedPluginSchema.and(parsedOperationSchema)),
+  templates: import_zod2.z.record(installedPluginSchema.and(parsedTemplateSchema)),
+  plugins: import_zod2.z.array(pluginInfoSchema)
+});
+
+// out/types/NonEmptyString.ts
+var schemas = {
+  rawSchema: nonEmptyStringSchema,
+  schema: nonEmptyStringSchema.transform((val) => val)
+};
+var rawSchema = schemas.rawSchema;
+
+// SanitizedAbsPath.ts
+var path = __toESM(require("path"));
+var import_zod4 = require("zod");
+var rawSchema2 = import_zod4.z.string({ description: "SanitizedAbsPath" }).min(1);
+var { schemas: generatedSchemas, factory } = Base_default({
+  isStringLike: true,
+  rawSchema: rawSchema2,
+  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: create2, make, of } = factory;
+var schemas2 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+
+// SanitizedArgs.ts
+var import_zod5 = require("zod");
+var rawSchema3 = import_zod5.z.object({
+  _: import_zod5.z.array(import_zod5.z.union([import_zod5.z.string().min(1), import_zod5.z.number()])),
+  projectDir: schemas2.schema,
+  maxConcurrency: import_zod5.z.preprocess(
     (val) => typeof val === "string" ? parseInt(val) : Number(val),
-    import_zod.z.number().int().min(1).default(10)
+    import_zod5.z.number().int().min(1).default(10)
   ),
-  debug: import_zod.z.preprocess(
+  debug: import_zod5.z.preprocess(
     (val) => Boolean(val),
-    import_zod.z.boolean().default(false)
+    import_zod5.z.boolean().default(false)
   ),
-  disableState: import_zod.z.preprocess(
+  disableState: import_zod5.z.preprocess(
     (val) => Boolean(val),
-    import_zod.z.boolean().default(false)
+    import_zod5.z.boolean().default(false)
   ),
-  logPluginRequests: import_zod.z.preprocess(
+  logPluginRequests: import_zod5.z.preprocess(
     (val) => Boolean(val),
-    import_zod.z.boolean().default(false)
+    import_zod5.z.boolean().default(false)
   ),
-  fromVsCode: import_zod.z.preprocess(
+  fromVsCode: import_zod5.z.preprocess(
     (val) => Boolean(val),
-    import_zod.z.boolean().default(false)
+    import_zod5.z.boolean().default(false)
   ),
-  version: import_zod.z.preprocess(
+  version: import_zod5.z.preprocess(
     (val) => Boolean(val),
-    import_zod.z.boolean().optional()
+    import_zod5.z.boolean().optional()
   ),
-  build: import_zod.z.preprocess(
+  build: import_zod5.z.preprocess(
     (val) => Boolean(val),
-    import_zod.z.boolean().optional()
+    import_zod5.z.boolean().optional()
   ),
-  help: import_zod.z.preprocess(
+  help: import_zod5.z.preprocess(
     (val) => Boolean(val),
-    import_zod.z.boolean().optional()
+    import_zod5.z.boolean().optional()
   ),
-  yes: import_zod.z.preprocess(
+  yes: import_zod5.z.preprocess(
     (val) => Boolean(val),
-    import_zod.z.boolean().optional()
+    import_zod5.z.boolean().optional()
   ),
-  plugin: NonEmptyString.schemas.schema.optional(),
-  env: import_zod.z.string().optional(),
-  quickstart: import_zod.z.string().min(1).optional(),
-  setBuild: import_zod.z.preprocess(
+  plugin: schemas.schema.optional(),
+  env: import_zod5.z.string().optional(),
+  quickstart: import_zod5.z.string().min(1).optional(),
+  setBuild: import_zod5.z.preprocess(
     (val) => String(val),
-    import_zod.z.string().min(3)
+    import_zod5.z.string().min(3)
   ),
-  setVersion: import_zod.z.string().min(3),
-  pluginName: import_zod.z.string().min(1).optional()
+  setVersion: import_zod5.z.string().min(3),
+  pluginName: import_zod5.z.string().min(1).optional()
 }, { description: "Sanitizied Args" }).passthrough();
-var scaffoldRawSchema = rawSchema.extend({
-  scaffoldProjectDir: import_zod.z.string().min(1).transform((val) => val),
-  scaffoldUrl: import_zod.z.string().min(1).url().transform((val) => val),
-  branch: import_zod.z.string().min(1).optional()
+var scaffoldRawSchema = rawSchema3.extend({
+  scaffoldProjectDir: import_zod5.z.string().min(1).transform((val) => val),
+  scaffoldUrl: import_zod5.z.string().min(1).url().transform((val) => val),
+  branch: import_zod5.z.string().min(1).optional()
 });
-var initRawSchema = rawSchema.extend({
-  workflow: import_zod.z.string().refine((val) => val === "ligo" || val === "smartpy" || val === "archetype" || val === "michelson").optional()
+var initRawSchema = rawSchema3.extend({
+  workflow: import_zod5.z.string().refine((val) => val === "ligo" || val === "smartpy" || val === "archetype" || val === "michelson").optional()
 });
-var provisionRawSchema = rawSchema.extend({
-  operation: import_zod.z.string().min(1).describe("Operation name"),
-  name: import_zod.z.string().min(1).regex(
+var provisionRawSchema = rawSchema3.extend({
+  operation: import_zod5.z.string().min(1).describe("Operation name"),
+  name: import_zod5.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 = rawSchema.extend({
-  template: import_zod.z.string().min(1)
+var templateRawSchema = rawSchema3.extend({
+  template: import_zod5.z.string().min(1)
 }).passthrough();
-var managePluginRawSchema = rawSchema.omit({ pluginName: true }).extend({
-  pluginName: import_zod.z.string().min(1)
+var managePluginRawSchema = rawSchema3.omit({ pluginName: true }).extend({
+  pluginName: import_zod5.z.string().min(1)
 });
-var setEnvRawSchema = rawSchema.extend({
-  defaultEnvironment: import_zod.z.string().min(1)
+var setEnvRawSchema = rawSchema3.extend({
+  defaultEnvironment: import_zod5.z.string().min(1)
 });
-var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
-  rawSchema,
+var { schemas: generatedSchemas2, factory: factory2 } = Base_default({
+  rawSchema: rawSchema3,
   parseErrMsg: "The arguments provided are invalid",
   unknownErrMsg: "Something went wrong parsing the command-line arguments"
 });
-var { create, of, make } = factory;
+var { create: create3, of: of2, make: make2 } = factory2;
 var schemas3 = {
-  ...generatedSchemas,
-  schema: generatedSchemas.schema.transform((val) => val)
+  ...generatedSchemas2,
+  schema: generatedSchemas2.schema.transform((val) => val)
 };
-var scaffoldTaskArgs = (0, import_Base.default)({
+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 = (0, import_Base.default)({
+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 = (0, import_Base.default)({
+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 = (0, import_Base.default)({
+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 = (0, import_Base.default)({
+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 = (0, import_Base.default)({
+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"