@xyo-network/sdk 2.102.4 → 7.0.2

package/dist/_pkg/node-memory/neutral/NodeHelper/attachToExistingNode.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
+import type { NodeInstance } from '../../../node-model/neutral/index.ts';
+export declare const attachToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;

package/dist/_pkg/node-memory/neutral/NodeHelper/attachToNewNode.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
+import type { NodeInstance } from '../../../node-model/neutral/index.ts';
+import type { MemoryNodeParams } from '../MemoryNode.ts';
+export declare const attachToNewNode: (source: NodeInstance, id: ModuleIdentifier, destinationParams?: MemoryNodeParams) => Promise<NodeInstance>;

package/dist/_pkg/node-memory/neutral/NodeHelper/flatAttachToExistingNode.d.ts

@@ -0,0 +1,5 @@
+import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
+import type { NodeInstance } from '../../../node-model/neutral/index.ts';
+export declare const flatAttachAllToExistingNode: (source: NodeInstance, destination: NodeInstance) => Promise<NodeInstance>;
+export declare const flatAttachChildToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;
+export declare const flatAttachToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;

package/dist/_pkg/node-memory/neutral/NodeHelper/flatAttachToNewNode.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
+import type { NodeInstance } from '../../../node-model/neutral/index.ts';
+import type { MemoryNodeParams } from '../MemoryNode.ts';
+export declare const flatAttachToNewNode: (source: NodeInstance, id: ModuleIdentifier, destinationParams: MemoryNodeParams) => Promise<NodeInstance>;

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

@@ -0,0 +1,13 @@
+import type { ModuleIdentifier, ModuleInstance } from '../../../module-model/neutral/index.ts';
+import type { NodeInstance } from '../../../node-model/neutral/index.ts';
+import type { MemoryNodeParams } from '../MemoryNode.ts';
+export declare const MemoryNodeHelper: {
+    attachToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;
+    attachToNewNode: (source: NodeInstance, id: ModuleIdentifier, destinationParams?: MemoryNodeParams) => Promise<NodeInstance>;
+    attachedPrivateModules: (node: NodeInstance, maxDepth?: number) => Promise<ModuleInstance[]>;
+    attachedPublicModules: (node: NodeInstance, maxDepth?: number) => Promise<ModuleInstance[]>;
+    flatAttachAllToExistingNode: (source: NodeInstance, destination: NodeInstance) => Promise<NodeInstance>;
+    flatAttachChildToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;
+    flatAttachToExistingNode: (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance) => Promise<NodeInstance>;
+    flatAttachToNewNode: (source: NodeInstance, id: ModuleIdentifier, destinationParams: MemoryNodeParams) => Promise<NodeInstance>;
+};

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

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

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

