@xyo-network/chain-orchestration 1.20.28 → 1.20.29

package/dist/node/index.mjs

@@ -4,7 +4,201 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/shared/actor/FinalizerActor.ts
 import { creatable } from "@xylabs/sdk-js";
 import { processPendingBlocks } from "@xyo-network/chain-sdk";
-import { ActorV3, BlockValidationViewerMoniker, BlockViewerMoniker, DeadLetterQueueRunnerMoniker, FinalizationRunnerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-sdk";
+import { BlockValidationViewerMoniker, BlockViewerMoniker, DeadLetterQueueRunnerMoniker, FinalizationRunnerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-sdk";
+
+// src/shared/actor/v3/ActorV3.ts
+import { AbstractCreatable, assertEx, delay, IdLogger } from "@xylabs/sdk-js";
+import { Semaphore } from "async-mutex";
+import z from "zod";
+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 ActorParamsV3Zod = z.object({
+  account: AccountInstanceZod,
+  locator: z.unknown(),
+  name: CreatableNameZod,
+  statusReporter: StatusReporterInstanceZod.optional()
+});
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    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();
+  _logger;
+  _readyDeferred = createDeferred();
+  _readyError;
+  _readyState = "pending";
+  get logger() {
+    this._logger = new IdLogger(assertEx(this.context.logger, () => `Logger is required in context for actor ${this.name}.`), () => this.name);
+    return this._logger;
+  }
+  get readyError() {
+    return this._readyError;
+  }
+  get readyState() {
+    return this._readyState;
+  }
+  get account() {
+    return this.params.account;
+  }
+  get context() {
+    return this.locator.context;
+  }
+  get locator() {
+    return this.params.locator;
+  }
+  static async paramsHandler(params) {
+    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 {
+      ...baseParams,
+      account,
+      locator
+    };
+  }
+  /**
+  * 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.`);
+      return;
+    }
+    let running = false;
+    this._semaphores.set(timerName, new Semaphore(1));
+    const timeoutId = setTimeout(() => {
+      const intervalId = setInterval(() => {
+        const semaphore = this._semaphores.get(timerName);
+        if (this.status !== "started" || !this._intervals.has(timerName) || !semaphore || running) return;
+        if (semaphore.isLocked()) {
+          this.logger?.warn(`Skipping timer '${this.name}:${timerName}' execution because previous execution is still running.`);
+          return;
+        }
+        semaphore.acquire().then(([, release]) => {
+          const startTime = Date.now();
+          running = true;
+          callback().then(() => {
+            const duration = Date.now() - startTime;
+            if (duration > periodMs) {
+              this.logger?.warn(`Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than the period (${periodMs}ms).`);
+            } else if (duration > 5e3) {
+              this.logger?.warn(`Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than 5000ms.`);
+            }
+          }).catch((error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger?.error(`Error in timer '${this.name}:${timerName}': ${err.message}`);
+            if (err.stack) this.logger?.error(err.stack);
+          }).finally(() => {
+            release();
+            running = false;
+          });
+        }).catch((error) => {
+          const err = error instanceof Error ? error : new Error(String(error));
+          this.logger?.error(`Error acquiring semaphore for timer '${this.name}:${timerName}': ${err.message}`);
+        });
+      }, periodMs);
+      this._intervals.set(timerName, intervalId);
+    }, dueTimeMs);
+    this._timeouts.set(timerName, timeoutId);
+    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.
+  */
+  async runReadyHandler() {
+    if (this._readyState !== "pending") return;
+    try {
+      await this.readyHandler();
+      this._readyState = "ready";
+      this._readyDeferred.resolve();
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this._readyState = "failed";
+      this._readyError = error;
+      this._readyDeferred.reject(error);
+      throw error;
+    }
+  }
+  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();
+    }));
+    this._semaphores.clear();
+    for (const [, timeoutRef] of this._timeouts.entries()) {
+      clearTimeout(timeoutRef);
+    }
+    this._timeouts.clear();
+    for (const [, intervalRef] of this._intervals.entries()) {
+      clearInterval(intervalRef);
+    }
+    this._intervals.clear();
+    this.logger?.debug("Stopped.");
+  }
+  async whenReady(timeoutMs) {
+    if (timeoutMs === void 0) {
+      await this._readyDeferred.promise;
+      return;
+    }
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error(`Actor ${this.name} did not become ready within ${timeoutMs}ms`));
+      }, timeoutMs);
+    });
+    try {
+      await Promise.race([
+        this._readyDeferred.promise,
+        timeout
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  /**
+  * 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() {
+  }
+};
+var Actor = class extends ActorV3 {
+  static {
+    __name(this, "Actor");
+  }
+};
+
+// src/shared/actor/FinalizerActor.ts
 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);
@@ -16,6 +210,17 @@ var FinalizerActor = class extends ActorV3 {
   static {
     __name(this, "FinalizerActor");
   }
+  static needs = {
+    required: [
+      BlockValidationViewerMoniker,
+      BlockViewerMoniker,
+      FinalizationRunnerMoniker,
+      MempoolViewerMoniker
+    ],
+    optional: [
+      DeadLetterQueueRunnerMoniker
+    ]
+  };
   _blockValidationViewer;
   _blockViewer;
   _deadLetterQueueRunner;
@@ -49,25 +254,32 @@ var FinalizerActor = class extends ActorV3 {
   }
   async startHandler() {
     await super.startHandler();
+    const interval = this.params.config.finalizationCheckInterval ?? 500;
     this.registerTimer("FinalizerActor", async () => {
-      await this.spanAsync("processPendingBlocks", async () => {
-        this.logger?.debug("FinalizerActor: Processing pending blocks...");
-        await processPendingBlocks({
-          blockValidationViewer: this.blockValidationViewer,
-          context: this.context,
-          logger: this.logger,
-          mempoolViewer: this.mempoolViewer,
-          blockViewer: this.blockViewer,
-          finalizationRunner: this.finalizationRunner,
-          allowedProducers: this.allowedProducers,
-          minCandidates: this.minCandidates,
-          deadLetterQueueRunner: this._deadLetterQueueRunner
-        });
-      }, {
-        ...this.context,
-        timeBudgetLimit: 1500
+      await this.runFinalizationPass();
+    }, 2e3, interval);
+  }
+  async readyHandler() {
+    await this.runFinalizationPass();
+  }
+  async runFinalizationPass() {
+    await this.spanAsync("processPendingBlocks", async () => {
+      this.logger?.debug("FinalizerActor: Processing pending blocks...");
+      await processPendingBlocks({
+        blockValidationViewer: this.blockValidationViewer,
+        context: this.context,
+        logger: this.logger,
+        mempoolViewer: this.mempoolViewer,
+        blockViewer: this.blockViewer,
+        finalizationRunner: this.finalizationRunner,
+        allowedProducers: this.allowedProducers,
+        minCandidates: this.minCandidates,
+        deadLetterQueueRunner: this._deadLetterQueueRunner
       });
-    }, 2e3, 500);
+    }, {
+      ...this.context,
+      timeBudgetLimit: 1500
+    });
   }
 };
 FinalizerActor = _ts_decorate([
@@ -96,12 +308,12 @@ __name(buildTelemetryConfig, "buildTelemetryConfig");
 // src/shared/config/actors/Api.ts
 import { zodAsFactory, zodIsFactory, zodToFactory } from "@xylabs/sdk-js";
 import { BaseConfigContextZod, HostActorConfigZod } from "@xyo-network/xl1-sdk";
-import { globalRegistry, z } from "zod";
-var ApiConfigZod = HostActorConfigZod.extend(z.object({
-  initRewardsCache: z.union([
-    z.number(),
-    z.string(),
-    z.boolean()
+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, {
     description: "Whether to initialize the rewards cache on startup",
     title: "api.initRewardsCache",
@@ -121,7 +333,7 @@ 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 z2 } from "zod";
+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;
 var DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress("2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6");
@@ -130,7 +342,7 @@ var DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY = toHex("0xac0974bec39a17e36
 var DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress("5FbDB2315678afecb367f032d93F642f64180aa3");
 var DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(1000000n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(1500n) * AttoXL1ConvertFactor.xl1);
-var BasisPointsZod = z2.coerce.number().int().nonnegative().max(1e4);
+var BasisPointsZod = z3.coerce.number().int().nonnegative().max(1e4);
 var BridgeConfigZod = HostActorConfigZod2.extend({
   escrowAddress: AddressZod.optional().register(globalRegistry2, {
     description: "Address to which bridge escrow will be sent",
@@ -166,13 +378,13 @@ var BridgeConfigZod = HostActorConfigZod2.extend({
     title: "bridge.minBridgeAmount",
     type: "string"
   }),
-  redisHost: z2.string().default("localhost").register(globalRegistry2, {
+  redisHost: z3.string().default("localhost").register(globalRegistry2, {
     default: "localhost",
     description: "Host for the Bridge Redis instance",
     title: "bridge.redisHost",
     type: "string"
   }),
-  redisPort: z2.coerce.number().int().positive().default(6379).register(globalRegistry2, {
+  redisPort: z3.coerce.number().int().positive().default(6379).register(globalRegistry2, {
     default: 6379,
     description: "Port for the Bridge Redis instance",
     title: "bridge.redisPort",
@@ -237,10 +449,14 @@ var toBridgeConfigContext = zodToFactory2(BridgeConfigContext, "toBridgeConfigCo
 // 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 z3 } from "zod";
+import { z as z4 } from "zod";
 var FinalizerConfigZod = HostActorConfigZod3.extend({
-  allowedProducers: z3.array(AddressZod2).optional(),
-  minCandidates: z3.number().int().min(0).default(DEFAULT_MIN_CANDIDATES)
+  allowedProducers: z4.array(AddressZod2).optional(),
+  // 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)
 });
 var isFinalizerConfig = zodIsFactory3(FinalizerConfigZod);
 var asFinalizerConfig = zodAsFactory3(FinalizerConfigZod, "asFinalizerConfig");
@@ -255,13 +471,13 @@ var toFinalizerConfigContext = zodToFactory3(FinalizerConfigContext, "toFinalize
 // src/shared/config/actors/Mempool.ts
 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 z4 } from "zod";
+import { globalRegistry as globalRegistry3, z as z5 } from "zod";
 var DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL = 1e3;
 var DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL = 1e3;
 var MempoolConfigZod = HostActorConfigZod4.extend({
-  enabled: z4.union([
-    z4.string(),
-    z4.boolean()
+  enabled: z5.union([
+    z5.string(),
+    z5.boolean()
   ]).default("false").transform((val, ctx) => {
     if (typeof val === "boolean") return val;
     const normalized = val.toLowerCase().trim();
@@ -282,19 +498,19 @@ var MempoolConfigZod = HostActorConfigZod4.extend({
       expected: "boolean",
       message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
     });
-    return z4.NEVER;
+    return z5.NEVER;
   }).register(globalRegistry3, {
     default: "false",
     description: "Enable the Mempool",
     title: "mempool.enabled",
     type: "boolean"
   }),
-  blockPruneInterval: z4.coerce.number().default(DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL).register(globalRegistry3, {
+  blockPruneInterval: z5.coerce.number().default(DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL).register(globalRegistry3, {
     description: "The interval time (in milliseconds) between pending block prune attempts",
     title: "mempool.blockPruneInterval",
     type: "number"
   }),
-  transactionPruneInterval: z4.coerce.number().default(DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL).register(globalRegistry3, {
+  transactionPruneInterval: z5.coerce.number().default(DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL).register(globalRegistry3, {
     description: "The interval time (in milliseconds) between pending transaction prune attempts",
     title: "mempool.transactionPruneInterval",
     type: "number"
@@ -311,44 +527,39 @@ var asMempoolConfigContext = zodAsFactory4(MempoolConfigContext, "asMempoolConfi
 var toMempoolConfigContext = zodToFactory4(MempoolConfigContext, "toMempoolConfigContext");
 
 // src/shared/config/actors/Producer.ts
-import { AddressZod as AddressZod3, asAddress, 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 z5 } from "zod";
+import { globalRegistry as globalRegistry4, z as z6 } from "zod";
 var DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL = 1e4;
-var ProducerConfigZod = ActorConfigZod.extend(z5.object({
-  allowlist: z5.preprocess((val) => {
-    if (typeof val === "string") {
-      return val.split(",").map((s) => asAddress(s.trim()));
-    }
-    return val;
-  }, z5.array(AddressZod3).optional().register(globalRegistry4, {
+var ProducerConfigZod = ActorConfigZod.extend(z6.object({
+  allowlist: z6.array(AddressZod3).optional().register(globalRegistry4, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
-  })),
-  blockProductionCheckInterval: z5.coerce.number().default(DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry4, {
+  }),
+  blockProductionCheckInterval: z6.coerce.number().default(DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry4, {
     description: "The interval time (in milliseconds) between block production attempts",
     title: "producer.blockProductionCheckInterval",
     type: "number"
   }),
-  disableIntentRedeclaration: z5.boolean().optional().register(globalRegistry4, {
+  disableIntentRedeclaration: z6.boolean().optional().register(globalRegistry4, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
     type: "boolean"
   }),
-  heartbeatInterval: z5.coerce.number().default(36e5).register(globalRegistry4, {
+  heartbeatInterval: z6.coerce.number().default(36e5).register(globalRegistry4, {
     description: "The number of milliseconds between heartbeats if no blocks are produced",
     title: "producer.heartbeatInterval",
     type: "number"
   }),
   // TODO: BigInt schema
-  minStake: z5.coerce.number().default(1).register(globalRegistry4, {
+  minStake: z6.coerce.number().default(1).register(globalRegistry4, {
     description: "Minimum stake required to be a Producer",
     title: "producer.minStake",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z5.string().optional().register(globalRegistry4, {
+  rewardAddress: z6.string().optional().register(globalRegistry4, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
@@ -765,7 +976,7 @@ async function initActorAccount({ config, logger }) {
 __name(initActorAccount, "initActorAccount");
 
 // src/shared/init/initActorSeedPhrase.ts
-import { assertEx, isString } from "@xylabs/sdk-js";
+import { assertEx as assertEx2, isString } from "@xylabs/sdk-js";
 async function initActorSeedPhrase(context, bios) {
   const { logger, config } = context;
   const walletKind = config.name;
@@ -774,12 +985,12 @@ async function initActorSeedPhrase(context, bios) {
   if (isString(report?.root.mnemonic)) return report.root.mnemonic;
   const fallback = getBuiltInDevMnemonic();
   logger?.debug(`[${walletKind}] Falling back to built-in development mnemonic`);
-  return assertEx(fallback, () => "Unable to resolve mnemonic");
+  return assertEx2(fallback, () => "Unable to resolve mnemonic");
 }
 __name(initActorSeedPhrase, "initActorSeedPhrase");
 
 // src/shared/init/initBridgedModule.ts
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
 import { asAttachableArchivistInstance, asAttachableModuleInstance } from "@xyo-network/sdk-js";
 import { Mutex } from "async-mutex";
 var initMutex = new Mutex();
@@ -788,8 +999,8 @@ async function initBridgedModule({ bridge, moduleName }) {
   return await initMutex.runExclusive(async () => {
     const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName];
     if (existing) return existing;
-    const mod = assertEx2(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
-    const moduleInstance = assertEx2(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
+    const mod = assertEx3(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
+    const moduleInstance = assertEx3(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
     let moduleMap = bridgedModuleDictionary[bridge.address];
     if (moduleMap === void 0) {
       moduleMap = {};
@@ -801,7 +1012,7 @@ async function initBridgedModule({ bridge, moduleName }) {
 }
 __name(initBridgedModule, "initBridgedModule");
 async function initBridgedArchivistModule({ bridge, moduleName }) {
-  return assertEx2(asAttachableArchivistInstance(await initBridgedModule({
+  return assertEx3(asAttachableArchivistInstance(await initBridgedModule({
     bridge,
     moduleName
   })), () => `Could not convert ${moduleName} to attachable archivist instance`);
@@ -836,7 +1047,7 @@ async function initActorWallet(context) {
 __name(initActorWallet, "initActorWallet");
 
 // src/shared/orchestrator/Orchestrator.ts
-import { AbstractCreatable, creatable as creatable2 } from "@xylabs/sdk-js";
+import { AbstractCreatable as AbstractCreatable2, creatable as creatable2 } from "@xylabs/sdk-js";
 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);
@@ -844,25 +1055,43 @@ function _ts_decorate2(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate2, "_ts_decorate");
-var Orchestrator = class extends AbstractCreatable {
+var Orchestrator = class extends AbstractCreatable2 {
   static {
     __name(this, "Orchestrator");
   }
   actors = [];
-  keepAliveHandle = null;
   running = false;
+  shuttingDown = false;
+  get readyState() {
+    if (this.actors.length === 0) return "pending";
+    if (this.actors.some((a) => isLocalActor(a) && a.readyState === "failed")) return "failed";
+    if (this.actors.every((a) => isLocalActor(a) && a.readyState === "ready")) return "ready";
+    return "pending";
+  }
+  isReady() {
+    return this.readyState === "ready" && !this.shuttingDown;
+  }
+  isShuttingDown() {
+    return this.shuttingDown;
+  }
   /**
   * Registers an actor.
   * (We won't activate the actor until `start()` is called.)
   */
   async registerActor(actor) {
+    this.actors.push(actor);
     if (this.running) {
       await actor.start();
+      if (isLocalActor(actor)) {
+        actor.runReadyHandler().catch((err) => {
+          this.logger?.error(`[Orchestrator] Actor [${actor.name}] readyHandler failed: ${formatError(err)}`);
+        });
+      }
     }
-    this.actors.push(actor);
   }
   /**
-  * Starts the orchestrator: activates all actors.
+  * 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();
@@ -870,13 +1099,26 @@ var Orchestrator = class extends AbstractCreatable {
       this.logger?.warn("[Orchestrator] Already started.");
       return;
     }
-    this.logger?.log("[Orchestrator] Starting...");
+    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
+      }
+    ] : []);
+    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`);
+    }
     for (const actor of this.actors) {
-      await actor.start();
+      if (isLocalActor(actor)) {
+        actor.runReadyHandler().catch((err) => {
+          this.logger?.error(`[Orchestrator] Actor [${actor.name}] readyHandler failed: ${formatError(err)}`);
+        });
+      }
     }
-    this.keepAliveHandle = setInterval(() => {
-    }, 2147483647);
   }
   /**
   * Stops the orchestrator: deactivates all actors.
@@ -888,20 +1130,55 @@ var Orchestrator = class extends AbstractCreatable {
       return;
     }
     this.logger?.log("[Orchestrator] Stopping...");
-    for (const actor of this.actors) {
-      await actor.stop();
-    }
+    this.shuttingDown = true;
+    await Promise.allSettled(this.actors.map((a) => a.stop()));
     this.running = false;
-    if (this.keepAliveHandle) clearInterval(this.keepAliveHandle);
-    this.logger?.log("[Orchestrator] Stopped...");
+    this.shuttingDown = false;
+    this.logger?.log("[Orchestrator] Stopped.");
+  }
+  /**
+  * 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;
+    if (timeoutMs === void 0) {
+      await Promise.all(localActors.map((a) => a.whenReady()));
+      return;
+    }
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error(`[Orchestrator] Not ready within ${timeoutMs}ms`));
+      }, timeoutMs);
+    });
+    try {
+      await Promise.race([
+        Promise.all(localActors.map((a) => a.whenReady())),
+        timeout
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
   }
 };
 Orchestrator = _ts_decorate2([
   creatable2()
 ], 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 assertEx3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
 import { AbstractCreatableProvider, creatableProvider } from "@xyo-network/xl1-sdk";
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -927,7 +1204,7 @@ var SimpleRejectedTransactionsArchivistProvider = class _SimpleRejectedTransacti
   static async paramsHandler(params) {
     return {
       ...await super.paramsHandler(params),
-      archivist: assertEx3(params?.archivist, () => "archivist is required")
+      archivist: assertEx4(params?.archivist, () => "archivist is required")
     };
   }
 };
@@ -935,91 +1212,346 @@ SimpleRejectedTransactionsArchivistProvider = _ts_decorate3([
   creatableProvider()
 ], SimpleRejectedTransactionsArchivistProvider);
 
-// src/node/config/locators/basicRemoteRunnerLocator.ts
-import { isAccountInstance } from "@xyo-network/sdk-js";
-import { basicRemoteRunnerLocator as sdkBasicRemoteRunnerLocator, JsonRpcAccountBalanceViewer, JsonRpcXyoSigner, SimpleXyoSigner } from "@xyo-network/xl1-sdk";
-function signerFactoryFromParam(signer) {
-  if (isAccountInstance(signer)) {
-    return SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, {
-      account: signer
-    });
+// src/node/config/capabilities/Capability.ts
+var CapabilityRegistry = class CapabilityRegistry2 {
+  static {
+    __name(this, "CapabilityRegistry");
   }
-  return JsonRpcXyoSigner.factory(JsonRpcXyoSigner.dependencies, {
-    transport: signer
-  });
+  _entries = /* @__PURE__ */ new Map();
+  get(id) {
+    const cap = this._entries.get(id);
+    if (!cap) throw new Error(`Capability not found: ${id}`);
+    return cap;
+  }
+  register(cap) {
+    if (this._entries.has(cap.id)) {
+      throw new Error(`Capability already registered: ${cap.id}`);
+    }
+    this._entries.set(cap.id, cap);
+    return this;
+  }
+  toJson() {
+    const result = {};
+    for (const [id, cap] of this._entries.entries()) {
+      const { id: _, ...rest } = cap;
+      result[id] = rest;
+    }
+    return result;
+  }
+  tryGet(id) {
+    return this._entries.get(id);
+  }
+};
+function createCapabilityRegistry() {
+  return new CapabilityRegistry();
 }
-__name(signerFactoryFromParam, "signerFactoryFromParam");
-function basicRemoteRunnerLocator(name, remoteConfig, signer, dataLakeEndpoint, validators) {
-  const transport = isAccountInstance(signer) ? void 0 : signer;
-  return sdkBasicRemoteRunnerLocator(name, remoteConfig, transport, dataLakeEndpoint, {
-    additionalProviders: [
-      JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {})
-    ],
-    signerFactory: signerFactoryFromParam(signer),
-    skipGatewayRunner: true,
-    validators
-  });
+__name(createCapabilityRegistry, "createCapabilityRegistry");
+
+// src/node/config/capabilities/defaultCapabilityRegistry.ts
+import { AccountBalanceViewerMoniker, BlockRunnerMoniker, BlockValidationViewerMoniker as BlockValidationViewerMoniker2, BlockViewerMoniker as BlockViewerMoniker2, ChainContractViewerMoniker, DeadLetterQueueRunnerMoniker as DeadLetterQueueRunnerMoniker2, DeadLetterQueueViewerMoniker, FinalizationRunnerMoniker as FinalizationRunnerMoniker2, FinalizationViewerMoniker, MempoolRunnerMoniker, MempoolViewerMoniker as MempoolViewerMoniker2, StakeTotalsViewerMoniker, TimeSyncViewerMoniker, TransactionValidationViewerMoniker, TransactionViewerMoniker, WindowedBlockViewerMoniker, XyoViewerMoniker } from "@xyo-network/xl1-sdk";
+var XyoConnectionMoniker = "XyoConnection";
+var XyoGatewayRunnerMoniker = "XyoGatewayRunner";
+var capabilities = [
+  {
+    id: BlockViewerMoniker2,
+    label: "Block viewer",
+    kind: "viewer"
+  },
+  {
+    id: WindowedBlockViewerMoniker,
+    label: "Windowed block viewer",
+    kind: "viewer"
+  },
+  {
+    id: MempoolViewerMoniker2,
+    label: "Mempool viewer",
+    kind: "viewer"
+  },
+  {
+    id: MempoolRunnerMoniker,
+    label: "Mempool runner",
+    kind: "runner"
+  },
+  {
+    id: AccountBalanceViewerMoniker,
+    label: "Account balance viewer",
+    kind: "viewer"
+  },
+  {
+    id: FinalizationViewerMoniker,
+    label: "Finalization viewer",
+    kind: "viewer"
+  },
+  {
+    id: FinalizationRunnerMoniker2,
+    label: "Finalization runner",
+    kind: "runner"
+  },
+  {
+    id: TransactionViewerMoniker,
+    label: "Transaction viewer",
+    kind: "viewer"
+  },
+  {
+    id: BlockValidationViewerMoniker2,
+    label: "Block validation viewer",
+    kind: "viewer"
+  },
+  {
+    id: TransactionValidationViewerMoniker,
+    label: "Transaction validation viewer",
+    kind: "viewer"
+  },
+  {
+    id: DeadLetterQueueViewerMoniker,
+    label: "Dead-letter queue viewer",
+    kind: "viewer"
+  },
+  {
+    id: DeadLetterQueueRunnerMoniker2,
+    label: "Dead-letter queue runner",
+    kind: "runner"
+  },
+  {
+    id: ChainContractViewerMoniker,
+    label: "Chain contract viewer",
+    kind: "viewer"
+  },
+  {
+    id: StakeTotalsViewerMoniker,
+    label: "Stake totals viewer",
+    kind: "viewer"
+  },
+  {
+    id: TimeSyncViewerMoniker,
+    label: "Time sync viewer",
+    kind: "viewer"
+  },
+  {
+    id: XyoViewerMoniker,
+    label: "XYO viewer",
+    kind: "viewer"
+  },
+  {
+    id: XyoConnectionMoniker,
+    label: "XYO connection",
+    kind: "gateway"
+  },
+  {
+    id: XyoGatewayRunnerMoniker,
+    label: "XYO gateway runner",
+    kind: "gateway"
+  },
+  {
+    id: RejectedTransactionsArchivistProviderMoniker,
+    label: "Rejected transactions archivist provider",
+    kind: "archivist"
+  },
+  {
+    id: BlockRunnerMoniker,
+    label: "Block runner",
+    kind: "runner",
+    implies: [
+      AccountBalanceViewerMoniker,
+      BlockValidationViewerMoniker2,
+      ChainContractViewerMoniker,
+      FinalizationViewerMoniker,
+      MempoolRunnerMoniker,
+      MempoolViewerMoniker2,
+      TimeSyncViewerMoniker
+    ]
+  }
+];
+function createDefaultCapabilityRegistry() {
+  const registry = createCapabilityRegistry();
+  for (const cap of capabilities) registry.register(cap);
+  return registry;
 }
-__name(basicRemoteRunnerLocator, "basicRemoteRunnerLocator");
+__name(createDefaultCapabilityRegistry, "createDefaultCapabilityRegistry");
 
-// src/node/config/locators/basicRemoteViewerLocator.ts
-import { basicRemoteViewerLocator as sdkBasicRemoteViewerLocator, JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer2 } from "@xyo-network/xl1-sdk";
-function basicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, validators) {
-  return sdkBasicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, {
-    additionalProviders: [
-      JsonRpcAccountBalanceViewer2.factory(JsonRpcAccountBalanceViewer2.dependencies, {})
+// src/node/config/capabilities/descriptors.ts
+import { SimpleAccountBalanceViewer, SimpleBlockValidationViewer, SimpleBlockViewer, SimpleDeadLetterQueueRunner, SimpleDeadLetterQueueViewer, SimpleFinalizationRunner, SimpleFinalizationViewer, SimpleMempoolRunner, SimpleMempoolViewer, SimpleTransactionValidationViewer, SimpleTransactionViewer, SimpleWindowedBlockViewer, SimpleXyoConnectionViewer, SimpleXyoViewer } from "@xyo-network/xl1-sdk";
+var passes = /* @__PURE__ */ __name(() => true, "passes");
+var localTier1Descriptors = [
+  {
+    id: "SimpleMempoolViewer",
+    satisfies: [
+      SimpleMempoolViewer.defaultMoniker
     ],
-    validators
-  });
-}
-__name(basicRemoteViewerLocator, "basicRemoteViewerLocator");
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
+      pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
+      pendingBlocksArchivist: ctx.process.pendingBlocksArchivist
+    }), "build")
+  },
+  {
+    id: "SimpleMempoolRunner",
+    satisfies: [
+      SimpleMempoolRunner.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, {
+      pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
+      pendingBlocksArchivist: ctx.process.pendingBlocksArchivist
+    }), "build")
+  },
+  {
+    id: "SimpleAccountBalanceViewer",
+    satisfies: [
+      SimpleAccountBalanceViewer.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleAccountBalanceViewer.factory(SimpleAccountBalanceViewer.dependencies, {
+      balancesSummaryMap: ctx.process.balancesSummaryMap,
+      transfersSummaryMap: ctx.process.transfersSummaryMap
+    }), "build")
+  },
+  {
+    id: "SimpleFinalizationViewer",
+    satisfies: [
+      SimpleFinalizationViewer.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, {
+      finalizedArchivist: ctx.process.readonlyChainArchivist
+    }), "build")
+  },
+  {
+    id: "SimpleBlockViewer",
+    satisfies: [
+      SimpleBlockViewer.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleBlockViewer.factory(SimpleBlockViewer.dependencies, {
+      finalizedArchivist: ctx.process.readonlyChainArchivist
+    }), "build")
+  },
+  {
+    id: "SimpleWindowedBlockViewer",
+    satisfies: [
+      SimpleWindowedBlockViewer.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name(() => SimpleWindowedBlockViewer.factory(SimpleWindowedBlockViewer.dependencies, {
+      maxWindowSize: 1e3,
+      syncInterval: 1e4
+    }), "build")
+  },
+  {
+    id: "SimpleXyoConnectionViewer",
+    satisfies: [
+      SimpleXyoConnectionViewer.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name(() => SimpleXyoConnectionViewer.factory(SimpleXyoConnectionViewer.dependencies, {}), "build")
+  },
+  {
+    id: "SimpleTransactionViewer",
+    satisfies: [
+      SimpleTransactionViewer.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name(() => SimpleTransactionViewer.factory(SimpleTransactionViewer.dependencies, {}), "build")
+  },
+  {
+    id: "SimpleXyoViewer",
+    satisfies: [
+      SimpleXyoViewer.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name(() => SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {}), "build")
+  },
+  {
+    id: "SimpleFinalizationRunner",
+    satisfies: [
+      SimpleFinalizationRunner.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleFinalizationRunner.factory(SimpleFinalizationRunner.dependencies, {
+      finalizedArchivist: ctx.process.writableChainArchivist
+    }), "build")
+  },
+  {
+    id: "SimpleBlockValidationViewer",
+    satisfies: [
+      SimpleBlockValidationViewer.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
+      state: ctx.process.blockStateValidator,
+      protocol: ctx.process.blockProtocolValidator
+    }), "build")
+  },
+  {
+    id: "SimpleTransactionValidationViewer",
+    satisfies: [
+      SimpleTransactionValidationViewer.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleTransactionValidationViewer.factory(SimpleTransactionValidationViewer.dependencies, {
+      protocol: ctx.process.transactionProtocolValidator,
+      state: ctx.process.transactionStateValidator
+    }), "build")
+  },
+  {
+    id: "SimpleDeadLetterQueueRunner",
+    satisfies: [
+      SimpleDeadLetterQueueRunner.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleDeadLetterQueueRunner.factory(SimpleDeadLetterQueueRunner.dependencies, {
+      rejectedBlocksArchivist: ctx.process.rejectedBlocksArchivist,
+      rejectedTransactionsArchivist: ctx.process.rejectedTransactionsArchivist
+    }), "build")
+  },
+  {
+    id: "SimpleDeadLetterQueueViewer",
+    satisfies: [
+      SimpleDeadLetterQueueViewer.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleDeadLetterQueueViewer.factory(SimpleDeadLetterQueueViewer.dependencies, {
+      rejectedBlocksArchivist: ctx.process.rejectedBlocksArchivist,
+      rejectedTransactionsArchivist: ctx.process.rejectedTransactionsArchivist
+    }), "build")
+  },
+  {
+    id: "SimpleRejectedTransactionsArchivistProvider",
+    satisfies: [
+      SimpleRejectedTransactionsArchivistProvider.defaultMoniker
+    ],
+    tier: 1,
+    preconditions: passes,
+    build: /* @__PURE__ */ __name((ctx) => SimpleRejectedTransactionsArchivistProvider.factory(SimpleRejectedTransactionsArchivistProvider.dependencies, {
+      archivist: ctx.process.rejectedTransactionsArchivist
+    }), "build")
+  }
+];
 
