@xyo-network/xl1-protocol-sdk 2.2.1 → 3.0.0

package/dist/neutral/getFileConfig.d.ts

@@ -25,8 +25,39 @@ export declare function getFileConfig(searchPlaces?: string[]): Promise<{
         logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
         silent: boolean;
     };
+    connections: Record<string, {
+        root: string;
+        type: "lmdb";
+        access?: "read" | "write" | undefined;
+        store?: string | undefined;
+    } | {
+        type: "mongo";
+        connectionString?: string | undefined;
+        database?: string | undefined;
+        domain?: string | undefined;
+        password?: string | undefined;
+        username?: string | undefined;
+    } | {
+        protocol: string;
+        url: string;
+        type: "rpc";
+    } | {
+        type: "rest";
+        baseUrl: string;
+    } | {
+        type: "s3";
+        bucket?: string | undefined;
+        prefix?: string | undefined;
+        readUrl?: string | undefined;
+        accessKeyId?: string | undefined;
+        accountId?: string | undefined;
+        secretAccessKey?: string | undefined;
+    } | {
+        type: "evm-rpc";
+        url: string;
+    }>;
     providerBindings: Record<string, {
-        implementation?: string | undefined;
+        connection?: string | undefined;
         transport?: string | undefined;
     }>;
     providers: {
@@ -45,8 +76,10 @@ export declare function getFileConfig(searchPlaces?: string[]): Promise<{
         } | undefined;
     };
     transports: Record<string, {
-        type: "lmdb";
         root: string;
+        type: "lmdb";
+        access?: "read" | "write" | undefined;
+        store?: string | undefined;
     } | {
         type: "mongo";
         connectionString?: string | undefined;
@@ -162,8 +195,39 @@ export declare function getFileConfig(searchPlaces?: string[]): Promise<{
             logLevel: "error" | "warn" | "info" | "log" | "debug" | "trace";
             silent: boolean;
         };
+        connections: Record<string, {
+            root: string;
+            type: "lmdb";
+            access?: "read" | "write" | undefined;
+            store?: string | undefined;
+        } | {
+            type: "mongo";
+            connectionString?: string | undefined;
+            database?: string | undefined;
+            domain?: string | undefined;
+            password?: string | undefined;
+            username?: string | undefined;
+        } | {
+            protocol: string;
+            url: string;
+            type: "rpc";
+        } | {
+            type: "rest";
+            baseUrl: string;
+        } | {
+            type: "s3";
+            bucket?: string | undefined;
+            prefix?: string | undefined;
+            readUrl?: string | undefined;
+            accessKeyId?: string | undefined;
+            accountId?: string | undefined;
+            secretAccessKey?: string | undefined;
+        } | {
+            type: "evm-rpc";
+            url: string;
+        }>;
         providerBindings: Record<string, {
-            implementation?: string | undefined;
+            connection?: string | undefined;
             transport?: string | undefined;
         }>;
         providers: {
@@ -182,8 +246,10 @@ export declare function getFileConfig(searchPlaces?: string[]): Promise<{
             } | undefined;
         };
         transports: Record<string, {
-            type: "lmdb";
             root: string;
+            type: "lmdb";
+            access?: "read" | "write" | undefined;
+            store?: string | undefined;
         } | {
             type: "mongo";
             connectionString?: string | undefined;

package/dist/neutral/getFileConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getFileConfig.d.ts","sourceRoot":"","sources":["../../src/getFileConfig.ts"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,wBAAsB,aAAa,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiB1D"}
+{"version":3,"file":"getFileConfig.d.ts","sourceRoot":"","sources":["../../src/getFileConfig.ts"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,wBAAsB,aAAa,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiB1D"}

package/dist/neutral/getFileConfig.mjs

@@ -31,16 +31,167 @@ var ChainConfigZod = z.object({
   })
 });
 
+// src/config/transports/Transport.ts
+import { globalRegistry as globalRegistry4, z as z5 } from "zod";
+
+// src/config/Remote.ts
+import { globalRegistry as globalRegistry2, z as z2 } from "zod";
+var RpcRemoteConfigBaseZod = z2.object({
+  protocol: z2.string("http").register(globalRegistry2, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  })
+}).describe("Base configuration for the remote RPC");
+var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
+  protocol: z2.string("http").register(globalRegistry2, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  }).default("http"),
+  url: z2.string().register(globalRegistry2, {
+    description: "URL for the Chain RPC API",
+    type: "string"
+  })
+}).describe("Configuration for the remote RPC using Http");
+var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
+  protocol: z2.string().register(globalRegistry2, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  }).default("postMessage"),
+  networkId: z2.string().register(globalRegistry2, {
+    description: "Network ID to use for the postMessage RPC connection",
+    type: "string"
+  }),
+  sessionId: z2.string().register(globalRegistry2, {
+    description: "Session ID to use for the postMessage RPC connection",
+    type: "string"
+  })
+}).describe("Configuration for the remote RPC using postMessage");
+var RpcRemoteConfigZod = z2.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
+var RemoteConfigZod = z2.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
+
+// src/config/storage/driver/Mongo.ts
+import { isDefined, isUndefined } from "@xylabs/sdk-js";
+import { globalRegistry as globalRegistry3, z as z3 } from "zod";
+var MongoConfigZod = z3.object({
+  // TODO: Create from other arguments
+  connectionString: z3.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB connection string",
+    title: "storage.mongo.connectionString",
+    type: "string"
+  }),
+  database: z3.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB database name",
+    title: "storage.mongo.database",
+    type: "string"
+  }),
+  domain: z3.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB domain",
+    title: "storage.mongo.domain",
+    type: "string"
+  }),
+  password: z3.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB password",
+    title: "storage.mongo.password",
+    type: "string"
+  }),
+  username: z3.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB username",
+    title: "storage.mongo.username",
+    type: "string"
+  })
+});
+
+// src/config/storage/driver/S3.ts
+import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { z as z4 } from "zod";
+var S3BucketConfigZod = z4.object({
+  accessKeyId: z4.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
+  accountId: z4.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
+  bucket: z4.string().nonempty().optional().describe("S3-compatible bucket name"),
+  prefix: z4.string().nonempty().optional().describe("Optional key prefix within the bucket"),
+  readUrl: z4.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
+  secretAccessKey: z4.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
+});
+var S3ConfigZod = z4.object({
+  accessKeyId: z4.string().nonempty().optional().describe("Shared S3-compatible access key id (default for all buckets)"),
+  accountId: z4.string().nonempty().optional().describe("Shared account id (default for all buckets; on Cloudflare R2 it forms the endpoint)"),
+  chainState: S3BucketConfigZod.optional().describe("Bucket for the mutable chain state (the head pointer)"),
+  finalized: S3BucketConfigZod.optional().describe("Bucket for the finalized files (blocks, payloads, manifest)"),
+  index: S3BucketConfigZod.optional().describe("Bucket for the chain index (the step-summary families)"),
+  prefix: z4.string().nonempty().optional().describe("Shared key prefix (default for all buckets)"),
+  secretAccessKey: z4.string().nonempty().optional().describe("Shared S3-compatible secret access key (default for all buckets)")
+});
+
+// src/config/transports/Transport.ts
+var LmdbTransportConfigZod = z5.object({
+  access: z5.enum(["read", "write"]).optional().register(globalRegistry4, {
+    description: "Access mode for this LMDB connection (read or write)",
+    title: "transports.lmdb.access",
+    type: "string"
+  }),
+  root: z5.string().register(globalRegistry4, {
+    description: "Root directory for local LMDB storage",
+    title: "transports.lmdb.root",
+    type: "string"
+  }),
+  store: z5.string().optional().register(globalRegistry4, {
+    description: "Logical store name within the LMDB root (e.g. finalized-chain, mempool)",
+    title: "transports.lmdb.store",
+    type: "string"
+  }),
+  type: z5.literal("lmdb")
+}).describe("LMDB local storage transport");
+var MongoTransportConfigZod = z5.object({
+  type: z5.literal("mongo"),
+  connectionString: MongoConfigZod.shape.connectionString,
+  database: MongoConfigZod.shape.database,
+  domain: MongoConfigZod.shape.domain,
+  password: MongoConfigZod.shape.password,
+  username: MongoConfigZod.shape.username
+}).describe("MongoDB storage transport");
+var RpcTransportConfigZod = HttpRpcRemoteConfigZod.extend({ type: z5.literal("rpc") }).describe("XL1 JSON-RPC transport");
+var RestTransportConfigZod = z5.object({
+  type: z5.literal("rest"),
+  baseUrl: z5.string().register(globalRegistry4, {
+    description: "HTTP base URL for REST reads",
+    title: "transports.rest.baseUrl",
+    type: "string"
+  })
+}).describe("HTTP REST read transport");
+var S3TransportConfigZod = S3BucketConfigZod.extend({
+  type: z5.literal("s3"),
+  accessKeyId: z5.string().optional(),
+  accountId: z5.string().optional(),
+  secretAccessKey: z5.string().optional()
+}).describe("S3-compatible object storage transport");
+var EvmRpcTransportConfigZod = z5.object({
+  type: z5.literal("evm-rpc"),
+  url: z5.string().register(globalRegistry4, {
+    description: "EVM JSON-RPC URL",
+    title: "transports.evm-rpc.url",
+    type: "string"
+  })
+}).describe("EVM JSON-RPC transport");
+var TransportConfigZod = z5.discriminatedUnion("type", [
+  LmdbTransportConfigZod,
+  MongoTransportConfigZod,
+  RpcTransportConfigZod,
+  RestTransportConfigZod,
+  S3TransportConfigZod,
+  EvmRpcTransportConfigZod
+]);
+var TransportsConfigZod = z5.record(z5.string(), TransportConfigZod).default({});
+
 // src/config/DataLake/DataLake.ts
