@xyo-network/xl1-protocol-sdk 1.26.46 → 1.26.48

package/dist/neutral/capabilities/Backing.d.ts

@@ -0,0 +1,52 @@
+/**
+ * A `Backing` names a class of runtime resources a provider may need access to.
+ * Each backing is owned (writable) by exactly one actor in a deployment; other
+ * actors may hold it as read-only or not at all.
+ *
+ * - `chain-store` — finalized/canonical chain archivists. Owned by the Finalizer.
+ * - `mempool-store` — pending transaction and pending block archivists. Owned by the Mempool actor.
+ * - `dlq-store` — rejected blocks and rejected transactions archivists. Owned by the Finalizer.
+ * - `indexer-store` — derived summary maps (account balances, transfers, etc.).
+ *   Owned by the IndexerActor.
+ * - `evm-rpc` — connection to the backing EVM chain (Sepolia/Mainnet/Hardhat). Owned by the Bridge.
+ * - `wallet` — per-actor signing wallet. Each actor owns its own.
+ * - `network` — JSON-RPC transport to another XL1 actor. Pure transport; no ownership.
+ */
+export type Backing = 'chain-store' | 'mempool-store' | 'dlq-store' | 'indexer-store' | 'evm-rpc' | 'wallet' | 'network';
+/**
+ * A `BackingNeed` pairs a backing with the access mode required.
+ *
+ * - `read` is satisfied by either a `read` or `write` ownership in the locator.
+ * - `write` is only satisfied by `write` ownership.
+ *
+ * Descriptors declare the backings they need; locators declare the backings they have.
+ * The resolver filters out descriptors whose backings aren't a subset of the locator's.
+ */
+export interface BackingNeed {
+    readonly backing: Backing;
+    readonly mode: 'read' | 'write';
+}
+/**
+ * The two API surfaces exposed by an XL1 API actor over JSON-RPC.
+ *
+ * - `node` — point queries on canonical chain state (block/tx/mempool/finality/balance).
+ *   Analogous to a base Ethereum node's RPC. Exposed at `POST /rpc`.
+ * - `indexed` — cross-key or aggregate queries that require an indexer
+ *   (stake-by-staker, stake-events, NetworkStake step rewards, etc.).
+ *   Analogous to Etherscan-style APIs. Exposed at `POST /rpc/indexed`.
+ *
+ * The litmus test: if the query is `f(primary_key) → value` it's `node`; if it's
+ * `f(secondary_attribute) → list` it's `indexed`.
+ */
+export type Surface = 'node' | 'indexed';
+/**
+ * Returns true iff every need in `required` is satisfied by some entry in `available`.
+ * `read` is satisfied by either `read` or `write`; `write` requires `write`.
+ */
+export declare function backingsSatisfied(required: readonly BackingNeed[], available: readonly BackingNeed[]): boolean;
+/**
+ * Diagnostic helper: returns a human-readable description of which needs are unmet
+ * given the available backings.
+ */
+export declare function unmetBackings(required: readonly BackingNeed[], available: readonly BackingNeed[]): readonly BackingNeed[];
+//# sourceMappingURL=Backing.d.ts.map

package/dist/neutral/capabilities/Backing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Backing.d.ts","sourceRoot":"","sources":["../../../src/capabilities/Backing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,OAAO,GACb,aAAa,GACb,eAAe,GACf,WAAW,GACX,eAAe,GACf,SAAS,GACT,QAAQ,GACR,SAAS,CAAA;AAEf;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;CAChC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,SAAS,CAAA;AAExC;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,SAAS,EAAE,SAAS,WAAW,EAAE,GAChC,OAAO,CAMT;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,SAAS,EAAE,SAAS,WAAW,EAAE,GAChC,SAAS,WAAW,EAAE,CAIxB"}

package/dist/neutral/capabilities/Capability.d.ts

