Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
import { z } from "zod";
import { MAX_CHAT_CODE_POINTS, normalizeChatText, REACTION_IDS, isThrow } from "./room-interactions.js";
import { MAX_ENDPOINT_MEDIA_COPY_CAPACITY } from "./media-copy-accounting.js";
import { isCanonicalVideoCodecEvidence } from "./video-codec-evidence.js";
import { NAT_TRAVERSAL_PATHS } from "./nat-candidate.js";
export const MAX_VIEWERS_PER_ROOM_LIMIT = 20;
export const MAX_PARTICIPANTS_PER_ROOM_LIMIT = MAX_VIEWERS_PER_ROOM_LIMIT + 1;
export const MAX_SIGNAL_BYTES = 64 * 1024;
export const SIGNALING_PROTOCOL = "piik-v24";
export const SIGNAL_CLOSE_CODES = {
serviceRestart: 1012,
sessionReplaced: 4001,
clientReconnect: 4002,
authenticationFailed: 4003,
viewerAccessRevoked: 4004,
} as const;
export const ROOM_CODE_LENGTH = 4;
export const MAX_MEDIA_ROUTE_REVISION = Number.MAX_SAFE_INTEGER;
export const MAX_ICE_SERVER_URLS = 8;
export const MAX_NAT_PREDICTION_AUXILIARY_STUN_URLS = 2;
export const MAX_VIEWER_QUALITY_EVIDENCE_BYTES = 2 * 1024;
export const VIEWER_QUALITY_EVIDENCE_INTERVAL_MS = 2_000;
export const VIEWER_QUALITY_EVIDENCE_EXPIRY_MS = 5_000;
export const PERSISTENT_NATIVE_EDGE_DEGRADED_WINDOWS = 3;
export const MAX_DISPLAY_NAME_CODE_POINTS = 24;
export const DEFAULT_VIEWER_DISPLAY_NAME = "观众";
export const DEFAULT_HOST_DISPLAY_NAME_PREFIX = "房主";
export const MIN_VIEWER_PASSWORD_LENGTH = 1;
export const MAX_VIEWER_PASSWORD_LENGTH = 64;
const FORBIDDEN_DISPLAY_NAME_CHARACTERS =
/[\p{Cc}\p{Zl}\p{Zp}\u061c\u200b\u200e\u200f\u202a-\u202e\u2060\u2066-\u2069\ufeff]/u;
export function normalizeDisplayName(value: string): string | null {
if (FORBIDDEN_DISPLAY_NAME_CHARACTERS.test(value)) {
return null;
}
for (const character of value) {
const codePoint = character.codePointAt(0)!;
if (codePoint >= 0xd800 && codePoint <= 0xdfff) {
return null;
}
}
const normalized = value.normalize("NFC").trim().replace(/\p{Zs}+/gu, " ");
const codePointCount = Array.from(normalized).length;
return codePointCount >= 1 && codePointCount <= MAX_DISPLAY_NAME_CODE_POINTS
? normalized
: null;
}
export const displayNameSchema = z
.string()
.min(1)
.max(MAX_DISPLAY_NAME_CODE_POINTS * 4)
.refine((value) => normalizeDisplayName(value) === value, {
message: "Display name must be canonical",
});
export type DisplayName = z.infer<typeof displayNameSchema>;
const opaqueIdSchema = z
.string()
.min(8)
.max(128)
.regex(/^[A-Za-z0-9_-]+$/);
const coPlayGrantSchema = z.object({
endpointId: z.string().regex(/^[0-9a-f]{32}$/),
}).strict();
const coPlayParticipantSchema = z.object({ peerId: opaqueIdSchema }).strict();
export type CoPlayGrant = z.infer<typeof coPlayGrantSchema>;
export type CoPlayParticipant = z.infer<typeof coPlayParticipantSchema>;
const chatPayloadSchema = z.object({ kind: z.literal("chat"),
text: z.string().min(1).max(MAX_CHAT_CODE_POINTS * 2)
.refine(value => normalizeChatText(value) === value) }).strict();
const reactionPayloadSchema = z.object({ kind: z.literal("reaction"),
reaction: z.string().min(1).max(32).regex(/^[a-z][a-z0-9-]*$/),
targetPeerId: opaqueIdSchema.optional() }).strict()
.refine(payload => !isThrow(payload.reaction) || !!payload.targetPeerId,
{ message: "Throwing a prop requires a participant" });
// Commands require a registered effect; received events may carry a future
// display-only identifier. Identity, payload shape and target bounds stay strict.
export const interactionPayloadSchema = z.discriminatedUnion("kind", [
chatPayloadSchema, reactionPayloadSchema.safeExtend({ reaction: z.enum(REACTION_IDS) }),
]);
const receivedInteractionPayloadSchema = z.discriminatedUnion("kind", [
chatPayloadSchema, reactionPayloadSchema,
]);
export type InteractionPayload = z.infer<typeof interactionPayloadSchema>;
const noMediaRouteUpstreamSchema = z
.object({ kind: z.literal("none") })
.strict();
const peerMediaRouteUpstreamSchema = z
.object({
kind: z.literal("peer"),
peerId: opaqueIdSchema,
})
.strict();
const sfuMediaRouteUpstreamSchema = z
.object({ kind: z.literal("sfu") })
.strict();
export const mediaRouteUpstreamSchema = z.discriminatedUnion("kind", [
noMediaRouteUpstreamSchema,
peerMediaRouteUpstreamSchema,
sfuMediaRouteUpstreamSchema,
]);
export type MediaRouteUpstream = z.infer<typeof mediaRouteUpstreamSchema>;
const activeMediaRouteUpstreamSchema = z.discriminatedUnion("kind", [
peerMediaRouteUpstreamSchema,
sfuMediaRouteUpstreamSchema,
]);
export const viewerPresenceEntrySchema = z
.object({
role: z.literal("viewer"),
peerId: opaqueIdSchema,
displayName: displayNameSchema,
upstream: mediaRouteUpstreamSchema,
mediaReady: z.literal(true).optional(),
})
.strict();
export type ViewerPresenceEntry = z.infer<typeof viewerPresenceEntrySchema>;
export const participantPresenceEntrySchema = z.discriminatedUnion("role", [
z
.object({
role: z.literal("host"),
peerId: opaqueIdSchema,
displayName: displayNameSchema,
upstream: z.object({ kind: z.literal("none") }).strict(),
})
.strict(),
viewerPresenceEntrySchema,
]);
export type ParticipantPresenceEntry = z.infer<
typeof participantPresenceEntrySchema
>;
const tokenSchema = z
.string()
.min(32)
.max(128)
.regex(/^[A-Za-z0-9_-]+$/);
export const viewerGrantSchema = z
.string()
.length(22)
.regex(/^[A-Za-z0-9_-]{21}[AQgw]$/);
export const viewerPasswordSchema = z
.string()
.min(MIN_VIEWER_PASSWORD_LENGTH)
.max(MAX_VIEWER_PASSWORD_LENGTH)
.regex(/^[\x21-\x7e]+$/);
export const codeEntryPolicySchema = z.enum(["open", "private"]);
export type CodeEntryPolicy = z.infer<typeof codeEntryPolicySchema>;
export const roomCodeSchema = z
.string()
.length(ROOM_CODE_LENGTH)
.max(ROOM_CODE_LENGTH)
.regex(/^[1-9]\d*$/);
export const roleSchema = z.enum(["host", "viewer"]);
export type Role = z.infer<typeof roleSchema>;
// Describes a requested ceiling, not encoder availability or an allocation.
// WebRTC uses unsigned-long dimensions/bitrates and a double frame rate.
// Alignment, usable ranges and allocation budgets belong to the media adapter.
export const positiveUint32Schema = z.number().int().positive().max(0xffff_ffff);
export const qualityResolutionSchema = z.object({
width: positiveUint32Schema,
height: positiveUint32Schema,
}).strict();
export type QualityResolution = z.infer<typeof qualityResolutionSchema>;
export const degradationPreferenceSchema = z.enum([
"maintain-resolution",
"balanced",
"maintain-framerate",
]);
export type DegradationPreference = z.infer<
typeof degradationPreferenceSchema
>;
export const MIN_AUDIO_BITRATE = 6_000;
export const MAX_AUDIO_BITRATE = 510_000;
export const maxAudioBitrateSchema = z.number().int().min(MIN_AUDIO_BITRATE).max(MAX_AUDIO_BITRATE);
export const qualitySettingsSchema = z
.object({
resolution: qualityResolutionSchema,
maxFramerate: z.number().positive().max(Number.MAX_SAFE_INTEGER),
maxBitrate: positiveUint32Schema,
degradationPreference: degradationPreferenceSchema,
maxAudioBitrate: maxAudioBitrateSchema.optional(),
})
.strict();
export type QualitySettings = z.infer<typeof qualitySettingsSchema>;
export const DEFAULT_QUALITY_SETTINGS = {
resolution: { width: 1920, height: 1080 },
maxFramerate: 30,
maxBitrate: 5_000_000,
degradationPreference: "balanced",
maxAudioBitrate: 128000,
} as const satisfies QualitySettings;
export const routePolicySchema = z
.object({
peerOnly: z.boolean(),
topologyOptimization: z.boolean(),
natPrediction: z.boolean(),
})
.strict();
export type RoutePolicy = z.infer<typeof routePolicySchema>;
export const viewerRoutePreferenceSchema = z.enum(["auto", "p2p", "sfu"]);
export type ViewerRoutePreference = z.infer<typeof viewerRoutePreferenceSchema>;
export const DEFAULT_ROUTE_POLICY = {
peerOnly: false,
topologyOptimization: true,
natPrediction: false,
} as const satisfies RoutePolicy;
export const runtimeCapabilitiesSchema = z.object({
sfu: z.boolean().default(false),
sfuOnly: z.boolean().optional(),
natPrediction: z.boolean().default(false),
roomInteractions: z.boolean().default(false),
roomVoice: z.boolean().default(false),
roomVoiceListeningPresence: z.boolean().default(false),
roomVoiceBitrate: z.boolean().optional(),
relayVolunteer: z.boolean().default(false),
roomReactionIds: z.array(z.string().max(32).regex(/^[a-z][a-z0-9-]*$/)).max(64).optional(),
hostRoomSession: z.boolean().default(false),
remoteInput: z.boolean().default(false),
viewerRouteSelection: z.boolean().default(false),
audioPresence: z.boolean().default(false),
coPlayPresence: z.boolean().default(false),
});
export type RuntimeCapabilities = z.infer<typeof runtimeCapabilitiesSchema>;
export const relayDownstreamEdgesSchema = z
.number()
.int()
.min(0)
.max(MAX_ENDPOINT_MEDIA_COPY_CAPACITY);
export type RelayDownstreamEdges = z.infer<typeof relayDownstreamEdgesSchema>;
function isValidStunUrl(value: string): boolean {
const schemeSeparator = value.indexOf(":");
if (
schemeSeparator <= 0 ||
value.slice(0, schemeSeparator).toLowerCase() !== "stun"
) {
return false;
}
const authorityText = value.slice(schemeSeparator + 1);
if (
!authorityText ||
/[\\/\s?#]/.test(authorityText) ||
authorityText.endsWith(":")
) {
return false;
}
let authority: URL;
try {
authority = new URL(`http://${authorityText}`);
} catch {
return false;
}
return Boolean(
authority.hostname &&
!authority.username &&
!authority.password &&
authority.pathname === "/" &&
!authority.search &&
!authority.hash &&
(!authority.port || Number(authority.port) > 0),
);
}
export const stunUrlSchema = z
.string()
.min(1)
.max(512)
.refine(isValidStunUrl, { message: "Invalid STUN URL" });
const iceServerSchema = z
.object({
urls: z.union([
stunUrlSchema,
z.array(stunUrlSchema).min(1).max(MAX_ICE_SERVER_URLS),
]),
})
.strict();
export const iceConfigSchema = z
.object({
iceServers: z.array(iceServerSchema).max(8),
natPredictionStunUrls: z
.array(stunUrlSchema)
.max(MAX_NAT_PREDICTION_AUXILIARY_STUN_URLS),
})
.strict();
export type WireIceConfig = z.infer<typeof iceConfigSchema>;
export type IceConfig = {
iceServers: Array<z.infer<typeof iceServerSchema>>;
natPredictionStunUrls?: string[];
};
const sessionDescriptionSchema = z
.object({
type: z.enum(["offer", "answer"]),
sdp: z.string().min(1).max(48 * 1024),
})
.strict();
export const iceCandidateSchema = z
.object({
candidate: z.string().max(4096),
sdpMid: z.string().max(128).nullable().optional(),
sdpMLineIndex: z.number().int().min(0).max(255).nullable().optional(),
usernameFragment: z.string().max(256).nullable().optional(),
})
.strict();
export const voiceDescriptionSchema = z.object({
revision: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
sdp: sessionDescriptionSchema,
tracks: z.array(z.object({ mid: z.string().min(1).max(128), publicationId: opaqueIdSchema }).strict())
.max(MAX_PARTICIPANTS_PER_ROOM_LIMIT * 2),
}).strict();
export type VoiceDescription = z.infer<typeof voiceDescriptionSchema>;
const voiceSignalShape = {
connectionId: opaqueIdSchema,
description: voiceDescriptionSchema.optional(),
candidate: iceCandidateSchema.optional(),
renegotiate: z.literal(true).optional(),
};
export const roomVoiceCommandSchema = z.discriminatedUnion("action", [
z.object({ action: z.literal("join") }).strict(),
z.object({ action: z.literal("leave") }).strict(),
z.object({ action: z.literal("publish") }).strict(),
z.object({ action: z.literal("unpublish"), publicationId: opaqueIdSchema }).strict(),
z.object({ action: z.literal("deafen"), deafened: z.boolean() }).strict(),
z.object({ action: z.literal("bitrate"), bitrate: maxAudioBitrateSchema }).strict(),
]);
export type RoomVoiceCommand = z.infer<typeof roomVoiceCommandSchema>;
export const roomVoiceStateSchema = z.object({
type: z.literal("room-voice-state"),
bitrate: maxAudioBitrateSchema.optional(),
revision: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
enabled: z.boolean(),
hostPeerId: opaqueIdSchema.nullable(),
members: z.array(z.object({ peerId: opaqueIdSchema, connected: z.boolean(), joined: z.boolean(),
upstream: mediaRouteUpstreamSchema, publicationId: opaqueIdSchema.optional(), deafened: z.boolean().optional() }).strict())
.max(MAX_PARTICIPANTS_PER_ROOM_LIMIT),
publications: z.array(z.object({ id: opaqueIdSchema, peerId: opaqueIdSchema }).strict())
.max(MAX_PARTICIPANTS_PER_ROOM_LIMIT),
connections: z.array(z.object({ connectionId: opaqueIdSchema, parentPeerId: opaqueIdSchema.optional(),
childPeerId: opaqueIdSchema, transport: z.enum(["peer", "sfu"]), pending: z.boolean(),
revision: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
send: z.array(opaqueIdSchema).max(MAX_PARTICIPANTS_PER_ROOM_LIMIT),
receive: z.array(opaqueIdSchema).max(MAX_PARTICIPANTS_PER_ROOM_LIMIT),
}).strict()).max(MAX_PARTICIPANTS_PER_ROOM_LIMIT + 1),
unavailable: z.array(opaqueIdSchema).max(MAX_PARTICIPANTS_PER_ROOM_LIMIT),
}).strict();
export type RoomVoiceState = z.infer<typeof roomVoiceStateSchema>;
export type VoiceConnection = RoomVoiceState["connections"][number];
export const punchPredictionSchema = z.object({
address: z.ipv4(),
port: z.number().int().min(1024).max(65535),
step: z.number().int().min(0).max(16),
}).strict().refine(({ port, step }) => port + 4 * step <= 65535);
export type PunchPrediction = z.infer<typeof punchPredictionSchema>;
export const punchSignalSchema = z.discriminatedUnion("phase", [
z.object({ phase: z.literal("prepare"), secret: z.string().regex(/^[0-9a-f]{64}$/) }).strict(),
z.object({ phase: z.literal("ready"), prediction: punchPredictionSchema.optional() }).strict(),
z.object({ phase: z.literal("start"), prediction: punchPredictionSchema }).strict(),
z.object({ phase: z.literal("complete"), connected: z.boolean() }).strict(),
]);
export type PunchSignal = z.infer<typeof punchSignalSchema>;
export const signalPayloadSchema = z.discriminatedUnion("kind", [
z.object({ kind: z.literal("punch"), connectionId: opaqueIdSchema, punch: punchSignalSchema }).strict(),
z
.object({
kind: z.literal("description"),
connectionId: opaqueIdSchema,
description: sessionDescriptionSchema,
punched: z.literal(true).optional(),
})
.strict(),
z
.object({
kind: z.literal("candidate"),
connectionId: opaqueIdSchema,
candidate: iceCandidateSchema.nullable(),
})
.strict(),
]);
export type SignalPayload = z.infer<typeof signalPayloadSchema>;
export const sfuMediaSchema = z.object({
codec: z.enum(["h264", "vp8"]),
layers: z.array(z.object({
rid: z.string().max(16),
width: positiveUint32Schema,
height: positiveUint32Schema,
bitrate: positiveUint32Schema,
}).strict()).min(1).max(3),
audio: z.boolean(),
audioBitrate: z.number().int().min(0).max(MAX_AUDIO_BITRATE),
}).strict().refine((media) =>
(!media.audio || media.audioBitrate > 0) &&
new Set(media.layers.map((layer) => layer.rid)).size === media.layers.length &&
(media.layers.length === 1 || media.layers.every((layer) => layer.rid !== "")),
);
export type SfuMedia = z.infer<typeof sfuMediaSchema>;
const sfuSignalMessageSchema = z.object({
type: z.literal("sfu-signal"),
revision: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
publicationGeneration: opaqueIdSchema,
connectionId: opaqueIdSchema,
kind: z.enum(["subscribe", "description", "candidate", "media", "layers"]),
description: sessionDescriptionSchema.optional(),
candidate: iceCandidateSchema.optional(),
media: sfuMediaSchema.optional(),
activeCount: z.number().int().min(0).max(3).optional(),
}).strict().refine((message) => {
if (message.kind === "layers") return message.activeCount !== undefined && !message.description && !message.candidate && !message.media;
if (message.activeCount !== undefined) return false;
if (message.kind === "media") return Boolean(message.media) && !message.description && !message.candidate;
if (message.kind === "subscribe") return !message.description && !message.candidate && !message.media;
if (message.kind === "candidate") return !message.description && !message.media;
return Boolean(message.description) && !message.candidate && (!message.media || message.description?.type === "offer");
});
export type SfuSignalMessage = z.infer<typeof sfuSignalMessageSchema>;
export const preparedRouteCandidateSchema = z
.object({
childPeerId: opaqueIdSchema,
connectionId: opaqueIdSchema,
transport: z.enum(["direct", "sfu"]),
qualityProbe: z.boolean(),
connectionAttempt: z.object({
current: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
total: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
}).strict().refine(({ current, total }) => current <= total).optional(),
})
.strict();
export type PreparedRouteCandidate = z.infer<
typeof preparedRouteCandidateSchema
>;
export const mediaRouteRevisionSchema = z
.number()
.int()
.min(0)
.max(MAX_MEDIA_ROUTE_REVISION);
export const mediaRoutePhaseSchema = z.enum(["prepare", "active"]);
export type MediaRoutePhase = z.infer<typeof mediaRoutePhaseSchema>;
export const routeDemandReasonSchema = z.enum([
"join",
"edge-unavailable",
"parent-departed",
"capacity-reduction",
"sfu-bootstrap",
"direct-convergence",
"quality-convergence",
"root-convergence",
"publication-attach",
]);
export type RouteDemandReason = z.infer<typeof routeDemandReasonSchema>;
export const routeDiagnosticFinalRouteSchema = z.enum([
"direct",
"sfu",
"waiting",
"failed",
]);
export type RouteDiagnosticFinalRoute = z.infer<
typeof routeDiagnosticFinalRouteSchema
>;
export const routeDiagnosticRejectionBucketSchema = z.enum([
"none",
"stale",
"endpoint-capacity",
"sfu-admission",
"candidate-failed",
"first-frame-timeout",
"operation-deadline",
"aborted",
]);
export type RouteDiagnosticRejectionBucket = z.infer<
typeof routeDiagnosticRejectionBucketSchema
>;
const routeDiagnosticDurationSchema = z
.number()
.int()
.min(0)
.max(Number.MAX_SAFE_INTEGER)
.nullable();
const routeDiagnosticOrdinalSchema = z
.number()
.int()
.min(1)
.max(MAX_VIEWERS_PER_ROOM_LIMIT);
const routeDiagnosticParentSchema = z.discriminatedUnion("kind", [
z.object({ kind: z.literal("none") }).strict(),
z.object({ kind: z.literal("host") }).strict(),
z.object({ kind: z.literal("sfu") }).strict(),
z
.object({
kind: z.literal("viewer"),
ordinal: routeDiagnosticOrdinalSchema,
})
.strict(),
]);
const routeDiagnosticQualityValueSchema = z
.number()
.int()
.min(0)
.max(Number.MAX_SAFE_INTEGER);
const routeDiagnosticQualitySchema = z
.object({
eligibleWindows: routeDiagnosticQualityValueSchema,
eligibleDurationMs: routeDiagnosticQualityValueSchema,
freezeWindows: routeDiagnosticQualityValueSchema,
freezeCount: routeDiagnosticQualityValueSchema,
freezeDurationMs: routeDiagnosticQualityValueSchema,
pauseCount: routeDiagnosticQualityValueSchema,
pauseDurationMs: routeDiagnosticQualityValueSchema,
})
.strict();
const routeDiagnosticChildSchema = z
.object({
ordinal: routeDiagnosticOrdinalSchema,
parent: routeDiagnosticParentSchema,
effectiveCapacity: z
.number()
.int()
.min(0)
.max(MAX_VIEWERS_PER_ROOM_LIMIT),
childCount: z
.number()
.int()
.min(0)
.max(MAX_VIEWERS_PER_ROOM_LIMIT),
demandAgeMs: routeDiagnosticDurationSchema,
queueWaitMs: routeDiagnosticDurationSchema,
candidateStartMs: routeDiagnosticDurationSchema,
firstDecodedFrameMs: routeDiagnosticDurationSchema,
finalMs: routeDiagnosticDurationSchema,
finalRoute: routeDiagnosticFinalRouteSchema,
rejectionBucket: routeDiagnosticRejectionBucketSchema,
quality: routeDiagnosticQualitySchema.nullable(),
})
.strict();
const routeDiagnosticOperationSchema = z
.object({
childOrdinal: routeDiagnosticOrdinalSchema,
reason: routeDemandReasonSchema,
stage: z.enum(["admission", "first-frame", "quality-proof"]),
cursor: z.number().int().min(0).max(MAX_VIEWERS_PER_ROOM_LIMIT),
candidateCount: z.number().int().min(1).max(MAX_VIEWERS_PER_ROOM_LIMIT + 1),
})
.strict();
export const routeDiagnosticSnapshotSchema = z
.object({
children: z
.array(routeDiagnosticChildSchema)
.max(MAX_VIEWERS_PER_ROOM_LIMIT),
operation: routeDiagnosticOperationSchema.nullable(),
})
.strict()
.superRefine((snapshot, context) => {
const ordinals = new Set(snapshot.children.map((child) => child.ordinal));
if (ordinals.size !== snapshot.children.length) {
context.addIssue({
code: "custom",
message: "Route diagnostic ordinals must be unique",
path: ["children"],
});
return;
}
for (const [index, child] of snapshot.children.entries()) {
if (
child.parent.kind === "viewer" &&
(!ordinals.has(child.parent.ordinal) ||
child.parent.ordinal === child.ordinal)
) {
context.addIssue({
code: "custom",
message: "Route diagnostic parent ordinal is invalid",
path: ["children", index, "parent"],
});
}
}
if (
snapshot.operation &&
(!ordinals.has(snapshot.operation.childOrdinal) ||
snapshot.operation.cursor >= snapshot.operation.candidateCount)
) {
context.addIssue({
code: "custom",
message: "Route diagnostic operation is invalid",
path: ["operation"],
});
}
});
export type RouteDiagnosticSnapshot = z.infer<
typeof routeDiagnosticSnapshotSchema
>;
export const sfuPublicationGenerationSchema = opaqueIdSchema;
export const participantRouteAssignmentSchema = z
.object({
upstream: mediaRouteUpstreamSchema,
childPeerIds: z
.array(opaqueIdSchema)
.max(MAX_VIEWERS_PER_ROOM_LIMIT)
.refine((peerIds) => new Set(peerIds).size === peerIds.length),
sfuPublicationGeneration: sfuPublicationGenerationSchema.nullable(),
})
.strict()
.superRefine((assignment, context) => {
if (
assignment.upstream.kind === "sfu" &&
assignment.sfuPublicationGeneration === null
) {
context.addIssue({
code: "custom",
message: "An SFU upstream requires its publication generation",
path: ["sfuPublicationGeneration"],
});
}
if (
assignment.upstream.kind === "peer" &&
assignment.sfuPublicationGeneration !== null
) {
context.addIssue({
code: "custom",
message: "A peer upstream cannot own an SFU publication generation",
path: ["sfuPublicationGeneration"],
});
}
});
export type ParticipantRouteAssignment = z.infer<
typeof participantRouteAssignmentSchema
>;
const nullableEvidenceNumber = (maximum: number) =>
z.number().finite().min(0).max(maximum).nullable();
const nullableSignedEvidenceNumber = (absoluteMaximum: number) =>
z.number().finite().min(-absoluteMaximum).max(absoluteMaximum).nullable();
export const nullableSafeEvidenceNumber = z
.number()
.finite()
.min(0)
.max(Number.MAX_SAFE_INTEGER)
.nullable();
export const nullableSafeEvidenceInteger = z
.number()
.int()
.min(0)
.max(Number.MAX_SAFE_INTEGER)
.nullable();
export const viewerQualityEvidenceMetricsSchema = z
.object({
natTraversalPath: z.enum(NAT_TRAVERSAL_PATHS),
width: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER).nullable(),
height: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER).nullable(),
framesPerSecond: nullableSafeEvidenceNumber,
bitrateKbps: nullableSafeEvidenceNumber,
packetsReceivedDelta: nullableSafeEvidenceInteger,
packetsLostDelta: nullableSafeEvidenceInteger,
rttMs: nullableSafeEvidenceNumber,
jitterMs: nullableSafeEvidenceNumber,
framesDecodedDelta: nullableSafeEvidenceInteger,
framesDroppedDelta: nullableSafeEvidenceInteger,
decodeMsPerFrame: nullableSafeEvidenceNumber,
freezeCountDelta: nullableSafeEvidenceInteger,
freezeDurationMsDelta: nullableSafeEvidenceNumber,
pauseCountDelta: nullableSafeEvidenceInteger,
pauseDurationMsDelta: nullableSafeEvidenceNumber,
codec: z
.string()
.max(64)
.regex(/^video\/[A-Za-z0-9.+-]{1,32}$/i)
.nullable(),
codecProfile: z
.string()
.max(64)
.regex(/^[a-z0-9-]+=[a-z0-9]+$/)
.nullable(),
codecParameters: z
.string()
.max(128)
.regex(/^[a-z0-9-]+=[a-z0-9]+(?:; [a-z0-9-]+=[a-z0-9]+)*$/)
.nullable(),
audioBitrateKbps: nullableSafeEvidenceNumber,
audioPacketLossPercent: nullableEvidenceNumber(100),
audioJitterMs: nullableSafeEvidenceNumber,
audioVideoPlayoutDeltaMs: nullableSignedEvidenceNumber(Number.MAX_SAFE_INTEGER),
videoJitterBufferDelayMs: nullableSafeEvidenceNumber,
audioJitterBufferDelayMs: nullableSafeEvidenceNumber,
audioConcealedSamplesPercent: nullableEvidenceNumber(100),
audioConcealmentEventsDelta: nullableSafeEvidenceInteger,
audioCodec: z
.string()
.max(64)
.regex(/^audio\/[A-Za-z0-9.+-]{1,32}$/i)
.nullable(),
})
.strict()
.refine(
(metrics) =>
(metrics.width === null && metrics.height === null) ||
(metrics.width !== null && metrics.height !== null),
{ message: "Viewer quality dimensions must be present together" },
)
.refine(isCanonicalVideoCodecEvidence, {
message: "Viewer codec evidence is not canonical",
path: ["codecParameters"],
});
export type ViewerQualityEvidenceMetrics = z.infer<
typeof viewerQualityEvidenceMetricsSchema
>;
const viewerQualityEvidenceGuardSchema = z
.object({
connectionId: opaqueIdSchema,
routeRevision: mediaRouteRevisionSchema,
presentationEpoch: z
.number()
.int()
.min(0)
.max(Number.MAX_SAFE_INTEGER),
})
.strict();
const viewerQualityEvidenceWindowShape = {
sequence: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
windowMs: z.number().int().min(1_000).max(5_000),
metrics: viewerQualityEvidenceMetricsSchema,
};
const senderQualityDiagnosticsSchema = z
.object({
natTraversalPath: z.enum(NAT_TRAVERSAL_PATHS),
reason: z.enum(["none", "bandwidth", "cpu"]).nullable(),
framesPerSecond: nullableSafeEvidenceNumber,
bitrateKbps: nullableSafeEvidenceNumber,
captureFramesPerSecond: nullableSafeEvidenceNumber.optional(),
mediaSourceFramesPerSecond: nullableSafeEvidenceNumber.optional(),
width: nullableSafeEvidenceInteger.optional(),
height: nullableSafeEvidenceInteger.optional(),
videoEncodingCount: nullableSafeEvidenceInteger.optional(),
activeVideoEncodingCount: nullableSafeEvidenceInteger.optional(),
availableOutgoingKbps: nullableSafeEvidenceNumber.optional(),
rttMs: nullableSafeEvidenceNumber.optional(),
packetLossPercent: nullableEvidenceNumber(100).optional(),
})
.strict();
export const viewerQualityEvidenceMessageSchema = z
.object({
type: z.literal("viewer-quality-evidence"),
guard: viewerQualityEvidenceGuardSchema,
...viewerQualityEvidenceWindowShape,
})
.strict();
export const senderQualityEvidenceMessageSchema = z
.object({
type: z.literal("sender-quality-evidence"),
childPeerId: opaqueIdSchema,
connectionId: opaqueIdSchema,
rtpStatsId: z.string().min(1).max(256).nullable(),
trackIdentifier: z.string().min(1).max(256).nullable(),
sampleTimestampMs: z
.number()
.finite()
.min(0)
.max(Number.MAX_SAFE_INTEGER)
.nullable(),
routeRevision: mediaRouteRevisionSchema,
state: z.enum(["unknown", "healthy", "degraded"]),
diagnostics: senderQualityDiagnosticsSchema,
})
.strict()
.superRefine((message, context) => {
if (
(message.state !== "unknown" &&
(message.rtpStatsId === null ||
message.trackIdentifier === null ||
message.sampleTimestampMs === null))
) {
context.addIssue({
code: "custom",
message: "Known sender quality needs exact RTP identity",
path: ["rtpStatsId"],
});
}
const reason = message.diagnostics.reason;
if (
(message.state === "healthy" && reason !== "none") ||
(message.state === "degraded" &&
reason !== "bandwidth" &&
reason !== "cpu") ||
(message.state === "unknown" && reason !== null)
) {
context.addIssue({
code: "custom",
message: "Sender quality reason must match its native state",
path: ["diagnostics", "reason"],
});
}
});
export const sfuPublisherQualityEvidenceMessageSchema = z
.object({
type: z.literal("sfu-publisher-quality-evidence"),
publicationGeneration: opaqueIdSchema,
routeRevision: mediaRouteRevisionSchema,
state: z.enum(["unknown", "healthy", "degraded"]),
sampleTimestampMs: z
.number()
.finite()
.min(0)
.max(Number.MAX_SAFE_INTEGER)
.nullable(),
diagnostics: senderQualityDiagnosticsSchema,
})
.strict()
.superRefine((message, context) => {
if (message.state !== "unknown" && message.sampleTimestampMs === null) {
context.addIssue({
code: "custom",
message: "Known SFU publisher quality needs an exact sample",
path: ["sampleTimestampMs"],
});
}
const reason = message.diagnostics.reason;
if (
(message.state === "healthy" && reason !== "none") ||
(message.state === "degraded" &&
reason !== "bandwidth" &&
reason !== "cpu") ||
(message.state === "unknown" && reason !== null)
) {
context.addIssue({
code: "custom",
message: "SFU publisher reason must match its native state",
path: ["diagnostics", "reason"],
});
}
});
const authenticateMessageSchema = z.discriminatedUnion("role", [
z
.object({
type: z.literal("authenticate"),
protocol: z.literal(SIGNALING_PROTOCOL),
roomId: roomCodeSchema,
role: z.literal("host"),
token: tokenSchema,
clientId: opaqueIdSchema,
shareGeneration: opaqueIdSchema.optional(),
roomOnly: z.literal(true).optional(),
roomSession: z.literal(true).optional(),
sharingPaused: z.boolean().optional(),
qualitySettings: qualitySettingsSchema.optional(),
routePolicy: routePolicySchema.default(DEFAULT_ROUTE_POLICY),
viewerPresence: z.literal(true).optional(),
displayName: displayNameSchema.optional(),
})
.strict()
.superRefine((message, context) => {
if (message.roomOnly === true && message.roomSession !== true) {
context.addIssue({
code: "custom",
message: "roomOnly requires roomSession",
path: ["roomOnly"],
});
}
}),
z
.object({
type: z.literal("authenticate"),
protocol: z.literal(SIGNALING_PROTOCOL),
roomId: roomCodeSchema,
role: z.literal("viewer"),
clientId: opaqueIdSchema,
viewerGrant: viewerGrantSchema.optional(),
viewerPassword: viewerPasswordSchema.optional(),
routePreference: viewerRoutePreferenceSchema.optional(),
displayName: displayNameSchema.optional(),
viewerPresence: z.literal(true).optional(),
})
.strict(),
]);
const signalingChallengeSequenceSchema = z
.number()
.int()
.min(0)
.max(Number.MAX_SAFE_INTEGER);
export const clientMessageSchema = z.union([
z.object({ type: z.literal("set-relay-volunteer"), enabled: z.boolean(), capacity: z.number().int().min(0).max(MAX_VIEWERS_PER_ROOM_LIMIT) }).strict(),
z.object({ type: z.literal("subscribe-room-voice"), deafened: z.boolean().optional(), bitrate: z.literal(true).optional() }).strict(),
z.object({ type: z.literal("room-voice-command"), command: roomVoiceCommandSchema }).strict(),
z.object({ type: z.literal("room-voice-signal"), ...voiceSignalShape }).strict()
.refine(value => Number(!!value.description) + Number(!!value.candidate) + Number(!!value.renegotiate) === 1),
z.object({ type: z.literal("room-voice-transport"), connectionId: opaqueIdSchema,
state: z.enum(["connected", "failed"]) }).strict(),
z.object({ type: z.literal("set-viewer-route-preference"), preference: viewerRoutePreferenceSchema }).strict(),
z.object({ type: z.literal("subscribe-audio-presence") }).strict(),
z.object({ type: z.literal("subscribe-co-play-presence") }).strict(),
z.object({ type: z.literal("set-co-play-presence"), shareGeneration: opaqueIdSchema,
grants: z.array(coPlayGrantSchema).max(MAX_VIEWERS_PER_ROOM_LIMIT)
.refine(grants => new Set(grants.map(grant => grant.endpointId)).size === grants.length) }).strict(),
z.object({ type: z.literal("set-audio-presence"), shareGeneration: opaqueIdSchema, available: z.boolean() }).strict(),
z.object({ type: z.literal("subscribe-remote-input"), endpointId: z.string().regex(/^[0-9a-f]{32}$/).optional(),
secret: z.string().regex(/^[0-9a-f]{64}$/).optional() }).strict(),
z.object({ type: z.literal("subscribe-room-interactions") }).strict(),
z.object({ type: z.literal("send-room-interaction"), requestId: opaqueIdSchema,
payload: interactionPayloadSchema }).strict(),
authenticateMessageSchema,
z
.object({
type: z.literal("signaling-challenge"),
sequence: signalingChallengeSequenceSchema,
})
.strict(),
z
.object({
type: z.literal("signal"),
targetPeerId: opaqueIdSchema.optional(),
payload: signalPayloadSchema,
})
.strict(),
z
.object({
type: z.literal("restart-request"),
targetPeerId: opaqueIdSchema.optional(),
connectionId: opaqueIdSchema,
rebuild: z.boolean(),
})
.strict(),
z
.object({
type: z.literal("set-quality-settings"),
qualitySettings: qualitySettingsSchema,
})
.strict(),
z
.object({
type: z.literal("relay-capacity"),
downstreamEdges: relayDownstreamEdgesSchema,
})
.strict(),
z
.object({
type: z.literal("route-ready"),
revision: mediaRouteRevisionSchema,
phase: mediaRoutePhaseSchema,
qualityApproved: z.literal(true).optional(),
})
.strict(),
z
.object({
type: z.literal("route-transport-connected"),
revision: mediaRouteRevisionSchema,
connectionId: opaqueIdSchema,
})
.strict(),
z
.object({
type: z.literal("route-media-unavailable"),
revision: mediaRouteRevisionSchema,
})
.strict(),
z
.object({
type: z.literal("route-failed"),
revision: mediaRouteRevisionSchema,
phase: mediaRoutePhaseSchema,
connectionId: opaqueIdSchema.nullable(),
})
.strict(),
z
.object({
type: z.literal("refresh-sfu"),
revision: mediaRouteRevisionSchema,
})
.strict(),
sfuSignalMessageSchema,
z.object({ type: z.literal("request-route-diagnostic") }).strict(),
viewerQualityEvidenceMessageSchema,
senderQualityEvidenceMessageSchema,
sfuPublisherQualityEvidenceMessageSchema,
z.object({ type: z.literal("reset-sender-quality") }).strict(),
z
.object({
type: z.literal("set-display-name"),
displayName: displayNameSchema,
})
.strict(),
z
.object({
type: z.literal("set-sharing-paused"),
shareGeneration: opaqueIdSchema,
paused: z.boolean(),
})
.strict(),
z
.object({
type: z.literal("stop-sharing"),
shareGeneration: opaqueIdSchema.optional(),
})
.strict(),
z
.object({
type: z.literal("start-sharing"),
shareGeneration: opaqueIdSchema,
sharingPaused: z.boolean().optional(),
qualitySettings: qualitySettingsSchema.optional(),
routePolicy: routePolicySchema,
})
.strict(),
z.object({ type: z.literal("abandon-room") }).strict(),
]);
export type ClientMessage = z.infer<typeof clientMessageSchema>;
const errorCodeSchema = z.enum([
"AUTH_REQUIRED",
"INVALID_MESSAGE",
"INVALID_TOKEN",
"ROOM_ACCESS_DENIED",
"ROOM_NOT_FOUND",
"ROOM_FULL",
"HOST_ALREADY_CONNECTED",
"PEER_NOT_FOUND",
"FORBIDDEN",
"SERVER_ERROR",
]);
const authenticatedMessageShape = {
type: z.literal("authenticated"),
protocol: z.literal(SIGNALING_PROTOCOL),
peerId: opaqueIdSchema,
maxViewers: z.number().int().min(1).max(MAX_VIEWERS_PER_ROOM_LIMIT),
endpointMediaCopyCapacity: z
.number()
.int()
.min(1)
.max(MAX_ENDPOINT_MEDIA_COPY_CAPACITY),
hostOnline: z.boolean(),
hostPaused: z.boolean().optional(),
connectionId: opaqueIdSchema.nullable(),
iceConfig: iceConfigSchema,
routePolicy: routePolicySchema.default(DEFAULT_ROUTE_POLICY),
codeEntryPolicy: codeEntryPolicySchema,
viewerAuthorizationGeneration: opaqueIdSchema,
};
const authenticatedHostMessageShape = {
...authenticatedMessageShape,
role: z.literal("host"),
viewerPasswordEnabled: z.boolean(),
};
const authenticatedViewerMessageShape = {
...authenticatedMessageShape,
role: z.literal("viewer"),
};
const routeAuthenticatedShape = {
mediaMode: z.literal("peer-assisted"),
shareGeneration: opaqueIdSchema.nullable(),
routeRevision: mediaRouteRevisionSchema,
routeAssignment: participantRouteAssignmentSchema,
qualitySettings: qualitySettingsSchema,
};
const authenticatedMessageSchema = z.union([
z
.object({
...authenticatedHostMessageShape,
...routeAuthenticatedShape,
})
.strict(),
z
.object({
...authenticatedViewerMessageShape,
...routeAuthenticatedShape,
})
.strict(),
]);
export const serverMessageSchema = z.union([
z.object({ type: z.literal("relay-volunteer"), enabled: z.boolean(), capacity: z.number().int().min(0).max(MAX_VIEWERS_PER_ROOM_LIMIT) }).strict(),
roomVoiceStateSchema,
z.object({ type: z.literal("room-voice-signal"), ...voiceSignalShape }).strict()
.refine(value => Number(!!value.description) + Number(!!value.candidate) + Number(!!value.renegotiate) === 1),
z.object({ type: z.literal("room-voice-error"),
code: z.enum(["not-allowed", "not-enabled", "connection-unavailable"]) }).strict(),
z.object({ type: z.literal("viewer-route-preference"), preference: viewerRoutePreferenceSchema, accepted: z.boolean() }).strict(),
z.object({ type: z.literal("audio-presence"), available: z.boolean().nullable() }).strict(),
z.object({ type: z.literal("co-play-presence"), participants: z.array(coPlayParticipantSchema).max(MAX_VIEWERS_PER_ROOM_LIMIT)
.refine(participants => new Set(participants.map(person => person.peerId)).size === participants.length) }).strict(),
z.object({ type: z.literal("remote-input-peers"), peers: z.array(z.object({ peerId: opaqueIdSchema,
endpointId: z.string().regex(/^[0-9a-f]{32}$/), secret: z.string().regex(/^[0-9a-f]{64}$/) }).strict()).max(MAX_VIEWERS_PER_ROOM_LIMIT) }).strict(),
z.object({ type: z.literal("room-interactions-ready"), serverTime: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER) }).strict(),
z.object({ type: z.literal("room-interaction-rejected"), requestId: opaqueIdSchema,
reason: z.enum(["rate-limited", "target-unavailable", "not-subscribed", "busy"]) }).strict(),
z.object({ type: z.literal("room-interaction"), id: opaqueIdSchema, requestId: opaqueIdSchema,
occurredAt: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
sender: z.object({ peerId: opaqueIdSchema, role: z.enum(["host", "viewer"]), displayName: displayNameSchema }).strict(),
payload: receivedInteractionPayloadSchema }).strict(),
authenticatedMessageSchema,
z.object({
type: z.literal("sharing-start-failed"),
shareGeneration: opaqueIdSchema,
code: z.enum(["FORBIDDEN", "SERVER_ERROR"]),
}).strict(),
z
.object({
type: z.literal("sharing-started"),
shareGeneration: opaqueIdSchema,
routePolicy: routePolicySchema,
routeRevision: mediaRouteRevisionSchema,
routeAssignment: participantRouteAssignmentSchema,
qualitySettings: qualitySettingsSchema,
paused: z.boolean(),
})
.strict(),
z
.object({
type: z.literal("signaling-challenge-response"),
sequence: signalingChallengeSequenceSchema,
})
.strict(),
z
.object({
type: z.literal("signal"),
fromPeerId: opaqueIdSchema,
payload: signalPayloadSchema,
})
.strict(),
z
.object({
type: z.literal("restart-request"),
fromPeerId: opaqueIdSchema,
connectionId: opaqueIdSchema,
rebuild: z.boolean(),
})
.strict(),
z.discriminatedUnion("phase", [
z
.object({
type: z.literal("route-update"),
revision: mediaRouteRevisionSchema,
phase: z.literal("prepare"),
assignment: participantRouteAssignmentSchema,
candidate: preparedRouteCandidateSchema,
})
.strict(),
z
.object({
type: z.literal("route-update"),
revision: mediaRouteRevisionSchema,
phase: z.literal("active"),
assignment: participantRouteAssignmentSchema,
})
.strict(),
]),
z.discriminatedUnion("state", [
z
.object({
type: z.literal("route-status"),
revision: mediaRouteRevisionSchema,
state: z.literal("waiting"),
reason: z.literal("sfu-admission"),
})
.strict(),
z
.object({
type: z.literal("route-status"),
revision: mediaRouteRevisionSchema,
state: z.literal("failed"),
reason: z.literal("route-exhausted"),
})
.strict(),
]),
z
.object({
type: z.literal("route-diagnostic-snapshot"),
snapshot: routeDiagnosticSnapshotSchema,
})
.strict(),
z
.object({
type: z.literal("sfu-config"),
revision: mediaRouteRevisionSchema,
publicationGeneration: opaqueIdSchema,
connectionId: opaqueIdSchema,
})
.strict(),
sfuSignalMessageSchema,
z
.object({
type: z.literal("quality-settings"),
qualitySettings: qualitySettingsSchema,
})
.strict(),
z
.object({
type: z.literal("route-policy"),
shareGeneration: opaqueIdSchema,
routePolicy: routePolicySchema,
})
.strict(),
z
.object({
type: z.literal("pause-sharing-source"),
shareGeneration: opaqueIdSchema,
})
.strict(),
z
.object({
type: z.literal("viewer-quality-evidence"),
viewerPeerId: opaqueIdSchema,
upstream: activeMediaRouteUpstreamSchema,
guard: viewerQualityEvidenceGuardSchema,
...viewerQualityEvidenceWindowShape,
})
.strict(),
z
.object({
type: z.literal("host-status"),
online: z.boolean(),
paused: z.boolean(),
})
.strict(),
z
.object({
type: z.literal("viewer-presence"),
viewers: z
.array(participantPresenceEntrySchema)
.max(MAX_PARTICIPANTS_PER_ROOM_LIMIT),
})
.strict()
.superRefine((message, context) => {
const peerIds = new Set<string>();
for (const viewer of message.viewers) {
if (peerIds.has(viewer.peerId)) {
context.addIssue({
code: "custom",
message: "Viewer presence peer IDs must be unique",
path: ["viewers"],
});
return;
}
peerIds.add(viewer.peerId);
}
}),
z
.object({
type: z.literal("viewer-grant-revoked"),
viewerAuthorizationGeneration: opaqueIdSchema,
})
.strict(),
z.object({ type: z.literal("sharing-stopped") }).strict(),
z
.object({
type: z.literal("room-closed"),
reason: z.literal("host-ended"),
})
.strict(),
z
.object({
type: z.literal("error"),
code: errorCodeSchema,
message: z.string().min(1).max(256),
})
.strict(),
]);
export type ServerMessage = z.infer<typeof serverMessageSchema>;
export const createRoomResponseSchema = z
.object({
roomId: roomCodeSchema,
hostToken: tokenSchema,
inviteUrl: z.string().url().max(2048),
codeEntryPolicy: codeEntryPolicySchema,
})
.strict();
export type CreateRoomResponse = z.infer<typeof createRoomResponseSchema>;
export const createRoomRequestSchema = z
.object({
codeEntryPolicy: codeEntryPolicySchema,
roomPassword: viewerPasswordSchema.nullable().optional(),
preferredRoomId: roomCodeSchema.optional(),
})
.strict();
export const replaceRoomRequestSchema = z
.object({
codeEntryPolicy: codeEntryPolicySchema,
roomPassword: viewerPasswordSchema.nullable().optional(),
})
.strict();
export type ReplaceRoomRequest = z.infer<typeof replaceRoomRequestSchema>;
export const roomAccessUpdateRequestSchema = z.discriminatedUnion("action", [
z
.object({
action: z.literal("set-code-entry-policy"),
policy: codeEntryPolicySchema,
})
.strict(),
z.object({ action: z.literal("rotate-viewer-grant") }).strict(),
z.object({ action: z.literal("revoke-viewer-grant") }).strict(),
z
.object({
action: z.literal("set-viewer-password"),
password: viewerPasswordSchema.nullable(),
})
.strict(),
]);
export type RoomAccessUpdateRequest = z.infer<
typeof roomAccessUpdateRequestSchema
>;
export const roomAccessUpdateResponseSchema = z.discriminatedUnion("type", [
z
.object({
type: z.literal("code-entry-policy-updated"),
codeEntryPolicy: codeEntryPolicySchema,
viewerPasswordEnabled: z.boolean(),
})
.strict(),
z
.object({
type: z.literal("viewer-grant-updated"),
viewerAuthorizationGeneration: opaqueIdSchema,
inviteUrl: z.string().url().max(2048).nullable(),
})
.strict(),
z
.object({
type: z.literal("viewer-password-updated"),
enabled: z.boolean(),
})
.strict(),
]);
export type RoomAccessUpdateResponse = z.infer<
typeof roomAccessUpdateResponseSchema
>;
export function decodeClientMessage(value: string): ClientMessage {
return clientMessageSchema.parse(JSON.parse(value));
}
export function decodeServerMessage(value: string): ServerMessage {
return serverMessageSchema.parse(JSON.parse(value));
}