@xyo-network/xl1-protocol-sdk 4.0.10 → 4.0.12

package/dist/node/config/LocatorConfigFields.d.ts

@@ -1,116 +0,0 @@
-import { z } from 'zod/mini';
-/**
- * Shared locator process fields — single source of truth for connection and
- * provider binding config. Composed by `ConfigZod`, refined by
- * `ResolvedLocatorConfigZod`, and imported by orchestration run-config parsing.
- */
-export declare const LocatorConfigFieldsZod: z.ZodMiniObject<{
-    chain: z.ZodMiniDefault<z.ZodMiniObject<{
-        id: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
-        genesisRewardAddress: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-    }, z.core.$strip>>;
-    log: z.ZodMiniDefault<import("zod").ZodObject<{
-        logLevel: import("zod").ZodDefault<import("zod").ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
-            log: "log";
-            debug: "debug";
-            trace: "trace";
-        }>>;
-        silent: import("zod").ZodDefault<import("zod").ZodBoolean>;
-    }, z.core.$strip>>;
-    connections: z.ZodMiniDefault<import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-        access: import("zod").ZodOptional<import("zod").ZodEnum<{
-            read: "read";
-            write: "write";
-        }>>;
-        root: import("zod").ZodString;
-        store: import("zod").ZodOptional<import("zod").ZodString>;
-        type: import("zod").ZodLiteral<"lmdb">;
-    }, z.core.$strip>, import("zod").ZodObject<{
-        type: import("zod").ZodLiteral<"mongo">;
-        connectionString: import("zod").ZodOptional<import("zod").ZodString>;
-        database: import("zod").ZodOptional<import("zod").ZodString>;
-        domain: import("zod").ZodOptional<import("zod").ZodString>;
-        password: import("zod").ZodOptional<import("zod").ZodString>;
-        username: import("zod").ZodOptional<import("zod").ZodString>;
-        collection: import("zod").ZodOptional<import("zod").ZodString>;
-    }, z.core.$strip>, import("zod").ZodObject<{
-        type: import("zod").ZodLiteral<"rpc">;
-        protocol: import("zod").ZodDefault<import("zod").ZodString>;
-        url: import("zod").ZodOptional<import("zod").ZodString>;
-        networkId: import("zod").ZodOptional<import("zod").ZodString>;
-        sessionId: import("zod").ZodOptional<import("zod").ZodString>;
-    }, z.core.$strip>, import("zod").ZodObject<{
-        type: import("zod").ZodLiteral<"rest">;
-        baseUrl: import("zod").ZodString;
-    }, z.core.$strip>, import("zod").ZodObject<{
-        bucket: import("zod").ZodOptional<import("zod").ZodString>;
-        endpoint: import("zod").ZodOptional<import("zod").ZodString>;
-        prefix: import("zod").ZodOptional<import("zod").ZodString>;
-        readUrl: import("zod").ZodOptional<import("zod").ZodString>;
-        type: import("zod").ZodLiteral<"s3">;
-        accessKeyId: import("zod").ZodOptional<import("zod").ZodString>;
-        accountId: import("zod").ZodOptional<import("zod").ZodString>;
-        secretAccessKey: import("zod").ZodOptional<import("zod").ZodString>;
-    }, z.core.$strip>, import("zod").ZodObject<{
-        type: import("zod").ZodLiteral<"evm-rpc">;
-        url: import("zod").ZodString;
-        chainId: import("zod").ZodOptional<import("zod").ZodString>;
-    }, z.core.$strip>, import("zod").ZodObject<{
-        type: import("zod").ZodLiteral<"memory">;
-    }, z.core.$strip>], "type">>>>;
-    providerBindings: z.ZodMiniDefault<import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-        connection: import("zod").ZodOptional<import("zod").ZodString>;
-        provider: import("zod").ZodOptional<import("zod").ZodString>;
-    }, z.core.$strip>>>>;
-    providers: z.ZodMiniDefault<import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
-        moniker: import("zod").ZodString;
-        labels: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-    }, z.core.$loose>>>>;
-    telemetry: z.ZodMiniDefault<import("zod").ZodObject<{
-        metrics: import("zod").ZodOptional<import("zod").ZodObject<{
-            scrape: import("zod").ZodObject<{
-                path: import("zod").ZodDefault<import("zod").ZodString>;
-                port: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
-            }, z.core.$strip>;
-        }, z.core.$strip>>;
-        otel: import("zod").ZodOptional<import("zod").ZodObject<{
-            otlpEndpoint: import("zod").ZodOptional<import("zod").ZodURL>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    validation: z.ZodMiniDefault<import("zod").ZodObject<{
-        signerAuthorizations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"completedStepReward">;
-            signers: import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-        }, z.core.$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"derivedReceive">;
-            scope: import("zod").ZodString;
-            signers: import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-        }, z.core.$strip>], "type">>>;
-        minCandidates: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
-        backoffMs: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
-    }, z.core.$strip>>;
-}, z.core.$strict>;
-/** Loose locator input (yaml, host config, run-config process slice). */
-export type LocatorConfig = z.infer<typeof LocatorConfigFieldsZod>;
-/**
- * Parses locator process fields from a host, actor, or run-config slice.
- * Strips actor/orchestration keys (`name`, `actors`, `healthCheckPort`, …)
- * before applying `LocatorConfigFieldsZod`.
- */
-export declare function parseLocatorConfigFields(raw: unknown): LocatorConfig;
-//# sourceMappingURL=LocatorConfigFields.d.ts.map

