@rapidmx/meet-plugin 0.5.0 → 0.8.0

package/dist/types/util/RedisRelayBus.d.ts

@@ -0,0 +1,131 @@
+import type { RelayBus, RelayBusListener } from "./RelayHub.js";
+/** The prefix of the Redis pub/sub channel a room's frames travel on: `videoconf:relay:<roomId>`. */
+export declare const REDIS_RELAY_CHANNEL_PREFIX = "videoconf:relay:";
+/** The length, in bytes, of the random id every `RedisRelayBus` stamps on what it publishes. */
+export declare const REDIS_RELAY_ORIGIN_BYTES = 16;
+/** The least time between two `warn` messages about failing Redis commands; the failures in between are logged at
+ * `debug`, so a Redis outage cannot flood the log at the rate media frames arrive. */
+export declare const REDIS_RELAY_WARN_INTERVAL_MS = 30000;
+/** The channel a room's frames are published to. */
+export declare function redisRelayChannel(roomId: string): string;
+/** The logger a `RedisRelayBus` writes to - the framework's logger satisfies it. */
+export interface RedisRelayBusLogger {
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+export interface RedisRelayBusOptions {
+    /** The `datastores:events` Redis URL. */
+    url: string;
+    logger: RedisRelayBusLogger;
+}
+/** What the bus counts, for tests and diagnostics. */
+export interface RedisRelayBusStats {
+    /** Frames published to Redis. */
+    published: number;
+    /** Frames not published because the publisher was not connected (or the sender id cannot be encoded). */
+    publishSkipped: number;
+    /** Redis commands (publish, subscribe, unsubscribe, connect) that failed. */
+    failures: number;
+    /** Messages received from Redis and handed to local listeners. */
+    received: number;
+    /** Messages received from Redis and ignored: this bus's own, garbled, or for a room with no local listener. */
+    receivedDropped: number;
+}
+/**
+ * A `RelayBus` that also carries frames between server replicas over Redis pub/sub, so participants whose relay
+ * sockets landed on different replicas still reach each other. The Redis is the deployment's `datastores:events` one,
+ * the same the framework's push system (`BasePushRoute`) uses across replicas.
+ *
+ * ## How
+ *
+ * The bus owns exactly two Redis clients for the whole process, however many sockets and rooms there are: a
+ * publisher, and one shared subscriber (a client in subscriber mode cannot publish). Both come from
+ * `importRedis()` and `attachRedisErrorHandler()` of `@rapidrest/service-core`, exactly as `BasePushRoute` obtains its
+ * clients - see `connect()`.
+ *
+ * Each room has a channel, `videoconf:relay:<roomId>`. The bus counts the local listeners of every room: the first
+ * one to arrive makes it SUBSCRIBE and the last one to leave makes it UNSUBSCRIBE, so a replica receives only the
+ * rooms it has sockets in. Subscriptions use the client's BUFFER mode, so media bytes are never decoded as text.
+ *
+ * `publish()` delivers to this process's listeners synchronously, exactly as `InProcessRelayBus` does - local
+ * delivery never goes through Redis - and, when the publisher is connected, also publishes the frame to the room's
+ * channel without waiting for it. Every message carries the id of the bus that published it and a bus ignores its own,
+ * so nothing is delivered twice on the replica of origin, while every other replica delivers it to its own listeners.
+ *
+ * ## Wire format of a Redis message
+ *
+ * `[16 bytes: origin bus id][1 byte: N][N bytes: the sender's peer id, UTF-8][the frame]`, where `frame` is what the
+ * `RelayHub` gave `publish()` (its own `[sender length][sender][payload]` header included). The origin id is random
+ * per bus instance. A message that is shorter than that, whose length byte is 0 or overruns it, or that carries no
+ * frame, is dropped; parsing never throws.
+ *
+ * ## Failure behaviour
+ *
+ * Redis being down or slow never affects local delivery and never throws into the hub: `publish()` is fire-and-forget,
+ * is skipped outright while the publisher is not connected (its offline queue is disabled, so an outage cannot pile
+ * frames up in memory), and every failed command is caught and counted. Failures are logged at `warn` at most once per
+ * `REDIS_RELAY_WARN_INTERVAL_MS` and at `debug` otherwise; connection errors themselves are logged by
+ * `attachRedisErrorHandler()` (one error per outage). The clients keep node-redis's default reconnect strategy
+ * (retry forever with backoff), and on reconnect node-redis re-issues SUBSCRIBE for every channel the subscriber held
+ * (`resubscribe()` in the client's socket initiator), so the bus needs no re-subscribe logic of its own - relay
+ * between replicas resumes by itself when Redis comes back, and frames sent during the outage are simply lost, which
+ * media tolerates. A bus used before `connect()`, after `close()`, or whose Redis is unavailable behaves as an
+ * `InProcessRelayBus`.
+ *
+ * ## Bandwidth
+ *
+ * Every relayed frame is published once, whatever the number of receivers, and Redis delivers it to every replica
+ * subscribed to that room - including replicas whose sockets there do not `want` the sender at all (the hub filters
+ * after the bus). A room's cross-replica traffic is therefore roughly its total relayed upload times the number of
+ * OTHER replicas holding sockets of it, and each of those replicas' subscribers reads all of it. A single-replica
+ * room costs a publish per frame and no receiving. Redis pub/sub buffers nothing for a slow subscriber beyond the
+ * server's client-output-buffer limit for pub/sub, after which Redis drops that connection (the client then
+ * reconnects and resubscribes).
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class RedisRelayBus implements RelayBus {
+    private readonly options;
+    /** What the bus has done so far. */
+    readonly stats: RedisRelayBusStats;
+    private readonly id;
+    private readonly rooms;
+    private publisher?;
+    private subscriber?;
+    private lastWarn;
+    constructor(options: RedisRelayBusOptions);
+    /** Whether frames are currently being published to Redis: `connect()` was called, the bus is not closed and the
+     * publisher's connection is up. */
+    get connected(): boolean;
+    /**
+     * Creates the publisher and the shared subscriber and starts connecting them, then returns without waiting for
+     * either connection - a Redis that is down at start-up delays cross-replica relay, not the server, and the
+     * clients keep retrying. Rooms subscribed to before this call are not caught up (the route calls it before it
+     * exposes the bus). Does nothing when already connected. Throws when the `redis` package is not installed or the
+     * URL is unusable; nothing is left open then.
+     */
+    connect(): Promise<void>;
+    /**
+     * Shuts the bus down: destroys both clients (which ends their connections, and with them every subscription) and
+     * stops publishing. Local delivery keeps working, as after a failed `connect()`. Safe to call repeatedly.
+     * Nothing is unsubscribed one by one: the connection going away does that server-side, and an UNSUBSCRIBE could
+     * only stall behind a Redis that is down.
+     */
+    close(): void;
+    subscribe(roomId: string, listener: RelayBusListener): () => void;
+    publish(roomId: string, sender: string, frame: Buffer): void;
+    private publishToRedis;
+    private redisSubscribe;
+    private redisUnsubscribe;
+    /** Handles one message of a room's channel: parses it defensively and hands its frame to the local listeners,
+     * unless this very bus published it. Never throws - it runs inside the Redis client's own message dispatch. */
+    private receive;
+    /** Splits a Redis message into its sender and frame; `undefined` for a garbled one or this bus's own. */
+    private parse;
+    /** Runs a Redis command without waiting for it: a failure, thrown or rejected, is only counted and logged. */
+    private run;
+    /** Counts a failure and logs it - at `warn` once per `REDIS_RELAY_WARN_INTERVAL_MS`, at `debug` in between. */
+    private report;
+}