@@ -0,0 +1,40 @@
+import type { ProviderMoniker } from '@xyo-network/xl1-protocol-model';
+import type { Surface } from './Backing.ts';
+export type { ProviderMoniker } from '@xyo-network/xl1-protocol-model';
+/**
+ * Declarative description of a capability that an actor may need.
+ *
+ * The capability registry is a sidecar to the moniker namespace — every
+ * moniker that an actor consumes should have a corresponding `Capability`
+ * entry. The registry is what lets the resolver walk transitive needs
+ * (via `implies`) and produce useful diagnostics.
+ */
+export interface Capability {
+    /** Canonical id — equals the existing moniker constant string. */
+    readonly id: ProviderMoniker;
+    /**
+     * Other capabilities a consumer of this one transitively requires.
+     * Drives plan-time prerequisite walking — e.g. `BlockRunner` requires
+     * `BlockViewer`, `MempoolRunner`, `MempoolViewer`, etc.
+     */
+    readonly implies?: readonly ProviderMoniker[];
+    readonly kind: 'viewer' | 'runner' | 'gateway' | 'archivist' | 'signer';
+    /** Human label for diagnostics. */
+    readonly label: string;
+    /**
+     * Which API surface this capability is exposed under — `'node'` for point
+     * queries on canonical state (Ethereum-node analog) or `'indexed'` for
+     * cross-key/aggregate queries (Etherscan analog). Connection-level umbrellas
+     * (`XyoConnection`, `XyoGatewayRunner`) carry `'node'`; the actual filtering
+     * is done downstream by `connectionSubsetBySurface`.
+     */
+    readonly surface: Surface;
+}
+export interface CapabilityRegistryInstance {
+    get(id: ProviderMoniker): Capability;
+    register(cap: Capability): this;
+    toJson(): Record<ProviderMoniker, Omit<Capability, 'id'>>;
+    tryGet(id: ProviderMoniker): Capability | undefined;
+}
+export declare function createCapabilityRegistry(): CapabilityRegistryInstance;
+//# sourceMappingURL=Capability.d.ts.map

package/dist/neutral/capabilities/Capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Capability.d.ts","sourceRoot":"","sources":["../../../src/capabilities/Capability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAEtE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAE3C,YAAY,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAEtE;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,EAAE,eAAe,CAAA;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;IAC7C,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAA;IACvE,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,0BAA0B;IACzC,GAAG,CAAC,EAAE,EAAE,eAAe,GAAG,UAAU,CAAA;IACpC,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAA;IAC/B,MAAM,IAAI,MAAM,CAAC,eAAe,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAA;IACzD,MAAM,CAAC,EAAE,EAAE,eAAe,GAAG,UAAU,GAAG,SAAS,CAAA;CACpD;AAiCD,wBAAgB,wBAAwB,IAAI,0BAA0B,CAErE"}

package/dist/neutral/capabilities/Provider.d.ts

@@ -0,0 +1,64 @@
+import type { CreatableProviderFactory } from '../CreatableProvider/index.ts';
+import type { BackingNeed, Surface } from './Backing.ts';
+import type { CapabilityRegistryInstance, ProviderMoniker } from './Capability.ts';
+/**
+ * Tier expresses *intrinsic strength* of a provider — lower numbers win.
+ *
+ * - `1` — In-process, direct backing-store access (Simple* providers reading/writing the local archivist).
+ * - `2` — Direct EVM contract access (Evm* providers calling Ethereum nodes for chain-of-truth data).
+ * - `3` — Remote JSON-RPC to another XL1 node (JsonRpc* providers).
+ * - `4` — Stub/fallback (Simple* providers fed empty arrays — usable only when nothing better exists).
+ */
+export type ProviderTier = 1 | 2 | 3 | 4;
+/**
+ * Sidecar metadata for a `CreatableProviderFactory`-producing class. Tells the
+ * resolver which capability the provider satisfies, at what tier, under what
+ * preconditions, and how to construct the factory at plan time.
+ *
+ * Descriptors are deliberately separated from the provider classes themselves
+ * so the SDK packages stay un-coupled to the descriptor system — descriptors
+ * live alongside the consumer that picks them.
+ */
+export interface ProviderDescriptor<TCtx extends ResolutionContext = ResolutionContext> {
+    /**
+     * The backing resources this descriptor's `build()` reads from `ctx`. Used
+     * by the resolver to filter out descriptors whose backings are not a subset
+     * of the locator's `availableBackings`. Empty array means the descriptor
+     * has no backing needs (pure stateless factory or function-only viewer).
+     */
+    readonly backings: readonly BackingNeed[];
+    /** Globally-unique key, usually `<className>` — used in snapshots and diagnostics. */
+    readonly id: string;
+    /** Soft tie-break inside a tier; higher wins. Default 0. */
+    readonly priority?: number;
+    /** Capabilities this provider satisfies (typically one moniker, occasionally several). */
+    readonly satisfies: readonly ProviderMoniker[];
+    /**
+     * Which API surface this descriptor's capability is exposed under. Mirrors
+     * the corresponding `Capability.surface`; declared on the descriptor too so
+     * the resolver can filter candidates by surface without a registry lookup.
+     */
+    readonly surface: Surface;
+    readonly tier: ProviderTier;
+    /**
+     * Build the factory args from the resolution context. Returning undefined
+     * signals "skip me at runtime" (preconditions said yes, but a missing optional
+     * resource was discovered during the build).
+     */
+    build(ctx: TCtx): CreatableProviderFactory | undefined;
+    /**
+     * Returns true iff the provider can be constructed in this process given `ctx`.
+     * Pure & sync — must not read DB or do I/O.
+     */
+    preconditions(ctx: TCtx): boolean;
+}
+/**
+ * Inputs the resolver hands to descriptors. `capabilities` is the registry
+ * the resolver consults for `implies` walks. Subtypes may extend this with
+ * live runtime resources — archivists, EVM provider, wallet — that descriptors
+ * need at `build()` time.
+ */
+export interface ResolutionContext {
+    readonly capabilities: CapabilityRegistryInstance;
+}
+//# sourceMappingURL=Provider.d.ts.map