@@ -0,0 +1,283 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+
+// src/MemoryNode.ts
+import {
+  assertEx,
+  exists,
+  isAddress,
+  isDefined
+} from "@xylabs/sdk";
+import {
+  creatableModule
+} from "../../module-model/neutral/index.mjs";
+import { AbstractNode } from "../../node-abstract/neutral/index.mjs";
+import { isNodeModule } from "../../node-model/neutral/index.mjs";
+import { Mutex } from "async-mutex";
+var MemoryNode = class extends AbstractNode {
+  registeredModuleMap = {};
+  _attachMutex = new Mutex();
+  _attachedPrivateModules = /* @__PURE__ */ new Set();
+  _attachedPublicModules = /* @__PURE__ */ new Set();
+  async attachHandler(id, external) {
+    await this.startedAsync("warn", true);
+    return assertEx(
+      isAddress(id) ? await this.attachUsingAddress(id, external) : await this.attachUsingName(id, external),
+      () => `Unable to locate module [${id}]`
+    );
+  }
+  async certifyHandler(id) {
+    const child = (await this.publicChildren()).find((child2) => child2.modName === id || child2.address === id);
+    if (child) {
+      return {
+        address: child.address,
+        expiration: Date.now() + 1e3 * 60 * 10
+        /* 10 minutes */
+      };
+    }
+    throw new Error(`Unable to certify child module [${id}]`);
+  }
+  async detachHandler(id) {
+    return isAddress(id) ? await this.detachUsingAddress(id) : await this.detachUsingName(id);
+  }
+  async privateChildren() {
+    return [...await this.attachedPrivateModules(), ...this.params.privateChildren ?? []];
+  }
+  async publicChildren() {
+    return [...await this.attachedPublicModules(), ...this.params.publicChildren ?? []];
+  }
+  async register(mod) {
+    this.started("warn");
+    if (this.registeredModuleMap[mod.address]) {
+      if (this.registeredModuleMap[mod.address] === mod) {
+        this.logger?.warn(`Module already registered at that address[${mod.address}]|${mod.id}|[${mod.config.schema}]`);
+      } else {
+        throw new Error(`Other module already registered at that address[${mod.address}]|${mod.id}|[${mod.config.schema}]`);
+      }
+    }
+    this.registeredModuleMap[mod.address] = mod;
+    const args = { mod, name: mod.modName };
+    await this.emit("moduleRegistered", args);
+  }
+  registeredHandler() {
+    return Promise.resolve(
+      Object.keys(this.registeredModuleMap).map((key) => {
+        return key;
+      })
+    );
+  }
+  registeredModules() {
+    return Object.values(this.registeredModuleMap).map((value) => {
+      return value;
+    }).filter(exists);
+  }
+  async unregister(mod) {
+    try {
+      await this.detach(mod.address);
+    } catch {
+    }
+    delete this.registeredModuleMap[mod.address];
+    const args = { mod, name: mod.modName };
+    await this.emit("moduleUnregistered", args);
+    return this;
+  }
+  async attachUsingAddress(address, external) {
+    return await this._attachMutex.runExclusive(async () => {
+      const existingModule = await this.resolve(address);
+      if (existingModule) {
+        this.logger?.warn(`MemoryNode: Module [${existingModule?.modName ?? existingModule?.address}] already attached at address [${address}]`);
+      }
+      const mod = assertEx(this.registeredModuleMap[address], () => `No Module Registered at address [${address}]`);
+      if (this._attachedPublicModules.has(mod.address)) {
+        this.logger?.warn(`Module [${mod.modName}] already attached at [${address}] (public)`);
+      }
+      if (this._attachedPrivateModules.has(mod.address)) {
+        this.logger?.warn(`Module [${mod.modName}] already attached at [${address}] (private)`);
+      }
+      const notificationList = await this.getModulesToNotifyAbout(mod);
+      mod.upResolver.addResolver?.(this.privateResolver);
+      mod.upResolver.addResolver?.(this.downResolver);
+      mod.upResolver.addResolver?.(this.upResolver);
+      if (external) {
+        this._attachedPublicModules.add(mod.address);
+        this.downResolver.addResolver(mod.downResolver);
+      } else {
+        this._attachedPrivateModules.add(mod.address);
+        this.privateResolver.addResolver(mod.downResolver);
+      }
+      mod.addParent(this);
+      const args = { mod, name: mod.modName };
+      await this.emit("moduleAttached", args);
+      if (isNodeModule(mod) && external) {
+        const attachedListener = async (args2) => await this.emit("moduleAttached", args2);
+        const detachedListener = async (args2) => await this.emit("moduleDetached", args2);
+        mod.on("moduleAttached", attachedListener);
+        mod.on("moduleDetached", detachedListener);
+      }
+      await this.notifyOfExistingModulesAttached(notificationList);
+      return address;
+    });
+  }
+  async detachUsingAddress(address) {
+    const mod = assertEx(this.registeredModuleMap[address], () => `No Module Registered at address [${address}]`);
+    const isAttachedPublic = this._attachedPublicModules.has(mod.address);
+    const isAttachedPrivate = this._attachedPrivateModules.has(mod.address);
+    assertEx(isAttachedPublic || isAttachedPrivate, () => `Module [${mod.modName}] not attached at [${address}]`);
+    mod.upResolver?.removeResolver?.(this.privateResolver);
+    mod.upResolver?.removeResolver?.(this.upResolver);
+    this.downResolver.removeResolver(mod.downResolver);
+    mod.removeParent(this.address);
+    if (isAttachedPublic) {
+      this._attachedPublicModules.delete(mod.address);
+    }
+    if (isAttachedPrivate) {
+      this._attachedPrivateModules.delete(mod.address);
+    }
+    const args = { mod, name: mod.modName };
+    await this.emit("moduleDetached", args);
+    if (isNodeModule(mod)) {
+      const notificationList = await this.getModulesToNotifyAbout(mod);
+      await this.notifyOfExistingModulesDetached(notificationList);
+    }
+    return address;
+  }
+  startHandler() {
+    return super.startHandler();
+  }
+  async attachUsingName(name, external) {
+    const address = this.registeredModuleAddressFromName(name);
+    if (isDefined(address)) {
+      return await this.attachUsingAddress(address, external);
+    }
+  }
+  async detachUsingName(name) {
+    const address = this.registeredModuleAddressFromName(name);
+    if (isDefined(address)) {
+      return await this.detachUsingAddress(address);
+    }
+  }
+  async getModulesToNotifyAbout(node) {
+    const notifiedAddresses = [];
+    const childModules = await node.resolve("*", { direction: "down" });
+    return childModules.map((child) => {
+      if (node.address === child.address) {
+        return;
+      }
+      if (notifiedAddresses.includes(child.address)) {
+        return;
+      }
+      notifiedAddresses.push(child.address);
+      return child;
+    }).filter(exists);
+  }
+  async notifyOfExistingModulesAttached(childModules) {
+    await Promise.all(
+      childModules.map(async (child) => {
+        const args = { mod: child, name: child.modName };
+        await this.emit("moduleAttached", args);
+      })
+    );
+  }
+  async notifyOfExistingModulesDetached(childModules) {
+    await Promise.all(
+      childModules.map(async (child) => {
+        const args = { mod: child, name: child.modName };
+        await this.emit("moduleDetached", args);
+      })
+    );
+  }
+  registeredModuleAddressFromName(name) {
+    return Object.values(this.registeredModuleMap).find((value) => {
+      return value?.modName === name;
+    })?.address;
+  }
+};
+MemoryNode = __decorateClass([
+  creatableModule()
+], MemoryNode);
+
+// src/NodeHelper/index.ts
+import { NodeHelper } from "../../node-abstract/neutral/index.mjs";
+
+// src/NodeHelper/attachToExistingNode.ts
+import { assertEx as assertEx3 } from "@xylabs/sdk";
+import { asNodeInstance } from "../../node-model/neutral/index.mjs";
+
+// src/NodeHelper/flatAttachToExistingNode.ts
+import { assertEx as assertEx2, exists as exists2 } from "@xylabs/sdk";
+import { asAttachableModuleInstance } from "../../module-model/neutral/index.mjs";
+var flatAttachAllToExistingNode = async (source, destination) => {
+  const children = (await source.publicChildren()).map((child) => asAttachableModuleInstance(child)).filter(exists2);
+  await Promise.all(
+    children.map(async (child) => {
+      await destination.register?.(child);
+      await destination.attach(child.address, true);
+    })
+  );
+  return destination;
+};
+var flatAttachChildToExistingNode = async (source, id, destination) => {
+  assertEx2(id !== "*", () => "* is not a single child");
+  const child = assertEx2(await source.resolve(id), () => `Module ${id} not found`);
+  const attachableChild = asAttachableModuleInstance(child, () => `Module ${id} is not attachable`, { required: true });
+  await destination.register?.(attachableChild);
+  await destination.attach(child.address, true);
+  return destination;
+};
+var flatAttachToExistingNode = async (source, id, destination) => {
+  return id === "*" ? await flatAttachAllToExistingNode(source, destination) : flatAttachChildToExistingNode(source, id, destination);
+};
+
+// src/NodeHelper/attachToExistingNode.ts
+var attachToExistingNode = async (source, id, destination) => {
+  const parts = id.split(":");
+  const first = assertEx3(parts.shift(), () => "missing first part");
+  if (parts.length === 0) {
+    return await flatAttachToExistingNode(source, first, destination);
+  } else {
+    const firstModule = await source.resolve(first);
+    const firstNode = asNodeInstance(firstModule, () => "first part is not a node", { required: true });
+    const newNode = await MemoryNode.create({ config: firstNode.config });
+    await destination.register?.(newNode);
+    await destination.attach(newNode.address, true);
+    await attachToExistingNode(firstNode, parts.join(":"), newNode);
+    return destination;
+  }
+};
+
+// src/NodeHelper/attachToNewNode.ts
+import { NodeConfigSchema } from "../../node-model/neutral/index.mjs";
+var DEFAULT_NODE_PARAMS = { config: { schema: NodeConfigSchema }, name: "MemoryNode" };
+var attachToNewNode = async (source, id, destinationParams = DEFAULT_NODE_PARAMS) => {
+  const destination = await MemoryNode.create(destinationParams);
+  return await attachToExistingNode(source, id, destination);
+};
+
+// src/NodeHelper/flatAttachToNewNode.ts
+var flatAttachToNewNode = async (source, id, destinationParams) => {
+  const destination = await MemoryNode.create(destinationParams);
+  return await flatAttachToExistingNode(source, id, destination);
+};
+
+// src/NodeHelper/index.ts
+var MemoryNodeHelper = {
+  ...NodeHelper,
+  attachToExistingNode,
+  attachToNewNode,
+  flatAttachAllToExistingNode,
+  flatAttachChildToExistingNode,
+  flatAttachToExistingNode,
+  flatAttachToNewNode
+};
+export {
+  MemoryNode,
+  MemoryNodeHelper
+};

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

