@absolutejs/meeting 0.0.1-beta.0 → 0.0.1-beta.10

package/LICENSE

@@ -0,0 +1,88 @@
+# Business Source License 1.1
+
+**Licensor:** Alex Kahn
+
+**Licensed Work:** @absolutejs/meeting (https://github.com/absolutejs/meeting)
+
+**Change Date:** May 29, 2030
+
+**Change License:** Apache License, Version 2.0
+
+---
+
+## Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, permitting limited production use.
+
+### Additional Use Grant
+
+You may use the Licensed Work in production, provided your use does not include
+any of the following:
+
+1. **Offering a Competing Service.** You may not offer the Licensed Work, or
+   any derivative or substantial portion of it, to third parties as a hosted or
+   managed service that competes with a hosted meeting bot, meeting transcription, or meeting-intelligence service (including, but not limited to, services like Recall.ai, Fireflies, Gong, Otter, or Read.ai). This includes any
+   product whose primary value to its users is the functionality the Licensed
+   Work provides.
+
+2. **Resale or Redistribution as a Standalone Product.** You may not sell,
+   license, or distribute the Licensed Work, or any derivative or fork of it,
+   as a standalone commercial product.
+
+3. **Removal of Attribution.** Any derivative work, fork, or redistribution of
+   the Licensed Work must prominently credit AbsoluteJS and include a link to
+   the original project repository (https://github.com/absolutejs/meeting).
+
+For clarity, the following uses are expressly permitted:
+
+- Using the Licensed Work to build and operate your own applications, websites,
+  internal tools, or SaaS products (whether commercial or non-commercial), so
+  long as the Licensed Work itself is not the primary product you are selling.
+- Using the Licensed Work as a dependency in commercial software you build and
+  sell, as long as the software is not itself a competing managed service of
+  the kind described in clause 1.
+- Providing consulting, development, or professional services to clients using
+  the Licensed Work.
+- Forking and modifying the Licensed Work for your own internal use, provided
+  attribution is maintained.
+
+### Change Date and Change License
+
+On the Change Date specified above, or on such other date as the Licensor may
+specify by written notice, the Licensed Work will be made available under the
+Change License (Apache License, Version 2.0). Until the Change Date, the terms
+of this Business Source License 1.1 apply.
+
+### Trademark
+
+This license does not grant you any rights to use the "AbsoluteJS" or
+"@absolutejs" name, logo, or any related trademarks. Forks and derivative works
+must not be named or branded in a manner that suggests endorsement by or
+affiliation with AbsoluteJS or the Licensor.
+
+### Notices
+
+You must not remove or obscure any licensing, copyright, or other notices
+included in the Licensed Work.
+
+### No Warranty
+
+THE LICENSED WORK IS PROVIDED "AS IS". THE LICENSOR HEREBY DISCLAIMS ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE LICENSOR BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR
+IN CONNECTION WITH THE LICENSED WORK OR THE USE OR OTHER DEALINGS IN THE
+LICENSED WORK.
+
+---
+
+## Contact
+
+For commercial licensing inquiries or additional permissions, contact:
+
+- **Alex Kahn**
+- alexkahndev@gmail.com
+- alexkahndev.github.io

package/README.md

@@ -37,6 +37,28 @@ await meeting.start(); // bot joins the call
 // ... later: await meeting.stop()
 ```
 
+For an application that joins dynamic calls, bind provider configuration once
+and use the multi-session manager. Installation itself never contacts a meeting
+platform:
+
+```ts
+import { createMeetingManager } from "@absolutejs/meeting";
+import { createRecallMeetingSourceFactory } from "@absolutejs/meeting-recall";
+
+const meetings = createMeetingManager({
+  source: createRecallMeetingSourceFactory({
+    apiKey: process.env.RECALL_API_KEY!,
+    websocketUrl: "wss://app.example.com/meeting/audio",
+  }),
+  stt: deepgram({ apiKey: process.env.DEEPGRAM_API_KEY!, diarize: true }),
+});
+
+await meetings.start({
+  sessionId: "deal-123",
+  target: "https://meet.google.com/abc-defg-hij",
+});
+```
+
 ### Testing without a platform
 
 `createBufferMeetingSource` streams an in-memory PCM buffer in real time — the
@@ -46,10 +68,12 @@ reference `MeetingSource` implementation and a test harness.
 
 - `createMeeting(options)` → `MeetingSession` (`on`, `start`, `stop`,
   `getTranscript`, `getParticipants`).
+- `createMeetingManager(options)` → dynamic, idempotent multi-session host
+  boundary (`start`, `stop`, `get`, `list`).
 - `createBufferMeetingSource(options)` → `MeetingSource`.
 - Types: `MeetingSource`, `MeetingSourceEventMap`, `MeetingParticipant`,
   `MeetingSession`, `MeetingTurn`, `CreateMeetingOptions`.
 
 ## License
 
-CC BY-NC 4.0
+Business Source License 1.1 — production use is free except offering the package as a competing hosted service (see the Additional Use Grant in [LICENSE](./LICENSE)). Converts to Apache 2.0 on May 29, 2030.

package/dist/bufferSource.d.ts

@@ -1,5 +1,6 @@
 import type { AudioFormat } from "@absolutejs/voice";
 import type { MeetingParticipant, MeetingSource } from "./source";
+import type { MeetingSourceFactory } from "./manager";
 export type BufferMeetingSourceOptions = {
     format: AudioFormat;
     /** Raw audio matching `format` (e.g. pcm_s16le bytes). */
@@ -15,3 +16,5 @@ export type BufferMeetingSourceOptions = {
  * the reference implementation of `MeetingSource` for adapter authors.
  */
 export declare const createBufferMeetingSource: (options: BufferMeetingSourceOptions) => MeetingSource;
+/** Build a fresh buffer source for every managed meeting session. */
+export declare const createBufferMeetingSourceFactory: (options: BufferMeetingSourceOptions) => MeetingSourceFactory;

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

@@ -1,5 +1,7 @@
 export { createMeeting } from "./meeting";
 export type { MeetingSession, MeetingTurn, MeetingEventMap, CreateMeetingOptions, } from "./meeting";
-export { createBufferMeetingSource } from "./bufferSource";
+export { createMeetingManager } from "./manager";
+export type { ManagedMeeting, MeetingManager, MeetingManagerOptions, MeetingSourceFactory, MeetingSourceFactoryInput, } from "./manager";
+export { createBufferMeetingSource, createBufferMeetingSourceFactory, } from "./bufferSource";
 export type { BufferMeetingSourceOptions } from "./bufferSource";
-export type { MeetingSource, MeetingSourceEventMap, MeetingParticipant, } 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,37 @@ 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) {
+        throw new Error("meeting.speak: this source does not implement speak() \u2014 the bot can't play audio into the call");
+      }
+      await options.source.speak(audio);
+    },
+    stopSpeaking: async () => {
+      await options.source.stopSpeaking?.();
     },
     start: () => options.source.start(),
     stop: async (reason) => {
@@ -71,29 +106,87 @@ var createMeeting = async (options) => {
     }
   };
 };
+// src/manager.ts
+var createMeetingManager = (options) => {
+  const active = new Map;
+  const pending = new Map;
+  const start = async (input) => {
+    const existing = active.get(input.sessionId);
+    if (existing !== undefined) {
+      if (existing.target !== input.target) {
+        throw new Error(`meeting session ${input.sessionId} is already bound to a different target`);
+      }
+      return existing.meeting;
+    }
+    const inFlight = pending.get(input.sessionId);
+    if (inFlight !== undefined) {
+      if (inFlight.target !== input.target) {
+        throw new Error(`meeting session ${input.sessionId} is already being created for a different target`);
+      }
+      return inFlight.promise;
+    }
+    const create = (async () => {
+      const source = await options.source(input);
+      const meeting = await createMeeting({
+        ...options.languageStrategy !== undefined ? { languageStrategy: options.languageStrategy } : {},
+        ...options.lexicon !== undefined ? { lexicon: options.lexicon } : {},
+        ...options.phraseHints !== undefined ? { phraseHints: options.phraseHints } : {},
+        sessionId: input.sessionId,
+        source,
+        stt: options.stt
+      });
+      active.set(input.sessionId, {
+        meeting,
+        sessionId: input.sessionId,
+        target: input.target
+      });
+      meeting.on("end", () => {
+        active.delete(input.sessionId);
+      });
+      try {
+        await meeting.start();
+      } catch (error) {
+        active.delete(input.sessionId);
+        throw error;
+      }
+      return meeting;
+    })();
+    pending.set(input.sessionId, { promise: create, target: input.target });
+    try {
+      return await create;
+    } finally {
+      pending.delete(input.sessionId);
+    }
+  };
+  return {
+    get: (sessionId) => active.get(sessionId)?.meeting,
+    list: () => [...active.values()],
+    start,
+    stop: async (sessionId, reason) => {
+      const managed = active.get(sessionId);
+      if (managed === undefined)
+        return false;
+      await managed.meeting.stop(reason);
+      active.delete(sessionId);
+      return true;
+    }
+  };
+};
 // src/bufferSource.ts
 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 });
@@ -114,7 +207,10 @@ var createBufferMeetingSource = (options) => {
     }
   };
 };
+var createBufferMeetingSourceFactory = (options) => () => createBufferMeetingSource(options);
 export {
+  createMeetingManager,
   createMeeting,
+  createBufferMeetingSourceFactory,
   createBufferMeetingSource
 };

package/dist/manager.d.ts

@@ -0,0 +1,36 @@
+import type { CreateMeetingOptions, MeetingSession } from "./meeting";
+import type { MeetingSource } from "./source";
+export type MeetingSourceFactoryInput = {
+    /** Stable host-owned identity used for tracing, idempotency, and storage. */
+    sessionId: string;
+    /**
+     * Adapter-defined call target. Recall uses a Meet/Zoom/Teams URL; Discord
+     * uses a voice-channel id. The core deliberately does not interpret it.
+     */
+    target: string;
+};
+export type MeetingSourceFactory = (input: MeetingSourceFactoryInput) => MeetingSource | Promise<MeetingSource>;
+export type MeetingManagerOptions = Omit<CreateMeetingOptions, "sessionId" | "source"> & {
+    source: MeetingSourceFactory;
+};
+export type ManagedMeeting = {
+    meeting: MeetingSession;
+    sessionId: string;
+    target: string;
+};
+export type MeetingManager = {
+    /**
+     * Create and join one meeting. Session ids are unique while active; callers
+     * retrying the same id receive the existing session without joining twice.
+     */
+    start(input: MeetingSourceFactoryInput): Promise<MeetingSession>;
+    get(sessionId: string): MeetingSession | undefined;
+    list(): ManagedMeeting[];
+    stop(sessionId: string, reason?: string): Promise<boolean>;
+};
+/**
+ * Multi-session host boundary for dynamic meeting targets. It keeps provider
+ * configuration in the source factory and accepts only the per-call target
+ * and stable session identity at execution time.
+ */
+export declare const createMeetingManager: (options: MeetingManagerOptions) => MeetingManager;

package/dist/manifest.d.ts

@@ -0,0 +1,28 @@
+import type { MeetingManager, MeetingManagerOptions } from "./manager";
+export declare const manifest: Omit<import("@absolutejs/manifest").PackageManifest<MeetingManagerOptions, MeetingManager>, "contract" | "settings" | "tools"> & (({
+    contract: 1;
+    tools?: Record<string, import("@absolutejs/manifest").LegacyManifestTool<MeetingManager>> | undefined;
+} | {
+    contract: 2;
+    tools?: Record<string, import("@absolutejs/manifest").AuthorizedManifestTool<MeetingManager>> | undefined;
+}) & {
+    settings: import("@sinclair/typebox").TObject<{
+        languageStrategy: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+            allowedLanguages: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            mode: import("@sinclair/typebox").TLiteral<"auto-detect">;
+        }>, import("@sinclair/typebox").TObject<{
+            mode: import("@sinclair/typebox").TLiteral<"fixed">;
+            primaryLanguage: import("@sinclair/typebox").TString;
+            secondaryLanguages: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        }>, import("@sinclair/typebox").TObject<{
+            mode: import("@sinclair/typebox").TLiteral<"allow-switching">;
+            primaryLanguage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            secondaryLanguages: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        }>]>>;
+        phraseHints: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            aliases: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            boost: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            text: import("@sinclair/typebox").TString;
+        }>>>;
+    }>;
+});