@xyo-network/sdk 2.102.4 → 7.0.3

package/dist/_pkg/module-wrapper/neutral/ModuleWrapper.d.ts

@@ -0,0 +1,97 @@
+import type { CreatableName, EventAnyListener, EventEmitter, EventListener, EventUnsubscribeFunction, Logger, Promisable } from '@xylabs/sdk';
+import { Base, PromiseEx } from '@xylabs/sdk';
+import type { AddressPreviousHashPayload, AnyConfigSchema, AttachableModuleInstance, InstanceTypeCheck, ModuleConfig, ModuleEventData, ModuleFilterOptions, ModuleIdentifier, ModuleInstance, ModuleQueryResult, ModuleResolverInstance, ModuleStatus, QueryableModule, QueryableModuleParams, QueryableModuleTypeCheck } from '../../module-model/neutral/index.ts';
+import type { AccountInstance, ModuleError, ModuleManifestPayload, Payload, Query, QueryBoundWitness, XyoAddress, XyoQuantAddress } from '../../sdk-protocol/neutral/index.ts';
+import { LRUCache } from 'lru-cache';
+import type { ModuleWrapperParams } from './models.ts';
+export interface ConstructableModuleWrapper<TWrapper extends ModuleWrapper> {
+    defaultLogger?: Logger;
+    instanceIdentityCheck: InstanceTypeCheck;
+    moduleIdentityCheck: QueryableModuleTypeCheck;
+    requiredQueries: string[];
+    new (params: ModuleWrapperParams<TWrapper['mod']>): TWrapper;
+    canWrap(mod: QueryableModule | undefined): boolean;
+    is<TModuleWrapper extends ModuleWrapper>(this: ConstructableModuleWrapper<TModuleWrapper>, wrapper?: any): wrapper is TModuleWrapper;
+    tryWrap<TModuleWrapper extends ModuleWrapper>(this: ConstructableModuleWrapper<TModuleWrapper>, mod: QueryableModule | undefined, account: AccountInstance, checkIdentity?: boolean): TModuleWrapper | undefined;
+    wrap<TModuleWrapper extends ModuleWrapper>(this: ConstructableModuleWrapper<TModuleWrapper>, mod: QueryableModule | undefined, account: AccountInstance, checkIdentity?: boolean): TModuleWrapper;
+}
+export declare function constructableModuleWrapper<TWrapper extends ModuleWrapper>(): <U extends ConstructableModuleWrapper<TWrapper>>(constructor: U) => void;
+export declare class ModuleWrapper<TWrappedModule extends QueryableModule = QueryableModule> extends Base<Exclude<Omit<TWrappedModule['params'], 'config'> & {
+    config: Exclude<TWrappedModule['params']['config'], undefined>;
+}, undefined>> implements AttachableModuleInstance<TWrappedModule['params'], TWrappedModule['eventData']> {
+    static readonly instanceIdentityCheck: InstanceTypeCheck;
+    static readonly moduleIdentityCheck: QueryableModuleTypeCheck;
+    static readonly requiredQueries: string[];
+    eventData: TWrappedModule["eventData"];
+    protected readonly cachedCalls: LRUCache<string, Payload[], unknown>;
+    protected readonly wrapperParams: ModuleWrapperParams<TWrappedModule>;
+    private _parents;
+    private _status;
+    constructor(params: ModuleWrapperParams<TWrappedModule>);
+    get account(): AccountInstance;
+    get additionalSigners(): AccountInstance[];
+    get address(): (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | XyoQuantAddress;
+    get config(): Exclude<TWrappedModule["params"]["config"], undefined>;
+    get downResolver(): ModuleResolverInstance;
+    get id(): string;
+    get mod(): TWrappedModule;
+    get modName(): string | undefined;
+    get name(): CreatableName;
+    get priority(): 1;
+    get privateResolver(): ModuleResolverInstance;
+    get queries(): string[];
+    get upResolver(): ModuleResolverInstance;
+    get status(): ModuleStatus;
+    protected set status(value: ModuleStatus);
+    /** Narrowed view of `mod` typed against the wrapped module's actual `eventData` so generic event method calls type-check across the constraint boundary. */
+    protected get modEvents(): EventEmitter<TWrappedModule['eventData']>;
+    static canWrap(mod?: QueryableModule): mod is QueryableModule<QueryableModuleParams<AnyConfigSchema<ModuleConfig>>, ModuleEventData<object>>;
+    static hasRequiredQueries(mod: QueryableModule): boolean;
+    static is<TModuleWrapper extends ModuleWrapper>(this: ConstructableModuleWrapper<TModuleWrapper>, wrapper: any): wrapper is TModuleWrapper;
+    static missingRequiredQueries(mod: QueryableModule): string[];
+    static tryWrap<TModuleWrapper extends ModuleWrapper>(this: ConstructableModuleWrapper<TModuleWrapper>, mod: QueryableModule | undefined, account: AccountInstance, checkIdentity?: boolean): TModuleWrapper | undefined;
+    static with<TModuleWrapper extends ModuleWrapper, R extends Promisable<void> = void>(this: ConstructableModuleWrapper<TModuleWrapper>, mod: any, closure: (mod: TModuleWrapper) => R): R | undefined;
+    static wrap<TModuleWrapper extends ModuleWrapper>(this: ConstructableModuleWrapper<TModuleWrapper>, mod: QueryableModule | undefined, account: AccountInstance, checkIdentity?: boolean): TModuleWrapper;
+    addParent(mod: ModuleInstance): void;
+    addressPreviousHash(): Promise<AddressPreviousHashPayload>;
+    clearListeners(eventNames: Parameters<TWrappedModule['clearListeners']>[0]): void;
+    emit<TEventName extends keyof TWrappedModule['eventData']>(eventName: TEventName, eventArgs: TWrappedModule['eventData'][TEventName]): Promise<void>;
+    emitSerial<TEventName extends keyof TWrappedModule['eventData']>(eventName: TEventName, eventArgs: TWrappedModule['eventData'][TEventName]): Promise<void>;
+    listenerCount(eventNames: Parameters<TWrappedModule['listenerCount']>[0]): number;
+    manifest(maxDepth?: number): Promise<ModuleManifestPayload>;
+    manifestQuery(account: AccountInstance, maxDepth?: number): Promise<ModuleQueryResult<ModuleManifestPayload>>;
+    moduleAddress(): Promise<AddressPreviousHashPayload[]>;
+    off<TEventName extends keyof TWrappedModule['eventData']>(eventNames: TEventName, listener: EventListener<TWrappedModule['eventData'][TEventName]>): void;
+    offAny(listener: EventAnyListener): void;
+    on<TEventName extends keyof TWrappedModule['eventData']>(eventNames: TEventName, listener: EventListener<TWrappedModule['eventData'][TEventName]>): EventUnsubscribeFunction;
+    onAny(listener: EventAnyListener): EventUnsubscribeFunction;
+    once<TEventName extends keyof TWrappedModule['eventData']>(eventName: TEventName, listener: EventListener<TWrappedModule['eventData'][TEventName]>): EventUnsubscribeFunction;
+    parents(): Promisable<ModuleInstance[]>;
+    previousHash(): Promise<string | undefined>;
+    previousHashQuery(account?: AccountInstance): Promise<ModuleQueryResult<AddressPreviousHashPayload>>;
+    privateChildren(): Promise<ModuleInstance[]>;
+    publicChildren(): Promise<ModuleInstance[]>;
+    query<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryResult>;
+    queryable<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promisable<boolean>;
+    removeParent(address: XyoAddress): void;
+    /** @deprecated do not pass undefined.  If trying to get all, pass '*' */
+    resolve<T extends ModuleInstance = ModuleInstance>(): Promise<T[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<ModuleInstance>;
+    resolvePrivate<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolvePrivate<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>;
+    siblings(): Promise<ModuleInstance[]>;
+    start(): Promise<boolean>;
+    state(): Promise<Payload[]>;
+    stateQuery(_account: AccountInstance): Promise<ModuleQueryResult>;
+    stop(): Promise<boolean>;
+    protected bindQuery<T extends Query>(query: T, payloads?: Payload[], account?: AccountInstance, additionalSigners?: AccountInstance[]): PromiseEx<[QueryBoundWitness, Payload[], ModuleError[]], AccountInstance>;
+    protected bindQueryInternal<T extends Query>(query: T, payloads?: Payload[], account?: AccountInstance, additionalSigners?: AccountInstance[]): Promise<[QueryBoundWitness, Payload[], ModuleError[]]>;
+    protected filterErrors([bw, payloads]: ModuleQueryResult): ModuleError[];
+    protected sendQuery<T extends Query, P extends Payload = Payload, R extends Payload = Payload>(queryPayload: T, payloads?: P[]): Promise<R[]>;
+    protected sendQueryRaw<T extends Query, P extends Payload = Payload, R extends Payload = Payload>(queryPayload: T, payloads?: P[], account?: AccountInstance): Promise<ModuleQueryResult<R>>;
+}

package/dist/_pkg/module-wrapper/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './models.ts';
+export * from './ModuleWrapper.ts';

package/dist/_pkg/module-wrapper/neutral/index.mjs

@@ -0,0 +1,317 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/ModuleWrapper.ts
+import {
+  assertEx,
+  Base,
+  exists,
+  isDefined,
+  PromiseEx
+} from "@xylabs/sdk";
+import {
+  AddressPreviousHashSchema,
+  asAttachableModuleInstance,
+  asModuleInstance,
+  duplicateModules,
+  isModuleInstance,
+  isQueryableModule,
+  ModuleAddressQuerySchema,
+  ModuleManifestQuerySchema,
+  ModuleStateQuerySchema,
+  ObjectResolverPriority
+} from "../../module-model/neutral/index.mjs";
+import {
+  BoundWitnessWrapper,
+  ModuleErrorSchema,
+  QueryBoundWitnessBuilder
+} from "../../sdk-protocol/neutral/index.mjs";
+import { LRUCache } from "lru-cache";
+function constructableModuleWrapper() {
+  return (constructor) => {
+    constructor;
+  };
+}
+var ModuleWrapper = class extends Base {
+  eventData = {};
+  cachedCalls = new LRUCache({
+    max: 1e3,
+    ttl: 1e3 * 60,
+    ttlAutopurge: true
+  });
+  wrapperParams;
+  _parents = [];
+  _status = "wrapped";
+  constructor(params) {
+    const mutatedWrapperParams = { ...params };
+    const mutatedParams = { ...params.mod.params, config: { ...params.mod.params.config } };
+    super(mutatedParams);
+    this.wrapperParams = mutatedWrapperParams;
+  }
+  get account() {
+    return this.wrapperParams.account;
+  }
+  get additionalSigners() {
+    return this.wrapperParams.additionalSigners ?? [];
+  }
+  get address() {
+    return this.mod.address;
+  }
+  get config() {
+    return this.mod.config;
+  }
+  get downResolver() {
+    const instance = asAttachableModuleInstance(this.mod);
+    if (instance) {
+      return instance.downResolver;
+    }
+    throw new Error("Unsupported");
+  }
+  get id() {
+    return this.mod.id;
+  }
+  get mod() {
+    return this.wrapperParams.mod;
+  }
+  get modName() {
+    return this.mod.modName;
+  }
+  get name() {
+    return "ModuleWrapper";
+  }
+  get priority() {
+    return ObjectResolverPriority.Low;
+  }
+  get privateResolver() {
+    const instance = asAttachableModuleInstance(this.mod);
+    if (instance) {
+      return instance.privateResolver;
+    }
+    throw new Error("Unsupported");
+  }
+  get queries() {
+    return this.mod.queries;
+  }
+  get upResolver() {
+    const instance = asAttachableModuleInstance(this.mod);
+    if (instance) {
+      return instance.upResolver;
+    }
+    throw new Error("Unsupported");
+  }
+  // Getter/setter adjacency conflicts with the class member-ordering rule here.
+  // eslint-disable-next-line @typescript-eslint/member-ordering
+  get status() {
+    return this._status;
+  }
+  set status(value) {
+    this._status = value;
+  }
+  /** Narrowed view of `mod` typed against the wrapped module's actual `eventData` so generic event method calls type-check across the constraint boundary. */
+  // eslint-disable-next-line @typescript-eslint/member-ordering
+  get modEvents() {
+    return this.wrapperParams.mod;
+  }
+  static canWrap(mod) {
+    return !!mod && this.moduleIdentityCheck(mod);
+  }
+  static hasRequiredQueries(mod) {
+    return this.missingRequiredQueries(mod).length === 0;
+  }
+  static is(wrapper) {
+    return wrapper instanceof this;
+  }
+  static missingRequiredQueries(mod) {
+    const modQueries = mod.queries;
+    return this.requiredQueries.map((query) => {
+      return modQueries.includes(query) ? null : query;
+    }).filter(exists);
+  }
+  static tryWrap(mod, account, checkIdentity = true) {
+    if (!checkIdentity || this.canWrap(mod)) {
+      return new this({ account, mod });
+    }
+  }
+  static with(mod, closure) {
+    return this.is(mod) ? closure(mod) : void 0;
+  }
+  static wrap(mod, account, checkIdentity = true) {
+    assertEx(!checkIdentity || mod && this.moduleIdentityCheck(mod), () => `Passed mod failed identity check: ${mod?.config?.schema}`);
+    return assertEx(this.tryWrap(mod, account, checkIdentity), () => "Unable to wrap mod as ModuleWrapper");
+  }
+  addParent(mod) {
+    const hasExistingEntry = this._parents.some((parent) => parent.address === mod.address);
+    if (!hasExistingEntry) {
+      this._parents.push(mod);
+    }
+  }
+  async addressPreviousHash() {
+    const queryPayload = { schema: ModuleAddressQuerySchema };
+    return assertEx(
+      (await this.sendQuery(queryPayload)).find((payload) => payload.schema === AddressPreviousHashSchema),
+      () => "Result did not include correct payload"
+    );
+  }
+  clearListeners(eventNames) {
+    return this.mod.clearListeners(eventNames);
+  }
+  emit(eventName, eventArgs) {
+    return this.modEvents.emit(eventName, eventArgs);
+  }
+  emitSerial(eventName, eventArgs) {
+    return this.modEvents.emitSerial(eventName, eventArgs);
+  }
+  listenerCount(eventNames) {
+    return this.mod.listenerCount(eventNames);
+  }
+  async manifest(maxDepth) {
+    const queryPayload = { schema: ModuleManifestQuerySchema, ...maxDepth === void 0 ? {} : { maxDepth } };
+    return (await this.sendQuery(queryPayload))[0];
+  }
+  async manifestQuery(account, maxDepth) {
+    const queryPayload = { schema: ModuleManifestQuerySchema, ...maxDepth === void 0 ? {} : { maxDepth } };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async moduleAddress() {
+    const queryPayload = { schema: ModuleAddressQuerySchema };
+    return await this.sendQuery(queryPayload);
+  }
+  off(eventNames, listener) {
+    return this.modEvents.off(eventNames, listener);
+  }
+  offAny(listener) {
+    return this.mod.offAny(listener);
+  }
+  on(eventNames, listener) {
+    return this.modEvents.on(eventNames, listener);
+  }
+  onAny(listener) {
+    return this.mod.onAny(listener);
+  }
+  once(eventName, listener) {
+    return this.modEvents.once(eventName, listener);
+  }
+  parents() {
+    return this._parents;
+  }
+  async previousHash() {
+    const queryPayload = { schema: ModuleAddressQuerySchema };
+    return (await this.sendQuery(queryPayload)).pop().previousHash;
+  }
+  async previousHashQuery(account) {
+    const queryPayload = { schema: ModuleAddressQuerySchema };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  async privateChildren() {
+    if (isModuleInstance(this.mod)) {
+      return await this.mod.privateChildren();
+    }
+    return [];
+  }
+  async publicChildren() {
+    if (isModuleInstance(this.mod)) {
+      return await this.mod.publicChildren();
+    }
+    return [];
+  }
+  async query(query, payloads) {
+    return await this.mod.query(query, payloads);
+  }
+  queryable(query, payloads) {
+    return this.mod.queryable(query, payloads);
+  }
+  removeParent(address) {
+    this._parents = this._parents.filter((item) => item.address !== address);
+  }
+  async resolve(id = "*", options) {
+    const instance = asModuleInstance(this.mod);
+    if (instance?.resolve) {
+      if (id === "*") {
+        return await instance.resolve("*", options);
+      }
+      switch (typeof id) {
+        case "string": {
+          return await instance.resolve(id, options);
+        }
+        default: {
+          return;
+        }
+      }
+    }
+    return typeof id === "string" && id !== "*" ? void 0 : [];
+  }
+  async resolvePrivate(id, _options) {
+    if (id === "*") return await Promise.resolve([]);
+  }
+  async siblings() {
+    return (await Promise.all((await this.parents()).map((parent) => parent.publicChildren()))).flat().filter(duplicateModules);
+  }
+  start() {
+    throw new Error("Cannot start a wrapped module");
+  }
+  async state() {
+    const cachedResult = this.cachedCalls.get("state");
+    if (cachedResult) {
+      return cachedResult;
+    }
+    const queryPayload = { schema: ModuleStateQuerySchema };
+    const result = await this.sendQuery(queryPayload);
+    this.cachedCalls.set("state", result);
+    return result;
+  }
+  async stateQuery(_account) {
+    const queryPayload = { schema: ModuleStateQuerySchema };
+    return await this.sendQueryRaw(queryPayload);
+  }
+  stop() {
+    throw new Error("Cannot stop a wrapped module");
+  }
+  bindQuery(query, payloads, account = this.account, additionalSigners = this.additionalSigners) {
+    return new PromiseEx(async (resolve) => {
+      const result = await this.bindQueryInternal(query, payloads, account, additionalSigners);
+      resolve?.(result);
+      return result;
+    }, account);
+  }
+  async bindQueryInternal(query, payloads, account = this.account, additionalSigners = this.additionalSigners) {
+    const builder = new QueryBoundWitnessBuilder().payloads(payloads).query(query);
+    const accounts = [account, ...additionalSigners].filter(exists);
+    return await (accounts.length > 0 ? builder.signers(accounts) : builder).build();
+  }
+  filterErrors([bw, payloads]) {
+    const wrapper = BoundWitnessWrapper.wrap(bw, payloads);
+    return wrapper.payloadsBySchema(ModuleErrorSchema);
+  }
+  async sendQuery(queryPayload, payloads) {
+    const queryResults = await this.sendQueryRaw(queryPayload, payloads);
+    const [, resultPayloads, errors] = queryResults;
+    if (isDefined(errors) && errors.length > 0) {
+      throw new Error(JSON.stringify(errors[0]));
+    }
+    return resultPayloads;
+  }
+  async sendQueryRaw(queryPayload, payloads, account) {
+    const query = await this.bindQuery(queryPayload, payloads, account);
+    return await this.query(query[0], query[1]);
+  }
+};
+__publicField(ModuleWrapper, "instanceIdentityCheck", isModuleInstance);
+__publicField(ModuleWrapper, "moduleIdentityCheck", isQueryableModule);
+__publicField(ModuleWrapper, "requiredQueries", [ModuleStateQuerySchema]);
+ModuleWrapper = __decorateClass([
+  constructableModuleWrapper()
+], ModuleWrapper);
+export {
+  ModuleWrapper,
+  constructableModuleWrapper
+};

package/dist/_pkg/module-wrapper/neutral/models.d.ts

@@ -0,0 +1,8 @@
+import type { BaseParams } from '@xylabs/sdk';
+import type { QueryableModule } from '../../module-model/neutral/index.ts';
+import type { AccountInstance } from '../../sdk-protocol/neutral/index.ts';
+export type ModuleWrapperParams<TWrappedModule extends QueryableModule = QueryableModule> = BaseParams<{
+    account: AccountInstance;
+    additionalSigners?: AccountInstance[];
+    mod: TWrappedModule;
+}>;

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

@@ -0,0 +1,78 @@
+import * as z from 'zod/mini';
+export declare const NetworkNodeTypeZod: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"archivist">, z.ZodMiniLiteral<"diviner">, z.ZodMiniLiteral<"bridge">, z.ZodMiniLiteral<"sentinel">]>;
+export type NetworkNodeType = z.infer<typeof NetworkNodeTypeZod>;
+export declare const NetworkNodeSchema: "network.xyo.network.node" & {
+    readonly __schema: true;
+};
+export type NetworkNodeSchema = typeof NetworkNodeSchema;
+export declare const NetworkNodePayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.network.node" & {
+        readonly __schema: true;
+    }>;
+    docs: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    slug: z.ZodMiniString<string>;
+    type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"archivist">, z.ZodMiniLiteral<"diviner">, z.ZodMiniLiteral<"bridge">, z.ZodMiniLiteral<"sentinel">]>;
+    uri: z.ZodMiniString<string>;
+    web: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export type NetworkNodePayload = z.infer<typeof NetworkNodePayloadZod>;
+export declare const isNetworkNodePayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.network.node" & {
+        readonly __schema: true;
+    };
+    slug: string;
+    type: "archivist" | "diviner" | "bridge" | "sentinel";
+    uri: string;
+    docs?: string | undefined;
+    name?: string | undefined;
+    web?: string | undefined;
+};
+export declare const asNetworkNodePayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    };
+};
+export declare const toNetworkNodePayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    };
+};

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

