@hediet/linkrpc 0.0.2 → 0.0.3

package/dist/hub/client/index.d.ts

@@ -2,9 +2,9 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import { Jt as IRequestSender, K as Principal, Pn as SignedCapability, Qt as RawStreamingCall, Ra as JsonValue, V as SigningCallCtx, an as IMessageTransport, nn as StreamSendOpts, tn as SendOpts, vt as PublicSigningIdentity } from "../../chunks/linkRpcConnection-BadD37ok.js";
-import { i as hubFromConnection, n as SlotPrerequest, r as SlotReservation, t as Hub } from "../../chunks/hubFacade-DtQpGpUy.js";
-import { a as HubAccessResult, i as HubAccessRequest } from "../../chunks/hubAccess-C06qAKao.js";
+import { Fr as SignedCapability, Mi as StreamSendOpts, Ni as IMessageTransport, Oi as RawStreamingCall, Sr as PublicSigningIdentity, To as JsonValue, Wn as SigningCallCtx, Yn as Principal, ji as SendOpts, wi as IRequestSender } from "../../chunks/linkRpcConnection-C_Gs4nZ9.js";
+import { i as hubFromConnection, n as SlotPrerequest, r as SlotReservation, t as Hub } from "../../chunks/hubFacade-CLgLIvBa.js";
+import { a as HubAccessResult, i as HubAccessRequest } from "../../chunks/hubAccess-DKl7hDrh.js";
 //#region src/hub/client/hubSigningSender.d.ts
 /**
  * The single connection handle a hub client consumes: a signing request

package/dist/hub/client/index.js

@@ -2,9 +2,9 @@
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
-import { H as JsonRpcChannel, m as SigningSender } from "../../chunks/src-CAhXne71.js";
-import { t as hubAccessInterface } from "../../chunks/hub.interfaces-Bf4VfWNX.js";
-import { n as hubFromConnection, t as Hub } from "../../chunks/hubFacade-BIB9CoAv.js";
+import { m as SigningSender, tt as JsonRpcChannel } from "../../chunks/src-BaCs8mWd.js";
+import { t as hubAccessInterface } from "../../chunks/hub.interfaces-BWqqhgtT.js";
+import { n as hubFromConnection, t as Hub } from "../../chunks/hubFacade-rlsBq0ZU.js";
 //#region src/hub/client/hubSigningSender.ts
 /**
 * The single connection handle a hub client consumes: a signing request

package/dist/hub/common/index.d.ts

@@ -2,8 +2,8 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import { $i as RequestType, Br as TopologyTransportInfo, Di as InterfaceClient, Gt as Channel, Jt as IRequestSender, K as Principal, L as CapProvider, Oi as InterfaceDefinition, Ui as ApplicationErrorDescriptorBase, V as SigningCallCtx, an as IMessageTransport, ca as LinkRpcInterfaceSchema, d as ServiceIdPattern, u as RootPrincipalSet, ua as MethodSchema, z as ManagedSigningChannel } from "../../chunks/linkRpcConnection-BadD37ok.js";
-import { a as HubAccessResult, i as HubAccessRequest, n as HubAccessPattern, o as findCoveringCapabilities, r as HubAccessPermission, t as HubAccessDuration } from "../../chunks/hubAccess-C06qAKao.js";
+import { Aa as ApplicationErrorDescriptorBase, An as WalkHubResult, Ba as RequestType, Bn as CapProvider, Cn as HubDirectoryNodeState, Dn as ReflectionChannel, En as ListOptions, Fn as normalizeServiceIdScopes, Hn as ManagedSigningChannel, In as serviceIdMatchesPattern, Ln as serviceIdMatchesScopes, Mn as fetchSchema, Ni as IMessageTransport, Nn as findMethodInSchema, On as ServiceListing, Pn as intersectServiceIdScopes, Rn as walkHub, Sn as HubDirectoryNodeReport, Tn as InaccessibleDirectory, Wn as SigningCallCtx, Wt as TopologyTransportInfo, Yn as Principal, _n as HubDirectoryChange, bn as HubDirectoryGraphSnapshot, gn as DiscoveredListing, ha as InterfaceDefinition, hn as DEFAULT_WALK_DEPTH, jn as fetchDirectory, kn as WalkHubOptions, ma as InterfaceClient, vn as HubDirectoryExplorer, wi as IRequestSender, wn as HubDirectoryParentReport, xi as Channel, xn as HubDirectoryGraphTarget, yn as HubDirectoryGraphEvent, zn as walkHubDetailed } from "../../chunks/linkRpcConnection-C_Gs4nZ9.js";
+import { a as HubAccessResult, i as HubAccessRequest, n as HubAccessPattern, o as findCoveringCapabilities, r as HubAccessPermission, t as HubAccessDuration } from "../../chunks/hubAccess-DKl7hDrh.js";
 //#region src/hub/common/serviceId.d.ts
 /**
  * A **ServiceId** is a `'/'`-segmented address naming a routing destination
@@ -862,328 +862,5 @@ declare function createAutoNegotiatingCapProvider(opts: {
   readonly consumer: AutoNegotiateConsumer;
 }): CapProvider;
 //#endregion
-//#region src/hub/common/directoryWalk.d.ts
-/**
- * Portable reflection walk over the `hubrpc.directory` referral tree.
- *
- * A directory may explicitly list other `hubrpc.directory` services as
- * referrals. Flattening that graph into an interface inventory is the
- * consumer's job. Routing state is deliberately not part of this contract.
- */
-/**
- * The sender reflection helpers speak over: the signing decorator that wraps
- * the live channel. Decoupled from the concrete `JsonRpcChannel` so reconnect
- * can swap the underlying channel transparently.
- */
-type ReflectionChannel = IRequestSender<SigningCallCtx>;
-interface ServiceListing {
-  readonly serviceId: string;
-  readonly interfaceId: string;
-  readonly hash: string;
-  readonly path?: string;
-  /** Optional non-normative description of the owning service. */
-  readonly serviceDescription?: string;
-  /**
-   * Root node ids required to access the owning service, in CNF. Surfaced by
-   * the directory; {@link walkHubDetailed} additionally folds transitive
-   * requirements from ancestor directories onto descendants.
-   */
-  readonly rootPrincipalSets?: readonly RootPrincipalSet[];
-  /** Scope carried by a directory referral; omitted means its service-id subtree. */
-  readonly reachableServiceIds?: readonly ServiceIdPattern[];
-}
-/**
- * A {@link ServiceListing} enriched with the service id of the directory that
- * reported it. This is provenance only: every listing is asserted reachable by
- * sending to the endpoint that answered the directory.
- */
-interface DiscoveredListing extends ServiceListing {
-  readonly discoveredFrom: string;
-}
-interface ListOptions {
-  readonly interfaceId?: string;
-  readonly interfaceIdPrefix?: string;
-  readonly serviceId?: string;
-  readonly serviceIdScopes?: readonly ServiceIdPattern[];
-  readonly limit?: number;
-  readonly timeoutMs?: number;
-  /**
-   * When set, send the reflection call to that service via form-3
-   * (`<target>::hubrpc.directory::list`) instead of the implicit root
-   * directory. Used when talking to a hub: the root directory is the hub
-   * itself, but per-service reflection lives on each participant.
-   */
-  readonly target?: string;
-}
-declare function fetchDirectory(channel: ReflectionChannel, opts?: ListOptions): Promise<ServiceListing[]>;
-declare function fetchSchema(channel: ReflectionChannel, interfaceId: string, hash: string | undefined,
-/**
- * Optional routing target. When set, the schema request is addressed to
- * `<target>::hubrpc.schemas::get` (form-3) so it reaches the service that
- * actually hosts this interface — needed when talking to a hub and the
- * interface lives behind a participant.
- */
-target?: string): Promise<LinkRpcInterfaceSchema>;
-declare function findMethodInSchema(schema: LinkRpcInterfaceSchema, methodName: string): MethodSchema | undefined;
-/** Default recursion depth when walking the bus. */
-declare const DEFAULT_WALK_DEPTH = 5;
-/** Segment-aware service-id pattern matching (`foo` includes `foo/bar`, not `foobar`). */
-declare function serviceIdMatchesPattern(serviceId: string, pattern: ServiceIdPattern): boolean;
-/** Whether a service id is included by a union of patterns. `undefined` means unfiltered. */
-declare function serviceIdMatchesScopes(serviceId: string, scopes: readonly ServiceIdPattern[] | undefined): boolean;
-/** Canonicalize a pattern union by removing duplicates and contained patterns. */
-declare function normalizeServiceIdScopes(scopes: readonly ServiceIdPattern[]): ServiceIdPattern[];
-/** Pairwise intersection of two pattern unions. */
-declare function intersectServiceIdScopes(left: readonly ServiceIdPattern[], right: readonly ServiceIdPattern[]): ServiceIdPattern[];
-/**
- * A sub-directory the walk surfaced but could not enumerate — typically because
- * it is capability-gated (e.g. the `hub` directory, reachable only once the
- * connection holds a capability for it). The services it would have listed are
- * therefore absent from the walk; callers can surface `reason` to explain the
- * gap rather than silently dropping the branch.
- */
-interface InaccessibleDirectory {
-  /** The directory target (serviceId) that could not be enumerated. */
-  readonly serviceId: string;
-  /** The error message from the denied directory lookup. */
-  readonly reason: string;
-}
-interface WalkHubResult {
-  /** Every interface reachable from the directories the walk could read. */
-  readonly listings: DiscoveredListing[];
-  /**
-   * Sub-directories that were referenced but could not be enumerated (e.g.
-   * capability-gated). Their services are not present in `listings`.
-   */
-  readonly inaccessible: InaccessibleDirectory[];
-}
-/**
- * Recursive graph walk: list a directory, intersect the accumulated service-id
- * scope with every explicit `hubrpc.directory` referral, and recurse. Bounded
- * by `maxDepth`.
- *
- * Every listing is tagged with `discoveredFrom` — the serviceId of the
- * directory that produced it. When the same `(serviceId, interfaceId, hash)`
- * shows up via several directories (e.g. once forwarded by the hub, once
- * directly from the participant), we keep the one whose `discoveredFrom`
- * matches the item's `serviceId`, since that's the directory that
- * authoritatively knows about it.
- *
- * Transitive root-node-id requirements flow down the tree: when the walk
- * recurses into a directory whose own `rootPrincipalSets` include `transitive`
- * reqs, every interface discovered at or below that directory inherits them (as
- * singleton AND-sets, kept transitive so they keep flowing further down). This
- * replaces the hub-side `applyTransitiveReqs` fold that the v1 aggregating
- * directory performed.
- *
- * A sub-directory the walk cannot read is recorded in
- * {@link WalkHubResult.inaccessible} rather than silently dropped. A failure to
- * read the *root* directory is left silent — there is no sub-tree to explain —
- * and simply yields empty results.
- *
- * When {@link WalkHubOptions.unlockGatedDirectory} is supplied, each gated
- * sub-directory is offered to the hook; if it returns `true` (a capability was
- * granted), that directory is re-queued and the walk continues into it — a
- * fixpoint that keeps unlocking newly-revealed gated branches until nothing
- * more can be opened (still bounded by `maxDepth`).
- */
-interface WalkHubOptions {
-  readonly maxDepth?: number;
-  /** Hard deadline for each directory page request. Defaults to 5 seconds. */
-  readonly timeoutMs?: number;
-  /** Return only listings for this exact interface id after traversing directories. */
-  readonly interfaceId?: string;
-  /** Return only listings whose interface id starts with this prefix after traversal. */
-  readonly interfaceIdPrefix?: string;
-  /** Return only listings for this exact service id after traversal. */
-  readonly serviceId?: string;
-  /** Initial service-id scope. Defaults to the universal `{ prefix: "" }`. */
-  readonly serviceIdScopes?: readonly ServiceIdPattern[];
-  /**
-   * The directory the walk starts from. Defaults to the implicit root
-   * directory (form-2 `hubrpc.directory::list`). Pass a serviceId to start at
-   * `<rootTarget>::hubrpc.directory::list` — e.g. the hub's own global
-   * directory (`'hub'`) when walking from the hub's in-process connection.
-   */
-  readonly rootTarget?: string;
-  /**
-   * Invoked once per gated sub-directory the walk encounters. Return `true`
-   * if a capability for its `hubrpc.directory::list` was granted and the
-   * directory should be re-listed; `false` (or omitted hook) leaves it in
-   * {@link WalkHubResult.inaccessible}. Called at most once per `serviceId`.
-   */
-  unlockGatedDirectory?: (serviceId: string) => Promise<boolean>;
-  /** Optional diagnostic sink for inaccessible lists and ended watches. */
-  readonly log?: (message: string) => void;
-}
-declare function walkHubDetailed(channel: ReflectionChannel, opts?: WalkHubOptions): Promise<WalkHubResult>;
-/**
- * Backward-compatible wrapper over {@link walkHubDetailed} that returns only the
- * reachable listings, dropping the inaccessible-directory report.
- */
-declare function walkHub(channel: ReflectionChannel, opts?: WalkHubOptions): Promise<DiscoveredListing[]>;
-interface HubDirectoryChange {
-  /** Directory that emitted the tick. `undefined` denotes the connection root. */
-  readonly target: string | undefined;
-  readonly result: WalkHubResult;
-}
-type HubDirectoryGraphTarget = {
-  readonly kind: 'root';
-  readonly serviceId?: string;
-} | {
-  readonly kind: 'addressed';
-  readonly serviceId: string;
-};
-type HubDirectoryNodeState = 'unexplored' | 'loading' | 'loaded' | 'inaccessible';
-interface HubDirectoryParentReport {
-  readonly target: HubDirectoryGraphTarget;
-  readonly scopes: readonly ServiceIdPattern[];
-  /** Resulting depth for this incoming parent path. */
-  readonly depth: number;
-}
-/** Stable public report for one native directory response. */
-interface HubDirectoryNodeReport {
-  readonly target: HubDirectoryGraphTarget;
-  readonly state: HubDirectoryNodeState;
-  readonly effectiveScopes: readonly ServiceIdPattern[];
-  readonly depth: number;
-  readonly parents: readonly HubDirectoryParentReport[];
-  /** Per-directory listings, normalized to `ServiceListing`, before inherited metadata is folded. */
-  readonly nativeListings: readonly ServiceListing[];
-  readonly inaccessibleReason?: string;
-  readonly watching: boolean;
-}
-/**
- * Complete point-in-time graph document. `root` exists from construction in
- * the `unexplored` state, so consumers can render before exploration starts.
- */
-interface HubDirectoryGraphSnapshot {
-  readonly revision: number;
-  readonly complete: boolean;
-  readonly root: HubDirectoryNodeReport;
-  readonly directories: readonly HubDirectoryNodeReport[];
-  readonly result: WalkHubResult;
-}
-type HubDirectoryGraphEvent = {
-  readonly type: 'snapshot';
-  readonly reason: 'subscribed' | 'reconciliation-started' | 'reset';
-  readonly snapshot: HubDirectoryGraphSnapshot;
-} | {
-  readonly type: 'node-added';
-  readonly reason: 'referral';
-  readonly node: HubDirectoryNodeReport;
-  readonly snapshot: HubDirectoryGraphSnapshot;
-} | {
-  readonly type: 'node-updated';
-  readonly reason: 'loading' | 'loaded' | 'inaccessible' | 'referral' | 'watch-started' | 'watch-stopped' | 'watch-ended' | 'reset';
-  readonly previous: HubDirectoryNodeReport;
-  readonly node: HubDirectoryNodeReport;
-  readonly snapshot: HubDirectoryGraphSnapshot;
-} | {
-  readonly type: 'node-removed';
-  readonly reason: 'unreachable' | 'reset';
-  readonly previous: HubDirectoryNodeReport;
-  readonly snapshot: HubDirectoryGraphSnapshot;
-} | {
-  readonly type: 'settled';
-  readonly snapshot: HubDirectoryGraphSnapshot;
-};
-/**
- * Reusable directory graph explorer and watcher.
- *
- * The class keeps one native snapshot per directory target. A watch tick
- * re-lists only its source target; outgoing referral changes then propagate
- * through affected descendants. Unchanged siblings retain both their snapshot
- * and watch. Multi-parent targets are queried with the normalized union of all
- * incoming path scopes.
- */
-declare class HubDirectoryExplorer {
-  private readonly _channel;
-  private readonly _options;
-  private readonly _maxDepth;
-  private readonly _initialScopes;
-  private readonly _nodes;
-  private readonly _unlockAttempted;
-  private readonly _listeners;
-  private readonly _graphListeners;
-  private readonly _pendingTicks;
-  private readonly _watchRetryTimers;
-  private readonly _watchRetryDelays;
-  private _initialized;
-  private _disposed;
-  private _watching;
-  private _complete;
-  private _revision;
-  private _work;
-  private _explorePromise;
-  constructor(_channel: ReflectionChannel, _options?: WalkHubOptions);
-  /** Perform a fresh bounded exploration without starting watches. */
-  explore(): Promise<WalkHubResult>;
-  private _explore;
-  /** Current deduplicated graph snapshot. */
-  get result(): WalkHubResult;
-  /** Current complete-or-progressive directory graph report. */
-  get graphSnapshot(): HubDirectoryGraphSnapshot;
-  /**
-   * Subscribe to progressive graph reports. The listener is registered before
-   * receiving a synchronous current snapshot, avoiding the subscribe/explore
-   * race for both idle and already-running explorers.
-   */
-  subscribe(listener: (event: HubDirectoryGraphEvent) => void): () => void;
-  /**
-   * Explore once, then watch every reachable directory. Resolves after the
-   * initial graph and watches are established.
-   */
-  watch(listener: (change: HubDirectoryChange) => void): Promise<() => void>;
-  /** Wait until all currently queued watch reconciliation has settled. */
-  whenIdle(): Promise<void>;
-  dispose(): void;
-  private _loadNode;
-  private _tryUnlock;
-  private _reconcileOutgoing;
-  private _outgoingFor;
-  private _createRootNode;
-  private _createNode;
-  private _updateNodeFromParents;
-  private _deriveNodeFromParents;
-  private _derivedNodeState;
-  /**
-   * Rebuild incoming contributions from the root seed. Starting with no
-   * non-root contributions computes the least fixed point, so a disconnected
-   * or narrowed cycle cannot keep scopes contributed by its previous state.
-   */
-  private _reconcileScopesFromRoot;
-  private _computeScopeFixedPoint;
-  private _pruneUnreachable;
-  /**
-   * Every changed watch scope uses list/watch/list: callers reach this method
-   * only after a list under the current scope, then the replacement watch is
-   * installed before a verification list. Either the verification sees a
-   * handoff mutation or the new watch ticks for it.
-   */
-  private _synchronizeWatches;
-  private _replaceWatch;
-  private _queueTick;
-  private _stopWatch;
-  private _stopAllWatches;
-  private _scheduleWatchRetry;
-  private _clearWatchRetry;
-  private _clearNodes;
-  private _resetForExplore;
-  private _updateNode;
-  private _nodeReport;
-  private _targetForKey;
-  private _emitNodeAdded;
-  private _emitNodeUpdated;
-  private _emitNodeRemoved;
-  private _startReconciliation;
-  private _settle;
-  private _emitSnapshot;
-  private _emitGraphEvent;
-  private _deliverGraphEvent;
-  private _nodeKeyForTarget;
-  private _throwIfDisposed;
-}
-//#endregion
 export { type AutoNegotiateConsumer, DEFAULT_WALK_DEPTH, type DiscoveredListing, type HubAccessDuration, type HubAccessManifestDecision, type HubAccessManifestRequest, type HubAccessPattern, type HubAccessPermission, type HubAccessRequest, type HubAccessResult, type HubDirectoryChange, HubDirectoryExplorer, type HubDirectoryGraphEvent, type HubDirectoryGraphSnapshot, type HubDirectoryGraphTarget, type HubDirectoryNodeReport, type HubDirectoryNodeState, type HubDirectoryParentReport, type IHubAccessManifest, type ITransportServer, type InaccessibleDirectory, type ListOptions, type ManagedSigningOptions, ROOT_SERVICE_ID, type ReflectionChannel, SERVICE_ID_SEPARATOR, type ServiceId, type ServiceListing, type Transport, type WalkHubOptions, type WalkHubResult, createAutoNegotiatingCapProvider, createManagedSigningChannel, fetchDirectory, fetchSchema, findCoveringCapabilities, findMethodInSchema, hubAccessInterface, hubAccessManifestInterface, hubGrantedServiceIdInterface, hubServiceIdRegistryInterface, intersectServiceIdScopes, isServiceIdUnder, isValidServiceId, mapTransport, normalizeServiceIdScopes, registerGrantedServiceId, serviceIdMatchesPattern, serviceIdMatchesScopes, splitServiceId, walkHub, walkHubDetailed };
 //# sourceMappingURL=index.d.ts.map