package/dist/neutral/capabilities/Provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["../../../src/capabilities/Provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AAC7E,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,KAAK,EAAE,0BAA0B,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAElF;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAExC;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB,CAAC,IAAI,SAAS,iBAAiB,GAAG,iBAAiB;IACpF;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAA;IACzC,sFAAsF;IACtF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,0FAA0F;IAC1F,QAAQ,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,CAAA;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B;;;;OAIG;IACH,KAAK,CAAC,GAAG,EAAE,IAAI,GAAG,wBAAwB,GAAG,SAAS,CAAA;IACtD;;;OAGG;IACH,aAAa,CAAC,GAAG,EAAE,IAAI,GAAG,OAAO,CAAA;CAClC;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,YAAY,EAAE,0BAA0B,CAAA;CAClD"}

package/dist/neutral/capabilities/connectionSubsetBySurface.d.ts

@@ -0,0 +1,17 @@
+import type { XyoConnection } from '@xyo-network/xl1-protocol-lib';
+import type { Surface } from './Backing.ts';
+/**
+ * Returns a shallow-cloned `XyoConnection` retaining only the branches whose
+ * surface matches the requested one.
+ *
+ * The filter walks a fixed structural map of `XyoConnection` (see
+ * `surfaceMap.ts`). Branches whose surface differs are omitted from the
+ * returned connection so that downstream consumers (`rpcMethodHandlersFromConnection`,
+ * `rpcServerFromConnection`, etc.) naturally produce a smaller method set
+ * without having to know about surfaces themselves.
+ *
+ * Used by API actor route wiring to mount `POST /rpc` (node-only) and
+ * `POST /rpc/indexed` (indexer-only) over the same underlying connection.
+ */
+export declare function connectionSubsetBySurface(connection: XyoConnection, surface: Surface): XyoConnection;
+//# sourceMappingURL=connectionSubsetBySurface.d.ts.map

package/dist/neutral/capabilities/connectionSubsetBySurface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionSubsetBySurface.d.ts","sourceRoot":"","sources":["../../../src/capabilities/connectionSubsetBySurface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAElE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAM3C;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,aAAa,EACzB,OAAO,EAAE,OAAO,GACf,aAAa,CAcf"}

package/dist/neutral/capabilities/factoryBrand.d.ts