@@ -0,0 +1,16 @@
+import type { Hash } from '@xylabs/sdk';
+import { PayloadWrapper } from '../../payload-wrapper/neutral/index.ts';
+import type { NetworkNodePayload } from './NetworkNodePayload.ts';
+export declare class NetworkNodePayloadWrapper<T extends NetworkNodePayload = NetworkNodePayload> extends PayloadWrapper<T> {
+    static known(hash: Hash): Promise<NetworkNodePayloadWrapper<{
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }>>;
+}

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

@@ -0,0 +1,118 @@
+import * as z from 'zod/mini';
+export declare const NetworkSchema: "network.xyo.network" & {
+    readonly __schema: true;
+};
+export type NetworkSchema = typeof NetworkSchema;
+export declare const NetworkPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.network" & {
+        readonly __schema: true;
+    }>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    nodes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+        schema: z.ZodMiniLiteral<"network.xyo.network.node" & {
+            readonly __schema: true;
+        }>;
+        docs: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        slug: z.ZodMiniString<string>;
+        type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"archivist">, z.ZodMiniLiteral<"diviner">, z.ZodMiniLiteral<"bridge">, z.ZodMiniLiteral<"sentinel">]>;
+        uri: z.ZodMiniString<string>;
+        web: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>>>;
+    slug: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type NetworkPayload = z.infer<typeof NetworkPayloadZod>;
+export declare const isNetworkPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.network" & {
+        readonly __schema: true;
+    };
+    slug: string;
+    name?: string | undefined;
+    nodes?: {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }[] | undefined;
+};
+export declare const asNetworkPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    };
+};
+export declare const toNetworkPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    };
+};