package/dist/hub/common/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/hub/common/serviceId.ts","../../../src/hub/common/transportServer.ts","../../../src/hub/common/hub.interfaces.ts","../../../src/hub/common/baseCapabilities.ts","../../../src/hub/common/managedSigning.ts","../../../src/hub/common/directoryWalk.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/hub/common/serviceId.ts","../../../src/hub/common/transportServer.ts","../../../src/hub/common/hub.interfaces.ts","../../../src/hub/common/baseCapabilities.ts","../../../src/hub/common/managedSigning.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;KAmBY;;cAGC,iBAAiB;;cAGjB;;;;;;iBAOG,iBAAiB;;;;;;;;iBAcjB,eAAe,IAAI;;;;;;iBASnB,iBAAiB,WAAW,WAAW,QAAQ;;;;;;;;;;UC7C9C,kBAAkB;;WAEtB,eAAe;;;;;;EAMxB,WAAW;;;;;;;;UASE,iBAAiB,UAAU;;;;;EAKxC,qBAAqB,UAAU,WAAW;EAC1C;;;;;;;;;;iBAWY,aAAa,WAAW,WAAW,WAAW,WAC1D,QAAQ,iBAAiB,KACzB,MAAM,WAAW,OAAO,iBAAiB,QAAQ,kBAClD,iBAAiB;;;;;;;;;;;;;cCoIP;;;;;;;;;;;;;;;;;;;;;;;;cAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4ED,qBAAqB,uBAAuB;;KAG5C,2BACR,QAAQ,WAAW;;KAGX,4BACR,QAAQ,WAAW;;;;;;;;;iBC/mBD,yBAClB,QAAQ,eAAe,iBACvB,oBACD;;;;UCcc;WACJ;WACA;WACA;;;UAII;;;;;;;;;;;;WAYJ;;WAEA,WAAW;;;;;;;;;;;;;iBAcF,4BAClB,SAAS,oBACT,OAAO,wBACR,QAAQ;;;;;;;;;;;;;;iBAkCK,iCAAiC;WACpC,QAAQ,eAAe;WACvB,WAAW;WACX,UAAU;IACnB"}