@@ -0,0 +1,46 @@
+import type { CreatableProviderFactory } from '../CreatableProvider/index.ts';
+import type { BackingNeed } from './Backing.ts';
+/**
+ * Phantom-typed brand on `CreatableProviderFactory` recording which backings
+ * the factory's underlying provider needs.
+ *
+ * Purely a compile-time tag — there is no runtime impact. Runtime callers
+ * that don't care can keep using the bare `CreatableProviderFactory` type;
+ * locators that want to enforce a backing-subset rule at compile time can
+ * accept `BrandedFactory<L>` parameters that constrain what factories may be
+ * registered.
+ */
+export type BrandedFactory<B extends readonly BackingNeed[] = readonly BackingNeed[]> = CreatableProviderFactory & {
+    readonly __backings?: B;
+};
+/**
+ * Brand a factory with the backings it depends on. Returns the same value at
+ * runtime — the brand is only a phantom type.
+ *
+ * @example
+ *   const f = backedFactory(
+ *     [{ backing: 'chain-store', mode: 'write' }] as const,
+ *     SimpleFinalizationRunner.factory(SimpleFinalizationRunner.dependencies, {...}),
+ *   )
+ *   // f is BrandedFactory<readonly [{backing: 'chain-store', mode: 'write'}]>
+ */
+export declare function backedFactory<B extends readonly BackingNeed[]>(_backings: B, factory: CreatableProviderFactory): BrandedFactory<B>;
+/**
+ * Helper: brand a factory as needing only the network transport. Convenient
+ * shorthand for `JsonRpc*` factories.
+ */
+export declare function networkBackedFactory(factory: CreatableProviderFactory): BrandedFactory<readonly [{
+    readonly backing: 'network';
+    readonly mode: 'read';
+}]>;
+/**
+ * Runtime check: is `factory`'s declared backings a subset of `availableBackings`?
+ *
+ * The brand is type-only, so at runtime we have no way to inspect what backings
+ * the factory was branded with. This helper exists for cases where the caller
+ * has the backings array separately (e.g. from the descriptor that built the
+ * factory) and wants a runtime gate. Use `backingsSatisfied` directly with the
+ * descriptor's `backings` field.
+ */
+export declare function factoryBackingsCompatible(declared: readonly BackingNeed[], available: readonly BackingNeed[]): boolean;
+//# sourceMappingURL=factoryBrand.d.ts.map

package/dist/neutral/capabilities/factoryBrand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factoryBrand.d.ts","sourceRoot":"","sources":["../../../src/capabilities/factoryBrand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AAC7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAG/C;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,SAAS,WAAW,EAAE,GAAG,SAAS,WAAW,EAAE,IAChF,wBAAwB,GAAG;IAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;CAAE,CAAA;AAE1D;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,SAAS,WAAW,EAAE,EAC5D,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,wBAAwB,GAChC,cAAc,CAAC,CAAC,CAAC,CAEnB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,wBAAwB,GAChC,cAAc,CAAC,SAAS,CAAC;IAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAEnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,SAAS,EAAE,SAAS,WAAW,EAAE,GAChC,OAAO,CAET"}

package/dist/neutral/capabilities/index.d.ts

@@ -0,0 +1,8 @@
+export * from './Backing.ts';
+export * from './Capability.ts';
+export * from './connectionSubsetBySurface.ts';
+export * from './factoryBrand.ts';
+export * from './Provider.ts';
+export * from './resolveProviders.ts';
+export * from './surfaceMap.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/capabilities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/capabilities/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gCAAgC,CAAA;AAC9C,cAAc,mBAAmB,CAAA;AACjC,cAAc,eAAe,CAAA;AAC7B,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA"}

package/dist/neutral/capabilities/resolveProviders.d.ts

