@taqueria/protocol 0.24.2 → 0.25.3-alpha

package/RequestArgs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RequestArgs.d.ts","sourceRoot":"","sources":["RequestArgs.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6BxB,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK/C,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAClE,MAAM,MAAM,CAAC,GAAG,WAAW,CAAC;AAE5B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC;AAuBF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"RequestArgs.d.ts","sourceRoot":"","sources":["RequestArgs.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAC"}

package/RequestArgs.js

@@ -1,136 +1,21 @@
 "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, from2, except, desc) => {
-  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-    for (let key of __getOwnPropNames(from2))
+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: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+        __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // RequestArgs.ts
 var RequestArgs_exports = {};
-__export(RequestArgs_exports, {
-  create: () => create,
-  createProxyRequestArgs: () => createProxyRequestArgs,
-  createProxyTemplateRequestArgs: () => createProxyTemplateRequestArgs,
-  factory: () => factory,
-  from: () => from,
-  generatedSchemas: () => generatedSchemas,
-  make: () => make,
-  makeProxyRequestArgs: () => makeProxyRequestArgs,
-  makeProxyTemplateRequestArgs: () => makeProxyTemplateRequestArgs,
-  of: () => of,
-  ofProxyRequestArgs: () => ofProxyRequestArgs,
-  ofProxyTemplateRequestArgs: () => ofProxyTemplateRequestArgs,
-  proxy: () => proxy,
-  proxyFactory: () => proxyFactory,
-  proxySchemas: () => proxySchemas,
-  proxyTemplate: () => proxyTemplate,
-  schemas: () => schemas2
-});
 module.exports = __toCommonJS(RequestArgs_exports);
-var import_Base = __toESM(require("@taqueria/protocol/Base"));
-var LoadedConfig = __toESM(require("@taqueria/protocol/LoadedConfig"));
-var import_SanitizedArgs = require("@taqueria/protocol/SanitizedArgs");
-var import_zod = require("zod");
-var taqRunSchema = import_zod.z.union([
-  import_zod.z.literal("pluginInfo"),
-  import_zod.z.literal("proxy"),
-  import_zod.z.literal("checkRuntimeDependencies"),
-  import_zod.z.literal("installRuntimeDependencies"),
-  import_zod.z.literal("proxyTemplate")
-]);
-var rawSchema2 = import_SanitizedArgs.rawSchema.extend({
-  taqRun: taqRunSchema,
-  config: import_zod.z.preprocess(
-    (val) => typeof val === "string" ? JSON.parse(val) : val,
-    LoadedConfig.rawSchema
-  )
-}).describe("RequestArgs").passthrough();
-var internalSchema = import_SanitizedArgs.rawSchema.extend({
-  taqRun: taqRunSchema,
-  config: import_zod.z.preprocess(
-    (val) => typeof val === "string" ? JSON.parse(val) : val,
-    LoadedConfig.schemas.schema
-  )
-}).describe("RequestArgs").passthrough();
-var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
-  rawSchema: rawSchema2,
-  internalSchema,
-  parseErrMsg: "The request is invalid",
-  unknownErrMsg: "Something went wrong trying to parse the request"
-});
-var schemas2 = {
-  ...generatedSchemas,
-  schema: generatedSchemas.schema.transform((val) => val)
-};
-var rawProxyTaskSchema = rawSchema2.extend({
-  task: import_zod.z.string().min(1)
-}).describe("ProxyRequestArgs").passthrough();
-var internalProxyTaskSchema = internalSchema.extend({
-  task: import_zod.z.string().min(1)
-}).describe("ProxyRequestArgs").passthrough();
-var rawProxyTemplateSchema = rawSchema2.extend({
-  template: import_zod.z.string().min(1)
-});
-var internalProxyTemplateSchema = rawSchema2.extend({
-  template: import_zod.z.string().min(1)
-});
-var proxy = (0, import_Base.default)({
-  rawSchema: rawProxyTaskSchema,
-  internalSchema: internalProxyTaskSchema,
-  parseErrMsg: "The request is invalid",
-  unknownErrMsg: "Something went wrong trying to parse the request"
-});
-var proxyTemplate = (0, import_Base.default)({
-  rawSchema: rawProxyTemplateSchema,
-  internalSchema: internalProxyTemplateSchema,
-  parseErrMsg: "The request is invalid",
-  unknownErrMsg: "Something went wrong trying to parse the request"
-});
-var proxySchemas = proxy.schemas;
-var proxyFactory = proxy.factory;
-var createProxyRequestArgs = proxyFactory.from;
-var makeProxyRequestArgs = proxyFactory.make;
-var ofProxyRequestArgs = proxyFactory.of;
-var createProxyTemplateRequestArgs = proxyTemplate.factory.from;
-var makeProxyTemplateRequestArgs = proxyTemplate.factory.make;
-var ofProxyTemplateRequestArgs = proxyTemplate.factory.of;
-var { create, make, of, from } = factory;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  createProxyRequestArgs,
-  createProxyTemplateRequestArgs,
-  factory,
-  from,
-  generatedSchemas,
-  make,
-  makeProxyRequestArgs,
-  makeProxyTemplateRequestArgs,
-  of,
-  ofProxyRequestArgs,
-  ofProxyTemplateRequestArgs,
-  proxy,
-  proxyFactory,
-  proxySchemas,
-  proxyTemplate,
-  schemas
-});
+__reExport(RequestArgs_exports, require("@taqueria/protocol/out/types/RequestArgs"), module.exports);
 //# sourceMappingURL=RequestArgs.js.map

package/RequestArgs.js.map