package/dist/hub/common/index.js

@@ -2,8 +2,8 @@
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
-import { $ as walkHubDetailed, G as fetchDirectory, J as intersectServiceIdScopes, K as fetchSchema, Q as walkHub, U as DEFAULT_WALK_DEPTH, W as HubDirectoryExplorer, X as serviceIdMatchesPattern, Y as normalizeServiceIdScopes, Z as serviceIdMatchesScopes, g as createManagedPrincipal, ht as permissionMatchesTarget, m as SigningSender, mt as matchParams, q as findMethodInSchema, s as capabilityFreshAt, ut as methodNameToTarget } from "../../chunks/src-CAhXne71.js";
-import { i as hubServiceIdRegistryInterface, n as hubAccessManifestInterface, r as hubGrantedServiceIdInterface, t as hubAccessInterface } from "../../chunks/hub.interfaces-Bf4VfWNX.js";
+import { It as methodNameToTarget, K as matchParams, at as HubDirectoryExplorer, ct as findMethodInSchema, dt as serviceIdMatchesPattern, ft as serviceIdMatchesScopes, g as createManagedPrincipal, it as DEFAULT_WALK_DEPTH, lt as intersectServiceIdScopes, m as SigningSender, mt as walkHubDetailed, ot as fetchDirectory, pt as walkHub, q as permissionMatchesTarget, s as capabilityFreshAt, st as fetchSchema, ut as normalizeServiceIdScopes } from "../../chunks/src-BaCs8mWd.js";
+import { i as hubServiceIdRegistryInterface, n as hubAccessManifestInterface, r as hubGrantedServiceIdInterface, t as hubAccessInterface } from "../../chunks/hub.interfaces-BWqqhgtT.js";
 //#region src/hub/common/serviceId.ts
 /** The root service id — the hub's own local services. */
 const ROOT_SERVICE_ID = "";

package/dist/index.d.ts

