wire-mesh-core 1.45.2 → 1.46.0

package/dist/domain/webrtc-signaling.cjs

@@ -0,0 +1,107 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_tokens = require("../tokens-DxGVURpB.cjs");
+//#region src/domain/webrtc-signaling.ts
+/** The one capability verb gating every core/webrtc message shape: an authority over this node's own signaling as a whole, not three separate resources, mirroring how core/exec's exec:pty gates all of its own inner verbs. webrtc.sfu-track-map is gated by this same verb (see spec/webrtc.cddl's own comment): an SFU able to shape a negotiation can already misreport whose media is on which mid, so a separate capability over the track-map itself would guard nothing a client doesn't already have to trust the SFU for. */
+const WEBRTC_SIGNAL_VERB = "webrtc:signal";
+/** No path: there is no filesystem subtree involved in signaling, only the node itself. */
+const WEBRTC_SIGNAL_SCOPE = { kind: "node" };
+function isWebrtcOffer(params) {
+	return typeof params === "object" && "verb" in params && params.verb === "webrtc.offer";
+}
+function isWebrtcAnswer(params) {
+	return typeof params === "object" && "verb" in params && params.verb === "webrtc.answer";
+}
+function isWebrtcIceCandidate(params) {
+	return typeof params === "object" && "verb" in params && params.verb === "webrtc.ice-candidate";
+}
+function isSfuTrackMap(params) {
+	return typeof params === "object" && "verb" in params && params.verb === "webrtc.sfu-track-map";
+}
+function buildOfferCommand(negotiationId, sdp) {
+	return {
+		verb: WEBRTC_SIGNAL_VERB,
+		params: {
+			verb: "webrtc.offer",
+			"negotiation-id": negotiationId,
+			sdp
+		}
+	};
+}
+function buildAnswerCommand(negotiationId, sdp) {
+	return {
+		verb: WEBRTC_SIGNAL_VERB,
+		params: {
+			verb: "webrtc.answer",
+			"negotiation-id": negotiationId,
+			sdp
+		}
+	};
+}
+function buildIceCandidateCommand(negotiationId, candidate) {
+	return {
+		verb: WEBRTC_SIGNAL_VERB,
+		params: {
+			verb: "webrtc.ice-candidate",
+			"negotiation-id": negotiationId,
+			...candidate !== void 0 ? { candidate } : {}
+		}
+	};
+}
+/** Builds the manage-command an SFU sends to report which room member each SDP mid on a negotiation belongs to: sent once a negotiation completes (the initial track set) and again, as a full resend rather than an incremental diff, on every membership change. An empty tracks array is itself a valid, meaningful message (the call is now empty), not a degenerate case. */
+function buildSfuTrackMapCommand(negotiationId, tracks) {
+	return {
+		verb: WEBRTC_SIGNAL_VERB,
+		params: {
+			verb: "webrtc.sfu-track-map",
+			"negotiation-id": negotiationId,
+			tracks: [...tracks]
+		}
+	};
+}
+function wireIceCandidateFromRtc(candidate) {
+	return {
+		candidate: candidate.candidate,
+		...candidate.sdpMid !== null ? { "sdp-mid": candidate.sdpMid } : {},
+		...candidate.sdpMLineIndex !== null ? { "sdp-m-line-index": candidate.sdpMLineIndex } : {},
+		...candidate.usernameFragment !== null ? { "username-fragment": candidate.usernameFragment } : {}
+	};
+}
+function rtcIceCandidateInitFromWire(wire) {
+	return {
+		candidate: wire.candidate,
+		...wire["sdp-mid"] !== void 0 ? { sdpMid: wire["sdp-mid"] } : {},
+		...wire["sdp-m-line-index"] !== void 0 ? { sdpMLineIndex: wire["sdp-m-line-index"] } : {},
+		...wire["username-fragment"] !== void 0 ? { usernameFragment: wire["username-fragment"] } : {}
+	};
+}
+/** A fresh, independent, monotonically increasing negotiation-id source starting at 0, extracted as its own pure function so id allocation is testable without an RTCPeerConnection or any transport. */
+function createNegotiationIdAllocator() {
+	let next = 0;
+	return () => {
+		const id = next;
+		next += 1;
+		return id;
+	};
+}
+/** True when an incoming offer's own token authorizes webrtc:signal against this node's scope: verifyCapabilityToken checks the token's own internal validity and delegation chain; the capability/scope match against what is actually being invoked here is this caller's own responsibility, same as any other domain's request handler. expectedBearer is deliberately not checked: neither a browser client's MeshSession nor an SFU's own connection handling exposes a way to learn a peer's device-id independently of the token itself, unlike a scope with a path that constrains a specific resource. */
+async function authorizeIncomingOffer(incoming, options) {
+	if (incoming.token === void 0) return false;
+	const verdict = await require_tokens.verifyCapabilityToken(incoming.token, options);
+	if (!verdict.ok) return false;
+	return verdict.claims.capability === "webrtc:signal" && verdict.claims.scope.kind === WEBRTC_SIGNAL_SCOPE.kind;
+}
+//#endregion
+exports.WEBRTC_SIGNAL_SCOPE = WEBRTC_SIGNAL_SCOPE;
+exports.WEBRTC_SIGNAL_VERB = WEBRTC_SIGNAL_VERB;
+exports.authorizeIncomingOffer = authorizeIncomingOffer;
+exports.buildAnswerCommand = buildAnswerCommand;
+exports.buildIceCandidateCommand = buildIceCandidateCommand;
+exports.buildOfferCommand = buildOfferCommand;
+exports.buildSfuTrackMapCommand = buildSfuTrackMapCommand;
+exports.createNegotiationIdAllocator = createNegotiationIdAllocator;
+exports.isSfuTrackMap = isSfuTrackMap;
+exports.isWebrtcAnswer = isWebrtcAnswer;
+exports.isWebrtcIceCandidate = isWebrtcIceCandidate;
+exports.isWebrtcOffer = isWebrtcOffer;
+exports.rtcIceCandidateInitFromWire = rtcIceCandidateInitFromWire;
+exports.wireIceCandidateFromRtc = wireIceCandidateFromRtc;

package/dist/domain/webrtc-signaling.d.cts

@@ -0,0 +1,38 @@
+import { Bt as WebrtcAnswer, H as ManageCommandParams, Ht as WebrtcOffer, Mt as SfuTrackMap, V as ManageCommand, Vt as WebrtcIceCandidate, f as CapabilityScope, jt as SfuTrackEntry, z as IceCandidateInit } from "../protocol-D8CU6s2_.cjs";
+import { IncomingManageRequest } from "./mesh-session.cjs";
+import { u as VerifyCapabilityTokenOptions } from "../tokens-B1-MAIST.cjs";
+//#region src/domain/webrtc-signaling.d.ts
+/** The one capability verb gating every core/webrtc message shape: an authority over this node's own signaling as a whole, not three separate resources, mirroring how core/exec's exec:pty gates all of its own inner verbs. webrtc.sfu-track-map is gated by this same verb (see spec/webrtc.cddl's own comment): an SFU able to shape a negotiation can already misreport whose media is on which mid, so a separate capability over the track-map itself would guard nothing a client doesn't already have to trust the SFU for. */
+export declare const WEBRTC_SIGNAL_VERB = "webrtc:signal";
+/** No path: there is no filesystem subtree involved in signaling, only the node itself. */
+export declare const WEBRTC_SIGNAL_SCOPE: CapabilityScope;
+export declare function isWebrtcOffer(params: ManageCommandParams): params is WebrtcOffer;
+export declare function isWebrtcAnswer(params: ManageCommandParams): params is WebrtcAnswer;
+export declare function isWebrtcIceCandidate(params: ManageCommandParams): params is WebrtcIceCandidate;
+export declare function isSfuTrackMap(params: ManageCommandParams): params is SfuTrackMap;
+export declare function buildOfferCommand(negotiationId: number, sdp: string): ManageCommand;
+export declare function buildAnswerCommand(negotiationId: number, sdp: string): ManageCommand;
+export declare function buildIceCandidateCommand(negotiationId: number, candidate?: Readonly<IceCandidateInit>): ManageCommand;
+/** Builds the manage-command an SFU sends to report which room member each SDP mid on a negotiation belongs to: sent once a negotiation completes (the initial track set) and again, as a full resend rather than an incremental diff, on every membership change. An empty tracks array is itself a valid, meaningful message (the call is now empty), not a degenerate case. */
+export declare function buildSfuTrackMapCommand(negotiationId: number, tracks: readonly SfuTrackEntry[]): ManageCommand;
+/** The subset of RTCIceCandidate's own fields this module actually reads: a real RTCIceCandidate satisfies this structurally, and so does a plain test object or a server-side candidate description, with no cast needed either way. */
+export type MinimalRtcIceCandidate = Readonly<{
+  candidate: string;
+  sdpMid: string | null;
+  sdpMLineIndex: number | null;
+  usernameFragment: string | null;
+}>;
+export declare function wireIceCandidateFromRtc(candidate: MinimalRtcIceCandidate): IceCandidateInit;
+/** The subset of RTCIceCandidateInit's own shape this module produces: structurally identical to the DOM lib's own type (candidate, sdpMid, sdpMLineIndex, usernameFragment, each optional), so a caller in an environment with the DOM lib available (web-console) can pass this straight to RTCPeerConnection.addIceCandidate() with no cast, while core itself stays free of any DOM lib dependency. */
+export interface WireRtcIceCandidateInit {
+  candidate?: string;
+  sdpMid?: string;
+  sdpMLineIndex?: number;
+  usernameFragment?: string;
+}
+export declare function rtcIceCandidateInitFromWire(wire: Readonly<IceCandidateInit>): WireRtcIceCandidateInit;
+/** A fresh, independent, monotonically increasing negotiation-id source starting at 0, extracted as its own pure function so id allocation is testable without an RTCPeerConnection or any transport. */
+export declare function createNegotiationIdAllocator(): () => number;
+/** True when an incoming offer's own token authorizes webrtc:signal against this node's scope: verifyCapabilityToken checks the token's own internal validity and delegation chain; the capability/scope match against what is actually being invoked here is this caller's own responsibility, same as any other domain's request handler. expectedBearer is deliberately not checked: neither a browser client's MeshSession nor an SFU's own connection handling exposes a way to learn a peer's device-id independently of the token itself, unlike a scope with a path that constrains a specific resource. */
+export declare function authorizeIncomingOffer(incoming: Readonly<IncomingManageRequest>, options: Readonly<VerifyCapabilityTokenOptions>): Promise<boolean>;
+//#endregion