package/dist/node/config/LocatorConfigFields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LocatorConfigFields.d.ts","sourceRoot":"","sources":["../../../src/config/LocatorConfigFields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAU5B;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcjC,CAAA;AAEF,yEAAyE;AACzE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAQlE;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,GAAG,aAAa,CAOpE"}

package/dist/node/config/Log.d.ts

@@ -1,16 +0,0 @@
-import { z } from 'zod';
-/** LogConfigZod constant. */
-export declare const LogConfigZod: z.ZodObject<{
-    logLevel: z.ZodDefault<z.ZodEnum<{
-        error: "error";
-        warn: "warn";
-        info: "info";
-        log: "log";
-        debug: "debug";
-        trace: "trace";
-    }>>;
-    silent: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-/** LogConfig type. */
-export type LogConfig = z.infer<typeof LogConfigZod>;
-//# sourceMappingURL=Log.d.ts.map

package/dist/node/config/Log.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Log.d.ts","sourceRoot":"","sources":["../../../src/config/Log.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvC,6BAA6B;AAC7B,eAAO,MAAM,YAAY;;;;;;;;;;iBAcvB,CAAA;AAEF,sBAAsB;AACtB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/node/config/Provider.d.ts

@@ -1,40 +0,0 @@
-import { z } from 'zod';
-/**
- * @deprecated Not consumed by locator/provider resolution — registration is
- * driven by `providerBindings` + `connections` instead. Kept temporarily to
- * detect any remaining config usage before removal.
- */
-export declare const ProviderConfigZod: z.ZodObject<{
-    moniker: z.ZodString;
-    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-/** @deprecated Use `providerBindings` + `connections` instead. */
-export type ProviderConfig = z.infer<typeof ProviderConfigZod>;
-/** @deprecated Type guard for the deprecated `ProviderConfig` shape. */
-export declare const isProviderConfig: <T>(value: T) => value is T & {
-    moniker: string;
-    labels?: string[] | undefined;
-};
-/** @deprecated Converter for the deprecated `ProviderConfig` shape. */
-export declare const asProviderConfig: {
-    <T>(value: T): (T & {
-        moniker: string;
-        labels?: string[] | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        moniker: string;
-        labels?: string[] | undefined;
-    };
-};
-/** @deprecated Converter for the deprecated `ProviderConfig` shape. */
-export declare const toProviderConfig: {
-    <T>(value: T): (T & {
-        moniker: string;
-        labels?: string[] | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        moniker: string;
-        labels?: string[] | undefined;
-    };
-};
-//# sourceMappingURL=Provider.d.ts.map

package/dist/node/config/Provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["../../../src/config/Provider.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;iBAGa,CAAA;AAE3C,kEAAkE;AAElE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,wEAAwE;AAExE,eAAO,MAAM,gBAAgB;;;CAAkC,CAAA;AAC/D,uEAAuE;AAEvE,eAAO,MAAM,gBAAgB;;;;;;;;;CAAsD,CAAA;AACnF,uEAAuE;AAEvE,eAAO,MAAM,gBAAgB;;;;;;;;;CAAsD,CAAA"}

package/dist/node/config/ProviderBinding.d.ts

@@ -1,17 +0,0 @@
-import { z } from 'zod';
-/**
- * Binds a capability moniker to a named connection profile.
- * Keys in `providerBindings` use the provider moniker (e.g. `BlockViewer`).
- */
-export declare const ProviderBindingConfigZod: z.ZodObject<{
-    connection: z.ZodOptional<z.ZodString>;
-    provider: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ProviderBindingConfig = z.infer<typeof ProviderBindingConfigZod>;
-/** Map of provider moniker → binding. */
-export declare const ProviderBindingsConfigZod: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-    connection: z.ZodOptional<z.ZodString>;
-    provider: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>>;
-export type ProviderBindingsConfig = z.infer<typeof ProviderBindingsConfigZod>;
-//# sourceMappingURL=ProviderBinding.d.ts.map

package/dist/node/config/ProviderBinding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ProviderBinding.d.ts","sourceRoot":"","sources":["../../../src/config/ProviderBinding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvC;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;;iBAWK,CAAA;AAE1C,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE5E,yCAAyC;AACzC,eAAO,MAAM,yBAAyB;;;mBAA6D,CAAA;AAEnG,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA"}

package/dist/node/config/Providers.d.ts

@@ -1,13 +0,0 @@
-import z from 'zod';
-/**
- * @deprecated Not consumed by locator/provider resolution — registration is
- * driven by `providerBindings` + `connections` instead. Kept temporarily to
- * detect any remaining config usage before removal.
- */
-export declare const ProvidersConfigZod: z.ZodDefault<z.ZodArray<z.ZodObject<{
-    moniker: z.ZodString;
-    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.z.core.$loose>>>;
-/** @deprecated Use `providerBindings` + `connections` instead. */
-export type ProvidersConfig = z.infer<typeof ProvidersConfigZod>;
-//# sourceMappingURL=Providers.d.ts.map

package/dist/node/config/Providers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Providers.d.ts","sourceRoot":"","sources":["../../../src/config/Providers.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;qBAGsB,CAAA;AAErD,kEAAkE;AAElE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/node/config/ResolvedLocatorConfig.d.ts

@@ -1,123 +0,0 @@
-import type { ProviderMoniker } from '@xyo-network/xl1-protocol-model';
-import { type LocatorConfig } from './LocatorConfigFields.ts';
-export interface ResolveProvidersPlanInput {
-    readonly optional?: ReadonlySet<ProviderMoniker>;
-    readonly required: ReadonlySet<ProviderMoniker>;
-}
-declare const resolvedLocatorConfigBrand: unique symbol;
-/** Locator config after compile — same fields as `LocatorConfig`, branded at assert. */
-export type ResolvedLocatorConfig = LocatorConfig & {
-    readonly [resolvedLocatorConfigBrand]: true;
-};
-export interface AssertResolvedLocatorConfigOptions {
-    readonly needs?: ResolveProvidersPlanInput;
-}
-/**
- * Parses locator process fields and asserts resolve-ready invariants.
- * Closure coverage for `needs.required` is checked when `needs` is supplied.
- */
-export declare function assertResolvedLocatorConfig(raw: unknown, options?: AssertResolvedLocatorConfigOptions): ResolvedLocatorConfig;
-/** @internal Zod parse + connection-reference refine (needs supplied separately). */
-export declare const ResolvedLocatorConfigZod: import("zod/mini").ZodMiniObject<{
-    chain: import("zod/mini").ZodMiniDefault<import("zod/mini").ZodMiniObject<{
-        id: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
-        genesisRewardAddress: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-    }, import("zod/v4/core").$strip>>;
-    log: import("zod/mini").ZodMiniDefault<import("zod").ZodObject<{
-        logLevel: import("zod").ZodDefault<import("zod").ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
-            log: "log";
-            debug: "debug";
-            trace: "trace";
-        }>>;
-        silent: import("zod").ZodDefault<import("zod").ZodBoolean>;
-    }, import("zod/v4/core").$strip>>;
-    connections: import("zod/mini").ZodMiniDefault<import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-        access: import("zod").ZodOptional<import("zod").ZodEnum<{
-            read: "read";
-            write: "write";
-        }>>;
-        root: import("zod").ZodString;
-        store: import("zod").ZodOptional<import("zod").ZodString>;
-        type: import("zod").ZodLiteral<"lmdb">;
-    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-        type: import("zod").ZodLiteral<"mongo">;
-        connectionString: import("zod").ZodOptional<import("zod").ZodString>;
-        database: import("zod").ZodOptional<import("zod").ZodString>;
-        domain: import("zod").ZodOptional<import("zod").ZodString>;
-        password: import("zod").ZodOptional<import("zod").ZodString>;
-        username: import("zod").ZodOptional<import("zod").ZodString>;
-        collection: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-        type: import("zod").ZodLiteral<"rpc">;
-        protocol: import("zod").ZodDefault<import("zod").ZodString>;
-        url: import("zod").ZodOptional<import("zod").ZodString>;
-        networkId: import("zod").ZodOptional<import("zod").ZodString>;
-        sessionId: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-        type: import("zod").ZodLiteral<"rest">;
-        baseUrl: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-        bucket: import("zod").ZodOptional<import("zod").ZodString>;
-        endpoint: import("zod").ZodOptional<import("zod").ZodString>;
-        prefix: import("zod").ZodOptional<import("zod").ZodString>;
-        readUrl: import("zod").ZodOptional<import("zod").ZodString>;
-        type: import("zod").ZodLiteral<"s3">;
-        accessKeyId: import("zod").ZodOptional<import("zod").ZodString>;
-        accountId: import("zod").ZodOptional<import("zod").ZodString>;
-        secretAccessKey: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-        type: import("zod").ZodLiteral<"evm-rpc">;
-        url: import("zod").ZodString;
-        chainId: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-        type: import("zod").ZodLiteral<"memory">;
-    }, import("zod/v4/core").$strip>], "type">>>>;
-    providerBindings: import("zod/mini").ZodMiniDefault<import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-        connection: import("zod").ZodOptional<import("zod").ZodString>;
-        provider: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>>>>;
-    providers: import("zod/mini").ZodMiniDefault<import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
-        moniker: import("zod").ZodString;
-        labels: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-    }, import("zod/v4/core").$loose>>>>;
-    telemetry: import("zod/mini").ZodMiniDefault<import("zod").ZodObject<{
-        metrics: import("zod").ZodOptional<import("zod").ZodObject<{
-            scrape: import("zod").ZodObject<{
-                path: import("zod").ZodDefault<import("zod").ZodString>;
-                port: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
-            }, import("zod/v4/core").$strip>;
-        }, import("zod/v4/core").$strip>>;
-        otel: import("zod").ZodOptional<import("zod").ZodObject<{
-            otlpEndpoint: import("zod").ZodOptional<import("zod").ZodURL>;
-        }, import("zod/v4/core").$strip>>;
-    }, import("zod/v4/core").$strip>>;
-    validation: import("zod/mini").ZodMiniDefault<import("zod").ZodObject<{
-        signerAuthorizations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"completedStepReward">;
-            signers: import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"derivedReceive">;
-            scope: import("zod").ZodString;
-            signers: import("zod").ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-        }, import("zod/v4/core").$strip>], "type">>>;
-        minCandidates: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
-        backoffMs: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
-    }, import("zod/v4/core").$strip>>;
-}, import("zod/v4/core").$strict>;
-export {};
-//# sourceMappingURL=ResolvedLocatorConfig.d.ts.map