@@ -2,5 +2,5 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import { $ as ManagedIdentityStorageBackend, $i as RequestType, $n as signedHash, $r as zTopologyLinkEndpoint, $t as Result, A as VerifyRpcCallResult, Aa as JsonRpcNotification, Ai as InterfaceHandlers, An as Capability, Ar as nodeInterface, B as OneShotCapStaging, Bi as defineInterface, Bn as permissionPermits, Br as TopologyTransportInfo, Bt as ExpBackoffOptions, C as VerifyCallOptions, Ca as SchemaBase, Ci as EXTENSION_PREFIX, Cn as ParsedMethodName, Cr as StreamControlReason, Ct as CmdEnvEndpoint, D as SignRpcCallOptions, Da as ErrorCode, Di as InterfaceClient, Dn as Call, Dr as streamInterface, Dt as ResolvedEndpoint, E as verifyCall, Ea as UnionSchema, Ei as CheckedCallResult, En as Ability, Er as StreamSendParams, Et as FormatEndpointOptions, F as identityStorageInterface, Fa as isNotification, Fi as MemberMap, Fn as TargetPattern, Fr as TopologyLink, Ft as DEFAULT_RPC_TIMEOUT_MS, G as createManagedPrincipal, Gi as ApplicationErrorValue, Gn as LINKRPC_META_KEY, Gr as TrafficWatchResult, Gt as Channel, H as SigningSender, Hi as ApplicationErrorDescriptor, Hn as HUBRPC_META_KEY, Hr as TrafficOverflowEvent, Ht as OnChannelConnect, I as crypto_d_exports, Ia as isRequest, Ii as RemoteRpcError, In as capabilityPermits, Ir as TopologyLinkEndpoint, It as withRpcTimeout, J as CapBagOptions, Ji as DeclaredApplicationErrorOf, Jn as SignDomain, Jr as zParticipantDescriptor, Jt as IRequestSender, K as Principal, Ki as ApplicationErrorsOf, Kn as LINKRPC_SIGNATURE_KEY, Kr as topologyInterface, Kt as ChannelTransport, L as CapProvider, La as isResponse, Li as StreamApi, Ln as hasSignedCapabilityShape, Lr as TopologyNode, Lt as JsonRpcChannel, M as signRpcCall, Ma as JsonRpcResponse, Mi as InterfaceMemberRef, Mn as Pattern, Mr as ParticipantDescriptorSource, Mt as isHubEndpoint, N as verifyRpcCall, Na as JsonRpcSuccess, Ni as InterfaceMemberRefMap, Nn as Permission, Nr as RouteClaim, Nt as parseEndpointUri, O as SignedRpcCall, Oa as JsonRpcError, Oi as InterfaceDefinition, On as CallBind, Or as NodeInfo, Ot as SocketEndpoint, P as identityInterface, Pa as RequestId, Pi as LocalRpcError, Pn as SignedCapability, Pr as TopologyGraph, Pt as CancellableRequest, Q as ManagedIdentityStorage, Qi as PublicApplicationErrorOf, Qn as readSignature, Qr as zTopologyLink, Qt as RawStreamingCall, R as CapProviderResult, Ra as JsonValue, Ri as StreamCallOptions, Rn as matchParams, Rr as TopologyPort, Rt as ChannelConnector, S as SignParamsOptions, Sa as RefSchema, Si as normalizeJsonSchema, Sn as stripLinkRpcWireMeta, Sr as STREAM_METHOD, St as WrappingIdentity, T as signParams, Ta as TupleSchema, Ti as CheckedCall, Tn as parseMethodName, Tr as StreamDir, Tt as EndpointCommand, U as SigningSenderConfig, Ui as ApplicationErrorDescriptorBase, Un as HUBRPC_SIGNATURE_KEY, Ur as TrafficTransitEndpoint, Ut as BareInterfaceTarget, V as SigningCallCtx, Vi as interfaceFromSchema, Vn as Base64Sha256, Vr as TrafficEvent, Vt as KeepConnectedHandle, W as PrincipalWithStore, Wi as ApplicationErrorOf, Wn as HUBRPC_UNSIGNED_KEY, Wr as TrafficTransitEvent, Wt as bareInterfaceTarget, X as InMemoryManagedIdentityStorage, Xi as MemberType, Xn as Signatures, Xr as zRouteClaim, Xt as IncomingStream, Y as InMemoryManagedIdentity, Yi as MemberDocs, Yn as SignatureEnvelope, Yr as zParticipantDescriptorSource, Yt as IncomingCall, Z as ManagedIdentity, Zi as NotificationType, Zn as getKeyId, Zr as zTopologyGraph, Zt as MessageWithCtx, _ as SeededPrincipalOptions, _a as LinkRpcJsonSchema, _i as componentSchemaName, _n as LinkRpcJsonRpcRequest, _r as principalForPublicKey, _t as KeypairSigningIdentity, a as LinkRpcConnection, aa as requestType, ai as zTrafficOverflowEvent, an as IMessageTransport, ar as Keypair, at as ParamMatcherFor, b as createSeededSigningIdentity, ba as ObjectSchema, bi as isAssignable, bn as LinkRpcWireParams, br as jcsCanonicalize, bt as SerializedKeypairSigningIdentity, c as ServiceHandle, ca as LinkRpcInterfaceSchema, ci as zTrafficWatchResult, cn as MessageTransportWithContext, cr as PrivateKey, ct as capBagFreshAt, d as ServiceIdPattern, da as ArraySchema, di as SchemaToZodContext, dn as connectTransports, dr as Signature, dt as issueCapability, ea as Schema, ei as zTopologyNode, en as RpcError, er as signingDomainValue, et as createManagedIdentity, f as defaultsInterface, fa as BooleanSchema, fi as createSchemaToZod, fn as traceMessageTransport, fr as X25519Keypair, ft as permits, g as zServiceIdPattern, ga as IntegerSchema, gi as assertSchemaReferences, gn as LinkRpcJsonRpcNotification, gr as keyIdForPublicKey, gt as KeypairIdentity, h as schemasInterface, ha as EnumSchema, hi as materializeJsonSchema, hn as LinkRpcJsonRpcMessage, hr as keyIdForPrincipal, ht as Identity, i as InterfaceRegistration, ia as notificationType, ii as zTrafficEvent, in as MuxEnvelope, ir as KeyId, it as IssueCapabilityOptions, j as attachCapabilities, ja as JsonRpcRequest, ji as InterfaceInfo, jn as ParamMatcher, jr as ParticipantDescriptor, jt as formatEndpointUri, k as VerifyRpcCallOptions, ka as JsonRpcMessage, ki as InterfaceDefinitionOpts, kn as CallTarget, kr as TopologyIdGenerator, kt as WsEndpoint, l as RootPrincipalReq, la as MemberAnnotations, li as GenerateInterfaceOptions, ln as MessageWithContext, lr as PublicKey, lt as capabilityFreshAt, m as directoryWatchNever, ma as DiscriminatorSchema, mi as MaterializedJsonSchema, mn as CallMeta, mr as bytesToBase64Url, mt as signCapability, n as GetOptions, na as applicationError, ni as zTopologyTransportEndpoint, nn as StreamSendOpts, nr as withSignature, nt as registerLazyIdentityOnOverlay, o as LinkRpcConnectionOptions, oa as zodToSvcJsonSchema, oi as zTrafficTransitEndpoint, on as MessageTransportDirection, or as PRINCIPAL_PREFIX, ot as ParamMatchers, p as directoryInterface, pa as ConstSchema, pi as schemaToZod, pr as base64UrlToBytes, pt as prefix, q as CapBag, qi as CreatedApplicationErrorValue, qn as LINKRPC_UNSIGNED_KEY, qr as trafficInterface, qt as IRequestHandler, r as InspectionRegistration, ra as isApplicationErrorValue, ri as zTopologyTransportInfo, rn as MultiplexedTransport, rr as KEY_ID_PREFIX, rt as AcceptedRootIssuer, s as RegisterOptions, sa as ErrorSchema, si as zTrafficTransitEvent, sn as MessageTransportTrace, sr as PrincipalId, st as PermitResult, t as BareGetOptions, ta as ZodToSvcJsonSchemaOptions, ti as zTopologyPort, tn as SendOpts, tr as signingInput, tt as registerIdentityOnOverlay, u as RootPrincipalSet, ua as MethodSchema, ui as generateTsInterface, un as TransportPair, ur as ResolveSigningKeyArgs, ut as invoke, v as createMemoryPrincipal, va as NullSchema, vi as componentSchemaRef, vn as LinkRpcUnsigned, vr as publicKeyForKeyId, vt as PublicSigningIdentity, w as VerifyResult, wa as StringSchema, wi as computeInterfaceHash, wn as methodNameToTarget, wr as StreamControlType, wt as CmdStdioEndpoint, x as JsonObject, xa as OneOfSchema, xi as matchesJsonSchema, xn as requireObjectParams, xr as jcsCanonicalizeBytes, xt as SigningIdentity, y as createSeededMemoryPrincipal, ya as NumberSchema, yi as Components, yn as LinkRpcWireMeta, yr as resolveSigningKey, yt as PublicWrappingIdentity, z as ManagedSigningChannel, zi as StreamingCall, zn as permissionMatchesTarget, zr as TopologyTransportEndpoint, zt as ConnectableChannel } from "./chunks/linkRpcConnection-BadD37ok.js";
-export { Ability, type AcceptedRootIssuer, ApplicationErrorDescriptor, ApplicationErrorDescriptorBase, ApplicationErrorOf, ApplicationErrorValue, ApplicationErrorsOf, ArraySchema, BareGetOptions, type BareInterfaceTarget, Base64Sha256, BooleanSchema, Call, CallBind, CallMeta, CallTarget, type CancellableRequest, CapBag, CapBagOptions, type CapProvider, type CapProviderResult, Capability, Channel, ChannelConnector, type ChannelTransport, CheckedCall, CheckedCallResult, type CmdEnvEndpoint, type CmdStdioEndpoint, Components, type ConnectableChannel, ConstSchema, CreatedApplicationErrorValue, DEFAULT_RPC_TIMEOUT_MS, DeclaredApplicationErrorOf, DiscriminatorSchema, EXTENSION_PREFIX, type EndpointCommand, EnumSchema, ErrorCode, ErrorSchema, type ExpBackoffOptions, type FormatEndpointOptions, GenerateInterfaceOptions, GetOptions, HUBRPC_META_KEY, HUBRPC_SIGNATURE_KEY, HUBRPC_UNSIGNED_KEY, IMessageTransport, type IRequestHandler, type IRequestSender, Identity, InMemoryManagedIdentity, InMemoryManagedIdentityStorage, type IncomingCall, type IncomingStream, InspectionRegistration, IntegerSchema, InterfaceClient, InterfaceDefinition, InterfaceDefinitionOpts, InterfaceHandlers, InterfaceInfo, InterfaceMemberRef, InterfaceMemberRefMap, InterfaceRegistration, type IssueCapabilityOptions, JsonObject, JsonRpcChannel, JsonRpcError, JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, JsonRpcSuccess, JsonValue, KEY_ID_PREFIX, type KeepConnectedHandle, KeyId, Keypair, KeypairIdentity, KeypairSigningIdentity, LINKRPC_META_KEY, LINKRPC_SIGNATURE_KEY, LINKRPC_UNSIGNED_KEY, LinkRpcConnection, LinkRpcConnectionOptions, LinkRpcInterfaceSchema, LinkRpcJsonRpcMessage, LinkRpcJsonRpcNotification, LinkRpcJsonRpcRequest, LinkRpcJsonSchema, LinkRpcUnsigned, LinkRpcWireMeta, LinkRpcWireParams, LocalRpcError, ManagedIdentity, ManagedIdentityStorage, ManagedIdentityStorageBackend, type ManagedSigningChannel, MaterializedJsonSchema, MemberAnnotations, MemberDocs, MemberMap, MemberType, MessageTransportDirection, MessageTransportTrace, MessageTransportWithContext, MessageWithContext, type MessageWithCtx, MethodSchema, MultiplexedTransport, MuxEnvelope, NodeInfo, NotificationType, NullSchema, NumberSchema, ObjectSchema, type OnChannelConnect, OneOfSchema, OneShotCapStaging, PRINCIPAL_PREFIX, ParamMatcher, type ParamMatcherFor, type ParamMatchers, ParsedMethodName, ParticipantDescriptor, ParticipantDescriptorSource, Pattern, Permission, type PermitResult, Principal, PrincipalId, PrincipalWithStore, PrivateKey, PublicApplicationErrorOf, PublicKey, PublicSigningIdentity, PublicWrappingIdentity, type RawStreamingCall, RefSchema, RegisterOptions, RemoteRpcError, RequestId, RequestType, ResolveSigningKeyArgs, type ResolvedEndpoint, type Result, RootPrincipalReq, RootPrincipalSet, RouteClaim, RpcError, STREAM_METHOD, Schema, SchemaBase, SchemaToZodContext, SeededPrincipalOptions, type SendOpts, SerializedKeypairSigningIdentity, ServiceHandle, ServiceIdPattern, SignDomain, SignParamsOptions, SignRpcCallOptions, Signature, SignatureEnvelope, Signatures, SignedCapability, SignedRpcCall, type SigningCallCtx, SigningIdentity, SigningSender, type SigningSenderConfig, type SocketEndpoint, StreamApi, StreamCallOptions, StreamControlReason, StreamControlType, StreamDir, type StreamSendOpts, StreamSendParams, StreamingCall, StringSchema, TargetPattern, TopologyGraph, TopologyIdGenerator, TopologyLink, TopologyLinkEndpoint, TopologyNode, TopologyPort, TopologyTransportEndpoint, TopologyTransportInfo, TrafficEvent, TrafficOverflowEvent, TrafficTransitEndpoint, TrafficTransitEvent, TrafficWatchResult, TransportPair, TupleSchema, UnionSchema, VerifyCallOptions, VerifyResult, VerifyRpcCallOptions, VerifyRpcCallResult, WrappingIdentity, type WsEndpoint, X25519Keypair, ZodToSvcJsonSchemaOptions, applicationError, assertSchemaReferences, attachCapabilities, bareInterfaceTarget, base64UrlToBytes, bytesToBase64Url, capBagFreshAt, capabilityFreshAt, capabilityPermits, componentSchemaName, componentSchemaRef, computeInterfaceHash, connectTransports, createManagedIdentity, createManagedPrincipal, createMemoryPrincipal, createSchemaToZod, createSeededMemoryPrincipal, createSeededSigningIdentity, crypto_d_exports as crypto, defaultsInterface, defineInterface, directoryInterface, directoryWatchNever, formatEndpointUri, generateTsInterface, getKeyId, hasSignedCapabilityShape, identityInterface, identityStorageInterface, interfaceFromSchema, invoke, isApplicationErrorValue, isAssignable, isHubEndpoint, isNotification, isRequest, isResponse, issueCapability, jcsCanonicalize, jcsCanonicalizeBytes, keyIdForPrincipal, keyIdForPublicKey, matchParams, matchesJsonSchema, materializeJsonSchema, methodNameToTarget, nodeInterface, normalizeJsonSchema, notificationType, parseEndpointUri, parseMethodName, permissionMatchesTarget, permissionPermits, permits, prefix, principalForPublicKey, publicKeyForKeyId, readSignature, registerIdentityOnOverlay, registerLazyIdentityOnOverlay, requestType, requireObjectParams, resolveSigningKey, schemaToZod, schemasInterface, signCapability, signParams, signRpcCall, signedHash, signingDomainValue, signingInput, streamInterface, stripLinkRpcWireMeta, topologyInterface, traceMessageTransport, trafficInterface, verifyCall, verifyRpcCall, withRpcTimeout, withSignature, zParticipantDescriptor, zParticipantDescriptorSource, zRouteClaim, zServiceIdPattern, zTopologyGraph, zTopologyLink, zTopologyLinkEndpoint, zTopologyNode, zTopologyPort, zTopologyTransportEndpoint, zTopologyTransportInfo, zTrafficEvent, zTrafficOverflowEvent, zTrafficTransitEndpoint, zTrafficTransitEvent, zTrafficWatchResult, zodToSvcJsonSchema };
+import { $ as ExpBackoffOptions, $a as BooleanSchema, $i as createSchemaToZod, $n as InMemoryManagedIdentityStorage, $r as readSignature, $t as zParticipantDescriptorSource, A as VerifyRpcCallResult, Aa as ApplicationErrorDescriptorBase, Ai as RpcError, Ar as CallTarget, At as StreamSendParams, B as FormatEndpointOptions, Ba as RequestType, Bi as traceMessageTransport, Bn as CapProvider, Br as permissionMatchesTarget, Bt as TopologyLinkEndpoint, C as VerifyCallOptions, Ca as RemoteRpcError, Ci as IRequestHandler, Co as isRequest, Cr as PublicWrappingIdentity, Ct as parseMethodName, D as SignRpcCallOptions, Da as defineInterface, Di as MessageWithCtx, Dr as Ability, Dt as StreamControlReason, E as verifyCall, Ea as StreamingCall, Ei as IncomingStream, Er as WrappingIdentity, Et as STREAM_METHOD, F as identityStorageInterface, Fa as DeclaredApplicationErrorOf, Fi as MessageTransportTrace, Fr as SignedCapability, Ft as ParticipantDescriptor, G as formatEndpointUri, Ga as notificationType, Gi as StaticHubSchema, Gn as SigningSender, Gr as HUBRPC_UNSIGNED_KEY, Gt as TrafficEvent, H as SocketEndpoint, Ha as ZodToSvcJsonSchemaOptions, Hi as GenerateContractOptions, Hn as ManagedSigningChannel, Hr as Base64Sha256, Ht as TopologyPort, I as crypto_d_exports, Ia as MemberDocs, Ii as MessageTransportWithContext, Ir as TargetPattern, It as ParticipantDescriptorSource, J as CancellableRequest, Ja as ErrorSchema, Ji as StaticService, Jn as createManagedPrincipal, Jr as LINKRPC_UNSIGNED_KEY, Jt as TrafficTransitEvent, K as isHubEndpoint, Ka as requestType, Ki as StaticHubSchemaDocument, Kn as SigningSenderConfig, Kr as LINKRPC_META_KEY, Kt as TrafficOverflowEvent, L as CmdEnvEndpoint, La as MemberType, Li as MessageWithContext, Lr as capabilityPermits, Lt as RouteClaim, M as signRpcCall, Ma as ApplicationErrorValue, Mi as StreamSendOpts, Mr as ParamMatcher, Mt as NodeInfo, N as verifyRpcCall, Na as ApplicationErrorsOf, Ni as IMessageTransport, Nr as Pattern, Nt as TopologyIdGenerator, O as SignedRpcCall, Oa as interfaceFromSchema, Oi as RawStreamingCall, Or as Call, Ot as StreamControlType, P as identityInterface, Pa as CreatedApplicationErrorValue, Pi as MessageTransportDirection, Pr as Permission, Pt as nodeInterface, Q as ConnectableChannel, Qa as ArraySchema, Qi as SchemaToZodContext, Qn as InMemoryManagedIdentity, Qr as getKeyId, Qt as zParticipantDescriptor, R as CmdStdioEndpoint, Ra as NotificationType, Ri as TransportPair, Rr as hasSignedCapabilityShape, Rt as TopologyGraph, S as SignParamsOptions, Sa as MemberMap, Si as ChannelTransport, So as isNotification, Sr as PublicSigningIdentity, St as methodNameToTarget, T as signParams, Ta as StreamCallOptions, Ti as IncomingCall, To as JsonValue, Tr as SigningIdentity, Tt as jcsCanonicalizeBytes, U as WsEndpoint, Ua as applicationError, Ui as generateTsContract, Un as OneShotCapStaging, Ur as HUBRPC_META_KEY, Ut as TopologyTransportEndpoint, V as ResolvedEndpoint, Va as Schema, Vn as CapProviderResult, Vr as permissionPermits, Vt as TopologyNode, Wa as isApplicationErrorValue, Wi as InterfaceRef, Wn as SigningCallCtx, Wr as HUBRPC_SIGNATURE_KEY, Wt as TopologyTransportInfo, X as withRpcTimeout, Xa as MemberAnnotations, Xi as GenerateInterfaceOptions, Xn as CapBag, Xr as SignatureEnvelope, Xt as topologyInterface, Y as DEFAULT_RPC_TIMEOUT_MS, Ya as LinkRpcInterfaceSchema, Yi as parseStaticHubSchema, Yn as Principal, Yr as SignDomain, Yt as TrafficWatchResult, Z as ChannelConnector, Za as MethodSchema, Zi as generateTsInterface, Zn as CapBagOptions, Zr as Signatures, Zt as trafficInterface, _ as SeededPrincipalOptions, _a as InterfaceHandlers, _i as keyIdForPublicKey, _o as JsonRpcNotification, _r as prefix, _t as LinkRpcWireMeta, a as LinkRpcConnection, aa as componentSchemaRef, ai as KeyId, an as zTopologyPort, ao as NullSchema, ar as registerLazyIdentityOnOverlay, at as defaultInterfaceTarget, b as createSeededSigningIdentity, ba as InterfaceMemberRefMap, bi as resolveSigningKey, bo as JsonRpcSuccess, br as KeypairIdentity, bt as stripLinkRpcWireMeta, c as ServiceHandle, ca as matchesJsonSchema, ci as PrincipalId, cn as zTrafficEvent, co as OneOfSchema, cr as IssueCapabilityOptions, ct as BareInterfaceTarget, d as ServiceIdPattern, da as computeInterfaceHash, di as ResolveSigningKeyArgs, dn as zTrafficTransitEvent, do as StringSchema, dr as PermitResult, dt as MuxEnvelope, ea as schemaToZod, ei as signedHash, en as zRouteClaim, eo as ConstSchema, er as ManagedIdentity, et as KeepConnectedHandle, f as defaultsInterface, fa as CheckedCall, fi as Signature, fn as zTrafficWatchResult, fo as TupleSchema, fr as capBagFreshAt, ft as CallMeta, g as zServiceIdPattern, ga as InterfaceDefinitionOpts, gi as keyIdForPrincipal, go as JsonRpcMessage, gr as permits, gt as LinkRpcUnsigned, h as schemasInterface, ha as InterfaceDefinition, hi as bytesToBase64Url, ho as JsonRpcError, hr as issueCapability, ht as LinkRpcJsonRpcRequest, i as InterfaceRegistration, ia as componentSchemaName, ii as KEY_ID_PREFIX, in as zTopologyNode, io as LinkRpcJsonSchema, ir as registerIdentityOnOverlay, it as QualifiedInterfaceTarget, j as attachCapabilities, ja as ApplicationErrorOf, ji as SendOpts, jr as Capability, jt as streamInterface, k as VerifyRpcCallOptions, ka as ApplicationErrorDescriptor, ki as Result, kr as CallBind, kt as StreamDir, l as RootPrincipalReq, la as normalizeJsonSchema, li as PrivateKey, ln as zTrafficOverflowEvent, lo as RefSchema, lr as ParamMatcherFor, lt as bareInterfaceTarget, m as directoryWatchNever, ma as InterfaceClient, mi as base64UrlToBytes, mn as exportStaticHubSchema, mo as ErrorCode, mr as invoke, mt as LinkRpcJsonRpcNotification, n as GetOptions, na as materializeJsonSchema, ni as signingInput, nn as zTopologyLink, no as EnumSchema, nr as ManagedIdentityStorageBackend, nt as DefaultInterfaceTarget, o as LinkRpcConnectionOptions, oa as Components, oi as Keypair, on as zTopologyTransportEndpoint, oo as NumberSchema, or as JsonRpcChannel, ot as interfaceTarget, p as directoryInterface, pa as CheckedCallResult, pi as X25519Keypair, pn as ExportStaticHubSchemaOptions, po as UnionSchema, pr as capabilityFreshAt, pt as LinkRpcJsonRpcMessage, q as parseEndpointUri, qa as zodToSvcJsonSchema, qi as StaticInterfaceReference, qn as PrincipalWithStore, qr as LINKRPC_SIGNATURE_KEY, qt as TrafficTransitEndpoint, r as InspectionRegistration, ra as assertSchemaReferences, ri as withSignature, rn as zTopologyLinkEndpoint, ro as IntegerSchema, rr as createManagedIdentity, rt as InterfaceTarget, s as RegisterOptions, sa as isAssignable, si as PRINCIPAL_PREFIX, sn as zTopologyTransportInfo, so as ObjectSchema, sr as AcceptedRootIssuer, st as isInterfaceTarget, t as BareGetOptions, ta as MaterializedJsonSchema, ti as signingDomainValue, tn as zTopologyGraph, to as DiscriminatorSchema, tr as ManagedIdentityStorage, tt as OnChannelConnect, u as RootPrincipalSet, ua as EXTENSION_PREFIX, ui as PublicKey, un as zTrafficTransitEndpoint, uo as SchemaBase, ur as ParamMatchers, ut as MultiplexedTransport, v as createMemoryPrincipal, va as InterfaceInfo, vi as principalForPublicKey, vo as JsonRpcRequest, vr as signCapability, vt as LinkRpcWireParams, w as VerifyResult, wa as StreamApi, wi as IRequestSender, wo as isResponse, wr as SerializedKeypairSigningIdentity, wt as jcsCanonicalize, x as JsonObject, xa as LocalRpcError, xi as Channel, xo as RequestId, xr as KeypairSigningIdentity, xt as ParsedMethodName, y as createSeededMemoryPrincipal, ya as InterfaceMemberRef, yi as publicKeyForKeyId, yo as JsonRpcResponse, yr as Identity, yt as requireObjectParams, z as EndpointCommand, za as PublicApplicationErrorOf, zi as connectTransports, zr as matchParams, zt as TopologyLink } from "./chunks/linkRpcConnection-C_Gs4nZ9.js";
+export { Ability, type AcceptedRootIssuer, ApplicationErrorDescriptor, ApplicationErrorDescriptorBase, ApplicationErrorOf, ApplicationErrorValue, ApplicationErrorsOf, ArraySchema, BareGetOptions, type BareInterfaceTarget, Base64Sha256, BooleanSchema, Call, CallBind, CallMeta, CallTarget, type CancellableRequest, CapBag, CapBagOptions, type CapProvider, type CapProviderResult, Capability, Channel, ChannelConnector, type ChannelTransport, CheckedCall, CheckedCallResult, type CmdEnvEndpoint, type CmdStdioEndpoint, Components, type ConnectableChannel, ConstSchema, CreatedApplicationErrorValue, DEFAULT_RPC_TIMEOUT_MS, DeclaredApplicationErrorOf, DefaultInterfaceTarget, DiscriminatorSchema, EXTENSION_PREFIX, type EndpointCommand, EnumSchema, ErrorCode, ErrorSchema, type ExpBackoffOptions, ExportStaticHubSchemaOptions, type FormatEndpointOptions, GenerateContractOptions, GenerateInterfaceOptions, GetOptions, HUBRPC_META_KEY, HUBRPC_SIGNATURE_KEY, HUBRPC_UNSIGNED_KEY, IMessageTransport, type IRequestHandler, type IRequestSender, Identity, InMemoryManagedIdentity, InMemoryManagedIdentityStorage, type IncomingCall, type IncomingStream, InspectionRegistration, IntegerSchema, InterfaceClient, InterfaceDefinition, InterfaceDefinitionOpts, InterfaceHandlers, InterfaceInfo, InterfaceMemberRef, InterfaceMemberRefMap, InterfaceRef, InterfaceRegistration, InterfaceTarget, type IssueCapabilityOptions, JsonObject, JsonRpcChannel, JsonRpcError, JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, JsonRpcSuccess, JsonValue, KEY_ID_PREFIX, type KeepConnectedHandle, KeyId, Keypair, KeypairIdentity, KeypairSigningIdentity, LINKRPC_META_KEY, LINKRPC_SIGNATURE_KEY, LINKRPC_UNSIGNED_KEY, LinkRpcConnection, LinkRpcConnectionOptions, LinkRpcInterfaceSchema, LinkRpcJsonRpcMessage, LinkRpcJsonRpcNotification, LinkRpcJsonRpcRequest, LinkRpcJsonSchema, LinkRpcUnsigned, LinkRpcWireMeta, LinkRpcWireParams, LocalRpcError, ManagedIdentity, ManagedIdentityStorage, ManagedIdentityStorageBackend, type ManagedSigningChannel, MaterializedJsonSchema, MemberAnnotations, MemberDocs, MemberMap, MemberType, MessageTransportDirection, MessageTransportTrace, MessageTransportWithContext, MessageWithContext, type MessageWithCtx, MethodSchema, MultiplexedTransport, MuxEnvelope, NodeInfo, NotificationType, NullSchema, NumberSchema, ObjectSchema, type OnChannelConnect, OneOfSchema, OneShotCapStaging, PRINCIPAL_PREFIX, ParamMatcher, type ParamMatcherFor, type ParamMatchers, ParsedMethodName, ParticipantDescriptor, ParticipantDescriptorSource, Pattern, Permission, type PermitResult, Principal, PrincipalId, PrincipalWithStore, PrivateKey, PublicApplicationErrorOf, PublicKey, PublicSigningIdentity, PublicWrappingIdentity, QualifiedInterfaceTarget, type RawStreamingCall, RefSchema, RegisterOptions, RemoteRpcError, RequestId, RequestType, ResolveSigningKeyArgs, type ResolvedEndpoint, type Result, RootPrincipalReq, RootPrincipalSet, RouteClaim, RpcError, STREAM_METHOD, Schema, SchemaBase, SchemaToZodContext, SeededPrincipalOptions, type SendOpts, SerializedKeypairSigningIdentity, ServiceHandle, ServiceIdPattern, SignDomain, SignParamsOptions, SignRpcCallOptions, Signature, SignatureEnvelope, Signatures, SignedCapability, SignedRpcCall, type SigningCallCtx, SigningIdentity, SigningSender, type SigningSenderConfig, type SocketEndpoint, StaticHubSchema, StaticHubSchemaDocument, StaticInterfaceReference, StaticService, StreamApi, StreamCallOptions, StreamControlReason, StreamControlType, StreamDir, type StreamSendOpts, StreamSendParams, StreamingCall, StringSchema, TargetPattern, TopologyGraph, TopologyIdGenerator, TopologyLink, TopologyLinkEndpoint, TopologyNode, TopologyPort, TopologyTransportEndpoint, TopologyTransportInfo, TrafficEvent, TrafficOverflowEvent, TrafficTransitEndpoint, TrafficTransitEvent, TrafficWatchResult, TransportPair, TupleSchema, UnionSchema, VerifyCallOptions, VerifyResult, VerifyRpcCallOptions, VerifyRpcCallResult, WrappingIdentity, type WsEndpoint, X25519Keypair, ZodToSvcJsonSchemaOptions, applicationError, assertSchemaReferences, attachCapabilities, bareInterfaceTarget, base64UrlToBytes, bytesToBase64Url, capBagFreshAt, capabilityFreshAt, capabilityPermits, componentSchemaName, componentSchemaRef, computeInterfaceHash, connectTransports, createManagedIdentity, createManagedPrincipal, createMemoryPrincipal, createSchemaToZod, createSeededMemoryPrincipal, createSeededSigningIdentity, crypto_d_exports as crypto, defaultInterfaceTarget, defaultsInterface, defineInterface, directoryInterface, directoryWatchNever, exportStaticHubSchema, formatEndpointUri, generateTsContract, generateTsInterface, getKeyId, hasSignedCapabilityShape, identityInterface, identityStorageInterface, interfaceFromSchema, interfaceTarget, invoke, isApplicationErrorValue, isAssignable, isHubEndpoint, isInterfaceTarget, isNotification, isRequest, isResponse, issueCapability, jcsCanonicalize, jcsCanonicalizeBytes, keyIdForPrincipal, keyIdForPublicKey, matchParams, matchesJsonSchema, materializeJsonSchema, methodNameToTarget, nodeInterface, normalizeJsonSchema, notificationType, parseEndpointUri, parseMethodName, parseStaticHubSchema, permissionMatchesTarget, permissionPermits, permits, prefix, principalForPublicKey, publicKeyForKeyId, readSignature, registerIdentityOnOverlay, registerLazyIdentityOnOverlay, requestType, requireObjectParams, resolveSigningKey, schemaToZod, schemasInterface, signCapability, signParams, signRpcCall, signedHash, signingDomainValue, signingInput, streamInterface, stripLinkRpcWireMeta, topologyInterface, traceMessageTransport, trafficInterface, verifyCall, verifyRpcCall, withRpcTimeout, withSignature, zParticipantDescriptor, zParticipantDescriptorSource, zRouteClaim, zServiceIdPattern, zTopologyGraph, zTopologyLink, zTopologyLinkEndpoint, zTopologyNode, zTopologyPort, zTopologyTransportEndpoint, zTopologyTransportInfo, zTrafficEvent, zTrafficOverflowEvent, zTrafficTransitEndpoint, zTrafficTransitEvent, zTrafficWatchResult, zodToSvcJsonSchema };