package/dist/types/util/RelayHub.d.ts

@@ -0,0 +1,188 @@
+/** The version of the relay wire protocol this module implements - the `v` of `hello`/`ready`. */
+export declare const RELAY_PROTOCOL_VERSION = 1;
+/** The largest binary payload (in bytes, excluding the sender header the server adds) a socket may send; anything
+ * larger or empty is dropped. Matches `@rapidrest/service-core`'s uWS `DEFAULT_WS_OPTIONS.maxPayloadLength` (16 KiB),
+ * which this framework's route registration cannot raise - a larger message closes the socket at the transport. */
+export declare const RELAY_MAX_PAYLOAD_BYTES: number;
+/** The larger message limit the relay route asks the framework for when the installed `@rapidrest/service-core` lets a
+ * `@WebSocket()` route set one (its 2.4.0 and later): a video key frame then fits in one message instead of several,
+ * with far less fragmenting and reassembly for the client to get wrong. The hub advertises whichever limit applies to
+ * the client in `ready` (`maxMessageBytes`). */
+export declare const RELAY_LARGE_PAYLOAD_BYTES: number;
+/** How many bytes the framework may hold unsent for one relay socket before it drops further messages to it, when the
+ * installed `@rapidrest/service-core` lets a route set that (its default, 64 KiB, is smaller than one key frame's worth
+ * of headroom and made a briefly slow receiver lose frames constantly). One MiB is roughly two seconds of a 350 kbps
+ * video stream plus audio. */
+export declare const RELAY_WS_MAX_BACKPRESSURE_BYTES: number;
+/** The most sockets (registered or still awaiting their `hello`) one room holds at once. */
+export declare const RELAY_MAX_SOCKETS_PER_ROOM = 16;
+/** The most sockets one authenticated uid may hold in one room at once (several tabs or devices of one account). */
+export declare const RELAY_MAX_SOCKETS_PER_UID = 4;
+/** Sustained inbound binary budget per socket, in bytes per second (a token bucket refill rate). */
+export declare const RELAY_RATE_BYTES_PER_SECOND: number;
+/** Burst allowance of a socket's token bucket, in bytes - also the bucket's capacity. */
+export declare const RELAY_BURST_BYTES: number;
+/** How long a socket may stay over budget continuously before it is closed with 1008 "Too much data.". */
+export declare const RELAY_OVER_BUDGET_CLOSE_MS = 10000;
+/** Two over-budget drops further apart than this are separate episodes: a socket is "continuously" over budget only
+ * while it keeps being dropped at least this often. A sender that exceeds its budget by a hair (one drop every few
+ * seconds) is throttled but never closed; one that keeps sending well past it is closed after
+ * `RELAY_OVER_BUDGET_CLOSE_MS`. */
+export declare const RELAY_OVER_BUDGET_GRACE_MS = 1000;
+/** How long a new socket has to send its `hello` before it is closed with 1008 "Hello timeout.". */
+export declare const RELAY_HELLO_TIMEOUT_MS = 10000;
+/** The longest peer id, in characters. Its UTF-8 encoding must also fit in the one length byte of a forwarded frame
+ * (255), which `isValidRelayPeer()` enforces too. */
+export declare const RELAY_MAX_PEER_LENGTH = 128;
+/** The most peers one `want` message may name; further valid entries are ignored. */
+export declare const RELAY_MAX_WANT_PEERS = 32;
+/** The minimal socket surface the hub needs - satisfied by the framework's uWS/Bun/`ws` sockets and by a trivial
+ * fake in a test. */
+export interface RelaySocket {
+    /** Sends a text or binary message. `cb` is called with an error when the message could not be sent - for the
+     * framework's uWS shim that includes "dropped because the receiver's backpressure limit was reached". */
+    send(data: string | Uint8Array, cb?: (err?: Error | null) => void): void;
+    close(code?: number, reason?: string): void;
+}
+/** Receives every frame published to a room, whichever replica published it. */
+export type RelayBusListener = (sender: string, frame: Buffer) => void;
+/**
+ * **The seam between sockets.** How a frame gets from the socket that sent it to the sockets that want it. The hub
+ * never delivers directly: it `publish()`es the stamped frame and delivers whatever its own `subscribe()`d listener
+ * receives, so a bus that also carries frames between server replicas (a Redis pub/sub channel per room, say) makes
+ * the whole relay multi-replica without touching the hub. `InProcessRelayBus` delivers within this process only;
+ * `RedisRelayBus` (`util/RedisRelayBus.ts`) also crosses server replicas over Redis pub/sub.
+ */
+export interface RelayBus {
+    /** Registers `listener` for `roomId`'s frames - including frames this very process publishes - and returns a
+     * function that removes it. */
+    subscribe(roomId: string, listener: RelayBusListener): () => void;
+    /** Publishes `frame` (the complete forwarded message, sender header included) that `sender` (a peer id) sent
+     * to `roomId`. */
+    publish(roomId: string, sender: string, frame: Buffer): void;
+}
+/** A `RelayBus` that delivers synchronously to the listeners of this one process - see `RelayHub`'s doc comment for
+ * what that means for a deployment with several server replicas. */
+export declare class InProcessRelayBus implements RelayBus {
+    private readonly listeners;
+    subscribe(roomId: string, listener: RelayBusListener): () => void;
+    publish(roomId: string, sender: string, frame: Buffer): void;
+}
+/** What the hub tells a caller about one socket it accepted; the caller feeds it the socket's events. */
+export interface RelayConnection {
+    /** Handles one message received from the socket. Never throws, whatever the payload. */
+    message(data: string | Uint8Array, isBinary: boolean): void;
+    /** Handles the socket having closed. Idempotent, and safe after the hub itself closed the socket. */
+    close(): void;
+}
+/** Counters of what the hub did with frames - for tests and diagnostics. */
+export interface RelayStats {
+    /** Frames handed to a receiver's `send()`, including any of them it then reported as dropped. */
+    framesForwarded: number;
+    /** Frames a receiver's `send()` reported as dropped (uWS backpressure) or threw on - a subset of the above,
+     * apart from a throw, which is not counted as forwarded. */
+    framesDroppedBackpressure: number;
+    /** Frames dropped because their sender was over its token-bucket budget. */
+    framesDroppedBudget: number;
+    /** Frames dropped for being empty, oversized, or sent before `hello`. */
+    framesDroppedInvalid: number;
+}
+export interface RelayHubOptions {
+    /** Where frames travel between sockets. Defaults to a new `InProcessRelayBus`. */
+    bus?: RelayBus;
+    logger?: {
+        debug(message: string): void;
+    };
+    /** The largest binary message (and text message) a socket may send, and what `ready` tells the client. Defaults to
+     * `RELAY_MAX_PAYLOAD_BYTES`; the route sets `RELAY_LARGE_PAYLOAD_BYTES` when the framework was asked for that much. */
+    maxPayloadBytes?: number;
+}
+/**
+ * Returns whether `peer` is a well-formed relay peer id: a string of 1 to `RELAY_MAX_PEER_LENGTH` characters with no
+ * whitespace, separator, control or other invisible (Unicode category C or Z) character, whose UTF-8 encoding fits in
+ * the single length byte of a forwarded frame.
+ */
+export declare function isValidRelayPeer(peer: unknown): peer is string;
+/**
+ * Reads the `mail:videoconf:relay:enabled` setting. Environment-variable config arrives as a string ("true", "false",
+ * "0", "1") and nconf may parse it into a boolean or a number, so all of those are accepted; `false`, `0`, `"false"`
+ * and `"0"` (case-insensitive, trimmed) disable the relay and anything else - including an unset or unrecognizable
+ * value - leaves it enabled, the default.
+ */
+export declare function parseRelayEnabled(value: unknown): boolean;
+/**
+ * A fan-out relay of opaque binary frames between the participants of a room (one meeting) - the last-resort tier
+ * for participants whose network allows neither a direct WebRTC connection nor a TURN relay, only a WebSocket to this
+ * server. It knows nothing about meetings, users, HTTP or any framework: a caller authorizes a socket however it
+ * likes, hands it to `attach()` and feeds the returned `RelayConnection` the socket's `message` and `close` events.
+ *
+ * ## Wire protocol (version 1)
+ *
+ * Client to server, the first message must be a text message
+ * `{"op":"hello","v":1,"peer":"<peerId>"}`, sent within `RELAY_HELLO_TIMEOUT_MS`. `peer` is the caller's uid (the `uid`
+ * given to `attach()`) or starts with `<uid>~` - a per-tab or per-device id - and passes `isValidRelayPeer()`. Anything
+ * else closes the socket with 1008 "Invalid peer."; a wrong `v` closes it with 1008 "Unsupported version.". The server
+ * answers with the text message `{"op":"ready","v":1,"maxMessageBytes":<the limit below>}`. A second socket registering an already registered peer in the
+ * same room replaces the older one, which is closed with 1008 "Replaced.".
+ *
+ * After that, `{"op":"want","peers":["<peerId>", ...]}` REPLACES the socket's interest set with the valid entries, at
+ * most `RELAY_MAX_WANT_PEERS` of them; every other or malformed text message is ignored. Binary messages of 1 to
+ * `RelayHubOptions.maxPayloadBytes` bytes (`RELAY_MAX_PAYLOAD_BYTES` unless the route asked for more; opaque to the hub) are forwarded to every other socket of the room whose interest
+ * set contains the sender's peer id; binary before `hello`, empty and oversized messages are dropped.
+ *
+ * Server to client: `{"op":"ready","v":1,"maxMessageBytes":N}` once, then binary messages `[1 byte: UTF-8 length N of the sender's peer
+ * id][N bytes: the sender's peer id][the original payload]`. The sender is stamped by the hub from the `hello`,
+ * never trusted from the payload.
+ *
+ * ## Limits
+ *
+ * At most `RELAY_MAX_SOCKETS_PER_ROOM` sockets per room and `RELAY_MAX_SOCKETS_PER_UID` per uid per room, counting
+ * a socket from `attach()` on (a socket refused for either is closed with 1008 "Room full." / "Too many
+ * connections."). Each socket's inbound binary traffic is metered by a token bucket of `RELAY_RATE_BYTES_PER_SECOND`
+ * sustained with a `RELAY_BURST_BYTES` burst: an over-budget message is dropped silently, and a socket kept over
+ * budget for more than `RELAY_OVER_BUDGET_CLOSE_MS` (see `RELAY_OVER_BUDGET_GRACE_MS`) is closed with 1008 "Too
+ * much data.". A receiver whose `send()` reports the message as dropped (uWS backpressure) simply misses that
+ * frame - counted in `stats`, never queued or retried. Sockets and rooms are released when their socket closes; an
+ * empty room is deleted.
+ *
+ * ## Replicas
+ *
+ * The transport between sockets is the `RelayBus` given to the constructor, `InProcessRelayBus` by default, which
+ * delivers only within this process: **with several server replicas, participants whose sockets landed on different
+ * replicas cannot relay to each other** - a room exists independently on each replica and its members see only the
+ * members connected to the same one. Give the hub a `RedisRelayBus` and frames cross replicas over Redis pub/sub (one
+ * channel per room; `BaseVideoMeetingRoute` does that whenever `datastores:events` is configured); nothing else in the
+ * hub changes for it.
+ *
+ * Every limit above is enforced **per replica**, because a hub only knows its own sockets. A room's capacity across
+ * replicas is therefore up to `replicas x RELAY_MAX_SOCKETS_PER_ROOM` sockets (and `replicas x
+ * RELAY_MAX_SOCKETS_PER_UID` for one uid) in the worst case, where the load balancer spreads a meeting's sockets
+ * evenly. A peer id that registers on two replicas is not detected as a duplicate either (the "Replaced." rule is
+ * per replica), and each frame reaches every socket that wants its sender on every replica.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class RelayHub {
+    /** What has happened to frames so far. */
+    readonly stats: RelayStats;
+    private readonly bus;
+    private readonly logger?;
+    private readonly rooms;
+    private readonly env;
+    constructor(options?: RelayHubOptions);
+    /** The number of rooms that currently hold at least one socket. */
+    get roomCount(): number;
+    /** The number of sockets in `roomId` (0 for an unknown room). */
+    socketCount(roomId: string): number;
+    /**
+     * Accepts an already-authorized `socket` of `uid` into room `roomId`, or refuses it (closing it with 1008) when
+     * the room or the uid is at its limit. Returns the connection to feed the socket's events to, or `undefined`
+     * when refused.
+     */
+    attach(roomId: string, uid: string, socket: RelaySocket): RelayConnection | undefined;
+    /** Forgets `conn`, and its room once that is empty. */
+    private remove;
+    /** Hands `frame` from `sender` to every other socket of room `roomId` that wants it. A bus that delivers
+     * asynchronously (across replicas) may deliver a frame for a room that has just emptied; that is ignored. */
+    private deliver;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rapidmx/meet-plugin",
-    "version": "0.5.0",
+    "version": "0.8.0",
     "description": "RapidMX plugin that provides WebRTC video conferencing, joinable from a calendar invite or a shared link.",
     "repository": "https://github.com/rapidmx/meet-plugin.git",
     "author": "RapidREST <rapidrests@gmail.com>",
