@taqueria/protocol 0.16.0 → 0.19.2

package/PersistentState.js

@@ -0,0 +1,98 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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,
+  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"));
+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")
+}).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)
+}).transform((val) => ({
+  operations: val.operations,
+  tasks: val.tasks
+}));
+var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
+  rawSchema: rawSchema3,
+  parseErrMsg: `The persistent state is invalid`,
+  unknownErrMsg: `Something went wrong trying to parse the persistent state`
+});
+var { create, of, make } = factory;
+var schemas4 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  factory,
+  generatedSchemas,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas
+});
+//# sourceMappingURL=PersistentState.js.map

package/PersistentState.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PersistentState.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as SHA256 from '@taqueria/protocol/SHA256';\nimport * as Timestamp from '@taqueria/protocol/Timestamp';\nimport * as Verb from '@taqueria/protocol/Verb';\nimport { z } from 'zod';\n\nconst rawOpSchema = z.object({\n\thash: SHA256.rawSchema.describe('state.op.hash'),\n\ttime: Timestamp.rawSchema.describe('state.op.time'),\n\toutput: z.unknown().describe('state.op.output'),\n}).describe('Persistent State Operation');\n\nconst rawTaskSchema = z.object({\n\ttask: Verb.schemas.rawSchema,\n\tplugin: z.string().min(1),\n\ttime: Timestamp.rawSchema.describe('state.task.time'),\n\toutput: z.unknown().describe('state.task.output'),\n});\n\nconst internalOpSchema = z.object({\n\thash: SHA256.schemas.schema.describe('state.op.hash'),\n\ttime: Timestamp.schemas.schema.describe('state.op.time'),\n\toutput: z.unknown().describe('state.op.output'),\n});\n\nconst internalTaskSchema = z.object({\n\ttask: Verb.schemas.schema,\n\tplugin: z.string().min(1),\n\ttime: Timestamp.schemas.schema.describe('state.task.time'),\n\toutput: z.unknown().describe('state.op.output'),\n});\n\nexport type PersistedTask = z.infer<typeof internalTaskSchema>;\n\nexport type PersistedOperation = z.infer<typeof internalOpSchema>;\n\nexport const rawSchema = z.object({\n\toperations: z.record(rawOpSchema),\n\ttasks: z.record(rawTaskSchema),\n});\n\nexport const internalSchema = z.object({\n\toperations: z.record(internalOpSchema),\n\ttasks: z.record(internalTaskSchema),\n}).transform(val => ({\n\toperations: val.operations as unknown as Record<string, PersistedOperation>,\n\ttasks: val.tasks as unknown as Record<string, PersistedTask>,\n}));\n\ntype RawInput = z.infer<typeof rawSchema>;\n\ntype Input = z.infer<typeof internalSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tparseErrMsg: `The persistent state is invalid`,\n\tunknownErrMsg: `Something went wrong trying to parse the persistent state`,\n});\n\nexport type PersistentState = z.infer<typeof generatedSchemas.schema>;\nexport type t = PersistentState;\nexport type State = PersistentState;\n\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as unknown as PersistentState),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAAA;AAAA,EAAA,eAAAC;AAAA;AAAA;AAAA,kBAAuB;AACvB,aAAwB;AACxB,gBAA2B;AAC3B,WAAsB;AACtB,iBAAkB;AAElB,IAAM,cAAc,aAAE,OAAO;AAAA,EAC5B,MAAa,iBAAU,SAAS,eAAe;AAAA,EAC/C,MAAgB,oBAAU,SAAS,eAAe;AAAA,EAClD,QAAQ,aAAE,QAAQ,EAAE,SAAS,iBAAiB;AAC/C,CAAC,EAAE,SAAS,4BAA4B;AAExC,IAAM,gBAAgB,aAAE,OAAO;AAAA,EAC9B,MAAW,aAAQ;AAAA,EACnB,QAAQ,aAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACxB,MAAgB,oBAAU,SAAS,iBAAiB;AAAA,EACpD,QAAQ,aAAE,QAAQ,EAAE,SAAS,mBAAmB;AACjD,CAAC;AAED,IAAM,mBAAmB,aAAE,OAAO;AAAA,EACjC,MAAa,eAAQ,OAAO,SAAS,eAAe;AAAA,EACpD,MAAgB,kBAAQ,OAAO,SAAS,eAAe;AAAA,EACvD,QAAQ,aAAE,QAAQ,EAAE,SAAS,iBAAiB;AAC/C,CAAC;AAED,IAAM,qBAAqB,aAAE,OAAO;AAAA,EACnC,MAAW,aAAQ;AAAA,EACnB,QAAQ,aAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACxB,MAAgB,kBAAQ,OAAO,SAAS,iBAAiB;AAAA,EACzD,QAAQ,aAAE,QAAQ,EAAE,SAAS,iBAAiB;AAC/C,CAAC;AAMM,IAAMD,aAAY,aAAE,OAAO;AAAA,EACjC,YAAY,aAAE,OAAO,WAAW;AAAA,EAChC,OAAO,aAAE,OAAO,aAAa;AAC9B,CAAC;AAEM,IAAM,iBAAiB,aAAE,OAAO;AAAA,EACtC,YAAY,aAAE,OAAO,gBAAgB;AAAA,EACrC,OAAO,aAAE,OAAO,kBAAkB;AACnC,CAAC,EAAE,UAAU,UAAQ;AAAA,EACpB,YAAY,IAAI;AAAA,EAChB,OAAO,IAAI;AACZ,EAAE;AAMK,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAE,SAA4B;AAAA,EACjF,WAAAF;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAMM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAE7B,IAAMC,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAiC;AACnF;","names":["rawSchema","schemas","createType"]}

