@hediet/linkrpc 0.0.1

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

@@ -0,0 +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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"}

package/dist/hub/common/index.js

@@ -0,0 +1,267 @@
+/*---------------------------------------------------------------------------------------------
+*  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-D3NUIwyo.js";
+import { i as hubServiceIdRegistryInterface, n as hubAccessManifestInterface, r as hubGrantedServiceIdInterface, t as hubAccessInterface } from "../../chunks/hub.interfaces-BzWfsVT2.js";
+//#region src/hub/common/serviceId.ts
+/** The root service id — the hub's own local services. */
+const ROOT_SERVICE_ID = "";
+/** The separator between service id segments. */
+const SERVICE_ID_SEPARATOR = "/";
+/**
+* Whether `id` is a well-formed {@link ServiceId}. The root (`""`) is
+* valid; any other value must be non-empty segments joined by single
+* `'/'`s, with no leading, trailing, or empty segments.
+*/
+function isValidServiceId(id) {
+	if (id === "") return true;
+	if (id.startsWith("/") || id.endsWith("/")) return false;
+	if (id.includes("//")) return false;
+	return true;
+}
+/**
+* Split a {@link ServiceId} into its segments. The root (`""`) yields the
+* empty array; `"foo/bar"` yields `["foo", "bar"]`.
+*
+* Does not validate — pair with {@link isValidServiceId} when the input is
+* untrusted.
+*/
+function splitServiceId(id) {
+	return id === "" ? [] : id.split("/");
+}
+/**
+* Whether `serviceId` is equal to or nested beneath `prefix` (segment-aware):
+* `"a/b"` covers `"a/b"` and `"a/b/c"` but **not** `"a/bc"`. The root prefix
+* (`""`) covers everything.
+*/
+function isServiceIdUnder(serviceId, prefix) {
+	if (prefix === "") return true;
+	if (serviceId === prefix) return true;
+	return serviceId.startsWith(prefix + "/");
+}
+//#endregion
+//#region src/hub/common/transportServer.ts
+/**
+* Lift a transport server from emitting `T1` to emitting `T2`. The `map` may
+* be async (e.g. to attest a peer before exposing it) and may return
+* `undefined` to **drop** a connection — the downstream handler is simply not
+* invoked for it. The transport's identity is preserved when the map returns
+* the same object (important: the hub keys routing state on the transport
+* reference), so prefer annotating in place over wrapping.
+*/
+function mapTransport(source, map) {
+	return new MappedTransportServer(source, map);
+}
+var MappedTransportServer = class {
+	_source;
+	_map;
+	_handler;
+	_wired = false;
+	constructor(_source, _map) {
+		this._source = _source;
+		this._map = _map;
+	}
+	setConnectionHandler(handler) {
+		this._handler = handler;
+		if (this._wired) return;
+		this._wired = true;
+		this._source.setConnectionHandler((t1) => {
+			this._onIncoming(t1);
+		});
+	}
+	async _onIncoming(t1) {
+		const t2 = await this._map(t1);
+		if (t2 !== void 0 && this._handler) this._handler(t2);
+	}
+	dispose() {
+		this._source.dispose();
+	}
+};
+//#endregion
+//#region src/hub/common/hubAccess.ts
+/**
+* Return fresh durable capabilities that collectively cover an explicit access
+* request, or `undefined` when the caller must ask the hub for more authority.
+*
+* This is the broad-request counterpart to checking whether a cap bag covers
+* one concrete call. Clients use it before opening consent so persisted grants
+* are reused without weakening any service/interface/member pattern.
+*/
+function findCoveringCapabilities(capabilities, requested, options = {}) {
+	if (requested.length === 0) return void 0;
+	const nowMs = options.nowMs ?? Date.now();
+	const freshnessMarginMs = options.freshnessMarginMs ?? 0;
+	const reusable = capabilities.filter((capability) => capabilityFreshAt(capability, nowMs, freshnessMarginMs) && capability.permissions.every((permission) => permission.callBind === void 0));
+	const matching = /* @__PURE__ */ new Set();
+	for (const request of requested) {
+		const capability = reusable.find((candidate) => candidate.permissions.some((granted) => permissionCovers(granted, request)));
+		if (!capability) return void 0;
+		matching.add(capability);
+	}
+	return [...matching];
+}
+function permissionCovers(granted, requested) {
+	if (requested.canInvoke && !granted.canInvoke) return false;
+	if (requested.canDelegate && !granted.canDelegate) return false;
+	if (!patternCovers(granted.target.serviceId, requested.target.serviceId, "/")) return false;
+	if (!patternCovers(granted.target.interfaceId, requested.target.interfaceId, ".")) return false;
+	if (granted.target.interfaceHash !== void 0 && granted.target.interfaceHash !== requested.target.interfaceHash) return false;
+	if (!requested.target.members.every((requestedMember) => granted.target.members.some((grantedMember) => patternCovers(grantedMember, requestedMember, "")))) return false;
+	if (requested.params === void 0) return granted.params === void 0;
+	if (granted.params === void 0) return true;
+	return paramsEqual(granted.params, requested.params);
+}
+function patternCovers(granted, requested, delimiter) {
+	if ("exact" in granted) return "exact" in requested && granted.exact === requested.exact;
+	if (granted.prefix === "") return true;
+	if ("exact" in requested) return requested.exact === granted.prefix || requested.exact.startsWith(granted.prefix + delimiter);
+	if (requested.prefix === granted.prefix) return true;
+	return delimiter === "" ? requested.prefix.startsWith(granted.prefix) : requested.prefix.startsWith(granted.prefix + delimiter);
+}
+function paramsEqual(granted, requested) {
+	return JSON.stringify(granted) === JSON.stringify(requested);
+}
+//#endregion
+//#region src/hub/common/baseCapabilities.ts
+/**
+* Claim a serviceId prefix within this connection's provenance-granted
+* namespace via `hubGrantedServiceId::register` (no capability needed).
+* Resolves once the claim is registered. Rejects when the prefix is outside
+* the granted namespace or already owned.
+*/
+async function registerGrantedServiceId(sender, serviceId) {
+	await sender.sendRequest(`${hubGrantedServiceIdInterface.info.id}::register`, { serviceId });
+}
+//#endregion
+//#region src/hub/common/managedSigning.ts
+/** How long before expiry a cap is considered stale (transit + clock skew). */
+const CAP_FRESHNESS_MARGIN_MS = 2e3;
+/**
+* Build a managed-identity signing {@link Channel} from a raw channel, with
+* optional per-call capability auto-negotiation.
+*
+* Like {@link SigningSender.fromChannelWithManagedPrincipal}, the
+* `identity::*` bootstrap rides the raw (unsigned) sender, and the returned
+* signing channel is what callers hand to `LinkRpcConnection`. When
+* {@link ManagedSigningOptions.autoNegotiateCaps} is set, the returned
+* channel additionally negotiates capabilities on demand — the browser-safe
+* equivalent of the CLI's `setupSigning({ autoNegotiatePerCall: true })`.
+*/
+async function createManagedSigningChannel(channel, opts) {
+	const principal = await createManagedPrincipal(channel.sender);
+	const config = { principal };
+	const signing = SigningSender.wrapChannel(channel, config);
+	if (opts?.autoNegotiateCaps) config.capProvider = createAutoNegotiatingCapProvider({
+		sender: signing.sender,
+		principal,
+		consumer: opts.consumer ?? { name: "linkrpc client" }
+	});
+	return {
+		channel: signing,
+		principal
+	};
+}
+/**
+* A sign-time {@link CapProvider} that negotiates access per gated call.
+*
+* For each outbound call it: presents any fresh caps already in the bag; if
+* none cover the call, bootstraps the root `hubAccess` capability (once), then
+* asks `hubAccess::requestAccess` for a grant scoped to exactly this call
+* (`callIntent` pinned to the method/params/nonce). Durable grants are added to
+* the bag; a one-shot grant is attached to just this call.
+*
+* Fail-soft: any negotiation error (open hub, denied consent, unreachable front
+* door) falls back to presenting the current bag, letting the call surface
+* `permissionRequired` if it is truly gated.
+*/
+function createAutoNegotiatingCapProvider(opts) {
+	const { sender, principal, consumer } = opts;
+	let inAccessNegotiation = false;
+	const hubAccessMethod = `${hubAccessInterface.info.id}::requestAccess`;
+	return async ({ method, params, nonce, signedAtMs, interfaceHash }) => {
+		const fresh = principal.capBag.capabilities.filter((c) => capabilityFreshAt(c, signedAtMs, CAP_FRESHNESS_MARGIN_MS));
+		const present = fresh.length > 0 ? { capabilities: fresh } : {};
+		if (inAccessNegotiation) return present;
+		let call;
+		try {
+			call = {
+				...methodNameToTarget(method),
+				...interfaceHash !== void 0 ? { interfaceHash } : {}
+			};
+		} catch {
+			return present;
+		}
+		if (call.serviceId === "" || call.interfaceId === hubAccessInterface.info.id) return present;
+		if (capBagCovers(fresh, call, params)) return present;
+		inAccessNegotiation = true;
+		try {
+			const granted = await requestAccessForCall(sender, hubAccessMethod, {
+				...consumer,
+				principal: principal.id
+			}, {
+				call,
+				method,
+				params,
+				nonce,
+				signedAtMs,
+				interfaceHash
+			});
+			if (granted.length === 0) return present;
+			const oneShot = granted.filter(isOneShotCap);
+			const persistent = granted.filter((c) => !isOneShotCap(c));
+			if (persistent.length > 0) await principal.capBag.add(...persistent);
+			const durable = principal.capBag.capabilities.filter((c) => capabilityFreshAt(c, signedAtMs, CAP_FRESHNESS_MARGIN_MS));
+			if (oneShot.length > 0) return { capabilities: [...durable, ...oneShot] };
+			return durable.length > 0 ? { capabilities: durable } : {};
+		} catch {
+			return present;
+		} finally {
+			inAccessNegotiation = false;
+		}
+	};
+}
+/** A cap is one-shot when any permission pins it to a single call via `callBind`. */
+function isOneShotCap(sc) {
+	return sc.permissions.some((p) => p.callBind !== void 0);
+}
+/** True when a durable (non-one-shot) cap in the bag authorises this call. */
+function capBagCovers(caps, target, params) {
+	return caps.some((sc) => !isOneShotCap(sc) && sc.permissions.some((p) => permissionMatchesTarget(target, p) && (p.params === void 0 || matchParams(p.params, params).ok)));
+}
+async function requestAccessForCall(sender, hubAccessMethod, consumer, req) {
+	const result = await sender.sendRequest(hubAccessMethod, {
+		consumer: {
+			...consumer,
+			purpose: consumer.purpose ?? `Invoke ${req.method}.`
+		},
+		permissions: [{
+			target: {
+				serviceId: { exact: req.call.serviceId },
+				interfaceId: { exact: req.call.interfaceId },
+				members: [{ exact: req.call.member }]
+			},
+			canInvoke: true,
+			params: exactParamMatchers(req.params),
+			callIntent: {
+				method: req.method,
+				params: req.params,
+				nonce: req.nonce,
+				signedAtMs: req.signedAtMs,
+				...req.interfaceHash !== void 0 ? { interfaceHash: req.interfaceHash } : {},
+				suggestion: "once"
+			}
+		}],
+		duration: "once"
+	});
+	if (result.status !== "granted") return [];
+	return result.capabilities ?? [];
+}
+function exactParamMatchers(params) {
+	if (params === null || typeof params !== "object" || Array.isArray(params)) return {};
+	return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, { exact: value }]));
+}
+//#endregion
+export { DEFAULT_WALK_DEPTH, HubDirectoryExplorer, ROOT_SERVICE_ID, SERVICE_ID_SEPARATOR, createAutoNegotiatingCapProvider, createManagedSigningChannel, fetchDirectory, fetchSchema, findCoveringCapabilities, findMethodInSchema, hubAccessInterface, hubAccessManifestInterface, hubGrantedServiceIdInterface, hubServiceIdRegistryInterface, intersectServiceIdScopes, isServiceIdUnder, isValidServiceId, mapTransport, normalizeServiceIdScopes, registerGrantedServiceId, serviceIdMatchesPattern, serviceIdMatchesScopes, splitServiceId, walkHub, walkHubDetailed };
+
+//# sourceMappingURL=index.js.map

