@speakableio/core 0.1.106 → 1.0.0

package/dist/hooks.js

@@ -1,38 +1,3 @@
-import {
-  logStartAssignment,
-  logSubmitAssignment
-} from "./chunk-YKUMIPSO.js";
-import {
-  ANALYTICS_PLANS,
-  ASSIGNMENT_SETTINGS_PLANS,
-  SPEAKABLE_NOTIFICATIONS,
-  SpeakableNotificationTypes,
-  WEB_BASE_URL,
-  refsScoresPractice
-} from "./chunk-2CRI5MJP.js";
-import "./chunk-YO34TZYN.js";
-import {
-  getSet
-} from "./chunk-EEBMPASA.js";
-import {
-  createCard,
-  createCards,
-  getCard,
-  withErrorHandler
-} from "./chunk-233VJDUF.js";
-import "./chunk-H5XNOXRC.js";
-import {
-  refsAssignmentFiresotre
-} from "./chunk-AWVUNWML.js";
-import {
-  calculateScoreAndProgress_default,
-  defaultScore
-} from "./chunk-YMJRCINF.js";
-import {
-  api
-} from "./chunk-CJ5JXKII.js";
-import "./chunk-LZG3MTSH.js";
-
 // src/providers/SpeakableProvider.tsx
 import { createContext, useContext, useEffect, useState } from "react";
 import { jsx } from "react/jsx-runtime";
@@ -107,6 +72,162 @@ var handleOptimisticUpdate = async ({
   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();
@@ -135,6 +256,131 @@ var usePermissions = () => {
 };
 var usePermissions_default = usePermissions;
 
+// 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, orderBy, limit, startAt, startAfter, endAt, endBefore, where, increment } = this.helpers;
+    return {
+      query,
+      orderBy,
+      limit,
+      startAt,
+      startAfter,
+      endAt,
+      endBefore,
+      where,
+      increment
+    };
+  }
+  accessHelpers() {
+    const { doc, collection, writeBatch, serverTimestamp, setDoc } = this.helpers;
+    return {
+      doc: (path) => doc(this.db, path),
+      collection: (path) => collection(this.db, path),
+      writeBatch: () => writeBatch(this.db),
+      serverTimestamp,
+      setDoc
+    };
+  }
+  async getDoc(path) {
+    const { getDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    const docSnap = await getDoc(docRef);
+    const data = docSnap.exists() ? {
+      ...docSnap.data(),
+      id: docSnap.id
+    } : null;
+    return {
+      id: docSnap.id,
+      data
+    };
+  }
+  async getDocs(path, ...queryConstraints) {
+    const { getDocs, query, collection } = this.helpers;
+    const collectionRef = collection(this.db, path);
+    const q = queryConstraints.length > 0 ? query(collectionRef, ...queryConstraints) : collectionRef;
+    const querySnapshot = await getDocs(q);
+    const data = querySnapshot.docs.map((doc) => ({
+      data: doc.data(),
+      id: doc.id
+    }));
+    return {
+      data,
+      querySnapshot,
+      empty: querySnapshot.empty
+    };
+  }
+  async addDoc(path, data) {
+    const { addDoc, collection } = this.helpers;
+    const collectionRef = collection(this.db, path);
+    const docRef = await addDoc(collectionRef, data);
+    return {
+      ...data,
+      id: docRef.id
+    };
+  }
+  async setDoc(path, data, options = {}) {
+    const { setDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    await setDoc(docRef, data, options);
+  }
+  async updateDoc(path, data) {
+    const { updateDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    await updateDoc(docRef, data);
+  }
+  async deleteDoc(path) {
+    const { deleteDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    await deleteDoc(docRef);
+  }
+  async runTransaction(updateFunction) {
+    const { runTransaction } = this.helpers;
+    return runTransaction(this.db, updateFunction);
+  }
+  async runBatch(operations) {
+    const { writeBatch } = this.helpers;
+    const batch = writeBatch(this.db);
+    await Promise.all(operations.map((op) => op()));
+    await batch.commit();
+  }
+  writeBatch() {
+    const { writeBatch } = this.helpers;
+    const batch = writeBatch(this.db);
+    return batch;
+  }
+};
+var api = FirebaseAPI.getInstance();
+
 // src/hooks/useGoogleClassroom.ts
 var useGoogleClassroom = () => {
   const submitAssignmentToGoogleClassroom = async ({
@@ -163,7 +409,10 @@ var useGoogleClassroom = () => {
       }));
       return result;
     } catch (error) {
-      return { error: true, message: error.message };
+      if (error instanceof Error) {
+        return { error: true, message: error.message };
+      }
+      return { error: true, message: "Unknown error" };
     }
   };
   return {
@@ -171,9 +420,129 @@ var useGoogleClassroom = () => {
   };
 };
 
+// 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 ANALYTICS_EVENT_TYPES = {
+  VOICE_SUCCESS: "voice_success",
+  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"
+};
+
+// 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: ANALYTICS_EVENT_TYPES.SUBMISSION,
+    ...data
+  });
+  api.logEvent(ANALYTICS_EVENT_TYPES.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: ANALYTICS_EVENT_TYPES.ASSIGNMENT_STARTED,
+      ...data
+    });
+  }
+  api.logEvent(ANALYTICS_EVENT_TYPES.ASSIGNMENT_STARTED, data);
+};
+
 // src/domains/notification/services/create-notification.service.ts
 import dayjs from "dayjs";
 
