@xyo-network/chain-orchestration 1.23.0 → 2.0.0

package/dist/neutral/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,27 +1157,24 @@ var SimpleRejectedTransactionsArchivistProvider = class _SimpleRejectedTransacti
     };
   }
 };
-SimpleRejectedTransactionsArchivistProvider = _ts_decorate2([
+__publicField(SimpleRejectedTransactionsArchivistProvider, "defaultMoniker", RejectedTransactionsArchivistProviderMoniker);
+__publicField(SimpleRejectedTransactionsArchivistProvider, "dependencies", []);
+__publicField(SimpleRejectedTransactionsArchivistProvider, "monikers", [RejectedTransactionsArchivistProviderMoniker]);
+SimpleRejectedTransactionsArchivistProvider = __decorateClass([
   creatableProvider()
 ], SimpleRejectedTransactionsArchivistProvider);
 
 // src/neutral/config/locators/basicRemoteRunnerLocator.ts
 import { basicRemoteRunnerLocator as sdkBasicRemoteRunnerLocator } from "@xyo-network/xl1-sdk";
 function basicRemoteRunnerLocator(name, remoteConfig, signerTransport, dataLakeEndpoint, validators) {
-  return sdkBasicRemoteRunnerLocator(name, remoteConfig, signerTransport, dataLakeEndpoint, {
-    validators
-  });
+  return sdkBasicRemoteRunnerLocator(name, remoteConfig, signerTransport, dataLakeEndpoint, { validators });
 }
-__name(basicRemoteRunnerLocator, "basicRemoteRunnerLocator");
 
 // src/neutral/config/locators/basicRemoteViewerLocator.ts
 import { basicRemoteViewerLocator as sdkBasicRemoteViewerLocator } from "@xyo-network/xl1-sdk";
 function basicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, validators) {
-  return sdkBasicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, {
-    validators
-  });
+  return sdkBasicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, { validators });
 }
-__name(basicRemoteViewerLocator, "basicRemoteViewerLocator");
 
 // src/neutral/config/locators/rootLocatorFromConfig.ts
 import { assertEx as assertEx5 } from "@xylabs/sdk-js";
@@ -1250,11 +1182,13 @@ import { commonLocatorFromConfig, remoteLocatorFromConfig } from "@xyo-network/x
 async function rootLocatorFromConfig(context, validateDepsOnRegister = false) {
   const { config } = context;
   await commonLocatorFromConfig(context, validateDepsOnRegister);
-  const locator = assertEx5(await (config.remote.rpc ? remoteLocatorFromConfig(context, validateDepsOnRegister) : void 0), () => "Root locator could not be created from config. No supported configuration found.");
+  const locator = assertEx5(
+    await (config.remote.rpc ? remoteLocatorFromConfig(context, validateDepsOnRegister) : void 0),
+    () => "Root locator could not be created from config. No supported configuration found."
+  );
   locator.freeze();
   return locator;
 }
-__name(rootLocatorFromConfig, "rootLocatorFromConfig");
 export {
   Actor,
   ActorMnemonicNotAllowedError,
@@ -1358,4 +1292,4 @@ export {
   toRewardRedemptionConfig,
   toRewardRedemptionConfigContext
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map