@xyo-network/sdk-protocol 7.0.13 → 7.0.15

package/dist/node/payload-model.mjs

@@ -1,3 +1,452 @@
-// src/payload-model.ts
-export * from "@xyo-network/payload-model";
+// src/modules/payload-model/Error.ts
+import {
+  HashZod as HashZod2,
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory2
+} from "@ariestools/sdk";
+import * as z4 from "zod/mini";
+
+// src/modules/payload-model/PayloadZod.ts
+import {
+  HashZod,
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory
+} from "@ariestools/sdk";
+import * as z3 from "zod/mini";
+
+// src/modules/payload-model/Schema.ts
+import { zodAsFactory, zodIsFactory } from "@ariestools/sdk";
+import * as z from "zod/mini";
+var SchemaRegEx = /^(?:[a-z0-9]+\.)*[a-z0-9]+$/;
+var SchemaZod = z.pipe(z.string().check(z.regex(SchemaRegEx)), z.transform((v) => v));
+var makeSchema = (value) => {
+  return z.pipe(z.literal(value), z.transform((x) => x));
+};
+var isSchema = zodIsFactory(SchemaZod);
+var asSchema = zodAsFactory(SchemaZod, "asSchema");
+var toSchema = zodAsFactory(SchemaZod, "toSchema");
+var PayloadSchema = asSchema("network.xyo.payload", true);
+var PayloadSchemaZod = z.literal(PayloadSchema);
+
+// src/modules/payload-model/StorageMeta/Sequence.ts
+import { AsObjectFactory } from "@ariestools/sdk";
+var isSequenceStorageMeta = (value) => {
+  return value?._sequence != void 0;
+};
+var asSequenceStorageMeta = AsObjectFactory.create(isSequenceStorageMeta);
+var asOptionalSequenceStorageMeta = AsObjectFactory.createOptional(isSequenceStorageMeta);
+
+// src/modules/payload-model/StorageMeta/sequence/Parser.ts
+import {
+  assertEx,
+  isAddress,
+  toAddress,
+  toHex,
+  toUint8Array
+} from "@ariestools/sdk";
+
+// src/modules/payload-model/StorageMeta/sequence/Sequence.ts
+import { isHex } from "@ariestools/sdk";
+var isEpoch = (value) => {
+  return isHex(value) && value.length === SequenceConstants.epochBytes * 2;
+};
+var isNonce = (value) => {
+  return isHex(value) && value.length === SequenceConstants.nonceBytes * 2;
+};
+var isLocalSequence = (value) => {
+  return isHex(value) && value.length === SequenceConstants.localSequenceBytes * 2;
+};
+var isQualifiedSequence = (value) => {
+  return isHex(value) && value.length === SequenceConstants.qualifiedSequenceBytes * 2;
+};
+var isSequence = (value) => {
+  return isLocalSequence(value) || isQualifiedSequence(value);
+};
+var SequenceNonceComponentLengths = {
+  nonceIndexBytes: 4,
+  nonceHashBytes: 4
+};
+var SequenceComponentLengths = {
+  ...SequenceNonceComponentLengths,
+  epochBytes: 8,
+  nonceBytes: SequenceNonceComponentLengths.nonceIndexBytes + SequenceNonceComponentLengths.nonceHashBytes,
+  addressBytes: 20
+};
+var SequenceComponentMinMax = {
+  minEpoch: "0".repeat(SequenceComponentLengths.epochBytes * 2),
+  maxEpoch: "f".repeat(SequenceComponentLengths.epochBytes * 2),
+  minNonce: "0".repeat(SequenceComponentLengths.nonceBytes * 2),
+  maxNonce: "f".repeat(SequenceComponentLengths.nonceBytes * 2),
+  minAddress: "0".repeat(SequenceComponentLengths.addressBytes * 2),
+  maxAddress: "f".repeat(SequenceComponentLengths.addressBytes * 2)
+};
+var LocalSequenceConstants = {
+  ...SequenceComponentLengths,
+  ...SequenceComponentMinMax,
+  localSequenceBytes: SequenceComponentLengths.epochBytes + SequenceComponentLengths.nonceBytes,
+  minLocalSequence: SequenceComponentMinMax.minEpoch + SequenceComponentMinMax.minNonce,
+  maxLocalSequence: SequenceComponentMinMax.maxEpoch + SequenceComponentMinMax.maxNonce
+};
+var QualifiedSequenceConstants = {
+  qualifiedSequenceBytes: LocalSequenceConstants.localSequenceBytes + SequenceComponentLengths.addressBytes,
+  minQualifiedSequence: LocalSequenceConstants.minLocalSequence + SequenceComponentMinMax.minAddress,
+  maxQualifiedSequence: LocalSequenceConstants.maxLocalSequence + SequenceComponentMinMax.maxAddress
+};
+var SequenceConstants = {
+  ...LocalSequenceConstants,
+  ...QualifiedSequenceConstants
+};
+
+// src/modules/payload-model/StorageMeta/sequence/Parser.ts
+var SequenceParser = class _SequenceParser {
+  static privateConstructorKey = Date.now().toString();
+  data;
+  constructor(privateConstructorKey, hex) {
+    assertEx(_SequenceParser.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
+    const paddedHex = toHex(hex, {
+      prefix: false,
+      bitLength: SequenceConstants[hex.length <= SequenceConstants.localSequenceBytes * 2 ? "localSequenceBytes" : "qualifiedSequenceBytes"] * 8
+    });
+    this.data = toUint8Array(paddedHex);
+  }
+  static from(timestampOrSequence, nonceOrAddress, addressOrIndex, addressOnly) {
+    if (isSequence(timestampOrSequence)) {
+      if (nonceOrAddress) {
+        assertEx(!isQualifiedSequence(timestampOrSequence), () => "Providing both a qualified sequence and a address is not allowed");
+        assertEx(isAddress(nonceOrAddress), () => "Invalid address provided");
+        const combined = timestampOrSequence + nonceOrAddress;
+        return this.create(combined);
+      }
+      return this.create(timestampOrSequence);
+    }
+    const address = typeof addressOrIndex === "number" ? addressOnly : addressOrIndex;
+    const index = typeof addressOrIndex === "number" ? addressOrIndex : void 0;
+    const epoch = this.toEpoch(timestampOrSequence);
+    const nonce = nonceOrAddress === void 0 ? void 0 : this.toNonce(nonceOrAddress, index);
+    const addressHex = address ? toHex(address, { bitLength: SequenceConstants.addressBytes * 8 }) : SequenceConstants.minAddress;
+    const hexString = epoch + nonce + addressHex;
+    assertEx(isSequence(hexString), () => `Invalid sequence [${hexString}] [${epoch}, ${nonce}, ${addressHex}]`);
+    return this.create(hexString);
+  }
+  static parse(value) {
+    const hex = toHex(value);
+    if (isSequence(hex)) {
+      return this.create(hex);
+    }
+    throw new Error(`Invalid sequence [${hex}]`);
+  }
+  // can convert a short number/hex to an epoch (treats it as the whole value) or extract an epoch from a sequence
+  static toEpoch(value) {
+    assertEx(
+      typeof value !== "number" || Number.isSafeInteger(value),
+      () => "Value must be in integer"
+    );
+    const hex = toHex(value, { prefix: false });
+    if (hex.length <= SequenceConstants.epochBytes * 2) {
+      return toHex(value, { prefix: false, bitLength: SequenceConstants.epochBytes * 8 });
+    }
+    if (isSequence(hex)) {
+      return hex.slice(0, SequenceConstants.epochBytes * 2);
+    }
+    throw new Error(`Value could not be converted to epoch [${hex}]`);
+  }
+  // can convert a short number/hex to a nonce (treats it as the whole value) or extract an nonce from a sequence
+  static toNonce(value, index = 0) {
+    assertEx(
+      typeof value !== "number" || Number.isSafeInteger(value),
+      () => "Value must be in integer"
+    );
+    const hex = toHex(value, { prefix: false });
+    if (isSequence(hex)) {
+      return hex.slice(SequenceConstants.epochBytes * 2, SequenceConstants.localSequenceBytes * 2);
+    }
+    const hashHex = toHex(hex, { prefix: false, bitLength: SequenceConstants.nonceHashBytes * 8 }).slice(-SequenceConstants.nonceHashBytes * 2);
+    const indexHex = toHex(index, { prefix: false, bitLength: SequenceConstants.nonceIndexBytes * 8 }).slice(-SequenceConstants.nonceIndexBytes * 2);
+    return (indexHex + hashHex).slice(-SequenceConstants.nonceBytes * 2);
+  }
+  static create(hex) {
+    return new _SequenceParser(this.privateConstructorKey, hex);
+  }
+  get address() {
+    const start = SequenceConstants.localSequenceBytes;
+    const end = SequenceConstants.qualifiedSequenceBytes;
+    return toAddress(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get epoch() {
+    const start = 0;
+    const end = SequenceConstants.epochBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get localSequence() {
+    const start = 0;
+    const end = SequenceConstants.localSequenceBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get nonce() {
+    const start = SequenceConstants.epochBytes;
+    const end = SequenceConstants.localSequenceBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+  get qualifiedSequence() {
+    const start = 0;
+    const end = SequenceConstants.qualifiedSequenceBytes;
+    return toHex(this.data.slice(start, end).buffer, { prefix: false });
+  }
+};
+
+// src/modules/payload-model/StorageMeta/sequence/Comparer.ts
+var local = (a, b) => {
+  const aa = SequenceParser.from(a);
+  const bb = SequenceParser.from(b);
+  return aa.localSequence > bb.localSequence ? 1 : aa.localSequence < bb.localSequence ? -1 : 0;
+};
+var qualified = (a, b) => {
+  const aa = SequenceParser.from(a);
+  const bb = SequenceParser.from(b);
+  return aa.qualifiedSequence > bb.qualifiedSequence ? 1 : aa.qualifiedSequence < bb.qualifiedSequence ? -1 : 0;
+};
+var SequenceComparer = { local, qualified };
+
+// src/modules/payload-model/StorageMeta/sequence/SequenceZod.ts
+import { HexRegExMinMax, toHex as toHex2 } from "@ariestools/sdk";
+import * as z2 from "zod/mini";
+var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
+var LocalSequenceToStringZod = z2.string().check(z2.regex(LocalSequenceRegex));
+var LocalSequenceFromStringZod = z2.pipe(
+  z2.string().check(z2.regex(LocalSequenceRegex)),
+  z2.transform((v) => toHex2(v))
+);
+var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
+var QualifiedSequenceToStringZod = z2.string().check(z2.regex(QualifiedSequenceRegex));
+var QualifiedSequenceFromStringZod = z2.pipe(
+  z2.string().check(z2.regex(QualifiedSequenceRegex)),
+  z2.transform((v) => toHex2(v))
+);
+var SequenceToStringZod = z2.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
+var SequenceFromStringZod = z2.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
+
+// src/modules/payload-model/PayloadZod.ts
+var HashMetaZod = z3.object({
+  _hash: HashZod,
+  _dataHash: HashZod
+});
+var isHashMeta = zodIsFactory2(HashMetaZod);
+var asHashMeta = zodAsFactory2(HashMetaZod, "asHashMeta");
+var toHashMeta = zodToFactory(HashMetaZod, "toHashMeta");
+var SequenceMetaZod = z3.object({ _sequence: SequenceFromStringZod });
+var isSequenceMeta = zodIsFactory2(SequenceMetaZod);
+var asSequenceMeta = zodAsFactory2(SequenceMetaZod, "asSequenceMeta");
+var toSequenceMeta = zodToFactory(SequenceMetaZod, "toSequenceMeta");
+var StorageMetaZod = z3.object({
+  _hash: HashZod,
+  _dataHash: HashZod,
+  _sequence: SequenceFromStringZod
+});
+var isStorageMeta = zodIsFactory2(StorageMetaZod);
+var asStorageMeta = zodAsFactory2(StorageMetaZod, "asStorageMeta");
+var toStorageMeta = zodToFactory(StorageMetaZod, "toStorageMeta");
+var PayloadZod = z3.object({ schema: SchemaZod });
+var isPayload = zodIsFactory2(PayloadZod);
+var asPayload = zodAsFactory2(PayloadZod, "asPayload");
+var toPayload = zodToFactory(PayloadZod, "toPayload");
+var AnyPayloadZod = z3.looseObject({ schema: SchemaZod });
+var isAnyPayload = zodIsFactory2(AnyPayloadZod);
+var asAnyPayload = zodAsFactory2(AnyPayloadZod, "asAnyPayload");
+var toAnyPayload = zodToFactory(AnyPayloadZod, "toAnyPayload");
+function WithStorageMetaZod(valueZod) {
+  return z3.object({ ...valueZod.shape, ...StorageMetaZod.shape });
+}
+function WithHashMetaZod(valueZod) {
+  return z3.object({ ...valueZod.shape, ...HashMetaZod.shape });
+}
+var PayloadZodStrict = z3.strictObject({ schema: SchemaZod });
+var PayloadZodLoose = z3.looseObject({ schema: SchemaZod });
+var WithHashMetaPayloadZodLoose = z3.extend(PayloadZodLoose, HashMetaZod.shape);
+var PayloadZodOfSchema = (schema) => z3.extend(PayloadZod, { schema: z3.literal(schema) });
+var PayloadZodStrictOfSchema = (schema) => z3.extend(PayloadZodStrict, { schema: z3.literal(schema) });
+var PayloadZodLooseOfSchema = (schema) => z3.extend(PayloadZodLoose, { schema: z3.literal(schema) });
+
+// src/modules/payload-model/Error.ts
+var ModuleErrorSchema = asSchema("network.xyo.error.module", true);
+var ModuleErrorZod = z4.extend(PayloadZodOfSchema(ModuleErrorSchema), {
+  details: z4.optional(z4.custom()),
+  message: z4.optional(z4.string()),
+  name: z4.optional(z4.string()),
+  query: z4.optional(z4.union([HashZod2, SchemaZod]))
+});
+var isModuleError = zodIsFactory3(ModuleErrorZod);
+var asModuleError = zodAsFactory3(ModuleErrorZod, "asModuleError");
+var toModuleError = zodToFactory2(ModuleErrorZod, "toModuleError");
+
+// src/modules/payload-model/isPayloadOfSchemaType.ts
+function isPayloadOfSchemaType(schema) {
+  return (x) => isAnyPayload(x) && x?.schema === schema;
+}
+var isPayloadOfSchemaTypeWithSources = (schema) => {
+  return (x) => isPayloadOfSchemaType(schema)(x) && x.$sources != void 0 && Array.isArray(x.$sources);
+};
+var notPayloadOfSchemaType = (schema) => {
+  return (x) => !isAnyPayload(x) || x?.schema !== schema;
+};
+
+// src/modules/payload-model/isPayloadOfZodType.ts
+import { isDefined } from "@ariestools/sdk";
+import * as z5 from "zod/mini";
+function isPayloadOfZodType(zodSchema, schema) {
+  return (x) => {
+    if (!isAnyPayload(x)) return false;
+    if (isDefined(schema) && x.schema !== schema) return false;
+    const { schema: _, ...data } = x;
+    return z5.safeParse(zodSchema, data).success;
+  };
+}
+
+// src/modules/payload-model/PayloadBundle.ts
+import {
+  HashZod as HashZod3,
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory3
+} from "@ariestools/sdk";
+import * as z6 from "zod/mini";
+var PayloadBundleSchema = asSchema("network.xyo.payload.bundle", true);
+var PayloadBundleFieldsZod = z6.object({
+  payloads: z6.array(PayloadZodLoose),
+  root: HashZod3
+});
+var PayloadBundleZod = z6.extend(PayloadZodOfSchema(PayloadBundleSchema), PayloadBundleFieldsZod.shape);
+var isPayloadBundle = zodIsFactory4(PayloadBundleZod);
+var asPayloadBundle = zodAsFactory4(PayloadBundleZod, "asPayloadBundle");
+var asOptionalPayloadBundle = zodToFactory3(PayloadBundleZod, "asPayloadBundle");
+
+// src/modules/payload-model/PayloadSet/PayloadSetPayload.ts
+import {
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory4
+} from "@ariestools/sdk";
+import * as z7 from "zod/mini";
+
+// src/modules/payload-model/PayloadSet/PayloadSetSchema.ts
+var PayloadSetSchema = asSchema("network.xyo.payload.set", true);
+
+// src/modules/payload-model/PayloadSet/PayloadSetPayload.ts
+var stringNumberRecordZod = z7.record(z7.string(), z7.number());
+var PayloadSetZod = z7.object({
+  optional: z7.optional(stringNumberRecordZod),
+  required: z7.optional(stringNumberRecordZod)
+});
+var PayloadSetPayloadZod = z7.extend(PayloadZodOfSchema(PayloadSetSchema), PayloadSetZod.shape);
+var isPayloadSetPayload = zodIsFactory5(PayloadSetPayloadZod);
+var asPayloadSetPayload = zodAsFactory5(PayloadSetPayloadZod, "asPayloadSetPayload");
+var toPayloadSetPayload = zodToFactory4(PayloadSetPayloadZod, "toPayloadSetPayload");
+
+// src/modules/payload-model/Query.ts
+import * as z8 from "zod/mini";
+import { XyoAddressZod } from "#address";
+var queryAddressZod = z8.union([XyoAddressZod, z8.array(XyoAddressZod)]);
+var maxFrequencyZod = z8.union([
+  z8.literal("once"),
+  z8.literal("second"),
+  z8.literal("minute"),
+  z8.literal("hour"),
+  z8.literal("day"),
+  z8.literal("week"),
+  z8.literal("month"),
+  z8.literal("year")
+]);
+var QueryFieldsZod = z8.object({
+  /** @field The addresses of the intended handlers */
+  address: z8.optional(queryAddressZod),
+  /** @field The maximum XYO that can be spent executing the query */
+  budget: z8.optional(z8.number()),
+  /** @field The frequency on which this query can be rerun */
+  maxFrequency: z8.optional(maxFrequencyZod),
+  /** @field The starting point for the bidding on the query */
+  minBid: z8.optional(z8.number())
+});
+export {
+  AnyPayloadZod,
+  HashMetaZod,
+  LocalSequenceConstants,
+  LocalSequenceFromStringZod,
+  LocalSequenceToStringZod,
+  ModuleErrorSchema,
+  ModuleErrorZod,
+  PayloadBundleFieldsZod,
+  PayloadBundleSchema,
+  PayloadBundleZod,
+  PayloadSchema,
+  PayloadSchemaZod,
+  PayloadSetPayloadZod,
+  PayloadSetSchema,
+  PayloadSetZod,
+  PayloadZod,
+  PayloadZodLoose,
+  PayloadZodLooseOfSchema,
+  PayloadZodOfSchema,
+  PayloadZodStrict,
+  PayloadZodStrictOfSchema,
+  QualifiedSequenceConstants,
+  QualifiedSequenceFromStringZod,
+  QualifiedSequenceToStringZod,
+  QueryFieldsZod,
+  SchemaRegEx,
+  SchemaZod,
+  SequenceComparer,
+  SequenceComponentLengths,
+  SequenceComponentMinMax,
+  SequenceConstants,
+  SequenceFromStringZod,
+  SequenceMetaZod,
+  SequenceNonceComponentLengths,
+  SequenceParser,
+  SequenceToStringZod,
+  StorageMetaZod,
+  WithHashMetaPayloadZodLoose,
+  WithHashMetaZod,
+  WithStorageMetaZod,
+  asAnyPayload,
+  asHashMeta,
+  asModuleError,
+  asOptionalPayloadBundle,
+  asOptionalSequenceStorageMeta,
+  asPayload,
+  asPayloadBundle,
+  asPayloadSetPayload,
+  asSchema,
+  asSequenceMeta,
+  asSequenceStorageMeta,
+  asStorageMeta,
+  isAnyPayload,
+  isEpoch,
+  isHashMeta,
+  isLocalSequence,
+  isModuleError,
+  isNonce,
+  isPayload,
+  isPayloadBundle,
+  isPayloadOfSchemaType,
+  isPayloadOfSchemaTypeWithSources,
+  isPayloadOfZodType,
+  isPayloadSetPayload,
+  isQualifiedSequence,
+  isSchema,
+  isSequence,
+  isSequenceMeta,
+  isSequenceStorageMeta,
+  isStorageMeta,
+  makeSchema,
+  notPayloadOfSchemaType,
+  toAnyPayload,
+  toHashMeta,
+  toModuleError,
+  toPayload,
+  toPayloadSetPayload,
+  toSchema,
+  toSequenceMeta,
+  toStorageMeta
+};
 //# sourceMappingURL=payload-model.mjs.map

package/dist/node/payload-model.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../../src/payload-model.ts"],
-  "sourcesContent": ["export * from '@xyo-network/payload-model'\n"],
-  "mappings": ";AAAA,cAAc;",
-  "names": []
+  "sources": ["../../src/modules/payload-model/Error.ts", "../../src/modules/payload-model/PayloadZod.ts", "../../src/modules/payload-model/Schema.ts", "../../src/modules/payload-model/StorageMeta/Sequence.ts", "../../src/modules/payload-model/StorageMeta/sequence/Parser.ts", "../../src/modules/payload-model/StorageMeta/sequence/Sequence.ts", "../../src/modules/payload-model/StorageMeta/sequence/Comparer.ts", "../../src/modules/payload-model/StorageMeta/sequence/SequenceZod.ts", "../../src/modules/payload-model/isPayloadOfSchemaType.ts", "../../src/modules/payload-model/isPayloadOfZodType.ts", "../../src/modules/payload-model/PayloadBundle.ts", "../../src/modules/payload-model/PayloadSet/PayloadSetPayload.ts", "../../src/modules/payload-model/PayloadSet/PayloadSetSchema.ts", "../../src/modules/payload-model/Query.ts"],
+  "sourcesContent": ["import type { JsonValue } from '@ariestools/sdk'\nimport {\n  HashZod, zodAsFactory, zodIsFactory, zodToFactory,\n} from '@ariestools/sdk'\nimport * as z from 'zod/mini'\n\nimport { PayloadZodOfSchema } from './PayloadZod.ts'\nimport { asSchema, SchemaZod } from './Schema.ts'\n\nexport const ModuleErrorSchema = asSchema('network.xyo.error.module', true)\nexport type ModuleErrorSchema = typeof ModuleErrorSchema\n\nexport const ModuleErrorZod = z.extend(PayloadZodOfSchema(ModuleErrorSchema), {\n  details: z.optional(z.custom<JsonValue>()),\n  message: z.optional(z.string()),\n  name: z.optional(z.string()),\n  query: z.optional(z.union([HashZod, SchemaZod])),\n})\n\nexport type ModuleError = z.infer<typeof ModuleErrorZod>\n\nexport const isModuleError = zodIsFactory(ModuleErrorZod)\nexport const asModuleError = zodAsFactory(ModuleErrorZod, 'asModuleError')\nexport const toModuleError = zodToFactory(ModuleErrorZod, 'toModuleError')\n", "import {\n  HashZod,\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '@ariestools/sdk'\nimport * as z from 'zod/mini'\n\nimport type { Payload } from './Payload.ts'\nimport type { Schema } from './Schema.ts'\nimport { SchemaZod } from './Schema.ts'\nimport { SequenceFromStringZod } from './StorageMeta/index.ts'\n\nexport const HashMetaZod = z.object({\n  _hash: HashZod,\n  _dataHash: HashZod,\n})\n\nexport type HashMeta = z.infer<typeof HashMetaZod>\n\nexport type WithHashMeta<T extends Payload> = T & HashMeta\n\nexport const isHashMeta = zodIsFactory(HashMetaZod)\nexport const asHashMeta = zodAsFactory(HashMetaZod, 'asHashMeta')\nexport const toHashMeta = zodToFactory(HashMetaZod, 'toHashMeta')\n\nexport const SequenceMetaZod = z.object({ _sequence: SequenceFromStringZod })\n\nexport type SequenceMeta = z.infer<typeof SequenceMetaZod>\n\nexport const isSequenceMeta = zodIsFactory(SequenceMetaZod)\nexport const asSequenceMeta = zodAsFactory(SequenceMetaZod, 'asSequenceMeta')\nexport const toSequenceMeta = zodToFactory(SequenceMetaZod, 'toSequenceMeta')\n\nexport const StorageMetaZod = z.object({\n  _hash: HashZod,\n  _dataHash: HashZod,\n  _sequence: SequenceFromStringZod,\n})\n\nexport type StorageMeta = z.infer<typeof StorageMetaZod>\n\nexport type WithStorageMeta<T extends Payload = Payload> = T & StorageMeta\n\nexport const isStorageMeta = zodIsFactory(StorageMetaZod)\nexport const asStorageMeta = zodAsFactory(StorageMetaZod, 'asStorageMeta')\nexport const toStorageMeta = zodToFactory(StorageMetaZod, 'toStorageMeta')\n\nexport const PayloadZod = z.object({ schema: SchemaZod })\n\nexport const isPayload = zodIsFactory(PayloadZod)\nexport const asPayload = zodAsFactory(PayloadZod, 'asPayload')\nexport const toPayload = zodToFactory(PayloadZod, 'toPayload')\n\nexport const AnyPayloadZod = z.looseObject({ schema: SchemaZod })\n\nexport const isAnyPayload = zodIsFactory(AnyPayloadZod)\nexport const asAnyPayload = zodAsFactory(AnyPayloadZod, 'asAnyPayload')\nexport const toAnyPayload = zodToFactory(AnyPayloadZod, 'toAnyPayload')\n\nexport type AnyPayload = z.infer<typeof AnyPayloadZod>\n\nexport function WithStorageMetaZod<T extends z.core.$ZodLooseShape>(valueZod: z.ZodMiniObject<T>) {\n  return z.object({ ...valueZod.shape, ...StorageMetaZod.shape })\n}\n\nexport function WithHashMetaZod<T extends z.core.$ZodLooseShape>(valueZod: z.ZodMiniObject<T>) {\n  return z.object({ ...valueZod.shape, ...HashMetaZod.shape })\n}\n\nexport const PayloadZodStrict = z.strictObject({ schema: SchemaZod })\nexport type PayloadZodStrict = typeof PayloadZodStrict\n\nexport const PayloadZodLoose: PayloadZodStrict = z.looseObject({ schema: SchemaZod })\nexport type PayloadZodLoose = typeof PayloadZodLoose\n\nexport const WithHashMetaPayloadZodLoose = z.extend(PayloadZodLoose, HashMetaZod.shape)\nexport type WithHashMetaPayloadZodLoose = typeof WithHashMetaPayloadZodLoose\n\nexport const PayloadZodOfSchema = <S extends Schema>(schema: S) => z.extend(PayloadZod, { schema: z.literal(schema) })\nexport const PayloadZodStrictOfSchema = <S extends Schema>(schema: S) => z.extend(PayloadZodStrict, { schema: z.literal(schema) })\nexport const PayloadZodLooseOfSchema = <S extends Schema>(schema: S) => z.extend(PayloadZodLoose, { schema: z.literal(schema) })\n", "import type { Brand } from '@ariestools/sdk'\nimport { zodAsFactory, zodIsFactory } from '@ariestools/sdk'\nimport * as z from 'zod/mini'\n\nexport type BrandedSchema<T extends string = string> = Brand<T, { readonly __schema: true }>\nexport const SchemaRegEx = /^(?:[a-z0-9]+\\.)*[a-z0-9]+$/\n\nexport const SchemaZod = z.pipe(z.string().check(z.regex(SchemaRegEx)), z.transform((v: string): BrandedSchema => v as BrandedSchema))\nexport type Schema<T extends string = string> = z.infer<typeof SchemaZod> & BrandedSchema<T>\n\nexport const makeSchema = <T extends string>(value: T) => {\n  return z.pipe(z.literal(value), z.transform((x: T): T & { __schema: true } => x as T & { __schema: true }))\n}\n\nexport const isSchema = zodIsFactory(SchemaZod)\nexport const asSchema = zodAsFactory(SchemaZod, 'asSchema')\nexport const toSchema = zodAsFactory(SchemaZod, 'toSchema')\n\nexport const PayloadSchema = asSchema('network.xyo.payload', true)\nexport const PayloadSchemaZod = z.literal(PayloadSchema)\nexport type PayloadSchema = z.infer<typeof PayloadSchemaZod>\n", "import { AsObjectFactory } from '@ariestools/sdk'\n\nimport type { Payload } from '../Payload.ts'\nimport type { Sequence } from './sequence/index.ts'\n\nexport interface SequenceStorageMeta {\n  _sequence: Sequence\n}\n\nexport type WithSequenceStorageMeta<T extends Payload = Payload> = T & SequenceStorageMeta\nexport type WithPartialSequenceStorageMeta<T extends Payload = Payload> = Partial<WithSequenceStorageMeta<T>>\n\nexport const isSequenceStorageMeta = (value: unknown): value is SequenceStorageMeta => {\n  return (value as WithSequenceStorageMeta)?._sequence != undefined\n}\n\nexport const asSequenceStorageMeta = AsObjectFactory.create(isSequenceStorageMeta)\nexport const asOptionalSequenceStorageMeta = AsObjectFactory.createOptional(isSequenceStorageMeta)\n", "import type { Hash, Hex } from '@ariestools/sdk'\nimport {\n  assertEx, isAddress, toAddress, toHex, toUint8Array,\n} from '@ariestools/sdk'\n\nimport type { XyoLegacyAddress } from '#address'\n\nimport type {\n  Epoch, LocalSequence, Nonce, QualifiedSequence,\n  Sequence,\n} from './Sequence.ts'\nimport {\n  isQualifiedSequence, isSequence,\n  SequenceConstants,\n} from './Sequence.ts'\n\nexport class SequenceParser {\n  protected static privateConstructorKey = Date.now().toString()\n\n  private readonly data: Readonly<Uint8Array>\n\n  protected constructor(privateConstructorKey: string, hex: Hex) {\n    assertEx(SequenceParser.privateConstructorKey === privateConstructorKey, () => 'Use create function instead of constructor')\n    const paddedHex = toHex(hex, {\n      prefix: false,\n      bitLength: SequenceConstants[hex.length <= SequenceConstants.localSequenceBytes * 2 ? 'localSequenceBytes' : 'qualifiedSequenceBytes'] * 8,\n    })\n    this.data = toUint8Array(paddedHex)\n  }\n\n  static from(sequence: Sequence, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: Hex, hash: Hash, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: Hex, hash: Hex, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: Hex, nonce: Nonce, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: Hex, hash: Hash, index?: number, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: Hex, hash: Hex, index?: number, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: Hex, nonce: Nonce, index?: number, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: number, hash: Hash, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: number, hash: Hex, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: number, nonce: Nonce, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: number, hash: Hash, index?: number, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: number, hash: Hex, index?: number, address?: XyoLegacyAddress): SequenceParser\n  static from(timestamp: number, nonce: Nonce, index?: number, address?: XyoLegacyAddress): SequenceParser\n  static from(\n    timestampOrSequence: Hex | number,\n    nonceOrAddress?: Hex,\n    addressOrIndex?: XyoLegacyAddress | number,\n    addressOnly?: XyoLegacyAddress,\n  ): SequenceParser {\n    if (isSequence(timestampOrSequence)) {\n      if (nonceOrAddress) {\n        assertEx(!isQualifiedSequence(timestampOrSequence), () => 'Providing both a qualified sequence and a address is not allowed')\n        assertEx(isAddress(nonceOrAddress), () => 'Invalid address provided')\n        const combined = (timestampOrSequence + nonceOrAddress) as Hex\n        return this.create(combined)\n      }\n      return this.create(timestampOrSequence)\n    }\n    const address = typeof addressOrIndex === 'number' ? addressOnly : addressOrIndex\n    const index = typeof addressOrIndex === 'number' ? addressOrIndex : undefined\n    const epoch = this.toEpoch(timestampOrSequence)\n    const nonce = nonceOrAddress === undefined ? undefined : this.toNonce(nonceOrAddress, index)\n    const addressHex: Hex = address ? toHex(address, { bitLength: SequenceConstants.addressBytes * 8 }) : SequenceConstants.minAddress\n    const hexString = (epoch + nonce + addressHex) as Hex\n    assertEx(isSequence(hexString), () => `Invalid sequence [${hexString}] [${epoch}, ${nonce}, ${addressHex}]`)\n    return this.create(hexString)\n  }\n\n  static parse(value: Hex | string | ArrayBufferLike): SequenceParser {\n    const hex = toHex(value)\n    if (isSequence(hex)) {\n      return this.create(hex)\n    }\n    throw new Error(`Invalid sequence [${hex}]`)\n  }\n\n  // can convert a short number/hex to an epoch (treats it as the whole value) or extract an epoch from a sequence\n  static toEpoch(value: number | Hex | Epoch): Epoch {\n    assertEx(\n      typeof value !== 'number' || Number.isSafeInteger(value),\n      () => 'Value must be in integer',\n    )\n    const hex = toHex(value, { prefix: false })\n    if (hex.length <= SequenceConstants.epochBytes * 2) {\n      return toHex(value, { prefix: false, bitLength: SequenceConstants.epochBytes * 8 }) as Epoch\n    }\n    if (isSequence(hex)) {\n      return hex.slice(0, SequenceConstants.epochBytes * 2) as Epoch\n    }\n    throw new Error(`Value could not be converted to epoch [${hex}]`)\n  }\n\n  // can convert a short number/hex to a nonce (treats it as the whole value) or extract an nonce from a sequence\n  static toNonce(value: Hash | Hex, index = 0): Nonce {\n    assertEx(\n      typeof value !== 'number' || Number.isSafeInteger(value),\n      () => 'Value must be in integer',\n    )\n    const hex = toHex(value, { prefix: false })\n    if (isSequence(hex)) {\n      return hex.slice(SequenceConstants.epochBytes * 2, SequenceConstants.localSequenceBytes * 2) as Nonce\n    }\n    const hashHex = toHex(hex, { prefix: false, bitLength: SequenceConstants.nonceHashBytes * 8 }).slice(-SequenceConstants.nonceHashBytes * 2)\n    const indexHex = toHex(index, { prefix: false, bitLength: SequenceConstants.nonceIndexBytes * 8 }).slice(-SequenceConstants.nonceIndexBytes * 2)\n    return (indexHex + hashHex).slice(-SequenceConstants.nonceBytes * 2) as Nonce\n  }\n\n  private static create(hex: Hex): SequenceParser {\n    // `new this()` is not a readable constructor per unicorn/no-unreadable-new-expression\n    return new SequenceParser(this.privateConstructorKey, hex)\n  }\n\n  get address(): XyoLegacyAddress {\n    const start = SequenceConstants.localSequenceBytes\n    const end = SequenceConstants.qualifiedSequenceBytes\n    return toAddress(this.data.slice(start, end).buffer, { prefix: false })\n  }\n\n  get epoch(): Epoch {\n    const start = 0\n    const end = SequenceConstants.epochBytes\n    return toHex(this.data.slice(start, end).buffer, { prefix: false }) as Epoch\n  }\n\n  get localSequence(): LocalSequence {\n    const start = 0\n    const end = SequenceConstants.localSequenceBytes\n    return toHex(this.data.slice(start, end).buffer, { prefix: false }) as LocalSequence\n  }\n\n  get nonce(): Nonce {\n    const start = SequenceConstants.epochBytes\n    const end = SequenceConstants.localSequenceBytes\n    return toHex(this.data.slice(start, end).buffer, { prefix: false }) as Nonce\n  }\n\n  get qualifiedSequence(): QualifiedSequence {\n    const start = 0\n    const end = SequenceConstants.qualifiedSequenceBytes\n    return toHex(this.data.slice(start, end).buffer, { prefix: false }) as QualifiedSequence\n  }\n}\n", "import type { Brand, Hex } from '@ariestools/sdk'\nimport { isHex } from '@ariestools/sdk'\n\nimport type { XyoLegacyAddress } from '#address'\n\n// we use Exclude to intentionally make the type not equal to string\nexport type LocalSequence = Brand<Hex, { __localSequence: true }>\nexport type QualifiedSequence = Brand<Hex, { __qualifiedSequence: true }>\nexport type Sequence = LocalSequence | QualifiedSequence\n\nexport type Epoch = Brand<Hex, { __epoch: true }>\n\nexport const isEpoch = (value: unknown): value is Epoch => {\n  return isHex(value) && (value as string).length === SequenceConstants.epochBytes * 2\n}\n\nexport type Nonce = Brand<Hex, { __nonce: true }>\n\nexport const isNonce = (value: unknown): value is Nonce => {\n  return isHex(value) && (value as string).length === SequenceConstants.nonceBytes * 2\n}\n\nexport const isLocalSequence = (value: unknown): value is LocalSequence => {\n  return isHex(value) && (value as string).length === SequenceConstants.localSequenceBytes * 2\n}\n\nexport const isQualifiedSequence = (value: unknown): value is QualifiedSequence => {\n  return isHex(value) && (value as string).length === SequenceConstants.qualifiedSequenceBytes * 2\n}\n\nexport const isSequence = (value: unknown): value is Sequence => {\n  return isLocalSequence(value) || isQualifiedSequence(value)\n}\n\nexport const SequenceNonceComponentLengths = {\n  nonceIndexBytes: 4,\n  nonceHashBytes: 4,\n}\n\nexport const SequenceComponentLengths = {\n  ...SequenceNonceComponentLengths,\n  epochBytes: 8,\n  nonceBytes: SequenceNonceComponentLengths.nonceIndexBytes + SequenceNonceComponentLengths.nonceHashBytes,\n  addressBytes: 20,\n}\n\nexport const SequenceComponentMinMax = {\n  minEpoch: '0'.repeat(SequenceComponentLengths.epochBytes * 2) as Epoch,\n  maxEpoch: 'f'.repeat(SequenceComponentLengths.epochBytes * 2) as Epoch,\n  minNonce: '0'.repeat(SequenceComponentLengths.nonceBytes * 2) as Nonce,\n  maxNonce: 'f'.repeat(SequenceComponentLengths.nonceBytes * 2) as Nonce,\n  minAddress: '0'.repeat(SequenceComponentLengths.addressBytes * 2) as XyoLegacyAddress,\n  maxAddress: 'f'.repeat(SequenceComponentLengths.addressBytes * 2) as XyoLegacyAddress,\n}\n\nexport const LocalSequenceConstants = {\n  ...SequenceComponentLengths,\n  ...SequenceComponentMinMax,\n  localSequenceBytes: SequenceComponentLengths.epochBytes + SequenceComponentLengths.nonceBytes,\n  minLocalSequence: SequenceComponentMinMax.minEpoch + SequenceComponentMinMax.minNonce as LocalSequence,\n  maxLocalSequence: SequenceComponentMinMax.maxEpoch + SequenceComponentMinMax.maxNonce as LocalSequence,\n}\n\nexport const QualifiedSequenceConstants = {\n  qualifiedSequenceBytes: LocalSequenceConstants.localSequenceBytes + SequenceComponentLengths.addressBytes,\n  minQualifiedSequence: LocalSequenceConstants.minLocalSequence + SequenceComponentMinMax.minAddress as QualifiedSequence,\n  maxQualifiedSequence: LocalSequenceConstants.maxLocalSequence + SequenceComponentMinMax.maxAddress as QualifiedSequence,\n}\n\nexport const SequenceConstants = {\n  ...LocalSequenceConstants,\n  ...QualifiedSequenceConstants,\n}\n\n// \"11111111111111112222222222222222\" is and example of a local sequence string\n\n// \"111111111111111122222222222222223333333333333333333333333333333333333333\" is and example of a local sequence string\n// epoch = \"1111111111111111\"\n// nonce = \"2222222222222222\"\n// address = \"3333333333333333333333333333333333333333\"\n", "import type { Compare } from '@ariestools/sdk'\n\nimport { SequenceParser } from './Parser.ts'\nimport type { Sequence } from './Sequence.ts'\n\nconst local: Compare<Sequence> = (a, b) => {\n  const aa = SequenceParser.from(a)\n  const bb = SequenceParser.from(b)\n  return aa.localSequence > bb.localSequence ? 1 : aa.localSequence < bb.localSequence ? -1 : 0\n}\n\nconst qualified: Compare<Sequence> = (a, b) => {\n  const aa = SequenceParser.from(a)\n  const bb = SequenceParser.from(b)\n  return aa.qualifiedSequence > bb.qualifiedSequence ? 1 : aa.qualifiedSequence < bb.qualifiedSequence ? -1 : 0\n}\n\nexport const SequenceComparer = { local, qualified }\n", "import { HexRegExMinMax, toHex } from '@ariestools/sdk'\nimport * as z from 'zod/mini'\n\nimport type { LocalSequence, QualifiedSequence } from './Sequence.ts'\nimport { SequenceConstants } from './Sequence.ts'\n\nconst LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes))\nexport const LocalSequenceToStringZod = z.string().check(z.regex(LocalSequenceRegex))\nexport const LocalSequenceFromStringZod = z.pipe(\n  z.string().check(z.regex(LocalSequenceRegex)),\n  z.transform((v: string): LocalSequence => toHex(v) as LocalSequence),\n)\n\nconst QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes))\nexport const QualifiedSequenceToStringZod = z.string().check(z.regex(QualifiedSequenceRegex))\nexport const QualifiedSequenceFromStringZod = z.pipe(\n  z.string().check(z.regex(QualifiedSequenceRegex)),\n  z.transform((v: string): QualifiedSequence => toHex(v) as QualifiedSequence),\n)\n\nexport const SequenceToStringZod = z.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod])\nexport const SequenceFromStringZod = z.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod])\n", "import type { Payload, WithSources } from './Payload.ts'\nimport { isAnyPayload } from './PayloadZod.ts'\n\nexport function isPayloadOfSchemaType<T extends Payload = never>(schema: T['schema']) {\n  return (x?: unknown): x is T => isAnyPayload(x) && x?.schema === schema\n}\n\nexport const isPayloadOfSchemaTypeWithSources = <T extends Payload = never>(schema: T['schema']) => {\n  return (x?: unknown): x is WithSources<T> =>\n    isPayloadOfSchemaType<WithSources<T>>(schema)(x) && x.$sources != undefined && Array.isArray(x.$sources)\n}\n\nexport const notPayloadOfSchemaType = <T extends Payload = never>(schema: T['schema']) => {\n  return (x?: unknown): x is T => !isAnyPayload(x) || x?.schema !== schema\n}\n\n// test types -- keep for future validation, but comment out\n\n/*\ntype TestSchema = 'network.xyo.test'\nconst TestSchema: TestSchema = 'network.xyo.test'\n\ntype Test = Payload<{ field: string }, TestSchema>\n\nconst testPayload: Test = { field: 'test', schema: TestSchema }\n\nconst testPayloads: Payload[] = [testPayload]\n\nconst isTest: Test[] = testPayloads.filter(isPayloadOfSchemaType<Payload>(TestSchema))\n\nconst isTestFromMetaTyped = testMetaPayloads.filter(isPayloadOfSchemaType<Test>(TestSchema))\n*/\n", "import { isDefined } from '@ariestools/sdk'\nimport * as z from 'zod/mini'\n\nimport type { Payload } from './Payload.ts'\nimport { isAnyPayload } from './PayloadZod.ts'\n\n/**\n * Checks if a value is a payload of a specific Zod type.\n * @param zodSchema The Zod schema to validate against\n * @param schema The schema string to match against the payload. Optional in\n * case you want to validate any payload matching the Zod schema or in case\n * schema is part of the Zod schema.\n * @returns A function that checks if a value is a payload of the specified Zod type\n */\nexport function isPayloadOfZodType<\n  T extends Payload = never,\n  S extends z.core.$ZodObject = z.core.$ZodObject,\n>(zodSchema: S, schema?: T['schema']) {\n  return (x?: unknown): x is T => {\n    if (!isAnyPayload(x)) return false\n    if (isDefined(schema) && x.schema !== schema) return false\n    const { schema: _, ...data } = x\n    return z.safeParse(zodSchema, data).success\n  }\n}\n", "import {\n  HashZod,\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '@ariestools/sdk'\nimport * as z from 'zod/mini'\n\nimport { PayloadZodLoose, PayloadZodOfSchema } from './PayloadZod.ts'\nimport { asSchema } from './Schema.ts'\n\n// payload that wraps a complete boundwitness with its payloads for use in systems such as submission queues\nexport const PayloadBundleSchema = asSchema('network.xyo.payload.bundle', true)\nexport type PayloadBundleSchema = typeof PayloadBundleSchema\n\nexport const PayloadBundleFieldsZod = z.object({\n  payloads: z.array(PayloadZodLoose),\n  root: HashZod,\n})\n\nexport type PayloadBundleFields = z.infer<typeof PayloadBundleFieldsZod>\n\nexport const PayloadBundleZod = z.extend(PayloadZodOfSchema(PayloadBundleSchema), PayloadBundleFieldsZod.shape)\n\nexport type PayloadBundle = z.infer<typeof PayloadBundleZod>\n\nexport const isPayloadBundle = zodIsFactory(PayloadBundleZod)\nexport const asPayloadBundle = zodAsFactory(PayloadBundleZod, 'asPayloadBundle')\nexport const asOptionalPayloadBundle = zodToFactory(PayloadBundleZod, 'asPayloadBundle')\n", "import {\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '@ariestools/sdk'\nimport * as z from 'zod/mini'\n\nimport { PayloadZodOfSchema } from '../PayloadZod.ts'\nimport { PayloadSetSchema } from './PayloadSetSchema.ts'\n\nconst stringNumberRecordZod = z.record(z.string(), z.number())\n\nexport const PayloadSetZod = z.object({\n  optional: z.optional(stringNumberRecordZod),\n  required: z.optional(stringNumberRecordZod),\n})\n\nexport type PayloadSet = z.infer<typeof PayloadSetZod>\n\nexport const PayloadSetPayloadZod = z.extend(PayloadZodOfSchema(PayloadSetSchema), PayloadSetZod.shape)\n\nexport type PayloadSetPayload = z.infer<typeof PayloadSetPayloadZod>\n\nexport const isPayloadSetPayload = zodIsFactory(PayloadSetPayloadZod)\nexport const asPayloadSetPayload = zodAsFactory(PayloadSetPayloadZod, 'asPayloadSetPayload')\nexport const toPayloadSetPayload = zodToFactory(PayloadSetPayloadZod, 'toPayloadSetPayload')\n", "import { asSchema } from '../Schema.ts'\n\nexport const PayloadSetSchema = asSchema('network.xyo.payload.set', true)\nexport type PayloadSetSchema = typeof PayloadSetSchema\n", "import type { EmptyObject } from '@ariestools/sdk'\nimport * as z from 'zod/mini'\n\nimport { XyoAddressZod } from '#address'\n\nimport type { Payload, SchemaField } from './Payload.ts'\nimport type { Schema } from './Schema.ts'\n\nconst queryAddressZod = z.union([XyoAddressZod, z.array(XyoAddressZod)])\nconst maxFrequencyZod = z.union([\n  z.literal('once'),\n  z.literal('second'),\n  z.literal('minute'),\n  z.literal('hour'),\n  z.literal('day'),\n  z.literal('week'),\n  z.literal('month'),\n  z.literal('year'),\n])\n\nexport const QueryFieldsZod = z.object({\n  /** @field The addresses of the intended handlers */\n  address: z.optional(queryAddressZod),\n  /** @field The maximum XYO that can be spent executing the query */\n  budget: z.optional(z.number()),\n  /** @field The frequency on which this query can be rerun */\n  maxFrequency: z.optional(maxFrequencyZod),\n  /** @field The starting point for the bidding on the query */\n  minBid: z.optional(z.number()),\n})\n\nexport type QueryFields = z.infer<typeof QueryFieldsZod>\n\nexport type Query<T extends void | EmptyObject | SchemaField = void, S extends Schema | void = void> = Payload<\n  T extends void ? QueryFields : T & QueryFields,\n  S extends void\n    ? T extends SchemaField ? T['schema']\n      : T extends void ? Schema\n        : void\n    : S\n>\n"],
+  "mappings": "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",
+  "names": ["HashZod", "zodAsFactory", "zodIsFactory", "zodToFactory", "z", "zodAsFactory", "zodIsFactory", "z", "toHex", "z", "toHex", "zodIsFactory", "zodAsFactory", "HashZod", "zodIsFactory", "zodAsFactory", "zodToFactory", "z", "HashZod", "zodAsFactory", "zodIsFactory", "zodToFactory", "z", "HashZod", "zodIsFactory", "zodAsFactory", "zodToFactory", "zodAsFactory", "zodIsFactory", "zodToFactory", "z", "zodIsFactory", "zodAsFactory", "zodToFactory", "z"]
 }

package/dist/node/payload-plugin.d.ts

@@ -1,2 +1,2 @@
-export * from '@xyo-network/payload-plugin';
+export * from './modules/payload-plugin/index.js';
 //# sourceMappingURL=payload-plugin.d.ts.map

package/dist/node/payload-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payload-plugin.d.ts","sourceRoot":"","sources":["../../src/payload-plugin.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA"}
+{"version":3,"file":"payload-plugin.d.ts","sourceRoot":"","sources":["../../src/payload-plugin.ts"],"names":[],"mappings":"AACA,cAAc,iBAAiB,CAAA"}

package/dist/node/payload-utils.d.ts

@@ -1,2 +1,2 @@
-export * from '@xyo-network/payload-utils';
+export * from './modules/payload-utils/index.js';
 //# sourceMappingURL=payload-utils.d.ts.map

package/dist/node/payload-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payload-utils.d.ts","sourceRoot":"","sources":["../../src/payload-utils.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA"}
+{"version":3,"file":"payload-utils.d.ts","sourceRoot":"","sources":["../../src/payload-utils.ts"],"names":[],"mappings":"AACA,cAAc,gBAAgB,CAAA"}

package/dist/node/payload-validator.d.ts

@@ -1,2 +1,2 @@
-export * from '@xyo-network/payload-validator';
+export * from './modules/payload-validator/index.js';
 //# sourceMappingURL=payload-validator.d.ts.map

package/dist/node/payload-validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payload-validator.d.ts","sourceRoot":"","sources":["../../src/payload-validator.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAA"}
+{"version":3,"file":"payload-validator.d.ts","sourceRoot":"","sources":["../../src/payload-validator.ts"],"names":[],"mappings":"AACA,cAAc,oBAAoB,CAAA"}

package/dist/node/payload-wrapper.d.ts

@@ -1,2 +1,2 @@
-export * from '@xyo-network/payload-wrapper';
+export * from './modules/payload-wrapper/index.js';
 //# sourceMappingURL=payload-wrapper.d.ts.map

package/dist/node/payload-wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payload-wrapper.d.ts","sourceRoot":"","sources":["../../src/payload-wrapper.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA"}
+{"version":3,"file":"payload-wrapper.d.ts","sourceRoot":"","sources":["../../src/payload-wrapper.ts"],"names":[],"mappings":"AACA,cAAc,kBAAkB,CAAA"}

package/dist/node/payload.d.ts

@@ -1,2 +1,2 @@
-export * from '@xyo-network/payload';
+export * from './modules/payload/index.js';
 //# sourceMappingURL=payload.d.ts.map

package/dist/node/payload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../src/payload.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../src/payload.ts"],"names":[],"mappings":"AACA,cAAc,UAAU,CAAA"}

package/dist/node/payload.mjs

@@ -1,3 +1,7 @@
-// src/payload.ts
-export * from "@xyo-network/payload";
+// src/modules/payload/index.ts
+export * from "#huri";
+export * from "#payload-builder";
+export * from "#payload-model";
+export * from "#payload-validator";
+export * from "#payload-wrapper";
 //# sourceMappingURL=payload.mjs.map

package/dist/node/payload.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../../src/payload.ts"],
-  "sourcesContent": ["export * from '@xyo-network/payload'\n"],
-  "mappings": ";AAAA,cAAc;",
+  "sources": ["../../src/modules/payload/index.ts"],
+  "sourcesContent": ["export * from '#huri'\nexport * from '#payload-builder'\nexport * from '#payload-model'\nexport * from '#payload-validator'\nexport * from '#payload-wrapper'\n"],
+  "mappings": ";AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
   "names": []
 }

package/dist/node/payload.model.d.ts

@@ -0,0 +1,2 @@
+export type * from './modules/payload/model.js';
+//# sourceMappingURL=payload.model.d.ts.map

package/dist/node/payload.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.model.d.ts","sourceRoot":"","sources":["../../src/payload.model.ts"],"names":[],"mappings":"AACA,mBAAmB,gBAAgB,CAAA"}

package/dist/node/pqc.d.ts

@@ -1,2 +1,2 @@
-export * from '@xyo-network/pqc';
+export * from './modules/pqc/index.js';
 //# sourceMappingURL=pqc.d.ts.map

package/dist/node/pqc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pqc.d.ts","sourceRoot":"","sources":["../../src/pqc.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"pqc.d.ts","sourceRoot":"","sources":["../../src/pqc.ts"],"names":[],"mappings":"AACA,cAAc,MAAM,CAAA"}

package/dist/node/previous-hash-store-indexeddb.d.ts

@@ -1,2 +1,2 @@
-export * from '@xyo-network/previous-hash-store-indexeddb';
+export * from './modules/previous-hash-store-indexeddb/index.js';
 //# sourceMappingURL=previous-hash-store-indexeddb.d.ts.map

package/dist/node/previous-hash-store-indexeddb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"previous-hash-store-indexeddb.d.ts","sourceRoot":"","sources":["../../src/previous-hash-store-indexeddb.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAA"}
+{"version":3,"file":"previous-hash-store-indexeddb.d.ts","sourceRoot":"","sources":["../../src/previous-hash-store-indexeddb.ts"],"names":[],"mappings":"AACA,cAAc,gCAAgC,CAAA"}

package/dist/node/previous-hash-store-model.d.ts

@@ -1,2 +1,2 @@
-export * from '@xyo-network/previous-hash-store-model';
+export * from './modules/previous-hash-store-model/index.js';
 //# sourceMappingURL=previous-hash-store-model.d.ts.map