package/dist/domain/webrtc-signaling.d.mts

@@ -0,0 +1,38 @@
+import { Bt as WebrtcAnswer, H as ManageCommandParams, Ht as WebrtcOffer, Mt as SfuTrackMap, V as ManageCommand, Vt as WebrtcIceCandidate, f as CapabilityScope, jt as SfuTrackEntry, z as IceCandidateInit } from "../protocol-D8CU6s2_.mjs";
+import { IncomingManageRequest } from "./mesh-session.mjs";
+import { u as VerifyCapabilityTokenOptions } from "../tokens-Bh82oidM.mjs";
+//#region src/domain/webrtc-signaling.d.ts
+/** The one capability verb gating every core/webrtc message shape: an authority over this node's own signaling as a whole, not three separate resources, mirroring how core/exec's exec:pty gates all of its own inner verbs. webrtc.sfu-track-map is gated by this same verb (see spec/webrtc.cddl's own comment): an SFU able to shape a negotiation can already misreport whose media is on which mid, so a separate capability over the track-map itself would guard nothing a client doesn't already have to trust the SFU for. */
+export declare const WEBRTC_SIGNAL_VERB = "webrtc:signal";
+/** No path: there is no filesystem subtree involved in signaling, only the node itself. */
+export declare const WEBRTC_SIGNAL_SCOPE: CapabilityScope;
+export declare function isWebrtcOffer(params: ManageCommandParams): params is WebrtcOffer;
+export declare function isWebrtcAnswer(params: ManageCommandParams): params is WebrtcAnswer;
+export declare function isWebrtcIceCandidate(params: ManageCommandParams): params is WebrtcIceCandidate;
+export declare function isSfuTrackMap(params: ManageCommandParams): params is SfuTrackMap;
+export declare function buildOfferCommand(negotiationId: number, sdp: string): ManageCommand;
+export declare function buildAnswerCommand(negotiationId: number, sdp: string): ManageCommand;
+export declare function buildIceCandidateCommand(negotiationId: number, candidate?: Readonly<IceCandidateInit>): ManageCommand;
+/** Builds the manage-command an SFU sends to report which room member each SDP mid on a negotiation belongs to: sent once a negotiation completes (the initial track set) and again, as a full resend rather than an incremental diff, on every membership change. An empty tracks array is itself a valid, meaningful message (the call is now empty), not a degenerate case. */
+export declare function buildSfuTrackMapCommand(negotiationId: number, tracks: readonly SfuTrackEntry[]): ManageCommand;
+/** The subset of RTCIceCandidate's own fields this module actually reads: a real RTCIceCandidate satisfies this structurally, and so does a plain test object or a server-side candidate description, with no cast needed either way. */
+export type MinimalRtcIceCandidate = Readonly<{
+  candidate: string;
+  sdpMid: string | null;
+  sdpMLineIndex: number | null;
+  usernameFragment: string | null;
+}>;
+export declare function wireIceCandidateFromRtc(candidate: MinimalRtcIceCandidate): IceCandidateInit;
+/** The subset of RTCIceCandidateInit's own shape this module produces: structurally identical to the DOM lib's own type (candidate, sdpMid, sdpMLineIndex, usernameFragment, each optional), so a caller in an environment with the DOM lib available (web-console) can pass this straight to RTCPeerConnection.addIceCandidate() with no cast, while core itself stays free of any DOM lib dependency. */
+export interface WireRtcIceCandidateInit {
+  candidate?: string;
+  sdpMid?: string;
+  sdpMLineIndex?: number;
+  usernameFragment?: string;
+}
+export declare function rtcIceCandidateInitFromWire(wire: Readonly<IceCandidateInit>): WireRtcIceCandidateInit;
+/** A fresh, independent, monotonically increasing negotiation-id source starting at 0, extracted as its own pure function so id allocation is testable without an RTCPeerConnection or any transport. */
+export declare function createNegotiationIdAllocator(): () => number;
+/** True when an incoming offer's own token authorizes webrtc:signal against this node's scope: verifyCapabilityToken checks the token's own internal validity and delegation chain; the capability/scope match against what is actually being invoked here is this caller's own responsibility, same as any other domain's request handler. expectedBearer is deliberately not checked: neither a browser client's MeshSession nor an SFU's own connection handling exposes a way to learn a peer's device-id independently of the token itself, unlike a scope with a path that constrains a specific resource. */
+export declare function authorizeIncomingOffer(incoming: Readonly<IncomingManageRequest>, options: Readonly<VerifyCapabilityTokenOptions>): Promise<boolean>;
+//#endregion

package/dist/domain/webrtc-signaling.mjs

@@ -0,0 +1,93 @@
+import { i as verifyCapabilityToken } from "../tokens-CdQwzCyJ.mjs";
+//#region src/domain/webrtc-signaling.ts
+/** The one capability verb gating every core/webrtc message shape: an authority over this node's own signaling as a whole, not three separate resources, mirroring how core/exec's exec:pty gates all of its own inner verbs. webrtc.sfu-track-map is gated by this same verb (see spec/webrtc.cddl's own comment): an SFU able to shape a negotiation can already misreport whose media is on which mid, so a separate capability over the track-map itself would guard nothing a client doesn't already have to trust the SFU for. */
+const WEBRTC_SIGNAL_VERB = "webrtc:signal";
+/** No path: there is no filesystem subtree involved in signaling, only the node itself. */
+const WEBRTC_SIGNAL_SCOPE = { kind: "node" };
+function isWebrtcOffer(params) {
+	return typeof params === "object" && "verb" in params && params.verb === "webrtc.offer";
+}
+function isWebrtcAnswer(params) {
+	return typeof params === "object" && "verb" in params && params.verb === "webrtc.answer";
+}
+function isWebrtcIceCandidate(params) {
+	return typeof params === "object" && "verb" in params && params.verb === "webrtc.ice-candidate";
+}
+function isSfuTrackMap(params) {
+	return typeof params === "object" && "verb" in params && params.verb === "webrtc.sfu-track-map";
+}
+function buildOfferCommand(negotiationId, sdp) {
+	return {
+		verb: WEBRTC_SIGNAL_VERB,
+		params: {
+			verb: "webrtc.offer",
+			"negotiation-id": negotiationId,
+			sdp
+		}
+	};
+}
+function buildAnswerCommand(negotiationId, sdp) {
+	return {
+		verb: WEBRTC_SIGNAL_VERB,
+		params: {
+			verb: "webrtc.answer",
+			"negotiation-id": negotiationId,
+			sdp
+		}
+	};
+}
+function buildIceCandidateCommand(negotiationId, candidate) {
+	return {
+		verb: WEBRTC_SIGNAL_VERB,
+		params: {
+			verb: "webrtc.ice-candidate",
+			"negotiation-id": negotiationId,
+			...candidate !== void 0 ? { candidate } : {}
+		}
+	};
+}
+/** Builds the manage-command an SFU sends to report which room member each SDP mid on a negotiation belongs to: sent once a negotiation completes (the initial track set) and again, as a full resend rather than an incremental diff, on every membership change. An empty tracks array is itself a valid, meaningful message (the call is now empty), not a degenerate case. */
+function buildSfuTrackMapCommand(negotiationId, tracks) {
+	return {
+		verb: WEBRTC_SIGNAL_VERB,
+		params: {
+			verb: "webrtc.sfu-track-map",
+			"negotiation-id": negotiationId,
+			tracks: [...tracks]
+		}
+	};
+}
+function wireIceCandidateFromRtc(candidate) {
+	return {
+		candidate: candidate.candidate,
+		...candidate.sdpMid !== null ? { "sdp-mid": candidate.sdpMid } : {},
+		...candidate.sdpMLineIndex !== null ? { "sdp-m-line-index": candidate.sdpMLineIndex } : {},
+		...candidate.usernameFragment !== null ? { "username-fragment": candidate.usernameFragment } : {}
+	};
+}
+function rtcIceCandidateInitFromWire(wire) {
+	return {
+		candidate: wire.candidate,
+		...wire["sdp-mid"] !== void 0 ? { sdpMid: wire["sdp-mid"] } : {},
+		...wire["sdp-m-line-index"] !== void 0 ? { sdpMLineIndex: wire["sdp-m-line-index"] } : {},
+		...wire["username-fragment"] !== void 0 ? { usernameFragment: wire["username-fragment"] } : {}
+	};
+}
+/** A fresh, independent, monotonically increasing negotiation-id source starting at 0, extracted as its own pure function so id allocation is testable without an RTCPeerConnection or any transport. */
+function createNegotiationIdAllocator() {
+	let next = 0;
+	return () => {
+		const id = next;
+		next += 1;
+		return id;
+	};
+}
+/** True when an incoming offer's own token authorizes webrtc:signal against this node's scope: verifyCapabilityToken checks the token's own internal validity and delegation chain; the capability/scope match against what is actually being invoked here is this caller's own responsibility, same as any other domain's request handler. expectedBearer is deliberately not checked: neither a browser client's MeshSession nor an SFU's own connection handling exposes a way to learn a peer's device-id independently of the token itself, unlike a scope with a path that constrains a specific resource. */
+async function authorizeIncomingOffer(incoming, options) {
+	if (incoming.token === void 0) return false;
+	const verdict = await verifyCapabilityToken(incoming.token, options);
+	if (!verdict.ok) return false;
+	return verdict.claims.capability === "webrtc:signal" && verdict.claims.scope.kind === WEBRTC_SIGNAL_SCOPE.kind;
+}
+//#endregion
+export { WEBRTC_SIGNAL_SCOPE, WEBRTC_SIGNAL_VERB, authorizeIncomingOffer, buildAnswerCommand, buildIceCandidateCommand, buildOfferCommand, buildSfuTrackMapCommand, createNegotiationIdAllocator, isSfuTrackMap, isWebrtcAnswer, isWebrtcIceCandidate, isWebrtcOffer, rtcIceCandidateInitFromWire, wireIceCandidateFromRtc };