@@ -0,0 +1,18 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import { type XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const ChildCertificationSchema: 'network.xyo.child.certification' & {
+    readonly __schema: true;
+};
+export type ChildCertificationSchema = typeof ChildCertificationSchema;
+export interface ChildCertificationFields {
+    address: XyoAddress;
+    expiration: number;
+}
+export declare const ChildCertificationZod: z.ZodMiniIntersection<z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<ChildCertificationSchema>;
+}, z.core.$strip>, z.ZodMiniCustom<ChildCertificationFields, ChildCertificationFields>>;
+export type ChildCertification = z.infer<typeof ChildCertificationZod>;
+export declare const isChildCertification: ReturnType<typeof zodIsFactory<ChildCertification>>;
+export declare const asChildCertification: ReturnType<typeof zodAsFactory<ChildCertification>>;
+export declare const toChildCertification: ReturnType<typeof zodToFactory<ChildCertification>>;

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

@@ -0,0 +1,20 @@
+import type { EmptyObject, WithAdditional } from '@xylabs/sdk';
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { ModuleConfig } from '../../module-model/neutral/index.ts';
+import { ModuleConfigZod } from '../../module-model/neutral/index.ts';
+import type { Payload, Schema } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const NodeConfigSchema: 'network.xyo.node.config' & {
+    readonly __schema: true;
+};
+export type NodeConfigSchema = typeof NodeConfigSchema;
+export declare const NodeConfigZod: z.ZodMiniObject<Omit<(typeof ModuleConfigZod)['shape'], 'schema'> & {
+    schema: z.ZodMiniLiteral<NodeConfigSchema>;
+}, z.core.$strip>;
+export type NodeConfigBase = z.infer<typeof NodeConfigZod>;
+export declare const isNodeConfig: ReturnType<typeof zodIsFactory<NodeConfigBase>>;
+export declare const asNodeConfig: ReturnType<typeof zodAsFactory<NodeConfigBase>>;
+export declare const toNodeConfig: ReturnType<typeof zodToFactory<NodeConfigBase>>;
+export type NodeConfig<TConfig extends EmptyObject | Payload | void = void, TSchema extends Schema | void = void> = ModuleConfig<WithAdditional<{
+    archivist?: string;
+}, TConfig>, TSchema extends void ? TConfig extends Payload ? TConfig['schema'] : NodeConfigSchema : TSchema>;

