@hediet/linkrpc 0.0.1 → 0.0.2

package/dist/chunks/{src-D3NUIwyo.js → src-CAhXne71.js}

@@ -3,10 +3,9 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 import { t as __exportAll } from "./rolldown-runtime-4LSo1kEK.js";
-import { A as NotificationType, C as defineInterface, D as sha256$1, M as notificationType, N as requestType, O as jcsCanonicalize, a as topologyInterface, i as nodeInterface, j as RequestType, k as jcsCanonicalizeBytes, o as trafficInterface, r as TrafficWatchFlowTracker, t as BoundedTrafficSubscription } from "./boundedTrafficSubscription-1L592xc7.js";
+import { B as requestType, C as defineInterface, F as NotificationType, I as RequestType, M as sha256$1, N as jcsCanonicalize, P as jcsCanonicalizeBytes, R as isApplicationErrorValue, V as zodToSvcJsonSchema, a as topologyInterface, i as nodeInterface, o as trafficInterface, r as TrafficWatchFlowTracker, t as BoundedTrafficSubscription, z as notificationType } from "./boundedTrafficSubscription-XZ1KwXZC.js";
 import { array, boolean, enum as enum$1, int, nonnegative, number, object, optional, positive, string, union, unknown } from "zod/mini";
 import { safeParse } from "zod/v4/core";
-import { z } from "zod";
 //#region src/schema/assignability.ts
 /**
 * Structural subtype check: returns `true` iff every JSON value matching
@@ -19,6 +18,10 @@ import { z } from "zod";
 function isAssignable(sub, sup, components = {}) {
 	return _check(sub, sup, components, /* @__PURE__ */ new Set());
 }
