@xyo-network/chain-orchestration 1.23.0 → 2.0.0

package/dist/node/index.mjs

@@ -1,34 +1,45 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/shared/actor/v3/ActorV3.ts
-import { AbstractCreatable, assertEx, delay, IdLogger } from "@xylabs/sdk-js";
+import {
+  AbstractCreatable,
+  assertEx,
+  delay,
+  IdLogger
+} from "@xylabs/sdk-js";
 import { Semaphore } from "async-mutex";
-import z from "zod";
-var noopCounter = {
-  add: /* @__PURE__ */ __name(() => {
-  }, "add")
-};
-var noopUpDownCounter = {
-  add: /* @__PURE__ */ __name(() => {
-  }, "add")
-};
-var noopGauge = {
-  record: /* @__PURE__ */ __name(() => {
-  }, "record")
-};
-var noopHistogram = {
-  record: /* @__PURE__ */ __name(() => {
-  }, "record")
-};
+import { z } from "zod/mini";
+var noopCounter = { add: () => {
+} };
+var noopUpDownCounter = { add: () => {
+} };
+var noopGauge = { record: () => {
+} };
+var noopHistogram = { record: () => {
+} };
 var CreatableNameZod = z.custom((val) => typeof val === "string" && val.length > 0);
-var StatusReporterInstanceZod = z.custom((val) => val !== null && typeof val === "object" && "report" in val);
-var AccountInstanceZod = z.custom((val) => val !== null && typeof val === "object" && "address" in val);
+var StatusReporterInstanceZod = z.custom(
+  (val) => val !== null && typeof val === "object" && "report" in val
+);
+var AccountInstanceZod = z.custom(
+  (val) => val !== null && typeof val === "object" && "address" in val
+);
 var ActorParamsV3Zod = z.object({
   account: AccountInstanceZod,
   locator: z.unknown(),
   name: CreatableNameZod,
-  statusReporter: StatusReporterInstanceZod.optional()
+  statusReporter: z.optional(StatusReporterInstanceZod)
 });
 function createDeferred() {
   let resolve;
@@ -43,11 +54,7 @@ function createDeferred() {
     reject
   };
 }