package/dist/_pkg/node-model/neutral/EventsModels/ModuleAttached.d.ts

@@ -0,0 +1,6 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+export type ModuleAttachedEventArgs<TModule extends QueryableModule = QueryableModule> = ModuleEventArgs<TModule>;
+export interface ModuleAttachedEventData extends EventData {
+    moduleAttached: ModuleAttachedEventArgs;
+}

package/dist/_pkg/node-model/neutral/EventsModels/ModuleDetached.d.ts

@@ -0,0 +1,6 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+export type ModuleDetachedEventArgs<TModule extends QueryableModule = QueryableModule> = ModuleEventArgs<TModule>;
+export interface ModuleDetachedEventData extends EventData {
+    moduleDetached: ModuleDetachedEventArgs;
+}

package/dist/_pkg/node-model/neutral/EventsModels/ModuleRegistered.d.ts

@@ -0,0 +1,6 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+export type ModuleRegisteredEventArgs<TModule extends QueryableModule = QueryableModule> = ModuleEventArgs<TModule>;
+export interface ModuleRegisteredEventData extends EventData {
+    moduleRegistered: ModuleRegisteredEventArgs;
+}

package/dist/_pkg/node-model/neutral/EventsModels/ModuleUnregistered.d.ts

@@ -0,0 +1,6 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs, QueryableModule } from '../../../module-model/neutral/index.ts';
+export type ModuleUnregisteredEventArgs<TModule extends QueryableModule = QueryableModule> = ModuleEventArgs<TModule>;
+export interface ModuleUnregisteredEventData extends EventData {
+    moduleUnregistered: ModuleUnregisteredEventArgs;
+}