package/PersistentState.mjs

@@ -0,0 +1,60 @@
+// PersistentState.ts
+import createType from "@taqueria/protocol/Base";
+import * as SHA256 from "@taqueria/protocol/SHA256";
+import * as Timestamp from "@taqueria/protocol/Timestamp";
+import * as Verb from "@taqueria/protocol/Verb";
+import { z } from "zod";
+var rawOpSchema = z.object({
+  hash: SHA256.rawSchema.describe("state.op.hash"),
+  time: Timestamp.rawSchema.describe("state.op.time"),
+  output: z.unknown().describe("state.op.output")
+}).describe("Persistent State Operation");
+var rawTaskSchema = z.object({
+  task: Verb.schemas.rawSchema,
+  plugin: z.string().min(1),
+  time: Timestamp.rawSchema.describe("state.task.time"),
+  output: z.unknown().describe("state.task.output")
+});
+var internalOpSchema = z.object({
+  hash: SHA256.schemas.schema.describe("state.op.hash"),
+  time: Timestamp.schemas.schema.describe("state.op.time"),
+  output: z.unknown().describe("state.op.output")
+});
+var internalTaskSchema = z.object({
+  task: Verb.schemas.schema,
+  plugin: z.string().min(1),
+  time: Timestamp.schemas.schema.describe("state.task.time"),
+  output: z.unknown().describe("state.op.output")
+});
+var rawSchema3 = z.object({
+  operations: z.record(rawOpSchema),
+  tasks: z.record(rawTaskSchema)
+});
+var internalSchema = z.object({
+  operations: z.record(internalOpSchema),
+  tasks: z.record(internalTaskSchema)
+}).transform((val) => ({
+  operations: val.operations,
+  tasks: val.tasks
+}));
+var { schemas: generatedSchemas, factory } = createType({
+  rawSchema: rawSchema3,
+  parseErrMsg: `The persistent state is invalid`,
+  unknownErrMsg: `Something went wrong trying to parse the persistent state`
+});
+var { create, of, make } = factory;
+var schemas4 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+export {
+  create,
+  factory,
+  generatedSchemas,
+  internalSchema,
+  make,
+  of,
+  rawSchema3 as rawSchema,
+  schemas4 as schemas
+};
+//# sourceMappingURL=PersistentState.mjs.map