-// src/node/config/locators/telemetryContextFromConfig.ts
-import { initTelemetry } from "@xyo-network/chain-telemetry";
-async function telemetryContextFromConfig(config, serviceName, serviceVersion) {
-  const { otlpEndpoint } = config.telemetry?.otel ?? {};
-  const { path: endpoint = "/metrics", port = 9466 } = config.telemetry?.metrics?.scrape ?? {};
-  return await initTelemetry({
-    attributes: {
-      serviceName,
-      serviceVersion
-    },
-    otlpEndpoint,
-    metricsConfig: {
-      endpoint,
-      port
-    }
-  });
-}
-__name(telemetryContextFromConfig, "telemetryContextFromConfig");
+// src/node/config/capabilities/locatorFromActorNeeds.ts
+import { ProviderFactoryLocator } from "@xyo-network/xl1-sdk";
 
-// src/node/config/locators/contextFromConfigWithoutLocator.ts
-async function contextFromConfigWithoutLocator(config, logger, serviceName, serviceVersion) {
-  const singletons = {};
-  const caches = {};
-  const telemetryConfig = await telemetryContextFromConfig(config, serviceName, serviceVersion);
-  const statusReporter = initStatusReporter({
-    logger
-  });
-  return {
-    ...telemetryConfig,
-    config,
-    singletons,
-    caches,
-    logger,
-    statusReporter
-  };
-}
-__name(contextFromConfigWithoutLocator, "contextFromConfigWithoutLocator");
-
-// src/node/config/locators/localLocatorFromConfig.ts
-import { assertEx as assertEx8 } from "@xylabs/sdk-js";
-import { validateHydratedBlock, validateHydratedBlockState } from "@xyo-network/chain-validation";
-import { BlockCumulativeBalanceValidatorFactory, ProviderFactoryLocator, SimpleAccountBalanceViewer, SimpleBlockValidationViewer, SimpleBlockViewer, SimpleDeadLetterQueueRunner, SimpleDeadLetterQueueViewer, SimpleFinalizationRunner, SimpleFinalizationViewer, SimpleMempoolRunner, SimpleMempoolViewer, SimpleTransactionValidationViewer, SimpleTransactionViewer, SimpleWindowedBlockViewer, SimpleXyoConnectionViewer, SimpleXyoViewer, validateTransaction } from "@xyo-network/xl1-sdk";
+// src/node/config/capabilities/ProcessSharedResources.ts
+import { validateHydratedBlock, validateHydratedBlockState, validateHydratedTransactionState } from "@xyo-network/chain-validation";
+import { BlockCumulativeBalanceValidatorFactory, validateTransaction } from "@xyo-network/xl1-sdk";
 
 // src/node/init/initBalanceSummaryMap.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5 } from "@xylabs/sdk-js";
 import { MongoMap } from "@xyo-network/chain-protocol-driver-mongodb";
 import { hasMongoConfig, MemoryMap } from "@xyo-network/xl1-sdk";
 async function initBalanceSummaryMap({ logger, config }) {
@@ -1044,7 +1576,7 @@ async function initBalanceSummaryMap({ logger, config }) {
         maxEntries: 5e3
       }
     });
