@taqueria/protocol 0.28.0 → 0.28.1

package/PluginSchema.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,69 +15,612 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // PluginSchema.ts
 var PluginSchema_exports = {};
 __export(PluginSchema_exports, {
-  create: () => create,
-  factory: () => factory,
+  create: () => create4,
+  factory: () => factory2,
   generatedSchemas: () => generatedSchemas,
-  make: () => make,
-  of: () => of,
-  rawSchema: () => rawSchema4,
-  schemas: () => schemas3
+  make: () => make2,
+  of: () => of2,
+  rawSchema: () => rawSchema9,
+  schemas: () => schemas9
 });
 module.exports = __toCommonJS(PluginSchema_exports);
-var Alias = __toESM(require("@taqueria/protocol/Alias"));
-var import_Base = __toESM(require("@taqueria/protocol/Base"));
-var Operation = __toESM(require("@taqueria/protocol/Operation"));
-var PluginInfo = __toESM(require("@taqueria/protocol/PluginInfo"));
-var Template = __toESM(require("@taqueria/protocol/Template"));
+
+// 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;
+
+// out/types/Alias.ts
+var import_fluture2 = require("fluture");
+var import_zod2 = require("zod");
+
+// out/types-zod.ts
 var import_zod = require("zod");
-var internalSchema2 = PluginInfo.internalSchema.extend({
-  operations: import_zod.z.preprocess(
+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;
+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")]).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 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(),
+    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 pluginResponseEncodingSchema = import_zod.z.union([import_zod.z.literal("none"), import_zod.z.literal("json"), import_zod.z.literal("application/json")]).default("none");
+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("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 persistedTaskSchema = import_zod.z.object({
+  task: verbSchema,
+  plugin: nonEmptyStringSchema,
+  time: timestampSchema,
+  output: import_zod.z.unknown().optional()
+});
+var persistedOperationSchema = import_zod.z.object({
+  hash: sha256Schema,
+  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 versionV2Schema = import_zod.z.string().regex(/^v2$/);
+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 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 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 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 persistentStateSchema = import_zod.z.object({
+  operations: import_zod.z.record(persistedOperationSchema),
+  tasks: import_zod.z.record(persistedTaskSchema)
+});
+var configAccountSchema = import_zod.z.object({
+  balance: currencyAmountV2Schema
+});
+var 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 networkConfigSchema = import_zod.z.object({
+  label: humanReadableIdentifierSchema,
+  rpcUrl: urlSchema,
+  accounts: import_zod.z.record(networkAccountConfigSchema).optional(),
+  faucet: faucetSchema.optional()
+});
+var pluginSchemaBaseSchema = import_zod.z.object({
+  name: nonEmptyStringSchema,
+  version: versionNumberSchema,
+  schema: versionNumberSchema,
+  alias: aliasSchema,
+  tasks: import_zod.z.array(taskSchema).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 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 loadedConfigSchema = configSchema.extend(
+  {
+    projectDir: sanitizedAbsPathSchema,
+    configFile: sanitizedAbsPathSchema,
+    hash: sha256Schema
+  }
+);
+var parsedConfigSchema = configSchema.omit({ sandbox: true }).extend(
+  {
+    sandbox: import_zod.z.record(import_zod.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_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 pluginInfoSchema = pluginSchemaBaseSchema.extend(
+  {
+    operations: import_zod.z.array(parsedOperationSchema).optional(),
+    templates: import_zod.z.array(parsedTemplateSchema).optional()
+  }
+);
+var pluginSchemaSchema = pluginSchemaBaseSchema.extend(
+  {
+    operations: import_zod.z.array(operationSchema).optional(),
+    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 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 schemas = {
+  rawSchema: aliasSchema,
+  schema: aliasSchema.transform((val) => val)
+};
+var rawSchema = schemas.rawSchema;
+
+// Base.ts
+var import_fluture3 = require("fluture");
+var import_zod3 = require("zod");
+var createSchema = (params) => {
+  var _a, _b;
+  const { rawSchema: rawSchema10, isStringLike } = params;
+  const internalSchema3 = (_a = params.internalSchema) != null ? _a : params.rawSchema;
+  const noop = (val) => val;
+  const transformer = (_b = params.transformer) != null ? _b : noop;
+  const schema = isStringLike ? internalSchema3.transform(
+    (val) => transformer(val)
+  ) : internalSchema3.transform(
+    (val) => transformer(val)
+  );
+  return {
+    rawSchema: rawSchema10,
+    internalSchema: internalSchema3,
+    schema
+  };
+};
+var createType = (params) => {
+  const schemas10 = createSchema(params);
+  const { parseErrMsg, unknownErrMsg } = params;
+  const internalOf = (input) => {
+    try {
+      return (0, import_fluture3.resolve)(schemas10.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_zod3.ZodError) {
+        return toFutureParseErr(previous, parseMsg, input);
+      }
+      return toFutureParseUnknownErr(previous, unknownMsg, input);
+    }
+  };
+  const of3 = internalOf;
+  const make3 = (input) => internalOf(input);
+  const create5 = (input) => schemas10.schema.parse(input);
+  const from = (input) => schemas10.schema.parse(input);
+  const factory3 = {
+    make: make3,
+    of: of3,
+    create: create5,
+    from
+  };
+  return {
+    schemas: schemas10,
+    factory: factory3
+  };
+};
+var Base_default = createType;
+
+// out/types/Operation.ts
+var import_fluture4 = require("fluture");
+var import_zod4 = require("zod");
+var schemas2 = {
+  rawSchema: operationSchema,
+  schema: operationSchema.transform((val) => val)
+};
+var rawSchema2 = schemas2.rawSchema;
+
+// out/types/ParsedOperation.ts
+var import_fluture5 = require("fluture");
+var import_zod5 = require("zod");
+var schemas3 = {
+  rawSchema: parsedOperationSchema,
+  schema: parsedOperationSchema.transform((val) => val)
+};
+var rawSchema3 = schemas3.rawSchema;
+
+// out/types/ParsedTemplate.ts
+var import_fluture6 = require("fluture");
+var import_zod6 = require("zod");
+var schemas4 = {
+  rawSchema: parsedTemplateSchema,
+  schema: parsedTemplateSchema.transform((val) => val)
+};
+var rawSchema4 = schemas4.rawSchema;
+
+// out/types/Task.ts
+var import_fluture7 = require("fluture");
+var import_zod7 = require("zod");
+var schemas5 = {
+  rawSchema: taskSchema,
+  schema: taskSchema.transform((val) => val)
+};
+var rawSchema5 = schemas5.rawSchema;
+
+// out/types/VersionNumber.ts
+var import_fluture8 = require("fluture");
+var import_zod8 = require("zod");
+var schemas6 = {
+  rawSchema: versionNumberSchema,
+  schema: versionNumberSchema.transform((val) => val)
+};
+var rawSchema6 = schemas6.rawSchema;
+
+// PluginInfo.ts
+var import_zod9 = require("zod");
+var rawSchema7 = import_zod9.z.object({
+  name: import_zod9.z.string({ description: "Plugin Name" }).min(1),
+  version: rawSchema6.describe("Plugin Version #"),
+  schema: rawSchema6.describe("Plugin Schema Version #"),
+  alias: rawSchema.describe("Plugin Alias"),
+  tasks: import_zod9.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod9.z.array(
+      schemas5.schema.describe("Plugin Task"),
+      { description: "Plugin Tasks" }
+    )
+  ).optional(),
+  operations: import_zod9.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod9.z.array(
+      schemas3.schema.describe("Plugin Operation"),
+      { description: "Plugin Operations" }
+    )
+  ).optional(),
+  templates: import_zod9.z.preprocess(
     (val) => val != null ? val : [],
-    import_zod.z.array(
-      Operation.schemas.schema,
+    import_zod9.z.array(
+      schemas4.schema.describe("Plugin Template")
+    )
+  ).optional()
+});
+var internalSchema = rawSchema7.extend({
+  version: schemas6.schema.describe("Plugin Version #"),
+  schema: schemas6.schema.describe("Plugin Schema Version #"),
+  alias: schemas.schema.describe("Plugin Alias"),
+  tasks: import_zod9.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod9.z.array(
+      schemas5.schema.describe("Plugin Task"),
+      { description: "Plugin Tasks" }
+    )
+  ).optional(),
+  operations: import_zod9.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod9.z.array(
+      schemas3.schema.describe("Plugin Operation"),
+      { description: "Plugin Operations" }
+    )
+  ).optional(),
+  templates: import_zod9.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod9.z.array(
+      schemas4.schema.describe("Plugin Template")
+    )
+  ).optional()
+}).describe("Plugin Schema");
+var { schemas: schemas7, factory } = Base_default({
+  rawSchema: rawSchema7,
+  internalSchema,
+  parseErrMsg: "The schema returned from the plugin is invalid",
+  unknownErrMsg: "Something went wrong parsing the schema from a plugin"
+});
+var { create: create2, of, make } = factory;
+
+// out/types/Template.ts
+var import_fluture9 = require("fluture");
+var import_zod10 = require("zod");
+var schemas8 = {
+  rawSchema: templateSchema,
+  schema: templateSchema.transform((val) => val)
+};
+var rawSchema8 = schemas8.rawSchema;
+
+// PluginSchema.ts
+var import_zod11 = require("zod");
+var internalSchema2 = internalSchema.extend({
+  operations: import_zod11.z.preprocess(
+    (val) => val != null ? val : [],
+    import_zod11.z.array(
+      schemas2.schema,
       { description: "ParsedOperations" }
     ).optional()
   ),
-  templates: import_zod.z.preprocess(
+  templates: import_zod11.z.preprocess(
     (val) => val != null ? val : [],
-    import_zod.z.array(
-      Template.schemas.schema
+    import_zod11.z.array(
+      schemas8.schema
     ).optional()
   )
 }).passthrough().describe("ParsedPluginInfo");
-var rawSchema4 = PluginInfo.rawSchema.extend({
-  name: Alias.rawSchema.optional(),
-  operations: import_zod.z.preprocess(
+var rawSchema9 = rawSchema7.extend({
+  name: rawSchema.optional(),
+  operations: import_zod11.z.preprocess(
     (val) => val != null ? val : [],
-    import_zod.z.array(
-      Operation.rawSchema,
+    import_zod11.z.array(
+      rawSchema2,
       { description: "ParsedOperation" }
     )
   ).optional(),
-  templates: import_zod.z.preprocess(
+  templates: import_zod11.z.preprocess(
     (val) => val != null ? val : [],
-    import_zod.z.array(
-      Template.schemas.schema
+    import_zod11.z.array(
+      schemas8.schema
     ).optional()
   )
 }).passthrough().describe("ParsedPluginInfo");
-var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
-  rawSchema: rawSchema4,
+var { schemas: generatedSchemas, factory: factory2 } = Base_default({
+  rawSchema: rawSchema9,
   internalSchema: internalSchema2,
   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, of, make } = factory;
-var schemas3 = {
+var { create: create4, of: of2, make: make2 } = factory2;
+var schemas9 = {
   ...generatedSchemas,
   schema: generatedSchemas.schema.transform((val) => val)
 };