package/PersistentState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PersistentState.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as SHA256 from '@taqueria/protocol/SHA256';\nimport * as Timestamp from '@taqueria/protocol/Timestamp';\nimport * as Verb from '@taqueria/protocol/Verb';\nimport { z } from 'zod';\n\nconst rawOpSchema = z.object({\n\thash: SHA256.rawSchema.describe('state.op.hash'),\n\ttime: Timestamp.rawSchema.describe('state.op.time'),\n\toutput: z.unknown().describe('state.op.output'),\n}).describe('Persistent State Operation');\n\nconst rawTaskSchema = z.object({\n\ttask: Verb.schemas.rawSchema,\n\tplugin: z.string().min(1),\n\ttime: Timestamp.rawSchema.describe('state.task.time'),\n\toutput: z.unknown().describe('state.task.output'),\n});\n\nconst internalOpSchema = z.object({\n\thash: SHA256.schemas.schema.describe('state.op.hash'),\n\ttime: Timestamp.schemas.schema.describe('state.op.time'),\n\toutput: z.unknown().describe('state.op.output'),\n});\n\nconst internalTaskSchema = z.object({\n\ttask: Verb.schemas.schema,\n\tplugin: z.string().min(1),\n\ttime: Timestamp.schemas.schema.describe('state.task.time'),\n\toutput: z.unknown().describe('state.op.output'),\n});\n\nexport type PersistedTask = z.infer<typeof internalTaskSchema>;\n\nexport type PersistedOperation = z.infer<typeof internalOpSchema>;\n\nexport const rawSchema = z.object({\n\toperations: z.record(rawOpSchema),\n\ttasks: z.record(rawTaskSchema),\n});\n\nexport const internalSchema = z.object({\n\toperations: z.record(internalOpSchema),\n\ttasks: z.record(internalTaskSchema),\n}).transform(val => ({\n\toperations: val.operations as unknown as Record<string, PersistedOperation>,\n\ttasks: val.tasks as unknown as Record<string, PersistedTask>,\n}));\n\ntype RawInput = z.infer<typeof rawSchema>;\n\ntype Input = z.infer<typeof internalSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tparseErrMsg: `The persistent state is invalid`,\n\tunknownErrMsg: `Something went wrong trying to parse the persistent state`,\n});\n\nexport type PersistentState = z.infer<typeof generatedSchemas.schema>;\nexport type t = PersistentState;\nexport type State = PersistentState;\n\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as unknown as PersistentState),\n};\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,YAAY,YAAY;AACxB,YAAY,eAAe;AAC3B,YAAY,UAAU;AACtB,SAAS,SAAS;AAElB,IAAM,cAAc,EAAE,OAAO;AAAA,EAC5B,MAAa,iBAAU,SAAS,eAAe;AAAA,EAC/C,MAAgB,oBAAU,SAAS,eAAe;AAAA,EAClD,QAAQ,EAAE,QAAQ,EAAE,SAAS,iBAAiB;AAC/C,CAAC,EAAE,SAAS,4BAA4B;AAExC,IAAM,gBAAgB,EAAE,OAAO;AAAA,EAC9B,MAAW,aAAQ;AAAA,EACnB,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACxB,MAAgB,oBAAU,SAAS,iBAAiB;AAAA,EACpD,QAAQ,EAAE,QAAQ,EAAE,SAAS,mBAAmB;AACjD,CAAC;AAED,IAAM,mBAAmB,EAAE,OAAO;AAAA,EACjC,MAAa,eAAQ,OAAO,SAAS,eAAe;AAAA,EACpD,MAAgB,kBAAQ,OAAO,SAAS,eAAe;AAAA,EACvD,QAAQ,EAAE,QAAQ,EAAE,SAAS,iBAAiB;AAC/C,CAAC;AAED,IAAM,qBAAqB,EAAE,OAAO;AAAA,EACnC,MAAW,aAAQ;AAAA,EACnB,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EACxB,MAAgB,kBAAQ,OAAO,SAAS,iBAAiB;AAAA,EACzD,QAAQ,EAAE,QAAQ,EAAE,SAAS,iBAAiB;AAC/C,CAAC;AAMM,IAAMA,aAAY,EAAE,OAAO;AAAA,EACjC,YAAY,EAAE,OAAO,WAAW;AAAA,EAChC,OAAO,EAAE,OAAO,aAAa;AAC9B,CAAC;AAEM,IAAM,iBAAiB,EAAE,OAAO;AAAA,EACtC,YAAY,EAAE,OAAO,gBAAgB;AAAA,EACrC,OAAO,EAAE,OAAO,kBAAkB;AACnC,CAAC,EAAE,UAAU,UAAQ;AAAA,EACpB,YAAY,IAAI;AAAA,EAChB,OAAO,IAAI;AACZ,EAAE;AAMK,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA4B;AAAA,EACjF,WAAAA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAMM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAE7B,IAAMC,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAiC;AACnF;","names":["rawSchema","schemas"]}

