@xyo-network/chain-orchestration 1.23.0 → 1.23.2

package/dist/neutral/index.mjs

@@ -1,29 +1,40 @@
 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")
-};
+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(),
@@ -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,70 +241,61 @@ 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, {
+  initRewardsCache: z2.union([z2.number(), z2.string(), z2.boolean()]).transform(
+    (v) => v !== "0" && v !== "false" && v !== false && v != 0
+  ).default(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.union([z2.number(), z2.string(), z2.boolean()]).transform(
+    (v) => v === "1" || v === "true" || v === true || v == 1
+  ).default(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.union([z2.number(), z2.string(), z2.boolean()]).transform(
+    (v) => v !== "0" && v !== "false" && v !== false && v != 0
+  ).default(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"
@@ -318,16 +304,27 @@ var ApiConfigZod = HostActorConfigZod.extend(z2.object({
 var isApiConfig = zodIsFactory(ApiConfigZod);
 var asApiConfig = zodAsFactory(ApiConfigZod, "asApiConfig");
 var toApiConfig = zodToFactory(ApiConfigZod, "toApiConfig");
-var ApiConfigContext = BaseConfigContextZod.extend({
-  config: ApiConfigZod
-});
+var ApiConfigContext = BaseConfigContextZod.extend({ 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 {
+  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";
 var DEFAULT_FIXED_FEE = toHex(XL1(1000n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_VARIABLE_FEE_BASIS_POINTS = 300;
@@ -449,16 +446,23 @@ var BridgeSettingsZod = BridgeConfigZod.pick({
 var isBridgeConfig = zodIsFactory2(BridgeConfigZod);
 var asBridgeConfig = zodAsFactory2(BridgeConfigZod, "asBridgeConfig");
 var toBridgeConfig = zodToFactory2(BridgeConfigZod, "toBridgeConfig");
-var BridgeConfigContext = BaseConfigContextZod2.extend({
-  config: BridgeConfigZod
-});
+var BridgeConfigContext = BaseConfigContextZod2.extend({ 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 {
+  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(),
@@ -471,15 +475,17 @@ var FinalizerConfigZod = HostActorConfigZod3.extend({
 var isFinalizerConfig = zodIsFactory3(FinalizerConfigZod);
 var asFinalizerConfig = zodAsFactory3(FinalizerConfigZod, "asFinalizerConfig");
 var toFinalizerConfig = zodToFactory3(FinalizerConfigZod, "toFinalizerConfig");
-var FinalizerConfigContext = BaseConfigContextZod3.extend({
-  config: FinalizerConfigZod
-});
+var FinalizerConfigContext = BaseConfigContextZod3.extend({ 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";
 var DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL = 1e3;
@@ -487,24 +493,11 @@ 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) => {
+  enabled: z5.union([z5.string(), z5.boolean()]).default("false").transform((val, ctx) => {
     if (typeof val === "boolean") return val;
     const normalized = val.toLowerCase().trim();
-    if ([
-      "true",
-      "1",
-      "yes",
-      "on"
-    ].includes(normalized)) return true;
-    if ([
-      "false",
-      "0",
-      "no",
-      "off"
-    ].includes(normalized)) return false;
+    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",
@@ -541,15 +534,18 @@ 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 = BaseConfigContextZod4.extend({ 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";
 var DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL = 1e4;
@@ -590,23 +586,23 @@ var ProducerConfigZod = ActorConfigZod.extend(z6.object({
 var isProducerConfig = zodIsFactory5(ProducerConfigZod);
 var asProducerConfig = zodAsFactory5(ProducerConfigZod, "asProducerConfig");
 var toProducerConfig = zodToFactory5(ProducerConfigZod, "toProducerConfig");
-var ProducerConfigContext = BaseConfigContextZod5.extend({
-  config: ProducerConfigZod
-});
+var ProducerConfigContext = BaseConfigContextZod5.extend({ 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({});
 var isRewardRedemptionConfig = zodIsFactory6(RewardRedemptionConfigZod);
 var asRewardRedemptionConfig = zodAsFactory6(RewardRedemptionConfigZod, "asRewardRedemptionConfig");
 var toRewardRedemptionConfig = zodToFactory6(RewardRedemptionConfigZod, "toRewardRedemptionConfig");
-var RewardRedemptionConfigContext = BaseConfigContextZod6.extend({
-  config: RewardRedemptionConfigZod
-});
+var RewardRedemptionConfigContext = BaseConfigContextZod6.extend({ config: RewardRedemptionConfigZod });
 var isRewardRedemptionConfigContext = zodIsFactory6(RewardRedemptionConfigContext);
 var asRewardRedemptionConfigContext = zodAsFactory6(RewardRedemptionConfigContext, "asRewardRedemptionConfigContext");
 var toRewardRedemptionConfigContext = zodToFactory6(RewardRedemptionConfigContext, "toRewardRedemptionConfigContext");
@@ -621,26 +617,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 +654,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 +703,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 +726,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 +744,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 +763,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 +771,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 +786,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 +802,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 +818,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 +879,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 +889,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 +913,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 +931,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 +955,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 +977,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 +1010,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 +1030,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 +1045,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 +1057,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 +1071,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 +1087,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 +1104,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 +1138,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 +1163,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 +1273,4 @@ export {
   toRewardRedemptionConfig,
   toRewardRedemptionConfigContext
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map