+// src/constants/web.constants.ts
+var WEB_BASE_URL = "https://app.speakable.io";
+
+// 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/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) {
+      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/domains/notification/services/send-notification.service.ts
 var _sendNotification = async (sendTo, notification) => {
   var _a, _b, _c;
@@ -333,6 +702,49 @@ var useCreateNotification = () => {
   };
 };
 
+// src/domains/assignment/assignment.constants.ts
+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/utils/create-default-score.ts
+var defaultScore = (props) => {
+  const { serverTimestamp } = api.accessHelpers();
+  const score = {
+    progress: 0,
+    score: 0,
+    startDate: serverTimestamp(),
+    status: "IN_PROGRESS",
+    submitted: false,
+    cards: {},
+    lastPlayed: serverTimestamp(),
+    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
 async function _createScore(params) {
   var _a, _b, _c;
@@ -444,6 +856,42 @@ async function _getScore(params) {
 }
 var getScore = withErrorHandler(_getScore, "getScore");
 
+// src/domains/assignment/utils/calculateScoreAndProgress.ts
+var calculateScoreAndProgress = (scores, cardsList, weights) => {
+  const totalSetPoints = cardsList.reduce((acc, cardId) => {
+    acc += (weights == null ? void 0 : weights[cardId]) || 1;
+    return acc;
+  }, 0);
+  const totalPointsAwarded = Object.keys((scores == null ? void 0 : scores.cards) || {}).reduce((acc, cardId) => {
+    var _a, _b;
+    const cardScores = (_a = scores == null ? void 0 : scores.cards) == null ? void 0 : _a[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((_b = cardScores == null ? void 0 : cardScores.score) != null ? _b : 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((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 == 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({
@@ -885,9 +1333,177 @@ function useSubmitPracticeScore() {
   };
 }
 
+// src/hooks/useActivity.ts
+import { useEffect as useEffect2 } from "react";
+
+// src/domains/sets/set.hooks.ts
+import { useQuery as useQuery3 } from "@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 useQuery3({
+    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/cards/card.hooks.ts
-import { useMutation as useMutation2, useQueries, useQuery as useQuery3 } from "@tanstack/react-query";
+import { useMutation as useMutation2, useQueries, useQuery as useQuery4 } from "@tanstack/react-query";
 import { useMemo } from "react";
+
+// src/domains/cards/card.constants.ts
+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;
+  return response.data;
+}
+var getCard = withErrorHandler(_getCard, "getCard");
+
+// src/domains/cards/services/create-card.service.ts
+import { v4 } from "uuid";
+
+// src/utils/text-utils.ts
+import sha1 from "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 = 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, doc } = api.accessHelpers();
+  const batch = writeBatch();
+  const cardsWithId = [];
+  for (const card of cards) {
+    const cardId = v4();
+    const ref = doc(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]
@@ -954,7 +1570,7 @@ function updateCardInCache({
   queryClient.setQueryData(cardsQueryKeys.one({ cardId }), card);
 }
 function useGetCard({ cardId, enabled = true }) {
-  const query = useQuery3({
+  const query = useQuery4({
     queryKey: cardsQueryKeys.one({ cardId }),
     queryFn: () => getCard({ cardId }),
     enabled: enabled && !!cardId
@@ -962,34 +1578,1095 @@ function useGetCard({ cardId, enabled = true }) {
   return query;
 }
 
-// src/domains/sets/set.hooks.ts
-import { useQuery as useQuery4 } from "@tanstack/react-query";
-var setsQueryKeys = {
-  all: ["sets"],
-  one: (params) => [...setsQueryKeys.all, params.setId]
+// 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);
 };
-var useSet = ({ setId, enabled }) => {
-  return useQuery4({
-    queryKey: setsQueryKeys.one({ setId }),
-    queryFn: () => getSet({ setId }),
-    enabled: setId !== void 0 && setId !== "" && enabled
-  });
-};
-function getSetFromCache({
-  setId,
-  queryClient
+
+// src/hooks/useActivityTracker.ts
+import { v4 as v42 } from "uuid";
+function useActivityTracker({ userId }) {
+  const trackActivity = async ({
+    activityName,
+    activityType,
+    id = v42(),
+    language = ""
+  }) => {
+    if (userId) {
+      const { doc, serverTimestamp, setDoc } = api.accessHelpers();
+      const activityRef = doc(`users/${userId}/activity/${id}`);
+      const timestamp = serverTimestamp();
+      await setDoc(activityRef, {
+        name: activityName,
+        type: activityType,
+        lastSeen: timestamp,
+        id,
+        language
+      });
+    }
+  };
+  return {
+    trackActivity
+  };
+}
+
+// src/hooks/useActivity.ts
+function useActivity({
+  id,
+  isAssignment,
+  onAssignmentSubmitted,
+  ltiData
 }) {
-  if (!setId) return null;
-  return queryClient.getQueryData(setsQueryKeys.one({ setId }));
+  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 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: contentCardsToUse != null ? contentCardsToUse : [],
+    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, _x;
+    try {
+      let results;
+      if (isAssignment) {
+        const cardScores = ((_a2 = scoreQuery.data) == null ? void 0 : _a2.cards) || {};
+        const hasPendingReview = Object.values(cardScores).some(
+          (cardScore) => cardScore.status === "pending_review"
+        );
+        results = await submitAssignmentScore2({
+          assignment: {
+            id: (_c = (_b2 = assignmentQuery.data) == null ? void 0 : _b2.id) != null ? _c : "",
+            name: (_e = (_d = assignmentQuery.data) == null ? void 0 : _d.name) != null ? _e : "",
+            owners: (_g = (_f = assignmentQuery.data) == null ? void 0 : _f.owners) != null ? _g : [],
+            courseId: (_i = (_h = assignmentQuery.data) == null ? void 0 : _h.courseId) != null ? _i : "",
+            courseWorkId: (_k = (_j = assignmentQuery.data) == null ? void 0 : _j.courseWorkId) != null ? _k : "",
+            isAssessment: (_m = (_l = assignmentQuery.data) == null ? void 0 : _l.isAssessment) != null ? _m : false,
+            maxPoints: (_o = (_n = assignmentQuery.data) == null ? void 0 : _n.maxPoints) != null ? _o : 0
+          },
+          userId,
+          cardIds: contentCardsToUse != null ? contentCardsToUse : [],
+          scores: scoreQuery.data,
+          weights: weightsToUse != null ? weightsToUse : {},
+          status: hasPendingReview ? "PENDING_REVIEW" : "FINALIZED"
+        });
+        if ((_p = assignmentQuery.data) == null ? void 0 : _p.ltiDeeplink) {
+          submitLTIScore({
+            maxPoints: (_q = assignmentQuery.data) == null ? void 0 : _q.maxPoints,
+            score: (_s = (_r = scoreQuery.data) == null ? void 0 : _r.score) != null ? _s : 0,
+            SERVICE_KEY: (_t = ltiData == null ? void 0 : ltiData.serviceKey) != null ? _t : "",
+            lineItemId: (_u = ltiData == null ? void 0 : ltiData.lineItemId) != null ? _u : "",
+            lti_id: (_v = ltiData == null ? void 0 : ltiData.lti_id) != null ? _v : ""
+          });
+        }
+      } else {
+        results = await submitPracticeScore2({
+          setId: (_x = (_w = querySet.data) == null ? void 0 : _w.id) != null ? _x : "",
+          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 serverTimestamp = 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: serverTimestamp(),
+        language: (_i = card == null ? void 0 : card.language) != null ? _i : ""
+      },
+      userId
+    );
+  };
+  useEffect2(() => {
+    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
+      }
+    }
+  };
 }
-function updateSetInCache({
+var useInitActivity = ({
+  assignment,
   set,
-  queryClient
-}) {
-  const { id, ...setData } = set;
-  queryClient.setQueryData(setsQueryKeys.one({ setId: id }), setData);
+  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
+    });
+  };
+  useEffect2(() => {
+    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/useActivityFeedbackAccess.ts
+import { useQuery as useQuery5 } from "@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 query = useQuery5({
+    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 {
+    ...query
+  };
+};
+
+// 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/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 getTranscript = async (audioUrl, language) => {
+    var _a, _b;
+    try {
+      const getAssemblyAITranscript = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "transcribeAssemblyAIAudio");
+      const response = await (getAssemblyAITranscript == null ? void 0 : getAssemblyAITranscript({
+        audioUrl,
+        language
+      }));
+      const transcript = response == null ? void 0 : response.data;
+      return transcript;
+    } catch (error) {
+      console.log("error", error);
+      onTranscriptError({
+        type: "TRANSCRIPT",
+        message: (error == null ? void 0 : error.message) || "Error getting transcript"
+      });
+      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
+  }) => {
+    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 getTranscript(audio, language);
+          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);
+        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 getAIResponse = async ({ cardId, transcript }) => {
+    var _a, _b, _c, _d, _e;
+    try {
+      const getGeminiFeedback = (_b = (_a = api).httpsCallable) == null ? void 0 : _b.call(_a, "callGetFeedback");
+      const getProficiencyEstimate = (_d = (_c = api).httpsCallable) == null ? void 0 : _d.call(_c, "getProficiencyEstimate");
+      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([
+          getGeminiFeedback == null ? void 0 : getGeminiFeedback({
+            cardId,
+            studentId: currentUserId,
+            studentResponse: transcript
+          }),
+          getProficiencyEstimate == null ? void 0 : getProficiencyEstimate({
+            cardId,
+            studentId: currentUserId,
+            studentResponse: transcript
+          })
+        ]);
+        proficiencyData = (proficiencyResult == null ? void 0 : proficiencyResult.data) || {};
+        feedbackData = {
+          ...(_e = geminiResult == null ? void 0 : geminiResult.data) != null ? _e : {},
+          // @ts-ignore
+          proficiency_level: (proficiencyData == null ? void 0 : proficiencyData.proficiency_level) || null
+        };
+      } else {
+        const geminiResult = await (getGeminiFeedback == null ? void 0 : getGeminiFeedback({
+          cardId,
+          studentId: currentUserId,
+          studentResponse: transcript
+        }));
+        feedbackData = geminiResult == null ? void 0 : geminiResult.data;
+      }
+      const results = {
+        ...feedbackData,
+        // ...proficiencyData,
+        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,
+    getFreeResponseCompletion,
+    getFeedback
+  };
+};
+
+// src/hooks/useUserPlan.ts
+function useUserPlan() {
+  const { permissions } = useSpeakableApi();
+  const checkIsTeacherProPlan = (plan) => plan === SpeakablePlanTypes.teacher_pro || plan === SpeakablePlanTypes.starter;
+  const checkIsOrganizationPlan = (plan) => plan === SpeakablePlanTypes.organization || plan === SpeakablePlanTypes.professional || plan === SpeakablePlanTypes.growth;
+  const checkIsSchoolStarter = (plan) => plan === SpeakablePlanTypes.school_starter;
+  const checkIsFreePlan = (plan) => plan === SpeakablePlanTypes.basic || !plan;
+  return {
+    userPlan: permissions.plan,
+    loaded: !!permissions.plan,
+    isFreePlan: checkIsFreePlan(permissions.plan),
+    isTeacherProPlan: checkIsTeacherProPlan(permissions.plan),
+    isOrganizationPlan: checkIsOrganizationPlan(permissions.plan),
+    isSchoolStarter: checkIsSchoolStarter(permissions.plan),
+    checkIsFreePlan,
+    checkIsTeacherProPlan,
+    checkIsOrganizationPlan
+  };
 }
+
+// src/hooks/useOrganizationAccess.ts
+import { useQuery as useQuery6 } from "@tanstack/react-query";
+var useOrganizationAccess = () => {
+  const { user } = useSpeakableApi();
+  const email = user.auth.email;
+  const query = useQuery6({
+    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 {
+    ...query
+  };
+};
+var getOrganizationAccess = async (email) => {
+  const { limit, where } = api.accessQueryConstraints();
+  try {
+    const organizationSnapshot = await api.getDocs(
+      "organizations",
+      where("members", "array-contains", email),
+      where("masterSubscriptionStatus", "==", "active"),
+      limit(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",
+      where("users", "array-contains", email),
+      where("active", "==", true),
+      limit(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/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 } = 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: serverTimestamp(),
+      phrase_length
+    };
+    return {
+      docPath,
+      communityPath,
+      data
+    };
+  };
+  const markVoiceSuccess = async () => {
+    const { docPath, communityPath, data } = getDataObject();
+    const { increment } = api.accessQueryConstraints();
+    const { serverTimestamp } = api.accessHelpers();
+    data.voiceSuccess = increment(1);
+    try {
+      await api.updateDoc(docPath, data);
+    } catch (error) {
+      if (error instanceof Error && error.message === "not-found") {
+        data.firstSeen = serverTimestamp();
+        await api.setDoc(docPath, data, { merge: true });
+      } else {
+        console.log(error);
+      }
+    }
+    try {
+      data.pronunciations = increment(1);
+      await api.setDoc(communityPath, data, { merge: true });
+    } catch (error) {
+      console.log(error);
+    }
+  };
+  const markVoiceFail = async () => {
+    const { docPath, communityPath, data } = getDataObject();
+    const { increment } = api.accessQueryConstraints();
+    const { serverTimestamp } = api.accessHelpers();
+    data.voiceFail = increment(1);
+    try {
+      await api.updateDoc(docPath, data);
+    } catch (error) {
+      if (error instanceof Error && error.message === "not-found") {
+        data.firstSeen = serverTimestamp();
+        await api.setDoc(docPath, data, { merge: true });
+      } else {
+        console.log(error);
+      }
+    }
+    try {
+      data.fails = increment(1);
+      await api.setDoc(communityPath, data, { merge: true });
+    } catch (error) {
+      console.log(error);
+    }
+  };
+  return {
+    studentVocabMarkVoiceSuccess: markVoiceSuccess,
+    studentVocabMarkVoiceFail: markVoiceFail
+  };
+};
 export {
+  activityFeedbackAccessQueryKeys,
   assignmentQueryKeys,
   cardsQueryKeys,
   getCardFromCache,
@@ -998,18 +2675,25 @@ export {
   setsQueryKeys,
   updateCardInCache,
   updateSetInCache,
+  useActivity,
+  useActivityFeedbackAccess,
   useAssignment,
+  useBaseOpenAI,
   useCards,
   useClearScore,
   useCreateCard,
   useCreateCards,
   useCreateNotification,
   useGetCard,
+  useGoogleClassroom,
+  useOrganizationAccess,
   useScore,
   useSet,
   useSubmitAssignmentScore,
   useSubmitPracticeScore,
   useUpdateCardScore,
-  useUpdateScore
+  useUpdateScore,
+  useUpdateStudentVocab,
+  useUserPlan
 };
 //# sourceMappingURL=hooks.js.map