@@ -1 +1 @@
-{"version":3,"sources":["RequestArgs.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as LoadedConfig from '@taqueria/protocol/LoadedConfig';\nimport { rawSchema as sanitizedArgsSchema } from '@taqueria/protocol/SanitizedArgs';\nimport { z } from 'zod';\n\nconst taqRunSchema = z.union([\n\tz.literal('pluginInfo'),\n\tz.literal('proxy'),\n\tz.literal('checkRuntimeDependencies'),\n\tz.literal('installRuntimeDependencies'),\n\tz.literal('proxyTemplate'),\n]);\n\nconst rawSchema = sanitizedArgsSchema.extend({\n\ttaqRun: taqRunSchema,\n\tconfig: z.preprocess(\n\t\tval => typeof val === 'string' ? JSON.parse(val) : val,\n\t\tLoadedConfig.rawSchema,\n\t),\n}).describe('RequestArgs').passthrough();\n\nconst internalSchema = sanitizedArgsSchema.extend({\n\ttaqRun: taqRunSchema,\n\tconfig: z.preprocess(\n\t\tval => typeof val === 'string' ? JSON.parse(val) : val,\n\t\tLoadedConfig.schemas.schema,\n\t),\n}).describe('RequestArgs').passthrough();\n\ntype RawInput = z.infer<typeof rawSchema>;\ntype Input = z.infer<typeof internalSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport type RequestArgs = z.infer<typeof generatedSchemas.schema>;\nexport type t = RequestArgs;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as RequestArgs),\n};\n\nconst rawProxyTaskSchema = rawSchema.extend({\n\ttask: z.string().min(1),\n}).describe('ProxyRequestArgs').passthrough();\n\nconst internalProxyTaskSchema = internalSchema.extend({\n\ttask: z.string().min(1),\n}).describe('ProxyRequestArgs').passthrough();\n\nconst rawProxyTemplateSchema = rawSchema.extend({\n\ttemplate: z.string().min(1),\n});\n\nconst internalProxyTemplateSchema = rawSchema.extend({\n\ttemplate: z.string().min(1),\n});\n\ntype RawProxyInput = z.infer<typeof rawProxyTaskSchema>;\ntype ProxyInput = z.infer<typeof internalProxyTaskSchema>;\ntype RawProxyTemplateInput = z.infer<typeof rawProxyTemplateSchema>;\ntype ProxyTemplateInput = z.infer<typeof internalProxyTemplateSchema>;\n\nexport const proxy = createType<RawProxyInput, ProxyInput>({\n\trawSchema: rawProxyTaskSchema,\n\tinternalSchema: internalProxyTaskSchema,\n\tparseErrMsg: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport const proxyTemplate = createType<RawProxyTemplateInput, ProxyTemplateInput>({\n\trawSchema: rawProxyTemplateSchema,\n\tinternalSchema: internalProxyTemplateSchema,\n\tparseErrMsg: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport const proxySchemas = proxy.schemas;\nexport const proxyFactory = proxy.factory;\n\nexport type ProxyRequestArgs = z.infer<typeof proxySchemas.schema>;\nexport type ProxyTemplateRequestArgs = z.infer<typeof proxyTemplate.schemas.schema>;\n\nexport const createProxyRequestArgs = proxyFactory.from;\nexport const makeProxyRequestArgs = proxyFactory.make;\nexport const ofProxyRequestArgs = proxyFactory.of;\n\nexport const createProxyTemplateRequestArgs = proxyTemplate.factory.from;\nexport const makeProxyTemplateRequestArgs = proxyTemplate.factory.make;\nexport const ofProxyTemplateRequestArgs = proxyTemplate.factory.of;\n\nexport const { create, make, of, from } = factory;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,mBAA8B;AAC9B,2BAAiD;AACjD,iBAAkB;AAElB,IAAM,eAAe,aAAE,MAAM;AAAA,EAC5B,aAAE,QAAQ,YAAY;AAAA,EACtB,aAAE,QAAQ,OAAO;AAAA,EACjB,aAAE,QAAQ,0BAA0B;AAAA,EACpC,aAAE,QAAQ,4BAA4B;AAAA,EACtC,aAAE,QAAQ,eAAe;AAC1B,CAAC;AAED,IAAMC,aAAY,qBAAAC,UAAoB,OAAO;AAAA,EAC5C,QAAQ;AAAA,EACR,QAAQ,aAAE;AAAA,IACT,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAI;AAAA,IACtC;AAAA,EACd;AACD,CAAC,EAAE,SAAS,aAAa,EAAE,YAAY;AAEvC,IAAM,iBAAiB,qBAAAA,UAAoB,OAAO;AAAA,EACjD,QAAQ;AAAA,EACR,QAAQ,aAAE;AAAA,IACT,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAI;AAAA,IACtC,qBAAQ;AAAA,EACtB;AACD,CAAC,EAAE,SAAS,aAAa,EAAE,YAAY;AAKhC,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAC,SAA4B;AAAA,EACjF,WAAAF;AAAA,EACA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAKM,IAAMD,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAkB;AACpE;AAEA,IAAM,qBAAqBC,WAAU,OAAO;AAAA,EAC3C,MAAM,aAAE,OAAO,EAAE,IAAI,CAAC;AACvB,CAAC,EAAE,SAAS,kBAAkB,EAAE,YAAY;AAE5C,IAAM,0BAA0B,eAAe,OAAO;AAAA,EACrD,MAAM,aAAE,OAAO,EAAE,IAAI,CAAC;AACvB,CAAC,EAAE,SAAS,kBAAkB,EAAE,YAAY;AAE5C,IAAM,yBAAyBA,WAAU,OAAO;AAAA,EAC/C,UAAU,aAAE,OAAO,EAAE,IAAI,CAAC;AAC3B,CAAC;AAED,IAAM,8BAA8BA,WAAU,OAAO;AAAA,EACpD,UAAU,aAAE,OAAO,EAAE,IAAI,CAAC;AAC3B,CAAC;AAOM,IAAM,YAAQ,YAAAE,SAAsC;AAAA,EAC1D,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAEM,IAAM,oBAAgB,YAAAA,SAAsD;AAAA,EAClF,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAEM,IAAM,eAAe,MAAM;AAC3B,IAAM,eAAe,MAAM;AAK3B,IAAM,yBAAyB,aAAa;AAC5C,IAAM,uBAAuB,aAAa;AAC1C,IAAM,qBAAqB,aAAa;AAExC,IAAM,iCAAiC,cAAc,QAAQ;AAC7D,IAAM,+BAA+B,cAAc,QAAQ;AAC3D,IAAM,6BAA6B,cAAc,QAAQ;AAEzD,IAAM,EAAE,QAAQ,MAAM,IAAI,KAAK,IAAI;","names":["schemas","rawSchema","sanitizedArgsSchema","createType"]}
+{"version":3,"sources":["RequestArgs.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/RequestArgs';\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,gCAAc,qDAAd;","names":[]}

package/RequestArgs.mjs

@@ -1,89 +1,3 @@
 // RequestArgs.ts
-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";
-var taqRunSchema = z.union([
-  z.literal("pluginInfo"),
-  z.literal("proxy"),
-  z.literal("checkRuntimeDependencies"),
-  z.literal("installRuntimeDependencies"),
-  z.literal("proxyTemplate")
-]);
-var rawSchema2 = sanitizedArgsSchema.extend({
-  taqRun: taqRunSchema,
-  config: z.preprocess(
-    (val) => typeof val === "string" ? JSON.parse(val) : val,
-    LoadedConfig.rawSchema
-  )
-}).describe("RequestArgs").passthrough();
-var internalSchema = sanitizedArgsSchema.extend({
-  taqRun: taqRunSchema,
-  config: z.preprocess(
-    (val) => typeof val === "string" ? JSON.parse(val) : val,
-    LoadedConfig.schemas.schema
-  )
-}).describe("RequestArgs").passthrough();
-var { schemas: generatedSchemas, factory } = createType({
-  rawSchema: rawSchema2,
-  internalSchema,
-  parseErrMsg: "The request is invalid",
-  unknownErrMsg: "Something went wrong trying to parse the request"
-});
-var schemas2 = {
-  ...generatedSchemas,
-  schema: generatedSchemas.schema.transform((val) => val)
-};
-var rawProxyTaskSchema = rawSchema2.extend({
-  task: z.string().min(1)
-}).describe("ProxyRequestArgs").passthrough();
-var internalProxyTaskSchema = internalSchema.extend({
-  task: z.string().min(1)
-}).describe("ProxyRequestArgs").passthrough();
-var rawProxyTemplateSchema = rawSchema2.extend({
-  template: z.string().min(1)
-});
-var internalProxyTemplateSchema = rawSchema2.extend({
-  template: z.string().min(1)
-});
-var proxy = createType({
-  rawSchema: rawProxyTaskSchema,
-  internalSchema: internalProxyTaskSchema,
-  parseErrMsg: "The request is invalid",
-  unknownErrMsg: "Something went wrong trying to parse the request"
-});
-var proxyTemplate = createType({
-  rawSchema: rawProxyTemplateSchema,
-  internalSchema: internalProxyTemplateSchema,
-  parseErrMsg: "The request is invalid",
-  unknownErrMsg: "Something went wrong trying to parse the request"
-});
-var proxySchemas = proxy.schemas;
-var proxyFactory = proxy.factory;
-var createProxyRequestArgs = proxyFactory.from;
-var makeProxyRequestArgs = proxyFactory.make;
-var ofProxyRequestArgs = proxyFactory.of;
-var createProxyTemplateRequestArgs = proxyTemplate.factory.from;
-var makeProxyTemplateRequestArgs = proxyTemplate.factory.make;
-var ofProxyTemplateRequestArgs = proxyTemplate.factory.of;
-var { create, make, of, from } = factory;
-export {
-  create,
-  createProxyRequestArgs,
-  createProxyTemplateRequestArgs,
-  factory,
-  from,
-  generatedSchemas,
-  make,
-  makeProxyRequestArgs,
-  makeProxyTemplateRequestArgs,
-  of,
-  ofProxyRequestArgs,
-  ofProxyTemplateRequestArgs,
-  proxy,
-  proxyFactory,
-  proxySchemas,
-  proxyTemplate,
-  schemas2 as schemas
-};
+export * from "@taqueria/protocol/out/types/RequestArgs";
 //# sourceMappingURL=RequestArgs.mjs.map

package/RequestArgs.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["RequestArgs.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as LoadedConfig from '@taqueria/protocol/LoadedConfig';\nimport { rawSchema as sanitizedArgsSchema } from '@taqueria/protocol/SanitizedArgs';\nimport { z } from 'zod';\n\nconst taqRunSchema = z.union([\n\tz.literal('pluginInfo'),\n\tz.literal('proxy'),\n\tz.literal('checkRuntimeDependencies'),\n\tz.literal('installRuntimeDependencies'),\n\tz.literal('proxyTemplate'),\n]);\n\nconst rawSchema = sanitizedArgsSchema.extend({\n\ttaqRun: taqRunSchema,\n\tconfig: z.preprocess(\n\t\tval => typeof val === 'string' ? JSON.parse(val) : val,\n\t\tLoadedConfig.rawSchema,\n\t),\n}).describe('RequestArgs').passthrough();\n\nconst internalSchema = sanitizedArgsSchema.extend({\n\ttaqRun: taqRunSchema,\n\tconfig: z.preprocess(\n\t\tval => typeof val === 'string' ? JSON.parse(val) : val,\n\t\tLoadedConfig.schemas.schema,\n\t),\n}).describe('RequestArgs').passthrough();\n\ntype RawInput = z.infer<typeof rawSchema>;\ntype Input = z.infer<typeof internalSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport type RequestArgs = z.infer<typeof generatedSchemas.schema>;\nexport type t = RequestArgs;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as RequestArgs),\n};\n\nconst rawProxyTaskSchema = rawSchema.extend({\n\ttask: z.string().min(1),\n}).describe('ProxyRequestArgs').passthrough();\n\nconst internalProxyTaskSchema = internalSchema.extend({\n\ttask: z.string().min(1),\n}).describe('ProxyRequestArgs').passthrough();\n\nconst rawProxyTemplateSchema = rawSchema.extend({\n\ttemplate: z.string().min(1),\n});\n\nconst internalProxyTemplateSchema = rawSchema.extend({\n\ttemplate: z.string().min(1),\n});\n\ntype RawProxyInput = z.infer<typeof rawProxyTaskSchema>;\ntype ProxyInput = z.infer<typeof internalProxyTaskSchema>;\ntype RawProxyTemplateInput = z.infer<typeof rawProxyTemplateSchema>;\ntype ProxyTemplateInput = z.infer<typeof internalProxyTemplateSchema>;\n\nexport const proxy = createType<RawProxyInput, ProxyInput>({\n\trawSchema: rawProxyTaskSchema,\n\tinternalSchema: internalProxyTaskSchema,\n\tparseErrMsg: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport const proxyTemplate = createType<RawProxyTemplateInput, ProxyTemplateInput>({\n\trawSchema: rawProxyTemplateSchema,\n\tinternalSchema: internalProxyTemplateSchema,\n\tparseErrMsg: 'The request is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the request',\n});\n\nexport const proxySchemas = proxy.schemas;\nexport const proxyFactory = proxy.factory;\n\nexport type ProxyRequestArgs = z.infer<typeof proxySchemas.schema>;\nexport type ProxyTemplateRequestArgs = z.infer<typeof proxyTemplate.schemas.schema>;\n\nexport const createProxyRequestArgs = proxyFactory.from;\nexport const makeProxyRequestArgs = proxyFactory.make;\nexport const ofProxyRequestArgs = proxyFactory.of;\n\nexport const createProxyTemplateRequestArgs = proxyTemplate.factory.from;\nexport const makeProxyTemplateRequestArgs = proxyTemplate.factory.make;\nexport const ofProxyTemplateRequestArgs = proxyTemplate.factory.of;\n\nexport const { create, make, of, from } = factory;\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,YAAY,kBAAkB;AAC9B,SAAS,aAAa,2BAA2B;AACjD,SAAS,SAAS;AAElB,IAAM,eAAe,EAAE,MAAM;AAAA,EAC5B,EAAE,QAAQ,YAAY;AAAA,EACtB,EAAE,QAAQ,OAAO;AAAA,EACjB,EAAE,QAAQ,0BAA0B;AAAA,EACpC,EAAE,QAAQ,4BAA4B;AAAA,EACtC,EAAE,QAAQ,eAAe;AAC1B,CAAC;AAED,IAAMA,aAAY,oBAAoB,OAAO;AAAA,EAC5C,QAAQ;AAAA,EACR,QAAQ,EAAE;AAAA,IACT,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAI;AAAA,IACtC;AAAA,EACd;AACD,CAAC,EAAE,SAAS,aAAa,EAAE,YAAY;AAEvC,IAAM,iBAAiB,oBAAoB,OAAO;AAAA,EACjD,QAAQ;AAAA,EACR,QAAQ,EAAE;AAAA,IACT,SAAO,OAAO,QAAQ,WAAW,KAAK,MAAM,GAAG,IAAI;AAAA,IACtC,qBAAQ;AAAA,EACtB;AACD,CAAC,EAAE,SAAS,aAAa,EAAE,YAAY;AAKhC,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA4B;AAAA,EACjF,WAAAA;AAAA,EACA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAKM,IAAMC,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAkB;AACpE;AAEA,IAAM,qBAAqBD,WAAU,OAAO;AAAA,EAC3C,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AACvB,CAAC,EAAE,SAAS,kBAAkB,EAAE,YAAY;AAE5C,IAAM,0BAA0B,eAAe,OAAO;AAAA,EACrD,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC;AACvB,CAAC,EAAE,SAAS,kBAAkB,EAAE,YAAY;AAE5C,IAAM,yBAAyBA,WAAU,OAAO;AAAA,EAC/C,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC;AAC3B,CAAC;AAED,IAAM,8BAA8BA,WAAU,OAAO;AAAA,EACpD,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC;AAC3B,CAAC;AAOM,IAAM,QAAQ,WAAsC;AAAA,EAC1D,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAEM,IAAM,gBAAgB,WAAsD;AAAA,EAClF,WAAW;AAAA,EACX,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAEM,IAAM,eAAe,MAAM;AAC3B,IAAM,eAAe,MAAM;AAK3B,IAAM,yBAAyB,aAAa;AAC5C,IAAM,uBAAuB,aAAa;AAC1C,IAAM,qBAAqB,aAAa;AAExC,IAAM,iCAAiC,cAAc,QAAQ;AAC7D,IAAM,+BAA+B,cAAc,QAAQ;AAC3D,IAAM,6BAA6B,cAAc,QAAQ;AAEzD,IAAM,EAAE,QAAQ,MAAM,IAAI,KAAK,IAAI;","names":["rawSchema","schemas"]}
+{"version":3,"sources":["RequestArgs.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/RequestArgs';\n"],"mappings":";AAAA,cAAc;","names":[]}

package/SHA256.d.ts

@@ -1,29 +1,37 @@
 import { TaqError } from '@taqueria/protocol/TaqError';
 import { FutureInstance as Future } from 'fluture';
 import { z } from 'zod';
+interface SubtleCrypto {
+    digest(method: 'SHA-256', data: Uint8Array): ArrayBuffer;
+}
+export declare class Crypto {
+    subtle: SubtleCrypto;
+    constructor();
+}
 export declare const rawSchema: z.ZodString;
 export declare const toSHA256: (value: string) => Promise<string & {
-    readonly __kind: any;
+    readonly __type: any;
 }>;
 export declare const internalSchema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
-    readonly __kind: any;
+    readonly __type: any;
 }, any>;
 export type SHA256 = z.infer<typeof internalSchema>;
 export type t = SHA256;
 export declare const create: (input: string) => string & {
-    readonly __kind: any;
+    readonly __type: any;
 }, of: (input: unknown) => Future<TaqError, string & {
-    readonly __kind: any;
+    readonly __type: any;
 }>, make: (input: string) => Future<TaqError, string & {
-    readonly __kind: any;
+    readonly __type: any;
 }>;
 export declare const schemas: {
     schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
-        readonly __kind: any;
+        readonly __type: any;
     }, any>, string & {
-        readonly __kind: any;
+        readonly __type: any;
     }, any>;
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
+export {};
 //# sourceMappingURL=SHA256.d.ts.map

package/SHA256.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SHA256.d.ts","sourceRoot":"","sources":["SHA256.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,cAAc,IAAI,MAAM,EAAmB,MAAM,SAAS,CAAC;AAEpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,SAAS,aAAiD,CAAC;AAWxE,eAAO,MAAM,QAAQ,UAAiB,MAAM;;EAQ3C,CAAC;AAEF,eAAO,MAAM,cAAc;;OAA0B,CAAC;AAEtD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACpD,MAAM,MAAM,CAAC,GAAG,MAAM,CAAC;AACvB,eAAO,MAAQ,MAAM;;GAAE,EAAE;;IAAE,IAAI;;EAAY,CAAC;AAC5C,eAAO,MAAM,OAAO;;;;;;;;CAGnB,CAAC"}
+{"version":3,"file":"SHA256.d.ts","sourceRoot":"","sources":["SHA256.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,cAAc,IAAI,MAAM,EAAmB,MAAM,SAAS,CAAC;AAGpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,UAAU,YAAY;IACrB,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,WAAW,CAAC;CACzD;AACD,qBAAa,MAAM;IAClB,MAAM,EAAE,YAAY,CAAC;;CAQrB;AAcD,eAAO,MAAM,SAAS,aAAiD,CAAC;AAWxE,eAAO,MAAM,QAAQ,UAAiB,MAAM;;EAO3C,CAAC;AAEF,eAAO,MAAM,cAAc;;OAA0B,CAAC;AAEtD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACpD,MAAM,MAAM,CAAC,GAAG,MAAM,CAAC;AACvB,eAAO,MAAQ,MAAM;;GAAE,EAAE;;IAAE,IAAI;;EAAY,CAAC;AAC5C,eAAO,MAAM,OAAO;;;;;;;;CAGnB,CAAC"}

package/SHA256.js

@@ -26,6 +26,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // SHA256.ts
 var SHA256_exports = {};
 __export(SHA256_exports, {
+  Crypto: () => Crypto,
   create: () => create,
   internalSchema: () => internalSchema,
   make: () => make,
@@ -35,15 +36,32 @@ __export(SHA256_exports, {
   toSHA256: () => toSHA256
 });
 module.exports = __toCommonJS(SHA256_exports);
-var import_webcrypto = require("@peculiar/webcrypto");
 var import_Base = __toESM(require("@taqueria/protocol/Base"));
 var import_TaqError = require("@taqueria/protocol/TaqError");
 var import_fluture = require("fluture");
+var import_rambda = require("rambda");
 var import_util = require("util");
 var import_zod = require("zod");
 var eager = (f) => (0, import_fluture.promise)(
   (0, import_fluture.mapRej)((err) => new import_TaqError.E_TaqError(err))(f)
 );
+var Crypto = class {
+  constructor() {
+    this.subtle = {
+      digest(_method, _data) {
+        return new ArrayBuffer(50);
+      }
+    };
+  }
+};
+var getSubtleCrypto = async () => {
+  if ((0, import_rambda.has)("SubtleCrypto", globalThis)) {
+    return Promise.resolve(crypto.subtle);
+  }
+  const { Crypto: Crypto2 } = await import("@peculiar/webcrypto");
+  const webcrypto = new Crypto2();
+  return Promise.resolve(webcrypto.subtle);
+};
 var rawSchema = import_zod.z.string({ description: "SHA256" }).length(64);
 var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
   isStringLike: true,
@@ -54,8 +72,7 @@ var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
 var toSHA256 = async (value) => {
   const encoder = new import_util.TextEncoder();
   const data = encoder.encode(value);
-  const crypto = new import_webcrypto.Crypto();
-  const hash = await crypto.subtle.digest("SHA-256", data);
+  const hash = await (await getSubtleCrypto()).digest("SHA-256", data);
   const hashArray = Array.from(new Uint8Array(hash));
   const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
   return eager(factory.make(hashHex));
@@ -68,6 +85,7 @@ var schemas = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Crypto,
   create,
   internalSchema,
   make,

package/SHA256.js.map

@@ -1 +1 @@
-{"version":3,"sources":["SHA256.ts"],"sourcesContent":["import { Crypto } from '@peculiar/webcrypto';\nimport createType from '@taqueria/protocol/Base';\nimport { E_TaqError, TaqError } from '@taqueria/protocol/TaqError';\nimport { FutureInstance as Future, mapRej, promise } from 'fluture';\nimport { TextEncoder } from 'util';\nimport { z } from 'zod';\n\nconst eager = <T>(f: Future<TaqError, T>) =>\n\tpromise(\n\t\tmapRej((err: TaqError) => new E_TaqError(err))(f),\n\t);\n\nexport const rawSchema = z.string({ description: 'SHA256' }).length(64);\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nconst { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({\n\tisStringLike: true,\n\trawSchema,\n\tparseErrMsg: (value: unknown) => `${value} is an invalid SHA256 hash`,\n\tunknownErrMsg: (value: unknown) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`,\n});\n\nexport const toSHA256 = async (value: string) => {\n\tconst encoder = new TextEncoder();\n\tconst data = encoder.encode(value);\n\tconst crypto = new Crypto();\n\tconst hash = await crypto.subtle.digest('SHA-256', data);\n\tconst hashArray = Array.from(new Uint8Array(hash)); // convert buffer to byte array\n\tconst hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');\n\treturn eager(factory.make(hashHex));\n};\n\nexport const internalSchema = generatedSchemas.schema;\n\nexport type SHA256 = z.infer<typeof internalSchema>;\nexport type t = SHA256;\nexport const { create, of, make } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as SHA256),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAuB;AACvB,kBAAuB;AACvB,sBAAqC;AACrC,qBAA0D;AAC1D,kBAA4B;AAC5B,iBAAkB;AAElB,IAAM,QAAQ,CAAI,UACjB;AAAA,MACC,uBAAO,CAAC,QAAkB,IAAI,2BAAW,GAAG,CAAC,EAAE,CAAC;AACjD;AAEM,IAAM,YAAY,aAAE,OAAO,EAAE,aAAa,SAAS,CAAC,EAAE,OAAO,EAAE;AAItE,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAA,SAA+B;AAAA,EAC7E,cAAc;AAAA,EACd;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe,CAAC,UAAmB,yEAAyE;AAC7G,CAAC;AAEM,IAAM,WAAW,OAAO,UAAkB;AAChD,QAAM,UAAU,IAAI,wBAAY;AAChC,QAAM,OAAO,QAAQ,OAAO,KAAK;AACjC,QAAM,SAAS,IAAI,wBAAO;AAC1B,QAAM,OAAO,MAAM,OAAO,OAAO,OAAO,WAAW,IAAI;AACvD,QAAM,YAAY,MAAM,KAAK,IAAI,WAAW,IAAI,CAAC;AACjD,QAAM,UAAU,UAAU,IAAI,OAAK,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAC3E,SAAO,MAAM,QAAQ,KAAK,OAAO,CAAC;AACnC;AAEO,IAAM,iBAAiB,iBAAiB;AAIxC,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAC7B,IAAM,UAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAa;AAC/D;","names":["createType"]}
+{"version":3,"sources":["SHA256.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { E_TaqError, TaqError } from '@taqueria/protocol/TaqError';\nimport { FutureInstance as Future, mapRej, promise } from 'fluture';\nimport { has } from 'rambda';\nimport { TextEncoder } from 'util';\nimport { z } from 'zod';\n\nconst eager = <T>(f: Future<TaqError, T>) =>\n\tpromise(\n\t\tmapRej((err: TaqError) => new E_TaqError(err))(f),\n\t);\n\n// Access to SubtleCrypto is different on NodeJS vs Deno\ninterface SubtleCrypto {\n\tdigest(method: 'SHA-256', data: Uint8Array): ArrayBuffer;\n}\nexport class Crypto {\n\tsubtle: SubtleCrypto;\n\tconstructor() {\n\t\tthis.subtle = {\n\t\t\tdigest(_method: 'SHA-256', _data: Uint8Array) {\n\t\t\t\treturn new ArrayBuffer(50);\n\t\t\t},\n\t\t};\n\t}\n}\n// deno-lint-ignore var\ndeclare var crypto: Crypto;\n\nconst getSubtleCrypto = async () => {\n\tif (has('SubtleCrypto', globalThis)) {\n\t\treturn Promise.resolve(crypto.subtle);\n\t}\n\n\tconst { Crypto } = await import('@peculiar/webcrypto');\n\tconst webcrypto = new Crypto();\n\treturn Promise.resolve(webcrypto.subtle);\n};\n\nexport const rawSchema = z.string({ description: 'SHA256' }).length(64);\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nconst { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({\n\tisStringLike: true,\n\trawSchema,\n\tparseErrMsg: (value: unknown) => `${value} is an invalid SHA256 hash`,\n\tunknownErrMsg: (value: unknown) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`,\n});\n\nexport const toSHA256 = async (value: string) => {\n\tconst encoder = new TextEncoder();\n\tconst data = encoder.encode(value);\n\tconst hash = await (await getSubtleCrypto()).digest('SHA-256', data);\n\tconst hashArray = Array.from(new Uint8Array(hash)); // convert buffer to byte array\n\tconst hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');\n\treturn eager(factory.make(hashHex));\n};\n\nexport const internalSchema = generatedSchemas.schema;\n\nexport type SHA256 = z.infer<typeof internalSchema>;\nexport type t = SHA256;\nexport const { create, of, make } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as SHA256),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,sBAAqC;AACrC,qBAA0D;AAC1D,oBAAoB;AACpB,kBAA4B;AAC5B,iBAAkB;AAElB,IAAM,QAAQ,CAAI,UACjB;AAAA,MACC,uBAAO,CAAC,QAAkB,IAAI,2BAAW,GAAG,CAAC,EAAE,CAAC;AACjD;AAMM,IAAM,SAAN,MAAa;AAAA,EAEnB,cAAc;AACb,SAAK,SAAS;AAAA,MACb,OAAO,SAAoB,OAAmB;AAC7C,eAAO,IAAI,YAAY,EAAE;AAAA,MAC1B;AAAA,IACD;AAAA,EACD;AACD;AAIA,IAAM,kBAAkB,YAAY;AACnC,UAAI,mBAAI,gBAAgB,UAAU,GAAG;AACpC,WAAO,QAAQ,QAAQ,OAAO,MAAM;AAAA,EACrC;AAEA,QAAM,EAAE,QAAAA,QAAO,IAAI,MAAM,OAAO;AAChC,QAAM,YAAY,IAAIA,QAAO;AAC7B,SAAO,QAAQ,QAAQ,UAAU,MAAM;AACxC;AAEO,IAAM,YAAY,aAAE,OAAO,EAAE,aAAa,SAAS,CAAC,EAAE,OAAO,EAAE;AAItE,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAC,SAA+B;AAAA,EAC7E,cAAc;AAAA,EACd;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe,CAAC,UAAmB,yEAAyE;AAC7G,CAAC;AAEM,IAAM,WAAW,OAAO,UAAkB;AAChD,QAAM,UAAU,IAAI,wBAAY;AAChC,QAAM,OAAO,QAAQ,OAAO,KAAK;AACjC,QAAM,OAAO,OAAO,MAAM,gBAAgB,GAAG,OAAO,WAAW,IAAI;AACnE,QAAM,YAAY,MAAM,KAAK,IAAI,WAAW,IAAI,CAAC;AACjD,QAAM,UAAU,UAAU,IAAI,OAAK,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAC3E,SAAO,MAAM,QAAQ,KAAK,OAAO,CAAC;AACnC;AAEO,IAAM,iBAAiB,iBAAiB;AAIxC,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAC7B,IAAM,UAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAa;AAC/D;","names":["Crypto","createType"]}

package/SHA256.mjs

@@ -1,13 +1,30 @@
 // SHA256.ts
-import { Crypto } from "@peculiar/webcrypto";
 import createType from "@taqueria/protocol/Base";
 import { E_TaqError } from "@taqueria/protocol/TaqError";
 import { mapRej, promise } from "fluture";
+import { has } from "rambda";
 import { TextEncoder } from "util";
 import { z } from "zod";
 var eager = (f) => promise(
   mapRej((err) => new E_TaqError(err))(f)
 );
+var Crypto = class {
+  constructor() {
+    this.subtle = {
+      digest(_method, _data) {
+        return new ArrayBuffer(50);
+      }
+    };
+  }
+};
+var getSubtleCrypto = async () => {
+  if (has("SubtleCrypto", globalThis)) {
+    return Promise.resolve(crypto.subtle);
+  }
+  const { Crypto: Crypto2 } = await import("@peculiar/webcrypto");
+  const webcrypto = new Crypto2();
+  return Promise.resolve(webcrypto.subtle);
+};
 var rawSchema = z.string({ description: "SHA256" }).length(64);
 var { schemas: generatedSchemas, factory } = createType({
   isStringLike: true,
@@ -18,8 +35,7 @@ var { schemas: generatedSchemas, factory } = createType({
 var toSHA256 = async (value) => {
   const encoder = new TextEncoder();
   const data = encoder.encode(value);
-  const crypto = new Crypto();
-  const hash = await crypto.subtle.digest("SHA-256", data);
+  const hash = await (await getSubtleCrypto()).digest("SHA-256", data);
   const hashArray = Array.from(new Uint8Array(hash));
   const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
   return eager(factory.make(hashHex));
@@ -31,6 +47,7 @@ var schemas = {
   schema: generatedSchemas.schema.transform((val) => val)
 };
 export {
+  Crypto,
   create,
   internalSchema,
   make,

package/SHA256.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["SHA256.ts"],"sourcesContent":["import { Crypto } from '@peculiar/webcrypto';\nimport createType from '@taqueria/protocol/Base';\nimport { E_TaqError, TaqError } from '@taqueria/protocol/TaqError';\nimport { FutureInstance as Future, mapRej, promise } from 'fluture';\nimport { TextEncoder } from 'util';\nimport { z } from 'zod';\n\nconst eager = <T>(f: Future<TaqError, T>) =>\n\tpromise(\n\t\tmapRej((err: TaqError) => new E_TaqError(err))(f),\n\t);\n\nexport const rawSchema = z.string({ description: 'SHA256' }).length(64);\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nconst { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({\n\tisStringLike: true,\n\trawSchema,\n\tparseErrMsg: (value: unknown) => `${value} is an invalid SHA256 hash`,\n\tunknownErrMsg: (value: unknown) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`,\n});\n\nexport const toSHA256 = async (value: string) => {\n\tconst encoder = new TextEncoder();\n\tconst data = encoder.encode(value);\n\tconst crypto = new Crypto();\n\tconst hash = await crypto.subtle.digest('SHA-256', data);\n\tconst hashArray = Array.from(new Uint8Array(hash)); // convert buffer to byte array\n\tconst hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');\n\treturn eager(factory.make(hashHex));\n};\n\nexport const internalSchema = generatedSchemas.schema;\n\nexport type SHA256 = z.infer<typeof internalSchema>;\nexport type t = SHA256;\nexport const { create, of, make } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as SHA256),\n};\n"],"mappings":";AAAA,SAAS,cAAc;AACvB,OAAO,gBAAgB;AACvB,SAAS,kBAA4B;AACrC,SAAmC,QAAQ,eAAe;AAC1D,SAAS,mBAAmB;AAC5B,SAAS,SAAS;AAElB,IAAM,QAAQ,CAAI,MACjB;AAAA,EACC,OAAO,CAAC,QAAkB,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;AACjD;AAEM,IAAM,YAAY,EAAE,OAAO,EAAE,aAAa,SAAS,CAAC,EAAE,OAAO,EAAE;AAItE,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA+B;AAAA,EAC7E,cAAc;AAAA,EACd;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe,CAAC,UAAmB,yEAAyE;AAC7G,CAAC;AAEM,IAAM,WAAW,OAAO,UAAkB;AAChD,QAAM,UAAU,IAAI,YAAY;AAChC,QAAM,OAAO,QAAQ,OAAO,KAAK;AACjC,QAAM,SAAS,IAAI,OAAO;AAC1B,QAAM,OAAO,MAAM,OAAO,OAAO,OAAO,WAAW,IAAI;AACvD,QAAM,YAAY,MAAM,KAAK,IAAI,WAAW,IAAI,CAAC;AACjD,QAAM,UAAU,UAAU,IAAI,OAAK,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAC3E,SAAO,MAAM,QAAQ,KAAK,OAAO,CAAC;AACnC;AAEO,IAAM,iBAAiB,iBAAiB;AAIxC,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAC7B,IAAM,UAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAa;AAC/D;","names":[]}
+{"version":3,"sources":["SHA256.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { E_TaqError, TaqError } from '@taqueria/protocol/TaqError';\nimport { FutureInstance as Future, mapRej, promise } from 'fluture';\nimport { has } from 'rambda';\nimport { TextEncoder } from 'util';\nimport { z } from 'zod';\n\nconst eager = <T>(f: Future<TaqError, T>) =>\n\tpromise(\n\t\tmapRej((err: TaqError) => new E_TaqError(err))(f),\n\t);\n\n// Access to SubtleCrypto is different on NodeJS vs Deno\ninterface SubtleCrypto {\n\tdigest(method: 'SHA-256', data: Uint8Array): ArrayBuffer;\n}\nexport class Crypto {\n\tsubtle: SubtleCrypto;\n\tconstructor() {\n\t\tthis.subtle = {\n\t\t\tdigest(_method: 'SHA-256', _data: Uint8Array) {\n\t\t\t\treturn new ArrayBuffer(50);\n\t\t\t},\n\t\t};\n\t}\n}\n// deno-lint-ignore var\ndeclare var crypto: Crypto;\n\nconst getSubtleCrypto = async () => {\n\tif (has('SubtleCrypto', globalThis)) {\n\t\treturn Promise.resolve(crypto.subtle);\n\t}\n\n\tconst { Crypto } = await import('@peculiar/webcrypto');\n\tconst webcrypto = new Crypto();\n\treturn Promise.resolve(webcrypto.subtle);\n};\n\nexport const rawSchema = z.string({ description: 'SHA256' }).length(64);\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nconst { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({\n\tisStringLike: true,\n\trawSchema,\n\tparseErrMsg: (value: unknown) => `${value} is an invalid SHA256 hash`,\n\tunknownErrMsg: (value: unknown) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`,\n});\n\nexport const toSHA256 = async (value: string) => {\n\tconst encoder = new TextEncoder();\n\tconst data = encoder.encode(value);\n\tconst hash = await (await getSubtleCrypto()).digest('SHA-256', data);\n\tconst hashArray = Array.from(new Uint8Array(hash)); // convert buffer to byte array\n\tconst hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');\n\treturn eager(factory.make(hashHex));\n};\n\nexport const internalSchema = generatedSchemas.schema;\n\nexport type SHA256 = z.infer<typeof internalSchema>;\nexport type t = SHA256;\nexport const { create, of, make } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as SHA256),\n};\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,SAAS,kBAA4B;AACrC,SAAmC,QAAQ,eAAe;AAC1D,SAAS,WAAW;AACpB,SAAS,mBAAmB;AAC5B,SAAS,SAAS;AAElB,IAAM,QAAQ,CAAI,MACjB;AAAA,EACC,OAAO,CAAC,QAAkB,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;AACjD;AAMM,IAAM,SAAN,MAAa;AAAA,EAEnB,cAAc;AACb,SAAK,SAAS;AAAA,MACb,OAAO,SAAoB,OAAmB;AAC7C,eAAO,IAAI,YAAY,EAAE;AAAA,MAC1B;AAAA,IACD;AAAA,EACD;AACD;AAIA,IAAM,kBAAkB,YAAY;AACnC,MAAI,IAAI,gBAAgB,UAAU,GAAG;AACpC,WAAO,QAAQ,QAAQ,OAAO,MAAM;AAAA,EACrC;AAEA,QAAM,EAAE,QAAAA,QAAO,IAAI,MAAM,OAAO;AAChC,QAAM,YAAY,IAAIA,QAAO;AAC7B,SAAO,QAAQ,QAAQ,UAAU,MAAM;AACxC;AAEO,IAAM,YAAY,EAAE,OAAO,EAAE,aAAa,SAAS,CAAC,EAAE,OAAO,EAAE;AAItE,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA+B;AAAA,EAC7E,cAAc;AAAA,EACd;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe,CAAC,UAAmB,yEAAyE;AAC7G,CAAC;AAEM,IAAM,WAAW,OAAO,UAAkB;AAChD,QAAM,UAAU,IAAI,YAAY;AAChC,QAAM,OAAO,QAAQ,OAAO,KAAK;AACjC,QAAM,OAAO,OAAO,MAAM,gBAAgB,GAAG,OAAO,WAAW,IAAI;AACnE,QAAM,YAAY,MAAM,KAAK,IAAI,WAAW,IAAI,CAAC;AACjD,QAAM,UAAU,UAAU,IAAI,OAAK,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAC3E,SAAO,MAAM,QAAQ,KAAK,OAAO,CAAC;AACnC;AAEO,IAAM,iBAAiB,iBAAiB;AAIxC,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAC7B,IAAM,UAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAa;AAC/D;","names":["Crypto"]}

package/SandboxAccountConfig.d.ts

@@ -1,145 +1,2 @@
-import { z } from 'zod';
-export declare const rawSchema: z.ZodObject<{
-    encryptedKey: z.ZodString;
-    publicKeyHash: z.ZodString;
-    secretKey: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    encryptedKey: string;
-    publicKeyHash: string;
-    secretKey: string;
-}, {
-    encryptedKey: string;
-    publicKeyHash: string;
-    secretKey: string;
-}>;
-export declare const generatedSchemas: {
-    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
-    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
-    schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
-        encryptedKey: string;
-        publicKeyHash: string & {
-            readonly __kind: any;
-        };
-        secretKey: string;
-    } & {
-        readonly __kind: any;
-    }, any>;
-}, factory: {
-    make: (input: {
-        encryptedKey: string;
-        publicKeyHash: string & {
-            readonly __kind: any;
-        };
-        secretKey: string;
-    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
-        encryptedKey: string;
-        publicKeyHash: string & {
-            readonly __kind: any;
-        };
-        secretKey: string;
-    } & {
-        readonly __kind: any;
-    }>;
-    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
-        encryptedKey: string;
-        publicKeyHash: string & {
-            readonly __kind: any;
-        };
-        secretKey: string;
-    } & {
-        readonly __kind: any;
-    }>;
-    create: (input: {
-        encryptedKey: string;
-        publicKeyHash: string & {
-            readonly __kind: any;
-        };
-        secretKey: string;
-    } | {
-        encryptedKey: string;
-        publicKeyHash: string;
-        secretKey: string;
-    }) => {
-        encryptedKey: string;
-        publicKeyHash: string & {
-            readonly __kind: any;
-        };
-        secretKey: string;
-    } & {
-        readonly __kind: any;
-    };
-    from: (input: unknown) => {
-        encryptedKey: string;
-        publicKeyHash: string & {
-            readonly __kind: any;
-        };
-        secretKey: string;
-    } & {
-        readonly __kind: any;
-    };
-};
-export type SandboxAccountConfig = z.infer<typeof generatedSchemas.schema>;
-export type t = SandboxAccountConfig;
-export declare const create: (input: {
-    encryptedKey: string;
-    publicKeyHash: string & {
-        readonly __kind: any;
-    };
-    secretKey: string;
-} | {
-    encryptedKey: string;
-    publicKeyHash: string;
-    secretKey: string;
-}) => {
-    encryptedKey: string;
-    publicKeyHash: string & {
-        readonly __kind: any;
-    };
-    secretKey: string;
-} & {
-    readonly __kind: any;
-}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
-    encryptedKey: string;
-    publicKeyHash: string & {
-        readonly __kind: any;
-    };
-    secretKey: string;
-} & {
-    readonly __kind: any;
-}>, make: (input: {
-    encryptedKey: string;
-    publicKeyHash: string & {
-        readonly __kind: any;
-    };
-    secretKey: string;
-}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
-    encryptedKey: string;
-    publicKeyHash: string & {
-        readonly __kind: any;
-    };
-    secretKey: string;
-} & {
-    readonly __kind: any;
-}>;
-export declare const schemas: {
-    schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
-        encryptedKey: string;
-        publicKeyHash: string & {
-            readonly __kind: any;
-        };
-        secretKey: string;
-    } & {
-        readonly __kind: any;
-    }, any>, {
-        encryptedKey: string;
-        publicKeyHash: string & {
-            readonly __kind: any;
-        };
-        secretKey: string;
-    } & {
-        readonly __kind: any;
-    }, any>;
-    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
-    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
-};
+export * from '@taqueria/protocol/out/types/SandboxAccountConfig';
 //# sourceMappingURL=SandboxAccountConfig.d.ts.map

package/SandboxAccountConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SandboxAccountConfig.d.ts","sourceRoot":"","sources":["SandboxAccountConfig.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,SAAS;;;;;;;;;;;;EAI8B,CAAC;AAMrD,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK/C,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAC3E,MAAM,MAAM,CAAC,GAAG,oBAAoB,CAAC;AACrC,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;GAAE,EAAE;;;;;;;;IAAE,IAAI;;;;;;;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC"}
+{"version":3,"file":"SandboxAccountConfig.d.ts","sourceRoot":"","sources":["SandboxAccountConfig.ts"],"names":[],"mappings":"AAAA,cAAc,mDAAmD,CAAC"}