@xyo-network/sdk 2.102.3 → 7.0.2

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

@@ -0,0 +1,62 @@
+import type { Hash } from '@xylabs/sdk';
+import { PayloadWrapper } from '../../payload-wrapper/neutral/index.ts';
+import type { NetworkNodeType } from './NetworkNodePayload.ts';
+import type { NetworkPayload } from './NetworkPayload.ts';
+export declare class NetworkPayloadWrapper extends PayloadWrapper<NetworkPayload> {
+    static known(hash: Hash): Promise<NetworkPayload | undefined>;
+    get archivists(): {
+        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;
+    get bridges(): {
+        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;
+    get diviners(): {
+        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;
+    get sentinels(): {
+        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;
+    filterNodesByType(type: NetworkNodeType): {
+        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;
+}

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

@@ -0,0 +1,7 @@
+export * from './knownArchivists.ts';
+export * from './knownDiviners.ts';
+export * from './knownNetworks.ts';
+export * from './NetworkNodePayload.ts';
+export * from './NetworkNodePayloadWrapper.ts';
+export * from './NetworkPayload.ts';
+export * from './NetworkPayloadWrapper.ts';

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

@@ -0,0 +1,210 @@
+// 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
+};

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

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

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

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

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

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

package/dist/_pkg/node/neutral/abstract.d.ts

@@ -0,0 +1 @@
+export * from '../../node-abstract/neutral/index.ts';

package/dist/_pkg/node/neutral/abstract.mjs

@@ -0,0 +1,2 @@
+// src/abstract.ts
+export * from "../../node-abstract/neutral/index.mjs";

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

@@ -0,0 +1,4 @@
+export * from '../../node-abstract/neutral/index.ts';
+export * from '../../node-memory/neutral/index.ts';
+export * from '../../node-model/neutral/index.ts';
+export * from '../../node-wrapper/neutral/index.ts';

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

@@ -0,0 +1,5 @@
+// src/index.ts
+export * from "../../node-abstract/neutral/index.mjs";
+export * from "../../node-memory/neutral/index.mjs";
+export * from "../../node-model/neutral/index.mjs";
+export * from "../../node-wrapper/neutral/index.mjs";

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

@@ -0,0 +1 @@
+export * from '../../node-model/neutral/index.ts';

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

@@ -0,0 +1,2 @@
+// src/model.ts
+export * from "../../node-model/neutral/index.mjs";

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

@@ -0,0 +1 @@
+export * from '../../node-wrapper/neutral/index.ts';

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

@@ -0,0 +1,2 @@
+// src/wrapper.ts
+export * from "../../node-wrapper/neutral/index.mjs";

package/dist/_pkg/node-abstract/neutral/AbstractNode.d.ts

@@ -0,0 +1,36 @@
+import type { Promisable } from '@xylabs/sdk';
+import { AbstractModuleInstance } from '../../module-abstract/neutral/index.ts';
+import type { AddressPayload, ModuleConfig, ModuleIdentifier, ModuleInstance, ModuleQueryHandlerResult, ModuleQueryResult, QueryableModule } from '../../module-model/neutral/index.ts';
+import type { AttachableNodeInstance, ChildCertification, ChildCertificationFields, NodeInstance, NodeModule, NodeModuleEventData, NodeParams } from '../../node-model/neutral/index.ts';
+import type { AccountInstance, ModuleManifestPayload, Payload, QueryBoundWitness, Schema, XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+export declare abstract class AbstractNode<TParams extends NodeParams = NodeParams, TEventData extends NodeModuleEventData = NodeModuleEventData> extends AbstractModuleInstance<TParams, TEventData> implements AttachableNodeInstance<TParams, TEventData>, QueryableModule<TParams, TEventData>, NodeInstance<TParams, TEventData>, ModuleInstance<TParams, TEventData>, NodeModule<TParams, TEventData> {
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    static readonly uniqueName: string;
+    private readonly isNode;
+    get queries(): Schema[];
+    static isNode(mod: unknown): boolean;
+    attach(id: ModuleIdentifier, external?: boolean): Promise<XyoAddress | undefined>;
+    attachQuery(id: ModuleIdentifier, external?: boolean, account?: AccountInstance): Promise<ModuleQueryResult<AddressPayload>>;
+    attached(): Promise<XyoAddress[]>;
+    attachedHandler(): Promise<XyoAddress[]>;
+    attachedQuery(account?: AccountInstance): Promise<ModuleQueryResult<AddressPayload>>;
+    certify(id: ModuleIdentifier): Promise<ChildCertificationFields | undefined>;
+    certifyQuery(id: ModuleIdentifier, account?: AccountInstance): Promise<ModuleQueryResult<ChildCertification>>;
+    detach(id: ModuleIdentifier): Promise<XyoAddress | undefined>;
+    detachQuery(id: ModuleIdentifier, account?: AccountInstance): Promise<ModuleQueryResult<AddressPayload>>;
+    manifest(maxDepth?: number, ignoreAddresses?: XyoAddress[]): Promise<ModuleManifestPayload>;
+    privateChildren(): Promise<ModuleInstance[]>;
+    publicChildren(): Promise<ModuleInstance[]>;
+    registered(): Promise<XyoAddress[]>;
+    registeredQuery(account?: AccountInstance): Promise<ModuleQueryResult<AddressPayload>>;
+    protected attachedPrivateModules(maxDepth?: number): Promise<ModuleInstance[]>;
+    protected attachedPublicModules(maxDepth?: number): Promise<ModuleInstance[]>;
+    protected generateConfigAndAddress(maxDepth?: number): Promise<Payload[]>;
+    protected manifestHandler(maxDepth?: number, ignoreAddresses?: XyoAddress[]): Promise<ModuleManifestPayload>;
+    protected queryHandler<T extends QueryBoundWitness = QueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(query: T, payloads?: Payload[], queryConfig?: TConfig): Promise<ModuleQueryHandlerResult>;
+    abstract attachHandler(id: ModuleIdentifier, external?: boolean): Promisable<XyoAddress | undefined>;
+    abstract certifyHandler(id: ModuleIdentifier): Promisable<ChildCertificationFields | undefined>;
+    abstract detachHandler(id: ModuleIdentifier): Promisable<XyoAddress | undefined>;
+    abstract registeredHandler(): Promisable<XyoAddress[]>;
+}

package/dist/_pkg/node-abstract/neutral/NodeHelper/attachedPrivateModules.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleInstance } from '../../../module-model/neutral/index.ts';
+import type { NodeInstance } from '../../../node-model/neutral/index.ts';
+export declare const attachedPrivateModules: (node: NodeInstance, maxDepth?: number) => Promise<ModuleInstance[]>;

package/dist/_pkg/node-abstract/neutral/NodeHelper/attachedPublicModules.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleInstance } from '../../../module-model/neutral/index.ts';
+import type { NodeInstance } from '../../../node-model/neutral/index.ts';
+export declare const attachedPublicModules: (node: NodeInstance, maxDepth?: number) => Promise<ModuleInstance[]>;

package/dist/_pkg/node-abstract/neutral/NodeHelper/index.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleInstance } from '../../../module-model/neutral/index.ts';
+import type { NodeInstance } from '../../../node-model/neutral/index.ts';
+export declare const NodeHelper: {
+    attachedPrivateModules: (node: NodeInstance, maxDepth?: number) => Promise<ModuleInstance[]>;
+    attachedPublicModules: (node: NodeInstance, maxDepth?: number) => Promise<ModuleInstance[]>;
+};

package/dist/_pkg/node-abstract/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AbstractNode.ts';
+export * from './NodeHelper/index.ts';

package/dist/_pkg/node-abstract/neutral/index.mjs

@@ -0,0 +1,234 @@
+// src/AbstractNode.ts
+import { assertEx, globallyUnique } from "@xylabs/sdk";
+import { AbstractModuleInstance } from "../../module-abstract/neutral/index.mjs";
+import { AddressSchema } from "../../module-model/neutral/index.mjs";
+import {
+  ChildCertificationSchema,
+  NodeAttachedQuerySchema,
+  NodeAttachQuerySchema,
+  NodeCertifyQuerySchema,
+  NodeConfigSchema,
+  NodeDetachQuerySchema,
+  NodeRegisteredQuerySchema
+} from "../../node-model/neutral/index.mjs";
+import {
+  NodeManifestPayloadSchema,
+  PayloadBuilder,
+  QueryBoundWitnessWrapper
+} from "../../sdk-protocol/neutral/index.mjs";
+var AbstractNode = class _AbstractNode extends AbstractModuleInstance {
+  static configSchemas = [...super.configSchemas, NodeConfigSchema];
+  static defaultConfigSchema = NodeConfigSchema;
+  static uniqueName = globallyUnique("AbstractNode", _AbstractNode, "xyo");
+  isNode = true;
+  get queries() {
+    return [
+      NodeAttachQuerySchema,
+      NodeCertifyQuerySchema,
+      NodeDetachQuerySchema,
+      NodeAttachedQuerySchema,
+      NodeRegisteredQuerySchema,
+      ...super.queries
+    ];
+  }
+  static isNode(mod) {
+    return mod.isNode;
+  }
+  async attach(id, external) {
+    this._noOverride("attach");
+    return await this.attachHandler(id, external);
+  }
+  async attachQuery(id, external, account) {
+    this._noOverride("attachQuery");
+    const queryPayload = {
+      external,
+      id,
+      schema: NodeAttachQuerySchema
+    };
+    return await this.sendQueryRaw(queryPayload, [], account);
+  }
+  async attached() {
+    this._noOverride("attached");
+    return await this.attachedHandler();
+  }
+  async attachedHandler() {
+    return [...(await this.attachedPublicModules()).map((mod) => mod.address), ...(await this.attachedPrivateModules()).map((mod) => mod.address)];
+  }
+  async attachedQuery(account) {
+    this._noOverride("attachedQuery");
+    const queryPayload = { schema: NodeAttachedQuerySchema };
+    return await this.sendQueryRaw(queryPayload, [], account);
+  }
+  async certify(id) {
+    this._noOverride("certify");
+    return await this.certifyHandler(id);
+  }
+  async certifyQuery(id, account) {
+    const queryPayload = { id, schema: NodeCertifyQuerySchema };
+    return await this.sendQueryRaw(queryPayload, [], account);
+  }
+  async detach(id) {
+    this._noOverride("detach");
+    return await this.detachHandler(id);
+  }
+  async detachQuery(id, account) {
+    this._noOverride("detachQuery");
+    const queryPayload = { id, schema: NodeDetachQuerySchema };
+    return await this.sendQueryRaw(queryPayload, [], account);
+  }
+  async manifest(maxDepth = 10, ignoreAddresses = []) {
+    return await this.manifestHandler(maxDepth, ignoreAddresses);
+  }
+  async privateChildren() {
+    return await this.attachedPrivateModules();
+  }
+  async publicChildren() {
+    return await this.attachedPublicModules();
+  }
+  async registered() {
+    this._noOverride("registered");
+    return await this.registeredHandler();
+  }
+  async registeredQuery(account) {
+    this._noOverride("registeredQuery");
+    const queryPayload = { schema: NodeRegisteredQuerySchema };
+    return await this.sendQueryRaw(queryPayload, [], account);
+  }
+  async attachedPrivateModules(maxDepth = 1) {
+    return (await (this.resolvePrivate("*", { maxDepth }) ?? [])).filter((mod) => mod.address !== this.address);
+  }
+  async attachedPublicModules(maxDepth = 1) {
+    return (await (this.downResolver.resolve("*", { direction: "down", maxDepth }) ?? [])).filter((mod) => mod.address !== this.address);
+  }
+  async generateConfigAndAddress(maxDepth = 10) {
+    const childMods = await this.attachedPublicModules(maxDepth);
+    const childModAddresses = childMods.map((mod) => new PayloadBuilder({ schema: AddressSchema }).fields({ address: mod.address }).build());
+    return [...await super.generateConfigAndAddress(maxDepth), ...childModAddresses];
+  }
+  async manifestHandler(maxDepth = 10, ignoreAddresses = []) {
+    const cachedResult = this._cachedManifests.get(maxDepth);
+    if (cachedResult) {
+      return cachedResult;
+    }
+    const manifest = { ...await super.manifestHandler(maxDepth, ignoreAddresses), schema: NodeManifestPayloadSchema };
+    const newIgnoreAddresses = [...ignoreAddresses, this.address];
+    const notThisModule = (mod) => mod.address !== this.address && !ignoreAddresses.includes(mod.address);
+    const toManifest = (mod) => mod.manifest(maxDepth - 1, newIgnoreAddresses);
+    const publicChildren = await this.publicChildren();
+    const publicModuleManifests = await Promise.all(publicChildren.filter(notThisModule).map(toManifest));
+    if (publicModuleManifests.length > 0) {
+      manifest.modules = manifest.modules ?? {};
+      manifest.modules.public = publicModuleManifests;
+    }
+    this._cachedManifests.set(maxDepth, manifest);
+    return manifest;
+  }
+  // eslint-disable-next-line max-statements
+  async queryHandler(query, payloads, queryConfig) {
+    const wrapper = QueryBoundWitnessWrapper.parseQuery(query, payloads);
+    const queryPayload = await wrapper.getQuery();
+    assertEx(await this.queryable(query, payloads, queryConfig), () => "Module is not queryable with the provided query");
+    const resultPayloads = [];
+    switch (queryPayload.schema) {
+      case NodeAttachQuerySchema: {
+        const typedQueryPayload = queryPayload;
+        const address = await this.attachHandler(typedQueryPayload.id, typedQueryPayload.external);
+        if (address) {
+          const payload = new PayloadBuilder({ schema: AddressSchema }).fields({ address }).build();
+          resultPayloads.push(payload);
+        }
+        break;
+      }
+      case NodeCertifyQuerySchema: {
+        const typedQueryPayload = queryPayload;
+        const fields = await this.certifyHandler(typedQueryPayload.id);
+        if (fields) {
+          const payload = new PayloadBuilder({ schema: ChildCertificationSchema }).fields(fields).build();
+          resultPayloads.push(payload);
+        }
+        break;
+      }
+      case NodeDetachQuerySchema: {
+        const typedQueryPayload = queryPayload;
+        const address = await this.detachHandler(typedQueryPayload.id);
+        if (address) {
+          const payload = new PayloadBuilder({ schema: AddressSchema }).fields({ address }).build();
+          resultPayloads.push(payload);
+        }
+        break;
+      }
+      case NodeAttachedQuerySchema: {
+        const addresses = await this.attachedHandler();
+        for (const address of addresses) {
+          const payload = new PayloadBuilder({ schema: AddressSchema }).fields({ address }).build();
+          resultPayloads.push(payload);
+        }
+        break;
+      }
+      case NodeRegisteredQuerySchema: {
+        const addresses = await this.registeredHandler();
+        for (const address of addresses) {
+          const payload = new PayloadBuilder({ schema: AddressSchema }).fields({ address }).build();
+          resultPayloads.push(payload);
+        }
+        break;
+      }
+      default: {
+        return await super.queryHandler(query, payloads);
+      }
+    }
+    return resultPayloads;
+  }
+};
+
+// src/NodeHelper/attachedPrivateModules.ts
+import { asNodeInstance } from "../../node-model/neutral/index.mjs";
+var attachedPrivateModules = async (node, maxDepth = 1) => {
+  const remainingDepth = maxDepth - 1;
+  const mods = [];
+  const publicChildren = await node.privateChildren();
+  mods.push(...publicChildren);
+  if (remainingDepth > 0) {
+    await Promise.all(
+      publicChildren.map(async (mod) => {
+        const node2 = asNodeInstance(mod);
+        if (node2) {
+          const children = await attachedPrivateModules(node2, remainingDepth);
+          mods.push(...children);
+        }
+      })
+    );
+  }
+  return mods;
+};
+
+// src/NodeHelper/attachedPublicModules.ts
+import { asNodeInstance as asNodeInstance2 } from "../../node-model/neutral/index.mjs";
+var attachedPublicModules = async (node, maxDepth = 1) => {
+  const remainingDepth = maxDepth - 1;
+  const mods = [];
+  const publicChildren = await node.publicChildren();
+  mods.push(...publicChildren);
+  if (remainingDepth > 0) {
+    await Promise.all(
+      publicChildren.map(async (mod) => {
+        const node2 = asNodeInstance2(mod);
+        if (node2) {
+          const children = await attachedPublicModules(node2, remainingDepth);
+          mods.push(...children);
+        }
+      })
+    );
+  }
+  return mods;
+};
+
+// src/NodeHelper/index.ts
+var NodeHelper = {
+  attachedPrivateModules,
+  attachedPublicModules
+};
+export {
+  AbstractNode,
+  NodeHelper
+};

package/dist/_pkg/node-memory/neutral/MemoryNode.d.ts

@@ -0,0 +1,46 @@
+import type { Promisable } from '@xylabs/sdk';
+import { type AnyConfigSchema, type AttachableModuleInstance, type ModuleIdentifier, type ModuleInstance } from '../../module-model/neutral/index.ts';
+import { AbstractNode } from '../../node-abstract/neutral/index.ts';
+import type { ChildCertificationFields, NodeConfig, NodeInstanceParams, NodeModuleEventData } from '../../node-model/neutral/index.ts';
+import type { XyoAddress, XyoQuantAddress } from '../../sdk-protocol/neutral/index.ts';
+export type MemoryNodeParams = NodeInstanceParams<AnyConfigSchema<NodeConfig>>;
+export declare class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams, TEventData extends NodeModuleEventData = NodeModuleEventData> extends AbstractNode<TParams, TEventData> {
+    protected registeredModuleMap: Partial<Record<XyoAddress, AttachableModuleInstance>>;
+    private _attachMutex;
+    private _attachedPrivateModules;
+    private _attachedPublicModules;
+    attachHandler(id: ModuleIdentifier, external?: boolean): Promise<(Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | XyoQuantAddress>;
+    certifyHandler(id: ModuleIdentifier): Promise<ChildCertificationFields>;
+    detachHandler(id: ModuleIdentifier): Promise<(Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | XyoQuantAddress | undefined>;
+    privateChildren(): Promise<ModuleInstance[]>;
+    publicChildren(): Promise<ModuleInstance[]>;
+    register(mod: AttachableModuleInstance): Promise<void>;
+    registeredHandler(): Promisable<XyoAddress[]>;
+    registeredModules(): AttachableModuleInstance[];
+    unregister(mod: ModuleInstance): Promise<ModuleInstance>;
+    protected attachUsingAddress(address: XyoAddress, external?: boolean): Promise<(Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | XyoQuantAddress>;
+    protected detachUsingAddress(address: XyoAddress): Promise<(Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | XyoQuantAddress>;
+    protected startHandler(): Promise<void>;
+    private attachUsingName;
+    private detachUsingName;
+    private getModulesToNotifyAbout;
+    private notifyOfExistingModulesAttached;
+    private notifyOfExistingModulesDetached;
+    private registeredModuleAddressFromName;
+}