package/dist/node/config/ResolvedLocatorConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ResolvedLocatorConfig.d.ts","sourceRoot":"","sources":["../../../src/config/ResolvedLocatorConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAEtE,OAAO,EAAE,KAAK,aAAa,EAA0B,MAAM,0BAA0B,CAAA;AAErF,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC,eAAe,CAAC,CAAA;IAChD,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,eAAe,CAAC,CAAA;CAChD;AAED,OAAO,CAAC,MAAM,0BAA0B,EAAE,OAAO,MAAM,CAAA;AAEvD,wFAAwF;AACxF,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG;IAClD,QAAQ,CAAC,CAAC,0BAA0B,CAAC,EAAE,IAAI,CAAA;CAC5C,CAAA;AAED,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,yBAAyB,CAAA;CAC3C;AA6BD;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,OAAO,EACZ,OAAO,GAAE,kCAAuC,GAC/C,qBAAqB,CAOvB;AAED,qFAAqF;AACrF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAYnC,CAAA"}

package/dist/node/config/Telemetry.d.ts

@@ -1,40 +0,0 @@
-import { z } from 'zod';
-/** DefaultMetricsScrapePorts constant. */
-export declare const DefaultMetricsScrapePorts: {
-    api: number;
-    bridge: number;
-    mempool: number;
-    producer: number;
-    rewardRedemptionApi: number;
-};
-/** MetricsScrapeConfigZod constant. */
-export declare const MetricsScrapeConfigZod: z.ZodObject<{
-    path: z.ZodDefault<z.ZodString>;
-    port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>;
-/** MetricsConfigZod constant. */
-export declare const MetricsConfigZod: z.ZodObject<{
-    scrape: z.ZodObject<{
-        path: z.ZodDefault<z.ZodString>;
-        port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/** OpenTelemetryConfigZod constant. */
-export declare const OpenTelemetryConfigZod: z.ZodObject<{
-    otlpEndpoint: z.ZodOptional<z.ZodURL>;
-}, z.core.$strip>;
-/** TelemetryConfigZod constant. */
-export declare const TelemetryConfigZod: z.ZodObject<{
-    metrics: z.ZodOptional<z.ZodObject<{
-        scrape: z.ZodObject<{
-            path: z.ZodDefault<z.ZodString>;
-            port: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-        }, z.core.$strip>;
-    }, z.core.$strip>>;
-    otel: z.ZodOptional<z.ZodObject<{
-        otlpEndpoint: z.ZodOptional<z.ZodURL>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-/** TelemetryConfig type. */
-export type TelemetryConfig = z.infer<typeof TelemetryConfigZod>;
-//# sourceMappingURL=Telemetry.d.ts.map

package/dist/node/config/Telemetry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Telemetry.d.ts","sourceRoot":"","sources":["../../../src/config/Telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvC,0CAA0C;AAC1C,eAAO,MAAM,yBAAyB;;;;;;CAMrC,CAAA;AAED,uCAAuC;AACvC,eAAO,MAAM,sBAAsB;;;iBAYQ,CAAA;AAE3C,iCAAiC;AACjC,eAAO,MAAM,gBAAgB;;;;;iBAAyF,CAAA;AAEtH,uCAAuC;AACvC,eAAO,MAAM,sBAAsB;;iBAOjC,CAAA;AAEF,mCAAmC;AACnC,eAAO,MAAM,kBAAkB;;;;;;;;;;iBAKe,CAAA;AAE9C,4BAA4B;AAC5B,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/node/config/UsageMeta.d.ts

@@ -1,32 +0,0 @@
-import { z } from 'zod';
-/** Schema identifier for JSONMeta payloads. */
-export declare const JSONSchemaMetaSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    deprecated: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$catchall<z.ZodUnknown>>;
-/** Schema identifier for GlobalMeta payloads. */
-export declare const GlobalMetaSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    deprecated: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$catchall<z.ZodUnknown>>;
-/** Schema identifier for UsageMeta payloads. */
-export declare const UsageMetaSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    deprecated: z.ZodOptional<z.ZodBoolean>;
-    choices: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodLiteral<true>, z.ZodUndefined]>>>>;
-    default: z.ZodOptional<z.ZodUnknown>;
-    description: z.ZodString;
-    group: z.ZodOptional<z.ZodString>;
-    hidden: z.ZodOptional<z.ZodBoolean>;
-    title: z.ZodString;
-    type: z.ZodUnion<readonly [z.ZodLiteral<"array">, z.ZodLiteral<"count">, z.ZodLiteral<"boolean">, z.ZodLiteral<"number">, z.ZodLiteral<"string">]>;
-}, z.core.$catchall<z.ZodUnknown>>;
-/** UsageMeta type. */
-export type UsageMeta = z.infer<typeof UsageMetaSchema>;
-/** Type guard that checks if a value is a valid UsageMeta. */
-export declare function isUsageMeta(v: unknown): v is UsageMeta;
-//# sourceMappingURL=UsageMeta.d.ts.map

package/dist/node/config/UsageMeta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"UsageMeta.d.ts","sourceRoot":"","sources":["../../../src/config/UsageMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,+CAA+C;AAC/C,eAAO,MAAM,oBAAoB;;;;;kCAOT,CAAA;AAExB,iDAAiD;AACjD,eAAO,MAAM,gBAAgB;;;;;kCAAkC,CAAA;AAM/D,gDAAgD;AAChD,eAAO,MAAM,eAAe;;;;;;;;;;kCAc1B,CAAA;AAEF,sBAAsB;AACtB,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,8DAA8D;AAC9D,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,SAAS,CAEtD"}

package/dist/node/config/Validation.d.ts

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-/** ValidationConfigZod constant. */
-export declare const ValidationConfigZod: z.ZodObject<{
-    signerAuthorizations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"completedStepReward">;
-        signers: z.ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"derivedReceive">;
-        scope: z.ZodString;
-        signers: z.ZodArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-            readonly __hex: true;
-        } & {
-            readonly __address: true;
-        }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
-    }, z.core.$strip>], "type">>>;
-    minCandidates: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    backoffMs: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>;
-/** ValidationConfig type. */
-export type ValidationConfig = z.infer<typeof ValidationConfigZod>;
-//# sourceMappingURL=Validation.d.ts.map

package/dist/node/config/Validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Validation.d.ts","sourceRoot":"","sources":["../../../src/config/Validation.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvC,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;iBAkB9B,CAAA;AAEF,6BAA6B;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/node/config/connections/Connection.d.ts

@@ -1,150 +0,0 @@
-import { z } from 'zod';
-/** Named LMDB backing-store connection. */
-export declare const LmdbConnectionConfigZod: z.ZodObject<{
-    access: z.ZodOptional<z.ZodEnum<{
-        read: "read";
-        write: "write";
-    }>>;
-    root: z.ZodString;
-    store: z.ZodOptional<z.ZodString>;
-    type: z.ZodLiteral<"lmdb">;
-}, z.core.$strip>;
-/** MongoDB backing-store connection. */
-export declare const MongoConnectionConfigZod: z.ZodObject<{
-    type: z.ZodLiteral<"mongo">;
-    connectionString: z.ZodOptional<z.ZodString>;
-    database: z.ZodOptional<z.ZodString>;
-    domain: z.ZodOptional<z.ZodString>;
-    password: z.ZodOptional<z.ZodString>;
-    username: z.ZodOptional<z.ZodString>;
-    collection: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/** JSON-RPC wire connection (HTTP or postMessage). */
-export declare const RpcConnectionConfigZod: z.ZodObject<{
-    type: z.ZodLiteral<"rpc">;
-    protocol: z.ZodDefault<z.ZodString>;
-    url: z.ZodOptional<z.ZodString>;
-    networkId: z.ZodOptional<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/** HTTP REST read connection (CDN / public read base URL). */
-export declare const RestConnectionConfigZod: z.ZodObject<{
-    type: z.ZodLiteral<"rest">;
-    baseUrl: z.ZodString;
-}, z.core.$strip>;
-/** S3-compatible object storage connection (API + optional public read URL). */
-export declare const S3ConnectionConfigZod: z.ZodObject<{
-    bucket: z.ZodOptional<z.ZodString>;
-    endpoint: z.ZodOptional<z.ZodString>;
-    prefix: z.ZodOptional<z.ZodString>;
-    readUrl: z.ZodOptional<z.ZodString>;
-    type: z.ZodLiteral<"s3">;
-    accessKeyId: z.ZodOptional<z.ZodString>;
-    accountId: z.ZodOptional<z.ZodString>;
-    secretAccessKey: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/** EVM JSON-RPC connection. */
-export declare const EvmRpcConnectionConfigZod: z.ZodObject<{
-    type: z.ZodLiteral<"evm-rpc">;
-    url: z.ZodString;
-    chainId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/** In-process shared-memory connection (ephemeral; backed by a MemoryArchivist). */
-export declare const MemoryConnectionConfigZod: z.ZodObject<{
-    type: z.ZodLiteral<"memory">;
-}, z.core.$strip>;
-/** Discriminated union of all supported connection kinds. */
-export declare const ConnectionConfigZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    access: z.ZodOptional<z.ZodEnum<{
-        read: "read";
-        write: "write";
-    }>>;
-    root: z.ZodString;
-    store: z.ZodOptional<z.ZodString>;
-    type: z.ZodLiteral<"lmdb">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"mongo">;
-    connectionString: z.ZodOptional<z.ZodString>;
-    database: z.ZodOptional<z.ZodString>;
-    domain: z.ZodOptional<z.ZodString>;
-    password: z.ZodOptional<z.ZodString>;
-    username: z.ZodOptional<z.ZodString>;
-    collection: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"rpc">;
-    protocol: z.ZodDefault<z.ZodString>;
-    url: z.ZodOptional<z.ZodString>;
-    networkId: z.ZodOptional<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"rest">;
-    baseUrl: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    bucket: z.ZodOptional<z.ZodString>;
-    endpoint: z.ZodOptional<z.ZodString>;
-    prefix: z.ZodOptional<z.ZodString>;
-    readUrl: z.ZodOptional<z.ZodString>;
-    type: z.ZodLiteral<"s3">;
-    accessKeyId: z.ZodOptional<z.ZodString>;
-    accountId: z.ZodOptional<z.ZodString>;
-    secretAccessKey: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"evm-rpc">;
-    url: z.ZodString;
-    chainId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"memory">;
-}, z.core.$strip>], "type">;
-export type LmdbConnectionConfig = z.infer<typeof LmdbConnectionConfigZod>;
-export type MongoConnectionConfig = z.infer<typeof MongoConnectionConfigZod>;
-export type RpcConnectionConfig = z.infer<typeof RpcConnectionConfigZod>;
-export type RestConnectionConfig = z.infer<typeof RestConnectionConfigZod>;
-export type S3ConnectionConfig = z.infer<typeof S3ConnectionConfigZod>;
-export type EvmRpcConnectionConfig = z.infer<typeof EvmRpcConnectionConfigZod>;
-export type MemoryConnectionConfig = z.infer<typeof MemoryConnectionConfigZod>;
-export type ConnectionConfig = z.infer<typeof ConnectionConfigZod>;
-/** Map of connection name → connection configuration. */
-export declare const ConnectionsConfigZod: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
-    access: z.ZodOptional<z.ZodEnum<{
-        read: "read";
-        write: "write";
-    }>>;
-    root: z.ZodString;
-    store: z.ZodOptional<z.ZodString>;
-    type: z.ZodLiteral<"lmdb">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"mongo">;
-    connectionString: z.ZodOptional<z.ZodString>;
-    database: z.ZodOptional<z.ZodString>;
-    domain: z.ZodOptional<z.ZodString>;
-    password: z.ZodOptional<z.ZodString>;
-    username: z.ZodOptional<z.ZodString>;
-    collection: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"rpc">;
-    protocol: z.ZodDefault<z.ZodString>;
-    url: z.ZodOptional<z.ZodString>;
-    networkId: z.ZodOptional<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"rest">;
-    baseUrl: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    bucket: z.ZodOptional<z.ZodString>;
-    endpoint: z.ZodOptional<z.ZodString>;
-    prefix: z.ZodOptional<z.ZodString>;
-    readUrl: z.ZodOptional<z.ZodString>;
-    type: z.ZodLiteral<"s3">;
-    accessKeyId: z.ZodOptional<z.ZodString>;
-    accountId: z.ZodOptional<z.ZodString>;
-    secretAccessKey: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"evm-rpc">;
-    url: z.ZodString;
-    chainId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"memory">;
-}, z.core.$strip>], "type">>>;
-export type ConnectionsConfig = z.infer<typeof ConnectionsConfigZod>;
-export type ConnectionKind = ConnectionConfig['type'];
-//# sourceMappingURL=Connection.d.ts.map

package/dist/node/config/connections/Connection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Connection.d.ts","sourceRoot":"","sources":["../../../../src/config/connections/Connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvC,2CAA2C;AAC3C,eAAO,MAAM,uBAAuB;;;;;;;;iBAiBQ,CAAA;AAE5C,wCAAwC;AACxC,eAAO,MAAM,wBAAwB;;;;;;;;iBAYI,CAAA;AAEzC,sDAAsD;AACtD,eAAO,MAAM,sBAAsB;;;;;;iBAsBG,CAAA;AAEtC,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB;;;iBAOI,CAAA;AAExC,gFAAgF;AAChF,eAAO,MAAM,qBAAqB;;;;;;;;;iBAKoB,CAAA;AAEtD,+BAA+B;AAC/B,eAAO,MAAM,yBAAyB;;;;iBAYA,CAAA;AAEtC,oFAAoF;AACpF,eAAO,MAAM,yBAAyB;;iBAAmF,CAAA;AAEzH,6DAA6D;AAC7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQ9B,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACxE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAC1E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACtE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAC9E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAC9E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAElE,yDAAyD;AACzD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAAwD,CAAA;AAEzF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,MAAM,MAAM,cAAc,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAA"}