package/dist/hub/common/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/hub/common/serviceId.ts","../../../src/hub/common/transportServer.ts","../../../src/hub/common/hubAccess.ts","../../../src/hub/common/baseCapabilities.ts","../../../src/hub/common/managedSigning.ts"],"sourcesContent":["/**\n * A **ServiceId** is a `'/'`-segmented address naming a routing destination\n * on a {@link Hub}. The empty string is the **root** (the hub's own / local\n * services); every other id is one or more non-empty segments joined by\n * `'/'`.\n *\n * Examples:\n * - `\"\"`          → root (valid)\n * - `\"foo\"`       → valid\n * - `\"foo/bar\"`   → valid\n * - `\"/\"`         → invalid (empty segments)\n * - `\"/foo\"`      → invalid (leading separator)\n * - `\"foo/\"`      → invalid (trailing separator)\n * - `\"foo//bar\"`  → invalid (empty interior segment)\n *\n * It is a plain `string` alias — the name exists only to mark the role at\n * call sites. Use {@link isValidServiceId} / {@link splitServiceId} to work\n * with it structurally.\n */\nexport type ServiceId = string;\n\n/** The root service id — the hub's own local services. */\nexport const ROOT_SERVICE_ID: ServiceId = '';\n\n/** The separator between service id segments. */\nexport const SERVICE_ID_SEPARATOR = '/';\n\n/**\n * Whether `id` is a well-formed {@link ServiceId}. The root (`\"\"`) is\n * valid; any other value must be non-empty segments joined by single\n * `'/'`s, with no leading, trailing, or empty segments.\n */\nexport function isValidServiceId(id: string): boolean {\n    if (id === ROOT_SERVICE_ID) return true;\n    if (id.startsWith(SERVICE_ID_SEPARATOR) || id.endsWith(SERVICE_ID_SEPARATOR)) return false;\n    if (id.includes(SERVICE_ID_SEPARATOR + SERVICE_ID_SEPARATOR)) return false;\n    return true;\n}\n\n/**\n * Split a {@link ServiceId} into its segments. The root (`\"\"`) yields the\n * empty array; `\"foo/bar\"` yields `[\"foo\", \"bar\"]`.\n *\n * Does not validate — pair with {@link isValidServiceId} when the input is\n * untrusted.\n */\nexport function splitServiceId(id: ServiceId): string[] {\n    return id === ROOT_SERVICE_ID ? [] : id.split(SERVICE_ID_SEPARATOR);\n}\n\n/**\n * Whether `serviceId` is equal to or nested beneath `prefix` (segment-aware):\n * `\"a/b\"` covers `\"a/b\"` and `\"a/b/c\"` but **not** `\"a/bc\"`. The root prefix\n * (`\"\"`) covers everything.\n */\nexport function isServiceIdUnder(serviceId: ServiceId, prefix: ServiceId): boolean {\n    if (prefix === ROOT_SERVICE_ID) return true;\n    if (serviceId === prefix) return true;\n    return serviceId.startsWith(prefix + SERVICE_ID_SEPARATOR);\n}\n","import type { IMessageTransport } from '../../index';\nimport type { TopologyTransportInfo } from '../../inspection/inspection.interfaces';\n\n/**\n * A link the hub can route, plus a close signal. {@link IMessageTransport}\n * on its own has no \"closed\" event (it only learns of teardown through its\n * own `dispose`), but a *server*-produced connection must be able to tell\n * downstream consumers when the remote end goes away so overlays can be torn\n * down and prefixes released. {@link Transport} adds exactly that.\n */\nexport interface Transport extends IMessageTransport {\n    /** Optional diagnostics surfaced on the corresponding topology link. Never include credentials or payloads. */\n    readonly topologyInfo?: TopologyTransportInfo;\n    /**\n     * Register a handler fired exactly once when the transport closes (remote\n     * hang-up or local {@link IMessageTransport.dispose}). Handlers added\n     * after close fire on the next microtask.\n     */\n    onDidClose(handler: () => void): void;\n}\n\n/**\n * A source of inbound {@link Transport}s — the single seam every transport\n * backend (UDS socket, websocket, iframe postMessage, in-process pair)\n * implements. The hub side consumes only this; it never names `net.Socket`\n * or any backend-specific type.\n */\nexport interface ITransportServer<T extends Transport> {\n    /**\n     * Install the handler invoked once per accepted transport. Replacing the\n     * handler is allowed; only the most recent one receives new connections.\n     */\n    setConnectionHandler(handler: (transport: T) => void): void;\n    dispose(): void;\n}\n\n/**\n * Lift a transport server from emitting `T1` to emitting `T2`. The `map` may\n * be async (e.g. to attest a peer before exposing it) and may return\n * `undefined` to **drop** a connection — the downstream handler is simply not\n * invoked for it. The transport's identity is preserved when the map returns\n * the same object (important: the hub keys routing state on the transport\n * reference), so prefer annotating in place over wrapping.\n */\nexport function mapTransport<T1 extends Transport, T2 extends Transport>(\n    source: ITransportServer<T1>,\n    map: (transport: T1) => T2 | undefined | Promise<T2 | undefined>,\n): ITransportServer<T2> {\n    return new MappedTransportServer(source, map);\n}\n\nclass MappedTransportServer<T1 extends Transport, T2 extends Transport>\n    implements ITransportServer<T2>\n{\n    private _handler: ((transport: T2) => void) | undefined;\n    private _wired = false;\n\n    constructor(\n        private readonly _source: ITransportServer<T1>,\n        private readonly _map: (t: T1) => T2 | undefined | Promise<T2 | undefined>,\n    ) {}\n\n    public setConnectionHandler(handler: (transport: T2) => void): void {\n        this._handler = handler;\n        if (this._wired) {\n            return;\n        }\n        this._wired = true;\n        this._source.setConnectionHandler((t1) => {\n            void this._onIncoming(t1);\n        });\n    }\n\n    private async _onIncoming(t1: T1): Promise<void> {\n        const t2 = await this._map(t1);\n        if (t2 !== undefined && this._handler) {\n            this._handler(t2);\n        }\n    }\n\n    public dispose(): void {\n        this._source.dispose();\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nimport {\n    type ParamMatcher,\n    type Pattern,\n    type Permission,\n    type SignedCapability,\n} from '../../protocol';\nimport { capabilityFreshAt } from '../../identity/capability';\n\n/**\n * The client-facing wire shapes of the hub's capability-negotiation protocol\n * (`hubAccess::requestAccess`, see {@link hubAccessInterface}). Any hub client —\n * the CLI, the MCP server, or an embedder — speaks these shapes to ask a hub\n * for authority in a single consent prompt.\n */\n\n/** How long a granted capability should live. */\nexport type HubAccessDuration = 'once' | 'shortLived' | 'longLived' | 'persistent';\n\n/** A `serviceId` / `interfaceId` / member matcher (wire shape of `TargetPattern`). */\nexport type HubAccessPattern = { readonly exact: string; } | { readonly prefix: string; };\n\n/** One authority the consumer wants — the wire shape of a `requestAccess` permission. */\nexport interface HubAccessPermission {\n    readonly target: {\n        readonly serviceId: HubAccessPattern;\n        readonly interfaceId: HubAccessPattern;\n        readonly interfaceHash?: string;\n        readonly members: readonly HubAccessPattern[];\n    };\n    /** Default false (fail closed). Set true to actually call the members. */\n    readonly canInvoke?: boolean;\n    /** Default false. Set true to let the consumer re-delegate this authority. */\n    readonly canDelegate?: boolean;\n    readonly params?: Record<string, unknown>;\n}\n\n/** A batched, explicit access request — possibly many permissions in one prompt. */\nexport interface HubAccessRequest {\n    readonly consumer: { readonly name: string; readonly origin?: string; readonly purpose?: string; };\n    /** One or more authorities to request together (single consent prompt). */\n    readonly permissions: readonly HubAccessPermission[];\n    /** `once` (short-lived), `session` (this connection), or `persistent` (saved). */\n    readonly duration?: HubAccessDuration;\n}\n\n/**\n * Outcome of a `requestAccess` call. `granted` carries every capability the hub\n * minted plus how many of them were durable and added to the connection's cap\n * bag (a client-side augmentation over the pure wire result).\n */\nexport type HubAccessResult =\n    | {\n        readonly status: 'granted';\n        /** Every capability the hub minted for this request. */\n        readonly capabilities: readonly SignedCapability[];\n        /** How many of them were durable and added to the connection's cap bag. */\n        readonly addedDurable: number;\n    }\n    | { readonly status: 'denied'; readonly reason?: string; }\n    | { readonly status: string; readonly reason?: string; };\n\n/**\n * Return fresh durable capabilities that collectively cover an explicit access\n * request, or `undefined` when the caller must ask the hub for more authority.\n *\n * This is the broad-request counterpart to checking whether a cap bag covers\n * one concrete call. Clients use it before opening consent so persisted grants\n * are reused without weakening any service/interface/member pattern.\n */\nexport function findCoveringCapabilities(\n    capabilities: readonly SignedCapability[],\n    requested: readonly HubAccessPermission[],\n    options: {\n        readonly nowMs?: number;\n        readonly freshnessMarginMs?: number;\n    } = {},\n): readonly SignedCapability[] | undefined {\n    if (requested.length === 0) return undefined;\n    const nowMs = options.nowMs ?? Date.now();\n    const freshnessMarginMs = options.freshnessMarginMs ?? 0;\n    const reusable = capabilities.filter((capability) =>\n        capabilityFreshAt(capability, nowMs, freshnessMarginMs)\n        && capability.permissions.every((permission) => permission.callBind === undefined),\n    );\n    const matching = new Set<SignedCapability>();\n\n    for (const request of requested) {\n        const capability = reusable.find((candidate) =>\n            candidate.permissions.some((granted) => permissionCovers(granted, request)),\n        );\n        if (!capability) return undefined;\n        matching.add(capability);\n    }\n\n    return [...matching];\n}\n\nfunction permissionCovers(\n    granted: Permission,\n    requested: HubAccessPermission,\n): boolean {\n    if (requested.canInvoke && !granted.canInvoke) return false;\n    if (requested.canDelegate && !granted.canDelegate) return false;\n    if (!patternCovers(granted.target.serviceId, requested.target.serviceId, '/')) return false;\n    if (!patternCovers(granted.target.interfaceId, requested.target.interfaceId, '.')) return false;\n    if (\n        granted.target.interfaceHash !== undefined\n        && granted.target.interfaceHash !== requested.target.interfaceHash\n    ) {\n        return false;\n    }\n    if (!requested.target.members.every((requestedMember) =>\n        granted.target.members.some((grantedMember) =>\n            patternCovers(grantedMember, requestedMember, ''),\n        ),\n    )) {\n        return false;\n    }\n\n    if (requested.params === undefined) return granted.params === undefined;\n    if (granted.params === undefined) return true;\n    return paramsEqual(granted.params, requested.params);\n}\n\nfunction patternCovers(granted: Pattern, requested: HubAccessPattern, delimiter: string): boolean {\n    if ('exact' in granted) {\n        return 'exact' in requested && granted.exact === requested.exact;\n    }\n    if (granted.prefix === '') return true;\n    if ('exact' in requested) {\n        return requested.exact === granted.prefix\n            || requested.exact.startsWith(granted.prefix + delimiter);\n    }\n    if (requested.prefix === granted.prefix) return true;\n    return delimiter === ''\n        ? requested.prefix.startsWith(granted.prefix)\n        : requested.prefix.startsWith(granted.prefix + delimiter);\n}\n\nfunction paramsEqual(\n    granted: Record<string, ParamMatcher>,\n    requested: Record<string, unknown>,\n): boolean {\n    // HubAccessPermission keeps this field dependency-light as `unknown`, but\n    // broad explicit requests carry the same ParamMatcher wire shapes as a\n    // Permission. Exact equality is the only safe coverage claim here.\n    return JSON.stringify(granted) === JSON.stringify(requested);\n}\n","import type { IRequestSender, SigningCallCtx } from '../../index';\nimport { hubGrantedServiceIdInterface } from './hub.interfaces';\n\n/**\n * Claim a serviceId prefix within this connection's provenance-granted\n * namespace via `hubGrantedServiceId::register` (no capability needed).\n * Resolves once the claim is registered. Rejects when the prefix is outside\n * the granted namespace or already owned.\n */\nexport async function registerGrantedServiceId(\n    sender: IRequestSender<SigningCallCtx>,\n    serviceId: string,\n): Promise<void> {\n    await sender.sendRequest(\n        `${hubGrantedServiceIdInterface.info.id}::register`,\n        { serviceId } as never,\n    );\n}\n","import type {\n    CapProvider,\n    CapProviderResult,\n    CallTarget,\n    Channel,\n    IRequestSender,\n    ManagedSigningChannel,\n    Principal,\n    SignedCapability,\n    SigningCallCtx,\n    SigningSenderConfig,\n} from '../../index';\nimport {\n    capabilityFreshAt,\n    createManagedPrincipal,\n    matchParams,\n    methodNameToTarget,\n    permissionMatchesTarget,\n    SigningSender,\n} from '../../index';\nimport { hubAccessInterface } from './hub.interfaces';\n\n/** How long before expiry a cap is considered stale (transit + clock skew). */\nconst CAP_FRESHNESS_MARGIN_MS = 2000;\n\n/** Who is asking — surfaced in the hub's consent prompt. */\nexport interface AutoNegotiateConsumer {\n    readonly name: string;\n    readonly origin?: string;\n    readonly purpose?: string;\n}\n\n/** Options for {@link createManagedSigningChannel}. */\nexport interface ManagedSigningOptions {\n    /**\n     * When set, install a sign-time {@link CapProvider} that lazily negotiates\n     * the capability each gated call needs through the hub's `hubAccess`\n     * consent front door. Durable grants are absorbed into the principal's cap\n     * bag so later calls present them automatically; one-shot grants are\n     * attached to just the call that prompted them.\n     *\n     * Without it, the channel signs every call but presents no capabilities —\n     * gated calls then fail with `permissionRequired` unless the caller has\n     * arranged a capability some other way.\n     */\n    readonly autoNegotiateCaps?: boolean;\n    /** Consumer identity shown in the consent prompt. */\n    readonly consumer?: AutoNegotiateConsumer;\n}\n\n/**\n * Build a managed-identity signing {@link Channel} from a raw channel, with\n * optional per-call capability auto-negotiation.\n *\n * Like {@link SigningSender.fromChannelWithManagedPrincipal}, the\n * `identity::*` bootstrap rides the raw (unsigned) sender, and the returned\n * signing channel is what callers hand to `LinkRpcConnection`. When\n * {@link ManagedSigningOptions.autoNegotiateCaps} is set, the returned\n * channel additionally negotiates capabilities on demand — the browser-safe\n * equivalent of the CLI's `setupSigning({ autoNegotiatePerCall: true })`.\n */\nexport async function createManagedSigningChannel(\n    channel: Channel<undefined>,\n    opts?: ManagedSigningOptions,\n): Promise<ManagedSigningChannel<undefined>> {\n    const principal = await createManagedPrincipal(channel.sender);\n\n    // Mutable config: the SigningSender reads its fields fresh per call, so we\n    // can install the cap provider *after* the signing sender exists (the\n    // provider needs to issue its `hubAccess` calls through that same signed\n    // sender).\n    const config: { principal: Principal; capProvider?: CapProvider } = { principal };\n    const signing = SigningSender.wrapChannel(channel, config as SigningSenderConfig);\n\n    if (opts?.autoNegotiateCaps) {\n        config.capProvider = createAutoNegotiatingCapProvider({\n            sender: signing.sender,\n            principal,\n            consumer: opts.consumer ?? { name: 'linkrpc client' },\n        });\n    }\n\n    return { channel: signing, principal };\n}\n\n/**\n * A sign-time {@link CapProvider} that negotiates access per gated call.\n *\n * For each outbound call it: presents any fresh caps already in the bag; if\n * none cover the call, bootstraps the root `hubAccess` capability (once), then\n * asks `hubAccess::requestAccess` for a grant scoped to exactly this call\n * (`callIntent` pinned to the method/params/nonce). Durable grants are added to\n * the bag; a one-shot grant is attached to just this call.\n *\n * Fail-soft: any negotiation error (open hub, denied consent, unreachable front\n * door) falls back to presenting the current bag, letting the call surface\n * `permissionRequired` if it is truly gated.\n */\nexport function createAutoNegotiatingCapProvider(opts: {\n    readonly sender: IRequestSender<SigningCallCtx>;\n    readonly principal: Principal;\n    readonly consumer: AutoNegotiateConsumer;\n}): CapProvider {\n    const { sender, principal, consumer } = opts;\n    let inAccessNegotiation = false;\n\n    // `hubAccess` is served at the connection root (never forwarded, never\n    // gated), so it is addressed in root form with no serviceId prefix and no\n    // bootstrap capability.\n    const hubAccessMethod = `${hubAccessInterface.info.id}::requestAccess`;\n\n    return async ({ method, params, nonce, signedAtMs, interfaceHash }) => {\n        const fresh = principal.capBag.capabilities.filter((c) =>\n            capabilityFreshAt(c, signedAtMs, CAP_FRESHNESS_MARGIN_MS),\n        );\n        const present: CapProviderResult = fresh.length > 0 ? { capabilities: fresh } : {};\n\n        // Reentrancy guard: the `hubAccess` calls this provider issues are\n        // themselves signed through the same sender, which re-enters here.\n        // Present only what is in the bag for those.\n        if (inAccessNegotiation) return present;\n\n        let call: CallTarget;\n        try {\n            call = {\n                ...methodNameToTarget(method),\n                ...(interfaceHash !== undefined ? { interfaceHash } : {}),\n            };\n        } catch {\n            return present;\n        }\n        // Never negotiate for the root or the hub's own consent front door.\n        if (call.serviceId === '' || call.interfaceId === hubAccessInterface.info.id) {\n            return present;\n        }\n        if (capBagCovers(fresh, call, params)) return present;\n\n        inAccessNegotiation = true;\n        try {\n            const granted = await requestAccessForCall(sender, hubAccessMethod, {\n                ...consumer,\n                principal: principal.id,\n            }, {\n                call,\n                method,\n                params,\n                nonce,\n                signedAtMs,\n                interfaceHash,\n            });\n            if (granted.length === 0) return present;\n\n            const oneShot = granted.filter(isOneShotCap);\n            const persistent = granted.filter((c) => !isOneShotCap(c));\n            if (persistent.length > 0) await principal.capBag.add(...persistent);\n\n            const durable = principal.capBag.capabilities.filter((c) =>\n                capabilityFreshAt(c, signedAtMs, CAP_FRESHNESS_MARGIN_MS),\n            );\n            if (oneShot.length > 0) return { capabilities: [...durable, ...oneShot] };\n            return durable.length > 0 ? { capabilities: durable } : {};\n        } catch {\n            return present;\n        } finally {\n            inAccessNegotiation = false;\n        }\n    };\n}\n\n/** A cap is one-shot when any permission pins it to a single call via `callBind`. */\nfunction isOneShotCap(sc: SignedCapability): boolean {\n    return sc.permissions.some((p) => p.callBind !== undefined);\n}\n\n/** True when a durable (non-one-shot) cap in the bag authorises this call. */\nfunction capBagCovers(caps: readonly SignedCapability[], target: CallTarget, params: unknown): boolean {\n    return caps.some((sc) =>\n        !isOneShotCap(sc) &&\n        sc.permissions.some((p) =>\n            permissionMatchesTarget(target, p) &&\n            (p.params === undefined || matchParams(p.params, params).ok),\n        ),\n    );\n}\n\ninterface AccessCallRequest {\n    readonly call: CallTarget;\n    readonly method: string;\n    readonly params: unknown;\n    readonly nonce: string;\n    readonly signedAtMs: number;\n    readonly interfaceHash?: string;\n}\n\nasync function requestAccessForCall(\n    sender: IRequestSender<SigningCallCtx>,\n    hubAccessMethod: string,\n    consumer: AutoNegotiateConsumer & { readonly principal: string },\n    req: AccessCallRequest,\n): Promise<SignedCapability[]> {\n    const raw = await sender.sendRequest(hubAccessMethod, {\n        consumer: { ...consumer, purpose: consumer.purpose ?? `Invoke ${req.method}.` },\n        permissions: [{\n            target: {\n                serviceId: { exact: req.call.serviceId },\n                interfaceId: { exact: req.call.interfaceId },\n                members: [{ exact: req.call.member }],\n            },\n            canInvoke: true,\n            params: exactParamMatchers(req.params),\n            callIntent: {\n                method: req.method,\n                params: req.params,\n                nonce: req.nonce,\n                signedAtMs: req.signedAtMs,\n                ...(req.interfaceHash !== undefined ? { interfaceHash: req.interfaceHash } : {}),\n                suggestion: 'once' as const,\n            },\n        }],\n        // The hub mints both a once and an always proposal regardless; this\n        // only nudges the default. The user's choice decides one-shot vs durable.\n        duration: 'once',\n    } as never);\n    const result = raw as unknown as { status: string; capabilities?: SignedCapability[] };\n    if (result.status !== 'granted') return [];\n    return result.capabilities ?? [];\n}\n\nfunction exactParamMatchers(params: unknown): Record<string, { exact: unknown }> {\n    if (params === null || typeof params !== 'object' || Array.isArray(params)) return {};\n    return Object.fromEntries(\n        Object.entries(params as Record<string, unknown>).map(([key, value]) => [key, { exact: value }]),\n    );\n}\n"],"mappings":"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"}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,7 @@
+/*---------------------------------------------------------------------------------------------
+*  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 NotificationType, C as defineInterface, E as computeInterfaceHash, F as normalizeJsonSchema, M as notificationType, N as requestType, O as jcsCanonicalize, P as zodToSvcJsonSchema, S as InterfaceDefinition, T as EXTENSION_PREFIX, _ 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 RequestType, k as jcsCanonicalizeBytes, 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 } from "./chunks/boundedTrafficSubscription-1L592xc7.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, an as componentSchemaRef, 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 createSchemaToZod, 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, in as componentSchemaName, 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 materializeJsonSchema, nt as Channel, o as capBagFreshAt, on as isAssignable, ot as connectTransports, p as OneShotCapStaging, pt as hasSignedCapabilityShape, qt as defaultsInterface, r as createSeededSigningIdentity, rn as assertSchemaReferences, rt as RpcError, s as capabilityFreshAt, st as traceMessageTransport, t as createMemoryPrincipal, tn as schemaToZod, 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-D3NUIwyo.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, 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, isAssignable, isHubEndpoint, isNotification, isRequest, isResponse, issueCapability, jcsCanonicalize, jcsCanonicalizeBytes, keyIdForPrincipal, keyIdForPublicKey, matchParams, 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 };

package/dist/inspection/index.d.ts

@@ -0,0 +1,66 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { $r as zTopologyLinkEndpoint, Ar as nodeInterface, Br as TopologyTransportInfo, Fr as TopologyLink, Gr as TrafficWatchResult, Hr as TrafficOverflowEvent, Ir as TopologyLinkEndpoint, Jr as zParticipantDescriptor, Kr as topologyInterface, Lr as TopologyNode, Mr as ParticipantDescriptorSource, Nr as RouteClaim, Or as NodeInfo, Pr as TopologyGraph, Qr as zTopologyLink, Rr as TopologyPort, Ur as TrafficTransitEndpoint, Vr as TrafficEvent, Wr as TrafficTransitEvent, Xr as zRouteClaim, Yr as zParticipantDescriptorSource, Zr as zTopologyGraph, ai as zTrafficOverflowEvent, ci as zTrafficWatchResult, ei as zTopologyNode, ii as zTrafficEvent, jr as ParticipantDescriptor, kr as TopologyIdGenerator, ni as zTopologyTransportEndpoint, oi as zTrafficTransitEndpoint, qr as trafficInterface, ri as zTopologyTransportInfo, si as zTrafficTransitEvent, ti as zTopologyPort, zr as TopologyTransportEndpoint } from "../chunks/linkRpcConnection-CtlQmetO.js";
+//#region src/inspection/trafficFlowFilter.d.ts
+interface TrafficRequestRef {
+  readonly portId: string;
+  readonly requestId: string | number;
+}
+interface TrafficFlowFilterOptions {
+  readonly focus?: TrafficRequestRef;
+}
+declare class TrafficFlowFilter {
+  private readonly _focused;
+  constructor(options: TrafficFlowFilterOptions);
+  shouldInclude(transit: TrafficTransitEvent): boolean;
+}
+declare class TrafficWatchFlowTracker {
+  private readonly _active;
+  private readonly _unclaimed;
+  accept(transit: TrafficTransitEvent): boolean;
+  private _findFlow;
+  private _removeFlow;
+  claim(trafficIgnoreKey: string): boolean;
+  clear(): void;
+}
+//#endregion
+//#region src/inspection/boundedTrafficSubscription.d.ts
+interface TrafficSubscriptionOptions {
+  readonly methodPrefix?: string;
+  readonly maxPayloadBytes?: number;
+  readonly trafficIgnoreKey?: string;
+  readonly focusRequest?: TrafficRequestRef;
+}
+interface TrafficSubscription {
+  readonly closed: Promise<TrafficWatchResult>;
+  dispose(): void;
+}
+/**
+ * Applies per-subscriber filtering and payload policy while isolating traffic
+ * producers from slow or failed stream consumers.
+ */
+declare class BoundedTrafficSubscription implements TrafficSubscription {
+  private readonly _options;
+  private readonly _send;
+  private readonly _onDispose;
+  private readonly _queueLimit;
+  private readonly _queue;
+  private _active;
+  private _pumping;
+  private _overflowPending;
+  private _delivered;
+  private _dropped;
+  private readonly _resolveClosed;
+  private readonly _filter;
+  readonly closed: Promise<TrafficWatchResult>;
+  constructor(_options: TrafficSubscriptionOptions, _send: (event: TrafficEvent) => Promise<void>, _onDispose: () => void, _queueLimit?: number);
+  enqueue(transit: TrafficTransitEvent): void;
+  dispose(): void;
+  private _pump;
+  private _complete;
+}
+//#endregion
+export { BoundedTrafficSubscription, NodeInfo, ParticipantDescriptor, ParticipantDescriptorSource, RouteClaim, TopologyGraph, TopologyIdGenerator, TopologyLink, TopologyLinkEndpoint, TopologyNode, TopologyPort, TopologyTransportEndpoint, TopologyTransportInfo, TrafficEvent, TrafficFlowFilter, type TrafficFlowFilterOptions, TrafficOverflowEvent, type TrafficRequestRef, type TrafficSubscription, type TrafficSubscriptionOptions, TrafficTransitEndpoint, TrafficTransitEvent, TrafficWatchFlowTracker, TrafficWatchResult, nodeInterface, topologyInterface, trafficInterface, zParticipantDescriptor, zParticipantDescriptorSource, zRouteClaim, zTopologyGraph, zTopologyLink, zTopologyLinkEndpoint, zTopologyNode, zTopologyPort, zTopologyTransportEndpoint, zTopologyTransportInfo, zTrafficEvent, zTrafficOverflowEvent, zTrafficTransitEndpoint, zTrafficTransitEvent, zTrafficWatchResult };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/inspection/trafficFlowFilter.ts","../../src/inspection/boundedTrafficSubscription.ts"],"mappings":";;;;;;UAKiB;WACJ;WACA;;UAGI;WACJ,QAAQ;;cAGR;mBACQ;EAEL,YAAA,SAAS;EAMd,cAAc,SAAS;;cAMrB;mBACQ;mBACA;EAEV,OAAO,SAAS;UA+Bf;UAOA;EAOD,MAAM;EAIN;;;;UCrEM;WACJ;WACA;WACA;WACA,eAAe;;UAGX;WACJ,QAAQ,QAAQ;EACzB;;;;;;cAOS,sCAAsC;mBAY1B;mBACA;mBACA;mBACA;mBAdJ;UACT;UACA;UACA;UACA;UACA;mBACS;mBACA;WACD,QAAQ,QAAQ;EAGX,YAAA,UAAU,4BACV,QAAQ,OAAO,iBAAiB,eAChC,wBACA;EAUd,QAAQ,SAAS;EAyBjB;UAUO;UA2BN"}

package/dist/inspection/index.js

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+import { _ 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, l as zRouteClaim, m as zTopologyPort, n as TrafficFlowFilter, o as trafficInterface, p as zTopologyNode, r as TrafficWatchFlowTracker, s as zParticipantDescriptor, t as BoundedTrafficSubscription, u as zTopologyGraph, v as zTrafficOverflowEvent, x as zTrafficWatchResult, y as zTrafficTransitEndpoint } from "../chunks/boundedTrafficSubscription-1L592xc7.js";
+export { BoundedTrafficSubscription, TrafficFlowFilter, TrafficWatchFlowTracker, nodeInterface, topologyInterface, trafficInterface, zParticipantDescriptor, zParticipantDescriptorSource, zRouteClaim, zTopologyGraph, zTopologyLink, zTopologyLinkEndpoint, zTopologyNode, zTopologyPort, zTopologyTransportEndpoint, zTopologyTransportInfo, zTrafficEvent, zTrafficOverflowEvent, zTrafficTransitEndpoint, zTrafficTransitEvent, zTrafficWatchResult };