@@ -21,6 +21,9 @@
         "release": "npx @rapidrest/cli release",
         "prepublish": "yarn build"
     },
+    "dependencies": {
+        "@mediapipe/tasks-vision": "^1.0.1"
+    },
     "peerDependencies": {
         "@rapidmx/react-shared": ">=0.19.0 <1",
         "@rapidmx/restapi": ">=0.23.0 <1",
@@ -32,12 +35,12 @@
         "react-dom": "19.x"
     },
     "devDependencies": {
-        "@rapidmx/react-shared": "^0.19.0",
-        "@rapidmx/restapi": "^0.23.0",
-        "@rapidmx/web-client": "^0.17.0",
+        "@rapidmx/react-shared": "^0.22.0",
+        "@rapidmx/restapi": "^0.24.0",
+        "@rapidmx/web-client": "^0.21.0",
         "@rapidrest/core": "^6.0.0",
         "@rapidrest/react": "^2.1.0",
-        "@rapidrest/service-core": "^2.3.0",
+        "@rapidrest/service-core": "^2.4.0",
         "@swc/core": "^1.16.2",
         "@testing-library/dom": "^10.4.1",
         "@testing-library/jest-dom": "^7.0.1",
@@ -114,7 +117,7 @@
     "rapidmx": {
         "plugin": {
             "apiVersion": 1,
-            "displayName": "Video Conferencing",
+            "displayName": "Meet",
             "description": "Private and public WebRTC video meetings. A private meeting mints one link per invitee for a calendar invite's location and body; a public meeting shares a single link. Joining needs no account - a guest picks a name, checks their camera and microphone, and enters.",
             "mailboxScopedData": true,
             "settings": [
@@ -130,7 +133,7 @@
                     "label": "TURN server URL",
                     "type": "string",
                     "default": "",
-                    "help": "A turn: or turns: URL (e.g. turns:turn.example.com:5349), or several separated by commas (turn:turn.example.com:3478,turns:turn.example.com:5349), relaying media for a participant behind a restrictive NAT or firewall, for whom a direct peer-to-peer connection fails. Public STUN servers are used for everyone else and need no configuration. Leave empty to serve calls with STUN only - most calls will still connect, but some participants may not."
+                    "help": "A turn: or turns: URL (e.g. turns:turn.example.com:5349), or several separated by commas (turn:turn.example.com:3478,turns:turn.example.com:5349), relaying media for a participant behind a restrictive NAT or firewall, for whom a direct peer-to-peer connection fails. A plain turn: address is offered over both UDP and TCP (a network that blocks UDP can still use the TCP one); add ?transport=udp or ?transport=tcp to an address to offer only that. Public STUN servers are used for everyone else and need no configuration. Leave empty to serve calls with STUN only - most calls will still connect, but some participants may not."
                 },
                 {
                     "key": "mail:videoconf:turn:username",
@@ -152,6 +155,20 @@
                     "type": "string",
                     "default": "",
                     "help": "coturn's static-auth-secret, if configured. When set, every join mints its own short-lived username/credential pair (an HMAC-SHA1 of a timestamp with this secret) instead of handing out one permanent password to every participant - the recommended setup. Leave empty to use the static username/credential above instead."
+                },
+                {
+                    "key": "mail:videoconf:relay:enabled",
+                    "label": "WebSocket media relay",
+                    "type": "boolean",
+                    "default": true,
+                    "help": "The last-resort tier for a participant whose network blocks both a direct connection and TURN (e.g. a corporate firewall that only allows web traffic): their media travels over a WebSocket this server relays between the meeting's participants. Turn off to serve calls with direct and TURN connections only. With several server replicas it connects participants across them through the same Redis the push system uses; without that Redis it works only between participants on the same replica."
+                },
+                {
+                    "key": "mail:videoconf:effects:assets_url",
+                    "label": "Video effects assets URL",
+                    "type": "string",
+                    "default": "",
+                    "help": "Video effects (background blur, custom backgrounds, face accessories) run a small machine-learning model in the participant's browser. By default the model files and their WebAssembly runtime are downloaded, only when a participant turns such an effect on, from cdn.jsdelivr.net and storage.googleapis.com. To serve them yourself instead, set this to the base URL (https://files.example.com/meet-effects, or a path on this server) of a directory holding wasm/ (the contents of the @mediapipe/tasks-vision package's wasm directory), selfie_segmenter.tflite and face_landmarker.task. Leave empty to use the public CDNs."
                 }
             ],
             "ui": {