@taqueria/protocol 0.3.0 → 0.4.0-rc2

package/PublicKeyHash.ts

@@ -0,0 +1,28 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+export const rawSchema = z
+	.string({ description: 'Public Key Hash' })
+	.min(1) // TODO: what's the actual minimum length here?
+	.refine(
+		val => val.startsWith('tz1'),
+		val => ({ message: `${val} is not a valid public key hash` }),
+	);
+
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	isStringLike: true,
+	rawSchema,
+	parseErrMsg: (value: unknown) => `${value} is an invalid public key hash`,
+	unknownErrMsg: 'Something went wrong parsing the public key hash',
+});
+
+export type PublicKeyHash = z.infer<typeof generatedSchemas.schema>;
+export type t = PublicKeyHash;
+export type PKH = PublicKeyHash;
+export const { create, of, make } = factory;
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as PublicKeyHash),
+};

package/README.md

@@ -1,7 +1,91 @@
 # Taqueria Protocol
 
-Provides a shared collection of TypeScript types used in Taqueria
+This package provides TypeScript "types" to both the Taqueria CLI and the Taqueria Node SDK.
 
-This package is consumed by `taqueria` itself, as well as `taqueria-sdk`
+This package is consumable in Node and Deno, and therefore care must
+be taken to assure that any changes made to the types do not depend
+solely on a Node or Deno API.
 