package/dist/_pkg/node-model/neutral/EventsModels/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ModuleAttached.ts';
+export * from './ModuleDetached.ts';
+export * from './ModuleRegistered.ts';
+export * from './ModuleUnregistered.ts';

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

@@ -0,0 +1,7 @@
+import type { ModuleEventData, QueryableModule } from '../../module-model/neutral/index.ts';
+import type { ModuleAttachedEventData, ModuleDetachedEventData, ModuleRegisteredEventData, ModuleUnregisteredEventData } from './EventsModels/index.ts';
+import type { NodeParams } from './Params.ts';
+export interface NodeModuleEventData extends ModuleAttachedEventData, ModuleDetachedEventData, ModuleRegisteredEventData, ModuleUnregisteredEventData, ModuleEventData {
+}
+export interface NodeModule<TParams extends NodeParams = NodeParams, TEventData extends NodeModuleEventData = NodeModuleEventData> extends QueryableModule<TParams, TEventData> {
+}

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

@@ -0,0 +1,6 @@
+import type { AnyConfigSchema, ModuleInstanceParams, QueryableModuleParams } from '../../module-model/neutral/index.ts';
+import type { NodeConfig } from './Config.ts';
+export interface NodeParams<TConfig extends AnyConfigSchema<NodeConfig> = AnyConfigSchema<NodeConfig>> extends QueryableModuleParams<TConfig> {
+}
+export interface NodeInstanceParams<TConfig extends AnyConfigSchema<NodeConfig> = AnyConfigSchema<NodeConfig>> extends ModuleInstanceParams<TConfig> {
+}

package/dist/_pkg/node-model/neutral/Queries/Attach.d.ts