+/** Match one JSON value against the structural LinkRPC subset without transforming it. */
+function matchesJsonSchema(value, schema, components = {}) {
+	return _matches(value, schema, components, /* @__PURE__ */ new Set());
+}
 function _check(sub, sup, c, seen) {
 	if (sup === true) return true;
 	if (sub === false) return true;
@@ -119,8 +122,9 @@ function _matches(v, sup, c, seen) {
 	if (sup === true) return true;
 	if (sup === false) return false;
 	if (_isRef(sup)) {
+		if (seen.has(sup.$ref)) return false;
 		const r = _resolveRef(sup, c);
-		return r ? _matches(v, r, c, seen) : false;
+		return r ? _matches(v, r, c, new Set(seen).add(sup.$ref)) : false;
 	}
 	if (_isUnion(sup)) return _branches(sup).some((b) => _matches(v, b, c, seen));
 	if (_isConst(sup)) return _jsonEq(v, sup.const);
@@ -131,12 +135,12 @@ function _matches(v, sup, c, seen) {
 		case "number": return typeof v === "number";
 		case "integer": return typeof v === "number" && Number.isInteger(v);
 		case "string": return typeof v === "string";
-		case "array": return Array.isArray(v) && _matchesArray(v, sup, c, seen);
-		case "object": return v !== null && typeof v === "object" && !Array.isArray(v) && _matchesObject(v, sup, c, seen);
+		case "array": return Array.isArray(v) && _matchesArray(v, sup, c);
+		case "object": return v !== null && typeof v === "object" && !Array.isArray(v) && _matchesObject(v, sup, c);
 		default: return false;
 	}
 }
-function _matchesArray(v, sup, c, seen) {
+function _matchesArray(v, sup, c) {
 	const prefix = sup.prefixItems ?? [];
 	const rest = _restOf(sup);
 	if (rest === false && v.length !== prefix.length) {
@@ -145,16 +149,16 @@ function _matchesArray(v, sup, c, seen) {
 	for (let i = 0; i < v.length; i++) {
 		const s = prefix[i] ?? (rest === false ? false : rest);
 		if (s === false) return false;
-		if (!_matches(v[i], s, c, seen)) return false;
+		if (!_matches(v[i], s, c, /* @__PURE__ */ new Set())) return false;
 	}
 	return true;
 }
-function _matchesObject(v, sup, c, seen) {
-	for (const k of sup.required ?? []) if (!(k in v)) return false;
+function _matchesObject(v, sup, c) {
+	for (const k of sup.required ?? []) if (!Object.hasOwn(v, k)) return false;
 	for (const [k, val] of Object.entries(v)) {
-		const s = sup.properties[k] ?? sup.additionalProperties;
+		const s = Object.hasOwn(sup.properties, k) ? sup.properties[k] : sup.additionalProperties;
 		if (s === false) return false;
-		if (!_matches(val, s, c, seen)) return false;
+		if (!_matches(val, s, c, /* @__PURE__ */ new Set())) return false;
 	}
 	return true;
 }
@@ -218,59 +222,6 @@ function _jsonEq(a, b) {
 	return false;
 }
 //#endregion
-//#region src/schema/assertSchemaReferences.ts
-const componentPrefix = "#/components/schemas/";
-function componentSchemaRef(name) {
-	return componentPrefix + name.replace(/~/g, "~0").replace(/\//g, "~1");
-}
-function componentSchemaName(ref) {
-	if (!ref.startsWith(componentPrefix)) throw new Error(`Invalid component reference: ${ref}`);
-	const token = ref.slice(21);
-	if (token.includes("/") || /~(?:[^01]|$)/.test(token)) throw new Error(`Invalid component reference token: ${ref}`);
-	return token.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-/**
-* Check the finite schema graph without interpreting JSON literal payloads.
-* A reference/union-only cycle is invalid; descending into an object member
-* or an array item guards a cycle, but does not imply the schema is nonempty.
-*/
-function assertSchemaReferences(roots, components = {}) {
-	const nodes = /* @__PURE__ */ new Set();
-	const pending = [...roots, ...Object.values(components)];
-	const unguarded = /* @__PURE__ */ new Map();
-	while (pending.length > 0) {
-		const node = pending.pop();
-		if (typeof node === "boolean" || nodes.has(node)) continue;
-		nodes.add(node);
-		const edges = [];
-		if ("$ref" in node) {
-			const name = componentSchemaName(node.$ref);
-			if (!Object.hasOwn(components, name)) throw new Error(`Unresolved component reference: ${node.$ref}`);
-			edges.push(components[name]);
-		}
-		if ("anyOf" in node) edges.push(...node.anyOf);
-		if ("oneOf" in node) edges.push(...node.oneOf);
-		unguarded.set(node, edges);
-		pending.push(...edges);
-		if ("type" in node && node.type === "object") pending.push(...Object.values(node.properties ?? {}), node.additionalProperties);
-		if ("type" in node && node.type === "array") {
-			if ("prefixItems" in node) pending.push(...node.prefixItems);
-			if (node.items !== void 0) pending.push(node.items);
-		}
-	}
-	const visiting = /* @__PURE__ */ new Set();
-	const checked = /* @__PURE__ */ new Set();
-	const visit = (node) => {
-		if (typeof node === "boolean" || checked.has(node)) return;
-		if (visiting.has(node)) throw new Error("Unguarded recursive schema: cycle does not descend into a child value");
-		visiting.add(node);
-		for (const child of unguarded.get(node) ?? []) visit(child);
-		visiting.delete(node);
-		checked.add(node);
-	};
-	for (const node of nodes) visit(node);
-}
-//#endregion
 //#region src/schema/materializeJsonSchema.ts
 /**
 * Export a LinkRPC schema and its components as standalone JSON Schema
@@ -357,128 +308,6 @@ function isRecord(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 //#endregion
-//#region src/schema/schemaToZod.ts
-/**
-* Create a recursive LinkRPC-schema validator materializer. Component
-* references are lazy, so self and mutual recursion remain guarded.
-*/
-function createSchemaToZod(components = {}) {
-	assertSchemaReferences([], components);
-	const refs = /* @__PURE__ */ new Map();
-	const component = (name) => {
-		const existing = refs.get(name);
-		if (existing !== void 0) return existing;
-		const source = components[name];
-		if (source === void 0) throw new Error(`schemaToZod: dangling component reference "${name}"`);
-		const lazy = z.lazy(() => compile(source));
-		refs.set(name, lazy);
-		return lazy;
-	};
-	const compile = (schema) => {
-		if (schema === true) return z.unknown();
-		if (schema === false) return z.never();
-		const raw = schema;
-		if (Array.isArray(raw.type)) return union$1(raw.type.map((type) => compile({
-			...raw,
-			type
-		})));
-		let base;
-		if ("$ref" in schema) base = component(componentSchemaName(schema.$ref));
-		else if ("const" in schema) base = valueSchema(schema.const);
-		else if ("enum" in schema) base = union$1(schema.enum.map(valueSchema));
-		else if ("anyOf" in schema) base = union$1(schema.anyOf.map(compile));
-		else if ("oneOf" in schema) base = union$1(schema.oneOf.map(compile));
-		else if (isAnnotationOnlySchema(raw)) base = z.unknown();
-		else switch (schema.type) {
-			case "null":
-				base = z.null();
-				break;
-			case "boolean":
-				base = z.boolean();
-				break;
-			case "string":
-				base = stringSchema(schema.format);
-				break;
-			case "integer":
-				base = z.number().int();
-				break;
-			case "number":
-				base = z.number();
-				break;
-			case "array":
-				if ("prefixItems" in schema) {
-					const tuple = z.tuple(schema.prefixItems.map(compile));
-					base = schema.items !== void 0 && schema.items !== false ? tuple.rest(compile(schema.items)) : tuple;
-				} else base = z.array(compile(schema.items));
-				break;
-			case "object": {
-				const required = new Set(schema.required ?? []);
-				const shape = {};
-				for (const [name, property] of Object.entries(schema.properties)) {
-					const validator = compile(property);
-					shape[name] = required.has(name) ? validator : validator.optional();
-				}
-				const object = z.object(shape);
-				if (schema.additionalProperties === false) base = object.strict();
-				else if (schema.additionalProperties === true) base = object.loose();
-				else base = object.catchall(compile(schema.additionalProperties));
-				break;
-			}
-		}
-		return base;
-	};
-	return { toZod(schema) {
-		assertSchemaReferences([schema], components);
-		return compile(schema);
-	} };
-}
-function isAnnotationOnlySchema(schema) {
-	return ![
-		"$ref",
-		"const",
-		"enum",
-		"anyOf",
-		"oneOf",
-		"type",
-		"properties",
-		"items",
-		"prefixItems",
-		"additionalProperties"
-	].some((key) => Object.hasOwn(schema, key));
-}
-function schemaToZod(schema, components = {}) {
-	return createSchemaToZod(components).toZod(schema);
-}
-function union$1(items) {
-	if (items.length === 0) return z.never();
-	if (items.length === 1) return items[0];
-	return z.union(items);
-}
-function valueSchema(expected) {
-	return z.unknown().refine((actual) => jsonValueEqual(actual, expected), { message: `Expected ${JSON.stringify(expected)}` });
-}
-function jsonValueEqual(actual, expected) {
-	if (Object.is(actual, expected)) return true;
-	if (Array.isArray(actual) && Array.isArray(expected)) return actual.length === expected.length && actual.every((value, index) => jsonValueEqual(value, expected[index]));
-	if (actual !== null && expected !== null && typeof actual === "object" && typeof expected === "object" && !Array.isArray(actual) && !Array.isArray(expected)) {
-		const actualRecord = actual;
-		const expectedRecord = expected;
-		const keys = Object.keys(actualRecord);
-		return keys.length === Object.keys(expectedRecord).length && keys.every((key) => Object.hasOwn(expectedRecord, key) && jsonValueEqual(actualRecord[key], expectedRecord[key]));
-	}
-	return false;
-}
-function stringSchema(format) {
-	switch (format) {
-		case "email": return z.email();
-		case "uri":
-		case "url": return z.url();
-		case "uuid": return z.uuid();
-		case "date-time": return z.iso.datetime();
-		default: return z.string();
-	}
-}
-//#endregion
 //#region src/connection/bareInterfaceTarget.ts
 /**
 * Bundle an interface definition with metadata-free foreign-protocol
@@ -566,13 +395,15 @@ var CodeWriter = class {
 * components receive explicit payload types; other types remain Zod-inferred.
 */
 function generateTsInterface(schema, options = {}) {
+	_validateErrors(schema.methods);
 	const linkRpcImport = options.linkRpcImport ?? "@hediet/linkrpc";
 	const exportName = options.exportName ?? _deriveExportName(schema.id);
 	const preserveWireSchema = options.preserveWireSchema ?? false;
 	if (options.bareTarget !== void 0) validateBarePrefix(options.bareTarget.prefix, "bareInterfaceTarget");
 	const w = new CodeWriter();
 	const bareTargetImport = options.bareTarget === void 0 ? "" : "bareInterfaceTarget, ";
-	const definitionImport = preserveWireSchema ? `${bareTargetImport}InterfaceDefinition, notificationType, requestType, type LinkRpcInterfaceSchema` : `${bareTargetImport}defineInterface, notificationType, requestType`;
+	const errorImport = Object.values(schema.methods).some((method) => (method.errors?.length ?? 0) > 0) ? "applicationError, " : "";
+	const definitionImport = preserveWireSchema ? `${errorImport}${bareTargetImport}InterfaceDefinition, notificationType, requestType, type LinkRpcInterfaceSchema` : `${errorImport}${bareTargetImport}defineInterface, notificationType, requestType`;
 	w.writeLine(`import { ${definitionImport} } from "${linkRpcImport}";`);
 	w.writeLine(`import { z } from "zod";`);
 	w.writeLine();
@@ -715,6 +546,20 @@ function _writeMethod(w, method, components, preserveWireSchema) {
 	}
 	w.dedent();
 	w.append(")");
+	if ((method.errors?.length ?? 0) > 0) {
+		w.append(".withErrors([").newline();
+		w.indent();
+		for (const error of method.errors) {
+			w.append(`applicationError(${error.code}, ${JSON.stringify(error.message)}`);
+			if (error.data !== void 0) {
+				w.append(", ");
+				_writeSchema(w, error.data, components, preserveWireSchema);
+			}
+			w.append("),").newline();
+		}
+		w.dedent();
+		w.append("] as const)");
+	}
 	if (method.clientStream !== void 0 || method.serverStream !== void 0) {
 		w.append(".withStream({").newline();
 		w.indent();
@@ -732,6 +577,19 @@ function _writeMethod(w, method, components, preserveWireSchema) {
 		w.append("})");
 	}
 }
+function _validateErrors(methods) {
+	for (const [name, method] of Object.entries(methods)) {
+		if (method.result === void 0 && method.errors !== void 0) throw new Error(`generateInterface: notification "${name}" cannot declare errors`);
+		const seen = /* @__PURE__ */ new Set();
+		for (const error of method.errors ?? []) {
+			if (typeof error.message !== "string") throw new Error(`generateInterface: error message on "${name}" is not a string`);
+			if (!Number.isInteger(error.code) || error.code < -2147483648 || error.code > 2147483647) throw new Error(`generateInterface: error code ${error.code} on "${name}" is not a signed i32`);
+			if (error.code >= -32768 && error.code <= -32e3 || error.code === -32800) throw new Error(`generateInterface: error code ${error.code} on "${name}" is reserved`);
+			if (seen.has(error.code)) throw new Error(`generateInterface: duplicate error code ${error.code} on "${name}"`);
+			seen.add(error.code);
+		}
+	}
+}
 function _collectMemberDocs(method) {
 	const docs = {};
 	if (method.description !== void 0) docs.description = method.description;
@@ -2178,12 +2036,16 @@ var Channel = class Channel {
 };
 var RpcError = class extends Error {
 	code;
+	origin;
 	data;
-	constructor(message, code, data) {
+	hasData;
+	constructor(message, code, data, origin = "local", hasData = data !== void 0) {
 		super(message);
 		this.code = code;
-		this.data = data;
+		this.origin = origin;
 		this.name = "RpcError";
+		this.hasData = hasData;
+		if (hasData) this.data = data;
 	}
 };
 //#endregion
@@ -3350,7 +3212,7 @@ var JsonRpcChannel = class JsonRpcChannel {
 			this._streamListeners.delete(key);
 			if ("error" in m) {
 				const e = m.error;
-				const err = new RpcError(e.message, e.code, e.data);
+				const err = new RpcError(e.message, e.code, e.data, "remote", Object.hasOwn(e, "data"));
 				pending.reject(err);
 			} else pending.resolve(m.result);
 			return;
@@ -4043,18 +3905,20 @@ var LinkRpcConnection = class LinkRpcConnection {
 						} : sendOpts;
 						this._validateOutboundParamsFor(member, wireMethod, params);
 						const call = this.channel.sendRequestWithStream(wireMethod, params, channelOpts);
-						const result = call.result.then((raw) => validateWireResult(member.resultSchema, raw, wireMethod));
-						return Object.assign(result, {
+						const checked = addCheckedResult(call.result.then((raw) => validateWireResult(member.resultSchema, raw, wireMethod)), member);
+						return Object.assign(checked, {
 							send: async (payload) => call.send(payload),
 							cancel: async (reason) => call.cancel(reason),
 							dispose: (reason) => call.dispose?.(reason),
 							ping: () => call.ping()
 						});
 					};
-				} else proxy[name] = async (params) => {
-					this._validateOutboundParamsFor(member, wireMethod, params);
-					const raw = await this.channel.sendRequest(wireMethod, params, sendOpts);
-					return validateWireResult(member.resultSchema, raw, wireMethod);
+				} else proxy[name] = (params) => {
+					return addCheckedResult((async () => {
+						this._validateOutboundParamsFor(member, wireMethod, params);
+						const raw = await this.channel.sendRequest(wireMethod, params, sendOpts);
+						return validateWireResult(member.resultSchema, raw, wireMethod);
+					})(), member);
 				};
 			} else {
 				const notify = (params) => {
@@ -4089,6 +3953,8 @@ var LinkRpcConnection = class LinkRpcConnection {
 		const stream = this._buildStreamApi(call.stream, call.signal, member);
 		try {
 			const result = await handler(parsedParams.data, call.context, stream);
+			const encodedError = encodeApplicationError(member, result);
+			if (encodedError !== void 0) return { error: encodedError };
 			validateValue(member.resultSchema, result, `Invalid result for ${call.method}`, ErrorCode.internalError);
 			return { result: result === void 0 ? null : result };
 		} catch (e) {
@@ -4273,6 +4139,102 @@ function directoryWatcherMatchesEntry(watcher, entry) {
 	const serviceId = entry.serviceId ?? "";
 	return (watcher.interfaceId === void 0 || watcher.interfaceId === entry.iface.info.id) && (watcher.interfaceIdPrefix === void 0 || entry.iface.info.id.startsWith(watcher.interfaceIdPrefix)) && (watcher.serviceId === void 0 || watcher.serviceId === serviceId) && serviceIdMatchesScopes(serviceId, watcher.serviceIdScopes);
 }
+function addCheckedResult(promise, member) {
+	return Object.assign(promise, { result: async () => {
+		try {
+			return {
+				ok: true,
+				value: await promise
+			};
+		} catch (cause) {
+			return {
+				ok: false,
+				error: decodeCheckedError(cause, member.applicationErrors)
+			};
+		}
+	} });
+}
+function decodeCheckedError(cause, descriptors) {
+	if (!(cause instanceof RpcError) || cause.origin !== "remote") return {
+		kind: "local",
+		cause
+	};
+	const descriptor = descriptors.find((candidate) => candidate.code === cause.code && candidate.message === cause.message);
+	if (descriptor !== void 0) {
+		if (descriptor.dataSchema === void 0 && !cause.hasData) return {
+			kind: "application",
+			code: descriptor.code,
+			message: descriptor.message
+		};
+		if (descriptor.dataSchema !== void 0 && cause.hasData && matchesApplicationData(descriptor.dataSchema, cause.data)) {
+			if (safeParse(descriptor.dataSchema, cause.data).success) return {
+				kind: "application",
+				code: descriptor.code,
+				message: descriptor.message,
+				data: cause.data
+			};
+		}
+	}
+	return {
+		kind: "remote",
+		code: cause.code,
+		message: cause.message,
+		...cause.hasData ? { data: cause.data } : {}
+	};
+}
+function encodeApplicationError(member, value) {
+	if (!isApplicationErrorValue(value)) return void 0;
+	const candidate = value;
+	const descriptor = member.applicationErrors.find((error) => error.code === candidate.code && error.message === candidate.message);
+	if (descriptor === void 0) throw new RpcError(`Undeclared application error ${String(candidate.code)}`, ErrorCode.internalError);
+	const hasData = Object.hasOwn(candidate, "data");
+	if (descriptor.dataSchema === void 0) {
+		if (hasData) throw new RpcError(`Application error ${descriptor.code} must not contain data`, ErrorCode.internalError);
+		return {
+			code: descriptor.code,
+			message: descriptor.message
+		};
+	}
+	if (!hasData) throw new RpcError(`Application error ${descriptor.code} requires data`, ErrorCode.internalError);
+	if (!matchesApplicationData(descriptor.dataSchema, candidate.data)) throw new RpcError(`Invalid data for application error ${descriptor.code}`, ErrorCode.internalError, { issues: [{ message: "Data must be JSON matching the declared wire schema" }] });
+	const parsed = safeParse(descriptor.dataSchema, candidate.data);
+	if (!parsed.success) throw new RpcError(`Invalid data for application error ${descriptor.code}`, ErrorCode.internalError, { issues: parsed.error.issues });
+	return {
+		code: descriptor.code,
+		message: descriptor.message,
+		data: candidate.data
+	};
+}
+/** Reject values JSON serialization would silently omit, coerce, or replace via toJSON. */
+function isWireJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object" || ancestors.has(value)) return false;
+	if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return false;
+	ancestors.add(value);
+	const children = Array.isArray(value) ? value.values() : Object.values(value);
+	for (const child of children) if (!isWireJsonValue(child, ancestors)) return false;
+	ancestors.delete(value);
+	return true;
+}
+const applicationDataSchemas = /* @__PURE__ */ new WeakMap();
+function matchesApplicationData(schema, value) {
+	if (!isWireJsonValue(value)) return false;
+	let wire = applicationDataSchemas.get(schema);
+	if (wire === void 0) {
+		const components = {};
+		wire = {
+			schema: zodToSvcJsonSchema(schema, {
+				methodName: "applicationError",
+				schemaPosition: "data",
+				components
+			}),
+			components
+		};
+		applicationDataSchemas.set(schema, wire);
+	}
+	return matchesJsonSchema(value, wire.schema, { schemas: wire.components });
+}
 function validateWireResult(schema, raw, wireMethod) {
 	const value = normalizeWireResult(schema, raw);
 	validateValue(schema, value, `Invalid result for ${wireMethod}`, ErrorCode.internalError);
@@ -7790,6 +7752,6 @@ async function createSeededSigningIdentity(opts) {
 	return KeypairSigningIdentity.fromKeypair(ed);
 }
 //#endregion
-export { walkHubDetailed as $, bareInterfaceTarget as $t, attachCapabilities as A, PRINCIPAL_PREFIX as At, LinkRpcConnection as B, isRequest as Bt, identityStorageInterface as C, getKeyId as Ct, PublicWrappingIdentity as D, signingInput as Dt, PublicSigningIdentity as E, signingDomainValue as Et, generateX25519Keypair as F, principalForPublicKey as Ft, fetchDirectory as G, StreamDir as Gt, JsonRpcChannel as H, STREAM_METHOD as Ht, formatEndpointUri as I, publicKeyForKeyId as It, intersectServiceIdScopes as J, directoryInterface as Jt, fetchSchema as K, streamInterface as Kt, isHubEndpoint as L, resolveSigningKey as Lt, verifyRpcCall as M, bytesToBase64Url as Mt, crypto_exports as N, keyIdForPrincipal as Nt, Principal as O, withSignature as Ot, generateKeypair as P, keyIdForPublicKey as Pt, walkHub as Q, generateTsInterface as Qt, parseEndpointUri as R, ErrorCode as Rt, identityInterface as S, LINKRPC_UNSIGNED_KEY as St, KeypairSigningIdentity as T, signedHash as Tt, DEFAULT_WALK_DEPTH as U, StreamControlReason as Ut, ServiceHandle as V, isResponse as Vt, HubDirectoryExplorer as W, StreamControlType as Wt, serviceIdMatchesPattern as X, schemasInterface as Xt, normalizeServiceIdScopes as Y, directoryWatchNever as Yt, serviceIdMatchesScopes as Z, zServiceIdPattern as Zt, InMemoryManagedIdentity as _, HUBRPC_META_KEY as _t, verifyCall as a, componentSchemaRef as an, TransportPair as at, registerIdentityOnOverlay as b, LINKRPC_META_KEY as bt, invoke as c, requireObjectParams as ct, prefix as d, parseMethodName as dt, createSchemaToZod as en, DEFAULT_RPC_TIMEOUT_MS as et, signCapability as f, capabilityPermits as ft, createManagedPrincipal as g, permissionPermits as gt, PrincipalWithStore as h, permissionMatchesTarget as ht, signParams as i, componentSchemaName as in, MultiplexedTransport as it, signRpcCall as j, base64UrlToBytes$1 as jt, CapBag as k, KEY_ID_PREFIX as kt, issueCapability as l, stripLinkRpcWireMeta as lt, SigningSender as m, matchParams as mt, createSeededMemoryPrincipal as n, materializeJsonSchema as nn, Channel as nt, capBagFreshAt as o, isAssignable as on, connectTransports as ot, OneShotCapStaging as p, hasSignedCapabilityShape as pt, findMethodInSchema as q, defaultsInterface as qt, createSeededSigningIdentity as r, assertSchemaReferences as rn, RpcError as rt, capabilityFreshAt as s, traceMessageTransport as st, createMemoryPrincipal as t, schemaToZod as tn, withRpcTimeout as tt, permits as u, methodNameToTarget as ut, InMemoryManagedIdentityStorage as v, HUBRPC_SIGNATURE_KEY as vt, KeypairIdentity as w, readSignature as wt, registerLazyIdentityOnOverlay as x, LINKRPC_SIGNATURE_KEY as xt, createManagedIdentity as y, HUBRPC_UNSIGNED_KEY as yt, ChannelConnector as z, isNotification as zt };
+export { walkHubDetailed as $, bareInterfaceTarget as $t, attachCapabilities as A, PRINCIPAL_PREFIX as At, LinkRpcConnection as B, isRequest as Bt, identityStorageInterface as C, getKeyId as Ct, PublicWrappingIdentity as D, signingInput as Dt, PublicSigningIdentity as E, signingDomainValue as Et, generateX25519Keypair as F, principalForPublicKey as Ft, fetchDirectory as G, StreamDir as Gt, JsonRpcChannel as H, STREAM_METHOD as Ht, formatEndpointUri as I, publicKeyForKeyId as It, intersectServiceIdScopes as J, directoryInterface as Jt, fetchSchema as K, streamInterface as Kt, isHubEndpoint as L, resolveSigningKey as Lt, verifyRpcCall as M, bytesToBase64Url as Mt, crypto_exports as N, keyIdForPrincipal as Nt, Principal as O, withSignature as Ot, generateKeypair as P, keyIdForPublicKey as Pt, walkHub as Q, generateTsInterface as Qt, parseEndpointUri as R, ErrorCode as Rt, identityInterface as S, LINKRPC_UNSIGNED_KEY as St, KeypairSigningIdentity as T, signedHash as Tt, DEFAULT_WALK_DEPTH as U, StreamControlReason as Ut, ServiceHandle as V, isResponse as Vt, HubDirectoryExplorer as W, StreamControlType as Wt, serviceIdMatchesPattern as X, schemasInterface as Xt, normalizeServiceIdScopes as Y, directoryWatchNever as Yt, serviceIdMatchesScopes as Z, zServiceIdPattern as Zt, InMemoryManagedIdentity as _, HUBRPC_META_KEY as _t, verifyCall as a, TransportPair as at, registerIdentityOnOverlay as b, LINKRPC_META_KEY as bt, invoke as c, requireObjectParams as ct, prefix as d, parseMethodName as dt, materializeJsonSchema as en, DEFAULT_RPC_TIMEOUT_MS as et, signCapability as f, capabilityPermits as ft, createManagedPrincipal as g, permissionPermits as gt, PrincipalWithStore as h, permissionMatchesTarget as ht, signParams as i, MultiplexedTransport as it, signRpcCall as j, base64UrlToBytes$1 as jt, CapBag as k, KEY_ID_PREFIX as kt, issueCapability as l, stripLinkRpcWireMeta as lt, SigningSender as m, matchParams as mt, createSeededMemoryPrincipal as n, matchesJsonSchema as nn, Channel as nt, capBagFreshAt as o, connectTransports as ot, OneShotCapStaging as p, hasSignedCapabilityShape as pt, findMethodInSchema as q, defaultsInterface as qt, createSeededSigningIdentity as r, RpcError as rt, capabilityFreshAt as s, traceMessageTransport as st, createMemoryPrincipal as t, isAssignable as tn, withRpcTimeout as tt, permits as u, methodNameToTarget as ut, InMemoryManagedIdentityStorage as v, HUBRPC_SIGNATURE_KEY as vt, KeypairIdentity as w, readSignature as wt, registerLazyIdentityOnOverlay as x, LINKRPC_SIGNATURE_KEY as xt, createManagedIdentity as y, HUBRPC_UNSIGNED_KEY as yt, ChannelConnector as z, isNotification as zt };
 
-//# sourceMappingURL=src-D3NUIwyo.js.map
+//# sourceMappingURL=src-CAhXne71.js.map