@tribe-nest/media-protocol 1.0.0

package/build/mp-build/frames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames.d.ts","sourceRoot":"","sources":["../src/frames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,eAAO,MAAM,kBAAkB;;;;IAK3B;;8CAE0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmB1C,4DAA4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuC9D,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;AAEnD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;IAK5B;gFAC4E;;;;;;;;;;;;;IAI9E,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;iEACiE;AACjE,eAAO,MAAM,UAAU;;;;;;;;;;;;EAIrB,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9C,eAAO,MAAM,gBAAgB;;;;IAKzB,4EAA4E;;;;;;;;;;;;;;;IAG5E;;qCAEiC;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGjC;oCACgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuBlC,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;AAE5C,qCAAqC;AACrC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;IA7D1B;gFAC4E;;;;;;;;;;;;;;;;;IAsB5E,4EAA4E;;;;;;;;;;;;;;;IAG5E;;qCAEiC;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGjC;oCACgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6B6C,CAAC;AAClF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,OAAO,GAAI,OAAO,WAAW,KAAG,KAAK,IAAI,UAA8B,CAAC"}

package/build/mp-build/frames.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEvent = exports.serverFrameSchema = exports.eventFrameSchema = exports.peerSchema = exports.responseFrameSchema = exports.requestFrameSchema = void 0;
+const zod_1 = require("zod");
+const errorSchema_1 = require("./errorSchema");
+const grants_1 = require("./grants");
+/**
+ * The client <-> node signalling wire.
+ *
+ * One envelope, stated once. Six phase plans independently invented four
+ * different ones (`m` / `type` / `method` / `action`, numeric versus string
+ * ids, `result` versus `data`), and every mismatch is a hard parse failure
+ * discovered at integration by a different pair of people.
+ *
+ * ## Shape
+ *
+ * Requests carry an `id` and get exactly one reply with the same `id`. Events
+ * carry no `id` and are never replied to. That is the whole protocol; anything
+ * needing more structure is a request that returns a handle.
+ *
+ * ## What is deliberately NOT here
+ *
+ * No pipe verb, no node id, no mesh address. A client cannot express "pipe this
+ * producer to that node", because piping is a side effect of `consume` and the
+ * only way to keep it lazy is for eager piping to be unsayable.
+ */
+exports.requestFrameSchema = zod_1.z.discriminatedUnion("method", [
+    zod_1.z.object({
+        method: zod_1.z.literal("join"),
+        id: zod_1.z.number().int().nonnegative(),
+        protocolVersion: zod_1.z.number().int(),
+        /** The token travels in the first frame, NEVER in the URL: a query string
+         * lands in load-balancer access logs, and a join ticket in a log is a join
+         * ticket for anyone who can read logs. */
+        token: zod_1.z.string().min(1),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("createTransport"),
+        id: zod_1.z.number().int().nonnegative(),
+        direction: zod_1.z.enum(["send", "recv"]),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("connectTransport"),
+        id: zod_1.z.number().int().nonnegative(),
+        transportId: zod_1.z.string(),
+        dtlsParameters: zod_1.z.unknown(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("produce"),
+        id: zod_1.z.number().int().nonnegative(),
+        transportId: zod_1.z.string(),
+        kind: zod_1.z.enum(["audio", "video"]),
+        /** Opaque to this package: only mediasoup interprets it. */
+        rtpParameters: zod_1.z.unknown(),
+        appData: zod_1.z.record(zod_1.z.unknown()).optional(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("consume"),
+        id: zod_1.z.number().int().nonnegative(),
+        transportId: zod_1.z.string(),
+        producerId: zod_1.z.string(),
+        rtpCapabilities: zod_1.z.unknown(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("pauseProducer"),
+        id: zod_1.z.number().int().nonnegative(),
+        producerId: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("resumeProducer"),
+        id: zod_1.z.number().int().nonnegative(),
+        producerId: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("resumeConsumer"),
+        id: zod_1.z.number().int().nonnegative(),
+        consumerId: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        method: zod_1.z.literal("closeProducer"),
+        id: zod_1.z.number().int().nonnegative(),
+        producerId: zod_1.z.string(),
+    }),
+    /** A keyframe request. Without it every active-speaker switch shows garbage
+     * until the encoder happens to send one. */
+    zod_1.z.object({
+        method: zod_1.z.literal("requestKeyFrame"),
+        id: zod_1.z.number().int().nonnegative(),
+        consumerId: zod_1.z.string(),
+    }),
+    zod_1.z.object({ method: zod_1.z.literal("leave"), id: zod_1.z.number().int().nonnegative() }),
+]);
+exports.responseFrameSchema = zod_1.z.union([
+    zod_1.z.object({ id: zod_1.z.number().int().nonnegative(), ok: zod_1.z.literal(true), data: zod_1.z.unknown() }),
+    zod_1.z.object({
+        id: zod_1.z.number().int().nonnegative(),
+        ok: zod_1.z.literal(false),
+        /** The client sees a CODE, never why a token was refused. Telling a caller
+         * whether the signature or the room was wrong turns this into an oracle. */
+        code: errorSchema_1.mediaErrorCodeSchema,
+        message: zod_1.z.string().optional(),
+    }),
+]);
+/** A participant as everyone else sees them. Grants are NOT included: what
+ * someone else is permitted to do is not the room's business. */
+exports.peerSchema = zod_1.z.object({
+    identity: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    kind: grants_1.participantKindSchema,
+});
+exports.eventFrameSchema = zod_1.z.discriminatedUnion("event", [
+    zod_1.z.object({
+        event: zod_1.z.literal("joined"),
+        identity: zod_1.z.string(),
+        room: zod_1.z.string(),
+        /** Everything the client needs to build its device before any transport. */
+        routerRtpCapabilities: zod_1.z.unknown(),
+        peers: zod_1.z.array(exports.peerSchema),
+        /** Producers this participant is ALLOWED to see. The barrier is applied to
+         * the snapshot, not only at consume: an identity it may not receive must
+         * not be discoverable either. */
+        producers: zod_1.z.array(zod_1.z.object({ producerId: zod_1.z.string(), identity: zod_1.z.string(), kind: zod_1.z.enum(["audio", "video"]) })),
+        iceServers: zod_1.z.array(zod_1.z.object({ urls: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]), username: zod_1.z.string().optional(), credential: zod_1.z.string().optional() })),
+        /** True while any `kind: "egress"` participant is present. A consent
+         * requirement, not a nicety. */
+        recording: zod_1.z.boolean(),
+    }),
+    zod_1.z.object({ event: zod_1.z.literal("peerJoined"), peer: exports.peerSchema }),
+    zod_1.z.object({ event: zod_1.z.literal("peerLeft"), identity: zod_1.z.string() }),
+    zod_1.z.object({
+        event: zod_1.z.literal("producerAppeared"),
+        producerId: zod_1.z.string(),
+        identity: zod_1.z.string(),
+        kind: zod_1.z.enum(["audio", "video"]),
+    }),
+    zod_1.z.object({ event: zod_1.z.literal("producerClosed"), producerId: zod_1.z.string() }),
+    zod_1.z.object({ event: zod_1.z.literal("producerPaused"), producerId: zod_1.z.string(), paused: zod_1.z.boolean() }),
+    /** The active set the node wants this client to consume. How a 1,000-person
+     * room stays survivable: the server decides, the client follows. */
+    zod_1.z.object({ event: zod_1.z.literal("activeSpeakers"), producerIds: zod_1.z.array(zod_1.z.string()) }),
+    zod_1.z.object({ event: zod_1.z.literal("recordingChanged"), recording: zod_1.z.boolean() }),
+    /** This node is going away. Reconnect through MEDIA_URL; do not retry here. */
+    zod_1.z.object({ event: zod_1.z.literal("draining"), reconnectAfterMs: zod_1.z.number().int().nonnegative() }),
+    zod_1.z.object({ event: zod_1.z.literal("roomClosed"), reason: zod_1.z.string() }),
+    /** Barrier changes are pushed, because a rule that only applies at join is a
+     * rule that does not apply to anyone already in the room. */
+    zod_1.z.object({ event: zod_1.z.literal("subscribeRuleChanged"), subscribe: grants_1.subscribeRuleSchema }),
+]);
+/** Anything arriving from a node. */
+exports.serverFrameSchema = zod_1.z.union([exports.responseFrameSchema, exports.eventFrameSchema]);
+const isEvent = (frame) => "event" in frame;
+exports.isEvent = isEvent;
+//# sourceMappingURL=frames.js.map

package/build/mp-build/frames.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames.js","sourceRoot":"","sources":["../src/frames.ts"],"names":[],"mappings":"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"}

package/build/mp-build/grants.d.ts

@@ -0,0 +1,245 @@
+import { z } from "zod";
+/**
+ * What a participant is allowed to do, and - the part that matters most - who
+ * they may receive.
+ *
+ * ## Why the schema is `.strict()`
+ *
+ * This is the single line that stops the information barrier failing open.
+ *
+ * Ten phase plans were written in parallel and two of them disagreed on a name:
+ * one minted `grants.subscribeOnly`, the other read `grants.subscribe`. The
+ * reader would have found nothing, applied its documented default ("an absent
+ * rule means everyone"), and two Mandanten in one room would have received each
+ * other with nothing anywhere erroring. That is a §203 incident whose start
+ * date is unrecoverable from logs.
+ *
+ * `.strict()` turns that class of mistake from silent permissiveness into a
+ * loud verification failure: a token carrying an unknown grant key is rejected
+ * with `bad_claims` rather than partially understood. Any future rename fails
+ * the same way, at mint time, in a test.
+ */
+/**
+ * Who a participant may receive, or be received by.
+ *
+ * A boolean cannot express an information barrier. "A and B are in one room and
+ * must not receive each other, while C may receive both" is the actual
+ * requirement for a Kanzlei, and it is a per-identity rule rather than a
+ * per-room one.
+ */
+export declare const subscribeRuleSchema: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+    mode: z.ZodLiteral<"all">;
+}, "strict", z.ZodTypeAny, {
+    mode: "all";
+}, {
+    mode: "all";
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"none">;
+}, "strict", z.ZodTypeAny, {
+    mode: "none";
+}, {
+    mode: "none";
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"allow">;
+    identities: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    mode: "allow";
+    identities: string[];
+}, {
+    mode: "allow";
+    identities: string[];
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"deny">;
+    identities: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    mode: "deny";
+    identities: string[];
+}, {
+    mode: "deny";
+    identities: string[];
+}>]>;
+export type SubscribeRule = z.infer<typeof subscribeRuleSchema>;
+export declare const participantKindSchema: z.ZodEnum<["human", "agent", "egress", "sip", "ingress"]>;
+export type ParticipantKind = z.infer<typeof participantKindSchema>;
+/**
+ * Transport authority is NOT media authority, which is why this is its own
+ * claim rather than something inferred from `kind`.
+ *
+ * A browser holding a perfectly valid join token must not be able to ask for a
+ * `PlainTransport` pointed at an address of its choosing. That is an RTP
+ * reflector and an unauthenticated publish path into whatever room the token
+ * names. Three phases independently needed to refuse it and none could, because
+ * nothing carried the fact.
+ */
+export declare const transportKindSchema: z.ZodEnum<["webrtc", "plain", "pipe"]>;
+export type TransportKind = z.infer<typeof transportKindSchema>;
+export declare const mediaGrantsSchema: z.ZodObject<{
+    canPublish: z.ZodBoolean;
+    canSubscribe: z.ZodBoolean;
+    canPublishData: z.ZodBoolean;
+    /** Who I may receive. Omitted means `{ mode: "all" }`. */
+    subscribe: z.ZodOptional<z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"all">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "all";
+    }, {
+        mode: "all";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"none">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "none";
+    }, {
+        mode: "none";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"allow">;
+        identities: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "allow";
+        identities: string[];
+    }, {
+        mode: "allow";
+        identities: string[];
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"deny">;
+        identities: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "deny";
+        identities: string[];
+    }, {
+        mode: "deny";
+        identities: string[];
+    }>]>>;
+    /**
+     * Who may receive ME. Enforced on the PRODUCER side from the owner's stored
+     * grants, so a barrier holds even if the other party's token is generous.
+     */
+    visibleTo: z.ZodOptional<z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"all">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "all";
+    }, {
+        mode: "all";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"none">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "none";
+    }, {
+        mode: "none";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"allow">;
+        identities: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "allow";
+        identities: string[];
+    }, {
+        mode: "allow";
+        identities: string[];
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"deny">;
+        identities: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "deny";
+        identities: string[];
+    }, {
+        mode: "deny";
+        identities: string[];
+    }>]>>;
+    publishKinds: z.ZodOptional<z.ZodArray<z.ZodEnum<["audio", "video", "screen"]>, "many">>;
+    /**
+     * Bypasses the top-N active-speaker refusal. Mintable ONLY for a non-human
+     * kind: a recorder needs every track, a human asking for 1,000 does not.
+     */
+    subscribeExempt: z.ZodOptional<z.ZodBoolean>;
+    /** Hard ceiling on concurrent consumers, for a non-human participant. */
+    maxSubscriptions: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    canPublish: boolean;
+    canSubscribe: boolean;
+    canPublishData: boolean;
+    subscribe?: {
+        mode: "all";
+    } | {
+        mode: "none";
+    } | {
+        mode: "allow";
+        identities: string[];
+    } | {
+        mode: "deny";
+        identities: string[];
+    } | undefined;
+    visibleTo?: {
+        mode: "all";
+    } | {
+        mode: "none";
+    } | {
+        mode: "allow";
+        identities: string[];
+    } | {
+        mode: "deny";
+        identities: string[];
+    } | undefined;
+    publishKinds?: ("audio" | "video" | "screen")[] | undefined;
+    subscribeExempt?: boolean | undefined;
+    maxSubscriptions?: number | undefined;
+}, {
+    canPublish: boolean;
+    canSubscribe: boolean;
+    canPublishData: boolean;
+    subscribe?: {
+        mode: "all";
+    } | {
+        mode: "none";
+    } | {
+        mode: "allow";
+        identities: string[];
+    } | {
+        mode: "deny";
+        identities: string[];
+    } | undefined;
+    visibleTo?: {
+        mode: "all";
+    } | {
+        mode: "none";
+    } | {
+        mode: "allow";
+        identities: string[];
+    } | {
+        mode: "deny";
+        identities: string[];
+    } | undefined;
+    publishKinds?: ("audio" | "video" | "screen")[] | undefined;
+    subscribeExempt?: boolean | undefined;
+    maxSubscriptions?: number | undefined;
+}>;
+export type MediaGrants = z.infer<typeof mediaGrantsSchema>;
+/**
+ * May `consumer` receive `producer`? Two-sided, and deny wins.
+ *
+ * One-sided is not enough. If only the consumer's rule were consulted, a
+ * participant whose own token was minted generously could receive someone who
+ * had been explicitly walled off from them. So the producer's `visibleTo` is
+ * checked from the OWNER's stored grants, not from anything the consumer
+ * presents.
+ *
+ * **An unreadable owner is `false`.** If the producer's grants cannot be found,
+ * this refuses rather than falling through to the permissive default. A missing
+ * record is exactly the state a race or a partial failure produces, and in a
+ * room with an information barrier the safe reading of "I do not know" is "no".
+ * Note this differs deliberately from an ABSENT RULE on a record that WAS
+ * found, which means everyone.
+ */
+export declare function maySubscribe(input: {
+    consumerIdentity: string;
+    consumerGrants: MediaGrants;
+    producerIdentity: string;
+    /** `undefined` when the owner's record could not be read. */
+    ownerGrants: MediaGrants | undefined;
+}): boolean;
+/**
+ * `subscribeExempt` and `maxSubscriptions` are meaningless for a human and
+ * dangerous if mintable for one: exemption is what lets a recorder take every
+ * track, and a human with it can pull a thousand streams through a node.
+ * Checked at MINT time so a bad token never exists.
+ */
+export declare function grantsAreValidForKind(grants: MediaGrants, kind: ParticipantKind): true | string;
+//# sourceMappingURL=grants.d.ts.map