@@ -0,0 +1,41 @@
+import type { BackingNeed } from './Backing.ts';
+import type { ProviderMoniker } from './Capability.ts';
+import type { ProviderDescriptor, ResolutionContext } from './Provider.ts';
+export interface ResolutionPlan {
+    /** Capability moniker -> winning descriptor id (for snapshot diffing). */
+    readonly bindings: Readonly<Record<ProviderMoniker, string>>;
+    /** Descriptors that lost; included for diagnostics. */
+    readonly rejected: readonly RejectedDescriptor[];
+    /** Descriptors that should be instantiated, in topological order. */
+    readonly selected: readonly ProviderDescriptor[];
+}
+export interface RejectedDescriptor {
+    readonly descriptor: ProviderDescriptor;
+    readonly reason: string;
+}
+export declare class MissingCapabilityError extends Error {
+    readonly moniker: ProviderMoniker;
+    readonly reasons: readonly string[];
+    constructor(moniker: ProviderMoniker, reasons: readonly string[]);
+}
+export interface ResolveProvidersOptions {
+    /**
+     * The backings the locator's process holds. If provided, the resolver filters
+     * out any candidate whose `backings` are not a subset of `availableBackings`
+     * (with mode compatibility — `read` is satisfied by either `read` or `write`;
+     * `write` requires `write`). If omitted, no backing-based filtering happens.
+     */
+    readonly availableBackings?: readonly BackingNeed[];
+}
+/**
+ * Plans which providers to register for a given set of needs.
+ *
+ * 1. Walk `Capability.implies` from the needs set to fixed point.
+ * 2. Filter candidates by backing requirements (if `availableBackings` provided).
+ * 3. Filter remaining candidates by `preconditions(ctx)`.
+ * 4. Pick the head of `(tier asc, priority desc, descriptor.id asc)` per moniker.
+ * 5. Toposort selected descriptors using the registry's `implies`.
+ * 6. Throw `MissingCapabilityError` if any wanted moniker has zero survivors.
+ */
+export declare function resolveProviders<TCtx extends ResolutionContext>(needs: ReadonlySet<ProviderMoniker>, candidates: readonly ProviderDescriptor<TCtx>[], ctx: TCtx, options?: ResolveProvidersOptions): ResolutionPlan;
+//# sourceMappingURL=resolveProviders.d.ts.map

package/dist/neutral/capabilities/resolveProviders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveProviders.d.ts","sourceRoot":"","sources":["../../../src/capabilities/resolveProviders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAE1E,MAAM,WAAW,cAAc;IAC7B,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5D,uDAAuD;IACvD,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAA;IAChD,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAA;CACjD;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAA;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;gBAEvB,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE;CAOjE;AAED,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,WAAW,EAAE,CAAA;CACpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,SAAS,iBAAiB,EAC7D,KAAK,EAAE,WAAW,CAAC,eAAe,CAAC,EACnC,UAAU,EAAE,SAAS,kBAAkB,CAAC,IAAI,CAAC,EAAE,EAC/C,GAAG,EAAE,IAAI,EACT,OAAO,GAAE,uBAA4B,GACpC,cAAc,CAWhB"}

package/dist/neutral/capabilities/surfaceMap.d.ts

@@ -0,0 +1,11 @@
+import type { Surface } from './Backing.ts';
+export declare function surfaceForBranch(branch: string): Surface | undefined;
+/**
+ * Branch keys on `XyoViewer` that may need to be filtered by surface.
+ * `connectionSubsetBySurface` iterates over this list to decide what to keep.
+ *
+ * Each entry is `[viewerKey, fully-qualified-branch-key]`.
+ */
+export declare const VIEWER_BRANCH_KEYS: readonly [readonly ["block", "viewer.block"], readonly ["transaction", "viewer.transaction"], readonly ["mempool", "viewer.mempool"], readonly ["finalization", "viewer.finalization"], readonly ["time", "viewer.time"], readonly ["account", "viewer.account.balance"], readonly ["networkStake", "viewer.networkStake"], readonly ["stake", "viewer.stake"], readonly ["step", "viewer.step"]];
+export type ViewerBranchKey = (typeof VIEWER_BRANCH_KEYS)[number][0];
+//# sourceMappingURL=surfaceMap.d.ts.map

package/dist/neutral/capabilities/surfaceMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surfaceMap.d.ts","sourceRoot":"","sources":["../../../src/capabilities/surfaceMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAgC3C,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAEpE;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,mYAUrB,CAAA;AAEV,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA"}

package/dist/neutral/index.d.ts

@@ -1,5 +1,6 @@
 export * from './amount/index.ts';
 export * from './block/index.ts';
+export * from './capabilities/index.ts';
 export * from './ChainContextHelpers.ts';
 export * from './config/index.ts';
 export * from './constants.ts';

package/dist/neutral/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,oBAAoB,CAAA;AAClC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AACpC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,oBAAoB,CAAA;AAClC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AACpC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA"}