@xyo-network/xl1-protocol-sdk 3.0.10 → 3.0.12

package/dist/neutral/model/CreatableProviderContext.zod.d.ts

@@ -31,7 +31,6 @@ export declare const BaseConfigContextZod: z.ZodMiniObject<{
                 readonly __address: true;
             }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xyo-network/sdk-protocol-js").XyoQuantAddress, string>>]>>;
         }, z.core.$strip>>;
-        dataLake: z.ZodMiniOptional<import("zod").ZodType<import("../config/index.ts").DataLakeConfig, unknown, z.core.$ZodTypeInternals<import("../config/index.ts").DataLakeConfig, unknown>>>;
         log: z.ZodMiniDefault<import("zod").ZodObject<{
             logLevel: import("zod").ZodDefault<import("zod").ZodEnum<{
                 error: "error";
@@ -84,7 +83,6 @@ export declare const BaseConfigContextZod: z.ZodMiniObject<{
         }, 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>;
-            transport: 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;
@@ -178,7 +176,6 @@ export declare const isBaseConfigContext: <T>(value: T) => value is T & {
         }>;
         providerBindings: Record<string, {
             connection?: string | undefined;
-            transport?: string | undefined;
         }>;
         providers: {
             [x: string]: unknown;
@@ -210,7 +207,6 @@ export declare const isBaseConfigContext: <T>(value: T) => value is T & {
                 readonly __address: true;
             }) | import("@xyo-network/sdk-protocol-js").XyoQuantAddress)[] | undefined;
         };
-        dataLake?: import("../config/index.ts").DataLakeConfig | undefined;
     };
     logger?: import("@xylabs/sdk-js").Logger | undefined;
     meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
@@ -275,7 +271,6 @@ export declare const asBaseConfigContext: {
             }>;
             providerBindings: Record<string, {
                 connection?: string | undefined;
-                transport?: string | undefined;
             }>;
             providers: {
                 [x: string]: unknown;
@@ -307,7 +302,6 @@ export declare const asBaseConfigContext: {
                     readonly __address: true;
                 }) | import("@xyo-network/sdk-protocol-js").XyoQuantAddress)[] | undefined;
             };
-            dataLake?: import("../config/index.ts").DataLakeConfig | undefined;
         };
         logger?: import("@xylabs/sdk-js").Logger | undefined;
         meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
@@ -370,7 +364,6 @@ export declare const asBaseConfigContext: {
             }>;
             providerBindings: Record<string, {
                 connection?: string | undefined;
-                transport?: string | undefined;
             }>;
             providers: {
                 [x: string]: unknown;
@@ -402,7 +395,6 @@ export declare const asBaseConfigContext: {
                     readonly __address: true;
                 }) | import("@xyo-network/sdk-protocol-js").XyoQuantAddress)[] | undefined;
             };
-            dataLake?: import("../config/index.ts").DataLakeConfig | undefined;
         };
         logger?: import("@xylabs/sdk-js").Logger | undefined;
         meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
@@ -468,7 +460,6 @@ export declare const toBaseConfigContext: {
             }>;
             providerBindings: Record<string, {
                 connection?: string | undefined;
-                transport?: string | undefined;
             }>;
             providers: {
                 [x: string]: unknown;
@@ -500,7 +491,6 @@ export declare const toBaseConfigContext: {
                     readonly __address: true;
                 }) | import("@xyo-network/sdk-protocol-js").XyoQuantAddress)[] | undefined;
             };
-            dataLake?: import("../config/index.ts").DataLakeConfig | undefined;
         };
         logger?: import("@xylabs/sdk-js").Logger | undefined;
         meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
@@ -563,7 +553,6 @@ export declare const toBaseConfigContext: {
             }>;
             providerBindings: Record<string, {
                 connection?: string | undefined;
-                transport?: string | undefined;
             }>;
             providers: {
                 [x: string]: unknown;
@@ -595,7 +584,6 @@ export declare const toBaseConfigContext: {
                     readonly __address: true;
                 }) | import("@xyo-network/sdk-protocol-js").XyoQuantAddress)[] | undefined;
             };
-            dataLake?: import("../config/index.ts").DataLakeConfig | undefined;
         };
         logger?: import("@xylabs/sdk-js").Logger | undefined;
         meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;

