@xyo-network/sdk 2.102.4 → 7.0.3

package/dist/_pkg/module-event-emitter/neutral/ModuleBaseEmitter.d.ts

@@ -0,0 +1,4 @@
+import type { BaseParams, EventData } from '@xylabs/sdk';
+import { BaseEmitter } from '@xylabs/sdk';
+export declare class ModuleBaseEmitter<TParams extends BaseParams = BaseParams, TEventData extends EventData = EventData> extends BaseEmitter<TParams, TEventData> {
+}

package/dist/_pkg/module-event-emitter/neutral/index.d.ts

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

package/dist/_pkg/module-event-emitter/neutral/index.mjs

@@ -0,0 +1,7 @@
+// src/ModuleBaseEmitter.ts
+import { BaseEmitter } from "@xylabs/sdk";
+var ModuleBaseEmitter = class extends BaseEmitter {
+};
+export {
+  ModuleBaseEmitter
+};

package/dist/_pkg/module-factory-locator/neutral/ModuleFactoryLocator.d.ts

@@ -0,0 +1,43 @@
+import type { CreatableModuleFactory, CreatableModuleRegistry, LabeledCreatableModuleFactory, Labels, ModuleFactoryLocatorInstance } from '../../module-model/neutral/index.ts';
+import { type Schema } from '../../sdk-protocol/neutral/index.ts';
+/**
+ * A class which encapsulates the Service Locator Pattern for Module Factories
+ */
+export declare class ModuleFactoryLocator implements ModuleFactoryLocatorInstance {
+    protected readonly _registry: CreatableModuleRegistry;
+    private _frozen;
+    constructor(_registry?: CreatableModuleRegistry);
+    /**
+     * The current registry for the module factory
+     */
+    get registry(): Readonly<CreatableModuleRegistry>;
+    static empty(): ModuleFactoryLocator;
+    static standard(): ModuleFactoryLocator;
+    freeze(): void;
+    /**
+     * Locates a module factory that matches the supplied schema and labels
+     * @param schema The config schema for the module
+     * @param labels The labels for the module factory
+     * @returns A module factory that matches the supplied schema and labels or throws if one is not found
+     */
+    locate(schema: Schema, labels?: Labels): CreatableModuleFactory | LabeledCreatableModuleFactory;
+    merge(locator: ModuleFactoryLocatorInstance): ModuleFactoryLocatorInstance;
+    /**
+     * Registers a single module factory (with optional tags) with the locator
+     * @param factory The factory to register
+     * @param labels The labels for the module factory
+     */
+    register(factory: CreatableModuleFactory, labels?: Labels, primary?: boolean | Schema | Schema[]): this;
+    /**
+     * Registers multiple module factories with the locator
+     * @param factories The factories to register
+     */
+    registerMany(factories: CreatableModuleFactory[]): this;
+    /**
+     * Tries to locate a module factory that matches the supplied schema and labels
+     * @param schema The config schema for the module
+     * @param labels The labels for the module factory
+     * @returns A module factory that matches the supplied schema and labels or undefined
+     */
+    tryLocate(schema: Schema, labels?: Labels): CreatableModuleFactory | LabeledCreatableModuleFactory | undefined;
+}

package/dist/_pkg/module-factory-locator/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ModuleFactoryLocator.ts';
+export * from './standardCreatableFactories.ts';

package/dist/_pkg/module-factory-locator/neutral/index.mjs