@@ -0,0 +1,18 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
+import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const NodeAttachQuerySchema: 'network.xyo.query.node.attach' & {
+    readonly __schema: true;
+};
+export type NodeAttachQuerySchema = typeof NodeAttachQuerySchema;
+export declare const NodeAttachQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<NodeAttachQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'] & {
+    external: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    id: z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>;
+}, z.core.$strip>;
+export type NodeAttachQuery = z.infer<typeof NodeAttachQueryZod>;
+export declare const isNodeAttachQuery: ReturnType<typeof zodIsFactory<NodeAttachQuery>>;
+export declare const asNodeAttachQuery: ReturnType<typeof zodAsFactory<NodeAttachQuery>>;
+export declare const toNodeAttachQuery: ReturnType<typeof zodToFactory<NodeAttachQuery>>;

package/dist/_pkg/node-model/neutral/Queries/Attached.d.ts

@@ -0,0 +1,14 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const NodeAttachedQuerySchema: 'network.xyo.query.node.attached' & {
+    readonly __schema: true;
+};
+export type NodeAttachedQuerySchema = typeof NodeAttachedQuerySchema;
+export declare const NodeAttachedQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<NodeAttachedQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
+export type NodeAttachedQuery = z.infer<typeof NodeAttachedQueryZod>;
+export declare const isNodeAttachedQuery: ReturnType<typeof zodIsFactory<NodeAttachedQuery>>;
+export declare const asNodeAttachedQuery: ReturnType<typeof zodAsFactory<NodeAttachedQuery>>;
+export declare const toNodeAttachedQuery: ReturnType<typeof zodToFactory<NodeAttachedQuery>>;

package/dist/_pkg/node-model/neutral/Queries/Certify.d.ts

@@ -0,0 +1,17 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
+import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const NodeCertifyQuerySchema: 'network.xyo.query.node.certify' & {
+    readonly __schema: true;
+};
+export type NodeCertifyQuerySchema = typeof NodeCertifyQuerySchema;
+export declare const NodeCertifyQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<NodeCertifyQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'] & {
+    id: z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>;
+}, z.core.$strip>;
+export type NodeCertifyQuery = z.infer<typeof NodeCertifyQueryZod>;
+export declare const isNodeCertifyQuery: ReturnType<typeof zodIsFactory<NodeCertifyQuery>>;
+export declare const asNodeCertifyQuery: ReturnType<typeof zodAsFactory<NodeCertifyQuery>>;
+export declare const toNodeCertifyQuery: ReturnType<typeof zodToFactory<NodeCertifyQuery>>;

package/dist/_pkg/node-model/neutral/Queries/Detach.d.ts

@@ -0,0 +1,17 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { ModuleIdentifier } from '../../../module-model/neutral/index.ts';
+import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const NodeDetachQuerySchema: 'network.xyo.query.node.detach' & {
+    readonly __schema: true;
+};
+export type NodeDetachQuerySchema = typeof NodeDetachQuerySchema;
+export declare const NodeDetachQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<NodeDetachQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'] & {
+    id: z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>;
+}, z.core.$strip>;
+export type NodeDetachQuery = z.infer<typeof NodeDetachQueryZod>;
+export declare const isNodeDetachQuery: ReturnType<typeof zodIsFactory<NodeDetachQuery>>;
+export declare const asNodeDetachQuery: ReturnType<typeof zodAsFactory<NodeDetachQuery>>;
+export declare const toNodeDetachQuery: ReturnType<typeof zodToFactory<NodeDetachQuery>>;

package/dist/_pkg/node-model/neutral/Queries/Registered.d.ts

@@ -0,0 +1,14 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import { QueryFieldsZod } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const NodeRegisteredQuerySchema: 'network.xyo.query.node.registered' & {
+    readonly __schema: true;
+};
+export type NodeRegisteredQuerySchema = typeof NodeRegisteredQuerySchema;
+export declare const NodeRegisteredQueryZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<NodeRegisteredQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'], z.core.$strip>;
+export type NodeRegisteredQuery = z.infer<typeof NodeRegisteredQueryZod>;
+export declare const isNodeRegisteredQuery: ReturnType<typeof zodIsFactory<NodeRegisteredQuery>>;
+export declare const asNodeRegisteredQuery: ReturnType<typeof zodAsFactory<NodeRegisteredQuery>>;
+export declare const toNodeRegisteredQuery: ReturnType<typeof zodToFactory<NodeRegisteredQuery>>;

