@absolutejs/meeting 0.0.1-beta.3 → 0.0.1-beta.5

package/dist/emitter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tiny hand-rolled event emitter — a `Set` of listeners per event plus a fan-out
+ * `emit`. Deliberately not Node's `EventEmitter`: this runs in the browser too,
+ * keeps zero deps, and stays fully typed against an event map (no `any`, no
+ * `as never`). Used by the meeting core and the buffer source, and the shape the
+ * platform adapters mirror.
+ *
+ * Construct with the exhaustive list of event names so each set exists up front;
+ * the mapped type then guarantees `on`/`emit` are exhaustive over the map.
+ */
+export type Listener<T> = (payload: T) => void | Promise<void>;
+export type Emitter<EventMap> = {
+    on: <K extends keyof EventMap>(event: K, handler: Listener<EventMap[K]>) => () => void;
+    emit: <K extends keyof EventMap>(event: K, payload: EventMap[K]) => void;
+};
+export declare const createEmitter: <EventMap>(events: readonly (keyof EventMap)[]) => Emitter<EventMap>;

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { createMeeting } from "./meeting";
 export type { MeetingSession, MeetingTurn, MeetingEventMap, CreateMeetingOptions, } from "./meeting";
 export { createBufferMeetingSource } from "./bufferSource";
 export type { BufferMeetingSourceOptions } from "./bufferSource";
-export type { MeetingSource, MeetingSourceEventMap, MeetingParticipant, SpeakAudio, } from "./source";
+export type { ChatMessage, MeetingCapabilities, MeetingSource, MeetingSourceEventMap, MeetingParticipant, SpeakAudio, } from "./source";

package/dist/index.js

@@ -3,6 +3,28 @@
 import {
   createVoiceScribe
 } from "@absolutejs/voice";
