@xyo-network/sdk 2.102.4 → 7.0.2

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

@@ -0,0 +1,228 @@
+// src/attachable/asAttachableInstance.ts
+import { AsObjectFactory as AsObjectFactory2 } from "@xylabs/sdk";
+
+// src/attachable/isAttachableInstance.ts
+import { IsObjectFactory } from "@xylabs/sdk";
+import { isAttachableModuleInstance } from "../../module-model/neutral/index.mjs";
+
+// src/typeChecks.ts
+import { AsObjectFactory } from "@xylabs/sdk";
+import {
+  IsInstanceFactory,
+  isModuleInstance,
+  IsQueryableModuleFactory,
+  WithFactory
+} from "../../module-model/neutral/index.mjs";
+
+// src/Queries/Attach.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import {
+  asSchema,
+  PayloadZodOfSchema,
+  QueryFieldsZod
+} from "../../sdk-protocol/neutral/index.mjs";
+import * as z from "zod/mini";
+var NodeAttachQuerySchema = asSchema("network.xyo.query.node.attach", true);
+var NodeAttachQueryZod = z.extend(PayloadZodOfSchema(NodeAttachQuerySchema), {
+  ...QueryFieldsZod.shape,
+  external: z.optional(z.boolean()),
+  id: z.custom()
+});
+var isNodeAttachQuery = zodIsFactory(NodeAttachQueryZod);
+var asNodeAttachQuery = zodAsFactory(NodeAttachQueryZod, "asNodeAttachQuery");
+var toNodeAttachQuery = zodToFactory(NodeAttachQueryZod, "toNodeAttachQuery");
+
+// src/Queries/Attached.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk";
+import {
+  asSchema as asSchema2,
+  PayloadZodOfSchema as PayloadZodOfSchema2,
+  QueryFieldsZod as QueryFieldsZod2
+} from "../../sdk-protocol/neutral/index.mjs";
+import * as z2 from "zod/mini";
+var NodeAttachedQuerySchema = asSchema2("network.xyo.query.node.attached", true);
+var NodeAttachedQueryZod = z2.extend(PayloadZodOfSchema2(NodeAttachedQuerySchema), { ...QueryFieldsZod2.shape });
+var isNodeAttachedQuery = zodIsFactory2(NodeAttachedQueryZod);
+var asNodeAttachedQuery = zodAsFactory2(NodeAttachedQueryZod, "asNodeAttachedQuery");
+var toNodeAttachedQuery = zodToFactory2(NodeAttachedQueryZod, "toNodeAttachedQuery");
+
+// src/Queries/Certify.ts
+import {
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@xylabs/sdk";
+import {
+  asSchema as asSchema3,
+  PayloadZodOfSchema as PayloadZodOfSchema3,
+  QueryFieldsZod as QueryFieldsZod3
+} from "../../sdk-protocol/neutral/index.mjs";
+import * as z3 from "zod/mini";
+var NodeCertifyQuerySchema = asSchema3("network.xyo.query.node.certify", true);
+var NodeCertifyQueryZod = z3.extend(PayloadZodOfSchema3(NodeCertifyQuerySchema), {
+  ...QueryFieldsZod3.shape,
+  id: z3.custom()
+});
+var isNodeCertifyQuery = zodIsFactory3(NodeCertifyQueryZod);
+var asNodeCertifyQuery = zodAsFactory3(NodeCertifyQueryZod, "asNodeCertifyQuery");
+var toNodeCertifyQuery = zodToFactory3(NodeCertifyQueryZod, "toNodeCertifyQuery");
+
+// src/Queries/Detach.ts
+import {
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory4
+} from "@xylabs/sdk";
+import {
+  asSchema as asSchema4,
+  PayloadZodOfSchema as PayloadZodOfSchema4,
+  QueryFieldsZod as QueryFieldsZod4
+} from "../../sdk-protocol/neutral/index.mjs";
+import * as z4 from "zod/mini";
+var NodeDetachQuerySchema = asSchema4("network.xyo.query.node.detach", true);
+var NodeDetachQueryZod = z4.extend(PayloadZodOfSchema4(NodeDetachQuerySchema), {
+  ...QueryFieldsZod4.shape,
+  id: z4.custom()
+});
+var isNodeDetachQuery = zodIsFactory4(NodeDetachQueryZod);
+var asNodeDetachQuery = zodAsFactory4(NodeDetachQueryZod, "asNodeDetachQuery");
+var toNodeDetachQuery = zodToFactory4(NodeDetachQueryZod, "toNodeDetachQuery");
+
+// src/Queries/Registered.ts
+import {
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory5
+} from "@xylabs/sdk";
+import {
+  asSchema as asSchema5,
+  PayloadZodOfSchema as PayloadZodOfSchema5,
+  QueryFieldsZod as QueryFieldsZod5
+} from "../../sdk-protocol/neutral/index.mjs";
+import * as z5 from "zod/mini";
+var NodeRegisteredQuerySchema = asSchema5("network.xyo.query.node.registered", true);
+var NodeRegisteredQueryZod = z5.extend(PayloadZodOfSchema5(NodeRegisteredQuerySchema), { ...QueryFieldsZod5.shape });
+var isNodeRegisteredQuery = zodIsFactory5(NodeRegisteredQueryZod);
+var asNodeRegisteredQuery = zodAsFactory5(NodeRegisteredQueryZod, "asNodeRegisteredQuery");
+var toNodeRegisteredQuery = zodToFactory5(NodeRegisteredQueryZod, "toNodeRegisteredQuery");
+
+// src/typeChecks.ts
+var instanceFactory = new IsInstanceFactory();
+var isNodeInstance = instanceFactory.create(
+  {
+    attach: "function",
+    attached: "function",
+    certify: "function",
+    detach: "function",
+    registered: "function"
+  },
+  [isModuleInstance]
+);
+var isNodeModule = new IsQueryableModuleFactory().create([NodeAttachedQuerySchema]);
+var asNodeModule = AsObjectFactory.create(isNodeModule);
+var asNodeInstance = AsObjectFactory.create(isNodeInstance);
+var withNodeModule = WithFactory.create(isNodeModule);
+var withNodeInstance = WithFactory.create(isNodeInstance);
+
+// src/attachable/isAttachableInstance.ts
+var requiredAttachableNodeInstanceFunctions = {};
+var factory = new IsObjectFactory();
+var isAttachableNodeInstance = factory.create(requiredAttachableNodeInstanceFunctions, [
+  isNodeInstance,
+  isAttachableModuleInstance
+]);
+
+// src/attachable/asAttachableInstance.ts
+var asAttachableNodeInstance = AsObjectFactory2.create(isAttachableNodeInstance);
+
+// src/attachable/AttachableInstance.ts
+import { IsObjectFactory as IsObjectFactory2 } from "@xylabs/sdk";
+var IsAttachableNodeInstanceFactory = class extends IsObjectFactory2 {
+};
+
+// src/ChildCertification.ts
+import {
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory6
+} from "@xylabs/sdk";
+import {
+  asSchema as asSchema6,
+  PayloadZodOfSchema as PayloadZodOfSchema6
+} from "../../sdk-protocol/neutral/index.mjs";
+import * as z6 from "zod/mini";
+var ChildCertificationSchema = asSchema6("network.xyo.child.certification", true);
+var ChildCertificationZod = z6.intersection(PayloadZodOfSchema6(ChildCertificationSchema), z6.custom());
+var isChildCertification = zodIsFactory6(ChildCertificationZod);
+var asChildCertification = zodAsFactory6(ChildCertificationZod, "asChildCertification");
+var toChildCertification = zodToFactory6(ChildCertificationZod, "toChildCertification");
+
+// src/Config.ts
+import {
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory7,
+  zodToFactory as zodToFactory7
+} from "@xylabs/sdk";
+import { ModuleConfigZod } from "../../module-model/neutral/index.mjs";
+import { asSchema as asSchema7 } from "../../sdk-protocol/neutral/index.mjs";
+import * as z7 from "zod/mini";
+var NodeConfigSchema = asSchema7("network.xyo.node.config", true);
+var NodeConfigZod = z7.extend(ModuleConfigZod, { schema: z7.literal(NodeConfigSchema) });
+var isNodeConfig = zodIsFactory7(NodeConfigZod);
+var asNodeConfig = zodAsFactory7(NodeConfigZod, "asNodeConfig");
+var toNodeConfig = zodToFactory7(NodeConfigZod, "toNodeConfig");
+export {
+  ChildCertificationSchema,
+  ChildCertificationZod,
+  IsAttachableNodeInstanceFactory,
+  NodeAttachQuerySchema,
+  NodeAttachQueryZod,
+  NodeAttachedQuerySchema,
+  NodeAttachedQueryZod,
+  NodeCertifyQuerySchema,
+  NodeCertifyQueryZod,
+  NodeConfigSchema,
+  NodeConfigZod,
+  NodeDetachQuerySchema,
+  NodeDetachQueryZod,
+  NodeRegisteredQuerySchema,
+  NodeRegisteredQueryZod,
+  asAttachableNodeInstance,
+  asChildCertification,
+  asNodeAttachQuery,
+  asNodeAttachedQuery,
+  asNodeCertifyQuery,
+  asNodeConfig,
+  asNodeDetachQuery,
+  asNodeInstance,
+  asNodeModule,
+  asNodeRegisteredQuery,
+  isAttachableNodeInstance,
+  isChildCertification,
+  isNodeAttachQuery,
+  isNodeAttachedQuery,
+  isNodeCertifyQuery,
+  isNodeConfig,
+  isNodeDetachQuery,
+  isNodeInstance,
+  isNodeModule,
+  isNodeRegisteredQuery,
+  requiredAttachableNodeInstanceFunctions,
+  toChildCertification,
+  toNodeAttachQuery,
+  toNodeAttachedQuery,
+  toNodeCertifyQuery,
+  toNodeConfig,
+  toNodeDetachQuery,
+  toNodeRegisteredQuery,
+  withNodeInstance,
+  withNodeModule
+};

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

@@ -0,0 +1,24 @@
+import type { AddressPayload, AttachableModuleInstance, ModuleIdentifier, ModuleInstance, ModuleQueryResult } from '../../module-model/neutral/index.ts';
+import type { AccountInstance, XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+import type { ChildCertification, ChildCertificationFields } from './ChildCertification.ts';
+import type { NodeModule, NodeModuleEventData } from './Node.ts';
+import type { NodeParams } from './Params.ts';
+export interface NodeQueryFunctions {
+    attach: (id: ModuleIdentifier, external?: boolean) => Promise<XyoAddress | undefined>;
+    attachQuery: (id: ModuleIdentifier, external?: boolean, account?: AccountInstance) => Promise<ModuleQueryResult<AddressPayload>>;
+    attached: () => 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>>;
+    registered: () => Promise<XyoAddress[]>;
+    registeredQuery: (account?: AccountInstance) => Promise<ModuleQueryResult<AddressPayload>>;
+}
+export interface NodeRegistrationFunctions {
+    register?: (mod: AttachableModuleInstance) => Promise<void>;
+    registeredModules?: () => AttachableModuleInstance[];
+    unregister?: (mod: ModuleInstance) => Promise<ModuleInstance>;
+}
+export interface NodeInstance<TParams extends NodeParams = NodeParams, TEventData extends NodeModuleEventData = NodeModuleEventData> extends NodeModule<TParams, TEventData>, NodeQueryFunctions, NodeRegistrationFunctions, ModuleInstance<TParams, TEventData> {
+}

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

@@ -0,0 +1,11 @@
+import type { TypeCheck } from '@xylabs/sdk';
+import type { NodeInstance } from './instance.ts';
+import type { NodeModule } from './Node.ts';
+export declare const isNodeInstance: TypeCheck<NodeInstance>;
+export declare const isNodeModule: TypeCheck<NodeModule>;
+export declare const asNodeModule: import("@xylabs/sdk").AsTypeFunction<NodeModule<import("./Params.ts").NodeParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").NodeConfig>>, import("./Node.ts").NodeModuleEventData>>;
+export declare const asNodeInstance: import("@xylabs/sdk").AsTypeFunction<NodeInstance<import("./Params.ts").NodeParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").NodeConfig>>, import("./Node.ts").NodeModuleEventData>>;
+/** @deprecated use narrowing instead [ if(is) ] */
+export declare const withNodeModule: <R>(mod: any, closure: (mod: NodeModule<import("./Params.ts").NodeParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").NodeConfig>>, import("./Node.ts").NodeModuleEventData>) => R) => R | undefined;
+/** @deprecated use narrowing instead [ if(is) ] */
+export declare const withNodeInstance: <R>(mod: any, closure: (mod: NodeInstance<import("./Params.ts").NodeParams<import("../../module-model/neutral/index.ts").AnyConfigSchema<import("./Config.ts").NodeConfig>>, import("./Node.ts").NodeModuleEventData>) => R) => R | undefined;

package/dist/_pkg/node-view/neutral/ViewNode.d.ts

@@ -0,0 +1,55 @@
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { AnyConfigSchema, ModuleFilterOptions, ModuleIdentifier, ModuleInstance } from '../../module-model/neutral/index.ts';
+import { MemoryNode } from '../../node-memory/neutral/index.ts';
+import type { AttachableNodeInstance, NodeConfig, NodeModuleEventData, NodeParams } from '../../node-model/neutral/index.ts';
+import { NodeConfigZod } from '../../node-model/neutral/index.ts';
+import { type Schema, type XyoAddress, type XyoQuantAddress } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const ViewNodeConfigSchema: 'network.xyo.node.view.config' & {
+    readonly __schema: true;
+};
+export type ViewNodeConfigSchema = typeof ViewNodeConfigSchema;
+export declare const ViewNodeConfigZod: z.ZodMiniObject<Omit<(typeof NodeConfigZod)['shape'], 'schema'> & {
+    ids: z.ZodMiniArray<z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>>;
+    schema: z.ZodMiniLiteral<ViewNodeConfigSchema>;
+    source: z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>;
+}, z.core.$strip>;
+export type ViewNodeConfigBase = z.infer<typeof ViewNodeConfigZod>;
+export declare const isViewNodeConfig: ReturnType<typeof zodIsFactory<ViewNodeConfigBase>>;
+export declare const asViewNodeConfig: ReturnType<typeof zodAsFactory<ViewNodeConfigBase>>;
+export declare const toViewNodeConfig: ReturnType<typeof zodToFactory<ViewNodeConfigBase>>;
+export type ViewNodeConfig = NodeConfig<{
+    ids: ModuleIdentifier[];
+    source: ModuleIdentifier;
+}, ViewNodeConfigSchema>;
+export type ViewNodeParams = NodeParams<AnyConfigSchema<ViewNodeConfig>>;
+export declare class ViewNode<TParams extends ViewNodeParams = ViewNodeParams, TEventData extends NodeModuleEventData = NodeModuleEventData> extends MemoryNode<TParams, TEventData> implements AttachableNodeInstance<TParams, TEventData> {
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    static readonly labels: {
+        ModuleLimitationLabelName: string;
+    };
+    private _buildMutex;
+    private _built;
+    private _limitedResolver;
+    get ids(): ModuleIdentifier[] | undefined;
+    get queries(): Schema[];
+    get source(): ModuleIdentifier | undefined;
+    /** @deprecated do not pass undefined.  If trying to get all, pass '*' */
+    resolve(): Promise<ModuleInstance[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>;
+    protected attachUsingAddress(address: XyoAddress): Promise<(Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | XyoQuantAddress>;
+    protected attachedPublicModules(): Promise<ModuleInstance[]>;
+    protected detachUsingAddress(address: XyoAddress): Promise<(Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | XyoQuantAddress>;
+    protected startHandler(): Promise<void>;
+    private build;
+}

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

@@ -0,0 +1 @@
+export * from './ViewNode.ts';

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

@@ -0,0 +1,143 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getProtoOf = Object.getPrototypeOf;
+var __reflectGet = Reflect.get;
+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);
+var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
+
+// src/ViewNode.ts
+import {
+  assertEx,
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { creatableModule, ModuleLimitationViewLabel } from "../../module-model/neutral/index.mjs";
+import { SimpleModuleResolver } from "../../module-resolver/neutral/index.mjs";
+import { MemoryNode, MemoryNodeHelper } from "../../node-memory/neutral/index.mjs";
+import {
+  asNodeInstance,
+  isNodeModule,
+  NodeAttachQuerySchema,
+  NodeConfigZod,
+  NodeDetachQuerySchema,
+  NodeRegisteredQuerySchema
+} from "../../node-model/neutral/index.mjs";
+import {
+  asSchema
+} from "../../sdk-protocol/neutral/index.mjs";
+import { Mutex } from "async-mutex";
+import * as z from "zod/mini";
+var ViewNodeConfigSchema = asSchema("network.xyo.node.view.config", true);
+var ViewNodeConfigZod = z.extend(NodeConfigZod, {
+  ids: z.array(z.custom()),
+  schema: z.literal(ViewNodeConfigSchema),
+  source: z.custom()
+});
+var isViewNodeConfig = zodIsFactory(ViewNodeConfigZod);
+var asViewNodeConfig = zodAsFactory(ViewNodeConfigZod, "asViewNodeConfig");
+var toViewNodeConfig = zodToFactory(ViewNodeConfigZod, "toViewNodeConfig");
+var ViewNode = class extends MemoryNode {
+  _buildMutex = new Mutex();
+  _built = false;
+  _limitedResolver = new SimpleModuleResolver({ root: this });
+  get ids() {
+    return this.config.ids;
+  }
+  get queries() {
+    const disallowedQueries = /* @__PURE__ */ new Set([NodeAttachQuerySchema, NodeDetachQuerySchema, NodeRegisteredQuerySchema]);
+    const queries = [...super.queries];
+    return queries.filter((query) => !disallowedQueries.has(query));
+  }
+  get source() {
+    return this.config.source;
+  }
+  async resolve(idOrFilter = "*", _options = {}) {
+    if (!this._built) {
+      await this.build();
+    }
+    const mods = await this._limitedResolver.resolve("*");
+    if (idOrFilter === "*") {
+      return mods;
+    }
+    switch (typeof idOrFilter) {
+      case "string": {
+        const mod = mods.find((mod2) => mod2.modName === idOrFilter || mod2.address === idOrFilter);
+        return mod;
+      }
+    }
+  }
+  async attachUsingAddress(address) {
+    const attached = await this.attached();
+    const mods = this.registeredModules().filter((mod2) => attached.includes(mod2.address));
+    const existingModule = mods.find((mod2) => mod2.address === address);
+    if (existingModule) {
+      this.logger?.warn(`ViewNode: Module [${existingModule?.modName ?? existingModule?.address}] already attached at address [${address}]`);
+    }
+    const mod = assertEx(this.registeredModuleMap[address], () => `Module [${address}] not found in registered mods`);
+    mod.addParent(this);
+    const args = { mod, name: mod.modName };
+    await this.emit("moduleAttached", args);
+    this._limitedResolver.add(mod);
+    if (isNodeModule(mod)) {
+      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);
+    }
+    return address;
+  }
+  async attachedPublicModules() {
+    return (await this._limitedResolver.resolve("*")).filter((mod) => mod.address !== this.address);
+  }
+  async detachUsingAddress(address) {
+    const mod = assertEx(await this.downResolver.resolve(address), () => `Module [${address}] not found in down resolver`);
+    this._limitedResolver.remove(mod.address);
+    return address;
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.build();
+  }
+  async build() {
+    if (this._buildMutex.isLocked()) {
+      return;
+    }
+    return await this._buildMutex.runExclusive(async () => {
+      if (!this._built) {
+        const source = this.source === void 0 ? void 0 : asNodeInstance(await super.resolve(this.source));
+        if (source) {
+          await Promise.all(
+            this.ids?.map(async (id) => {
+              await MemoryNodeHelper.attachToExistingNode(source, id, this);
+            }) ?? []
+          );
+          this._built = true;
+        }
+      }
+    });
+  }
+};
+__publicField(ViewNode, "configSchemas", [...__superGet(ViewNode, ViewNode, "configSchemas"), ViewNodeConfigSchema]);
+__publicField(ViewNode, "defaultConfigSchema", ViewNodeConfigSchema);
+__publicField(ViewNode, "labels", { ...ModuleLimitationViewLabel });
+ViewNode = __decorateClass([
+  creatableModule()
+], ViewNode);
+export {
+  ViewNode,
+  ViewNodeConfigSchema,
+  ViewNodeConfigZod,
+  asViewNodeConfig,
+  isViewNodeConfig,
+  toViewNodeConfig
+};

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

@@ -0,0 +1,24 @@
+import type { TypeCheck } from '@xylabs/sdk';
+import type { AddressPayload, AnyConfigSchema, InstanceTypeCheck, ModuleIdentifier, ModuleQueryResult } from '../../module-model/neutral/index.ts';
+import { ModuleWrapper } from '../../module-wrapper/neutral/index.ts';
+import type { ChildCertification, ChildCertificationFields, NodeConfig, NodeInstance, NodeModule, NodeModuleEventData, NodeParams } from '../../node-model/neutral/index.ts';
+import type { AccountInstance, NodeManifestPayload, XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+import { Mutex } from 'async-mutex';
+export declare class NodeWrapper<TWrappedModule extends NodeModule = NodeModule> extends ModuleWrapper<TWrappedModule> implements NodeInstance<TWrappedModule['params']> {
+    static readonly instanceIdentityCheck: InstanceTypeCheck<NodeInstance>;
+    static readonly moduleIdentityCheck: TypeCheck<NodeModule<NodeParams<AnyConfigSchema<NodeConfig>>, NodeModuleEventData>>;
+    static readonly requiredQueries: string[];
+    protected _attached?: XyoAddress[];
+    protected _attachedMutex: Mutex;
+    attach(id: ModuleIdentifier, external?: boolean): Promise<XyoAddress | undefined>;
+    attachQuery(id: ModuleIdentifier, external?: boolean, account?: AccountInstance): Promise<ModuleQueryResult<AddressPayload>>;
+    attached(): 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): Promise<NodeManifestPayload>;
+    registered(): Promise<XyoAddress[]>;
+    registeredQuery(account?: AccountInstance): Promise<ModuleQueryResult<AddressPayload>>;
+}

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

@@ -0,0 +1 @@
+export * from './NodeWrapper.ts';

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

@@ -0,0 +1,92 @@
+// src/NodeWrapper.ts
+import {
+  AddressSchema,
+  ModuleManifestQuerySchema
+} from "../../module-model/neutral/index.mjs";
+import { constructableModuleWrapper, ModuleWrapper } from "../../module-wrapper/neutral/index.mjs";
+import {
+  ChildCertificationSchema,
+  isNodeInstance,
+  isNodeModule,
+  NodeAttachedQuerySchema,
+  NodeAttachQuerySchema,
+  NodeCertifyQuerySchema,
+  NodeDetachQuerySchema,
+  NodeRegisteredQuerySchema
+} from "../../node-model/neutral/index.mjs";
+import { isPayloadOfSchemaType, NodeManifestPayloadSchema } from "../../sdk-protocol/neutral/index.mjs";
+import { Mutex } from "async-mutex";
+constructableModuleWrapper();
+var NodeWrapper = class extends ModuleWrapper {
+  static instanceIdentityCheck = isNodeInstance;
+  static moduleIdentityCheck = isNodeModule;
+  static requiredQueries = [NodeAttachQuerySchema, ...ModuleWrapper.requiredQueries];
+  _attached;
+  _attachedMutex = new Mutex();
+  async attach(id, external) {
+    const queryPayload = {
+      external,
+      id,
+      schema: NodeAttachQuerySchema
+    };
+    const payloads = (await this.sendQuery(queryPayload)).filter(isPayloadOfSchemaType(AddressSchema));
+    return payloads.pop()?.address;
+  }
+  async attachQuery(id, external, account) {
+    const queryPayload = {
+      external,
+      id,
+      schema: NodeAttachQuerySchema
+    };
+    return await this.sendQueryRaw(queryPayload, [], account);
+  }
+  async attached() {
+    return await this._attachedMutex.runExclusive(async () => {
+      if (this._attached === void 0) {
+        const queryPayload = { schema: NodeAttachedQuerySchema };
+        const payloads = (await this.sendQuery(queryPayload)).filter(isPayloadOfSchemaType(AddressSchema));
+        this._attached = payloads.map((p) => p.address);
+      }
+      return this._attached;
+    });
+  }
+  async attachedQuery(account) {
+    const queryPayload = { schema: NodeAttachedQuerySchema };
+    return await this.sendQueryRaw(queryPayload, [], account);
+  }
+  async certify(id) {
+    const queryPayload = { id, schema: NodeCertifyQuerySchema };
+    const payloads = (await this.sendQuery(queryPayload)).filter(isPayloadOfSchemaType(ChildCertificationSchema));
+    return payloads.pop();
+  }
+  async certifyQuery(id, account) {
+    const queryPayload = { id, schema: NodeCertifyQuerySchema };
+    return await this.sendQueryRaw(queryPayload, [], account);
+  }
+  async detach(id) {
+    const queryPayload = { id, schema: NodeDetachQuerySchema };
+    const payloads = (await this.sendQuery(queryPayload)).filter(isPayloadOfSchemaType(AddressSchema));
+    return payloads.pop()?.address;
+  }
+  async detachQuery(id, account) {
+    const queryPayload = { id, schema: NodeDetachQuerySchema };
+    return await this.sendQueryRaw(queryPayload, [], account);
+  }
+  async manifest(maxDepth) {
+    const queryPayload = { schema: ModuleManifestQuerySchema, ...maxDepth ? { maxDepth } : {} };
+    const payloads = (await this.sendQuery(queryPayload)).filter(isPayloadOfSchemaType(NodeManifestPayloadSchema));
+    return payloads.pop();
+  }
+  async registered() {
+    const queryPayload = { schema: NodeRegisteredQuerySchema };
+    const payloads = (await this.sendQuery(queryPayload)).filter(isPayloadOfSchemaType(AddressSchema));
+    return payloads.map((p) => p.address);
+  }
+  async registeredQuery(account) {
+    const queryPayload = { schema: NodeRegisteredQuerySchema };
+    return await this.sendQueryRaw(queryPayload, [], account);
+  }
+};
+export {
+  NodeWrapper
+};

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

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

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

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

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

@@ -0,0 +1,5 @@
+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';

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

@@ -0,0 +1,6 @@
+// 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";

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

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

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

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

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

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

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

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

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

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

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

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