fireflies-api 0.5.0

package/dist/index.cjs

@@ -0,0 +1,3389 @@
+'use strict';
+
+var socket_ioClient = require('socket.io-client');
+var crypto = require('crypto');
+
+// src/errors.ts
+var FirefliesError = class extends Error {
+  code = "FIREFLIES_ERROR";
+  status;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "FirefliesError";
+    this.status = options?.status;
+  }
+};
+var AuthenticationError = class extends FirefliesError {
+  code = "AUTHENTICATION_ERROR";
+  constructor(message = "Invalid or missing API key") {
+    super(message, { status: 401 });
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends FirefliesError {
+  code = "RATE_LIMIT_ERROR";
+  /** Suggested wait time in milliseconds before retrying. */
+  retryAfter;
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, { status: 429 });
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NotFoundError = class extends FirefliesError {
+  code = "NOT_FOUND";
+  constructor(message = "Resource not found") {
+    super(message, { status: 404 });
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends FirefliesError {
+  code = "VALIDATION_ERROR";
+  constructor(message) {
+    super(message, { status: 400 });
+    this.name = "ValidationError";
+  }
+};
+var GraphQLError = class extends FirefliesError {
+  code = "GRAPHQL_ERROR";
+  errors;
+  constructor(message, errors) {
+    super(message);
+    this.name = "GraphQLError";
+    this.errors = errors;
+  }
+};
+var TimeoutError = class extends FirefliesError {
+  code = "TIMEOUT_ERROR";
+  constructor(message = "Request timed out") {
+    super(message, { status: 408 });
+    this.name = "TimeoutError";
+  }
+};
+var NetworkError = class extends FirefliesError {
+  code = "NETWORK_ERROR";
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "NetworkError";
+  }
+};
+var RealtimeError = class extends FirefliesError {
+  code = "REALTIME_ERROR";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RealtimeError";
+  }
+};
+var ConnectionError = class extends RealtimeError {
+  code = "CONNECTION_ERROR";
+  constructor(message = "Failed to establish realtime connection", options) {
+    super(message, options);
+    this.name = "ConnectionError";
+  }
+};
+var StreamClosedError = class extends RealtimeError {
+  code = "STREAM_CLOSED";
+  constructor(message = "Stream has been closed") {
+    super(message);
+    this.name = "StreamClosedError";
+  }
+};
+var WebhookVerificationError = class extends FirefliesError {
+  code = "WEBHOOK_VERIFICATION_FAILED";
+  constructor(message) {
+    super(message, { status: 401 });
+    this.name = "WebhookVerificationError";
+  }
+};
+var WebhookParseError = class extends FirefliesError {
+  code = "WEBHOOK_PARSE_FAILED";
+  constructor(message) {
+    super(message, { status: 400 });
+    this.name = "WebhookParseError";
+  }
+};
+var ChunkTimeoutError = class extends RealtimeError {
+  code = "CHUNK_TIMEOUT";
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`No chunks received for ${timeoutMs}ms`);
+    this.name = "ChunkTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+function parseErrorResponse(status, body, defaultMessage) {
+  const message = extractErrorMessage(body) ?? defaultMessage;
+  switch (status) {
+    case 401:
+      return new AuthenticationError(message);
+    case 404:
+      return new NotFoundError(message);
+    case 429: {
+      const retryAfter = extractRetryAfter(body);
+      return new RateLimitError(message, retryAfter);
+    }
+    case 400:
+      return new ValidationError(message);
+    default:
+      return new FirefliesError(message, { status });
+  }
+}
+function extractErrorMessage(body) {
+  if (typeof body === "object" && body !== null) {
+    const obj = body;
+    if (typeof obj.message === "string") {
+      return obj.message;
+    }
+    if (typeof obj.error === "string") {
+      return obj.error;
+    }
+  }
+  return void 0;
+}
+function extractRetryAfter(body) {
+  if (typeof body === "object" && body !== null) {
+    const obj = body;
+    if (typeof obj.retryAfter === "number") {
+      return obj.retryAfter;
+    }
+  }
+  return void 0;
+}
+
+// src/utils/rate-limit-tracker.ts
+var RATE_LIMIT_REMAINING_HEADER = "x-ratelimit-remaining-api";
+var RATE_LIMIT_LIMIT_HEADER = "x-ratelimit-limit-api";
+var RATE_LIMIT_RESET_HEADER = "x-ratelimit-reset-api";
+var RateLimitTracker = class {
+  _remaining;
+  _limit;
+  _resetInSeconds;
+  _updatedAt;
+  warningThreshold;
+  /**
+   * Create a new RateLimitTracker.
+   * @param warningThreshold - Threshold below which isLow returns true
+   */
+  constructor(warningThreshold = 10) {
+    this._remaining = void 0;
+    this._limit = void 0;
+    this._resetInSeconds = void 0;
+    this._updatedAt = 0;
+    this.warningThreshold = warningThreshold;
+  }
+  /**
+   * Get the current rate limit state.
+   */
+  get state() {
+    return {
+      remaining: this._remaining,
+      limit: this._limit,
+      resetInSeconds: this._resetInSeconds,
+      updatedAt: this._updatedAt
+    };
+  }
+  /**
+   * Check if remaining requests are below the warning threshold.
+   * Returns false if remaining is undefined (header not received).
+   */
+  get isLow() {
+    return this._remaining !== void 0 && this._remaining < this.warningThreshold;
+  }
+  /**
+   * Update state from response headers.
+   * Extracts x-ratelimit-remaining-api, x-ratelimit-limit-api, and x-ratelimit-reset-api headers.
+   *
+   * @param headers - Response headers (Headers object or plain object)
+   */
+  update(headers) {
+    const remaining = this.getHeader(headers, RATE_LIMIT_REMAINING_HEADER);
+    if (remaining !== null) {
+      const parsed = Number.parseInt(remaining, 10);
+      if (!Number.isNaN(parsed) && parsed >= 0) {
+        this._remaining = parsed;
+      }
+    }
+    const limit = this.getHeader(headers, RATE_LIMIT_LIMIT_HEADER);
+    if (limit !== null) {
+      const parsed = Number.parseInt(limit, 10);
+      if (!Number.isNaN(parsed) && parsed >= 0) {
+        this._limit = parsed;
+      }
+    }
+    const reset = this.getHeader(headers, RATE_LIMIT_RESET_HEADER);
+    if (reset !== null) {
+      const parsed = Number.parseInt(reset, 10);
+      if (!Number.isNaN(parsed) && parsed >= 0) {
+        this._resetInSeconds = parsed;
+      }
+    }
+    this._updatedAt = Date.now();
+  }
+  /**
+   * Reset the tracker to initial state.
+   */
+  reset() {
+    this._remaining = void 0;
+    this._limit = void 0;
+    this._resetInSeconds = void 0;
+    this._updatedAt = 0;
+  }
+  /**
+   * Calculate the delay to apply before the next request.
+   * Returns 0 if throttling is disabled or not needed.
+   *
+   * Uses linear interpolation: more delay as remaining approaches 0.
+   * - remaining >= startThreshold: no delay
+   * - remaining = 0: maxDelay
+   * - remaining in between: proportional delay
+   *
+   * @param config - Throttle configuration
+   * @returns Delay in milliseconds
+   */
+  getThrottleDelay(config) {
+    if (!config?.enabled) {
+      return 0;
+    }
+    if (this._remaining === void 0) {
+      return 0;
+    }
+    const startThreshold = Math.max(1, config.startThreshold ?? 20);
+    let minDelay = config.minDelay ?? 100;
+    let maxDelay = config.maxDelay ?? 2e3;
+    if (minDelay > maxDelay) {
+      [minDelay, maxDelay] = [maxDelay, minDelay];
+    }
+    if (this._remaining >= startThreshold) {
+      return 0;
+    }
+    if (this._remaining <= 0) {
+      return maxDelay;
+    }
+    const ratio = 1 - this._remaining / startThreshold;
+    return Math.round(minDelay + ratio * (maxDelay - minDelay));
+  }
+  /**
+   * Extract a header value from Headers object or plain object.
+   * For plain objects, performs case-insensitive key lookup.
+   */
+  getHeader(headers, name) {
+    if (headers instanceof Headers) {
+      return headers.get(name);
+    }
+    const lowerName = name.toLowerCase();
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === lowerName) {
+        return headers[key] ?? null;
+      }
+    }
+    return null;
+  }
+};
+
+// src/utils/retry.ts
+var DEFAULT_OPTIONS = {
+  maxRetries: 3,
+  baseDelay: 1e3,
+  maxDelay: 3e4
+};
+async function retry(fn, options) {
+  const maxRetries = options?.maxRetries ?? DEFAULT_OPTIONS.maxRetries;
+  const baseDelay = options?.baseDelay ?? DEFAULT_OPTIONS.baseDelay;
+  const maxDelay = options?.maxDelay ?? DEFAULT_OPTIONS.maxDelay;
+  const shouldRetry = options?.shouldRetry ?? isRetryableError;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries || !shouldRetry(error, attempt)) {
+        throw error;
+      }
+      const delay4 = calculateDelay(error, attempt, baseDelay, maxDelay);
+      await sleep(delay4);
+    }
+  }
+  throw lastError;
+}
+function isRetryableError(error) {
+  if (error instanceof RateLimitError) {
+    return true;
+  }
+  if (error instanceof TimeoutError) {
+    return true;
+  }
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  if (error instanceof Error && "status" in error && typeof error.status === "number") {
+    return error.status >= 500 && error.status < 600;
+  }
+  return false;
+}
+function calculateDelay(error, attempt, baseDelay, maxDelay) {
+  if (error instanceof RateLimitError && error.retryAfter !== void 0) {
+    return Math.min(error.retryAfter, maxDelay);
+  }
+  const exponentialDelay = baseDelay * 2 ** attempt;
+  const jitter = Math.random() * 0.1 * exponentialDelay;
+  return Math.min(exponentialDelay + jitter, maxDelay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/graphql/client.ts
+var DEFAULT_BASE_URL = "https://api.fireflies.ai/graphql";
+var DEFAULT_TIMEOUT = 3e4;
+var GraphQLClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  retryOptions;
+  rateLimitTracker;
+  rateLimitConfig;
+  lastWarningRemaining;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new FirefliesError("API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.retryOptions = buildRetryOptions(config.retry);
+    if (config.rateLimit) {
+      const warningThreshold = config.rateLimit.warningThreshold ?? 10;
+      this.rateLimitTracker = new RateLimitTracker(warningThreshold);
+      this.rateLimitConfig = config.rateLimit;
+    } else {
+      this.rateLimitTracker = null;
+      this.rateLimitConfig = null;
+    }
+  }
+  /**
+   * Get the current rate limit state.
+   * Returns undefined if rate limit tracking is not configured.
+   */
+  get rateLimitState() {
+    return this.rateLimitTracker?.state;
+  }
+  /**
+   * Execute a GraphQL query or mutation.
+   *
+   * @param query - GraphQL query string
+   * @param variables - Optional query variables
+   * @returns The data from the GraphQL response
+   * @throws GraphQLError if the response contains errors
+   * @throws AuthenticationError if the API key is invalid
+   * @throws RateLimitError if rate limits are exceeded
+   */
+  async execute(query, variables) {
+    return retry(() => this.executeOnce(query, variables), this.retryOptions);
+  }
+  async executeOnce(query, variables) {
+    await this.applyThrottleDelay();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(this.baseUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ query, variables }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      this.updateRateLimitState(response.headers);
+      if (!response.ok) {
+        const body = await this.safeParseJson(response);
+        if (response.status === 429) {
+          const retryAfter = this.parseRetryAfter(response.headers);
+          this.invokeRateLimitedCallback(retryAfter);
+          throw parseErrorResponse(
+            response.status,
+            body,
+            `GraphQL request failed with status ${response.status}`
+          );
+        }
+        throw parseErrorResponse(
+          response.status,
+          body,
+          `GraphQL request failed with status ${response.status}`
+        );
+      }
+      const json = await response.json();
+      if (json.errors && json.errors.length > 0) {
+        throw this.parseGraphQLErrors(json.errors);
+      }
+      if (json.data === void 0) {
+        throw new FirefliesError("GraphQL response missing data field");
+      }
+      return json.data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof FirefliesError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new TimeoutError(`Request timed out after ${this.timeout}ms`);
+        }
+        throw new NetworkError(`Network request failed: ${error.message}`, error);
+      }
+      throw new NetworkError("Unknown network error occurred", error);
+    }
+  }
+  async safeParseJson(response) {
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Apply throttle delay before request if configured.
+   */
+  async applyThrottleDelay() {
+    if (!this.rateLimitTracker || !this.rateLimitConfig?.throttle) {
+      return;
+    }
+    const delay4 = this.rateLimitTracker.getThrottleDelay(this.rateLimitConfig.throttle);
+    if (delay4 > 0) {
+      await sleep2(delay4);
+    }
+  }
+  /**
+   * Update rate limit state from response headers and invoke callbacks.
+   */
+  updateRateLimitState(headers) {
+    if (!this.rateLimitTracker || !this.rateLimitConfig) {
+      return;
+    }
+    const wasLow = this.rateLimitTracker.isLow;
+    this.rateLimitTracker.update(headers);
+    const state = this.rateLimitTracker.state;
+    this.safeCallback(() => this.rateLimitConfig?.onUpdate?.(state));
+    if (this.rateLimitTracker.isLow) {
+      const shouldWarn = !wasLow || // Just crossed threshold
+      state.remaining !== void 0 && this.lastWarningRemaining !== void 0 && state.remaining < this.lastWarningRemaining;
+      if (shouldWarn) {
+        this.lastWarningRemaining = state.remaining;
+        this.safeCallback(() => this.rateLimitConfig?.onWarning?.(state));
+      }
+    }
+  }
+  /**
+   * Parse Retry-After header value.
+   */
+  parseRetryAfter(headers) {
+    const value = headers.get("retry-after");
+    if (!value) return void 0;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? void 0 : parsed;
+  }
+  /**
+   * Invoke the onRateLimited callback.
+   */
+  invokeRateLimitedCallback(retryAfter) {
+    if (!this.rateLimitTracker || !this.rateLimitConfig?.onRateLimited) {
+      return;
+    }
+    const state = this.rateLimitTracker.state;
+    this.safeCallback(() => this.rateLimitConfig?.onRateLimited?.(state, retryAfter));
+  }
+  /**
+   * Safely invoke a callback, catching any errors to prevent user code from breaking the SDK.
+   */
+  safeCallback(fn) {
+    try {
+      fn();
+    } catch {
+    }
+  }
+  parseGraphQLErrors(errors) {
+    const firstError = errors[0];
+    if (!firstError) {
+      return new GraphQLError("Unknown GraphQL error", errors);
+    }
+    const message = firstError.message;
+    if (message.toLowerCase().includes("unauthorized") || message.toLowerCase().includes("authentication")) {
+      return parseErrorResponse(401, { message }, message);
+    }
+    if (message.toLowerCase().includes("not found")) {
+      return parseErrorResponse(404, { message }, message);
+    }
+    return new GraphQLError(message, errors);
+  }
+};
+function buildRetryOptions(config) {
+  if (!config) {
+    return {};
+  }
+  return {
+    maxRetries: config.maxRetries,
+    baseDelay: config.baseDelay,
+    maxDelay: config.maxDelay
+  };
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/graphql/mutations/audio.ts
+function createAudioAPI(client) {
+  return {
+    async upload(params) {
+      const mutation = `
+        mutation UploadAudio($input: AudioUploadInput!) {
+          uploadAudio(input: $input) {
+            success
+            title
+            message
+          }
+        }
+      `;
+      const data = await client.execute(mutation, {
+        input: params
+      });
+      return data.uploadAudio;
+    }
+  };
+}
+
+// src/graphql/mutations/transcripts.ts
+function createTranscriptsMutationsAPI(client) {
+  return {
+    async delete(id) {
+      const mutation = `
+        mutation deleteTranscript($id: String!) {
+          deleteTranscript(id: $id) {
+            id
+            title
+            organizer_email
+            date
+            duration
+          }
+        }
+      `;
+      const data = await client.execute(mutation, { id });
+      return data.deleteTranscript;
+    }
+  };
+}
+
+// src/graphql/mutations/users.ts
+function createUsersMutationsAPI(client) {
+  return {
+    async setRole(userId, role) {
+      const mutation = `
+        mutation setUserRole($userId: String!, $role: Role!) {
+          setUserRole(user_id: $userId, role: $role) {
+            id
+            name
+            email
+            role
+          }
+        }
+      `;
+      const data = await client.execute(mutation, {
+        userId,
+        role
+      });
+      return data.setUserRole;
+    }
+  };
+}
+
+// src/helpers/pagination.ts
+async function* paginate(fetcher, pageSize = 50) {
+  let skip = 0;
+  let hasMore = true;
+  while (hasMore) {
+    const page = await fetcher(skip, pageSize);
+    for (const item of page) {
+      yield item;
+    }
+    if (page.length < pageSize) {
+      hasMore = false;
+    } else {
+      skip += pageSize;
+    }
+  }
+}
+async function collectAll(iterable) {
+  const items = [];
+  for await (const item of iterable) {
+    items.push(item);
+  }
+  return items;
+}
+
+// src/graphql/queries/ai-apps.ts
+var AI_APP_OUTPUT_FIELDS = `
+  transcript_id
+  user_id
+  app_id
+  created_at
+  title
+  prompt
+  response
+`;
+function createAIAppsAPI(client) {
+  return {
+    async list(params) {
+      const query = `
+        query GetAIAppsOutputs(
+          $appId: String
+          $transcriptId: String
+          $skip: Float
+          $limit: Float
+        ) {
+          apps(
+            app_id: $appId
+            transcript_id: $transcriptId
+            skip: $skip
+            limit: $limit
+          ) {
+            outputs { ${AI_APP_OUTPUT_FIELDS} }
+          }
+        }
+      `;
+      const data = await client.execute(query, {
+        appId: params?.app_id,
+        transcriptId: params?.transcript_id,
+        skip: params?.skip,
+        limit: params?.limit ?? 10
+      });
+      return data.apps.outputs;
+    },
+    listAll(params) {
+      return paginate((skip, limit) => this.list({ ...params, skip, limit }), 10);
+    }
+  };
+}
+
+// src/graphql/queries/bites.ts
+var BITE_FIELDS = `
+  id
+  transcript_id
+  user_id
+  name
+  status
+  summary
+  summary_status
+  media_type
+  start_time
+  end_time
+  created_at
+  thumbnail
+  preview
+  captions {
+    index
+    text
+    start_time
+    end_time
+    speaker_id
+    speaker_name
+  }
+  sources {
+    src
+    type
+  }
+  user {
+    id
+    name
+    first_name
+    last_name
+    picture
+  }
+  created_from {
+    id
+    name
+    type
+    description
+    duration
+  }
+  privacies
+`;
+function createBitesAPI(client) {
+  return {
+    async get(id) {
+      const query = `
+        query Bite($biteId: ID!) {
+          bite(id: $biteId) { ${BITE_FIELDS} }
+        }
+      `;
+      const data = await client.execute(query, { biteId: id });
+      return data.bite;
+    },
+    async list(params) {
+      const query = `
+        query Bites(
+          $transcriptId: ID
+          $mine: Boolean
+          $myTeam: Boolean
+          $limit: Int
+          $skip: Int
+        ) {
+          bites(
+            transcript_id: $transcriptId
+            mine: $mine
+            my_team: $myTeam
+            limit: $limit
+            skip: $skip
+          ) { ${BITE_FIELDS} }
+        }
+      `;
+      const data = await client.execute(query, {
+        transcriptId: params.transcript_id,
+        mine: params.mine,
+        myTeam: params.my_team,
+        limit: params.limit ?? 50,
+        skip: params.skip
+      });
+      return data.bites;
+    },
+    listAll(params) {
+      return paginate((skip, limit) => this.list({ ...params, skip, limit }), 50);
+    },
+    async create(params) {
+      const mutation = `
+        mutation CreateBite(
+          $transcriptId: ID!
+          $startTime: Float!
+          $endTime: Float!
+          $name: String
+          $mediaType: String
+          $summary: String
+          $privacies: [BitePrivacy!]
+        ) {
+          createBite(
+            transcript_Id: $transcriptId
+            start_time: $startTime
+            end_time: $endTime
+            name: $name
+            media_type: $mediaType
+            summary: $summary
+            privacies: $privacies
+          ) {
+            id
+            name
+            status
+            summary
+          }
+        }
+      `;
+      const data = await client.execute(mutation, {
+        transcriptId: params.transcript_id,
+        startTime: params.start_time,
+        endTime: params.end_time,
+        name: params.name,
+        mediaType: params.media_type,
+        summary: params.summary,
+        privacies: params.privacies
+      });
+      return data.createBite;
+    }
+  };
+}
+
+// src/graphql/queries/meetings.ts
+var ACTIVE_MEETING_FIELDS = `
+  id
+  title
+  organizer_email
+  meeting_link
+  start_time
+  end_time
+  privacy
+  state
+`;
+function createMeetingsAPI(client) {
+  return {
+    async active(params) {
+      const query = `
+        query ActiveMeetings($email: String, $states: [MeetingState!]) {
+          active_meetings(input: { email: $email, states: $states }) {
+            ${ACTIVE_MEETING_FIELDS}
+          }
+        }
+      `;
+      const data = await client.execute(query, {
+        email: params?.email,
+        states: params?.states
+      });
+      return data.active_meetings;
+    },
+    async addBot(params) {
+      const mutation = `
+        mutation AddToLiveMeeting(
+          $meetingLink: String!
+          $title: String
+          $meetingPassword: String
+          $duration: Int
+          $language: String
+        ) {
+          addToLiveMeeting(
+            meeting_link: $meetingLink
+            title: $title
+            meeting_password: $meetingPassword
+            duration: $duration
+            language: $language
+          ) {
+            success
+          }
+        }
+      `;
+      const data = await client.execute(mutation, {
+        meetingLink: params.meeting_link,
+        title: params.title,
+        meetingPassword: params.password,
+        duration: params.duration,
+        language: params.language
+      });
+      return data.addToLiveMeeting;
+    }
+  };
+}
+
+// src/helpers/action-items.ts
+var ASSIGNEE_PATTERNS = [
+  { pattern: /@(\w+)/i, group: 1 },
+  // @Alice
+  { pattern: /^(\w+):/i, group: 1 },
+  // Alice: at start
+  { pattern: /assigned to (\w+)/i, group: 1 },
+  // assigned to Alice
+  { pattern: /(\w+) will\b/i, group: 1 },
+  // Alice will
+  { pattern: /(\w+) to\b/i, group: 1 },
+  // Alice to (do something)
+  { pattern: /\s-\s*(\w+)$/i, group: 1 }
+  // ... - Alice
+];
+var DUE_DATE_PATTERNS = [
+  { pattern: /by (monday|tuesday|wednesday|thursday|friday|saturday|sunday)/i, group: 1 },
+  { pattern: /by (tomorrow|today)/i, group: 1 },
+  { pattern: /by (EOD|end of day)/i, group: 1 },
+  { pattern: /by (EOW|end of week)/i, group: 1 },
+  { pattern: /due (\d{4}-\d{2}-\d{2})/i, group: 1 },
+  { pattern: /due (jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+\d+/i, group: 0 },
+  { pattern: /by (\d{1,2}\/\d{1,2})/i, group: 1 }
+];
+var LIST_PREFIX_PATTERN = /^(?:[-•*]|\d+\.)\s*/;
+var SECTION_HEADER_PATTERN = /^\*\*(.+)\*\*$/;
+function extractActionItems(transcript, options = {}) {
+  const actionItemsText = transcript.summary?.action_items;
+  if (!actionItemsText || actionItemsText.trim().length === 0) {
+    return emptyResult();
+  }
+  const config = {
+    detectAssignees: options.detectAssignees ?? true,
+    detectDueDates: options.detectDueDates ?? true,
+    includeSourceSentences: options.includeSourceSentences ?? false,
+    participantNames: options.participantNames ?? []
+  };
+  const taskSentences = config.includeSourceSentences ? buildTaskSentenceLookup(transcript) : [];
+  const lines = actionItemsText.split(/\n/);
+  return parseAllLines(lines, config, taskSentences);
+}
+function parseAllLines(lines, config, taskSentences) {
+  const items = [];
+  const assigneeSet = /* @__PURE__ */ new Set();
+  let currentSectionAssignee;
+  for (let i = 0; i < lines.length; i++) {
+    const result = processLine(lines[i], i + 1, config, taskSentences, currentSectionAssignee);
+    if (result.type === "header") {
+      currentSectionAssignee = result.assignee;
+    } else if (result.type === "item" && result.item) {
+      items.push(result.item);
+      if (result.item.assignee) {
+        assigneeSet.add(result.item.assignee);
+      }
+    }
+  }
+  return buildResult(items, assigneeSet);
+}
+function processLine(line, lineNumber, config, taskSentences, sectionAssignee) {
+  if (!line) return { type: "skip" };
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return { type: "skip" };
+  const headerMatch = trimmed.match(SECTION_HEADER_PATTERN);
+  if (headerMatch?.[1]) {
+    const headerName = headerMatch[1];
+    const assignee = headerName.toLowerCase() === "unassigned" ? void 0 : headerName;
+    return { type: "header", assignee };
+  }
+  const item = parseLine(line, lineNumber, config, taskSentences, sectionAssignee);
+  if (item) {
+    return { type: "item", item };
+  }
+  return { type: "skip" };
+}
+function parseLine(line, lineNumber, config, taskSentences, sectionAssignee) {
+  if (!line) return null;
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return null;
+  const text = trimmed.replace(LIST_PREFIX_PATTERN, "");
+  if (text.length === 0) return null;
+  const inlineAssignee = config.detectAssignees ? detectAssignee(text, config.participantNames) : void 0;
+  const assignee = inlineAssignee ?? sectionAssignee;
+  const dueDate = config.detectDueDates ? detectDueDate(text) : void 0;
+  const sourceSentence = config.includeSourceSentences ? findSourceSentence(text, taskSentences) : void 0;
+  return { text, assignee, dueDate, lineNumber, sourceSentence };
+}
+function buildResult(items, assigneeSet) {
+  return {
+    items,
+    totalItems: items.length,
+    assignedItems: items.filter((i) => i.assignee !== void 0).length,
+    datedItems: items.filter((i) => i.dueDate !== void 0).length,
+    assignees: Array.from(assigneeSet)
+  };
+}
+function emptyResult() {
+  return {
+    items: [],
+    totalItems: 0,
+    assignedItems: 0,
+    datedItems: 0,
+    assignees: []
+  };
+}
+function detectAssignee(text, participantNames) {
+  const participantSet = new Set(participantNames.map((n) => n.toLowerCase()));
+  const filterByParticipants = participantSet.size > 0;
+  for (const { pattern, group } of ASSIGNEE_PATTERNS) {
+    const match = text.match(pattern);
+    if (match?.[group]) {
+      const name = match[group];
+      if (filterByParticipants) {
+        if (participantSet.has(name.toLowerCase())) {
+          return name;
+        }
+        continue;
+      }
+      return name;
+    }
+  }
+  return void 0;
+}
+function detectDueDate(text) {
+  for (const { pattern, group } of DUE_DATE_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      if (group === 0 && match[0]) {
+        const fullMatch = match[0];
+        const dateMatch = fullMatch.match(
+          /(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+\d+/i
+        );
+        if (dateMatch?.[0]) {
+          return dateMatch[0];
+        }
+      }
+      if (match[group]) {
+        return match[group];
+      }
+    }
+  }
+  return void 0;
+}
+function buildTaskSentenceLookup(transcript) {
+  const sentences = transcript.sentences ?? [];
+  const result = [];
+  for (const sentence of sentences) {
+    const task = sentence.ai_filters?.task;
+    if (task) {
+      result.push({
+        text: sentence.text,
+        task: task.toLowerCase(),
+        speakerName: sentence.speaker_name,
+        startTime: Number.parseFloat(sentence.start_time)
+      });
+    }
+  }
+  return result;
+}
+function findSourceSentence(actionItemText, taskSentences) {
+  const normalizedItem = actionItemText.toLowerCase();
+  for (const sentence of taskSentences) {
+    if (normalizedItem.includes(sentence.task) || sentence.task.includes(normalizedItem)) {
+      return {
+        speakerName: sentence.speakerName,
+        text: sentence.text,
+        startTime: sentence.startTime
+      };
+    }
+    const itemWords = new Set(normalizedItem.split(/\s+/).filter((w) => w.length > 3));
+    const taskWords = sentence.task.split(/\s+/).filter((w) => w.length > 3);
+    const matchingWords = taskWords.filter((w) => itemWords.has(w));
+    if (taskWords.length > 0 && matchingWords.length / taskWords.length >= 0.5) {
+      return {
+        speakerName: sentence.speakerName,
+        text: sentence.text,
+        startTime: sentence.startTime
+      };
+    }
+  }
+  return void 0;
+}
+
+// src/helpers/action-items-format.ts
+function filterActionItems(items, options) {
+  const { assignees, assignedOnly, datedOnly } = options;
+  const normalizedAssignees = assignees?.map((a) => a.toLowerCase());
+  return items.filter((item) => {
+    if (normalizedAssignees && normalizedAssignees.length > 0) {
+      if (!item.assignee) return false;
+      if (!normalizedAssignees.includes(item.assignee.toLowerCase())) return false;
+    }
+    if (assignedOnly && !item.assignee) {
+      return false;
+    }
+    if (datedOnly && !item.dueDate) {
+      return false;
+    }
+    return true;
+  });
+}
+function aggregateActionItems(transcripts, extractionOptions, filterOptions) {
+  if (transcripts.length === 0) {
+    return emptyAggregatedResult();
+  }
+  const allItems = [];
+  let transcriptsWithItems = 0;
+  for (const transcript of transcripts) {
+    const extracted = extractActionItems(transcript, extractionOptions);
+    if (extracted.items.length > 0) {
+      transcriptsWithItems++;
+      for (const item of extracted.items) {
+        allItems.push({
+          ...item,
+          transcriptId: transcript.id,
+          transcriptTitle: transcript.title,
+          transcriptDate: transcript.dateString
+        });
+      }
+    }
+  }
+  const filteredItems = filterOptions ? filterActionItems(allItems, filterOptions) : allItems;
+  return buildAggregatedResult(filteredItems, transcripts.length, transcriptsWithItems);
+}
+function emptyAggregatedResult() {
+  return {
+    items: [],
+    totalItems: 0,
+    transcriptsProcessed: 0,
+    transcriptsWithItems: 0,
+    assignedItems: 0,
+    datedItems: 0,
+    assignees: [],
+    dateRange: { earliest: "", latest: "" }
+  };
+}
+function buildAggregatedResult(items, transcriptsProcessed, transcriptsWithItems) {
+  const assigneeSet = /* @__PURE__ */ new Set();
+  let assignedItems = 0;
+  let datedItems = 0;
+  for (const item of items) {
+    if (item.assignee) {
+      assigneeSet.add(item.assignee);
+      assignedItems++;
+    }
+    if (item.dueDate) {
+      datedItems++;
+    }
+  }
+  const dates = items.map((i) => i.transcriptDate).filter(Boolean).sort();
+  return {
+    items,
+    totalItems: items.length,
+    transcriptsProcessed,
+    transcriptsWithItems,
+    assignedItems,
+    datedItems,
+    assignees: Array.from(assigneeSet),
+    dateRange: {
+      earliest: dates[0] ?? "",
+      latest: dates[dates.length - 1] ?? ""
+    }
+  };
+}
+function isAggregatedResult(result) {
+  return "transcriptsProcessed" in result;
+}
+function isAggregatedItem(item) {
+  return "transcriptId" in item;
+}
+function escapeMarkdown(text) {
+  return text.replace(/\\/g, "\\\\").replace(/\*/g, "\\*").replace(/#/g, "\\#").replace(/\[/g, "\\[").replace(/\]/g, "\\]").replace(/_/g, "\\_").replace(/`/g, "\\`");
+}
+function getPresetOptions(preset) {
+  switch (preset) {
+    case "notion":
+      return {
+        style: "checkbox",
+        includeAssignee: true,
+        includeDueDate: true
+      };
+    case "obsidian":
+      return {
+        style: "checkbox",
+        includeAssignee: false,
+        includeDueDate: true
+      };
+    case "github":
+      return {
+        style: "checkbox",
+        includeAssignee: true,
+        includeDueDate: true
+      };
+    default:
+      return {};
+  }
+}
+function formatItem(item, index, options) {
+  const { style, includeAssignee, includeDueDate, includeMeetingTitle } = options;
+  let prefix;
+  switch (style) {
+    case "bullet":
+      prefix = "-";
+      break;
+    case "numbered":
+      prefix = `${index + 1}.`;
+      break;
+    default:
+      prefix = "- [ ]";
+      break;
+  }
+  let text = escapeMarkdown(item.text);
+  const metadata = [];
+  if (includeAssignee && item.assignee) {
+    metadata.push(`@${item.assignee}`);
+  }
+  if (includeDueDate && item.dueDate) {
+    metadata.push(`due: ${item.dueDate}`);
+  }
+  if (includeMeetingTitle && isAggregatedItem(item)) {
+    metadata.push(`*${item.transcriptTitle}*`);
+  }
+  if (metadata.length > 0) {
+    text += ` (${metadata.join(", ")})`;
+  }
+  return `${prefix} ${text}`;
+}
+function groupBy(items, keyFn) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFn(item);
+    const group = groups.get(key);
+    if (group) {
+      group.push(item);
+    } else {
+      groups.set(key, [item]);
+    }
+  }
+  return groups;
+}
+function formatSummaryLine(result) {
+  return `**Summary:** ${result.totalItems} items from ${result.transcriptsProcessed} meetings (${result.assignedItems} assigned, ${result.datedItems} with due dates)`;
+}
+function sortGroupKeys(keys) {
+  return keys.sort((a, b) => {
+    if (a === "Unassigned") return 1;
+    if (b === "Unassigned") return -1;
+    return a.localeCompare(b);
+  });
+}
+function formatGroupedItems(result, groupByOption, itemOptions) {
+  const lines = [];
+  const keyFn = getGroupKeyFn(groupByOption);
+  const groups = groupBy(result.items, keyFn);
+  const sortedKeys = sortGroupKeys(Array.from(groups.keys()));
+  for (const key of sortedKeys) {
+    const groupItems = groups.get(key);
+    if (!groupItems) continue;
+    lines.push(`### ${key}`);
+    lines.push("");
+    groupItems.forEach((item, index) => {
+      lines.push(formatItem(item, index, itemOptions));
+    });
+    lines.push("");
+  }
+  return lines;
+}
+function formatFlatItems(items, itemOptions) {
+  return items.map((item, index) => formatItem(item, index, itemOptions));
+}
+function formatActionItemsMarkdown(result, options = {}) {
+  if (result.items.length === 0) {
+    return "";
+  }
+  const presetOptions = getPresetOptions(options.preset);
+  const mergedOptions = { ...presetOptions, ...options };
+  const {
+    style = "checkbox",
+    groupBy: groupByOption = "none",
+    includeAssignee = false,
+    includeDueDate = false,
+    includeMeetingTitle = false,
+    includeSummary = false
+  } = mergedOptions;
+  const lines = [];
+  if (includeSummary && isAggregatedResult(result)) {
+    lines.push(formatSummaryLine(result));
+    lines.push("");
+  }
+  const itemOptions = { style, includeAssignee, includeDueDate, includeMeetingTitle };
+  const shouldGroup = groupByOption !== "none" && isAggregatedResult(result);
+  if (shouldGroup) {
+    lines.push(...formatGroupedItems(result, groupByOption, itemOptions));
+  } else {
+    lines.push(...formatFlatItems(result.items, itemOptions));
+  }
+  return lines.join("\n").trim();
+}
+function getGroupKeyFn(groupBy2) {
+  switch (groupBy2) {
+    case "assignee":
+      return (item) => item.assignee ?? "Unassigned";
+    case "transcript":
+      return (item) => item.transcriptTitle;
+    case "date":
+      return (item) => item.transcriptDate;
+  }
+}
+
+// src/helpers/domain-utils.ts
+function extractDomain(email) {
+  const atIndex = email.indexOf("@");
+  if (atIndex < 0) return "";
+  const domain = email.slice(atIndex + 1).toLowerCase();
+  return domain || "";
+}
+function hasExternalParticipants(participants, internalDomain) {
+  const normalizedInternal = internalDomain.toLowerCase();
+  return participants.some((email) => {
+    const domain = extractDomain(email);
+    return domain !== "" && domain !== normalizedInternal;
+  });
+}
+
+// src/helpers/meeting-insights.ts
+function analyzeMeetings(transcripts, options = {}) {
+  const { speakers, groupBy: groupBy2, topSpeakersCount = 10, topParticipantsCount = 10 } = options;
+  if (transcripts.length === 0) {
+    return emptyInsights();
+  }
+  const totalDurationMinutes = sumDurations(transcripts);
+  const averageDurationMinutes = totalDurationMinutes / transcripts.length;
+  const byDayOfWeek = calculateDayOfWeekStats(transcripts);
+  const byTimeGroup = groupBy2 ? calculateTimeGroupStats(transcripts, groupBy2) : void 0;
+  const participantData = aggregateParticipants(transcripts);
+  const totalUniqueParticipants = participantData.uniqueEmails.size;
+  const averageParticipantsPerMeeting = calculateAverageParticipants(transcripts);
+  const topParticipants = buildTopParticipants(participantData.stats, topParticipantsCount);
+  const speakerData = aggregateSpeakers(transcripts, speakers);
+  const totalUniqueSpeakers = speakerData.uniqueNames.size;
+  const topSpeakers = buildTopSpeakers(speakerData.stats, topSpeakersCount);
+  const { earliestMeeting, latestMeeting } = findDateRange(transcripts);
+  return {
+    totalMeetings: transcripts.length,
+    totalDurationMinutes,
+    averageDurationMinutes,
+    byDayOfWeek,
+    byTimeGroup,
+    totalUniqueParticipants,
+    averageParticipantsPerMeeting,
+    topParticipants,
+    totalUniqueSpeakers,
+    topSpeakers,
+    earliestMeeting,
+    latestMeeting
+  };
+}
+function emptyInsights() {
+  return {
+    totalMeetings: 0,
+    totalDurationMinutes: 0,
+    averageDurationMinutes: 0,
+    byDayOfWeek: emptyDayOfWeekStats(),
+    byTimeGroup: void 0,
+    totalUniqueParticipants: 0,
+    averageParticipantsPerMeeting: 0,
+    topParticipants: [],
+    totalUniqueSpeakers: 0,
+    topSpeakers: [],
+    earliestMeeting: "",
+    latestMeeting: ""
+  };
+}
+function emptyDayOfWeekStats() {
+  const emptyDay = () => ({ count: 0, totalMinutes: 0 });
+  return {
+    monday: emptyDay(),
+    tuesday: emptyDay(),
+    wednesday: emptyDay(),
+    thursday: emptyDay(),
+    friday: emptyDay(),
+    saturday: emptyDay(),
+    sunday: emptyDay()
+  };
+}
+function sumDurations(transcripts) {
+  return transcripts.reduce((sum, t) => sum + (t.duration ?? 0), 0);
+}
+function calculateDayOfWeekStats(transcripts) {
+  const stats = emptyDayOfWeekStats();
+  const dayNames = [
+    "sunday",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday"
+  ];
+  for (const t of transcripts) {
+    const date = parseDate(t.dateString);
+    if (!date) continue;
+    const dayIndex = date.getUTCDay();
+    const dayName = dayNames[dayIndex];
+    if (dayName) {
+      stats[dayName].count++;
+      stats[dayName].totalMinutes += t.duration ?? 0;
+    }
+  }
+  return stats;
+}
+function calculateTimeGroupStats(transcripts, groupBy2) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of transcripts) {
+    const date = parseDate(t.dateString);
+    if (!date) continue;
+    const period = formatPeriod(date, groupBy2);
+    const existing = groups.get(period) ?? { count: 0, totalMinutes: 0 };
+    existing.count++;
+    existing.totalMinutes += t.duration ?? 0;
+    groups.set(period, existing);
+  }
+  const result = [];
+  for (const [period, data] of groups) {
+    result.push({
+      period,
+      count: data.count,
+      totalMinutes: data.totalMinutes,
+      averageMinutes: data.totalMinutes / data.count
+    });
+  }
+  result.sort((a, b) => a.period.localeCompare(b.period));
+  return result;
+}
+function formatPeriod(date, groupBy2) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  switch (groupBy2) {
+    case "day":
+      return `${year}-${month}-${day}`;
+    case "week":
+      return getISOWeek(date);
+    case "month":
+      return `${year}-${month}`;
+  }
+}
+function getISOWeek(date) {
+  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const weekNumber = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return `${d.getUTCFullYear()}-W${String(weekNumber).padStart(2, "0")}`;
+}
+function aggregateParticipants(transcripts) {
+  const uniqueEmails = /* @__PURE__ */ new Set();
+  const stats = /* @__PURE__ */ new Map();
+  for (const t of transcripts) {
+    const participants = t.participants ?? [];
+    const seenInMeeting = /* @__PURE__ */ new Set();
+    for (const email of participants) {
+      const normalizedEmail = email.toLowerCase();
+      uniqueEmails.add(normalizedEmail);
+      if (seenInMeeting.has(normalizedEmail)) continue;
+      seenInMeeting.add(normalizedEmail);
+      const existing = stats.get(normalizedEmail) ?? { meetingCount: 0, totalMinutes: 0 };
+      existing.meetingCount++;
+      existing.totalMinutes += t.duration ?? 0;
+      stats.set(normalizedEmail, existing);
+    }
+  }
+  return { uniqueEmails, stats };
+}
+function calculateAverageParticipants(transcripts) {
+  if (transcripts.length === 0) return 0;
+  let totalParticipants = 0;
+  for (const t of transcripts) {
+    const unique = new Set((t.participants ?? []).map((p) => p.toLowerCase()));
+    totalParticipants += unique.size;
+  }
+  return totalParticipants / transcripts.length;
+}
+function buildTopParticipants(stats, limit) {
+  const result = [];
+  for (const [email, data] of stats) {
+    result.push({
+      email,
+      meetingCount: data.meetingCount,
+      totalMinutes: data.totalMinutes
+    });
+  }
+  result.sort((a, b) => b.meetingCount - a.meetingCount);
+  return result.slice(0, limit);
+}
+function aggregateSpeakers(transcripts, filterSpeakers) {
+  const uniqueNames = /* @__PURE__ */ new Set();
+  const stats = /* @__PURE__ */ new Map();
+  const filterSet = filterSpeakers ? new Set(filterSpeakers) : null;
+  for (const t of transcripts) {
+    const sentences = t.sentences ?? [];
+    for (const sentence of sentences) {
+      const speakerName = sentence.speaker_name;
+      if (filterSet && !filterSet.has(speakerName)) continue;
+      uniqueNames.add(speakerName);
+      const existing = stats.get(speakerName) ?? {
+        meetingCount: 0,
+        totalTalkTimeSeconds: 0,
+        meetings: /* @__PURE__ */ new Set()
+      };
+      const duration = parseSentenceDuration(sentence);
+      existing.totalTalkTimeSeconds += duration;
+      if (!existing.meetings.has(t.id)) {
+        existing.meetings.add(t.id);
+        existing.meetingCount++;
+      }
+      stats.set(speakerName, existing);
+    }
+  }
+  return { uniqueNames, stats };
+}
+function parseSentenceDuration(sentence) {
+  const start = Number.parseFloat(sentence.start_time);
+  const end = Number.parseFloat(sentence.end_time);
+  return Math.max(0, end - start);
+}
+function buildTopSpeakers(stats, limit) {
+  const result = [];
+  for (const [name, data] of stats) {
+    result.push({
+      name,
+      meetingCount: data.meetingCount,
+      totalTalkTimeSeconds: data.totalTalkTimeSeconds,
+      averageTalkTimeSeconds: data.meetingCount > 0 ? data.totalTalkTimeSeconds / data.meetingCount : 0
+    });
+  }
+  result.sort((a, b) => b.totalTalkTimeSeconds - a.totalTalkTimeSeconds);
+  return result.slice(0, limit);
+}
+function findDateRange(transcripts) {
+  let earliest = null;
+  let latest = null;
+  for (const t of transcripts) {
+    const date = parseDate(t.dateString);
+    if (!date) continue;
+    if (!earliest || date < earliest) {
+      earliest = date;
+    }
+    if (!latest || date > latest) {
+      latest = date;
+    }
+  }
+  return {
+    earliestMeeting: earliest ? formatDateOnly(earliest) : "",
+    latestMeeting: latest ? formatDateOnly(latest) : ""
+  };
+}
+function parseDate(dateString) {
+  if (!dateString) return null;
+  const date = new Date(dateString);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function formatDateOnly(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+// src/helpers/search.ts
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchesSpeaker(sentence, speakerSet) {
+  if (!speakerSet) return true;
+  return speakerSet.has(sentence.speaker_name.toLowerCase());
+}
+function matchesAIFilters(sentence, filterQuestions, filterTasks) {
+  if (!filterQuestions && !filterTasks) return true;
+  const hasQuestion = Boolean(sentence.ai_filters?.question);
+  const hasTask = Boolean(sentence.ai_filters?.task);
+  if (filterQuestions && filterTasks) {
+    return hasQuestion || hasTask;
+  }
+  if (filterQuestions) return hasQuestion;
+  if (filterTasks) return hasTask;
+  return true;
+}
+function extractContext(sentences, index, contextLines) {
+  const beforeStart = Math.max(0, index - contextLines);
+  const afterEnd = Math.min(sentences.length, index + contextLines + 1);
+  return {
+    before: sentences.slice(beforeStart, index).map((s) => ({
+      speakerName: s.speaker_name,
+      text: s.text
+    })),
+    after: sentences.slice(index + 1, afterEnd).map((s) => ({
+      speakerName: s.speaker_name,
+      text: s.text
+    }))
+  };
+}
+function sentenceToMatch(sentence, transcript, context) {
+  return {
+    transcriptId: transcript.id,
+    transcriptTitle: transcript.title,
+    transcriptDate: transcript.dateString,
+    transcriptUrl: transcript.transcript_url,
+    sentence: {
+      index: sentence.index,
+      text: sentence.text,
+      speakerName: sentence.speaker_name,
+      startTime: Number.parseFloat(sentence.start_time),
+      endTime: Number.parseFloat(sentence.end_time),
+      isQuestion: Boolean(sentence.ai_filters?.question),
+      isTask: Boolean(sentence.ai_filters?.task)
+    },
+    context
+  };
+}
+function searchTranscript(transcript, options) {
+  const {
+    query,
+    caseSensitive = false,
+    speakers,
+    filterQuestions = false,
+    filterTasks = false,
+    contextLines = 1
+  } = options;
+  if (!query || query.trim() === "") {
+    return [];
+  }
+  const sentences = transcript.sentences ?? [];
+  if (sentences.length === 0) {
+    return [];
+  }
+  const escapedQuery = escapeRegex(query);
+  const regex = new RegExp(escapedQuery, caseSensitive ? "" : "i");
+  const speakerSet = speakers ? new Set(speakers.map((s) => s.toLowerCase())) : null;
+  const matches = [];
+  for (let i = 0; i < sentences.length; i++) {
+    const sentence = sentences[i];
+    if (!sentence) continue;
+    if (!regex.test(sentence.text)) continue;
+    if (!matchesSpeaker(sentence, speakerSet)) continue;
+    if (!matchesAIFilters(sentence, filterQuestions, filterTasks)) continue;
+    const context = extractContext(sentences, i, contextLines);
+    matches.push(sentenceToMatch(sentence, transcript, context));
+  }
+  return matches;
+}
+
+// src/graphql/queries/transcripts.ts
+var TRANSCRIPT_BASE_FIELDS = `
+  id
+  title
+  organizer_email
+  host_email
+  user {
+    user_id
+    email
+    name
+  }
+  speakers {
+    id
+    name
+  }
+  transcript_url
+  participants
+  meeting_attendees {
+    displayName
+    email
+    phoneNumber
+    name
+    location
+  }
+  meeting_attendance {
+    name
+    join_time
+    leave_time
+  }
+  fireflies_users
+  workspace_users
+  duration
+  dateString
+  date
+  audio_url
+  video_url
+  calendar_id
+  meeting_info {
+    fred_joined
+    silent_meeting
+    summary_status
+  }
+  cal_id
+  calendar_type
+  apps_preview {
+    outputs {
+      transcript_id
+      user_id
+      app_id
+      created_at
+      title
+      prompt
+      response
+    }
+  }
+  meeting_link
+  analytics {
+    sentiments {
+      negative_pct
+      neutral_pct
+      positive_pct
+    }
+  }
+  channels {
+    id
+    title
+    is_private
+    created_at
+    updated_at
+    created_by
+    members {
+      user_id
+      email
+      name
+    }
+  }
+`;
+var SENTENCES_FIELDS = `
+  sentences {
+    index
+    text
+    raw_text
+    start_time
+    end_time
+    speaker_id
+    speaker_name
+    ai_filters {
+      task
+      pricing
+      metric
+      question
+      date_and_time
+      text_cleanup
+      sentiment
+    }
+  }
+`;
+var SUMMARY_FIELDS = `
+  summary {
+    action_items
+    keywords
+    outline
+    overview
+    shorthand_bullet
+    notes
+    gist
+    bullet_gist
+    short_summary
+    short_overview
+    meeting_type
+    topics_discussed
+    transcript_chapters
+    extended_sections {
+      title
+      content
+    }
+  }
+`;
+function buildTranscriptFields(params) {
+  const includeSentences = params?.includeSentences !== false;
+  const includeSummary = params?.includeSummary !== false;
+  let fields = TRANSCRIPT_BASE_FIELDS;
+  if (includeSentences) {
+    fields += SENTENCES_FIELDS;
+  }
+  if (includeSummary) {
+    fields += SUMMARY_FIELDS;
+  }
+  return fields;
+}
+var TRANSCRIPT_LIST_FIELDS = `
+  id
+  title
+  organizer_email
+  transcript_url
+  participants
+  duration
+  dateString
+  date
+  video_url
+  meeting_info {
+    fred_joined
+    silent_meeting
+    summary_status
+  }
+`;
+function createTranscriptsAPI(client) {
+  return {
+    async get(id, params) {
+      const fields = buildTranscriptFields(params);
+      const query = `
+        query GetTranscript($id: String!) {
+          transcript(id: $id) {
+            ${fields}
+          }
+        }
+      `;
+      const data = await client.execute(query, { id });
+      return normalizeTranscript(data.transcript);
+    },
+    async list(params) {
+      const query = `
+        query ListTranscripts(
+          $keyword: String
+          $scope: String
+          $organizers: [String!]
+          $participants: [String!]
+          $user_id: String
+          $mine: Boolean
+          $channel_id: String
+          $fromDate: DateTime
+          $toDate: DateTime
+          $limit: Int
+          $skip: Int
+          $title: String
+          $host_email: String
+          $organizer_email: String
+          $participant_email: String
+          $date: Float
+        ) {
+          transcripts(
+            keyword: $keyword
+            scope: $scope
+            organizers: $organizers
+            participants: $participants
+            user_id: $user_id
+            mine: $mine
+            channel_id: $channel_id
+            fromDate: $fromDate
+            toDate: $toDate
+            limit: $limit
+            skip: $skip
+            title: $title
+            host_email: $host_email
+            organizer_email: $organizer_email
+            participant_email: $participant_email
+            date: $date
+          ) {
+            ${TRANSCRIPT_LIST_FIELDS}
+          }
+        }
+      `;
+      const variables = buildListVariables(params);
+      const data = await client.execute(query, variables);
+      return data.transcripts.map(normalizeTranscript);
+    },
+    async getSummary(id) {
+      const query = `
+        query GetTranscriptSummary($id: String!) {
+          transcript(id: $id) {
+            summary {
+              action_items
+              keywords
+              outline
+              overview
+              shorthand_bullet
+              notes
+              gist
+              bullet_gist
+              short_summary
+              short_overview
+              meeting_type
+              topics_discussed
+              transcript_chapters
+              extended_sections {
+                title
+                content
+              }
+            }
+          }
+        }
+      `;
+      const data = await client.execute(query, { id });
+      return data.transcript.summary;
+    },
+    listAll(params) {
+      return paginate((skip, limit) => this.list({ ...params, skip, limit }), 50);
+    },
+    async search(query, params = {}) {
+      const {
+        caseSensitive = false,
+        scope = "sentences",
+        speakers,
+        filterQuestions,
+        filterTasks,
+        contextLines = 1,
+        limit,
+        ...listParams
+      } = params;
+      const transcripts = [];
+      for await (const t of this.listAll({
+        keyword: query,
+        scope,
+        ...listParams
+      })) {
+        transcripts.push(t);
+        if (limit && transcripts.length >= limit) break;
+      }
+      const allMatches = [];
+      let transcriptsWithMatches = 0;
+      for (const t of transcripts) {
+        const full = await this.get(t.id, { includeSentences: true });
+        const matches = searchTranscript(full, {
+          query,
+          caseSensitive,
+          speakers,
+          filterQuestions,
+          filterTasks,
+          contextLines
+        });
+        if (matches.length > 0) {
+          transcriptsWithMatches++;
+          allMatches.push(...matches);
+        }
+      }
+      return {
+        query,
+        options: params,
+        totalMatches: allMatches.length,
+        transcriptsSearched: transcripts.length,
+        transcriptsWithMatches,
+        matches: allMatches
+      };
+    },
+    async insights(params = {}) {
+      const {
+        fromDate,
+        toDate,
+        mine,
+        organizers,
+        participants,
+        user_id,
+        channel_id,
+        limit,
+        external,
+        speakers,
+        groupBy: groupBy2,
+        topSpeakersCount,
+        topParticipantsCount
+      } = params;
+      let internalDomain;
+      if (external) {
+        const userQuery = "query { user { email } }";
+        const userData = await client.execute(userQuery);
+        internalDomain = extractDomain(userData.user.email);
+      }
+      const transcripts = [];
+      for await (const t of this.listAll({
+        fromDate,
+        toDate,
+        mine,
+        organizers,
+        participants,
+        user_id,
+        channel_id
+      })) {
+        if (internalDomain && !hasExternalParticipants(t.participants, internalDomain)) {
+          continue;
+        }
+        const full = await this.get(t.id, { includeSentences: true, includeSummary: false });
+        transcripts.push(full);
+        if (limit && transcripts.length >= limit) break;
+      }
+      return analyzeMeetings(transcripts, {
+        speakers,
+        groupBy: groupBy2,
+        topSpeakersCount,
+        topParticipantsCount
+      });
+    },
+    async exportActionItems(params = {}) {
+      const { fromDate, toDate, mine, organizers, participants, limit, filterOptions } = params;
+      const transcripts = [];
+      for await (const t of this.listAll({
+        fromDate,
+        toDate,
+        mine,
+        organizers,
+        participants
+      })) {
+        const full = await this.get(t.id, { includeSentences: false, includeSummary: true });
+        transcripts.push(full);
+        if (limit && transcripts.length >= limit) break;
+      }
+      return aggregateActionItems(transcripts, {}, filterOptions);
+    }
+  };
+}
+function orUndefined(value) {
+  return value ?? void 0;
+}
+function orEmptyArray(value) {
+  return value ?? [];
+}
+function normalizeRequiredFields(raw) {
+  return {
+    id: raw.id,
+    title: raw.title ?? "",
+    organizer_email: raw.organizer_email ?? "",
+    transcript_url: raw.transcript_url ?? "",
+    duration: raw.duration ?? 0,
+    dateString: raw.dateString ?? "",
+    date: raw.date ?? 0
+  };
+}
+function normalizeArrayFields(raw) {
+  return {
+    speakers: orEmptyArray(raw.speakers),
+    participants: orEmptyArray(raw.participants),
+    meeting_attendees: orEmptyArray(raw.meeting_attendees),
+    meeting_attendance: orEmptyArray(raw.meeting_attendance),
+    fireflies_users: orEmptyArray(raw.fireflies_users),
+    workspace_users: orEmptyArray(raw.workspace_users),
+    sentences: orEmptyArray(raw.sentences),
+    channels: orEmptyArray(raw.channels)
+  };
+}
+function normalizeOptionalFields(raw) {
+  return {
+    host_email: orUndefined(raw.host_email),
+    user: orUndefined(raw.user),
+    audio_url: orUndefined(raw.audio_url),
+    video_url: orUndefined(raw.video_url),
+    calendar_id: orUndefined(raw.calendar_id),
+    summary: orUndefined(raw.summary),
+    meeting_info: orUndefined(raw.meeting_info),
+    cal_id: orUndefined(raw.cal_id),
+    calendar_type: orUndefined(raw.calendar_type),
+    apps_preview: orUndefined(raw.apps_preview),
+    meeting_link: orUndefined(raw.meeting_link),
+    analytics: orUndefined(raw.analytics)
+  };
+}
+function normalizeTranscript(raw) {
+  return {
+    ...normalizeRequiredFields(raw),
+    ...normalizeArrayFields(raw),
+    ...normalizeOptionalFields(raw)
+  };
+}
+function buildListVariables(params) {
+  if (!params) {
+    return { limit: 50 };
+  }
+  return {
+    keyword: params.keyword,
+    scope: params.scope,
+    organizers: params.organizers,
+    participants: params.participants,
+    user_id: params.user_id,
+    mine: params.mine,
+    channel_id: params.channel_id,
+    fromDate: params.fromDate,
+    toDate: params.toDate,
+    limit: params.limit ?? 50,
+    skip: params.skip,
+    title: params.title,
+    host_email: params.host_email,
+    organizer_email: params.organizer_email,
+    participant_email: params.participant_email,
+    date: params.date
+  };
+}
+
+// src/graphql/queries/users.ts
+var USER_FIELDS = `
+  user_id
+  email
+  name
+  num_transcripts
+  recent_meeting
+  recent_transcript
+  minutes_consumed
+  is_admin
+  integrations
+  user_groups {
+    id
+    name
+    handle
+    members {
+      user_id
+      email
+    }
+  }
+`;
+function createUsersAPI(client) {
+  return {
+    async me() {
+      const query = `query { user { ${USER_FIELDS} } }`;
+      const data = await client.execute(query);
+      return data.user;
+    },
+    async get(id) {
+      const query = `
+        query User($userId: String!) {
+          user(id: $userId) { ${USER_FIELDS} }
+        }
+      `;
+      const data = await client.execute(query, { userId: id });
+      return data.user;
+    },
+    async list() {
+      const query = `query Users { users { ${USER_FIELDS} } }`;
+      const data = await client.execute(query);
+      return data.users;
+    }
+  };
+}
+var DEFAULT_WS_URL = "wss://api.fireflies.ai";
+var DEFAULT_WS_PATH = "/ws/realtime";
+var DEFAULT_TIMEOUT2 = 2e4;
+var DEFAULT_CHUNK_TIMEOUT = 2e4;
+var DEFAULT_RECONNECT_DELAY = 5e3;
+var DEFAULT_MAX_RECONNECT_DELAY = 6e4;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var RealtimeConnection = class {
+  socket = null;
+  config;
+  constructor(config) {
+    this.config = {
+      wsUrl: DEFAULT_WS_URL,
+      wsPath: DEFAULT_WS_PATH,
+      timeout: DEFAULT_TIMEOUT2,
+      chunkTimeout: DEFAULT_CHUNK_TIMEOUT,
+      reconnect: true,
+      maxReconnectAttempts: DEFAULT_MAX_RECONNECT_ATTEMPTS,
+      reconnectDelay: DEFAULT_RECONNECT_DELAY,
+      maxReconnectDelay: DEFAULT_MAX_RECONNECT_DELAY,
+      ...config
+    };
+  }
+  /**
+   * Establish connection and wait for auth success.
+   */
+  async connect() {
+    if (this.socket?.connected) {
+      return;
+    }
+    const socket = socket_ioClient.io(this.config.wsUrl, {
+      path: this.config.wsPath,
+      auth: {
+        token: `Bearer ${this.config.apiKey}`,
+        transcriptId: this.config.transcriptId
+      },
+      // Force WebSocket transport (proven more reliable than polling)
+      transports: ["websocket"],
+      reconnection: this.config.reconnect,
+      reconnectionDelay: this.config.reconnectDelay,
+      reconnectionDelayMax: this.config.maxReconnectDelay,
+      reconnectionAttempts: this.config.maxReconnectAttempts,
+      // Exponential backoff factor (default 2x matches our fireflies-whiteboard pattern)
+      randomizationFactor: 0.5,
+      timeout: this.config.timeout,
+      autoConnect: false
+    });
+    this.socket = socket;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        socket.disconnect();
+        reject(new TimeoutError(`Realtime connection timed out after ${this.config.timeout}ms`));
+      }, this.config.timeout);
+      const cleanup = () => clearTimeout(timeoutId);
+      socket.once("auth.success", () => {
+        cleanup();
+        resolve();
+      });
+      socket.once("auth.failed", (data) => {
+        cleanup();
+        socket.disconnect();
+        reject(new AuthenticationError(`Realtime auth failed: ${formatData(data)}`));
+      });
+      socket.once("connection.error", (data) => {
+        cleanup();
+        socket.disconnect();
+        reject(new ConnectionError(`Realtime connection error: ${formatData(data)}`));
+      });
+      socket.once("connect_error", (error) => {
+        cleanup();
+        socket.disconnect();
+        const message = error.message || "Connection failed";
+        if (message.includes("auth") || message.includes("401") || message.includes("unauthorized")) {
+          reject(new AuthenticationError(`Realtime auth failed: ${message}`));
+        } else {
+          reject(
+            new ConnectionError(`Realtime connection failed: ${message}`, {
+              cause: error
+            })
+          );
+        }
+      });
+      socket.connect();
+    });
+  }
+  /**
+   * Register a chunk handler.
+   * Handles both { payload: {...} } and direct payload shapes.
+   */
+  onChunk(handler) {
+    this.socket?.on("transcription.broadcast", (data) => {
+      const chunk = "payload" in data ? data.payload : data;
+      handler(chunk);
+    });
+  }
+  /**
+   * Register a disconnect handler.
+   */
+  onDisconnect(handler) {
+    this.socket?.on("disconnect", handler);
+  }
+  /**
+   * Register a reconnect handler.
+   */
+  onReconnect(handler) {
+    this.socket?.io.on("reconnect", handler);
+  }
+  /**
+   * Register a reconnect attempt handler.
+   */
+  onReconnectAttempt(handler) {
+    this.socket?.io.on("reconnect_attempt", handler);
+  }
+  /**
+   * Register an error handler.
+   */
+  onError(handler) {
+    this.socket?.on("connect_error", handler);
+  }
+  /**
+   * Disconnect and cleanup.
+   */
+  disconnect() {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+  get connected() {
+    return this.socket?.connected ?? false;
+  }
+};
+function formatData(data) {
+  if (data === void 0 || data === null) {
+    return String(data);
+  }
+  try {
+    return JSON.stringify(data);
+  } catch {
+    return String(data);
+  }
+}
+
+// src/realtime/stream.ts
+var RealtimeStream = class {
+  connection;
+  listeners = /* @__PURE__ */ new Map();
+  buffer = [];
+  waiters = [];
+  closed = false;
+  lastChunkId = null;
+  lastChunk = null;
+  constructor(config) {
+    this.connection = new RealtimeConnection(config);
+  }
+  /**
+   * Connect to the realtime stream.
+   * @throws AuthenticationError if authentication fails
+   * @throws ConnectionError if connection fails
+   * @throws TimeoutError if connection times out
+   */
+  async connect() {
+    await this.connection.connect();
+    this.setupHandlers();
+    this.emit("connected");
+  }
+  setupHandlers() {
+    this.connection.onChunk((rawChunk) => {
+      const isNewChunk = this.lastChunkId !== null && rawChunk.chunk_id !== this.lastChunkId;
+      if (isNewChunk && this.lastChunk) {
+        const finalChunk = { ...this.lastChunk, isFinal: true };
+        this.emitChunk(finalChunk);
+      }
+      const chunk = { ...rawChunk, isFinal: false };
+      this.lastChunkId = chunk.chunk_id;
+      this.lastChunk = chunk;
+      this.emit("chunk", chunk);
+    });
+    this.connection.onDisconnect((reason) => {
+      if (this.lastChunk) {
+        const finalChunk = { ...this.lastChunk, isFinal: true };
+        this.emitChunk(finalChunk);
+        this.lastChunk = null;
+      }
+      this.emit("disconnected", reason);
+      if (!this.connection.connected) {
+        this.closed = true;
+        for (const waiter of this.waiters) {
+          waiter(null);
+        }
+        this.waiters = [];
+      }
+    });
+    this.connection.onReconnectAttempt((attempt) => {
+      this.emit("reconnecting", attempt);
+    });
+    this.connection.onReconnect(() => {
+      this.emit("connected");
+    });
+    this.connection.onError((error) => {
+      this.emit("error", error);
+    });
+  }
+  /**
+   * Register an event listener.
+   * @param event - Event name
+   * @param handler - Event handler
+   */
+  on(event, handler) {
+    let handlers = this.listeners.get(event);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.listeners.set(event, handlers);
+    }
+    handlers.add(handler);
+    return this;
+  }
+  /**
+   * Remove an event listener.
+   * @param event - Event name
+   * @param handler - Event handler to remove
+   */
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+    return this;
+  }
+  /**
+   * Emit a chunk to both event listeners and async iterator buffer.
+   * Used for final chunks that should be yielded by the iterator.
+   */
+  emitChunk(chunk) {
+    this.emit("chunk", chunk);
+    if (chunk.isFinal) {
+      if (this.waiters.length > 0) {
+        const waiter = this.waiters.shift();
+        waiter?.(chunk);
+      } else {
+        this.buffer.push(chunk);
+      }
+    }
+  }
+  emit(event, ...args) {
+    const handlers = this.listeners.get(event);
+    handlers?.forEach((handler) => {
+      try {
+        handler(...args);
+      } catch {
+      }
+    });
+  }
+  /**
+   * AsyncIterable implementation for `for await` loops.
+   */
+  async *[Symbol.asyncIterator]() {
+    if (this.closed) {
+      throw new StreamClosedError();
+    }
+    while (!this.closed) {
+      const buffered = this.buffer.shift();
+      if (buffered) {
+        yield buffered;
+        continue;
+      }
+      const chunk = await new Promise((resolve) => {
+        if (this.closed) {
+          resolve(null);
+          return;
+        }
+        this.waiters.push(resolve);
+      });
+      if (chunk === null) {
+        break;
+      }
+      yield chunk;
+    }
+  }
+  /**
+   * Close the stream and disconnect.
+   */
+  close() {
+    if (this.lastChunk) {
+      const finalChunk = { ...this.lastChunk, isFinal: true };
+      this.emitChunk(finalChunk);
+      this.lastChunk = null;
+    }
+    this.closed = true;
+    this.connection.disconnect();
+    this.buffer = [];
+    this.lastChunkId = null;
+    for (const waiter of this.waiters) {
+      waiter(null);
+    }
+    this.waiters = [];
+  }
+  /**
+   * Whether the stream is currently connected.
+   */
+  get connected() {
+    return this.connection.connected;
+  }
+};
+
+// src/realtime/api.ts
+function createRealtimeAPI(apiKey, baseConfig) {
+  return {
+    async connect(transcriptId) {
+      const stream = new RealtimeStream({
+        apiKey,
+        transcriptId,
+        ...baseConfig
+      });
+      await stream.connect();
+      return stream;
+    },
+    async *stream(transcriptId) {
+      const stream = new RealtimeStream({
+        apiKey,
+        transcriptId,
+        ...baseConfig
+      });
+      try {
+        await stream.connect();
+        yield* stream;
+      } finally {
+        stream.close();
+      }
+    }
+  };
+}
+
+// src/client.ts
+var FirefliesClient = class {
+  graphql;
+  /**
+   * Transcript operations: list, get, search, delete.
+   */
+  transcripts;
+  /**
+   * User operations: me, get, list, setRole.
+   */
+  users;
+  /**
+   * Bite operations: get, list, create.
+   */
+  bites;
+  /**
+   * Meeting operations: active meetings, add bot.
+   */
+  meetings;
+  /**
+   * Audio operations: upload audio for transcription.
+   */
+  audio;
+  /**
+   * AI Apps operations: list outputs.
+   */
+  aiApps;
+  /**
+   * Realtime transcription streaming.
+   */
+  realtime;
+  /**
+   * Create a new Fireflies client.
+   *
+   * @param config - Client configuration
+   * @throws FirefliesError if API key is missing
+   */
+  constructor(config) {
+    this.graphql = new GraphQLClient(config);
+    const transcriptsQueries = createTranscriptsAPI(this.graphql);
+    const transcriptsMutations = createTranscriptsMutationsAPI(this.graphql);
+    this.transcripts = { ...transcriptsQueries, ...transcriptsMutations };
+    const usersQueries = createUsersAPI(this.graphql);
+    const usersMutations = createUsersMutationsAPI(this.graphql);
+    this.users = { ...usersQueries, ...usersMutations };
+    this.bites = createBitesAPI(this.graphql);
+    this.meetings = createMeetingsAPI(this.graphql);
+    this.audio = createAudioAPI(this.graphql);
+    this.aiApps = createAIAppsAPI(this.graphql);
+    this.realtime = createRealtimeAPI(config.apiKey);
+  }
+  /**
+   * Get the current rate limit state.
+   * Returns undefined if rate limit tracking is not configured.
+   *
+   * @example
+   * ```typescript
+   * const client = new FirefliesClient({
+   *   apiKey: '...',
+   *   rateLimit: { warningThreshold: 10 }
+   * });
+   *
+   * await client.users.me();
+   * console.log(client.rateLimits);
+   * // { remaining: 59, limit: 60, resetInSeconds: 60, updatedAt: 1706299500000 }
+   * ```
+   */
+  get rateLimits() {
+    return this.graphql.rateLimitState;
+  }
+};
+
+// src/helpers/accumulator.ts
+var TranscriptAccumulator = class {
+  turns = [];
+  currentTurn = null;
+  seenChunkIds = /* @__PURE__ */ new Set();
+  /**
+   * Add a chunk to the accumulator.
+   *
+   * Only final chunks are accumulated; non-final chunks are ignored.
+   * Duplicate chunk IDs are also ignored.
+   *
+   * @param chunk - The transcription chunk to add
+   */
+  add(chunk) {
+    if (!chunk.isFinal) return;
+    if (this.seenChunkIds.has(chunk.chunk_id)) return;
+    this.seenChunkIds.add(chunk.chunk_id);
+    if (this.currentTurn && this.currentTurn.speaker === chunk.speaker_name) {
+      this.currentTurn.text += ` ${chunk.text}`;
+      this.currentTurn.endTime = chunk.end_time;
+      this.currentTurn.chunks.push(chunk);
+    } else {
+      this.currentTurn = {
+        speaker: chunk.speaker_name,
+        text: chunk.text,
+        startTime: chunk.start_time,
+        endTime: chunk.end_time,
+        chunks: [chunk]
+      };
+      this.turns.push(this.currentTurn);
+    }
+  }
+  /**
+   * Get the current accumulated transcript state.
+   *
+   * Statistics are computed on demand to ensure accuracy.
+   *
+   * @returns The accumulated transcript with turns, speakers, and statistics
+   */
+  getTranscript() {
+    const speakers = this.getUniqueSpeakers();
+    const wordCount = this.computeWordCount();
+    const duration = this.computeDuration();
+    return {
+      turns: this.turns,
+      speakers,
+      wordCount,
+      duration,
+      chunkCount: this.seenChunkIds.size
+    };
+  }
+  /**
+   * Clear all accumulated data.
+   *
+   * Useful for resetting the accumulator between sessions.
+   */
+  clear() {
+    this.turns = [];
+    this.currentTurn = null;
+    this.seenChunkIds.clear();
+  }
+  getUniqueSpeakers() {
+    const seen = /* @__PURE__ */ new Set();
+    const speakers = [];
+    for (const turn of this.turns) {
+      if (!seen.has(turn.speaker)) {
+        seen.add(turn.speaker);
+        speakers.push(turn.speaker);
+      }
+    }
+    return speakers;
+  }
+  computeWordCount() {
+    let count = 0;
+    for (const turn of this.turns) {
+      if (turn.text.length === 0) continue;
+      const words = turn.text.trim().split(/\s+/);
+      count += words.filter((w) => w.length > 0).length;
+    }
+    return count;
+  }
+  computeDuration() {
+    const firstTurn = this.turns[0];
+    const lastTurn = this.turns[this.turns.length - 1];
+    if (!firstTurn || !lastTurn) return 0;
+    const firstChunk = firstTurn.chunks[0];
+    if (!firstChunk) return 0;
+    return lastTurn.endTime - firstChunk.start_time;
+  }
+};
+
+// src/helpers/batch.ts
+async function* batch(items, processor, options = {}) {
+  const { delayMs = 100, handleRateLimit = true, maxRateLimitRetries = 3 } = options;
+  let isFirst = true;
+  for await (const item of items) {
+    if (!isFirst && delayMs > 0) {
+      await delay(delayMs);
+    }
+    isFirst = false;
+    yield await processWithRetry(item, processor, {
+      handleRateLimit,
+      maxRateLimitRetries
+    });
+  }
+}
+async function batchAll(items, processor, options = {}) {
+  const { continueOnError = false, ...batchOptions } = options;
+  const results = [];
+  const errors = [];
+  for await (const batchResult of batch(items, processor, batchOptions)) {
+    if (batchResult.error) {
+      if (!continueOnError) {
+        throw batchResult.error;
+      }
+      errors.push(batchResult.error);
+    } else {
+      results.push(batchResult.result);
+    }
+  }
+  return results;
+}
+async function processWithRetry(item, processor, options) {
+  const { handleRateLimit, maxRateLimitRetries } = options;
+  let retries = 0;
+  while (true) {
+    try {
+      const result = await processor(item);
+      return { item, result };
+    } catch (err) {
+      if (handleRateLimit && err instanceof RateLimitError && retries < maxRateLimitRetries) {
+        const waitTime = err.retryAfter ?? 1e3;
+        await delay(waitTime);
+        retries++;
+        continue;
+      }
+      return {
+        item,
+        error: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/helpers/external-questions.ts
+function findExternalParticipantQuestions(transcript, internalDomains) {
+  const domains = normalizeDomains(internalDomains);
+  const speakerEmailMap = buildSpeakerEmailMap(transcript);
+  const { externalSpeakers } = classifySpeakers(transcript, speakerEmailMap, domains);
+  const questions = [];
+  for (const sentence of transcript.sentences ?? []) {
+    if (!sentence.ai_filters?.question) {
+      continue;
+    }
+    if (!externalSpeakers.has(sentence.speaker_name)) {
+      continue;
+    }
+    questions.push({
+      text: sentence.text,
+      speakerName: sentence.speaker_name,
+      speakerEmail: speakerEmailMap.get(sentence.speaker_name),
+      sentenceIndex: sentence.index,
+      startTime: sentence.start_time,
+      endTime: sentence.end_time
+    });
+  }
+  const externalParticipants = Array.from(externalSpeakers).map((name) => ({
+    name,
+    email: speakerEmailMap.get(name)
+  }));
+  return {
+    externalParticipants,
+    questions,
+    totalQuestions: questions.length
+  };
+}
+function normalizeDomains(input) {
+  const raw = Array.isArray(input) ? input : [input];
+  return raw.map((d) => {
+    const domain = d.toLowerCase().trim();
+    return domain.startsWith("@") ? domain : `@${domain}`;
+  });
+}
+function buildSpeakerEmailMap(transcript) {
+  const map = /* @__PURE__ */ new Map();
+  for (const attendee of transcript.meeting_attendees ?? []) {
+    if (attendee.displayName && attendee.email) {
+      map.set(attendee.displayName, attendee.email.toLowerCase());
+    }
+    if (attendee.name && attendee.email) {
+      map.set(attendee.name, attendee.email.toLowerCase());
+    }
+  }
+  return map;
+}
+function classifySpeakers(transcript, speakerEmailMap, internalDomains) {
+  const internalSpeakers = /* @__PURE__ */ new Set();
+  const externalSpeakers = /* @__PURE__ */ new Set();
+  const speakerNames = new Set((transcript.sentences ?? []).map((s) => s.speaker_name));
+  for (const name of speakerNames) {
+    const email = speakerEmailMap.get(name);
+    if (isInternal(email, internalDomains)) {
+      internalSpeakers.add(name);
+    } else {
+      externalSpeakers.add(name);
+    }
+  }
+  return { internalSpeakers, externalSpeakers };
+}
+function isInternal(email, internalDomains) {
+  if (!email) {
+    return false;
+  }
+  const lowerEmail = email.toLowerCase();
+  return internalDomains.some((domain) => lowerEmail.endsWith(domain));
+}
+
+// src/helpers/markdown.ts
+var DEFAULT_OPTIONS2 = {
+  includeMetadata: true,
+  includeSummary: true,
+  includeActionItems: true,
+  actionItemFormat: "checkbox",
+  includeTimestamps: false,
+  speakerFormat: "bold",
+  groupBySpeaker: true
+};
+var DEFAULT_CHUNKS_OPTIONS = {
+  title: "Live Transcript",
+  includeTimestamps: false,
+  speakerFormat: "bold",
+  groupBySpeaker: true
+};
+async function transcriptToMarkdown(transcript, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const sections = [];
+  if (opts.includeMetadata) {
+    sections.push(formatMetadata(transcript));
+  }
+  if (opts.includeSummary && transcript.summary) {
+    sections.push(formatSummary(transcript.summary, opts));
+  }
+  if (transcript.sentences && transcript.sentences.length > 0) {
+    sections.push(formatTranscript(transcript.sentences, opts));
+  }
+  const content = sections.join("\n\n---\n\n");
+  await writeIfOutputPath(content, options.outputPath);
+  return content;
+}
+async function chunksToMarkdown(chunks, options = {}) {
+  const opts = { ...DEFAULT_CHUNKS_OPTIONS, ...options };
+  const lines = [`# ${opts.title}`];
+  if (chunks.length === 0) {
+    lines.push("", "## Transcript", "", "*No transcription data*");
+  } else {
+    lines.push("", "## Transcript");
+    if (opts.groupBySpeaker) {
+      const groups = groupChunksBySpeaker(chunks);
+      for (const group of groups) {
+        lines.push("", formatChunkGroup(group, opts));
+      }
+    } else {
+      for (const chunk of chunks) {
+        lines.push("", formatChunk(chunk, opts));
+      }
+    }
+  }
+  const content = lines.join("\n");
+  await writeIfOutputPath(content, options.outputPath);
+  return content;
+}
+function formatMetadata(transcript) {
+  const lines = [`# ${transcript.title || "Untitled Meeting"}`];
+  if (transcript.dateString) {
+    lines.push(`
+**Date:** ${formatDate(transcript.dateString)}`);
+  }
+  const duration = calculateDuration(transcript);
+  if (duration > 0) {
+    lines.push(`**Duration:** ${formatDuration(duration)}`);
+  }
+  const participants = getParticipantNames(transcript);
+  if (participants.length > 0) {
+    lines.push(`**Participants:** ${participants.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function calculateDuration(transcript) {
+  if (transcript.sentences && transcript.sentences.length > 0) {
+    const lastSentence = transcript.sentences[transcript.sentences.length - 1];
+    if (lastSentence) {
+      return parseFloat(lastSentence.end_time);
+    }
+  }
+  return transcript.duration || 0;
+}
+function formatSummary(summary, opts) {
+  const sections = ["## Summary"];
+  if (summary.gist) {
+    sections.push("", summary.gist);
+  }
+  if (summary.bullet_gist) {
+    const bullets = parseMultilineField(summary.bullet_gist);
+    if (bullets.length > 0) {
+      sections.push("", "### Key Points");
+      sections.push(bullets.map((p) => `- ${p}`).join("\n"));
+    }
+  }
+  if (opts.includeActionItems && summary.action_items) {
+    const items = parseMultilineField(summary.action_items);
+    if (items.length > 0) {
+      sections.push("", "### Action Items");
+      const prefix = opts.actionItemFormat === "checkbox" ? "- [ ] " : "- ";
+      sections.push(items.map((a) => `${prefix}${a}`).join("\n"));
+    }
+  }
+  return sections.join("\n");
+}
+function formatTranscript(sentences, opts) {
+  const lines = ["## Transcript"];
+  if (opts.groupBySpeaker) {
+    const groups = groupSentencesBySpeaker(sentences);
+    for (const group of groups) {
+      lines.push("", formatSpeakerGroup(group, opts));
+    }
+  } else {
+    for (const sentence of sentences) {
+      lines.push("", formatSentence(sentence, opts));
+    }
+  }
+  return lines.join("\n");
+}
+function groupSentencesBySpeaker(sentences) {
+  const groups = [];
+  let current = null;
+  for (const sentence of sentences) {
+    if (!current || current.speakerName !== sentence.speaker_name) {
+      current = { speakerName: sentence.speaker_name, sentences: [] };
+      groups.push(current);
+    }
+    current.sentences.push(sentence);
+  }
+  return groups;
+}
+function formatSpeakerGroup(group, opts) {
+  const speaker = formatSpeakerName(group.speakerName, opts.speakerFormat);
+  const text = group.sentences.map((s) => s.text).join(" ");
+  const firstSentence = group.sentences[0];
+  if (opts.includeTimestamps && firstSentence) {
+    const timestamp = formatTimestamp(firstSentence.start_time);
+    return `${timestamp} ${speaker} ${text}`;
+  }
+  return `${speaker} ${text}`;
+}
+function formatSentence(sentence, opts) {
+  const speaker = formatSpeakerName(sentence.speaker_name, opts.speakerFormat);
+  if (opts.includeTimestamps) {
+    const timestamp = formatTimestamp(sentence.start_time);
+    return `${timestamp} ${speaker} ${sentence.text}`;
+  }
+  return `${speaker} ${sentence.text}`;
+}
+function groupChunksBySpeaker(chunks) {
+  const groups = [];
+  let current = null;
+  for (const chunk of chunks) {
+    if (!current || current.speakerName !== chunk.speaker_name) {
+      current = { speakerName: chunk.speaker_name, chunks: [] };
+      groups.push(current);
+    }
+    current.chunks.push(chunk);
+  }
+  return groups;
+}
+function formatChunkGroup(group, opts) {
+  const speaker = formatSpeakerName(group.speakerName, opts.speakerFormat);
+  const text = group.chunks.map((c) => c.text).join(" ");
+  const firstChunk = group.chunks[0];
+  if (opts.includeTimestamps && firstChunk) {
+    const timestamp = formatTimestamp(firstChunk.start_time.toString());
+    return `${timestamp} ${speaker} ${text}`;
+  }
+  return `${speaker} ${text}`;
+}
+function formatChunk(chunk, opts) {
+  const speaker = formatSpeakerName(chunk.speaker_name, opts.speakerFormat);
+  if (opts.includeTimestamps) {
+    const timestamp = formatTimestamp(chunk.start_time.toString());
+    return `${timestamp} ${speaker} ${chunk.text}`;
+  }
+  return `${speaker} ${chunk.text}`;
+}
+function formatSpeakerName(name, format) {
+  switch (format) {
+    case "bold":
+      return `**${name}:**`;
+    case "plain":
+      return `${name}:`;
+  }
+}
+function formatTimestamp(startTime) {
+  const seconds = parseFloat(startTime);
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.floor(seconds % 60);
+  return `[${mins}:${secs.toString().padStart(2, "0")}]`;
+}
+function formatDuration(seconds) {
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.floor(seconds % 3600 / 60);
+  if (hours > 0) {
+    return `${hours}h ${mins}m`;
+  }
+  return `${mins} minutes`;
+}
+function formatDate(isoString) {
+  return new Date(isoString).toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+}
+function getParticipantNames(transcript) {
+  if (transcript.meeting_attendees?.length) {
+    return transcript.meeting_attendees.map((a) => a.displayName || a.name || a.email).filter(Boolean);
+  }
+  return transcript.speakers?.map((s) => s.name) || [];
+}
+function parseMultilineField(value) {
+  return value.split(/\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+async function writeIfOutputPath(content, outputPath) {
+  if (outputPath) {
+    const { writeFile } = await import('fs/promises');
+    await writeFile(outputPath, content, "utf-8");
+  }
+}
+
+// src/utils/dedup.ts
+var Deduplicator = class {
+  seen = /* @__PURE__ */ new Set();
+  queue = [];
+  maxSize;
+  constructor(maxSize = 1e3) {
+    this.maxSize = maxSize;
+  }
+  /**
+   * Check if item is a duplicate and mark as seen.
+   * @param key - Unique key to check
+   * @returns true if duplicate, false if new
+   */
+  isDuplicate(key) {
+    if (this.seen.has(key)) {
+      return true;
+    }
+    this.seen.add(key);
+    this.queue.push(key);
+    while (this.queue.length > this.maxSize) {
+      const oldest = this.queue.shift();
+      if (oldest) this.seen.delete(oldest);
+    }
+    return false;
+  }
+  /**
+   * Clear all tracked keys.
+   */
+  clear() {
+    this.seen.clear();
+    this.queue = [];
+  }
+  /**
+   * Get current number of tracked keys.
+   */
+  get size() {
+    return this.seen.size;
+  }
+};
+
+// src/helpers/multi-user.ts
+async function* getMeetingsForMultipleUsers(apiKeys, options = {}) {
+  const { deduplicate = true, filter, delayMs = 100 } = options;
+  const dedup = deduplicate ? new Deduplicator() : null;
+  let needsDelay = false;
+  for (const [sourceIndex, apiKey] of apiKeys.entries()) {
+    const client = new FirefliesClient({ apiKey });
+    for await (const transcript of client.transcripts.listAll(filter)) {
+      if (needsDelay && delayMs > 0) {
+        await delay2(delayMs);
+      }
+      needsDelay = true;
+      if (dedup?.isDuplicate(transcript.id)) {
+        continue;
+      }
+      yield {
+        transcript,
+        sourceApiKey: apiKey,
+        sourceIndex
+      };
+    }
+  }
+}
+function delay2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/helpers/normalize.ts
+var DEFAULT_OPTIONS3 = {
+  timeUnit: "seconds",
+  includeRawData: false,
+  includeAIFilters: true,
+  includeSummary: true,
+  resolveSpeakerName: (speaker) => speaker.name,
+  enrichParticipant: () => ({})
+};
+function normalizeTranscript2(transcript, options) {
+  const opts = { ...DEFAULT_OPTIONS3, ...options };
+  const speakers = normalizeSpeakers(transcript.speakers ?? [], transcript, opts);
+  const sentences = normalizeSentences(transcript.sentences ?? [], opts);
+  const participants = normalizeParticipants(transcript, opts);
+  const summary = opts.includeSummary ? normalizeSummary(transcript.summary) : void 0;
+  const attendees = normalizeAttendees(transcript.meeting_attendance ?? []);
+  const channels = normalizeChannels(transcript.channels ?? []);
+  const analytics = normalizeAnalytics(transcript.analytics);
+  return {
+    id: `fireflies:${transcript.id}`,
+    title: transcript.title,
+    date: new Date(transcript.date),
+    duration: transcript.duration * 60,
+    // minutes → seconds
+    url: transcript.transcript_url,
+    speakers,
+    sentences,
+    participants,
+    summary,
+    attendees,
+    channels,
+    analytics,
+    source: {
+      provider: "fireflies",
+      originalId: transcript.id,
+      rawData: opts.includeRawData ? transcript : void 0
+    }
+  };
+}
+function createNormalizer(options) {
+  return (transcript) => normalizeTranscript2(transcript, options);
+}
+function normalizeSpeakers(speakers, transcript, opts) {
+  return speakers.map((speaker) => ({
+    id: speaker.id,
+    name: opts.resolveSpeakerName(speaker, transcript)
+  }));
+}
+function normalizeSentences(sentences, opts) {
+  const timeMultiplier = opts.timeUnit === "milliseconds" ? 1e3 : 1;
+  return sentences.map((sentence) => {
+    const normalized = {
+      index: sentence.index,
+      speakerId: sentence.speaker_id,
+      speakerName: sentence.speaker_name,
+      text: sentence.text,
+      rawText: sentence.raw_text,
+      startTime: parseTime(sentence.start_time) * timeMultiplier,
+      endTime: parseTime(sentence.end_time) * timeMultiplier
+    };
+    if (opts.includeAIFilters && sentence.ai_filters) {
+      const sentiment = mapSentiment(sentence.ai_filters.sentiment);
+      if (sentiment) {
+        normalized.sentiment = sentiment;
+      }
+      if (sentence.ai_filters.question) {
+        normalized.isQuestion = true;
+      }
+      if (sentence.ai_filters.task) {
+        normalized.isActionItem = true;
+      }
+    }
+    return normalized;
+  });
+}
+function parseTime(timeStr) {
+  const parsed = Number.parseFloat(timeStr);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function mapSentiment(sentiment) {
+  if (!sentiment) return void 0;
+  const lower = sentiment.toLowerCase();
+  if (lower === "positive") return "positive";
+  if (lower === "negative") return "negative";
+  if (lower === "neutral") return "neutral";
+  return void 0;
+}
+function normalizeParticipants(transcript, opts) {
+  const participants = transcript.participants ?? [];
+  const attendeeMap = /* @__PURE__ */ new Map();
+  for (const attendee of transcript.meeting_attendees ?? []) {
+    if (attendee.email && attendee.name) {
+      attendeeMap.set(attendee.email.toLowerCase(), attendee.name);
+    }
+  }
+  return participants.map((email) => {
+    const isOrganizer = email.toLowerCase() === transcript.organizer_email.toLowerCase();
+    const attendeeName = attendeeMap.get(email.toLowerCase());
+    const enrichment = opts.enrichParticipant(email, transcript);
+    return {
+      name: enrichment.name ?? attendeeName ?? "",
+      email,
+      role: enrichment.role ?? (isOrganizer ? "organizer" : "attendee")
+    };
+  });
+}
+function normalizeSummary(summary) {
+  if (!summary) return void 0;
+  const keyPoints = parseKeyPoints(summary.shorthand_bullet);
+  return {
+    overview: summary.overview,
+    keyPoints: keyPoints.length > 0 ? keyPoints : void 0,
+    actionItems: summary.action_items,
+    outline: summary.outline,
+    topics: summary.topics_discussed
+  };
+}
+function parseKeyPoints(shorthandBullet) {
+  if (!shorthandBullet) return [];
+  return shorthandBullet.split("\n").map((line) => line.replace(/^[-*•]\s*/, "").trim()).filter((line) => line.length > 0);
+}
+function normalizeAttendees(attendance) {
+  return attendance.map((a) => ({
+    name: a.name,
+    joinTime: a.join_time ? new Date(a.join_time) : void 0,
+    leaveTime: a.leave_time ? new Date(a.leave_time) : void 0
+  }));
+}
+function normalizeChannels(channels) {
+  return channels.map((ch) => ({
+    id: ch.id,
+    title: ch.title,
+    isPrivate: ch.is_private ?? false
+  }));
+}
+function normalizeAnalytics(analytics) {
+  if (!analytics?.sentiments) return void 0;
+  return {
+    sentiments: {
+      positive: analytics.sentiments.positive_pct ?? 0,
+      neutral: analytics.sentiments.neutral_pct ?? 0,
+      negative: analytics.sentiments.negative_pct ?? 0
+    }
+  };
+}
+function delay3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function* normalizeTranscripts(transcripts, options) {
+  const { delayMs = 0, ...normalizationOptions } = options ?? {};
+  let isFirst = true;
+  for await (const transcript of transcripts) {
+    if (!isFirst && delayMs > 0) {
+      await delay3(delayMs);
+    }
+    isFirst = false;
+    try {
+      const result = normalizeTranscript2(transcript, normalizationOptions);
+      yield { item: transcript, result };
+    } catch (err) {
+      yield {
+        item: transcript,
+        error: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+  }
+}
+async function normalizeTranscriptsAll(transcripts, options) {
+  const results = [];
+  for await (const result of normalizeTranscripts(transcripts, options)) {
+    results.push(result);
+  }
+  return results;
+}
+
+// src/helpers/speaker-analytics.ts
+function analyzeSpeakers(transcript, options = {}) {
+  const {
+    mergeSpeakersByName = true,
+    roundPercentages = true,
+    unbalancedThreshold = 40,
+    dominatedThreshold = 60
+  } = options;
+  const sentences = transcript.sentences ?? [];
+  if (sentences.length === 0) {
+    return emptyAnalytics();
+  }
+  const speakerMap = /* @__PURE__ */ new Map();
+  let prevSpeakerKey = null;
+  for (const sentence of sentences) {
+    const groupKey = mergeSpeakersByName ? sentence.speaker_name : sentence.speaker_id;
+    const data = getOrCreateSpeakerData(speakerMap, groupKey, sentence);
+    data.sentences.push(sentence);
+    data.talkTime += parseDuration(sentence);
+    data.wordCount += countWords(sentence.text);
+    if (groupKey !== prevSpeakerKey) {
+      data.turnCount++;
+      prevSpeakerKey = groupKey;
+    }
+  }
+  const totalTalkTime = sumTalkTime(speakerMap);
+  const totalDuration = calculateDuration2(sentences);
+  const totalWords = sumWords(speakerMap);
+  const speakers = buildSpeakerStats(speakerMap, totalTalkTime, roundPercentages);
+  speakers.sort((a, b) => b.talkTime - a.talkTime);
+  const dominant = speakers[0];
+  return {
+    speakers,
+    totalDuration,
+    totalTalkTime,
+    totalSentences: sentences.length,
+    totalWords,
+    dominantSpeaker: dominant?.name ?? "",
+    dominantSpeakerPercentage: dominant?.talkTimePercentage ?? 0,
+    balance: classifyBalance(speakers, unbalancedThreshold, dominatedThreshold)
+  };
+}
+function emptyAnalytics() {
+  return {
+    speakers: [],
+    totalDuration: 0,
+    totalTalkTime: 0,
+    totalSentences: 0,
+    totalWords: 0,
+    dominantSpeaker: "",
+    dominantSpeakerPercentage: 0,
+    balance: "balanced"
+  };
+}
+function getOrCreateSpeakerData(speakerMap, groupKey, sentence) {
+  let data = speakerMap.get(groupKey);
+  if (!data) {
+    data = {
+      id: sentence.speaker_id,
+      // Use first encountered ID
+      name: sentence.speaker_name,
+      sentences: [],
+      talkTime: 0,
+      wordCount: 0,
+      turnCount: 0
+    };
+    speakerMap.set(groupKey, data);
+  }
+  return data;
+}
+function parseDuration(sentence) {
+  const start = Number.parseFloat(sentence.start_time);
+  const end = Number.parseFloat(sentence.end_time);
+  return Math.max(0, end - start);
+}
+function countWords(text) {
+  if (!text || text.length === 0) return 0;
+  return text.trim().split(/\s+/).filter((w) => w.length > 0).length;
+}
+function sumTalkTime(speakerMap) {
+  let total = 0;
+  for (const data of speakerMap.values()) {
+    total += data.talkTime;
+  }
+  return total;
+}
+function sumWords(speakerMap) {
+  let total = 0;
+  for (const data of speakerMap.values()) {
+    total += data.wordCount;
+  }
+  return total;
+}
+function calculateDuration2(sentences) {
+  if (sentences.length === 0) return 0;
+  const lastSentence = sentences[sentences.length - 1];
+  return Number.parseFloat(lastSentence?.end_time ?? "0");
+}
+function buildSpeakerStats(speakerMap, totalTalkTime, roundPercentages) {
+  const speakers = [];
+  for (const data of speakerMap.values()) {
+    const percentage = totalTalkTime > 0 ? data.talkTime / totalTalkTime * 100 : 0;
+    const sentenceCount = data.sentences.length;
+    const talkTimeMinutes = data.talkTime / 60;
+    const wordsPerMinute = talkTimeMinutes > 0 ? data.wordCount / talkTimeMinutes : 0;
+    const averageSentenceLength = sentenceCount > 0 ? data.wordCount / sentenceCount : 0;
+    speakers.push({
+      name: data.name,
+      id: data.id,
+      talkTime: data.talkTime,
+      talkTimePercentage: roundPercentages ? Math.round(percentage) : percentage,
+      sentenceCount,
+      wordCount: data.wordCount,
+      wordsPerMinute: roundPercentages ? Math.round(wordsPerMinute) : wordsPerMinute,
+      averageSentenceLength,
+      turnCount: data.turnCount
+    });
+  }
+  return speakers;
+}
+function classifyBalance(speakers, unbalancedThreshold, dominatedThreshold) {
+  if (speakers.length <= 2) return "balanced";
+  const top = speakers[0]?.talkTimePercentage ?? 0;
+  if (top > dominatedThreshold) return "dominated";
+  if (top > unbalancedThreshold) return "unbalanced";
+  return "balanced";
+}
+
+// src/helpers/videos.ts
+async function* getMeetingVideos(client, options) {
+  for await (const transcript of client.transcripts.listAll(options)) {
+    if (transcript.video_url) {
+      yield {
+        transcript,
+        videoUrl: transcript.video_url
+      };
+    }
+  }
+}
+function hasVideo(transcript) {
+  return typeof transcript.video_url === "string" && transcript.video_url.length > 0;
+}
+function verifyWebhookSignature(options) {
+  const { payload, signature, secret } = options;
+  if (!signature || !secret) {
+    return false;
+  }
+  const payloadString = typeof payload === "string" ? payload : JSON.stringify(payload);
+  const computed = crypto.createHmac("sha256", secret).update(payloadString).digest("hex");
+  try {
+    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(computed));
+  } catch {
+    return false;
+  }
+}
+
+// src/webhooks/parse.ts
+var VALID_EVENT_TYPES = ["Transcription completed"];
+function isValidEventType(value) {
+  return VALID_EVENT_TYPES.includes(value);
+}
+function isValidWebhookPayload(payload) {
+  if (!payload || typeof payload !== "object") {
+    return false;
+  }
+  const meetingId = payload["meetingId"];
+  const eventType = payload["eventType"];
+  const clientReferenceId = payload["clientReferenceId"];
+  return typeof meetingId === "string" && typeof eventType === "string" && isValidEventType(eventType) && (clientReferenceId === void 0 || typeof clientReferenceId === "string");
+}
+function parseWebhookPayload(payload, options) {
+  if (options?.signature && options?.secret) {
+    const isValid = verifyWebhookSignature({
+      payload,
+      signature: options.signature,
+      secret: options.secret
+    });
+    if (!isValid) {
+      throw new WebhookVerificationError("Invalid webhook signature");
+    }
+  }
+  if (!isValidWebhookPayload(payload)) {
+    throw new WebhookParseError(
+      "Invalid webhook payload: expected meetingId (string), eventType (valid event type), and optional clientReferenceId (string)"
+    );
+  }
+  return payload;
+}
+
+exports.AuthenticationError = AuthenticationError;
+exports.ChunkTimeoutError = ChunkTimeoutError;
+exports.ConnectionError = ConnectionError;
+exports.Deduplicator = Deduplicator;
+exports.FirefliesClient = FirefliesClient;
+exports.FirefliesError = FirefliesError;
+exports.GraphQLError = GraphQLError;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.RateLimitError = RateLimitError;
+exports.RealtimeError = RealtimeError;
+exports.RealtimeStream = RealtimeStream;
+exports.StreamClosedError = StreamClosedError;
+exports.TimeoutError = TimeoutError;
+exports.TranscriptAccumulator = TranscriptAccumulator;
+exports.ValidationError = ValidationError;
+exports.WebhookParseError = WebhookParseError;
+exports.WebhookVerificationError = WebhookVerificationError;
+exports.aggregateActionItems = aggregateActionItems;
+exports.analyzeMeetings = analyzeMeetings;
+exports.analyzeSpeakers = analyzeSpeakers;
+exports.batch = batch;
+exports.batchAll = batchAll;
+exports.chunksToMarkdown = chunksToMarkdown;
+exports.collectAll = collectAll;
+exports.createNormalizer = createNormalizer;
+exports.extractActionItems = extractActionItems;
+exports.extractDomain = extractDomain;
+exports.filterActionItems = filterActionItems;
+exports.findExternalParticipantQuestions = findExternalParticipantQuestions;
+exports.formatActionItemsMarkdown = formatActionItemsMarkdown;
+exports.getMeetingVideos = getMeetingVideos;
+exports.getMeetingsForMultipleUsers = getMeetingsForMultipleUsers;
+exports.hasExternalParticipants = hasExternalParticipants;
+exports.hasVideo = hasVideo;
+exports.isValidWebhookPayload = isValidWebhookPayload;
+exports.normalizeTranscript = normalizeTranscript2;
+exports.normalizeTranscripts = normalizeTranscripts;
+exports.normalizeTranscriptsAll = normalizeTranscriptsAll;
+exports.paginate = paginate;
+exports.parseWebhookPayload = parseWebhookPayload;
+exports.searchTranscript = searchTranscript;
+exports.transcriptToMarkdown = transcriptToMarkdown;
+exports.verifyWebhookSignature = verifyWebhookSignature;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map