-    assertEx4(await result.start(), () => "Failed to start transfer summary map");
+    assertEx5(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
@@ -1106,7 +1638,7 @@ async function initEvmProvidersIfAvailable(locator) {
 __name(initEvmProvidersIfAvailable, "initEvmProvidersIfAvailable");
 
 // src/node/init/initFinalizationArchivistIfNeeded.ts
-import { assertEx as assertEx5 } from "@xylabs/sdk-js";
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
 import { createBootstrapHead } from "@xyo-network/chain-sdk";
 import { Account } from "@xyo-network/sdk-js";
 import { asAttoXL1, findMostRecentBlock, flattenHydratedBlock } from "@xyo-network/xl1-sdk";
@@ -1129,8 +1661,8 @@ async function initFinalizationArchivistIfNeeded(archivist, config, account, opt
     const payloads = chain.flatMap((block) => flattenHydratedBlock(block));
     await archivist.insert(payloads);
   }
-  const head = possibleHead ?? assertEx5(await findMostRecentBlock(archivist), () => "No blocks found in chain archivist");
-  const chainId = assertEx5(possibleChainId, () => "Chain ID could not be determined");
+  const head = possibleHead ?? assertEx6(await findMostRecentBlock(archivist), () => "No blocks found in chain archivist");
+  const chainId = assertEx6(possibleChainId, () => "Chain ID could not be determined");
   return [
     head,
     chainId
@@ -1157,7 +1689,7 @@ async function initFinalizedArchivist(config) {
 __name(initFinalizedArchivist, "initFinalizedArchivist");
 
 // src/node/init/initServerNode.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
 import { asArchivistInstance } from "@xyo-network/sdk-js";
 
 // src/node/manifest/getLocator.ts
@@ -1165,7 +1697,7 @@ import { isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { LmdbArchivistConfigSchema } from "@xyo-network/archivist-lmdb";
 import { MongoDBArchivistV2 as MongoDBArchivistV22, MongoDBArchivistV2Deletable } from "@xyo-network/archivist-mongodb";
 import { ViewArchivist } from "@xyo-network/archivist-view";
-import { initTelemetry as initTelemetry2 } from "@xyo-network/chain-telemetry";
+import { initTelemetry } from "@xyo-network/chain-telemetry";
 import { AbstractModule, LoggerModuleStatusReporter, MemoryArchivist, MemorySentinel, ModuleFactoryLocator } from "@xyo-network/sdk-js";
 import { hasMongoConfig as hasMongoConfig2 } from "@xyo-network/xl1-sdk";
 
@@ -1197,7 +1729,7 @@ var NamedLmdbArchivist = class extends LmdbArchivist {
 var getLocator = /* @__PURE__ */ __name(async ({ logger, config }) => {
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
   const { path: endpoint = "/metrics", port = 9465 } = config.telemetry?.metrics?.scrape ?? {};
-  const { traceProvider, meterProvider } = await initTelemetry2({
+  const { traceProvider, meterProvider } = await initTelemetry({
     attributes: {
       serviceName: "xl1-api",
       serviceVersion: "1.0.0"
@@ -1484,7 +2016,7 @@ async function writableChainArchivistFromNode(node) {
 }
 __name(writableChainArchivistFromNode, "writableChainArchivistFromNode");
 async function readonlyChainArchivistFromNode(node) {
-  return assertEx6(asArchivistInstance(await node.resolve("Chain:Validated"), {
+  return assertEx7(asArchivistInstance(await node.resolve("Chain:Validated"), {
     required: true
   }));
 }
@@ -1515,7 +2047,7 @@ async function rejectedTransactionsArchivistFromNode(node) {
 __name(rejectedTransactionsArchivistFromNode, "rejectedTransactionsArchivistFromNode");
 async function initServerNode(context, wallet, providedNode) {
   const node = providedNode ?? await loadNode(context, wallet);
-  assertEx6(await node.start(), () => "Failed to start node");
+  assertEx7(await node.start(), () => "Failed to start node");
   const writableChainArchivist = await writableChainArchivistFromNode(node);
   const readonlyChainArchivist = await readonlyChainArchivistFromNode(node);
   const pendingTransactionsArchivist = await pendingTransactionsArchivistFromNode(node);
@@ -1536,7 +2068,7 @@ __name(initServerNode, "initServerNode");
 
 // src/node/init/initTransferSummaryMap.ts
 import { BaseMongoSdk as BaseMongoSdk2 } from "@xylabs/mongo";
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
 import { MongoMap as MongoMap2 } from "@xyo-network/chain-protocol-driver-mongodb";
 import { hasMongoConfig as hasMongoConfig3, MemoryMap as MemoryMap2 } from "@xyo-network/xl1-sdk";
 async function initTransferSummaryMap({ logger, config }) {
@@ -1561,7 +2093,7 @@ async function initTransferSummaryMap({ logger, config }) {
         maxEntries: 5e3
       }
     });
-    assertEx7(await result.start(), () => "Failed to start transfer summary map");
+    assertEx8(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.");
@@ -1570,7 +2102,7 @@ async function initTransferSummaryMap({ logger, config }) {
 }
 __name(initTransferSummaryMap, "initTransferSummaryMap");
 
-// src/node/config/locators/localLocatorFromConfig.ts
+// src/node/config/capabilities/ProcessSharedResources.ts
 var cumulativeBalanceValidator = BlockCumulativeBalanceValidatorFactory();
 var validateHydratedBlockStateWithCumulativeBalance = /* @__PURE__ */ __name(async (context, block) => {
   const [stateErrors, cumulativeErrors] = await Promise.all([
@@ -1582,68 +2114,335 @@ var validateHydratedBlockStateWithCumulativeBalance = /* @__PURE__ */ __name(asy
     ...cumulativeErrors
   ];
 }, "validateHydratedBlockStateWithCumulativeBalance");
-async function localLocatorFromConfig(context, validateDepsOnRegister = false, onInsecureGenesisConfirm) {
-  const balancesSummaryMap = assertEx8(await initBalanceSummaryMap(context), () => "Balance Summary Map not initialized");
-  const transfersSummaryMap = assertEx8(await initTransferSummaryMap(context), () => "Transfer Summary Map not initialized");
+async function buildProcessSharedResources(context, options) {
+  const balancesSummaryMap = await initBalanceSummaryMap(context);
+  if (!balancesSummaryMap) throw new Error("Balance Summary Map not initialized");
+  const transfersSummaryMap = await initTransferSummaryMap(context);
+  if (!transfersSummaryMap) throw new Error("Transfer Summary Map not initialized");
   const wallet = await initActorWallet(context);
-  const { writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist, rejectedBlocksArchivist, rejectedTransactionsArchivist } = await initServerNode(context, wallet);
+  const serverNode = await initServerNode(context, wallet);
+  const { writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist, rejectedBlocksArchivist, rejectedTransactionsArchivist } = serverNode;
   await initFinalizationArchivistIfNeeded(writableChainArchivist, context.config, wallet, {
     logger: context.logger,
-    onInsecureGenesisConfirm
+    onInsecureGenesisConfirm: options?.onInsecureGenesisConfirm
   });
-  const locator = new ProviderFactoryLocator(context, {}, validateDepsOnRegister);
-  locator.registerMany([
-    SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
-      pendingTransactionsArchivist,
-      pendingBlocksArchivist
-    }),
-    SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, {
-      pendingTransactionsArchivist,
-      pendingBlocksArchivist
-    }),
-    SimpleAccountBalanceViewer.factory(SimpleAccountBalanceViewer.dependencies, {
-      balancesSummaryMap,
-      transfersSummaryMap
-    }),
-    SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, {
-      finalizedArchivist: readonlyChainArchivist
-    }),
-    SimpleBlockViewer.factory(SimpleBlockViewer.dependencies, {
-      finalizedArchivist: readonlyChainArchivist
-    }),
-    SimpleWindowedBlockViewer.factory(SimpleWindowedBlockViewer.dependencies, {
-      maxWindowSize: 1e3,
-      syncInterval: 1e4
-    }),
-    SimpleXyoConnectionViewer.factory(SimpleXyoConnectionViewer.dependencies, {}),
-    SimpleTransactionViewer.factory(SimpleTransactionViewer.dependencies, {}),
-    SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {}),
-    SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, {
-      finalizedArchivist: readonlyChainArchivist
-    }),
-    SimpleFinalizationRunner.factory(SimpleFinalizationRunner.dependencies, {
-      finalizedArchivist: writableChainArchivist
-    }),
-    SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
-      state: validateHydratedBlockStateWithCumulativeBalance,
-      protocol: validateHydratedBlock
-    }),
-    SimpleTransactionValidationViewer.factory(SimpleTransactionValidationViewer.dependencies, {
-      protocol: validateTransaction
-    }),
-    SimpleDeadLetterQueueRunner.factory(SimpleDeadLetterQueueRunner.dependencies, {
-      rejectedBlocksArchivist,
-      rejectedTransactionsArchivist
-    }),
-    SimpleDeadLetterQueueViewer.factory(SimpleDeadLetterQueueViewer.dependencies, {
-      rejectedBlocksArchivist,
-      rejectedTransactionsArchivist
-    }),
-    SimpleRejectedTransactionsArchivistProvider.factory(SimpleRejectedTransactionsArchivistProvider.dependencies, {
-      archivist: rejectedTransactionsArchivist
-    })
-  ]);
-  return locator;
+  return {
+    balancesSummaryMap,
+    transfersSummaryMap,
+    wallet,
+    node: serverNode.node,
+    writableChainArchivist,
+    readonlyChainArchivist,
+    pendingTransactionsArchivist,
+    pendingBlocksArchivist,
+    rejectedBlocksArchivist,
+    rejectedTransactionsArchivist,
+    blockProtocolValidator: validateHydratedBlock,
+    blockStateValidator: validateHydratedBlockStateWithCumulativeBalance,
+    transactionProtocolValidator: validateTransaction,
+    transactionStateValidator: validateHydratedTransactionState
+  };
+}
+__name(buildProcessSharedResources, "buildProcessSharedResources");
+
+// src/node/config/capabilities/resolveProviders.ts
+var MissingCapabilityError = class extends Error {
+  static {
+    __name(this, "MissingCapabilityError");
+  }
+  moniker;
+  reasons;
+  constructor(moniker, reasons) {
+    const detail = reasons.length === 0 ? "(no candidates registered)" : reasons.join("; ");
+    super(`No provider satisfies capability '${moniker}': ${detail}`);
+    this.name = "MissingCapabilityError";
+    this.moniker = moniker;
+    this.reasons = reasons;
+  }
+};
+function resolveProviders(needs, candidates, ctx) {
+  const wanted = expandNeeds(needs, ctx);
+  const { surviving, rejected } = filterByPreconditions(candidates, ctx);
+  const byCapability = groupByCapability(surviving, wanted);
+  const { bindings, selectedById } = pickWinners(wanted, byCapability, rejected, candidates);
+  const selected = topoSort([
+    ...selectedById.values()
+  ], ctx);
+  return {
+    bindings,
+    rejected,
+    selected
+  };
+}
+__name(resolveProviders, "resolveProviders");
+function expandNeeds(needs, ctx) {
+  const wanted = new Set(needs);
+  const stack = [
+    ...needs
+  ];
+  while (stack.length > 0) {
+    const moniker = stack.pop();
+    const cap = ctx.capabilities.tryGet(moniker);
+    if (!cap?.implies) continue;
+    for (const dep of cap.implies) {
+      if (!wanted.has(dep)) {
+        wanted.add(dep);
+        stack.push(dep);
+      }
+    }
+  }
+  return wanted;
+}
+__name(expandNeeds, "expandNeeds");
+function filterByPreconditions(candidates, ctx) {
+  const surviving = [];
+  const rejected = [];
+  for (const descriptor of candidates) {
+    try {
+      if (descriptor.preconditions(ctx)) {
+        surviving.push(descriptor);
+      } else {
+        rejected.push({
+          descriptor,
+          reason: "preconditions returned false"
+        });
+      }
+    } catch (err) {
+      rejected.push({
+        descriptor,
+        reason: `preconditions threw: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  return {
+    surviving,
+    rejected
+  };
+}
+__name(filterByPreconditions, "filterByPreconditions");
+function groupByCapability(surviving, wanted) {
+  const byCapability = /* @__PURE__ */ new Map();
+  for (const descriptor of surviving) {
+    for (const moniker of descriptor.satisfies) {
+      if (!wanted.has(moniker)) continue;
+      const list = byCapability.get(moniker) ?? [];
+      list.push(descriptor);
+      byCapability.set(moniker, list);
+    }
+  }
+  return byCapability;
+}
+__name(groupByCapability, "groupByCapability");
+function pickWinners(wanted, byCapability, rejected, allCandidates) {
+  const bindings = {};
+  const selectedById = /* @__PURE__ */ new Map();
+  for (const moniker of wanted) {
+    const group = byCapability.get(moniker);
+    if (!group || group.length === 0) {
+      throw new MissingCapabilityError(moniker, reasonsFor(moniker, rejected, allCandidates));
+    }
+    const sorted = group.toSorted(compareDescriptors);
+    const winner = sorted[0];
+    bindings[moniker] = winner.id;
+    selectedById.set(winner.id, winner);
+    for (const loser of sorted.slice(1)) {
+      rejected.push({
+        descriptor: loser,
+        reason: `tier ${loser.tier} lost to ${winner.id} (tier ${winner.tier}) for ${moniker}`
+      });
+    }
+  }
+  return {
+    bindings,
+    selectedById
+  };
+}
+__name(pickWinners, "pickWinners");
+function reasonsFor(moniker, rejected, allCandidates) {
+  const candidatesForMoniker = allCandidates.filter((c) => c.satisfies.includes(moniker));
+  if (candidatesForMoniker.length === 0) return [];
+  return rejected.filter((r) => r.descriptor.satisfies.includes(moniker)).map((r) => `${r.descriptor.id}: ${r.reason}`);
+}
+__name(reasonsFor, "reasonsFor");
+function compareDescriptors(a, b) {
+  if (a.tier !== b.tier) return a.tier - b.tier;
+  const pa = a.priority ?? 0;
+  const pb = b.priority ?? 0;
+  if (pa !== pb) return pb - pa;
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+__name(compareDescriptors, "compareDescriptors");
+function topoSort(descriptors, ctx) {
+  const byMoniker = /* @__PURE__ */ new Map();
+  for (const d of descriptors) for (const m of d.satisfies) byMoniker.set(m, d);
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((d) => {
+    if (seen.has(d.id)) return;
+    if (visiting.has(d.id)) {
+      throw new Error(`Cycle detected through provider ${d.id}`);
+    }
+    visiting.add(d.id);
+    for (const moniker of d.satisfies) {
+      const cap = ctx.capabilities.tryGet(moniker);
+      if (!cap?.implies) continue;
+      for (const dep of cap.implies) {
+        const depDesc = byMoniker.get(dep);
+        if (depDesc) visit(depDesc);
+      }
+    }
+    visiting.delete(d.id);
+    seen.add(d.id);
+    order.push(d);
+  }, "visit");
+  for (const d of descriptors) visit(d);
+  return order;
+}
+__name(topoSort, "topoSort");
+
+// src/node/config/capabilities/locatorFromActorNeeds.ts
+async function locatorFromActorNeeds(context, actorNeeds, options = {}) {
+  const process2 = await buildProcessSharedResources(context, options);
+  const capabilities2 = createDefaultCapabilityRegistry();
+  const resolutionContext = {
+    actorContext: context,
+    capabilities: capabilities2,
+    process: process2
+  };
+  const needs = unionNeeds(actorNeeds);
+  const candidates = [
+    ...localTier1Descriptors,
+    ...options.extraDescriptors ?? []
+  ];
+  const plan = resolveProviders(needs, candidates, resolutionContext);
+  const locator = new ProviderFactoryLocator(context, {}, options.validateDepsOnRegister ?? false);
+  const factories = plan.selected.map((d) => d.build(resolutionContext)).filter((f) => f !== void 0);
+  locator.registerMany(factories);
+  return {
+    locator,
+    plan,
+    process: process2
+  };
+}
+__name(locatorFromActorNeeds, "locatorFromActorNeeds");
+function unionNeeds(actorNeeds) {
+  const result = /* @__PURE__ */ new Set();
+  for (const needs of actorNeeds) {
+    for (const moniker of needs.required) result.add(moniker);
+    if (needs.optional) for (const moniker of needs.optional) result.add(moniker);
+  }
+  return result;
+}
+__name(unionNeeds, "unionNeeds");
+
+// src/node/config/locators/basicRemoteRunnerLocator.ts
+import { isAccountInstance } from "@xyo-network/sdk-js";
+import { basicRemoteRunnerLocator as sdkBasicRemoteRunnerLocator, JsonRpcAccountBalanceViewer, JsonRpcXyoSigner, SimpleXyoSigner } from "@xyo-network/xl1-sdk";
+function signerFactoryFromParam(signer) {
+  if (isAccountInstance(signer)) {
+    return SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, {
+      account: signer
+    });
+  }
+  return JsonRpcXyoSigner.factory(JsonRpcXyoSigner.dependencies, {
+    transport: signer
+  });
+}
+__name(signerFactoryFromParam, "signerFactoryFromParam");
+function basicRemoteRunnerLocator(name, remoteConfig, signer, dataLakeEndpoint, validators) {
+  const transport = isAccountInstance(signer) ? void 0 : signer;
+  return sdkBasicRemoteRunnerLocator(name, remoteConfig, transport, dataLakeEndpoint, {
+    additionalProviders: [
+      JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {})
+    ],
+    signerFactory: signerFactoryFromParam(signer),
+    skipGatewayRunner: true,
+    validators
+  });
+}
+__name(basicRemoteRunnerLocator, "basicRemoteRunnerLocator");
+
+// src/node/config/locators/basicRemoteViewerLocator.ts
+import { basicRemoteViewerLocator as sdkBasicRemoteViewerLocator, JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer2 } from "@xyo-network/xl1-sdk";
+function basicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, validators) {
+  return sdkBasicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, {
+    additionalProviders: [
+      JsonRpcAccountBalanceViewer2.factory(JsonRpcAccountBalanceViewer2.dependencies, {})
+    ],
+    validators
+  });
+}
+__name(basicRemoteViewerLocator, "basicRemoteViewerLocator");
+
+// src/node/config/locators/telemetryContextFromConfig.ts
+import { initTelemetry as initTelemetry2 } from "@xyo-network/chain-telemetry";
+async function telemetryContextFromConfig(config, serviceName, serviceVersion) {
+  const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = 9466 } = config.telemetry?.metrics?.scrape ?? {};
+  return await initTelemetry2({
+    attributes: {
+      serviceName,
+      serviceVersion
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint,
+      port
+    }
+  });
+}
+__name(telemetryContextFromConfig, "telemetryContextFromConfig");
+
+// src/node/config/locators/contextFromConfigWithoutLocator.ts
+async function contextFromConfigWithoutLocator(config, logger, serviceName, serviceVersion) {
+  const singletons = {};
+  const caches = {};
+  const telemetryConfig = await telemetryContextFromConfig(config, serviceName, serviceVersion);
+  const statusReporter = initStatusReporter({
+    logger
+  });
+  return {
+    ...telemetryConfig,
+    config,
+    singletons,
+    caches,
+    logger,
+    statusReporter
+  };
+}
+__name(contextFromConfigWithoutLocator, "contextFromConfigWithoutLocator");
+
+// src/node/config/locators/localLocatorFromConfig.ts
+import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2, BlockValidationViewerMoniker as BlockValidationViewerMoniker3, BlockViewerMoniker as BlockViewerMoniker3, DeadLetterQueueRunnerMoniker as DeadLetterQueueRunnerMoniker3, DeadLetterQueueViewerMoniker as DeadLetterQueueViewerMoniker2, FinalizationRunnerMoniker as FinalizationRunnerMoniker3, FinalizationViewerMoniker as FinalizationViewerMoniker2, MempoolRunnerMoniker as MempoolRunnerMoniker2, MempoolViewerMoniker as MempoolViewerMoniker3, TransactionValidationViewerMoniker as TransactionValidationViewerMoniker2, TransactionViewerMoniker as TransactionViewerMoniker2, WindowedBlockViewerMoniker as WindowedBlockViewerMoniker2, XyoViewerMoniker as XyoViewerMoniker2 } from "@xyo-network/xl1-sdk";
+var XyoConnectionMoniker2 = "XyoConnection";
+var LOCAL_LEGACY_NEEDS = {
+  required: [
+    AccountBalanceViewerMoniker2,
+    BlockValidationViewerMoniker3,
+    BlockViewerMoniker3,
+    DeadLetterQueueRunnerMoniker3,
+    DeadLetterQueueViewerMoniker2,
+    FinalizationRunnerMoniker3,
+    FinalizationViewerMoniker2,
+    MempoolRunnerMoniker2,
+    MempoolViewerMoniker3,
+    RejectedTransactionsArchivistProviderMoniker,
+    TransactionValidationViewerMoniker2,
+    TransactionViewerMoniker2,
+    WindowedBlockViewerMoniker2,
+    XyoConnectionMoniker2,
+    XyoViewerMoniker2
+  ]
+};
+async function localLocatorFromConfig(context, validateDepsOnRegister = false, onInsecureGenesisConfirm) {
+  const result = await locatorFromActorNeeds(context, [
+    LOCAL_LEGACY_NEEDS
+  ], {
+    onInsecureGenesisConfirm,
+    validateDepsOnRegister
+  });
+  return result.locator;
 }
 __name(localLocatorFromConfig, "localLocatorFromConfig");
 
@@ -1752,7 +2551,7 @@ function mempoolLocatorFromConfig(context, parent) {
 __name(mempoolLocatorFromConfig, "mempoolLocatorFromConfig");
 
 // src/node/config/locators/actors/producerLocatorFromConfig.ts
-import { asAddress as asAddress2 } from "@xylabs/sdk-js";
+import { asAddress } from "@xylabs/sdk-js";
 import { SimpleBlockRunner } from "@xyo-network/chain-services";
 import { ProviderFactoryLocator as ProviderFactoryLocator6 } from "@xyo-network/xl1-sdk";
 async function producerLocatorFromConfig(context, parent) {
@@ -1762,7 +2561,7 @@ async function producerLocatorFromConfig(context, parent) {
     ...context,
     locator: parent
   });
-  const rewardAddress = asAddress2(config.rewardAddress ?? account.address, true);
+  const rewardAddress = asAddress(config.rewardAddress ?? account.address, true);
   logger?.info(`Using reward address ${rewardAddress}`);
   if (rewardAddress === account.address) {
     logger?.warn(`Using producer account address as reward address: ${account.address}`);
@@ -1773,7 +2572,11 @@ async function producerLocatorFromConfig(context, parent) {
     SimpleBlockRunner.factory(SimpleBlockRunner.dependencies, {
       account,
       rewardAddress,
-      rejectedTransactionsArchivist
+      rejectedTransactionsArchivist,
+      // ProducerConfigZod has always exposed `heartbeatInterval`, but until now
+      // it was not wired anywhere. Threading it into the BlockRunner lets tests
+      // (and operators who want denser heartbeat blocks) override the 1-h default.
+      heartbeatInterval: config.heartbeatInterval
     })
   ]);
   locator.freeze();
@@ -1959,7 +2762,10 @@ export * from "@xyo-network/chain-orchestration-evm";
 export * from "@xyo-network/chain-orchestration-express";
 export * from "@xyo-network/chain-orchestration-storage";
 export {
+  Actor,
   ActorMnemonicNotAllowedError,
+  ActorParamsV3Zod,
+  ActorV3,
   ApiConfigContext,
   ApiConfigZod,
   BUILT_IN_DEV_MNEMONIC,
@@ -1982,6 +2788,7 @@ export {
   INSECURE_GENESIS_REWARD_MNEMONIC,
   MempoolConfigContext,
   MempoolConfigZod,
+  MissingCapabilityError,
   NodeManifest,
   Orchestrator,
   PrivateChildManifests,
@@ -2011,9 +2818,12 @@ export {
   basicRemoteRunnerLocator,
   basicRemoteViewerLocator,
   buildInsecureGenesisRewardAccounts,
+  buildProcessSharedResources,
   buildTelemetryConfig,
   clearResolvedWalletReport,
   contextFromConfigWithoutLocator,
+  createCapabilityRegistry,
+  createDefaultCapabilityRegistry,
   createProducerChainStakeIntentBlock,
   detectDerivationPathCollisions,
   expandAccountPath,
@@ -2051,11 +2861,14 @@ export {
   isRewardRedemptionConfigContext,
   loadNode,
   localLocatorFromConfig,
+  localTier1Descriptors,
+  locatorFromActorNeeds,
   locatorsFromConfig,
   mergeConfig,
   resolveActorAccountPath,
   resolveActorWallet,
   resolveGenesisRewardAddress,
+  resolveProviders,
   resolveRootWallet,
   resolveWalletForActor,
   resolveWalletReport,