package/dist/neutral/model/CreatableProviderContext.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CreatableProviderContext.zod.d.ts","sourceRoot":"","sources":["../../../src/model/CreatableProviderContext.zod.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,OAAO,EAAE,KAAK,UAAU,EAAiB,MAAM,oBAAoB,CAAA;AACnE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAA;AACnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAE9D,wCAAwC;AACxC,eAAO,MAAM,uBAAuB,6DAAsG,CAAA;AAE1I,0CAA0C;AAC1C,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,WAAW,CAAC,8BAA8B,CACqE,CAAA;AAEzJ,yCAAyC;AACzC,MAAM,MAAM,4BAA4B,GAAG,cAAc,GAAG;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,8BAA8B,CAAA;IACvC,cAAc,CAAC,EAAE,oBAAoB,CAAA;CACtC,CAAA;AAED,qCAAqC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG/B,CAAA;AACF,8BAA8B;AAC9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B,EAAE,CAAC,CAAC,WAAW,CAAC,4BAA4B,CAK/E,CAAA;AAEL,sEAAsE;AACtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;AACrE,kEAAkE;AAClE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAC5F,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAE5F,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B;;;;;;;;UA9B/B,MAAM;YACJ,UAAU;aACT,8BAA8B;qBACtB,oBAAoB;CA2B4C,CAAA;AACnF,yEAAyE;AACzE,eAAO,MAAM,0BAA0B;;;;;;;;;cAhC/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;;;;;;;;;cAH/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;CA6B0E,CAAA;AACjH,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;cAlC/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;;;;;;;;;cAH/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;CA+B0E,CAAA"}
+{"version":3,"file":"CreatableProviderContext.zod.d.ts","sourceRoot":"","sources":["../../../src/model/CreatableProviderContext.zod.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,OAAO,EAAE,KAAK,UAAU,EAAiB,MAAM,oBAAoB,CAAA;AACnE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAA;AACnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAE9D,wCAAwC;AACxC,eAAO,MAAM,uBAAuB,6DAAsG,CAAA;AAE1I,0CAA0C;AAC1C,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,WAAW,CAAC,8BAA8B,CACqE,CAAA;AAEzJ,yCAAyC;AACzC,MAAM,MAAM,4BAA4B,GAAG,cAAc,GAAG;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,8BAA8B,CAAA;IACvC,cAAc,CAAC,EAAE,oBAAoB,CAAA;CACtC,CAAA;AAED,qCAAqC;AACrC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG/B,CAAA;AACF,8BAA8B;AAC9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B,EAAE,CAAC,CAAC,WAAW,CAAC,4BAA4B,CAK/E,CAAA;AAEL,sEAAsE;AACtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;AACrE,kEAAkE;AAClE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAC5F,oCAAoC;AACpC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAE5F,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B;;;;;;;;UA9B/B,MAAM;YACJ,UAAU;aACT,8BAA8B;qBACtB,oBAAoB;CA2B4C,CAAA;AACnF,yEAAyE;AACzE,eAAO,MAAM,0BAA0B;;;;;;;;;cAhC/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;;;;;;;;;cAH/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;CA6B0E,CAAA;AACjH,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;cAlC/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;;;;;;;;;cAH/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;CA+B0E,CAAA"}

package/dist/neutral/simple/datalake/AbstractRestDataLake.d.ts

@@ -7,7 +7,8 @@ import { AbstractCreatableProvider, type CreatableProviderParams } from '../../C
 export interface AbstractRestDataLakeParams extends CreatableProviderParams {
     allowedSchemas?: Schema[];
     disallowedSchemas?: Schema[];
-    endpoint: string;
+    /** When omitted, resolved from `providerBindings` + a `rest` connection at startup. */
+    endpoint?: string;
 }
 /** Abstract base class for RestDataLake implementations. */
 export declare abstract class AbstractRestDataLake<TParams extends AbstractRestDataLakeParams = AbstractRestDataLakeParams> extends AbstractCreatableProvider<TParams> implements Omit<DataLakeViewer, 'moniker'> {
@@ -15,6 +16,15 @@ export declare abstract class AbstractRestDataLake<TParams extends AbstractRestD
     get client(): FetchJsonClient;
     get disallowedSchemas(): Schema[] | undefined;
     get endpoint(): string;
+    static paramsHandler(params?: Partial<AbstractRestDataLakeParams>): Promise<{
+        endpoint: string;
+        context: import("../../index.ts").CreatableProviderContextType;
+        name?: import("@xylabs/sdk-js").CreatableName;
+        statusReporter?: import("@xylabs/sdk-js").CreatableStatusReporter<void> | undefined;
+        logger?: import("@xylabs/sdk-js").Logger;
+        meterProvider?: import("@opentelemetry/api").MeterProvider;
+        traceProvider?: import("@opentelemetry/api").TracerProvider;
+    }>;
     get(hashes: Hash[]): Promise<DataLakeData[]>;
     next(_options?: NextOptions<Sequence>): PromisableArray<DataLakeData>;
     protected getOne(hash: Hash): Promise<DataLakeData | undefined>;

package/dist/neutral/simple/datalake/AbstractRestDataLake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractRestDataLake.d.ts","sourceRoot":"","sources":["../../../../src/simple/datalake/AbstractRestDataLake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAClE,OAAO,EACG,KAAK,IAAI,EAAE,KAAK,eAAe,EACxC,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EACV,WAAW,EAAE,MAAM,EAAE,QAAQ,EAC9B,MAAM,qBAAqB,CAAA;AAE5B,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEjF,OAAO,EAAE,yBAAyB,EAAE,KAAK,uBAAuB,EAAE,MAAM,kCAAkC,CAAA;AAE1G,2CAA2C;AAC3C,MAAM,WAAW,0BAA2B,SAC1C,uBAAuB;IAEvB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,4DAA4D;AAC5D,8BAAsB,oBAAoB,CAAC,OAAO,SAAS,0BAA0B,GAAG,0BAA0B,CAAE,SAClH,yBAAyB,CAAC,OAAO,CAAE,YAAW,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC;IAC7E,IAAI,cAAc,IAAI,MAAM,EAAE,GAAG,SAAS,CAEzC;IAED,IAAI,MAAM,oBAET;IAED,IAAI,iBAAiB,IAAI,MAAM,EAAE,GAAG,SAAS,CAE5C;IAED,IAAI,QAAQ,WAEX;IAEK,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAKlD,IAAI,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,GAAG,eAAe,CAAC,YAAY,CAAC;cAIrD,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAarE,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,GAAG,OAAO;IAO7D,SAAS,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;CASnD"}
+{"version":3,"file":"AbstractRestDataLake.d.ts","sourceRoot":"","sources":["../../../../src/simple/datalake/AbstractRestDataLake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAClE,OAAO,EACa,KAAK,IAAI,EAAa,KAAK,eAAe,EAC7D,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EACV,WAAW,EAAE,MAAM,EAAE,QAAQ,EAC9B,MAAM,qBAAqB,CAAA;AAE5B,OAAO,KAAK,EACV,YAAY,EAAE,cAAc,EAC7B,MAAM,+BAA+B,CAAA;AAGtC,OAAO,EAAE,yBAAyB,EAAE,KAAK,uBAAuB,EAAE,MAAM,kCAAkC,CAAA;AAE1G,2CAA2C;AAC3C,MAAM,WAAW,0BAA2B,SAC1C,uBAAuB;IAEvB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B,uFAAuF;IACvF,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,4DAA4D;AAC5D,8BAAsB,oBAAoB,CAAC,OAAO,SAAS,0BAA0B,GAAG,0BAA0B,CAAE,SAClH,yBAAyB,CAAC,OAAO,CAAE,YAAW,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC;IAC7E,IAAI,cAAc,IAAI,MAAM,EAAE,GAAG,SAAS,CAEzC;IAED,IAAI,MAAM,oBAET;IAED,IAAI,iBAAiB,IAAI,MAAM,EAAE,GAAG,SAAS,CAE5C;IAED,IAAI,QAAQ,WAEX;WAEqB,aAAa,CAAC,MAAM,GAAE,OAAO,CAAC,0BAA0B,CAAM;;;;;;;;;IAc9E,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAKlD,IAAI,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,GAAG,eAAe,CAAC,YAAY,CAAC;cAIrD,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAarE,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,GAAG,OAAO;IAO7D,SAAS,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;CASnD"}

package/dist/neutral/test/index.mjs

@@ -1029,10 +1029,10 @@ import {
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory2
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry11, z as z16 } from "zod/mini";
+import { globalRegistry as globalRegistry8, z as z12 } from "zod/mini";
 
 // src/config/Base.ts
-import { z as z15 } from "zod/mini";
+import { z as z11 } from "zod/mini";
 
 // src/config/Chain.ts
 import { HexZod } from "@xylabs/sdk-js";
@@ -1051,10 +1051,10 @@ var ChainConfigZod = z.object({
   })
 });
 
-// src/config/transports/Transport.ts
+// src/config/connections/Connection.ts
 import { globalRegistry as globalRegistry3, z as z4 } from "zod";
 
-// src/config/transports/Mongo.ts
+// src/config/connections/Mongo.ts
 import { globalRegistry as globalRegistry2, z as z2 } from "zod";
 var MongoConfigZod = z2.object({
   // TODO: Create from other arguments
@@ -1085,7 +1085,7 @@ var MongoConfigZod = z2.object({
   })
 });
 
-// src/config/transports/S3.ts
+// src/config/connections/S3.ts
 import { z as z3 } from "zod";
 var S3BucketConfigZod = z3.object({
   accessKeyId: z3.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
@@ -1096,151 +1096,108 @@ var S3BucketConfigZod = z3.object({
   secretAccessKey: z3.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
 });
 
-// src/config/transports/Transport.ts
-var LmdbTransportConfigZod = z4.object({
+// src/config/connections/Connection.ts
+var LmdbConnectionConfigZod = z4.object({
   access: z4.enum(["read", "write"]).optional().register(globalRegistry3, {
     description: "Access mode for this LMDB connection (read or write)",
-    title: "transports.lmdb.access",
+    title: "connections.lmdb.access",
     type: "string"
   }),
   root: z4.string().register(globalRegistry3, {
     description: "Root directory for local LMDB storage",
-    title: "transports.lmdb.root",
+    title: "connections.lmdb.root",
     type: "string"
   }),
   store: z4.string().optional().register(globalRegistry3, {
     description: "Logical store name within the LMDB root (e.g. finalized-chain, mempool)",
-    title: "transports.lmdb.store",
+    title: "connections.lmdb.store",
     type: "string"
   }),
   type: z4.literal("lmdb")
-}).describe("LMDB local storage transport");
-var MongoTransportConfigZod = z4.object({
+}).describe("LMDB local storage connection");
+var MongoConnectionConfigZod = z4.object({
   type: z4.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 = z4.object({
+}).describe("MongoDB storage connection");
+var RpcConnectionConfigZod = z4.object({
   type: z4.literal("rpc"),
   protocol: z4.string().default("http").register(globalRegistry3, {
     description: "Protocol for the RPC connection (http or postMessage)",
-    title: "transports.rpc.protocol",
+    title: "connections.rpc.protocol",
     type: "string"
   }),
   url: z4.string().optional().register(globalRegistry3, {
     description: "URL for the Chain RPC API (http protocol)",
-    title: "transports.rpc.url",
+    title: "connections.rpc.url",
     type: "string"
   }),
   networkId: z4.string().optional().register(globalRegistry3, {
     description: "Network ID for the postMessage RPC connection",
-    title: "transports.rpc.networkId",
+    title: "connections.rpc.networkId",
     type: "string"
   }),
   sessionId: z4.string().optional().register(globalRegistry3, {
     description: "Session ID for the postMessage RPC connection",
-    title: "transports.rpc.sessionId",
+    title: "connections.rpc.sessionId",
     type: "string"
   })
-}).describe("XL1 JSON-RPC transport");
-var RestTransportConfigZod = z4.object({
+}).describe("XL1 JSON-RPC connection");
+var RestConnectionConfigZod = z4.object({
   type: z4.literal("rest"),
   baseUrl: z4.string().register(globalRegistry3, {
     description: "HTTP base URL for REST reads",
-    title: "transports.rest.baseUrl",
+    title: "connections.rest.baseUrl",
     type: "string"
   })
-}).describe("HTTP REST read transport");
-var S3TransportConfigZod = S3BucketConfigZod.extend({
+}).describe("HTTP REST read connection");
+var S3ConnectionConfigZod = S3BucketConfigZod.extend({
   type: z4.literal("s3"),
   accessKeyId: z4.string().optional(),
   accountId: z4.string().optional(),
   secretAccessKey: z4.string().optional()
-}).describe("S3-compatible object storage transport");
-var EvmRpcTransportConfigZod = z4.object({
+}).describe("S3-compatible object storage connection");
+var EvmRpcConnectionConfigZod = z4.object({
   type: z4.literal("evm-rpc"),
   url: z4.string().register(globalRegistry3, {
     description: "EVM JSON-RPC URL",
-    title: "transports.evm-rpc.url",
+    title: "connections.evm-rpc.url",
     type: "string"
   }),
   chainId: z4.string().optional().register(globalRegistry3, {
     description: "EVM chain ID for this RPC endpoint; auto-detected from the endpoint when omitted",
-    title: "transports.evm-rpc.chainId",
+    title: "connections.evm-rpc.chainId",
     type: "string"
   })
-}).describe("EVM JSON-RPC transport");
-var MemoryTransportConfigZod = z4.object({ type: z4.literal("memory") }).describe("In-process memory transport");
-var TransportConfigZod = z4.discriminatedUnion("type", [
-  LmdbTransportConfigZod,
-  MongoTransportConfigZod,
-  RpcTransportConfigZod,
-  RestTransportConfigZod,
-  S3TransportConfigZod,
-  EvmRpcTransportConfigZod,
-  MemoryTransportConfigZod
+}).describe("EVM JSON-RPC connection");
+var MemoryConnectionConfigZod = z4.object({ type: z4.literal("memory") }).describe("In-process memory connection");
+var ConnectionConfigZod = z4.discriminatedUnion("type", [
+  LmdbConnectionConfigZod,
+  MongoConnectionConfigZod,
+  RpcConnectionConfigZod,
+  RestConnectionConfigZod,
+  S3ConnectionConfigZod,
+  EvmRpcConnectionConfigZod,
+  MemoryConnectionConfigZod
 ]);
-var TransportsConfigZod = z4.record(z4.string(), TransportConfigZod).default({});
-
-// src/config/DataLake/DataLake.ts
-import { z as z8 } from "zod";
-
-// src/config/DataLake/RestDataLakeConfig.ts
-import { globalRegistry as globalRegistry5, z as z6 } from "zod";
-
-// src/config/DataLake/DataLakeRemoteConfig.ts
-import { globalRegistry as globalRegistry4, z as z5 } from "zod";
-var DataLakeDriverConfigBaseZod = z5.object({
-  driver: z5.string().register(globalRegistry4, {
-    description: "Driver for the data lake",
-    type: "string"
-  })
-}).describe("Base configuration for a data lake driver");
-
-// src/config/DataLake/RestDataLakeConfig.ts
-var RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
-  driver: z6.literal("rest").register(globalRegistry5, {
-    description: "Driver for the REST data lake",
-    type: "string"
-  }),
-  url: z6.string().register(globalRegistry5, {
-    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 globalRegistry6, z as z7 } from "zod";
-var RouterDataLakeConfigZod = z7.object({
-  driver: z7.literal("router").register(globalRegistry6, {
-    description: "Driver for the router data lake",
-    type: "string"
-  }),
-  children: z7.array(z7.lazy(() => DataLakeConfigZod)).register(globalRegistry6, {
-    description: "Child data lake drivers",
-    type: "array"
-  })
-}).describe("Configuration for the router data lake driver");
-
-// src/config/DataLake/DataLake.ts
-var DataLakeConfigZod = z8.lazy(() => z8.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
+var ConnectionsConfigZod = z4.record(z4.string(), ConnectionConfigZod).default({});
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry7, z as z9 } from "zod";
+import { globalRegistry as globalRegistry4, z as z5 } from "zod";
 var LogLevelNames = Object.keys(LogLevel);
-var LogConfigZod = z9.object({
-  logLevel: z9.enum(LogLevelNames).default("info").register(globalRegistry7, {
+var LogConfigZod = z5.object({
+  logLevel: z5.enum(LogLevelNames).default("info").register(globalRegistry4, {
     choices: LogLevelNames,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z9.boolean().default(false).register(globalRegistry7, {
+  silent: z5.boolean().default(false).register(globalRegistry4, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -1249,23 +1206,18 @@ var LogConfigZod = z9.object({
 });
 
 // src/config/ProviderBinding.ts
-import { globalRegistry as globalRegistry8, z as z10 } from "zod";
-var ProviderBindingConfigZod = z10.object({
-  connection: z10.string().optional().register(globalRegistry8, {
+import { globalRegistry as globalRegistry5, z as z6 } from "zod";
+var ProviderBindingConfigZod = z6.object({
+  connection: z6.string().optional().register(globalRegistry5, {
     description: "Named connection from the top-level connections map",
     title: "providerBindings.connection",
     type: "string"
-  }),
-  transport: z10.string().optional().register(globalRegistry8, {
-    description: "Deprecated alias for connection (kept in sync during migration)",
-    title: "providerBindings.transport",
-    type: "string"
   })
 }).describe("Provider connection binding");
-var ProviderBindingsConfigZod = z10.record(z10.string(), ProviderBindingConfigZod).default({});
+var ProviderBindingsConfigZod = z6.record(z6.string(), ProviderBindingConfigZod).default({});
 
 // src/config/Providers.ts
-import z12 from "zod";
+import z8 from "zod";
 
 // src/config/Provider.ts
 import {
@@ -1273,43 +1225,43 @@ import {
   zodIsFactory,
   zodToFactory
 } from "@xylabs/sdk-js";
-import { z as z11 } from "zod";
-var ProviderConfigZod = z11.object({
-  moniker: z11.string(),
-  labels: z11.array(z11.string()).optional()
+import { z as z7 } from "zod";
+var ProviderConfigZod = z7.object({
+  moniker: z7.string(),
+  labels: z7.array(z7.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 = z12.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
+var ProvidersConfigZod = z8.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry9, z as z13 } from "zod";
-var MetricsScrapeConfigZod = z13.object({
-  path: z13.string().default("/metrics").register(globalRegistry9, {
+import { globalRegistry as globalRegistry6, z as z9 } from "zod";
+var MetricsScrapeConfigZod = z9.object({
+  path: z9.string().default("/metrics").register(globalRegistry6, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z13.coerce.number().int().nonnegative().optional().register(globalRegistry9, {
+  port: z9.coerce.number().int().nonnegative().optional().register(globalRegistry6, {
     description: "Port for the metrics scrape endpoint (0 disables the scrape endpoint)",
     title: "telemetry.metrics.scrape.port",
     type: "number"
   })
 }).describe("Metrics scrape configuration");
-var MetricsConfigZod = z13.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z13.object({
+var MetricsConfigZod = z9.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z9.object({
   // OpenTelemetry options
-  otlpEndpoint: z13.url().optional().register(globalRegistry9, {
+  otlpEndpoint: z9.url().optional().register(globalRegistry6, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z13.object({
+var TelemetryConfigZod = z9.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
@@ -1318,7 +1270,7 @@ var TelemetryConfigZod = z13.object({
 
 // src/config/Validation.ts
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-js";
-import { globalRegistry as globalRegistry10, z as z14 } from "zod";
+import { globalRegistry as globalRegistry7, z as z10 } from "zod";
 
 // src/primitives/block/rate/blockRate.ts
 import { isDefined as isDefined5, isFalsy } from "@xylabs/sdk-js";
@@ -1558,24 +1510,24 @@ var DEFAULT_MIN_CANDIDATES = 1;
 var DEFAULT_BACKOFF_MS = 12e4;
 
 // src/config/Validation.ts
-var ValidationConfigZod = z14.object({
-  allowedRewardRedeemers: z14.array(XyoAddressZod2).optional().register(globalRegistry10, {
+var ValidationConfigZod = z10.object({
+  allowedRewardRedeemers: z10.array(XyoAddressZod2).optional().register(globalRegistry7, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   }),
-  allowedRewardEscrowAccountSigners: z14.array(XyoAddressZod2).optional().register(globalRegistry10, {
+  allowedRewardEscrowAccountSigners: z10.array(XyoAddressZod2).optional().register(globalRegistry7, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
   }),
-  minCandidates: z14.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry10, {
+  minCandidates: z10.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry7, {
     default: DEFAULT_MIN_CANDIDATES,
     description: "Minimum number of uncle candidates before selecting the best uncle",
     title: "validation.minCandidates",
     type: "number"
   }),
-  backoffMs: z14.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry10, {
+  backoffMs: z10.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry7, {
     default: DEFAULT_BACKOFF_MS,
     description: "Back-off timeout in ms. If head age exceeds this, minCandidates is ignored",
     title: "validation.backoffMs",
@@ -1584,25 +1536,24 @@ var ValidationConfigZod = z14.object({
 });
 
 // src/config/Base.ts
-var BaseConfigZod = z15.object({
-  chain: z15._default(ChainConfigZod, ChainConfigZod.parse({})).check(z15.describe("Configuration for the chain")),
-  dataLake: z15.optional(DataLakeConfigZod).check(z15.describe("Configuration for data lakes")),
-  log: z15._default(LogConfigZod, LogConfigZod.parse({})).check(z15.describe("Configuration for logging")),
-  connections: z15._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z15.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
-  providerBindings: z15._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z15.describe("Per-moniker provider connection bindings")),
-  providers: z15._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z15.describe("Configuration for providers")),
-  telemetry: z15._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z15.describe("Configuration for telemetry")),
-  validation: z15._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z15.describe("Configuration for validation"))
+var BaseConfigZod = z11.object({
+  chain: z11._default(ChainConfigZod, ChainConfigZod.parse({})).check(z11.describe("Configuration for the chain")),
+  log: z11._default(LogConfigZod, LogConfigZod.parse({})).check(z11.describe("Configuration for logging")),
+  connections: z11._default(ConnectionsConfigZod, ConnectionsConfigZod.parse({})).check(z11.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
+  providerBindings: z11._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z11.describe("Per-moniker provider connection bindings")),
+  providers: z11._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z11.describe("Configuration for providers")),
+  telemetry: z11._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z11.describe("Configuration for telemetry")),
+  validation: z11._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z11.describe("Configuration for validation"))
 });
 
 // src/config/Actor.ts
-var AccountPathZod = z16.string().check(z16.regex(
+var AccountPathZod = z12.string().check(z12.regex(
   /^(m(\/\d+'?)+|\d+'?(\/\d+'?)*)$/,
   `Invalid BIP-32 derivation path. Use either an absolute path like "m/44'/60'/0'/0/0" or a relative path like "0", "0/1", or "44'/60'/0'/0/0".`
 ));
-var ActorConfigZod = z16.extend(BaseConfigZod, {
-  name: z16.string(),
-  accountPath: z16.optional(AccountPathZod).register(globalRegistry11, {
+var ActorConfigZod = z12.extend(BaseConfigZod, {
+  name: z12.string(),
+  accountPath: z12.optional(AccountPathZod).register(globalRegistry8, {
     description: 'BIP-32 derivation path for the actor wallet. Absolute when it starts with "m/"; otherwise relative to the root wallet base path. Each actor must derive to a distinct path.',
     title: "accountPath",
     type: "string"
@@ -1613,22 +1564,22 @@ var asActorConfig = zodAsFactory2(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
-import { z as z17 } from "zod/mini";
-var ActorsConfigZod = z17._default(
-  z17.array(z17.looseObject(ActorConfigZod.shape)).check(z17.describe("Actor-specific configurations that override the base configuration when the actor is running")),
+import { z as z13 } from "zod/mini";
+var ActorsConfigZod = z13._default(
+  z13.array(z13.looseObject(ActorConfigZod.shape)).check(z13.describe("Actor-specific configurations that override the base configuration when the actor is running")),
   []
 );
 
 // src/config/Config.ts
-import { globalRegistry as globalRegistry12, z as z18 } from "zod/mini";
-var ConfigZod = z18.extend(BaseConfigZod, {
+import { globalRegistry as globalRegistry9, z as z14 } from "zod/mini";
+var ConfigZod = z14.extend(BaseConfigZod, {
   actors: ActorsConfigZod,
-  healthCheckPort: z18.optional(z18.coerce.number()).register(globalRegistry12, {
+  healthCheckPort: z14.optional(z14.coerce.number()).register(globalRegistry9, {
     description: "Port for the system-wide health, readiness, and liveness endpoints (/healthz, /livez, /readyz). Set to 0 to disable.",
     title: "healthCheckPort",
     type: "number"
   })
-}).check(z18.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
+}).check(z14.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
 
 // src/summary/primitives/blocks/blocksMaxStep.ts
 var blocksMaxStep = 3;