-This package can be consumed as an NPM package or included as a Deno module
+## Zod Types and Schemas
+
+Each type is validated using either of the following [Zod](https://github.com/colinhacks/zod#default) schemas:
+
+### Raw Schema
+
+A schema that parses and _validates_ input using _built-in data types_.
+
+### Internal Schema
+
+A schema that extends the rawSchema but parses data into custom-defined _concrete types_. 
+
+### Schema
+
+A schema which extends the internalSchema, and _casts_ the data into its custom-defined concrete type
+
+
+#### Example:
+
+Let's say that we're trying to parse a Person, expecting a JSON object as input. For simplicity, lets say that define a Person with the following shape:
+```
+Person: {
+    firstName: Name.t,
+    lastName: Name.t
+}
+```
+
+Both fields are of type Name.t.
+
+
+Name.t would have a rawSchema that parses input as a string, with a minimum length of 2, and match against a regex to ensure that the string begins with an uppercase letter, and that only alphabetical characters, hyphens, and spaces are allowed. The rawSchema is essentially parsing the input into a built-in type, a string in this case, and validating that the string represents the data expected.
+
+The internalSchema of the Name.t type would be the same as the rawSchema in this place, as the rawSchema is parsing the input into a scalar value and simple type, rather than a complex type, such as an object.
+
+The schema of the Name.t type would take the value as output from the internalSchema, which would be a validated string in this case, and cast it to a Name.t.
+
+---
+
+The _rawSchema_ of a Person.t would parse the input as an object, with two required fields, and would validate those fields using the rawSchema provided by the Name.t type:
+
+```
+// rawSchema for Person.t
+export const rawSchema = z.object({
+    firstName: Name.rawSchema,
+    lastName: Name.rawSchema
+})
+```
+
+The _internalSchema_ extends the rawSchema by parsing the two fields into their proper concrete types:
+
+```
+// internalSchema for Person.t
+export const internalSchema = z.object({
+    firstName: Name.schema,
+    lastName: Name.schema
+})
+
+Recall that the _schema_ returns a value casted to its appropriate concrete type. Thus, the internalSchema above can be inferred as a Zod Schema with two Name.t fields.
+```
+
+Finally, the _schema_ will cast the object to its own concerete type, Person.t:
+```
+// schema for Person.t
+export const schema = internalSchema.transform(val => val as Person.t)
+```
+
+
+#### Factory methods
+
+Each type module has the following methods which map input to a parsed value of it's associated type:
+- `make()` - accepts a value as input that can be inferred to a type represented by the internalSchema. Returns a `Future<TaqError, T>`. Should be used internally by the CLI
+- `create()` - accepts a value as input with an unknown shape. Throws on failure. Should be used by plugin authors, not internally in the CLI.
+- `of()` - accepts a value as input with an unknown shape. Returns a `Future<TaqError, T>`. Typically used by the CLI when parsing input from files such as config.json.
+
+## Tips
+
+Zod schemas expose a default() method. This doesn't work well when the optional() method is used as well. As such, please use the transform() method to set default values.
+
+E.g.
+
+Instead of this: `z.string().default('contracts').optional()`
+
+Use this: `z.string().optional().transform(val => val ?? 'contracts')`

package/RequestArgs.ts

@@ -0,0 +1,76 @@
+import createType from '@taqueria/protocol/Base';
+import * as LoadedConfig from '@taqueria/protocol/LoadedConfig';
+import { rawSchema as sanitizedArgsSchema } from '@taqueria/protocol/SanitizedArgs';
+import { z } from 'zod';
+
+const rawSchema = sanitizedArgsSchema.extend({
+	taqRun: z.union([
+		z.literal('pluginInfo'),
+		z.literal('proxy'),
+		z.literal('checkRuntimeDependencies'),
+		z.literal('installRuntimeDependencies'),
+	], { description: 'request.taq_run' }),
+	config: z.preprocess(
+		val => typeof val === 'string' ? JSON.parse(val) : val,
+		LoadedConfig.rawSchema,
+	),
+}).describe('RequestArgs').passthrough();
+
+const internalSchema = sanitizedArgsSchema.extend({
+	taqRun: z.union([
+		z.literal('pluginInfo'),
+		z.literal('proxy'),
+		z.literal('checkRuntimeDependencies'),
+		z.literal('installRuntimeDependencies'),
+	], { description: 'request.taq_run' }),
+	config: z.preprocess(
+		val => typeof val === 'string' ? JSON.parse(val) : val,
+		LoadedConfig.schemas.schema,
+	),
+}).describe('RequestArgs').passthrough();
+
+type RawInput = z.infer<typeof rawSchema>;
+type Input = z.infer<typeof internalSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: 'The request is invalid',
+	unknownErrMsg: 'Something went wrong trying to parse the request',
+});
+
+export type RequestArgs = z.infer<typeof generatedSchemas.schema>;
+export type t = RequestArgs;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as RequestArgs),
+};
+
+const rawProxySchema = rawSchema.extend({
+	task: z.string().min(1),
+}).describe('ProxyRequestArgs').passthrough();
+
+const internalProxySchema = internalSchema.extend({
+	task: z.string().min(1),
+}).describe('ProxyRequestArgs').passthrough();
+
+type RawProxyInput = z.infer<typeof rawProxySchema>;
+type ProxyInput = z.infer<typeof internalProxySchema>;
+
+export const proxy = createType<RawProxyInput, ProxyInput>({
+	rawSchema: rawProxySchema,
+	internalSchema: internalProxySchema,
+	parseErrMsg: 'The request is invalid',
+	unknownErrMsg: 'Something went wrong trying to parse the request',
+});
+
+export const proxySchemas = proxy.schemas;
+export const proxyFactory = proxy.factory;
+
+export type ProxyRequestArgs = z.infer<typeof proxySchemas.schema>;
+
+export const createProxyRequestArgs = proxyFactory.from;
+export const makeProxyRequestArgs = proxyFactory.make;
+export const ofProxyRequestArgs = proxyFactory.of;
+export const { create, make, of, from } = factory;

package/SHA256.ts