-import { z as z5 } from "zod";
+import { z as z9 } from "zod";
 
 // src/config/DataLake/RestDataLakeConfig.ts
-import { globalRegistry as globalRegistry3, z as z3 } from "zod";
+import { globalRegistry as globalRegistry6, z as z7 } from "zod";
 
 // src/config/DataLake/DataLakeRemoteConfig.ts
-import { globalRegistry as globalRegistry2, z as z2 } from "zod";
-var DataLakeDriverConfigBaseZod = z2.object({
-  driver: z2.string().register(globalRegistry2, {
+import { globalRegistry as globalRegistry5, z as z6 } from "zod";
+var DataLakeDriverConfigBaseZod = z6.object({
+  driver: z6.string().register(globalRegistry5, {
     description: "Driver for the data lake",
     type: "string"
   })
@@ -48,55 +199,55 @@ var DataLakeDriverConfigBaseZod = z2.object({
 
 // src/config/DataLake/RestDataLakeConfig.ts
 var RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
-  driver: z3.literal("rest").register(globalRegistry3, {
+  driver: z7.literal("rest").register(globalRegistry6, {
     description: "Driver for the REST data lake",
     type: "string"
   }),
-  url: z3.string().register(globalRegistry3, {
+  url: z7.string().register(globalRegistry6, {
     description: "URL for the REST data lake",
     type: "string"
   })
 }).describe("Configuration for the REST data lake driver");
 
 // src/config/DataLake/RouterDataLakeConfig.ts
-import { globalRegistry as globalRegistry4, z as z4 } from "zod";
-var RouterDataLakeConfigZod = z4.object({
-  driver: z4.literal("router").register(globalRegistry4, {
+import { globalRegistry as globalRegistry7, z as z8 } from "zod";
+var RouterDataLakeConfigZod = z8.object({
+  driver: z8.literal("router").register(globalRegistry7, {
     description: "Driver for the router data lake",
     type: "string"
   }),
-  children: z4.array(z4.lazy(() => DataLakeConfigZod)).register(globalRegistry4, {
+  children: z8.array(z8.lazy(() => DataLakeConfigZod)).register(globalRegistry7, {
     description: "Child data lake drivers",
     type: "array"
   })
 }).describe("Configuration for the router data lake driver");
 
 // src/config/DataLake/DataLake.ts
-var DataLakeConfigZod = z5.lazy(() => z5.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
+var DataLakeConfigZod = z9.lazy(() => z9.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
 
 // src/config/Evm.ts
-import { globalRegistry as globalRegistry5, z as z6 } from "zod";
-var EvmInfuraConfigZod = z6.object({
-  projectId: z6.string().optional().register(globalRegistry5, {
+import { globalRegistry as globalRegistry8, z as z10 } from "zod";
+var EvmInfuraConfigZod = z10.object({
+  projectId: z10.string().optional().register(globalRegistry8, {
     description: "Infura project ID",
     title: "evm.infura.projectId",
     type: "string"
   }),
-  projectSecret: z6.string().optional().register(globalRegistry5, {
+  projectSecret: z10.string().optional().register(globalRegistry8, {
     description: "Infura project secret",
     title: "evm.infura.projectSecret",
     type: "string"
   })
 });
-var EvmJsonRpcConfigZod = z6.object({
-  url: z6.url().optional().register(globalRegistry5, {
+var EvmJsonRpcConfigZod = z10.object({
+  url: z10.url().optional().register(globalRegistry8, {
     description: "JSON-RPC URL",
     title: "evm.jsonRpc.url",
     type: "string"
   })
 });
-var EvmConfigZod = z6.object({
-  chainId: z6.string().optional().register(globalRegistry5, {
+var EvmConfigZod = z10.object({
+  chainId: z10.string().optional().register(globalRegistry8, {
     description: "EVM chain ID",
     title: "evm.chainId",
     type: "string"
@@ -107,17 +258,17 @@ var EvmConfigZod = z6.object({
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry6, z as z7 } from "zod";
+import { globalRegistry as globalRegistry9, z as z11 } from "zod";
 var LogLevelNames = Object.keys(LogLevel);
-var LogConfigZod = z7.object({
-  logLevel: z7.enum(LogLevelNames).default("info").register(globalRegistry6, {
+var LogConfigZod = z11.object({
+  logLevel: z11.enum(LogLevelNames).default("info").register(globalRegistry9, {
     choices: LogLevelNames,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z7.boolean().default(false).register(globalRegistry6, {
+  silent: z11.boolean().default(false).register(globalRegistry9, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -126,23 +277,23 @@ var LogConfigZod = z7.object({
 });
 
 // src/config/ProviderBinding.ts
-import { globalRegistry as globalRegistry7, z as z8 } from "zod";
-var ProviderBindingConfigZod = z8.object({
-  implementation: z8.string().optional().register(globalRegistry7, {
-    description: "Installed provider implementation id (descriptor id)",
-    title: "providerBindings.implementation",
+import { globalRegistry as globalRegistry10, z as z12 } from "zod";
+var ProviderBindingConfigZod = z12.object({
+  connection: z12.string().optional().register(globalRegistry10, {
+    description: "Named connection from the top-level connections map",
+    title: "providerBindings.connection",
     type: "string"
   }),
-  transport: z8.string().optional().register(globalRegistry7, {
-    description: "Named transport from the top-level transports map",
+  transport: z12.string().optional().register(globalRegistry10, {
+    description: "Deprecated alias for connection (kept in sync during migration)",
     title: "providerBindings.transport",
     type: "string"
   })
-}).describe("Provider implementation and transport binding");
-var ProviderBindingsConfigZod = z8.record(z8.string(), ProviderBindingConfigZod).default({});
+}).describe("Provider connection binding");
+var ProviderBindingsConfigZod = z12.record(z12.string(), ProviderBindingConfigZod).default({});
 
 // src/config/Providers.ts
-import z10 from "zod";
+import z14 from "zod";
 
 // src/config/Provider.ts
 import {
@@ -150,111 +301,23 @@ import {
   zodIsFactory,
   zodToFactory
 } from "@xylabs/sdk-js";
-import { z as z9 } from "zod";
-var ProviderConfigZod = z9.object({
-  moniker: z9.string(),
-  labels: z9.array(z9.string()).optional()
+import { z as z13 } from "zod";
+var ProviderConfigZod = z13.object({
+  moniker: z13.string(),
+  labels: z13.array(z13.string()).optional()
 }).describe("Configuration for a Provider");
 var isProviderConfig = zodIsFactory(ProviderConfigZod);
 var asProviderConfig = zodAsFactory(ProviderConfigZod, "asProviderConfig");
 var toProviderConfig = zodToFactory(ProviderConfigZod, "toProviderConfig");
 
 // src/config/Providers.ts
-var ProvidersConfigZod = z10.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
-
-// src/config/Remote.ts
-import { globalRegistry as globalRegistry8, z as z11 } from "zod";
-var RpcRemoteConfigBaseZod = z11.object({
-  protocol: z11.string("http").register(globalRegistry8, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  })
-}).describe("Base configuration for the remote RPC");
-var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z11.string("http").register(globalRegistry8, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("http"),
-  url: z11.string().register(globalRegistry8, {
-    description: "URL for the Chain RPC API",
-    type: "string"
-  })
-}).describe("Configuration for the remote RPC using Http");
-var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z11.string().register(globalRegistry8, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("postMessage"),
-  networkId: z11.string().register(globalRegistry8, {
-    description: "Network ID to use for the postMessage RPC connection",
-    type: "string"
-  }),
-  sessionId: z11.string().register(globalRegistry8, {
-    description: "Session ID to use for the postMessage RPC connection",
-    type: "string"
-  })
-}).describe("Configuration for the remote RPC using postMessage");
-var RpcRemoteConfigZod = z11.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
-var RemoteConfigZod = z11.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
-
-// src/config/storage/driver/Mongo.ts
-import { isDefined, isUndefined } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry9, z as z12 } from "zod";
-var MongoConfigZod = z12.object({
-  // TODO: Create from other arguments
-  connectionString: z12.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB connection string",
-    title: "storage.mongo.connectionString",
-    type: "string"
-  }),
-  database: z12.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB database name",
-    title: "storage.mongo.database",
-    type: "string"
-  }),
-  domain: z12.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB domain",
-    title: "storage.mongo.domain",
-    type: "string"
-  }),
-  password: z12.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB password",
-    title: "storage.mongo.password",
-    type: "string"
-  }),
-  username: z12.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB username",
-    title: "storage.mongo.username",
-    type: "string"
-  })
-});
-
-// src/config/storage/driver/S3.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
-import { z as z13 } from "zod";
-var S3BucketConfigZod = z13.object({
-  accessKeyId: z13.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
-  accountId: z13.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
-  bucket: z13.string().nonempty().optional().describe("S3-compatible bucket name"),
-  prefix: z13.string().nonempty().optional().describe("Optional key prefix within the bucket"),
-  readUrl: z13.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
-  secretAccessKey: z13.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
-});
-var S3ConfigZod = z13.object({
-  accessKeyId: z13.string().nonempty().optional().describe("Shared S3-compatible access key id (default for all buckets)"),
-  accountId: z13.string().nonempty().optional().describe("Shared account id (default for all buckets; on Cloudflare R2 it forms the endpoint)"),
-  chainState: S3BucketConfigZod.optional().describe("Bucket for the mutable chain state (the head pointer)"),
-  finalized: S3BucketConfigZod.optional().describe("Bucket for the finalized files (blocks, payloads, manifest)"),
-  index: S3BucketConfigZod.optional().describe("Bucket for the chain index (the step-summary families)"),
-  prefix: z13.string().nonempty().optional().describe("Shared key prefix (default for all buckets)"),
-  secretAccessKey: z13.string().nonempty().optional().describe("Shared S3-compatible secret access key (default for all buckets)")
-});
+var ProvidersConfigZod = z14.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
 
 // src/config/storage/Storage.ts
-import { globalRegistry as globalRegistry10, z as z14 } from "zod";
-var StorageConfigZod = z14.object({
+import { globalRegistry as globalRegistry11, z as z15 } from "zod";
+var StorageConfigZod = z15.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z14.string().optional().register(globalRegistry10, {
+  root: z15.string().optional().register(globalRegistry11, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -263,87 +326,36 @@ var StorageConfigZod = z14.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry11, z as z15 } from "zod";
-var MetricsScrapeConfigZod = z15.object({
-  path: z15.string().default("/metrics").register(globalRegistry11, {
+import { globalRegistry as globalRegistry12, z as z16 } from "zod";
+var MetricsScrapeConfigZod = z16.object({
+  path: z16.string().default("/metrics").register(globalRegistry12, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z15.coerce.number().int().positive().optional().register(globalRegistry11, {
+  port: z16.coerce.number().int().positive().optional().register(globalRegistry12, {
     description: "Port for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.port",
     type: "number"
   })
 }).describe("Metrics scrape configuration");
-var MetricsConfigZod = z15.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z15.object({
+var MetricsConfigZod = z16.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z16.object({
   // OpenTelemetry options
-  otlpEndpoint: z15.url().optional().register(globalRegistry11, {
+  otlpEndpoint: z16.url().optional().register(globalRegistry12, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z15.object({
+var TelemetryConfigZod = z16.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
   otel: OpenTelemetryConfigZod.optional().describe("OpenTelemetry configuration")
 }).describe("Telemetry configuration options");
 
-// src/config/transports/Transport.ts
-import { globalRegistry as globalRegistry12, z as z16 } from "zod";
-var LmdbTransportConfigZod = z16.object({
-  type: z16.literal("lmdb"),
-  root: z16.string().register(globalRegistry12, {
-    description: "Root directory for local LMDB storage",
-    title: "transports.lmdb.root",
-    type: "string"
-  })
-}).describe("LMDB local storage transport");
-var MongoTransportConfigZod = z16.object({
-  type: z16.literal("mongo"),
-  connectionString: MongoConfigZod.shape.connectionString,
-  database: MongoConfigZod.shape.database,
-  domain: MongoConfigZod.shape.domain,
-  password: MongoConfigZod.shape.password,
-  username: MongoConfigZod.shape.username
-}).describe("MongoDB storage transport");
-var RpcTransportConfigZod = HttpRpcRemoteConfigZod.extend({ type: z16.literal("rpc") }).describe("XL1 JSON-RPC transport");
-var RestTransportConfigZod = z16.object({
-  type: z16.literal("rest"),
-  baseUrl: z16.string().register(globalRegistry12, {
-    description: "HTTP base URL for REST reads",
-    title: "transports.rest.baseUrl",
-    type: "string"
-  })
-}).describe("HTTP REST read transport");
-var S3TransportConfigZod = S3BucketConfigZod.extend({
-  type: z16.literal("s3"),
-  accessKeyId: z16.string().optional(),
-  accountId: z16.string().optional(),
-  secretAccessKey: z16.string().optional()
-}).describe("S3-compatible object storage transport");
-var EvmRpcTransportConfigZod = z16.object({
-  type: z16.literal("evm-rpc"),
-  url: z16.string().register(globalRegistry12, {
-    description: "EVM JSON-RPC URL",
-    title: "transports.evm-rpc.url",
-    type: "string"
-  })
-}).describe("EVM JSON-RPC transport");
-var TransportConfigZod = z16.discriminatedUnion("type", [
-  LmdbTransportConfigZod,
-  MongoTransportConfigZod,
-  RpcTransportConfigZod,
-  RestTransportConfigZod,
-  S3TransportConfigZod,
-  EvmRpcTransportConfigZod
-]);
-var TransportsConfigZod = z16.record(z16.string(), TransportConfigZod).default({});
-
 // src/config/Validation.ts
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-js";
 import { globalRegistry as globalRegistry13, z as z17 } from "zod";
@@ -384,10 +396,11 @@ var BaseConfigZod = z18.object({
   dataLake: z18.optional(DataLakeConfigZod).check(z18.describe("Configuration for data lakes")),
   evm: z18._default(EvmConfigZod, EvmConfigZod.parse({})).check(z18.describe("Configuration for EVM-backed services")),
   log: z18._default(LogConfigZod, LogConfigZod.parse({})).check(z18.describe("Configuration for logging")),
-  providerBindings: z18._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z18.describe("Per-moniker provider implementation and transport bindings")),
+  connections: z18._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z18.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
+  providerBindings: z18._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z18.describe("Per-moniker provider connection bindings")),
   providers: z18._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z18.describe("Configuration for providers")),
   remote: z18._default(RemoteConfigZod, RemoteConfigZod.parse({})).check(z18.describe("Configuration for remote services")),
-  transports: z18._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z18.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
+  transports: z18._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z18.describe("Deprecated alias for connections (kept in sync during migration)")),
   storage: z18._default(StorageConfigZod, StorageConfigZod.parse({})).check(z18.describe("Configuration for the storage")),
   telemetry: z18._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z18.describe("Configuration for telemetry")),
   validation: z18._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z18.describe("Configuration for validation"))