agent-protocols 0.2.3 → 0.3.1

package/dist/discourse.js

@@ -1,8 +1,19 @@
+/**
+ * Agent Discourse Protocol 1.0: kernel types, the room type system, and
+ * verification helpers.
+ *
+ * The protocol defines nine built-in event types. Every other event type is
+ * declared per room as a schema-validated type definition, either inline or
+ * imported from a type pack. Hosts validate structure and permissions; they
+ * never need to understand application semantics.
+ */
+import { Validator } from "@cfworker/json-schema";
 import canonicalize from "canonicalize";
 import { createHash } from "node:crypto";
 import { protocolError } from "./errors.js";
 import { createEvent, verifyEnvelope, withRoomId, } from "./identity.js";
 export const DISCOURSE_PROTOCOL = "agent-discourse/1.0";
+/** The nine built-in event types. All other types are room-defined. */
 export const eventType = {
     ROOM_CREATE: "room.create",
     ROOM_JOIN: "room.join",
@@ -11,147 +22,309 @@ export const eventType = {
     ROOM_MEMBER_ROLE_UPDATE: "room.member.role.update",
     ROOM_CLOSE: "room.close",
     ROOM_CANCEL: "room.cancel",
+    TYPE_DEFINE: "type.define",
     MESSAGE_CREATE: "message.create",
-    REACTION_CREATE: "reaction.create",
-    MESSAGE_PROPOSAL_CREATE: "message.proposal.create",
-    MESSAGE_POLL_CREATE: "message.poll.create",
-    MESSAGE_POLL_VOTE: "message.poll.vote",
-    MESSAGE_RESOLUTION_CREATE: "message.resolution.create",
-    SOURCE_ADD: "source.add",
-    TURN_UPDATE: "turn.update",
-    QUESTION_CREATE: "question.create",
-    ROOM_STEER: "room.steer",
-    MAP_UPDATE: "map.update",
-    ARTIFACT_CREATE: "artifact.create",
-    SESSION_OFFER: "session.offer",
-    SESSION_ANSWER: "session.answer",
-    SESSION_CANDIDATE: "session.candidate",
-    SESSION_CLOSE: "session.close",
 };
-const sessionMediaKinds = new Set([
-    "audio",
-    "video",
-    "screen",
-    "data",
-    "file",
-]);
+export const BUILTIN_EVENT_TYPES = Object.values(eventType);
+/** Custom event types must not use these prefixes. */
+export const RESERVED_TYPE_PREFIXES = ["room.", "type."];
+/** Registered type packs defined by the specification in `1.0.packs.json`. */
+export const packId = {
+    REACTIONS: "adp:reactions/1.0",
+    DELIBERATION: "adp:deliberation/1.0",
+    CURATION: "adp:curation/1.0",
+    MODERATION: "adp:moderation/1.0",
+    REALTIME: "adp:realtime/1.0",
+};
+export const REGISTERED_PACK_IDS = Object.values(packId);
+/** Indexes the packs of a document by pack id for registry materialization. */
+export function packMap(document) {
+    const packs = {};
+    for (const pack of document.packs)
+        packs[pack.id] = pack;
+    return packs;
+}
 export function roomCreateEvent(actor, createdAt, nonce, payload) {
     return createEvent(DISCOURSE_PROTOCOL, eventType.ROOM_CREATE, actor, createdAt, nonce, payload);
 }
+export function typeDefineEvent(actor, createdAt, nonce, roomId, declaration) {
+    return withRoomId(createEvent(DISCOURSE_PROTOCOL, eventType.TYPE_DEFINE, actor, createdAt, nonce, declaration), roomId);
+}
 export function discourseEvent(type, actor, createdAt, nonce, roomId, payload) {
     return withRoomId(createEvent(DISCOURSE_PROTOCOL, type, actor, createdAt, nonce, payload), roomId);
 }
+export function isBuiltinEventType(type) {
+    return BUILTIN_EVENT_TYPES.includes(type);
+}
+export function eventRequiresRoomId(type) {
+    return type !== eventType.ROOM_CREATE;
+}
 export function validateDiscourseEnvelope(envelope) {
     verifyEnvelope(envelope);
     const protocol = envelope.event.protocol;
     if (protocol !== DISCOURSE_PROTOCOL) {
         throw protocolError("invalid_event_protocol", `expected ${DISCOURSE_PROTOCOL}, got ${protocol}`);
     }
-    if (eventRequiresRoomId(envelope.event.type) &&
-        envelope.event.room_id === undefined) {
+    if (envelope.event.type === eventType.ROOM_CREATE) {
+        if (envelope.event.room_id !== undefined) {
+            throw protocolError("invalid_event", "room.create must not include room_id");
+        }
+    }
+    else if (envelope.event.room_id === undefined) {
         throw protocolError("missing_room_id", "event requires a room_id");
     }
 }
 export function validateRoomPath(envelope, pathRoomId) {
     const actual = envelope.event.room_id;
-    if (actual === undefined && envelope.event.type === eventType.ROOM_CREATE)
+    if (envelope.event.type === eventType.ROOM_CREATE) {
+        if (actual !== undefined) {
+            throw protocolError("invalid_event", "room.create must not include room_id");
+        }
         return;
+    }
     if (actual === undefined)
         throw protocolError("missing_room_id", "event requires a room_id");
     if (actual !== pathRoomId)
         throw protocolError("room_id_mismatch", `expected ${pathRoomId}, got ${actual}`);
 }
-export function eventRequiresRoomId(type) {
-    return type !== eventType.ROOM_CREATE;
+/**
+ * Checks the shape of a custom event type name: lowercase dot-separated, at
+ * least two segments, not built-in, not under a reserved prefix.
+ */
+export function validateCustomEventTypeName(name) {
+    const segments = name.split(".");
+    const validShape = segments.length >= 2 &&
+        segments.every((segment) => /^[a-z0-9][a-z0-9_-]*$/.test(segment));
+    if (!validShape) {
+        throw protocolError("invalid_event", `invalid event type name: ${name}`);
+    }
+    if (isBuiltinEventType(name)) {
+        throw protocolError("invalid_event", `${name} is a built-in event type`);
+    }
+    if (RESERVED_TYPE_PREFIXES.some((prefix) => name.startsWith(prefix))) {
+        throw protocolError("invalid_event", `${name} uses a reserved type prefix`);
+    }
+}
+export function isPackImport(declaration) {
+    return (typeof declaration === "object" &&
+        declaration !== null &&
+        ("use" in declaration || "pack" in declaration || "digest" in declaration));
+}
+export function isTypeDef(declaration) {
+    return (typeof declaration === "object" &&
+        declaration !== null &&
+        !isPackImport(declaration) &&
+        "type" in declaration);
+}
+export function validateTypeDef(def) {
+    validateCustomEventTypeName(def.type);
+    if (!["message", "signal", "control"].includes(def.kind)) {
+        throw protocolError("invalid_event", `invalid type kind: ${def.kind}`);
+    }
+    if (typeof def.title !== "string" || def.title.trim() === "") {
+        throw protocolError("invalid_event", "type definition title must not be empty");
+    }
+    if (typeof def.schema !== "object" ||
+        def.schema === null ||
+        Array.isArray(def.schema)) {
+        throw protocolError("invalid_event", "type definition schema must be a JSON Schema object");
+    }
+    compileSchema(def.schema);
+    if (def.roles !== undefined && def.roles.length === 0) {
+        throw protocolError("invalid_event", "type definition roles must not be empty");
+    }
+    for (const hint of [def.rate_hint, def.max_payload_hint]) {
+        if (hint !== undefined && (!Number.isInteger(hint) || hint < 1)) {
+            throw protocolError("invalid_event", "type definition hints must be positive integers");
+        }
+    }
+}
+export function validatePackImport(declaration) {
+    const hasUse = declaration.use !== undefined;
+    const hasExternal = declaration.pack !== undefined && declaration.digest !== undefined;
+    if (hasUse) {
+        if (declaration.pack !== undefined || declaration.digest !== undefined) {
+            throw protocolError("invalid_event", "pack import requires either use, or pack with digest");
+        }
+        if (!isRegisteredPackId(declaration.use)) {
+            throw protocolError("invalid_event", `invalid registered pack id: ${declaration.use}`);
+        }
+    }
+    else if (hasExternal) {
+        if (declaration.digest.trim() === "") {
+            throw protocolError("invalid_event", "external pack digest must not be empty");
+        }
+    }
+    else {
+        throw protocolError("invalid_event", "pack import requires either use, or pack with digest");
+    }
+    if (declaration.types !== undefined && declaration.types.length === 0) {
+        throw protocolError("invalid_event", "pack import types subset must not be empty");
+    }
+}
+export function validateTypeDeclaration(declaration) {
+    if (isPackImport(declaration)) {
+        validatePackImport(declaration);
+    }
+    else if (isTypeDef(declaration)) {
+        validateTypeDef(declaration);
+    }
+    else {
+        throw protocolError("invalid_event", "type declaration must be an inline definition or a pack import");
+    }
+}
+function isRegisteredPackId(id) {
+    return /^adp:[a-z0-9-]+\/[0-9]+\.[0-9]+$/.test(id);
 }
 export function validateRoomCreatePayload(payload) {
     if (payload.topic.trim() === "") {
-        throw protocolError("invalid_room", "room topic must not be empty");
+        throw protocolError("invalid_event", "room topic must not be empty");
     }
     if (payload.start_time >= payload.end_time) {
-        throw protocolError("invalid_room", "start_time must be before end_time");
+        throw protocolError("invalid_event", "start_time must be before end_time");
+    }
+    const maxSpeakers = payload.policy?.max_speakers;
+    if (maxSpeakers !== undefined &&
+        (!Number.isInteger(maxSpeakers) || maxSpeakers < 1)) {
+        throw protocolError("invalid_event", "max_speakers must be a positive integer");
     }
-    const maxParticipants = payload.policy?.max_participants;
-    if (maxParticipants !== undefined &&
-        (!Number.isInteger(maxParticipants) || maxParticipants < 1)) {
-        throw protocolError("invalid_room", "max_participants must be a positive integer");
+    for (const declaration of payload.types ?? []) {
+        validateTypeDeclaration(declaration);
     }
 }
-export function validatePollCreatePayload(payload) {
-    if (payload.poll_id.trim() === "" || payload.question.trim() === "") {
-        throw protocolError("invalid_poll", "poll_id and question are required");
+export function validateMessageCreatePayload(payload) {
+    if (payload.content_type.trim() === "") {
+        throw protocolError("invalid_event", "content_type must not be empty");
     }
-    if (payload.options.length < 2) {
-        throw protocolError("invalid_poll", "poll requires at least two options");
+}
+/** The effective set of type definitions active in a room. */
+export class TypeRegistry {
+    types = new Map();
+    /**
+     * Materializes a registry from declarations, resolving pack imports from
+     * `packs`, keyed by registered pack id or external pack URI.
+     */
+    static fromDeclarations(declarations, packs = {}) {
+        const registry = new TypeRegistry();
+        for (const declaration of declarations) {
+            registry.apply(declaration, packs);
+        }
+        return registry;
     }
-    const optionIds = new Set();
-    for (const option of payload.options) {
-        if (option.id.trim() === "" || option.label.trim() === "") {
-            throw protocolError("invalid_poll", "option id and label are required");
+    /**
+     * Applies one declaration: an inline definition or a pack import.
+     * Redefining an existing type replaces it; the latest definition wins.
+     */
+    apply(declaration, packs = {}) {
+        if (isPackImport(declaration)) {
+            this.import(declaration, packs);
         }
-        if (optionIds.has(option.id)) {
-            throw protocolError("invalid_poll", "poll option ids must be unique");
+        else if (isTypeDef(declaration)) {
+            this.define(declaration);
+        }
+        else {
+            throw protocolError("invalid_event", "type declaration must be an inline definition or a pack import");
         }
-        optionIds.add(option.id);
     }
-    const minChoices = payload.min_choices ?? 1;
-    const maxChoices = payload.max_choices ?? 1;
-    if (minChoices < 1 || maxChoices < minChoices) {
-        throw protocolError("invalid_poll", "invalid poll choice limits");
+    define(def) {
+        validateTypeDef(def);
+        this.types.set(def.type, def);
     }
-}
-export function validatePollVotePayload(payload, poll, nowMs) {
-    if (poll.closes_at !== undefined && nowMs !== undefined && nowMs > poll.closes_at) {
-        throw protocolError("poll_closed", "poll is closed");
-    }
-    const minChoices = poll.min_choices ?? 1;
-    const maxChoices = poll.max_choices ?? 1;
-    const optionIds = new Set(poll.options.map((option) => option.id));
-    const selected = new Set(payload.option_ids);
-    if (selected.size !== payload.option_ids.length) {
-        throw protocolError("invalid_poll_vote", "duplicate poll options");
+    import(declaration, packs) {
+        validatePackImport(declaration);
+        const reference = declaration.use ?? declaration.pack;
+        const pack = packs[reference];
+        if (!pack) {
+            throw protocolError("pack_unavailable", `pack not available: ${reference}`);
+        }
+        const available = new Set(pack.types.map((def) => def.type));
+        for (const name of declaration.types ?? []) {
+            if (!available.has(name)) {
+                throw protocolError("pack_unavailable", `type ${name} is not in pack ${reference}`);
+            }
+        }
+        const subset = declaration.types !== undefined ? new Set(declaration.types) : undefined;
+        for (const name of Object.keys(declaration.overrides ?? {})) {
+            const imported = subset ? subset.has(name) : available.has(name);
+            if (!imported) {
+                throw protocolError("invalid_event", `override target ${name} is not imported from pack ${reference}`);
+            }
+        }
+        for (const def of pack.types) {
+            if (subset && !subset.has(def.type))
+                continue;
+            const override = declaration.overrides?.[def.type];
+            this.define(override ? { ...def, ...override } : { ...def });
+        }
     }
-    if (selected.size < minChoices || selected.size > maxChoices) {
-        throw protocolError("invalid_poll_vote", "invalid number of options");
+    get(type) {
+        return this.types.get(type);
     }
-    for (const optionId of selected) {
-        if (!optionIds.has(optionId)) {
-            throw protocolError("invalid_poll_vote", "unknown poll option");
-        }
+    has(type) {
+        return this.types.has(type);
     }
-}
-export function validateSessionOfferPayload(payload) {
-    validateSessionId(payload.session_id);
-    if (payload.session_type !== "webrtc") {
-        throw protocolError("invalid_session", "session_type must be webrtc");
+    get size() {
+        return this.types.size;
     }
-    if (!Array.isArray(payload.media) || payload.media.length === 0) {
-        throw protocolError("invalid_session", "media must not be empty");
+    definitions() {
+        return [...this.types.values()];
     }
-    for (const media of payload.media) {
-        if (!sessionMediaKinds.has(media)) {
-            throw protocolError("invalid_session", `unsupported media kind ${media}`);
+    /** Validates a custom event payload against the type's schema and status. */
+    validatePayload(type, payload) {
+        const def = this.types.get(type);
+        if (!def) {
+            throw protocolError("type_not_defined", type);
+        }
+        if ((def.status ?? "active") === "disabled") {
+            throw protocolError("type_disabled", type);
+        }
+        const validator = compileSchema(def.schema);
+        const result = validator.validate(payload);
+        if (!result.valid) {
+            const detail = result.errors
+                .slice(0, 3)
+                .map((error) => error.error)
+                .join("; ");
+            throw protocolError("payload_schema_violation", `${type}: ${detail}`);
         }
     }
-    validateSessionDescription(payload.description, "offer");
-    validateSessionTransfers(payload.transfers ?? []);
 }
-export function validateSessionAnswerPayload(payload) {
-    validateSessionId(payload.session_id);
-    if (payload.offer_event_id.trim() === "") {
-        throw protocolError("invalid_session", "offer_event_id is required");
+/**
+ * Validates an event payload: built-in payloads are accepted as-is (use the
+ * typed validators for them); custom payloads must satisfy the registry.
+ */
+export function validateEventAgainstRegistry(type, payload, registry) {
+    if (isBuiltinEventType(type))
+        return;
+    registry.validatePayload(type, payload);
+}
+function compileSchema(schema) {
+    try {
+        return new Validator(schema, "2020-12", false);
+    }
+    catch (error) {
+        throw protocolError("invalid_event", `invalid type schema: ${error}`);
     }
-    validateSessionDescription(payload.description, "answer");
-    validateSessionTransfers(payload.transfers ?? []);
 }
-export function validateSessionCandidatePayload(payload) {
-    validateSessionId(payload.session_id);
-    if (payload.end_of_candidates)
-        return;
-    if (!payload.candidate ||
-        typeof payload.candidate.candidate !== "string" ||
-        payload.candidate.candidate.trim() === "") {
-        throw protocolError("invalid_session", "candidate is required unless end_of_candidates is true");
+/**
+ * Verifies a `<algorithm>:<base64url-digest>` content digest over raw bytes.
+ * Supports `sha256` and `sha3-256`.
+ */
+export function verifyPackDigest(bytes, digest) {
+    const separator = digest.indexOf(":");
+    if (separator < 0) {
+        throw protocolError("pack_unavailable", `invalid digest format: ${digest}`);
+    }
+    const algorithm = digest.slice(0, separator);
+    const expected = digest.slice(separator + 1);
+    if (algorithm !== "sha256" && algorithm !== "sha3-256") {
+        throw protocolError("pack_unavailable", `unsupported digest algorithm: ${algorithm}`);
+    }
+    const actual = createHash(algorithm)
+        .update(bytes)
+        .digest("base64url");
+    if (actual !== expected) {
+        throw protocolError("pack_unavailable", "pack digest mismatch");
     }
 }
 export function serverRecordHashPayload(roomId, seq, preHash, envelopeHash, receivedAt) {
@@ -207,149 +380,76 @@ export function verifyServerRecordChain(records) {
 export function archiveEventsDigest(records) {
     return hashCanonicalJson(records);
 }
-export function canSubmitEvent(type, context) {
-    if (type === eventType.ROOM_CREATE)
-        return true;
-    if (type === eventType.ROOM_JOIN)
-        return Boolean(context.joinRequestApproved);
-    if (context.isCreator)
-        return isKnownEventType(type);
-    switch (context.role) {
-        case "moderator":
-            return moderatorCanSubmit(type, context.moderatorAuthorized ?? false);
-        case "expert":
-            return speakerCanSubmit(type, context.expertPolicyAllowed ?? false);
-        case "participant":
-            return speakerCanSubmit(type, context.participantPolicyAllowed ?? false);
-        case "observer":
-            return observerCanSubmit(type, context);
-        default:
-            return false;
+/** Default sender roles for each kind. The creator passes every role check. */
+export function defaultKindRoles(kind) {
+    switch (kind) {
+        case "message":
+            return ["moderator", "speaker"];
+        case "signal":
+            return ["moderator", "speaker", "observer"];
+        case "control":
+            return ["moderator"];
+    }
+}
+/**
+ * Role check for one event type, using kind defaults and per-type overrides
+ * from the room's type registry. State checks are separate.
+ */
+export function canSubmitEvent(type, context, registry = new TypeRegistry()) {
+    switch (type) {
+        case eventType.ROOM_CREATE:
+            return true;
+        case eventType.ROOM_JOIN:
+            return Boolean(context.joinRequestApproved);
+        case eventType.ROOM_LEAVE:
+            return Boolean(context.isCreator) || context.role !== undefined;
+        case eventType.ROOM_JOIN_REVIEW:
+        case eventType.ROOM_MEMBER_ROLE_UPDATE:
+        case eventType.ROOM_CLOSE:
+        case eventType.ROOM_CANCEL:
+        case eventType.TYPE_DEFINE:
+            return Boolean(context.isCreator) || context.role === "moderator";
+        case eventType.MESSAGE_CREATE:
+            return (Boolean(context.isCreator) ||
+                context.role === "moderator" ||
+                context.role === "speaker");
+        default: {
+            const def = registry.get(type);
+            if (!def || (def.status ?? "active") === "disabled")
+                return false;
+            if (context.isCreator)
+                return true;
+            if (context.role === undefined)
+                return false;
+            const roles = def.roles ?? defaultKindRoles(def.kind);
+            return roles.includes(context.role);
+        }
     }
 }
-export function canWriteInState(type, state, options = {}) {
+export function canWriteInState(type, state) {
     switch (state) {
         case "scheduled":
-            return eventTypeIn(type, [
-                eventType.ROOM_JOIN,
-                eventType.ROOM_JOIN_REVIEW,
-                eventType.ROOM_CANCEL,
-            ]);
+            return (type === eventType.ROOM_JOIN ||
+                type === eventType.ROOM_JOIN_REVIEW ||
+                type === eventType.ROOM_MEMBER_ROLE_UPDATE ||
+                type === eventType.ROOM_LEAVE ||
+                type === eventType.TYPE_DEFINE ||
+                type === eventType.ROOM_CANCEL);
         case "active":
             return type !== eventType.ROOM_CREATE && type !== eventType.ROOM_CANCEL;
         case "ended":
-            return (Boolean(options.postEndReactionAllowed) &&
-                type === eventType.REACTION_CREATE);
         case "cancelled":
             return false;
     }
 }
-export function canAcceptRoomWrite(type, state, permission, options = {}) {
-    return (canSubmitEvent(type, permission) && canWriteInState(type, state, options));
+export function canAcceptRoomWrite(type, state, permission, registry = new TypeRegistry()) {
+    return canSubmitEvent(type, permission, registry) && canWriteInState(type, state);
 }
-export function validateRoomWrite(type, state, permission, options = {}) {
-    if (!canAcceptRoomWrite(type, state, permission, options)) {
+export function validateRoomWrite(type, state, permission, registry = new TypeRegistry()) {
+    if (!canAcceptRoomWrite(type, state, permission, registry)) {
         throw protocolError("permission_denied", "actor lacks permission or state is not writable");
     }
 }
-function moderatorCanSubmit(type, moderatorAuthorized) {
-    return (eventTypeIn(type, [
-        eventType.ROOM_JOIN_REVIEW,
-        eventType.ROOM_CLOSE,
-        eventType.MESSAGE_CREATE,
-        eventType.SOURCE_ADD,
-        eventType.TURN_UPDATE,
-        eventType.QUESTION_CREATE,
-        eventType.ROOM_STEER,
-        eventType.MAP_UPDATE,
-        eventType.ARTIFACT_CREATE,
-        eventType.SESSION_OFFER,
-        eventType.SESSION_ANSWER,
-        eventType.SESSION_CANDIDATE,
-        eventType.SESSION_CLOSE,
-        eventType.MESSAGE_PROPOSAL_CREATE,
-        eventType.MESSAGE_POLL_CREATE,
-        eventType.MESSAGE_POLL_VOTE,
-        eventType.MESSAGE_RESOLUTION_CREATE,
-        eventType.REACTION_CREATE,
-        eventType.ROOM_LEAVE,
-    ]) ||
-        (moderatorAuthorized &&
-            eventTypeIn(type, [
-                eventType.ROOM_MEMBER_ROLE_UPDATE,
-                eventType.ROOM_CANCEL,
-            ])));
-}
-function speakerCanSubmit(type, policyAllowed) {
-    return (eventTypeIn(type, [
-        eventType.MESSAGE_CREATE,
-        eventType.SOURCE_ADD,
-        eventType.ROOM_STEER,
-        eventType.MESSAGE_PROPOSAL_CREATE,
-        eventType.MESSAGE_POLL_CREATE,
-        eventType.MESSAGE_POLL_VOTE,
-        eventType.SESSION_OFFER,
-        eventType.SESSION_ANSWER,
-        eventType.SESSION_CANDIDATE,
-        eventType.SESSION_CLOSE,
-        eventType.REACTION_CREATE,
-        eventType.ROOM_LEAVE,
-    ]) ||
-        (policyAllowed &&
-            eventTypeIn(type, [
-                eventType.QUESTION_CREATE,
-                eventType.MAP_UPDATE,
-                eventType.ARTIFACT_CREATE,
-                eventType.MESSAGE_RESOLUTION_CREATE,
-            ])));
-}
-function observerCanSubmit(type, context) {
-    return (eventTypeIn(type, [eventType.REACTION_CREATE, eventType.ROOM_LEAVE]) ||
-        (Boolean(context.observerSteeringAllowed) &&
-            type === eventType.ROOM_STEER) ||
-        (Boolean(context.observerPollVoteAllowed) &&
-            type === eventType.MESSAGE_POLL_VOTE));
-}
-function isKnownEventType(type) {
-    return eventTypeIn(type, Object.values(eventType));
-}
-function eventTypeIn(type, values) {
-    return values.includes(type);
-}
-function validateSessionId(sessionId) {
-    if (sessionId.trim() === "") {
-        throw protocolError("invalid_session", "session_id is required");
-    }
-}
-function validateSessionDescription(description, expectedType) {
-    if (!description ||
-        typeof description.type !== "string" ||
-        typeof description.sdp !== "string") {
-        throw protocolError("invalid_session", "session description is required");
-    }
-    if (description.type !== expectedType) {
-        throw protocolError("invalid_session", `session description type must be ${expectedType}`);
-    }
-    if (description.sdp.trim() === "") {
-        throw protocolError("invalid_session", "session description sdp is required");
-    }
-}
-function validateSessionTransfers(transfers) {
-    if (!Array.isArray(transfers)) {
-        throw protocolError("invalid_session", "transfers must be an array");
-    }
-    for (const transfer of transfers) {
-        if (!transfer ||
-            typeof transfer.transfer_id !== "string" ||
-            transfer.transfer_id.trim() === "") {
-            throw protocolError("invalid_session", "transfer_id is required");
-        }
-        if (transfer.size_bytes !== undefined &&
-            (!Number.isInteger(transfer.size_bytes) || transfer.size_bytes < 0)) {
-            throw protocolError("invalid_session", "size_bytes must be a non-negative integer");
-        }
-    }
-}
 function hashCanonicalJson(value) {
     const canonical = canonicalize(value);
     if (canonical === undefined) {