@memberjunction/ai-bridge-livekit 0.0.1 → 5.42.0

package/README.md

@@ -1,45 +1,139 @@
 # @memberjunction/ai-bridge-livekit
 
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@memberjunction/ai-bridge-livekit`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+The **LiveKit** Realtime Bridge driver — the **MJ-native multi-party room**. Unlike every other bridge
+in MemberJunction's Realtime Bridges program (which connect **out** to a 3rd-party meeting platform like
+Zoom/Teams/Meet or a telephony carrier), LiveKit is a **self-hosted WebRTC SFU that MJ runs itself**. The
+architecture treats a Zoom meeting and an MJ-native LiveKit room **identically** — both are multi-party
+media transports — so this is "*another bridge, not a special build.*"
+
+It connects the one realtime agent engine to a **LiveKit room** as a bot participant: bidirectional
+audio (and full video/screen), a per-participant diarized roster, room-admin mute, data-channel chat, and
+a **Meeting Controls** facilitator channel — all behind an injectable LiveKit room SDK seam so the driver
+builds and unit-tests with **no network and no real LiveKit SDK**.
+
+See the [Realtime Bridges Guide](../../../../guides/REALTIME_BRIDGES_GUIDE.md) and
+[`/plans/realtime/realtime-bridges-architecture.md`](../../../../plans/realtime/realtime-bridges-architecture.md)
+(§4c multi-party / MJ-native room, §3 provider abstraction, §4b channels) for the full architecture.
+
+## Install
+
+```bash
+npm install @memberjunction/ai-bridge-livekit
+```
+
+## Self-hosted vs. connecting out
+
+| | The other bridges (Zoom, Teams, Meet, Webex, Slack, Discord, Twilio…) | **LiveKit (this package)** |
+|---|---|---|
+| Who owns the room | a 3rd-party platform | **MJ — self-hosted SFU** |
+| How you join | a join URL / number you were handed | a room URL + a **token MJ mints** |
+| Bot admission | per-platform review/quirks | none — MJ controls the room |
+| Use case | meet the customer where they already are | an MJ-native multi-party experience (e.g. embedded in Explorer) |
+
+The same multi-party machinery (§4c) works either way: put **1+ agents into a shared room** and the room
+itself is the shared media plane.
+
+## What it provides
+
+- **`LiveKitBridge`** — `@RegisterClass(BaseRealtimeBridge, 'LiveKitBridge')`. The `MJ: AI Bridge
+  Providers` row with `DriverClass = 'LiveKitBridge'` resolves to this driver via the `ClassFactory`.
+  Implements the four `BaseRealtimeBridge` abstracts (`Connect` / `Disconnect` / `SendMedia` / `OnMedia`)
+  and the capability-gated virtuals LiveKit supports (`GetParticipants`, `OnParticipantChange`), plus
+  `GetMeetingControlsEventSource` for the facilitator channel and a `SendDataMessage` helper.
+- **`ILiveKitRoomSdk`** — the **injectable seam** the driver depends on instead of the real SDK.
+- **`LiveKitMeetingControlsEventSource`** — adapts the seam's roster / speaking / mute into the bridge's
+  `IBridgeMeetingControlsEventSource`, so the engine wires the Meeting Controls channel.
+
+## Capability coverage (the LiveKit seed row)
+
+| Capability | Status |
+|---|---|
+| On-demand join | ✅ |
+| Audio in / out | ✅ |
+| Video in / out | ✅ (LiveKit does full A/V) |
+| Screen in / out | ✅ (full screen share) |
+| Speaker diarization (per-participant tracks → labels) | ✅ — **native**, the SFU delivers tracks per participant |
+| Room-admin mute (Meeting Controls) | ✅ |
+| Data-channel chat | ✅ |
+| Scheduled / invite / native-invite join, DTMF / transfer / recording | ➖ not LiveKit-room features — the gated base methods throw `BridgeCapabilityNotSupportedError` |
+
+Capability gating is two-layer (defense-in-depth): the engine checks the provider's `SupportedFeatures`
+first, and the driver re-asserts each flag with `RequireFeature` at the top of its overrides.
+
+## The LiveKit room SDK seam (`ILiveKitRoomSdk`)
+
+The driver never imports the real LiveKit SDK. It depends only on this minimal interface:
+
+```typescript
+export interface ILiveKitRoomSdk {
+    connect(args: LiveKitConnectArgs): Promise<LiveKitConnectResult>;       // roomUrl + signed token → join as bot
+    disconnect(): Promise<void>;
+    publishAudioFrame(pcm: ArrayBuffer): void;                              // agent's voice out
+    onAudioTrack(cb: (frame: LiveKitAudioFrame) => void): void;            // per-participant audio in (diarization)
+    publishVideoFrame(frame: ArrayBuffer): void;                            // full video out
+    publishScreenFrame(frame: ArrayBuffer): void;                           // full screen share out
+    onParticipantJoin(cb: (p: LiveKitParticipant) => void): void;
+    onParticipantLeave(cb: (id: string) => void): void;
+    getParticipants(): Promise<LiveKitParticipant[]>;
+    sendDataMessage(text: string): Promise<void>;                           // data-channel chat
+    onDisconnected(cb: () => void): void;
+}
+```
+
+**Native binding:** this package ships **`LiveKitNativeMeetingSdk`** (`livekit-native-sdk.ts`) — the
+two-way adapter over the LiveKit room client, activated with `bridge.SetSdkFactory(BindLiveKitNative())`
+(auto-bound by the engine as the registered default for `DriverClass = 'LiveKitBridge'`). It's the MJ-side
+adapter, unit-tested against a fake module; none of the SDK types leak into this package.
+
+**The real room client now ships too:** [`@memberjunction/ai-bridge-livekit-native`](../LiveKitNative)
+wraps `@livekit/rtc-node` behind this adapter's `NativeRoomModule` contract. The LiveKit coordinator points
+`NativeModuleSpecifier` at it by default (overridable via the `LIVEKIT_NATIVE_MODULE` env), so a deployment
+just needs to `npm install @livekit/rtc-node` on the agent host. Until a module is configured, `connect`
+throws an explicit "load the native LiveKit module" error.
+
+LiveKit is the recommended **internal proving ground** (pair with the `mj-livekit-room` Explorer tab or the
+LiveKit Agents Playground) — see
+[`plans/realtime/native-bridge-buildout-plan.md`](../../../../plans/realtime/native-bridge-buildout-plan.md) §6.
+
+## Echo / self-audio
+
+A LiveKit SFU **never delivers a participant its own published track back** — the bot does not hear its
+own voice, so no echo gate is needed. This is exactly the property the multi-party model relies on
+(§4c): each agent in a room hears the *others'* mix natively, never itself, so two agents can converse
+without a transcript-relay hack.
+
+## Usage
+
+```typescript
+import { LiveKitBridge } from '@memberjunction/ai-bridge-livekit';
+import { AIBridgeEngine } from '@memberjunction/ai-bridge-server';
+
+// The engine resolves the driver by DriverClass via the ClassFactory; you do not new it up directly.
+// In production, bind the real SDK factory once at boot:
+//   (resolved per provider config) — LiveKitBridge instances call SetSdkFactory with a real adapter.
+
+const active = await AIBridgeEngine.Instance.StartBridgeSession({
+    AgentSessionID: sessionId,
+    Provider: liveKitProvider,            // MJ: AI Bridge Providers row, DriverClass='LiveKitBridge'
+    RealtimeSession: realtimeSession,     // injected IRealtimeSession
+    Address: 'wss://livekit.myorg.com',   // the MJ-native room server
+    Configuration: { AccessToken: signedToken, BotDisplayName: 'Sage' },
+    MetadataProvider: provider,
+    ContextUser: user,
+});
+```
+
+For multiple agents in one LiveKit room, register each session with the engine's room coordinator — see
+the [Multi-party section of the guide](../../../../guides/REALTIME_BRIDGES_GUIDE.md) and
+`MultiAgentRoomCoordinator` in `@memberjunction/ai-bridge-server`.
+
+## Testing
+
+`FakeLiveKitRoomSdk` (in the test file) implements `ILiveKitRoomSdk` in memory with drive helpers and
+capture sinks — connect/disconnect, audio in→`OnMedia` (speaker labels) + out→track, video/screen out,
+participant join/leave→roster, speaking attribution, data-channel chat, and capability gating. **24
+tests, no network.** Run with `npm test`.
+
+## License
+
+ISC

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './livekit-sdk.js';
+export * from './livekit-native-sdk.js';
+export * from './livekit-meeting-controls.js';
+export * from './livekit-bridge.js';
+export * from './register-native.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from './livekit-sdk.js';
+export * from './livekit-native-sdk.js';
+export * from './livekit-meeting-controls.js';
+export * from './livekit-bridge.js';
+export * from './register-native.js';
+import { LoadLiveKitBridge } from './livekit-bridge.js';
+import { RegisterLiveKitNativeSdk } from './register-native.js';
+// Static reference so bundlers cannot tree-shake the @RegisterClass(BaseRealtimeBridge, 'LiveKitBridge')
+// registration. Calling the no-op here keeps the driver resolvable by the engine's ClassFactory.
+LoadLiveKitBridge();
+// Register LiveKit's native two-way SDK binding so the engine auto-binds it at StartBridgeSession.
+RegisterLiveKitNativeSdk();
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAElC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,yGAAyG;AACzG,iGAAiG;AACjG,iBAAiB,EAAE,CAAC;AACpB,mGAAmG;AACnG,wBAAwB,EAAE,CAAC"}

package/dist/livekit-bridge.d.ts

@@ -0,0 +1,166 @@
+/**
+ * @fileoverview `LiveKitBridge` — the **MJ-native multi-party room** Realtime Bridge driver. Unlike
+ * every other bridge (which connects OUT to a 3rd-party meeting/telephony platform), LiveKit is a
+ * **self-hosted WebRTC SFU that MJ runs itself** — the "MJ-native room"
+ * (`/plans/realtime/realtime-bridges-architecture.md` §4c). The architecture treats a Zoom meeting and
+ * an MJ-native LiveKit room **identically** — both are multi-party media transports — so this is
+ * "*another bridge, not a special build*."
+ *
+ * Implements the {@link BaseRealtimeBridge} contract against an injectable {@link ILiveKitRoomSdk} seam
+ * so it builds + unit-tests with NO network and NO real LiveKit SDK (the Zoom `SetSdkFactory`
+ * testability pattern).
+ *
+ * LiveKit capability coverage (per the §4c / §8 seed row): on-demand join, **full** audio/video/screen
+ * in+out (LiveKit does the lot), and per-participant diarization (`SpeakerDiarization`) — the SFU
+ * delivers tracks per participant, so speaker labels come free. No scheduled/invite/telephony features.
+ * Those virtual base methods keep throwing `BridgeCapabilityNotSupportedError`.
+ *
+ * ## Echo / self-audio
+ * A LiveKit SFU **never delivers a participant its own published track back**, so the bot does not hear
+ * its own voice — no echo gate is required (see {@link wireInboundAudio}). This is exactly the property
+ * §4c relies on for putting **multiple agents in one room**: each agent hears the *others'* mixed audio
+ * natively, not its own, so two agents converse without a transcript-relay hack.
+ *
+ * @module @memberjunction/ai-bridge-livekit
+ * @author MemberJunction.com
+ */
+import { BaseRealtimeBridge, BridgeConnectResult, BridgeDisconnectReason, BridgeMediaFrame, BridgeMediaTrackKind, BridgeParticipantInfo, RealtimeBridgeContext, IBridgeMeetingControlsEventSource } from '@memberjunction/ai-bridge-base';
+import { LiveKitRoomSdkFactory } from './livekit-sdk.js';
+/**
+ * The `DriverClass` key {@link LiveKitBridge} registers under. A `MJ: AI Bridge Providers` row with
+ * `DriverClass = 'LiveKitBridge'` resolves to this driver via the `ClassFactory`.
+ */
+export declare const LIVEKIT_BRIDGE_DRIVER_CLASS = "LiveKitBridge";
+/**
+ * Realtime Bridge driver for the **MJ-native LiveKit room**.
+ *
+ * Construct the driver with the default constructor (the engine's `ClassFactory` path) — it lazily
+ * builds the LiveKit room SDK from the {@link sdkFactory} at {@link Connect} time. Tests inject a
+ * `FakeLiveKitRoomSdk` by overriding the factory via {@link SetSdkFactory} (the creation seam) before
+ * connecting.
+ *
+ * Registered via `@RegisterClass(BaseRealtimeBridge, 'LiveKitBridge')`.
+ */
+export declare class LiveKitBridge extends BaseRealtimeBridge {
+    /** The live LiveKit SDK seam for this session, created at {@link Connect}. */
+    private sdk;
+    /** The bot's own participant identity in the joined room (set at {@link Connect}). */
+    private botIdentity;
+    /** The inbound-media handler registered via {@link OnMedia}; raw audio frames are forwarded to it. */
+    private mediaHandler?;
+    /** The roster-change handler registered via {@link OnParticipantChange}. */
+    private participantHandler?;
+    /** The Meeting Controls event source for this session (only when diarization is supported). */
+    private meetingControls;
+    /**
+     * The SDK creation seam. Defaults to a factory that throws an explicit "bind the real LiveKit SDK"
+     * error, since this package ships WITHOUT the real SDK adapter (a deployment concern). Production
+     * sets a real factory via {@link SetSdkFactory}; tests inject a `FakeLiveKitRoomSdk`.
+     */
+    private sdkFactory;
+    /**
+     * Sets the {@link LiveKitRoomSdkFactory} this driver uses to construct its SDK seam at connect — the
+     * creation seam (mirroring Zoom's `SetSdkFactory`). Production binds the real LiveKit room SDK
+     * adapter here; tests inject a `FakeLiveKitRoomSdk`.
+     *
+     * @param factory The factory that builds the {@link ILiveKitRoomSdk} for a session.
+     */
+    SetSdkFactory(factory: LiveKitRoomSdkFactory): void;
+    /**
+     * Connects to the MJ-native LiveKit room and brings the bot online. Captures the capability context,
+     * builds the SDK from the {@link sdkFactory}, wires the inbound per-participant audio path and
+     * room-disconnected callback, connects, and (when the provider diarizes) constructs + seeds the
+     * Meeting Controls event source.
+     *
+     * @param ctx The bridge context (features, provider name, the room URL as `Address`, config carrying
+     *   the signed access token).
+     * @returns The bot identity + room (external connection) identifiers, persisted by the engine.
+     */
+    Connect(ctx: RealtimeBridgeContext): Promise<BridgeConnectResult>;
+    /**
+     * Disconnects from the LiveKit room and releases all SDK resources. Tolerant of teardown errors.
+     *
+     * @param _reason Why the disconnect happened (LiveKit teardown is uniform; the bot simply leaves).
+     */
+    Disconnect(_reason: BridgeDisconnectReason): Promise<void>;
+    /**
+     * Sends an outbound media frame into the room. LiveKit does the FULL media set, so audio, video, and
+     * screen are all published on their respective tracks (gated by the directional capability flags —
+     * the realtime models light audio first, video/screen ride the same path once a model emits them).
+     *
+     * @param track The outbound track the frame targets.
+     * @param frame The media frame to send.
+     */
+    /** Flushes the agent's queued outbound voice on barge-in (the user interrupted the agent). */
+    FlushOutboundMedia(): void;
+    SendMedia(track: BridgeMediaTrackKind, frame: BridgeMediaFrame): void;
+    /**
+     * Registers the inbound-media handler. The driver forwards each raw per-participant audio frame
+     * (with its speaker identity) to this handler; the engine routes it to `IRealtimeSession.SendInput`.
+     *
+     * @param handler Invoked with each inbound media frame.
+     */
+    OnMedia(handler: (frame: BridgeMediaFrame) => void): void;
+    /**
+     * Returns the current LiveKit participant roster (gated by `SpeakerDiarization`). Re-asserts the
+     * flag (defense-in-depth) so even an engine-bypassing caller cannot pull a roster a disabled
+     * provider forbids.
+     *
+     * @returns The current participants.
+     * @throws {BridgeCapabilityNotSupportedError} when diarization is not enabled for the provider.
+     */
+    GetParticipants(): Promise<BridgeParticipantInfo[]>;
+    /**
+     * Registers a roster-change handler (gated by `SpeakerDiarization`). The driver fires it from the
+     * SDK's participant join/leave stream with the full current roster.
+     *
+     * @param handler Invoked with the updated participant list on each change.
+     * @throws {BridgeCapabilityNotSupportedError} when diarization is not enabled.
+     */
+    OnParticipantChange(handler: (participants: BridgeParticipantInfo[]) => void): void;
+    /**
+     * Returns the LiveKit Meeting Controls event source for this session (roster · speaking · mute), or
+     * `null` when diarization is off (no roster to facilitate). The engine wires the Meeting Controls
+     * channel from this.
+     */
+    GetMeetingControlsEventSource(): IBridgeMeetingControlsEventSource | null;
+    /**
+     * Sends a message on the LiveKit data channel — the room-native "chat". Exposed for the channel
+     * plane / turn-taking hybrid mode (the social-cost-free "raise hand"). Best-effort — a failure is
+     * logged, never fatal.
+     *
+     * @param text The data/chat message to send.
+     */
+    SendDataMessage(text: string): Promise<void>;
+    /** The bot's participant identity in the joined room (or `null` before {@link Connect}). */
+    get BotIdentity(): string | null;
+    /**
+     * Wires the SDK's inbound per-participant audio callback to a diarized inbound
+     * {@link BridgeMediaFrame}. The SFU never echoes the bot's own audio, so no self-audio gate is
+     * needed; the frame's `SpeakerLabel` is the source participant identity.
+     */
+    private wireInboundAudio;
+    /**
+     * Wires the SDK's participant join/leave streams ONCE (the driver is the single owner; the SDK seam
+     * is latest-handler-wins). Each roster change fans out to both the driver's own roster-change
+     * handler and the Meeting Controls source.
+     */
+    private wireRoster;
+    /** Pulls the current roster from the SDK and fans it out to both the participant handler + Meeting Controls. */
+    private refreshRoster;
+    /** Handles the SDK's room-disconnected signal: surface an empty roster so the engine sees everyone gone. */
+    private handleRoomDisconnected;
+    /** Builds the SDK connect args from the bridge context (Address is the room URL; token from config). */
+    private buildConnectArgs;
+    /** Returns the bytes of an outbound media frame, preferring the binary payload. */
+    private framePcm;
+    /** Decodes a base64 payload to an `ArrayBuffer` (Node `Buffer` fast path, `atob` fallback). */
+    private decodeBase64;
+}
+/**
+ * Tree-shaking-prevention loader. Modern bundlers cannot see the `@RegisterClass` dynamic registration
+ * of {@link LiveKitBridge} and may eliminate it. Import and call this no-op from a static code path
+ * (the package entry point does) so the `ClassFactory` can resolve `'LiveKitBridge'`.
+ */
+export declare function LoadLiveKitBridge(): void;
+//# sourceMappingURL=livekit-bridge.d.ts.map

package/dist/livekit-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"livekit-bridge.d.ts","sourceRoot":"","sources":["../src/livekit-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,EACH,kBAAkB,EAClB,mBAAmB,EACnB,sBAAsB,EACtB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EAErB,qBAAqB,EACrB,iCAAiC,EACpC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAEH,qBAAqB,EAKxB,MAAM,eAAe,CAAC;AAGvB;;;GAGG;AACH,eAAO,MAAM,2BAA2B,kBAAkB,CAAC;AA0C3D;;;;;;;;;GASG;AACH,qBACa,aAAc,SAAQ,kBAAkB;IACjD,8EAA8E;IAC9E,OAAO,CAAC,GAAG,CAAgC;IAE3C,sFAAsF;IACtF,OAAO,CAAC,WAAW,CAAuB;IAE1C,sGAAsG;IACtG,OAAO,CAAC,YAAY,CAAC,CAAoC;IAEzD,4EAA4E;IAC5E,OAAO,CAAC,kBAAkB,CAAC,CAAkD;IAE7E,+FAA+F;IAC/F,OAAO,CAAC,eAAe,CAAkD;IAEzE;;;;OAIG;IACH,OAAO,CAAC,UAAU,CAKhB;IAEF;;;;;;OAMG;IACI,aAAa,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI;IAM1D;;;;;;;;;OASG;IACU,OAAO,CAAC,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA2B9E;;;;OAIG;IACU,UAAU,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBvE;;;;;;;OAOG;IACH,8FAA8F;IAC9E,kBAAkB,IAAI,IAAI;IAInC,SAAS,CAAC,KAAK,EAAE,oBAAoB,EAAE,KAAK,EAAE,gBAAgB,GAAG,IAAI;IA4B5E;;;;;OAKG;IACI,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,GAAG,IAAI;IAMhE;;;;;;;OAOG;IACmB,eAAe,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;IASzE;;;;;;OAMG;IACa,mBAAmB,CAAC,OAAO,EAAE,CAAC,YAAY,EAAE,qBAAqB,EAAE,KAAK,IAAI,GAAG,IAAI;IAKnG;;;;OAIG;IACa,6BAA6B,IAAI,iCAAiC,GAAG,IAAI;IAMzF;;;;;;OAMG;IACU,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWzD,4FAA4F;IAC5F,IAAW,WAAW,IAAI,MAAM,GAAG,IAAI,CAEtC;IAID;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;;;OAIG;IACH,OAAO,CAAC,UAAU;IAKlB,gHAAgH;YAClG,aAAa;IAU3B,4GAA4G;IAC5G,OAAO,CAAC,sBAAsB;IAK9B,wGAAwG;IACxG,OAAO,CAAC,gBAAgB;IASxB,mFAAmF;IACnF,OAAO,CAAC,QAAQ;IAUhB,+FAA+F;IAC/F,OAAO,CAAC,YAAY;CAcvB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAExC"}