-__name(createDeferred, "createDeferred");
 var ActorV3 = class extends AbstractCreatable {
-  static {
-    __name(this, "ActorV3");
-  }
   _intervals = /* @__PURE__ */ new Map();
   _semaphores = /* @__PURE__ */ new Map();
   _timeouts = /* @__PURE__ */ new Map();
@@ -56,7 +63,10 @@ var ActorV3 = class extends AbstractCreatable {
   _readyError;
   _readyState = "pending";
   get logger() {
-    this._logger = new IdLogger(assertEx(this.context.logger, () => `Logger is required in context for actor ${this.name}.`), () => this.name);
+    this._logger = new IdLogger(
+      assertEx(this.context.logger, () => `Logger is required in context for actor ${this.name}.`),
+      () => this.name
+    );
     return this._logger;
   }
   get readyError() {
@@ -75,10 +85,9 @@ var ActorV3 = class extends AbstractCreatable {
     return this.params.locator;
   }
   static async paramsHandler(params) {
-    const baseParams = await super.paramsHandler({
-      ...params,
-      name: params.name ?? "UnknownActor"
-    });
+    const baseParams = await super.paramsHandler(
+      { ...params, name: params.name ?? "UnknownActor" }
+    );
     const account = assertEx(params.account, () => `params.account is required for actor ${baseParams.name}.`);
     const locator = assertEx(params.locator, () => `params.locator is required for actor ${baseParams.name}.`);
     return {
@@ -88,8 +97,8 @@ var ActorV3 = class extends AbstractCreatable {
     };
   }
   /**
-  * The timer runs until the actor is deactivated (or you manually stop it).
-  */
+   * The timer runs until the actor is deactivated (or you manually stop it).
+   */
   registerTimer(timerName, callback, dueTimeMs, periodMs) {
     if (this.status !== "starting") {
       this.logger?.warn(`Cannot register timer '${timerName}' because actor is not starting.`);
@@ -134,10 +143,10 @@ var ActorV3 = class extends AbstractCreatable {
     this.logger?.debug(`Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`);
   }
   /**
-  * Invoked by the Orchestrator after `start()` to run the warm-pass.
-  * Idempotent: returns immediately if already invoked.
-  * Throws if `readyHandler` throws; resolves once `readyHandler` resolves.
-  */
+   * Invoked by the Orchestrator after `start()` to run the warm-pass.
+   * Idempotent: returns immediately if already invoked.
+   * Throws if `readyHandler` throws; resolves once `readyHandler` resolves.
+   */
   async runReadyHandler() {
     if (this._readyState !== "pending") return;
     try {
@@ -155,15 +164,15 @@ var ActorV3 = class extends AbstractCreatable {
   async stopHandler() {
     await super.stopHandler();
     this.logger?.debug("Stopping all timers...");
-    await Promise.all([
-      ...this._semaphores.values()
-    ].map(async (semaphore) => {
-      while (semaphore.isLocked()) {
-        this.logger?.debug("Waiting for running timer task to complete...");
-        await delay(500);
-      }
-      await semaphore.acquire();
-    }));
+    await Promise.all(
+      [...this._semaphores.values()].map(async (semaphore) => {
+        while (semaphore.isLocked()) {
+          this.logger?.debug("Waiting for running timer task to complete...");
+          await delay(500);
+        }
+        await semaphore.acquire();
+      })
+    );
     this._semaphores.clear();
     for (const [, timeoutRef] of this._timeouts.entries()) {
       clearTimeout(timeoutRef);
@@ -187,58 +196,44 @@ var ActorV3 = class extends AbstractCreatable {
       }, timeoutMs);
     });
     try {
-      await Promise.race([
-        this._readyDeferred.promise,
-        timeout
-      ]);
+      await Promise.race([this._readyDeferred.promise, timeout]);
     } finally {
       if (timer) clearTimeout(timer);
     }
   }
   /**
-  * Create a `Counter` instrument bound to this actor's meter, or a no-op
-  * stub if telemetry is not wired. Always returns a non-undefined value so
-  * call sites can drop the optional-chain on `.add()`.
-  *
-  * TODO: in a future pass, consider folding these single-instrument helpers
-  * into a declarative `createActorMeters({ counters: {...}, gauges: {...} })`
-  * spec API for actors with many instruments.
-  */
+   * Create a `Counter` instrument bound to this actor's meter, or a no-op
+   * stub if telemetry is not wired. Always returns a non-undefined value so
+   * call sites can drop the optional-chain on `.add()`.
+   *
+   * TODO: in a future pass, consider folding these single-instrument helpers
+   * into a declarative `createActorMeters({ counters: {...}, gauges: {...} })`
+   * spec API for actors with many instruments.
+   */
   counter(name, description) {
-    return this.meter?.createCounter(name, {
-      description
-    }) ?? noopCounter;
+    return this.meter?.createCounter(name, { description }) ?? noopCounter;
   }
   /** Create a synchronous `Gauge` instrument, or a no-op stub if telemetry is not wired. */
   gauge(name, description) {
-    return this.meter?.createGauge(name, {
-      description
-    }) ?? noopGauge;
+    return this.meter?.createGauge(name, { description }) ?? noopGauge;
   }
   /** Create a `Histogram` instrument, or a no-op stub if telemetry is not wired. */
   histogram(name, description) {
-    return this.meter?.createHistogram(name, {
-      description
-    }) ?? noopHistogram;
+    return this.meter?.createHistogram(name, { description }) ?? noopHistogram;
   }
   /**
-  * Override in subclasses to prove the actor can do useful work.
-  * Default: no-op (the actor declares itself ready as soon as `start()` returns).
-  */
+   * Override in subclasses to prove the actor can do useful work.
+   * Default: no-op (the actor declares itself ready as soon as `start()` returns).
+   */
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   async readyHandler() {
   }
   /** Create an `UpDownCounter` instrument, or a no-op stub if telemetry is not wired. */
   upDownCounter(name, description) {
-    return this.meter?.createUpDownCounter(name, {
-      description
-    }) ?? noopUpDownCounter;
+    return this.meter?.createUpDownCounter(name, { description }) ?? noopUpDownCounter;
   }
 };
 var Actor = class extends ActorV3 {
-  static {
-    __name(this, "Actor");
-  }
 };
 
 // src/shared/buildTelemetryConfig.ts
@@ -246,89 +241,96 @@ function buildTelemetryConfig(config, serviceName, serviceVersion, defaultMetric
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
   const { path: endpoint = "/metrics", port = defaultMetricsScrapePort } = config.telemetry?.metrics?.scrape ?? {};
   const telemetryConfig = {
-    attributes: {
-      serviceName,
-      serviceVersion
-    },
+    attributes: { serviceName, serviceVersion },
     otlpEndpoint,
-    metricsConfig: {
-      endpoint,
-      port
-    }
+    metricsConfig: { endpoint, port }
   };
   return telemetryConfig;
 }
-__name(buildTelemetryConfig, "buildTelemetryConfig");
 
 // src/shared/config/actors/Api.ts
-import { zodAsFactory, zodIsFactory, zodToFactory } from "@xylabs/sdk-js";
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk-js";
 import { BaseConfigContextZod, HostActorConfigZod } from "@xyo-network/xl1-sdk";
-import { globalRegistry, z as z2 } from "zod";
-var ApiConfigZod = HostActorConfigZod.extend(z2.object({
-  initRewardsCache: z2.union([
-    z2.number(),
-    z2.string(),
-    z2.boolean()
-  ]).transform((v) => v !== "0" && v !== "false" && v !== false && v != 0).default(true).register(globalRegistry, {
+import { globalRegistry, z as z2 } from "zod/mini";
+var toBooleanDefaultTrue = (v) => v !== "0" && v !== "false" && v !== false && v !== 0;
+var toBooleanDefaultFalse = (v) => v === "1" || v === "true" || v === true || v === 1;
+var ApiConfigZod = z2.extend(HostActorConfigZod, {
+  initRewardsCache: z2._default(
+    z2.pipe(z2.union([z2.number(), z2.string(), z2.boolean()]), z2.transform(toBooleanDefaultTrue)),
+    true
+  ).register(globalRegistry, {
     description: "Whether to initialize the rewards cache on startup",
     title: "api.initRewardsCache",
     type: "boolean"
   }),
   /**
-  * When `true`, the API actor runs in stateless mode: it holds no local
-  * backing-store ownership, never loads the local LMDB/MongoDB node, and
-  * federates every JSON-RPC request to upstream owner-actors via `JsonRpc*`
-  * providers. Multiple stateless API instances can run behind a load
-  * balancer for horizontal scaling. Requires `remote.rpc` to point at the
-  * upstream API/Finalizer/Mempool/Indexer surfaces.
-  */
-  stateless: z2.union([
-    z2.number(),
-    z2.string(),
-    z2.boolean()
-  ]).transform((v) => v === "1" || v === "true" || v === true || v == 1).default(false).register(globalRegistry, {
+   * When `true`, the API actor runs in stateless mode: it holds no local
+   * backing-store ownership, never loads the local LMDB/MongoDB node, and
+   * federates every JSON-RPC request to upstream owner-actors via `JsonRpc*`
+   * providers. Multiple stateless API instances can run behind a load
+   * balancer for horizontal scaling. Requires `remote.rpc` to point at the
+   * upstream API/Finalizer/Mempool/Indexer surfaces.
+   */
+  stateless: z2._default(
+    z2.pipe(z2.union([z2.number(), z2.string(), z2.boolean()]), z2.transform(toBooleanDefaultFalse)),
+    false
+  ).register(globalRegistry, {
     description: "Run the API actor as a stateless federation node (availableBackings: [network])",
     title: "api.stateless",
     type: "boolean"
   }),
   /**
-  * Back-compat for the surface-aware route split. When `true`, `POST /rpc`
-  * serves the full `XyoConnection` (both node-surface and indexed-surface
-  * methods), preserving pre-Phase-7 behavior for clients that haven't yet
-  * migrated to `POST /rpc/indexed`. When `false`, `/rpc` is strictly
-  * node-surface only and indexed methods are 404 at `/rpc`.
-  *
-  * `/rpc/indexed` mounts independently of this flag whenever the locator's
-  * connection has any indexed branch.
-  *
-  * Default `true` for the first release that includes Phase 7 — flip to
-  * `false` per environment once external clients (explorers, wallets, dApps)
-  * have moved their indexed-method calls to `/rpc/indexed`.
-  */
-  legacyMixedRpc: z2.union([
-    z2.number(),
-    z2.string(),
-    z2.boolean()
-  ]).transform((v) => v !== "0" && v !== "false" && v !== false && v != 0).default(true).register(globalRegistry, {
+   * Back-compat for the surface-aware route split. When `true`, `POST /rpc`
+   * serves the full `XyoConnection` (both node-surface and indexed-surface
+   * methods), preserving pre-Phase-7 behavior for clients that haven't yet
+   * migrated to `POST /rpc/indexed`. When `false`, `/rpc` is strictly
+   * node-surface only and indexed methods are 404 at `/rpc`.
+   *
+   * `/rpc/indexed` mounts independently of this flag whenever the locator's
+   * connection has any indexed branch.
+   *
+   * Default `true` for the first release that includes Phase 7 — flip to
+   * `false` per environment once external clients (explorers, wallets, dApps)
+   * have moved their indexed-method calls to `/rpc/indexed`.
+   */
+  legacyMixedRpc: z2._default(
+    z2.pipe(z2.union([z2.number(), z2.string(), z2.boolean()]), z2.transform(toBooleanDefaultTrue)),
+    true
+  ).register(globalRegistry, {
     description: "Serve the full XyoConnection at POST /rpc (no surface filter). Set false to enforce node-surface-only at /rpc; indexed methods always available at /rpc/indexed regardless.",
     title: "api.legacyMixedRpc",
     type: "boolean"
   })
-}).shape);
+});
 var isApiConfig = zodIsFactory(ApiConfigZod);
 var asApiConfig = zodAsFactory(ApiConfigZod, "asApiConfig");
 var toApiConfig = zodToFactory(ApiConfigZod, "toApiConfig");
-var ApiConfigContext = BaseConfigContextZod.extend({
-  config: ApiConfigZod
-});
+var ApiConfigContext = z2.extend(BaseConfigContextZod, { config: ApiConfigZod });
 var isApiConfigContext = zodIsFactory(ApiConfigContext);
 var asApiConfigContext = zodAsFactory(ApiConfigContext, "asApiConfigContext");
 var toApiConfigContext = zodToFactory(ApiConfigContext, "toApiConfigContext");
 
 // src/shared/config/actors/Bridge.ts
-import { AddressZod, HexZod, toAddress, toHex, zodAsFactory as zodAsFactory2, zodIsFactory as zodIsFactory2, zodToFactory as zodToFactory2 } from "@xylabs/sdk-js";
-import { AttoXL1ConvertFactor, BaseConfigContextZod as BaseConfigContextZod2, HostActorConfigZod as HostActorConfigZod2, XL1 } from "@xyo-network/xl1-sdk";
-import { globalRegistry as globalRegistry2, z as z3 } from "zod";
+import {
+  AddressZod,
+  HexZod,
+  toAddress,
+  toHex,
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk-js";
+import {
+  AttoXL1ConvertFactor,
+  BaseConfigContextZod as BaseConfigContextZod2,
+  HostActorConfigZod as HostActorConfigZod2,
+  XL1
+} from "@xyo-network/xl1-sdk";
+import { globalRegistry as globalRegistry2, z as z3 } from "zod/mini";
 var DEFAULT_FIXED_FEE = toHex(XL1(1000n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_VARIABLE_FEE_BASIS_POINTS = 300;
 var DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress("2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6");
@@ -338,103 +340,108 @@ var DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress("5FbDB2315678afecb367f032d93F642f
 var DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(1000000n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(1500n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_SCANNER_INTERVAL_MS = 3e4;
-var BasisPointsZod = z3.coerce.number().int().nonnegative().max(1e4);
-var BridgeConfigZod = HostActorConfigZod2.extend({
-  escrowAddress: AddressZod.optional().register(globalRegistry2, {
+var BasisPointsZod = z3.coerce.number().check(z3.multipleOf(1), z3.nonnegative(), z3.maximum(1e4));
+var BridgeConfigZod = z3.extend(HostActorConfigZod2, {
+  escrowAddress: z3.optional(AddressZod).register(globalRegistry2, {
     description: "Address to which bridge escrow will be sent",
     title: "bridge.escrowAddress",
     type: "string"
   }),
-  feesAddress: AddressZod.optional().register(globalRegistry2, {
+  feesAddress: z3.optional(AddressZod).register(globalRegistry2, {
     description: "Address to which bridge fees will be sent",
     title: "bridge.feesAddress",
     type: "string"
   }),
-  feeFixed: HexZod.default(DEFAULT_FIXED_FEE).register(globalRegistry2, {
+  feeFixed: z3._default(HexZod, DEFAULT_FIXED_FEE).register(globalRegistry2, {
     default: DEFAULT_FIXED_FEE,
     description: "Fixed fee (in AttoXL1) applied to bridge transfers",
     title: "bridge.feeFixed",
     type: "bigint"
   }),
-  feeRateBasisPoints: BasisPointsZod.default(DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry2, {
+  feeRateBasisPoints: z3._default(BasisPointsZod, DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry2, {
     default: DEFAULT_VARIABLE_FEE_BASIS_POINTS,
     description: "Variable rate fee (in basis points where 1 bps = 0.01%) applied to bridge transfers",
     title: "bridge.feeRateBasisPoints",
     type: "number"
   }),
-  maxBridgeAmount: HexZod.default(DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry2, {
+  maxBridgeAmount: z3._default(HexZod, DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry2, {
     default: DEFAULT_MAX_BRIDGE_AMOUNT,
     description: "Maximum amount allowed for a bridge transfer",
     title: "bridge.maxBridgeAmount",
     type: "string"
   }),
-  minBridgeAmount: HexZod.default(DEFAULT_MIN_BRIDGE_AMOUNT).register(globalRegistry2, {
+  minBridgeAmount: z3._default(HexZod, DEFAULT_MIN_BRIDGE_AMOUNT).register(globalRegistry2, {
     default: DEFAULT_MIN_BRIDGE_AMOUNT,
     description: "Minimum amount required for a bridge transfer",
     title: "bridge.minBridgeAmount",
     type: "string"
   }),
-  redisHost: z3.string().default("localhost").register(globalRegistry2, {
+  redisHost: z3._default(z3.string(), "localhost").register(globalRegistry2, {
     default: "localhost",
     description: "Host for the Bridge Redis instance",
     title: "bridge.redisHost",
     type: "string"
   }),
-  redisPort: z3.coerce.number().int().positive().default(6379).register(globalRegistry2, {
+  redisPort: z3._default(z3.coerce.number().check(z3.multipleOf(1), z3.positive()), 6379).register(globalRegistry2, {
     default: 6379,
     description: "Port for the Bridge Redis instance",
     title: "bridge.redisPort",
     type: "number"
   }),
-  scannerIntervalMs: z3.coerce.number().int().positive().default(DEFAULT_SCANNER_INTERVAL_MS).register(globalRegistry2, {
+  scannerIntervalMs: z3._default(z3.coerce.number().check(z3.multipleOf(1), z3.positive()), DEFAULT_SCANNER_INTERVAL_MS).register(globalRegistry2, {
     default: DEFAULT_SCANNER_INTERVAL_MS,
     description: "How often (ms) the EVM->XL1 scanner polls the remote bridge contract for new BridgedToRemote ids confirmed at depth.",
     title: "bridge.scannerIntervalMs",
     type: "number"
   }),
-  remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry2, {
+  remoteBridgeContractAddress: z3._default(AddressZod, DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry2, {
     default: DEFAULT_HARDHAT_BRIDGE_CONTRACT,
     description: "Hex representation of remote token address used for bridging",
     title: "bridge.remoteBridgeContractAddress",
     type: "string"
   }),
-  remoteChainId: HexZod.default(DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry2, {
+  remoteBridgeContractDeployBlock: z3.optional(z3.coerce.number().check(z3.multipleOf(1), z3.nonnegative())).register(globalRegistry2, {
+    description: "EVM block at which the remote bridge contract was deployed. When unset, the bridge actor probes the chain via eth_getCode at actor startup. Setting this avoids the probe and is cheaper for chains with high heads; it must be at or before the actual deploy block.",
+    title: "bridge.remoteBridgeContractDeployBlock",
+    type: "number"
+  }),
+  remoteChainId: z3._default(HexZod, DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry2, {
     default: DEFAULT_HARDHAT_CHAIN_ID,
     description: "Remote chain ID",
     title: "bridge.remoteChainId",
     type: "string"
   }),
-  remoteConfirmationDepth: z3.union([
-    z3.coerce.number().int().nonnegative(),
+  remoteConfirmationDepth: z3.optional(z3.union([
+    z3.coerce.number().check(z3.multipleOf(1), z3.nonnegative()),
     z3.literal("finalized")
-  ]).optional().register(globalRegistry2, {
+  ])).register(globalRegistry2, {
     description: "Block depth or BlockTag at which the remote (EVM) chain is read as canonical. Numeric: number of confirmations behind head. 'finalized': Casper FFG finalized block. Resolved per-chain by getRemoteConfirmationDepth when unset.",
     title: "bridge.remoteConfirmationDepth",
     type: "string"
   }),
-  remoteTokenAddress: HexZod.default(DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry2, {
+  remoteTokenAddress: z3._default(HexZod, DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry2, {
     default: DEFAULT_HARDHAT_TOKEN_CONTRACT,
     description: "Hex representation of remote token address used for bridging",
     title: "bridge.remoteTokenAddress",
     type: "string"
   }),
-  remoteChainWalletPrivateKey: HexZod.default(DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry2, {
+  remoteChainWalletPrivateKey: z3._default(HexZod, DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry2, {
     description: "Private key for the wallet to use for the remote chain wallet",
     title: "bridge.remoteChainWalletPrivateKey",
     type: "string"
   }),
-  xl1ChainId: HexZod.optional().register(globalRegistry2, {
+  xl1ChainId: z3.optional(HexZod).register(globalRegistry2, {
     description: "XL1 chain id used for bridging",
     title: "bridge.xl1ChainId",
     type: "string"
   }),
-  xl1TokenAddress: HexZod.optional().register(globalRegistry2, {
+  xl1TokenAddress: z3.optional(HexZod).register(globalRegistry2, {
     description: "XL1 token address used for bridging",
     title: "bridge.xl1TokenAddress",
     type: "string"
   })
 });
-var BridgeSettingsZod = BridgeConfigZod.pick({
+var BridgeSettingsZod = z3.required(z3.pick(BridgeConfigZod, {
   feeFixed: true,
   feeRateBasisPoints: true,
   feesAddress: true,
@@ -445,94 +452,98 @@ var BridgeSettingsZod = BridgeConfigZod.pick({
   remoteTokenAddress: true,
   xl1TokenAddress: true,
   xl1ChainId: true
-}).required();
+}));
 var isBridgeConfig = zodIsFactory2(BridgeConfigZod);
 var asBridgeConfig = zodAsFactory2(BridgeConfigZod, "asBridgeConfig");
 var toBridgeConfig = zodToFactory2(BridgeConfigZod, "toBridgeConfig");
-var BridgeConfigContext = BaseConfigContextZod2.extend({
-  config: BridgeConfigZod
-});
+var BridgeConfigContext = z3.extend(BaseConfigContextZod2, { config: BridgeConfigZod });
 var isBridgeConfigContext = zodIsFactory2(BridgeConfigContext);
 var asBridgeConfigContext = zodAsFactory2(BridgeConfigContext, "asBridgeConfigContext");
 var toBridgeConfigContext = zodToFactory2(BridgeConfigContext, "toBridgeConfigContext");
 
 // src/shared/config/actors/Finalizer.ts
-import { AddressZod as AddressZod2, zodAsFactory as zodAsFactory3, zodIsFactory as zodIsFactory3, zodToFactory as zodToFactory3 } from "@xylabs/sdk-js";
-import { BaseConfigContextZod as BaseConfigContextZod3, DEFAULT_MIN_CANDIDATES, HostActorConfigZod as HostActorConfigZod3 } from "@xyo-network/xl1-sdk";
-import { z as z4 } from "zod";
-var FinalizerConfigZod = HostActorConfigZod3.extend({
-  allowedProducers: z4.array(AddressZod2).optional(),
+import {
+  AddressZod as AddressZod2,
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@xylabs/sdk-js";
+import {
+  BaseConfigContextZod as BaseConfigContextZod3,
+  DEFAULT_MIN_CANDIDATES,
+  HostActorConfigZod as HostActorConfigZod3
+} from "@xyo-network/xl1-sdk";
+import { z as z4 } from "zod/mini";
+var FinalizerConfigZod = z4.extend(HostActorConfigZod3, {
+  allowedProducers: z4.optional(z4.array(AddressZod2)),
   // Period (ms) between finalizer ticks. Default matches the historical
   // hardcoded value in FinalizerActor; tests can lower it to drive faster
   // block finalization.
-  finalizationCheckInterval: z4.coerce.number().default(500),
-  minCandidates: z4.number().int().min(0).default(DEFAULT_MIN_CANDIDATES)
+  finalizationCheckInterval: z4._default(z4.coerce.number(), 500),
+  minCandidates: z4._default(z4.number().check(z4.multipleOf(1), z4.nonnegative()), DEFAULT_MIN_CANDIDATES)
 });
 var isFinalizerConfig = zodIsFactory3(FinalizerConfigZod);
 var asFinalizerConfig = zodAsFactory3(FinalizerConfigZod, "asFinalizerConfig");
 var toFinalizerConfig = zodToFactory3(FinalizerConfigZod, "toFinalizerConfig");
-var FinalizerConfigContext = BaseConfigContextZod3.extend({
-  config: FinalizerConfigZod
-});
+var FinalizerConfigContext = z4.extend(BaseConfigContextZod3, { config: FinalizerConfigZod });
 var isFinalizerConfigContext = zodIsFactory3(FinalizerConfigContext);
 var asFinalizerConfigContext = zodAsFactory3(FinalizerConfigContext, "asFinalizerConfigContext");
 var toFinalizerConfigContext = zodToFactory3(FinalizerConfigContext, "toFinalizerConfigContext");
 
 // src/shared/config/actors/Mempool.ts
-import { zodAsFactory as zodAsFactory4, zodIsFactory as zodIsFactory4, zodToFactory as zodToFactory4 } from "@xylabs/sdk-js";
+import {
+  zodAsFactory as zodAsFactory4,
+  zodIsFactory as zodIsFactory4,
+  zodToFactory as zodToFactory4
+} from "@xylabs/sdk-js";
 import { BaseConfigContextZod as BaseConfigContextZod4, HostActorConfigZod as HostActorConfigZod4 } from "@xyo-network/xl1-sdk";
-import { globalRegistry as globalRegistry3, z as z5 } from "zod";
+import { globalRegistry as globalRegistry3, z as z5 } from "zod/mini";
 var DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL = 1e3;
 var DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL = 1e3;
 var DEFAULT_MEMPOOL_DEMOTION_THRESHOLD = 3;
 var DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS = 0;
-var MempoolConfigZod = HostActorConfigZod4.extend({
-  enabled: z5.union([
-    z5.string(),
-    z5.boolean()
-  ]).default("false").transform((val, ctx) => {
-    if (typeof val === "boolean") return val;
+var TRUE_VALUES = /* @__PURE__ */ new Set(["true", "1", "yes", "on"]);
+var FALSE_VALUES = /* @__PURE__ */ new Set(["false", "0", "no", "off"]);
+var FlexibleBooleanZod = z5.pipe(
+  z5.union([z5.string(), z5.boolean()]).check(z5.refine((val) => {
+    if (typeof val === "boolean") return true;
     const normalized = val.toLowerCase().trim();
-    if ([
-      "true",
-      "1",
-      "yes",
-      "on"
-    ].includes(normalized)) return true;
-    if ([
-      "false",
-      "0",
-      "no",
-      "off"
-    ].includes(normalized)) return false;
-    ctx.addIssue({
-      code: "invalid_type",
-      expected: "boolean",
-      message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
-    });
-    return z5.NEVER;
-  }).register(globalRegistry3, {
-    default: "false",
+    return TRUE_VALUES.has(normalized) || FALSE_VALUES.has(normalized);
+  }, { error: "Invalid boolean value. Use true/false, 1/0, yes/no." })),
+  z5.transform((val) => {
+    if (typeof val === "boolean") return val;
+    return TRUE_VALUES.has(val.toLowerCase().trim());
+  })
+);
+var MempoolConfigZod = z5.extend(HostActorConfigZod4, {
+  enabled: z5._default(FlexibleBooleanZod, false).register(globalRegistry3, {
+    default: false,
     description: "Enable the Mempool",
     title: "mempool.enabled",
     type: "boolean"
   }),
-  blockPruneInterval: z5.coerce.number().default(DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL).register(globalRegistry3, {
+  blockPruneInterval: z5._default(z5.coerce.number(), DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL).register(globalRegistry3, {
     description: "The interval time (in milliseconds) between pending block prune attempts",
     title: "mempool.blockPruneInterval",
     type: "number"
   }),
-  demotionThreshold: z5.coerce.number().int().positive().default(DEFAULT_MEMPOOL_DEMOTION_THRESHOLD).register(globalRegistry3, {
+  demotionThreshold: z5._default(
+    z5.coerce.number().check(z5.multipleOf(1), z5.positive()),
+    DEFAULT_MEMPOOL_DEMOTION_THRESHOLD
+  ).register(globalRegistry3, {
     description: "Number of times a transaction may be handed out to producers without being included in a block before it is considered demoted",
     title: "mempool.demotionThreshold",
     type: "number"
   }),
-  maxPendingTransactions: z5.coerce.number().int().nonnegative().default(DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS).register(globalRegistry3, {
+  maxPendingTransactions: z5._default(
+    z5.coerce.number().check(z5.multipleOf(1), z5.nonnegative()),
+    DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS
+  ).register(globalRegistry3, {
     description: "Maximum number of pending transactions in the pool. When exceeded, demoted transactions are evicted first, then oldest by sequence. 0 disables the cap.",
     title: "mempool.maxPendingTransactions",
     type: "number"
   }),
-  transactionPruneInterval: z5.coerce.number().default(DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL).register(globalRegistry3, {
+  transactionPruneInterval: z5._default(z5.coerce.number(), DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL).register(globalRegistry3, {
     description: "The interval time (in milliseconds) between pending transaction prune attempts",
     title: "mempool.transactionPruneInterval",
     type: "number"
@@ -541,72 +552,76 @@ var MempoolConfigZod = HostActorConfigZod4.extend({
 var isMempoolConfig = zodIsFactory4(MempoolConfigZod);
 var asMempoolConfig = zodAsFactory4(MempoolConfigZod, "asMempoolConfig");
 var toMempoolConfig = zodToFactory4(MempoolConfigZod, "toMempoolConfig");
-var MempoolConfigContext = BaseConfigContextZod4.extend({
-  config: MempoolConfigZod
-});
+var MempoolConfigContext = z5.extend(BaseConfigContextZod4, { config: MempoolConfigZod });
 var isMempoolConfigContext = zodIsFactory4(MempoolConfigContext);
 var asMempoolConfigContext = zodAsFactory4(MempoolConfigContext, "asMempoolConfigContext");
 var toMempoolConfigContext = zodToFactory4(MempoolConfigContext, "toMempoolConfigContext");
 
 // src/shared/config/actors/Producer.ts
-import { AddressZod as AddressZod3, zodAsFactory as zodAsFactory5, zodIsFactory as zodIsFactory5, zodToFactory as zodToFactory5 } from "@xylabs/sdk-js";
+import {
+  AddressZod as AddressZod3,
+  zodAsFactory as zodAsFactory5,
+  zodIsFactory as zodIsFactory5,
+  zodToFactory as zodToFactory5
+} from "@xylabs/sdk-js";
 import { ActorConfigZod, BaseConfigContextZod as BaseConfigContextZod5 } from "@xyo-network/xl1-sdk";
-import { globalRegistry as globalRegistry4, z as z6 } from "zod";
+import { globalRegistry as globalRegistry4, z as z6 } from "zod/mini";
 var DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL = 1e4;
-var ProducerConfigZod = ActorConfigZod.extend(z6.object({
-  allowlist: z6.array(AddressZod3).optional().register(globalRegistry4, {
+var ProducerConfigZod = z6.extend(ActorConfigZod, {
+  allowlist: z6.optional(z6.array(AddressZod3)).register(globalRegistry4, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   }),
-  blockProductionCheckInterval: z6.coerce.number().default(DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry4, {
+  blockProductionCheckInterval: z6._default(z6.coerce.number(), DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry4, {
     description: "The interval time (in milliseconds) between block production attempts",
     title: "producer.blockProductionCheckInterval",
     type: "number"
   }),
-  disableIntentRedeclaration: z6.boolean().optional().register(globalRegistry4, {
+  disableIntentRedeclaration: z6.optional(z6.boolean()).register(globalRegistry4, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
     type: "boolean"
   }),
-  heartbeatInterval: z6.coerce.number().default(36e5).register(globalRegistry4, {
+  heartbeatInterval: z6._default(z6.coerce.number(), 36e5).register(globalRegistry4, {
     description: "The number of milliseconds between heartbeats if no blocks are produced",
     title: "producer.heartbeatInterval",
     type: "number"
   }),
   // TODO: BigInt schema
-  minStake: z6.coerce.number().default(1).register(globalRegistry4, {
+  minStake: z6._default(z6.coerce.number(), 1).register(globalRegistry4, {
     description: "Minimum stake required to be a Producer",
     title: "producer.minStake",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z6.string().optional().register(globalRegistry4, {
+  rewardAddress: z6.optional(z6.string()).register(globalRegistry4, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
   })
-}).shape);
+});
 var isProducerConfig = zodIsFactory5(ProducerConfigZod);
 var asProducerConfig = zodAsFactory5(ProducerConfigZod, "asProducerConfig");
 var toProducerConfig = zodToFactory5(ProducerConfigZod, "toProducerConfig");
-var ProducerConfigContext = BaseConfigContextZod5.extend({
-  config: ProducerConfigZod
-});
+var ProducerConfigContext = z6.extend(BaseConfigContextZod5, { config: ProducerConfigZod });
 var isProducerConfigContext = zodIsFactory5(ProducerConfigContext);
 var asProducerConfigContext = zodAsFactory5(ProducerConfigContext, "asProducerConfigContext");
 var toProducerConfigContext = zodToFactory5(ProducerConfigContext, "toProducerConfigContext");
 
 // src/shared/config/actors/RewardRedemption.ts
-import { zodAsFactory as zodAsFactory6, zodIsFactory as zodIsFactory6, zodToFactory as zodToFactory6 } from "@xylabs/sdk-js";
+import {
+  zodAsFactory as zodAsFactory6,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory6
+} from "@xylabs/sdk-js";
 import { BaseConfigContextZod as BaseConfigContextZod6, HostActorConfigZod as HostActorConfigZod5 } from "@xyo-network/xl1-sdk";
-var RewardRedemptionConfigZod = HostActorConfigZod5.extend({});
+import { z as z7 } from "zod/mini";
+var RewardRedemptionConfigZod = z7.extend(HostActorConfigZod5, {});
 var isRewardRedemptionConfig = zodIsFactory6(RewardRedemptionConfigZod);
 var asRewardRedemptionConfig = zodAsFactory6(RewardRedemptionConfigZod, "asRewardRedemptionConfig");
 var toRewardRedemptionConfig = zodToFactory6(RewardRedemptionConfigZod, "toRewardRedemptionConfig");
-var RewardRedemptionConfigContext = BaseConfigContextZod6.extend({
-  config: RewardRedemptionConfigZod
-});
+var RewardRedemptionConfigContext = z7.extend(BaseConfigContextZod6, { config: RewardRedemptionConfigZod });
 var isRewardRedemptionConfigContext = zodIsFactory6(RewardRedemptionConfigContext);
 var asRewardRedemptionConfigContext = zodAsFactory6(RewardRedemptionConfigContext, "asRewardRedemptionConfigContext");
 var toRewardRedemptionConfigContext = zodToFactory6(RewardRedemptionConfigContext, "toRewardRedemptionConfigContext");
@@ -621,26 +636,27 @@ function mergeConfig({ actors, ...baseConfig }) {
     })
   };
 }
-__name(mergeConfig, "mergeConfig");
 
 // src/shared/createDeclarationIntentBlock.ts
 import { buildNextBlock } from "@xyo-network/chain-sdk";
 import { createDeclarationIntent } from "@xyo-network/xl1-sdk";
 async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, range) {
-  const producerDeclarationPayload = createDeclarationIntent(producerAccount.address, "producer", range[0], range[1]);
-  return await buildNextBlock(prevBlock, [], [
-    producerDeclarationPayload
-  ], [
-    producerAccount
-  ]);
+  const producerDeclarationPayload = createDeclarationIntent(
+    producerAccount.address,
+    "producer",
+    range[0],
+    range[1]
+  );
+  return await buildNextBlock(
+    prevBlock,
+    [],
+    [producerDeclarationPayload],
+    [producerAccount]
+  );
 }
-__name(createProducerChainStakeIntentBlock, "createProducerChainStakeIntentBlock");
 
 // src/shared/host/implementation/DefaultHost.ts
 var GenericHost = class {
-  static {
-    __name(this, "GenericHost");
-  }
   services;
   constructor(services) {
     this.services = services;
@@ -657,9 +673,6 @@ var GenericHost = class {
 
 // src/shared/host/implementation/DefaultServiceProvider.ts
 var DefaultServiceProvider = class {
-  static {
-    __name(this, "DefaultServiceProvider");
-  }
   _services;
   constructor(services) {
     this._services = services;
@@ -709,24 +722,19 @@ var activeWalletReport;
 function getAccountLabel(actorName) {
   return ACTOR_LABELS[actorName] ?? actorName;
 }
-__name(getAccountLabel, "getAccountLabel");
 function clearResolvedWalletReport() {
   activeWalletReport = void 0;
 }
-__name(clearResolvedWalletReport, "clearResolvedWalletReport");
 function resolveActorAccountPath(actorName, actorConfig) {
   if (actorConfig?.accountPath !== void 0) return actorConfig.accountPath;
   return DEFAULT_ACTOR_ACCOUNT_PATH[actorName] ?? "0";
 }
-__name(resolveActorAccountPath, "resolveActorAccountPath");
 function isAbsoluteAccountPath(accountPath) {
   return accountPath.startsWith("m/");
 }
-__name(isAbsoluteAccountPath, "isAbsoluteAccountPath");
 function expandAccountPath(accountPath, basePath = DEFAULT_WALLET_PATH) {
   return isAbsoluteAccountPath(accountPath) ? accountPath : `${basePath}/${accountPath}`;
 }
-__name(expandAccountPath, "expandAccountPath");
 async function deriveWalletAtPath(mnemonic, accountPath) {
   if (isAbsoluteAccountPath(accountPath)) {
     const seed = Mnemonic.fromPhrase(mnemonic).computeSeed();
@@ -737,15 +745,12 @@ async function deriveWalletAtPath(mnemonic, accountPath) {
   const baseWallet = await generateXyoBaseWalletFromPhrase(mnemonic);
   return await baseWallet.derivePath(accountPath);
 }
-__name(deriveWalletAtPath, "deriveWalletAtPath");
 function getBuiltInDevMnemonic() {
   return BUILT_IN_DEV_MNEMONIC;
 }
-__name(getBuiltInDevMnemonic, "getBuiltInDevMnemonic");
 function getInsecureGenesisRewardMnemonic() {
   return INSECURE_GENESIS_REWARD_MNEMONIC;
 }
-__name(getInsecureGenesisRewardMnemonic, "getInsecureGenesisRewardMnemonic");
 function resolveRootWallet(configuration) {
   const isConfigured = configuration.mnemonic !== void 0;
   const mnemonic = configuration.mnemonic ?? BUILT_IN_DEV_MNEMONIC;
@@ -758,8 +763,12 @@ function resolveRootWallet(configuration) {
     mnemonicKind: isBuiltInDevMnemonic ? "built-in-dev" : "configured-root"
   };
 }
-__name(resolveRootWallet, "resolveRootWallet");
-async function resolveWalletMetadata({ accountPath, actorName, mnemonic, mnemonicKind }) {
+async function resolveWalletMetadata({
+  accountPath,
+  actorName,
+  mnemonic,
+  mnemonicKind
+}) {
   const account = await deriveWalletAtPath(mnemonic, accountPath);
   return {
     accountPath,
@@ -773,7 +782,6 @@ async function resolveWalletMetadata({ accountPath, actorName, mnemonic, mnemoni
     usesBuiltInDevMnemonic: mnemonic === BUILT_IN_DEV_MNEMONIC
   };
 }
-__name(resolveWalletMetadata, "resolveWalletMetadata");
 async function resolveActorWallet(actorName, actorConfig, root) {
   return await resolveWalletMetadata({
     accountPath: resolveActorAccountPath(actorName, actorConfig),
@@ -782,11 +790,7 @@ async function resolveActorWallet(actorName, actorConfig, root) {
     mnemonicKind: root.mnemonicKind
   });
 }
-__name(resolveActorWallet, "resolveActorWallet");
 var ActorMnemonicNotAllowedError = class extends Error {
-  static {
-    __name(this, "ActorMnemonicNotAllowedError");
-  }
   actors;
   constructor(actors) {
     super([
@@ -801,14 +805,12 @@ function assertNoActorMnemonics(configuration) {
   const offenders = configuration.actors.filter((actor) => typeof actor.mnemonic === "string").map((actor) => actor.name);
   if (offenders.length > 0) throw new ActorMnemonicNotAllowedError(offenders);
 }
-__name(assertNoActorMnemonics, "assertNoActorMnemonics");
 var DerivationPathCollisionError = class extends Error {
-  static {
-    __name(this, "DerivationPathCollisionError");
-  }
   collisions;
   constructor(collisions) {
-    const lines = Object.entries(collisions).map(([path, actors]) => `  - ${actors.join(", ")} \u2192 ${path}`);
+    const lines = Object.entries(collisions).map(
+      ([path, actors]) => `  - ${actors.join(", ")} \u2192 ${path}`
+    );
     super([
       "Two or more actors resolve to the same wallet derivation path:",
       ...lines,
@@ -819,10 +821,7 @@ var DerivationPathCollisionError = class extends Error {
   }
 };
 function detectDerivationPathCollisions(requestedActors, configuration) {
-  const actorConfigMap = new Map(configuration.actors.map((actor) => [
-    actor.name,
-    actor
-  ]));
+  const actorConfigMap = new Map(configuration.actors.map((actor) => [actor.name, actor]));
   const bucketsByPath = /* @__PURE__ */ new Map();
   for (const actorName of requestedActors) {
     const accountPath = resolveActorAccountPath(actorName, actorConfigMap.get(actorName));
@@ -838,71 +837,57 @@ function detectDerivationPathCollisions(requestedActors, configuration) {
   if (Object.keys(collisions).length === 0) return void 0;
   return new DerivationPathCollisionError(collisions);
 }
-__name(detectDerivationPathCollisions, "detectDerivationPathCollisions");
 async function resolveWalletReport(requestedActors, configuration) {
   const root = resolveRootWallet(configuration);
-  const actorConfigMap = new Map(configuration.actors.map((actor) => [
-    actor.name,
-    actor
-  ]));
-  const resolvedActors = await Promise.all(requestedActors.map(async (actorName) => await resolveActorWallet(actorName, actorConfigMap.get(actorName), root)));
+  const actorConfigMap = new Map(configuration.actors.map((actor) => [actor.name, actor]));
+  const resolvedActors = await Promise.all(
+    requestedActors.map(async (actorName) => await resolveActorWallet(actorName, actorConfigMap.get(actorName), root))
+  );
   const labelMap = /* @__PURE__ */ new Map();
   for (const actor of resolvedActors) {
     const labels = labelMap.get(actor.derivationPath) ?? [];
     labels.push(actor.label);
     labelMap.set(actor.derivationPath, labels);
   }
-  const sharedAccounts = await Promise.all(Array.from({
-    length: SHARED_ACCOUNT_REPORT_COUNT
-  }, (_, index) => index).map(async (sharedIndex) => {
-    const account = await resolveWalletMetadata({
-      accountPath: `${sharedIndex}`,
-      actorName: ROOT_WALLET_RUNTIME_ID,
-      mnemonic: root.mnemonic,
-      mnemonicKind: root.mnemonicKind
-    });
-    const labels = labelMap.get(account.derivationPath);
-    return {
-      ...account,
-      label: labels?.join(", ") ?? `shared[${sharedIndex}]`
-    };
-  }));
+  const sharedAccounts = await Promise.all(
+    Array.from({ length: SHARED_ACCOUNT_REPORT_COUNT }, (_, index) => index).map(async (sharedIndex) => {
+      const account = await resolveWalletMetadata({
+        accountPath: `${sharedIndex}`,
+        actorName: ROOT_WALLET_RUNTIME_ID,
+        mnemonic: root.mnemonic,
+        mnemonicKind: root.mnemonicKind
+      });
+      const labels = labelMap.get(account.derivationPath);
+      return { ...account, label: labels?.join(", ") ?? `shared[${sharedIndex}]` };
+    })
+  );
   return {
-    requestedActors: [
-      ...requestedActors
-    ],
+    requestedActors: [...requestedActors],
     root,
     sharedAccounts
   };
 }
-__name(resolveWalletReport, "resolveWalletReport");
 async function buildInsecureGenesisRewardAccounts() {
-  const accounts = await Promise.all(Array.from({
-    length: SHARED_ACCOUNT_REPORT_COUNT
-  }, (_, index) => index).map(async (sharedIndex) => {
-    const account = await resolveWalletMetadata({
-      accountPath: `${sharedIndex}`,
-      actorName: "genesisReward",
-      mnemonic: INSECURE_GENESIS_REWARD_MNEMONIC,
-      mnemonicKind: "insecure-genesis-reward"
-    });
-    return {
-      ...account,
-      label: sharedIndex === 0 ? "genesisRewardAddress" : `genesisReward[${sharedIndex}]`
-    };
-  }));
+  const accounts = await Promise.all(
+    Array.from({ length: SHARED_ACCOUNT_REPORT_COUNT }, (_, index) => index).map(async (sharedIndex) => {
+      const account = await resolveWalletMetadata({
+        accountPath: `${sharedIndex}`,
+        actorName: "genesisReward",
+        mnemonic: INSECURE_GENESIS_REWARD_MNEMONIC,
+        mnemonicKind: "insecure-genesis-reward"
+      });
+      return { ...account, label: sharedIndex === 0 ? "genesisRewardAddress" : `genesisReward[${sharedIndex}]` };
+    })
+  );
   return accounts;
 }
-__name(buildInsecureGenesisRewardAccounts, "buildInsecureGenesisRewardAccounts");
 async function initializeResolvedWalletReport(requestedActors, configuration) {
   activeWalletReport = await resolveWalletReport(requestedActors, configuration);
   return activeWalletReport;
 }
-__name(initializeResolvedWalletReport, "initializeResolvedWalletReport");
 function getResolvedWalletReport() {
   return activeWalletReport;
 }
-__name(getResolvedWalletReport, "getResolvedWalletReport");
 function formatSharedAccount(account, showPrivateKey) {
   const lines = [
     `[${account.accountPath}] ${account.label}`,
@@ -913,7 +898,6 @@ function formatSharedAccount(account, showPrivateKey) {
   if (showPrivateKey) lines.push(`privateKey: ${account.privateKey ?? "unavailable"}`);
   return lines.join("\n");
 }
-__name(formatSharedAccount, "formatSharedAccount");
 function formatGenesisRewardAccount(account) {
   const balance = account.accountPath === "0" ? GENESIS_REWARD_AMOUNT / ATTO_XL1_PER_XL1 : 0n;
   return [
@@ -924,7 +908,6 @@ function formatGenesisRewardAccount(account) {
     `balance: ${balance.toString()} XL1`
   ].join("\n");
 }
-__name(formatGenesisRewardAccount, "formatGenesisRewardAccount");
 function formatWalletReport(report) {
   const sections = [];
   const showSecrets = report.root.isBuiltInDevMnemonic;
@@ -949,7 +932,6 @@ function formatWalletReport(report) {
   ].join("\n"));
   return sections.join("\n\n");
 }
-__name(formatWalletReport, "formatWalletReport");
 function formatInsecureGenesisRewardWarning(accounts) {
   return [
     "INSECURE GENESIS REWARD WALLET WARNING",
@@ -968,21 +950,18 @@ function formatInsecureGenesisRewardWarning(accounts) {
     accounts.map((account) => formatGenesisRewardAccount(account)).join("\n\n")
   ].join("\n");
 }
-__name(formatInsecureGenesisRewardWarning, "formatInsecureGenesisRewardWarning");
 async function resolveGenesisRewardAddress(config) {
   if (config.chain.genesisRewardAddress) return config.chain.genesisRewardAddress;
   const wallet = await generateXyoBaseWalletFromPhrase(INSECURE_GENESIS_REWARD_MNEMONIC);
   const account = await wallet.derivePath("0");
   return account.address;
 }
-__name(resolveGenesisRewardAddress, "resolveGenesisRewardAddress");
 async function resolveWalletForActor(actorName, accountPath) {
   const report = activeWalletReport;
   const mnemonic = report?.root.mnemonic ?? BUILT_IN_DEV_MNEMONIC;
   const resolvedAccountPath = accountPath ?? resolveActorAccountPath(actorName);
   return await deriveWalletAtPath(mnemonic, resolvedAccountPath);
 }
-__name(resolveWalletForActor, "resolveWalletForActor");
 
 // src/shared/init/initActorSeedPhrase.ts
 async function initActorSeedPhrase(context, bios) {
@@ -995,7 +974,6 @@ async function initActorSeedPhrase(context, bios) {
   logger?.debug(`[${walletKind}] Falling back to built-in development mnemonic`);
   return assertEx2(fallback, () => "Unable to resolve mnemonic");
 }
-__name(initActorSeedPhrase, "initActorSeedPhrase");
 
 // src/shared/init/initBridgedModule.ts
 import { assertEx as assertEx3 } from "@xylabs/sdk-js";
@@ -1018,33 +996,26 @@ async function initBridgedModule({ bridge, moduleName }) {
     return moduleInstance;
   });
 }
-__name(initBridgedModule, "initBridgedModule");
 async function initBridgedArchivistModule({ bridge, moduleName }) {
-  return assertEx3(asAttachableArchivistInstance(await initBridgedModule({
-    bridge,
-    moduleName
-  })), () => `Could not convert ${moduleName} to attachable archivist instance`);
+  return assertEx3(
+    asAttachableArchivistInstance(await initBridgedModule({ bridge, moduleName })),
+    () => `Could not convert ${moduleName} to attachable archivist instance`
+  );
 }
-__name(initBridgedArchivistModule, "initBridgedArchivistModule");
 
 // src/shared/init/initStatusReporter.ts
 import { RuntimeStatusMonitor } from "@xyo-network/xl1-sdk";
 function initStatusReporter({ logger }) {
   const statusReporter = new RuntimeStatusMonitor(logger);
-  statusReporter.onGlobalTransition({
-    to: "started"
-  }, () => {
+  statusReporter.onGlobalTransition({ to: "started" }, () => {
     logger.log("All services started.");
   });
-  statusReporter.onGlobalTransition({
-    to: "error"
-  }, () => {
+  statusReporter.onGlobalTransition({ to: "error" }, () => {
     logger.error("Producer encountered an unhandled error!");
     process.exit(1);
   });
   return statusReporter;
 }
-__name(initStatusReporter, "initStatusReporter");
 
 // src/shared/init/initWallet.ts
 import { isDefined } from "@xylabs/sdk-js";
@@ -1058,21 +1029,10 @@ async function initActorWallet(context) {
   actorAccountSingletons[actorName] = account;
   return actorAccountSingletons[actorName];
 }
-__name(initActorWallet, "initActorWallet");
 
 // src/shared/orchestrator/Orchestrator.ts
 import { AbstractCreatable as AbstractCreatable2, creatable } from "@xylabs/sdk-js";
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
 var Orchestrator = class extends AbstractCreatable2 {
-  static {
-    __name(this, "Orchestrator");
-  }
   actors = [];
   running = false;
   shuttingDown = false;
@@ -1089,9 +1049,9 @@ var Orchestrator = class extends AbstractCreatable2 {
     return this.shuttingDown;
   }
   /**
-  * Registers an actor.
-  * (We won't activate the actor until `start()` is called.)
-  */
+   * Registers an actor.
+   * (We won't activate the actor until `start()` is called.)
+   */
   async registerActor(actor) {
     this.actors.push(actor);
     if (this.running) {
@@ -1104,9 +1064,9 @@ var Orchestrator = class extends AbstractCreatable2 {
     }
   }
   /**
-  * Starts the orchestrator: activates all actors in parallel and kicks off their warm-pass.
-  * `whenReady()` resolves once every actor's `readyHandler` has succeeded.
-  */
+   * Starts the orchestrator: activates all actors in parallel and kicks off their warm-pass.
+   * `whenReady()` resolves once every actor's `readyHandler` has succeeded.
+   */
   async startHandler() {
     await super.startHandler();
     if (this.running) {
@@ -1116,12 +1076,7 @@ var Orchestrator = class extends AbstractCreatable2 {
     this.logger?.log(`[Orchestrator] Starting ${this.actors.length} actor(s) in parallel...`);
     this.running = true;
     const startResults = await Promise.allSettled(this.actors.map((a) => a.start()));
-    const startFailures = startResults.flatMap((r, i) => r.status === "rejected" ? [
-      {
-        actor: this.actors[i],
-        reason: r.reason
-      }
-    ] : []);
+    const startFailures = startResults.flatMap((r, i) => r.status === "rejected" ? [{ actor: this.actors[i], reason: r.reason }] : []);
     if (startFailures.length > 0) {
       for (const f of startFailures) this.logger?.error(`[Orchestrator] Actor [${f.actor?.name ?? "?"}] failed to start: ${formatError(f.reason)}`);
       throw new Error(`[Orchestrator] ${startFailures.length} actor(s) failed to start`);
@@ -1135,8 +1090,8 @@ var Orchestrator = class extends AbstractCreatable2 {
     }
   }
   /**
-  * Stops the orchestrator: deactivates all actors.
-  */
+   * Stops the orchestrator: deactivates all actors.
+   */
   async stopHandler() {
     await super.stopHandler();
     if (!this.running) {
@@ -1151,9 +1106,9 @@ var Orchestrator = class extends AbstractCreatable2 {
     this.logger?.log("[Orchestrator] Stopped.");
   }
   /**
-  * Resolves once every actor reports ready. Rejects if any actor's `readyHandler` throws,
-  * or after `timeoutMs` if provided.
-  */
+   * Resolves once every actor reports ready. Rejects if any actor's `readyHandler` throws,
+   * or after `timeoutMs` if provided.
+   */
   async whenReady(timeoutMs) {
     const localActors = this.actors.filter(isLocalActor);
     if (localActors.length === 0) return;
@@ -1168,50 +1123,30 @@ var Orchestrator = class extends AbstractCreatable2 {
       }, timeoutMs);
     });
     try {
-      await Promise.race([
-        Promise.all(localActors.map((a) => a.whenReady())),
-        timeout
-      ]);
+      await Promise.race([Promise.all(localActors.map((a) => a.whenReady())), timeout]);
     } finally {
       if (timer) clearTimeout(timer);
     }
   }
 };
-Orchestrator = _ts_decorate([
+Orchestrator = __decorateClass([
   creatable()
 ], Orchestrator);
 function isLocalActor(actor) {
   return actor instanceof ActorV3;
 }
-__name(isLocalActor, "isLocalActor");
 function formatError(err) {
   if (err instanceof Error) return `${err.message}${err.stack ? `
 ${err.stack}` : ""}`;
   return String(err);
 }
-__name(formatError, "formatError");
 
 // src/shared/provider/SimpleRejectedTransactionsArchivistProvider.ts
 import { assertEx as assertEx4 } from "@xylabs/sdk-js";
 import { AbstractCreatableProvider, creatableProvider } from "@xyo-network/xl1-sdk";
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate2, "_ts_decorate");
 var RejectedTransactionsArchivistProviderMoniker = "RejectedTransactionsArchivistProvider";
-var SimpleRejectedTransactionsArchivistProvider = class _SimpleRejectedTransactionsArchivistProvider extends AbstractCreatableProvider {
-  static {
-    __name(this, "SimpleRejectedTransactionsArchivistProvider");
-  }
-  static defaultMoniker = RejectedTransactionsArchivistProviderMoniker;
-  static dependencies = [];
-  static monikers = [
-    RejectedTransactionsArchivistProviderMoniker
-  ];
-  moniker = _SimpleRejectedTransactionsArchivistProvider.defaultMoniker;
+var SimpleRejectedTransactionsArchivistProvider = class extends AbstractCreatableProvider {
+  moniker = SimpleRejectedTransactionsArchivistProvider.defaultMoniker;
   get archivist() {
     return this.params.archivist;
   }
@@ -1222,7 +1157,10 @@ var SimpleRejectedTransactionsArchivistProvider = class _SimpleRejectedTransacti
     };
   }
 };
-SimpleRejectedTransactionsArchivistProvider = _ts_decorate2([
+__publicField(SimpleRejectedTransactionsArchivistProvider, "defaultMoniker", RejectedTransactionsArchivistProviderMoniker);
+__publicField(SimpleRejectedTransactionsArchivistProvider, "dependencies", []);
+__publicField(SimpleRejectedTransactionsArchivistProvider, "monikers", [RejectedTransactionsArchivistProviderMoniker]);
+SimpleRejectedTransactionsArchivistProvider = __decorateClass([
   creatableProvider()
 ], SimpleRejectedTransactionsArchivistProvider);
 
@@ -1233,7 +1171,25 @@ import { backingsSatisfied, unmetBackings } from "@xyo-network/xl1-protocol-sdk"
 import { createCapabilityRegistry } from "@xyo-network/xl1-protocol-sdk";
 
 // src/node/config/capabilities/defaultCapabilityRegistry.ts
-import { AccountBalanceViewerMoniker, BlockRunnerMoniker, BlockValidationViewerMoniker, BlockViewerMoniker, ChainContractViewerMoniker, DeadLetterQueueRunnerMoniker, DeadLetterQueueViewerMoniker, FinalizationRunnerMoniker, FinalizationViewerMoniker, MempoolRunnerMoniker, MempoolViewerMoniker, StakeTotalsViewerMoniker, TimeSyncViewerMoniker, TransactionValidationViewerMoniker, TransactionViewerMoniker, WindowedBlockViewerMoniker, XyoViewerMoniker } from "@xyo-network/xl1-sdk";
+import {
+  AccountBalanceViewerMoniker,
+  BlockRunnerMoniker,
+  BlockValidationViewerMoniker,
+  BlockViewerMoniker,
+  ChainContractViewerMoniker,
+  DeadLetterQueueRunnerMoniker,
+  DeadLetterQueueViewerMoniker,
+  FinalizationRunnerMoniker,
+  FinalizationViewerMoniker,
+  MempoolRunnerMoniker,
+  MempoolViewerMoniker,
+  StakeTotalsViewerMoniker,
+  TimeSyncViewerMoniker,
+  TransactionValidationViewerMoniker,
+  TransactionViewerMoniker,
+  WindowedBlockViewerMoniker,
+  XyoViewerMoniker
+} from "@xyo-network/xl1-sdk";
 var XyoConnectionMoniker = "XyoConnection";
 var XyoGatewayRunnerMoniker = "XyoGatewayRunner";
 var capabilities = [
@@ -1254,12 +1210,22 @@ var capabilities = [
     label: "Mempool viewer",
     kind: "viewer",
     surface: "node"
+    // Note: `SimpleMempoolViewer.dependencies` lists `WindowedBlockViewer`,
+    // but the runtime constructor does NOT actually resolve it — the
+    // dependencies field is informational for `validateDepsOnRegister`.
+    // Adding `implies: [WindowedBlockViewerMoniker]` here would over-provision
+    // (selected by `locatorPlan.spec.ts`); leave it off intentionally.
   },
   {
     id: MempoolRunnerMoniker,
     label: "Mempool runner",
     kind: "runner",
     surface: "node"
+    // Note: `SimpleMempoolRunner.dependencies` lists BlockValidationViewer,
+    // ChainContractViewer, FinalizationViewer, TransactionValidationViewer —
+    // but the same "informational deps" principle applies: the runtime
+    // constructor does not eagerly resolve them. Adding them as `implies`
+    // would over-provision (selected by `locatorPlan.spec.ts`).
   },
   {
     id: AccountBalanceViewerMoniker,
@@ -1372,10 +1338,24 @@ function createDefaultCapabilityRegistry() {
   for (const cap of capabilities) registry.register(cap);
   return registry;
 }
-__name(createDefaultCapabilityRegistry, "createDefaultCapabilityRegistry");
 
 // src/node/config/capabilities/descriptors.ts
-import { SimpleAccountBalanceViewer, SimpleBlockValidationViewer, SimpleBlockViewer, SimpleDeadLetterQueueRunner, SimpleDeadLetterQueueViewer, SimpleFinalizationRunner, SimpleFinalizationViewer, SimpleMempoolRunner, SimpleMempoolViewer, SimpleTransactionValidationViewer, SimpleTransactionViewer, SimpleWindowedBlockViewer, SimpleXyoConnectionViewer, SimpleXyoViewer } from "@xyo-network/xl1-sdk";
+import {
+  SimpleAccountBalanceViewer,
+  SimpleBlockValidationViewer,
+  SimpleBlockViewer,
+  SimpleDeadLetterQueueRunner,
+  SimpleDeadLetterQueueViewer,
+  SimpleFinalizationRunner,
+  SimpleFinalizationViewer,
+  SimpleMempoolRunner,
+  SimpleMempoolViewer,
+  SimpleTransactionValidationViewer,
+  SimpleTransactionViewer,
+  SimpleWindowedBlockViewer,
+  SimpleXyoConnectionViewer,
+  SimpleXyoViewer
+} from "@xyo-network/xl1-sdk";
 function readMempoolTuning(ctx) {
   const cfg = ctx.actorContext.config;
   return {
@@ -1383,258 +1363,207 @@ function readMempoolTuning(ctx) {
     maxPendingTransactions: cfg?.mempool?.maxPendingTransactions
   };
 }
-__name(readMempoolTuning, "readMempoolTuning");
-var passes = /* @__PURE__ */ __name(() => true, "passes");
+var passes = () => true;
 var localTier1Descriptors = [
   {
     id: "SimpleMempoolViewer",
-    satisfies: [
-      SimpleMempoolViewer.defaultMoniker
-    ],
+    satisfies: [SimpleMempoolViewer.defaultMoniker],
     tier: 1,
-    backings: [
-      {
-        backing: "mempool-store",
-        mode: "read"
-      }
-    ],
+    backings: [{ backing: "mempool-store", mode: "read" }],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => {
+    build: (ctx) => {
       const { demotionThreshold } = readMempoolTuning(ctx);
-      return SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
-        pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
-        pendingBlocksArchivist: ctx.process.pendingBlocksArchivist,
-        demotionThreshold
-      });
-    }, "build")
+      return SimpleMempoolViewer.factory(
+        SimpleMempoolViewer.dependencies,
+        {
+          pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
+          pendingBlocksArchivist: ctx.process.pendingBlocksArchivist,
+          demotionThreshold
+        }
+      );
+    }
   },
   {
     id: "SimpleMempoolRunner",
-    satisfies: [
-      SimpleMempoolRunner.defaultMoniker
-    ],
+    satisfies: [SimpleMempoolRunner.defaultMoniker],
     tier: 1,
-    backings: [
-      {
-        backing: "mempool-store",
-        mode: "write"
-      }
-    ],
+    backings: [{ backing: "mempool-store", mode: "write" }],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => {
+    build: (ctx) => {
       const { maxPendingTransactions } = readMempoolTuning(ctx);
-      return SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, {
-        pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
-        pendingBlocksArchivist: ctx.process.pendingBlocksArchivist,
-        maxPendingTransactions
-      });
-    }, "build")
+      return SimpleMempoolRunner.factory(
+        SimpleMempoolRunner.dependencies,
+        {
+          pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
+          pendingBlocksArchivist: ctx.process.pendingBlocksArchivist,
+          maxPendingTransactions
+        }
+      );
+    }
   },
   {
     id: "SimpleAccountBalanceViewer",
-    satisfies: [
-      SimpleAccountBalanceViewer.defaultMoniker
-    ],
+    satisfies: [SimpleAccountBalanceViewer.defaultMoniker],
     tier: 1,
-    backings: [
-      {
-        backing: "indexer-store",
-        mode: "read"
-      }
-    ],
+    backings: [{ backing: "indexer-store", mode: "read" }],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleAccountBalanceViewer.factory(SimpleAccountBalanceViewer.dependencies, {
-      balancesSummaryMap: ctx.process.balancesSummaryMap,
-      transfersSummaryMap: ctx.process.transfersSummaryMap
-    }), "build")
+    build: (ctx) => SimpleAccountBalanceViewer.factory(
+      SimpleAccountBalanceViewer.dependencies,
+      {
+        balancesSummaryMap: ctx.process.balancesSummaryMap,
+        transfersSummaryMap: ctx.process.transfersSummaryMap
+      }
+    )
   },
   {
     id: "SimpleFinalizationViewer",
-    satisfies: [
-      SimpleFinalizationViewer.defaultMoniker
-    ],
+    satisfies: [SimpleFinalizationViewer.defaultMoniker],
     tier: 1,
-    backings: [
-      {
-        backing: "chain-store",
-        mode: "read"
-      }
-    ],
+    backings: [{ backing: "chain-store", mode: "read" }],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, {
-      finalizedArchivist: ctx.process.readonlyChainArchivist
-    }), "build")
+    build: (ctx) => SimpleFinalizationViewer.factory(
+      SimpleFinalizationViewer.dependencies,
+      { finalizedArchivist: ctx.process.readonlyChainArchivist }
+    )
   },
   {
     id: "SimpleBlockViewer",
-    satisfies: [
-      SimpleBlockViewer.defaultMoniker
-    ],
+    satisfies: [SimpleBlockViewer.defaultMoniker],
     tier: 1,
-    backings: [
-      {
-        backing: "chain-store",
-        mode: "read"
-      }
-    ],
+    backings: [{ backing: "chain-store", mode: "read" }],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleBlockViewer.factory(SimpleBlockViewer.dependencies, {
-      finalizedArchivist: ctx.process.readonlyChainArchivist
-    }), "build")
+    build: (ctx) => SimpleBlockViewer.factory(
+      SimpleBlockViewer.dependencies,
+      { finalizedArchivist: ctx.process.readonlyChainArchivist }
+    )
   },
   {
     id: "SimpleWindowedBlockViewer",
-    satisfies: [
-      SimpleWindowedBlockViewer.defaultMoniker
-    ],
+    satisfies: [SimpleWindowedBlockViewer.defaultMoniker],
     tier: 1,
     backings: [],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name(() => SimpleWindowedBlockViewer.factory(SimpleWindowedBlockViewer.dependencies, {
-      maxWindowSize: 1e3,
-      syncInterval: 1e4
-    }), "build")
+    build: () => SimpleWindowedBlockViewer.factory(
+      SimpleWindowedBlockViewer.dependencies,
+      { maxWindowSize: 1e3, syncInterval: 1e4 }
+    )
   },
   {
     id: "SimpleXyoConnectionViewer",
-    satisfies: [
-      SimpleXyoConnectionViewer.defaultMoniker
-    ],
+    satisfies: [SimpleXyoConnectionViewer.defaultMoniker],
     tier: 1,
     backings: [],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name(() => SimpleXyoConnectionViewer.factory(SimpleXyoConnectionViewer.dependencies, {}), "build")
+    build: () => SimpleXyoConnectionViewer.factory(SimpleXyoConnectionViewer.dependencies, {})
   },
   {
     id: "SimpleTransactionViewer",
-    satisfies: [
-      SimpleTransactionViewer.defaultMoniker
-    ],
+    satisfies: [SimpleTransactionViewer.defaultMoniker],
     tier: 1,
     backings: [],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name(() => SimpleTransactionViewer.factory(SimpleTransactionViewer.dependencies, {}), "build")
+    build: () => SimpleTransactionViewer.factory(SimpleTransactionViewer.dependencies, {})
   },
   {
     id: "SimpleXyoViewer",
-    satisfies: [
-      SimpleXyoViewer.defaultMoniker
-    ],
+    satisfies: [SimpleXyoViewer.defaultMoniker],
     tier: 1,
     backings: [],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name(() => SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {}), "build")
+    build: () => SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {})
   },
   {
     id: "SimpleFinalizationRunner",
-    satisfies: [
-      SimpleFinalizationRunner.defaultMoniker
-    ],
+    satisfies: [SimpleFinalizationRunner.defaultMoniker],
     tier: 1,
-    backings: [
-      {
-        backing: "chain-store",
-        mode: "write"
-      }
-    ],
+    backings: [{ backing: "chain-store", mode: "write" }],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleFinalizationRunner.factory(SimpleFinalizationRunner.dependencies, {
-      finalizedArchivist: ctx.process.writableChainArchivist
-    }), "build")
+    build: (ctx) => SimpleFinalizationRunner.factory(
+      SimpleFinalizationRunner.dependencies,
+      { finalizedArchivist: ctx.process.writableChainArchivist }
+    )
   },
   {
     id: "SimpleBlockValidationViewer",
-    satisfies: [
-      SimpleBlockValidationViewer.defaultMoniker
-    ],
+    satisfies: [SimpleBlockValidationViewer.defaultMoniker],
     tier: 1,
     backings: [],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
-      state: ctx.process.blockStateValidator,
-      protocol: ctx.process.blockProtocolValidator
-    }), "build")
+    build: (ctx) => SimpleBlockValidationViewer.factory(
+      SimpleBlockValidationViewer.dependencies,
+      {
+        state: ctx.process.blockStateValidator,
+        protocol: ctx.process.blockProtocolValidator
+      }
+    )
   },
   {
     id: "SimpleTransactionValidationViewer",
-    satisfies: [
-      SimpleTransactionValidationViewer.defaultMoniker
-    ],
+    satisfies: [SimpleTransactionValidationViewer.defaultMoniker],
     tier: 1,
     backings: [],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleTransactionValidationViewer.factory(SimpleTransactionValidationViewer.dependencies, {
-      protocol: ctx.process.transactionProtocolValidator,
-      state: ctx.process.transactionStateValidator
-    }), "build")
+    build: (ctx) => SimpleTransactionValidationViewer.factory(
+      SimpleTransactionValidationViewer.dependencies,
+      {
+        protocol: ctx.process.transactionProtocolValidator,
+        state: ctx.process.transactionStateValidator
+      }
+    )
   },
   {
     id: "SimpleDeadLetterQueueRunner",
-    satisfies: [
-      SimpleDeadLetterQueueRunner.defaultMoniker
-    ],
+    satisfies: [SimpleDeadLetterQueueRunner.defaultMoniker],
     tier: 1,
-    backings: [
-      {
-        backing: "dlq-store",
-        mode: "write"
-      }
-    ],
+    backings: [{ backing: "dlq-store", mode: "write" }],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleDeadLetterQueueRunner.factory(SimpleDeadLetterQueueRunner.dependencies, {
-      rejectedBlocksArchivist: ctx.process.rejectedBlocksArchivist,
-      rejectedTransactionsArchivist: ctx.process.rejectedTransactionsArchivist
-    }), "build")
+    build: (ctx) => SimpleDeadLetterQueueRunner.factory(
+      SimpleDeadLetterQueueRunner.dependencies,
+      {
+        rejectedBlocksArchivist: ctx.process.rejectedBlocksArchivist,
+        rejectedTransactionsArchivist: ctx.process.rejectedTransactionsArchivist
+      }
+    )
   },
   {
     id: "SimpleDeadLetterQueueViewer",
-    satisfies: [
-      SimpleDeadLetterQueueViewer.defaultMoniker
-    ],
+    satisfies: [SimpleDeadLetterQueueViewer.defaultMoniker],
     tier: 1,
-    backings: [
-      {
-        backing: "dlq-store",
-        mode: "read"
-      }
-    ],
+    backings: [{ backing: "dlq-store", mode: "read" }],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleDeadLetterQueueViewer.factory(SimpleDeadLetterQueueViewer.dependencies, {
-      rejectedBlocksArchivist: ctx.process.rejectedBlocksArchivist,
-      rejectedTransactionsArchivist: ctx.process.rejectedTransactionsArchivist
-    }), "build")
+    build: (ctx) => SimpleDeadLetterQueueViewer.factory(
+      SimpleDeadLetterQueueViewer.dependencies,
+      {
+        rejectedBlocksArchivist: ctx.process.rejectedBlocksArchivist,
+        rejectedTransactionsArchivist: ctx.process.rejectedTransactionsArchivist
+      }
+    )
   },
   {
     id: "SimpleRejectedTransactionsArchivistProvider",
-    satisfies: [
-      SimpleRejectedTransactionsArchivistProvider.defaultMoniker
-    ],
+    satisfies: [SimpleRejectedTransactionsArchivistProvider.defaultMoniker],
     tier: 1,
-    backings: [
-      {
-        backing: "dlq-store",
-        mode: "read"
-      }
-    ],
+    backings: [{ backing: "dlq-store", mode: "read" }],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleRejectedTransactionsArchivistProvider.factory(SimpleRejectedTransactionsArchivistProvider.dependencies, {
-      archivist: ctx.process.rejectedTransactionsArchivist
-    }), "build")
+    build: (ctx) => SimpleRejectedTransactionsArchivistProvider.factory(
+      SimpleRejectedTransactionsArchivistProvider.dependencies,
+      { archivist: ctx.process.rejectedTransactionsArchivist }
+    )
   }
 ];
 
@@ -1642,7 +1571,11 @@ var localTier1Descriptors = [
 import { ProviderFactoryLocator } from "@xyo-network/xl1-sdk";
 
 // src/node/config/capabilities/networkTier3Descriptors.ts
-import { indexedNetworkDescriptors, networkTier3Descriptors, nodeNetworkDescriptors } from "@xyo-network/xl1-sdk";
+import {
+  indexedNetworkDescriptors,
+  networkTier3Descriptors,
+  nodeNetworkDescriptors
+} from "@xyo-network/xl1-sdk";
 
 // src/node/init/initBalanceSummaryMap.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
@@ -1652,7 +1585,13 @@ import { hasMongoConfig, MemoryMap } from "@xyo-network/xl1-sdk";
 async function initBalanceSummaryMap({ logger, config }) {
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig(mongoConfig)) {
-    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const {
+      connectionString: dbConnectionString,
+      database: dbName,
+      domain: dbDomain,
+      password: dbPassword,
+      username: dbUserName
+    } = mongoConfig;
     const payloadSdkConfig = {
       dbConnectionString,
       dbDomain,
@@ -1660,16 +1599,10 @@ async function initBalanceSummaryMap({ logger, config }) {
       dbPassword,
       dbUserName
     };
-    const sdkBalanceSummaryMap = new BaseMongoSdk({
-      ...payloadSdkConfig,
-      collection: "balance_summary_map"
-    });
+    const sdkBalanceSummaryMap = new BaseMongoSdk({ ...payloadSdkConfig, collection: "balance_summary_map" });
     const result = await MongoMap.create({
       sdk: sdkBalanceSummaryMap,
-      getCache: {
-        enabled: true,
-        maxEntries: 5e3
-      }
+      getCache: { enabled: true, maxEntries: 5e3 }
     });
     assertEx5(await result.start(), () => "Failed to start transfer summary map");
     return result;
@@ -1678,13 +1611,24 @@ async function initBalanceSummaryMap({ logger, config }) {
     return new MemoryMap();
   }
 }
-__name(initBalanceSummaryMap, "initBalanceSummaryMap");
 
 // src/node/init/initEvmProvidersIfAvailable.ts
 import { asEthAddress } from "@xylabs/sdk-js";
-import { EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeTotalsViewer, EvmStakeViewer } from "@xyo-network/chain-ethereum";
+import {
+  EvmChainContractViewer,
+  EvmStakeEventsViewer,
+  EvmStakeTotalsViewer,
+  EvmStakeViewer
+} from "@xyo-network/chain-ethereum";
 import { canUseEvmProvider, initEvmProvider } from "@xyo-network/chain-orchestration-evm";
-import { SimpleChainContractViewer, SimpleStakeEventsViewer, SimpleStakeTotalsViewer, SimpleStakeViewer, SimpleTimeSyncViewer, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
+import {
+  SimpleChainContractViewer,
+  SimpleStakeEventsViewer,
+  SimpleStakeTotalsViewer,
+  SimpleStakeViewer,
+  SimpleTimeSyncViewer,
+  XYO_ZERO_ADDRESS
+} from "@xyo-network/xl1-sdk";
 async function initEvmProvidersIfAvailable(locator) {
   const context = locator.context;
   const { logger } = context;
@@ -1692,51 +1636,66 @@ async function initEvmProvidersIfAvailable(locator) {
     const chainId = context.config.chain.id;
     const provider = await initEvmProvider(context);
     const address = asEthAddress(chainId, true);
-    locator.register(EvmStakeEventsViewer.factory(EvmStakeEventsViewer.dependencies, {
-      address,
-      provider
-    }));
-    locator.register(EvmStakeViewer.factory(EvmStakeViewer.dependencies, {
-      address,
-      provider
-    }));
-    locator.register(EvmStakeTotalsViewer.factory(EvmStakeTotalsViewer.dependencies, {
-      address,
-      provider
-    }));
-    locator.register(EvmChainContractViewer.factory(EvmChainContractViewer.dependencies, {
-      address,
-      provider
-    }));
-    locator.register(SimpleTimeSyncViewer.factory(SimpleTimeSyncViewer.dependencies, {
-      ethProvider: provider
-    }));
+    locator.register(EvmStakeEventsViewer.factory(
+      EvmStakeEventsViewer.dependencies,
+      { address, provider }
+    ));
+    locator.register(EvmStakeViewer.factory(
+      EvmStakeViewer.dependencies,
+      { address, provider }
+    ));
+    locator.register(EvmStakeTotalsViewer.factory(
+      EvmStakeTotalsViewer.dependencies,
+      { address, provider }
+    ));
+    locator.register(EvmChainContractViewer.factory(
+      EvmChainContractViewer.dependencies,
+      { address, provider }
+    ));
+    locator.register(SimpleTimeSyncViewer.factory(
+      SimpleTimeSyncViewer.dependencies,
+      { ethProvider: provider }
+    ));
   } else {
     logger?.warn("EVM provider not available - running with memory based contract/stake viewers");
     const positions = [];
-    locator.register(SimpleStakeEventsViewer.factory(SimpleStakeEventsViewer.dependencies, {
-      positions
-    }));
-    locator.register(SimpleStakeViewer.factory(SimpleStakeViewer.dependencies, {
-      positions
-    }));
-    locator.register(SimpleStakeTotalsViewer.factory(SimpleStakeTotalsViewer.dependencies, {}));
-    locator.register(SimpleChainContractViewer.factory(SimpleChainContractViewer.dependencies, {
-      minWithdrawalBlocks: 10,
-      stakingTokenAddress: XYO_ZERO_ADDRESS,
-      rewardsContract: XYO_ZERO_ADDRESS
-    }));
-    locator.register(SimpleTimeSyncViewer.factory(SimpleTimeSyncViewer.dependencies, {}));
+    locator.register(SimpleStakeEventsViewer.factory(
+      SimpleStakeEventsViewer.dependencies,
+      { positions }
+    ));
+    locator.register(SimpleStakeViewer.factory(
+      SimpleStakeViewer.dependencies,
+      { positions }
+    ));
+    locator.register(SimpleStakeTotalsViewer.factory(
+      SimpleStakeTotalsViewer.dependencies,
+      {}
+    ));
+    locator.register(SimpleChainContractViewer.factory(
+      SimpleChainContractViewer.dependencies,
+      {
+        minWithdrawalBlocks: 10,
+        stakingTokenAddress: XYO_ZERO_ADDRESS,
+        rewardsContract: XYO_ZERO_ADDRESS
+      }
+    ));
+    locator.register(SimpleTimeSyncViewer.factory(
+      SimpleTimeSyncViewer.dependencies,
+      {}
+    ));
   }
   return locator;
 }
-__name(initEvmProvidersIfAvailable, "initEvmProvidersIfAvailable");
 
 // src/node/init/initFinalizationArchivistIfNeeded.ts
 import { assertEx as assertEx6 } from "@xylabs/sdk-js";
 import { createBootstrapHead } from "@xyo-network/chain-sdk";
 import { Account } from "@xyo-network/sdk-js";
-import { asAttoXL1, findMostRecentBlock, flattenHydratedBlock } from "@xyo-network/xl1-sdk";
+import {
+  asAttoXL1,
+  findMostRecentBlock,
+  flattenHydratedBlock
+} from "@xyo-network/xl1-sdk";
 async function initFinalizationArchivistIfNeeded(archivist, config, account, options = {}) {
   const configuredChainId = config.chain.id;
   const possibleHead = await findMostRecentBlock(archivist);
@@ -1752,18 +1711,19 @@ async function initFinalizationArchivistIfNeeded(archivist, config, account, opt
       if (options.onInsecureGenesisConfirm) await options.onInsecureGenesisConfirm();
     }
     const genesisRewardAddress = await resolveGenesisRewardAddress(config);
-    const chain = await createBootstrapHead(account, possibleChainId, asAttoXL1(GENESIS_REWARD_AMOUNT), genesisRewardAddress);
+    const chain = await createBootstrapHead(
+      account,
+      possibleChainId,
+      asAttoXL1(GENESIS_REWARD_AMOUNT),
+      genesisRewardAddress
+    );
     const payloads = chain.flatMap((block) => flattenHydratedBlock(block));
     await archivist.insert(payloads);
   }
   const head = possibleHead ?? assertEx6(await findMostRecentBlock(archivist), () => "No blocks found in chain archivist");
   const chainId = assertEx6(possibleChainId, () => "Chain ID could not be determined");
-  return [
-    head,
-    chainId
-  ];
+  return [head, chainId];
 }
-__name(initFinalizationArchivistIfNeeded, "initFinalizationArchivistIfNeeded");
 
 // src/node/init/initFinalizedArchivist.ts
 import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
@@ -1772,16 +1732,12 @@ async function initMongoFinalizedArchivist(config) {
     ...config.storage.mongo,
     collection: "chain_validated"
   };
-  return await MongoDBArchivistV2.create({
-    payloadSdkConfig
-  });
+  return await MongoDBArchivistV2.create({ payloadSdkConfig });
 }
-__name(initMongoFinalizedArchivist, "initMongoFinalizedArchivist");
 async function initFinalizedArchivist(config) {
   const finalizedArchivist = await initMongoFinalizedArchivist(config);
   return finalizedArchivist;
 }
-__name(initFinalizedArchivist, "initFinalizedArchivist");
 
 // src/node/init/initServerNode.ts
 import { assertEx as assertEx7 } from "@xylabs/sdk-js";
@@ -1792,15 +1748,18 @@ import { isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { LmdbArchivistConfigSchema } from "@xyo-network/archivist-lmdb";
 import { MongoDBArchivistV2 as MongoDBArchivistV22, MongoDBArchivistV2Deletable } from "@xyo-network/archivist-mongodb";
 import { ViewArchivist } from "@xyo-network/archivist-view";
-import { AbstractModule, LoggerModuleStatusReporter, MemoryArchivist, MemorySentinel, ModuleFactoryLocator } from "@xyo-network/sdk-js";
+import {
+  AbstractModule,
+  LoggerModuleStatusReporter,
+  MemoryArchivist,
+  MemorySentinel,
+  ModuleFactoryLocator
+} from "@xyo-network/sdk-js";
 import { hasMongoConfig as hasMongoConfig2 } from "@xyo-network/xl1-sdk";
 
 // src/node/manifest/NamedLmdbArchivist.ts
 import { LmdbArchivist } from "@xyo-network/archivist-lmdb";
 var NamedLmdbArchivist = class extends LmdbArchivist {
-  static {
-    __name(this, "NamedLmdbArchivist");
-  }
   get dbName() {
     return this.config.dbName ?? "xyo-chain";
   }
@@ -1820,13 +1779,24 @@ var NamedLmdbArchivist = class extends LmdbArchivist {
 };
 
 // src/node/manifest/getLocator.ts
-var getLocator = /* @__PURE__ */ __name(async ({ logger, traceProvider, meterProvider, config }) => {
+var getLocator = async ({
+  logger,
+  traceProvider,
+  meterProvider,
+  config
+}) => {
   if (isDefined2(logger)) AbstractModule.defaultLogger = logger;
   const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
   const locator = new ModuleFactoryLocator();
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig2(mongoConfig)) {
-    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const {
+      connectionString: dbConnectionString,
+      database: dbName,
+      domain: dbDomain,
+      password: dbPassword,
+      username: dbUserName
+    } = mongoConfig;
     const payloadSdkConfig = {
       dbConnectionString,
       dbDomain,
@@ -1841,9 +1811,7 @@ var getLocator = /* @__PURE__ */ __name(async ({ logger, traceProvider, meterPro
       traceProvider
     };
     locator.register(MongoDBArchivistV22.factory(params), void 0, true);
-    locator.register(MongoDBArchivistV2Deletable.factory(params), {
-      "network.xyo.storage.capabilities.delete": "enabled"
-    }, false);
+    locator.register(MongoDBArchivistV2Deletable.factory(params), { "network.xyo.storage.capabilities.delete": "enabled" }, false);
   } else if (isDefined2(config.storage?.root)) {
     const lmdbLocation = config.storage.root;
     const lmdbConfig = {
@@ -1851,12 +1819,16 @@ var getLocator = /* @__PURE__ */ __name(async ({ logger, traceProvider, meterPro
       location: lmdbLocation,
       schema: LmdbArchivistConfigSchema
     };
-    locator.register(NamedLmdbArchivist.factory({
-      config: lmdbConfig,
-      meterProvider,
-      statusReporter,
-      traceProvider
-    }), void 0, true);
+    locator.register(
+      NamedLmdbArchivist.factory({
+        config: lmdbConfig,
+        meterProvider,
+        statusReporter,
+        traceProvider
+      }),
+      void 0,
+      true
+    );
   }
   locator.register(MemoryArchivist.factory({
     traceProvider,
@@ -1874,7 +1846,7 @@ var getLocator = /* @__PURE__ */ __name(async ({ logger, traceProvider, meterPro
     statusReporter
   }));
   return locator;
-}, "getLocator");
+};
 
 // src/node/manifest/loadNode.ts
 import { ManifestWrapper } from "@xyo-network/sdk-js";
@@ -2078,7 +2050,7 @@ var PublicChildManifests = [
 ];
 
 // src/node/manifest/loadNode.ts
-var loadNode = /* @__PURE__ */ __name(async (context, wallet) => {
+var loadNode = async (context, wallet) => {
   const locator = await getLocator(context);
   const wrapper = new ManifestWrapper(NodeManifest, wallet, locator, PublicChildManifests, PrivateChildManifests);
   const [node, ...childNodes] = await wrapper.loadNodes();
@@ -2087,45 +2059,45 @@ var loadNode = /* @__PURE__ */ __name(async (context, wallet) => {
     await Promise.all(childNodes.map((childNode) => node.attach(childNode.address, true)));
   }
   return node;
-}, "loadNode");
+};
 
 // src/node/init/initServerNode.ts
 async function writableChainArchivistFromNode(node) {
-  return asArchivistInstance(await node.resolve("Chain:Validated"), {
-    required: true
-  });
+  return asArchivistInstance(
+    await node.resolve("Chain:Validated"),
+    { required: true }
+  );
 }
-__name(writableChainArchivistFromNode, "writableChainArchivistFromNode");
 async function readonlyChainArchivistFromNode(node) {
-  return assertEx7(asArchivistInstance(await node.resolve("Chain:Validated"), {
-    required: true
-  }));
+  return assertEx7(asArchivistInstance(
+    await node.resolve("Chain:Validated"),
+    { required: true }
+  ));
 }
-__name(readonlyChainArchivistFromNode, "readonlyChainArchivistFromNode");
 async function pendingTransactionsArchivistFromNode(node) {
-  return asArchivistInstance(await node.resolve("XYOChain:Pending:Transactions"), {
-    required: true
-  });
+  return asArchivistInstance(
+    await node.resolve("XYOChain:Pending:Transactions"),
+    { required: true }
+  );
 }
-__name(pendingTransactionsArchivistFromNode, "pendingTransactionsArchivistFromNode");
 async function pendingBlocksArchivistFromNode(node) {
-  return asArchivistInstance(await node.resolve("XYOChain:Pending:Blocks"), {
-    required: true
-  });
+  return asArchivistInstance(
+    await node.resolve("XYOChain:Pending:Blocks"),
+    { required: true }
+  );
 }
-__name(pendingBlocksArchivistFromNode, "pendingBlocksArchivistFromNode");
 async function rejectedBlocksArchivistFromNode(node) {
-  return asArchivistInstance(await node.resolve("XYOChain:DeadLetterQueue:RejectedBlocks"), {
-    required: true
-  });
+  return asArchivistInstance(
+    await node.resolve("XYOChain:DeadLetterQueue:RejectedBlocks"),
+    { required: true }
+  );
 }
-__name(rejectedBlocksArchivistFromNode, "rejectedBlocksArchivistFromNode");
 async function rejectedTransactionsArchivistFromNode(node) {
-  return asArchivistInstance(await node.resolve("XYOChain:DeadLetterQueue:RejectedTransactions"), {
-    required: true
-  });
+  return asArchivistInstance(
+    await node.resolve("XYOChain:DeadLetterQueue:RejectedTransactions"),
+    { required: true }
+  );
 }
-__name(rejectedTransactionsArchivistFromNode, "rejectedTransactionsArchivistFromNode");
 async function initServerNode(context, wallet, providedNode) {
   const node = providedNode ?? await loadNode(context, wallet);
   assertEx7(await node.start(), () => "Failed to start node");
@@ -2145,7 +2117,6 @@ async function initServerNode(context, wallet, providedNode) {
     rejectedTransactionsArchivist
   };
 }
-__name(initServerNode, "initServerNode");
 
 // src/node/init/initTransferSummaryMap.ts
 import { BaseMongoSdk as BaseMongoSdk2 } from "@xylabs/mongo";
@@ -2155,7 +2126,13 @@ import { hasMongoConfig as hasMongoConfig3, MemoryMap as MemoryMap2 } from "@xyo
 async function initTransferSummaryMap({ logger, config }) {
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig3(mongoConfig)) {
-    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const {
+      connectionString: dbConnectionString,
+      database: dbName,
+      domain: dbDomain,
+      password: dbPassword,
+      username: dbUserName
+    } = mongoConfig;
     const payloadSdkConfig = {
       dbConnectionString,
       dbDomain,
@@ -2163,16 +2140,10 @@ async function initTransferSummaryMap({ logger, config }) {
       dbPassword,
       dbUserName
     };
-    const sdkTransferSummaryMap = new BaseMongoSdk2({
-      ...payloadSdkConfig,
-      collection: "transfer_summary_map"
-    });
+    const sdkTransferSummaryMap = new BaseMongoSdk2({ ...payloadSdkConfig, collection: "transfer_summary_map" });
     const result = await MongoMap2.create({
       sdk: sdkTransferSummaryMap,
-      getCache: {
-        enabled: true,
-        maxEntries: 5e3
-      }
+      getCache: { enabled: true, maxEntries: 5e3 }
     });
     assertEx8(await result.start(), () => "Failed to start transfer summary map");
     return result;
@@ -2181,26 +2152,24 @@ async function initTransferSummaryMap({ logger, config }) {
     return new MemoryMap2();
   }
 }
-__name(initTransferSummaryMap, "initTransferSummaryMap");
 
 // src/node/config/capabilities/backings/buildChainStoreBacking.ts
 import { asArchivistInstance as asArchivistInstance2 } from "@xyo-network/sdk-js";
 async function buildChainStoreBacking(node, mode, options) {
-  const readonlyArchivist = asArchivistInstance2(await node.resolve("Chain:Validated"), {
-    required: true
-  });
+  const readonlyArchivist = asArchivistInstance2(
+    await node.resolve("Chain:Validated"),
+    { required: true }
+  );
   if (mode === "read") {
-    return {
-      mode,
-      readonlyArchivist
-    };
+    return { mode, readonlyArchivist };
   }
   if (!options) {
     throw new Error("buildChainStoreBacking(write) requires options { actorConfig, wallet }");
   }
-  const writableArchivist = asArchivistInstance2(await node.resolve("Chain:Validated"), {
-    required: true
-  });
+  const writableArchivist = asArchivistInstance2(
+    await node.resolve("Chain:Validated"),
+    { required: true }
+  );
   await initFinalizationArchivistIfNeeded(writableArchivist, options.actorConfig, options.wallet, {
     logger: options.logger,
     onInsecureGenesisConfirm: options.onInsecureGenesisConfirm
@@ -2211,24 +2180,24 @@ async function buildChainStoreBacking(node, mode, options) {
     writableArchivist
   };
 }
-__name(buildChainStoreBacking, "buildChainStoreBacking");
 
 // src/node/config/capabilities/backings/buildDlqStoreBacking.ts
 import { asArchivistInstance as asArchivistInstance3 } from "@xyo-network/sdk-js";
 async function buildDlqStoreBacking(node, mode) {
-  const rejectedBlocksArchivist = asArchivistInstance3(await node.resolve("XYOChain:DeadLetterQueue:RejectedBlocks"), {
-    required: true
-  });
-  const rejectedTransactionsArchivist = asArchivistInstance3(await node.resolve("XYOChain:DeadLetterQueue:RejectedTransactions"), {
-    required: true
-  });
+  const rejectedBlocksArchivist = asArchivistInstance3(
+    await node.resolve("XYOChain:DeadLetterQueue:RejectedBlocks"),
+    { required: true }
+  );
+  const rejectedTransactionsArchivist = asArchivistInstance3(
+    await node.resolve("XYOChain:DeadLetterQueue:RejectedTransactions"),
+    { required: true }
+  );
   return {
     mode,
     rejectedBlocksArchivist,
     rejectedTransactionsArchivist
   };
 }
-__name(buildDlqStoreBacking, "buildDlqStoreBacking");
 
 // src/node/config/capabilities/backings/buildIndexerStoreBacking.ts
 import { assertEx as assertEx9 } from "@xylabs/sdk-js";
@@ -2241,39 +2210,40 @@ async function buildIndexerStoreBacking(context, mode) {
     transfersSummaryMap
   };
 }
-__name(buildIndexerStoreBacking, "buildIndexerStoreBacking");
 
 // src/node/config/capabilities/backings/buildMempoolStoreBacking.ts
 import { asArchivistInstance as asArchivistInstance4 } from "@xyo-network/sdk-js";
 async function buildMempoolStoreBacking(node, mode) {
-  const pendingTransactionsArchivist = asArchivistInstance4(await node.resolve("XYOChain:Pending:Transactions"), {
-    required: true
-  });
-  const pendingBlocksArchivist = asArchivistInstance4(await node.resolve("XYOChain:Pending:Blocks"), {
-    required: true
-  });
+  const pendingTransactionsArchivist = asArchivistInstance4(
+    await node.resolve("XYOChain:Pending:Transactions"),
+    { required: true }
+  );
+  const pendingBlocksArchivist = asArchivistInstance4(
+    await node.resolve("XYOChain:Pending:Blocks"),
+    { required: true }
+  );
   return {
     mode,
     pendingBlocksArchivist,
     pendingTransactionsArchivist
   };
 }
-__name(buildMempoolStoreBacking, "buildMempoolStoreBacking");
 
 // src/node/config/capabilities/backings/buildValidators.ts
-import { validateHydratedBlock, validateHydratedBlockState, validateHydratedTransactionState } from "@xyo-network/chain-validation";
+import {
+  validateHydratedBlock,
+  validateHydratedBlockState,
+  validateHydratedTransactionState
+} from "@xyo-network/chain-validation";
 import { BlockCumulativeBalanceValidatorFactory, validateTransaction } from "@xyo-network/xl1-sdk";
 var cumulativeBalanceValidator = BlockCumulativeBalanceValidatorFactory();
-var validateHydratedBlockStateWithCumulativeBalance = /* @__PURE__ */ __name(async (context, block) => {
+var validateHydratedBlockStateWithCumulativeBalance = async (context, block) => {
   const [stateErrors, cumulativeErrors] = await Promise.all([
     validateHydratedBlockState(context, block),
     cumulativeBalanceValidator(context, block)
   ]);
-  return [
-    ...stateErrors,
-    ...cumulativeErrors
-  ];
-}, "validateHydratedBlockStateWithCumulativeBalance");
+  return [...stateErrors, ...cumulativeErrors];
+};
 function buildValidators() {
   return {
     blockProtocolValidator: validateHydratedBlock,
@@ -2282,7 +2252,6 @@ function buildValidators() {
     transactionStateValidator: validateHydratedTransactionState
   };
 }
-__name(buildValidators, "buildValidators");
 
 // src/node/config/capabilities/ProcessSharedResources.ts
 async function buildProcessSharedResources(context, options) {
@@ -2318,7 +2287,6 @@ async function buildProcessSharedResources(context, options) {
     writableChainArchivist: chainStore.writableArchivist
   };
 }
-__name(buildProcessSharedResources, "buildProcessSharedResources");
 
 // src/node/config/capabilities/resolveProviders.ts
 import { MissingCapabilityError, resolveProviders } from "@xyo-network/xl1-protocol-sdk";
@@ -2338,9 +2306,12 @@ async function locatorFromActorNeeds(context, actorNeeds, options = {}) {
     ...networkTier3Descriptors,
     ...options.extraDescriptors ?? []
   ];
-  const plan = resolveProviders(needs, candidates, resolutionContext, {
-    availableBackings: options.availableBackings
-  });
+  const plan = resolveProviders(
+    needs,
+    candidates,
+    resolutionContext,
+    { availableBackings: options.availableBackings }
+  );
   const locator = new ProviderFactoryLocator(context, {}, options.validateDepsOnRegister ?? false);
   const factories = plan.selected.map((d) => d.build(resolutionContext)).filter((f) => f !== void 0);
   locator.registerMany(factories);
@@ -2350,7 +2321,6 @@ async function locatorFromActorNeeds(context, actorNeeds, options = {}) {
     process: process2
   };
 }
-__name(locatorFromActorNeeds, "locatorFromActorNeeds");
 function unionNeeds(actorNeeds) {
   const result = /* @__PURE__ */ new Set();
   for (const needs of actorNeeds) {
@@ -2359,53 +2329,56 @@ function unionNeeds(actorNeeds) {
   }
   return result;
 }
-__name(unionNeeds, "unionNeeds");
 
 // src/node/config/locators/basicRemoteRunnerLocator.ts
 import { isAccountInstance } from "@xyo-network/sdk-js";
-import { basicRemoteRunnerLocator as sdkBasicRemoteRunnerLocator, JsonRpcAccountBalanceViewer, JsonRpcXyoSigner, SimpleXyoSigner } from "@xyo-network/xl1-sdk";
+import {
+  basicRemoteRunnerLocator as sdkBasicRemoteRunnerLocator,
+  JsonRpcAccountBalanceViewer,
+  JsonRpcXyoSigner,
+  SimpleXyoSigner
+} from "@xyo-network/xl1-sdk";
 function signerFactoryFromParam(signer) {
   if (isAccountInstance(signer)) {
-    return SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, {
-      account: signer
-    });
+    return SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, { account: signer });
   }
-  return JsonRpcXyoSigner.factory(JsonRpcXyoSigner.dependencies, {
-    transport: signer
-  });
+  return JsonRpcXyoSigner.factory(JsonRpcXyoSigner.dependencies, { transport: signer });
 }
-__name(signerFactoryFromParam, "signerFactoryFromParam");
 function basicRemoteRunnerLocator(name, remoteConfig, signer, dataLakeEndpoint, validators) {
   const transport = isAccountInstance(signer) ? void 0 : signer;
   return sdkBasicRemoteRunnerLocator(name, remoteConfig, transport, dataLakeEndpoint, {
     additionalProviders: [
-      JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {})
+      JsonRpcAccountBalanceViewer.factory(
+        JsonRpcAccountBalanceViewer.dependencies,
+        {}
+      )
     ],
     signerFactory: signerFactoryFromParam(signer),
     skipGatewayRunner: true,
     validators
   });
 }
-__name(basicRemoteRunnerLocator, "basicRemoteRunnerLocator");
 
 // src/node/config/locators/basicRemoteViewerLocator.ts
-import { basicRemoteViewerLocator as sdkBasicRemoteViewerLocator, JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer2 } from "@xyo-network/xl1-sdk";
+import {
+  basicRemoteViewerLocator as sdkBasicRemoteViewerLocator,
+  JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer2
+} from "@xyo-network/xl1-sdk";
 function basicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, validators) {
   return sdkBasicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, {
     additionalProviders: [
-      JsonRpcAccountBalanceViewer2.factory(JsonRpcAccountBalanceViewer2.dependencies, {})
+      JsonRpcAccountBalanceViewer2.factory(
+        JsonRpcAccountBalanceViewer2.dependencies,
+        {}
+      )
     ],
     validators
   });
 }
-__name(basicRemoteViewerLocator, "basicRemoteViewerLocator");
 
 // src/node/config/locators/buildStatelessApiLocator.ts
 var STATELESS_BACKINGS = [
-  {
-    backing: "network",
-    mode: "read"
-  }
+  { backing: "network", mode: "read" }
 ];
 async function buildStatelessApiLocator(context, needs) {
   const stubProcess = {};
@@ -2415,7 +2388,6 @@ async function buildStatelessApiLocator(context, needs) {
   });
   return result.locator;
 }
-__name(buildStatelessApiLocator, "buildStatelessApiLocator");
 
 // src/node/config/locators/telemetryContextFromConfig.ts
 import { initTelemetry } from "@xyo-network/chain-telemetry";
@@ -2428,22 +2400,16 @@ async function telemetryContextFromConfig(config, serviceName, serviceVersion, d
       serviceVersion
     },
     otlpEndpoint,
-    metricsConfig: {
-      endpoint,
-      port
-    }
+    metricsConfig: { endpoint, port }
   });
 }
-__name(telemetryContextFromConfig, "telemetryContextFromConfig");
 
 // src/node/config/locators/contextFromConfigWithoutLocator.ts
 async function contextFromConfigWithoutLocator(config, logger, serviceName, serviceVersion, defaultScrapePort) {
   const singletons = {};
   const caches = {};
   const telemetryConfig = await telemetryContextFromConfig(config, serviceName, serviceVersion, defaultScrapePort);
-  const statusReporter = initStatusReporter({
-    logger
-  });
+  const statusReporter = initStatusReporter({ logger });
   return {
     ...telemetryConfig,
     config,
@@ -2453,10 +2419,23 @@ async function contextFromConfigWithoutLocator(config, logger, serviceName, serv
     statusReporter
   };
 }
-__name(contextFromConfigWithoutLocator, "contextFromConfigWithoutLocator");
 
 // src/node/config/locators/localLocatorFromConfig.ts
-import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2, BlockValidationViewerMoniker as BlockValidationViewerMoniker2, BlockViewerMoniker as BlockViewerMoniker2, DeadLetterQueueRunnerMoniker as DeadLetterQueueRunnerMoniker2, DeadLetterQueueViewerMoniker as DeadLetterQueueViewerMoniker2, FinalizationRunnerMoniker as FinalizationRunnerMoniker2, FinalizationViewerMoniker as FinalizationViewerMoniker2, MempoolRunnerMoniker as MempoolRunnerMoniker2, MempoolViewerMoniker as MempoolViewerMoniker2, TransactionValidationViewerMoniker as TransactionValidationViewerMoniker2, TransactionViewerMoniker as TransactionViewerMoniker2, WindowedBlockViewerMoniker as WindowedBlockViewerMoniker2, XyoViewerMoniker as XyoViewerMoniker2 } from "@xyo-network/xl1-sdk";
+import {
+  AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2,
+  BlockValidationViewerMoniker as BlockValidationViewerMoniker2,
+  BlockViewerMoniker as BlockViewerMoniker2,
+  DeadLetterQueueRunnerMoniker as DeadLetterQueueRunnerMoniker2,
+  DeadLetterQueueViewerMoniker as DeadLetterQueueViewerMoniker2,
+  FinalizationRunnerMoniker as FinalizationRunnerMoniker2,
+  FinalizationViewerMoniker as FinalizationViewerMoniker2,
+  MempoolRunnerMoniker as MempoolRunnerMoniker2,
+  MempoolViewerMoniker as MempoolViewerMoniker2,
+  TransactionValidationViewerMoniker as TransactionValidationViewerMoniker2,
+  TransactionViewerMoniker as TransactionViewerMoniker2,
+  WindowedBlockViewerMoniker as WindowedBlockViewerMoniker2,
+  XyoViewerMoniker as XyoViewerMoniker2
+} from "@xyo-network/xl1-sdk";
 var XyoConnectionMoniker2 = "XyoConnection";
 var LOCAL_LEGACY_NEEDS = {
   required: [
@@ -2478,21 +2457,30 @@ var LOCAL_LEGACY_NEEDS = {
   ]
 };
 async function localLocatorFromConfig(context, validateDepsOnRegister = false, onInsecureGenesisConfirm) {
-  const result = await locatorFromActorNeeds(context, [
-    LOCAL_LEGACY_NEEDS
-  ], {
+  const result = await locatorFromActorNeeds(context, [LOCAL_LEGACY_NEEDS], {
     onInsecureGenesisConfirm,
     validateDepsOnRegister
   });
   return result.locator;
 }
-__name(localLocatorFromConfig, "localLocatorFromConfig");
 
 // src/node/config/locators/locatorsFromConfig.ts
 import { deepMerge as deepMerge3 } from "@xylabs/sdk-js";
 
 // src/node/config/locators/actors/apiLocatorFromConfig.ts
-import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3, BlockViewerMoniker as BlockViewerMoniker3, FinalizationViewerMoniker as FinalizationViewerMoniker3, MempoolViewerMoniker as MempoolViewerMoniker3, ProviderFactoryLocator as ProviderFactoryLocator2, SimpleXyoConnectionRunner, SimpleXyoGateway, SimpleXyoRunner, TransactionViewerMoniker as TransactionViewerMoniker3, XyoConnectionMoniker as XyoConnectionMoniker3, XyoViewerMoniker as XyoViewerMoniker3 } from "@xyo-network/xl1-sdk";
+import {
+  AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3,
+  BlockViewerMoniker as BlockViewerMoniker3,
+  FinalizationViewerMoniker as FinalizationViewerMoniker3,
+  MempoolViewerMoniker as MempoolViewerMoniker3,
+  ProviderFactoryLocator as ProviderFactoryLocator2,
+  SimpleXyoConnectionRunner,
+  SimpleXyoGateway,
+  SimpleXyoRunner,
+  TransactionViewerMoniker as TransactionViewerMoniker3,
+  XyoConnectionMoniker as XyoConnectionMoniker3,
+  XyoViewerMoniker as XyoViewerMoniker3
+} from "@xyo-network/xl1-sdk";
 var API_NEEDS = {
   required: [
     AccountBalanceViewerMoniker3,
@@ -2506,9 +2494,7 @@ var API_NEEDS = {
 };
 async function apiLocatorFromConfig(context, parent) {
   if (context.config.stateless) {
-    const locator2 = await buildStatelessApiLocator(context, [
-      API_NEEDS
-    ]);
+    const locator2 = await buildStatelessApiLocator(context, [API_NEEDS]);
     locator2.registerMany([
       SimpleXyoRunner.factory(SimpleXyoRunner.dependencies, {}),
       SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
@@ -2517,10 +2503,7 @@ async function apiLocatorFromConfig(context, parent) {
     locator2.freeze();
     return locator2;
   }
-  const locator = new ProviderFactoryLocator2({
-    ...context,
-    locator: parent
-  });
+  const locator = new ProviderFactoryLocator2({ ...context, locator: parent });
   locator.registerMany([
     SimpleXyoRunner.factory(SimpleXyoRunner.dependencies, {}),
     SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
@@ -2529,16 +2512,28 @@ async function apiLocatorFromConfig(context, parent) {
   locator.freeze();
   return locator;
 }
-__name(apiLocatorFromConfig, "apiLocatorFromConfig");
 
 // src/node/config/locators/actors/bridgeLocatorFromConfig.ts
 import { isDefined as isDefined3 } from "@xylabs/sdk-js";
-import { JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer3, JsonRpcBlockViewer, JsonRpcFinalizationViewer, JsonRpcMempoolRunner, JsonRpcMempoolViewer, JsonRpcXyoRunner, JsonRpcXyoViewer, ProviderFactoryLocator as ProviderFactoryLocator3, RestDataLakeRunner, RestDataLakeViewer, SimpleStakeEventsViewer as SimpleStakeEventsViewer2, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner2, SimpleXyoGatewayRunner, SimpleXyoRunner as SimpleXyoRunner2, SimpleXyoSigner as SimpleXyoSigner2 } from "@xyo-network/xl1-sdk";
+import {
+  JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer3,
+  JsonRpcBlockViewer,
+  JsonRpcFinalizationViewer,
+  JsonRpcMempoolRunner,
+  JsonRpcMempoolViewer,
+  JsonRpcXyoRunner,
+  JsonRpcXyoViewer,
+  ProviderFactoryLocator as ProviderFactoryLocator3,
+  RestDataLakeRunner,
+  RestDataLakeViewer,
+  SimpleStakeEventsViewer as SimpleStakeEventsViewer2,
+  SimpleXyoConnectionRunner as SimpleXyoConnectionRunner2,
+  SimpleXyoGatewayRunner,
+  SimpleXyoRunner as SimpleXyoRunner2,
+  SimpleXyoSigner as SimpleXyoSigner2
+} from "@xyo-network/xl1-sdk";
 async function bridgeLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator3({
-    ...context,
-    locator: parent
-  });
+  const locator = new ProviderFactoryLocator3({ ...context, locator: parent });
   const { config } = context;
   const { dataLake } = config;
   const signerAccount = await initActorWallet(context);
@@ -2546,8 +2541,14 @@ async function bridgeLocatorFromConfig(context, parent) {
     locator.registerMany([
       JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {}),
       JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, {}),
-      JsonRpcAccountBalanceViewer3.factory(JsonRpcAccountBalanceViewer3.dependencies, {}),
-      JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {}),
+      JsonRpcAccountBalanceViewer3.factory(
+        JsonRpcAccountBalanceViewer3.dependencies,
+        {}
+      ),
+      JsonRpcFinalizationViewer.factory(
+        JsonRpcFinalizationViewer.dependencies,
+        {}
+      ),
       JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, {}),
       JsonRpcXyoRunner.factory(JsonRpcXyoRunner.dependencies, {}),
       JsonRpcXyoViewer.factory(JsonRpcXyoViewer.dependencies, {})
@@ -2559,12 +2560,8 @@ async function bridgeLocatorFromConfig(context, parent) {
       case "rest": {
         const { url: endpoint } = dataLake;
         locator.registerMany([
-          RestDataLakeRunner.factory(RestDataLakeRunner.dependencies, {
-            endpoint
-          }),
-          RestDataLakeViewer.factory(RestDataLakeViewer.dependencies, {
-            endpoint
-          })
+          RestDataLakeRunner.factory(RestDataLakeRunner.dependencies, { endpoint }),
+          RestDataLakeViewer.factory(RestDataLakeViewer.dependencies, { endpoint })
         ]);
         break;
       }
@@ -2574,12 +2571,8 @@ async function bridgeLocatorFromConfig(context, parent) {
     }
   }
   locator.registerMany([
-    SimpleStakeEventsViewer2.factory(SimpleStakeEventsViewer2.dependencies, {
-      positions: []
-    }),
-    SimpleXyoSigner2.factory(SimpleXyoSigner2.dependencies, {
-      account: signerAccount
-    }),
+    SimpleStakeEventsViewer2.factory(SimpleStakeEventsViewer2.dependencies, { positions: [] }),
+    SimpleXyoSigner2.factory(SimpleXyoSigner2.dependencies, { account: signerAccount }),
     SimpleXyoRunner2.factory(SimpleXyoRunner2.dependencies, {}),
     SimpleXyoConnectionRunner2.factory(SimpleXyoConnectionRunner2.dependencies, {}),
     SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {})
@@ -2587,33 +2580,24 @@ async function bridgeLocatorFromConfig(context, parent) {
   locator.freeze();
   return locator;
 }
-__name(bridgeLocatorFromConfig, "bridgeLocatorFromConfig");
 
 // src/node/config/locators/actors/finalizerLocatorFromConfig.ts
 import { ProviderFactoryLocator as ProviderFactoryLocator4 } from "@xyo-network/xl1-sdk";
 function finalizerLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator4({
-    ...context,
-    locator: parent
-  });
+  const locator = new ProviderFactoryLocator4({ ...context, locator: parent });
   locator.registerMany([]);
   locator.freeze();
   return locator;
 }
-__name(finalizerLocatorFromConfig, "finalizerLocatorFromConfig");
 
 // src/node/config/locators/actors/mempoolLocatorFromConfig.ts
 import { ProviderFactoryLocator as ProviderFactoryLocator5 } from "@xyo-network/xl1-sdk";
 function mempoolLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator5({
-    ...context,
-    locator: parent
-  });
+  const locator = new ProviderFactoryLocator5({ ...context, locator: parent });
   locator.registerMany([]);
   locator.freeze();
   return locator;
 }
-__name(mempoolLocatorFromConfig, "mempoolLocatorFromConfig");
 
 // src/node/config/locators/actors/producerLocatorFromConfig.ts
 import { asAddress } from "@xylabs/sdk-js";
@@ -2622,57 +2606,72 @@ import { ProviderFactoryLocator as ProviderFactoryLocator6 } from "@xyo-network/
 async function producerLocatorFromConfig(context, parent) {
   const { logger, config } = context;
   const account = await initActorWallet(context);
-  const locator = new ProviderFactoryLocator6({
-    ...context,
-    locator: parent
-  });
+  const locator = new ProviderFactoryLocator6({ ...context, locator: parent });
   const rewardAddress = asAddress(config.rewardAddress ?? account.address, true);
   logger?.info(`Using reward address ${rewardAddress}`);
   if (rewardAddress === account.address) {
     logger?.warn(`Using producer account address as reward address: ${account.address}`);
   }
-  const rejectedTransactionsProvider = await parent?.tryGetInstance(RejectedTransactionsArchivistProviderMoniker);
+  const rejectedTransactionsProvider = await parent?.tryGetInstance(
+    RejectedTransactionsArchivistProviderMoniker
+  );
   const rejectedTransactionsArchivist = rejectedTransactionsProvider?.archivist;
   locator.registerMany([
-    SimpleBlockRunner.factory(SimpleBlockRunner.dependencies, {
-      account,
-      rewardAddress,
-      rejectedTransactionsArchivist,
-      // ProducerConfigZod has always exposed `heartbeatInterval`, but until now
-      // it was not wired anywhere. Threading it into the BlockRunner lets tests
-      // (and operators who want denser heartbeat blocks) override the 1-h default.
-      heartbeatInterval: config.heartbeatInterval
-    })
+    SimpleBlockRunner.factory(
+      SimpleBlockRunner.dependencies,
+      {
+        account,
+        rewardAddress,
+        rejectedTransactionsArchivist,
+        // ProducerConfigZod has always exposed `heartbeatInterval`, but until now
+        // it was not wired anywhere. Threading it into the BlockRunner lets tests
+        // (and operators who want denser heartbeat blocks) override the 1-h default.
+        heartbeatInterval: config.heartbeatInterval
+      }
+    )
   ]);
   locator.freeze();
   return locator;
 }
-__name(producerLocatorFromConfig, "producerLocatorFromConfig");
 
 // src/node/config/locators/actors/rewardRedemptionLocatorFromConfig.ts
-import { JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer4, JsonRpcBlockViewer as JsonRpcBlockViewer2, JsonRpcFinalizationViewer as JsonRpcFinalizationViewer2, JsonRpcMempoolRunner as JsonRpcMempoolRunner2, JsonRpcMempoolViewer as JsonRpcMempoolViewer2, JsonRpcXyoRunner as JsonRpcXyoRunner2, JsonRpcXyoViewer as JsonRpcXyoViewer2, ProviderFactoryLocator as ProviderFactoryLocator7, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner3, SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2, SimpleXyoRunner as SimpleXyoRunner3, SimpleXyoSigner as SimpleXyoSigner3 } from "@xyo-network/xl1-sdk";
+import {
+  JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer4,
+  JsonRpcBlockViewer as JsonRpcBlockViewer2,
+  JsonRpcFinalizationViewer as JsonRpcFinalizationViewer2,
+  JsonRpcMempoolRunner as JsonRpcMempoolRunner2,
+  JsonRpcMempoolViewer as JsonRpcMempoolViewer2,
+  JsonRpcXyoRunner as JsonRpcXyoRunner2,
+  JsonRpcXyoViewer as JsonRpcXyoViewer2,
+  ProviderFactoryLocator as ProviderFactoryLocator7,
+  SimpleXyoConnectionRunner as SimpleXyoConnectionRunner3,
+  SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2,
+  SimpleXyoRunner as SimpleXyoRunner3,
+  SimpleXyoSigner as SimpleXyoSigner3
+} from "@xyo-network/xl1-sdk";
 async function rewardRedemptionLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator7({
-    ...context,
-    locator: parent
-  });
+  const locator = new ProviderFactoryLocator7({ ...context, locator: parent });
   const { config } = context;
   const account = await initActorWallet(context);
   if (config.remote.rpc) {
     locator.registerMany([
       JsonRpcMempoolViewer2.factory(JsonRpcMempoolViewer2.dependencies, {}),
       JsonRpcMempoolRunner2.factory(JsonRpcMempoolRunner2.dependencies, {}),
-      JsonRpcAccountBalanceViewer4.factory(JsonRpcAccountBalanceViewer4.dependencies, {}),
-      JsonRpcFinalizationViewer2.factory(JsonRpcFinalizationViewer2.dependencies, {}),
+      JsonRpcAccountBalanceViewer4.factory(
+        JsonRpcAccountBalanceViewer4.dependencies,
+        {}
+      ),
+      JsonRpcFinalizationViewer2.factory(
+        JsonRpcFinalizationViewer2.dependencies,
+        {}
+      ),
       JsonRpcBlockViewer2.factory(JsonRpcBlockViewer2.dependencies, {}),
       JsonRpcXyoRunner2.factory(JsonRpcXyoRunner2.dependencies, {}),
       JsonRpcXyoViewer2.factory(JsonRpcXyoViewer2.dependencies, {})
     ]);
   }
   locator.registerMany([
-    SimpleXyoSigner3.factory(SimpleXyoSigner3.dependencies, {
-      account
-    }),
+    SimpleXyoSigner3.factory(SimpleXyoSigner3.dependencies, { account }),
     SimpleXyoRunner3.factory(SimpleXyoRunner3.dependencies, {}),
     SimpleXyoConnectionRunner3.factory(SimpleXyoConnectionRunner3.dependencies, {}),
     SimpleXyoGatewayRunner2.factory(SimpleXyoGatewayRunner2.dependencies, {})
@@ -2680,30 +2679,47 @@ async function rewardRedemptionLocatorFromConfig(context, parent) {
   locator.freeze();
   return locator;
 }
-__name(rewardRedemptionLocatorFromConfig, "rewardRedemptionLocatorFromConfig");
 
 // src/node/config/locators/rootLocatorFromConfig.ts
 import { commonLocatorFromConfig, remoteLocatorFromConfig } from "@xyo-network/xl1-sdk";
 async function rootLocatorFromConfig(context, validateDepsOnRegister = false, onInsecureGenesisConfirm) {
   const { config } = context;
   let locator = await commonLocatorFromConfig(context, validateDepsOnRegister);
-  const newLocator = await (config.remote.rpc ? remoteLocatorFromConfig(locator.context, validateDepsOnRegister) : localLocatorFromConfig({
-    ...locator.context,
-    config: {
-      ...locator.context.config,
-      ...context.config
-    }
-  }, validateDepsOnRegister, onInsecureGenesisConfirm));
+  const newLocator = await (config.remote.rpc ? remoteLocatorFromConfig(locator.context, validateDepsOnRegister) : localLocatorFromConfig(
+    { ...locator.context, config: { ...locator.context.config, ...context.config } },
+    validateDepsOnRegister,
+    onInsecureGenesisConfirm
+  ));
   locator = newLocator;
   locator = await initEvmProvidersIfAvailable(locator);
   locator.freeze();
   return locator;
 }
-__name(rootLocatorFromConfig, "rootLocatorFromConfig");
 
 // src/node/config/locators/sharedLocatorFromConfig.ts
 import { deepMerge as deepMerge2 } from "@xylabs/sdk-js";
-import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker4, BlockValidationViewerMoniker as BlockValidationViewerMoniker3, BlockViewerMoniker as BlockViewerMoniker4, commonLocatorFromConfig as commonLocatorFromConfig2, DeadLetterQueueRunnerMoniker as DeadLetterQueueRunnerMoniker3, FinalizationRunnerMoniker as FinalizationRunnerMoniker3, FinalizationViewerMoniker as FinalizationViewerMoniker4, MempoolRunnerMoniker as MempoolRunnerMoniker3, MempoolViewerMoniker as MempoolViewerMoniker4, ProviderFactoryLocator as ProviderFactoryLocator8, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner4, SimpleXyoGateway as SimpleXyoGateway2, SimpleXyoRunner as SimpleXyoRunner4, TransactionValidationViewerMoniker as TransactionValidationViewerMoniker3, TransactionViewerMoniker as TransactionViewerMoniker4, WindowedBlockViewerMoniker as WindowedBlockViewerMoniker3, XyoConnectionMoniker as XyoConnectionMoniker4, XyoGatewayMoniker, XyoRunnerMoniker, XyoViewerMoniker as XyoViewerMoniker4 } from "@xyo-network/xl1-sdk";
+import {
+  AccountBalanceViewerMoniker as AccountBalanceViewerMoniker4,
+  BlockValidationViewerMoniker as BlockValidationViewerMoniker3,
+  BlockViewerMoniker as BlockViewerMoniker4,
+  commonLocatorFromConfig as commonLocatorFromConfig2,
+  DeadLetterQueueRunnerMoniker as DeadLetterQueueRunnerMoniker3,
+  FinalizationRunnerMoniker as FinalizationRunnerMoniker3,
+  FinalizationViewerMoniker as FinalizationViewerMoniker4,
+  MempoolRunnerMoniker as MempoolRunnerMoniker3,
+  MempoolViewerMoniker as MempoolViewerMoniker4,
+  ProviderFactoryLocator as ProviderFactoryLocator8,
+  SimpleXyoConnectionRunner as SimpleXyoConnectionRunner4,
+  SimpleXyoGateway as SimpleXyoGateway2,
+  SimpleXyoRunner as SimpleXyoRunner4,
+  TransactionValidationViewerMoniker as TransactionValidationViewerMoniker3,
+  TransactionViewerMoniker as TransactionViewerMoniker4,
+  WindowedBlockViewerMoniker as WindowedBlockViewerMoniker3,
+  XyoConnectionMoniker as XyoConnectionMoniker4,
+  XyoGatewayMoniker,
+  XyoRunnerMoniker,
+  XyoViewerMoniker as XyoViewerMoniker4
+} from "@xyo-network/xl1-sdk";
 var apiNeeds = {
   required: [
     AccountBalanceViewerMoniker4,
@@ -2735,9 +2751,7 @@ var finalizerNeeds = {
     FinalizationRunnerMoniker3,
     MempoolViewerMoniker4
   ],
-  optional: [
-    DeadLetterQueueRunnerMoniker3
-  ]
+  optional: [DeadLetterQueueRunnerMoniker3]
 };
 var ACTOR_MIRRORS = {
   api: apiNeeds,
@@ -2747,54 +2761,42 @@ var ACTOR_MIRRORS = {
 var apiExtraDescriptors = [
   {
     id: "SimpleXyoRunner",
-    satisfies: [
-      XyoRunnerMoniker
-    ],
+    satisfies: [XyoRunnerMoniker],
     tier: 1,
     backings: [],
     surface: "node",
-    preconditions: /* @__PURE__ */ __name(() => true, "preconditions"),
-    build: /* @__PURE__ */ __name(() => SimpleXyoRunner4.factory(SimpleXyoRunner4.dependencies, {}), "build")
+    preconditions: () => true,
+    build: () => SimpleXyoRunner4.factory(SimpleXyoRunner4.dependencies, {})
   },
   {
     id: "SimpleXyoConnectionRunner",
-    satisfies: [
-      XyoConnectionMoniker4
-    ],
+    satisfies: [XyoConnectionMoniker4],
     // Same tier as `SimpleXyoConnectionViewer`; higher priority wins the
     // `XyoConnection` moniker in any actor mix that includes the API.
     tier: 1,
     priority: 100,
     backings: [],
     surface: "node",
-    preconditions: /* @__PURE__ */ __name(() => true, "preconditions"),
-    build: /* @__PURE__ */ __name(() => SimpleXyoConnectionRunner4.factory(SimpleXyoConnectionRunner4.dependencies, {}), "build")
+    preconditions: () => true,
+    build: () => SimpleXyoConnectionRunner4.factory(SimpleXyoConnectionRunner4.dependencies, {})
   },
   {
     id: "SimpleXyoGateway",
-    satisfies: [
-      XyoGatewayMoniker
-    ],
+    satisfies: [XyoGatewayMoniker],
     tier: 1,
     backings: [],
     surface: "node",
-    preconditions: /* @__PURE__ */ __name(() => true, "preconditions"),
-    build: /* @__PURE__ */ __name(() => SimpleXyoGateway2.factory(SimpleXyoGateway2.dependencies, {}), "build")
+    preconditions: () => true,
+    build: () => SimpleXyoGateway2.factory(SimpleXyoGateway2.dependencies, {})
   }
 ];
-var ACTOR_EXTRA_DESCRIPTORS = {
-  api: apiExtraDescriptors
-};
+var ACTOR_EXTRA_DESCRIPTORS = { api: apiExtraDescriptors };
 var ACTOR_CONFIG_PARSERS = {
   api: ApiConfigZod,
   mempool: MempoolConfigZod,
   finalizer: FinalizerConfigZod
 };
-var SHARED_LOCATOR_SUPPORTED_ACTORS = [
-  "api",
-  "mempool",
-  "finalizer"
-];
+var SHARED_LOCATOR_SUPPORTED_ACTORS = ["api", "mempool", "finalizer"];
 function canUseSharedLocator(actors, config) {
   if (actors.length === 0) return false;
   if (config.remote?.rpc) return false;
@@ -2810,31 +2812,19 @@ function canUseSharedLocator(actors, config) {
     return true;
   });
 }
-__name(canUseSharedLocator, "canUseSharedLocator");
 async function sharedLocatorFromConfig(context, actors, config, options = {}) {
   const unionNeeds2 = {
     required: dedupe(actors.flatMap((a) => ACTOR_MIRRORS[a.name]?.required ?? [])),
     optional: dedupe(actors.flatMap((a) => ACTOR_MIRRORS[a.name]?.optional ?? []))
   };
   const extraDescriptors = actors.flatMap((a) => ACTOR_EXTRA_DESCRIPTORS[a.name] ?? []);
-  const commonContext = {
-    ...context,
-    config: {
-      ...config,
-      name: "_shared_common"
-    }
-  };
+  const commonContext = { ...context, config: { ...config, name: "_shared_common" } };
   const commonLocator = await commonLocatorFromConfig2(commonContext);
   const sharedContext = {
     ...commonLocator.context,
-    config: {
-      ...config,
-      name: "_shared"
-    }
+    config: { ...config, name: "_shared" }
   };
-  const result = await locatorFromActorNeeds(sharedContext, [
-    unionNeeds2
-  ], {
+  const result = await locatorFromActorNeeds(sharedContext, [unionNeeds2], {
     extraDescriptors,
     onInsecureGenesisConfirm: options.onInsecureGenesisConfirm,
     validateDepsOnRegister: false
@@ -2853,18 +2843,11 @@ async function sharedLocatorFromConfig(context, actors, config, options = {}) {
     view.freeze();
     perActor[actor.name] = view;
   }
-  return {
-    shared: sharedWithEvm,
-    perActor
-  };
+  return { shared: sharedWithEvm, perActor };
 }
-__name(sharedLocatorFromConfig, "sharedLocatorFromConfig");
 function dedupe(items) {
-  return [
-    ...new Set(items)
-  ];
+  return [...new Set(items)];
 }
-__name(dedupe, "dedupe");
 
 // src/node/config/locators/locatorsFromConfig.ts
 function allActorsAreSelfSufficient(actors, config) {
@@ -2875,104 +2858,98 @@ function allActorsAreSelfSufficient(actors, config) {
     return merged.stateless === true;
   });
 }
-__name(allActorsAreSelfSufficient, "allActorsAreSelfSufficient");
 async function locatorsFromConfig(context, { actors, ...config }, onInsecureGenesisConfirm) {
   const result = {};
   if (canUseSharedLocator(actors, config)) {
-    const { perActor } = await sharedLocatorFromConfig(context, actors, config, {
-      onInsecureGenesisConfirm
-    });
+    const { perActor } = await sharedLocatorFromConfig(context, actors, config, { onInsecureGenesisConfirm });
     return perActor;
   }
   const skipRoot = allActorsAreSelfSufficient(actors, config);
   if (!skipRoot) {
-    const rootContext = {
-      ...context,
-      config: {
-        ...config,
-        name: "_root"
-      }
-    };
+    const rootContext = { ...context, config: { ...config, name: "_root" } };
     result._root = await rootLocatorFromConfig(rootContext, false, onInsecureGenesisConfirm);
   }
   for (const actorConfig of actors) {
     switch (actorConfig.name) {
       case "producer": {
-        result[actorConfig.name] = await producerLocatorFromConfig({
-          ...context,
-          config: ProducerConfigZod.parse(deepMerge3(config, actorConfig))
-        }, result._root);
+        result[actorConfig.name] = await producerLocatorFromConfig(
+          { ...context, config: ProducerConfigZod.parse(deepMerge3(config, actorConfig)) },
+          result._root
+        );
         break;
       }
       case "api": {
-        result[actorConfig.name] = await apiLocatorFromConfig({
-          ...context,
-          config: ApiConfigZod.parse(deepMerge3(config, actorConfig))
-        }, result._root);
+        result[actorConfig.name] = await apiLocatorFromConfig(
+          { ...context, config: ApiConfigZod.parse(deepMerge3(config, actorConfig)) },
+          result._root
+        );
         break;
       }
       case "mempool": {
-        result[actorConfig.name] = await mempoolLocatorFromConfig({
-          ...context,
-          config: MempoolConfigZod.parse(deepMerge3(config, actorConfig))
-        }, result._root);
+        result[actorConfig.name] = await mempoolLocatorFromConfig(
+          { ...context, config: MempoolConfigZod.parse(deepMerge3(config, actorConfig)) },
+          result._root
+        );
         break;
       }
       case "finalizer": {
-        result[actorConfig.name] = await finalizerLocatorFromConfig({
-          ...context,
-          config: FinalizerConfigZod.parse(deepMerge3(config, actorConfig))
-        }, result._root);
+        result[actorConfig.name] = await finalizerLocatorFromConfig(
+          { ...context, config: FinalizerConfigZod.parse(deepMerge3(config, actorConfig)) },
+          result._root
+        );
         break;
       }
       case "bridge": {
-        result[actorConfig.name] = await bridgeLocatorFromConfig({
-          ...context,
-          config: BridgeConfigZod.parse(deepMerge3(config, actorConfig))
-        }, result._root);
+        result[actorConfig.name] = await bridgeLocatorFromConfig(
+          { ...context, config: BridgeConfigZod.parse(deepMerge3(config, actorConfig)) },
+          result._root
+        );
         break;
       }
       case "rewardRedemption": {
-        result[actorConfig.name] = await rewardRedemptionLocatorFromConfig({
-          ...context,
-          config: RewardRedemptionConfigZod.parse(deepMerge3(config, actorConfig))
-        }, result._root);
+        result[actorConfig.name] = await rewardRedemptionLocatorFromConfig(
+          {
+            ...context,
+            config: RewardRedemptionConfigZod.parse(deepMerge3(config, actorConfig))
+          },
+          result._root
+        );
         break;
       }
     }
   }
   return result;
 }
-__name(locatorsFromConfig, "locatorsFromConfig");
 
 // src/node/config/tryParseConfig.ts
 import { isDefined as isDefined4, isNull } from "@xylabs/sdk-js";
 import { ConfigZod } from "@xyo-network/xl1-sdk";
 import { cosmiconfig } from "cosmiconfig";
+import { z as z8 } from "zod/mini";
 var configName = "xyo";
 var configSection = "xl1";
 var ConfigFileNotFoundError = class extends Error {
-  static {
-    __name(this, "ConfigFileNotFoundError");
-  }
   constructor(configPath) {
     super(`Config file not found: ${configPath}`);
     this.name = "ConfigFileNotFoundError";
   }
 };
-var isMissingFileError = /* @__PURE__ */ __name((error) => {
+var isMissingFileError = (error) => {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
-}, "isMissingFileError");
-var isRecord = /* @__PURE__ */ __name((value) => {
+};
+var isRecord = (value) => {
   return typeof value === "object" && value !== null;
-}, "isRecord");
+};
 async function tryParseConfig(options) {
   const { configPath, searchPlaces } = options ?? {};
-  const explorer = cosmiconfig(configName, {
-    cache: true,
-    // loaders: { '.ts': TypeScriptLoader() },
-    searchPlaces
-  });
+  const explorer = cosmiconfig(
+    configName,
+    {
+      cache: true,
+      // loaders: { '.ts': TypeScriptLoader() },
+      searchPlaces
+    }
+  );
   let result;
   if (isDefined4(configPath)) {
     try {
@@ -2992,16 +2969,12 @@ async function tryParseConfig(options) {
   if (isRecord(result)) {
     const section = result[configSection];
     if (isRecord(section)) {
-      const parsed = ConfigZod.loose().parse(section);
-      return typeof section.mnemonic === "string" ? {
-        ...parsed,
-        mnemonic: section.mnemonic
-      } : parsed;
+      const parsed = z8.looseObject(ConfigZod.shape).parse(section);
+      return typeof section.mnemonic === "string" ? { ...parsed, mnemonic: section.mnemonic } : parsed;
     }
   }
   return ConfigZod.parse({});
 }
-__name(tryParseConfig, "tryParseConfig");
 
 // src/node/index.ts
 export * from "@xyo-network/chain-orchestration-evm";
@@ -3143,4 +3116,4 @@ export {
   tryParseConfig,
   unmetBackings
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map