@taqueria/protocol 0.6.1 → 0.6.6

package/Config.ts

@@ -1,4 +1,5 @@
 import createType, { Flatten } from '@taqueria/protocol/Base';
+import * as Contract from '@taqueria/protocol/Contract';
 import * as Environment from '@taqueria/protocol/Environment';
 import * as InstalledPlugin from '@taqueria/protocol/InstalledPlugin';
 import * as NetworkConfig from '@taqueria/protocol/NetworkConfig';
@@ -89,6 +90,9 @@ const commonSchema = z.object({
 			z.string({ description: 'config.artifactsDir' })
 				.min(1, 'config.artifactsDir must have a value'),
 		),
+	contracts: z.record(
+		Contract.rawSchema,
+	).optional(),
 }).describe('config');
 
 export const internalSchema = commonSchema.extend({
@@ -96,6 +100,7 @@ export const internalSchema = commonSchema.extend({
 	sandbox: sandboxMap,
 	environment: environmentMap,
 	accounts: accountsMap,
+	contracts: z.record(Contract.schemas.schema).optional(),
 });
 
 export const rawSchema = commonSchema.extend({

package/Contract.ts

@@ -0,0 +1,35 @@
+import createType, { Flatten } from '@taqueria/protocol/Base';
+import * as SHA256 from '@taqueria/protocol/SHA256';
+import { z } from 'zod';
+
+export const rawSchema = z.object({
+	sourceFile: z.string().min(1),
+	hash: SHA256.rawSchema,
+	// TODO: Should plugin also be provided here?
+});
+
+export const internalSchema = z.object({
+	sourceFile: z.string().min(1),
+	hash: SHA256.schemas.schema,
+});
+
+type RawInput = z.infer<typeof rawSchema>;
+type Input = z.infer<typeof internalSchema>;
+
+const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: (value: unknown) => `${value} is not a valid contract`,
+	unknownErrMsg: 'Something went wrong trying to parse a contract',
+});
+
+export type Contract = z.infer<typeof generatedSchemas.schema>;
+
+export type t = Contract;
+
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as Contract),
+};

package/EphemeralState.ts

@@ -5,7 +5,9 @@ import type { i18n } from '@taqueria/protocol/i18n';
 import * as InstalledPlugin from '@taqueria/protocol/InstalledPlugin';
 import * as Option from '@taqueria/protocol/Option';
 import * as ParsedOperation from '@taqueria/protocol/ParsedOperation';
-import * as ParsedPluginInfo from '@taqueria/protocol/ParsedPluginInfo';
+import * as ParsedTemplate from '@taqueria/protocol/ParsedTemplate';
+import * as PluginInfo from '@taqueria/protocol/PluginInfo';
+import * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
 import { E_TaqError, TaqError } from '@taqueria/protocol/TaqError';
 import * as Task from '@taqueria/protocol/Task';
 import * as Verb from '@taqueria/protocol/Verb';
@@ -30,12 +32,20 @@ const operationToPluginMap = z.record(
 	], { description: 'Operation/Plugin Mapping' }),
 );
 
+const templateToPluginMap = z.record(
+	z.union([
+		InstalledPlugin.schemas.schema,
+		ParsedTemplate.schemas.schema,
+	]),
+);
+
 const rawSchema = z.object({
 	build: z.string({ description: 'cache.build' }),
 	configHash: z.string({ description: 'cache.configHash' }),
 	tasks: taskToPluginMap,
 	operations: operationToPluginMap,
-	plugins: z.array(ParsedPluginInfo.schemas.schema, { description: 'cache.plugins' }),
+	templates: templateToPluginMap,
+	plugins: z.array(PluginInfo.schemas.schema, { description: 'cache.plugins' }),
 }).describe('Ephemeral State');
 
 type RawInput = z.infer<typeof rawSchema>;
@@ -50,6 +60,7 @@ export type EphemeralState = z.infer<typeof generatedSchemas.schema>;
 export type t = EphemeralState;
 export type TaskToPluginMap = z.infer<typeof taskToPluginMap>;
 export type OpToPluginMap = z.infer<typeof operationToPluginMap>;
+export type TemplateToPluginMap = z.infer<typeof templateToPluginMap>;
 
 export const { create, of, make } = factory;
 
