@xyo-network/sdk 7.0.3 → 7.0.4

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

@@ -1,228 +0,0 @@
-// 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

@@ -1,24 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

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

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

@@ -1,143 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

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

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

@@ -1,92 +0,0 @@
-// 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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