@xyo-network/chain-orchestration 1.22.0 → 1.23.0

package/dist/neutral/node/config/locators/sharedLocatorFromConfig.d.ts

@@ -0,0 +1,68 @@
+import type { ActorConfig, CachingContext, Config, ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk';
+/**
+ * Names of the actors this builder supports. Outside this set, `locatorsFromConfig`
+ * routes to the legacy per-actor child-locator path.
+ */
+export declare const SHARED_LOCATOR_SUPPORTED_ACTORS: readonly string[];
+/**
+ * Returns true iff the configured actors are exactly the full canary trio
+ * (`api`, `mempool`, `finalizer`) running in one process AND the run is
+ * in-memory (no `remote.rpc`) AND no actor opts into stateless mode.
+ *
+ * The shared path was designed for the canary case where all three actors
+ * co-locate and share a single registry, so each provider is instantiated
+ * exactly once. Any subset has a transitive-dependency problem the union
+ * of `ACTOR_MIRRORS` cannot satisfy:
+ *
+ *   - Solo `api` — `SimpleXyoConnectionRunner` (chosen for `XyoConnection`)
+ *     requires a local `MempoolRunner`, only registered when `mempool` is in
+ *     the union. Crash:
+ *       "No provider instance for the supplied config moniker [MempoolRunner]"
+ *   - Solo `mempool` — `SimpleMempoolRunner` requires a local
+ *     `BlockValidationViewer`, only registered when `finalizer` is in the
+ *     union. Crash:
+ *       "No provider instance for the supplied config moniker [BlockValidationViewer]"
+ *   - Solo `finalizer` and `[api, finalizer]` etc. — same class of mismatch.
+ *
+ * Multi-process deployments (`xl1 start api` in one proc, `xl1 start mempool`
+ * in another) fall under "subset" and must therefore route to the legacy
+ * `_root` path. `localLocatorFromConfig` registers `LOCAL_LEGACY_NEEDS`
+ * (every canary moniker) on `_root`, which the per-actor child locators
+ * inherit — so each subset finds its transitive deps via `_root`.
+ */
+export declare function canUseSharedLocator(actors: readonly ActorConfig[], config: Omit<Config, 'actors'>): boolean;
+export interface SharedLocatorFromConfigResult {
+    /**
+     * Per-actor view locators. Each is a thin wrapper that shares `shared`'s
+     * registry by reference (`registry === shared.registry`) but has its own
+     * `context` carrying the actor-specific config block. Hand these to the
+     * actor constructors — `getApiActor`, `getMempoolActor`, `getFinalizerActor`
+     * pull their actor-specific config from `locator.context.config`.
+     */
+    readonly perActor: Record<string, ProviderFactoryLocatorInstance>;
+    /**
+     * The single underlying locator that owns the shared registry. Tests and
+     * the dump tool can introspect this directly to see the unique factory set.
+     */
+    readonly shared: ProviderFactoryLocatorInstance;
+}
+export interface SharedLocatorFromConfigOptions {
+    readonly onInsecureGenesisConfirm?: () => Promise<void>;
+}
+/**
+ * Builds a single shared locator driven by the union of the configured actors'
+ * declared `needs`, plus the EVM/memory contract+stake providers from
+ * `initEvmProvidersIfAvailable`. Each actor receives a thin view locator that
+ * shares the registry by reference, so every provider exists exactly once
+ * per process.
+ *
+ * Replaces the legacy `_root` + per-actor child-locator layering for the
+ * canary actor combos (api+mempool+finalizer subset). Eliminates Symptoms 2
+ * and 3 from the double-loading findings: no cross-locator duplicates, no
+ * empty actor-locator shells.
+ *
+ * Stateless API and remote-RPC paths are NOT supported here — the caller
+ * (`locatorsFromConfig`) routes those to the existing builders.
+ */
+export declare function sharedLocatorFromConfig(context: CachingContext, actors: readonly ActorConfig[], config: Omit<Config, 'actors'>, options?: SharedLocatorFromConfigOptions): Promise<SharedLocatorFromConfigResult>;
+//# sourceMappingURL=sharedLocatorFromConfig.d.ts.map

package/dist/neutral/node/config/locators/sharedLocatorFromConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharedLocatorFromConfig.d.ts","sourceRoot":"","sources":["../../../../../src/node/config/locators/sharedLocatorFromConfig.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EAEX,cAAc,EACd,MAAM,EACN,8BAA8B,EAC/B,MAAM,sBAAsB,CAAA;AAgJ7B;;;GAGG;AACH,eAAO,MAAM,+BAA+B,EAAE,SAAS,MAAM,EAAoC,CAAA;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,OAAO,CAgB3G;AAED,MAAM,WAAW,6BAA6B;IAC5C;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAA;IACjE;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,8BAA8B,CAAA;CAChD;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACxD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC9B,OAAO,GAAE,8BAAmC,GAC3C,OAAO,CAAC,6BAA6B,CAAC,CA2DxC"}

package/dist/neutral/shared/config/actors/Mempool.d.ts

@@ -3,6 +3,8 @@ import type { BaseConfigContext } from '@xyo-network/xl1-sdk';
 import { z } from 'zod';
 export declare const DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL = 1000;
 export declare const DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL = 1000;
+export declare const DEFAULT_MEMPOOL_DEMOTION_THRESHOLD = 3;
+export declare const DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS = 0;
 export declare const MempoolConfigZod: z.ZodObject<{
     chain: z.ZodDefault<z.ZodObject<{
         id: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>>;
@@ -90,6 +92,8 @@ export declare const MempoolConfigZod: z.ZodObject<{
     port: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     enabled: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>, z.ZodTransform<boolean, string | boolean>>;
     blockPruneInterval: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    demotionThreshold: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    maxPendingTransactions: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     transactionPruneInterval: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strip>;
 export type MempoolConfig = z.infer<typeof MempoolConfigZod>;
@@ -171,6 +175,8 @@ export declare const isMempoolConfig: <T>(value: T) => value is T & {
     port: number;
     enabled: boolean;
     blockPruneInterval: number;
+    demotionThreshold: number;
+    maxPendingTransactions: number;
     transactionPruneInterval: number;
     dataLake?: import("@xyo-network/xl1-sdk").DataLakeConfig | undefined;
     accountPath?: string | undefined;
@@ -255,6 +261,8 @@ export declare const asMempoolConfig: {
         port: number;
         enabled: boolean;
         blockPruneInterval: number;
+        demotionThreshold: number;
+        maxPendingTransactions: number;
         transactionPruneInterval: number;
         dataLake?: import("@xyo-network/xl1-sdk").DataLakeConfig | undefined;
         accountPath?: string | undefined;
@@ -338,6 +346,8 @@ export declare const asMempoolConfig: {
         port: number;
         enabled: boolean;
         blockPruneInterval: number;
+        demotionThreshold: number;
+        maxPendingTransactions: number;
         transactionPruneInterval: number;
         dataLake?: import("@xyo-network/xl1-sdk").DataLakeConfig | undefined;
         accountPath?: string | undefined;
@@ -423,6 +433,8 @@ export declare const toMempoolConfig: {
         port: number;
         enabled: boolean;
         blockPruneInterval: number;
+        demotionThreshold: number;
+        maxPendingTransactions: number;
         transactionPruneInterval: number;
         dataLake?: import("@xyo-network/xl1-sdk").DataLakeConfig | undefined;
         accountPath?: string | undefined;
@@ -506,6 +518,8 @@ export declare const toMempoolConfig: {
         port: number;
         enabled: boolean;
         blockPruneInterval: number;
+        demotionThreshold: number;
+        maxPendingTransactions: number;
         transactionPruneInterval: number;
         dataLake?: import("@xyo-network/xl1-sdk").DataLakeConfig | undefined;
         accountPath?: string | undefined;

package/dist/neutral/shared/config/actors/Mempool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mempool.d.ts","sourceRoot":"","sources":["../../../../../src/shared/config/actors/Mempool.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAAgB,YAAY,EACzC,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAE7D,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvC,eAAO,MAAM,oCAAoC,OAAO,CAAA;AACxD,eAAO,MAAM,0CAA0C,OAAO,CAAA;AAE9D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4B3B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE5D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAiC,CAAA;AAC7D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoD,CAAA;AAChF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoD,CAAA;AAEhF,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,iBAAiB,EAAE,QAAQ,CAAC;IAC7E,MAAM,EAAE,aAAa,CAAA;CACtB;AAED,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAA6D,CAAA;AAE9H,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,GAAG,oBAAyD,CAAA;AAC5H,eAAO,MAAM,sBAAsB,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,oBAAoB,CAAC,CAAgE,CAAA;AACzJ,eAAO,MAAM,sBAAsB,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,oBAAoB,CAAC,CAAgE,CAAA"}
+{"version":3,"file":"Mempool.d.ts","sourceRoot":"","sources":["../../../../../src/shared/config/actors/Mempool.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAAgB,YAAY,EACzC,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAE7D,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvC,eAAO,MAAM,oCAAoC,OAAO,CAAA;AACxD,eAAO,MAAM,0CAA0C,OAAO,CAAA;AAC9D,eAAO,MAAM,kCAAkC,IAAI,CAAA;AACnD,eAAO,MAAM,wCAAwC,IAAI,CAAA;AAEzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsC3B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE5D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAiC,CAAA;AAC7D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoD,CAAA;AAChF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoD,CAAA;AAEhF,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,iBAAiB,EAAE,QAAQ,CAAC;IAC7E,MAAM,EAAE,aAAa,CAAA;CACtB;AAED,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAA6D,CAAA;AAE9H,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,GAAG,oBAAyD,CAAA;AAC5H,eAAO,MAAM,sBAAsB,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,oBAAoB,CAAC,CAAgE,CAAA;AACzJ,eAAO,MAAM,sBAAsB,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,oBAAoB,CAAC,CAAgE,CAAA"}

package/dist/node/index.mjs

@@ -484,6 +484,8 @@ import { BaseConfigContextZod as BaseConfigContextZod4, HostActorConfigZod as Ho
 import { globalRegistry as globalRegistry3, z as z5 } from "zod";
 var DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL = 1e3;
 var DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL = 1e3;
+var DEFAULT_MEMPOOL_DEMOTION_THRESHOLD = 3;
+var DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS = 0;
 var MempoolConfigZod = HostActorConfigZod4.extend({
   enabled: z5.union([
     z5.string(),
@@ -520,6 +522,16 @@ var MempoolConfigZod = HostActorConfigZod4.extend({
     title: "mempool.blockPruneInterval",
     type: "number"
   }),
+  demotionThreshold: z5.coerce.number().int().positive().default(DEFAULT_MEMPOOL_DEMOTION_THRESHOLD).register(globalRegistry3, {
+    description: "Number of times a transaction may be handed out to producers without being included in a block before it is considered demoted",
+    title: "mempool.demotionThreshold",
+    type: "number"
+  }),
+  maxPendingTransactions: z5.coerce.number().int().nonnegative().default(DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS).register(globalRegistry3, {
+    description: "Maximum number of pending transactions in the pool. When exceeded, demoted transactions are evicted first, then oldest by sequence. 0 disables the cap.",
+    title: "mempool.maxPendingTransactions",
+    type: "number"
+  }),
   transactionPruneInterval: z5.coerce.number().default(DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL).register(globalRegistry3, {
     description: "The interval time (in milliseconds) between pending transaction prune attempts",
     title: "mempool.transactionPruneInterval",
@@ -1364,6 +1376,14 @@ __name(createDefaultCapabilityRegistry, "createDefaultCapabilityRegistry");
 
 // src/node/config/capabilities/descriptors.ts
 import { SimpleAccountBalanceViewer, SimpleBlockValidationViewer, SimpleBlockViewer, SimpleDeadLetterQueueRunner, SimpleDeadLetterQueueViewer, SimpleFinalizationRunner, SimpleFinalizationViewer, SimpleMempoolRunner, SimpleMempoolViewer, SimpleTransactionValidationViewer, SimpleTransactionViewer, SimpleWindowedBlockViewer, SimpleXyoConnectionViewer, SimpleXyoViewer } from "@xyo-network/xl1-sdk";
+function readMempoolTuning(ctx) {
+  const cfg = ctx.actorContext.config;
+  return {
+    demotionThreshold: cfg?.mempool?.demotionThreshold,
+    maxPendingTransactions: cfg?.mempool?.maxPendingTransactions
+  };
+}
+__name(readMempoolTuning, "readMempoolTuning");
 var passes = /* @__PURE__ */ __name(() => true, "passes");
 var localTier1Descriptors = [
   {
@@ -1380,10 +1400,14 @@ var localTier1Descriptors = [
     ],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
-      pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
-      pendingBlocksArchivist: ctx.process.pendingBlocksArchivist
-    }), "build")
+    build: /* @__PURE__ */ __name((ctx) => {
+      const { demotionThreshold } = readMempoolTuning(ctx);
+      return SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
+        pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
+        pendingBlocksArchivist: ctx.process.pendingBlocksArchivist,
+        demotionThreshold
+      });
+    }, "build")
   },
   {
     id: "SimpleMempoolRunner",
@@ -1399,10 +1423,14 @@ var localTier1Descriptors = [
     ],
     surface: "node",
     preconditions: passes,
-    build: /* @__PURE__ */ __name((ctx) => SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, {
-      pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
-      pendingBlocksArchivist: ctx.process.pendingBlocksArchivist
-    }), "build")
+    build: /* @__PURE__ */ __name((ctx) => {
+      const { maxPendingTransactions } = readMempoolTuning(ctx);
+      return SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, {
+        pendingTransactionsArchivist: ctx.process.pendingTransactionsArchivist,
+        pendingBlocksArchivist: ctx.process.pendingBlocksArchivist,
+        maxPendingTransactions
+      });
+    }, "build")
   },
   {
     id: "SimpleAccountBalanceViewer",
@@ -2461,7 +2489,7 @@ async function localLocatorFromConfig(context, validateDepsOnRegister = false, o
 __name(localLocatorFromConfig, "localLocatorFromConfig");
 
 // src/node/config/locators/locatorsFromConfig.ts
-import { deepMerge as deepMerge2 } from "@xylabs/sdk-js";
+import { deepMerge as deepMerge3 } from "@xylabs/sdk-js";
 
 // src/node/config/locators/actors/apiLocatorFromConfig.ts
 import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3, BlockViewerMoniker as BlockViewerMoniker3, FinalizationViewerMoniker as FinalizationViewerMoniker3, MempoolViewerMoniker as MempoolViewerMoniker3, ProviderFactoryLocator as ProviderFactoryLocator2, SimpleXyoConnectionRunner, SimpleXyoGateway, SimpleXyoRunner, TransactionViewerMoniker as TransactionViewerMoniker3, XyoConnectionMoniker as XyoConnectionMoniker3, XyoViewerMoniker as XyoViewerMoniker3 } from "@xyo-network/xl1-sdk";
@@ -2673,18 +2701,189 @@ async function rootLocatorFromConfig(context, validateDepsOnRegister = false, on
 }
 __name(rootLocatorFromConfig, "rootLocatorFromConfig");
 
+// src/node/config/locators/sharedLocatorFromConfig.ts
+import { deepMerge as deepMerge2 } from "@xylabs/sdk-js";
+import { AccountBalanceViewerMoniker as AccountBalanceViewerMoniker4, BlockValidationViewerMoniker as BlockValidationViewerMoniker3, BlockViewerMoniker as BlockViewerMoniker4, commonLocatorFromConfig as commonLocatorFromConfig2, DeadLetterQueueRunnerMoniker as DeadLetterQueueRunnerMoniker3, FinalizationRunnerMoniker as FinalizationRunnerMoniker3, FinalizationViewerMoniker as FinalizationViewerMoniker4, MempoolRunnerMoniker as MempoolRunnerMoniker3, MempoolViewerMoniker as MempoolViewerMoniker4, ProviderFactoryLocator as ProviderFactoryLocator8, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner4, SimpleXyoGateway as SimpleXyoGateway2, SimpleXyoRunner as SimpleXyoRunner4, TransactionValidationViewerMoniker as TransactionValidationViewerMoniker3, TransactionViewerMoniker as TransactionViewerMoniker4, WindowedBlockViewerMoniker as WindowedBlockViewerMoniker3, XyoConnectionMoniker as XyoConnectionMoniker4, XyoGatewayMoniker, XyoRunnerMoniker, XyoViewerMoniker as XyoViewerMoniker4 } from "@xyo-network/xl1-sdk";
+var apiNeeds = {
+  required: [
+    AccountBalanceViewerMoniker4,
+    BlockViewerMoniker4,
+    FinalizationViewerMoniker4,
+    MempoolViewerMoniker4,
+    TransactionViewerMoniker4,
+    XyoConnectionMoniker4,
+    XyoGatewayMoniker,
+    XyoRunnerMoniker,
+    XyoViewerMoniker4
+  ]
+};
+var mempoolNeeds = {
+  required: [
+    MempoolRunnerMoniker3,
+    // SimpleMempoolRunner.dependencies includes TransactionValidationViewer
+    // — not resolved by the actor directly but pulled in at construction.
+    TransactionValidationViewerMoniker3,
+    // SimpleMempoolViewer.dependencies includes WindowedBlockViewer — the
+    // mempool viewer is built when api/finalizer resolve MempoolViewer.
+    WindowedBlockViewerMoniker3
+  ]
+};
+var finalizerNeeds = {
+  required: [
+    BlockValidationViewerMoniker3,
+    BlockViewerMoniker4,
+    FinalizationRunnerMoniker3,
+    MempoolViewerMoniker4
+  ],
+  optional: [
+    DeadLetterQueueRunnerMoniker3
+  ]
+};
+var ACTOR_MIRRORS = {
+  api: apiNeeds,
+  mempool: mempoolNeeds,
+  finalizer: finalizerNeeds
+};
+var apiExtraDescriptors = [
+  {
+    id: "SimpleXyoRunner",
+    satisfies: [
+      XyoRunnerMoniker
+    ],
+    tier: 1,
+    backings: [],
+    surface: "node",
+    preconditions: /* @__PURE__ */ __name(() => true, "preconditions"),
+    build: /* @__PURE__ */ __name(() => SimpleXyoRunner4.factory(SimpleXyoRunner4.dependencies, {}), "build")
+  },
+  {
+    id: "SimpleXyoConnectionRunner",
+    satisfies: [
+      XyoConnectionMoniker4
+    ],
+    // Same tier as `SimpleXyoConnectionViewer`; higher priority wins the
+    // `XyoConnection` moniker in any actor mix that includes the API.
+    tier: 1,
+    priority: 100,
+    backings: [],
+    surface: "node",
+    preconditions: /* @__PURE__ */ __name(() => true, "preconditions"),
+    build: /* @__PURE__ */ __name(() => SimpleXyoConnectionRunner4.factory(SimpleXyoConnectionRunner4.dependencies, {}), "build")
+  },
+  {
+    id: "SimpleXyoGateway",
+    satisfies: [
+      XyoGatewayMoniker
+    ],
+    tier: 1,
+    backings: [],
+    surface: "node",
+    preconditions: /* @__PURE__ */ __name(() => true, "preconditions"),
+    build: /* @__PURE__ */ __name(() => SimpleXyoGateway2.factory(SimpleXyoGateway2.dependencies, {}), "build")
+  }
+];
+var ACTOR_EXTRA_DESCRIPTORS = {
+  api: apiExtraDescriptors
+};
+var ACTOR_CONFIG_PARSERS = {
+  api: ApiConfigZod,
+  mempool: MempoolConfigZod,
+  finalizer: FinalizerConfigZod
+};
+var SHARED_LOCATOR_SUPPORTED_ACTORS = [
+  "api",
+  "mempool",
+  "finalizer"
+];
+function canUseSharedLocator(actors, config) {
+  if (actors.length === 0) return false;
+  if (config.remote?.rpc) return false;
+  const names = new Set(actors.map((a) => a.name));
+  const fullCanary = SHARED_LOCATOR_SUPPORTED_ACTORS.every((name) => names.has(name));
+  if (!fullCanary) return false;
+  return actors.every((actor) => {
+    if (!SHARED_LOCATOR_SUPPORTED_ACTORS.includes(actor.name)) return false;
+    if (actor.name === "api") {
+      const merged = ApiConfigZod.parse(deepMerge2(config, actor));
+      if (merged.stateless === true) return false;
+    }
+    return true;
+  });
+}
+__name(canUseSharedLocator, "canUseSharedLocator");
+async function sharedLocatorFromConfig(context, actors, config, options = {}) {
+  const unionNeeds2 = {
+    required: dedupe(actors.flatMap((a) => ACTOR_MIRRORS[a.name]?.required ?? [])),
+    optional: dedupe(actors.flatMap((a) => ACTOR_MIRRORS[a.name]?.optional ?? []))
+  };
+  const extraDescriptors = actors.flatMap((a) => ACTOR_EXTRA_DESCRIPTORS[a.name] ?? []);
+  const commonContext = {
+    ...context,
+    config: {
+      ...config,
+      name: "_shared_common"
+    }
+  };
+  const commonLocator = await commonLocatorFromConfig2(commonContext);
+  const sharedContext = {
+    ...commonLocator.context,
+    config: {
+      ...config,
+      name: "_shared"
+    }
+  };
+  const result = await locatorFromActorNeeds(sharedContext, [
+    unionNeeds2
+  ], {
+    extraDescriptors,
+    onInsecureGenesisConfirm: options.onInsecureGenesisConfirm,
+    validateDepsOnRegister: false
+  });
+  const sharedWithEvm = await initEvmProvidersIfAvailable(result.locator);
+  sharedWithEvm.freeze();
+  const perActor = {};
+  for (const actor of actors) {
+    const parser = ACTOR_CONFIG_PARSERS[actor.name];
+    const actorConfig = parser ? parser.parse(deepMerge2(config, actor)) : actor;
+    const actorContext = {
+      ...sharedWithEvm.context,
+      config: actorConfig
+    };
+    const view = new ProviderFactoryLocator8(actorContext, sharedWithEvm.registry);
+    view.freeze();
+    perActor[actor.name] = view;
+  }
+  return {
+    shared: sharedWithEvm,
+    perActor
+  };
+}
+__name(sharedLocatorFromConfig, "sharedLocatorFromConfig");
+function dedupe(items) {
+  return [
+    ...new Set(items)
+  ];
+}
+__name(dedupe, "dedupe");
+
 // src/node/config/locators/locatorsFromConfig.ts
 function allActorsAreSelfSufficient(actors, config) {
   if (actors.length === 0) return false;
   return actors.every((actor) => {
     if (actor.name !== "api") return false;
-    const merged = ApiConfigZod.parse(deepMerge2(config, actor));
+    const merged = ApiConfigZod.parse(deepMerge3(config, actor));
     return merged.stateless === true;
   });
 }
 __name(allActorsAreSelfSufficient, "allActorsAreSelfSufficient");
 async function locatorsFromConfig(context, { actors, ...config }, onInsecureGenesisConfirm) {
   const result = {};
+  if (canUseSharedLocator(actors, config)) {
+    const { perActor } = await sharedLocatorFromConfig(context, actors, config, {
+      onInsecureGenesisConfirm
+    });
+    return perActor;
+  }
   const skipRoot = allActorsAreSelfSufficient(actors, config);
   if (!skipRoot) {
     const rootContext = {
@@ -2701,42 +2900,42 @@ async function locatorsFromConfig(context, { actors, ...config }, onInsecureGene
       case "producer": {
         result[actorConfig.name] = await producerLocatorFromConfig({
           ...context,
-          config: ProducerConfigZod.parse(deepMerge2(config, actorConfig))
+          config: ProducerConfigZod.parse(deepMerge3(config, actorConfig))
         }, result._root);
         break;
       }
       case "api": {
         result[actorConfig.name] = await apiLocatorFromConfig({
           ...context,
-          config: ApiConfigZod.parse(deepMerge2(config, actorConfig))
+          config: ApiConfigZod.parse(deepMerge3(config, actorConfig))
         }, result._root);
         break;
       }
       case "mempool": {
         result[actorConfig.name] = await mempoolLocatorFromConfig({
           ...context,
-          config: MempoolConfigZod.parse(deepMerge2(config, actorConfig))
+          config: MempoolConfigZod.parse(deepMerge3(config, actorConfig))
         }, result._root);
         break;
       }
       case "finalizer": {
         result[actorConfig.name] = await finalizerLocatorFromConfig({
           ...context,
-          config: FinalizerConfigZod.parse(deepMerge2(config, actorConfig))
+          config: FinalizerConfigZod.parse(deepMerge3(config, actorConfig))
         }, result._root);
         break;
       }
       case "bridge": {
         result[actorConfig.name] = await bridgeLocatorFromConfig({
           ...context,
-          config: BridgeConfigZod.parse(deepMerge2(config, actorConfig))
+          config: BridgeConfigZod.parse(deepMerge3(config, actorConfig))
         }, result._root);
         break;
       }
       case "rewardRedemption": {
         result[actorConfig.name] = await rewardRedemptionLocatorFromConfig({
           ...context,
-          config: RewardRedemptionConfigZod.parse(deepMerge2(config, actorConfig))
+          config: RewardRedemptionConfigZod.parse(deepMerge3(config, actorConfig))
         }, result._root);
         break;
       }
@@ -2824,6 +3023,8 @@ export {
   DEFAULT_ACTOR_ACCOUNT_PATH,
   DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL,
   DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL,
+  DEFAULT_MEMPOOL_DEMOTION_THRESHOLD,
+  DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS,
   DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL,
   DefaultServiceProvider,
   DerivationPathCollisionError,
@@ -2846,6 +3047,7 @@ export {
   RewardRedemptionConfigContext,
   RewardRedemptionConfigZod,
   SHARED_ACCOUNT_REPORT_COUNT,
+  SHARED_LOCATOR_SUPPORTED_ACTORS,
   ServiceLifetime,
   SimpleRejectedTransactionsArchivistProvider,
   asApiConfig,
@@ -2868,6 +3070,7 @@ export {
   buildProcessSharedResources,
   buildStatelessApiLocator,
   buildTelemetryConfig,
+  canUseSharedLocator,
   clearResolvedWalletReport,
   contextFromConfigWithoutLocator,
   createCapabilityRegistry,
@@ -2923,6 +3126,7 @@ export {
   resolveWalletForActor,
   resolveWalletReport,
   rootLocatorFromConfig,
+  sharedLocatorFromConfig,
   telemetryContextFromConfig,
   toApiConfig,
   toApiConfigContext,