@speakableio/core 1.0.59 → 1.0.60

package/dist/index.native.js

@@ -0,0 +1,3900 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/entry-points/index.native.ts
+var index_native_exports = {};
+__export(index_native_exports, {
+  ActivityPageType: () => ActivityPageType,
+  BASE_MULTIPLE_CHOICE_FIELD_VALUES: () => BASE_MULTIPLE_CHOICE_FIELD_VALUES,
+  BASE_REPEAT_FIELD_VALUES: () => BASE_REPEAT_FIELD_VALUES,
+  BASE_RESPOND_FIELD_VALUES: () => BASE_RESPOND_FIELD_VALUES,
+  CONVERSATION_PAGE_ACTIVITY_TYPES: () => CONVERSATION_PAGE_ACTIVITY_TYPES,
+  ConversationPageMode: () => ConversationPageMode,
+  FeedbackTypesCard: () => FeedbackTypesCard,
+  FsCtx: () => FsCtx,
+  LENIENCY_OPTIONS: () => LENIENCY_OPTIONS,
+  LeniencyCard: () => LeniencyCard,
+  MULTIPLE_CHOICE_PAGE_ACTIVITY_TYPES: () => MULTIPLE_CHOICE_PAGE_ACTIVITY_TYPES,
+  REPEAT_PAGE_ACTIVITY_TYPES: () => REPEAT_PAGE_ACTIVITY_TYPES,
+  RESPOND_AUDIO_PAGE_ACTIVITY_TYPES: () => RESPOND_AUDIO_PAGE_ACTIVITY_TYPES,
+  RESPOND_PAGE_ACTIVITY_TYPES: () => RESPOND_PAGE_ACTIVITY_TYPES,
+  RESPOND_WRITE_PAGE_ACTIVITY_TYPES: () => RESPOND_WRITE_PAGE_ACTIVITY_TYPES,
+  SPEAKABLE_ANALYTICS: () => SPEAKABLE_ANALYTICS,
+  SPEAKABLE_NOTIFICATIONS: () => SPEAKABLE_NOTIFICATIONS,
+  STUDENT_LEVELS_OPTIONS: () => STUDENT_LEVELS_OPTIONS,
+  SpeakableNotificationTypes: () => SpeakableNotificationTypes,
+  SpeakableProvider: () => SpeakableProvider,
+  VerificationCardStatus: () => VerificationCardStatus,
+  assignmentQueryKeys: () => assignmentQueryKeys,
+  cardsQueryKeys: () => cardsQueryKeys,
+  checkIsConversationPage: () => checkIsConversationPage,
+  checkIsMCPage: () => checkIsMCPage,
+  checkIsMediaPage: () => checkIsMediaPage,
+  checkIsRepeatPage: () => checkIsRepeatPage,
+  checkIsRespondAudioPage: () => checkIsRespondAudioPage,
+  checkIsRespondPage: () => checkIsRespondPage,
+  checkIsRespondWrittenPage: () => checkIsRespondWrittenPage,
+  checkIsShortAnswerPage: () => checkIsShortAnswerPage,
+  checkTypePageActivity: () => checkTypePageActivity,
+  cleanString: () => cleanString,
+  createAssignmentRepo: () => createAssignmentRepo,
+  createCardRepo: () => createCardRepo,
+  createFsClient: () => createFsClientNative,
+  createSetRepo: () => createSetRepo,
+  creditQueryKeys: () => creditQueryKeys,
+  debounce: () => debounce,
+  getCardFromCache: () => getCardFromCache,
+  getLabelPage: () => getLabelPage,
+  getPageMediaData: () => getPageMediaData,
+  getPagePrompt: () => getPagePrompt,
+  getPhraseLength: () => getPhraseLength,
+  getRespondCardTool: () => getRespondCardTool,
+  getSetFromCache: () => getSetFromCache,
+  getSingleMediaPageData: () => getSingleMediaPageData,
+  getTotalCompletedCards: () => getTotalCompletedCards,
+  getTranscript: () => getTranscript,
+  getTranscriptCycle: () => getTranscriptCycle,
+  getWordHash: () => getWordHash,
+  purify: () => purify,
+  refsCardsFiresotre: () => refsCardsFiresotre,
+  refsSetsFirestore: () => refsSetsFirestore,
+  scoreQueryKeys: () => scoreQueryKeys,
+  setsQueryKeys: () => setsQueryKeys,
+  updateCardInCache: () => updateCardInCache,
+  updateSetInCache: () => updateSetInCache,
+  useActivity: () => useActivity,
+  useActivityFeedbackAccess: () => useActivityFeedbackAccess,
+  useAssignment: () => useAssignment,
+  useBaseOpenAI: () => useBaseOpenAI,
+  useCards: () => useCards,
+  useClearScore: () => useClearScore,
+  useClearScoreV2: () => useClearScoreV2,
+  useCreateCard: () => useCreateCard,
+  useCreateCards: () => useCreateCards,
+  useCreateNotification: () => useCreateNotification,
+  useGetCard: () => useGetCard,
+  useOrganizationAccess: () => useOrganizationAccess,
+  useScore: () => useScore,
+  useSet: () => useSet,
+  useSpeakableApi: () => useSpeakableApi,
+  useSpeakableTranscript: () => useSpeakableTranscript,
+  useSpeakableTranscriptCycle: () => useSpeakableTranscriptCycle,
+  useSubmitAssignmentScore: () => useSubmitAssignmentScore,
+  useSubmitPracticeScore: () => useSubmitPracticeScore,
+  useUpdateCardScore: () => useUpdateCardScore,
+  useUpdateScore: () => useUpdateScore,
+  useUpdateStudentVocab: () => useUpdateStudentVocab,
+  useUserCredits: () => useUserCredits
+});
+module.exports = __toCommonJS(index_native_exports);
+
+// src/providers/SpeakableProvider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var FsCtx = (0, import_react.createContext)(null);
+function SpeakableProvider({
+  user,
+  children,
+  queryClient,
+  permissions,
+  fsClient
+}) {
+  const [speakableApi, setSpeakableApi] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    setSpeakableApi(fsClient);
+  }, [fsClient]);
+  if (!speakableApi) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    FsCtx.Provider,
+    {
+      value: {
+        speakableApi,
+        queryClient,
+        user,
+        permissions
+      },
+      children
+    }
+  );
+}
+function useSpeakableApi() {
+  const ctx = (0, import_react.useContext)(FsCtx);
+  if (!ctx) throw new Error("useSpeakableApi must be used within a SpeakableProvider");
+  return ctx;
+}
+
+// src/utils/error-handler.ts
+var ServiceError = class extends Error {
+  constructor(message, originalError, code) {
+    super(message);
+    this.originalError = originalError;
+    this.code = code;
+    this.name = "ServiceError";
+  }
+};
+function withErrorHandler(fn, serviceName) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      console.error(`Service ${serviceName} failed with args:`, args);
+      console.error("Error details:", error);
+      if (error instanceof Error && "code" in error) {
+        const firebaseError = error;
+        throw new ServiceError(
+          `Error in ${serviceName}: ${firebaseError.message}`,
+          error,
+          firebaseError.code
+        );
+      }
+      if (error instanceof Error) {
+        throw new ServiceError(`Error in ${serviceName}: ${error.message}`, error);
+      }
+      throw new ServiceError(`Unknown error in ${serviceName}`, error);
+    }
+  };
+}
+
+// src/lib/firebase/api.ts
+var FirebaseAPI = class _FirebaseAPI {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+    this.config = null;
+  }
+  static getInstance() {
+    if (!_FirebaseAPI.instance) {
+      _FirebaseAPI.instance = new _FirebaseAPI();
+    }
+    return _FirebaseAPI.instance;
+  }
+  initialize(config) {
+    this.config = config;
+  }
+  get db() {
+    if (!this.config) throw new Error("Firebase API not initialized");
+    return this.config.db;
+  }
+  get helpers() {
+    if (!this.config) throw new Error("Firebase API not initialized");
+    return this.config.helpers;
+  }
+  get httpsCallable() {
+    var _a;
+    return (_a = this.config) == null ? void 0 : _a.httpsCallable;
+  }
+  logEvent(name, data) {
+    var _a;
+    (_a = this.config) == null ? void 0 : _a.logEvent(name, data);
+  }
+  accessQueryConstraints() {
+    const { query: query2, orderBy: orderBy2, limit: limit2, startAt: startAt2, startAfter: startAfter2, endAt: endAt2, endBefore: endBefore2, where: where2, increment: increment2 } = this.helpers;
+    return {
+      query: query2,
+      orderBy: orderBy2,
+      limit: limit2,
+      startAt: startAt2,
+      startAfter: startAfter2,
+      endAt: endAt2,
+      endBefore: endBefore2,
+      where: where2,
+      increment: increment2
+    };
+  }
+  accessHelpers() {
+    const { doc: doc2, collection: collection2, writeBatch: writeBatch2, serverTimestamp: serverTimestamp2, setDoc: setDoc2 } = this.helpers;
+    return {
+      doc: (path) => doc2(this.db, path),
+      collection: (path) => collection2(this.db, path),
+      writeBatch: () => writeBatch2(this.db),
+      serverTimestamp: serverTimestamp2,
+      setDoc: setDoc2
+    };
+  }
+  async getDoc(path) {
+    const { getDoc: getDoc2, doc: doc2 } = this.helpers;
+    const docRef = doc2(this.db, path);
+    const docSnap = await getDoc2(docRef);
+    const data = docSnap.exists() ? {
+      ...docSnap.data(),
+      id: docSnap.id
+    } : null;
+    return {
+      id: docSnap.id,
+      data
+    };
+  }
+  async getDocs(path, ...queryConstraints) {
+    const { getDocs: getDocs2, query: query2, collection: collection2 } = this.helpers;
+    const collectionRef = collection2(this.db, path);
+    const q = queryConstraints.length > 0 ? query2(collectionRef, ...queryConstraints) : collectionRef;
+    const querySnapshot = await getDocs2(q);
+    const data = querySnapshot.docs.map((doc2) => ({
+      data: doc2.data(),
+      id: doc2.id
+    }));
+    return {
+      data,
+      querySnapshot,
+      empty: querySnapshot.empty
+    };
+  }
+  async addDoc(path, data) {
+    const { addDoc: addDoc2, collection: collection2 } = this.helpers;
+    const collectionRef = collection2(this.db, path);
+    const docRef = await addDoc2(collectionRef, data);
+    return {
+      ...data,
+      id: docRef.id
+    };
+  }
+  async setDoc(path, data, options = {}) {
+    const { setDoc: setDoc2, doc: doc2 } = this.helpers;
+    const docRef = doc2(this.db, path);
+    await setDoc2(docRef, data, options);
+  }
+  async updateDoc(path, data) {
+    const { updateDoc: updateDoc2, doc: doc2 } = this.helpers;
+    const docRef = doc2(this.db, path);
+    await updateDoc2(docRef, data);
+  }
+  async deleteDoc(path) {
+    const { deleteDoc: deleteDoc2, doc: doc2 } = this.helpers;
+    const docRef = doc2(this.db, path);
+    await deleteDoc2(docRef);
+  }
+  async runTransaction(updateFunction) {
+    const { runTransaction: runTransaction2 } = this.helpers;
+    return runTransaction2(this.db, updateFunction);
+  }
+  async runBatch(operations) {
+    const { writeBatch: writeBatch2 } = this.helpers;
+    const batch = writeBatch2(this.db);
+    await Promise.all(operations.map((op) => op()));
+    await batch.commit();
+  }
+  writeBatch() {
+    const { writeBatch: writeBatch2 } = this.helpers;
+    const batch = writeBatch2(this.db);
+    return batch;
+  }
+};
+var api = FirebaseAPI.getInstance();
+
+// src/domains/assignment/assignment.constants.ts
+var ASSIGNMENT_ANALYTICS_TYPES = [
+  "macro" /* Macro */,
+  "gradebook" /* Gradebook */,
+  "cards" /* Cards */,
+  "student" /* Student */,
+  "student_summary" /* StudentSummary */
+];
+var ASSIGNMENTS_COLLECTION = "assignments";
+var ANALYTICS_SUBCOLLECTION = "analytics";
+var SCORES_SUBCOLLECTION = "scores";
+var refsAssignmentFiresotre = {
+  allAssignments: () => ASSIGNMENTS_COLLECTION,
+  assignment: (params) => `${ASSIGNMENTS_COLLECTION}/${params.id}`,
+  assignmentAllAnalytics: (params) => `${ASSIGNMENTS_COLLECTION}/${params.id}/${ANALYTICS_SUBCOLLECTION}`,
+  assignmentAnalytics: (params) => `${ASSIGNMENTS_COLLECTION}/${params.id}/${ANALYTICS_SUBCOLLECTION}/${params.type}`,
+  assignmentScores: (params) => `${ASSIGNMENTS_COLLECTION}/${params.id}/${SCORES_SUBCOLLECTION}/${params.userId}`
+};
+
+// src/domains/assignment/services/get-assignments-score.service.ts
+var _getAssignmentScores = async ({
+  assignmentId,
+  analyticType = "macro" /* Macro */,
+  studentId,
+  currentUserId
+}) => {
+  if (analyticType === "student" /* Student */) {
+    const path = refsAssignmentFiresotre.assignmentScores({
+      id: assignmentId,
+      userId: currentUserId
+    });
+    const response = await api.getDoc(path);
+    return { scores: response.data, id: assignmentId };
+  }
+  if (analyticType === "student_summary" /* StudentSummary */ && studentId) {
+    const path = refsAssignmentFiresotre.assignmentScores({
+      id: assignmentId,
+      userId: studentId
+    });
+    const response = await api.getDoc(path);
+    return { scores: response.data, id: assignmentId };
+  }
+  if (analyticType !== "all" /* All */ && ASSIGNMENT_ANALYTICS_TYPES.includes(analyticType)) {
+    const ref = refsAssignmentFiresotre.assignmentAnalytics({
+      id: assignmentId,
+      type: analyticType
+    });
+    const docData = await api.getDoc(ref);
+    return { scores: docData.data, id: assignmentId };
+  } else if (analyticType === "all" /* All */) {
+    const ref = refsAssignmentFiresotre.assignmentAllAnalytics({ id: assignmentId });
+    const response = await api.getDocs(ref);
+    const data = response.data.reduce((acc, curr) => {
+      acc[curr.id] = curr;
+      return acc;
+    }, {});
+    return { scores: data, id: assignmentId };
+  }
+};
+var getAssignmentScores = withErrorHandler(_getAssignmentScores, "getAssignmentScores");
+
+// src/domains/assignment/services/attach-score-assignment.service.ts
+var _attachScoresAssignment = async ({
+  assignments,
+  analyticType,
+  studentId,
+  currentUserId
+}) => {
+  const scoresPromises = assignments.map((a) => {
+    return getAssignmentScores({
+      assignmentId: a.id,
+      analyticType,
+      studentId,
+      currentUserId
+    });
+  });
+  const scores = await Promise.all(scoresPromises);
+  const scoresObject = scores.reduce((acc, curr) => {
+    acc[curr.id] = curr.scores;
+    return acc;
+  }, {});
+  const assignmentsWithScores = assignments.map((a) => {
+    var _a;
+    return {
+      ...a,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      scores: (_a = scoresObject[a.id]) != null ? _a : null
+    };
+  });
+  return assignmentsWithScores;
+};
+var attachScoresAssignment = withErrorHandler(
+  _attachScoresAssignment,
+  "attachScoresAssignment"
+);
+
+// src/domains/assignment/services/get-all-assignment.service.ts
+async function _getAllAssignments() {
+  const path = refsAssignmentFiresotre.allAssignments();
+  const response = await api.getDocs(path);
+  return response.data;
+}
+var getAllAssignments = withErrorHandler(_getAllAssignments, "getAllAssignments");
+
+// src/domains/assignment/utils/check-assignment-availability.ts
+var import_dayjs = __toESM(require("dayjs"));
+var checkAssignmentAvailability = (scheduledTime) => {
+  if (!scheduledTime) return true;
+  const scheduledDate = typeof scheduledTime === "string" ? (0, import_dayjs.default)(scheduledTime) : (0, import_dayjs.default)(scheduledTime.toDate());
+  if (!scheduledDate.isValid()) return true;
+  return (0, import_dayjs.default)().isAfter(scheduledDate);
+};
+
+// src/domains/assignment/services/get-assignment.service.ts
+async function _getAssignment(params) {
+  var _a;
+  const path = refsAssignmentFiresotre.assignment({ id: params.assignmentId });
+  const response = await api.getDoc(path);
+  if (!response.data) return null;
+  const assignment = response.data;
+  const isAvailable = checkAssignmentAvailability(assignment.scheduledTime);
+  const assignmentWithId = {
+    ...assignment,
+    isAvailable,
+    id: params.assignmentId,
+    scheduledTime: (_a = assignment.scheduledTime) != null ? _a : null
+  };
+  if (params.analyticType) {
+    const assignmentsWithScores = await attachScoresAssignment({
+      assignments: [assignmentWithId],
+      analyticType: params.analyticType,
+      currentUserId: params.currentUserId
+    });
+    return assignmentsWithScores.length > 0 ? assignmentsWithScores[0] : assignmentWithId;
+  }
+  return assignmentWithId;
+}
+var getAssignment = withErrorHandler(_getAssignment, "getAssignment");
+
+// src/domains/assignment/assignment.repo.ts
+var createAssignmentRepo = () => {
+  return {
+    getAssignment,
+    attachScoresAssignment,
+    getAssignmentScores,
+    getAllAssignments
+  };
+};
+
+// src/domains/assignment/hooks/assignment.hooks.ts
+var import_react_query = require("@tanstack/react-query");
+var assignmentQueryKeys = {
+  all: ["assignments"],
+  byId: (id) => [...assignmentQueryKeys.all, id],
+  list: () => [...assignmentQueryKeys.all, "list"]
+};
+function useAssignment({
+  assignmentId,
+  enabled = true,
+  analyticType,
+  userId
+}) {
+  const { speakableApi } = useSpeakableApi();
+  return (0, import_react_query.useQuery)({
+    queryKey: assignmentQueryKeys.byId(assignmentId),
+    queryFn: () => speakableApi.assignmentRepo.getAssignment({
+      assignmentId,
+      analyticType,
+      currentUserId: userId
+    }),
+    enabled
+  });
+}
+
+// src/domains/assignment/hooks/score-hooks.ts
+var import_react_query2 = require("@tanstack/react-query");
+
+// src/utils/debounce.utils.ts
+function debounce(func, waitFor) {
+  let timeoutId;
+  return (...args) => new Promise((resolve, reject) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(async () => {
+      try {
+        const result = await func(...args);
+        resolve(result);
+      } catch (error) {
+        reject(error);
+      }
+    }, waitFor);
+  });
+}
+
+// src/lib/tanstack/handle-optimistic-update-query.ts
+var handleOptimisticUpdate = async ({
+  queryClient,
+  queryKey,
+  newData
+}) => {
+  await queryClient.cancelQueries({
+    queryKey
+  });
+  const previousData = queryClient.getQueryData(queryKey);
+  if (previousData === void 0) {
+    queryClient.setQueryData(queryKey, newData);
+  } else {
+    queryClient.setQueryData(queryKey, { ...previousData, ...newData });
+  }
+  return { previousData };
+};
+
+// src/constants/speakable-plans.ts
+var FEEDBACK_PLANS = {
+  FEEDBACK_TRANSCRIPT: "FEEDBACK_TRANSCRIPT",
+  // Transcript from the audio
+  FEEDBACK_SUMMARY: "FEEDBACK_SUMMARY",
+  // Chatty summary (Free plan)
+  FEEDBACK_GRAMMAR_INSIGHTS: "FEEDBACK_GRAMMAR_INSIGHTS",
+  // Grammar insights
+  FEEDBACK_SUGGESTED_RESPONSE: "FEEDBACK_SUGGESTED_RESPONSE",
+  // Suggested Response
+  FEEDBACK_RUBRIC: "FEEDBACK_RUBRIC",
+  // Suggested Response
+  FEEDBACK_GRADING_STANDARDS: "FEEDBACK_GRADING_STANDARDS",
+  // ACTFL / WIDA Estimate
+  FEEDBACK_TARGET_LANGUAGE: "FEEDBACK_TARGET_LANGUAGE",
+  // Ability to set the feedback language to the target language of the student
+  FEEDBACK_DISABLE_ALLOW_RETRIES: "FEEDBACK_DISABLE_ALLOW_RETRIES"
+  // Turn of allow retries
+};
+var AUTO_GRADING_PLANS = {
+  AUTO_GRADING_PASS_FAIL: "AUTO_GRADING_PASS_FAIL",
+  // Pass / fail grading
+  AUTO_GRADING_RUBRICS: "AUTO_GRADING_RUBRICS",
+  // Autograded rubrics
+  AUTO_GRADING_STANDARDS_BASED: "AUTO_GRADING_STANDARDS_BASED"
+  // Standards based grading
+};
+var AI_ASSISTANT_PLANS = {
+  AI_ASSISTANT_DOCUMENT_UPLOADS: "AI_ASSISTANT_DOCUMENT_UPLOADS",
+  // Allow document uploading
+  AI_ASSISTANT_UNLIMITED_USE: "AI_ASSISTANT_UNLIMITED_USE"
+  // Allow unlimited use of AI assistant. Otherwise, limits are used.
+};
+var ASSIGNMENT_SETTINGS_PLANS = {
+  ASSESSMENTS: "ASSESSMENTS",
+  // Ability to create assessment assignment types
+  GOOGLE_CLASSROOM_GRADE_PASSBACK: "GOOGLE_CLASSROOM_GRADE_PASSBACK"
+  // Assignment scores can sync with classroom
+};
+var ANALYTICS_PLANS = {
+  ANALYTICS_GRADEBOOK: "ANALYTICS_GRADEBOOK",
+  // Access to the gradebook page
+  ANALYTICS_CLASSROOM_ANALYTICS: "ANALYTICS_CLASSROOM_ANALYTICS",
+  // Access to the classroom analytics page
+  ANALYTICS_STUDENT_PROGRESS_REPORTS: "ANALYTICS_STUDENT_PROGRESS_REPORTS",
+  // Access to the panel that shows an individual student's progress and assignments
+  ANALYTICS_ASSIGNMENT_RESULTS: "ANALYTICS_ASSIGNMENT_RESULTS",
+  // Access to the assigment RESULTS page
+  ANALYTICS_ORGANIZATION: "ANALYTICS_ORGANIZATION"
+  // Access to the organization analytics panel (for permitted admins)
+};
+var SPACES_PLANS = {
+  SPACES_CREATE_SPACE: "SPACES_CREATE_SPACE",
+  // Ability to create spaces
+  SPACES_CHECK_POINTS: "SPACES_CHECK_POINTS"
+  // Feature not available yet. Ability to create checkpoints for spaces for data aggregation
+};
+var DISCOVER_PLANS = {
+  DISCOVER_ORGANIZATION_LIBRARY: "DISCOVER_ORGANIZATION_LIBRARY"
+  // Access to the organizations shared library
+};
+var MEDIA_AREA_PLANS = {
+  MEDIA_AREA_DOCUMENT_UPLOAD: "MEDIA_AREA_DOCUMENT_UPLOAD",
+  MEDIA_AREA_AUDIO_FILES: "MEDIA_AREA_AUDIO_FILES"
+};
+var FREE_PLAN = [];
+var TEACHER_PRO_PLAN = [
+  FEEDBACK_PLANS.FEEDBACK_TRANSCRIPT,
+  FEEDBACK_PLANS.FEEDBACK_SUMMARY,
+  FEEDBACK_PLANS.FEEDBACK_TARGET_LANGUAGE,
+  AUTO_GRADING_PLANS.AUTO_GRADING_PASS_FAIL,
+  ANALYTICS_PLANS.ANALYTICS_GRADEBOOK,
+  SPACES_PLANS.SPACES_CREATE_SPACE
+  // AUTO_GRADING_PLANS.AUTO_GRADING_STANDARDS_BASED,
+];
+var SCHOOL_STARTER = [
+  FEEDBACK_PLANS.FEEDBACK_TRANSCRIPT,
+  FEEDBACK_PLANS.FEEDBACK_SUMMARY,
+  FEEDBACK_PLANS.FEEDBACK_GRAMMAR_INSIGHTS,
+  FEEDBACK_PLANS.FEEDBACK_SUGGESTED_RESPONSE,
+  FEEDBACK_PLANS.FEEDBACK_RUBRIC,
+  FEEDBACK_PLANS.FEEDBACK_GRADING_STANDARDS,
+  FEEDBACK_PLANS.FEEDBACK_DISABLE_ALLOW_RETRIES,
+  FEEDBACK_PLANS.FEEDBACK_TARGET_LANGUAGE,
+  AUTO_GRADING_PLANS.AUTO_GRADING_PASS_FAIL,
+  AUTO_GRADING_PLANS.AUTO_GRADING_RUBRICS,
+  AUTO_GRADING_PLANS.AUTO_GRADING_STANDARDS_BASED,
+  AI_ASSISTANT_PLANS.AI_ASSISTANT_DOCUMENT_UPLOADS,
+  AI_ASSISTANT_PLANS.AI_ASSISTANT_UNLIMITED_USE,
+  // ASSIGNMENT_SETTINGS_PLANS.ASSESSMENTS,
+  ASSIGNMENT_SETTINGS_PLANS.GOOGLE_CLASSROOM_GRADE_PASSBACK,
+  ANALYTICS_PLANS.ANALYTICS_GRADEBOOK,
+  ANALYTICS_PLANS.ANALYTICS_STUDENT_PROGRESS_REPORTS,
+  ANALYTICS_PLANS.ANALYTICS_CLASSROOM_ANALYTICS,
+  // ANALYTICS_PLANS.ANALYTICS_ORGANIZATION,
+  SPACES_PLANS.SPACES_CREATE_SPACE,
+  SPACES_PLANS.SPACES_CHECK_POINTS,
+  // DISCOVER_PLANS.DISCOVER_ORGANIZATION_LIBRARY,
+  MEDIA_AREA_PLANS.MEDIA_AREA_DOCUMENT_UPLOAD,
+  MEDIA_AREA_PLANS.MEDIA_AREA_AUDIO_FILES
+];
+var ORGANIZATION_PLAN = [
+  FEEDBACK_PLANS.FEEDBACK_TRANSCRIPT,
+  FEEDBACK_PLANS.FEEDBACK_SUMMARY,
+  FEEDBACK_PLANS.FEEDBACK_GRAMMAR_INSIGHTS,
+  FEEDBACK_PLANS.FEEDBACK_SUGGESTED_RESPONSE,
+  FEEDBACK_PLANS.FEEDBACK_RUBRIC,
+  FEEDBACK_PLANS.FEEDBACK_GRADING_STANDARDS,
+  FEEDBACK_PLANS.FEEDBACK_DISABLE_ALLOW_RETRIES,
+  FEEDBACK_PLANS.FEEDBACK_TARGET_LANGUAGE,
+  AUTO_GRADING_PLANS.AUTO_GRADING_PASS_FAIL,
+  AUTO_GRADING_PLANS.AUTO_GRADING_RUBRICS,
+  AUTO_GRADING_PLANS.AUTO_GRADING_STANDARDS_BASED,
+  AI_ASSISTANT_PLANS.AI_ASSISTANT_DOCUMENT_UPLOADS,
+  AI_ASSISTANT_PLANS.AI_ASSISTANT_UNLIMITED_USE,
+  ASSIGNMENT_SETTINGS_PLANS.ASSESSMENTS,
+  ASSIGNMENT_SETTINGS_PLANS.GOOGLE_CLASSROOM_GRADE_PASSBACK,
+  ANALYTICS_PLANS.ANALYTICS_GRADEBOOK,
+  ANALYTICS_PLANS.ANALYTICS_STUDENT_PROGRESS_REPORTS,
+  ANALYTICS_PLANS.ANALYTICS_CLASSROOM_ANALYTICS,
+  ANALYTICS_PLANS.ANALYTICS_ORGANIZATION,
+  SPACES_PLANS.SPACES_CREATE_SPACE,
+  SPACES_PLANS.SPACES_CHECK_POINTS,
+  DISCOVER_PLANS.DISCOVER_ORGANIZATION_LIBRARY,
+  MEDIA_AREA_PLANS.MEDIA_AREA_DOCUMENT_UPLOAD,
+  MEDIA_AREA_PLANS.MEDIA_AREA_AUDIO_FILES
+];
+var SpeakablePlanTypes = {
+  basic: "basic",
+  teacher_pro: "teacher_pro",
+  school_starter: "school_starter",
+  organization: "organization",
+  // OLD PLANS
+  starter: "starter",
+  growth: "growth",
+  professional: "professional"
+};
+var SpeakablePermissionsMap = {
+  [SpeakablePlanTypes.basic]: FREE_PLAN,
+  [SpeakablePlanTypes.starter]: TEACHER_PRO_PLAN,
+  [SpeakablePlanTypes.teacher_pro]: TEACHER_PRO_PLAN,
+  [SpeakablePlanTypes.growth]: ORGANIZATION_PLAN,
+  [SpeakablePlanTypes.professional]: ORGANIZATION_PLAN,
+  [SpeakablePlanTypes.organization]: ORGANIZATION_PLAN,
+  [SpeakablePlanTypes.school_starter]: SCHOOL_STARTER
+};
+var SpeakablePlanHierarchy = [
+  SpeakablePlanTypes.basic,
+  SpeakablePlanTypes.starter,
+  SpeakablePlanTypes.teacher_pro,
+  SpeakablePlanTypes.growth,
+  SpeakablePlanTypes.professional,
+  SpeakablePlanTypes.school_starter,
+  SpeakablePlanTypes.organization
+];
+
+// src/hooks/usePermissions.ts
+var usePermissions = () => {
+  const { permissions } = useSpeakableApi();
+  const has = (permission) => {
+    var _a;
+    return (_a = permissions.permissions) == null ? void 0 : _a.includes(permission);
+  };
+  return {
+    plan: permissions.plan,
+    permissionsLoaded: permissions.loaded,
+    isStripePlan: permissions.isStripePlan,
+    refreshDate: permissions.refreshDate,
+    isInstitutionPlan: permissions.isInstitutionPlan,
+    subscriptionId: permissions.subscriptionId,
+    contact: permissions.contact,
+    hasGradebook: has(ANALYTICS_PLANS.ANALYTICS_GRADEBOOK),
+    hasGoogleClassroomGradePassback: has(ASSIGNMENT_SETTINGS_PLANS.GOOGLE_CLASSROOM_GRADE_PASSBACK),
+    hasAssessments: has(ASSIGNMENT_SETTINGS_PLANS.ASSESSMENTS),
+    hasSectionAnalytics: has(ANALYTICS_PLANS.ANALYTICS_CLASSROOM_ANALYTICS),
+    hasStudentReports: has(ANALYTICS_PLANS.ANALYTICS_STUDENT_PROGRESS_REPORTS),
+    permissions: permissions || [],
+    hasStudentPortfolios: permissions.hasStudentPortfolios,
+    isFreeOrgTrial: permissions.type === "free_org_trial",
+    freeOrgTrialExpired: permissions.freeOrgTrialExpired
+  };
+};
+var usePermissions_default = usePermissions;
+
+// src/domains/notification/notification.constants.ts
+var SPEAKABLE_NOTIFICATIONS = {
+  NEW_ASSIGNMENT: "new_assignment",
+  ASSESSMENT_SUBMITTED: "assessment_submitted",
+  ASSESSMENT_SCORED: "assessment_scored",
+  NEW_COMMENT: "NEW_COMMENT"
+};
+var SpeakableNotificationTypes = {
+  NEW_ASSIGNMENT: "NEW_ASSIGNMENT",
+  FEEDBACK_FROM_TEACHER: "FEEDBACK_FROM_TEACHER",
+  MESSAGE_FROM_STUDENT: "MESSAGE_FROM_STUDENT",
+  PHRASE_MARKED_CORRECT: "PHRASE_MARKED_CORRECT",
+  STUDENT_PROGRESS: "STUDENT_PROGRESS",
+  PLAYLIST_FOLLOWERS: "PLAYLIST_FOLLOWERS",
+  PLAYLIST_PLAYS: "PLAYLIST_PLAYS",
+  // New notifications
+  ASSESSMENT_SUBMITTED: "ASSESSMENT_SUBMITTED",
+  // Notification FOR TEACHER when student submits assessment
+  ASSESSMENT_SCORED: "ASSESSMENT_SCORED",
+  // Notification FOR STUDENT when teacher scores assessment
+  // Comment
+  NEW_COMMENT: "NEW_COMMENT"
+};
+
+// src/domains/notification/services/create-notification.service.ts
+var import_dayjs2 = __toESM(require("dayjs"));
+
+// src/constants/web.constants.ts
+var WEB_BASE_URL = "https://app.speakable.io";
+
+// src/domains/notification/services/send-notification.service.ts
+var _sendNotification = async (sendTo, notification) => {
+  var _a, _b, _c;
+  const results = await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "createNotificationV2")) == null ? void 0 : _c({
+    sendTo,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    notification
+  }));
+  return results;
+};
+var sendNotification = withErrorHandler(_sendNotification, "sendNotification");
+
+// src/domains/notification/services/create-notification.service.ts
+var createNotification = async ({
+  data,
+  type,
+  userId,
+  profile
+}) => {
+  let result;
+  switch (type) {
+    case SPEAKABLE_NOTIFICATIONS.NEW_ASSIGNMENT:
+      result = await handleAssignNotifPromise({ data, profile });
+      break;
+    case SPEAKABLE_NOTIFICATIONS.ASSESSMENT_SUBMITTED:
+      result = await createAssessmentSubmissionNotification({
+        data,
+        profile,
+        userId
+      });
+      break;
+    case SPEAKABLE_NOTIFICATIONS.ASSESSMENT_SCORED:
+      result = await createAssessmentScoredNotification({
+        data,
+        profile
+      });
+      break;
+    default:
+      result = null;
+      break;
+  }
+  return result;
+};
+var handleAssignNotifPromise = async ({
+  data: assignments,
+  profile
+}) => {
+  if (!assignments.length) return;
+  try {
+    const notifsPromises = assignments.map(async (assignment) => {
+      const {
+        section,
+        section: { members },
+        ...rest
+      } = assignment;
+      if (!section || !members) throw new Error("Invalid assignment data");
+      const data = { section, sendTo: members, assignment: { ...rest } };
+      return createNewAssignmentNotification({ data, profile });
+    });
+    await Promise.all(notifsPromises);
+    return {
+      success: true,
+      message: "Assignment notifications sent successfully"
+    };
+  } catch (error) {
+    console.error("Error in handleAssignNotifPromise:", error);
+    throw error;
+  }
+};
+var createNewAssignmentNotification = async ({
+  data,
+  profile
+}) => {
+  var _a;
+  const { assignment, sendTo } = data;
+  const teacherName = profile.displayName || "Your teacher";
+  const dueDate = assignment.dueDateTimestamp ? (0, import_dayjs2.default)(assignment.dueDateTimestamp.toDate()).format("MMM Do") : null;
+  const results = await sendNotification(sendTo, {
+    courseId: assignment.courseId,
+    type: SPEAKABLE_NOTIFICATIONS.NEW_ASSIGNMENT,
+    senderName: teacherName,
+    link: `${WEB_BASE_URL}/assignment/${assignment.id}`,
+    messagePreview: `A new assignment "${assignment.name}" is now available. ${dueDate ? `Due ${dueDate}` : ""}`,
+    title: "New Assignment Available!",
+    imageUrl: (_a = profile.image) == null ? void 0 : _a.url
+  });
+  return results;
+};
+var createAssessmentSubmissionNotification = async ({
+  data: assignment,
+  profile,
+  userId
+}) => {
+  var _a;
+  const studentName = profile.displayName || "Your student";
+  const results = await sendNotification(assignment.owners, {
+    courseId: assignment.courseId,
+    type: SPEAKABLE_NOTIFICATIONS.ASSESSMENT_SUBMITTED,
+    link: `${WEB_BASE_URL}/a/${assignment.id}?studentId=${userId}`,
+    title: `Assessment Submitted!`,
+    senderName: studentName,
+    messagePreview: `${studentName} has submitted the assessment "${assignment.name}"`,
+    imageUrl: (_a = profile.image) == null ? void 0 : _a.url
+  });
+  return results;
+};
+var createAssessmentScoredNotification = async ({
+  data,
+  profile
+}) => {
+  var _a, _b, _c, _d, _e;
+  const { assignment, sendTo } = data;
+  const teacherName = profile.displayName || "Your teacher";
+  const title = `${assignment.isAssessment ? "Assessment" : "Assignment"} Reviewed!`;
+  const messagePreview = `Your ${assignment.isAssessment ? "assessment" : "assignment"} has been reviewed by your teacher. Click to view the feedback.`;
+  const results = await sendNotification(sendTo, {
+    courseId: assignment.courseId,
+    type: SPEAKABLE_NOTIFICATIONS.ASSESSMENT_SCORED,
+    link: `${WEB_BASE_URL}/assignment/${assignment.id}`,
+    title,
+    messagePreview,
+    imageUrl: (_a = profile.image) == null ? void 0 : _a.url,
+    senderName: teacherName
+  });
+  await ((_e = (_c = (_b = api).httpsCallable) == null ? void 0 : _c.call(_b, "sendAssessmentScoredEmail")) == null ? void 0 : _e({
+    assessmentTitle: assignment.name,
+    link: `${WEB_BASE_URL}/assignment/${assignment.id}`,
+    senderImage: ((_d = profile.image) == null ? void 0 : _d.url) || "",
+    studentId: sendTo[0],
+    teacherName: profile.displayName
+  }));
+  return results;
+};
+
+// src/domains/notification/hooks/notification.hooks.ts
+var notificationQueryKeys = {
+  all: ["notifications"],
+  byId: (id) => [...notificationQueryKeys.all, id]
+};
+var useCreateNotification = () => {
+  const { user, queryClient } = useSpeakableApi();
+  const handleCreateNotifications = async (type, data) => {
+    var _a, _b;
+    const result = await createNotification({
+      type,
+      userId: user.auth.uid,
+      profile: (_a = user == null ? void 0 : user.profile) != null ? _a : {},
+      data
+    });
+    queryClient.invalidateQueries({
+      queryKey: notificationQueryKeys.byId((_b = user == null ? void 0 : user.auth.uid) != null ? _b : "")
+    });
+    return result;
+  };
+  return {
+    createNotification: handleCreateNotifications
+  };
+};
+
+// src/hooks/useGoogleClassroom.ts
+var useGoogleClassroom = () => {
+  const submitAssignmentToGoogleClassroom = async ({
+    assignment,
+    scores,
+    googleUserId = null
+    // optional to override the user's googleUserId
+  }) => {
+    var _a, _b, _c;
+    try {
+      const { googleClassroomUserId = null } = scores;
+      const googleId = googleUserId || googleClassroomUserId;
+      if (!googleId)
+        return {
+          error: true,
+          message: "No Google Classroom ID found"
+        };
+      const { courseWorkId, maxPoints, owners, courseId } = assignment;
+      const draftGrade = (scores == null ? void 0 : scores.score) ? (scores == null ? void 0 : scores.score) / 100 * maxPoints : 0;
+      const result = await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "submitAssignmentToGoogleClassroomV2")) == null ? void 0 : _c({
+        teacherId: owners[0],
+        courseId,
+        courseWorkId,
+        userId: googleId,
+        draftGrade
+      }));
+      return result;
+    } catch (error) {
+      return { error: true, message: error.message };
+    }
+  };
+  return {
+    submitAssignmentToGoogleClassroom
+  };
+};
+
+// src/lib/firebase/firebase-analytics/grading-standard.ts
+var logGradingStandardLog = (data) => {
+  var _a, _b, _c;
+  if (data.courseId && data.type && data.level) {
+    (_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "handleCouresAnalyticsEvent")) == null ? void 0 : _c({
+      eventType: data.type || "custom",
+      level: data.level,
+      courseId: data.courseId
+    });
+  }
+  api.logEvent("logGradingStandard", data);
+};
+
+// src/constants/analytics.constants.ts
+var SPEAKABLE_ANALYTICS = {
+  VOICE_SUCCESS: "voice_success",
+  VOICE_FALLBACK_SUCCESS: "voice_fallback_success",
+  VOICE_FALLBACK_FAIL: "voice_fallback_fail",
+  VOICE_FAIL: "voice_fail",
+  RESPOND_CARD_SUCCESS: "respond_card_success",
+  RESPOND_CARD_FAIL: "respond_card_fail",
+  RESPOND_WRITE_CARD_SUCCESS: "respond_write_card_success",
+  RESPOND_WRITE_CARD_FAIL: "respond_write_card_fail",
+  RESPOND_WRITE_CARD_SUBMITTED: "respond_write_card_submitted",
+  RESPOND_WRITE_CARD_ERROR: "respond_write_card_error",
+  RESPOND_CARD_ERROR: "respond_card_error",
+  RESPOND_CARD_SUBMITTED: "respond_card_submitted",
+  RESPOND_FREE_PLAN: "respond_free_plan",
+  RESPOND_WRITE_FREE_PLAN: "respond_write_free_plan",
+  SUBMISSION: "assignment_submitted",
+  ASSIGNMENT_STARTED: "assignment_started",
+  CREATE_ASSIGNMENT: "create_assignment",
+  MC_SUCCESS: "multiple_choice_success",
+  MC_FAIL: "multiple_choice_fail",
+  MC_ERROR: "multiple_choice_error",
+  ACTFL_LEVEL: "actfl_level",
+  WIDA_LEVEL: "wida_level",
+  // New events
+  VIEW_SCORES_MODAL: "view_scores_modal",
+  SHORT_ANSWER_SUCCESS: "short_answer_success",
+  SHORT_ANSWER_FAIL: "short_answer_fail",
+  SHORT_ANSWER_ERROR: "short_answer_error",
+  RETRY: "retry",
+  MESSAGE_SENT: "message_sent",
+  MESSAGE_ERROR: "message_error",
+  VIEW_DETAILS_CLICK: "view_details_click",
+  TABS_CLICK: "tabs_click",
+  VIEW_MEDIA: "view_media",
+  VIEW_SCORES: "view_scores",
+  VIEW_GRADING_METHOD: "view_grading_method",
+  VIEW_FEEDBACK: "view_feedback"
+};
+
+// src/lib/firebase/firebase-analytics/assignment.ts
+var logOpenAssignment = (data = {}) => {
+  api.logEvent("open_assignment", data);
+};
+var logOpenActivityPreview = (data = {}) => {
+  api.logEvent("open_activity_preview", data);
+};
+var logSubmitAssignment = (data = {}) => {
+  var _a, _b, _c;
+  (_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "handleCouresAnalyticsEvent")) == null ? void 0 : _c({
+    eventType: SPEAKABLE_ANALYTICS.SUBMISSION,
+    ...data
+  });
+  api.logEvent(SPEAKABLE_ANALYTICS.SUBMISSION, data);
+};
+var logStartAssignment = (data = {}) => {
+  var _a, _b, _c;
+  if (data.courseId) {
+    (_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "handleCouresAnalyticsEvent")) == null ? void 0 : _c({
+      eventType: SPEAKABLE_ANALYTICS.ASSIGNMENT_STARTED,
+      ...data
+    });
+  }
+  api.logEvent(SPEAKABLE_ANALYTICS.ASSIGNMENT_STARTED, data);
+};
+
+// src/domains/assignment/utils/create-default-score.ts
+var defaultScore = (props) => {
+  const { serverTimestamp: serverTimestamp2 } = api.accessHelpers();
+  const score = {
+    progress: 0,
+    score: 0,
+    startDate: serverTimestamp2(),
+    status: "IN_PROGRESS",
+    submitted: false,
+    cards: {},
+    lastPlayed: serverTimestamp2(),
+    owners: props.owners,
+    userId: props.userId
+  };
+  if (props.googleClassroomUserId) {
+    score.googleClassroomUserId = props.googleClassroomUserId;
+  }
+  if (props.courseId) {
+    score.courseId = props.courseId;
+  }
+  return score;
+};
+
+// src/domains/assignment/score-practice.constants.ts
+var SCORES_PRACTICE_COLLECTION = "users";
+var SCORES_PRACTICE_SUBCOLLECTION = "practice";
+var refsScoresPractice = {
+  practiceScores: (params) => `${SCORES_PRACTICE_COLLECTION}/${params.userId}/${SCORES_PRACTICE_SUBCOLLECTION}/${params.setId}`,
+  practiceScoreHistoryRefDoc: (params) => `${SCORES_PRACTICE_COLLECTION}/${params.userId}/${SCORES_PRACTICE_SUBCOLLECTION}/${params.setId}/attempts/${params.date}`
+};
+
+// src/domains/assignment/services/create-score.service.ts
+var _updateAssignmentGradebookStatus = async ({
+  assignmentId,
+  userId,
+  status,
+  score
+}) => {
+  var _a, _b, _c;
+  await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "updateAssignmentGradebookStatus")) == null ? void 0 : _c({
+    assignmentId,
+    userId,
+    status,
+    score
+  }));
+};
+var updateAssignmentGradebookStatus = withErrorHandler(
+  _updateAssignmentGradebookStatus,
+  "updateAssignmentGradebookStatus"
+);
+async function _createScore(params) {
+  var _a, _b, _c;
+  if (params.isAssignment) {
+    const ref = refsAssignmentFiresotre.assignmentScores({
+      id: params.activityId,
+      userId: params.userId
+    });
+    await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "updateAssignmentGradebookStatus")) == null ? void 0 : _c({
+      assignmentId: params.activityId,
+      userId: params.userId,
+      status: "IN_PROGRESS",
+      score: null
+    }));
+    await api.setDoc(ref, params.scoreData, { merge: true });
+    await updateAssignmentGradebookStatus({
+      assignmentId: params.activityId,
+      userId: params.userId,
+      status: "IN_PROGRESS",
+      score: null
+    });
+    return {
+      id: params.userId
+    };
+  } else {
+    const ref = refsScoresPractice.practiceScores({
+      userId: params.userId,
+      setId: params.activityId
+    });
+    await api.setDoc(ref, params.scoreData);
+    return {
+      id: params.userId
+    };
+  }
+}
+var createScore = withErrorHandler(_createScore, "createScore");
+
+// src/domains/assignment/services/get-score.service.ts
+async function getAssignmentScore({
+  userId,
+  assignment,
+  googleClassroomUserId
+}) {
+  const path = refsAssignmentFiresotre.assignmentScores({
+    id: assignment.id,
+    userId
+  });
+  const response = await api.getDoc(path);
+  if (response.data == null) {
+    const newScore = {
+      ...defaultScore({
+        owners: [userId],
+        userId,
+        courseId: assignment.courseId,
+        googleClassroomUserId
+      }),
+      assignmentId: assignment.id
+    };
+    logStartAssignment({
+      courseId: assignment.courseId
+    });
+    const result = await createScore({
+      activityId: assignment.id,
+      userId,
+      isAssignment: true,
+      scoreData: newScore
+    });
+    return {
+      ...newScore,
+      id: result.id
+    };
+  }
+  if (response.data.cards == null) {
+    try {
+      await api.updateDoc(path, { cards: {} });
+    } catch (error) {
+      console.error("Error initializing score cards:", error);
+    }
+    return {
+      ...response.data,
+      cards: {}
+    };
+  }
+  return response.data;
+}
+async function getPracticeScore({ userId, setId }) {
+  const path = refsScoresPractice.practiceScores({ userId, setId });
+  const response = await api.getDoc(path);
+  if (response.data == null) {
+    const newScore = {
+      ...defaultScore({
+        owners: [userId],
+        userId
+      }),
+      setId
+    };
+    const result = await createScore({
+      activityId: setId,
+      userId,
+      isAssignment: false,
+      scoreData: newScore
+    });
+    return {
+      ...newScore,
+      id: result.id
+    };
+  }
+  return response.data;
+}
+async function _getScore(params) {
+  if (params.isAssignment) {
+    return await getAssignmentScore({
+      userId: params.userId,
+      assignment: {
+        id: params.activityId,
+        courseId: params.courseId
+      },
+      googleClassroomUserId: params.googleClassroomUserId
+    });
+  } else {
+    return await getPracticeScore({
+      userId: params.userId,
+      setId: params.activityId
+    });
+  }
+}
+var getScore = withErrorHandler(_getScore, "getScore");
+
+// src/domains/assignment/utils/calculateScoreAndProgress.ts
+var calculateScoreAndProgress = (scores, cardsList, weights) => {
+  const filteredScoreCards = Object.keys((scores == null ? void 0 : scores.cards) || {}).reduce(
+    (acc, cardId) => {
+      var _a;
+      const cardScores = (_a = scores == null ? void 0 : scores.cards) == null ? void 0 : _a[cardId];
+      if (cardScores && !cardScores.media_area_opened) {
+        acc[cardId] = cardScores;
+      }
+      return acc;
+    },
+    {}
+  );
+  const totalSetPoints = cardsList.reduce((acc, cardId) => {
+    acc += (weights == null ? void 0 : weights[cardId]) || 1;
+    return acc;
+  }, 0);
+  const totalPointsAwarded = Object.keys(filteredScoreCards).reduce((acc, cardId) => {
+    var _a;
+    const cardScores = filteredScoreCards[cardId];
+    if ((cardScores == null ? void 0 : cardScores.completed) || (cardScores == null ? void 0 : cardScores.score) || (cardScores == null ? void 0 : cardScores.score) === 0) {
+      const score2 = (cardScores == null ? void 0 : cardScores.score) || (cardScores == null ? void 0 : cardScores.score) === 0 ? Number((_a = cardScores == null ? void 0 : cardScores.score) != null ? _a : 0) : null;
+      const weight = (weights == null ? void 0 : weights[cardId]) || 1;
+      const fraction = (score2 != null ? score2 : 0) / 100;
+      if (score2 || score2 === 0) {
+        acc += weight * fraction;
+      } else {
+        acc += weight;
+      }
+    }
+    return acc;
+  }, 0);
+  const totalCompletedCards = Object.keys(filteredScoreCards).reduce((acc, cardId) => {
+    const cardScores = filteredScoreCards[cardId];
+    if ((cardScores == null ? void 0 : cardScores.completed) || (cardScores == null ? void 0 : cardScores.score) || (cardScores == null ? void 0 : cardScores.score) === 0) {
+      acc += 1;
+    }
+    return acc;
+  }, 0);
+  const percent = totalPointsAwarded / totalSetPoints;
+  const score = Math.round(percent * 100);
+  const progress = Math.round(totalCompletedCards / (cardsList.length || 1) * 100);
+  return { score, progress };
+};
+var calculateScoreAndProgress_default = calculateScoreAndProgress;
+
+// src/domains/assignment/services/update-score.service.ts
+async function _updateScore(params) {
+  const path = params.isAssignment ? refsAssignmentFiresotre.assignmentScores({
+    id: params.activityId,
+    userId: params.userId
+  }) : refsScoresPractice.practiceScores({
+    setId: params.activityId,
+    userId: params.userId
+  });
+  await api.updateDoc(path, {
+    ...params.data
+  });
+}
+var updateScore = withErrorHandler(_updateScore, "updateScore");
+async function _updateCardScore(params) {
+  const path = params.isAssignment ? refsAssignmentFiresotre.assignmentScores({
+    id: params.activityId,
+    userId: params.userId
+  }) : refsScoresPractice.practiceScores({
+    setId: params.activityId,
+    userId: params.userId
+  });
+  const updates = Object.keys(params.updates.cardScore).reduce(
+    (acc, key) => {
+      acc[`cards.${params.cardId}.${key}`] = params.updates.cardScore[key];
+      return acc;
+    },
+    {}
+  );
+  if (params.updates.progress) {
+    updates.progress = params.updates.progress;
+  }
+  if (params.updates.score) {
+    updates.score = params.updates.score;
+  }
+  await api.updateDoc(path, {
+    ...updates
+  });
+}
+var updateCardScore = withErrorHandler(_updateCardScore, "updateCardScore");
+
+// src/domains/assignment/services/clear-score.service.ts
+var import_dayjs3 = __toESM(require("dayjs"));
+async function clearScore(params) {
+  var _a, _b, _c, _d, _e;
+  const update = {
+    [`cards.${params.cardId}`]: {
+      attempts: ((_a = params.cardScores.attempts) != null ? _a : 1) + 1,
+      correct: (_b = params.cardScores.correct) != null ? _b : 0,
+      // save old score history
+      history: [
+        {
+          ...params.cardScores,
+          attempts: (_c = params.cardScores.attempts) != null ? _c : 1,
+          correct: (_d = params.cardScores.correct) != null ? _d : 0,
+          retryTime: (0, import_dayjs3.default)().format("YYYY-MM-DD HH:mm:ss"),
+          history: null
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        ...(_e = params.cardScores.history) != null ? _e : []
+      ]
+    }
+  };
+  const path = params.isAssignment ? refsAssignmentFiresotre.assignmentScores({
+    id: params.activityId,
+    userId: params.userId
+  }) : refsScoresPractice.practiceScores({
+    setId: params.activityId,
+    userId: params.userId
+  });
+  await api.updateDoc(path, update);
+  return {
+    update,
+    activityId: params.activityId
+  };
+}
+async function clearScoreV2(params) {
+  var _a, _b, _c, _d, _e;
+  const update = {
+    [`cards.${params.cardId}`]: {
+      ...params.cardScores,
+      attempts: ((_a = params.cardScores.attempts) != null ? _a : 1) + 1,
+      correct: (_b = params.cardScores.correct) != null ? _b : 0,
+      history: [
+        {
+          ...params.cardScores,
+          attempts: (_c = params.cardScores.attempts) != null ? _c : 1,
+          correct: (_d = params.cardScores.correct) != null ? _d : 0,
+          retryTime: (0, import_dayjs3.default)().format("YYYY-MM-DD HH:mm:ss"),
+          history: null
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        ...(_e = params.cardScores.history) != null ? _e : []
+      ]
+    }
+  };
+  const path = params.isAssignment ? refsAssignmentFiresotre.assignmentScores({
+    id: params.activityId,
+    userId: params.userId
+  }) : refsScoresPractice.practiceScores({
+    setId: params.activityId,
+    userId: params.userId
+  });
+  await api.updateDoc(path, update);
+  return {
+    update,
+    activityId: params.activityId
+  };
+}
+
+// src/domains/assignment/services/submit-assignment-score.service.ts
+var import_dayjs4 = __toESM(require("dayjs"));
+async function _submitAssignmentScore({
+  assignment,
+  userId,
+  status,
+  studentName
+}) {
+  const { serverTimestamp: serverTimestamp2 } = api.accessHelpers();
+  const path = refsAssignmentFiresotre.assignmentScores({ id: assignment.id, userId });
+  const fieldsUpdated = {
+    submitted: true,
+    progress: 100,
+    submissionDate: serverTimestamp2(),
+    status
+  };
+  if (assignment.isAssessment) {
+    const result = await handleAssessment(assignment, userId, fieldsUpdated, studentName);
+    return result;
+  } else if (assignment.courseId) {
+    await handleCourseAssignment(assignment, userId);
+  }
+  await api.updateDoc(path, { ...fieldsUpdated });
+  return { success: true, fieldsUpdated };
+}
+var submitAssignmentScore = withErrorHandler(
+  _submitAssignmentScore,
+  "submitAssignmentScore"
+);
+async function handleAssessment(assignment, userId, fieldsUpdated, studentName) {
+  var _a, _b, _c;
+  const path = refsAssignmentFiresotre.assignmentScores({ id: assignment.id, userId });
+  const response = await api.getDoc(path);
+  if (!response.data) {
+    throw new Error("Score not found");
+  }
+  await api.updateDoc(path, { status: "PENDING_REVIEW" });
+  await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "submitAssessment")) == null ? void 0 : _c({
+    assignmentId: assignment.id,
+    assignmentTitle: assignment.name,
+    userId,
+    teacherId: assignment.owners[0],
+    studentName
+  }));
+  fieldsUpdated.status = "PENDING_REVIEW";
+  return { success: true, fieldsUpdated };
+}
+async function handleCourseAssignment(assignment, userId) {
+  var _a, _b, _c;
+  await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "submitAssignmentV2")) == null ? void 0 : _c({
+    assignmentId: assignment.id,
+    userId
+  }));
+}
+async function submitPracticeScore({
+  setId,
+  userId,
+  scores
+}) {
+  const { serverTimestamp: serverTimestamp2 } = api.accessHelpers();
+  const date = (0, import_dayjs4.default)().format("YYYY-MM-DD-HH-mm");
+  const ref = refsScoresPractice.practiceScoreHistoryRefDoc({ setId, userId, date });
+  const fieldsUpdated = {
+    ...scores,
+    submitted: true,
+    progress: 100,
+    submissionDate: serverTimestamp2(),
+    status: "SUBMITTED"
+  };
+  await api.setDoc(ref, { ...fieldsUpdated });
+  const refScores = refsScoresPractice.practiceScores({ userId, setId });
+  await api.deleteDoc(refScores);
+  return { success: true, fieldsUpdated };
+}
+
+// src/domains/assignment/hooks/score-hooks.ts
+var scoreQueryKeys = {
+  all: ["scores"],
+  byId: (id) => [...scoreQueryKeys.all, id],
+  list: () => [...scoreQueryKeys.all, "list"]
+};
+function useScore({
+  isAssignment,
+  activityId,
+  userId = "",
+  courseId,
+  enabled = true,
+  googleClassroomUserId
+}) {
+  return (0, import_react_query2.useQuery)({
+    queryFn: () => getScore({
+      userId,
+      courseId,
+      activityId,
+      googleClassroomUserId,
+      isAssignment
+    }),
+    queryKey: scoreQueryKeys.byId(activityId),
+    enabled
+  });
+}
+var debounceUpdateScore = debounce(updateScore, 500);
+function useUpdateScore() {
+  const { queryClient } = useSpeakableApi();
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: debounceUpdateScore,
+    onMutate: (variables) => {
+      return handleOptimisticUpdate({
+        queryClient,
+        queryKey: scoreQueryKeys.byId(variables.activityId),
+        newData: variables.data
+      });
+    },
+    onError: (_, variables, context) => {
+      if (context == null ? void 0 : context.previousData)
+        queryClient.setQueryData(scoreQueryKeys.byId(variables.activityId), context.previousData);
+    },
+    onSettled: (_, err, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: scoreQueryKeys.byId(variables.activityId)
+      });
+    }
+  });
+  return {
+    mutationUpdateScore: mutation
+  };
+}
+function useUpdateCardScore({
+  isAssignment,
+  activityId,
+  userId,
+  cardIds,
+  weights
+}) {
+  const { queryClient } = useSpeakableApi();
+  const queryKey = scoreQueryKeys.byId(activityId);
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: async ({ cardId, cardScore }) => {
+      const previousScores = queryClient.getQueryData(queryKey);
+      const { progress, score, newScoreUpdated, updatedCardScore } = getScoreUpdated({
+        previousScores: previousScores != null ? previousScores : {},
+        cardId,
+        cardScore,
+        cardIds,
+        weights
+      });
+      await updateCardScore({
+        userId,
+        cardId,
+        isAssignment,
+        activityId,
+        updates: {
+          cardScore: updatedCardScore,
+          progress,
+          score
+        }
+      });
+      return { cardId, scoresUpdated: newScoreUpdated };
+    },
+    onMutate: ({ cardId, cardScore }) => {
+      const previousData = queryClient.getQueryData(queryKey);
+      queryClient.setQueryData(queryKey, (previousScore) => {
+        const updates = handleOptimisticScore({
+          score: previousScore,
+          cardId,
+          cardScore,
+          cardIds,
+          weights
+        });
+        return {
+          ...previousScore,
+          ...updates
+        };
+      });
+      return { previousData };
+    },
+    onError: (error, variables, context) => {
+      console.log("Error updating card score:", error.message);
+      if (context == null ? void 0 : context.previousData) {
+        queryClient.setQueryData(queryKey, context.previousData);
+      }
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({
+        queryKey
+      });
+    }
+  });
+  return {
+    mutationUpdateCardScore: mutation
+  };
+}
+var getScoreUpdated = ({
+  cardId,
+  cardScore,
+  previousScores,
+  cardIds,
+  weights
+}) => {
+  var _a, _b;
+  const previousCard = (_a = previousScores.cards) == null ? void 0 : _a[cardId];
+  const newCardScore = {
+    ...previousCard != null ? previousCard : {},
+    ...cardScore
+  };
+  const newScores = {
+    ...previousScores,
+    cards: {
+      ...(_b = previousScores.cards) != null ? _b : {},
+      [cardId]: newCardScore
+    }
+  };
+  const { score, progress } = calculateScoreAndProgress_default(newScores, cardIds, weights);
+  return {
+    newScoreUpdated: newScores,
+    updatedCardScore: cardScore,
+    score,
+    progress
+  };
+};
+var handleOptimisticScore = ({
+  score,
+  cardId,
+  cardScore,
+  cardIds,
+  weights
+}) => {
+  var _a;
+  let cards = { ...(_a = score == null ? void 0 : score.cards) != null ? _a : {} };
+  cards = {
+    ...cards,
+    [cardId]: {
+      ...cards[cardId],
+      ...cardScore
+    }
+  };
+  const { score: scoreValue, progress } = calculateScoreAndProgress_default(
+    // @ts-ignore
+    {
+      ...score != null ? score : {},
+      cards
+    },
+    cardIds,
+    weights
+  );
+  return { cards, score: scoreValue, progress };
+};
+function useClearScore() {
+  const { queryClient } = useSpeakableApi();
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: clearScore,
+    onError: (error) => {
+      console.log("Error clearing score:", error.message);
+    },
+    onSettled: (result) => {
+      var _a;
+      queryClient.invalidateQueries({
+        queryKey: scoreQueryKeys.byId((_a = result == null ? void 0 : result.activityId) != null ? _a : "")
+      });
+    }
+  });
+  return {
+    mutationClearScore: mutation
+  };
+}
+function useClearScoreV2() {
+  const { queryClient } = useSpeakableApi();
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: clearScoreV2,
+    onError: (error) => {
+      console.log("Error clearing score V2:", error.message);
+    },
+    onSettled: (result) => {
+      var _a;
+      queryClient.invalidateQueries({
+        queryKey: scoreQueryKeys.byId((_a = result == null ? void 0 : result.activityId) != null ? _a : "")
+      });
+    }
+  });
+  return {
+    mutationClearScore: mutation
+  };
+}
+function useSubmitAssignmentScore({
+  onAssignmentSubmitted,
+  studentName
+}) {
+  const { queryClient } = useSpeakableApi();
+  const { hasGoogleClassroomGradePassback } = usePermissions_default();
+  const { submitAssignmentToGoogleClassroom } = useGoogleClassroom();
+  const { createNotification: createNotification2 } = useCreateNotification();
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: async ({
+      assignment,
+      userId,
+      scores,
+      status
+    }) => {
+      try {
+        const scoreUpdated = await submitAssignmentScore({
+          assignment,
+          userId,
+          status,
+          studentName
+        });
+        if (assignment.courseWorkId != null && !assignment.isAssessment && hasGoogleClassroomGradePassback) {
+          await submitAssignmentToGoogleClassroom({
+            assignment,
+            scores
+          });
+        }
+        if (assignment.isAssessment) {
+          createNotification2(SpeakableNotificationTypes.ASSESSMENT_SUBMITTED, assignment);
+        }
+        if (assignment == null ? void 0 : assignment.id) {
+          logSubmitAssignment({
+            courseId: assignment == null ? void 0 : assignment.courseId
+          });
+        }
+        onAssignmentSubmitted(assignment.id);
+        queryClient.setQueryData(scoreQueryKeys.byId(assignment.id), {
+          ...scores,
+          ...scoreUpdated.fieldsUpdated
+        });
+        return {
+          success: true,
+          message: "Score submitted successfully"
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error
+        };
+      }
+    }
+  });
+  return {
+    submitAssignmentScore: mutation.mutateAsync,
+    isLoading: mutation.isPending
+  };
+}
+function useSubmitPracticeScore() {
+  const { queryClient } = useSpeakableApi();
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: async ({
+      setId,
+      userId,
+      scores
+    }) => {
+      try {
+        await submitPracticeScore({
+          setId,
+          userId,
+          scores
+        });
+        queryClient.invalidateQueries({
+          queryKey: scoreQueryKeys.byId(setId)
+        });
+        return {
+          success: true,
+          message: "Score submitted successfully"
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error
+        };
+      }
+    }
+  });
+  return {
+    submitPracticeScore: mutation.mutateAsync,
+    isLoading: mutation.isPending
+  };
+}
+
+// src/domains/cards/card.hooks.ts
+var import_react_query3 = require("@tanstack/react-query");
+var import_react2 = require("react");
+
+// src/domains/cards/card.model.ts
+var ConversationPageMode = /* @__PURE__ */ ((ConversationPageMode2) => {
+  ConversationPageMode2["VoiceAndText"] = "voice_and_text";
+  ConversationPageMode2["PhoneCall"] = "phone_call";
+  return ConversationPageMode2;
+})(ConversationPageMode || {});
+var ActivityPageType = /* @__PURE__ */ ((ActivityPageType2) => {
+  ActivityPageType2["READ_REPEAT"] = "READ_REPEAT";
+  ActivityPageType2["READ_RESPOND"] = "READ_RESPOND";
+  ActivityPageType2["FREE_RESPONSE"] = "FREE_RESPONSE";
+  ActivityPageType2["REPEAT"] = "REPEAT";
+  ActivityPageType2["RESPOND"] = "RESPOND";
+  ActivityPageType2["RESPOND_WRITE"] = "RESPOND_WRITE";
+  ActivityPageType2["MULTIPLE_CHOICE"] = "MULTIPLE_CHOICE";
+  ActivityPageType2["MEDIA_PAGE"] = "MEDIA_PAGE";
+  ActivityPageType2["SHORT_ANSWER"] = "SHORT_ANSWER";
+  ActivityPageType2["CONVERSATION"] = "CONVERSATION";
+  return ActivityPageType2;
+})(ActivityPageType || {});
+var RESPOND_PAGE_ACTIVITY_TYPES = [
+  "READ_RESPOND" /* READ_RESPOND */,
+  "RESPOND" /* RESPOND */,
+  "RESPOND_WRITE" /* RESPOND_WRITE */,
+  "FREE_RESPONSE" /* FREE_RESPONSE */
+];
+var MULTIPLE_CHOICE_PAGE_ACTIVITY_TYPES = ["MULTIPLE_CHOICE" /* MULTIPLE_CHOICE */];
+var REPEAT_PAGE_ACTIVITY_TYPES = ["READ_REPEAT" /* READ_REPEAT */, "REPEAT" /* REPEAT */];
+var RESPOND_WRITE_PAGE_ACTIVITY_TYPES = [
+  "RESPOND_WRITE" /* RESPOND_WRITE */,
+  "FREE_RESPONSE" /* FREE_RESPONSE */
+];
+var RESPOND_AUDIO_PAGE_ACTIVITY_TYPES = [
+  "RESPOND" /* RESPOND */,
+  "READ_RESPOND" /* READ_RESPOND */
+];
+var CONVERSATION_PAGE_ACTIVITY_TYPES = ["CONVERSATION" /* CONVERSATION */];
+
+// src/domains/cards/card.constants.ts
+var FeedbackTypesCard = /* @__PURE__ */ ((FeedbackTypesCard2) => {
+  FeedbackTypesCard2["SuggestedResponse"] = "suggested_response";
+  FeedbackTypesCard2["Wida"] = "wida";
+  FeedbackTypesCard2["GrammarInsights"] = "grammar_insights";
+  FeedbackTypesCard2["Actfl"] = "actfl";
+  FeedbackTypesCard2["ProficiencyLevel"] = "proficiency_level";
+  return FeedbackTypesCard2;
+})(FeedbackTypesCard || {});
+var LeniencyCard = /* @__PURE__ */ ((LeniencyCard2) => {
+  LeniencyCard2["CONFIDENCE"] = "confidence";
+  LeniencyCard2["EASY"] = "easy";
+  LeniencyCard2["NORMAL"] = "normal";
+  LeniencyCard2["HARD"] = "hard";
+  return LeniencyCard2;
+})(LeniencyCard || {});
+var LENIENCY_OPTIONS = [
+  {
+    label: "Build Confidence - most lenient",
+    value: "confidence" /* CONFIDENCE */
+  },
+  {
+    label: "Very Lenient",
+    value: "easy" /* EASY */
+  },
+  {
+    label: "Normal",
+    value: "normal" /* NORMAL */
+  },
+  {
+    label: "No leniency - most strict",
+    value: "hard" /* HARD */
+  }
+];
+var STUDENT_LEVELS_OPTIONS = [
+  {
+    label: "Beginner",
+    description: "Beginner Level: Just starting out. Can say a few basic words and phrases.",
+    value: "beginner"
+  },
+  {
+    label: "Elementary",
+    description: "Elementary Level: Can understand simple sentences and have very basic conversations.",
+    value: "elementary"
+  },
+  {
+    label: "Intermediate",
+    description: "Intermediate Level: Can talk about everyday topics and handle common situations.",
+    value: "intermediate"
+  },
+  {
+    label: "Advanced",
+    description: "Advanced Level: Can speak and understand with ease, and explain ideas clearly.",
+    value: "advanced"
+  },
+  {
+    label: "Fluent",
+    description: "Fluent Level: Speaks naturally and easily. Can use the language in work or school settings.",
+    value: "fluent"
+  },
+  {
+    label: "Native-like",
+    description: "Native-like Level: Understands and speaks like a native. Can discuss complex ideas accurately.",
+    value: "nativeLike"
+  }
+];
+var BASE_RESPOND_FIELD_VALUES = {
+  title: "",
+  allowRetries: true,
+  respondTime: 180,
+  maxCharacters: 1e4
+};
+var BASE_REPEAT_FIELD_VALUES = {
+  repeat: 1
+};
+var BASE_MULTIPLE_CHOICE_FIELD_VALUES = {
+  MCQType: "single",
+  answer: ["A"],
+  choices: [
+    { option: "A", value: "Option A" },
+    { option: "B", value: "Option B" },
+    { option: "C", value: "Option C" }
+  ]
+};
+var VerificationCardStatus = /* @__PURE__ */ ((VerificationCardStatus2) => {
+  VerificationCardStatus2["VERIFIED"] = "VERIFIED";
+  VerificationCardStatus2["WARNING"] = "WARNING";
+  VerificationCardStatus2["NOT_RECOMMENDED"] = "NOT_RECOMMENDED";
+  VerificationCardStatus2["NOT_WORKING"] = "NOT_WORKING";
+  VerificationCardStatus2["NOT_CHECKED"] = "NOT_CHECKED";
+  return VerificationCardStatus2;
+})(VerificationCardStatus || {});
+var CARDS_COLLECTION = "flashcards";
+var refsCardsFiresotre = {
+  allCards: CARDS_COLLECTION,
+  card: (id) => `${CARDS_COLLECTION}/${id}`
+};
+
+// src/domains/cards/services/get-card.service.ts
+async function _getCard(params) {
+  const ref = refsCardsFiresotre.card(params.cardId);
+  const response = await api.getDoc(ref);
+  if (!response.data) return null;
+  const type = response.data.type || "READ_REPEAT" /* READ_REPEAT */;
+  const cardsMapped = {
+    ...response.data,
+    type
+  };
+  return cardsMapped;
+}
+var getCard = withErrorHandler(_getCard, "getCard");
+
+// src/domains/cards/services/create-card.service.ts
+var import_uuid = require("uuid");
+
+// src/utils/text-utils.ts
+var import_js_sha1 = require("js-sha1");
+var purify = (word) => {
+  return word.normalize("NFD").replace(/\/([^" "]*)/g, "").replace(/\([^()]*\)/g, "").replace(/（[^()]*）/g, "").replace(/[\u0300-\u036f]/g, "").replace(/[-]/g, " ").replace(/[.,/#!¡¿？؟。，.?$%^&*;:{}=\-_`~()’'…\s]/g, "").replace(/\s\s+/g, " ").toLowerCase().trim();
+};
+var cleanString = (words) => {
+  const splitWords = words == null ? void 0 : words.split("+");
+  if (splitWords && splitWords.length === 1) {
+    const newWord = purify(words);
+    return newWord;
+  } else if (splitWords && splitWords.length > 1) {
+    const split = splitWords.map((w) => purify(w));
+    return split;
+  } else {
+    return "";
+  }
+};
+var getWordHash = (word, language) => {
+  const cleanedWord = cleanString(word);
+  const wordHash = (0, import_js_sha1.sha1)(`${language}-${cleanedWord}`);
+  console.log("wordHash core library", wordHash);
+  return wordHash;
+};
+function getPhraseLength(phrase, input) {
+  if (Array.isArray(phrase) && phrase.includes(input)) {
+    return phrase[phrase.indexOf(input)].split(" ").length;
+  } else {
+    return phrase ? phrase.split(" ").length : 0;
+  }
+}
+
+// src/domains/cards/services/get-card-verification-status.service.ts
+var charactarLanguages = ["zh", "ja", "ko"];
+var getVerificationStatus = async (target_text, language) => {
+  if ((target_text == null ? void 0 : target_text.length) < 3 && !charactarLanguages.includes(language)) {
+    return "NOT_RECOMMENDED" /* NOT_RECOMMENDED */;
+  }
+  const hash = getWordHash(target_text, language);
+  const response = await api.getDoc(`checked-pronunciations/${hash}`);
+  try {
+    if (response.data) {
+      return processRecord(response.data);
+    } else {
+      return "NOT_CHECKED" /* NOT_CHECKED */;
+    }
+  } catch (e) {
+    return "NOT_CHECKED" /* NOT_CHECKED */;
+  }
+};
+var processRecord = (data) => {
+  const { pronunciations = 0, fails = 0 } = data;
+  const attempts = pronunciations + fails;
+  const successRate = attempts > 0 ? pronunciations / attempts * 100 : 0;
+  let newStatus = null;
+  if (attempts < 6) {
+    return "NOT_CHECKED" /* NOT_CHECKED */;
+  }
+  if (successRate > 25) {
+    newStatus = "VERIFIED" /* VERIFIED */;
+  } else if (successRate > 10) {
+    newStatus = "WARNING" /* WARNING */;
+  } else if (fails > 20 && successRate < 10 && pronunciations > 1) {
+    newStatus = "NOT_RECOMMENDED" /* NOT_RECOMMENDED */;
+  } else if (pronunciations === 0 && fails > 20) {
+    newStatus = "NOT_WORKING" /* NOT_WORKING */;
+  } else {
+    newStatus = "NOT_CHECKED" /* NOT_CHECKED */;
+  }
+  return newStatus;
+};
+
+// src/domains/cards/services/create-card.service.ts
+async function _createCard({ data }) {
+  const response = await api.addDoc(refsCardsFiresotre.allCards, data);
+  return response;
+}
+var createCard = withErrorHandler(_createCard, "createCard");
+async function _createCards({ cards }) {
+  const { writeBatch: writeBatch2, doc: doc2 } = api.accessHelpers();
+  const batch = writeBatch2();
+  const cardsWithId = [];
+  for (const card of cards) {
+    const cardId = (0, import_uuid.v4)();
+    const ref = doc2(refsCardsFiresotre.card(cardId));
+    const newCardObject = {
+      ...card,
+      id: cardId
+    };
+    if (card.type === "READ_REPEAT" /* READ_REPEAT */ && card.target_text && card.language) {
+      const verificationStatus = await getVerificationStatus(card.target_text, card.language);
+      newCardObject.verificationStatus = verificationStatus || null;
+    }
+    cardsWithId.push(newCardObject);
+    batch.set(ref, newCardObject);
+  }
+  await batch.commit();
+  return cardsWithId;
+}
+var createCards = withErrorHandler(_createCards, "createCards");
+
+// src/domains/cards/card.hooks.ts
+var cardsQueryKeys = {
+  all: ["cards"],
+  one: (params) => [...cardsQueryKeys.all, params.cardId]
+};
+function useCards({
+  cardIds,
+  enabled = true,
+  asObject
+}) {
+  const queries = (0, import_react_query3.useQueries)({
+    queries: cardIds.map((cardId) => ({
+      enabled: enabled && cardIds.length > 0,
+      queryKey: cardsQueryKeys.one({
+        cardId
+      }),
+      queryFn: () => getCard({ cardId })
+    }))
+  });
+  const cards = queries.map((query2) => query2.data).filter(Boolean);
+  const cardsObject = (0, import_react2.useMemo)(() => {
+    if (!asObject) return null;
+    return cards.reduce((acc, card) => {
+      acc[card.id] = card;
+      return acc;
+    }, {});
+  }, [asObject, cards]);
+  return {
+    cards,
+    cardsObject,
+    cardsQueries: queries
+  };
+}
+function useCreateCard() {
+  const { queryClient } = useSpeakableApi();
+  const mutationCreateCard = (0, import_react_query3.useMutation)({
+    mutationFn: createCard,
+    onSuccess: (cardCreated) => {
+      queryClient.invalidateQueries({ queryKey: cardsQueryKeys.one({ cardId: cardCreated.id }) });
+    }
+  });
+  return {
+    mutationCreateCard
+  };
+}
+function useCreateCards() {
+  const mutationCreateCards = (0, import_react_query3.useMutation)({
+    mutationFn: createCards
+  });
+  return {
+    mutationCreateCards
+  };
+}
+function getCardFromCache({
+  cardId,
+  queryClient
+}) {
+  return queryClient.getQueryData(cardsQueryKeys.one({ cardId }));
+}
+function updateCardInCache({
+  cardId,
+  card,
+  queryClient
+}) {
+  queryClient.setQueryData(cardsQueryKeys.one({ cardId }), card);
+}
+function useGetCard({ cardId, enabled = true }) {
+  const query2 = (0, import_react_query3.useQuery)({
+    queryKey: cardsQueryKeys.one({ cardId }),
+    queryFn: () => getCard({ cardId }),
+    enabled: enabled && !!cardId
+  });
+  return query2;
+}
+
+// src/domains/cards/card.repo.ts
+var createCardRepo = () => {
+  return {
+    createCard,
+    createCards,
+    getCard
+  };
+};
+
+// src/domains/cards/utils/check-page-type.ts
+function checkIsRepeatPage(cardType) {
+  if (cardType === void 0) return false;
+  return REPEAT_PAGE_ACTIVITY_TYPES.includes(cardType);
+}
+function checkIsMCPage(cardType) {
+  if (cardType === void 0) return false;
+  return MULTIPLE_CHOICE_PAGE_ACTIVITY_TYPES.includes(cardType);
+}
+function checkIsRespondPage(cardType) {
+  if (cardType === void 0) return false;
+  return RESPOND_PAGE_ACTIVITY_TYPES.includes(cardType);
+}
+function checkIsRespondWrittenPage(cardType) {
+  if (cardType === void 0) return false;
+  return RESPOND_WRITE_PAGE_ACTIVITY_TYPES.includes(cardType);
+}
+function checkIsRespondAudioPage(cardType) {
+  if (cardType === void 0) return false;
+  return RESPOND_AUDIO_PAGE_ACTIVITY_TYPES.includes(cardType);
+}
+var checkIsMediaPage = (cardType) => {
+  if (cardType === void 0) return false;
+  return cardType === "MEDIA_PAGE" /* MEDIA_PAGE */;
+};
+var checkIsShortAnswerPage = (cardType) => {
+  if (cardType === void 0) return false;
+  return cardType === "SHORT_ANSWER" /* SHORT_ANSWER */;
+};
+var checkIsConversationPage = (cardType) => {
+  if (cardType === void 0) return false;
+  return cardType === "CONVERSATION" /* CONVERSATION */;
+};
+var checkTypePageActivity = (cardType) => {
+  const isRespondAudio = checkIsRespondAudioPage(cardType);
+  const isRespondWritten = checkIsRespondWrittenPage(cardType);
+  const isRespond = checkIsRespondPage(cardType);
+  const isMC = checkIsMCPage(cardType);
+  const isRepeat = checkIsRepeatPage(cardType);
+  const isMediaPage = checkIsMediaPage(cardType);
+  const isShortAnswer = checkIsShortAnswerPage(cardType);
+  const isConversation = checkIsConversationPage(cardType);
+  const isNoOneOfThem = !isRespond && !isMC && !isRepeat && !isMediaPage && !isShortAnswer && !isConversation;
+  if (isNoOneOfThem) {
+    return {
+      isRespondAudio: false,
+      isRespondWritten: false,
+      isRespond: false,
+      isMC: false,
+      isRepeat: true,
+      isMediaPage: false,
+      isShortAnswer: false,
+      hasSomeType: false,
+      isConversation: false
+    };
+  }
+  return {
+    isRespondAudio,
+    isRespondWritten,
+    isRespond,
+    isMC,
+    isRepeat,
+    isMediaPage,
+    isShortAnswer,
+    hasSomeType: true,
+    isConversation
+  };
+};
+
+// src/domains/cards/utils/get-page-prompt.ts
+function extractTextFromRichText(richText) {
+  if (!richText) return "";
+  return richText.replace(/<[^>]*>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").trim();
+}
+function getPagePrompt(card) {
+  if (!card) return { has: false, text: "", rich_text: "", isTextEqualToRichText: false };
+  const { isMC, isRepeat, isRespond, isShortAnswer, isConversation } = checkTypePageActivity(
+    card == null ? void 0 : card.type
+  );
+  const hidePrompt = (card == null ? void 0 : card.hidePrompt) === true;
+  const createReturnObject = (text, richText, extraText) => {
+    const plainText = text || "";
+    const richTextPlain = extractTextFromRichText(richText);
+    return {
+      has: true,
+      text: plainText,
+      rich_text: richText || "",
+      isTextEqualToRichText: plainText.trim() === richTextPlain.trim(),
+      extraText: extraText || ""
+    };
+  };
+  if (isRepeat) {
+    return createReturnObject(card == null ? void 0 : card.target_text, card == null ? void 0 : card.rich_text);
+  }
+  if (isConversation) {
+    return createReturnObject(card == null ? void 0 : card.prompt, card == null ? void 0 : card.rich_text, card == null ? void 0 : card.goal);
+  }
+  if (isRespond && !hidePrompt) {
+    return createReturnObject(card == null ? void 0 : card.prompt, card == null ? void 0 : card.rich_text);
+  }
+  if (isMC) {
+    return createReturnObject(card == null ? void 0 : card.question, card == null ? void 0 : card.rich_text);
+  }
+  if (isShortAnswer && !hidePrompt) {
+    return createReturnObject(card == null ? void 0 : card.prompt, card == null ? void 0 : card.rich_text);
+  }
+  return {
+    has: false,
+    text: "",
+    rich_text: "",
+    isTextEqualToRichText: false,
+    extraText: ""
+  };
+}
+
+// src/domains/cards/utils/get-completed-pages.ts
+var getTotalCompletedCards = (pageScores) => {
+  return Object.values(pageScores != null ? pageScores : {}).reduce((acc, cardScore) => {
+    var _a, _b;
+    if (((_b = (_a = cardScore.completed) != null ? _a : cardScore.score) != null ? _b : cardScore.score === 0) && !cardScore.media_area_opened) {
+      acc++;
+    }
+    return acc;
+  }, 0);
+};
+
+// src/domains/cards/utils/get-label-page.ts
+var labels = {
+  repeat: {
+    short: "Repeat",
+    long: "Listen & Repeat"
+  },
+  mc: {
+    short: "Multiple Choice",
+    long: "Multiple Choice"
+  },
+  mediaPage: {
+    short: "Media Page",
+    long: "Media Page"
+  },
+  shortAnswer: {
+    short: "Short Answer",
+    long: "Short Answer"
+  },
+  respondWritten: {
+    short: "Open Response",
+    long: "Written Open Response"
+  },
+  respondAudio: {
+    short: "Open Response",
+    long: "Spoken Open Response"
+  }
+};
+var getLabelPage = (pageType) => {
+  if (!pageType) {
+    return {
+      short: "",
+      long: ""
+    };
+  }
+  const { isRepeat, isMC, isMediaPage, isShortAnswer, isRespondWritten, isRespondAudio } = checkTypePageActivity(pageType);
+  if (isRepeat) {
+    return labels.repeat;
+  }
+  if (isMC) {
+    return labels.mc;
+  }
+  if (isMediaPage) {
+    return labels.mediaPage;
+  }
+  if (isShortAnswer) {
+    return labels.shortAnswer;
+  }
+  if (isRespondWritten) {
+    return labels.respondWritten;
+  }
+  if (isRespondAudio) {
+    return labels.respondAudio;
+  }
+  return {
+    short: "",
+    long: ""
+  };
+};
+
+// src/domains/cards/utils/get-page-media-data.ts
+function getPageMediaData(page) {
+  var _a, _b, _c, _d;
+  const direction = (_a = page.media_area_layout) != null ? _a : "left";
+  const { isMediaPage } = checkTypePageActivity(page.type);
+  const singleMedia = getSingleMediaPageData(page);
+  const resource = {
+    id: (_c = (_b = page.media_area_id) != null ? _b : page.media_area_context_ref) != null ? _c : void 0,
+    shouldRender: ((_d = page.media_area_id) != null ? _d : page.media_area_context_ref) != null ? true : false
+  };
+  const promptMedia = {
+    direction,
+    content: singleMedia,
+    shouldRender: singleMedia !== void 0
+  };
+  return {
+    isMediaPage,
+    resource,
+    promptMedia
+  };
+}
+function getSingleMediaPageData(page) {
+  if (!page.media) return void 0;
+  const media = {
+    type: page.media.type,
+    content: page.media.url
+  };
+  return {
+    ...media,
+    rawObject: page.media
+  };
+}
+
+// src/domains/sets/set.hooks.ts
+var import_react_query4 = require("@tanstack/react-query");
+
+// src/domains/sets/set.constants.ts
+var SETS_COLLECTION = "sets";
+var refsSetsFirestore = {
+  allSets: SETS_COLLECTION,
+  set: (id) => `${SETS_COLLECTION}/${id}`
+};
+
+// src/domains/sets/services/get-set.service.ts
+async function _getSet({ setId }) {
+  const response = await api.getDoc(refsSetsFirestore.set(setId));
+  return response.data;
+}
+var getSet = withErrorHandler(_getSet, "getSet");
+
+// src/domains/sets/set.hooks.ts
+var setsQueryKeys = {
+  all: ["sets"],
+  one: (params) => [...setsQueryKeys.all, params.setId]
+};
+var useSet = ({ setId, enabled }) => {
+  return (0, import_react_query4.useQuery)({
+    queryKey: setsQueryKeys.one({ setId }),
+    queryFn: () => getSet({ setId }),
+    enabled: setId !== void 0 && setId !== "" && enabled
+  });
+};
+function getSetFromCache({
+  setId,
+  queryClient
+}) {
+  if (!setId) return null;
+  return queryClient.getQueryData(setsQueryKeys.one({ setId }));
+}
+function updateSetInCache({
+  set,
+  queryClient
+}) {
+  const { id, ...setData } = set;
+  queryClient.setQueryData(setsQueryKeys.one({ setId: id }), setData);
+}
+
+// src/domains/sets/set.repo.ts
+var createSetRepo = () => {
+  return {
+    getSet
+  };
+};
+
+// src/utils/ai/detect-transcript-hallucionation.ts
+var HALLUCINATION_THRESHOLDS = {
+  // Short repeats
+  MIN_CONSECUTIVE_REPEATS: 5,
+  // Increased from 3 to allow phrases like "pio pio pio" or "no no no no"
+  MIN_WORDS_FOR_RATIO_CHECK: 15,
+  // Increased from 10 to require longer text for ratio check
+  MAX_UNIQUE_WORDS_FOR_RATIO: 3,
+  MIN_REPETITION_RATIO: 4,
+  // Increased from 3 to be more permissive
+  // Phrase repeats
+  MIN_SENTENCE_LENGTH: 15,
+  // Increased from 10 to avoid flagging short natural sentences
+  MIN_CONSECUTIVE_SIMILAR_SENTENCES: 3,
+  // Increased from 2 to allow some natural repetition
+  MIN_SENTENCES_FOR_DUPLICATE_CHECK: 4,
+  // Increased from 3
+  // Cyclic patterns
+  MIN_CYCLE_LENGTH: 30,
+  // Increased from 20 to focus on longer patterns
+  MIN_CYCLE_REPEATS: 3,
+  // Entropy detection
+  MIN_LENGTH_FOR_ENTROPY_CHECK: 60,
+  // Increased from 50
+  MAX_ENTROPY_THRESHOLD: 2.2,
+  // Decreased from 2.5 to be more strict on entropy (lower = more repetitive needed)
+  // Similarity
+  SENTENCE_SIMILARITY_THRESHOLD: 0.85,
+  // Increased from 0.8 to require more similarity
+  SEGMENT_SIMILARITY_THRESHOLD: 0.9
+  // Increased from 0.85
+};
+function detectTranscriptHallucinationWithDetails(transcript) {
+  if (!transcript || transcript.trim().length === 0) {
+    return { isHallucination: false };
+  }
+  const text = transcript.trim();
+  if (text.length < 10) {
+    return { isHallucination: false };
+  }
+  const shortRepeats = detectShortRepeats(text);
+  if (shortRepeats) {
+    return {
+      isHallucination: true,
+      reason: "Detected repeated short words or phrases",
+      confidence: 0.9
+    };
+  }
+  const phraseRepeats = detectPhraseRepeats(text);
+  if (phraseRepeats) {
+    return {
+      isHallucination: true,
+      reason: "Detected repeated sentences or phrases",
+      confidence: 0.85
+    };
+  }
+  const cyclicRepeats = detectCyclicPattern(text);
+  if (cyclicRepeats) {
+    return {
+      isHallucination: true,
+      reason: "Detected cyclic repetition pattern",
+      confidence: 0.8
+    };
+  }
+  if (text.length >= HALLUCINATION_THRESHOLDS.MIN_LENGTH_FOR_ENTROPY_CHECK) {
+    const entropy = calculateEntropy(text);
+    if (entropy < HALLUCINATION_THRESHOLDS.MAX_ENTROPY_THRESHOLD) {
+      return {
+        isHallucination: true,
+        reason: "Detected low entropy (likely gibberish or excessive repetition)",
+        confidence: 0.75
+      };
+    }
+  }
+  return { isHallucination: false };
+}
+function detectShortRepeats(text) {
+  const words = text.toLowerCase().split(/[\s,;.!?]+/).filter((w) => w.length > 0);
+  if (words.length < 4) return false;
+  let repeatCount = 1;
+  for (let i = 1; i < words.length; i++) {
+    if (words[i] === words[i - 1]) {
+      repeatCount++;
+      if (repeatCount >= HALLUCINATION_THRESHOLDS.MIN_CONSECUTIVE_REPEATS) {
+        return true;
+      }
+    } else {
+      repeatCount = 1;
+    }
+  }
+  const uniqueWords = new Set(words);
+  const repetitionRatio = words.length / uniqueWords.size;
+  if (words.length >= HALLUCINATION_THRESHOLDS.MIN_WORDS_FOR_RATIO_CHECK && uniqueWords.size <= HALLUCINATION_THRESHOLDS.MAX_UNIQUE_WORDS_FOR_RATIO && repetitionRatio >= HALLUCINATION_THRESHOLDS.MIN_REPETITION_RATIO) {
+    return true;
+  }
+  return false;
+}
+function detectPhraseRepeats(text) {
+  const sentences = text.split(/[.!?]+/).map((s) => s.trim().toLowerCase()).filter((s) => s.length > HALLUCINATION_THRESHOLDS.MIN_SENTENCE_LENGTH);
+  if (sentences.length < 2) return false;
+  for (let i = 0; i < sentences.length - 1; i++) {
+    let consecutiveRepeats = 1;
+    for (let j = i + 1; j < sentences.length; j++) {
+      if (isSimilarSentence(sentences[i], sentences[j])) {
+        consecutiveRepeats++;
+      } else {
+        break;
+      }
+    }
+    if (consecutiveRepeats >= HALLUCINATION_THRESHOLDS.MIN_CONSECUTIVE_SIMILAR_SENTENCES) {
+      return true;
+    }
+  }
+  const uniqueSentences = new Set(sentences);
+  if (sentences.length >= HALLUCINATION_THRESHOLDS.MIN_SENTENCES_FOR_DUPLICATE_CHECK && uniqueSentences.size === 1) {
+    return true;
+  }
+  return false;
+}
+function isSimilarSentence(s1, s2, threshold = HALLUCINATION_THRESHOLDS.SENTENCE_SIMILARITY_THRESHOLD) {
+  if (s1 === s2) return true;
+  const normalized1 = s1.replace(/\s+/g, " ").trim();
+  const normalized2 = s2.replace(/\s+/g, " ").trim();
+  if (normalized1 === normalized2) return true;
+  const words1 = normalized1.split(/\s+/);
+  const words2 = normalized2.split(/\s+/);
+  if (Math.abs(words1.length - words2.length) > 2) return false;
+  const set1 = new Set(words1);
+  const set2 = new Set(words2);
+  const intersection = new Set([...set1].filter((w) => set2.has(w)));
+  const similarity = intersection.size * 2 / (set1.size + set2.size);
+  return similarity >= threshold;
+}
+function detectCyclicPattern(text) {
+  const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
+  const length = normalized.length;
+  const minCycleLength = HALLUCINATION_THRESHOLDS.MIN_CYCLE_LENGTH;
+  const maxCycleLength = Math.floor(length / 2);
+  if (maxCycleLength < minCycleLength) return false;
+  const step = 5;
+  for (let cycleLen = minCycleLength; cycleLen <= maxCycleLength; cycleLen += step) {
+    const pattern = normalized.substring(0, cycleLen);
+    let matchCount = 0;
+    let pos = 0;
+    while (pos < length) {
+      const segment = normalized.substring(pos, pos + cycleLen);
+      if (segment.length < cycleLen) {
+        const partialMatch = pattern.startsWith(segment);
+        if (partialMatch && matchCount > 0) {
+          matchCount++;
+        }
+        break;
+      }
+      if (segment === pattern || isSegmentSimilar(segment, pattern)) {
+        matchCount++;
+        pos += cycleLen;
+      } else {
+        break;
+      }
+    }
+    if (matchCount >= HALLUCINATION_THRESHOLDS.MIN_CYCLE_REPEATS) {
+      return true;
+    }
+  }
+  return false;
+}
+function isSegmentSimilar(s1, s2) {
+  if (s1 === s2) return true;
+  if (s1.length !== s2.length) return false;
+  let matches = 0;
+  const minLength = Math.min(s1.length, s2.length);
+  for (let i = 0; i < minLength; i++) {
+    if (s1[i] === s2[i]) {
+      matches++;
+    }
+  }
+  const similarity = matches / minLength;
+  return similarity >= HALLUCINATION_THRESHOLDS.SEGMENT_SIMILARITY_THRESHOLD;
+}
+function calculateEntropy(text) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  const frequencies = /* @__PURE__ */ new Map();
+  for (const char of text.toLowerCase()) {
+    frequencies.set(char, (frequencies.get(char) || 0) + 1);
+  }
+  let entropy = 0;
+  const length = text.length;
+  for (const count of frequencies.values()) {
+    const probability = count / length;
+    entropy -= probability * Math.log2(probability);
+  }
+  return entropy;
+}
+function cleanHallucinatedTranscript(transcript) {
+  var _a, _b;
+  const result = detectTranscriptHallucinationWithDetails(transcript);
+  if (result.isHallucination) {
+    console.warn(
+      "Hallucinated transcript detected and removed:",
+      transcript.substring(0, 100),
+      `
+Reason: ${(_a = result.reason) != null ? _a : "Unknown"}`,
+      `Confidence: ${String((_b = result.confidence) != null ? _b : "Unknown")}`
+    );
+    return "";
+  }
+  return transcript;
+}
+
+// src/utils/ai/get-transcript.ts
+async function getTranscript(model, args, cleanHallucinations = true) {
+  var _a, _b, _c, _d, _e, _f;
+  const getGeminiTranscript = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "getGeminiTranscript");
+  const getAssemblyAITranscript = (_d = (_c = api).httpsCallable) == null ? void 0 : _d.call(_c, "transcribeAssemblyAIAudio");
+  const getWhisperTranscript = (_f = (_e = api).httpsCallable) == null ? void 0 : _f.call(_e, "generateGroqTranscript");
+  if (model === "whisper") {
+    try {
+      const { data } = await (getWhisperTranscript == null ? void 0 : getWhisperTranscript({
+        audioUrl: args.audioUrl,
+        language: args.language
+      }));
+      return cleanHallucinations ? cleanHallucinatedTranscript(data) : data;
+    } catch (error) {
+      console.error("Error getting transcript from Whisper:", error);
+      throw error;
+    }
+  }
+  if (model === "gemini") {
+    try {
+      const { data } = await (getGeminiTranscript == null ? void 0 : getGeminiTranscript({
+        audioUrl: args.audioUrl,
+        targetLanguage: args.language,
+        prompt: args.prompt
+      }));
+      return cleanHallucinations ? cleanHallucinatedTranscript(data.transcript) : data.transcript;
+    } catch (error) {
+      console.error("Error getting transcript from Gemini:", error);
+      throw error;
+    }
+  }
+  if (model === "assemblyai") {
+    try {
+      const response = await (getAssemblyAITranscript == null ? void 0 : getAssemblyAITranscript({
+        audioUrl: args.audioUrl,
+        language: args.language
+      }));
+      return cleanHallucinations ? cleanHallucinatedTranscript(response.data) : response.data;
+    } catch (error) {
+      console.error("Error getting transcript from AssemblyAI:", error);
+      throw error;
+    }
+  }
+  return null;
+}
+async function getTranscriptCycle(args) {
+  const models = ["whisper", "gemini", "assemblyai"];
+  let transcript = "";
+  let lastError = null;
+  for (const model of models) {
+    try {
+      console.log("Getting transcript from", model);
+      const transcriptResult = await getTranscript(model, args, false);
+      const rawTranscript = transcriptResult || "";
+      transcript = cleanHallucinatedTranscript(rawTranscript);
+      if (transcript !== "") {
+        console.log(`Successfully got transcript from ${model}`);
+        break;
+      }
+      console.warn(`${model} returned empty transcript, trying next model`);
+    } catch (e) {
+      console.error(`Error with ${model} transcript:`, e);
+      lastError = e;
+    }
+  }
+  if (transcript === "") {
+    console.error("All transcript models failed or returned empty", lastError);
+    return {
+      transcript: "",
+      success: false
+    };
+  }
+  return {
+    transcript,
+    success: true
+  };
+}
+
+// src/constants/all-langs.json
+var all_langs_default = {
+  af: "Afrikaans",
+  sq: "Albanian",
+  am: "Amharic",
+  ar: "Arabic",
+  hy: "Armenian",
+  az: "Azerbaijani",
+  eu: "Basque",
+  be: "Belarusian",
+  bn: "Bengali",
+  bs: "Bosnian",
+  bg: "Bulgarian",
+  ca: "Catalan",
+  ceb: "Cebuano",
+  zh: "Chinese",
+  co: "Corsican",
+  hr: "Croatian",
+  cs: "Czech",
+  da: "Danish",
+  nl: "Dutch",
+  en: "English",
+  eo: "Esperanto",
+  et: "Estonian",
+  fi: "Finnish",
+  fr: "French",
+  fy: "Frisian",
+  gl: "Galician",
+  ka: "Georgian",
+  de: "German",
+  el: "Greek",
+  gu: "Gujarati",
+  ht: "Haitian Creole",
+  ha: "Hausa",
+  haw: "Hawaiian",
+  he: "Hebrew",
+  hi: "Hindi",
+  hmn: "Hmong",
+  hu: "Hungarian",
+  is: "Icelandic",
+  ig: "Igbo",
+  id: "Indonesian",
+  ga: "Irish",
+  it: "Italian",
+  ja: "Japanese",
+  jv: "Javanese",
+  kn: "Kannada",
+  kk: "Kazakh",
+  km: "Khmer",
+  ko: "Korean",
+  ku: "Kurdish",
+  ky: "Kyrgyz",
+  lo: "Lao",
+  la: "Latin",
+  lv: "Latvian",
+  lt: "Lithuanian",
+  lb: "Luxembourgish",
+  mk: "Macedonian",
+  mg: "Malagasy",
+  ms: "Malay",
+  ml: "Malayalam",
+  mt: "Maltese",
+  mi: "Maori",
+  mr: "Marathi",
+  mn: "Mongolian",
+  my: "Myanmar (Burmese)",
+  ne: "Nepali",
+  no: "Norwegian",
+  ny: "Nyanja (Chichewa)",
+  ps: "Pashto",
+  fa: "Persian",
+  pl: "Polish",
+  pt: "Portuguese",
+  pa: "Punjabi",
+  ro: "Romanian",
+  ru: "Russian",
+  sm: "Samoan",
+  gd: "Scots Gaelic",
+  sr: "Serbian",
+  st: "Sesotho",
+  sn: "Shona",
+  sd: "Sindhi",
+  si: "Sinhala (Sinhalese)",
+  sk: "Slovak",
+  sl: "Slovenian",
+  so: "Somali",
+  es: "Spanish",
+  su: "Sundanese",
+  sw: "Swahili",
+  sv: "Swedish",
+  tl: "Tagalog (Filipino)",
+  tg: "Tajik",
+  ta: "Tamil",
+  te: "Telugu",
+  th: "Thai",
+  tr: "Turkish",
+  uk: "Ukrainian",
+  ur: "Urdu",
+  uz: "Uzbek",
+  vi: "Vietnamese",
+  cy: "Welsh",
+  xh: "Xhosa",
+  yi: "Yiddish",
+  yo: "Yoruba",
+  zu: "Zulu"
+};
+
+// src/utils/ai/get-respond-card-tool.ts
+var getRespondCardTool = ({
+  language,
+  standard = "actfl"
+}) => {
+  const lang = all_langs_default[language] || "English";
+  const tool = {
+    tool_choice: {
+      type: "function",
+      function: { name: "get_feedback" }
+    },
+    tools: [
+      {
+        type: "function",
+        function: {
+          name: "get_feedback",
+          description: "Get feedback on a student's response",
+          parameters: {
+            type: "object",
+            required: [
+              "success",
+              "score",
+              "score_justification",
+              "errors",
+              "improvedResponse",
+              "compliments"
+            ],
+            properties: {
+              success: {
+                type: "boolean",
+                description: "Mark true if  the student's response was on-topic and generally demonstrated understanding. A few grammar mistakes are acceptable. Mark false if the student's response was off-topic or did not demonstrate understanding."
+              },
+              errors: {
+                type: "array",
+                items: {
+                  type: "object",
+                  required: ["error", "grammar_error_type", "correction", "justification"],
+                  properties: {
+                    error: {
+                      type: "string",
+                      description: "The grammatical error in the student's response."
+                    },
+                    correction: {
+                      type: "string",
+                      description: "The suggested correction to the error"
+                    },
+                    justification: {
+                      type: "string",
+                      description: `An explanation of the rationale behind the suggested correction. WRITE THIS IN ${lang}!`
+                    },
+                    grammar_error_type: {
+                      type: "string",
+                      enum: [
+                        "subjVerbAgree",
+                        "tenseErrors",
+                        "articleMisuse",
+                        "prepositionErrors",
+                        "adjNounAgree",
+                        "pronounErrors",
+                        "wordOrder",
+                        "verbConjugation",
+                        "pluralization",
+                        "negationErrors",
+                        "modalVerbMisuse",
+                        "relativeClause",
+                        "auxiliaryVerb",
+                        "complexSentenceAgreement",
+                        "idiomaticExpression",
+                        "registerInconsistency",
+                        "voiceMisuse"
+                      ],
+                      description: "The type of grammatical error found. It should be one of the following categories: subject-verb agreement, tense errors, article misuse, preposition errors, adjective-noun agreement, pronoun errors, word order, verb conjugation, pluralization errors, negation errors, modal verb misuse, relative clause errors, auxiliary verb misuse, complex sentence agreement, idiomatic expression, register inconsistency, or voice misuse"
+                    }
+                  }
+                },
+                description: "An array of objects, each representing a grammatical error in the student's response. Each object should have the following properties: error, grammar_error_type, correction, and justification. If there were no errors, return an empty array."
+              },
+              compliments: {
+                type: "array",
+                items: {
+                  type: "string"
+                },
+                description: `An array of strings, each representing something the student did well. Each string should be WRITTEN IN  ${lang}!`
+              },
+              improvedResponse: {
+                type: "string",
+                description: "An improved response with proper grammar and more detail, if applicable."
+              },
+              score: {
+                type: "number",
+                description: "A score between 0 and 100, reflecting the overall quality of the response"
+              },
+              score_justification: {
+                type: "string",
+                description: "An explanation of the rationale behind the assigned score, considering both accuracy and fluency"
+              }
+            }
+          }
+        }
+      }
+    ]
+  };
+  if (standard === "wida") {
+    const wida_level = {
+      type: "number",
+      enum: [1, 2, 3, 4, 5, 6],
+      description: `The student's WIDA (World-Class Instructional Design and Assessment) proficiency level. Choose one of the following options: 1, 2, 3, 4, 5, 6 which corresponds to
+				
+				1 - Entering
+				2 - Emerging
+				3 - Developing
+				4 - Expanding
+				5 - Bridging
+				6 - Reaching
+				
+			This is an estimate based on the level of the student's response. Use the descriptions of the WIDA speaking standards to guide your decision.
+				`
+    };
+    const wida_justification = {
+      type: "string",
+      description: `An explanation of the rationale behind the assigned WIDA level of the response, considering both accuracy and fluency. WRITE THIS IN ENGLISH!`
+    };
+    tool.tools[0].function.parameters.required.push("wida_level");
+    tool.tools[0].function.parameters.required.push("wida_justification");
+    tool.tools[0].function.parameters.properties.wida_level = wida_level;
+    tool.tools[0].function.parameters.properties.wida_justification = wida_justification;
+  } else {
+    const actfl_level = {
+      type: "string",
+      enum: ["NL", "NM", "NH", "IL", "IM", "IH", "AL", "AM", "AH", "S", "D"],
+      description: "The student's ACTFL (American Council on the Teaching of Foreign Languages) proficiency level. Choose one of the following options: NL, NM, NH, IL, IM, IH, AL, AM, AH, S, or D"
+    };
+    const actfl_justification = {
+      type: "string",
+      description: "An explanation of the rationale behind the assigned ACTFL level, considering both accuracy and fluency"
+    };
+    tool.tools[0].function.parameters.required.push("actfl_level");
+    tool.tools[0].function.parameters.required.push("actfl_justification");
+    tool.tools[0].function.parameters.properties.actfl_level = actfl_level;
+    tool.tools[0].function.parameters.properties.actfl_justification = actfl_justification;
+  }
+  return tool;
+};
+
+// src/hooks/useActivity.ts
+var import_react3 = require("react");
+
+// src/services/add-grading-standard.ts
+var addGradingStandardLog = async (gradingStandard, userId) => {
+  logGradingStandardLog(gradingStandard);
+  const path = `users/${userId}/grading_standard_logs`;
+  await api.addDoc(path, gradingStandard);
+};
+
+// src/hooks/useActivityTracker.ts
+var import_uuid2 = require("uuid");
+function useActivityTracker({ userId }) {
+  const trackActivity = async ({
+    activityName,
+    activityType,
+    id = (0, import_uuid2.v4)(),
+    language = ""
+  }) => {
+    if (userId) {
+      const { doc: doc2, serverTimestamp: serverTimestamp2, setDoc: setDoc2 } = api.accessHelpers();
+      const activityRef = doc2(`users/${userId}/activity/${id}`);
+      const timestamp = serverTimestamp2();
+      await setDoc2(activityRef, {
+        name: activityName,
+        type: activityType,
+        lastSeen: timestamp,
+        id,
+        language
+      });
+    }
+  };
+  return {
+    trackActivity
+  };
+}
+
+// src/hooks/useActivity.ts
+function useActivity({
+  id,
+  isAssignment,
+  onAssignmentSubmitted,
+  ltiData
+}) {
+  var _a, _b;
+  const { queryClient, user } = useSpeakableApi();
+  const userId = user.auth.uid;
+  const assignmentQuery = useAssignment({
+    assignmentId: id,
+    userId,
+    enabled: isAssignment
+  });
+  const activeAssignment = assignmentQuery.data;
+  const setId = isAssignment ? (_a = activeAssignment == null ? void 0 : activeAssignment.setId) != null ? _a : "" : id;
+  const querySet = useSet({ setId });
+  const setData = querySet.data;
+  const assignmentContent = activeAssignment == null ? void 0 : activeAssignment.content;
+  const assignmentWeights = activeAssignment == null ? void 0 : activeAssignment.weights;
+  const setContent = setData == null ? void 0 : setData.content;
+  const setWeights = setData == null ? void 0 : setData.weights;
+  const contentCardsToUse = isAssignment ? assignmentContent != null ? assignmentContent : setContent : setContent;
+  const weightsToUse = isAssignment ? assignmentWeights != null ? assignmentWeights : setWeights : setWeights;
+  const activityId = isAssignment ? (_b = activeAssignment == null ? void 0 : activeAssignment.id) != null ? _b : "" : setId;
+  const { cardsObject, cardsQueries, cards } = useCards({
+    cardIds: contentCardsToUse != null ? contentCardsToUse : [],
+    enabled: querySet.isSuccess,
+    asObject: true
+  });
+  const scorableCardIds = (contentCardsToUse != null ? contentCardsToUse : []).filter((cardId) => {
+    const card = cardsObject == null ? void 0 : cardsObject[cardId];
+    return (card == null ? void 0 : card.type) !== "MEDIA_PAGE" /* MEDIA_PAGE */;
+  });
+  const scoreQuery = useScore({
+    isAssignment,
+    activityId: id,
+    userId,
+    courseId: activeAssignment == null ? void 0 : activeAssignment.courseId,
+    googleClassroomUserId: user.profile.googleClassroomUserId,
+    enabled: isAssignment ? assignmentQuery.isSuccess : querySet.isSuccess
+  });
+  const { mutationUpdateScore } = useUpdateScore();
+  const { mutationUpdateCardScore } = useUpdateCardScore({
+    activityId,
+    isAssignment,
+    userId,
+    cardIds: scorableCardIds,
+    weights: weightsToUse != null ? weightsToUse : {}
+  });
+  const { mutationClearScore } = useClearScore();
+  const { submitAssignmentScore: submitAssignmentScore2 } = useSubmitAssignmentScore({
+    onAssignmentSubmitted,
+    studentName: user.profile.displayName
+  });
+  const { submitPracticeScore: submitPracticeScore2 } = useSubmitPracticeScore();
+  const handleUpdateScore = (data) => {
+    mutationUpdateScore.mutate({
+      data,
+      isAssignment,
+      activityId,
+      userId
+    });
+  };
+  const handleUpdateCardScore = (cardId, cardScore) => {
+    mutationUpdateCardScore.mutate({ cardId, cardScore });
+    if (cardScore.proficiency_level) {
+      logGradingStandardEntry({
+        type: cardScore.proficiency_level.standardId,
+        cardId,
+        gradingStandard: cardScore.proficiency_level
+      });
+    } else if (cardScore.wida || cardScore.actfl) {
+      logGradingStandardEntry({
+        type: cardScore.wida ? "wida" : "actfl",
+        cardId,
+        gradingStandard: cardScore.wida || cardScore.actfl || { level: "", justification: "" }
+      });
+    }
+  };
+  const onClearScore = ({
+    cardId,
+    wasCompleted = true
+  }) => {
+    var _a2, _b2;
+    const currentCard = cardsObject == null ? void 0 : cardsObject[cardId];
+    if ((currentCard == null ? void 0 : currentCard.type) === "MULTIPLE_CHOICE" /* MULTIPLE_CHOICE */ || (currentCard == null ? void 0 : currentCard.type) === "READ_REPEAT" /* READ_REPEAT */) {
+      return;
+    }
+    const queryKeys = scoreQueryKeys.byId(activityId);
+    const activeCardScores = (_b2 = (_a2 = queryClient.getQueryData(queryKeys)) == null ? void 0 : _a2.cards) == null ? void 0 : _b2[cardId];
+    if (activeCardScores === void 0) return;
+    mutationClearScore.mutate({
+      isAssignment,
+      activityId,
+      cardScores: activeCardScores,
+      cardId,
+      userId
+    });
+  };
+  const onSubmitScore = async () => {
+    var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+    try {
+      let results;
+      if (isAssignment) {
+        const someCardIsManualGraded = cards.some((page) => page.grading_method === "manual");
+        results = await submitAssignmentScore2({
+          assignment: {
+            id: (_b2 = (_a2 = assignmentQuery.data) == null ? void 0 : _a2.id) != null ? _b2 : "",
+            name: (_d = (_c = assignmentQuery.data) == null ? void 0 : _c.name) != null ? _d : "",
+            owners: (_f = (_e = assignmentQuery.data) == null ? void 0 : _e.owners) != null ? _f : [],
+            courseId: (_h = (_g = assignmentQuery.data) == null ? void 0 : _g.courseId) != null ? _h : "",
+            courseWorkId: (_j = (_i = assignmentQuery.data) == null ? void 0 : _i.courseWorkId) != null ? _j : "",
+            isAssessment: (_l = (_k = assignmentQuery.data) == null ? void 0 : _k.isAssessment) != null ? _l : false,
+            maxPoints: (_n = (_m = assignmentQuery.data) == null ? void 0 : _m.maxPoints) != null ? _n : 0
+          },
+          userId,
+          scores: scoreQuery.data,
+          status: someCardIsManualGraded ? "PENDING_REVIEW" : "SUBMITTED"
+        });
+        if ((_o = assignmentQuery.data) == null ? void 0 : _o.ltiDeeplink) {
+          submitLTIScore({
+            maxPoints: (_p = assignmentQuery.data) == null ? void 0 : _p.maxPoints,
+            score: (_r = (_q = scoreQuery.data) == null ? void 0 : _q.score) != null ? _r : 0,
+            SERVICE_KEY: (_s = ltiData == null ? void 0 : ltiData.serviceKey) != null ? _s : "",
+            lineItemId: (_t = ltiData == null ? void 0 : ltiData.lineItemId) != null ? _t : "",
+            lti_id: (_u = ltiData == null ? void 0 : ltiData.lti_id) != null ? _u : ""
+          });
+        }
+      } else {
+        results = await submitPracticeScore2({
+          setId: (_w = (_v = querySet.data) == null ? void 0 : _v.id) != null ? _w : "",
+          userId,
+          scores: scoreQuery.data
+        });
+      }
+      return results;
+    } catch (error) {
+      return {
+        success: false,
+        error
+      };
+    }
+  };
+  const logGradingStandardEntry = ({
+    cardId,
+    gradingStandard,
+    type
+  }) => {
+    var _a2, _b2, _c, _d, _e, _f, _g, _h, _i;
+    const card = cardsObject == null ? void 0 : cardsObject[cardId];
+    const scoresObject = queryClient.getQueryData(scoreQueryKeys.byId(activityId));
+    const cardScore = (_a2 = scoresObject == null ? void 0 : scoresObject.cards) == null ? void 0 : _a2[cardId];
+    const serverTimestamp2 = api.helpers.serverTimestamp;
+    addGradingStandardLog(
+      {
+        assignmentId: (_b2 = activeAssignment == null ? void 0 : activeAssignment.id) != null ? _b2 : "",
+        courseId: (_c = activeAssignment == null ? void 0 : activeAssignment.courseId) != null ? _c : "",
+        teacherId: (_d = activeAssignment == null ? void 0 : activeAssignment.owners[0]) != null ? _d : "",
+        setId: (_e = setData == null ? void 0 : setData.id) != null ? _e : "",
+        cardId,
+        level: gradingStandard.level,
+        justification: gradingStandard.justification,
+        transcript: (_f = cardScore == null ? void 0 : cardScore.transcript) != null ? _f : "",
+        audioUrl: (_g = cardScore == null ? void 0 : cardScore.audio) != null ? _g : "",
+        prompt: (_h = card == null ? void 0 : card.prompt) != null ? _h : "",
+        responseType: (card == null ? void 0 : card.type) === "RESPOND_WRITE" /* RESPOND_WRITE */ ? "written" : "spoken",
+        type,
+        dateMade: serverTimestamp2(),
+        language: (_i = card == null ? void 0 : card.language) != null ? _i : ""
+      },
+      userId
+    );
+  };
+  (0, import_react3.useEffect)(() => {
+    if (isAssignment) {
+      logOpenAssignment({ assignmentId: id });
+    } else {
+      logOpenActivityPreview({ setId: id });
+    }
+  }, []);
+  useInitActivity({
+    assignment: activeAssignment != null ? activeAssignment : void 0,
+    set: setData != null ? setData : void 0,
+    enabled: !!setData,
+    userId
+  });
+  return {
+    set: {
+      data: setData,
+      query: querySet
+    },
+    cards: {
+      data: cardsObject,
+      query: cardsQueries,
+      cardsArray: cards
+    },
+    assignment: {
+      data: isAssignment ? activeAssignment : void 0,
+      query: assignmentQuery
+    },
+    scores: {
+      data: scoreQuery.data,
+      query: scoreQuery,
+      actions: {
+        update: handleUpdateScore,
+        clear: onClearScore,
+        submit: onSubmitScore,
+        updateCard: handleUpdateCardScore,
+        logGradingStandardEntry
+      }
+    }
+  };
+}
+var useInitActivity = ({
+  assignment,
+  set,
+  enabled,
+  userId
+}) => {
+  const { trackActivity } = useActivityTracker({ userId });
+  const init = () => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!enabled) return;
+    if (!assignment) {
+      trackActivity({
+        activityName: (_a = set == null ? void 0 : set.name) != null ? _a : "",
+        activityType: "set",
+        id: set == null ? void 0 : set.id,
+        language: set == null ? void 0 : set.language
+      });
+    } else if (assignment.name) {
+      trackActivity({
+        activityName: assignment.name,
+        activityType: assignment.isAssessment ? "assessment" : "assignment",
+        id: assignment.id,
+        language: set == null ? void 0 : set.language
+      });
+    }
+    if (set == null ? void 0 : set.public) {
+      (_d = (_c = (_b = api).httpsCallable) == null ? void 0 : _c.call(_b, "onSetOpened")) == null ? void 0 : _d({
+        setId: set.id,
+        language: set.language
+      });
+    }
+    (_g = (_f = (_e = api).httpsCallable) == null ? void 0 : _f.call(_e, "updateAlgoliaIndex")) == null ? void 0 : _g({
+      updatePlays: true,
+      objectID: set == null ? void 0 : set.id
+    });
+  };
+  (0, import_react3.useEffect)(() => {
+    init();
+  }, [set]);
+};
+var submitLTIScore = async ({
+  maxPoints,
+  score,
+  SERVICE_KEY,
+  lineItemId,
+  lti_id
+}) => {
+  var _a, _b, _c;
+  try {
+    if (!SERVICE_KEY || !lineItemId || !lti_id) {
+      throw new Error("Missing required LTI credentials");
+    }
+    const earnedPoints = score ? score / 100 * maxPoints : 0;
+    const { data } = await ((_c = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "submitLTIAssignmentScore")) == null ? void 0 : _c({
+      SERVICE_KEY,
+      scoreData: {
+        lineItemId,
+        userId: lti_id,
+        maxPoints,
+        earnedPoints
+      }
+    }));
+    return { success: true, data };
+  } catch (error) {
+    console.error("Failed to submit LTI score:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error("Unknown error occurred")
+    };
+  }
+};
+
+// src/hooks/useCredits.ts
+var import_react_query5 = require("@tanstack/react-query");
+var creditQueryKeys = {
+  userCredits: (uid) => ["userCredits", uid]
+};
+var useUserCredits = () => {
+  const { user } = useSpeakableApi();
+  const email = user.auth.email;
+  const uid = user.auth.uid;
+  const query2 = (0, import_react_query5.useQuery)({
+    queryKey: creditQueryKeys.userCredits(uid),
+    queryFn: () => fetchUserCredits({ uid, email }),
+    enabled: !!uid,
+    refetchInterval: 1e3 * 60 * 5
+  });
+  return {
+    ...query2
+  };
+};
+var fetchUserCredits = async ({ uid, email }) => {
+  if (!uid) {
+    throw new Error("User ID is required");
+  }
+  const contractSnap = await api.getDoc(`creditContracts/${uid}`);
+  if (contractSnap.data == null) {
+    return {
+      id: uid,
+      userId: uid,
+      email,
+      effectivePlanId: "free_tier",
+      status: "inactive",
+      isUnlimited: false,
+      creditsAvailable: 100,
+      creditsAllocatedThisPeriod: 100,
+      topOffCreditsAvailable: 0,
+      topOffCreditsTotal: 0,
+      allocationSource: "free_tier",
+      sourceDetails: {},
+      periodStart: null,
+      periodEnd: null,
+      planTermEndTimestamp: null,
+      ownerType: "individual",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const contractData = contractSnap.data;
+  const monthlyCredits = (contractData == null ? void 0 : contractData.creditsAvailable) || 0;
+  const topOffCredits = (contractData == null ? void 0 : contractData.topOffCreditsAvailable) || 0;
+  const totalCredits = monthlyCredits + topOffCredits;
+  return {
+    id: contractSnap.id,
+    ...contractData,
+    // Add computed total for convenience
+    totalCreditsAvailable: totalCredits
+  };
+};
+
+// src/hooks/useOrganizationAccess.ts
+var import_react_query6 = require("@tanstack/react-query");
+var useOrganizationAccess = () => {
+  const { user } = useSpeakableApi();
+  const email = user.auth.email;
+  const query2 = (0, import_react_query6.useQuery)({
+    queryKey: ["organizationAccess", email],
+    queryFn: async () => {
+      if (!email) {
+        return {
+          hasUnlimitedAccess: false,
+          subscriptionId: null,
+          organizationId: null,
+          organizationName: null,
+          subscriptionEndDate: null,
+          accessType: "individual"
+        };
+      }
+      return getOrganizationAccess(email);
+    },
+    enabled: !!email,
+    // Only run query if we have a user email
+    staleTime: 5 * 60 * 1e3,
+    // Consider data fresh for 5 minutes
+    gcTime: 10 * 60 * 1e3,
+    // Keep in cache for 10 minutes
+    retry: 2
+    // Retry failed requests twice
+  });
+  return {
+    ...query2
+  };
+};
+var getOrganizationAccess = async (email) => {
+  const { limit: limit2, where: where2 } = api.accessQueryConstraints();
+  try {
+    const organizationSnapshot = await api.getDocs(
+      "organizations",
+      where2("members", "array-contains", email),
+      where2("masterSubscriptionStatus", "==", "active"),
+      limit2(1)
+    );
+    if (!organizationSnapshot.empty) {
+      const orgData = organizationSnapshot.data[0];
+      return {
+        hasUnlimitedAccess: true,
+        subscriptionId: orgData == null ? void 0 : orgData.masterSubscriptionId,
+        organizationId: orgData.id,
+        organizationName: orgData.name || "Unknown Organization",
+        subscriptionEndDate: orgData.masterSubscriptionEndDate || null,
+        accessType: "organization"
+      };
+    }
+    const institutionSnapshot = await api.getDocs(
+      "institution_subscriptions",
+      where2("users", "array-contains", email),
+      where2("active", "==", true),
+      limit2(1)
+    );
+    if (!institutionSnapshot.empty) {
+      const institutionData = institutionSnapshot.data[0];
+      const isUnlimited = (institutionData == null ? void 0 : institutionData.plan) === "organization" || (institutionData == null ? void 0 : institutionData.plan) === "school_starter";
+      return {
+        hasUnlimitedAccess: isUnlimited,
+        subscriptionId: institutionData.id,
+        organizationId: institutionData == null ? void 0 : institutionData.institutionId,
+        organizationName: institutionData.name || institutionData.institutionId || "Legacy Institution",
+        subscriptionEndDate: institutionData.endDate || null,
+        accessType: "institution_subscriptions"
+      };
+    }
+    return {
+      hasUnlimitedAccess: false,
+      subscriptionId: null,
+      organizationId: null,
+      organizationName: null,
+      subscriptionEndDate: null,
+      accessType: "individual"
+    };
+  } catch (error) {
+    console.error("Error checking organization access:", error);
+    return {
+      hasUnlimitedAccess: false,
+      subscriptionId: null,
+      organizationId: null,
+      organizationName: null,
+      subscriptionEndDate: null,
+      accessType: "individual"
+    };
+  }
+};
+
+// src/hooks/useSpeakableTranscript.ts
+var import_react_query7 = require("@tanstack/react-query");
+function useSpeakableTranscript() {
+  const mutation = (0, import_react_query7.useMutation)({
+    mutationFn: async ({
+      model,
+      audioUrl,
+      language,
+      prompt
+    }) => {
+      return getTranscript(model, { audioUrl, language, prompt });
+    },
+    retry: false
+  });
+  return {
+    mutation
+  };
+}
+function useSpeakableTranscriptCycle() {
+  const mutation = (0, import_react_query7.useMutation)({
+    mutationFn: async (args) => {
+      return getTranscriptCycle(args);
+    },
+    retry: false
+  });
+  return {
+    mutationTranscriptCycle: mutation
+  };
+}
+
+// src/hooks/useUpdateStudentVoc.ts
+var useUpdateStudentVocab = (page) => {
+  const { user } = useSpeakableApi();
+  const currentUserId = user == null ? void 0 : user.auth.uid;
+  if (!page || !currentUserId || !page.target_text || !page.language) {
+    return {
+      studentVocabMarkVoiceSuccess: void 0,
+      studentVocabMarkVoiceFail: void 0
+    };
+  }
+  const getDataObject = () => {
+    var _a, _b;
+    const { serverTimestamp: serverTimestamp2 } = api.accessHelpers();
+    const language = (_a = page.language) != null ? _a : "en";
+    const word = (_b = page.target_text) != null ? _b : "";
+    const phrase_length = getPhraseLength(word);
+    const wordHash = getWordHash(word, language);
+    const docPath = `users/${currentUserId}/vocab/${wordHash}`;
+    const communityPath = `checked-pronunciations/${wordHash}`;
+    const id = `${language}-${cleanString(word)}`;
+    const data = {
+      id,
+      word,
+      words: (word == null ? void 0 : word.split(" ")) || [],
+      wordHash,
+      language,
+      lastSeen: serverTimestamp2(),
+      phrase_length
+    };
+    return {
+      docPath,
+      communityPath,
+      data
+    };
+  };
+  const markVoiceSuccess = async () => {
+    const { docPath, communityPath, data } = getDataObject();
+    const { increment: increment2 } = api.accessQueryConstraints();
+    const { serverTimestamp: serverTimestamp2 } = api.accessHelpers();
+    data.voiceSuccess = increment2(1);
+    try {
+      await api.updateDoc(docPath, data);
+    } catch (error) {
+      if (error instanceof Error && "code" in error) {
+        const firebaseError = error;
+        if (firebaseError.code === "not-found") {
+          data.firstSeen = serverTimestamp2();
+          await api.setDoc(docPath, data, { merge: true });
+        } else {
+          console.error("Error actualizando vocabulario:", error);
+        }
+      } else {
+        console.error("Error desconocido:", error);
+      }
+    }
+    try {
+      data.pronunciations = increment2(1);
+      await api.setDoc(communityPath, data, { merge: true });
+    } catch (error) {
+      console.log(error);
+    }
+  };
+  const markVoiceFail = async () => {
+    const { docPath, communityPath, data } = getDataObject();
+    const { increment: increment2 } = api.accessQueryConstraints();
+    const { serverTimestamp: serverTimestamp2 } = api.accessHelpers();
+    data.voiceFail = increment2(1);
+    try {
+      await api.updateDoc(docPath, data);
+    } catch (error) {
+      if (error instanceof Error && error.message === "not-found") {
+        data.firstSeen = serverTimestamp2();
+        await api.setDoc(docPath, data, { merge: true });
+      } else {
+        console.log(error);
+      }
+    }
+    try {
+      data.fails = increment2(1);
+      await api.setDoc(communityPath, data, { merge: true });
+    } catch (error) {
+      console.log(error);
+    }
+  };
+  return {
+    studentVocabMarkVoiceSuccess: markVoiceSuccess,
+    studentVocabMarkVoiceFail: markVoiceFail
+  };
+};
+
+// src/hooks/useActivityFeedbackAccess.ts
+var import_react_query8 = require("@tanstack/react-query");
+var activityFeedbackAccessQueryKeys = {
+  activityFeedbackAccess: (args) => ["activityFeedbackAccess", ...Object.values(args)]
+};
+var useActivityFeedbackAccess = ({
+  aiEnabled = false,
+  isActivityRoute = false
+}) => {
+  var _a, _b, _c;
+  const { user } = useSpeakableApi();
+  const uid = user.auth.uid;
+  const isTeacher = (_a = user.profile) == null ? void 0 : _a.isTeacher;
+  const isStudent = (_b = user.profile) == null ? void 0 : _b.isStudent;
+  const userRoles = ((_c = user.profile) == null ? void 0 : _c.roles) || [];
+  const query2 = (0, import_react_query8.useQuery)({
+    queryKey: activityFeedbackAccessQueryKeys.activityFeedbackAccess({
+      aiEnabled,
+      isActivityRoute
+    }),
+    queryFn: async () => {
+      var _a2, _b2, _c2;
+      if (!uid) {
+        return {
+          canAccessFeedback: false,
+          reason: "Missing user ID",
+          isUnlimited: false,
+          accessType: "none"
+        };
+      }
+      try {
+        if (aiEnabled) {
+          return {
+            canAccessFeedback: true,
+            reason: "AI feedback enabled",
+            isUnlimited: true,
+            accessType: "ai_enabled"
+          };
+        }
+        if (isTeacher || userRoles.includes("ADMIN")) {
+          return {
+            canAccessFeedback: true,
+            reason: "Teacher preview access",
+            isUnlimited: true,
+            accessType: "teacher_preview"
+          };
+        }
+        if (isStudent && isActivityRoute) {
+          try {
+            const result = await ((_c2 = (_b2 = (_a2 = api).httpsCallable) == null ? void 0 : _b2.call(_a2, "checkStudentTeacherPlan")) == null ? void 0 : _c2({
+              studentId: uid
+            }));
+            const planCheckResult = result.data;
+            if (planCheckResult.canAccessFeedback) {
+              return {
+                canAccessFeedback: true,
+                reason: planCheckResult.reason || "Student access via teacher with active plan",
+                isUnlimited: planCheckResult.hasTeacherWithUnlimitedAccess,
+                accessType: "student_with_teacher_plan"
+              };
+            } else {
+              return {
+                canAccessFeedback: false,
+                reason: planCheckResult.reason || "No teacher with active plan found",
+                isUnlimited: false,
+                accessType: "none"
+              };
+            }
+          } catch (error) {
+            console.error("Error checking student teacher plan:", error);
+            return {
+              canAccessFeedback: false,
+              reason: "Error checking teacher plans",
+              isUnlimited: false,
+              accessType: "none"
+            };
+          }
+        }
+        return {
+          canAccessFeedback: false,
+          reason: "No access permissions found for current context",
+          isUnlimited: false,
+          accessType: "none"
+        };
+      } catch (error) {
+        console.error("Error checking activity feedback access:", error);
+        return {
+          canAccessFeedback: false,
+          reason: "Error checking access permissions",
+          isUnlimited: false,
+          accessType: "none"
+        };
+      }
+    },
+    enabled: !!uid,
+    staleTime: 5 * 60 * 1e3,
+    // 5 minutes
+    gcTime: 10 * 60 * 1e3
+    // 10 minutes
+  });
+  return {
+    ...query2
+  };
+};
+
+// src/hooks/useOpenAI.ts
+var useBaseOpenAI = ({
+  onTranscriptSuccess,
+  onTranscriptError,
+  onCompletionSuccess,
+  onCompletionError,
+  aiEnabled,
+  submitAudioResponse,
+  uploadAudioAndGetTranscript,
+  onGetAudioUrlAndTranscript
+}) => {
+  const { user, queryClient } = useSpeakableApi();
+  const currentUserId = user.auth.uid;
+  const { data: feedbackAccess } = useActivityFeedbackAccess({
+    aiEnabled
+  });
+  const getTranscript2 = async (audioUrl, language, prompt) => {
+    var _a, _b, _c, _d, _e, _f;
+    const getGeminiTranscript = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "getGeminiTranscript");
+    const getAssemblyAITranscript = (_d = (_c = api).httpsCallable) == null ? void 0 : _d.call(_c, "transcribeAssemblyAIAudio");
+    const getWhisperTranscript = (_f = (_e = api).httpsCallable) == null ? void 0 : _f.call(_e, "transcribeAudio");
+    try {
+      const { data } = await (getWhisperTranscript == null ? void 0 : getWhisperTranscript({
+        audioUrl,
+        language
+      }));
+      const transcript = data;
+      if (transcript) {
+        return transcript;
+      }
+    } catch (error) {
+      console.log("Whisper transcript failed, trying Gemini fallback:", error);
+    }
+    try {
+      const { data } = await (getGeminiTranscript == null ? void 0 : getGeminiTranscript({
+        audioUrl,
+        targetLanguage: language,
+        prompt: prompt || ""
+      }));
+      const transcript = data.transcript;
+      if (transcript) {
+        return transcript;
+      }
+    } catch (error) {
+      console.log("Gemini transcript failed, trying AssemblyAI fallback:", error);
+    }
+    try {
+      const response = await (getAssemblyAITranscript == null ? void 0 : getAssemblyAITranscript({
+        audioUrl,
+        language
+      }));
+      const transcript = response == null ? void 0 : response.data;
+      if (transcript) {
+        return transcript;
+      }
+      throw new Error("Both transcript services failed");
+    } catch (error) {
+      console.log("AssemblyAI transcript also failed:", error);
+      onTranscriptError({
+        type: "TRANSCRIPT",
+        message: (error == null ? void 0 : error.message) || "Error getting transcript from both services"
+      });
+      throw new Error(error);
+    }
+  };
+  const getFreeResponseCompletion = async (messages, isFreeResponse, feedbackLanguage, gradingStandard = "actfl") => {
+    var _a, _b, _c, _d, _e;
+    const responseTool = getRespondCardTool({
+      language: feedbackLanguage,
+      standard: gradingStandard
+    });
+    try {
+      const createChatCompletion = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "createChatCompletion");
+      const {
+        data: {
+          response,
+          prompt_tokens = 0,
+          completion_tokens = 0,
+          success: aiSuccess = false
+          // the AI was able to generate a response
+        }
+      } = await (createChatCompletion == null ? void 0 : createChatCompletion({
+        chat: {
+          model: isFreeResponse ? "gpt-4-1106-preview" : "gpt-3.5-turbo-1106",
+          messages,
+          temperature: 0.7,
+          ...responseTool
+        },
+        type: isFreeResponse ? "LONG_RESPONSE" : "SHORT_RESPONSE"
+      }));
+      const functionArguments = JSON.parse(((_e = (_d = (_c = response == null ? void 0 : response.tool_calls) == null ? void 0 : _c[0]) == null ? void 0 : _d.function) == null ? void 0 : _e.arguments) || "{}");
+      const result = {
+        ...functionArguments,
+        prompt_tokens,
+        completion_tokens,
+        aiSuccess
+      };
+      onCompletionSuccess(result);
+      return result;
+    } catch (error) {
+      onCompletionError({
+        type: "COMPLETION",
+        message: (error == null ? void 0 : error.message) || "Error getting completion"
+      });
+      throw new Error(error);
+    }
+  };
+  const getFeedback = async ({
+    cardId,
+    language = "en",
+    // required
+    writtenResponse = null,
+    // if the type = RESPOND_WRITE
+    audio = null,
+    autoGrade = true,
+    file = null,
+    pagePrompt = null
+  }) => {
+    try {
+      if (!(feedbackAccess == null ? void 0 : feedbackAccess.canAccessFeedback)) {
+        const result = {
+          noFeedbackAvailable: true,
+          success: true,
+          reason: (feedbackAccess == null ? void 0 : feedbackAccess.reason) || "No feedback access",
+          accessType: (feedbackAccess == null ? void 0 : feedbackAccess.accessType) || "none"
+        };
+        onCompletionSuccess(result);
+        return result;
+      }
+      let transcript;
+      let audioUrl = void 0;
+      if (writtenResponse) {
+        transcript = writtenResponse;
+        onTranscriptSuccess(writtenResponse);
+      } else if (typeof audio === "string" && file) {
+        if (feedbackAccess == null ? void 0 : feedbackAccess.canAccessFeedback) {
+          transcript = await getTranscript2(audio, language, pagePrompt != null ? pagePrompt : "");
+          audioUrl = audio;
+          onTranscriptSuccess(transcript);
+        } else {
+          console.info(
+            `Transcript not available: ${(feedbackAccess == null ? void 0 : feedbackAccess.reason) || "No feedback access"}`
+          );
+        }
+      } else {
+        const response = await uploadAudioAndGetTranscript(audio || "", language, pagePrompt != null ? pagePrompt : "");
+        transcript = response.transcript;
+        audioUrl = response.audioUrl;
+      }
+      onGetAudioUrlAndTranscript == null ? void 0 : onGetAudioUrlAndTranscript({ transcript, audioUrl });
+      if (feedbackAccess == null ? void 0 : feedbackAccess.canAccessFeedback) {
+        const results = await getAIResponse({
+          cardId,
+          transcript: transcript || ""
+        });
+        let output = results;
+        if (!autoGrade) {
+          output = {
+            ...output,
+            noFeedbackAvailable: true,
+            success: true
+          };
+        }
+        onCompletionSuccess(output);
+        return output;
+      } else {
+        const result = {
+          noFeedbackAvailable: true,
+          success: true,
+          reason: (feedbackAccess == null ? void 0 : feedbackAccess.reason) || "No feedback access",
+          accessType: (feedbackAccess == null ? void 0 : feedbackAccess.accessType) || "none"
+        };
+        onCompletionSuccess(result);
+        return result;
+      }
+    } catch (error) {
+      console.error("Error getting feedback:", error);
+      throw new Error(error);
+    }
+  };
+  const onGetGeminiFeedback = async ({
+    cardId,
+    studentId,
+    studentResponse
+  }) => {
+    var _a, _b;
+    try {
+      const getGeminiFeedback = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "callGetFeedback");
+      return await (getGeminiFeedback == null ? void 0 : getGeminiFeedback({
+        cardId,
+        studentId,
+        studentResponse
+      }));
+    } catch (error) {
+      console.error("Error getting Gemini feedback:", error);
+      throw error;
+    }
+  };
+  const onGetProficiencyEstimate = async ({
+    cardId,
+    studentId,
+    studentResponse
+  }) => {
+    var _a, _b;
+    try {
+      const getProficiencyEstimate = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "getProficiencyEstimate");
+      return await (getProficiencyEstimate == null ? void 0 : getProficiencyEstimate({
+        cardId,
+        studentId,
+        studentResponse
+      }));
+    } catch (error) {
+      console.error("Error getting proficiency estimate:", error);
+      return {};
+    }
+  };
+  const getAIResponse = async ({ cardId, transcript }) => {
+    var _a;
+    try {
+      const card = getCardFromCache({
+        cardId,
+        queryClient
+      });
+      let feedbackData;
+      let proficiencyData = {};
+      if (card && card.grading_method === "manual") {
+      } else if (card && card.grading_method !== "standards_based") {
+        const [geminiResult, proficiencyResult] = await Promise.all([
+          onGetGeminiFeedback == null ? void 0 : onGetGeminiFeedback({
+            cardId,
+            studentId: currentUserId,
+            studentResponse: transcript
+          }),
+          onGetProficiencyEstimate == null ? void 0 : onGetProficiencyEstimate({
+            cardId,
+            studentId: currentUserId,
+            studentResponse: transcript
+          })
+        ]);
+        proficiencyData = (proficiencyResult == null ? void 0 : proficiencyResult.data) || {};
+        feedbackData = {
+          ...(_a = geminiResult == null ? void 0 : geminiResult.data) != null ? _a : {},
+          // @ts-ignore
+          proficiency_level: (proficiencyData == null ? void 0 : proficiencyData.proficiency_level) || null
+        };
+      } else {
+        const geminiResult = await (onGetGeminiFeedback == null ? void 0 : onGetGeminiFeedback({
+          cardId,
+          studentId: currentUserId,
+          studentResponse: transcript
+        }));
+        feedbackData = geminiResult == null ? void 0 : geminiResult.data;
+      }
+      const results = {
+        ...proficiencyData,
+        ...feedbackData,
+        aiSuccess: true,
+        promptSuccess: (feedbackData == null ? void 0 : feedbackData.success) || false,
+        transcript
+      };
+      return results;
+    } catch (error) {
+      onCompletionError({
+        type: "AI_FEEDBACK",
+        message: (error == null ? void 0 : error.message) || "Error getting ai feedback"
+      });
+      throw new Error(error);
+    }
+  };
+  return {
+    submitAudioResponse,
+    uploadAudioAndGetTranscript,
+    getTranscript: getTranscript2,
+    getFreeResponseCompletion,
+    getFeedback
+  };
+};
+
+// src/lib/create-firebase-client-native.ts
+var import_firestore = require("@react-native-firebase/firestore");
+
+// src/lib/create-firebase-client.ts
+function createFsClientBase({
+  db,
+  helpers,
+  httpsCallable,
+  logEvent
+}) {
+  const dbAsFirestore = db;
+  api.initialize({
+    db: dbAsFirestore,
+    helpers,
+    httpsCallable,
+    logEvent
+  });
+  return {
+    assignmentRepo: createAssignmentRepo(),
+    cardRepo: createCardRepo()
+  };
+}
+
+// src/lib/create-firebase-client-native.ts
+var createFsClientNative = ({ db, httpsCallable, logEvent }) => {
+  return createFsClientBase({
+    db,
+    httpsCallable,
+    logEvent,
+    helpers: {
+      getDoc: import_firestore.getDoc,
+      getDocs: import_firestore.getDocs,
+      addDoc: import_firestore.addDoc,
+      setDoc: import_firestore.setDoc,
+      updateDoc: import_firestore.updateDoc,
+      deleteDoc: import_firestore.deleteDoc,
+      runTransaction: import_firestore.runTransaction,
+      writeBatch: import_firestore.writeBatch,
+      doc: import_firestore.doc,
+      collection: import_firestore.collection,
+      query: import_firestore.query,
+      serverTimestamp: import_firestore.serverTimestamp,
+      orderBy: import_firestore.orderBy,
+      limit: import_firestore.limit,
+      startAt: import_firestore.startAt,
+      startAfter: import_firestore.startAfter,
+      endAt: import_firestore.endAt,
+      endBefore: import_firestore.endBefore,
+      where: import_firestore.where,
+      increment: import_firestore.increment
+    }
+  });
+};
+//# sourceMappingURL=index.native.js.map