fireflies-api 0.5.0

package/dist/middleware/fastify.js

@@ -0,0 +1,2498 @@
+import { io } from 'socket.io-client';
+import { createHmac, timingSafeEqual } from '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";
+  }
+};
+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 delay = calculateDelay(error, attempt, baseDelay, maxDelay);
+      await sleep(delay);
+    }
+  }
+  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 delay = this.rateLimitTracker.getThrottleDelay(this.rateLimitConfig.throttle);
+    if (delay > 0) {
+      await sleep2(delay);
+    }
+  }
+  /**
+   * 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;
+    }
+  }
+}
+
+// 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] ?? ""
+    }
+  };
+}
+
+// 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, 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 = groupBy ? calculateTimeGroupStats(transcripts, groupBy) : 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, groupBy) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of transcripts) {
+    const date = parseDate(t.dateString);
+    if (!date) continue;
+    const period = formatPeriod(date, groupBy);
+    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, groupBy) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  switch (groupBy) {
+    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,
+        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,
+        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 = 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;
+  }
+};
+function verifyWebhookSignature(options) {
+  const { payload, signature, secret } = options;
+  if (!signature || !secret) {
+    return false;
+  }
+  const payloadString = typeof payload === "string" ? payload : JSON.stringify(payload);
+  const computed = createHmac("sha256", secret).update(payloadString).digest("hex");
+  try {
+    return 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;
+}
+
+// src/middleware/core.ts
+function validateOptions(options) {
+  if (!options.secret || !options.secret.trim()) {
+    throw new Error("Webhook middleware: secret is required");
+  }
+}
+function buildHandlerContext(params) {
+  const { payload, apiKey, transcript } = params;
+  const context = {
+    payload
+  };
+  if (apiKey) {
+    context.client = new FirefliesClient({ apiKey });
+  }
+  if (transcript) {
+    context.transcript = transcript;
+  }
+  return context;
+}
+function parseRawBody(rawBody) {
+  return Buffer.isBuffer(rawBody) ? rawBody.toString("utf-8") : rawBody;
+}
+function parseAndValidatePayload(rawBody, signature, secret) {
+  if (!signature) {
+    throw new WebhookVerificationError("Missing webhook signature");
+  }
+  const bodyString = parseRawBody(rawBody);
+  let jsonPayload;
+  try {
+    jsonPayload = JSON.parse(bodyString);
+  } catch {
+    throw new WebhookParseError("Invalid JSON in webhook body");
+  }
+  return parseWebhookPayload(jsonPayload, { signature, secret });
+}
+async function fetchTranscriptIfEnabled(payload, apiKey, autoFetch) {
+  if (!apiKey || autoFetch === false) {
+    return void 0;
+  }
+  try {
+    const client = new FirefliesClient({ apiKey });
+    return await client.transcripts.get(payload.meetingId);
+  } catch {
+    return void 0;
+  }
+}
+async function executeHandlers(context, options) {
+  const { onEvent, onTranscriptionCompleted } = options;
+  if (onEvent) {
+    await onEvent(context);
+  }
+  if (context.payload.eventType === "Transcription completed" && onTranscriptionCompleted) {
+    await onTranscriptionCompleted(context);
+  }
+}
+function mapErrorToResponse(error) {
+  if (error instanceof WebhookVerificationError) {
+    return {
+      success: false,
+      statusCode: 401,
+      body: "Invalid webhook signature",
+      error
+    };
+  }
+  if (error instanceof WebhookParseError) {
+    return {
+      success: false,
+      statusCode: 400,
+      body: "Invalid webhook payload",
+      error
+    };
+  }
+  if (error instanceof SyntaxError) {
+    return {
+      success: false,
+      statusCode: 400,
+      body: "Invalid JSON in webhook body",
+      error
+    };
+  }
+  return {
+    success: false,
+    statusCode: 500,
+    body: "Internal server error",
+    error: error instanceof Error ? error : new Error(String(error))
+  };
+}
+async function processWebhook(input, options) {
+  const { rawBody, signature } = input;
+  const { secret, apiKey, autoFetch, onError } = options;
+  let parsedPayload;
+  try {
+    parsedPayload = parseAndValidatePayload(rawBody, signature, secret);
+    const transcript = await fetchTranscriptIfEnabled(parsedPayload, apiKey, autoFetch);
+    const context = buildHandlerContext({
+      payload: parsedPayload,
+      apiKey,
+      transcript
+    });
+    await executeHandlers(context, options);
+    return {
+      success: true,
+      statusCode: 200,
+      body: "ok",
+      payload: parsedPayload
+    };
+  } catch (error) {
+    if (onError && error instanceof Error) {
+      await onError(error, parsedPayload);
+    }
+    return mapErrorToResponse(error);
+  }
+}
+
+// src/middleware/fastify.ts
+function createWebhookHandler(options) {
+  validateOptions(options);
+  return async (request, reply) => {
+    const rawBody = request.body;
+    const signature = request.headers["x-hub-signature"];
+    const result = await processWebhook(
+      {
+        rawBody,
+        signature
+      },
+      options
+    );
+    reply.status(result.statusCode).send(result.body);
+  };
+}
+var firefliesWebhook = (fastify, options, done) => {
+  validateOptions(options);
+  const { path = "/webhooks/fireflies", ...webhookOptions } = options;
+  fastify.addContentTypeParser("application/json", { parseAs: "buffer" }, (_req, body, done2) => {
+    done2(null, body);
+  });
+  fastify.post(path, createWebhookHandler(webhookOptions));
+  done();
+};
+
+export { createWebhookHandler, firefliesWebhook };
+//# sourceMappingURL=fastify.js.map
+//# sourceMappingURL=fastify.js.map