package/build/mp-build/grants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grants.d.ts","sourceRoot":"","sources":["../src/grants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,qBAAqB,2DAAyD,CAAC;AAC5F,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,wCAAsC,CAAC;AACvE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,iBAAiB;;;;IAK1B,0DAA0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE1D;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;;OAGG;;IAEH,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlE,CAAC;AAEZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAmB5D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,WAAW,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,6DAA6D;IAC7D,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC;CACtC,GAAG,OAAO,CAUV;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,eAAe,GAAG,IAAI,GAAG,MAAM,CAW/F"}

package/build/mp-build/grants.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaGrantsSchema = exports.transportKindSchema = exports.participantKindSchema = exports.subscribeRuleSchema = void 0;
+exports.maySubscribe = maySubscribe;
+exports.grantsAreValidForKind = grantsAreValidForKind;
+const zod_1 = require("zod");
+/**
+ * What a participant is allowed to do, and - the part that matters most - who
+ * they may receive.
+ *
+ * ## Why the schema is `.strict()`
+ *
+ * This is the single line that stops the information barrier failing open.
+ *
+ * Ten phase plans were written in parallel and two of them disagreed on a name:
+ * one minted `grants.subscribeOnly`, the other read `grants.subscribe`. The
+ * reader would have found nothing, applied its documented default ("an absent
+ * rule means everyone"), and two Mandanten in one room would have received each
+ * other with nothing anywhere erroring. That is a §203 incident whose start
+ * date is unrecoverable from logs.
+ *
+ * `.strict()` turns that class of mistake from silent permissiveness into a
+ * loud verification failure: a token carrying an unknown grant key is rejected
+ * with `bad_claims` rather than partially understood. Any future rename fails
+ * the same way, at mint time, in a test.
+ */
+/**
+ * Who a participant may receive, or be received by.
+ *
+ * A boolean cannot express an information barrier. "A and B are in one room and
+ * must not receive each other, while C may receive both" is the actual
+ * requirement for a Kanzlei, and it is a per-identity rule rather than a
+ * per-room one.
+ */
+exports.subscribeRuleSchema = zod_1.z.discriminatedUnion("mode", [
+    zod_1.z.object({ mode: zod_1.z.literal("all") }).strict(),
+    zod_1.z.object({ mode: zod_1.z.literal("none") }).strict(),
+    zod_1.z.object({ mode: zod_1.z.literal("allow"), identities: zod_1.z.array(zod_1.z.string()).max(500) }).strict(),
+    zod_1.z.object({ mode: zod_1.z.literal("deny"), identities: zod_1.z.array(zod_1.z.string()).max(500) }).strict(),
+]);
+exports.participantKindSchema = zod_1.z.enum(["human", "agent", "egress", "sip", "ingress"]);
+/**
+ * Transport authority is NOT media authority, which is why this is its own
+ * claim rather than something inferred from `kind`.
+ *
+ * A browser holding a perfectly valid join token must not be able to ask for a
+ * `PlainTransport` pointed at an address of its choosing. That is an RTP
+ * reflector and an unauthenticated publish path into whatever room the token
+ * names. Three phases independently needed to refuse it and none could, because
+ * nothing carried the fact.
+ */
+exports.transportKindSchema = zod_1.z.enum(["webrtc", "plain", "pipe"]);
+exports.mediaGrantsSchema = zod_1.z
+    .object({
+    canPublish: zod_1.z.boolean(),
+    canSubscribe: zod_1.z.boolean(),
+    canPublishData: zod_1.z.boolean(),
+    /** Who I may receive. Omitted means `{ mode: "all" }`. */
+    subscribe: exports.subscribeRuleSchema.optional(),
+    /**
+     * Who may receive ME. Enforced on the PRODUCER side from the owner's stored
+     * grants, so a barrier holds even if the other party's token is generous.
+     */
+    visibleTo: exports.subscribeRuleSchema.optional(),
+    publishKinds: zod_1.z.array(zod_1.z.enum(["audio", "video", "screen"])).optional(),
+    /**
+     * Bypasses the top-N active-speaker refusal. Mintable ONLY for a non-human
+     * kind: a recorder needs every track, a human asking for 1,000 does not.
+     */
+    subscribeExempt: zod_1.z.boolean().optional(),
+    /** Hard ceiling on concurrent consumers, for a non-human participant. */
+    maxSubscriptions: zod_1.z.number().int().positive().max(5000).optional(),
+})
+    .strict();
+/** An omitted rule means everyone. Stated once so both sides agree. */
+const DEFAULT_RULE = { mode: "all" };
+function ruleAllows(rule, identity) {
+    const r = rule ?? DEFAULT_RULE;
+    switch (r.mode) {
+        case "all":
+            return true;
+        case "none":
+            return false;
+        case "allow":
+            return r.identities.includes(identity);
+        case "deny":
+            return !r.identities.includes(identity);
+    }
+}
+/**
+ * May `consumer` receive `producer`? Two-sided, and deny wins.
+ *
+ * One-sided is not enough. If only the consumer's rule were consulted, a
+ * participant whose own token was minted generously could receive someone who
+ * had been explicitly walled off from them. So the producer's `visibleTo` is
+ * checked from the OWNER's stored grants, not from anything the consumer
+ * presents.
+ *
+ * **An unreadable owner is `false`.** If the producer's grants cannot be found,
+ * this refuses rather than falling through to the permissive default. A missing
+ * record is exactly the state a race or a partial failure produces, and in a
+ * room with an information barrier the safe reading of "I do not know" is "no".
+ * Note this differs deliberately from an ABSENT RULE on a record that WAS
+ * found, which means everyone.
+ */
+function maySubscribe(input) {
+    if (!input.consumerGrants.canSubscribe)
+        return false;
+    // Nobody subscribes to themselves; asking is a client bug, not a denial.
+    if (input.consumerIdentity === input.producerIdentity)
+        return false;
+    if (!input.ownerGrants)
+        return false;
+    return (ruleAllows(input.consumerGrants.subscribe, input.producerIdentity) &&
+        ruleAllows(input.ownerGrants.visibleTo, input.consumerIdentity));
+}
+/**
+ * `subscribeExempt` and `maxSubscriptions` are meaningless for a human and
+ * dangerous if mintable for one: exemption is what lets a recorder take every
+ * track, and a human with it can pull a thousand streams through a node.
+ * Checked at MINT time so a bad token never exists.
+ */
+function grantsAreValidForKind(grants, kind) {
+    if (kind === "human" && grants.subscribeExempt) {
+        return "subscribeExempt may not be minted for a human participant";
+    }
+    if (!grants.canSubscribe && (grants.subscribe || grants.subscribeExempt || grants.maxSubscriptions)) {
+        return "subscribe rules are meaningless when canSubscribe is false";
+    }
+    if (!grants.canPublish && grants.publishKinds?.length) {
+        return "publishKinds is meaningless when canPublish is false";
+    }
+    return true;
+}
+//# sourceMappingURL=grants.js.map