package/dist/_pkg/node-model/neutral/Queries/index.d.ts

@@ -0,0 +1,13 @@
+import type { ModuleQueries } from '../../../module-model/neutral/index.ts';
+import type { NodeAttachQuery } from './Attach.ts';
+import type { NodeAttachedQuery } from './Attached.ts';
+import type { NodeCertifyQuery } from './Certify.ts';
+import type { NodeDetachQuery } from './Detach.ts';
+import type { NodeRegisteredQuery } from './Registered.ts';
+export * from './Attach.ts';
+export * from './Attached.ts';
+export * from './Certify.ts';
+export * from './Detach.ts';
+export * from './Registered.ts';
+export type NodeQueries = NodeAttachQuery | NodeCertifyQuery | NodeDetachQuery | NodeAttachedQuery | NodeRegisteredQuery;
+export type NodeModuleQueries = ModuleQueries | NodeQueries;

package/dist/_pkg/node-model/neutral/attachable/AttachableInstance.d.ts

@@ -0,0 +1,11 @@
+import type { TypeCheck } from '@xylabs/sdk';
+import { IsObjectFactory } from '@xylabs/sdk';
+import type { AttachableModuleInstance } from '../../../module-model/neutral/index.ts';
+import type { NodeInstance } from '../instance.ts';
+import type { NodeModule, NodeModuleEventData } from '../Node.ts';
+import type { NodeParams } from '../Params.ts';
+export interface AttachableNodeInstance<TParams extends NodeParams = NodeParams, TEventData extends NodeModuleEventData = NodeModuleEventData> extends NodeModule<TParams, TEventData>, AttachableModuleInstance<TParams, TEventData>, NodeInstance<TParams, TEventData> {
+}
+export type AttachableNodeInstanceTypeCheck<T extends AttachableNodeInstance = AttachableNodeInstance> = TypeCheck<T>;
+export declare class IsAttachableNodeInstanceFactory<T extends AttachableNodeInstance = AttachableNodeInstance> extends IsObjectFactory<T> {
+}

package/dist/_pkg/node-model/neutral/attachable/asAttachableInstance.d.ts

@@ -0,0 +1 @@
+export declare const asAttachableNodeInstance: import("@xylabs/sdk").AsTypeFunction<import("./AttachableInstance.ts").AttachableNodeInstance<import("../Params.ts").NodeParams<import("../../../module-model/neutral/index.ts").AnyConfigSchema<import("../Config.ts").NodeConfig>>, import("../Node.ts").NodeModuleEventData>>;

package/dist/_pkg/node-model/neutral/attachable/index.d.ts

@@ -0,0 +1,3 @@
+export * from './asAttachableInstance.ts';
+export * from './AttachableInstance.ts';
+export * from './isAttachableInstance.ts';

package/dist/_pkg/node-model/neutral/attachable/isAttachableInstance.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectTypeShape, TypeCheck } from '@xylabs/sdk';
+import type { AttachableNodeInstance } from './AttachableInstance.ts';
+export declare const requiredAttachableNodeInstanceFunctions: ObjectTypeShape;
+export declare const isAttachableNodeInstance: TypeCheck<AttachableNodeInstance>;

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

@@ -0,0 +1,9 @@
+export * from './attachable/index.ts';
+export * from './ChildCertification.ts';
+export * from './Config.ts';
+export * from './EventsModels/index.ts';
+export * from './instance.ts';
+export * from './Node.ts';
+export * from './Params.ts';
+export * from './Queries/index.ts';
+export * from './typeChecks.ts';