package/PluginActionName.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+declare const rawSchema: z.ZodUnion<[z.ZodLiteral<"checkRuntimeDependencies">, z.ZodLiteral<"installRuntimeDependencies">, z.ZodLiteral<"proxy">, z.ZodLiteral<"proxyTemplate">, z.ZodLiteral<"pluginInfo">]>;
+export declare type PluginActionName = z.infer<typeof rawSchema>;
+export declare type t = PluginActionName;
+declare const pluginActionNotSupportedSchema: z.ZodObject<{
+    status: z.ZodLiteral<"notSupported">;
+    msg: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "notSupported";
+    msg: string;
+}, {
+    status: "notSupported";
+    msg: string;
+}>;
+export declare type PluginActionNotSupportedResponse = z.infer<typeof pluginActionNotSupportedSchema>;
+export declare const schemas: {
+    schema: z.ZodUnion<[z.ZodLiteral<"checkRuntimeDependencies">, z.ZodLiteral<"installRuntimeDependencies">, z.ZodLiteral<"proxy">, z.ZodLiteral<"proxyTemplate">, z.ZodLiteral<"pluginInfo">]>;
+    internalSchema: z.ZodUnion<[z.ZodLiteral<"checkRuntimeDependencies">, z.ZodLiteral<"installRuntimeDependencies">, z.ZodLiteral<"proxy">, z.ZodLiteral<"proxyTemplate">, z.ZodLiteral<"pluginInfo">]>;
+    rawSchema: z.ZodUnion<[z.ZodLiteral<"checkRuntimeDependencies">, z.ZodLiteral<"installRuntimeDependencies">, z.ZodLiteral<"proxy">, z.ZodLiteral<"proxyTemplate">, z.ZodLiteral<"pluginInfo">]>;
+};
+export {};
+//# sourceMappingURL=PluginActionName.d.ts.map

package/PluginActionName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginActionName.d.ts","sourceRoot":"","sources":["PluginActionName.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,SAAS,sLAMb,CAAC;AAIH,oBAAY,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AACzD,oBAAY,CAAC,GAAG,gBAAgB,CAAC;AAEjC,QAAA,MAAM,8BAA8B;;;;;;;;;EAGlC,CAAC;AAEH,oBAAY,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAE9F,eAAO,MAAM,OAAO;;;;CAInB,CAAC"}

