@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/network/neutral/index.mjs

@@ -0,0 +1,211 @@
+// src/NetworkNodePayload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { asSchema, PayloadZodOfSchema } from "../../payload-model/neutral/index.mjs";
+import * as z from "zod/mini";
+var NetworkNodeTypeZod = z.union([
+  z.literal("archivist"),
+  z.literal("diviner"),
+  z.literal("bridge"),
+  z.literal("sentinel")
+]);
+var NetworkNodeSchema = asSchema("network.xyo.network.node", true);
+var NetworkNodePayloadZod = z.extend(PayloadZodOfSchema(NetworkNodeSchema), {
+  docs: z.optional(z.string()),
+  name: z.optional(z.string()),
+  slug: z.string(),
+  type: NetworkNodeTypeZod,
+  uri: z.string(),
+  web: z.optional(z.string())
+});
+var isNetworkNodePayload = zodIsFactory(NetworkNodePayloadZod);
+var asNetworkNodePayload = zodAsFactory(NetworkNodePayloadZod, "asNetworkNodePayload");
+var toNetworkNodePayload = zodToFactory(NetworkNodePayloadZod, "toNetworkNodePayload");
+
+// src/knownArchivists.ts
+var kerplunkArchivist = () => {
+  return {
+    docs: "https://beta.archivist.xyo.network/api",
+    name: "XYO Shared Archivist (kerplunk)",
+    schema: NetworkNodeSchema,
+    slug: "kerplunk",
+    type: "archivist",
+    uri: "https://beta.api.archivist.xyo.network",
+    web: "https://beta.archivist.xyo.network"
+  };
+};
+var mainArchivist = () => {
+  return {
+    docs: "https://archivist.xyo.network/api",
+    name: "XYO Shared Archivist (main)",
+    schema: NetworkNodeSchema,
+    slug: "main",
+    type: "archivist",
+    uri: "https://api.archivist.xyo.network",
+    web: "https://archivist.xyo.network"
+  };
+};
+var localArchivist = () => {
+  return {
+    docs: "http://localhost:8080/api",
+    name: "XYO Shared Archivist (local)",
+    schema: NetworkNodeSchema,
+    slug: "local",
+    type: "archivist",
+    uri: "http://localhost:8080",
+    web: "http://localhost:8081"
+  };
+};
+var knownArchivists = () => [kerplunkArchivist(), mainArchivist(), localArchivist()];
+
+// src/knownDiviners.ts
+var beta = () => {
+  return {
+    name: "XYO Location (beta)",
+    schema: NetworkNodeSchema,
+    slug: "beta",
+    type: "diviner",
+    uri: "https://beta.api.location.diviner.xyo.network",
+    web: "https://beta.explore.xyo.network"
+  };
+};
+var main = () => {
+  return {
+    name: "XYO Location",
+    schema: NetworkNodeSchema,
+    slug: "main",
+    type: "diviner",
+    uri: "https://api.location.diviner.xyo.network",
+    web: "https://explore.xyo.network"
+  };
+};
+var knownDiviners = () => [beta(), main()];
+
+// src/NetworkNodePayloadWrapper.ts
+import { assertEx } from "@xylabs/sdk";
+import { PayloadBuilder } from "../../payload-builder/neutral/index.mjs";
+import { PayloadWrapper } from "../../payload-wrapper/neutral/index.mjs";
+var NetworkNodePayloadWrapper = class _NetworkNodePayloadWrapper extends PayloadWrapper {
+  static async known(hash) {
+    const config = assertEx(
+      await PayloadBuilder.findByDataHash(knownArchivists(), hash) ?? await PayloadBuilder.findByDataHash(knownDiviners(), hash),
+      () => "Unknown node"
+    );
+    return new _NetworkNodePayloadWrapper(config);
+  }
+};
+
+// src/NetworkPayload.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk";
+import { asSchema as asSchema2, PayloadZodOfSchema as PayloadZodOfSchema2 } from "../../payload-model/neutral/index.mjs";
+import * as z2 from "zod/mini";
+var NetworkSchema = asSchema2("network.xyo.network", true);
+var NetworkPayloadZod = z2.extend(PayloadZodOfSchema2(NetworkSchema), {
+  name: z2.optional(z2.string()),
+  nodes: z2.optional(z2.array(NetworkNodePayloadZod)),
+  slug: z2.string()
+});
+var isNetworkPayload = zodIsFactory2(NetworkPayloadZod);
+var asNetworkPayload = zodAsFactory2(NetworkPayloadZod, "asNetworkPayload");
+var toNetworkPayload = zodToFactory2(NetworkPayloadZod, "toNetworkPayload");
+
+// src/knownNetworks.ts
+async function knownNodePayload(hash) {
+  const wrapper = await NetworkNodePayloadWrapper.known(hash);
+  return wrapper?.payload;
+}
+var kerplunk = async () => {
+  return {
+    name: "Kerplunk",
+    nodes: [
+      await knownNodePayload("kerplunk-archivist-xyo-network"),
+      await knownNodePayload("beta-location-diviner-xyo-network")
+    ].filter(Boolean),
+    schema: NetworkSchema,
+    slug: "kerplunk"
+  };
+};
+var main2 = async () => {
+  return {
+    name: "Main",
+    nodes: [
+      await knownNodePayload("main-archivist-xyo-network"),
+      await knownNodePayload("location-diviner-xyo-network")
+    ].filter(Boolean),
+    schema: NetworkSchema,
+    slug: "main"
+  };
+};
+var local = async () => {
+  return {
+    name: "Local",
+    nodes: [
+      await knownNodePayload("kerplunk-archivist-xyo-network"),
+      await knownNodePayload("beta-location-diviner-xyo-network")
+    ].filter(Boolean),
+    schema: NetworkSchema,
+    slug: "local"
+  };
+};
+var custom = async () => {
+  return {
+    name: "Custom",
+    nodes: [
+      await knownNodePayload("kerplunk-archivist-xyo-network"),
+      await knownNodePayload("beta-location-diviner-xyo-network")
+    ].filter(Boolean),
+    schema: NetworkSchema,
+    slug: "custom"
+  };
+};
+var knownNetworks = async () => [await kerplunk(), await main2(), await local(), await custom()];
+
+// src/NetworkPayloadWrapper.ts
+import { PayloadBuilder as PayloadBuilder2 } from "../../payload-builder/neutral/index.mjs";
+import { PayloadWrapper as PayloadWrapper2 } from "../../payload-wrapper/neutral/index.mjs";
+var NetworkPayloadWrapper = class extends PayloadWrapper2 {
+  static async known(hash) {
+    return await PayloadBuilder2.findByDataHash(await knownNetworks(), hash);
+  }
+  get archivists() {
+    return this.filterNodesByType("archivist");
+  }
+  get bridges() {
+    return this.filterNodesByType("bridge");
+  }
+  get diviners() {
+    return this.filterNodesByType("diviner");
+  }
+  get sentinels() {
+    return this.filterNodesByType("sentinel");
+  }
+  filterNodesByType(type) {
+    return this.payload.nodes?.filter((node) => node.type === type);
+  }
+};
+export {
+  NetworkNodePayloadWrapper,
+  NetworkNodePayloadZod,
+  NetworkNodeSchema,
+  NetworkNodeTypeZod,
+  NetworkPayloadWrapper,
+  NetworkPayloadZod,
+  NetworkSchema,
+  asNetworkNodePayload,
+  asNetworkPayload,
+  isNetworkNodePayload,
+  isNetworkPayload,
+  knownArchivists,
+  knownDiviners,
+  knownNetworks,
+  toNetworkNodePayload,
+  toNetworkPayload
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/network/neutral/knownArchivists.d.ts

@@ -0,0 +1,3 @@
+import type { NetworkNodePayload } from './NetworkNodePayload.ts';
+export declare const knownArchivists: () => NetworkNodePayload[];
+//# sourceMappingURL=knownArchivists.d.ts.map

package/dist/_pkg/network/neutral/knownDiviners.d.ts

@@ -0,0 +1,3 @@
+import type { NetworkNodePayload } from './NetworkNodePayload.ts';
+export declare const knownDiviners: () => NetworkNodePayload[];
+//# sourceMappingURL=knownDiviners.d.ts.map

package/dist/_pkg/network/neutral/knownNetworks.d.ts

@@ -0,0 +1,3 @@
+import type { NetworkPayload } from './NetworkPayload.ts';
+export declare const knownNetworks: () => Promise<NetworkPayload[]>;
+//# sourceMappingURL=knownNetworks.d.ts.map

package/dist/_pkg/payload/neutral/builder.d.ts

@@ -0,0 +1,2 @@
+export * from '../../payload-builder/neutral/index.ts';
+//# sourceMappingURL=builder.d.ts.map

package/dist/_pkg/payload/neutral/builder.mjs

@@ -0,0 +1,3 @@
+// src/builder.ts
+export * from "../../payload-builder/neutral/index.mjs";
+//# sourceMappingURL=builder.mjs.map

package/dist/_pkg/payload/neutral/index.d.ts

@@ -0,0 +1,6 @@
+export * from '../../huri/neutral/index.ts';
+export * from '../../payload-builder/neutral/index.ts';
+export * from '../../payload-model/neutral/index.ts';
+export * from '../../payload-validator/neutral/index.ts';
+export * from '../../payload-wrapper/neutral/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/payload/neutral/index.mjs

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

package/dist/_pkg/payload/neutral/model.d.ts

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

package/dist/_pkg/payload/neutral/model.mjs

@@ -0,0 +1,3 @@
+// src/model.ts
+export * from "../../payload-model/neutral/index.mjs";
+//# sourceMappingURL=model.mjs.map

package/dist/_pkg/payload/neutral/validator.d.ts

@@ -0,0 +1,2 @@
+export * from '../../payload-validator/neutral/index.ts';
+//# sourceMappingURL=validator.d.ts.map

package/dist/_pkg/payload/neutral/validator.mjs

@@ -0,0 +1,3 @@
+// src/validator.ts
+export * from "../../payload-validator/neutral/index.mjs";
+//# sourceMappingURL=validator.mjs.map

package/dist/_pkg/payload/neutral/wrapper.d.ts

@@ -0,0 +1,2 @@
+export * from '../../payload-wrapper/neutral/index.ts';
+//# sourceMappingURL=wrapper.d.ts.map

package/dist/_pkg/payload/neutral/wrapper.mjs

@@ -0,0 +1,3 @@
+// src/wrapper.ts
+export * from "../../payload-wrapper/neutral/index.mjs";
+//# sourceMappingURL=wrapper.mjs.map

package/dist/_pkg/payload-builder/neutral/Builder.d.ts

@@ -0,0 +1,70 @@
+import type { AnyObject, Compare, EmptyObject, Hash, Promisable } from '@xylabs/sdk';
+import type { Payload, Schema, Sequence, WithHashMeta, WithOnlyClientMeta, WithOptionalSchema, WithoutClientMeta, WithoutMeta, WithoutPrivateStorageMeta, WithoutSchema, WithoutStorageMeta, WithStorageMeta } from '../../payload-model/neutral/index.ts';
+import type { PayloadBuilderOptions } from './Options.ts';
+export declare const omitSchema: <T extends WithOptionalSchema>(payload: T) => WithoutSchema<T>;
+export declare class PayloadBuilder<T extends Payload = Payload<AnyObject>, R = T> {
+    readonly options: PayloadBuilderOptions;
+    protected _fields?: WithoutStorageMeta<WithoutClientMeta<WithoutSchema<T>>>;
+    protected _meta?: WithOnlyClientMeta<T>;
+    protected _schema: Schema;
+    constructor(options: PayloadBuilderOptions);
+    static addHashMeta<T extends Payload>(payload: T): Promise<WithHashMeta<T>>;
+    static addHashMeta<T extends Payload>(payloads: T[]): Promise<WithHashMeta<T>[]>;
+    static addStorageMeta<T extends Payload>(payload: T, index?: number): Promise<WithStorageMeta<T>>;
+    static addStorageMeta<T extends Payload>(payloads: T[]): Promise<WithStorageMeta<T>[]>;
+    static compareStorageMeta(this: void, a: WithStorageMeta<Payload>, b: WithStorageMeta<Payload>, comparer?: Compare<Sequence>): number;
+    static dataHash<T extends Payload>(payload: T): Promise<Hash>;
+    static dataHashPairs<T extends Payload>(payloads: T[]): Promise<[T, Hash][]>;
+    static dataHashableFields<T extends Payload>(schema: Schema, payload: WithoutSchema<T>): Promisable<WithoutMeta<T>>;
+    static dataHashes(payloads: undefined): Promise<undefined>;
+    static dataHashes<T extends Payload>(payloads: T[]): Promise<Hash[]>;
+    static filterExclude<T extends Payload>(payloads: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static filterExcludeByDataHash<T extends Payload>(payloads: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static filterIncludeByDataHash<T extends Payload>(payloads: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static filterIncludeByEitherHash<T extends Payload>(payloads: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static findByDataHash<T extends Payload>(payloads: T[] | undefined, hash: Hash): Promise<T | undefined>;
+    static hash<T extends Payload>(payload: T): Promise<Hash>;
+    /**
+     * Creates an array of payload/hash tuples based on the payloads passed in
+     * @param objs Any array of payloads
+     * @returns An array of payload/hash tuples
+     */
+    static hashPairs<T extends Payload>(payloads: T[]): Promise<[T, Hash][]>;
+    static hashableFields<T extends Payload>(payload: T): WithoutStorageMeta<T>;
+    static hashes(payloads: undefined): Promise<undefined>;
+    static hashes<T extends Payload>(payloads: T[]): Promise<Hash[]>;
+    static omitClientMeta<T extends Payload>(payloads: T[], maxDepth?: number): WithoutClientMeta<T>[];
+    static omitClientMeta<T extends EmptyObject>(payloads: T[], maxDepth?: number): WithoutClientMeta<T>[];
+    static omitClientMeta<T extends Payload>(payload: T, maxDepth?: number): WithoutClientMeta<T>;
+    static omitClientMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutClientMeta<T>;
+    static omitMeta<T extends Payload>(payloads: T[], maxDepth?: number): WithoutMeta<T>[];
+    static omitMeta<T extends EmptyObject>(payloads: T[], maxDepth?: number): WithoutMeta<T>[];
+    static omitMeta<T extends Payload>(payload: T, maxDepth?: number): WithoutMeta<T>;
+    static omitMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutMeta<T>;
+    static omitPrivateStorageMeta<T extends Payload>(payloads: T[], maxDepth?: number): WithoutPrivateStorageMeta<T>[];
+    static omitPrivateStorageMeta<T extends EmptyObject>(payloads: T[], maxDepth?: number): WithoutPrivateStorageMeta<T>[];
+    static omitPrivateStorageMeta<T extends Payload>(payload: T, maxDepth?: number): WithoutPrivateStorageMeta<T>;
+    static omitPrivateStorageMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutPrivateStorageMeta<T>;
+    static omitStorageMeta<T extends EmptyObject[]>(payloads: T, maxDepth?: number): WithoutStorageMeta<T[number]>[];
+    static omitStorageMeta<T extends Payload[]>(payloads: T, maxDepth?: number): WithoutStorageMeta<T[number]>[];
+    static omitStorageMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutStorageMeta<T>;
+    static omitStorageMeta<T extends Payload>(payload: T, maxDepth?: number): WithoutStorageMeta<T>;
+    static pickClientMeta<T extends Payload>(payloads: T[], maxDepth?: number): WithOnlyClientMeta<T>[];
+    static pickClientMeta<T extends Payload>(payload: T, maxDepth?: number): WithOnlyClientMeta<T>;
+    static sortByStorageMeta<T extends Payload>(payloads: WithStorageMeta<T>[], direction?: -1 | 1, comparer?: Compare<Sequence>): WithStorageMeta<T>[];
+    static toAllHashMap<T extends Payload>(payloads: T[]): Promise<Record<Hash, T>>;
+    static toDataHashMap<T extends Payload>(objs: T[]): Promise<Record<Hash, T>>;
+    /**
+     * Creates an object map of payload hashes to payloads based on the payloads passed in
+     * @param objs Any array of payloads
+     * @returns A map of hashes to payloads
+     */
+    static toHashMap<T extends Payload>(objs: T[]): Promise<Record<Hash, T>>;
+    private static addSequencedStorageMeta;
+    build(): R;
+    dataHashableFields(): Promise<WithoutMeta<T>>;
+    fields(fields: WithoutSchema<WithoutStorageMeta<WithoutClientMeta<T>>>): this;
+    meta(meta: WithOnlyClientMeta<T>): this;
+    schema(value: Schema): void;
+}
+//# sourceMappingURL=Builder.d.ts.map

package/dist/_pkg/payload-builder/neutral/Options.d.ts

@@ -0,0 +1,7 @@
+import type { Logger } from '@xylabs/sdk';
+import type { Schema } from '../../payload-model/neutral/index.ts';
+export interface PayloadBuilderOptions {
+    readonly logger?: Logger;
+    readonly schema: Schema;
+}
+//# sourceMappingURL=Options.d.ts.map

package/dist/_pkg/payload-builder/neutral/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Builder.ts';
+export * from './Options.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/payload-builder/neutral/index.mjs

@@ -0,0 +1,218 @@
+// src/Builder.ts
+import {
+  assertEx,
+  exists,
+  isJsonObject,
+  omitByPrefix,
+  pickByPrefix,
+  toSafeJson
+} from "@xylabs/sdk";
+import { ObjectHasher, removeEmptyFields } from "../../hash/neutral/index-browser.mjs";
+import {
+  SequenceComparer,
+  SequenceParser
+} from "../../payload-model/neutral/index.mjs";
+var omitSchema = (payload) => {
+  const result = structuredClone(payload);
+  delete result.schema;
+  return result;
+};
+var PayloadBuilder = class _PayloadBuilder {
+  options;
+  _fields;
+  _meta;
+  _schema;
+  constructor(options) {
+    this.options = options;
+    const { schema } = options;
+    this._schema = schema;
+  }
+  static async addHashMeta(payloads) {
+    if (Array.isArray(payloads)) {
+      return await Promise.all(
+        payloads.map(async (payload) => {
+          return await this.addHashMeta(payload);
+        })
+      );
+    }
+    const _hash = await this.hash(payloads);
+    const _dataHash = await this.dataHash(payloads);
+    return {
+      ...payloads,
+      _dataHash,
+      _hash
+    };
+  }
+  static async addStorageMeta(payloads, index = 0) {
+    return Array.isArray(payloads) ? await (async () => {
+      const timestamp = Date.now();
+      const sequencedPayloads = await Promise.all(payloads.map(async (payload, i) => await this.addSequencedStorageMeta(
+        payload,
+        timestamp,
+        i
+      )));
+      return sequencedPayloads.toSorted(this.compareStorageMeta);
+    })() : this.addSequencedStorageMeta(
+      payloads,
+      index
+    );
+  }
+  static compareStorageMeta(a, b, comparer = SequenceComparer.local) {
+    return comparer(a._sequence, b._sequence);
+  }
+  static async dataHash(payload) {
+    return await ObjectHasher.hash(this.omitMeta(payload));
+  }
+  static async dataHashPairs(payloads) {
+    return await Promise.all(
+      payloads.map(async (payload) => {
+        const dataHash = await this.dataHash(payload);
+        return [payload, dataHash];
+      })
+    );
+  }
+  static dataHashableFields(schema, payload) {
+    const cleanFields = removeEmptyFields({ ...payload, schema });
+    assertEx(
+      cleanFields == void 0 || isJsonObject(cleanFields),
+      () => `Fields must be JsonObject: ${JSON.stringify(toSafeJson(cleanFields), null, 2)}`
+    );
+    return this.omitMeta(cleanFields);
+  }
+  static async dataHashes(payloads) {
+    return payloads ? await Promise.all(
+      payloads.map(async (payload) => {
+        return await this.dataHash(payload);
+      })
+    ) : void 0;
+  }
+  static async filterExclude(payloads = [], hash) {
+    return await ObjectHasher.filterExcludeByHash(await this.filterExcludeByDataHash(payloads, hash), hash);
+  }
+  static async filterExcludeByDataHash(payloads = [], hash) {
+    const hashes = Array.isArray(hash) ? hash : [hash];
+    const pairs = await this.dataHashPairs(payloads);
+    return pairs.filter(([_, objHash]) => !hashes.includes(objHash))?.map((pair) => pair[0]);
+  }
+  static async filterIncludeByDataHash(payloads = [], hash) {
+    const hashes = Array.isArray(hash) ? hash : [hash];
+    const pairs = await this.dataHashPairs(payloads);
+    return pairs.filter(([_, objHash]) => hashes.includes(objHash))?.map((pair) => pair[0]);
+  }
+  static async filterIncludeByEitherHash(payloads = [], hash) {
+    const hashes = Array.isArray(hash) ? hash : [hash];
+    const map = await this.toAllHashMap(payloads);
+    return hashes.map((hash2) => map[String(hash2)]).filter(exists);
+  }
+  static async findByDataHash(payloads = [], hash) {
+    const pairs = await this.dataHashPairs(payloads);
+    return pairs.find(([_, objHash]) => objHash === hash)?.[0];
+  }
+  static async hash(payload) {
+    return await ObjectHasher.hash(this.omitStorageMeta(payload));
+  }
+  /**
+   * Creates an array of payload/hash tuples based on the payloads passed in
+   * @param objs Any array of payloads
+   * @returns An array of payload/hash tuples
+   */
+  static async hashPairs(payloads) {
+    return await Promise.all(
+      payloads.map(async (payload) => {
+        return [payload, await this.hash(payload)];
+      })
+    );
+  }
+  static hashableFields(payload) {
+    return this.omitStorageMeta(payload);
+  }
+  static async hashes(payloads) {
+    return await ObjectHasher.hashes(payloads);
+  }
+  static omitClientMeta(payloads, maxDepth = 1) {
+    return Array.isArray(payloads) ? payloads.map((payload) => this.omitClientMeta(payload, maxDepth)) : omitByPrefix(payloads, "$", maxDepth);
+  }
+  static omitMeta(payloads, maxDepth = 1) {
+    return Array.isArray(payloads) ? payloads.map((payload) => this.omitMeta(payload, maxDepth)) : this.omitStorageMeta(this.omitClientMeta(payloads, maxDepth), maxDepth);
+  }
+  static omitPrivateStorageMeta(payloads, maxDepth = 1) {
+    return Array.isArray(payloads) ? payloads.map((payload) => this.omitPrivateStorageMeta(payload, maxDepth)) : omitByPrefix(payloads, "__", maxDepth);
+  }
+  static omitStorageMeta(payloads, maxDepth = 1) {
+    return Array.isArray(payloads) ? payloads.map((payload) => this.omitStorageMeta(payload, maxDepth)) : omitByPrefix(payloads, "_", maxDepth);
+  }
+  static pickClientMeta(payloads, maxDepth = 1) {
+    return Array.isArray(payloads) ? payloads.map((payload) => this.pickClientMeta(payload, maxDepth)) : pickByPrefix(payloads, "$", maxDepth);
+  }
+  static sortByStorageMeta(payloads, direction = 1, comparer = SequenceComparer.local) {
+    return payloads.toSorted((a, b) => direction * comparer(a._sequence, b._sequence));
+  }
+  static async toAllHashMap(payloads) {
+    const pairs = await this.hashPairs(payloads);
+    const entries = await Promise.all(
+      pairs.map(async ([payload, payloadHash]) => {
+        const dataHash = await this.dataHash(payload);
+        return [
+          [payloadHash, payload],
+          [dataHash, payload]
+        ];
+      })
+    );
+    return Object.fromEntries(entries.flat());
+  }
+  static async toDataHashMap(objs) {
+    const pairs = await this.dataHashPairs(objs);
+    return Object.fromEntries(pairs.map(([payload, dataHash]) => [dataHash, payload]));
+  }
+  /**
+   * Creates an object map of payload hashes to payloads based on the payloads passed in
+   * @param objs Any array of payloads
+   * @returns A map of hashes to payloads
+   */
+  static async toHashMap(objs) {
+    const pairs = await this.hashPairs(objs);
+    return Object.fromEntries(pairs.map(([payload, payloadHash]) => [payloadHash, payload]));
+  }
+  static async addSequencedStorageMeta(payload, timestamp, index = 0) {
+    const withHashMeta = await this.addHashMeta(payload);
+    const _sequence = SequenceParser.from(timestamp, withHashMeta._hash, index).localSequence;
+    return {
+      ...withHashMeta,
+      _sequence
+    };
+  }
+  build() {
+    return {
+      schema: this._schema,
+      ...this._fields,
+      ...this._meta
+    };
+  }
+  async dataHashableFields() {
+    return await _PayloadBuilder.dataHashableFields(
+      assertEx(this._schema, () => "Payload: Missing Schema"),
+      // TODO: Add verification that required fields are present
+      this._fields
+    );
+  }
+  fields(fields) {
+    const clonedFields = structuredClone(fields);
+    const withoutEmptyFields = removeEmptyFields(clonedFields);
+    const withoutSchema = omitSchema(withoutEmptyFields);
+    const withoutStorageMeta = _PayloadBuilder.omitStorageMeta(withoutSchema);
+    this._fields = _PayloadBuilder.omitClientMeta(withoutStorageMeta);
+    return this;
+  }
+  meta(meta) {
+    this._meta = pickByPrefix(meta, "$");
+    return this;
+  }
+  schema(value) {
+    this._schema = value;
+  }
+};
+export {
+  PayloadBuilder,
+  omitSchema
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/payload-model/neutral/Error.d.ts

@@ -0,0 +1,65 @@
+import * as z from 'zod/mini';
+export declare const ModuleErrorSchema: "network.xyo.error.module" & {
+    readonly __schema: true;
+};
+export type ModuleErrorSchema = typeof ModuleErrorSchema;
+export declare const ModuleErrorZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.error.module" & {
+        readonly __schema: true;
+    }>;
+    details: z.ZodMiniOptional<z.ZodMiniCustom<unknown, unknown>>;
+    message: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    query: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>]>>;
+}, z.core.$strip>;
+export type ModuleError = z.infer<typeof ModuleErrorZod>;
+export declare const isModuleError: <T>(value: T) => value is T & {
+    schema: "network.xyo.error.module" & {
+        readonly __schema: true;
+    };
+    details?: unknown;
+    message?: string | undefined;
+    name?: string | undefined;
+    query?: import("./Schema.ts").BrandedSchema<string> | import("@xylabs/sdk").BrandedHash | undefined;
+};
+export declare const asModuleError: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.error.module" & {
+            readonly __schema: true;
+        };
+        details?: unknown;
+        message?: string | undefined;
+        name?: string | undefined;
+        query?: import("./Schema.ts").BrandedSchema<string> | import("@xylabs/sdk").BrandedHash | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.error.module" & {
+            readonly __schema: true;
+        };
+        details?: unknown;
+        message?: string | undefined;
+        name?: string | undefined;
+        query?: import("./Schema.ts").BrandedSchema<string> | import("@xylabs/sdk").BrandedHash | undefined;
+    };
+};
+export declare const toModuleError: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.error.module" & {
+            readonly __schema: true;
+        };
+        details?: unknown;
+        message?: string | undefined;
+        name?: string | undefined;
+        query?: import("./Schema.ts").BrandedSchema<string> | import("@xylabs/sdk").BrandedHash | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.error.module" & {
+            readonly __schema: true;
+        };
+        details?: unknown;
+        message?: string | undefined;
+        name?: string | undefined;
+        query?: import("./Schema.ts").BrandedSchema<string> | import("@xylabs/sdk").BrandedHash | undefined;
+    };
+};
+//# sourceMappingURL=Error.d.ts.map