package/dist/generated/protocol.cjs

@@ -48,7 +48,8 @@ const manageCommandParamsSchema = zod.z.lazy(() => zod.z.union([
 	zod.z.union([
 		zod.z.lazy(() => webrtcOfferSchema),
 		zod.z.lazy(() => webrtcAnswerSchema),
-		zod.z.lazy(() => webrtcIceCandidateSchema)
+		zod.z.lazy(() => webrtcIceCandidateSchema),
+		zod.z.lazy(() => sfuTrackMapSchema)
 	])
 ]));
 const bulkDataFrameSchema = zod.z.lazy(() => zod.z.object({
@@ -427,6 +428,16 @@ const coordinatorFrameSchema = zod.z.lazy(() => zod.z.object({
 	"coordinator": zod.z.lazy(() => deviceIdSchema),
 	"capacity-hint": zod.z.number().int().nonnegative().optional()
 }));
+const sfuTrackMapSchema = zod.z.lazy(() => zod.z.object({
+	"verb": zod.z.literal("webrtc.sfu-track-map"),
+	"negotiation-id": zod.z.number().int().nonnegative(),
+	"tracks": zod.z.array(zod.z.lazy(() => sfuTrackEntrySchema))
+}));
+const sfuTrackEntrySchema = zod.z.lazy(() => zod.z.object({
+	"mid": zod.z.string(),
+	"member": zod.z.lazy(() => deviceIdSchema),
+	"kind": zod.z.union([zod.z.literal("audio"), zod.z.literal("video")])
+}));
 const webrtcOfferSchema = zod.z.lazy(() => zod.z.object({
 	"verb": zod.z.literal("webrtc.offer"),
 	"negotiation-id": zod.z.number().int().nonnegative(),
@@ -533,6 +544,8 @@ exports.roomPathSchema = roomPathSchema;
 exports.roomReadSchema = roomReadSchema;
 exports.roomRekeySchema = roomRekeySchema;
 exports.roomSendSchema = roomSendSchema;
+exports.sfuTrackEntrySchema = sfuTrackEntrySchema;
+exports.sfuTrackMapSchema = sfuTrackMapSchema;
 exports.streamAckFrameSchema = streamAckFrameSchema;
 exports.streamDataFrameSchema = streamDataFrameSchema;
 exports.streamEndFrameSchema = streamEndFrameSchema;

package/dist/generated/protocol.d.cts

@@ -1,2 +1,2 @@
-import { $ as PeerIdentity, $n as relayDataFrameSchema, $t as capabilityScopeSchema, A as DomainId, An as manageErrorSchema, At as RoomSend, B as IdentityKey, Bn as peerIdentitySchema, Bt as WebrtcOffer, C as CoseTokenHeaders, Cn as handleClaimsSchema, Cr as tokenClaimsSchema, Ct as RoomMembers, D as DeviceId, Dn as identityKeySchema, Dr as webrtcOfferSchema, Dt as RoomPath, E as DataRequestFrame, En as iceCandidateInitSchema, Er as webrtcIceCandidateSchema, Et as RoomNoticeClaims, F as GossipFrame, Fn as namespacedCapabilitySchema, Ft as SyncPunchFrame, G as ManageRequestFrame, Gn as procSignalSchema, Gt as bulkEndFrameSchema, H as ManageCommandParams, Hn as privateUseCapabilitySchema, Ht as bulkAckFrameSchema, I as HandleClaims, In as namespacedDomainIdSchema, It as TokenClaims, J as NamespacedCapability, Jn as ptyKillSchema, Jt as candidateKindSchema, K as ManageResponseFrame, Kn as procSpawnSchema, Kt as bulkOpenSchema, L as HandleRecord, Ln as observedAddressFrameSchema, Lt as TransferId, M as ExecSessionInfo, Mn as manageRequestFrameSchema, Mt as StreamDataFrame, N as Frame, Nn as manageResponseFrameSchema, Nt as StreamEndFrame, O as DeviceIdHex, On as manageCommandParamsSchema, Or as wireCandidateSchema, Ot as RoomRead, P as FrameVariant, Pn as messageRefSchema, Pt as StreamSession, Q as PeerAdvert, Qn as relayConnectFrameSchema, Qt as capabilityRequestSchema, R as HandshakeFrame, Rn as ownerNamedRoomPathSchema, Rt as WebrtcAnswer, S as CoseSign1, Sn as gossipFrameSchema, Sr as syncPunchFrameSchema, St as RoomMember, T as DataHaveFrame, Tn as handshakeFrameSchema, Tr as webrtcAnswerSchema, Tt as RoomNotice, U as ManageError, Un as privateUseDomainIdSchema, Ut as bulkCancelSchema, V as ManageCommand, Vn as pingFrameSchema, Vt as WireCandidate, W as ManageOk, Wn as procKillSchema, Wt as bulkDataFrameSchema, X as ObservedAddressFrame, Xn as ptySpawnSchema, Xt as capabilityGrantOkSchema, Y as NamespacedDomainId, Yn as ptyResizeSchema, Yt as candidatesFrameSchema, Z as OwnerNamedRoomPath, Zn as ptyWriteSchema, Zt as capabilityGrantSchema, _ as CoreCapability, _n as domainIdSchema, _r as roomSendSchema, _t as RevocationEntry, a as BulkOpen, an as coreDomainNameSchema, ar as roomInviteSchema, at as ProcSpawn, b as CoseHeaderKid, bn as frameSchema, br as streamEndFrameSchema, bt as RoomJoinOk, c as CandidatesFrame, cn as coseHeaderLabelSchema, cr as roomLeaveSchema, ct as PtyResize, d as CapabilityRequest, dn as dataEntriesFrameSchema, dr as roomMembersSchema, dt as RelayConnectFrame, en as capabilityTokenSchema, er as relayInboundFrameSchema, et as PingFrame, f as CapabilityScope, fn as dataHaveFrameSchema, fr as roomNoticeClaimsSchema, ft as RelayDataFrame, g as CoordinatorFrame, gn as dmRoomPathSchema, gr as roomRekeySchema, gt as RevocationClaims, h as CloseFrame, hn as deviceIdSchema, hr as roomReadSchema, ht as RevocationAnnounceFrame, i as BulkEndFrame, in as coreCapabilitySchema, ir as revocationEntrySchema, it as ProcSignal, j as ExecList, jn as manageOkSchema, jt as StreamAckFrame, k as DmRoomPath, kn as manageCommandSchema, kt as RoomRekey, l as CapabilityGrant, ln as coseSign1Schema, lr as roomMemberSchema, lt as PtySpawn, m as CapabilityVerb, mn as deviceIdHexSchema, mr as roomPathSchema, mt as RelayOfferFrame, n as BulkCancel, nn as closeFrameSchema, nr as revocationAnnounceFrameSchema, nt as PrivateUseDomainId, o as BulkResume, on as coseHeaderAlgSchema, or as roomJoinOkSchema, ot as ProtocolVersion, p as CapabilityToken, pn as dataRequestFrameSchema, pr as roomNoticeSchema, pt as RelayInboundFrame, q as MessageRef, qn as protocolVersionSchema, qt as bulkResumeSchema, r as BulkDataFrame, rn as coordinatorFrameSchema, rr as revocationClaimsSchema, rt as ProcKill, s as CandidateKind, sn as coseHeaderKidSchema, sr as roomJoinSchema, st as PtyKill, t as BulkAckFrame, tn as capabilityVerbSchema, tr as relayOfferFrameSchema, tt as PrivateUseCapability, u as CapabilityGrantOk, un as coseTokenHeadersSchema, ur as roomMembersOkSchema, ut as PtyWrite, v as CoreDomainName, vn as execListSchema, vr as streamAckFrameSchema, vt as RoomInvite, w as DataEntriesFrame, wn as handleRecordSchema, wr as transferIdSchema, wt as RoomMembersOk, x as CoseHeaderLabel, xn as frameVariantSchema, xr as streamSessionSchema, xt as RoomLeave, y as CoseHeaderAlg, yn as execSessionInfoSchema, yr as streamDataFrameSchema, yt as RoomJoin, z as IceCandidateInit, zn as peerAdvertSchema, zt as WebrtcIceCandidate } from "../protocol-gbXtNeOc.cjs";
-export { BulkAckFrame, BulkCancel, BulkDataFrame, BulkEndFrame, BulkOpen, BulkResume, CandidateKind, CandidatesFrame, CapabilityGrant, CapabilityGrantOk, CapabilityRequest, CapabilityScope, CapabilityToken, CapabilityVerb, CloseFrame, CoordinatorFrame, CoreCapability, CoreDomainName, CoseHeaderAlg, CoseHeaderKid, CoseHeaderLabel, CoseSign1, CoseTokenHeaders, DataEntriesFrame, DataHaveFrame, DataRequestFrame, DeviceId, DeviceIdHex, DmRoomPath, DomainId, ExecList, ExecSessionInfo, Frame, FrameVariant, GossipFrame, HandleClaims, HandleRecord, HandshakeFrame, IceCandidateInit, IdentityKey, ManageCommand, ManageCommandParams, ManageError, ManageOk, ManageRequestFrame, ManageResponseFrame, MessageRef, NamespacedCapability, NamespacedDomainId, ObservedAddressFrame, OwnerNamedRoomPath, PeerAdvert, PeerIdentity, PingFrame, PrivateUseCapability, PrivateUseDomainId, ProcKill, ProcSignal, ProcSpawn, ProtocolVersion, PtyKill, PtyResize, PtySpawn, PtyWrite, RelayConnectFrame, RelayDataFrame, RelayInboundFrame, RelayOfferFrame, RevocationAnnounceFrame, RevocationClaims, RevocationEntry, RoomInvite, RoomJoin, RoomJoinOk, RoomLeave, RoomMember, RoomMembers, RoomMembersOk, RoomNotice, RoomNoticeClaims, RoomPath, RoomRead, RoomRekey, RoomSend, StreamAckFrame, StreamDataFrame, StreamEndFrame, StreamSession, SyncPunchFrame, TokenClaims, TransferId, WebrtcAnswer, WebrtcIceCandidate, WebrtcOffer, WireCandidate, bulkAckFrameSchema, bulkCancelSchema, bulkDataFrameSchema, bulkEndFrameSchema, bulkOpenSchema, bulkResumeSchema, candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityGrantSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomRekeySchema, roomSendSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, transferIdSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };
+import { $ as PeerIdentity, $n as ptyWriteSchema, $t as capabilityGrantSchema, A as DomainId, An as manageCommandParamsSchema, Ar as webrtcIceCandidateSchema, At as RoomSend, B as IdentityKey, Bn as ownerNamedRoomPathSchema, Bt as WebrtcAnswer, C as CoseTokenHeaders, Cn as frameVariantSchema, Cr as streamDataFrameSchema, Ct as RoomMembers, D as DeviceId, Dn as handshakeFrameSchema, Dr as tokenClaimsSchema, Dt as RoomPath, E as DataRequestFrame, En as handleRecordSchema, Er as syncPunchFrameSchema, Et as RoomNoticeClaims, F as GossipFrame, Fn as manageResponseFrameSchema, Ft as StreamEndFrame, G as ManageRequestFrame, Gn as privateUseDomainIdSchema, Gt as bulkCancelSchema, H as ManageCommandParams, Hn as peerIdentitySchema, Ht as WebrtcOffer, I as HandleClaims, In as messageRefSchema, It as StreamSession, J as NamespacedCapability, Jn as procSpawnSchema, Jt as bulkOpenSchema, K as ManageResponseFrame, Kn as procKillSchema, Kt as bulkDataFrameSchema, L as HandleRecord, Ln as namespacedCapabilitySchema, Lt as SyncPunchFrame, M as ExecSessionInfo, Mn as manageErrorSchema, Mr as wireCandidateSchema, Mt as SfuTrackMap, N as Frame, Nn as manageOkSchema, Nt as StreamAckFrame, O as DeviceIdHex, On as iceCandidateInitSchema, Or as transferIdSchema, Ot as RoomRead, P as FrameVariant, Pn as manageRequestFrameSchema, Pt as StreamDataFrame, Q as PeerAdvert, Qn as ptySpawnSchema, Qt as capabilityGrantOkSchema, R as HandshakeFrame, Rn as namespacedDomainIdSchema, Rt as TokenClaims, S as CoseSign1, Sn as frameSchema, Sr as streamAckFrameSchema, St as RoomMember, T as DataHaveFrame, Tn as handleClaimsSchema, Tr as streamSessionSchema, Tt as RoomNotice, U as ManageError, Un as pingFrameSchema, Ut as WireCandidate, V as ManageCommand, Vn as peerAdvertSchema, Vt as WebrtcIceCandidate, W as ManageOk, Wn as privateUseCapabilitySchema, Wt as bulkAckFrameSchema, X as ObservedAddressFrame, Xn as ptyKillSchema, Xt as candidateKindSchema, Y as NamespacedDomainId, Yn as protocolVersionSchema, Yt as bulkResumeSchema, Z as OwnerNamedRoomPath, Zn as ptyResizeSchema, Zt as candidatesFrameSchema, _ as CoreCapability, _n as deviceIdSchema, _r as roomReadSchema, _t as RevocationEntry, a as BulkOpen, an as coordinatorFrameSchema, ar as revocationClaimsSchema, at as ProcSpawn, b as CoseHeaderKid, bn as execListSchema, br as sfuTrackEntrySchema, bt as RoomJoinOk, c as CandidatesFrame, cn as coseHeaderAlgSchema, cr as roomJoinOkSchema, ct as PtyResize, d as CapabilityRequest, dn as coseSign1Schema, dr as roomMemberSchema, dt as RelayConnectFrame, en as capabilityRequestSchema, er as relayConnectFrameSchema, et as PingFrame, f as CapabilityScope, fn as coseTokenHeadersSchema, fr as roomMembersOkSchema, ft as RelayDataFrame, g as CoordinatorFrame, gn as deviceIdHexSchema, gr as roomPathSchema, gt as RevocationClaims, h as CloseFrame, hn as dataRequestFrameSchema, hr as roomNoticeSchema, ht as RevocationAnnounceFrame, i as BulkEndFrame, in as closeFrameSchema, ir as revocationAnnounceFrameSchema, it as ProcSignal, j as ExecList, jn as manageCommandSchema, jr as webrtcOfferSchema, jt as SfuTrackEntry, k as DmRoomPath, kn as identityKeySchema, kr as webrtcAnswerSchema, kt as RoomRekey, l as CapabilityGrant, ln as coseHeaderKidSchema, lr as roomJoinSchema, lt as PtySpawn, m as CapabilityVerb, mn as dataHaveFrameSchema, mr as roomNoticeClaimsSchema, mt as RelayOfferFrame, n as BulkCancel, nn as capabilityTokenSchema, nr as relayInboundFrameSchema, nt as PrivateUseDomainId, o as BulkResume, on as coreCapabilitySchema, or as revocationEntrySchema, ot as ProtocolVersion, p as CapabilityToken, pn as dataEntriesFrameSchema, pr as roomMembersSchema, pt as RelayInboundFrame, q as MessageRef, qn as procSignalSchema, qt as bulkEndFrameSchema, r as BulkDataFrame, rn as capabilityVerbSchema, rr as relayOfferFrameSchema, rt as ProcKill, s as CandidateKind, sn as coreDomainNameSchema, sr as roomInviteSchema, st as PtyKill, t as BulkAckFrame, tn as capabilityScopeSchema, tr as relayDataFrameSchema, tt as PrivateUseCapability, u as CapabilityGrantOk, un as coseHeaderLabelSchema, ur as roomLeaveSchema, ut as PtyWrite, v as CoreDomainName, vn as dmRoomPathSchema, vr as roomRekeySchema, vt as RoomInvite, w as DataEntriesFrame, wn as gossipFrameSchema, wr as streamEndFrameSchema, wt as RoomMembersOk, x as CoseHeaderLabel, xn as execSessionInfoSchema, xr as sfuTrackMapSchema, xt as RoomLeave, y as CoseHeaderAlg, yn as domainIdSchema, yr as roomSendSchema, yt as RoomJoin, z as IceCandidateInit, zn as observedAddressFrameSchema, zt as TransferId } from "../protocol-D8CU6s2_.cjs";
+export { BulkAckFrame, BulkCancel, BulkDataFrame, BulkEndFrame, BulkOpen, BulkResume, CandidateKind, CandidatesFrame, CapabilityGrant, CapabilityGrantOk, CapabilityRequest, CapabilityScope, CapabilityToken, CapabilityVerb, CloseFrame, CoordinatorFrame, CoreCapability, CoreDomainName, CoseHeaderAlg, CoseHeaderKid, CoseHeaderLabel, CoseSign1, CoseTokenHeaders, DataEntriesFrame, DataHaveFrame, DataRequestFrame, DeviceId, DeviceIdHex, DmRoomPath, DomainId, ExecList, ExecSessionInfo, Frame, FrameVariant, GossipFrame, HandleClaims, HandleRecord, HandshakeFrame, IceCandidateInit, IdentityKey, ManageCommand, ManageCommandParams, ManageError, ManageOk, ManageRequestFrame, ManageResponseFrame, MessageRef, NamespacedCapability, NamespacedDomainId, ObservedAddressFrame, OwnerNamedRoomPath, PeerAdvert, PeerIdentity, PingFrame, PrivateUseCapability, PrivateUseDomainId, ProcKill, ProcSignal, ProcSpawn, ProtocolVersion, PtyKill, PtyResize, PtySpawn, PtyWrite, RelayConnectFrame, RelayDataFrame, RelayInboundFrame, RelayOfferFrame, RevocationAnnounceFrame, RevocationClaims, RevocationEntry, RoomInvite, RoomJoin, RoomJoinOk, RoomLeave, RoomMember, RoomMembers, RoomMembersOk, RoomNotice, RoomNoticeClaims, RoomPath, RoomRead, RoomRekey, RoomSend, SfuTrackEntry, SfuTrackMap, StreamAckFrame, StreamDataFrame, StreamEndFrame, StreamSession, SyncPunchFrame, TokenClaims, TransferId, WebrtcAnswer, WebrtcIceCandidate, WebrtcOffer, WireCandidate, bulkAckFrameSchema, bulkCancelSchema, bulkDataFrameSchema, bulkEndFrameSchema, bulkOpenSchema, bulkResumeSchema, candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityGrantSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomRekeySchema, roomSendSchema, sfuTrackEntrySchema, sfuTrackMapSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, transferIdSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };

package/dist/generated/protocol.d.mts

@@ -1,2 +1,2 @@
-import { $ as PeerIdentity, $n as relayDataFrameSchema, $t as capabilityScopeSchema, A as DomainId, An as manageErrorSchema, At as RoomSend, B as IdentityKey, Bn as peerIdentitySchema, Bt as WebrtcOffer, C as CoseTokenHeaders, Cn as handleClaimsSchema, Cr as tokenClaimsSchema, Ct as RoomMembers, D as DeviceId, Dn as identityKeySchema, Dr as webrtcOfferSchema, Dt as RoomPath, E as DataRequestFrame, En as iceCandidateInitSchema, Er as webrtcIceCandidateSchema, Et as RoomNoticeClaims, F as GossipFrame, Fn as namespacedCapabilitySchema, Ft as SyncPunchFrame, G as ManageRequestFrame, Gn as procSignalSchema, Gt as bulkEndFrameSchema, H as ManageCommandParams, Hn as privateUseCapabilitySchema, Ht as bulkAckFrameSchema, I as HandleClaims, In as namespacedDomainIdSchema, It as TokenClaims, J as NamespacedCapability, Jn as ptyKillSchema, Jt as candidateKindSchema, K as ManageResponseFrame, Kn as procSpawnSchema, Kt as bulkOpenSchema, L as HandleRecord, Ln as observedAddressFrameSchema, Lt as TransferId, M as ExecSessionInfo, Mn as manageRequestFrameSchema, Mt as StreamDataFrame, N as Frame, Nn as manageResponseFrameSchema, Nt as StreamEndFrame, O as DeviceIdHex, On as manageCommandParamsSchema, Or as wireCandidateSchema, Ot as RoomRead, P as FrameVariant, Pn as messageRefSchema, Pt as StreamSession, Q as PeerAdvert, Qn as relayConnectFrameSchema, Qt as capabilityRequestSchema, R as HandshakeFrame, Rn as ownerNamedRoomPathSchema, Rt as WebrtcAnswer, S as CoseSign1, Sn as gossipFrameSchema, Sr as syncPunchFrameSchema, St as RoomMember, T as DataHaveFrame, Tn as handshakeFrameSchema, Tr as webrtcAnswerSchema, Tt as RoomNotice, U as ManageError, Un as privateUseDomainIdSchema, Ut as bulkCancelSchema, V as ManageCommand, Vn as pingFrameSchema, Vt as WireCandidate, W as ManageOk, Wn as procKillSchema, Wt as bulkDataFrameSchema, X as ObservedAddressFrame, Xn as ptySpawnSchema, Xt as capabilityGrantOkSchema, Y as NamespacedDomainId, Yn as ptyResizeSchema, Yt as candidatesFrameSchema, Z as OwnerNamedRoomPath, Zn as ptyWriteSchema, Zt as capabilityGrantSchema, _ as CoreCapability, _n as domainIdSchema, _r as roomSendSchema, _t as RevocationEntry, a as BulkOpen, an as coreDomainNameSchema, ar as roomInviteSchema, at as ProcSpawn, b as CoseHeaderKid, bn as frameSchema, br as streamEndFrameSchema, bt as RoomJoinOk, c as CandidatesFrame, cn as coseHeaderLabelSchema, cr as roomLeaveSchema, ct as PtyResize, d as CapabilityRequest, dn as dataEntriesFrameSchema, dr as roomMembersSchema, dt as RelayConnectFrame, en as capabilityTokenSchema, er as relayInboundFrameSchema, et as PingFrame, f as CapabilityScope, fn as dataHaveFrameSchema, fr as roomNoticeClaimsSchema, ft as RelayDataFrame, g as CoordinatorFrame, gn as dmRoomPathSchema, gr as roomRekeySchema, gt as RevocationClaims, h as CloseFrame, hn as deviceIdSchema, hr as roomReadSchema, ht as RevocationAnnounceFrame, i as BulkEndFrame, in as coreCapabilitySchema, ir as revocationEntrySchema, it as ProcSignal, j as ExecList, jn as manageOkSchema, jt as StreamAckFrame, k as DmRoomPath, kn as manageCommandSchema, kt as RoomRekey, l as CapabilityGrant, ln as coseSign1Schema, lr as roomMemberSchema, lt as PtySpawn, m as CapabilityVerb, mn as deviceIdHexSchema, mr as roomPathSchema, mt as RelayOfferFrame, n as BulkCancel, nn as closeFrameSchema, nr as revocationAnnounceFrameSchema, nt as PrivateUseDomainId, o as BulkResume, on as coseHeaderAlgSchema, or as roomJoinOkSchema, ot as ProtocolVersion, p as CapabilityToken, pn as dataRequestFrameSchema, pr as roomNoticeSchema, pt as RelayInboundFrame, q as MessageRef, qn as protocolVersionSchema, qt as bulkResumeSchema, r as BulkDataFrame, rn as coordinatorFrameSchema, rr as revocationClaimsSchema, rt as ProcKill, s as CandidateKind, sn as coseHeaderKidSchema, sr as roomJoinSchema, st as PtyKill, t as BulkAckFrame, tn as capabilityVerbSchema, tr as relayOfferFrameSchema, tt as PrivateUseCapability, u as CapabilityGrantOk, un as coseTokenHeadersSchema, ur as roomMembersOkSchema, ut as PtyWrite, v as CoreDomainName, vn as execListSchema, vr as streamAckFrameSchema, vt as RoomInvite, w as DataEntriesFrame, wn as handleRecordSchema, wr as transferIdSchema, wt as RoomMembersOk, x as CoseHeaderLabel, xn as frameVariantSchema, xr as streamSessionSchema, xt as RoomLeave, y as CoseHeaderAlg, yn as execSessionInfoSchema, yr as streamDataFrameSchema, yt as RoomJoin, z as IceCandidateInit, zn as peerAdvertSchema, zt as WebrtcIceCandidate } from "../protocol-gbXtNeOc.mjs";
-export { BulkAckFrame, BulkCancel, BulkDataFrame, BulkEndFrame, BulkOpen, BulkResume, CandidateKind, CandidatesFrame, CapabilityGrant, CapabilityGrantOk, CapabilityRequest, CapabilityScope, CapabilityToken, CapabilityVerb, CloseFrame, CoordinatorFrame, CoreCapability, CoreDomainName, CoseHeaderAlg, CoseHeaderKid, CoseHeaderLabel, CoseSign1, CoseTokenHeaders, DataEntriesFrame, DataHaveFrame, DataRequestFrame, DeviceId, DeviceIdHex, DmRoomPath, DomainId, ExecList, ExecSessionInfo, Frame, FrameVariant, GossipFrame, HandleClaims, HandleRecord, HandshakeFrame, IceCandidateInit, IdentityKey, ManageCommand, ManageCommandParams, ManageError, ManageOk, ManageRequestFrame, ManageResponseFrame, MessageRef, NamespacedCapability, NamespacedDomainId, ObservedAddressFrame, OwnerNamedRoomPath, PeerAdvert, PeerIdentity, PingFrame, PrivateUseCapability, PrivateUseDomainId, ProcKill, ProcSignal, ProcSpawn, ProtocolVersion, PtyKill, PtyResize, PtySpawn, PtyWrite, RelayConnectFrame, RelayDataFrame, RelayInboundFrame, RelayOfferFrame, RevocationAnnounceFrame, RevocationClaims, RevocationEntry, RoomInvite, RoomJoin, RoomJoinOk, RoomLeave, RoomMember, RoomMembers, RoomMembersOk, RoomNotice, RoomNoticeClaims, RoomPath, RoomRead, RoomRekey, RoomSend, StreamAckFrame, StreamDataFrame, StreamEndFrame, StreamSession, SyncPunchFrame, TokenClaims, TransferId, WebrtcAnswer, WebrtcIceCandidate, WebrtcOffer, WireCandidate, bulkAckFrameSchema, bulkCancelSchema, bulkDataFrameSchema, bulkEndFrameSchema, bulkOpenSchema, bulkResumeSchema, candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityGrantSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomRekeySchema, roomSendSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, transferIdSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };
+import { $ as PeerIdentity, $n as ptyWriteSchema, $t as capabilityGrantSchema, A as DomainId, An as manageCommandParamsSchema, Ar as webrtcIceCandidateSchema, At as RoomSend, B as IdentityKey, Bn as ownerNamedRoomPathSchema, Bt as WebrtcAnswer, C as CoseTokenHeaders, Cn as frameVariantSchema, Cr as streamDataFrameSchema, Ct as RoomMembers, D as DeviceId, Dn as handshakeFrameSchema, Dr as tokenClaimsSchema, Dt as RoomPath, E as DataRequestFrame, En as handleRecordSchema, Er as syncPunchFrameSchema, Et as RoomNoticeClaims, F as GossipFrame, Fn as manageResponseFrameSchema, Ft as StreamEndFrame, G as ManageRequestFrame, Gn as privateUseDomainIdSchema, Gt as bulkCancelSchema, H as ManageCommandParams, Hn as peerIdentitySchema, Ht as WebrtcOffer, I as HandleClaims, In as messageRefSchema, It as StreamSession, J as NamespacedCapability, Jn as procSpawnSchema, Jt as bulkOpenSchema, K as ManageResponseFrame, Kn as procKillSchema, Kt as bulkDataFrameSchema, L as HandleRecord, Ln as namespacedCapabilitySchema, Lt as SyncPunchFrame, M as ExecSessionInfo, Mn as manageErrorSchema, Mr as wireCandidateSchema, Mt as SfuTrackMap, N as Frame, Nn as manageOkSchema, Nt as StreamAckFrame, O as DeviceIdHex, On as iceCandidateInitSchema, Or as transferIdSchema, Ot as RoomRead, P as FrameVariant, Pn as manageRequestFrameSchema, Pt as StreamDataFrame, Q as PeerAdvert, Qn as ptySpawnSchema, Qt as capabilityGrantOkSchema, R as HandshakeFrame, Rn as namespacedDomainIdSchema, Rt as TokenClaims, S as CoseSign1, Sn as frameSchema, Sr as streamAckFrameSchema, St as RoomMember, T as DataHaveFrame, Tn as handleClaimsSchema, Tr as streamSessionSchema, Tt as RoomNotice, U as ManageError, Un as pingFrameSchema, Ut as WireCandidate, V as ManageCommand, Vn as peerAdvertSchema, Vt as WebrtcIceCandidate, W as ManageOk, Wn as privateUseCapabilitySchema, Wt as bulkAckFrameSchema, X as ObservedAddressFrame, Xn as ptyKillSchema, Xt as candidateKindSchema, Y as NamespacedDomainId, Yn as protocolVersionSchema, Yt as bulkResumeSchema, Z as OwnerNamedRoomPath, Zn as ptyResizeSchema, Zt as candidatesFrameSchema, _ as CoreCapability, _n as deviceIdSchema, _r as roomReadSchema, _t as RevocationEntry, a as BulkOpen, an as coordinatorFrameSchema, ar as revocationClaimsSchema, at as ProcSpawn, b as CoseHeaderKid, bn as execListSchema, br as sfuTrackEntrySchema, bt as RoomJoinOk, c as CandidatesFrame, cn as coseHeaderAlgSchema, cr as roomJoinOkSchema, ct as PtyResize, d as CapabilityRequest, dn as coseSign1Schema, dr as roomMemberSchema, dt as RelayConnectFrame, en as capabilityRequestSchema, er as relayConnectFrameSchema, et as PingFrame, f as CapabilityScope, fn as coseTokenHeadersSchema, fr as roomMembersOkSchema, ft as RelayDataFrame, g as CoordinatorFrame, gn as deviceIdHexSchema, gr as roomPathSchema, gt as RevocationClaims, h as CloseFrame, hn as dataRequestFrameSchema, hr as roomNoticeSchema, ht as RevocationAnnounceFrame, i as BulkEndFrame, in as closeFrameSchema, ir as revocationAnnounceFrameSchema, it as ProcSignal, j as ExecList, jn as manageCommandSchema, jr as webrtcOfferSchema, jt as SfuTrackEntry, k as DmRoomPath, kn as identityKeySchema, kr as webrtcAnswerSchema, kt as RoomRekey, l as CapabilityGrant, ln as coseHeaderKidSchema, lr as roomJoinSchema, lt as PtySpawn, m as CapabilityVerb, mn as dataHaveFrameSchema, mr as roomNoticeClaimsSchema, mt as RelayOfferFrame, n as BulkCancel, nn as capabilityTokenSchema, nr as relayInboundFrameSchema, nt as PrivateUseDomainId, o as BulkResume, on as coreCapabilitySchema, or as revocationEntrySchema, ot as ProtocolVersion, p as CapabilityToken, pn as dataEntriesFrameSchema, pr as roomMembersSchema, pt as RelayInboundFrame, q as MessageRef, qn as procSignalSchema, qt as bulkEndFrameSchema, r as BulkDataFrame, rn as capabilityVerbSchema, rr as relayOfferFrameSchema, rt as ProcKill, s as CandidateKind, sn as coreDomainNameSchema, sr as roomInviteSchema, st as PtyKill, t as BulkAckFrame, tn as capabilityScopeSchema, tr as relayDataFrameSchema, tt as PrivateUseCapability, u as CapabilityGrantOk, un as coseHeaderLabelSchema, ur as roomLeaveSchema, ut as PtyWrite, v as CoreDomainName, vn as dmRoomPathSchema, vr as roomRekeySchema, vt as RoomInvite, w as DataEntriesFrame, wn as gossipFrameSchema, wr as streamEndFrameSchema, wt as RoomMembersOk, x as CoseHeaderLabel, xn as execSessionInfoSchema, xr as sfuTrackMapSchema, xt as RoomLeave, y as CoseHeaderAlg, yn as domainIdSchema, yr as roomSendSchema, yt as RoomJoin, z as IceCandidateInit, zn as observedAddressFrameSchema, zt as TransferId } from "../protocol-D8CU6s2_.mjs";
+export { BulkAckFrame, BulkCancel, BulkDataFrame, BulkEndFrame, BulkOpen, BulkResume, CandidateKind, CandidatesFrame, CapabilityGrant, CapabilityGrantOk, CapabilityRequest, CapabilityScope, CapabilityToken, CapabilityVerb, CloseFrame, CoordinatorFrame, CoreCapability, CoreDomainName, CoseHeaderAlg, CoseHeaderKid, CoseHeaderLabel, CoseSign1, CoseTokenHeaders, DataEntriesFrame, DataHaveFrame, DataRequestFrame, DeviceId, DeviceIdHex, DmRoomPath, DomainId, ExecList, ExecSessionInfo, Frame, FrameVariant, GossipFrame, HandleClaims, HandleRecord, HandshakeFrame, IceCandidateInit, IdentityKey, ManageCommand, ManageCommandParams, ManageError, ManageOk, ManageRequestFrame, ManageResponseFrame, MessageRef, NamespacedCapability, NamespacedDomainId, ObservedAddressFrame, OwnerNamedRoomPath, PeerAdvert, PeerIdentity, PingFrame, PrivateUseCapability, PrivateUseDomainId, ProcKill, ProcSignal, ProcSpawn, ProtocolVersion, PtyKill, PtyResize, PtySpawn, PtyWrite, RelayConnectFrame, RelayDataFrame, RelayInboundFrame, RelayOfferFrame, RevocationAnnounceFrame, RevocationClaims, RevocationEntry, RoomInvite, RoomJoin, RoomJoinOk, RoomLeave, RoomMember, RoomMembers, RoomMembersOk, RoomNotice, RoomNoticeClaims, RoomPath, RoomRead, RoomRekey, RoomSend, SfuTrackEntry, SfuTrackMap, StreamAckFrame, StreamDataFrame, StreamEndFrame, StreamSession, SyncPunchFrame, TokenClaims, TransferId, WebrtcAnswer, WebrtcIceCandidate, WebrtcOffer, WireCandidate, bulkAckFrameSchema, bulkCancelSchema, bulkDataFrameSchema, bulkEndFrameSchema, bulkOpenSchema, bulkResumeSchema, candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityGrantSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomRekeySchema, roomSendSchema, sfuTrackEntrySchema, sfuTrackMapSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, transferIdSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };

package/dist/generated/protocol.mjs

@@ -47,7 +47,8 @@ const manageCommandParamsSchema = z.lazy(() => z.union([
 	z.union([
 		z.lazy(() => webrtcOfferSchema),
 		z.lazy(() => webrtcAnswerSchema),
-		z.lazy(() => webrtcIceCandidateSchema)
+		z.lazy(() => webrtcIceCandidateSchema),
+		z.lazy(() => sfuTrackMapSchema)
 	])
 ]));
 const bulkDataFrameSchema = z.lazy(() => z.object({
@@ -426,6 +427,16 @@ const coordinatorFrameSchema = z.lazy(() => z.object({
 	"coordinator": z.lazy(() => deviceIdSchema),
 	"capacity-hint": z.number().int().nonnegative().optional()
 }));
+const sfuTrackMapSchema = z.lazy(() => z.object({
+	"verb": z.literal("webrtc.sfu-track-map"),
+	"negotiation-id": z.number().int().nonnegative(),
+	"tracks": z.array(z.lazy(() => sfuTrackEntrySchema))
+}));
+const sfuTrackEntrySchema = z.lazy(() => z.object({
+	"mid": z.string(),
+	"member": z.lazy(() => deviceIdSchema),
+	"kind": z.union([z.literal("audio"), z.literal("video")])
+}));
 const webrtcOfferSchema = z.lazy(() => z.object({
 	"verb": z.literal("webrtc.offer"),
 	"negotiation-id": z.number().int().nonnegative(),
@@ -448,4 +459,4 @@ const iceCandidateInitSchema = z.lazy(() => z.object({
 	"username-fragment": z.string().optional()
 }));
 //#endregion
-export { bulkAckFrameSchema, bulkCancelSchema, bulkDataFrameSchema, bulkEndFrameSchema, bulkOpenSchema, bulkResumeSchema, candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityGrantSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomRekeySchema, roomSendSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, transferIdSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };
+export { bulkAckFrameSchema, bulkCancelSchema, bulkDataFrameSchema, bulkEndFrameSchema, bulkOpenSchema, bulkResumeSchema, candidateKindSchema, candidatesFrameSchema, capabilityGrantOkSchema, capabilityGrantSchema, capabilityRequestSchema, capabilityScopeSchema, capabilityTokenSchema, capabilityVerbSchema, closeFrameSchema, coordinatorFrameSchema, coreCapabilitySchema, coreDomainNameSchema, coseHeaderAlgSchema, coseHeaderKidSchema, coseHeaderLabelSchema, coseSign1Schema, coseTokenHeadersSchema, dataEntriesFrameSchema, dataHaveFrameSchema, dataRequestFrameSchema, deviceIdHexSchema, deviceIdSchema, dmRoomPathSchema, domainIdSchema, execListSchema, execSessionInfoSchema, frameSchema, frameVariantSchema, gossipFrameSchema, handleClaimsSchema, handleRecordSchema, handshakeFrameSchema, iceCandidateInitSchema, identityKeySchema, manageCommandParamsSchema, manageCommandSchema, manageErrorSchema, manageOkSchema, manageRequestFrameSchema, manageResponseFrameSchema, messageRefSchema, namespacedCapabilitySchema, namespacedDomainIdSchema, observedAddressFrameSchema, ownerNamedRoomPathSchema, peerAdvertSchema, peerIdentitySchema, pingFrameSchema, privateUseCapabilitySchema, privateUseDomainIdSchema, procKillSchema, procSignalSchema, procSpawnSchema, protocolVersionSchema, ptyKillSchema, ptyResizeSchema, ptySpawnSchema, ptyWriteSchema, relayConnectFrameSchema, relayDataFrameSchema, relayInboundFrameSchema, relayOfferFrameSchema, revocationAnnounceFrameSchema, revocationClaimsSchema, revocationEntrySchema, roomInviteSchema, roomJoinOkSchema, roomJoinSchema, roomLeaveSchema, roomMemberSchema, roomMembersOkSchema, roomMembersSchema, roomNoticeClaimsSchema, roomNoticeSchema, roomPathSchema, roomReadSchema, roomRekeySchema, roomSendSchema, sfuTrackEntrySchema, sfuTrackMapSchema, streamAckFrameSchema, streamDataFrameSchema, streamEndFrameSchema, streamSessionSchema, syncPunchFrameSchema, tokenClaimsSchema, transferIdSchema, webrtcAnswerSchema, webrtcIceCandidateSchema, webrtcOfferSchema, wireCandidateSchema };

package/dist/{identity-B4XBWkqg.d.cts → identity-DHf0J6IA.d.cts}

@@ -1,4 +1,4 @@
-import { B as IdentityKey, D as DeviceId } from "./protocol-gbXtNeOc.cjs";
+import { B as IdentityKey, D as DeviceId } from "./protocol-D8CU6s2_.cjs";
 //#region src/ports/identity.d.ts
 /**
  * Wraps the local node's own identity plus the signing/verification primitives capability-token handling needs -- never hardcoded to one crypto library's own API shape (Node's webcrypto, a WASM implementation, a hardware key, etc. can all satisfy this same contract).

package/dist/{identity-CIb9dGkJ.d.mts → identity-Oelt3uEn.d.mts}

@@ -1,4 +1,4 @@
-import { B as IdentityKey, D as DeviceId } from "./protocol-gbXtNeOc.mjs";
+import { B as IdentityKey, D as DeviceId } from "./protocol-D8CU6s2_.mjs";
 //#region src/ports/identity.d.ts
 /**
  * Wraps the local node's own identity plus the signing/verification primitives capability-token handling needs -- never hardcoded to one crypto library's own API shape (Node's webcrypto, a WASM implementation, a hardware key, etc. can all satisfy this same contract).

package/dist/ports/identity.d.cts

@@ -1,2 +1,2 @@
-import { t as IdentityPort } from "../identity-B4XBWkqg.cjs";
+import { t as IdentityPort } from "../identity-DHf0J6IA.cjs";
 export { IdentityPort };

package/dist/ports/identity.d.mts

@@ -1,2 +1,2 @@
-import { t as IdentityPort } from "../identity-CIb9dGkJ.mjs";
+import { t as IdentityPort } from "../identity-Oelt3uEn.mjs";
 export { IdentityPort };

package/dist/ports/transport.d.cts

@@ -1,2 +1,2 @@
-import { n as Listener, r as Transport, t as Connection } from "../transport-DAsFqDDS.cjs";
+import { n as Listener, r as Transport, t as Connection } from "../transport-BbSGNRFZ.cjs";
 export { Connection, Listener, Transport };

package/dist/ports/transport.d.mts

@@ -1,2 +1,2 @@
-import { n as Listener, r as Transport, t as Connection } from "../transport-Dy4h2eNY.mjs";
+import { n as Listener, r as Transport, t as Connection } from "../transport-BNeF6kDe.mjs";
 export { Connection, Listener, Transport };

package/dist/{protocol-gbXtNeOc.d.cts → protocol-D8CU6s2_.d.cts}

@@ -123,6 +123,14 @@ declare const manageCommandParamsSchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodUni
     "sdp-m-line-index": z.ZodOptional<z.ZodNumber>;
     "username-fragment": z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>>>;
+}, z.core.$strip>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+  verb: z.ZodLiteral<"webrtc.sfu-track-map">;
+  "negotiation-id": z.ZodNumber;
+  tracks: z.ZodArray<z.ZodLazy<z.ZodLazy<z.ZodObject<{
+    mid: z.ZodString;
+    member: z.ZodLazy<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
+    kind: z.ZodUnion<readonly [z.ZodLiteral<"audio">, z.ZodLiteral<"video">]>;
+  }, z.core.$strip>>>>;
 }, z.core.$strip>>>]>]>>;
 declare const bulkDataFrameSchema: z.ZodLazy<z.ZodObject<{
   type: z.ZodLiteral<"bulk-data">;
@@ -387,6 +395,14 @@ declare const frameVariantSchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodLazy<z.Zod
         "sdp-m-line-index": z.ZodOptional<z.ZodNumber>;
         "username-fragment": z.ZodOptional<z.ZodString>;
       }, z.core.$strip>>>>;
+    }, z.core.$strip>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      verb: z.ZodLiteral<"webrtc.sfu-track-map">;
+      "negotiation-id": z.ZodNumber;
+      tracks: z.ZodArray<z.ZodLazy<z.ZodLazy<z.ZodObject<{
+        mid: z.ZodString;
+        member: z.ZodLazy<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
+        kind: z.ZodUnion<readonly [z.ZodLiteral<"audio">, z.ZodLiteral<"video">]>;
+      }, z.core.$strip>>>>;
     }, z.core.$strip>>>]>]>>>;
   }, z.core.$strip>>>;
   scope: z.ZodLazy<z.ZodLazy<z.ZodObject<{
@@ -618,6 +634,14 @@ declare const frameSchema: z.ZodLazy<z.ZodLazy<z.ZodLazy<z.ZodUnion<readonly [z.
         "sdp-m-line-index": z.ZodOptional<z.ZodNumber>;
         "username-fragment": z.ZodOptional<z.ZodString>;
       }, z.core.$strip>>>>;
+    }, z.core.$strip>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      verb: z.ZodLiteral<"webrtc.sfu-track-map">;
+      "negotiation-id": z.ZodNumber;
+      tracks: z.ZodArray<z.ZodLazy<z.ZodLazy<z.ZodObject<{
+        mid: z.ZodString;
+        member: z.ZodLazy<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
+        kind: z.ZodUnion<readonly [z.ZodLiteral<"audio">, z.ZodLiteral<"video">]>;
+      }, z.core.$strip>>>>;
     }, z.core.$strip>>>]>]>>>;
   }, z.core.$strip>>>;
   scope: z.ZodLazy<z.ZodLazy<z.ZodObject<{
@@ -820,6 +844,14 @@ declare const manageCommandSchema: z.ZodLazy<z.ZodObject<{
       "sdp-m-line-index": z.ZodOptional<z.ZodNumber>;
       "username-fragment": z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>>;
+  }, z.core.$strip>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+    verb: z.ZodLiteral<"webrtc.sfu-track-map">;
+    "negotiation-id": z.ZodNumber;
+    tracks: z.ZodArray<z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      mid: z.ZodString;
+      member: z.ZodLazy<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
+      kind: z.ZodUnion<readonly [z.ZodLiteral<"audio">, z.ZodLiteral<"video">]>;
+    }, z.core.$strip>>>>;
   }, z.core.$strip>>>]>]>>>;
 }, z.core.$strip>>;
 declare const manageRequestFrameSchema: z.ZodLazy<z.ZodObject<{
@@ -933,6 +965,14 @@ declare const manageRequestFrameSchema: z.ZodLazy<z.ZodObject<{
         "sdp-m-line-index": z.ZodOptional<z.ZodNumber>;
         "username-fragment": z.ZodOptional<z.ZodString>;
       }, z.core.$strip>>>>;
+    }, z.core.$strip>>>, z.ZodLazy<z.ZodLazy<z.ZodObject<{
+      verb: z.ZodLiteral<"webrtc.sfu-track-map">;
+      "negotiation-id": z.ZodNumber;
+      tracks: z.ZodArray<z.ZodLazy<z.ZodLazy<z.ZodObject<{
+        mid: z.ZodString;
+        member: z.ZodLazy<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
+        kind: z.ZodUnion<readonly [z.ZodLiteral<"audio">, z.ZodLiteral<"video">]>;
+      }, z.core.$strip>>>>;
     }, z.core.$strip>>>]>]>>>;
   }, z.core.$strip>>>;
   scope: z.ZodLazy<z.ZodLazy<z.ZodObject<{
@@ -1224,6 +1264,20 @@ declare const coordinatorFrameSchema: z.ZodLazy<z.ZodObject<{
   coordinator: z.ZodLazy<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
   "capacity-hint": z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>>;
+declare const sfuTrackMapSchema: z.ZodLazy<z.ZodObject<{
+  verb: z.ZodLiteral<"webrtc.sfu-track-map">;
+  "negotiation-id": z.ZodNumber;
+  tracks: z.ZodArray<z.ZodLazy<z.ZodLazy<z.ZodObject<{
+    mid: z.ZodString;
+    member: z.ZodLazy<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
+    kind: z.ZodUnion<readonly [z.ZodLiteral<"audio">, z.ZodLiteral<"video">]>;
+  }, z.core.$strip>>>>;
+}, z.core.$strip>>;
+declare const sfuTrackEntrySchema: z.ZodLazy<z.ZodObject<{
+  mid: z.ZodString;
+  member: z.ZodLazy<z.ZodLazy<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>>;
+  kind: z.ZodUnion<readonly [z.ZodLiteral<"audio">, z.ZodLiteral<"video">]>;
+}, z.core.$strip>>;
 declare const webrtcOfferSchema: z.ZodLazy<z.ZodObject<{
   verb: z.ZodLiteral<"webrtc.offer">;
   "negotiation-id": z.ZodNumber;
@@ -1341,9 +1395,11 @@ type RelayConnectFrame = z.infer<typeof relayConnectFrameSchema>;
 type RelayDataFrame = z.infer<typeof relayDataFrameSchema>;
 type RelayInboundFrame = z.infer<typeof relayInboundFrameSchema>;
 type CoordinatorFrame = z.infer<typeof coordinatorFrameSchema>;
+type SfuTrackMap = z.infer<typeof sfuTrackMapSchema>;
+type SfuTrackEntry = z.infer<typeof sfuTrackEntrySchema>;
 type WebrtcOffer = z.infer<typeof webrtcOfferSchema>;
 type WebrtcAnswer = z.infer<typeof webrtcAnswerSchema>;
 type WebrtcIceCandidate = z.infer<typeof webrtcIceCandidateSchema>;
 type IceCandidateInit = z.infer<typeof iceCandidateInitSchema>;
 //#endregion
-export { PeerIdentity as $, relayDataFrameSchema as $n, capabilityScopeSchema as $t, DomainId as A, manageErrorSchema as An, RoomSend as At, IdentityKey as B, peerIdentitySchema as Bn, WebrtcOffer as Bt, CoseTokenHeaders as C, handleClaimsSchema as Cn, tokenClaimsSchema as Cr, RoomMembers as Ct, DeviceId as D, identityKeySchema as Dn, webrtcOfferSchema as Dr, RoomPath as Dt, DataRequestFrame as E, iceCandidateInitSchema as En, webrtcIceCandidateSchema as Er, RoomNoticeClaims as Et, GossipFrame as F, namespacedCapabilitySchema as Fn, SyncPunchFrame as Ft, ManageRequestFrame as G, procSignalSchema as Gn, bulkEndFrameSchema as Gt, ManageCommandParams as H, privateUseCapabilitySchema as Hn, bulkAckFrameSchema as Ht, HandleClaims as I, namespacedDomainIdSchema as In, TokenClaims as It, NamespacedCapability as J, ptyKillSchema as Jn, candidateKindSchema as Jt, ManageResponseFrame as K, procSpawnSchema as Kn, bulkOpenSchema as Kt, HandleRecord as L, observedAddressFrameSchema as Ln, TransferId as Lt, ExecSessionInfo as M, manageRequestFrameSchema as Mn, StreamDataFrame as Mt, Frame as N, manageResponseFrameSchema as Nn, StreamEndFrame as Nt, DeviceIdHex as O, manageCommandParamsSchema as On, wireCandidateSchema as Or, RoomRead as Ot, FrameVariant as P, messageRefSchema as Pn, StreamSession as Pt, PeerAdvert as Q, relayConnectFrameSchema as Qn, capabilityRequestSchema as Qt, HandshakeFrame as R, ownerNamedRoomPathSchema as Rn, WebrtcAnswer as Rt, CoseSign1 as S, gossipFrameSchema as Sn, syncPunchFrameSchema as Sr, RoomMember as St, DataHaveFrame as T, handshakeFrameSchema as Tn, webrtcAnswerSchema as Tr, RoomNotice as Tt, ManageError as U, privateUseDomainIdSchema as Un, bulkCancelSchema as Ut, ManageCommand as V, pingFrameSchema as Vn, WireCandidate as Vt, ManageOk as W, procKillSchema as Wn, bulkDataFrameSchema as Wt, ObservedAddressFrame as X, ptySpawnSchema as Xn, capabilityGrantOkSchema as Xt, NamespacedDomainId as Y, ptyResizeSchema as Yn, candidatesFrameSchema as Yt, OwnerNamedRoomPath as Z, ptyWriteSchema as Zn, capabilityGrantSchema as Zt, CoreCapability as _, domainIdSchema as _n, roomSendSchema as _r, RevocationEntry as _t, BulkOpen as a, coreDomainNameSchema as an, roomInviteSchema as ar, ProcSpawn as at, CoseHeaderKid as b, frameSchema as bn, streamEndFrameSchema as br, RoomJoinOk as bt, CandidatesFrame as c, coseHeaderLabelSchema as cn, roomLeaveSchema as cr, PtyResize as ct, CapabilityRequest as d, dataEntriesFrameSchema as dn, roomMembersSchema as dr, RelayConnectFrame as dt, capabilityTokenSchema as en, relayInboundFrameSchema as er, PingFrame as et, CapabilityScope as f, dataHaveFrameSchema as fn, roomNoticeClaimsSchema as fr, RelayDataFrame as ft, CoordinatorFrame as g, dmRoomPathSchema as gn, roomRekeySchema as gr, RevocationClaims as gt, CloseFrame as h, deviceIdSchema as hn, roomReadSchema as hr, RevocationAnnounceFrame as ht, BulkEndFrame as i, coreCapabilitySchema as in, revocationEntrySchema as ir, ProcSignal as it, ExecList as j, manageOkSchema as jn, StreamAckFrame as jt, DmRoomPath as k, manageCommandSchema as kn, RoomRekey as kt, CapabilityGrant as l, coseSign1Schema as ln, roomMemberSchema as lr, PtySpawn as lt, CapabilityVerb as m, deviceIdHexSchema as mn, roomPathSchema as mr, RelayOfferFrame as mt, BulkCancel as n, closeFrameSchema as nn, revocationAnnounceFrameSchema as nr, PrivateUseDomainId as nt, BulkResume as o, coseHeaderAlgSchema as on, roomJoinOkSchema as or, ProtocolVersion as ot, CapabilityToken as p, dataRequestFrameSchema as pn, roomNoticeSchema as pr, RelayInboundFrame as pt, MessageRef as q, protocolVersionSchema as qn, bulkResumeSchema as qt, BulkDataFrame as r, coordinatorFrameSchema as rn, revocationClaimsSchema as rr, ProcKill as rt, CandidateKind as s, coseHeaderKidSchema as sn, roomJoinSchema as sr, PtyKill as st, BulkAckFrame as t, capabilityVerbSchema as tn, relayOfferFrameSchema as tr, PrivateUseCapability as tt, CapabilityGrantOk as u, coseTokenHeadersSchema as un, roomMembersOkSchema as ur, PtyWrite as ut, CoreDomainName as v, execListSchema as vn, streamAckFrameSchema as vr, RoomInvite as vt, DataEntriesFrame as w, handleRecordSchema as wn, transferIdSchema as wr, RoomMembersOk as wt, CoseHeaderLabel as x, frameVariantSchema as xn, streamSessionSchema as xr, RoomLeave as xt, CoseHeaderAlg as y, execSessionInfoSchema as yn, streamDataFrameSchema as yr, RoomJoin as yt, IceCandidateInit as z, peerAdvertSchema as zn, WebrtcIceCandidate as zt };
+export { PeerIdentity as $, ptyWriteSchema as $n, capabilityGrantSchema as $t, DomainId as A, manageCommandParamsSchema as An, webrtcIceCandidateSchema as Ar, RoomSend as At, IdentityKey as B, ownerNamedRoomPathSchema as Bn, WebrtcAnswer as Bt, CoseTokenHeaders as C, frameVariantSchema as Cn, streamDataFrameSchema as Cr, RoomMembers as Ct, DeviceId as D, handshakeFrameSchema as Dn, tokenClaimsSchema as Dr, RoomPath as Dt, DataRequestFrame as E, handleRecordSchema as En, syncPunchFrameSchema as Er, RoomNoticeClaims as Et, GossipFrame as F, manageResponseFrameSchema as Fn, StreamEndFrame as Ft, ManageRequestFrame as G, privateUseDomainIdSchema as Gn, bulkCancelSchema as Gt, ManageCommandParams as H, peerIdentitySchema as Hn, WebrtcOffer as Ht, HandleClaims as I, messageRefSchema as In, StreamSession as It, NamespacedCapability as J, procSpawnSchema as Jn, bulkOpenSchema as Jt, ManageResponseFrame as K, procKillSchema as Kn, bulkDataFrameSchema as Kt, HandleRecord as L, namespacedCapabilitySchema as Ln, SyncPunchFrame as Lt, ExecSessionInfo as M, manageErrorSchema as Mn, wireCandidateSchema as Mr, SfuTrackMap as Mt, Frame as N, manageOkSchema as Nn, StreamAckFrame as Nt, DeviceIdHex as O, iceCandidateInitSchema as On, transferIdSchema as Or, RoomRead as Ot, FrameVariant as P, manageRequestFrameSchema as Pn, StreamDataFrame as Pt, PeerAdvert as Q, ptySpawnSchema as Qn, capabilityGrantOkSchema as Qt, HandshakeFrame as R, namespacedDomainIdSchema as Rn, TokenClaims as Rt, CoseSign1 as S, frameSchema as Sn, streamAckFrameSchema as Sr, RoomMember as St, DataHaveFrame as T, handleClaimsSchema as Tn, streamSessionSchema as Tr, RoomNotice as Tt, ManageError as U, pingFrameSchema as Un, WireCandidate as Ut, ManageCommand as V, peerAdvertSchema as Vn, WebrtcIceCandidate as Vt, ManageOk as W, privateUseCapabilitySchema as Wn, bulkAckFrameSchema as Wt, ObservedAddressFrame as X, ptyKillSchema as Xn, candidateKindSchema as Xt, NamespacedDomainId as Y, protocolVersionSchema as Yn, bulkResumeSchema as Yt, OwnerNamedRoomPath as Z, ptyResizeSchema as Zn, candidatesFrameSchema as Zt, CoreCapability as _, deviceIdSchema as _n, roomReadSchema as _r, RevocationEntry as _t, BulkOpen as a, coordinatorFrameSchema as an, revocationClaimsSchema as ar, ProcSpawn as at, CoseHeaderKid as b, execListSchema as bn, sfuTrackEntrySchema as br, RoomJoinOk as bt, CandidatesFrame as c, coseHeaderAlgSchema as cn, roomJoinOkSchema as cr, PtyResize as ct, CapabilityRequest as d, coseSign1Schema as dn, roomMemberSchema as dr, RelayConnectFrame as dt, capabilityRequestSchema as en, relayConnectFrameSchema as er, PingFrame as et, CapabilityScope as f, coseTokenHeadersSchema as fn, roomMembersOkSchema as fr, RelayDataFrame as ft, CoordinatorFrame as g, deviceIdHexSchema as gn, roomPathSchema as gr, RevocationClaims as gt, CloseFrame as h, dataRequestFrameSchema as hn, roomNoticeSchema as hr, RevocationAnnounceFrame as ht, BulkEndFrame as i, closeFrameSchema as in, revocationAnnounceFrameSchema as ir, ProcSignal as it, ExecList as j, manageCommandSchema as jn, webrtcOfferSchema as jr, SfuTrackEntry as jt, DmRoomPath as k, identityKeySchema as kn, webrtcAnswerSchema as kr, RoomRekey as kt, CapabilityGrant as l, coseHeaderKidSchema as ln, roomJoinSchema as lr, PtySpawn as lt, CapabilityVerb as m, dataHaveFrameSchema as mn, roomNoticeClaimsSchema as mr, RelayOfferFrame as mt, BulkCancel as n, capabilityTokenSchema as nn, relayInboundFrameSchema as nr, PrivateUseDomainId as nt, BulkResume as o, coreCapabilitySchema as on, revocationEntrySchema as or, ProtocolVersion as ot, CapabilityToken as p, dataEntriesFrameSchema as pn, roomMembersSchema as pr, RelayInboundFrame as pt, MessageRef as q, procSignalSchema as qn, bulkEndFrameSchema as qt, BulkDataFrame as r, capabilityVerbSchema as rn, relayOfferFrameSchema as rr, ProcKill as rt, CandidateKind as s, coreDomainNameSchema as sn, roomInviteSchema as sr, PtyKill as st, BulkAckFrame as t, capabilityScopeSchema as tn, relayDataFrameSchema as tr, PrivateUseCapability as tt, CapabilityGrantOk as u, coseHeaderLabelSchema as un, roomLeaveSchema as ur, PtyWrite as ut, CoreDomainName as v, dmRoomPathSchema as vn, roomRekeySchema as vr, RoomInvite as vt, DataEntriesFrame as w, gossipFrameSchema as wn, streamEndFrameSchema as wr, RoomMembersOk as wt, CoseHeaderLabel as x, execSessionInfoSchema as xn, sfuTrackMapSchema as xr, RoomLeave as xt, CoseHeaderAlg as y, domainIdSchema as yn, roomSendSchema as yr, RoomJoin as yt, IceCandidateInit as z, observedAddressFrameSchema as zn, TransferId as zt };