@xyo-network/xl1-protocol-sdk 2.2.3 → 3.0.1

package/dist/neutral/index.mjs

@@ -1017,6 +1017,18 @@ function filterViewerBySurface(viewer, surface) {
   };
 }
 
+// src/capabilities/connectionTypes.ts
+function descriptorConnectionTypes(descriptor) {
+  return descriptor.connectionTypes ?? [];
+}
+function descriptorMatchesConnectionType(descriptor, connectionType) {
+  const types = descriptorConnectionTypes(descriptor);
+  if (types.length === 0) {
+    return true;
+  }
+  return types.includes(connectionType);
+}
+
 // src/capabilities/factoryBrand.ts
 function backedFactory(_backings, factory) {
   return factory;
@@ -1028,7 +1040,339 @@ function factoryBackingsCompatible(declared, available) {
   return backingsSatisfied(declared, available);
 }
 
+// src/config/normalizeConnectionsConfig.ts
+function mergeConnectionMaps(transports, connections) {
+  return { ...transports, ...connections };
+}
+function normalizeProviderBinding(binding) {
+  const connectionName = binding.connection ?? binding.transport;
+  if (connectionName === void 0 || connectionName === "") {
+    return binding;
+  }
+  return {
+    ...binding,
+    connection: connectionName,
+    transport: connectionName
+  };
+}
+function normalizeProviderBindings(bindings) {
+  const normalized = {};
+  for (const [moniker, binding] of Object.entries(bindings)) {
+    if (binding === void 0) continue;
+    normalized[moniker] = normalizeProviderBinding(binding);
+  }
+  return normalized;
+}
+function normalizeConnectionsConfig(config) {
+  const transports = config.transports ?? {};
+  const connections = config.connections ?? {};
+  const merged = mergeConnectionMaps(transports, connections);
+  return {
+    ...config,
+    connections: merged,
+    providerBindings: normalizeProviderBindings(config.providerBindings ?? {}),
+    transports: merged
+  };
+}
+function hasDeclaredConnectionProfiles(config) {
+  return Object.keys(config.transports ?? {}).length > 0 || Object.keys(config.connections ?? {}).length > 0;
+}
+
+// src/CreatableProvider/ProviderFactoryLocator.ts
+import { hasAllLabels } from "@xylabs/sdk-js";
+import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+
+// src/CreatableProvider/CreatableProviderRegistry.ts
+import { isTruthy } from "@xylabs/sdk-js";
+
+// src/CreatableProvider/ProviderFactory.ts
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
+function providerFactoryDescription(factory, labels) {
+  return `${factory.providerName}:${factory.defaultMoniker}:${JSON.stringify(labels ?? factory.labels ?? {})}`;
+}
+var ProviderFactory = class _ProviderFactory {
+  creatableProvider;
+  defaultMoniker;
+  defaultParams;
+  dependencies;
+  labels;
+  monikers;
+  providerName;
+  scope;
+  _uniqueId;
+  constructor(creatableProvider2, dependencies, params, labels = {}, scope = "context") {
+    this.creatableProvider = creatableProvider2;
+    this.defaultParams = params;
+    this.defaultMoniker = creatableProvider2.defaultMoniker;
+    this.dependencies = dependencies;
+    this.monikers = creatableProvider2.monikers;
+    this.scope = scope;
+    assertEx8(this.monikers.includes(this.defaultMoniker), () => "defaultMoniker must be in monikers");
+    this.labels = Object.assign({}, creatableProvider2.labels ?? {}, labels ?? {});
+    this.providerName = creatableProvider2.name;
+    this._uniqueId = Symbol(providerFactoryDescription(this));
+  }
+  get resolvedMoniker() {
+    const labels = this.labels ?? {};
+    const labelString = Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(",");
+    return labelString.length === 0 ? this.defaultMoniker : `${this.defaultMoniker}|${labelString}`;
+  }
+  get uniqueId() {
+    return this._uniqueId;
+  }
+  static withParams(creatableProvider2, dependencies, params, labels = {}) {
+    return new _ProviderFactory(creatableProvider2, dependencies, params, labels);
+  }
+  factory(dependencies, params, labels = {}) {
+    return new _ProviderFactory(this.creatableProvider, dependencies, params, labels);
+  }
+  async getInstance(params, { start = true }) {
+    let scopeObject;
+    switch (this.scope) {
+      case "global": {
+        scopeObject = getOrCreateGlobalSingletons();
+        break;
+      }
+      case "context": {
+        const context = assertEx8(
+          params?.context,
+          () => "Context is required for context-scoped providers"
+        );
+        context.singletons ??= {};
+        scopeObject = context.singletons;
+        break;
+      }
+      default: {
+        scopeObject = {};
+        break;
+      }
+    }
+    const mergedParams = {
+      ...this.defaultParams,
+      ...params
+    };
+    const resultPromise = scopeObject[this.resolvedMoniker] ?? this.creatableProvider.create(mergedParams);
+    scopeObject[this.resolvedMoniker] = resultPromise;
+    const result = await resultPromise;
+    if (start) {
+      assertEx8(await result.start(), () => `Failed to start provider instance [${this.resolvedMoniker}]`);
+    }
+    return result;
+  }
+  async tryGetInstance(params, options) {
+    try {
+      return await this.getInstance(params, options);
+    } catch {
+      return;
+    }
+  }
+};
+function getOrCreateGlobalSingletons() {
+  const existing = globalThis.xyoServiceSingletons;
+  if (existing !== void 0) {
+    return existing;
+  }
+  const singletons = {};
+  Reflect.set(globalThis, "xyoServiceSingletons", singletons);
+  return singletons;
+}
+
+// src/CreatableProvider/CreatableProviderRegistry.ts
+var buildProviderFactory = (provider, defaultParams, labels) => {
+  const factory = {
+    monikers: provider.monikers,
+    uniqueId: Symbol(providerFactoryDescription(provider, labels)),
+    // Merge module & supplied labels
+    labels: { ...provider.labels, ...labels },
+    creatableProvider: provider.creatableProvider,
+    dependencies: provider.dependencies,
+    resolvedMoniker: provider.resolvedMoniker,
+    providerName: provider.providerName,
+    scope: provider.scope,
+    defaultParams,
+    getInstance: provider.getInstance.bind(provider),
+    tryGetInstance: provider.tryGetInstance?.bind(provider),
+    defaultMoniker: provider.defaultMoniker,
+    factory: provider.factory.bind(provider)
+  };
+  return factory;
+};
+var registerCreatableProviderFactory = (registry, factory, labels, primary = false) => {
+  const primaryMonikers = primary !== true && isTruthy(primary) ? Array.isArray(primary) ? primary : [primary] : [];
+  for (const primaryMoniker of primaryMonikers) {
+    if (!factory.monikers.includes(primaryMoniker)) {
+      throw new Error(`Primary moniker ${String(primaryMoniker)} not found in factory monikers`);
+    }
+  }
+  const isPrimaryForMoniker = (moniker) => {
+    switch (typeof primary) {
+      case "boolean": {
+        return primary;
+      }
+      case "string": {
+        return moniker === primary;
+      }
+      case "object": {
+        if (Array.isArray(primary)) {
+          return primary.includes(moniker);
+        }
+      }
+    }
+    throw new Error(`Invalid primary value: ${String(primary)}`);
+  };
+  const factoryClone = buildProviderFactory(factory, factory.defaultParams, labels);
+  registry[factoryClone.defaultMoniker] = [factoryClone, ...registry[factoryClone.defaultMoniker] ?? []];
+  for (const moniker of factoryClone.monikers) {
+    if (moniker === factoryClone.defaultMoniker) continue;
+    registry[moniker] = isPrimaryForMoniker(moniker) ? [factoryClone, ...registry[moniker] ?? []] : [...registry[moniker] ?? [], factoryClone];
+  }
+};
+var registerCreatableProviderFactories = (factories, registry = {}, primary = false) => {
+  for (const factory of factories) {
+    registerCreatableProviderFactory(registry, factory, void 0, primary);
+  }
+  return registry;
+};
+
+// src/CreatableProvider/LabeledCreatableProviderFactory.ts
+var hasLabels = (factory) => {
+  return factory.labels !== void 0;
+};
+function labeledCreatableProviderFactory() {
+  return (constructor) => {
+    constructor;
+  };
+}
+
+// src/CreatableProvider/ProviderFactoryLocator.ts
+var ProviderFactoryLocator = class _ProviderFactoryLocator {
+  _context;
+  _registry;
+  _frozen = false;
+  _parent;
+  _validateDepsOnRegister;
+  constructor(context, registry = {}, validateDepsOnRegister = false) {
+    this._registry = registry;
+    this._context = { ...context, locator: this };
+    this._parent = context.locator;
+    this._validateDepsOnRegister = validateDepsOnRegister;
+  }
+  get context() {
+    return this._context;
+  }
+  get logger() {
+    return this.context.logger;
+  }
+  /**
+   * The current registry for the module factory
+   */
+  get registry() {
+    return this._registry;
+  }
+  get validateDepsOnRegister() {
+    return this._validateDepsOnRegister;
+  }
+  freeze() {
+    this._frozen = true;
+  }
+  async getInstance(moniker, { start = true, labels } = {}) {
+    return assertEx9(
+      await this.tryGetInstance(moniker, { start, labels }),
+      () => `No provider instance for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} could be created`
+    );
+  }
+  has(moniker) {
+    return Object.hasOwn(this._registry, moniker);
+  }
+  /**
+   * Locates a provider factory that matches the supplied moniker and labels
+   * @param moniker The config moniker for the provider
+   * @param labels The labels for the provider factory
+   * @returns A provider factory that matches the supplied moniker and labels or throws if one is not found
+   */
+  locate(moniker, labels) {
+    return assertEx9(
+      this.tryLocate(moniker, labels),
+      () => `No module factory for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} registered`
+    );
+  }
+  merge(locator) {
+    const registry = { ...this.registry };
+    for (const moniker in locator.registry) {
+      const existing = registry[moniker];
+      if (existing === void 0) {
+        registry[moniker] = locator.registry[moniker];
+      } else {
+        existing.push(...locator.registry[moniker] ?? []);
+      }
+    }
+    return new _ProviderFactoryLocator(this.context, registry);
+  }
+  /**
+   * Registers a single module factory (with optional tags) with the locator
+   * @param factory The factory to register
+   * @param labels The labels for the module factory
+   */
+  register(factory, labels, primary = false) {
+    assertEx9(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
+    if (this.validateDepsOnRegister) {
+      const missingDeps = factory.dependencies.filter((dep) => !this.registered(dep));
+      assertEx9(missingDeps.length === 0, () => `Cannot register module factory [${factory.uniqueId.description}] due to missing dependencies: ${missingDeps.join(", ")}`);
+    }
+    registerCreatableProviderFactory(this._registry, factory, labels, primary);
+    return this;
+  }
+  /**
+   * Registers multiple module factories with the locator
+   * @param factories The factories to register
+   */
+  registerMany(factories) {
+    for (const factory of factories) {
+      this.register(factory);
+    }
+    return this;
+  }
+  registered(moniker) {
+    return Object.hasOwn(this.registry, moniker) || (this._parent?.registered(moniker) ?? false);
+  }
+  async tryGetInstance(moniker, { start = true, labels } = {}) {
+    const resolvedParams = { context: this.context };
+    const factory = this.tryLocate(moniker, labels);
+    if (factory !== void 0) {
+      if (Object.hasOwn(this.context.singletons, factory.uniqueId)) {
+        return this.context.singletons[factory.uniqueId];
+      }
+      this.logger?.debug(`Creating provider instance for moniker [${moniker}]${labels ? ` with labels [${JSON.stringify(labels)}]` : ""} using factory [${factory.uniqueId.description}]`);
+      const result = await factory.getInstance(resolvedParams, { start });
+      this.context.singletons[factory.uniqueId] = result;
+      return result;
+    }
+  }
+  /**
+   * Tries to locate a module factory that matches the supplied moniker and labels
+   * @param moniker The config moniker for the module
+   * @param labels The labels for the module factory
+   * @returns A module factory that matches the supplied moniker and labels or undefined
+   */
+  tryLocate(moniker, labels) {
+    const result = (labels ? this._registry[moniker]?.filter(hasLabels).find((factory) => hasAllLabels(factory?.labels, labels)) ?? this._registry[moniker]?.[0] : this._registry[moniker]?.[0]) ?? this._parent?.tryLocate(moniker, labels);
+    return result;
+  }
+  validateDependencies(recursive = false) {
+    if (recursive) {
+      this._parent?.validateDependencies();
+    }
+    for (const moniker in this.registry) {
+      for (const factory of this.registry[moniker] ?? []) {
+        const missingDeps = factory.dependencies.filter((dep) => !this.registered(dep));
+        assertEx9(missingDeps.length === 0, () => `Module factory [${factory.uniqueId.description}] is missing dependencies: ${missingDeps.join(", ")}`);
+      }
+    }
+  }
+};
+
 // src/capabilities/resolveProviders.ts
+import { isDefined as isDefined4 } from "@xylabs/sdk-js";
 var MissingCapabilityError = class extends Error {
   moniker;
   reasons;
@@ -1040,158 +1384,252 @@ var MissingCapabilityError = class extends Error {
     this.reasons = reasons;
   }
 };
-function resolveProviders(needs, candidates, ctx, options = {}) {
-  const wanted = expandNeeds(needs, ctx);
-  const { backingFiltered, backingRejected } = filterByBackings(candidates, options.availableBackings);
-  const { surviving, rejected: preconditionRejected } = filterByPreconditions(backingFiltered, ctx);
-  const rejected = [...backingRejected, ...preconditionRejected];
-  const byCapability = groupByCapability(surviving, wanted);
-  const { bindings, selectedById } = pickWinners(wanted, byCapability, rejected, candidates, options);
-  const selected = topoSort(selectedById.values().toArray(), ctx);
+var AmbiguousProviderError = class extends Error {
+  candidates;
+  moniker;
+  constructor(moniker, candidates) {
+    const ids = candidates.map((descriptor) => descriptor.id);
+    super(
+      `Multiple providers satisfy capability '${moniker}' for the requested connection: ${ids.join(", ")}`
+    );
+    this.name = "AmbiguousProviderError";
+    this.moniker = moniker;
+    this.candidates = ids;
+  }
+};
+var UnboundProviderError = class extends Error {
+  moniker;
+  constructor(moniker) {
+    super(`Provider "${moniker}" has no providerBindings.connection`);
+    this.name = "UnboundProviderError";
+    this.moniker = moniker;
+  }
+};
+var UnknownConnectionError = class extends Error {
+  connectionName;
+  moniker;
+  constructor(moniker, connectionName) {
+    super(
+      `providerBindings.${moniker}.connection references unknown connection "${connectionName}"`
+    );
+    this.name = "UnknownConnectionError";
+    this.moniker = moniker;
+    this.connectionName = connectionName;
+  }
+};
+function resolveProviders(needs, candidates, options = {}) {
+  const rejected = [];
+  const wanted = new Set(needs);
+  const bindings = {};
+  const selectedById = /* @__PURE__ */ new Map();
+  const candidatesByMoniker = indexCandidatesByMoniker(candidates);
+  expandBindingClosure(
+    wanted,
+    bindings,
+    selectedById,
+    candidatesByMoniker,
+    rejected,
+    candidates,
+    options
+  );
+  const selected = topoSort(selectedById.values().toArray(), bindings, selectedById);
   return {
     bindings,
     rejected,
     selected
   };
 }
-function filterByBackings(candidates, availableBackings) {
-  if (!availableBackings) {
-    return { backingFiltered: [...candidates], backingRejected: [] };
-  }
-  const backingFiltered = [];
-  const backingRejected = [];
-  for (const descriptor of candidates) {
-    if (backingsSatisfied(descriptor.backings, availableBackings)) {
-      backingFiltered.push(descriptor);
-    } else {
-      const missing = unmetBackings(descriptor.backings, availableBackings);
-      const rendered = missing.map((m) => `${m.backing}:${m.mode}`).join(", ");
-      backingRejected.push({ descriptor, reason: `missing backings [${rendered}]` });
-    }
-  }
-  return { backingFiltered, backingRejected };
-}
-function expandNeeds(needs, ctx) {
-  const wanted = new Set(needs);
-  const stack = [...needs];
-  while (stack.length > 0) {
-    const moniker = stack.pop();
-    const cap = ctx.capabilities.tryGet(moniker);
-    if (!cap?.implies) continue;
-    for (const dep of cap.implies) {
-      if (!wanted.has(dep)) {
-        wanted.add(dep);
-        stack.push(dep);
+function expandBindingClosure(wanted, bindings, selectedById, candidatesByMoniker, rejected, allCandidates, options) {
+  let grew = true;
+  while (grew) {
+    grew = false;
+    for (const moniker of [...wanted].toSorted((a, b) => a.localeCompare(b))) {
+      if (!Object.hasOwn(bindings, moniker)) {
+        grew = bindMoniker(
+          moniker,
+          wanted,
+          bindings,
+          selectedById,
+          candidatesByMoniker,
+          rejected,
+          allCandidates,
+          options
+        ) || grew;
       }
     }
   }
-  return wanted;
 }
-function filterByPreconditions(candidates, ctx) {
-  const surviving = [];
-  const rejected = [];
-  for (const descriptor of candidates) {
-    try {
-      if (descriptor.preconditions(ctx)) {
-        surviving.push(descriptor);
-      } else {
-        rejected.push({ descriptor, reason: "preconditions returned false" });
-      }
-    } catch (err) {
-      rejected.push({
-        descriptor,
-        reason: `preconditions threw: ${err instanceof Error ? err.message : String(err)}`
-      });
-    }
+function bindMoniker(moniker, wanted, bindings, selectedById, candidatesByMoniker, rejected, allCandidates, options) {
+  const connectionName = connectionNameForMoniker(moniker, options);
+  const connection = options.connections?.[connectionName];
+  if (!isDefined4(connection)) {
+    throw new UnknownConnectionError(moniker, connectionName);
+  }
+  const group = candidatesByMoniker.get(moniker) ?? [];
+  const { filtered, rejected: connectionRejected } = filterByConnection(
+    group,
+    connection.type,
+    connectionName
+  );
+  rejected.push(...connectionRejected);
+  if (filtered.length === 0) {
+    throw new MissingCapabilityError(moniker, reasonsFor(moniker, rejected, allCandidates));
   }
-  return { surviving, rejected };
-}
-function addDescriptorCapabilities(byCapability, descriptor, wanted) {
-  for (const moniker of descriptor.satisfies) {
-    if (!wanted.has(moniker)) {
-      continue;
+  if (filtered.length > 1) {
+    throw new AmbiguousProviderError(moniker, filtered);
+  }
+  const winner = filtered[0];
+  bindings[moniker] = winner.id;
+  selectedById.set(winner.id, winner);
+  let grew = false;
+  for (const dep of winner.dependencies ?? []) {
+    if (!wanted.has(dep)) {
+      wanted.add(dep);
+      grew = true;
     }
-    const list = byCapability.get(moniker) ?? [];
-    list.push(descriptor);
-    byCapability.set(moniker, list);
   }
+  return grew;
 }
-function groupByCapability(surviving, wanted) {
-  const byCapability = /* @__PURE__ */ new Map();
-  for (const descriptor of surviving) {
-    addDescriptorCapabilities(byCapability, descriptor, wanted);
+function connectionNameForMoniker(moniker, options) {
+  const binding = options.providerBindings?.[moniker];
+  const connectionName = binding?.connection ?? binding?.transport;
+  if (!isDefined4(connectionName) || connectionName === "") {
+    throw new UnboundProviderError(moniker);
   }
-  return byCapability;
+  return connectionName;
 }
-function pickWinners(wanted, byCapability, rejected, allCandidates, options) {
-  const bindings = {};
-  const selectedById = /* @__PURE__ */ new Map();
-  for (const moniker of wanted) {
-    let group = byCapability.get(moniker);
-    const pinned = options.implementations?.[moniker];
-    if (pinned !== void 0 && pinned !== "") {
-      const pinnedGroup = group?.filter((descriptor) => descriptor.id === pinned);
-      if (!pinnedGroup || pinnedGroup.length === 0) {
-        throw new MissingCapabilityError(moniker, [`requested implementation '${pinned}' not available`]);
-      }
-      group = pinnedGroup;
-    }
-    if (!group || group.length === 0) {
-      throw new MissingCapabilityError(moniker, reasonsFor(moniker, rejected, allCandidates));
+function indexCandidatesByMoniker(candidates) {
+  const byMoniker = /* @__PURE__ */ new Map();
+  for (const descriptor of candidates) {
+    for (const moniker of descriptor.satisfies) {
+      const list = byMoniker.get(moniker) ?? [];
+      list.push(descriptor);
+      byMoniker.set(moniker, list);
     }
-    const sorted = group.toSorted(compareDescriptors);
-    const winner = sorted[0];
-    bindings[moniker] = winner.id;
-    selectedById.set(winner.id, winner);
-    for (const loser of sorted.slice(1)) {
+  }
+  return byMoniker;
+}
+function filterByConnection(group, connectionType, connectionName) {
+  const rejected = [];
+  const filtered = group.filter((descriptor) => {
+    const matches = descriptorMatchesConnectionType(descriptor, connectionType);
+    if (!matches) {
+      const types = descriptor.connectionTypes;
       rejected.push({
-        descriptor: loser,
-        reason: `tier ${loser.tier} lost to ${winner.id} (tier ${winner.tier}) for ${moniker}`
+        descriptor,
+        reason: `connection "${connectionName}" is type "${connectionType}" but descriptor supports [${types.join(", ")}]`
       });
     }
-  }
-  return { bindings, selectedById };
+    return matches;
+  });
+  return { filtered, rejected };
 }
 function reasonsFor(moniker, rejected, allCandidates) {
-  const candidatesForMoniker = allCandidates.filter((c) => c.satisfies.includes(moniker));
-  if (candidatesForMoniker.length === 0) return [];
-  return rejected.filter((r) => r.descriptor.satisfies.includes(moniker)).map((r) => `${r.descriptor.id}: ${r.reason}`);
-}
-function compareDescriptors(a, b) {
-  if (a.tier !== b.tier) return a.tier - b.tier;
-  const pa = a.priority ?? 0;
-  const pb = b.priority ?? 0;
-  if (pa !== pb) return pb - pa;
-  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-}
-function topoSort(descriptors, ctx) {
-  const byMoniker = /* @__PURE__ */ new Map();
-  for (const d of descriptors) for (const m of d.satisfies) byMoniker.set(m, d);
+  const candidatesForMoniker = allCandidates.filter((candidate) => candidate.satisfies.includes(moniker));
+  if (candidatesForMoniker.length === 0) {
+    return [];
+  }
+  return rejected.filter((rejection) => rejection.descriptor.satisfies.includes(moniker)).map((rejection) => `${rejection.descriptor.id}: ${rejection.reason}`);
+}
+function topoSort(descriptors, bindings, selectedById) {
+  const monikerToDescriptor = /* @__PURE__ */ new Map();
+  for (const [moniker, id] of Object.entries(bindings)) {
+    const descriptor = selectedById.get(id);
+    if (descriptor !== void 0) {
+      monikerToDescriptor.set(moniker, descriptor);
+    }
+  }
   const order = [];
   const seen = /* @__PURE__ */ new Set();
   const visiting = /* @__PURE__ */ new Set();
-  const visit = (d) => {
-    if (seen.has(d.id)) return;
-    if (visiting.has(d.id)) {
-      throw new Error(`Cycle detected through provider ${d.id}`);
-    }
-    visiting.add(d.id);
-    for (const moniker of d.satisfies) {
-      const cap = ctx.capabilities.tryGet(moniker);
-      if (!cap?.implies) continue;
-      for (const dep of cap.implies) {
-        const depDesc = byMoniker.get(dep);
-        if (depDesc) visit(depDesc);
+  const visit = (descriptor) => {
+    if (seen.has(descriptor.id)) {
+      return;
+    }
+    if (visiting.has(descriptor.id)) {
+      return;
+    }
+    visiting.add(descriptor.id);
+    for (const depMoniker of descriptor.dependencies ?? []) {
+      const depDescriptor = monikerToDescriptor.get(depMoniker);
+      if (depDescriptor !== void 0) {
+        visit(depDescriptor);
       }
     }
-    visiting.delete(d.id);
-    seen.add(d.id);
-    order.push(d);
+    visiting.delete(descriptor.id);
+    seen.add(descriptor.id);
+    order.push(descriptor);
   };
-  for (const d of descriptors) visit(d);
+  for (const descriptor of descriptors) {
+    visit(descriptor);
+  }
   return order;
 }
 
+// src/capabilities/locatorFromConfig.ts
+function resolveProvidersFromConfig(needs, candidates, config) {
+  const normalized = normalizeConnectionsConfig(config);
+  return resolveProviders(needs, candidates, {
+    connections: normalized.connections,
+    providerBindings: normalized.providerBindings
+  });
+}
+function registerFactoriesFromPlan(locator, plan) {
+  for (const descriptor of plan.selected) {
+    const { creatableProvider: creatableProvider2 } = descriptor;
+    const dependencies = [...descriptor.dependencies ?? creatableProvider2.dependencies];
+    locator.register(creatableProvider2.factory(dependencies, {}));
+  }
+}
+function locatorFromConfig(options) {
+  const normalized = normalizeConnectionsConfig(options.config);
+  const plan = resolveProvidersFromConfig(options.needs, options.candidates, normalized);
+  const locator = new ProviderFactoryLocator({
+    singletons: {},
+    caches: {},
+    ...options.context,
+    config: normalized
+  });
+  registerFactoriesFromPlan(locator, plan);
+  return locator;
+}
+
+// src/capabilities/needsFromProviderBindings.ts
+function needsFromProviderBindings(config) {
+  return new Set(Object.keys(config.providerBindings));
+}
+function needsFromConnectionTypes(config, connectionTypes) {
+  const allowed = new Set(connectionTypes);
+  const needs = /* @__PURE__ */ new Set();
+  for (const moniker of Object.keys(config.providerBindings)) {
+    const binding = config.providerBindings[moniker];
+    const connectionName = binding?.connection ?? binding?.transport;
+    if (connectionName === void 0 || connectionName === "") {
+      continue;
+    }
+    const connection = config.connections[connectionName];
+    if (connection !== void 0 && allowed.has(connection.type)) {
+      needs.add(moniker);
+    }
+  }
+  return needs;
+}
+
+// src/capabilities/providerCandidateFromClass.ts
+function providerCandidateFromClass(creatableProvider2, id = creatableProvider2.name) {
+  return {
+    connectionTypes: creatableProvider2.connectionTypes ?? [],
+    creatableProvider: creatableProvider2,
+    dependencies: creatableProvider2.dependencies,
+    id,
+    satisfies: creatableProvider2.monikers,
+    surface: creatableProvider2.surface ?? "node"
+  };
+}
+function providerCandidatesFromClasses(creatableProviders) {
+  return creatableProviders.map((provider) => providerCandidateFromClass(provider));
+}
+
 // src/config/Actor.ts
 import {
   zodAsFactory as zodAsFactory3,
@@ -1220,16 +1658,191 @@ var ChainConfigZod = z2.object({
   })
 });
 
+// src/config/transports/Transport.ts
+import { globalRegistry as globalRegistry4, z as z6 } from "zod";
+
+// src/config/Remote.ts
+import { globalRegistry as globalRegistry2, z as z3 } from "zod";
+var RpcRemoteConfigBaseZod = z3.object({
+  protocol: z3.string("http").register(globalRegistry2, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  })
+}).describe("Base configuration for the remote RPC");
+var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
+  protocol: z3.string("http").register(globalRegistry2, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  }).default("http"),
+  url: z3.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: z3.string().register(globalRegistry2, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  }).default("postMessage"),
+  networkId: z3.string().register(globalRegistry2, {
+    description: "Network ID to use for the postMessage RPC connection",
+    type: "string"
+  }),
+  sessionId: z3.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 = z3.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
+var RemoteConfigZod = z3.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
+
+// src/config/storage/driver/Mongo.ts
+import { isDefined as isDefined5, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
+import { globalRegistry as globalRegistry3, z as z4 } from "zod";
+var hasMongoConfig = (config) => {
+  if (isUndefined5(config)) return false;
+  return isDefined5(config.connectionString) && isDefined5(config.database) && isDefined5(config.domain);
+};
+var MongoConfigZod = z4.object({
+  // TODO: Create from other arguments
+  connectionString: z4.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB connection string",
+    title: "storage.mongo.connectionString",
+    type: "string"
+  }),
+  database: z4.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB database name",
+    title: "storage.mongo.database",
+    type: "string"
+  }),
+  domain: z4.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB domain",
+    title: "storage.mongo.domain",
+    type: "string"
+  }),
+  password: z4.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB password",
+    title: "storage.mongo.password",
+    type: "string"
+  }),
+  username: z4.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB username",
+    title: "storage.mongo.username",
+    type: "string"
+  })
+});
+
+// src/config/storage/driver/S3.ts
+import { isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { z as z5 } from "zod";
+var S3BucketConfigZod = z5.object({
+  accessKeyId: z5.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
+  accountId: z5.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
+  bucket: z5.string().nonempty().optional().describe("S3-compatible bucket name"),
+  prefix: z5.string().nonempty().optional().describe("Optional key prefix within the bucket"),
+  readUrl: z5.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
+  secretAccessKey: z5.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
+});
+var S3ConfigZod = z5.object({
+  accessKeyId: z5.string().nonempty().optional().describe("Shared S3-compatible access key id (default for all buckets)"),
+  accountId: z5.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: z5.string().nonempty().optional().describe("Shared key prefix (default for all buckets)"),
+  secretAccessKey: z5.string().nonempty().optional().describe("Shared S3-compatible secret access key (default for all buckets)")
+});
+function resolveS3Bucket(config, which) {
+  if (config === void 0) return void 0;
+  const entry = config[which];
+  const accessKeyId = entry?.accessKeyId ?? config.accessKeyId;
+  const accountId = entry?.accountId ?? config.accountId;
+  const secretAccessKey = entry?.secretAccessKey ?? config.secretAccessKey;
+  const bucket = entry?.bucket ?? config.finalized?.bucket;
+  if (!isDefined6(accessKeyId) || !isDefined6(accountId) || !isDefined6(secretAccessKey) || !isDefined6(bucket)) return void 0;
+  return {
+    accessKeyId,
+    accountId,
+    bucket,
+    prefix: entry?.prefix ?? config.prefix,
+    readUrl: entry?.readUrl,
+    secretAccessKey
+  };
+}
+function hasS3Config(config, which = "finalized") {
+  return resolveS3Bucket(config, which) !== void 0;
+}
+
+// src/config/transports/Transport.ts
+var LmdbTransportConfigZod = z6.object({
+  access: z6.enum(["read", "write"]).optional().register(globalRegistry4, {
+    description: "Access mode for this LMDB connection (read or write)",
+    title: "transports.lmdb.access",
+    type: "string"
+  }),
+  root: z6.string().register(globalRegistry4, {
+    description: "Root directory for local LMDB storage",
+    title: "transports.lmdb.root",
+    type: "string"
+  }),
+  store: z6.string().optional().register(globalRegistry4, {
+    description: "Logical store name within the LMDB root (e.g. finalized-chain, mempool)",
+    title: "transports.lmdb.store",
+    type: "string"
+  }),
+  type: z6.literal("lmdb")
+}).describe("LMDB local storage transport");
+var MongoTransportConfigZod = z6.object({
+  type: z6.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: z6.literal("rpc") }).describe("XL1 JSON-RPC transport");
+var RestTransportConfigZod = z6.object({
+  type: z6.literal("rest"),
+  baseUrl: z6.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: z6.literal("s3"),
+  accessKeyId: z6.string().optional(),
+  accountId: z6.string().optional(),
+  secretAccessKey: z6.string().optional()
+}).describe("S3-compatible object storage transport");
+var EvmRpcTransportConfigZod = z6.object({
+  type: z6.literal("evm-rpc"),
+  url: z6.string().register(globalRegistry4, {
+    description: "EVM JSON-RPC URL",
+    title: "transports.evm-rpc.url",
+    type: "string"
+  })
+}).describe("EVM JSON-RPC transport");
+var TransportConfigZod = z6.discriminatedUnion("type", [
+  LmdbTransportConfigZod,
+  MongoTransportConfigZod,
+  RpcTransportConfigZod,
+  RestTransportConfigZod,
+  S3TransportConfigZod,
+  EvmRpcTransportConfigZod
+]);
+var TransportsConfigZod = z6.record(z6.string(), TransportConfigZod).default({});
+
 // src/config/DataLake/DataLake.ts
-import { z as z6 } from "zod";
+import { z as z10 } from "zod";
 
 // src/config/DataLake/RestDataLakeConfig.ts
-import { globalRegistry as globalRegistry3, z as z4 } from "zod";
+import { globalRegistry as globalRegistry6, z as z8 } from "zod";
 
 // src/config/DataLake/DataLakeRemoteConfig.ts
-import { globalRegistry as globalRegistry2, z as z3 } from "zod";
-var DataLakeDriverConfigBaseZod = z3.object({
-  driver: z3.string().register(globalRegistry2, {
+import { globalRegistry as globalRegistry5, z as z7 } from "zod";
+var DataLakeDriverConfigBaseZod = z7.object({
+  driver: z7.string().register(globalRegistry5, {
     description: "Driver for the data lake",
     type: "string"
   })
@@ -1237,237 +1850,125 @@ var DataLakeDriverConfigBaseZod = z3.object({
 
 // src/config/DataLake/RestDataLakeConfig.ts
 var RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
-  driver: z4.literal("rest").register(globalRegistry3, {
+  driver: z8.literal("rest").register(globalRegistry6, {
     description: "Driver for the REST data lake",
     type: "string"
   }),
-  url: z4.string().register(globalRegistry3, {
+  url: z8.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 z5 } from "zod";
-var RouterDataLakeConfigZod = z5.object({
-  driver: z5.literal("router").register(globalRegistry4, {
+import { globalRegistry as globalRegistry7, z as z9 } from "zod";
+var RouterDataLakeConfigZod = z9.object({
+  driver: z9.literal("router").register(globalRegistry7, {
     description: "Driver for the router data lake",
     type: "string"
   }),
-  children: z5.array(z5.lazy(() => DataLakeConfigZod)).register(globalRegistry4, {
+  children: z9.array(z9.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 = z6.lazy(() => z6.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
+var DataLakeConfigZod = z10.lazy(() => z10.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
 
 // src/config/Evm.ts
-import { globalRegistry as globalRegistry5, z as z7 } from "zod";
-var EvmInfuraConfigZod = z7.object({
-  projectId: z7.string().optional().register(globalRegistry5, {
+import { globalRegistry as globalRegistry8, z as z11 } from "zod";
+var EvmInfuraConfigZod = z11.object({
+  projectId: z11.string().optional().register(globalRegistry8, {
     description: "Infura project ID",
     title: "evm.infura.projectId",
     type: "string"
   }),
-  projectSecret: z7.string().optional().register(globalRegistry5, {
+  projectSecret: z11.string().optional().register(globalRegistry8, {
     description: "Infura project secret",
     title: "evm.infura.projectSecret",
     type: "string"
   })
 });
-var EvmJsonRpcConfigZod = z7.object({
-  url: z7.url().optional().register(globalRegistry5, {
+var EvmJsonRpcConfigZod = z11.object({
+  url: z11.url().optional().register(globalRegistry8, {
     description: "JSON-RPC URL",
-    title: "evm.jsonRpc.url",
-    type: "string"
-  })
-});
-var EvmConfigZod = z7.object({
-  chainId: z7.string().optional().register(globalRegistry5, {
-    description: "EVM chain ID",
-    title: "evm.chainId",
-    type: "string"
-  }),
-  infura: EvmInfuraConfigZod.optional().describe("Infura Provider configuration"),
-  jsonRpc: EvmJsonRpcConfigZod.optional().describe("JSON-RPC Provider configuration")
-});
-
-// src/config/Log.ts
-import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry6, z as z8 } from "zod";
-var LogLevelNames = Object.keys(LogLevel);
-var LogConfigZod = z8.object({
-  logLevel: z8.enum(LogLevelNames).default("info").register(globalRegistry6, {
-    choices: LogLevelNames,
-    default: "info",
-    description: "Desired process verbosity",
-    title: "logLevel",
-    type: "string"
-  }),
-  silent: z8.boolean().default(false).register(globalRegistry6, {
-    default: false,
-    description: "Whether to run in silent mode",
-    title: "silent",
-    type: "boolean"
-  })
-});
-
-// src/config/ProviderBinding.ts
-import { globalRegistry as globalRegistry7, z as z9 } from "zod";
-var ProviderBindingConfigZod = z9.object({
-  implementation: z9.string().optional().register(globalRegistry7, {
-    description: "Installed provider implementation id (descriptor id)",
-    title: "providerBindings.implementation",
-    type: "string"
-  }),
-  transport: z9.string().optional().register(globalRegistry7, {
-    description: "Named transport from the top-level transports map",
-    title: "providerBindings.transport",
-    type: "string"
-  })
-}).describe("Provider implementation and transport binding");
-var ProviderBindingsConfigZod = z9.record(z9.string(), ProviderBindingConfigZod).default({});
-
-// src/config/Providers.ts
-import z11 from "zod";
-
-// src/config/Provider.ts
-import {
-  zodAsFactory as zodAsFactory2,
-  zodIsFactory,
-  zodToFactory
-} from "@xylabs/sdk-js";
-import { z as z10 } from "zod";
-var ProviderConfigZod = z10.object({
-  moniker: z10.string(),
-  labels: z10.array(z10.string()).optional()
-}).describe("Configuration for a Provider");
-var isProviderConfig = zodIsFactory(ProviderConfigZod);
-var asProviderConfig = zodAsFactory2(ProviderConfigZod, "asProviderConfig");
-var toProviderConfig = zodToFactory(ProviderConfigZod, "toProviderConfig");
-
-// src/config/Providers.ts
-var ProvidersConfigZod = z11.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
-
-// src/config/Remote.ts
-import { globalRegistry as globalRegistry8, z as z12 } from "zod";
-var RpcRemoteConfigBaseZod = z12.object({
-  protocol: z12.string("http").register(globalRegistry8, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  })
-}).describe("Base configuration for the remote RPC");
-var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z12.string("http").register(globalRegistry8, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("http"),
-  url: z12.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: z12.string().register(globalRegistry8, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("postMessage"),
-  networkId: z12.string().register(globalRegistry8, {
-    description: "Network ID to use for the postMessage RPC connection",
-    type: "string"
-  }),
-  sessionId: z12.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 = z12.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
-var RemoteConfigZod = z12.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
-
-// src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined4, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry9, z as z13 } from "zod";
-var hasMongoConfig = (config) => {
-  if (isUndefined5(config)) return false;
-  return isDefined4(config.connectionString) && isDefined4(config.database) && isDefined4(config.domain);
-};
-var MongoConfigZod = z13.object({
-  // TODO: Create from other arguments
-  connectionString: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB connection string",
-    title: "storage.mongo.connectionString",
+    title: "evm.jsonRpc.url",
     type: "string"
-  }),
-  database: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB database name",
-    title: "storage.mongo.database",
+  })
+});
+var EvmConfigZod = z11.object({
+  chainId: z11.string().optional().register(globalRegistry8, {
+    description: "EVM chain ID",
+    title: "evm.chainId",
     type: "string"
   }),
-  domain: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB domain",
-    title: "storage.mongo.domain",
+  infura: EvmInfuraConfigZod.optional().describe("Infura Provider configuration"),
+  jsonRpc: EvmJsonRpcConfigZod.optional().describe("JSON-RPC Provider configuration")
+});
+
+// src/config/Log.ts
+import { LogLevel } from "@xylabs/sdk-js";
+import { globalRegistry as globalRegistry9, z as z12 } from "zod";
+var LogLevelNames = Object.keys(LogLevel);
+var LogConfigZod = z12.object({
+  logLevel: z12.enum(LogLevelNames).default("info").register(globalRegistry9, {
+    choices: LogLevelNames,
+    default: "info",
+    description: "Desired process verbosity",
+    title: "logLevel",
     type: "string"
   }),
-  password: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB password",
-    title: "storage.mongo.password",
+  silent: z12.boolean().default(false).register(globalRegistry9, {
+    default: false,
+    description: "Whether to run in silent mode",
+    title: "silent",
+    type: "boolean"
+  })
+});
+
+// src/config/ProviderBinding.ts
+import { globalRegistry as globalRegistry10, z as z13 } from "zod";
+var ProviderBindingConfigZod = z13.object({
+  connection: z13.string().optional().register(globalRegistry10, {
+    description: "Named connection from the top-level connections map",
+    title: "providerBindings.connection",
     type: "string"
   }),
-  username: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB username",
-    title: "storage.mongo.username",
+  transport: z13.string().optional().register(globalRegistry10, {
+    description: "Deprecated alias for connection (kept in sync during migration)",
+    title: "providerBindings.transport",
     type: "string"
   })
-});
+}).describe("Provider connection binding");
+var ProviderBindingsConfigZod = z13.record(z13.string(), ProviderBindingConfigZod).default({});
 
-// src/config/storage/driver/S3.ts
-import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+// src/config/Providers.ts
+import z15 from "zod";
+
+// src/config/Provider.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk-js";
 import { z as z14 } from "zod";
-var S3BucketConfigZod = z14.object({
-  accessKeyId: z14.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
-  accountId: z14.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
-  bucket: z14.string().nonempty().optional().describe("S3-compatible bucket name"),
-  prefix: z14.string().nonempty().optional().describe("Optional key prefix within the bucket"),
-  readUrl: z14.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
-  secretAccessKey: z14.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
-});
-var S3ConfigZod = z14.object({
-  accessKeyId: z14.string().nonempty().optional().describe("Shared S3-compatible access key id (default for all buckets)"),
-  accountId: z14.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: z14.string().nonempty().optional().describe("Shared key prefix (default for all buckets)"),
-  secretAccessKey: z14.string().nonempty().optional().describe("Shared S3-compatible secret access key (default for all buckets)")
-});
-function resolveS3Bucket(config, which) {
-  if (config === void 0) return void 0;
-  const entry = config[which];
-  const accessKeyId = entry?.accessKeyId ?? config.accessKeyId;
-  const accountId = entry?.accountId ?? config.accountId;
-  const secretAccessKey = entry?.secretAccessKey ?? config.secretAccessKey;
-  const bucket = entry?.bucket ?? config.finalized?.bucket;
-  if (!isDefined5(accessKeyId) || !isDefined5(accountId) || !isDefined5(secretAccessKey) || !isDefined5(bucket)) return void 0;
-  return {
-    accessKeyId,
-    accountId,
-    bucket,
-    prefix: entry?.prefix ?? config.prefix,
-    readUrl: entry?.readUrl,
-    secretAccessKey
-  };
-}
-function hasS3Config(config, which = "finalized") {
-  return resolveS3Bucket(config, which) !== void 0;
-}
+var ProviderConfigZod = z14.object({
+  moniker: z14.string(),
+  labels: z14.array(z14.string()).optional()
+}).describe("Configuration for a Provider");
+var isProviderConfig = zodIsFactory(ProviderConfigZod);
+var asProviderConfig = zodAsFactory2(ProviderConfigZod, "asProviderConfig");
+var toProviderConfig = zodToFactory(ProviderConfigZod, "toProviderConfig");
+
+// src/config/Providers.ts
+var ProvidersConfigZod = z15.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
 
 // src/config/storage/Storage.ts
-import { globalRegistry as globalRegistry10, z as z15 } from "zod";
-var StorageConfigZod = z15.object({
+import { globalRegistry as globalRegistry11, z as z16 } from "zod";
+var StorageConfigZod = z16.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z15.string().optional().register(globalRegistry10, {
+  root: z16.string().optional().register(globalRegistry11, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -1476,7 +1977,7 @@ var StorageConfigZod = z15.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry11, z as z16 } from "zod";
+import { globalRegistry as globalRegistry12, z as z17 } from "zod";
 var DefaultMetricsScrapePorts = {
   api: 9465,
   bridge: 9468,
@@ -1484,86 +1985,35 @@ var DefaultMetricsScrapePorts = {
   producer: 9464,
   rewardRedemptionApi: 9467
 };
-var MetricsScrapeConfigZod = z16.object({
-  path: z16.string().default("/metrics").register(globalRegistry11, {
+var MetricsScrapeConfigZod = z17.object({
+  path: z17.string().default("/metrics").register(globalRegistry12, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z16.coerce.number().int().positive().optional().register(globalRegistry11, {
+  port: z17.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 = z16.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z16.object({
+var MetricsConfigZod = z17.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z17.object({
   // OpenTelemetry options
-  otlpEndpoint: z16.url().optional().register(globalRegistry11, {
+  otlpEndpoint: z17.url().optional().register(globalRegistry12, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z16.object({
+var TelemetryConfigZod = z17.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 z17 } from "zod";
-var LmdbTransportConfigZod = z17.object({
-  type: z17.literal("lmdb"),
-  root: z17.string().register(globalRegistry12, {
-    description: "Root directory for local LMDB storage",
-    title: "transports.lmdb.root",
-    type: "string"
-  })
-}).describe("LMDB local storage transport");
-var MongoTransportConfigZod = z17.object({
-  type: z17.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: z17.literal("rpc") }).describe("XL1 JSON-RPC transport");
-var RestTransportConfigZod = z17.object({
-  type: z17.literal("rest"),
-  baseUrl: z17.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: z17.literal("s3"),
-  accessKeyId: z17.string().optional(),
-  accountId: z17.string().optional(),
-  secretAccessKey: z17.string().optional()
-}).describe("S3-compatible object storage transport");
-var EvmRpcTransportConfigZod = z17.object({
-  type: z17.literal("evm-rpc"),
-  url: z17.string().register(globalRegistry12, {
-    description: "EVM JSON-RPC URL",
-    title: "transports.evm-rpc.url",
-    type: "string"
-  })
-}).describe("EVM JSON-RPC transport");
-var TransportConfigZod = z17.discriminatedUnion("type", [
-  LmdbTransportConfigZod,
-  MongoTransportConfigZod,
-  RpcTransportConfigZod,
-  RestTransportConfigZod,
-  S3TransportConfigZod,
-  EvmRpcTransportConfigZod
-]);
-var TransportsConfigZod = z17.record(z17.string(), TransportConfigZod).default({});
-
 // src/config/Validation.ts
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-js";
 import { globalRegistry as globalRegistry13, z as z18 } from "zod";
@@ -1587,11 +2037,11 @@ function blockRangeSteps(range, steps) {
 }
 
 // src/primitives/block/rate/blockRate.ts
-import { isDefined as isDefined7, isFalsy } from "@xylabs/sdk-js";
+import { isDefined as isDefined8, isFalsy } from "@xylabs/sdk-js";
 import { asXL1BlockRange } from "@xyo-network/xl1-protocol-lib";
 
 // src/primitives/block/rate/timeHelpers.ts
-import { assertEx as assertEx8, isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, isDefined as isDefined7 } from "@xylabs/sdk-js";
 var rateMultipliers = {
   millis: 1,
   seconds: 1e3,
@@ -1609,7 +2059,7 @@ var timeDurations = (timeInMs) => ({
   weeks: timeInMs / (1e3 * 60 * 60 * 24 * 7)
 });
 var getTimeConfigInMilliseconds = (timeConfig) => {
-  const assertedTimeConfig = assertEx8(isDefined6(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
+  const assertedTimeConfig = assertEx10(isDefined7(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
   let totalMilliseconds = 0;
   if ("years" in assertedTimeConfig) {
     totalMilliseconds += assertedTimeConfig.years * 31536e6;
@@ -1648,13 +2098,13 @@ var blockRate = (startBlock, endBlock, timeUnit) => {
     throw new Error("Time difference must be greater than 0");
   }
   const rate = heightDifference / timeDifference;
-  const timeUnitValue = isDefined7(timeUnit) ? timeUnit : "millis";
-  const returnedTimeDifference = isDefined7(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
+  const timeUnitValue = isDefined8(timeUnit) ? timeUnit : "millis";
+  const returnedTimeDifference = isDefined8(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
   const timePerBlock = returnedTimeDifference / heightDifference;
   return {
     range: asXL1BlockRange([startingBlock.block, endingBlock.block], true),
     span: heightDifference,
-    rate: isDefined7(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
+    rate: isDefined8(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
     timeUnit: timeUnitValue,
     timeDifference: returnedTimeDifference,
     timePerBlock
@@ -1682,7 +2132,7 @@ var calculateBlockRate = async (viewer, range, timeUnit) => {
 };
 
 // src/primitives/block/rate/stepRate.ts
-import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
 import {
   asXL1BlockRange as asXL1BlockRange2,
   isValidStep,
@@ -1694,28 +2144,28 @@ var stepRate = async (viewer, start, step, count = 1, timeUnit) => {
   return await calculateBlockRate(viewer, range, timeUnit);
 };
 var calculateStepSizeRate = async (viewer, start, stepIndex, count = 1, timeUnit) => {
-  assertEx9(isValidStep(stepIndex), () => `Invalid step index: ${stepIndex}`);
+  assertEx11(isValidStep(stepIndex), () => `Invalid step index: ${stepIndex}`);
   const step = StepSizes4[stepIndex];
   return await stepRate(viewer, start, step, count, timeUnit);
 };
 
 // src/primitives/block/rate/timeRate.ts
 import {
-  assertEx as assertEx10,
-  isDefined as isDefined8,
+  assertEx as assertEx12,
+  isDefined as isDefined9,
   isDefinedNotNull
 } from "@xylabs/sdk-js";
 import { asXL1BlockNumber as asXL1BlockNumber3, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol-lib";
 var DEFAULT_TOLERANCE_MS = 3e4;
 var DEFAULT_MAX_ATTEMPTS = 10;
 var calculateTimeRate = async (viewer, timeConfig, startBlockNumber, timeUnit, toleranceMs = DEFAULT_TOLERANCE_MS, maxAttempts = DEFAULT_MAX_ATTEMPTS) => {
-  assertEx10(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
+  assertEx12(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
   const startBlock = isDefinedNotNull(startBlockNumber) ? await viewer.blockByNumber(startBlockNumber) : null;
   const currentBlockResult = await viewer.currentBlock();
   const blockResult = isDefinedNotNull(startBlock) ? startBlock : currentBlockResult;
   const resolvedStartBlock = blockResult[0];
   const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig);
-  assertEx10(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
+  assertEx12(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
   const blocksPerMillisecondRate = 1 / (12 * 1e3);
   const initialBlocksInDuration = Math.floor(blocksPerMillisecondRate * timeInMilliseconds);
   const endBlockNumber = await findEndBlockRecursive(
@@ -1733,15 +2183,15 @@ var calculateTimeRate = async (viewer, timeConfig, startBlockNumber, timeUnit, t
   );
 };
 var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBlocksBack, toleranceMs, attemptsRemaining) => {
-  assertEx10(attemptsRemaining >= 0, () => "Maximum attempts reached while searching for end block");
+  assertEx12(attemptsRemaining >= 0, () => "Maximum attempts reached while searching for end block");
   const startBlockEpoch = startBlock.$epoch;
   const estimatedEndBlockNumber = asXL1BlockNumber3(startBlock.block - estimatedBlocksBack, true);
   if (estimatedEndBlockNumber < 0) {
     throw new Error("Estimated end block number is less than zero");
   }
   const endBlock = await viewer.blockByNumber(estimatedEndBlockNumber);
-  const resolvedEndBlock = assertEx10(
-    isDefined8(endBlock?.[0]) ? endBlock[0] : void 0,
+  const resolvedEndBlock = assertEx12(
+    isDefined9(endBlock?.[0]) ? endBlock[0] : void 0,
     () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
   );
   const endBlockEpoch = resolvedEndBlock.$epoch;
@@ -1777,8 +2227,8 @@ var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBl
 
 // src/primitives/chain/getWindowedChain.ts
 import {
-  assertEx as assertEx11,
-  isDefined as isDefined9,
+  assertEx as assertEx13,
+  isDefined as isDefined10,
   isNull,
   spanRootAsync
 } from "@xylabs/sdk-js";
@@ -1792,14 +2242,14 @@ async function getWindowedChain(context, blockViewer, maxWindowSize, previousCha
     while (currentBlock !== null && newChain.length < maxWindowSize) {
       const currentBlockNumber = currentBlock[0].block;
       const nextBlock = newChain[0];
-      if (isDefined9(nextBlock)) {
+      if (isDefined10(nextBlock)) {
         const nextBlockNumber = nextBlock[0].block;
-        assertEx11(
+        assertEx13(
           currentBlockNumber === nextBlockNumber - 1,
           () => `[getWindowedChain] Non-monotonic block sequence detected: current=${currentBlockNumber}, next=${nextBlockNumber}`
         );
       }
-      assertEx11(
+      assertEx13(
         currentBlockNumber <= head[0].block,
         () => `[getWindowedChain] Current block number (${currentBlockNumber}) exceeds head block number (${head[0].block})`
       );
@@ -1813,7 +2263,7 @@ async function getWindowedChain(context, blockViewer, maxWindowSize, previousCha
 }
 
 // src/primitives/chain/step/chainStepRewardAddress.ts
-import { assertEx as assertEx14, exists } from "@xylabs/sdk-js";
+import { assertEx as assertEx16, exists } from "@xylabs/sdk-js";
 import { toXyoAddress as toXyoAddress2 } from "@xyo-network/sdk-js";
 import {
   asTransfer,
@@ -1845,7 +2295,7 @@ function stepBlockRange({ block, step }) {
 }
 
 // src/primitives/step/stepTransferIndex.ts
-import { assertEx as assertEx12 } from "@xylabs/sdk-js";
+import { assertEx as assertEx14 } from "@xylabs/sdk-js";
 import { StepSizes as StepSizes6 } from "@xyo-network/xl1-protocol-lib";
 function stepTransferIndex(block, step) {
   let rewardTransferCount = 0;
@@ -1859,16 +2309,16 @@ function stepTransferIndex(block, step) {
       rewardTransferCount++;
     }
   }
-  assertEx12(rewardTransferIndex >= 0, () => `Could not find step size for step ${step} at block ${block}`);
+  assertEx14(rewardTransferIndex >= 0, () => `Could not find step size for step ${step} at block ${block}`);
   return [rewardTransferIndex, rewardTransferCount];
 }
 
 // src/primitives/chain/step/stepRewardBlock.ts
-import { assertEx as assertEx13 } from "@xylabs/sdk-js";
+import { assertEx as assertEx15 } from "@xylabs/sdk-js";
 import { StepSizes as StepSizes7 } from "@xyo-network/xl1-protocol-lib";
 async function stepRewardBlock(context, blockViewer, { block, step }) {
-  assertEx13(block % StepSizes7[step] === 0, () => `Block must be the first block of the step [${StepSizes7[step]}], got ${block}`);
-  return assertEx13(await blockViewer.blockByNumber(block), () => `Could not find block for block number ${block}`);
+  assertEx15(block % StepSizes7[step] === 0, () => `Block must be the first block of the step [${StepSizes7[step]}], got ${block}`);
+  return assertEx15(await blockViewer.blockByNumber(block), () => `Could not find block for block number ${block}`);
 }
 
 // src/primitives/chain/step/chainStepRewardAddress.ts
@@ -1881,7 +2331,7 @@ async function chainStepRewardAddress(context, blockViewer, { block, step }) {
   const rewardEntry = Object.entries(mergedTransfers).find(([address]) => address === XYO_STEP_REWARD_ADDRESS);
   const fromEntries = Object.entries(rewardEntry?.[1] ?? {});
   const sortedTransferAmounts = fromEntries.toSorted(([, a], [, b]) => a > b ? -1 : a < b ? 1 : 0);
-  assertEx14(
+  assertEx16(
     sortedTransferAmounts.length === transferCount,
     () => `Step Transfers mismatch ${block} (${blockBw._hash}) [${sortedTransferAmounts.length} - ${transferCount}]`
   );
@@ -1889,7 +2339,7 @@ async function chainStepRewardAddress(context, blockViewer, { block, step }) {
 }
 
 // src/primitives/chain/step/stepRewardTotal.ts
-import { assertEx as assertEx15, isDefined as isDefined10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx17, isDefined as isDefined11 } from "@xylabs/sdk-js";
 import {
   asAttoXL1,
   asXL1BlockRange as asXL1BlockRange5,
@@ -1982,18 +2432,18 @@ function stepInRange(step, range) {
   return stepRange[0] >= range[0] && stepRange[1] <= range[1];
 }
 async function stepRewardTotal(context, blockViewer, { block, step }, multipliers) {
-  const cacheKey = `${block}|${step}|${isDefined10(multipliers)}`;
+  const cacheKey = `${block}|${step}|${isDefined11(multipliers)}`;
   return await withContextCacheResponse(context, "stepRewardTotal", cacheKey, async () => {
     const [blockBw, payloads] = await stepRewardBlock(context, blockViewer, { block, step });
-    assertEx15(blockBw.block === block, () => `Block Mismatch: expected ${block}, got ${blockBw.block}`);
+    assertEx17(blockBw.block === block, () => `Block Mismatch: expected ${block}, got ${blockBw.block}`);
     const [transferIndex] = stepTransferIndex(block, step);
-    const stepTransfer = assertEx15(
+    const stepTransfer = assertEx17(
       payloads.find((p) => isTransfer5(p) && p.from === XYO_STEP_REWARD_ADDRESS2),
       () => `No step transfer found for step ${step} at block ${block} (${blockBw._hash})`
     );
     const netTransfers = netTransfersForPayloads(context, [stepTransfer]);
     const rewardEntry = Object.entries(netTransfers).find(([address]) => address === XYO_STEP_REWARD_ADDRESS2);
-    const rewards = assertEx15(
+    const rewards = assertEx17(
       rewardEntry?.[1],
       () => `No rewards found for step reward address ${XYO_STEP_REWARD_ADDRESS2} at block ${block} (${blockBw._hash})`
     );
@@ -2036,7 +2486,7 @@ async function stepsRewardTotal(context, blockViewer, steps, multipliers) {
 }
 
 // src/primitives/chain/time/externalBlockNumberFromXl1BlockNumber.ts
-import { assertEx as assertEx16, isArray } from "@xylabs/sdk-js";
+import { assertEx as assertEx18, isArray } from "@xylabs/sdk-js";
 import {
   asBlockNumber,
   asTimePayload,
@@ -2047,7 +2497,7 @@ async function externalBlockNumberFromXL1BlockNumber(context, blockViewer, xl1Bl
   const cacheKey = `${xl1BlockNumber}-${externalTimeName}-${externalGenesisTime ?? "default"}`;
   return await withContextCacheResponse(context, functionName, cacheKey, async () => {
     const [, payloads = []] = await blockViewer.blockByNumber(xl1BlockNumber) ?? [];
-    assertEx16(isArray(payloads));
+    assertEx18(isArray(payloads));
     const timePayload = asTimePayload(payloads.find(isTimePayload));
     return asBlockNumber(
       timePayload?.[externalTimeName] ?? externalGenesisTime ?? 23372716,
@@ -2073,7 +2523,7 @@ async function externalBlockRangeFromStep(context, blockViewer, stepIdentity) {
 }
 
 // src/primitives/mapToMapType.ts
-import { isDefined as isDefined11 } from "@xylabs/sdk-js";
+import { isDefined as isDefined12 } from "@xylabs/sdk-js";
 function mapToMapType(map) {
   return {
     get: (key) => map.get(key),
@@ -2092,7 +2542,7 @@ function mapToMapType(map) {
       const result = [];
       for (const key of keys) {
         const value = map.get(key);
-        if (isDefined11(value)) {
+        if (isDefined12(value)) {
           result.push(value);
         }
       }
@@ -2107,7 +2557,7 @@ function mapToMapType(map) {
 }
 
 // src/primitives/readPayloadMapFromStore.ts
-import { isDefined as isDefined12 } from "@xylabs/sdk-js";
+import { isDefined as isDefined13 } from "@xylabs/sdk-js";
 function readPayloadMapFromStore(store) {
   if (isReadArchivist(store)) {
     return {
@@ -2120,7 +2570,7 @@ function readPayloadMapFromStore(store) {
       },
       has: async (hash) => {
         const results = await store.get([hash]);
-        return isDefined12(results[0]);
+        return isDefined13(results[0]);
       }
     };
   }
@@ -2138,7 +2588,7 @@ function payloadMapFromStore(store) {
       },
       has: async (hash) => {
         const results = await store.get([hash]);
-        return isDefined12(results[0]);
+        return isDefined13(results[0]);
       },
       clear: async () => {
         return await store.clear();
@@ -2184,7 +2634,7 @@ function rewardFromBlockNumber(blockNumber) {
 import { XYO_NETWORK_STAKING_ADDRESS } from "@xyo-network/xl1-protocol-lib";
 
 // src/primitives/stake/activeStakeAtTimeByAddress.ts
-import { isDefined as isDefined13 } from "@xylabs/sdk-js";
+import { isDefined as isDefined14 } from "@xylabs/sdk-js";
 
 // src/primitives/stake/mergedAddRemoveStakeEventsByStaker.ts
 async function mergedAddRemoveStakeEventsByStaker(chainEvents, range, staked, staker) {
@@ -2204,7 +2654,7 @@ async function activeStakeAtTimeByAddress(chain, staked, time, staker) {
   for (const event of stakeEvents) {
     if (event.time > time) break;
     if (event.args.staked !== staked) continue;
-    if (isDefined13(staker) && event.args.staker !== staker) continue;
+    if (isDefined14(staker) && event.args.staker !== staker) continue;
     if (event.name === "StakeAdded") {
       result += event.args.amount;
     } else if (event.name === "StakeRemoved") {
@@ -2278,20 +2728,20 @@ async function allStakersForStep(context, blockViewer, stakeEventsViewer, stepCo
 }
 
 // src/primitives/stake/weightedStakeForRangeByPosition.ts
-import { isDefined as isDefined14 } from "@xylabs/sdk-js";
+import { isDefined as isDefined15 } from "@xylabs/sdk-js";
 import { asBlockNumber as asBlockNumber2 } from "@xyo-network/xl1-protocol-lib";
 async function weightedStakeForRangeByPosition(context, blockViewer, stakeEventsViewer, externalRange, staked, positionId) {
-  const cacheKey = isDefined14(positionId) ? `${externalRange[0]}-${externalRange[1]}-${positionId}` : `${externalRange[0]}-${externalRange[1]}-all`;
+  const cacheKey = isDefined15(positionId) ? `${externalRange[0]}-${externalRange[1]}-${positionId}` : `${externalRange[0]}-${externalRange[1]}-all`;
   return await withContextCacheResponse(context, "weightedStakeForRangeByPosition", cacheKey, async () => {
     let weightedStakeSum = 0n;
-    if (isDefined14(positionId)) {
+    if (isDefined15(positionId)) {
       const mergedEventsResult = await mergedAddRemoveStakeEventsByPosition(
         stakeEventsViewer,
         [0, externalRange[1]],
         positionId
       );
       const mergedEvents = mergedEventsResult.toSorted((a, b) => a.time - b.time);
-      if (isDefined14(staked) && mergedEvents.at(0)?.args.staked !== staked) {
+      if (isDefined15(staked) && mergedEvents.at(0)?.args.staked !== staked) {
         return 0n;
       }
       let currentTime = externalRange[0];
@@ -2364,7 +2814,7 @@ var findMostRecentBlock = async (chainArchivist, nextOptions = DEFAULT_NEXT_OPTI
 };
 
 // src/primitives/state/hydratedBlockByNumber.ts
-import { assertEx as assertEx17, spanAsync as spanAsync2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx19, spanAsync as spanAsync2 } from "@xylabs/sdk-js";
 async function hydratedBlockByNumber(context, blockNumber) {
   return await spanAsync2("hydratedBlockByNumber", async () => {
     if (blockNumber < 0) throw new Error(`Block number ${blockNumber} is less than 0`);
@@ -2372,7 +2822,7 @@ async function hydratedBlockByNumber(context, blockNumber) {
     if (blockNumber % 1 !== 0) throw new Error(`Block number ${blockNumber} is not an integer`);
     const cacheKey = String(blockNumber);
     return await withContextCacheResponse(context, "hydratedBlockByNumber", cacheKey, async () => {
-      const block = assertEx17(
+      const block = assertEx19(
         await blockFromBlockNumber(context, blockNumber),
         () => `Could not find block for block number ${blockNumber}`
       );
@@ -2423,7 +2873,7 @@ function findBestUncle(finalizedWindowedChain, uncles, options) {
 
 // src/primitives/uncle/findUncles.ts
 import {
-  assertEx as assertEx18,
+  assertEx as assertEx20,
   exists as exists2
 } from "@xylabs/sdk-js";
 import { isTransactionBoundWitness as isTransactionBoundWitness2 } from "@xyo-network/xl1-protocol-lib";
@@ -2456,7 +2906,7 @@ function blocksToChains(blocks) {
 }
 function toValidUncle(_context, finalizedWindowedChain, possibleUncle) {
   const finalizedWindowStartBlockNumber = finalizedWindowedChain.at(0)?.[0].block ?? -1;
-  const finalizedHead = assertEx18(finalizedWindowedChain.at(-1), () => "finalizedWindowedChain is empty");
+  const finalizedHead = assertEx20(finalizedWindowedChain.at(-1), () => "finalizedWindowedChain is empty");
   const prunedPossibleUncle = possibleUncle.filter((b) => b[0].block > finalizedHead[0].block);
   if (prunedPossibleUncle.length === 0) {
     return;
@@ -2515,10 +2965,11 @@ var BaseConfigZod = z19.object({
   dataLake: z19.optional(DataLakeConfigZod).check(z19.describe("Configuration for data lakes")),
   evm: z19._default(EvmConfigZod, EvmConfigZod.parse({})).check(z19.describe("Configuration for EVM-backed services")),
   log: z19._default(LogConfigZod, LogConfigZod.parse({})).check(z19.describe("Configuration for logging")),
-  providerBindings: z19._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z19.describe("Per-moniker provider implementation and transport bindings")),
+  connections: z19._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z19.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
+  providerBindings: z19._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z19.describe("Per-moniker provider connection bindings")),
   providers: z19._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z19.describe("Configuration for providers")),
   remote: z19._default(RemoteConfigZod, RemoteConfigZod.parse({})).check(z19.describe("Configuration for remote services")),
-  transports: z19._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z19.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
+  transports: z19._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z19.describe("Deprecated alias for connections (kept in sync during migration)")),
   storage: z19._default(StorageConfigZod, StorageConfigZod.parse({})).check(z19.describe("Configuration for the storage")),
   telemetry: z19._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z19.describe("Configuration for telemetry")),
   validation: z19._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z19.describe("Configuration for validation"))
@@ -2549,7 +3000,7 @@ var ActorsConfigZod = z21._default(
 );
 
 // src/config/adaptLegacyConfig.ts
-import { isDefined as isDefined15 } from "@xylabs/sdk-js";
+import { isDefined as isDefined16 } from "@xylabs/sdk-js";
 
 // src/config/Config.ts
 import { globalRegistry as globalRegistry15, z as z22 } from "zod/mini";
@@ -2597,7 +3048,7 @@ function rpcTransportFromRemote(rpc) {
   };
 }
 function s3TransportFromBucket(shared, entry, fallbackBucket) {
-  if (!isDefined15(entry?.bucket) && !isDefined15(entry?.readUrl)) {
+  if (!isDefined16(entry?.bucket) && !isDefined16(entry?.readUrl)) {
     return void 0;
   }
   return {
@@ -2636,34 +3087,105 @@ function synthesizeS3Transports(s3) {
 function hasTransport(transports, key) {
   return Object.hasOwn(transports, key) && transports[key] !== void 0;
 }
+function bindMoniker2(bindings, moniker, connectionName) {
+  bindings[moniker] = { connection: connectionName, transport: connectionName };
+}
+var LMDB_MONIKERS = [
+  "AccountBalanceViewer",
+  "BlockRewardViewer",
+  "BlockRunner",
+  "BlockValidationViewer",
+  "BlockViewer",
+  "ChainContractViewer",
+  "DeadLetterQueueRunner",
+  "DeadLetterQueueViewer",
+  "FinalizationRunner",
+  "FinalizationViewer",
+  "MempoolRunner",
+  "MempoolViewer",
+  "NetworkStakeViewer",
+  "NetworkStakeStepRewardsByPositionViewer",
+  "NetworkStakeStepRewardsByStakerViewer",
+  "NetworkStakeStepRewardsByStepViewer",
+  "NetworkStakeStepRewardsTotalViewer",
+  "NetworkStakeStepRewardsViewer",
+  "StakeEventsViewer",
+  "StakeTotalsViewer",
+  "StakeViewer",
+  "StepViewer",
+  "TimeSyncViewer",
+  "TransactionValidationViewer",
+  "TransactionViewer",
+  "WindowedBlockViewer",
+  "XyoConnection",
+  "XyoGateway",
+  "XyoRunner",
+  "XyoViewer"
+];
+var RPC_MONIKERS = [
+  "AccountBalanceViewer",
+  "BlockRewardViewer",
+  "BlockViewer",
+  "FinalizationViewer",
+  "MempoolRunner",
+  "MempoolViewer",
+  "NetworkStakeViewer",
+  "NetworkStakeStepRewardsByPositionViewer",
+  "NetworkStakeStepRewardsByStakerViewer",
+  "NetworkStakeStepRewardsByStepViewer",
+  "NetworkStakeStepRewardsTotalViewer",
+  "NetworkStakeStepRewardsViewer",
+  "StakeEventsViewer",
+  "StakeViewer",
+  "StepViewer",
+  "TimeSyncViewer",
+  "TransactionViewer",
+  "WindowedBlockViewer",
+  "XyoViewer"
+];
+function synthesizeLmdbProviderBindings(transports) {
+  const bindings = {};
+  if (!hasTransport(transports, DEFAULT_LMDB_TRANSPORT)) {
+    return bindings;
+  }
+  for (const moniker of LMDB_MONIKERS) {
+    bindMoniker2(bindings, moniker, DEFAULT_LMDB_TRANSPORT);
+  }
+  return bindings;
+}
 function synthesizeProviderBindings(transports) {
   const bindings = {};
   if (hasTransport(transports, DEFAULT_RPC_TRANSPORT)) {
-    bindings.BlockViewer = { transport: DEFAULT_RPC_TRANSPORT };
-    bindings.MempoolViewer = { transport: DEFAULT_RPC_TRANSPORT };
-    bindings.FinalizationViewer = { transport: DEFAULT_RPC_TRANSPORT };
-    bindings.TransactionViewer = { transport: DEFAULT_RPC_TRANSPORT };
-    bindings.AccountBalanceViewer = { transport: DEFAULT_RPC_TRANSPORT };
+    for (const moniker of RPC_MONIKERS) {
+      bindMoniker2(bindings, moniker, DEFAULT_RPC_TRANSPORT);
+    }
   }
   if (hasTransport(transports, S3_FINALIZED_TRANSPORT)) {
-    bindings.BlockPublishRunner = { transport: S3_FINALIZED_TRANSPORT };
+    bindMoniker2(bindings, "BlockPublishRunner", S3_FINALIZED_TRANSPORT);
   }
   if (hasTransport(transports, S3_CHAIN_STATE_TRANSPORT)) {
-    bindings.ChainStateViewer = { transport: S3_CHAIN_STATE_TRANSPORT };
-    bindings.ChainStatePublishRunner = { transport: S3_CHAIN_STATE_TRANSPORT };
+    bindMoniker2(bindings, "ChainStateViewer", S3_CHAIN_STATE_TRANSPORT);
+    bindMoniker2(bindings, "ChainStatePublishRunner", S3_CHAIN_STATE_TRANSPORT);
   }
   if (hasTransport(transports, S3_INDEX_TRANSPORT)) {
-    bindings.IndexPublishRunner = { transport: S3_INDEX_TRANSPORT };
+    bindMoniker2(bindings, "IndexPublishRunner", S3_INDEX_TRANSPORT);
+  }
+  if (hasTransport(transports, DEFAULT_EVM_RPC_TRANSPORT)) {
+    bindMoniker2(bindings, "ChainContractViewer", DEFAULT_EVM_RPC_TRANSPORT);
+    bindMoniker2(bindings, "StakeEventsViewer", DEFAULT_EVM_RPC_TRANSPORT);
+    bindMoniker2(bindings, "StakeTotalsViewer", DEFAULT_EVM_RPC_TRANSPORT);
+    bindMoniker2(bindings, "StakeViewer", DEFAULT_EVM_RPC_TRANSPORT);
+    bindMoniker2(bindings, "TimeSyncViewer", DEFAULT_EVM_RPC_TRANSPORT);
   }
   return bindings;
 }
 function adaptLegacyConfig(config) {
   const parsed = ConfigZod.parse(config);
-  if (Object.keys(parsed.transports).length > 0) {
-    return parsed;
+  if (hasDeclaredConnectionProfiles(parsed)) {
+    return ConfigZod.parse(normalizeConnectionsConfig(parsed));
   }
-  const transports = { ...parsed.transports };
-  if (isDefined15(parsed.storage?.root) && parsed.storage.root !== "") {
+  const transports = { ...parsed.transports, ...parsed.connections };
+  if (isDefined16(parsed.storage?.root) && parsed.storage.root !== "") {
     transports[DEFAULT_LMDB_TRANSPORT] = { type: "lmdb", root: parsed.storage.root };
   }
   if (hasMongoConfig(parsed.storage?.mongo)) {
@@ -2676,24 +3198,26 @@ function adaptLegacyConfig(config) {
       username: parsed.storage.mongo.username
     };
   }
-  if (isDefined15(parsed.remote?.rpc)) {
+  if (isDefined16(parsed.remote?.rpc)) {
     transports[DEFAULT_RPC_TRANSPORT] = rpcTransportFromRemote(parsed.remote.rpc);
   }
-  if (isDefined15(parsed.evm?.jsonRpc?.url)) {
+  if (isDefined16(parsed.evm?.jsonRpc?.url)) {
     transports[DEFAULT_EVM_RPC_TRANSPORT] = { type: "evm-rpc", url: parsed.evm.jsonRpc.url };
   }
-  if (isDefined15(parsed.storage?.s3)) {
+  if (isDefined16(parsed.storage?.s3)) {
     Object.assign(transports, synthesizeS3Transports(parsed.storage.s3));
   }
   const providerBindings = {
+    ...synthesizeLmdbProviderBindings(transports),
     ...synthesizeProviderBindings(transports),
     ...parsed.providerBindings
   };
-  return ConfigZod.parse({
+  return ConfigZod.parse(normalizeConnectionsConfig({
     ...parsed,
+    connections: transports,
     providerBindings,
     transports
-  });
+  }));
 }
 
 // src/config/HostActor.ts
@@ -2827,7 +3351,7 @@ import { PayloadBundleSchema as PayloadBundleSchema2 } from "@xyo-network/sdk-js
 import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/sdk-js";
 
 // src/transaction/buildTransaction.ts
-import { assertEx as assertEx19, toHex } from "@xylabs/sdk-js";
+import { assertEx as assertEx21, toHex } from "@xylabs/sdk-js";
 import {
   asAnyPayload as asAnyPayload2,
   BoundWitnessBuilder,
@@ -2853,7 +3377,7 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
   const script = Array.from(elevatedHashes, (elevatedHash) => `elevate|${elevatedHash}`);
   const fields = {
     ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx19(signer.at(0)?.address) : signer.address)
+    from: from ?? (Array.isArray(signer) ? assertEx21(signer.at(0)?.address) : signer.address)
   };
   if (script.length > 0) {
     fields.script = script;
@@ -2898,7 +3422,7 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
 // src/transaction/confirmSubmittedTransaction.ts
 import {
   delay,
-  isDefined as isDefined16,
+  isDefined as isDefined17,
   isNumber
 } from "@xylabs/sdk-js";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
@@ -2920,7 +3444,7 @@ var confirmSubmittedTransaction = async (viewer, txHash, options) => {
   let attempts = 0;
   while (true) {
     const tx = await viewer.transaction.byHash(txHash) ?? void 0;
-    if (isDefined16(tx)) {
+    if (isDefined17(tx)) {
       options?.logger?.debug("Transaction confirmed", txHash);
       return tx;
     }
@@ -2938,7 +3462,7 @@ var confirmSubmittedTransaction = async (viewer, txHash, options) => {
 };
 
 // src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx20 } from "@xylabs/sdk-js";
+import { assertEx as assertEx22 } from "@xylabs/sdk-js";
 import {
   asAnyPayload as asAnyPayload3,
   hydrateTypedBoundWitness,
@@ -3009,7 +3533,7 @@ var tryHydrateElevatedTransaction = async ({ chainMap }, hash) => {
   return void 0;
 };
 var hydrateElevatedTransaction = async (context, hash) => {
-  return assertEx20(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
+  return assertEx22(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
 };
 
 // src/transaction/primitives/transactionBlockByteCount.ts
@@ -3062,13 +3586,13 @@ function transactionRequiredGas(hydratedTransaction) {
 
 // src/transaction/signTransaction.ts
 import {
-  assertEx as assertEx21,
+  assertEx as assertEx23,
   hexFromArrayBuffer,
   toArrayBuffer
 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/sdk-js";
 async function signTransaction(tx, account) {
-  assertEx21(tx.from === account.address, () => "Signer address does not match transaction from address");
+  assertEx23(tx.from === account.address, () => "Signer address does not match transaction from address");
   const unsignedTx = structuredClone(tx);
   unsignedTx.addresses = [account.address];
   unsignedTx.previous_hashes = [account.previousHash ?? null];
@@ -3083,7 +3607,7 @@ async function signTransaction(tx, account) {
 }
 
 // src/transaction/TransactionBuilder.ts
-import { assertEx as assertEx22, Base } from "@xylabs/sdk-js";
+import { assertEx as assertEx24, Base } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
 import {
   asXL1BlockNumber as asXL1BlockNumber4,
@@ -3103,9 +3627,9 @@ var TransactionBuilder = class extends Base {
     super(options);
   }
   async build() {
-    const chain = assertEx22(this._chain, () => "Chain must be set before building the transaction");
-    const fees = assertEx22(this._fees, () => "Fees must be set before building the transaction");
-    const blockRange = assertEx22(this._blockRange, () => "Block range must be set before building the transaction");
+    const chain = assertEx24(this._chain, () => "Chain must be set before building the transaction");
+    const fees = assertEx24(this._fees, () => "Fees must be set before building the transaction");
+    const blockRange = assertEx24(this._blockRange, () => "Block range must be set before building the transaction");
     return await buildTransaction(
       chain,
       this._elevatedPayloads,
@@ -3135,7 +3659,7 @@ var TransactionBuilder = class extends Base {
   }
   elevatedPayload(payload) {
     const allowedPayload = isAllowedBlockPayload2(payload) ? payload : void 0;
-    const allowPayloadExists = assertEx22(allowedPayload, () => "Payload must be an AllowedBlockPayload");
+    const allowPayloadExists = assertEx24(allowedPayload, () => "Payload must be an AllowedBlockPayload");
     this._elevatedPayloads.push(allowPayloadExists);
     return this;
   }
@@ -3184,158 +3708,64 @@ var TransactionBuilder = class extends Base {
   async removeElevatedPayload(payload) {
     const hash = await PayloadBuilder11.hash(payload);
     const existingHashes = await PayloadBuilder11.hashes(this._elevatedPayloads);
-    const existingPayloadIndex = existingHashes.indexOf(hash);
-    if (existingPayloadIndex === -1) {
-      throw new Error("Payload not found in the transaction");
-    }
-    this._elevatedPayloads = this._elevatedPayloads.filter((_, index) => index !== existingPayloadIndex);
-    return this;
-  }
-  async removePayload(payload) {
-    const hash = await PayloadBuilder11.hash(payload);
-    const existingHashes = await PayloadBuilder11.hashes(this._payloads);
-    const existingPayloadIndex = existingHashes.indexOf(hash);
-    if (existingPayloadIndex === -1) {
-      throw new Error("Payload not found in the transaction");
-    }
-    this._payloads = this._payloads.filter((_, index) => index !== existingPayloadIndex);
-    return this;
-  }
-  signer(signer) {
-    if (signer) {
-      this._signers.push(signer);
-    }
-    return this;
-  }
-  signers(signers) {
-    if (signers)
-      for (const signer of signers) {
-        if (signer !== null) {
-          this.signer(signer);
-        }
-      }
-    return this;
-  }
-};
-
-// src/model/PayloadBundle/hydratedTransactionToPayloadBundle.ts
-var hydratedTransactionToPayloadBundle = (transaction) => {
-  const root = transaction[0]._hash;
-  return bundle2(root, transaction);
-};
-var bundle2 = (root, transaction) => {
-  const payloads = flattenHydratedTransaction(transaction);
-  const payloadBuilder = new PayloadBuilder12({ schema: PayloadBundleSchema2 });
-  const builder = payloadBuilder.fields({ payloads, root });
-  return builder.build();
-};
-
-// src/context/Actor.ts
-var ActorConfigContext = z26.extend(BaseConfigContextZod, { config: ActorConfigZod });
-var isActorConfigContext = zodIsFactory5(ActorConfigContext);
-var asActorConfigContext = zodAsFactory6(ActorConfigContext, "asActorConfigContext");
-var toActorConfigContext = zodToFactory5(ActorConfigContext, "toActorConfigContext");
-
-// src/CreatableProvider/AbstractCreatableProvider.ts
-import {
-  AbstractCreatable,
-  assertEx as assertEx24,
-  IdLogger
-} from "@xylabs/sdk-js";
-
-// src/CreatableProvider/ProviderFactory.ts
-import { assertEx as assertEx23 } from "@xylabs/sdk-js";
-function providerFactoryDescription(factory, labels) {
-  return `${factory.providerName}:${factory.defaultMoniker}:${JSON.stringify(labels ?? factory.labels ?? {})}`;
-}
-var ProviderFactory = class _ProviderFactory {
-  creatableProvider;
-  defaultMoniker;
-  defaultParams;
-  dependencies;
-  labels;
-  monikers;
-  providerName;
-  scope;
-  _uniqueId;
-  constructor(creatableProvider2, dependencies, params, labels = {}, scope = "context") {
-    this.creatableProvider = creatableProvider2;
-    this.defaultParams = params;
-    this.defaultMoniker = creatableProvider2.defaultMoniker;
-    this.dependencies = dependencies;
-    this.monikers = creatableProvider2.monikers;
-    this.scope = scope;
-    assertEx23(this.monikers.includes(this.defaultMoniker), () => "defaultMoniker must be in monikers");
-    this.labels = Object.assign({}, creatableProvider2.labels ?? {}, labels ?? {});
-    this.providerName = creatableProvider2.name;
-    this._uniqueId = Symbol(providerFactoryDescription(this));
-  }
-  get resolvedMoniker() {
-    const labels = this.labels ?? {};
-    const labelString = Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(",");
-    return labelString.length === 0 ? this.defaultMoniker : `${this.defaultMoniker}|${labelString}`;
-  }
-  get uniqueId() {
-    return this._uniqueId;
-  }
-  static withParams(creatableProvider2, dependencies, params, labels = {}) {
-    return new _ProviderFactory(creatableProvider2, dependencies, params, labels);
-  }
-  factory(dependencies, params, labels = {}) {
-    return new _ProviderFactory(this.creatableProvider, dependencies, params, labels);
-  }
-  async getInstance(params, { start = true }) {
-    let scopeObject;
-    switch (this.scope) {
-      case "global": {
-        scopeObject = getOrCreateGlobalSingletons();
-        break;
-      }
-      case "context": {
-        const context = assertEx23(
-          params?.context,
-          () => "Context is required for context-scoped providers"
-        );
-        context.singletons ??= {};
-        scopeObject = context.singletons;
-        break;
-      }
-      default: {
-        scopeObject = {};
-        break;
-      }
-    }
-    const mergedParams = {
-      ...this.defaultParams,
-      ...params
-    };
-    const resultPromise = scopeObject[this.resolvedMoniker] ?? this.creatableProvider.create(mergedParams);
-    scopeObject[this.resolvedMoniker] = resultPromise;
-    const result = await resultPromise;
-    if (start) {
-      assertEx23(await result.start(), () => `Failed to start provider instance [${this.resolvedMoniker}]`);
+    const existingPayloadIndex = existingHashes.indexOf(hash);
+    if (existingPayloadIndex === -1) {
+      throw new Error("Payload not found in the transaction");
     }
-    return result;
+    this._elevatedPayloads = this._elevatedPayloads.filter((_, index) => index !== existingPayloadIndex);
+    return this;
   }
-  async tryGetInstance(params, options) {
-    try {
-      return await this.getInstance(params, options);
-    } catch {
-      return;
+  async removePayload(payload) {
+    const hash = await PayloadBuilder11.hash(payload);
+    const existingHashes = await PayloadBuilder11.hashes(this._payloads);
+    const existingPayloadIndex = existingHashes.indexOf(hash);
+    if (existingPayloadIndex === -1) {
+      throw new Error("Payload not found in the transaction");
     }
+    this._payloads = this._payloads.filter((_, index) => index !== existingPayloadIndex);
+    return this;
   }
-};
-function getOrCreateGlobalSingletons() {
-  const existing = globalThis.xyoServiceSingletons;
-  if (existing !== void 0) {
-    return existing;
+  signer(signer) {
+    if (signer) {
+      this._signers.push(signer);
+    }
+    return this;
   }
-  const singletons = {};
-  Reflect.set(globalThis, "xyoServiceSingletons", singletons);
-  return singletons;
-}
+  signers(signers) {
+    if (signers)
+      for (const signer of signers) {
+        if (signer !== null) {
+          this.signer(signer);
+        }
+      }
+    return this;
+  }
+};
+
+// src/model/PayloadBundle/hydratedTransactionToPayloadBundle.ts
+var hydratedTransactionToPayloadBundle = (transaction) => {
+  const root = transaction[0]._hash;
+  return bundle2(root, transaction);
+};
+var bundle2 = (root, transaction) => {
+  const payloads = flattenHydratedTransaction(transaction);
+  const payloadBuilder = new PayloadBuilder12({ schema: PayloadBundleSchema2 });
+  const builder = payloadBuilder.fields({ payloads, root });
+  return builder.build();
+};
+
+// src/context/Actor.ts
+var ActorConfigContext = z26.extend(BaseConfigContextZod, { config: ActorConfigZod });
+var isActorConfigContext = zodIsFactory5(ActorConfigContext);
+var asActorConfigContext = zodAsFactory6(ActorConfigContext, "asActorConfigContext");
+var toActorConfigContext = zodToFactory5(ActorConfigContext, "toActorConfigContext");
 
 // src/CreatableProvider/AbstractCreatableProvider.ts
+import {
+  AbstractCreatable,
+  assertEx as assertEx25,
+  IdLogger
+} from "@xylabs/sdk-js";
 var AbstractCreatableProvider = class extends AbstractCreatable {
   dependencies = {};
   _contextCache;
@@ -3367,9 +3797,9 @@ var AbstractCreatableProvider = class extends AbstractCreatable {
     return factory;
   }
   static async paramsHandler(params = {}) {
-    const context = assertEx24(params.context, () => new Error("Context is required"));
-    const config = assertEx24(context.config, () => new Error("Context config is required"));
-    const locator = assertEx24(context.locator, () => new Error("Context locator is required"));
+    const context = assertEx25(params.context, () => new Error("Context is required"));
+    const config = assertEx25(context.config, () => new Error("Context config is required"));
+    const locator = assertEx25(context.locator, () => new Error("Context locator is required"));
     return await super.paramsHandler({
       ...params,
       statusReporter: params.statusReporter ?? context.statusReporter,
@@ -3411,203 +3841,6 @@ function labeledCreatableProvider() {
   };
 }
 
-// src/CreatableProvider/CreatableProviderRegistry.ts
-import { isTruthy } from "@xylabs/sdk-js";
-var buildProviderFactory = (provider, defaultParams, labels) => {
-  const factory = {
-    monikers: provider.monikers,
-    uniqueId: Symbol(providerFactoryDescription(provider, labels)),
-    // Merge module & supplied labels
-    labels: { ...provider.labels, ...labels },
-    creatableProvider: provider.creatableProvider,
-    dependencies: provider.dependencies,
-    resolvedMoniker: provider.resolvedMoniker,
-    providerName: provider.providerName,
-    scope: provider.scope,
-    defaultParams,
-    getInstance: provider.getInstance.bind(provider),
-    tryGetInstance: provider.tryGetInstance?.bind(provider),
-    defaultMoniker: provider.defaultMoniker,
-    factory: provider.factory.bind(provider)
-  };
-  return factory;
-};
-var registerCreatableProviderFactory = (registry, factory, labels, primary = false) => {
-  const primaryMonikers = primary !== true && isTruthy(primary) ? Array.isArray(primary) ? primary : [primary] : [];
-  for (const primaryMoniker of primaryMonikers) {
-    if (!factory.monikers.includes(primaryMoniker)) {
-      throw new Error(`Primary moniker ${String(primaryMoniker)} not found in factory monikers`);
-    }
-  }
-  const isPrimaryForMoniker = (moniker) => {
-    switch (typeof primary) {
-      case "boolean": {
-        return primary;
-      }
-      case "string": {
-        return moniker === primary;
-      }
-      case "object": {
-        if (Array.isArray(primary)) {
-          return primary.includes(moniker);
-        }
-      }
-    }
-    throw new Error(`Invalid primary value: ${String(primary)}`);
-  };
-  const factoryClone = buildProviderFactory(factory, factory.defaultParams, labels);
-  registry[factoryClone.defaultMoniker] = [factoryClone, ...registry[factoryClone.defaultMoniker] ?? []];
-  for (const moniker of factoryClone.monikers) {
-    if (moniker === factoryClone.defaultMoniker) continue;
-    registry[moniker] = isPrimaryForMoniker(moniker) ? [factoryClone, ...registry[moniker] ?? []] : [...registry[moniker] ?? [], factoryClone];
-  }
-};
-var registerCreatableProviderFactories = (factories, registry = {}, primary = false) => {
-  for (const factory of factories) {
-    registerCreatableProviderFactory(registry, factory, void 0, primary);
-  }
-  return registry;
-};
-
-// src/CreatableProvider/LabeledCreatableProviderFactory.ts
-var hasLabels = (factory) => {
-  return factory.labels !== void 0;
-};
-function labeledCreatableProviderFactory() {
-  return (constructor) => {
-    constructor;
-  };
-}
-
-// src/CreatableProvider/ProviderFactoryLocator.ts
-import { hasAllLabels } from "@xylabs/sdk-js";
-import { assertEx as assertEx25 } from "@xylabs/sdk-js";
-var ProviderFactoryLocator = class _ProviderFactoryLocator {
-  _context;
-  _registry;
-  _frozen = false;
-  _parent;
-  _validateDepsOnRegister;
-  constructor(context, registry = {}, validateDepsOnRegister = false) {
-    this._registry = registry;
-    this._context = { ...context, locator: this };
-    this._parent = context.locator;
-    this._validateDepsOnRegister = validateDepsOnRegister;
-  }
-  get context() {
-    return this._context;
-  }
-  get logger() {
-    return this.context.logger;
-  }
-  /**
-   * The current registry for the module factory
-   */
-  get registry() {
-    return this._registry;
-  }
-  get validateDepsOnRegister() {
-    return this._validateDepsOnRegister;
-  }
-  freeze() {
-    this._frozen = true;
-  }
-  async getInstance(moniker, { start = true, labels } = {}) {
-    return assertEx25(
-      await this.tryGetInstance(moniker, { start, labels }),
-      () => `No provider instance for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} could be created`
-    );
-  }
-  has(moniker) {
-    return Object.hasOwn(this._registry, moniker);
-  }
-  /**
-   * Locates a provider factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the provider
-   * @param labels The labels for the provider factory
-   * @returns A provider factory that matches the supplied moniker and labels or throws if one is not found
-   */
-  locate(moniker, labels) {
-    return assertEx25(
-      this.tryLocate(moniker, labels),
-      () => `No module factory for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} registered`
-    );
-  }
-  merge(locator) {
-    const registry = { ...this.registry };
-    for (const moniker in locator.registry) {
-      const existing = registry[moniker];
-      if (existing === void 0) {
-        registry[moniker] = locator.registry[moniker];
-      } else {
-        existing.push(...locator.registry[moniker] ?? []);
-      }
-    }
-    return new _ProviderFactoryLocator(this.context, registry);
-  }
-  /**
-   * Registers a single module factory (with optional tags) with the locator
-   * @param factory The factory to register
-   * @param labels The labels for the module factory
-   */
-  register(factory, labels, primary = false) {
-    assertEx25(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
-    if (this.validateDepsOnRegister) {
-      const missingDeps = factory.dependencies.filter((dep) => !this.registered(dep));
-      assertEx25(missingDeps.length === 0, () => `Cannot register module factory [${factory.uniqueId.description}] due to missing dependencies: ${missingDeps.join(", ")}`);
-    }
-    registerCreatableProviderFactory(this._registry, factory, labels, primary);
-    return this;
-  }
-  /**
-   * Registers multiple module factories with the locator
-   * @param factories The factories to register
-   */
-  registerMany(factories) {
-    for (const factory of factories) {
-      this.register(factory);
-    }
-    return this;
-  }
-  registered(moniker) {
-    return Object.hasOwn(this.registry, moniker) || (this._parent?.registered(moniker) ?? false);
-  }
-  async tryGetInstance(moniker, { start = true, labels } = {}) {
-    const resolvedParams = { context: this.context };
-    const factory = this.tryLocate(moniker, labels);
-    if (factory !== void 0) {
-      if (Object.hasOwn(this.context.singletons, factory.uniqueId)) {
-        return this.context.singletons[factory.uniqueId];
-      }
-      this.logger?.debug(`Creating provider instance for moniker [${moniker}]${labels ? ` with labels [${JSON.stringify(labels)}]` : ""} using factory [${factory.uniqueId.description}]`);
-      const result = await factory.getInstance(resolvedParams, { start });
-      this.context.singletons[factory.uniqueId] = result;
-      return result;
-    }
-  }
-  /**
-   * Tries to locate a module factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied moniker and labels or undefined
-   */
-  tryLocate(moniker, labels) {
-    const result = (labels ? this._registry[moniker]?.filter(hasLabels).find((factory) => hasAllLabels(factory?.labels, labels)) ?? this._registry[moniker]?.[0] : this._registry[moniker]?.[0]) ?? this._parent?.tryLocate(moniker, labels);
-    return result;
-  }
-  validateDependencies(recursive = false) {
-    if (recursive) {
-      this._parent?.validateDependencies();
-    }
-    for (const moniker in this.registry) {
-      for (const factory of this.registry[moniker] ?? []) {
-        const missingDeps = factory.dependencies.filter((dep) => !this.registered(dep));
-        assertEx25(missingDeps.length === 0, () => `Module factory [${factory.uniqueId.description}] is missing dependencies: ${missingDeps.join(", ")}`);
-      }
-    }
-  }
-};
-
 // src/context/getEmptyProviderContext.ts
 function getEmptyProviderContext(config) {
   const singletons = {};
@@ -3637,13 +3870,13 @@ var asHostActorConfigContext = zodAsFactory7(HostActorConfigContext, "asHostActo
 var toHostActorConfigContext = zodToFactory6(HostActorConfigContext, "toHostActorConfigContext");
 
 // src/createDeclarationPayload.ts
-import { isDefined as isDefined17 } from "@xylabs/sdk-js";
+import { isDefined as isDefined18 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/sdk-js";
 import {
   ChainStakeIntentSchema
 } from "@xyo-network/xl1-protocol-lib";
 var createDeclarationIntent = (address, intent, nbf, exp) => {
-  const expiration = isDefined17(exp) ? exp : nbf + 1e4;
+  const expiration = isDefined18(exp) ? exp : nbf + 1e4;
   const payloadBuilder = new PayloadBuilder13({ schema: ChainStakeIntentSchema });
   const builder = payloadBuilder.fields({
     from: address,
@@ -3827,7 +4060,7 @@ import {
   asHash as asHash4,
   assertEx as assertEx33,
   exists as exists3,
-  isDefined as isDefined18,
+  isDefined as isDefined19,
   ZERO_ADDRESS
 } from "@xylabs/sdk-js";
 import {
@@ -4326,7 +4559,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
             block[1].find((p) => p._hash === hash),
             () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`
           );
-        }).filter(exists3).filter((t) => t.from === address || isDefined18(t.transfers[address]));
+        }).filter(exists3).filter((t) => t.from === address || isDefined19(t.transfers[address]));
         if (transfers.length === 0) {
           continue;
         }
@@ -4445,7 +4678,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
     return await this.spanAsync("qualifiedAccountBalanceHistory", async () => {
       const range = asRange(headOrRange);
       const headHash = asHash4(headOrRange);
-      const [head] = assertEx33(isDefined18(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
+      const [head] = assertEx33(isDefined19(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
       const startingRange = asXL1BlockRange10(range ?? [0, head.block], true);
       const blockNumbers = await this.distillTransferHistory(address, startingRange);
       const blockResults = await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)));
@@ -4459,7 +4692,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
             block[1].find((p) => p._hash === hash),
             () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`
           );
-        }).filter(exists3).filter((t) => t.from === address || isDefined18(t.transfers[address]));
+        }).filter(exists3).filter((t) => t.from === address || isDefined19(t.transfers[address]));
         if (transfers.length === 0) {
           continue;
         }
@@ -4476,9 +4709,11 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
     }, this.context);
   }
 };
+__publicField(SimpleAccountBalanceViewer, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleAccountBalanceViewer, "defaultMoniker", AccountBalanceViewerMoniker);
 __publicField(SimpleAccountBalanceViewer, "dependencies", [BlockViewerMoniker]);
 __publicField(SimpleAccountBalanceViewer, "monikers", [AccountBalanceViewerMoniker]);
+__publicField(SimpleAccountBalanceViewer, "surface", "node");
 SimpleAccountBalanceViewer = __decorateClass([
   creatableProvider()
 ], SimpleAccountBalanceViewer);
@@ -4776,9 +5011,11 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
     this._headPollTimer = null;
   }
 };
+__publicField(SimpleBlockViewer, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleBlockViewer, "defaultMoniker", BlockViewerMoniker2);
 __publicField(SimpleBlockViewer, "dependencies", [FinalizationViewerMoniker]);
 __publicField(SimpleBlockViewer, "monikers", [BlockViewerMoniker2]);
+__publicField(SimpleBlockViewer, "surface", "node");
 SimpleBlockViewer = __decorateClass([
   creatableProvider()
 ], SimpleBlockViewer);
@@ -4793,9 +5030,11 @@ var SimpleBlockRewardViewer = class extends AbstractCreatableProvider {
     );
   }
 };
+__publicField(SimpleBlockRewardViewer, "connectionTypes", ["lmdb", "mongo", "rpc"]);
 __publicField(SimpleBlockRewardViewer, "defaultMoniker", BlockRewardViewerMoniker);
 __publicField(SimpleBlockRewardViewer, "dependencies", []);
 __publicField(SimpleBlockRewardViewer, "monikers", [BlockRewardViewerMoniker]);
+__publicField(SimpleBlockRewardViewer, "surface", "node");
 SimpleBlockRewardViewer = __decorateClass([
   creatableProvider()
 ], SimpleBlockRewardViewer);
@@ -4935,9 +5174,11 @@ var SimpleBlockValidationViewer = class extends AbstractCreatableProvider {
     return [...this._uncleWindowedChainCache];
   }
 };
+__publicField(SimpleBlockValidationViewer, "connectionTypes", ["lmdb", "mongo", "rpc"]);
 __publicField(SimpleBlockValidationViewer, "defaultMoniker", BlockValidationViewerMoniker);
 __publicField(SimpleBlockValidationViewer, "dependencies", [AccountBalanceViewerMoniker2, BlockViewerMoniker3, ChainContractViewerMoniker]);
 __publicField(SimpleBlockValidationViewer, "monikers", [BlockValidationViewerMoniker]);
+__publicField(SimpleBlockValidationViewer, "surface", "node");
 SimpleBlockValidationViewer = __decorateClass([
   creatableProvider()
 ], SimpleBlockValidationViewer);
@@ -4993,9 +5234,11 @@ var SimpleChainContractViewer = class extends AbstractCreatableProvider {
     return this.params.stakingTokenAddress;
   }
 };
+__publicField(SimpleChainContractViewer, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleChainContractViewer, "defaultMoniker", ChainContractViewerMoniker2);
 __publicField(SimpleChainContractViewer, "dependencies", [FinalizationViewerMoniker2]);
 __publicField(SimpleChainContractViewer, "monikers", [ChainContractViewerMoniker2]);
+__publicField(SimpleChainContractViewer, "surface", "node");
 SimpleChainContractViewer = __decorateClass([
   creatableProvider()
 ], SimpleChainContractViewer);
@@ -5096,9 +5339,11 @@ var RestDataLakeRunner = class extends AbstractRestDataLake {
     return [];
   }
 };
+__publicField(RestDataLakeRunner, "connectionTypes", ["rest"]);
 __publicField(RestDataLakeRunner, "defaultMoniker", DataLakeRunnerMoniker);
 __publicField(RestDataLakeRunner, "dependencies", []);
 __publicField(RestDataLakeRunner, "monikers", [DataLakeRunnerMoniker]);
+__publicField(RestDataLakeRunner, "surface", "node");
 RestDataLakeRunner = __decorateClass([
   creatableProvider()
 ], RestDataLakeRunner);
@@ -5108,9 +5353,11 @@ import { DataLakeViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 var RestDataLakeViewer = class extends AbstractRestDataLake {
   moniker = RestDataLakeViewer.defaultMoniker;
 };
+__publicField(RestDataLakeViewer, "connectionTypes", ["rest"]);
 __publicField(RestDataLakeViewer, "defaultMoniker", DataLakeViewerMoniker);
 __publicField(RestDataLakeViewer, "dependencies", []);
 __publicField(RestDataLakeViewer, "monikers", [DataLakeViewerMoniker]);
+__publicField(RestDataLakeViewer, "surface", "node");
 RestDataLakeViewer = __decorateClass([
   creatableProvider()
 ], RestDataLakeViewer);
@@ -5179,9 +5426,11 @@ var SimpleDataLakeRunner = class extends AbstractSimpleDataLake {
     return hashPairs.map(([payload]) => payload);
   }
 };
+__publicField(SimpleDataLakeRunner, "connectionTypes", []);
 __publicField(SimpleDataLakeRunner, "defaultMoniker", DataLakeRunnerMoniker2);
 __publicField(SimpleDataLakeRunner, "dependencies", []);
 __publicField(SimpleDataLakeRunner, "monikers", [DataLakeRunnerMoniker2]);
+__publicField(SimpleDataLakeRunner, "surface", "node");
 SimpleDataLakeRunner = __decorateClass([
   creatableProvider()
 ], SimpleDataLakeRunner);
@@ -5191,9 +5440,11 @@ import { DataLakeViewerMoniker as DataLakeViewerMoniker2 } from "@xyo-network/xl
 var SimpleDataLakeViewer = class extends AbstractSimpleDataLake {
   moniker = SimpleDataLakeViewer.defaultMoniker;
 };
+__publicField(SimpleDataLakeViewer, "connectionTypes", []);
 __publicField(SimpleDataLakeViewer, "defaultMoniker", DataLakeViewerMoniker2);
 __publicField(SimpleDataLakeViewer, "dependencies", []);
 __publicField(SimpleDataLakeViewer, "monikers", [DataLakeViewerMoniker2]);
+__publicField(SimpleDataLakeViewer, "surface", "node");
 SimpleDataLakeViewer = __decorateClass([
   creatableProvider()
 ], SimpleDataLakeViewer);
@@ -5221,9 +5472,11 @@ var SimpleFinalizationRunner = class extends AbstractCreatableProvider {
     return sortedBlocks.map((b) => b[0]._hash);
   }
 };
+__publicField(SimpleFinalizationRunner, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleFinalizationRunner, "defaultMoniker", FinalizationRunnerMoniker);
 __publicField(SimpleFinalizationRunner, "dependencies", []);
 __publicField(SimpleFinalizationRunner, "monikers", [FinalizationRunnerMoniker]);
+__publicField(SimpleFinalizationRunner, "surface", "node");
 SimpleFinalizationRunner = __decorateClass([
   creatableProvider()
 ], SimpleFinalizationRunner);
@@ -5313,9 +5566,11 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
     return result;
   }
 };
+__publicField(SimpleFinalizationViewer, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleFinalizationViewer, "defaultMoniker", FinalizationViewerMoniker3);
 __publicField(SimpleFinalizationViewer, "dependencies", [ChainContractViewerMoniker3]);
 __publicField(SimpleFinalizationViewer, "monikers", [FinalizationViewerMoniker3]);
+__publicField(SimpleFinalizationViewer, "surface", "node");
 SimpleFinalizationViewer = __decorateClass([
   creatableProvider()
 ], SimpleFinalizationViewer);
@@ -5341,7 +5596,7 @@ var SimpleXyoGateway = class _SimpleXyoGateway extends AbstractCreatableProvider
 import {
   assertEx as assertEx39,
   BigIntToJsonZod,
-  isDefined as isDefined19
+  isDefined as isDefined20
 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder20 } from "@xyo-network/sdk-js";
 import {
@@ -5379,9 +5634,9 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
       chain,
       fees
     } = options ?? {};
-    const resolvedChainId = isDefined19(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = asXL1BlockNumber10(isDefined19(nbf) ? nbf : await viewer.currentBlockNumber(), true);
-    const resolvedExp = asXL1BlockNumber10(isDefined19(exp) ? exp : resolvedNbf + 10, true);
+    const resolvedChainId = isDefined20(chain) ? chain : await viewer.chainId();
+    const resolvedNbf = asXL1BlockNumber10(isDefined20(nbf) ? nbf : await viewer.currentBlockNumber(), true);
+    const resolvedExp = asXL1BlockNumber10(isDefined20(exp) ? exp : resolvedNbf + 10, true);
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await this.signer.address(), fees);
     return await this.addTransactionToChain(tx, await PayloadBuilder20.addHashMeta(offChain));
   }
@@ -5863,9 +6118,11 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     this.logger?.debug(`Synced ${externalTxs.length} transactions from external mempool`);
   }
 };
+__publicField(SimpleMempoolRunner, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleMempoolRunner, "defaultMoniker", MempoolRunnerMoniker);
 __publicField(SimpleMempoolRunner, "dependencies", [FinalizationViewerMoniker4, BlockValidationViewerMoniker2, TransactionValidationViewerMoniker, ChainContractViewerMoniker4]);
 __publicField(SimpleMempoolRunner, "monikers", [MempoolRunnerMoniker]);
+__publicField(SimpleMempoolRunner, "surface", "node");
 SimpleMempoolRunner = __decorateClass([
   creatableProvider()
 ], SimpleMempoolRunner);
@@ -5873,7 +6130,7 @@ SimpleMempoolRunner = __decorateClass([
 // src/simple/mempool/SimpleMempoolViewer.ts
 import {
   exists as exists9,
-  isDefined as isDefined20,
+  isDefined as isDefined21,
   isHash as isHash2
 } from "@xylabs/sdk-js";
 import { isHashMeta as isHashMeta2, isPayloadBundle as isPayloadBundle2 } from "@xyo-network/sdk-js";
@@ -5934,7 +6191,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     let cursor = void 0;
     if (isHash2(providedCursor)) {
       const [p] = await this.pendingBlocksArchivist.get([providedCursor]);
-      if (isDefined20(p)) {
+      if (isDefined21(p)) {
         cursor = p._sequence;
       }
     }
@@ -5954,7 +6211,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     let cursor = void 0;
     if (isHash2(providedCursor)) {
       const [p] = await this.pendingTransactionsArchivist.get([providedCursor]);
-      if (isDefined20(p)) {
+      if (isDefined21(p)) {
         cursor = p._sequence;
       }
     }
@@ -6027,7 +6284,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     const hydratedResults = await Promise.all(
       filteredBundles.map(async (bundle3) => {
         const tx = await bundledPayloadToHydratedTransaction(bundle3);
-        return isDefined20(tx) ? { bundle: bundle3, tx } : void 0;
+        return isDefined21(tx) ? { bundle: bundle3, tx } : void 0;
       })
     );
     return hydratedResults.filter(exists9);
@@ -6080,9 +6337,11 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     return deduplicateWithBundleBySigner(randomSelected).slice(0, effectiveLimit);
   }
 };
+__publicField(SimpleMempoolViewer, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleMempoolViewer, "defaultMoniker", MempoolViewerMoniker2);
 __publicField(SimpleMempoolViewer, "dependencies", [WindowedBlockViewerMoniker]);
 __publicField(SimpleMempoolViewer, "monikers", [MempoolViewerMoniker2]);
+__publicField(SimpleMempoolViewer, "surface", "node");
 SimpleMempoolViewer = __decorateClass([
   creatableProvider()
 ], SimpleMempoolViewer);
@@ -6271,9 +6530,11 @@ var SimpleXyoRunner = class extends AbstractCreatableProvider {
     this._mempoolRunner = await this.locator.getInstance(MempoolRunnerMoniker2);
   }
 };
+__publicField(SimpleXyoRunner, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleXyoRunner, "defaultMoniker", XyoRunnerMoniker);
 __publicField(SimpleXyoRunner, "dependencies", [MempoolRunnerMoniker2]);
 __publicField(SimpleXyoRunner, "monikers", [XyoRunnerMoniker]);
+__publicField(SimpleXyoRunner, "surface", "node");
 SimpleXyoRunner = __decorateClass([
   creatableProvider()
 ], SimpleXyoRunner);
@@ -6285,9 +6546,11 @@ import {
   XyoSignerMoniker as XyoSignerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
 var SimpleXyoSigner = class _SimpleXyoSigner extends AbstractCreatableProvider {
+  static connectionTypes = ["wallet"];
   static defaultMoniker = XyoSignerMoniker2;
   static dependencies = [];
   static monikers = [XyoSignerMoniker2];
+  static surface = "node";
   moniker = _SimpleXyoSigner.defaultMoniker;
   static async paramsHandler(params) {
     let account;
@@ -6327,7 +6590,7 @@ var SimpleXyoSigner = class _SimpleXyoSigner extends AbstractCreatableProvider {
 };
 
 // src/simple/StakeEventsViewer/SimpleStakeEventsViewer.ts
-import { isDefined as isDefined21 } from "@xylabs/sdk-js";
+import { isDefined as isDefined22 } from "@xylabs/sdk-js";
 import { StakeEventsViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 var SimpleStakeEventsViewer = class extends AbstractCreatableProvider {
   moniker = SimpleStakeEventsViewer.defaultMoniker;
@@ -6340,7 +6603,7 @@ var SimpleStakeEventsViewer = class extends AbstractCreatableProvider {
   stakeEvents(range, { name } = {}) {
     const positions = this.positionsFromRange(range);
     const events = this.eventsFromPositions(positions);
-    if (isDefined21(name)) {
+    if (isDefined22(name)) {
       return events.filter((event) => event.name === name);
     }
     return events;
@@ -6397,9 +6660,11 @@ var SimpleStakeEventsViewer = class extends AbstractCreatableProvider {
     return filteredPositions;
   }
 };
+__publicField(SimpleStakeEventsViewer, "connectionTypes", []);
 __publicField(SimpleStakeEventsViewer, "defaultMoniker", StakeEventsViewerMoniker);
 __publicField(SimpleStakeEventsViewer, "dependencies", []);
 __publicField(SimpleStakeEventsViewer, "monikers", [StakeEventsViewerMoniker]);
+__publicField(SimpleStakeEventsViewer, "surface", "node");
 SimpleStakeEventsViewer = __decorateClass([
   creatableProvider()
 ], SimpleStakeEventsViewer);
@@ -6495,9 +6760,11 @@ var SimpleStakeTotalsViewer = class extends AbstractCreatableProvider {
     return withdrawn;
   }
 };
+__publicField(SimpleStakeTotalsViewer, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleStakeTotalsViewer, "defaultMoniker", StakeTotalsViewerMoniker);
 __publicField(SimpleStakeTotalsViewer, "dependencies", [StakeTotalsViewerMoniker]);
 __publicField(SimpleStakeTotalsViewer, "monikers", [StakeTotalsViewerMoniker]);
+__publicField(SimpleStakeTotalsViewer, "surface", "node");
 SimpleStakeTotalsViewer = __decorateClass([
   creatableProvider()
 ], SimpleStakeTotalsViewer);
@@ -6625,9 +6892,11 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
     return this.positions.filter((s) => s.withdrawBlock !== 0);
   }
 };
+__publicField(SimpleStakeViewer, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleStakeViewer, "defaultMoniker", StakeViewerMoniker2);
 __publicField(SimpleStakeViewer, "dependencies", [StakeEventsViewerMoniker2]);
 __publicField(SimpleStakeViewer, "monikers", [StakeViewerMoniker2]);
+__publicField(SimpleStakeViewer, "surface", "node");
 SimpleStakeViewer = __decorateClass([
   creatableProvider()
 ], SimpleStakeViewer);
@@ -6688,7 +6957,7 @@ RestSyncViewer = __decorateClass([
 import {
   asHash as asHash5,
   assertEx as assertEx45,
-  isDefined as isDefined22
+  isDefined as isDefined23
 } from "@xylabs/sdk-js";
 import {
   asTimePayload as asTimePayload2,
@@ -6712,7 +6981,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
         const [block, payloads] = assertEx45(await this.blockViewer.blockByNumber(asXL1BlockNumber11(from, true)), () => "Block not found");
         const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema);
         const hash = timeSchemaIndex === -1 ? void 0 : block.payload_hashes[timeSchemaIndex];
-        const timePayload = asTimePayload2(isDefined22(hash) ? payloads.find((p) => p._hash === hash) : void 0);
+        const timePayload = asTimePayload2(isDefined23(hash) ? payloads.find((p) => p._hash === hash) : void 0);
         if (timePayload === void 0) return 0;
         switch (toDomain) {
           case "xl1": {
@@ -6786,7 +7055,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
       xl1Hash: assertEx45(xl1Hash, () => "No xl1 hash available from time sync service"),
       epoch: Date.now()
     };
-    if (isDefined22(this.ethProvider)) {
+    if (isDefined23(this.ethProvider)) {
       const [ethereum, ethHashOrNull] = await this.currentTimeAndHash("ethereum");
       const ethereumHash = asHash5(ethHashOrNull, () => "No ethereum hash available from time sync service");
       timePayload.ethereum = ethereum;
@@ -6795,9 +7064,11 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
     return timePayload;
   }
 };
+__publicField(SimpleTimeSyncViewer, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleTimeSyncViewer, "defaultMoniker", TimeSyncViewerMoniker);
 __publicField(SimpleTimeSyncViewer, "dependencies", [BlockViewerMoniker4]);
 __publicField(SimpleTimeSyncViewer, "monikers", [TimeSyncViewerMoniker]);
+__publicField(SimpleTimeSyncViewer, "surface", "node");
 SimpleTimeSyncViewer = __decorateClass([
   creatableProvider()
 ], SimpleTimeSyncViewer);
@@ -6919,9 +7190,11 @@ var SimpleTransactionValidationViewer = class extends AbstractCreatableProvider
     }));
   }
 };
+__publicField(SimpleTransactionValidationViewer, "connectionTypes", ["lmdb", "mongo", "rpc"]);
 __publicField(SimpleTransactionValidationViewer, "defaultMoniker", TransactionValidationViewerMoniker2);
 __publicField(SimpleTransactionValidationViewer, "dependencies", [AccountBalanceViewerMoniker3, ChainContractViewerMoniker5, BlockViewerMoniker5]);
 __publicField(SimpleTransactionValidationViewer, "monikers", [TransactionValidationViewerMoniker2]);
+__publicField(SimpleTransactionValidationViewer, "surface", "node");
 SimpleTransactionValidationViewer = __decorateClass([
   creatableProvider()
 ], SimpleTransactionValidationViewer);
@@ -6999,6 +7272,7 @@ var SimpleTransactionViewer = class extends AbstractCreatableProvider {
     return await this.byHash(transactionHash);
   }
 };
+__publicField(SimpleTransactionViewer, "connectionTypes", ["lmdb", "mongo"]);
 __publicField(SimpleTransactionViewer, "defaultMoniker", TransactionViewerMoniker);
 __publicField(SimpleTransactionViewer, "dependencies", [BlockViewerMoniker6]);
 __publicField(SimpleTransactionViewer, "monikers", [TransactionViewerMoniker]);
@@ -7175,9 +7449,11 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
     });
   }
 };
+__publicField(SimpleWindowedBlockViewer, "connectionTypes", ["lmdb", "mongo", "rpc"]);
 __publicField(SimpleWindowedBlockViewer, "defaultMoniker", WindowedBlockViewerMoniker2);
 __publicField(SimpleWindowedBlockViewer, "dependencies", [BlockViewerMoniker7]);
 __publicField(SimpleWindowedBlockViewer, "monikers", [WindowedBlockViewerMoniker2]);
+__publicField(SimpleWindowedBlockViewer, "surface", "node");
 SimpleWindowedBlockViewer = __decorateClass([
   creatableProvider()
 ], SimpleWindowedBlockViewer);
@@ -7283,7 +7559,7 @@ import {
 } from "@xyo-network/xl1-protocol-lib";
 
 // src/test/buildBlock.ts
-import { assertEx as assertEx49, isDefined as isDefined23 } from "@xylabs/sdk-js";
+import { assertEx as assertEx49, isDefined as isDefined24 } from "@xylabs/sdk-js";
 import {
   asAnyPayload as asAnyPayload5,
   BoundWitnessBuilder as BoundWitnessBuilder3,
@@ -7367,7 +7643,7 @@ function buildStepHashes(blockNumber, inStepHashes, previousBlockHash, chainStep
         completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress2, { [completedStepRewardHolderAddress]: completedStepReward }));
       }
       step_hashes.push(assertEx49(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
-    } else if (isDefined23(inStepHashes.at(i))) {
+    } else if (isDefined24(inStepHashes.at(i))) {
       step_hashes.push(inStepHashes[i]);
     }
   }
@@ -7703,6 +7979,7 @@ export {
   ActorConfigZod,
   ActorsConfigZod,
   AddressPairSchema,
+  AmbiguousProviderError,
   BalancesStepSummarySchema,
   BaseConfigContextZod,
   BaseConfigZod,
@@ -7712,6 +7989,8 @@ export {
   COIN_TYPES,
   ChainIndexingServiceStateSchema,
   ConfigZod,
+  TransportConfigZod as ConnectionConfigZod,
+  TransportsConfigZod as ConnectionsConfigZod,
   CreatableProviderContextZod,
   DEFAULT_BACKOFF_MS,
   DEFAULT_MAX_ATTEMPTS,
@@ -7725,6 +8004,7 @@ export {
   EIP712DataPayloadSchema,
   EIP712SignaturePayloadFieldsZod,
   EIP712SignaturePayloadSchema,
+  EvmRpcTransportConfigZod as EvmConnectionConfigZod,
   EvmRpcTransportConfigZod,
   GlobalMetaSchema,
   HostActorConfigContext,
@@ -7733,11 +8013,13 @@ export {
   HydratedBoundWitnessWithStorageMetaZod,
   HydratedCache,
   JSONSchemaMetaSchema,
+  LmdbTransportConfigZod as LmdbConnectionConfigZod,
   LmdbTransportConfigZod,
   LoggerStatusReporter,
   MemoryPermissionsStore,
   MissingCapabilityError,
   MnemonicStringZod,
+  MongoTransportConfigZod as MongoConnectionConfigZod,
   MongoTransportConfigZod,
   PRODUCER_DIVERSITY_BONUS,
   PayloadLocator,
@@ -7750,6 +8032,7 @@ export {
   ProviderFactoryLocatorZod,
   ProvidersConfigZod,
   RemoteConfigZod,
+  RestTransportConfigZod as RestConnectionConfigZod,
   RestDataLakeConfigZod,
   RestDataLakeRunner,
   RestDataLakeViewer,
@@ -7757,11 +8040,13 @@ export {
   RestTransportConfigZod,
   RewardMultipliers,
   RouterDataLakeConfigZod,
+  RpcTransportConfigZod as RpcConnectionConfigZod,
   RpcRemoteConfigBaseZod,
   RpcRemoteConfigZod,
   RpcTransportConfigZod,
   RuntimeStatusMonitor,
   RuntimeStatusMonitorZod,
+  S3TransportConfigZod as S3ConnectionConfigZod,
   S3TransportConfigZod,
   SchemasStepSummarySchema,
   ShiftedBigInt,
@@ -7800,6 +8085,8 @@ export {
   TypedDataFieldZod,
   TypedDataTypesZod,
   TypedDataValueZod,
+  UnboundProviderError,
+  UnknownConnectionError,
   UsageMetaSchema,
   VIEWER_BRANCH_KEYS,
   WALLET_COMPLIANCE,
@@ -7875,6 +8162,8 @@ export {
   createTransactionHydrator,
   createTransferPayload,
   deepCalculateFramesFromRange,
+  descriptorConnectionTypes,
+  descriptorMatchesConnectionType,
   externalBlockNumberFromXL1BlockNumber,
   externalBlockRangeFromStep,
   externalBlockRangeFromXL1BlockRange,
@@ -7896,6 +8185,7 @@ export {
   getTimeConfigInMilliseconds,
   getUrl,
   getWindowedChain,
+  hasDeclaredConnectionProfiles,
   hasLabels,
   hasMongoConfig,
   hasS3Config,
@@ -7934,24 +8224,32 @@ export {
   isZodError,
   labeledCreatableProvider,
   labeledCreatableProviderFactory,
+  locatorFromConfig,
   mapToMapType,
   mergeTransfers,
   mergedAddRemoveStakeEventsByPosition,
+  needsFromConnectionTypes,
+  needsFromProviderBindings,
   netBalancesForPayloads,
   netSchemasForPayloads,
   netTransfersForPayloads,
   networkBackedFactory,
   networkStakeStepRewardPositionWeight,
+  normalizeConnectionsConfig,
   parseSignedBigInt,
   payloadMapFromStore,
   prettifyZodError,
+  providerCandidateFromClass,
+  providerCandidatesFromClasses,
   providerFactoryDescription,
   rateMultipliers,
   readPayloadMapFromStore,
   registerCreatableProviderFactories,
   registerCreatableProviderFactory,
+  registerFactoriesFromPlan,
   resolveConfig,
   resolveProviders,
+  resolveProvidersFromConfig,
   resolveS3Bucket,
   rewardFromBlockNumber,
   schemasMaxStep,