package/PluginActionName.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// PluginActionName.ts
+var PluginActionName_exports = {};
+__export(PluginActionName_exports, {
+  schemas: () => schemas
+});
+module.exports = __toCommonJS(PluginActionName_exports);
+var import_zod = require("zod");
+var rawSchema = import_zod.z.union([
+  import_zod.z.literal("checkRuntimeDependencies"),
+  import_zod.z.literal("installRuntimeDependencies"),
+  import_zod.z.literal("proxy"),
+  import_zod.z.literal("proxyTemplate"),
+  import_zod.z.literal("pluginInfo")
+]);
+var internalSchema = rawSchema;
+var pluginActionNotSupportedSchema = import_zod.z.object({
+  status: import_zod.z.literal("notSupported"),
+  msg: import_zod.z.string()
+});
+var schemas = {
+  schema: internalSchema,
+  internalSchema,
+  rawSchema
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  schemas
+});
+//# sourceMappingURL=PluginActionName.js.map

package/PluginActionName.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginActionName.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nconst rawSchema = z.union([\n\tz.literal('checkRuntimeDependencies'),\n\tz.literal('installRuntimeDependencies'),\n\tz.literal('proxy'),\n\tz.literal('proxyTemplate'),\n\tz.literal('pluginInfo'),\n]);\n\nconst internalSchema = rawSchema;\n\nexport type PluginActionName = z.infer<typeof rawSchema>;\nexport type t = PluginActionName;\n\nconst pluginActionNotSupportedSchema = z.object({\n\tstatus: z.literal('notSupported'),\n\tmsg: z.string(),\n});\n\nexport type PluginActionNotSupportedResponse = z.infer<typeof pluginActionNotSupportedSchema>;\n\nexport const schemas = {\n\tschema: internalSchema,\n\tinternalSchema,\n\trawSchema,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,iBAAkB;AAElB,IAAM,YAAY,aAAE,MAAM;AAAA,EACzB,aAAE,QAAQ,0BAA0B;AAAA,EACpC,aAAE,QAAQ,4BAA4B;AAAA,EACtC,aAAE,QAAQ,OAAO;AAAA,EACjB,aAAE,QAAQ,eAAe;AAAA,EACzB,aAAE,QAAQ,YAAY;AACvB,CAAC;AAED,IAAM,iBAAiB;AAKvB,IAAM,iCAAiC,aAAE,OAAO;AAAA,EAC/C,QAAQ,aAAE,QAAQ,cAAc;AAAA,EAChC,KAAK,aAAE,OAAO;AACf,CAAC;AAIM,IAAM,UAAU;AAAA,EACtB,QAAQ;AAAA,EACR;AAAA,EACA;AACD;","names":[]}

package/PluginActionName.mjs

@@ -0,0 +1,23 @@
+// PluginActionName.ts
+import { z } from "zod";
+var rawSchema = z.union([
+  z.literal("checkRuntimeDependencies"),
+  z.literal("installRuntimeDependencies"),
+  z.literal("proxy"),
+  z.literal("proxyTemplate"),
+  z.literal("pluginInfo")
+]);
+var internalSchema = rawSchema;
+var pluginActionNotSupportedSchema = z.object({
+  status: z.literal("notSupported"),
+  msg: z.string()
+});
+var schemas = {
+  schema: internalSchema,
+  internalSchema,
+  rawSchema
+};
+export {
+  schemas
+};
+//# sourceMappingURL=PluginActionName.mjs.map

package/PluginActionName.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginActionName.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nconst rawSchema = z.union([\n\tz.literal('checkRuntimeDependencies'),\n\tz.literal('installRuntimeDependencies'),\n\tz.literal('proxy'),\n\tz.literal('proxyTemplate'),\n\tz.literal('pluginInfo'),\n]);\n\nconst internalSchema = rawSchema;\n\nexport type PluginActionName = z.infer<typeof rawSchema>;\nexport type t = PluginActionName;\n\nconst pluginActionNotSupportedSchema = z.object({\n\tstatus: z.literal('notSupported'),\n\tmsg: z.string(),\n});\n\nexport type PluginActionNotSupportedResponse = z.infer<typeof pluginActionNotSupportedSchema>;\n\nexport const schemas = {\n\tschema: internalSchema,\n\tinternalSchema,\n\trawSchema,\n};\n"],"mappings":";AACA,SAAS,SAAS;AAElB,IAAM,YAAY,EAAE,MAAM;AAAA,EACzB,EAAE,QAAQ,0BAA0B;AAAA,EACpC,EAAE,QAAQ,4BAA4B;AAAA,EACtC,EAAE,QAAQ,OAAO;AAAA,EACjB,EAAE,QAAQ,eAAe;AAAA,EACzB,EAAE,QAAQ,YAAY;AACvB,CAAC;AAED,IAAM,iBAAiB;AAKvB,IAAM,iCAAiC,EAAE,OAAO;AAAA,EAC/C,QAAQ,EAAE,QAAQ,cAAc;AAAA,EAChC,KAAK,EAAE,OAAO;AACf,CAAC;AAIM,IAAM,UAAU;AAAA,EACtB,QAAQ;AAAA,EACR;AAAA,EACA;AACD;","names":[]}

package/PluginDependenciesResponse.d.ts

@@ -0,0 +1,152 @@
+import { z } from 'zod';
+export declare const schemas: {
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+    } & {
+        readonly __kind: any;
+    }, any>;
+}, factory: {
+    make: (input: {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+    } & {
+        readonly __kind: any;
+    }>;
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+    } & {
+        readonly __kind: any;
+    }>;
+    create: (input: {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+    }) => {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+    } & {
+        readonly __kind: any;
+    };
+    from: (input: unknown) => {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+    } & {
+        readonly __kind: any;
+    };
+};
+export declare type RuntimeDependency = z.infer<typeof schemas.schema>;
+declare const runtimeDependencyReport: z.ZodObject<z.extendShape<{
+    name: z.ZodString;
+    path: z.ZodString;
+    version: z.ZodString;
+    kind: z.ZodUnion<[z.ZodLiteral<"required">, z.ZodLiteral<"optional">]>;
+}, {
+    met: z.ZodBoolean;
+}>, "strip", z.ZodTypeAny, {
+    path: string;
+    name: string;
+    version: string;
+    kind: "required" | "optional";
+    met: boolean;
+}, {
+    path: string;
+    name: string;
+    version: string;
+    kind: "required" | "optional";
+    met: boolean;
+}>;
+export declare type RuntimeDependencyReport = z.infer<typeof runtimeDependencyReport>;
+declare const dependenciesResponseSchema: z.ZodObject<{
+    report: z.ZodArray<z.ZodObject<z.extendShape<{
+        name: z.ZodString;
+        path: z.ZodString;
+        version: z.ZodString;
+        kind: z.ZodUnion<[z.ZodLiteral<"required">, z.ZodLiteral<"optional">]>;
+    }, {
+        met: z.ZodBoolean;
+    }>, "strip", z.ZodTypeAny, {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+        met: boolean;
+    }, {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+        met: boolean;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    report: {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+        met: boolean;
+    }[];
+}, {
+    report: {
+        path: string;
+        name: string;
+        version: string;
+        kind: "required" | "optional";
+        met: boolean;
+    }[];
+}>;
+export declare type PluginDependenciesResponse = z.infer<typeof dependenciesResponseSchema>;
+export declare type t = PluginDependenciesResponse;
+export declare const of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    path: string;
+    name: string;
+    version: string;
+    kind: "required" | "optional";
+} & {
+    readonly __kind: any;
+}>, make: (input: {
+    path: string;
+    name: string;
+    version: string;
+    kind: "required" | "optional";
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    path: string;
+    name: string;
+    version: string;
+    kind: "required" | "optional";
+} & {
+    readonly __kind: any;
+}>, create: (input: {
+    path: string;
+    name: string;
+    version: string;
+    kind: "required" | "optional";
+}) => {
+    path: string;
+    name: string;
+    version: string;
+    kind: "required" | "optional";
+} & {
+    readonly __kind: any;
+};
+export {};
+//# sourceMappingURL=PluginDependenciesResponse.d.ts.map

package/PluginDependenciesResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginDependenciesResponse.d.ts","sourceRoot":"","sources":["PluginDependenciesResponse.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAQ,OAAO;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK7B,CAAC;AAEH,oBAAY,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC;AAE/D,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;EAAoD,CAAC;AAElF,oBAAY,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9B,CAAC;AAEH,oBAAY,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AACpF,oBAAY,CAAC,GAAG,0BAA0B,CAAC;AAE3C,eAAO,MAAQ,EAAE;;;;;;;IAAE,IAAI;;;;;;;;;;;;IAAE,MAAM;;;;;;;;;;;;CAAY,CAAC"}

package/PluginDependenciesResponse.js

@@ -0,0 +1,63 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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);
+
+// PluginDependenciesResponse.ts
+var PluginDependenciesResponse_exports = {};
+__export(PluginDependenciesResponse_exports, {
+  create: () => create,
+  factory: () => factory,
+  make: () => make,
+  of: () => of,
+  schemas: () => schemas
+});
+module.exports = __toCommonJS(PluginDependenciesResponse_exports);
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var import_zod = require("zod");
+var rawRuntimeDependency = import_zod.z.object({
+  name: import_zod.z.string(),
+  path: import_zod.z.string(),
+  version: import_zod.z.string(),
+  kind: import_zod.z.union([import_zod.z.literal("required"), import_zod.z.literal("optional")])
+});
+var { schemas, factory } = (0, import_Base.default)({
+  rawSchema: rawRuntimeDependency,
+  internalSchema: rawRuntimeDependency,
+  parseErrMsg: (value) => `The following runtime dependency is invalid: ${value}`,
+  unknownErrMsg: "Something went wrong trying to parse the template"
+});
+var runtimeDependencyReport = rawRuntimeDependency.extend({ met: import_zod.z.boolean() });
+var dependenciesResponseSchema = import_zod.z.object({
+  report: import_zod.z.array(runtimeDependencyReport)
+});
+var { of, make, create } = factory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  factory,
+  make,
+  of,
+  schemas
+});
+//# sourceMappingURL=PluginDependenciesResponse.js.map