package/build/mp-build/grants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grants.js","sourceRoot":"","sources":["../src/grants.ts"],"names":[],"mappings":"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"}

package/build/mp-build/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The contract between the backend, the media plane and every client.
+ *
+ * The root export is ISOMORPHIC: types, zod schemas, wire frames and the pure
+ * `maySubscribe` decision. It pulls in no `node:crypto`, no mediasoup, no DOM,
+ * so a browser SDK can import it.
+ *
+ * Signing and verifying live at `@tribe-nest/media-protocol/token`, which is
+ * Node-only. Keeping them apart is what stops importing a frame type from
+ * dragging crypto into a browser bundle.
+ *
+ * This package exists because `apps/backend` and `apps/media-server` may not
+ * import each other (there is a test), and six independently written phase
+ * plans each invented a different wire envelope for want of somewhere neutral
+ * to put one.
+ */
+export * from "./version";
+export * from "./errors";
+export * from "./errorSchema";
+export * from "./grants";
+export * from "./claims";
+export * from "./frames";
+//# sourceMappingURL=index.d.ts.map

package/build/mp-build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/build/mp-build/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * The contract between the backend, the media plane and every client.
+ *
+ * The root export is ISOMORPHIC: types, zod schemas, wire frames and the pure
+ * `maySubscribe` decision. It pulls in no `node:crypto`, no mediasoup, no DOM,
+ * so a browser SDK can import it.
+ *
+ * Signing and verifying live at `@tribe-nest/media-protocol/token`, which is
+ * Node-only. Keeping them apart is what stops importing a frame type from
+ * dragging crypto into a browser bundle.
+ *
+ * This package exists because `apps/backend` and `apps/media-server` may not
+ * import each other (there is a test), and six independently written phase
+ * plans each invented a different wire envelope for want of somewhere neutral
+ * to put one.
+ */
+__exportStar(require("./version"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./errorSchema"), exports);
+__exportStar(require("./grants"), exports);
+__exportStar(require("./claims"), exports);
+__exportStar(require("./frames"), exports);
+//# sourceMappingURL=index.js.map

package/build/mp-build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;GAeG;AACH,4CAA0B;AAC1B,2CAAyB;AACzB,gDAA8B;AAC9B,2CAAyB;AACzB,2CAAyB;AACzB,2CAAyB"}