@@ -0,0 +1,40 @@
+import { Crypto } from '@peculiar/webcrypto';
+import createType from '@taqueria/protocol/Base';
+import { E_TaqError, TaqError } from '@taqueria/protocol/TaqError';
+import { FutureInstance as Future, mapRej, promise } from 'fluture';
+import { TextEncoder } from 'util';
+import { z } from 'zod';
+
+const eager = <T>(f: Future<TaqError, T>) =>
+	promise(
+		mapRej((err: TaqError) => new E_TaqError(err))(f),
+	);
+
+export const rawSchema = z.string({ description: 'SHA256' }).length(64);
+
+type RawInput = z.infer<typeof rawSchema>;
+
+const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	isStringLike: true,
+	rawSchema,
+	parseErrMsg: (value: unknown) => `${value} is an invalid SHA256 hash`,
+	unknownErrMsg: (value: unknown) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`,
+});
+
+export const toSHA256 = async (value: string) => {
+	const encoder = new TextEncoder();
+	const data = encoder.encode(value);
+	const crypto = new Crypto();
+	const hash = await crypto.subtle.digest('SHA-256', data);
+	const hashArray = Array.from(new Uint8Array(hash)); // convert buffer to byte array
+	const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+	return eager(factory.make(hashHex));
+};
+
+export type SHA256 = z.infer<typeof generatedSchemas.schema>;
+export type t = SHA256;
+export const { create, of, make } = factory;
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as SHA256),
+};

package/SandboxAccountConfig.ts

@@ -0,0 +1,35 @@
+import createType from '@taqueria/protocol/Base';
+import * as PublicKeyHash from '@taqueria/protocol/PublicKeyHash';
+import { z } from 'zod';
+
+const internalSchema = z.object({
+	encryptedKey: z.string({ description: 'Sandbox Account Encrypted Key' }).min(1),
+	publicKeyHash: PublicKeyHash.schemas.schema.describe('Sandbox Account Public Key Hash'),
+	secretKey: z.string({ description: 'Sandbox Account Secret Key' }).min(1),
+}, { description: 'Sandbox Account Configuration' });
+
+export const rawSchema = z.object({
+	encryptedKey: z.string({ description: 'Sandbox Account Encrypted Key' }).min(1),
+	publicKeyHash: z.string({ description: 'Sandbox Account Public Key Hash' }).min(1),
+	secretKey: z.string({ description: 'Sandbox Account Secret Key' }).min(1),
+}, { description: 'Sandbox Account Configuration' });
+
+type Input = z.infer<typeof internalSchema>;
+
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: 'The sandbox account configuration is invalid',
+	unknownErrMsg: 'Something went wrong trying to parse the sandbox account configuration',
+});
+
+export type SandboxAccountConfig = z.infer<typeof generatedSchemas.schema>;
+export type t = SandboxAccountConfig;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as SandboxAccountConfig),
+};

package/SandboxConfig.ts

@@ -0,0 +1,63 @@
+import createType from '@taqueria/protocol/Base';
+import * as EconomicalProtocolHash from '@taqueria/protocol/EconomicalProtocolHash';
+import * as HumanReadableIdentifier from '@taqueria/protocol/HumanReadableIdentifier';
+import * as SandboxAccountConfig from '@taqueria/protocol/SandboxAccountConfig';
+import * as Url from '@taqueria/protocol/Url';
+import * as Verb from '@taqueria/protocol/Verb';
+import { z } from 'zod';
+
+const accountMapSchema = z.record(
+	z.union([
+		z.string().nonempty(),
+		SandboxAccountConfig.schemas.schema,
+	]),
+);
+
+export const rawSchema = z.object({
+	label: z.string({ description: 'Sandbox Label' }).min(1),
+	rpcUrl: z.string({ description: 'Sandbox RPC Url' }).min(5).url(),
+	protocol: z.string({ description: 'Sandbox Protocol Hash' }).min(8),
+	attributes: z.record(
+		z.union(
+			[z.string(), z.number(), z.boolean()],
+			{ description: 'Sandbox Attribute' },
+		),
+		{ description: 'Sandbox Attributes' },
+	).optional(),
+	plugin: Verb.rawSchema.describe('Sandbox Plugin').optional(),
+	accounts: z.union([
+		z.object({ default: z.string().min(1) }),
+		z.record(SandboxAccountConfig.rawSchema),
+	], { description: 'Sandbox Accounts' }).optional(),
+});
+
+const internalSchema = z.object({
+	label: HumanReadableIdentifier.schemas.schema.describe('Sandbox Label'),
+	rpcUrl: Url.schemas.schema.describe('Sandbox RPC Url'),
+	protocol: EconomicalProtocolHash.schemas.schema.describe('Sandbox Protocol Hash'),
+	attributes: z.record(
+		z.union([z.string(), z.number(), z.boolean()]),
+		{ description: 'Sandbox Attributes' },
+	).optional(),
+	plugin: Verb.schemas.schema.describe('Sandbox Plugin').optional(),
+	accounts: accountMapSchema.optional(),
+}, { description: 'Sandbox Configuration' });
+
+type RawInput = z.infer<typeof rawSchema>;
+type Input = z.infer<typeof internalSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: (value: unknown) => `${value} is not a valid sandbox configuration `,
+	unknownErrMsg: 'Something went wrong trying to parse the sandbox configuration',
+});
+
+export type SandboxConfig = z.infer<typeof generatedSchemas.schema>;
+export type t = SandboxConfig;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as SandboxConfig),
+};

package/SanitizedAbsPath.ts

@@ -0,0 +1,23 @@
+import createType from '@taqueria/protocol/Base';
+import * as path from 'path';
+import { z } from 'zod';
+
+export const rawSchema = z.string({ description: 'SanitizedAbsPath' }).min(1);
+
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	isStringLike: true,
+	rawSchema,
+	transformer: (value: unknown) => path.resolve(value as string) as unknown,
+	parseErrMsg: (value: unknown) => `${value} is an invalid absolute path`,
+	unknownErrMsg: (value: unknown) => `Something went wrong trying to parse the absolute path, ${value}`,
+});
+
+export type SanitizedAbsPath = z.infer<typeof generatedSchemas.schema>;
+export type t = SanitizedAbsPath;
+export const { create, make, of } = factory;
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as SanitizedAbsPath),
+};

package/SanitizedArgs.ts

@@ -0,0 +1,154 @@
+import createType from '@taqueria/protocol/Base';
+import * as SanitizedAbsPath from '@taqueria/protocol/SanitizedAbsPath';
+import * as Url from '@taqueria/protocol/Url';
+import { z } from 'zod';
+
+export const rawSchema = z.object({
+	_: z.array(z.union([z.string().min(1), z.number()])),
+	projectDir: SanitizedAbsPath.schemas.schema,
+	maxConcurrency: z.preprocess(
+		val => typeof val === 'string' ? parseInt(val) : Number(val),
+		z.number().int().min(1).default(10),
+	),
+	debug: z.preprocess(
+		val => Boolean(val),
+		z.boolean().default(false),
+	),
+	disableState: z.preprocess(
+		val => Boolean(val),
+		z.boolean().default(false),
+	),
+	logPluginRequests: z.preprocess(
+		val => Boolean(val),
+		z.boolean().default(false),
+	),
+	fromVsCode: z.preprocess(
+		val => Boolean(val),
+		z.boolean().default(false),
+	),
+	version: z.preprocess(
+		val => Boolean(val),
+		z.boolean().optional(),
+	),
+	build: z.preprocess(
+		val => Boolean(val),
+		z.boolean().optional(),
+	),
+	help: z.preprocess(
+		val => Boolean(val),
+		z.boolean().optional(),
+	),
+	yes: z.preprocess(
+		val => Boolean(val),
+		z.boolean().optional(),
+	),
+	plugin: z.string().min(1).optional(),
+	env: z.union([z.literal('production'), z.literal('testing'), z.literal('development'), z.string().nonempty()])
+		.default('development'),
+	quickstart: z.string().min(1).optional(),
+	setBuild: z.preprocess(
+		val => String(val),
+		z.string().min(3),
+	),
+	setVersion: z.string().min(3),
+	template: z.string().min(1).optional(),
+	pluginName: z.string().min(1).optional(),
+}, { description: 'Sanitizied Args' }).passthrough();
+
+export const scaffoldRawSchema = rawSchema.extend({
+	scaffoldProjectDir: z.string().min(1).transform((val: unknown) => val as SanitizedAbsPath.t),
+	scaffoldUrl: z.string().min(1).url().transform((val: unknown) => val as Url.t),
+});
+
+export const provisionRawSchema = rawSchema
+	.extend({
+		operation: z
+			.string()
+			.min(1)
+			.describe('Operation name'),
+		name: 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();
+
+export const managePluginRawSchema = rawSchema.omit({ pluginName: true }).extend({
+	pluginName: z.string().min(1),
+});
+
+export const versionRawSchema = rawSchema.extend({
+	version: z.boolean().default(true),
+});
+
+type RawInput = z.infer<typeof rawSchema>;
+type RawScaffoldInput = z.infer<typeof scaffoldRawSchema>;
+type RawProvisionInput = z.infer<typeof provisionRawSchema>;
+type RawManagePluginInput = z.infer<typeof managePluginRawSchema>;
+type RawVersionInput = z.infer<typeof versionRawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	rawSchema,
+	parseErrMsg: 'The arguments provided are invalid',
+	unknownErrMsg: 'Something went wrong parsing the command-line arguments',
+});
+
+export const { create, of, make } = factory;
+
+export type SanitizedArgs = z.infer<typeof generatedSchemas.schema>;
+export type t = SanitizedArgs;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as SanitizedArgs),
+};
+
+export const scaffoldTaskArgs = createType<RawScaffoldInput, RawScaffoldInput>({
+	rawSchema: scaffoldRawSchema,
+	parseErrMsg: 'The arguments provided are invalid for the scaffold task',
+	unknownErrMsg: 'Something went wrong parsing the arguments for the scaffold task',
+});
+
+export const provisionTaskArgs = createType<RawProvisionInput, RawProvisionInput>({
+	rawSchema: provisionRawSchema,
+	parseErrMsg: 'The arguments provided are invalid for the provision task',
+	unknownErrMsg: 'Something went wrong parsing the arguments for the provision task',
+});
+
+export const installTaskArgs = createType<RawManagePluginInput, RawManagePluginInput>({
+	rawSchema: managePluginRawSchema,
+	parseErrMsg: 'The arguments provided are invalid for the install task',
+	unknownErrMsg: 'Something went wrong parsing the arguments for the install task',
+});
+
+export const uninstallTaskArgs = createType<RawManagePluginInput, RawManagePluginInput>({
+	rawSchema: managePluginRawSchema,
+	parseErrMsg: 'The arguments provided are invalid for the uninstall task',
+	unknownErrMsg: 'Something went wrong parsing the arguments for the uninstall task',
+});
+
+export type ScaffoldTaskArgs = z.infer<typeof scaffoldTaskArgs.schemas.schema>;
+export type ProvisionTaskArgs = z.infer<typeof provisionTaskArgs.schemas.schema>;
+export type InstallTaskArgs = z.infer<typeof installTaskArgs.schemas.schema>;
+export type UninstallTaskArgs = z.infer<typeof uninstallTaskArgs.schemas.schema>;
+
+export const createScaffoldTaskArgs = scaffoldTaskArgs.factory.from;
+export const makeScaffoldTaskArgs = scaffoldTaskArgs.factory.make;
+export const ofScaffoldTaskArgs = scaffoldTaskArgs.factory.of;
+
+export const createProvisionTaskArgs = provisionTaskArgs.factory.create;
+export const makeProvisionTaskArgs = provisionTaskArgs.factory.make;
+export const ofProvisionTaskArgs = provisionTaskArgs.factory.of;
+
+export const createInstallTaskArgs = installTaskArgs.factory.create;
+export const makeInstallTaskArgs = installTaskArgs.factory.make;
+export const ofInstallTaskArgs = installTaskArgs.factory.of;
+
+export const createUninstallTaskArgs = uninstallTaskArgs.factory.create;
+export const makeUninstallTaskArgs = uninstallTaskArgs.factory.make;
+export const ofUninstallTaskArgs = uninstallTaskArgs.factory.of;

package/SanitizedPath.ts

@@ -0,0 +1,26 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+export const rawSchema = z
+	.string({ description: 'Sanitized Path' })
+	.transform(value => {
+		const result = value.match(/^(\.\.|\.\/|\/)/);
+		return result ? value : `./${value}`;
+	});
+
+type RawInput = z.infer<typeof rawSchema>;
+
+const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	isStringLike: true,
+	rawSchema,
+	parseErrMsg: (value: unknown) => `${value} is an invalid filesystem path`,
+	unknownErrMsg: (value: unknown) => `Something went wrong trying to parse the filesystem path, ${value}`,
+});
+
+export type SanitizedPath = z.infer<typeof generatedSchemas.schema>;
+export type t = SanitizedPath;
+export const { create, of, make } = factory;
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as SanitizedPath),
+};

package/SingleChar.ts

@@ -0,0 +1,23 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+export const rawSchema = z
+	.string({ description: 'Single character' })
+	.regex(/^[A-Za-z]$/, 'Must be a single character');
+
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { factory, schemas: generatedSchemas } = createType<RawInput, RawInput>({
+	isStringLike: true,
+	rawSchema,
+	parseErrMsg: (value: unknown) => `${value} is not a single character`,
+	unknownErrMsg: `Something went wrong trying to parse a single character`,
+});
+
+export type SingleChar = z.infer<typeof generatedSchemas.schema>;
+export type t = SingleChar;
+export const { create, of, make } = factory;
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as SingleChar),
+};

package/TaqError.ts

@@ -0,0 +1,73 @@
+import { map, reject } from 'fluture';
+import { ZodError } from 'zod';
+
+export type ErrorType =
+	| 'E_INVALID_PATH_DOES_NOT_EXIST'
+	| 'E_INVALID_PATH_ALREADY_EXISTS'
+	| 'E_INVALID_CONFIG'
+	| 'E_INVALID_JSON'
+	| 'E_FORK'
+	| 'E_INVALID_TASK'
+	| 'E_READFILE'
+	| 'E_NPM_INIT'
+	| 'E_INVALID_PLUGIN_RESPONSE'
+	| 'E_INVALID_ARGS'
+	| 'E_MKDIR_FAILED'
+	| 'E_GIT_CLONE_FAILED'
+	| 'E_PROVISION'
+	| 'E_PARSE'
+	| 'E_PARSE_UNKNOWN'
+	| 'E_INVALID_ARCH'
+	| 'E_NO_PROVISIONS';
+
+export interface TaqError {
+	readonly kind: ErrorType;
+	msg: string;
+	previous?: TaqError | Error | unknown;
+	context?: unknown;
+}
+
+export type t = TaqError;
+
+export class E_TaqError extends Error {
+	readonly context;
+	readonly kind;
+	readonly previous;
+	constructor(taqErr: TaqError) {
+		super(taqErr.msg);
+		this.context = taqErr.context;
+		this.kind = taqErr.kind;
+		this.name = this.kind;
+		this.previous = taqErr.previous;
+	}
+}
+
+export const toFutureParseErr = <T>(previous: ZodError, msg: string, context?: unknown) =>
+	reject(toParseErr(previous, msg, context))
+		.pipe(map((val: unknown) => val as T));
+
+export const toParseErr = (previous: ZodError, msg: string, context?: unknown) =>
+	create({
+		kind: 'E_PARSE',
+		msg: msg,
+		context,
+		previous,
+	});
+
+export const toParseUnknownErr = (previous: Error | TaqError | E_TaqError | unknown, msg: string, context?: unknown) =>
+	create({
+		kind: 'E_PARSE_UNKNOWN',
+		msg: msg,
+		context,
+		previous,
+	});
+
+export const toFutureParseUnknownErr = <T>(
+	previous: Error | TaqError | E_TaqError | unknown,
+	msg: string,
+	context?: unknown,
+) =>
+	reject(toParseUnknownErr(previous, msg, context))
+		.pipe(map((val: unknown) => val as T));
+
+export const create = (err: TaqError) => err;