package/PluginDependenciesResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginDependenciesResponse.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nconst rawRuntimeDependency = z.object({\n\tname: z.string(),\n\tpath: z.string(),\n\tversion: z.string(),\n\tkind: z.union([z.literal('required'), z.literal('optional')]),\n});\n\ntype RawRuntimeDependencyInput = z.infer<typeof rawRuntimeDependency>;\n\nexport const { schemas, factory } = createType<RawRuntimeDependencyInput, RawRuntimeDependencyInput>({\n\trawSchema: rawRuntimeDependency,\n\tinternalSchema: rawRuntimeDependency,\n\tparseErrMsg: (value: unknown) => `The following runtime dependency is invalid: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse the template',\n});\n\nexport type RuntimeDependency = z.infer<typeof schemas.schema>;\n\nconst runtimeDependencyReport = rawRuntimeDependency.extend({ met: z.boolean() });\n\nexport type RuntimeDependencyReport = z.infer<typeof runtimeDependencyReport>;\n\nconst dependenciesResponseSchema = z.object({\n\treport: z.array(runtimeDependencyReport),\n});\n\nexport type PluginDependenciesResponse = z.infer<typeof dependenciesResponseSchema>;\nexport type t = PluginDependenciesResponse;\n\nexport const { of, make, create } = factory;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,iBAAkB;AAElB,IAAM,uBAAuB,aAAE,OAAO;AAAA,EACrC,MAAM,aAAE,OAAO;AAAA,EACf,MAAM,aAAE,OAAO;AAAA,EACf,SAAS,aAAE,OAAO;AAAA,EAClB,MAAM,aAAE,MAAM,CAAC,aAAE,QAAQ,UAAU,GAAG,aAAE,QAAQ,UAAU,CAAC,CAAC;AAC7D,CAAC;AAIM,IAAM,EAAE,SAAS,QAAQ,QAAI,YAAAA,SAAiE;AAAA,EACpG,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,aAAa,CAAC,UAAmB,gDAAgD;AAAA,EACjF,eAAe;AAChB,CAAC;AAID,IAAM,0BAA0B,qBAAqB,OAAO,EAAE,KAAK,aAAE,QAAQ,EAAE,CAAC;AAIhF,IAAM,6BAA6B,aAAE,OAAO;AAAA,EAC3C,QAAQ,aAAE,MAAM,uBAAuB;AACxC,CAAC;AAKM,IAAM,EAAE,IAAI,MAAM,OAAO,IAAI;","names":["createType"]}

package/PluginDependenciesResponse.mjs

@@ -0,0 +1,28 @@
+// PluginDependenciesResponse.ts
+import createType from "@taqueria/protocol/Base";
+import { z } from "zod";
+var rawRuntimeDependency = z.object({
+  name: z.string(),
+  path: z.string(),
+  version: z.string(),
+  kind: z.union([z.literal("required"), z.literal("optional")])
+});
+var { schemas, factory } = createType({
+  rawSchema: rawRuntimeDependency,
+  internalSchema: rawRuntimeDependency,
+  parseErrMsg: (value) => `The following runtime dependency is invalid: ${value}`,
+  unknownErrMsg: "Something went wrong trying to parse the template"
+});
+var runtimeDependencyReport = rawRuntimeDependency.extend({ met: z.boolean() });
+var dependenciesResponseSchema = z.object({
+  report: z.array(runtimeDependencyReport)
+});
+var { of, make, create } = factory;
+export {
+  create,
+  factory,
+  make,
+  of,
+  schemas
+};
+//# sourceMappingURL=PluginDependenciesResponse.mjs.map

package/PluginDependenciesResponse.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["PluginDependenciesResponse.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nconst rawRuntimeDependency = z.object({\n\tname: z.string(),\n\tpath: z.string(),\n\tversion: z.string(),\n\tkind: z.union([z.literal('required'), z.literal('optional')]),\n});\n\ntype RawRuntimeDependencyInput = z.infer<typeof rawRuntimeDependency>;\n\nexport const { schemas, factory } = createType<RawRuntimeDependencyInput, RawRuntimeDependencyInput>({\n\trawSchema: rawRuntimeDependency,\n\tinternalSchema: rawRuntimeDependency,\n\tparseErrMsg: (value: unknown) => `The following runtime dependency is invalid: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse the template',\n});\n\nexport type RuntimeDependency = z.infer<typeof schemas.schema>;\n\nconst runtimeDependencyReport = rawRuntimeDependency.extend({ met: z.boolean() });\n\nexport type RuntimeDependencyReport = z.infer<typeof runtimeDependencyReport>;\n\nconst dependenciesResponseSchema = z.object({\n\treport: z.array(runtimeDependencyReport),\n});\n\nexport type PluginDependenciesResponse = z.infer<typeof dependenciesResponseSchema>;\nexport type t = PluginDependenciesResponse;\n\nexport const { of, make, create } = factory;\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,SAAS,SAAS;AAElB,IAAM,uBAAuB,EAAE,OAAO;AAAA,EACrC,MAAM,EAAE,OAAO;AAAA,EACf,MAAM,EAAE,OAAO;AAAA,EACf,SAAS,EAAE,OAAO;AAAA,EAClB,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,UAAU,GAAG,EAAE,QAAQ,UAAU,CAAC,CAAC;AAC7D,CAAC;AAIM,IAAM,EAAE,SAAS,QAAQ,IAAI,WAAiE;AAAA,EACpG,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,aAAa,CAAC,UAAmB,gDAAgD;AAAA,EACjF,eAAe;AAChB,CAAC;AAID,IAAM,0BAA0B,qBAAqB,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;AAIhF,IAAM,6BAA6B,EAAE,OAAO;AAAA,EAC3C,QAAQ,EAAE,MAAM,uBAAuB;AACxC,CAAC;AAKM,IAAM,EAAE,IAAI,MAAM,OAAO,IAAI;","names":[]}