+
+// src/emitter.ts
+var createEmitter = (events) => {
+  const listeners = {};
+  for (const event of events) {
+    listeners[event] = new Set;
+  }
+  return {
+    emit: (event, payload) => {
+      for (const handler of listeners[event])
+        handler(payload);
+    },
+    on: (event, handler) => {
+      listeners[event].add(handler);
+      return () => {
+        listeners[event].delete(handler);
+      };
+    }
+  };
+};
+
+// src/meeting.ts
 var createMeeting = async (options) => {
   const scribe = await createVoiceScribe({
     format: options.source.format,
@@ -14,16 +36,13 @@ var createMeeting = async (options) => {
   });
   const participants = new Map;
   let lastSpeaker;
-  const listeners = {
-    end: new Set,
-    error: new Set,
-    participant: new Set,
-    turn: new Set
-  };
-  const emit = (event, payload) => {
-    for (const handler of listeners[event])
-      handler(payload);
-  };
+  const { emit, on } = createEmitter([
+    "chat",
+    "end",
+    "error",
+    "participant",
+    "turn"
+  ]);
   const resolveParticipant = (turn) => participants.get(turn.speaker) ?? (lastSpeaker ? participants.get(lastSpeaker) : undefined);
   scribe.on("turn", ({ turn }) => {
     emit("turn", { turn: { ...turn, participant: resolveParticipant(turn) } });
@@ -48,21 +67,28 @@ var createMeeting = async (options) => {
     if (participant)
       lastSpeaker = participant;
     scribe.send(chunk);
-  }), options.source.on("participant", ({ participant }) => {
-    participants.set(participant.id, participant);
-    emit("participant", { participant });
-  }), options.source.on("end", ({ reason }) => void finalize(reason)), options.source.on("error", ({ error }) => emit("error", { error })));
+  }), options.source.on("participant", ({ participant, status }) => {
+    if (status !== "left")
+      participants.set(participant.id, participant);
+    emit("participant", { participant, ...status ? { status } : {} });
+  }), options.source.on("chat", (payload) => emit("chat", payload)), options.source.on("end", ({ reason }) => void finalize(reason)), options.source.on("error", ({ error }) => emit("error", { error })));
+  const capabilities = options.source.capabilities ?? {
+    canChat: Boolean(options.source.sendChat),
+    canSpeak: Boolean(options.source.speak)
+  };
   return {
+    capabilities,
     getParticipants: () => [...participants.values()],
     getTranscript: () => scribe.getTranscript().map((turn) => ({
       ...turn,
       participant: resolveParticipant(turn)
     })),
-    on: (event, handler) => {
-      listeners[event].add(handler);
-      return () => {
-        listeners[event].delete(handler);
-      };
+    on,
+    sendChat: async (text, opts) => {
+      if (!options.source.sendChat) {
+        throw new Error("meeting.sendChat: this source does not implement sendChat() \u2014 the bot can't post to the call chat");
+      }
+      await options.source.sendChat(text, opts);
     },
     speak: async (audio) => {
       if (!options.source.speak) {
@@ -70,6 +96,9 @@ var createMeeting = async (options) => {
       }
       await options.source.speak(audio);
     },
+    stopSpeaking: async () => {
+      await options.source.stopSpeaking?.();
+    },
     start: () => options.source.start(),
     stop: async (reason) => {
       await options.source.stop(reason);
@@ -81,25 +110,17 @@ var createMeeting = async (options) => {
 var bytesPerSample = (format) => (format.encoding === "pcm_s16le" ? 2 : 1) * format.channels;
 var createBufferMeetingSource = (options) => {
   const chunkMs = options.chunkMs ?? 40;
-  const listeners = {
-    audio: new Set,
-    end: new Set,
-    error: new Set,
-    participant: new Set
-  };
-  const emit = (event, payload) => {
-    for (const handler of listeners[event])
-      handler(payload);
-  };
+  const { emit, on } = createEmitter([
+    "audio",
+    "chat",
+    "end",
+    "error",
+    "participant"
+  ]);
   let stopped = false;
   return {
     format: options.format,
-    on: (event, handler) => {
-      listeners[event].add(handler);
-      return () => {
-        listeners[event].delete(handler);
-      };
-    },
+    on,
     start: async () => {
       for (const participant of options.participants ?? []) {
         emit("participant", { participant });

package/dist/meeting.d.ts

@@ -1,5 +1,5 @@
 import { type STTAdapter, type VoiceLanguageStrategy, type VoiceLexiconEntry, type VoicePhraseHint, type VoiceScribeTurn } from "@absolutejs/voice";
-import type { MeetingParticipant, MeetingSource, SpeakAudio } from "./source";
+import type { ChatMessage, MeetingCapabilities, MeetingParticipant, MeetingSource, SpeakAudio } from "./source";
 export type MeetingTurn = VoiceScribeTurn & {
     /** Resolved participant for this turn, when the source identified speakers. */
     participant?: MeetingParticipant;
@@ -8,8 +8,15 @@ export type MeetingEventMap = {
     turn: {
         turn: MeetingTurn;
     };
+    /** Roster update. `status` mirrors the source: "joined"/absent on appear,
+     *  "left" when a participant leaves the call. */
     participant: {
         participant: MeetingParticipant;
+        status?: "joined" | "left";
+    };
+    /** A text message arrived in the call chat. */
+    chat: {
+        message: ChatMessage;
     };
     end: {
         reason?: string;
@@ -31,6 +38,19 @@ export type MeetingSession = {
      * the formats each adapter accepts (Recall: mp3; Discord: pcm).
      */
     speak: (audio: SpeakAudio) => Promise<void>;
+    /** Cut the bot's in-progress speech (barge-in). No-op when the source can't
+     *  inject/stop audio or nothing is playing. */
+    stopSpeaking: () => Promise<void>;
+    /**
+     * Post a text message INTO the call chat. Delegates to the source; throws if
+     * the underlying adapter doesn't implement `sendChat`. `opts.system` is a hint
+     * for platforms that distinguish system messages (ignored elsewhere).
+     */
+    sendChat: (text: string, opts?: {
+        system?: boolean;
+    }) => Promise<void>;
+    /** What the underlying source can do (speak / chat). */
+    readonly capabilities: MeetingCapabilities;
     getTranscript: () => MeetingTurn[];
     getParticipants: () => MeetingParticipant[];
 };

package/dist/source.d.ts

@@ -7,6 +7,36 @@ export type MeetingParticipant = {
     platform?: string;
     metadata?: Record<string, unknown>;
 };
+/**
+ * A text message in the call's chat. `kind` distinguishes ordinary messages
+ * from emoji reactions and platform/system notices; everything but `text` is
+ * best-effort and may be absent depending on what the source can report.
+ */
+export type ChatMessage = {
+    /** The message body (or reaction emoji / system text). */
+    text: string;
+    /** What sort of chat event this is. Defaults to a normal "message". */
+    kind?: "message" | "reaction" | "system";
+    /** Resolved sender, when the source identified them. */
+    author?: MeetingParticipant;
+    /** Raw platform sender id, even when the full participant isn't resolved. */
+    authorId?: string;
+    /** Epoch ms the message was sent, when the source reports it. */
+    timestamp?: number;
+    /** Platform channel/thread id the message belongs to, when applicable. */
+    channelId?: string;
+};
+/**
+ * Which in-call outputs a source supports. Mirrors the optional `speak` /
+ * `sendChat` members so a consumer can branch on capabilities up front instead
+ * of probing for thrown "not implemented" errors.
+ */
+export type MeetingCapabilities = {
+    /** The bot can play audio INTO the call (`speak`). */
+    canSpeak: boolean;
+    /** The bot can post text into the call chat (`sendChat`). */
+    canChat: boolean;
+};
 /**
  * Audio the bot wants to play INTO the call. Adapters declare which formats
  * they accept (Recall: mp3; Discord: pcm); a TypeError is the right signal
@@ -29,9 +59,16 @@ export type MeetingSourceEventMap = {
         chunk: AudioChunk;
         participant?: string;
     };
-    /** Roster update — someone joined / was identified. */
+    /** Roster update — someone joined / left / was identified. `status` signals
+     *  the transition: "joined" (or absent — the historical behavior) when a
+     *  participant appears/is identified, "left" when they leave the call. */
     participant: {
         participant: MeetingParticipant;
+        status?: "joined" | "left";
+    };
+    /** A text message arrived in the call chat. */
+    chat: {
+        message: ChatMessage;
     };
     /** The call ended (everyone left, host stopped, etc.). */
     end: {
@@ -62,4 +99,24 @@ export type MeetingSource = {
      * the platform has accepted it, for fire-and-forget transports).
      */
     speak?: (audio: SpeakAudio) => Promise<void>;
+    /**
+     * Stop any in-progress `speak()` output immediately (barge-in / ducking).
+     * Optional — sources that can't inject audio (or can't stop it) omit it;
+     * `meeting.stopSpeaking()` then no-ops.
+     */
+    stopSpeaking?: () => Promise<void>;
+    /**
+     * Post a text message INTO the call chat. Optional — adapters that can't write
+     * chat simply don't implement it; `meeting.sendChat()` will throw a clear
+     * error in that case. `opts.system` is a hint for platforms that distinguish
+     * system/announcement messages from ordinary ones (ignored elsewhere).
+     */
+    sendChat?: (text: string, opts?: {
+        system?: boolean;
+    }) => Promise<void>;
+    /**
+     * What this source can do (speak / chat). Optional — when absent, consumers
+     * fall back to probing the presence of `speak` / `sendChat`.
+     */
+    readonly capabilities?: MeetingCapabilities;
 };

package/package.json

@@ -1,11 +1,15 @@
 {
 	"name": "@absolutejs/meeting",
-	"version": "0.0.1-beta.3",
+	"version": "0.0.1-beta.5",
 	"description": "Meeting-bot core for AbsoluteJS — join a call (via a source adapter), transcribe it live with the voice scribe, and surface diarized turns + participants for analysis",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/absolutejs/meeting.git"
 	},
+	"homepage": "https://github.com/absolutejs/meeting",
+	"bugs": {
+		"url": "https://github.com/absolutejs/meeting/issues"
+	},
 	"files": [
 		"dist",
 		"README.md"