@@ -61,8 +72,8 @@ export const schemas = {
 /**
  * Private functions
  */
-type Counts = Record<Verb.t, ParsedPluginInfo.t[]>;
-const getTaskCounts = (pluginInfo: ParsedPluginInfo.t[]): Counts => {
+type Counts = Record<Verb.t, PluginInfo.t[]>;
+const getTaskCounts = (pluginInfo: PluginInfo.t[]): Counts => {
 	return pluginInfo.reduce(
 		(retval, pluginInfo) =>
 			pluginInfo.tasks === undefined
@@ -70,7 +81,7 @@ const getTaskCounts = (pluginInfo: ParsedPluginInfo.t[]): Counts => {
 				: pluginInfo.tasks.reduce(
 					(retval: Counts, task: Task.t) => {
 						const taskName = task.task;
-						const providers: ParsedPluginInfo.t[] = retval[taskName]
+						const providers: PluginInfo.t[] = retval[taskName]
 							? [...retval[taskName], pluginInfo]
 							: [pluginInfo];
 						const mapping: Counts = {};
@@ -83,7 +94,28 @@ const getTaskCounts = (pluginInfo: ParsedPluginInfo.t[]): Counts => {
 	);
 };
 
-const getOperationCounts = (pluginInfo: ParsedPluginInfo.t[]): Counts => {
+const getTemplateCounts = (pluginInfo: PluginInfo.t[]): Counts => {
+	return pluginInfo.reduce(
+		(retval, pluginInfo) =>
+			!pluginInfo.templates
+				? retval
+				: pluginInfo.templates.reduce(
+					(retval: Counts, template: ParsedTemplate.t) => {
+						const templateName = template.template;
+						const providers = retval[templateName]
+							? [...retval[templateName], pluginInfo]
+							: [pluginInfo];
+						const mapping: Counts = {};
+						mapping[templateName] = providers.filter(provider => provider !== undefined);
+						return { ...retval, ...mapping };
+					},
+					retval,
+				),
+		{} as Counts,
+	);
+};
+
+const getOperationCounts = (pluginInfo: PluginInfo.t[]): Counts => {
 	return pluginInfo.reduce(
 		(retval, pluginInfo) =>
 			pluginInfo.operations === undefined
@@ -104,7 +136,7 @@ const getOperationCounts = (pluginInfo: ParsedPluginInfo.t[]): Counts => {
 	);
 };
 
-const toChoices = (plugins: ParsedPluginInfo.t[]) =>
+const toChoices = (plugins: PluginInfo.t[]) =>
 	plugins.reduce(
 		(retval, pluginInfo) => {
 			return [...retval, pluginInfo.name as string, pluginInfo.alias as string];
@@ -112,14 +144,14 @@ const toChoices = (plugins: ParsedPluginInfo.t[]) =>
 		[] as string[],
 	);
 
-const isComposite = (name: Verb.t, counts: Counts) => counts[name].length > 1;
+const isComposite = (name: Verb.t, counts: Counts) => counts[name] && counts[name].length > 1;
 
 const getInstalledPlugin = (config: Config.t, name: string) =>
 	config.plugins?.find(
 		(plugin: InstalledPlugin.t) => [`taqueria-plugin-${name}`, name].includes(plugin.name),
 	);
 
-export const mapTasksToPlugins = (config: Config.t, pluginInfo: ParsedPluginInfo.t[], i18n: i18n) => {
+export const mapTasksToPlugins = (config: Config.t, pluginInfo: PluginInfo.t[], i18n: i18n) => {
 	const taskCounts = getTaskCounts(pluginInfo);
 	return attemptP<TaqError, TaskToPluginMap>(async () =>
 		await pluginInfo.reduce(
@@ -161,7 +193,7 @@ export const mapTasksToPlugins = (config: Config.t, pluginInfo: ParsedPluginInfo
 	).pipe(mapRej(rej => rej as TaqError));
 };
 
-export const mapOperationsToPlugins = (config: Config.t, pluginInfo: ParsedPluginInfo.t[], i18n: i18n) => {
+export const mapOperationsToPlugins = (config: Config.t, pluginInfo: PluginInfo.t[], i18n: i18n) => {
 	const opCounts = getOperationCounts(pluginInfo);
 	return attemptP(async () =>
 		await pluginInfo.reduce(
@@ -201,7 +233,49 @@ export const mapOperationsToPlugins = (config: Config.t, pluginInfo: ParsedPlugi
 	).pipe(mapRej(rej => rej as TaqError));
 };
 
-export const getTasks = (pluginInfo: ParsedPluginInfo.t[]) =>
+export const mapTemplatesToPlugins = (config: Config.t, pluginInfo: PluginInfo.t[], i18n: i18n) => {
+	const tmplCounts = getTemplateCounts(pluginInfo);
+	return attemptP<TaqError, TemplateToPluginMap>(async () =>
+		await pluginInfo.reduce(
+			async (retval, pluginInfo) =>
+				!pluginInfo.templates
+					? Promise.resolve({} as TemplateToPluginMap)
+					: await pluginInfo.templates!.reduce(
+						async (retval, { template }) => {
+							if (isComposite(template, tmplCounts)) {
+								const command = await eager(Command.make(template));
+								const compositeTmpl = await eager(ParsedTemplate.make({
+									template,
+									command,
+									description: i18n.__('providedByMany'),
+									options: [
+										await eager(Option.make({
+											flag: await eager(Verb.make('plugin')),
+											description: 'Specify which plugin should be used to execute this task',
+											choices: toChoices(tmplCounts[template]),
+											required: true,
+										})),
+									],
+									handler: 'proxy',
+									encoding: PluginResponseEncoding.create('none'),
+								}));
+								return { ...await retval, [template]: compositeTmpl };
+							}
+
+							// Template is provided by just a single plugin
+							const installedPlugin = getInstalledPlugin(config, pluginInfo.name);
+							return installedPlugin
+								? { ...await retval, [template]: installedPlugin }
+								: retval;
+						},
+						retval,
+					),
+			Promise.resolve({} as TemplateToPluginMap),
+		)
+	).pipe(mapRej(rej => rej as TaqError));
+};
+
+export const getTasks = (pluginInfo: PluginInfo.t[]) =>
 	pluginInfo.reduce(
 		(retval: Task.t[], pluginInfo) => [...retval, ...(pluginInfo.tasks ?? [])],
 		[],

package/Option.ts

@@ -17,6 +17,10 @@ export const internalSchema = z.object({
 	).optional(),
 	required: z.boolean({ description: 'Option Is Required' }).default(false).optional(),
 	boolean: z.boolean({ description: 'Option Is Boolean' }).default(false).optional(),
+	type: z.union(
+		[z.literal('string'), z.literal('number'), z.literal('boolean')],
+		{ description: 'Positional Arg Datatype' },
+	).optional(),
 }).describe('Option');
 
 export const rawSchema = z.object({
@@ -33,6 +37,10 @@ export const rawSchema = z.object({
 	).optional(),
 	required: z.boolean({ description: 'Option Is Required' }).default(false).optional(),
 	boolean: z.boolean({ description: 'Option Is Boolean' }).default(false).optional(),
+	type: z.union(
+		[z.literal('string'), z.literal('number'), z.literal('boolean')],
+		{ description: 'Positional Arg Datatype' },
+	).optional(),
 }).describe('Option');
 
 type RawInput = z.infer<typeof rawSchema>;

package/ParsedTemplate.ts

@@ -0,0 +1,40 @@
+import createType from '@taqueria/protocol/Base';
+import * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
+import * as Template from '@taqueria/protocol/Template';
+import { z } from 'zod';
+
+const internalSchema = Template
+	.internalSchema
+	.extend({
+		handler: z.string(),
+		encoding: PluginResponseEncoding.schemas.schema,
+	})
+	.describe('ParsedTemplate');
+
+export const rawSchema = Template
+	.rawSchema
+	.extend({
+		handler: z.string(),
+		encoding: PluginResponseEncoding.schemas.schema,
+	})
+	.describe('ParsedTemplate');
+
+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) => `Could not parse the following template: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse an template',
+});
+
+export type ParsedTemplate = z.infer<typeof generatedSchemas.schema>;
+export type t = ParsedTemplate;
+
+export const { create, make, of } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as ParsedTemplate),
+};

package/PluginActionName.ts

@@ -0,0 +1,28 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+const rawSchema = z.union([
+	z.literal('checkRuntimeDependencies'),
+	z.literal('installRuntimeDependencies'),
+	z.literal('proxy'),
+	z.literal('proxyTemplate'),
+	z.literal('pluginInfo'),
+]);
+
+const internalSchema = rawSchema;
+
+export type PluginActionName = z.infer<typeof rawSchema>;
+export type t = PluginActionName;
+
+const pluginActionNotSupportedSchema = z.object({
+	status: z.literal('notSupported'),
+	msg: z.string(),
+});
+
+export type PluginActionNotSupportedResponse = z.infer<typeof pluginActionNotSupportedSchema>;
+
+export const schemas = {
+	schema: internalSchema,
+	internalSchema,
+	rawSchema,
+};

package/PluginDependenciesResponse.ts

@@ -0,0 +1,33 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+const rawRuntimeDependency = z.object({
+	name: z.string(),
+	path: z.string(),
+	version: z.string(),
+	kind: z.union([z.literal('required'), z.literal('optional')]),
+});
+
+type RawRuntimeDependencyInput = z.infer<typeof rawRuntimeDependency>;
+
+export const { schemas, factory } = createType<RawRuntimeDependencyInput, RawRuntimeDependencyInput>({
+	rawSchema: rawRuntimeDependency,
+	internalSchema: rawRuntimeDependency,
+	parseErrMsg: (value: unknown) => `The following runtime dependency is invalid: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse the template',
+});
+
+export type RuntimeDependency = z.infer<typeof schemas.schema>;
+
+const runtimeDependencyReport = rawRuntimeDependency.extend({ met: z.boolean() });
+
+export type RuntimeDependencyReport = z.infer<typeof runtimeDependencyReport>;
+
+const dependenciesResponseSchema = z.object({
+	report: z.array(runtimeDependencyReport),
+});
+
+export type PluginDependenciesResponse = z.infer<typeof dependenciesResponseSchema>;
+export type t = PluginDependenciesResponse;
+
+export const { of, make, create } = factory;

package/PluginInfo.ts

@@ -1,67 +1,76 @@
 import * as Alias from '@taqueria/protocol/Alias';
 import createType, { Flatten } from '@taqueria/protocol/Base';
-import * as Operation from '@taqueria/protocol/Operation';
+import * as ParsedOperation from '@taqueria/protocol/ParsedOperation';
+import * as ParsedTemplate from '@taqueria/protocol/ParsedTemplate';
 import * as Task from '@taqueria/protocol/Task';
 import * as VersionNumber from '@taqueria/protocol/VersionNumber';
 import { z } from 'zod';
 
-export const internalSchema = z.object({
+export const rawSchema = z.object({
 	name: z.string({ description: 'Plugin Name' }).min(1),
-	version: VersionNumber.schemas.schema.describe('Plugin Version #'),
-	schema: VersionNumber.schemas.schema.describe('Plugin Schema Version #'),
-	alias: Alias.schemas.schema.describe('Plugin Alias'),
+	version: VersionNumber.rawSchema.describe('Plugin Version #'),
+	schema: VersionNumber.rawSchema.describe('Plugin Schema Version #'),
+	alias: Alias.rawSchema.describe('Plugin Alias'),
 	tasks: z.preprocess(
 		val => val ?? [],
 		z.array(
 			Task.schemas.schema.describe('Plugin Task'),
 			{ description: 'Plugin Tasks' },
-		).optional(),
-	),
+		),
+	).optional(),
 	operations: z.preprocess(
 		val => val ?? [],
 		z.array(
-			Operation.schemas.schema.describe('Plugin Operation'),
+			ParsedOperation.schemas.schema.describe('Plugin Operation'),
 			{ description: 'Plugin Operations' },
-		).optional(),
-	),
-}).describe('Plugin Schema');
+		),
+	).optional(),
+	templates: z.preprocess(
+		val => val ?? [],
+		z.array(
+			ParsedTemplate.schemas.schema.describe('Plugin Template'),
+		),
+	).optional(),
+});
 
-export const rawSchema = z.object({
-	name: z.string({ description: 'Plugin Name' }).min(1),
-	version: VersionNumber.rawSchema.describe('Plugin Version #'),
-	schema: VersionNumber.rawSchema.describe('Plugin Schema Version #'),
-	alias: Alias.rawSchema.describe('Plugin Alias'),
+export const internalSchema = rawSchema.extend({
+	version: VersionNumber.schemas.schema.describe('Plugin Version #'),
+	schema: VersionNumber.schemas.schema.describe('Plugin Schema Version #'),
+	alias: Alias.schemas.schema.describe('Plugin Alias'),
 	tasks: z.preprocess(
 		val => val ?? [],
 		z.array(
-			Task.rawSchema.describe('Plugin Task'),
+			Task.schemas.schema.describe('Plugin Task'),
 			{ description: 'Plugin Tasks' },
-		).optional(),
-	),
+		),
+	).optional(),
 	operations: z.preprocess(
 		val => val ?? [],
 		z.array(
-			Operation.rawSchema.describe('Plugin Operation'),
+			ParsedOperation.schemas.schema.describe('Plugin Operation'),
 			{ description: 'Plugin Operations' },
-		).optional(),
-	),
+		),
+	).optional(),
+	templates: z.preprocess(
+		val => val ?? [],
+		z.array(
+			ParsedTemplate.schemas.schema.describe('Plugin Template'),
+		),
+	).optional(),
 }).describe('Plugin Schema');
 
+// export const rawSchema = internalSchema;
+
 type RawInput = z.infer<typeof rawSchema>;
 type Input = Flatten<z.infer<typeof internalSchema>>;
 
-export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+export const { schemas, factory } = createType<RawInput, Input>({
 	rawSchema,
 	internalSchema,
 	parseErrMsg: 'The schema returned from the plugin is invalid',
 	unknownErrMsg: 'Something went wrong parsing the schema from a plugin',
 });
 
-export type PluginInfo = Flatten<z.infer<typeof generatedSchemas.schema>>;
+export type PluginInfo = Flatten<z.infer<typeof schemas.schema>>;
 export type t = PluginInfo;
 export const { create, of, make } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as unknown as PluginInfo),
-};

package/PluginJsonResponse.ts

@@ -0,0 +1,26 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+export const rawSchema = z.object({
+	data: z.unknown().optional(),
+	render: z.union([
+		z.literal('none'),
+		z.literal('table'),
+		z.literal('string'),
+	]).optional(),
+});
+
+type RawPluginJsonResponseInput = z.infer<typeof rawSchema>;
+
+export const pluginJsonResponse = createType<RawPluginJsonResponseInput, RawPluginJsonResponseInput>({
+	rawSchema: rawSchema,
+	internalSchema: rawSchema,
+	parseErrMsg: (value: unknown) => `The following JSON response is invalid: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse the template',
+});
+
+export type PluginJsonResponse = z.infer<typeof pluginJsonResponse.schemas.schema>;
+
+export type t = PluginJsonResponse;
+
+export const { schemas, factory } = pluginJsonResponse;

package/PluginProxyResponse.ts

@@ -0,0 +1,24 @@
+import createType from '@taqueria/protocol/Base';
+import * as PluginJsonResponse from '@taqueria/protocol/PluginJsonResponse';
+import { z } from 'zod';
+
+const internalSchema = z.union([
+	PluginJsonResponse.schemas.internalSchema,
+	z.void(),
+]);
+
+export const rawSchema = internalSchema;
+
+type Input = z.infer<typeof internalSchema>;
+
+export const { schemas, factory } = createType<Input, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: 'The response from the proxy request is invalid',
+	unknownErrMsg: 'Something went wrong parsing the proxy response from the plugin',
+});
+
+export type PluginProxyResponse = z.infer<typeof schemas.schema>;
+export type t = PluginProxyResponse;
+
+export const { of, make, create } = factory;

package/PluginResponseEncoding.ts

@@ -0,0 +1,27 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+export const rawSchema = z.preprocess(
+	(val: unknown) => val ?? 'none',
+	z.union([
+		z.literal('json'),
+		z.literal('application/json'),
+		z.literal('none'),
+	])
+		.default('none')
+		.optional(),
+);
+
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { schemas, factory } = createType<RawInput, RawInput>({
+	rawSchema,
+	internalSchema: rawSchema,
+	parseErrMsg: (value: unknown) => `The following encoding is invalid: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse the encoding',
+});
+
+export type PluginResponseEncoding = z.infer<typeof schemas.schema>;
+export type t = PluginResponseEncoding;
+
+export const { create, of, make } = factory;

package/PluginSchema.ts

@@ -0,0 +1,81 @@
+import * as Alias from '@taqueria/protocol/Alias';
+import createType from '@taqueria/protocol/Base';
+import * as Operation from '@taqueria/protocol/Operation';
+import * as PluginDependenciesResponse from '@taqueria/protocol/PluginDependenciesResponse';
+import * as PluginInfo from '@taqueria/protocol/PluginInfo';
+import * as PluginProxyResponse from '@taqueria/protocol/PluginProxyResponse';
+import * as RequestArgs from '@taqueria/protocol/RequestArgs';
+import * as Template from '@taqueria/protocol/Template';
+import { z } from 'zod';
+
+const proxyFnSchema = z
+	.function()
+	.args(RequestArgs.proxySchemas.schema)
+	.returns(z.promise(PluginProxyResponse.schemas.schema));
+
+const runtimeDependenciesFn = z
+	.function()
+	.args(RequestArgs.schemas.schema)
+	.returns(z.promise(PluginDependenciesResponse.schemas.schema));
+
+const internalSchema = PluginInfo.internalSchema.extend({
+	operations: z.preprocess(
+		val => val ?? [],
+		z.array(
+			Operation.schemas.schema,
+			{ description: 'ParsedOperations' },
+		)
+			.optional(),
+	),
+	templates: z.preprocess(
+		val => val ?? [],
+		z.array(
+			Template.schemas.schema,
+		).optional(),
+	),
+	proxy: proxyFnSchema.optional(),
+	checkRuntimeDependencies: runtimeDependenciesFn.optional(),
+	installRuntimeDependencies: runtimeDependenciesFn.optional(),
+}).describe('ParsedPluginInfo');
+
+export const rawSchema = PluginInfo.rawSchema.extend({
+	name: Alias.rawSchema.optional(),
+	operations: z.preprocess(
+		val => val ?? [],
+		z.array(
+			Operation.rawSchema,
+			{ description: 'ParsedOperation' },
+		),
+	)
+		.optional(),
+	templates: z.preprocess(
+		val => val ?? [],
+		z.array(
+			Template.schemas.schema,
+		).optional(),
+	),
+	proxy: proxyFnSchema.optional(),
+	checkRuntimeDependencies: runtimeDependenciesFn.optional(),
+	installRuntimeDependencies: runtimeDependenciesFn.optional(),
+}).describe('ParsedPluginInfo');
+
+type Input = z.infer<typeof internalSchema>;
+
+export type RawPluginSchema = z.infer<typeof rawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawPluginSchema, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: (value: unknown) =>
+		`The following plugin info gave us trouble when parsing the following plugin information: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse the plugin information',
+});
+
+export type ParsedPluginInfo = z.infer<typeof generatedSchemas.schema>;
+export type t = ParsedPluginInfo;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as ParsedPluginInfo),
+};

package/PositionalArg.ts

@@ -13,19 +13,11 @@ export const rawSchema = z.object({
 		[z.literal('string'), z.literal('number'), z.literal('boolean')],
 		{ description: 'Positional Arg Datatype' },
 	).optional(),
+	required: z.boolean().optional(),
 }).describe('Positional Arg');
 
-const internalSchema = z.object({
+const internalSchema = rawSchema.extend({
 	placeholder: HumanReadableIdentifier.schemas.schema.describe('Positional Arg Placeholder'),
-	description: z.string({ description: 'Positional Arg Description' }).min(1),
-	defaultValue: z.union(
-		[z.string(), z.number(), z.boolean()],
-		{ description: 'Positional Arg Default Value' },
-	).optional(),
-	type: z.union(
-		[z.literal('string'), z.literal('number'), z.literal('boolean')],
-		{ description: 'Positional Arg Datatype' },
-	).optional(),
 }).describe('Positional Arg');
 
 type RawInput = z.infer<typeof rawSchema>;

package/RequestArgs.ts

@@ -3,13 +3,16 @@ import * as LoadedConfig from '@taqueria/protocol/LoadedConfig';
 import { rawSchema as sanitizedArgsSchema } from '@taqueria/protocol/SanitizedArgs';
 import { z } from 'zod';
 
+const taqRunSchema = z.union([
+	z.literal('pluginInfo'),
+	z.literal('proxy'),
+	z.literal('checkRuntimeDependencies'),
+	z.literal('installRuntimeDependencies'),
+	z.literal('proxyTemplate'),
+]);
+
 const rawSchema = sanitizedArgsSchema.extend({
-	taqRun: z.union([
-		z.literal('pluginInfo'),
-		z.literal('proxy'),
-		z.literal('checkRuntimeDependencies'),
-		z.literal('installRuntimeDependencies'),
-	], { description: 'request.taq_run' }),
+	taqRun: taqRunSchema,
 	config: z.preprocess(
 		val => typeof val === 'string' ? JSON.parse(val) : val,
 		LoadedConfig.rawSchema,
@@ -17,12 +20,7 @@ const rawSchema = sanitizedArgsSchema.extend({
 }).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' }),
+	taqRun: taqRunSchema,
 	config: z.preprocess(
 		val => typeof val === 'string' ? JSON.parse(val) : val,
 		LoadedConfig.schemas.schema,
@@ -47,20 +45,37 @@ export const schemas = {
 	schema: generatedSchemas.schema.transform(val => val as RequestArgs),
 };
 
-const rawProxySchema = rawSchema.extend({
+const rawProxyTaskSchema = rawSchema.extend({
 	task: z.string().min(1),
 }).describe('ProxyRequestArgs').passthrough();
 
-const internalProxySchema = internalSchema.extend({
+const internalProxyTaskSchema = internalSchema.extend({
 	task: z.string().min(1),
 }).describe('ProxyRequestArgs').passthrough();
 
-type RawProxyInput = z.infer<typeof rawProxySchema>;
-type ProxyInput = z.infer<typeof internalProxySchema>;
+const rawProxyTemplateSchema = rawSchema.extend({
+	template: z.string().min(1),
+});
+
+const internalProxyTemplateSchema = rawSchema.extend({
+	template: z.string().min(1),
+});
+
+type RawProxyInput = z.infer<typeof rawProxyTaskSchema>;
+type ProxyInput = z.infer<typeof internalProxyTaskSchema>;
+type RawProxyTemplateInput = z.infer<typeof rawProxyTemplateSchema>;
+type ProxyTemplateInput = z.infer<typeof internalProxyTemplateSchema>;
 
 export const proxy = createType<RawProxyInput, ProxyInput>({
-	rawSchema: rawProxySchema,
-	internalSchema: internalProxySchema,
+	rawSchema: rawProxyTaskSchema,
+	internalSchema: internalProxyTaskSchema,
+	parseErrMsg: 'The request is invalid',
+	unknownErrMsg: 'Something went wrong trying to parse the request',
+});
+
+export const proxyTemplate = createType<RawProxyTemplateInput, ProxyTemplateInput>({
+	rawSchema: rawProxyTemplateSchema,
+	internalSchema: internalProxyTemplateSchema,
 	parseErrMsg: 'The request is invalid',
 	unknownErrMsg: 'Something went wrong trying to parse the request',
 });
@@ -69,8 +84,14 @@ export const proxySchemas = proxy.schemas;
 export const proxyFactory = proxy.factory;
 
 export type ProxyRequestArgs = z.infer<typeof proxySchemas.schema>;
+export type ProxyTemplateRequestArgs = z.infer<typeof proxyTemplate.schemas.schema>;
 
 export const createProxyRequestArgs = proxyFactory.from;
 export const makeProxyRequestArgs = proxyFactory.make;
 export const ofProxyRequestArgs = proxyFactory.of;
+
+export const createProxyTemplateRequestArgs = proxyTemplate.factory.from;
+export const makeProxyTemplateRequestArgs = proxyTemplate.factory.make;
+export const ofProxyTemplateRequestArgs = proxyTemplate.factory.of;
+
 export const { create, make, of, from } = factory;

package/SanitizedArgs.ts

@@ -1,4 +1,5 @@
 import createType from '@taqueria/protocol/Base';
+import * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
 import * as SanitizedAbsPath from '@taqueria/protocol/SanitizedAbsPath';
 import * as Url from '@taqueria/protocol/Url';
 import { z } from 'zod';
@@ -51,7 +52,6 @@ export const rawSchema = z.object({
 		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();
 
@@ -78,6 +78,10 @@ export const provisionRawSchema = rawSchema
 	})
 	.passthrough();
 
+export const templateRawSchema = rawSchema.extend({
+	template: z.string().min(1),
+}).passthrough();
+
 export const managePluginRawSchema = rawSchema.omit({ pluginName: true }).extend({
 	pluginName: z.string().min(1),
 });
@@ -86,11 +90,34 @@ export const versionRawSchema = rawSchema.extend({
 	version: z.boolean().default(true),
 });
 
+export const addContractsRawSchema = z.preprocess(
+	val => {
+		const obj: {
+			contractName?: string;
+			sourceFile?: string;
+		} = typeof val === 'object' ? Object(val) : ({ contractName: '', sourceFile: '' });
+		return !obj.contractName && obj.sourceFile
+			? { ...obj, contractName: obj['sourceFile'] }
+			: obj;
+	},
+	rawSchema.extend({
+		sourceFile: z.string().min(1),
+		contractName: z.string().min(1),
+	}),
+);
+
+export const removeContractsRawSchema = rawSchema.extend({
+	contractName: z.string().min(1),
+});
+
 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>;
+type RawTemplateInput = z.infer<typeof templateRawSchema>;
+type RawAddContractsInput = z.infer<typeof addContractsRawSchema>;
+type RawRemoveContractsInput = z.infer<typeof removeContractsRawSchema>;
 
 export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
 	rawSchema,
@@ -132,10 +159,31 @@ export const uninstallTaskArgs = createType<RawManagePluginInput, RawManagePlugi
 	unknownErrMsg: 'Something went wrong parsing the arguments for the uninstall task',
 });
 
+export const createTaskArgs = createType<RawTemplateInput, RawTemplateInput>({
+	rawSchema: templateRawSchema,
+	parseErrMsg: 'The arguments provided are invalid for the create task',
+	unknownErrMsg: 'Something went wrong parsing the arguments for the create task',
+});
+
+export const addContractArgs = createType<RawAddContractsInput, RawAddContractsInput>({
+	rawSchema: addContractsRawSchema,
+	parseErrMsg: 'Please specify the source file to register.',
+	unknownErrMsg: 'Something went wrong parsing the arguments for registering a contract.',
+});
+
+export const removeContractsArgs = createType<RawRemoveContractsInput, RawRemoveContractsInput>({
+	rawSchema: removeContractsRawSchema,
+	parseErrMsg: 'Please specify the contract name to unregister.',
+	unknownErrMsg: 'Something went wrong parsing the arguments to unregister a contract.',
+});
+
 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 type CreateTaskArgs = z.infer<typeof createTaskArgs.schemas.schema>;
+export type AddContractArgs = z.infer<typeof addContractArgs.schemas.schema>;
+export type RemoveContractArgs = z.infer<typeof removeContractsArgs.schemas.schema>;
 
 export const createScaffoldTaskArgs = scaffoldTaskArgs.factory.from;
 export const makeScaffoldTaskArgs = scaffoldTaskArgs.factory.make;
@@ -152,3 +200,14 @@ export const ofInstallTaskArgs = installTaskArgs.factory.of;
 export const createUninstallTaskArgs = uninstallTaskArgs.factory.create;
 export const makeUninstallTaskArgs = uninstallTaskArgs.factory.make;
 export const ofUninstallTaskArgs = uninstallTaskArgs.factory.of;
+
+export const createCreateTaskArgs = createTaskArgs.factory.create;
+export const makeCreateTaskArgs = createTaskArgs.factory.make;
+export const ofCreateTaskArgs = createTaskArgs.factory.of;
+export const createAddContractArgs = addContractArgs.factory.create;
+export const makeAddContractArgs = addContractArgs.factory.make;
+export const ofAddContractArgs = addContractArgs.factory.of;
+
+export const createRemoveContractsArgs = removeContractsArgs.factory.create;
+export const makeRemoveContractsArgs = removeContractsArgs.factory.make;
+export const ofRemoveContractsArgs = removeContractsArgs.factory.of;

package/ScaffoldConfig.ts

@@ -0,0 +1,6 @@
+// TODO - use zod schema
+export interface ScaffoldType {
+	postInit?: string;
+}
+
+export type t = ScaffoldType;

package/TaqError.ts

@@ -19,8 +19,11 @@ export type ErrorType =
 	| 'E_PARSE'
 	| 'E_PARSE_UNKNOWN'
 	| 'E_INVALID_ARCH'
+	| 'E_CONTRACT_REGISTERED'
+	| 'E_CONTRACT_NOT_REGISTERED'
 	| 'E_NO_PROVISIONS'
-	| 'E_INTERNAL_LOGICAL_VALIDATION_FAILURE';
+	| 'E_INTERNAL_LOGICAL_VALIDATION_FAILURE'
+	| 'E_EXEC';
 
 export interface TaqError {
 	readonly kind: ErrorType;

package/Task.ts

@@ -2,22 +2,11 @@ import * as Alias from '@taqueria/protocol/Alias';
 import createType, { Flatten } from '@taqueria/protocol/Base';
 import * as Command from '@taqueria/protocol/Command';
 import * as Option from '@taqueria/protocol/Option';
+import * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
 import * as PositionalArg from '@taqueria/protocol/PositionalArg';
 import * as Verb from '@taqueria/protocol/Verb';
 import { z } from 'zod';
 
-const taskEncodingSchema = z.preprocess(
-	(val: unknown) => val ?? 'none',
-	z.union([
-		z.literal('json'),
-		z.literal('application/json'),
-		z.literal('none'),
-	])
-		.default('none')
-		.describe('Task Encoding')
-		.optional(),
-);
-
 const taskHandlerSchema = z.union([
 	z.literal('proxy'),
 	z.string().min(1),
@@ -30,20 +19,17 @@ export const rawSchema = z.object({
 	description: z.string({ description: 'Task Description' }).min(3),
 	example: z.string({ description: 'Task Example' }).optional(),
 	hidden: z.boolean({ description: 'Task Is Hidden' }).default(false).optional(),
-	encoding: taskEncodingSchema.describe('Task Encoding'),
+	encoding: PluginResponseEncoding.rawSchema.optional(),
 	handler: taskHandlerSchema.describe('Task Handler'),
 	options: z.array(Option.rawSchema).default([]).describe('Task Options').optional(),
 	positionals: z.array(PositionalArg.rawSchema).default([]).describe('Task Positional Args').optional(),
 }).describe('Task');
 
-const internalSchema = z.object({
+const internalSchema = rawSchema.extend({
 	task: Verb.schemas.schema.describe('Task Name'),
 	command: Command.schemas.schema.describe('Task Command'),
-	aliases: z.array(Alias.rawSchema).default([]).describe('Task Aliases').optional(),
-	description: z.string({ description: 'Task Description' }).min(3),
-	example: z.string({ description: 'Task Example' }).optional(),
-	hidden: z.boolean({ description: 'Task Is Hidden' }).default(false).optional(),
-	encoding: taskEncodingSchema.describe('Task Encoding'),
+	aliases: z.array(Alias.schemas.schema).default([]).describe('Task Aliases').optional(),
+	encoding: PluginResponseEncoding.schemas.schema.optional(),
 	handler: taskHandlerSchema.describe('Task Handler'),
 	options: z.preprocess(
 		val => val ?? [],

package/Template.ts

@@ -0,0 +1,76 @@
+import createType from '@taqueria/protocol/Base';
+import * as Command from '@taqueria/protocol/Command';
+import * as Option from '@taqueria/protocol/Option';
+import * as PluginJsonResponse from '@taqueria/protocol/PluginJsonResponse';
+import * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
+import * as PositionalArg from '@taqueria/protocol/PositionalArg';
+import * as RequestArgs from '@taqueria/protocol/RequestArgs';
+import * as Verb from '@taqueria/protocol/Verb';
+import { z } from 'zod';
+
+const handlerSchema = z.union([
+	z.string().min(1),
+	z.function().args(RequestArgs.schemas.schema).returns(z.union([
+		z.void(),
+		PluginJsonResponse.schemas.schema,
+		PluginJsonResponse.schemas.internalSchema,
+		z.promise(
+			z.union([
+				z.void(),
+				PluginJsonResponse.schemas.schema,
+				PluginJsonResponse.schemas.internalSchema,
+			]),
+		),
+	])),
+]);
+
+export const rawSchema = z.object({
+	template: Verb.rawSchema,
+	command: Command.rawSchema,
+	description: z.string().min(4),
+	hidden: z.preprocess(
+		val => val ?? false,
+		z.boolean(),
+	).optional(),
+	options: z.preprocess(
+		val => val ?? [],
+		z.array(Option.rawSchema),
+	).optional(),
+	positionals: z.preprocess(
+		val => val ?? [],
+		z.array(PositionalArg.rawSchema),
+	).optional(),
+	handler: handlerSchema.describe('Template Handler'),
+	encoding: PluginResponseEncoding.schemas.schema.optional(),
+});
+
+export const internalSchema = rawSchema.extend({
+	template: Verb.schemas.schema,
+	command: Command.schemas.schema,
+	options: z.preprocess(
+		val => val ?? [],
+		z.array(Option.schemas.schema),
+	).optional(),
+	positionals: z.preprocess(
+		val => val ?? [],
+		z.array(PositionalArg.schemas.schema),
+	).optional(),
+});
+
+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) => `The following template is invalid: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse the template',
+});
+
+export type Template = z.infer<typeof generatedSchemas.schema>;
+export type t = Template;
+export const { create, make, of } = factory;
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as unknown as Template),
+};

package/i18n.ts

@@ -54,6 +54,15 @@ export default async (): Promise<i18n> => {
 						'buildDesc': 'Display build information about the current version',
 						'pluginOption': "Use to specify what plugin you'd like when running this task.",
 						'yesOptionDesc': 'Select "yes" to any prompt',
+						'templateNotFound': 'Template not found. Perhaps you need to install a plugin?',
+						'createDesc': 'Create files from pre-existing templates',
+						'templateDesc': 'Name of the template to use',
+						'addContractDesc': 'Add a contract to the contract registry',
+						'addSourceFileDesc': 'Source file to add to the contract registry',
+						'removeContractDesc': 'Remove a contract from the contract registry',
+						'removeContractNameDesc': 'The name of the contract to remove',
+						'noContractsRegistered': 'No registered contracts found',
+						'listContractsDesc': 'List registered contracts',
 					},
 				},
 			},

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@taqueria/protocol",
-	"version": "0.6.1",
+	"version": "0.6.6",
 	"description": "A TypeScript package which contains types that are to be shared between @taqueria/node-sdk and @taqueria/taqueria.",
 	"main": "index.js",
 	"scripts": {

package/taqueria-protocol-types.ts

@@ -1,108 +1,35 @@
-import * as Alias from '@taqueria/protocol/Alias';
-import * as Config from '@taqueria/protocol/Config';
-import * as EconomicalProtocolHash from '@taqueria/protocol/EconomicalProtocolHash';
-import * as Environment from '@taqueria/protocol/Environment';
-import * as EphemeralState from '@taqueria/protocol/EphemeralState';
-import * as HumanReadableIdentifier from '@taqueria/protocol/HumanReadableIdentifier';
-import * as i18n from '@taqueria/protocol/i18n';
-import * as InstalledPlugin from '@taqueria/protocol/InstalledPlugin';
-import * as LoadedConfig from '@taqueria/protocol/LoadedConfig';
-import * as NetworkConfig from '@taqueria/protocol/NetworkConfig';
-import * as Operation from '@taqueria/protocol/Operation';
-import * as Option from '@taqueria/protocol/Option';
-import * as ParsedOperation from '@taqueria/protocol/ParsedOperation';
-import * as ParsedPluginInfo from '@taqueria/protocol/ParsedPluginInfo';
-import * as PersistentState from '@taqueria/protocol/PersistentState';
-import * as PluginInfo from '@taqueria/protocol/PluginInfo';
-import * as PositionalArg from '@taqueria/protocol/PositionalArg';
-import * as RequestArgs from '@taqueria/protocol/RequestArgs';
-import * as SandboxAccountConfig from '@taqueria/protocol/SandboxAccountConfig';
-import * as SandboxConfig from '@taqueria/protocol/SandboxConfig';
-import * as SanitizedAbsPath from '@taqueria/protocol/SanitizedAbsPath';
-import * as SanitizedArgs from '@taqueria/protocol/SanitizedArgs';
-import * as SanitizedPath from '@taqueria/protocol/SanitizedPath';
-import * as SHA256 from '@taqueria/protocol/SHA256';
-import * as TaqError from '@taqueria/protocol/TaqError';
-import * as Task from '@taqueria/protocol/Task';
-import * as Url from '@taqueria/protocol/Url';
-import * as Verb from '@taqueria/protocol/Verb';
-import * as VersionNumber from '@taqueria/protocol/VersionNumber';
-export interface RuntimeDependency {
-	readonly name: string;
-	readonly path: string;
-	readonly version: string;
-	readonly kind: 'required' | 'optional';
-}
-
-export type PluginActionName =
-	| 'checkRuntimeDependencies'
-	| 'installRuntimeDependencies'
-	| 'proxy'
-	| 'pluginInfo'
-	| string;
-
-export type PluginProxyAction = Task.t;
-
-export type PluginAction = 'checkRuntimeDependencies' | 'installRuntimeDependencies' | 'pluginInfo' | PluginProxyAction;
-
-export interface RuntimeDependencyReport extends RuntimeDependency {
-	readonly met: boolean;
-}
-
-export interface CheckRuntimeDependenciesResponse {
-	readonly report: RuntimeDependencyReport[];
-}
-
-export interface InstallRuntimeDependenciesResponse {
-	readonly report: RuntimeDependencyReport[];
-}
-
-export type PluginActionNotSupportedResponse = {
-	readonly status: 'notSupported';
-	readonly msg: string;
-};
-
-export interface PluginJsonResponse {
-	readonly data?: unknown;
-	readonly render?: 'none' | 'string' | 'table';
-}
-
-export type PluginResponse =
-	| PluginJsonResponse
-	| CheckRuntimeDependenciesResponse
-	| InstallRuntimeDependenciesResponse
-	| PluginInfo.t
-	| PluginActionNotSupportedResponse
-	| void;
-
-export {
-	Alias,
-	Config,
-	EconomicalProtocolHash,
-	Environment,
-	EphemeralState,
-	HumanReadableIdentifier,
-	i18n,
-	InstalledPlugin,
-	LoadedConfig,
-	NetworkConfig,
-	Operation,
-	Option,
-	ParsedOperation,
-	ParsedPluginInfo,
-	PersistentState,
-	PluginInfo,
-	PositionalArg,
-	RequestArgs,
-	SandboxAccountConfig,
-	SandboxConfig,
-	SanitizedAbsPath,
-	SanitizedArgs,
-	SanitizedPath,
-	SHA256,
-	TaqError,
-	Task,
-	Url,
-	Verb,
-	VersionNumber,
-};
+export * as Alias from '@taqueria/protocol/Alias';
+export * as Config from '@taqueria/protocol/Config';
+export * as EconomicalProtocolHash from '@taqueria/protocol/EconomicalProtocolHash';
+export * as Environment from '@taqueria/protocol/Environment';
+export * as EphemeralState from '@taqueria/protocol/EphemeralState';
+export * as HumanReadableIdentifier from '@taqueria/protocol/HumanReadableIdentifier';
+export * as i18n from '@taqueria/protocol/i18n';
+export * as InstalledPlugin from '@taqueria/protocol/InstalledPlugin';
+export * as LoadedConfig from '@taqueria/protocol/LoadedConfig';
+export * as NetworkConfig from '@taqueria/protocol/NetworkConfig';
+export * as Operation from '@taqueria/protocol/Operation';
+export * as Option from '@taqueria/protocol/Option';
+export * as ParsedOperation from '@taqueria/protocol/ParsedOperation';
+export * as ParsedTemplate from '@taqueria/protocol/ParsedTemplate';
+export * as PersistentState from '@taqueria/protocol/PersistentState';
+export * as PluginActionName from '@taqueria/protocol/PluginActionName';
+export * as PluginInfo from '@taqueria/protocol/PluginInfo';
+export * as PluginJsonResponse from '@taqueria/protocol/PluginJsonResponse';
+export * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
+export * as PluginSchema from '@taqueria/protocol/PluginSchema';
+export * as PositionalArg from '@taqueria/protocol/PositionalArg';
+export * as RequestArgs from '@taqueria/protocol/RequestArgs';
+export * as SandboxAccountConfig from '@taqueria/protocol/SandboxAccountConfig';
+export * as SandboxConfig from '@taqueria/protocol/SandboxConfig';
+export * as SanitizedAbsPath from '@taqueria/protocol/SanitizedAbsPath';
+export * as SanitizedArgs from '@taqueria/protocol/SanitizedArgs';
+export * as SanitizedPath from '@taqueria/protocol/SanitizedPath';
+export * as ScaffoldConfig from '@taqueria/protocol/ScaffoldConfig';
+export * as SHA256 from '@taqueria/protocol/SHA256';
+export * as TaqError from '@taqueria/protocol/TaqError';
+export * as Task from '@taqueria/protocol/Task';
+export * as Template from '@taqueria/protocol/Template';
+export * as Url from '@taqueria/protocol/Url';
+export * as Verb from '@taqueria/protocol/Verb';
+export * as VersionNumber from '@taqueria/protocol/VersionNumber';

package/ParsedPluginInfo.ts

@@ -1,47 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import * as ParsedOperation from '@taqueria/protocol/ParsedOperation';
-import * as PluginInfo from '@taqueria/protocol/PluginInfo';
-import { z } from 'zod';
-
-const internalSchema = PluginInfo.internalSchema.extend({
-	operations: z.preprocess(
-		val => val ?? [],
-		z.array(
-			ParsedOperation.schemas.schema,
-			{ description: 'ParsedOperations' },
-		)
-			.optional(),
-	),
-}).describe('ParsedPluginInfo');
-
-export const rawSchema = PluginInfo.internalSchema.extend({
-	operations: z.preprocess(
-		val => val ?? [],
-		z.array(
-			ParsedOperation.rawSchema,
-			{ description: 'ParsedOperation' },
-		),
-	)
-		.optional(),
-}).describe('ParsedPluginInfo');
-
-type Input = z.infer<typeof internalSchema>;
-
-type RawInput = z.infer<typeof rawSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
-	rawSchema,
-	internalSchema,
-	parseErrMsg: (value: unknown) =>
-		`The following plugin info gave us trouble when parsing the following plugin information: ${value}`,
-	unknownErrMsg: 'Something went wrong trying to parse the plugin information',
-});
-
-export type ParsedPluginInfo = z.infer<typeof generatedSchemas.schema>;
-export type t = ParsedPluginInfo;
-export const { create, of, make } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as ParsedPluginInfo),
-};