@xyo-network/xl1-protocol-sdk 4.0.3 → 4.0.5

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

@@ -0,0 +1,115 @@
+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("@xylabs/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>;
+    }, 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

@@ -0,0 +1 @@
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQjC,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

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

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+/** ProviderConfigZod constant. */
+export declare const ProviderConfigZod: z.ZodObject<{
+    moniker: z.ZodString;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** ProviderConfig type. */
+export type ProviderConfig = z.infer<typeof ProviderConfigZod>;
+/** Type guard that checks if a value is a valid ProviderConfig. */
+export declare const isProviderConfig: <T>(value: T) => value is T & {
+    moniker: string;
+    labels?: string[] | undefined;
+};
+/** Converts a value to ProviderConfig, throwing if invalid. */
+export declare const asProviderConfig: {
+    <T>(value: T): (T & {
+        moniker: string;
+        labels?: string[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        moniker: string;
+        labels?: string[] | undefined;
+    };
+};
+/** toProviderConfig constant. */
+export declare const toProviderConfig: {
+    <T>(value: T): (T & {
+        moniker: string;
+        labels?: string[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        moniker: string;
+        labels?: string[] | undefined;
+    };
+};
+//# sourceMappingURL=Provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["../../../src/config/Provider.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,kCAAkC;AAClC,eAAO,MAAM,iBAAiB;;;iBAGa,CAAA;AAE3C,2BAA2B;AAC3B,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,mEAAmE;AACnE,eAAO,MAAM,gBAAgB;;;CAAkC,CAAA;AAC/D,+DAA+D;AAC/D,eAAO,MAAM,gBAAgB;;;;;;;;;CAAsD,CAAA;AACnF,iCAAiC;AACjC,eAAO,MAAM,gBAAgB;;;;;;;;;CAAsD,CAAA"}

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

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

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

@@ -0,0 +1,9 @@
+import z from 'zod';
+/** ProvidersConfigZod constant. */
+export declare const ProvidersConfigZod: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    moniker: z.ZodString;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.z.core.$loose>>>;
+/** ProvidersConfig type. */
+export type ProvidersConfig = z.infer<typeof ProvidersConfigZod>;
+//# sourceMappingURL=Providers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Providers.d.ts","sourceRoot":"","sources":["../../../src/config/Providers.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,mCAAmC;AACnC,eAAO,MAAM,kBAAkB;;;qBAAyF,CAAA;AAExH,4BAA4B;AAC5B,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

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

@@ -0,0 +1,122 @@
+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("@xylabs/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>;
+    }, 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

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

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

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

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

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

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

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

@@ -0,0 +1,147 @@
+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>;
+}, 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>;
+}, 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>;
+}, 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

@@ -0,0 +1 @@
+{"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;;;;;;;iBAOI,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"}

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/** MongoConfigZod constant. */
+export declare const MongoConfigZod: z.ZodObject<{
+    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>;
+}, z.core.$strip>;
+/** MongoConfig type. */
+export type MongoConfig = z.infer<typeof MongoConfigZod>;
+//# sourceMappingURL=Mongo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Mongo.d.ts","sourceRoot":"","sources":["../../../../src/config/connections/Mongo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvC,+BAA+B;AAC/B,eAAO,MAAM,cAAc;;;;;;iBA2BzB,CAAA;AAEF,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}