@hediet/linkrpc 0.0.1

package/dist/chunks/boundedTrafficSubscription-1L592xc7.js

@@ -0,0 +1,1126 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+import { any, array, boolean, enum as enum$1, int, literal, nonnegative, number, object, optional, record, string, union, unknown, void as void$1 } from "zod/mini";
+import { toJSONSchema } from "zod/v4/core";
+//#region src/schema/normalize.ts
+/**
+* Keys that describe structural shape and are part of the decidable subset.
+* Everything else gets stripped during normalization.
+*
+* Note: `not` is intentionally NOT in this list. The special case `{"not":{}}`
+* (i.e. matches-nothing) is mapped to the literal `false` bottom; any other
+* `not` is dropped.
+*/
+const KEPT_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"format",
+	"properties",
+	"required",
+	"additionalProperties",
+	"items",
+	"prefixItems",
+	"const",
+	"enum",
+	"anyOf",
+	"oneOf",
+	"discriminator",
+	"$ref",
+	"title",
+	"description"
+]);
+/**
+* Normalize raw JSON Schema output (e.g. from `z.toJSONSchema`) into the
+* SvcJsonSchema subset:
+*
+*  - drop annotation keys (`examples`, `default`, `$comment`, `readOnly`, ...)
+*  - drop out-of-subset refinements (`pattern`, `minimum`, `multipleOf`,
+*    `allOf`, `oneOf`, `if/then/else`, `patternProperties`, ...)
+*  - empty schema `{}` ⇒ `true` (top)
+*  - `{"not":{}}` ⇒ `false` (bottom); any other `not` is stripped
+*  - `type:"object"` without `additionalProperties` ⇒ closed (`false`),
+*    matching linkrpc's stricter contract
+*
+* The output is canonical: structurally equal inputs produce structurally
+* equal outputs, which is what `computeInterfaceHash` relies on.
+*/
+function normalizeJsonSchema(raw) {
+	if (raw === true || raw === false) return raw;
+	if (raw === null || typeof raw !== "object") throw new Error(`normalizeJsonSchema: expected object, got ${typeof raw}`);
+	if (Array.isArray(raw)) throw new Error("normalizeJsonSchema: expected object, got array");
+	const r = raw;
+	if ("not" in r && isEmptyObject(r["not"])) return false;
+	const out = {};
+	for (const [k, v] of Object.entries(r)) {
+		if (!KEPT_KEYS.has(k)) continue;
+		const normalized = normalizeChild(k, v);
+		if (normalized === void 0) continue;
+		out[k] = normalized;
+	}
+	if (out["type"] === "object" && !("additionalProperties" in out)) out["additionalProperties"] = false;
+	if (Array.isArray(out["oneOf"]) && !("discriminator" in out)) {
+		const detected = _detectDiscriminator(out["oneOf"]);
+		if (detected !== void 0) out["discriminator"] = detected;
+	}
+	if ("discriminator" in out && !Array.isArray(out["oneOf"])) delete out["discriminator"];
+	if (Object.keys(out).length === 0) return true;
+	return out;
+}
+function normalizeChild(key, v) {
+	switch (key) {
+		case "properties": {
+			if (!isPlainObject(v)) return {};
+			const out = {};
+			for (const [pk, pv] of Object.entries(v)) out[pk] = normalizeJsonSchema(pv);
+			return out;
+		}
+		case "items":
+		case "additionalProperties":
+			if (v === false) return false;
+			return normalizeJsonSchema(v);
+		case "prefixItems":
+		case "anyOf":
+		case "oneOf":
+			if (!Array.isArray(v)) return [];
+			return v.map((s) => normalizeJsonSchema(s));
+		case "discriminator": {
+			if (!isPlainObject(v)) return void 0;
+			const name = v["propertyName"];
+			if (typeof name !== "string" || name.length === 0) return void 0;
+			return { propertyName: name };
+		}
+		case "enum":
+			if (!Array.isArray(v)) return [];
+			return v.slice();
+		case "required":
+			if (!Array.isArray(v)) return [];
+			return v.slice().sort();
+		default: return v;
+	}
+}
+function isEmptyObject(v) {
+	return isPlainObject(v) && Object.keys(v).length === 0;
+}
+function isPlainObject(v) {
+	return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+/**
+* Inspect a `oneOf` branch list and return a `discriminator` hint when
+* every branch is an object schema and there is exactly one property name
+* that appears in every branch with a distinct `const`-valued schema.
+*
+* This is the canonical JSON-Schema-only encoding of a tagged union, and
+* the shape `z.toJSONSchema(z.discriminatedUnion(...))` emits.
+*/
+function _detectDiscriminator(branches) {
+	if (branches.length < 2) return void 0;
+	const branchPropsList = [];
+	for (const b of branches) {
+		if (b === true || b === false) return void 0;
+		if (b.type !== "object") return void 0;
+		const props = b.properties;
+		if (!props) return void 0;
+		branchPropsList.push(props);
+	}
+	let candidates = _constPropNames(branchPropsList[0]);
+	for (let i = 1; i < branchPropsList.length; i++) {
+		candidates = candidates.filter((n) => _constPropNames(branchPropsList[i]).includes(n));
+		if (candidates.length === 0) return void 0;
+	}
+	for (const name of candidates) {
+		const seen = /* @__PURE__ */ new Set();
+		let allDistinct = true;
+		for (const props of branchPropsList) {
+			const s = props[name];
+			const key = JSON.stringify(s.const);
+			if (seen.has(key)) {
+				allDistinct = false;
+				break;
+			}
+			seen.add(key);
+		}
+		if (allDistinct) return { propertyName: name };
+	}
+}
+function _constPropNames(props) {
+	const out = [];
+	for (const [k, v] of Object.entries(props)) {
+		if (v === true || v === false) continue;
+		if ("const" in v) out.push(k);
+	}
+	return out;
+}
+//#endregion
+//#region src/schema/memberTypes.ts
+var RequestType = class RequestType {
+	paramsSchema;
+	resultSchema;
+	errorSchema;
+	docs;
+	clientStreamSchema;
+	serverStreamSchema;
+	kind = "request";
+	constructor(paramsSchema, resultSchema, errorSchema, docs = {}, clientStreamSchema, serverStreamSchema) {
+		this.paramsSchema = paramsSchema;
+		this.resultSchema = resultSchema;
+		this.errorSchema = errorSchema;
+		this.docs = docs;
+		this.clientStreamSchema = clientStreamSchema;
+		this.serverStreamSchema = serverStreamSchema;
+	}
+	/**
+	* Return a copy of this request type with stream payload schemas
+	* attached. Pass `undefined` for either direction to leave it
+	* closed.
+	*/
+	withStream(opts) {
+		return new RequestType(this.paramsSchema, this.resultSchema, this.errorSchema, this.docs, opts.client, opts.server);
+	}
+};
+var NotificationType = class {
+	paramsSchema;
+	docs;
+	kind = "notification";
+	constructor(paramsSchema, docs = {}) {
+		this.paramsSchema = paramsSchema;
+		this.docs = docs;
+	}
+};
+/**
+* Define a request method.
+*
+* @example
+*   bar: requestType(z.object({ to: z.string() }), z.string(), {
+*     description: "MUST resolve before the next call from the same caller.",
+*   })
+*/
+function requestType(params, result, docsOrError, maybeDocs) {
+	const isErrorSchema = (v) => typeof v === "object" && v !== null && "_zod" in v;
+	const error = isErrorSchema(docsOrError) ? docsOrError : void 0;
+	const docs = (!isErrorSchema(docsOrError) ? docsOrError : maybeDocs) ?? {};
+	return new RequestType(params, result ?? void$1(), error ?? void$1(), docs);
+}
+/**
+* Define a notification method.
+*
+* @example
+*   foo: notificationType(z.object({ message: z.string() }))
+*/
+function notificationType(params, docs = {}) {
+	return new NotificationType(params, docs);
+}
+/** Convert a zod schema to our restricted SvcJsonSchema subset. */
+function zodToSvcJsonSchema(schema, options) {
+	const type = schema._zod?.def?.type;
+	if (type === "void" || type === "undefined") return true;
+	return normalizeZodJsonSchema(toJSONSchema(schema), options);
+}
+function normalizeZodJsonSchema(raw, options) {
+	if (!isRecord(raw)) return normalizeJsonSchema(raw);
+	const definitions = isRecord(raw.$defs) ? raw.$defs : {};
+	const localRefs = collectLocalRefs(raw);
+	if (Object.keys(definitions).length === 0 && localRefs.size === 0) return normalizeJsonSchema(raw);
+	if (options === void 0) throw new Error("zodToSvcJsonSchema: local references require a component destination");
+	const componentNamePrefix = `method=${encodeComponentNamePart(options.methodName)}&schema=${encodeComponentNamePart(options.schemaPosition)}`;
+	const definitionComponents = /* @__PURE__ */ new Map();
+	for (const definitionName of Object.keys(definitions)) definitionComponents.set(definitionName, `${componentNamePrefix}&def=${encodeComponentNamePart(definitionName)}`);
+	const rootComponent = localRefs.has("#") ? `${componentNamePrefix}&root` : void 0;
+	const rewrite = (value) => rewriteLocalRefs(value, definitionComponents, rootComponent);
+	for (const [definitionName, definition] of Object.entries(definitions)) {
+		const componentName = definitionComponents.get(definitionName);
+		if (componentName === void 0) throw new Error(`zodToSvcJsonSchema: missing component for "${definitionName}"`);
+		addComponent(options.components, componentName, normalizeJsonSchema(rewrite(definition)));
+	}
+	const root = rewrite(raw);
+	if (rootComponent !== void 0) {
+		addComponent(options.components, rootComponent, normalizeJsonSchema(root));
+		return { $ref: componentRef(rootComponent) };
+	}
+	return normalizeJsonSchema(root);
+}
+function collectLocalRefs(value, refs = /* @__PURE__ */ new Set()) {
+	if (Array.isArray(value)) {
+		for (const child of value) collectLocalRefs(child, refs);
+		return refs;
+	}
+	if (!isRecord(value)) return refs;
+	if (typeof value.$ref === "string" && value.$ref.startsWith("#")) refs.add(value.$ref);
+	for (const child of Object.values(value)) collectLocalRefs(child, refs);
+	return refs;
+}
+function rewriteLocalRefs(value, definitionComponents, rootComponent) {
+	if (Array.isArray(value)) return value.map((child) => rewriteLocalRefs(child, definitionComponents, rootComponent));
+	if (!isRecord(value)) return value;
+	const result = {};
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "$defs") continue;
+		if (key === "$ref" && typeof child === "string") result[key] = rewriteLocalRef(child, definitionComponents, rootComponent);
+		else result[key] = rewriteLocalRefs(child, definitionComponents, rootComponent);
+	}
+	return result;
+}
+function rewriteLocalRef(ref, definitionComponents, rootComponent) {
+	if (ref === "#") {
+		if (rootComponent === void 0) throw new Error("zodToSvcJsonSchema: root reference has no component destination");
+		return componentRef(rootComponent);
+	}
+	if (ref.startsWith("#/$defs/")) {
+		const encodedName = ref.slice(8);
+		const definitionName = [...definitionComponents.keys()].find((name) => encodeJsonPointerSegment(name) === encodedName);
+		const componentName = definitionName === void 0 ? void 0 : definitionComponents.get(definitionName);
+		if (componentName === void 0) throw new Error(`zodToSvcJsonSchema: dangling local reference "${ref}"`);
+		return componentRef(componentName);
+	}
+	if (ref.startsWith("#") && !ref.startsWith("#/components/schemas/")) throw new Error(`zodToSvcJsonSchema: unsupported local reference "${ref}"`);
+	return ref;
+}
+function addComponent(components, name, schema) {
+	if (Object.hasOwn(components, name)) throw new Error(`zodToSvcJsonSchema: duplicate component name "${name}"`);
+	components[name] = schema;
+}
+function componentRef(name) {
+	return `#/components/schemas/${encodeJsonPointerSegment(name)}`;
+}
+function encodeJsonPointerSegment(value) {
+	return value.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function encodeComponentNamePart(value) {
+	return encodeURIComponent(value).replace(/~/g, "%7E");
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/protocol/jcs.ts
+/**
+* RFC 8785 JSON Canonicalization Scheme (JCS).
+*
+* Used as the byte-deterministic encoding under every linkrpc signature
+* (RPC calls, capabilities, hub-signed previews). Both signer and verifier
+* canonicalize the same value object and obtain byte-identical UTF-8 bytes.
+*
+* Implementation inlined from the `canonicalize` npm package (Apache-2.0,
+* https://github.com/erdtman/canonicalize) so this module stays
+* zero-dependency for browser bundlers that don't resolve transitive
+* npm specifiers (e.g. the in-house app-bundler).
+*/
+/** RFC 8785 canonical JSON string for `value`. */
+function jcsCanonicalize(value) {
+	const out = _canonicalize(value);
+	if (out === void 0) throw new Error("jcsCanonicalize: value is not JSON-representable");
+	return out;
+}
+const _encoder = new TextEncoder();
+/** UTF-8 bytes of the RFC 8785 canonical JSON for `value`. The thing actually signed / hashed. */
+function jcsCanonicalizeBytes(value) {
+	return _encoder.encode(jcsCanonicalize(value));
+}
+function _canonicalize(object, seen = /* @__PURE__ */ new Set()) {
+	if (typeof object === "number" && Number.isNaN(object)) throw new Error("NaN is not allowed");
+	if (typeof object === "number" && !Number.isFinite(object)) throw new Error("Infinity is not allowed");
+	if (object === null || typeof object !== "object") return JSON.stringify(object);
+	const obj = object;
+	if (typeof obj.toJSON === "function") {
+		if (seen.has(obj)) throw new Error("Circular reference detected");
+		seen.add(obj);
+		const result = _canonicalize(obj.toJSON(), seen);
+		seen.delete(obj);
+		return result;
+	}
+	if (seen.has(obj)) throw new Error("Circular reference detected");
+	seen.add(obj);
+	let result;
+	if (Array.isArray(obj)) result = `[${obj.map((cv) => {
+		return _canonicalize(cv === void 0 || typeof cv === "symbol" ? null : cv, seen);
+	}).join(",")}]`;
+	else {
+		const parts = [];
+		for (const key of Object.keys(obj).sort()) {
+			const v = obj[key];
+			if (v === void 0 || typeof v === "symbol") continue;
+			parts.push(`${JSON.stringify(key)}:${_canonicalize(v, seen)}`);
+		}
+		result = `{${parts.join(",")}}`;
+	}
+	seen.delete(obj);
+	return result;
+}
+//#endregion
+//#region src/crypto/sha256.ts
+/**
+* Pure-JS SHA-256 (RFC 6234 / FIPS 180-4). Synchronous, dependency-free,
+* isomorphic. Used internally by linkrpc for content-hashing interface
+* schemas and deriving identity slot names; also surfaced through the
+* `crypto` API as `crypto.sha256`. For signature work we go through the
+* `crypto` module (`./identity/crypto`).
+*
+* Replaces the previous `@noble/hashes/sha2` import so the bundle has
+* no runtime npm dependencies. Trades the well-vetted dep for ~80 lines
+* of straight-line code that has no branching on input contents and is
+* exercised by the existing test vectors plus `sha256.test.ts`.
+*/
+const K = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+function _rotr(x, n) {
+	return x >>> n | x << 32 - n;
+}
+function sha256(data) {
+	const inputLen = data.length;
+	const bitLen = inputLen * 8;
+	const paddedLen = inputLen + 9 + 63 & -64;
+	const padded = new Uint8Array(paddedLen);
+	padded.set(data);
+	padded[inputLen] = 128;
+	const view = new DataView(padded.buffer);
+	view.setUint32(paddedLen - 8, Math.floor(bitLen / 4294967296), false);
+	view.setUint32(paddedLen - 4, bitLen >>> 0, false);
+	const H = new Uint32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]);
+	const W = /* @__PURE__ */ new Uint32Array(64);
+	for (let block = 0; block < paddedLen; block += 64) {
+		for (let t = 0; t < 16; t++) W[t] = view.getUint32(block + t * 4, false);
+		for (let t = 16; t < 64; t++) {
+			const w15 = W[t - 15];
+			const w2 = W[t - 2];
+			const s0 = _rotr(w15, 7) ^ _rotr(w15, 18) ^ w15 >>> 3;
+			const s1 = _rotr(w2, 17) ^ _rotr(w2, 19) ^ w2 >>> 10;
+			W[t] = W[t - 16] + s0 + W[t - 7] + s1 >>> 0;
+		}
+		let a = H[0], b = H[1], c = H[2], d = H[3];
+		let e = H[4], f = H[5], g = H[6], h = H[7];
+		for (let t = 0; t < 64; t++) {
+			const S1 = _rotr(e, 6) ^ _rotr(e, 11) ^ _rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const temp1 = h + S1 + ch + K[t] + W[t] >>> 0;
+			const temp2 = (_rotr(a, 2) ^ _rotr(a, 13) ^ _rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + temp1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = temp1 + temp2 >>> 0;
+		}
+		H[0] = H[0] + a >>> 0;
+		H[1] = H[1] + b >>> 0;
+		H[2] = H[2] + c >>> 0;
+		H[3] = H[3] + d >>> 0;
+		H[4] = H[4] + e >>> 0;
+		H[5] = H[5] + f >>> 0;
+		H[6] = H[6] + g >>> 0;
+		H[7] = H[7] + h >>> 0;
+	}
+	const out = /* @__PURE__ */ new Uint8Array(32);
+	const outView = new DataView(out.buffer);
+	for (let i = 0; i < 8; i++) outView.setUint32(i * 4, H[i], false);
+	return out;
+}
+//#endregion
+//#region src/schema/hash.ts
+const methodSchemaFields = [
+	"params",
+	"result",
+	"clientStream",
+	"serverStream"
+];
+/**
+* Compute the interface hash: SHA-256 of the canonicalized schema, truncated
+* to 16 hex chars (64 bits of collision budget per id).
+*
+* Canonicalization strips the schema down to its **normative wire-contract
+* projection** before hashing, so a single interface document can carry richer
+* non-normative material (codegen hints, safety expressions, notes) without
+* changing identity:
+*
+*   1. Normalize every JSON-Schema position (`params`, `result`, streams, and
+*      `components.schemas`) onto the decidable linkrpc subset.
+*   2. Strip every `comment` field (non-normative — must not affect identity).
+*      `description` is NORMATIVE and kept in the hash.
+*   3. Strip every **specification-extension** field — any object key whose name
+*      begins with `x-` — at every level of the document (see
+*      {@link EXTENSION_PREFIX}). This is the minimal, explicit "one document,
+*      two views" mechanism: the stored document keeps the rich `x-…`
+*      expressions; identity hashes only the simple contract. It mirrors
+*      OpenRPC/OpenAPI specification extensions (this schema format is a subset
+*      of OpenRPC 1.x). Editing an `x-…` value never changes the hash; changing
+*      a wire field (`params`, `result`, member names, `type`, `required`,
+*      `description`, `annotations`, …) does.
+*   4. Omit the top-level `hash` field itself.
+*   5. RFC 8785 JCS encode (recursive key sort, no whitespace) via {@link jcsCanonicalize}.
+*
+* Because no interface schema uses `x-…` keys today, this preserves every
+* existing hash: stripping a set of keys that are always absent is a no-op.
+*
+* > Reservation. `x-…` is reserved for non-normative extensions at every level.
+* > Member names cannot collide (they are alphanumeric per chapter 01 §2), and
+* > object property names in the JSON Schema subset MUST NOT begin with `x-`.
+*/
+function computeInterfaceHash(schema) {
+	const json = jcsCanonicalize(stripNonNormative(normalizeSchemaPositions(schema), true));
+	const digest = sha256(new TextEncoder().encode(json));
+	return Array.from(digest.subarray(0, 8), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function normalizeSchemaPositions(schema) {
+	const methods = Object.fromEntries(Object.entries(schema.methods).map(([name, method]) => {
+		const normalized = { ...method };
+		for (const field of methodSchemaFields) {
+			const value = normalized[field];
+			if (value !== void 0) normalized[field] = normalizeJsonSchema(value);
+		}
+		return [name, normalized];
+	}));
+	const componentSchemas = schema.components?.schemas;
+	const components = componentSchemas === void 0 ? schema.components : {
+		...schema.components,
+		schemas: Object.fromEntries(Object.entries(componentSchemas).map(([name, value]) => [name, normalizeJsonSchema(value)]))
+	};
+	return {
+		...schema,
+		methods,
+		...components === void 0 ? {} : { components }
+	};
+}
+/**
+* Prefix marking a non-normative **specification-extension** key. Any object
+* key beginning with this prefix is stripped before hashing (at every level),
+* exactly like `comment`. Reserved for rich, identity-neutral material such as
+* codegen directives, richer validation/safety expressions, or tooling hints.
+*/
+const EXTENSION_PREFIX = "x-";
+/** True for a key that must not contribute to the interface hash. */
+function isNonNormativeKey(key, isRoot) {
+	return key === "comment" || key.startsWith("x-") || isRoot && key === "hash";
+}
+function stripNonNormative(value, isRoot = false) {
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map((v) => stripNonNormative(v));
+	const out = {};
+	for (const k of Object.keys(value)) {
+		if (isNonNormativeKey(k, isRoot)) continue;
+		const v = value[k];
+		if (v === void 0) continue;
+		out[k] = stripNonNormative(v);
+	}
+	return out;
+}
+//#endregion
+//#region src/connection/interfaceDefinition.ts
+const interfaceDefinitionState = /* @__PURE__ */ new WeakMap();
+var InterfaceDefinition = class {
+	info;
+	members;
+	/** Typed wire references for capability and access-request construction. */
+	ref;
+	constructor(info, members, opts = {}) {
+		this.info = info;
+		this.members = members;
+		interfaceDefinitionState.set(this, {
+			frozenSchema: opts.frozenSchema,
+			schemaCache: void 0,
+			hashCache: void 0
+		});
+		this.ref = Object.fromEntries(Object.keys(members).map((member) => [member, {
+			interfaceId: this.info.id,
+			interfaceHash: this.schemaHash,
+			member
+		}]));
+		if (info.hash !== void 0 && this.schemaHash !== info.hash) throw new Error(`Interface hash mismatch for "${info.id}": expected "${info.hash}", got "${this.schemaHash}". The interface's wire contract changed — update the pinned hash to "${this.schemaHash}" after reviewing the change.`);
+	}
+	/** Content hash of this interface (see `computeInterfaceHash`). */
+	get schemaHash() {
+		const state = interfaceDefinitionState.get(this);
+		if (state.hashCache === void 0) state.hashCache = computeInterfaceHash(state.frozenSchema ?? buildSchema(this.info, this.members, ""));
+		return state.hashCache;
+	}
+	/** Lower the definition to a wire-format `LinkRpcInterfaceSchema`, hash filled in. */
+	toSchema() {
+		const state = interfaceDefinitionState.get(this);
+		if (state.schemaCache === void 0) state.schemaCache = state.frozenSchema !== void 0 ? {
+			...state.frozenSchema,
+			hash: this.schemaHash
+		} : buildSchema(this.info, this.members, this.schemaHash);
+		return state.schemaCache;
+	}
+};
+function buildSchema(info, members, hash) {
+	const methods = {};
+	const components = {};
+	for (const [name, member] of Object.entries(members)) methods[name] = toMethodSchema(name, member, components);
+	const schema = {
+		id: info.id,
+		hash,
+		methods
+	};
+	if (Object.keys(components).length > 0) schema.components = { schemas: components };
+	if (info.description !== void 0) schema.description = info.description;
+	if (info.comment !== void 0) schema.comment = info.comment;
+	return schema;
+}
+function toMethodSchema(name, member, components) {
+	const docs = member.docs;
+	if (member.kind === "request") {
+		const m = {
+			params: convertMemberSchema(name, "params", member.paramsSchema, components),
+			result: convertMemberSchema(name, "result", member.resultSchema, components)
+		};
+		if (member.clientStreamSchema !== void 0) m.clientStream = convertMemberSchema(name, "clientStream", member.clientStreamSchema, components);
+		if (member.serverStreamSchema !== void 0) m.serverStream = convertMemberSchema(name, "serverStream", member.serverStreamSchema, components);
+		if (docs.description !== void 0) m.description = docs.description;
+		if (docs.comment !== void 0) m.comment = docs.comment;
+		if (docs.annotations !== void 0) m.annotations = docs.annotations;
+		return m;
+	}
+	const m = { params: convertMemberSchema(name, "params", member.paramsSchema, components) };
+	if (docs.description !== void 0) m.description = docs.description;
+	if (docs.comment !== void 0) m.comment = docs.comment;
+	if (docs.annotations !== void 0) m.annotations = docs.annotations;
+	return m;
+}
+function convertMemberSchema(methodName, position, schema, components) {
+	return zodToSvcJsonSchema(schema, {
+		methodName,
+		schemaPosition: position,
+		components
+	});
+}
+/**
+* Convenient builder for an interface definition. Tracks TypeScript types
+* through `requestType` / `notificationType` so client and server code can
+* derive their shapes from the definition.
+*
+* @example
+*   const myInterface = defineInterface(
+*     { id: "de.hediet.notification-target" },
+*     {
+*       send: requestType(z.object({ to: z.string() }), z.string()),
+*       notify: notificationType(z.object({ message: z.string() })),
+*     },
+*   );
+*/
+function defineInterface(info, members) {
+	return new InterfaceDefinition(info, members);
+}
+/**
+* Build a runtime {@link InterfaceDefinition} from a previously-published
+* {@link LinkRpcInterfaceSchema} — typically one received over the wire (e.g.
+* from `hubrpc.schemas::get`) or generated at runtime by tooling that does
+* not have the original zod sources at hand (codegen, faker / mock
+* services, dynamic gateways).
+*
+* The original schema is kept verbatim: `toSchema()` returns it (with
+* `hash` overlaid) and `schemaHash` is computed from it, so reflection
+* consumers see the real wire contract. Member-level params / results /
+* streams use `z.any()` because no zod source is available — call-site
+* validation is therefore a no-op and the caller is responsible for
+* shape-checking inputs and outputs.
+*
+* Methods with no `result` descriptor become notifications; methods with
+* `clientStream` / `serverStream` get pass-through stream payload
+* schemas attached.
+*/
+function interfaceFromSchema(schema) {
+	const members = {};
+	for (const [name, method] of Object.entries(schema.methods)) {
+		if (method.result === void 0) {
+			members[name] = new NotificationType(any());
+			continue;
+		}
+		const base = new RequestType(any(), any(), void$1());
+		members[name] = method.clientStream !== void 0 || method.serverStream !== void 0 ? base.withStream({
+			client: method.clientStream !== void 0 ? any() : void 0,
+			server: method.serverStream !== void 0 ? any() : void 0
+		}) : base;
+	}
+	const info = { id: schema.id };
+	if (schema.description !== void 0) info.description = schema.description;
+	if (schema.comment !== void 0) info.comment = schema.comment;
+	return new InterfaceDefinition(info, members, { frozenSchema: schema });
+}
+//#endregion
+//#region src/inspection/inspection.interfaces.ts
+const zTopologyPort = object({
+	portId: string(),
+	label: optional(string())
+});
+const zParticipantDescriptor = object({
+	type: optional(string()),
+	label: optional(string()),
+	processId: optional(number()),
+	processType: optional(string()),
+	nodeStatusServiceId: optional(string()),
+	metadata: optional(record(string(), union([
+		string(),
+		number(),
+		boolean()
+	])))
+});
+const zParticipantDescriptorSource = object({
+	source: enum$1(["self", "attacher"]),
+	descriptor: zParticipantDescriptor
+});
+const zTopologyNode = object({
+	nodeId: string(),
+	kind: optional(enum$1(["endpoint", "hub"])),
+	label: optional(string()),
+	descriptors: optional(array(zParticipantDescriptorSource)),
+	ports: array(zTopologyPort)
+});
+const zTopologyLinkEndpoint = object({
+	nodeId: string(),
+	portId: string()
+});
+const zTopologyTransportEndpoint = object({
+	address: optional(string()),
+	port: optional(number().check(int(), nonnegative()))
+});
+/**
+* Transport details as observed at a topology link. `local` corresponds to the
+* link's `from` endpoint and `remote` to its `to` endpoint.
+*/
+const zTopologyTransportInfo = object({
+	type: string(),
+	local: optional(zTopologyTransportEndpoint),
+	remote: optional(zTopologyTransportEndpoint),
+	path: optional(string()),
+	metadata: optional(record(string(), union([
+		string(),
+		number(),
+		boolean()
+	])))
+});
+const zTopologyLink = object({
+	from: zTopologyLinkEndpoint,
+	to: zTopologyLinkEndpoint,
+	label: optional(string()),
+	peerState: optional(enum$1([
+		"identified",
+		"pending",
+		"unsupported",
+		"error"
+	])),
+	transport: optional(zTopologyTransportInfo)
+});
+const zRouteClaim = object({
+	serviceId: string(),
+	nodeId: string(),
+	portId: string(),
+	match: enum$1(["exact", "prefix"])
+});
+const zTopologyGraph = object({
+	observerServiceId: string(),
+	entryNodeId: string(),
+	nodes: array(zTopologyNode),
+	links: array(zTopologyLink),
+	routes: array(zRouteClaim)
+});
+const topologyInterface = defineInterface({
+	id: "hubrpc.topology",
+	description: "Inspect the transport graph visible from a service. A watch emits invalidation ticks; consumers re-fetch getGraph after each tick."
+}, {
+	getGraph: requestType(object({}), zTopologyGraph).withStream({ client: object({}) }),
+	watchGraph: requestType(object({}), object({})).withStream({ server: object({}) })
+});
+const zTrafficTransitEndpoint = object({
+	edgeId: string(),
+	portId: string(),
+	requestId: optional(union([number(), string()]))
+});
+const zTrafficTransitEvent = object({
+	type: literal("transit"),
+	timeMs: number(),
+	nodeId: string(),
+	in: optional(zTrafficTransitEndpoint),
+	out: optional(zTrafficTransitEndpoint),
+	disposition: enum$1([
+		"forwarded",
+		"consumed",
+		"dropped",
+		"unroutable"
+	]),
+	kind: enum$1([
+		"request",
+		"notification",
+		"response",
+		"stream"
+	]),
+	method: optional(string()),
+	params: optional(unknown()),
+	result: optional(unknown()),
+	error: optional(object({
+		code: number(),
+		message: string(),
+		data: optional(unknown())
+	}))
+});
+const zTrafficOverflowEvent = object({
+	type: literal("overflow"),
+	dropped: number().check(int(), nonnegative())
+});
+const zTrafficEvent = union([zTrafficTransitEvent, zTrafficOverflowEvent]);
+const zTrafficWatchResult = object({
+	delivered: number().check(int(), nonnegative()),
+	dropped: number().check(int(), nonnegative())
+});
+const zTrafficWatchParams = object({
+	methodPrefix: optional(string()),
+	trafficIgnoreKey: optional(string()),
+	focusRequest: optional(object({
+		portId: string(),
+		requestId: union([number(), string()])
+	}))
+});
+const zTrafficWatchWithPayloadsParams = object({
+	methodPrefix: optional(string()),
+	trafficIgnoreKey: optional(string()),
+	focusRequest: optional(object({
+		portId: string(),
+		requestId: union([number(), string()])
+	})),
+	maxPayloadBytes: number().check(int(), nonnegative())
+});
+/**
+* Observe raw message transits at the node hosting the addressed service.
+* Consumers may correlate adjacent transits by shared `(portId, requestId)`.
+*/
+const trafficInterface = defineInterface({
+	id: "hubrpc.traffic",
+	description: "Stream raw message transits for the entire node hosting the addressed service. Payload-free and explicitly payload-bearing variants keep disclosure opt-in."
+}, {
+	watch: requestType(zTrafficWatchParams, zTrafficWatchResult).withStream({ server: zTrafficEvent }),
+	watchWithPayloads: requestType(zTrafficWatchWithPayloadsParams, zTrafficWatchResult).withStream({ server: zTrafficEvent })
+});
+//#endregion
+//#region src/inspection/node.interfaces.ts
+const zNodeInfo = object({
+	/**
+	* Random identity of this connection's node. It is a topology-correlation
+	* label only and must not be used for authentication or authorization.
+	*/
+	nodeId: string(),
+	/** Random identity of this connection's port on its node. */
+	portId: string(),
+	/** Optional diagnostic descriptors; never used for authorization. */
+	descriptors: optional(array(zParticipantDescriptorSource))
+});
+/**
+* Minimal root service for aligning the independently observed topologies at
+* both ends of a connection.
+*/
+const nodeInterface = defineInterface({
+	id: "hubrpc.node",
+	description: "Topology bootstrap: identify the node and port at this end of the direct connection."
+}, { getNodeId: requestType(object({}), zNodeInfo) });
+//#endregion
+//#region src/inspection/trafficFlowFilter.ts
+var TrafficFlowFilter = class {
+	_focused;
+	constructor(options) {
+		this._focused = options.focus !== void 0 ? new CorrelatedFlow([options.focus]) : void 0;
+	}
+	shouldInclude(transit) {
+		return this._focused?.accept(transit).matches ?? true;
+	}
+};
+var TrafficWatchFlowTracker = class {
+	_active = /* @__PURE__ */ new Set();
+	_unclaimed = /* @__PURE__ */ new Map();
+	accept(transit) {
+		if (transit.kind === "request" && isTrafficWatchMethod(transit.method)) {
+			const trafficIgnoreKey = readTrafficIgnoreKey(transit.params);
+			let flow = this._findFlow(transit);
+			if (flow === void 0) {
+				flow = new CorrelatedFlow(requestRefsOf(transit), completionRefOf(transit));
+				if (!isTerminal(transit)) this._active.add(flow);
+			} else flow.accept(transit);
+			if (isTerminal(transit)) {
+				this._removeFlow(flow);
+				return true;
+			}
+			if (trafficIgnoreKey !== void 0) this._unclaimed.set(trafficIgnoreKey, flow);
+			return true;
+		}
+		for (const flow of this._active) {
+			const match = flow.accept(transit);
+			if (!match.matches) continue;
+			if (match.completed) this._removeFlow(flow);
+			return true;
+		}
+		return false;
+	}
+	_findFlow(transit) {
+		for (const flow of this._active) if (flow.matches(transit)) return flow;
+	}
+	_removeFlow(flow) {
+		this._active.delete(flow);
+		for (const [key, pending] of this._unclaimed) if (pending === flow) this._unclaimed.delete(key);
+	}
+	claim(trafficIgnoreKey) {
+		return this._unclaimed.delete(trafficIgnoreKey);
+	}
+	clear() {
+		this._active.clear();
+		this._unclaimed.clear();
+	}
+};
+var CorrelatedFlow = class {
+	_endpoints = /* @__PURE__ */ new Set();
+	_completionEndpoint;
+	constructor(endpoints, completionEndpoint = endpoints[0]) {
+		for (const endpoint of endpoints) this._endpoints.add(endpointKey(endpoint));
+		this._completionEndpoint = completionEndpoint === void 0 ? void 0 : endpointKey(completionEndpoint);
+	}
+	matches(transit) {
+		return requestRefsOf(transit).some((endpoint) => this._endpoints.has(endpointKey(endpoint)));
+	}
+	accept(transit) {
+		const endpoints = requestRefsOf(transit);
+		if (!this.matches(transit)) return {
+			matches: false,
+			completed: false
+		};
+		for (const endpoint of endpoints) this._endpoints.add(endpointKey(endpoint));
+		const completed = transit.kind === "response" && (isTerminal(transit) || this._completionEndpoint !== void 0 && endpoints.some((endpoint) => endpointKey(endpoint) === this._completionEndpoint));
+		if (completed) this._endpoints.clear();
+		return {
+			matches: true,
+			completed
+		};
+	}
+};
+function isTerminal(transit) {
+	return transit.disposition === "dropped" || transit.disposition === "unroutable";
+}
+function requestRefsOf(transit) {
+	const result = [];
+	if (transit.in?.requestId !== void 0) result.push(requestRef(transit.in));
+	if (transit.out?.requestId !== void 0) result.push(requestRef(transit.out));
+	return result;
+}
+function requestRef(endpoint) {
+	return {
+		portId: endpoint.portId,
+		requestId: endpoint.requestId
+	};
+}
+function completionRefOf(transit) {
+	if (transit.in?.requestId !== void 0) return requestRef(transit.in);
+	if (transit.out?.requestId !== void 0) return requestRef(transit.out);
+}
+function endpointKey(endpoint) {
+	return JSON.stringify([
+		endpoint.portId,
+		typeof endpoint.requestId,
+		endpoint.requestId
+	]);
+}
+function isTrafficWatchMethod(method) {
+	return method?.endsWith("::hubrpc.traffic::watch") === true || method?.endsWith("::hubrpc.traffic::watchWithPayloads") === true || method === "hubrpc.traffic::watch" || method === "hubrpc.traffic::watchWithPayloads";
+}
+function readTrafficIgnoreKey(params) {
+	if (params === null || Array.isArray(params) || typeof params !== "object" || !("trafficIgnoreKey" in params)) return;
+	const value = params.trafficIgnoreKey;
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+//#region src/inspection/boundedTrafficSubscription.ts
+const DEFAULT_QUEUE_LIMIT = 256;
+/**
+* Applies per-subscriber filtering and payload policy while isolating traffic
+* producers from slow or failed stream consumers.
+*/
+var BoundedTrafficSubscription = class {
+	_options;
+	_send;
+	_onDispose;
+	_queueLimit;
+	_queue = [];
+	_active = true;
+	_pumping = false;
+	_overflowPending = 0;
+	_delivered = 0;
+	_dropped = 0;
+	_resolveClosed;
+	_filter;
+	closed;
+	constructor(_options, _send, _onDispose, _queueLimit = DEFAULT_QUEUE_LIMIT) {
+		this._options = _options;
+		this._send = _send;
+		this._onDispose = _onDispose;
+		this._queueLimit = _queueLimit;
+		let resolve;
+		this.closed = new Promise((r) => resolve = r);
+		this._resolveClosed = resolve;
+		this._filter = new TrafficFlowFilter({ focus: _options.focusRequest });
+	}
+	enqueue(transit) {
+		if (!this._active) return;
+		if (!this._filter.shouldInclude(transit)) return;
+		if (this._options.methodPrefix !== void 0 && !transit.method?.startsWith(this._options.methodPrefix)) return;
+		const event = this._options.maxPayloadBytes === void 0 ? withoutPayloads(transit) : withCappedPayloads(transit, this._options.maxPayloadBytes);
+		if (this._queue.length >= this._queueLimit) {
+			this._queue.shift();
+			this._dropped++;
+			this._overflowPending++;
+		}
+		this._queue.push(event);
+		if (!this._pumping) {
+			this._pumping = true;
+			queueMicrotask(() => void this._pump());
+		}
+	}
+	dispose() {
+		if (!this._active) return;
+		this._active = false;
+		this._dropped += this._queue.length;
+		this._queue.length = 0;
+		this._overflowPending = 0;
+		this._onDispose();
+		if (!this._pumping) this._complete();
+	}
+	async _pump() {
+		try {
+			while (this._active) {
+				if (this._overflowPending > 0) {
+					const dropped = this._overflowPending;
+					this._overflowPending = 0;
+					await this._send({
+						type: "overflow",
+						dropped
+					});
+					continue;
+				}
+				const event = this._queue.shift();
+				if (event === void 0) break;
+				await this._send(event);
+				this._delivered++;
+			}
+		} catch {
+			this.dispose();
+		} finally {
+			this._pumping = false;
+			if (!this._active) this._complete();
+			else if (this._queue.length > 0 || this._overflowPending > 0) {
+				this._pumping = true;
+				queueMicrotask(() => void this._pump());
+			}
+		}
+	}
+	_complete() {
+		this._resolveClosed({
+			delivered: this._delivered,
+			dropped: this._dropped
+		});
+	}
+};
+function withoutPayloads(transit) {
+	const { params: _params, result: _result, error, ...rest } = transit;
+	if (error === void 0) return rest;
+	return {
+		...rest,
+		error: {
+			code: error.code,
+			message: error.message
+		}
+	};
+}
+function withCappedPayloads(transit, maxPayloadBytes) {
+	return {
+		...transit,
+		params: capPayload(transit.params, maxPayloadBytes),
+		result: capPayload(transit.result, maxPayloadBytes),
+		error: transit.error === void 0 ? void 0 : {
+			...transit.error,
+			data: capPayload(transit.error.data, maxPayloadBytes)
+		}
+	};
+}
+function capPayload(value, maxBytes) {
+	if (value === void 0) return void 0;
+	if (maxBytes === Number.POSITIVE_INFINITY) return value;
+	const json = JSON.stringify(value);
+	if (json === void 0) return void 0;
+	const encoded = new TextEncoder().encode(json);
+	if (encoded.byteLength <= maxBytes) return value;
+	const encoder = new TextEncoder();
+	let preview = new TextDecoder().decode(encoded.slice(0, maxBytes));
+	while (encoder.encode(preview).byteLength > maxBytes) preview = preview.slice(0, -1);
+	return preview;
+}
+//#endregion
+export { NotificationType as A, defineInterface as C, sha256 as D, computeInterfaceHash as E, normalizeJsonSchema as F, notificationType as M, requestType as N, jcsCanonicalize as O, zodToSvcJsonSchema as P, InterfaceDefinition as S, EXTENSION_PREFIX as T, zTrafficEvent as _, topologyInterface as a, zTrafficTransitEvent as b, zParticipantDescriptorSource as c, zTopologyLink as d, zTopologyLinkEndpoint as f, zTopologyTransportInfo as g, zTopologyTransportEndpoint as h, nodeInterface as i, RequestType as j, jcsCanonicalizeBytes as k, zRouteClaim as l, zTopologyPort as m, TrafficFlowFilter as n, trafficInterface as o, zTopologyNode as p, TrafficWatchFlowTracker as r, zParticipantDescriptor as s, BoundedTrafficSubscription as t, zTopologyGraph as u, zTrafficOverflowEvent as v, interfaceFromSchema as w, zTrafficWatchResult as x, zTrafficTransitEndpoint as y };
+
+//# sourceMappingURL=boundedTrafficSubscription-1L592xc7.js.map