@@ -0,0 +1,120 @@
+// src/ModuleFactoryLocator.ts
+import { assertEx } from "@xylabs/sdk";
+import {
+  hasAllLabels,
+  hasLabels,
+  registerCreatableModuleFactory
+} from "../../module-model/neutral/index.mjs";
+import { asSchema } from "../../sdk-protocol/neutral/index.mjs";
+
+// src/standardCreatableFactories.ts
+import { MemoryArchivist } from "../../archivist-memory/neutral/index.mjs";
+import { ViewArchivist } from "../../archivist-view/neutral/index.mjs";
+import { HttpBridge } from "../../bridge-http/neutral/index.mjs";
+import { MemoryBoundWitnessDiviner } from "../../diviner-boundwitness/neutral/memory.mjs";
+import { IdentityDiviner } from "../../diviner-identity/neutral/index.mjs";
+import { GenericPayloadDiviner } from "../../diviner-payload-generic/neutral/index.mjs";
+import { registerCreatableModuleFactories } from "../../module-model/neutral/index.mjs";
+import { MemoryNode } from "../../node-memory/neutral/index.mjs";
+import { ViewNode } from "../../node-view/neutral/index.mjs";
+import { MemorySentinel } from "../../sentinel-memory/neutral/index.mjs";
+import { AdhocWitness } from "../../witness-adhoc/neutral/index.mjs";
+var standardCreatableModulesList = [
+  HttpBridge.factory(),
+  ViewArchivist.factory(),
+  ViewNode.factory(),
+  AdhocWitness.factory(),
+  GenericPayloadDiviner.factory(),
+  MemoryBoundWitnessDiviner.factory(),
+  IdentityDiviner.factory(),
+  MemoryArchivist.factory(),
+  MemoryArchivist.factory(),
+  MemoryNode.factory(),
+  MemorySentinel.factory(),
+  GenericPayloadDiviner.factory()
+];
+var standardCreatableFactories = () => {
+  return registerCreatableModuleFactories(standardCreatableModulesList, {}, true);
+};
+
+// src/ModuleFactoryLocator.ts
+var ModuleFactoryLocator = class _ModuleFactoryLocator {
+  _registry;
+  _frozen = false;
+  constructor(_registry = standardCreatableFactories()) {
+    this._registry = _registry;
+  }
+  /**
+   * The current registry for the module factory
+   */
+  get registry() {
+    return this._registry;
+  }
+  static empty() {
+    return new _ModuleFactoryLocator({});
+  }
+  static standard() {
+    return new _ModuleFactoryLocator(standardCreatableFactories());
+  }
+  freeze() {
+    this._frozen = true;
+  }
+  /**
+   * Locates a module factory that matches the supplied schema and labels
+   * @param schema The config schema for the module
+   * @param labels The labels for the module factory
+   * @returns A module factory that matches the supplied schema and labels or throws if one is not found
+   */
+  locate(schema, labels) {
+    return assertEx(
+      this.tryLocate(schema, labels),
+      () => `No module factory for the supplied config schema [${schema}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} registered`
+    );
+  }
+  merge(locator) {
+    const registry = { ...this.registry };
+    for (const schema in locator.registry) {
+      const typedSchema = asSchema(schema, true);
+      if (registry[typedSchema]) {
+        registry[typedSchema].push(...locator.registry[typedSchema] ?? []);
+      } else {
+        registry[typedSchema] = locator.registry[typedSchema];
+      }
+    }
+    return new _ModuleFactoryLocator(registry);
+  }
+  /**
+   * Registers a single module factory (with optional tags) with the locator
+   * @param factory The factory to register
+   * @param labels The labels for the module factory
+   */
+  register(factory, labels, primary = false) {
+    assertEx(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
+    registerCreatableModuleFactory(this._registry, factory, labels, primary);
+    return this;
+  }
+  /**
+   * Registers multiple module factories with the locator
+   * @param factories The factories to register
+   */
+  registerMany(factories) {
+    for (const factory of factories) {
+      this.register(factory);
+    }
+    return this;
+  }
+  /**
+   * Tries to locate a module factory that matches the supplied schema and labels
+   * @param schema The config schema for the module
+   * @param labels The labels for the module factory
+   * @returns A module factory that matches the supplied schema and labels or undefined
+   */
+  tryLocate(schema, labels) {
+    return labels ? this._registry[schema]?.filter(hasLabels).find((factory) => hasAllLabels(factory?.labels, labels)) ?? this._registry[schema]?.[0] : this._registry[schema]?.[0];
+  }
+};
+export {
+  ModuleFactoryLocator,
+  standardCreatableFactories,
+  standardCreatableModulesList
+};

package/dist/_pkg/module-factory-locator/neutral/standardCreatableFactories.d.ts

@@ -0,0 +1,3 @@
+import type { CreatableModuleFactory, CreatableModuleRegistry, LabeledCreatableModuleFactory } from '../../module-model/neutral/index.ts';
+export declare const standardCreatableModulesList: (CreatableModuleFactory | LabeledCreatableModuleFactory)[];
+export declare const standardCreatableFactories: () => CreatableModuleRegistry;

package/dist/_pkg/module-model/neutral/Config/Archiving.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+import type { ModuleIdentifier } from '../ModuleIdentifier.ts';
+export declare const ArchivingModuleConfigZod: z.ZodMiniObject<{
+    archiving: z.ZodMiniOptional<z.ZodMiniObject<{
+        archivists: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>>>;
+        queries: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniCustom<Schema, Schema>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ArchivingModuleConfig = z.infer<typeof ArchivingModuleConfigZod>;

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

@@ -0,0 +1,27 @@
+import type { EmptyObject } from '@xylabs/sdk';
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import { type Payload, PayloadZod, type Schema } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+import { ArchivingModuleConfigZod } from './Archiving.ts';
+import { ModuleConfigFieldsZod } from './Fields.ts';
+import { ArchivingReentrancyConfigZod } from './Reentrancy.ts';
+export declare const ModuleConfigSchema: 'network.xyo.module.config' & {
+    readonly __schema: true;
+};
+export type ModuleConfigSchema = typeof ModuleConfigSchema;
+export type WithAdditional<T extends EmptyObject = EmptyObject, TAdditional extends EmptyObject = EmptyObject> = T & TAdditional;
+export declare const ModuleConfigZod: z.ZodMiniObject<(typeof PayloadZod)['shape'] & (typeof ModuleConfigFieldsZod)['shape'] & (typeof ArchivingModuleConfigZod)['shape'] & (typeof ArchivingReentrancyConfigZod)['shape'], z.core.$strip>;
+export type ModuleConfigBase = z.infer<typeof ModuleConfigZod>;
+export declare const isModuleConfig: ReturnType<typeof zodIsFactory<ModuleConfigBase>>;
+export declare const asModuleConfig: ReturnType<typeof zodAsFactory<ModuleConfigBase>>;
+export declare const toModuleConfig: ReturnType<typeof zodToFactory<ModuleConfigBase>>;
+export type ModuleConfig<TConfig extends EmptyObject | Payload = EmptyObject, TSchema extends Schema | void = void> = Payload<WithAdditional<Omit<ModuleConfigBase, 'schema'>, TConfig>, TSchema extends void ? TConfig extends Payload ? TConfig['schema'] : Schema : TSchema>;
+export type AnyConfigSchema<TConfig extends Omit<ModuleConfig, 'schema'> & {
+    schema: Schema;
+} = Omit<ModuleConfig, 'schema'> & {
+    schema: Schema;
+}> = ModuleConfig<TConfig, Schema>;
+export type OptionalConfigSchema<TConfig extends AnyConfigSchema<ModuleConfig> = AnyConfigSchema<ModuleConfig>> = Omit<TConfig, 'schema'> & {
+    schema?: TConfig['schema'];
+};
+export type AnyModuleConfig = AnyConfigSchema<ModuleConfig>;

package/dist/_pkg/module-model/neutral/Config/Fields.d.ts

@@ -0,0 +1,23 @@
+import type { LogLevelValue, RetryConfig } from '@xylabs/sdk';
+import type { Schema } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+import type { Labels } from '../Labels/index.ts';
+import type { ModuleIdentifier, ModuleName } from '../ModuleIdentifier.ts';
+import type { ModuleSecurityConfig } from './Security.ts';
+export declare const ModuleConfigFieldsZod: z.ZodMiniObject<{
+    allowedQueries: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniCustom<Schema, Schema>>>;
+    archivist: z.ZodMiniOptional<z.ZodMiniCustom<ModuleIdentifier, ModuleIdentifier>>;
+    labels: z.ZodMiniOptional<z.ZodMiniCustom<Labels, Labels>>;
+    logLevel: z.ZodMiniOptional<z.ZodMiniCustom<LogLevelValue, LogLevelValue>>;
+    name: z.ZodMiniOptional<z.ZodMiniCustom<ModuleName, ModuleName>>;
+    paging: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+        size: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    }, z.core.$strip>>>;
+    retry: z.ZodMiniOptional<z.ZodMiniCustom<RetryConfig, RetryConfig>>;
+    security: z.ZodMiniOptional<z.ZodMiniCustom<ModuleSecurityConfig, ModuleSecurityConfig>>;
+    sign: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    storeQueries: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    timeBudget: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    timestamp: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strip>;
+export type ModuleConfigFields = z.infer<typeof ModuleConfigFieldsZod>;

package/dist/_pkg/module-model/neutral/Config/Reentrancy.d.ts

@@ -0,0 +1,8 @@
+import * as z from 'zod/mini';
+export declare const ArchivingReentrancyConfigZod: z.ZodMiniObject<{
+    reentrancy: z.ZodMiniOptional<z.ZodMiniObject<{
+        action: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<'skip'>, z.ZodMiniLiteral<'wait'>]>;
+        scope: z.ZodMiniLiteral<'global'>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ArchivingReentrancyConfig = z.infer<typeof ArchivingReentrancyConfigZod>;

package/dist/_pkg/module-model/neutral/Config/Security.d.ts

@@ -0,0 +1,9 @@
+import type { Schema, XyoAddress } from '../../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export type CosigningAddressSet = XyoAddress[];
+export declare const ModuleSecurityConfigZod: z.ZodMiniObject<{
+    allowAnonymous: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    allowed: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniCustom<Schema, Schema>, z.ZodMiniArray<z.ZodMiniCustom<XyoAddress | CosigningAddressSet, XyoAddress | CosigningAddressSet>>>>;
+    disallowed: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniCustom<Schema, Schema>, z.ZodMiniArray<z.ZodMiniCustom<XyoAddress, XyoAddress>>>>;
+}, z.core.$strip>;
+export type ModuleSecurityConfig = z.infer<typeof ModuleSecurityConfigZod>;

package/dist/_pkg/module-model/neutral/Config/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Archiving.ts';
+export * from './Config.ts';
+export * from './Fields.ts';
+export * from './Reentrancy.ts';
+export * from './Security.ts';

package/dist/_pkg/module-model/neutral/CreatableModule/CreatableModule.d.ts

@@ -0,0 +1,26 @@
+import type { Creatable, CreatableInstance, Logger } from '@xylabs/sdk';
+import type { Schema } from '../../../sdk-protocol/neutral/index.ts';
+import type { ModuleEventData } from '../EventsModels/index.ts';
+import type { AttachableModuleInstance } from '../instance/index.ts';
+import type { QueryableModuleParams } from '../QueryableModule/index.ts';
+export interface CreatableModuleInstance<TParams extends QueryableModuleParams = QueryableModuleParams, TEventData extends ModuleEventData = ModuleEventData> extends CreatableInstance<TParams, TEventData>, AttachableModuleInstance<TParams, TEventData> {
+}
+export interface CreatableModuleFactory<T extends CreatableModuleInstance = CreatableModuleInstance> extends Omit<CreatableModule<T>, 'create' | 'createHandler' | 'paramsHandler'> {
+    creatableModule: CreatableModule<T>;
+    defaultParams?: Partial<T['params']>;
+    create(this: CreatableModuleFactory<T>, params?: Partial<T['params']>): Promise<T>;
+}
+export interface CreatableModule<T extends CreatableModuleInstance = CreatableModuleInstance> extends Creatable<T> {
+    configSchemas: Schema[];
+    defaultConfigSchema: Schema;
+    defaultLogger?: Logger;
+    new (key: unknown, params: Partial<T['params']>): T;
+    factory(params?: Partial<T['params']>): CreatableModuleFactory<T>;
+}
+/**
+ * Class annotation to be used to decorate Modules which support
+ * an asynchronous creation pattern
+ * @returns The decorated Module requiring it implement the members
+ * of the CreatableModule as statics properties/methods
+ */
+export declare function creatableModule<TModule extends CreatableModuleInstance = CreatableModuleInstance>(): <U extends CreatableModule<TModule>>(constructor: U) => void;

package/dist/_pkg/module-model/neutral/CreatableModule/CreatableModuleRegistry.d.ts

@@ -0,0 +1,11 @@
+import { type Schema } from '../../../sdk-protocol/neutral/index.ts';
+import type { Labels } from '../Labels/index.ts';
+import type { CreatableModuleFactory, CreatableModuleInstance } from './CreatableModule.ts';
+import type { LabeledCreatableModuleFactory } from './LabeledCreatableModuleFactory.ts';
+export type CreatableModuleRegistry = Record<Schema, (CreatableModuleFactory | LabeledCreatableModuleFactory)[] | undefined>;
+export declare const registerCreatableModuleFactory: <TModule extends CreatableModuleInstance>(registry: CreatableModuleRegistry, factory: CreatableModuleFactory<TModule> | LabeledCreatableModuleFactory<TModule>, labels?: Labels, 
+/** register this as the primary factory for every schema it supports */
+primary?: boolean | Schema | Schema[]) => void;
+export declare const registerCreatableModuleFactories: (factories: (CreatableModuleFactory | LabeledCreatableModuleFactory)[], registry?: CreatableModuleRegistry, primary?: boolean) => CreatableModuleRegistry;
+/** @deprecated use registerCreatableModuleFactory instead */
+export declare const assignCreatableModuleRegistry: (target?: CreatableModuleRegistry, ...sources: CreatableModuleRegistry[]) => CreatableModuleRegistry;

package/dist/_pkg/module-model/neutral/CreatableModule/LabeledCreatableModule.d.ts

@@ -0,0 +1,13 @@
+import type { WithOptionalLabels } from '../Labels/index.ts';
+import type { CreatableModule, CreatableModuleInstance } from './CreatableModule.ts';
+import type { LabeledCreatableModuleFactory } from './LabeledCreatableModuleFactory.ts';
+export interface LabeledCreatableModule<T extends CreatableModuleInstance = CreatableModuleInstance> extends CreatableModule<T>, WithOptionalLabels {
+    factory(params?: Partial<T['params']>): LabeledCreatableModuleFactory<T>;
+}
+/**
+ * Class annotation to be used to decorate Modules which support
+ * an asynchronous creation pattern
+ * @returns The decorated Module requiring it implement the members
+ * of the CreatableModule as statics properties/methods
+ */
+export declare function labeledCreatableModule<TModule extends CreatableModuleInstance = CreatableModuleInstance>(): <U extends LabeledCreatableModule<TModule>>(constructor: U) => void;

package/dist/_pkg/module-model/neutral/CreatableModule/LabeledCreatableModuleFactory.d.ts

@@ -0,0 +1,11 @@
+import type { WithOptionalLabels } from '../Labels/index.ts';
+import type { CreatableModuleFactory, CreatableModuleInstance } from './CreatableModule.ts';
+export type LabeledCreatableModuleFactory<T extends CreatableModuleInstance = CreatableModuleInstance> = CreatableModuleFactory<T> & WithOptionalLabels;
+export declare const hasLabels: (factory: CreatableModuleFactory | LabeledCreatableModuleFactory) => factory is LabeledCreatableModuleFactory;
+/**
+ * Class annotation to be used to decorate Modules which support
+ * an asynchronous labeled creation factory pattern
+ * @returns The decorated Module requiring it implement the members
+ * of the CreatableModule as statics properties/methods
+ */
+export declare function labeledCreatableModuleFactory<TModule extends CreatableModuleInstance = CreatableModuleInstance>(): <U extends LabeledCreatableModuleFactory<TModule>>(constructor: U) => void;

package/dist/_pkg/module-model/neutral/CreatableModule/ModuleFactory.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from '@xylabs/sdk';
+import type { Schema } from '../../../sdk-protocol/neutral/index.ts';
+import type { Labels } from '../Labels/index.ts';
+import type { CreatableModule, CreatableModuleFactory, CreatableModuleInstance } from './CreatableModule.ts';
+export declare class ModuleFactory<TModule extends CreatableModuleInstance> implements CreatableModuleFactory<TModule> {
+    configSchemas: CreatableModule<TModule>['configSchemas'];
+    creatableModule: CreatableModule<TModule>;
+    defaultConfigSchema: Schema;
+    defaultLogger?: Logger;
+    defaultParams?: Partial<TModule['params']>;
+    labels?: Labels;
+    constructor(creatableModule: CreatableModule<TModule>, params?: Partial<TModule['params']>, labels?: Labels);
+    static withParams<T extends CreatableModuleInstance>(creatableModule: CreatableModule<T>, params?: Partial<T['params']>, labels?: Labels): ModuleFactory<T>;
+    create(this: CreatableModuleFactory<TModule>, params?: Partial<TModule['params']>): Promise<TModule>;
+    factory<T extends CreatableModuleInstance>(this: CreatableModuleFactory<T>, params?: Partial<T['params']>, labels?: Labels): CreatableModuleFactory<T>;
+}

package/dist/_pkg/module-model/neutral/CreatableModule/index.d.ts

@@ -0,0 +1,5 @@
+export * from './CreatableModule.ts';
+export * from './CreatableModuleRegistry.ts';
+export * from './LabeledCreatableModule.ts';
+export * from './LabeledCreatableModuleFactory.ts';
+export * from './ModuleFactory.ts';

package/dist/_pkg/module-model/neutral/DetailsError.d.ts

@@ -0,0 +1,5 @@
+import type { JsonValue } from '@xylabs/sdk';
+export declare class ModuleDetailsError extends Error {
+    details?: JsonValue;
+    constructor(message: string, details?: JsonValue);
+}

package/dist/_pkg/module-model/neutral/EventsModels/ModuleBusy.d.ts

@@ -0,0 +1,8 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs } from './ModuleEventArgs.ts';
+export type ModuleBusyEventArgs<TModule extends object = object> = ModuleEventArgs<TModule, {
+    busy: boolean;
+}>;
+export interface ModuleBusyEventData<TModule extends object = object> extends EventData {
+    moduleBusy: ModuleBusyEventArgs<TModule>;
+}

package/dist/_pkg/module-model/neutral/EventsModels/ModuleError.d.ts

@@ -0,0 +1,8 @@
+import type { EventData } from '@xylabs/sdk';
+import type { ModuleEventArgs } from './ModuleEventArgs.ts';
+export type ModuleErrorEventArgs<TModule extends object = object> = ModuleEventArgs<TModule, {
+    error: Error;
+}>;
+export interface ModuleErrorEventData<TModule extends object = object> extends EventData {
+    moduleError: ModuleErrorEventArgs<TModule>;
+}

package/dist/_pkg/module-model/neutral/EventsModels/ModuleEventArgs.d.ts

@@ -0,0 +1,5 @@
+export type ModuleEventArgs<TModule extends object = object, TArgs = undefined> = [TArgs] extends [undefined] ? {
+    mod: TModule;
+} : {
+    mod: TModule;
+} & TArgs;

package/dist/_pkg/module-model/neutral/EventsModels/ModuleEventData.d.ts

@@ -0,0 +1,5 @@
+import type { ModuleBusyEventData } from './ModuleBusy.ts';
+import type { ModuleErrorEventData } from './ModuleError.ts';
+import type { ModuleQueriedEventData } from './ModuleQueried.ts';
+export interface ModuleEventData<TModule extends object = object> extends ModuleQueriedEventData<TModule>, ModuleBusyEventData<TModule>, ModuleErrorEventData<TModule> {
+}

package/dist/_pkg/module-model/neutral/EventsModels/ModuleQueried.d.ts

@@ -0,0 +1,12 @@
+import type { EventData } from '@xylabs/sdk';
+import type { Payload, QueryBoundWitness } from '../../../sdk-protocol/neutral/index.ts';
+import type { ModuleQueryResult } from '../ModuleQueryResult.ts';
+import type { ModuleEventArgs } from './ModuleEventArgs.ts';
+export type ModuleQueriedEventArgs<TModule extends object = object> = ModuleEventArgs<TModule, {
+    payloads?: Payload[];
+    query: QueryBoundWitness;
+    result: ModuleQueryResult;
+}>;
+export interface ModuleQueriedEventData<TModule extends object = object> extends EventData {
+    moduleQueried: ModuleQueriedEventArgs<TModule>;
+}

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

@@ -0,0 +1,5 @@
+export * from './ModuleBusy.ts';
+export * from './ModuleError.ts';
+export * from './ModuleEventArgs.ts';
+export * from './ModuleEventData.ts';
+export * from './ModuleQueried.ts';

package/dist/_pkg/module-model/neutral/Job/Job.d.ts

@@ -0,0 +1,11 @@
+import type { Task } from './Task.ts';
+export type VoidFunction = (...anyArguments: unknown[]) => void;
+export interface Job {
+    name: string;
+    onComplete?: VoidFunction;
+    onFail?: VoidFunction;
+    onStart?: VoidFunction;
+    onSuccess?: VoidFunction;
+    schedule: string;
+    task: Task;
+}

package/dist/_pkg/module-model/neutral/Job/JobProvider.d.ts

@@ -0,0 +1,4 @@
+import type { Job } from './Job.ts';
+export interface JobProvider {
+    get jobs(): Job[];
+}

package/dist/_pkg/module-model/neutral/Job/JobQueue.d.ts

@@ -0,0 +1,12 @@
+import type { EventData, EventEmitter } from '@xylabs/sdk';
+import type { Job } from './Job.ts';
+/** @internal */
+export interface DefineOptions {
+    lockLifetime?: number;
+}
+/** @internal */
+export interface JobQueue extends EventEmitter<EventData> {
+    define: (name: string, options: DefineOptions, processor: Job['task']) => void;
+    every: (interval: string, names: string | string[]) => Promise<void>;
+    start: () => Promise<unknown>;
+}

package/dist/_pkg/module-model/neutral/Job/Task.d.ts

@@ -0,0 +1 @@
+export type Task = () => Promise<void>;

package/dist/_pkg/module-model/neutral/Job/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Job.ts';
+export * from './JobProvider.ts';
+export * from './JobQueue.ts';

package/dist/_pkg/module-model/neutral/Labels/Labels.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Object used to represent labels identifying a resource.
+ */
+export type Labels = Record<string, string | undefined>;
+/**
+ * Interface for objects that have labels.
+ */
+export interface WithLabels<T extends Labels = Labels> {
+    labels: T;
+}
+/**
+ * Interface for objects that have labels.
+ */
+export interface WithOptionalLabels<T extends Labels = Labels> {
+    labels?: T;
+}
+/**
+ * Returns true if the source object has all the labels from the required set
+ * @param source Source object to check against
+ * @param required Set of labels to check for in source
+ * @returns True of the source object has all the labels from the required set
+ */
+export declare const hasAllLabels: (source?: Labels, required?: Labels) => boolean;

package/dist/_pkg/module-model/neutral/Labels/index.d.ts

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

package/dist/_pkg/module-model/neutral/Labels/standard/View.d.ts

@@ -0,0 +1,5 @@
+export declare const ModuleLimitationLabelName = "network.xyo.module.limitation";
+export type ModuleLimitationLabelName = typeof ModuleLimitationLabelName;
+export declare const ModuleLimitationViewLabel: {
+    ModuleLimitationLabelName: string;
+};

package/dist/_pkg/module-model/neutral/Labels/standard/index.d.ts

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

package/dist/_pkg/module-model/neutral/ModuleDescription.d.ts

@@ -0,0 +1,8 @@
+import type { XyoAddress } from '../../sdk-protocol/neutral/index.ts';
+import type { ModuleName } from './ModuleIdentifier.ts';
+export interface ModuleDescription {
+    address: XyoAddress;
+    children?: string[];
+    name?: ModuleName;
+    queries: string[];
+}

package/dist/_pkg/module-model/neutral/ModuleFactoryLocatorInstance.d.ts

@@ -0,0 +1,36 @@
+import type { Schema } from '../../sdk-protocol/neutral/index.ts';
+import type { CreatableModuleFactory, CreatableModuleRegistry, LabeledCreatableModuleFactory } from './CreatableModule/index.ts';
+import type { Labels } from './Labels/index.ts';
+export interface ModuleFactoryLocatorInstance {
+    /**
+     * The current registry for the module factory
+     */
+    registry: Readonly<CreatableModuleRegistry>;
+    freeze(): void;
+    /**
+     * Locates a module factory that matches the supplied schema and labels
+     * @param schema The config schema for the module
+     * @param labels The labels for the module factory
+     * @returns A module factory that matches the supplied schema and labels or throws if one is not found
+     */
+    locate(schema: string, labels?: Labels): CreatableModuleFactory | LabeledCreatableModuleFactory;
+    merge(locator: ModuleFactoryLocatorInstance): ModuleFactoryLocatorInstance;
+    /**
+     * Registers a single module factory (with optional tags) with the locator
+     * @param factory The factory to register
+     * @param labels The labels for the module factory
+     */
+    register(factory: CreatableModuleFactory, labels?: Labels, primary?: boolean | Schema | Schema[]): ModuleFactoryLocatorInstance;
+    /**
+     * Registers multiple module factories with the locator
+     * @param factories The factories to register
+     */
+    registerMany(factories: CreatableModuleFactory[]): ModuleFactoryLocatorInstance;
+    /**
+     * Tries to locate a module factory that matches the supplied schema and labels
+     * @param schema The config schema for the module
+     * @param labels The labels for the module factory
+     * @returns A module factory that matches the supplied schema and labels or undefined
+     */
+    tryLocate(schema: string, labels?: Labels): CreatableModuleFactory | LabeledCreatableModuleFactory | undefined;
+}

package/dist/_pkg/module-model/neutral/ModuleIdentifier.d.ts

@@ -0,0 +1,42 @@
+import type { Address } from '@xylabs/sdk';
+export declare const MODULE_PATH_SEPARATOR: ":";
+export declare const DisallowedModuleIdentifierCharacters: {
+    ' ': boolean;
+    '!': boolean;
+    '"': boolean;
+    '#': boolean;
+    $: boolean;
+    '%': boolean;
+    '&': boolean;
+    "'": boolean;
+    '(': boolean;
+    ')': boolean;
+    '*': boolean;
+    ',': boolean;
+    '.': boolean;
+    '/': boolean;
+    ':': boolean;
+    ';': boolean;
+    '<': boolean;
+    '=': boolean;
+    '>': boolean;
+    '?': boolean;
+    '@': boolean;
+    '[': boolean;
+    ']': boolean;
+    '^': boolean;
+    _: boolean;
+    '{': boolean;
+    '|': boolean;
+    '}': boolean;
+    '~': boolean;
+};
+export type ReservedModuleIdentifierCharacter = keyof typeof DisallowedModuleIdentifierCharacters;
+export declare const ReservedModuleIdentifierCharacters: Set<ReservedModuleIdentifierCharacter>;
+export type ModuleName = string;
+export type ModuleIdentifier = ColonPair<ModuleIdentifierPart> | ColonPair<ColonPair<ModuleIdentifierPart>> | ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>> | ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>> | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>> | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>> | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>>>;
+export type ColonPair<T extends string> = `${T}:${T}` | T;
+export type ModuleIdentifierPart = Exclude<Address | ModuleName, '*'>;
+export declare const isModuleName: (value: unknown) => value is ModuleName;
+export declare const includesReservedModuleIdentifierCharacter: (value: unknown) => boolean;
+export declare const isModuleIdentifierPart: (value: unknown) => value is ModuleIdentifierPart;

package/dist/_pkg/module-model/neutral/ModuleIdentifierTransformer.d.ts

@@ -0,0 +1,6 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { ModuleIdentifier } from './ModuleIdentifier.ts';
+export type ModuleIdentifierTransformerFunc = (id: ModuleIdentifier) => Promisable<ModuleIdentifier | undefined>;
+export interface ModuleIdentifierTransformer {
+    transform: ModuleIdentifierTransformerFunc;
+}

package/dist/_pkg/module-model/neutral/ModuleQueryHandlerResult.d.ts

@@ -0,0 +1,2 @@
+import type { Payload } from '../../sdk-protocol/neutral/index.ts';
+export type ModuleQueryHandlerResult = Payload[];

package/dist/_pkg/module-model/neutral/ModuleQueryResult.d.ts

@@ -0,0 +1,6 @@
+import type { BoundWitness, ModuleError, Payload } from '../../sdk-protocol/neutral/index.ts';
+export type ModuleQueryResult<P extends Payload = Payload, E extends ModuleError = ModuleError, B extends BoundWitness = BoundWitness> = [
+    B,
+    P[],
+    E[]
+];