@taqueria/protocol 0.28.0 → 0.28.2

package/PersistentState.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,71 +15,528 @@ 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);
 
 // PersistentState.ts
 var PersistentState_exports = {};
 __export(PersistentState_exports, {
-  create: () => create,
-  factory: () => factory,
-  generatedSchemas: () => generatedSchemas,
-  internalSchema: () => internalSchema,
-  make: () => make,
-  of: () => of,
-  rawSchema: () => rawSchema3,
+  create: () => create3,
+  factory: () => factory2,
+  generatedSchemas: () => generatedSchemas2,
+  internalSchema: () => internalSchema2,
+  make: () => make2,
+  of: () => of2,
+  rawSchema: () => rawSchema4,
   schemas: () => schemas4
 });
 module.exports = __toCommonJS(PersistentState_exports);
-var import_Base = __toESM(require("@taqueria/protocol/Base"));
-var SHA256 = __toESM(require("@taqueria/protocol/SHA256"));
-var Timestamp = __toESM(require("@taqueria/protocol/Timestamp"));
-var Verb = __toESM(require("@taqueria/protocol/Verb"));
+
+// 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 rawOpSchema = import_zod.z.object({
-  hash: SHA256.rawSchema.describe("state.op.hash"),
-  time: Timestamp.rawSchema.describe("state.op.time"),
-  output: import_zod.z.unknown().describe("state.op.output")
+var createSchema = (params) => {
+  var _a, _b;
+  const { rawSchema: rawSchema5, 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: rawSchema5,
+    internalSchema: internalSchema3,
+    schema
+  };
+};
+var createType = (params) => {
+  const schemas5 = createSchema(params);
+  const { parseErrMsg, unknownErrMsg } = params;
+  const internalOf = (input) => {
+    try {
+      return (0, import_fluture2.resolve)(schemas5.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) => schemas5.schema.parse(input);
+  const from = (input) => schemas5.schema.parse(input);
+  const factory3 = {
+    make: make3,
+    of: of3,
+    create: create4,
+    from
+  };
+  return {
+    schemas: schemas5,
+    factory: factory3
+  };
+};
+var Base_default = createType;
+
+// SHA256.ts
+var import_fluture3 = require("fluture");
+var import_rambda = require("rambda");
+var import_util = require("util");
+var import_zod2 = require("zod");
+var rawSchema = import_zod2.z.string({ description: "SHA256" }).length(64);
+var { schemas: generatedSchemas, factory } = Base_default({
+  isStringLike: true,
+  rawSchema,
+  parseErrMsg: (value) => `${value} is an invalid SHA256 hash`,
+  unknownErrMsg: (value) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`
+});
+var internalSchema = generatedSchemas.schema;
+var { create: create2, of, make } = factory;
+var schemas = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+
+// out/types/Timestamp.ts
+var import_fluture4 = require("fluture");
+var import_zod4 = require("zod");
+
+// out/types-zod.ts
+var import_zod3 = require("zod");
+var nonEmptyStringSchema = import_zod3.z.string().min(1);
+var singleCharSchema = nonEmptyStringSchema.regex(/^[A-Za-z]$/);
+var verbSchema = nonEmptyStringSchema.regex(/^[A-Za-z\-\ ]+/);
+var aliasSchema = import_zod3.z.union([verbSchema, singleCharSchema]);
+var humanReadableIdentifierSchema = nonEmptyStringSchema.regex(
+  /^[A-Za-z]+[A-Za-z0-9-_ ]*$/
+);
+var sanitizedAbsPathSchema = nonEmptyStringSchema;
+var sanitizedPathSchema = nonEmptyStringSchema;
+var settingsSchema = import_zod3.z.object({
+  consent: import_zod3.z.union([
+    import_zod3.z.literal("opt_in"),
+    import_zod3.z.literal("opt_out"),
+    import_zod3.z.literal("unspecified")
+  ])
+});
+var timestampSchema = import_zod3.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_zod3.z.object({
+  shortFlag: singleCharSchema.optional(),
+  flag: verbSchema,
+  description: nonEmptyStringSchema,
+  defaultValue: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean()]).optional(),
+  type: import_zod3.z.union([import_zod3.z.literal("string"), import_zod3.z.literal("number"), import_zod3.z.literal("boolean")]).optional(),
+  required: import_zod3.z.boolean().optional(),
+  boolean: import_zod3.z.boolean().optional(),
+  choices: import_zod3.z.array(nonEmptyStringSchema).optional()
+});
+var positionalArgSchema = import_zod3.z.object({
+  placeholder: humanReadableIdentifierSchema,
+  description: nonEmptyStringSchema,
+  defaultValue: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean()]).optional(),
+  type: import_zod3.z.union([import_zod3.z.literal("string"), import_zod3.z.literal("number"), import_zod3.z.literal("boolean")]).optional(),
+  required: import_zod3.z.boolean().optional()
+});
+var installedPluginSchema = import_zod3.z.object({
+  type: import_zod3.z.union([import_zod3.z.literal("npm"), import_zod3.z.literal("binary"), import_zod3.z.literal("deno")]),
+  name: nonEmptyStringSchema
+});
+var runtimeDependencySchema = import_zod3.z.object({
+  name: humanReadableIdentifierSchema,
+  path: import_zod3.z.string(),
+  version: import_zod3.z.string(),
+  kind: import_zod3.z.union([import_zod3.z.literal("required"), import_zod3.z.literal("optional")])
+});
+var runtimeDependencyReportSchema = runtimeDependencySchema.extend(
+  {
+    met: import_zod3.z.boolean()
+  }
+);
+var pluginDependenciesResponseSchema = import_zod3.z.object({
+  report: import_zod3.z.array(runtimeDependencyReportSchema)
+});
+var pluginJsonResponseSchema = import_zod3.z.union([
+  import_zod3.z.object({
+    data: import_zod3.z.unknown().optional(),
+    render: import_zod3.z.union([import_zod3.z.literal("none"), import_zod3.z.literal("table"), import_zod3.z.literal("string")]).default("none")
+  }),
+  import_zod3.z.void()
+]);
+var pluginProxyResponseSchema = import_zod3.z.union([
+  import_zod3.z.void(),
+  pluginJsonResponseSchema
+]);
+var pluginResponseEncodingSchema = import_zod3.z.union([import_zod3.z.literal("none"), import_zod3.z.literal("json"), import_zod3.z.literal("application/json")]).default("none");
+var buildNumberSchema = import_zod3.z.number();
+var sanitizedArgsSchema = import_zod3.z.object({
+  _: import_zod3.z.array(import_zod3.z.string()),
+  projectDir: sanitizedPathSchema,
+  maxConcurrency: import_zod3.z.number(),
+  debug: import_zod3.z.boolean(),
+  disableState: import_zod3.z.boolean(),
+  logPluginRequests: import_zod3.z.boolean(),
+  fromVsCode: import_zod3.z.boolean(),
+  version: import_zod3.z.boolean(),
+  build: import_zod3.z.boolean(),
+  help: import_zod3.z.boolean(),
+  yes: import_zod3.z.boolean(),
+  plugin: nonEmptyStringSchema.optional(),
+  env: nonEmptyStringSchema,
+  quickstart: nonEmptyStringSchema,
+  setBuild: import_zod3.z.union([nonEmptyStringSchema, buildNumberSchema]),
+  setVersion: nonEmptyStringSchema
+}).passthrough();
+var pluginActionNameSchema = import_zod3.z.union([
+  import_zod3.z.literal("proxy"),
+  import_zod3.z.literal("pluginInfo"),
+  import_zod3.z.literal("checkRuntimeDependencies"),
+  import_zod3.z.literal("installRuntimeDependencies"),
+  import_zod3.z.literal("proxyTemplate")
+]);
+var economicalProtocolHashSchema = import_zod3.z.string();
+var publicKeyHashSchema = import_zod3.z.string().regex(/^tz\d[A-Za-z0-9]{33}$/);
+var sha256Schema = import_zod3.z.string().regex(/^[A-Fa-f0-9]{64}$/);
+var contractSchema = import_zod3.z.object({
+  sourceFile: nonEmptyStringSchema,
+  hash: sha256Schema
+});
+var faucetSchema = import_zod3.z.object({
+  pkh: publicKeyHashSchema,
+  mnemonic: import_zod3.z.array(import_zod3.z.string()),
+  email: import_zod3.z.string().email(),
+  password: import_zod3.z.string(),
+  amount: import_zod3.z.string().regex(/^\d+$/),
+  activation_code: import_zod3.z.string()
+});
+var tzKtConfigPostgresqlPortSchema = import_zod3.z.number().default(5432);
+var tzKtConfigApiPortSchema = import_zod3.z.number().default(5e3);
+var tzKtConfigSchema = import_zod3.z.object({
+  disableAutostartWithSandbox: import_zod3.z.boolean().optional(),
+  postgresqlPort: tzKtConfigPostgresqlPortSchema.optional(),
+  apiPort: tzKtConfigApiPortSchema.optional()
+});
+var persistedTaskSchema = import_zod3.z.object({
+  task: verbSchema,
+  plugin: nonEmptyStringSchema,
+  time: timestampSchema,
+  output: import_zod3.z.unknown().optional()
+});
+var persistedOperationSchema = import_zod3.z.object({
+  hash: sha256Schema,
+  time: timestampSchema,
+  output: import_zod3.z.unknown().optional()
+});
+var provisionerIDSchema = import_zod3.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_zod3.z.object({
+  id: provisionerIDSchema,
+  plugin: nonEmptyStringSchema,
+  operation: import_zod3.z.union([nonEmptyStringSchema, import_zod3.z.literal("custom")]),
+  command: import_zod3.z.string().optional(),
+  label: import_zod3.z.string().optional(),
+  depends_on: import_zod3.z.array(provisionerIDSchema).optional()
+});
+var provisionsSchema = import_zod3.z.array(provisionerSchema);
+var environmentSchema = import_zod3.z.object({
+  networks: import_zod3.z.array(nonEmptyStringSchema),
+  sandboxes: import_zod3.z.array(nonEmptyStringSchema),
+  storage: import_zod3.z.record(nonEmptyStringSchema).optional(),
+  aliases: import_zod3.z.record(import_zod3.z.record(nonEmptyStringSchema)).optional()
+});
+var environmentNameSchema = nonEmptyStringSchema.min(
+  1,
+  "Default environment must reference the name of an existing environment."
+);
+var humanLanguageSchema = import_zod3.z.union([import_zod3.z.literal("en"), import_zod3.z.literal("fr")]).default("en");
+var configContractsDirSchema = import_zod3.z.string().min(1).default("contracts");
+var configArtifactsDirSchema = import_zod3.z.string().min(1).default("artifacts");
+var currencyAmountV2Schema = import_zod3.z.object({
+  amount: import_zod3.z.string(),
+  units: import_zod3.z.string()
+});
+var versionV2Schema = import_zod3.z.string().regex(/^v2$/);
+var sandboxAccountSchema = import_zod3.z.object({
+  type: import_zod3.z.string().optional()
+}).passthrough();
+var sandboxAccountsSchema = import_zod3.z.record(sandboxAccountSchema);
+var configEnvironmentFileV2Schema = import_zod3.z.object({
+  type: import_zod3.z.string().optional(),
+  accounts: sandboxAccountsSchema.optional(),
+  accountDefault: import_zod3.z.any().optional(),
+  contracts: import_zod3.z.record(
+    import_zod3.z.object({
+      address: import_zod3.z.string().optional()
+    })
+  ).optional()
+}).passthrough();
+var metadataConfigSchema = import_zod3.z.object({
+  name: import_zod3.z.string().optional(),
+  projectDescription: import_zod3.z.string().optional(),
+  authors: import_zod3.z.array(import_zod3.z.string()).optional(),
+  license: import_zod3.z.string().optional(),
+  homepage: import_zod3.z.string().optional()
+});
+var networkAccountConfigSchema = import_zod3.z.object({
+  publicKey: nonEmptyStringSchema.optional(),
+  publicKeyHash: publicKeyHashSchema.optional(),
+  privateKey: nonEmptyStringSchema.optional(),
+  mnemonic: nonEmptyStringSchema.optional()
+});
+var sandboxAccountConfigSchema = import_zod3.z.object({
+  encryptedKey: nonEmptyStringSchema,
+  publicKeyHash: publicKeyHashSchema,
+  secretKey: nonEmptyStringSchema
+});
+var sandboxConfigSchema = import_zod3.z.object({
+  label: nonEmptyStringSchema,
+  rpcUrl: urlSchema,
+  protocol: economicalProtocolHashSchema.optional(),
+  plugin: verbSchema.optional(),
+  accounts: import_zod3.z.record(import_zod3.z.union([sandboxAccountConfigSchema, nonEmptyStringSchema])).optional(),
+  tzkt: tzKtConfigSchema.optional(),
+  annotations: import_zod3.z.record(import_zod3.z.unknown()).optional()
+});
+var scaffoldConfigSchema = import_zod3.z.object({
+  postInit: import_zod3.z.string().optional()
+});
+var taskSchema = import_zod3.z.object({
+  task: verbSchema,
+  command: commandSchema,
+  aliases: import_zod3.z.array(aliasSchema).optional(),
+  description: nonEmptyStringSchema.min(3).optional(),
+  example: nonEmptyStringSchema.optional(),
+  hidden: import_zod3.z.boolean().optional(),
+  encoding: pluginResponseEncodingSchema.optional(),
+  handler: import_zod3.z.union([import_zod3.z.literal("proxy"), nonEmptyStringSchema]),
+  options: import_zod3.z.array(optionSchema).optional(),
+  positionals: import_zod3.z.array(positionalArgSchema).optional()
+});
+var persistentStateSchema = import_zod3.z.object({
+  operations: import_zod3.z.record(persistedOperationSchema),
+  tasks: import_zod3.z.record(persistedTaskSchema)
+});
+var configAccountSchema = import_zod3.z.object({
+  balance: currencyAmountV2Schema
+});
+var configFileV2Schema = import_zod3.z.object({
+  version: versionV2Schema,
+  language: humanLanguageSchema.optional(),
+  metadata: metadataConfigSchema.optional(),
+  artifactsDir: configArtifactsDirSchema.optional(),
+  contractsDir: configContractsDirSchema.optional(),
+  accounts: import_zod3.z.record(configAccountSchema).optional(),
+  contracts: import_zod3.z.record(contractSchema).optional(),
+  environmentDefault: environmentNameSchema.optional(),
+  environments: import_zod3.z.record(configEnvironmentFileV2Schema).optional(),
+  plugins: import_zod3.z.array(installedPluginSchema).optional()
+});
+var networkConfigSchema = import_zod3.z.object({
+  label: humanReadableIdentifierSchema,
+  rpcUrl: urlSchema,
+  accounts: import_zod3.z.record(networkAccountConfigSchema).optional(),
+  faucet: faucetSchema.optional()
+});
+var pluginSchemaBaseSchema = import_zod3.z.object({
+  name: nonEmptyStringSchema,
+  version: versionNumberSchema,
+  schema: versionNumberSchema,
+  alias: aliasSchema,
+  tasks: import_zod3.z.array(taskSchema).optional()
+});
+var configSchema = import_zod3.z.object({
+  language: humanLanguageSchema.optional(),
+  metadata: metadataConfigSchema.optional(),
+  artifactsDir: configArtifactsDirSchema.optional(),
+  contractsDir: configContractsDirSchema.optional(),
+  contracts: import_zod3.z.record(contractSchema).optional(),
+  plugins: import_zod3.z.array(installedPluginSchema).optional(),
+  accounts: import_zod3.z.record(tzSchema).optional(),
+  environment: import_zod3.z.record(import_zod3.z.union([environmentSchema, environmentNameSchema])),
+  network: import_zod3.z.record(networkConfigSchema).optional(),
+  sandbox: import_zod3.z.record(sandboxConfigSchema).optional()
+});
+var configFileV1Schema = import_zod3.z.object({
+  language: humanLanguageSchema.optional(),
+  plugins: import_zod3.z.array(installedPluginSchema).optional(),
+  contractsDir: configContractsDirSchema.optional(),
+  artifactsDir: configArtifactsDirSchema.optional(),
+  network: import_zod3.z.record(networkConfigSchema).optional(),
+  sandbox: import_zod3.z.record(sandboxConfigSchema).optional(),
+  environment: import_zod3.z.record(import_zod3.z.union([environmentSchema, environmentNameSchema])).optional(),
+  accounts: import_zod3.z.record(tzSchema).optional(),
+  contracts: import_zod3.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_zod3.z.record(import_zod3.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_zod3.z.object({
+  operation: verbSchema,
+  command: commandSchema,
+  description: nonEmptyStringSchema.optional(),
+  positionals: import_zod3.z.array(positionalArgSchema).optional(),
+  options: import_zod3.z.array(optionSchema).optional(),
+  handler: import_zod3.z.function().args(persistentStateSchema).returns(import_zod3.z.function().args(requestArgsSchema).returns(import_zod3.z.void())).optional()
+});
+var parsedOperationSchema = operationSchema.omit({ handler: true });
+var templateHandlerSchema = import_zod3.z.union([
+  nonEmptyStringSchema,
+  import_zod3.z.function().args(requestArgsSchema).returns(
+    import_zod3.z.union([pluginJsonResponseSchema, import_zod3.z.promise(pluginJsonResponseSchema)])
+  ),
+  import_zod3.z.promise(import_zod3.z.void())
+]);
+var templateSchema = import_zod3.z.object({
+  template: verbSchema,
+  command: commandSchema,
+  description: nonEmptyStringSchema,
+  hidden: import_zod3.z.boolean().optional(),
+  options: import_zod3.z.array(optionSchema).optional(),
+  positionals: import_zod3.z.array(positionalArgSchema).optional(),
+  handler: templateHandlerSchema,
+  encoding: pluginResponseEncodingSchema.optional()
+});
+var parsedTemplateSchema = templateSchema.omit({ handler: true }).extend(
+  {
+    handler: import_zod3.z.string()
+  }
+);
+var pluginInfoSchema = pluginSchemaBaseSchema.extend(
+  {
+    operations: import_zod3.z.array(parsedOperationSchema).optional(),
+    templates: import_zod3.z.array(parsedTemplateSchema).optional()
+  }
+);
+var pluginSchemaSchema = pluginSchemaBaseSchema.extend(
+  {
+    operations: import_zod3.z.array(operationSchema).optional(),
+    templates: import_zod3.z.array(templateSchema).optional(),
+    proxy: import_zod3.z.function().args(requestArgsSchema).returns(import_zod3.z.promise(pluginProxyResponseSchema)).optional(),
+    checkRuntimeDependencies: import_zod3.z.function().args(requestArgsSchema).returns(import_zod3.z.promise(pluginDependenciesResponseSchema)).optional(),
+    installRuntimeDependencies: import_zod3.z.function().args(requestArgsSchema).returns(import_zod3.z.promise(pluginDependenciesResponseSchema)).optional()
+  }
+);
+var ephemeralStateSchema = import_zod3.z.object({
+  build: import_zod3.z.string(),
+  configHash: import_zod3.z.string(),
+  tasks: import_zod3.z.record(installedPluginSchema.and(taskSchema)),
+  operations: import_zod3.z.record(installedPluginSchema.and(parsedOperationSchema)),
+  templates: import_zod3.z.record(installedPluginSchema.and(parsedTemplateSchema)),
+  plugins: import_zod3.z.array(pluginInfoSchema)
+});
+
+// out/types/Timestamp.ts
+var schemas2 = {
+  rawSchema: timestampSchema,
+  schema: timestampSchema.transform((val) => val)
+};
+var rawSchema2 = schemas2.rawSchema;
+
+// out/types/Verb.ts
+var import_fluture5 = require("fluture");
+var import_zod5 = require("zod");
+var schemas3 = {
+  rawSchema: verbSchema,
+  schema: verbSchema.transform((val) => val)
+};
+var rawSchema3 = schemas3.rawSchema;
+
+// PersistentState.ts
+var import_zod6 = require("zod");
+var rawOpSchema = import_zod6.z.object({
+  hash: rawSchema.describe("state.op.hash"),
+  time: rawSchema2.describe("state.op.time"),
+  output: import_zod6.z.unknown().describe("state.op.output")
 }).describe("Persistent State Operation");
-var rawTaskSchema = import_zod.z.object({
-  task: Verb.schemas.rawSchema,
-  plugin: import_zod.z.string().min(1),
-  time: Timestamp.rawSchema.describe("state.task.time"),
-  output: import_zod.z.unknown().describe("state.task.output")
-});
-var internalOpSchema = import_zod.z.object({
-  hash: SHA256.schemas.schema.describe("state.op.hash"),
-  time: Timestamp.schemas.schema.describe("state.op.time"),
-  output: import_zod.z.unknown().describe("state.op.output")
-});
-var internalTaskSchema = import_zod.z.object({
-  task: Verb.schemas.schema,
-  plugin: import_zod.z.string().min(1),
-  time: Timestamp.schemas.schema.describe("state.task.time"),
-  output: import_zod.z.unknown().describe("state.op.output")
-});
-var rawSchema3 = import_zod.z.object({
-  operations: import_zod.z.record(rawOpSchema),
-  tasks: import_zod.z.record(rawTaskSchema)
-});
-var internalSchema = import_zod.z.object({
-  operations: import_zod.z.record(internalOpSchema),
-  tasks: import_zod.z.record(internalTaskSchema)
+var rawTaskSchema = import_zod6.z.object({
+  task: schemas3.rawSchema,
+  plugin: import_zod6.z.string().min(1),
+  time: rawSchema2.describe("state.task.time"),
+  output: import_zod6.z.unknown().describe("state.task.output")
+});
+var internalOpSchema = import_zod6.z.object({
+  hash: schemas.schema.describe("state.op.hash"),
+  time: schemas2.schema.describe("state.op.time"),
+  output: import_zod6.z.unknown().describe("state.op.output")
+});
+var internalTaskSchema = import_zod6.z.object({
+  task: schemas3.schema,
+  plugin: import_zod6.z.string().min(1),
+  time: schemas2.schema.describe("state.task.time"),
+  output: import_zod6.z.unknown().describe("state.op.output")
+});
+var rawSchema4 = import_zod6.z.object({
+  operations: import_zod6.z.record(rawOpSchema),
+  tasks: import_zod6.z.record(rawTaskSchema)
+});
+var internalSchema2 = import_zod6.z.object({
+  operations: import_zod6.z.record(internalOpSchema),
+  tasks: import_zod6.z.record(internalTaskSchema)
 }).transform((val) => ({
   operations: val.operations,
   tasks: val.tasks
 }));
-var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
-  rawSchema: rawSchema3,
+var { schemas: generatedSchemas2, factory: factory2 } = Base_default({
+  rawSchema: rawSchema4,
   parseErrMsg: `The persistent state is invalid`,
   unknownErrMsg: `Something went wrong trying to parse the persistent state`
 });
-var { create, of, make } = factory;
+var { create: create3, of: of2, make: make2 } = factory2;
 var schemas4 = {
-  ...generatedSchemas,
-  schema: generatedSchemas.schema.transform((val) => val)
+  ...generatedSchemas2,
+  schema: generatedSchemas2.schema.transform((val) => val)
 };
 //# sourceMappingURL=PersistentState.js.map