package/dist/index.js

@@ -2,6 +2,6 @@
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
-import { A as EXTENSION_PREFIX, B as requestType, C as defineInterface, D as assertSchemaReferences, E as schemaToZod, F as NotificationType, H as normalizeJsonSchema, I as RequestType, L as applicationError, N as jcsCanonicalize, O as componentSchemaName, P as jcsCanonicalizeBytes, R as isApplicationErrorValue, S as InterfaceDefinition, T as createSchemaToZod, V as zodToSvcJsonSchema, _ as zTrafficEvent, a as topologyInterface, b as zTrafficTransitEvent, c as zParticipantDescriptorSource, d as zTopologyLink, f as zTopologyLinkEndpoint, g as zTopologyTransportInfo, h as zTopologyTransportEndpoint, i as nodeInterface, j as computeInterfaceHash, k as componentSchemaRef, l as zRouteClaim, m as zTopologyPort, o as trafficInterface, p as zTopologyNode, s as zParticipantDescriptor, u as zTopologyGraph, v as zTrafficOverflowEvent, w as interfaceFromSchema, x as zTrafficWatchResult, y as zTrafficTransitEndpoint, z as notificationType } from "./chunks/boundedTrafficSubscription-XZ1KwXZC.js";
-import { $t as bareInterfaceTarget, A as attachCapabilities, At as PRINCIPAL_PREFIX, B as LinkRpcConnection, Bt as isRequest, C as identityStorageInterface, Ct as getKeyId, D as PublicWrappingIdentity, Dt as signingInput, E as PublicSigningIdentity, Et as signingDomainValue, Ft as principalForPublicKey, Gt as StreamDir, H as JsonRpcChannel, Ht as STREAM_METHOD, I as formatEndpointUri, It as publicKeyForKeyId, Jt as directoryInterface, Kt as streamInterface, L as isHubEndpoint, Lt as resolveSigningKey, M as verifyRpcCall, Mt as bytesToBase64Url, N as crypto_exports, Nt as keyIdForPrincipal, O as Principal, Ot as withSignature, Pt as keyIdForPublicKey, Qt as generateTsInterface, R as parseEndpointUri, Rt as ErrorCode, S as identityInterface, St as LINKRPC_UNSIGNED_KEY, T as KeypairSigningIdentity, Tt as signedHash, Ut as StreamControlReason, V as ServiceHandle, Vt as isResponse, Wt as StreamControlType, Xt as schemasInterface, Yt as directoryWatchNever, Zt as zServiceIdPattern, _ as InMemoryManagedIdentity, _t as HUBRPC_META_KEY, a as verifyCall, at as TransportPair, b as registerIdentityOnOverlay, bt as LINKRPC_META_KEY, c as invoke, ct as requireObjectParams, d as prefix, dt as parseMethodName, en as materializeJsonSchema, et as DEFAULT_RPC_TIMEOUT_MS, f as signCapability, ft as capabilityPermits, g as createManagedPrincipal, gt as permissionPermits, h as PrincipalWithStore, ht as permissionMatchesTarget, i as signParams, it as MultiplexedTransport, j as signRpcCall, jt as base64UrlToBytes, k as CapBag, kt as KEY_ID_PREFIX, l as issueCapability, lt as stripLinkRpcWireMeta, m as SigningSender, mt as matchParams, n as createSeededMemoryPrincipal, nn as matchesJsonSchema, nt as Channel, o as capBagFreshAt, ot as connectTransports, p as OneShotCapStaging, pt as hasSignedCapabilityShape, qt as defaultsInterface, r as createSeededSigningIdentity, rt as RpcError, s as capabilityFreshAt, st as traceMessageTransport, t as createMemoryPrincipal, tn as isAssignable, tt as withRpcTimeout, u as permits, ut as methodNameToTarget, v as InMemoryManagedIdentityStorage, vt as HUBRPC_SIGNATURE_KEY, w as KeypairIdentity, wt as readSignature, x as registerLazyIdentityOnOverlay, xt as LINKRPC_SIGNATURE_KEY, y as createManagedIdentity, yt as HUBRPC_UNSIGNED_KEY, z as ChannelConnector, zt as isNotification } from "./chunks/src-CAhXne71.js";
-export { CapBag, Channel, ChannelConnector, DEFAULT_RPC_TIMEOUT_MS, EXTENSION_PREFIX, ErrorCode, HUBRPC_META_KEY, HUBRPC_SIGNATURE_KEY, HUBRPC_UNSIGNED_KEY, InMemoryManagedIdentity, InMemoryManagedIdentityStorage, InterfaceDefinition, JsonRpcChannel, KEY_ID_PREFIX, KeypairIdentity, KeypairSigningIdentity, LINKRPC_META_KEY, LINKRPC_SIGNATURE_KEY, LINKRPC_UNSIGNED_KEY, LinkRpcConnection, MultiplexedTransport, NotificationType, OneShotCapStaging, PRINCIPAL_PREFIX, Principal, PrincipalWithStore, PublicSigningIdentity, PublicWrappingIdentity, RequestType, RpcError, STREAM_METHOD, ServiceHandle, SigningSender, StreamControlReason, StreamControlType, StreamDir, TransportPair, applicationError, assertSchemaReferences, attachCapabilities, bareInterfaceTarget, base64UrlToBytes, bytesToBase64Url, capBagFreshAt, capabilityFreshAt, capabilityPermits, componentSchemaName, componentSchemaRef, computeInterfaceHash, connectTransports, createManagedIdentity, createManagedPrincipal, createMemoryPrincipal, createSchemaToZod, createSeededMemoryPrincipal, createSeededSigningIdentity, crypto_exports as crypto, defaultsInterface, defineInterface, directoryInterface, directoryWatchNever, formatEndpointUri, generateTsInterface, getKeyId, hasSignedCapabilityShape, identityInterface, identityStorageInterface, interfaceFromSchema, invoke, isApplicationErrorValue, isAssignable, isHubEndpoint, isNotification, isRequest, isResponse, issueCapability, jcsCanonicalize, jcsCanonicalizeBytes, keyIdForPrincipal, keyIdForPublicKey, matchParams, matchesJsonSchema, materializeJsonSchema, methodNameToTarget, nodeInterface, normalizeJsonSchema, notificationType, parseEndpointUri, parseMethodName, permissionMatchesTarget, permissionPermits, permits, prefix, principalForPublicKey, publicKeyForKeyId, readSignature, registerIdentityOnOverlay, registerLazyIdentityOnOverlay, requestType, requireObjectParams, resolveSigningKey, schemaToZod, schemasInterface, signCapability, signParams, signRpcCall, signedHash, signingDomainValue, signingInput, streamInterface, stripLinkRpcWireMeta, topologyInterface, traceMessageTransport, trafficInterface, verifyCall, verifyRpcCall, withRpcTimeout, withSignature, zParticipantDescriptor, zParticipantDescriptorSource, zRouteClaim, zServiceIdPattern, zTopologyGraph, zTopologyLink, zTopologyLinkEndpoint, zTopologyNode, zTopologyPort, zTopologyTransportEndpoint, zTopologyTransportInfo, zTrafficEvent, zTrafficOverflowEvent, zTrafficTransitEndpoint, zTrafficTransitEvent, zTrafficWatchResult, zodToSvcJsonSchema };
+import { $ as jcsCanonicalize, A as PRINCIPAL_PREFIX, B as isRequest, C as zTopologyTransportInfo, D as zTrafficTransitEvent, E as zTrafficTransitEndpoint, F as principalForPublicKey, G as createSchemaToZod, H as InterfaceDefinition, I as publicKeyForKeyId, J as componentSchemaName, K as schemaToZod, L as resolveSigningKey, M as bytesToBase64Url, N as keyIdForPrincipal, O as zTrafficWatchResult, P as keyIdForPublicKey, R as ErrorCode, S as zTopologyTransportEndpoint, T as zTrafficOverflowEvent, U as defineInterface, V as isResponse, W as interfaceFromSchema, X as EXTENSION_PREFIX, Y as componentSchemaRef, Z as computeInterfaceHash, _ as zTopologyGraph, at as notificationType, b as zTopologyNode, c as StreamControlType, ct as normalizeJsonSchema, d as nodeInterface, et as jcsCanonicalizeBytes, f as topologyInterface, g as zRouteClaim, h as zParticipantDescriptorSource, it as isApplicationErrorValue, j as base64UrlToBytes, k as KEY_ID_PREFIX, l as StreamDir, m as zParticipantDescriptor, nt as RequestType, o as STREAM_METHOD, ot as requestType, p as trafficInterface, q as assertSchemaReferences, rt as applicationError, s as StreamControlReason, st as zodToSvcJsonSchema, tt as NotificationType, u as streamInterface, v as zTopologyLink, w as zTrafficEvent, x as zTopologyPort, y as zTopologyLinkEndpoint, z as isNotification } from "./chunks/inspectionHost-BA08eF6h.js";
+import { $ as interfaceTarget, A as attachCapabilities, At as getKeyId, B as MultiplexedTransport, Bt as generateTsInterface, C as identityStorageInterface, Ct as stripLinkRpcWireMeta, D as PublicWrappingIdentity, Dt as LINKRPC_META_KEY, E as PublicSigningIdentity, Et as HUBRPC_UNSIGNED_KEY, Ft as withSignature, G as hasSignedCapabilityShape, H as connectTransports, Ht as materializeJsonSchema, I as formatEndpointUri, It as methodNameToTarget, J as permissionPermits, K as matchParams, L as isHubEndpoint, Lt as parseMethodName, M as verifyRpcCall, Mt as signedHash, N as crypto_exports, Nt as signingDomainValue, O as Principal, Ot as LINKRPC_SIGNATURE_KEY, Pt as signingInput, Q as defaultInterfaceTarget, R as parseEndpointUri, Rt as generateTsContract, S as identityInterface, St as requireObjectParams, T as KeypairSigningIdentity, Tt as HUBRPC_SIGNATURE_KEY, U as traceMessageTransport, Ut as isAssignable, V as TransportPair, Vt as bareInterfaceTarget, W as capabilityPermits, Wt as matchesJsonSchema, X as LinkRpcConnection, Y as exportStaticHubSchema, Z as ServiceHandle, _ as InMemoryManagedIdentity, _t as defaultsInterface, a as verifyCall, b as registerIdentityOnOverlay, bt as schemasInterface, c as invoke, d as prefix, et as isInterfaceTarget, f as signCapability, g as createManagedPrincipal, gt as withRpcTimeout, h as PrincipalWithStore, ht as DEFAULT_RPC_TIMEOUT_MS, i as signParams, j as signRpcCall, jt as readSignature, k as CapBag, kt as LINKRPC_UNSIGNED_KEY, l as issueCapability, m as SigningSender, n as createSeededMemoryPrincipal, nt as Channel, o as capBagFreshAt, p as OneShotCapStaging, q as permissionMatchesTarget, r as createSeededSigningIdentity, rt as RpcError, s as capabilityFreshAt, t as createMemoryPrincipal, tt as JsonRpcChannel, u as permits, v as InMemoryManagedIdentityStorage, vt as directoryInterface, w as KeypairIdentity, wt as HUBRPC_META_KEY, x as registerLazyIdentityOnOverlay, xt as zServiceIdPattern, y as createManagedIdentity, yt as directoryWatchNever, z as ChannelConnector, zt as parseStaticHubSchema } from "./chunks/src-BaCs8mWd.js";
+export { CapBag, Channel, ChannelConnector, DEFAULT_RPC_TIMEOUT_MS, EXTENSION_PREFIX, ErrorCode, HUBRPC_META_KEY, HUBRPC_SIGNATURE_KEY, HUBRPC_UNSIGNED_KEY, InMemoryManagedIdentity, InMemoryManagedIdentityStorage, InterfaceDefinition, JsonRpcChannel, KEY_ID_PREFIX, KeypairIdentity, KeypairSigningIdentity, LINKRPC_META_KEY, LINKRPC_SIGNATURE_KEY, LINKRPC_UNSIGNED_KEY, LinkRpcConnection, MultiplexedTransport, NotificationType, OneShotCapStaging, PRINCIPAL_PREFIX, Principal, PrincipalWithStore, PublicSigningIdentity, PublicWrappingIdentity, RequestType, RpcError, STREAM_METHOD, ServiceHandle, SigningSender, StreamControlReason, StreamControlType, StreamDir, TransportPair, applicationError, assertSchemaReferences, attachCapabilities, bareInterfaceTarget, base64UrlToBytes, bytesToBase64Url, capBagFreshAt, capabilityFreshAt, capabilityPermits, componentSchemaName, componentSchemaRef, computeInterfaceHash, connectTransports, createManagedIdentity, createManagedPrincipal, createMemoryPrincipal, createSchemaToZod, createSeededMemoryPrincipal, createSeededSigningIdentity, crypto_exports as crypto, defaultInterfaceTarget, defaultsInterface, defineInterface, directoryInterface, directoryWatchNever, exportStaticHubSchema, formatEndpointUri, generateTsContract, generateTsInterface, getKeyId, hasSignedCapabilityShape, identityInterface, identityStorageInterface, interfaceFromSchema, interfaceTarget, invoke, isApplicationErrorValue, isAssignable, isHubEndpoint, isInterfaceTarget, isNotification, isRequest, isResponse, issueCapability, jcsCanonicalize, jcsCanonicalizeBytes, keyIdForPrincipal, keyIdForPublicKey, matchParams, matchesJsonSchema, materializeJsonSchema, methodNameToTarget, nodeInterface, normalizeJsonSchema, notificationType, parseEndpointUri, parseMethodName, parseStaticHubSchema, permissionMatchesTarget, permissionPermits, permits, prefix, principalForPublicKey, publicKeyForKeyId, readSignature, registerIdentityOnOverlay, registerLazyIdentityOnOverlay, requestType, requireObjectParams, resolveSigningKey, schemaToZod, schemasInterface, signCapability, signParams, signRpcCall, signedHash, signingDomainValue, signingInput, streamInterface, stripLinkRpcWireMeta, topologyInterface, traceMessageTransport, trafficInterface, verifyCall, verifyRpcCall, withRpcTimeout, withSignature, zParticipantDescriptor, zParticipantDescriptorSource, zRouteClaim, zServiceIdPattern, zTopologyGraph, zTopologyLink, zTopologyLinkEndpoint, zTopologyNode, zTopologyPort, zTopologyTransportEndpoint, zTopologyTransportInfo, zTrafficEvent, zTrafficOverflowEvent, zTrafficTransitEndpoint, zTrafficTransitEvent, zTrafficWatchResult, zodToSvcJsonSchema };