@vue-skuilder/cli 0.1.22 → 0.1.23

package/dist/standalone-ui-template/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.22",
+  "version": "0.1.23",
   "type": "module",
   "main": "./dist-lib/questions.cjs.js",
   "module": "./dist-lib/questions.mjs",
@@ -58,5 +58,5 @@
     "vue-tsc": "^1.8.0",
     "wait-on": "8.0.2"
   },
-  "stableVersion": "0.1.22"
+  "stableVersion": "0.1.23"
 }

package/dist/standalone-ui-template/src/router/index.ts

@@ -5,6 +5,7 @@ import ProgressView from '../views/ProgressView.vue';
 import BrowseView from '../views/BrowseView.vue';
 import UserStatsView from '../views/UserStatsView.vue';
 import UserSettingsView from '../views/UserSettingsView.vue';
+import AdminRegisterQuestionsView from '../views/AdminRegisterQuestionsView.vue';
 import { UserLogin, UserRegistration } from '@vue-skuilder/common-ui';
 
 const routes: Array<RouteRecordRaw> = [
@@ -55,6 +56,14 @@ const routes: Array<RouteRecordRaw> = [
     component: () => import('../views/TagViewer.vue'),
     props: true,
   },
+  {
+    path: '/admin/register-questions',
+    name: 'AdminRegisterQuestions',
+    component: AdminRegisterQuestionsView,
+    meta: {
+      requiresAuth: true,
+    },
+  },
 ];
 
 const router = createRouter({
@@ -62,4 +71,25 @@ const router = createRouter({
   routes,
 });
 
+// Navigation guard for protected routes
+router.beforeEach(async (to, _from, next) => {
+  // Check if route requires authentication
+  if (to.meta.requiresAuth) {
+    // Dynamically import auth store to avoid circular dependencies
+    const { useAuthStore } = await import('@vue-skuilder/common-ui');
+    const authStore = useAuthStore();
+
+    if (!authStore.currentUser) {
+      // Redirect to login with return path
+      next({
+        name: 'login',
+        query: { redirect: to.fullPath },
+      });
+      return;
+    }
+  }
+
+  next();
+});
+
 export default router;

package/dist/standalone-ui-template/src/views/AdminRegisterQuestionsView.vue

@@ -0,0 +1,306 @@
+<template>
+  <v-container>
+    <v-card>
+      <v-card-title class="text-h4 mb-4">
+        Register Question Types
+      </v-card-title>
+
+      <!-- Static Mode Warning -->
+      <v-alert v-if="isStaticMode" type="warning" variant="tonal" class="ma-4">
+        <v-alert-title>Static Mode Detected</v-alert-title>
+        <p class="mb-2">
+          Question type registration is not available in static mode.
+        </p>
+        <p class="mb-2">
+          To register custom question types, use Studio mode:
+        </p>
+        <v-code tag="pre" class="text-caption">yarn studio</v-code>
+        <p class="mt-2">
+          Studio mode provides a development environment with full database access for registering question types.
+        </p>
+      </v-alert>
+
+      <!-- Loading State -->
+      <v-card-text v-else-if="loading">
+        <v-progress-circular indeterminate color="primary" />
+        <span class="ml-4">Loading question type data...</span>
+      </v-card-text>
+
+      <!-- Error State -->
+      <v-alert v-else-if="error" type="error" variant="tonal" class="ma-4">
+        <v-alert-title>Error</v-alert-title>
+        {{ error }}
+      </v-alert>
+
+      <!-- Main Content -->
+      <v-card-text v-else>
+        <!-- Current State -->
+        <div class="mb-6">
+          <h3 class="text-h6 mb-2">Current CourseConfig</h3>
+          <v-list density="compact">
+            <v-list-item>
+              <template #prepend>
+                <v-icon>mdi-shape</v-icon>
+              </template>
+              <v-list-item-title>
+                {{ currentDataShapeCount }} DataShapes registered
+              </v-list-item-title>
+            </v-list-item>
+            <v-list-item>
+              <template #prepend>
+                <v-icon>mdi-help-circle</v-icon>
+              </template>
+              <v-list-item-title>
+                {{ currentQuestionTypeCount }} QuestionTypes registered
+              </v-list-item-title>
+            </v-list-item>
+          </v-list>
+        </div>
+
+        <!-- Custom Questions -->
+        <div class="mb-6">
+          <h3 class="text-h6 mb-2">From allCustomQuestions()</h3>
+          <v-list density="compact">
+            <v-list-item>
+              <template #prepend>
+                <v-icon>mdi-shape</v-icon>
+              </template>
+              <v-list-item-title>
+                {{ processedDataShapes.length }} DataShapes found
+              </v-list-item-title>
+            </v-list-item>
+            <v-list-item>
+              <template #prepend>
+                <v-icon>mdi-help-circle</v-icon>
+              </template>
+              <v-list-item-title>
+                {{ processedQuestions.length }} QuestionTypes found
+              </v-list-item-title>
+            </v-list-item>
+          </v-list>
+        </div>
+
+        <!-- Changes Preview -->
+        <div v-if="hasChanges" class="mb-6">
+          <h3 class="text-h6 mb-2">Changes to Apply</h3>
+          <v-list density="compact">
+            <v-list-item
+              v-for="change in changesList"
+              :key="change.key"
+              :class="change.type === 'add' ? 'text-success' : 'text-info'"
+            >
+              <template #prepend>
+                <v-icon :color="change.type === 'add' ? 'success' : 'info'">
+                  {{ change.type === 'add' ? 'mdi-plus' : 'mdi-update' }}
+                </v-icon>
+              </template>
+              <v-list-item-title>
+                {{ change.label }}
+              </v-list-item-title>
+            </v-list-item>
+          </v-list>
+        </div>
+
+        <!-- No Changes Message -->
+        <v-alert v-else type="info" variant="tonal">
+          All question types are already registered. No changes needed.
+        </v-alert>
+
+        <!-- Success Message -->
+        <v-alert v-if="successMessage" type="success" variant="tonal" class="mb-4">
+          <v-alert-title>Success</v-alert-title>
+          {{ successMessage }}
+        </v-alert>
+      </v-card-text>
+
+      <!-- Actions -->
+      <v-card-actions v-if="!isStaticMode && !loading && !error">
+        <v-spacer />
+        <v-btn
+          color="primary"
+          :disabled="!hasChanges || registering"
+          :loading="registering"
+          @click="registerQuestions"
+        >
+          Register Question Types
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-container>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, onMounted } from 'vue';
+import { getDataLayer } from '@vue-skuilder/db';
+import {
+  registerCustomQuestionTypes,
+  processCustomQuestionsData,
+  isDataShapeRegistered,
+  isQuestionTypeRegistered,
+  isDataShapeSchemaAvailable,
+  type CustomQuestionsData,
+  type ProcessedDataShape,
+  type ProcessedQuestionData,
+} from '@vue-skuilder/db';
+import { useAuthStore } from '@vue-skuilder/common-ui';
+import { allCustomQuestions } from '../questions';
+import config from '../../skuilder.config.json';
+
+// State
+const loading = ref(true);
+const error = ref<string | null>(null);
+const registering = ref(false);
+const successMessage = ref<string | null>(null);
+
+const courseConfig = ref<any>(null);
+const customQuestions = ref<CustomQuestionsData | null>(null);
+const processedDataShapes = ref<ProcessedDataShape[]>([]);
+const processedQuestions = ref<ProcessedQuestionData[]>([]);
+
+// Check if in static mode
+const isStaticMode = computed(() => config.dataLayerType === 'static');
+
+// Computed properties
+const currentDataShapeCount = computed(() => courseConfig.value?.dataShapes?.length ?? 0);
+const currentQuestionTypeCount = computed(() => courseConfig.value?.questionTypes?.length ?? 0);
+
+interface Change {
+  key: string;
+  type: 'add' | 'update';
+  label: string;
+}
+
+const changesList = computed<Change[]>(() => {
+  if (!courseConfig.value || !customQuestions.value) return [];
+
+  const changes: Change[] = [];
+
+  // Check DataShapes
+  for (const dataShape of processedDataShapes.value) {
+    const isRegistered = isDataShapeRegistered(dataShape, courseConfig.value);
+    const hasSchema = isDataShapeSchemaAvailable(dataShape, courseConfig.value);
+
+    if (!isRegistered) {
+      changes.push({
+        key: `ds-add-${dataShape.course}.${dataShape.name}`,
+        type: 'add',
+        label: `Add DataShape: ${dataShape.course}.${dataShape.name}`,
+      });
+    } else if (!hasSchema) {
+      changes.push({
+        key: `ds-update-${dataShape.course}.${dataShape.name}`,
+        type: 'update',
+        label: `Update DataShape schema: ${dataShape.course}.${dataShape.name}`,
+      });
+    }
+  }
+
+  // Check QuestionTypes
+  for (const question of processedQuestions.value) {
+    if (!isQuestionTypeRegistered(question, courseConfig.value)) {
+      changes.push({
+        key: `qt-add-${question.course}.${question.name}`,
+        type: 'add',
+        label: `Add QuestionType: ${question.name}`,
+      });
+    }
+  }
+
+  return changes;
+});
+
+const hasChanges = computed(() => changesList.value.length > 0);
+
+// Methods
+async function loadData() {
+  try {
+    loading.value = true;
+    error.value = null;
+
+    // Load custom questions
+    customQuestions.value = allCustomQuestions();
+
+    // Process custom questions
+    const processed = processCustomQuestionsData(customQuestions.value);
+    processedDataShapes.value = processed.dataShapes;
+    processedQuestions.value = processed.questions;
+
+    // Load course config
+    const courseId = config.course;
+    if (!courseId) {
+      throw new Error('No course ID configured in skuilder.config.json');
+    }
+
+    const courseDB = getDataLayer().getCourseDB(courseId);
+    courseConfig.value = await courseDB.getCourseConfig();
+  } catch (err) {
+    error.value = err instanceof Error ? err.message : String(err);
+    console.error('[AdminRegisterQuestions] Failed to load data:', err);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function registerQuestions() {
+  if (!customQuestions.value || !courseConfig.value) {
+    error.value = 'Missing data for registration';
+    return;
+  }
+
+  try {
+    registering.value = true;
+    error.value = null;
+    successMessage.value = null;
+
+    const authStore = useAuthStore();
+    const username = authStore.currentUser?.username || 'admin';
+
+    const courseId = config.course;
+    if (!courseId) {
+      throw new Error('No course ID configured');
+    }
+
+    const courseDB = getDataLayer().getCourseDB(courseId);
+
+    const result = await registerCustomQuestionTypes(
+      customQuestions.value,
+      courseConfig.value,
+      courseDB,
+      username
+    );
+
+    if (result.success) {
+      successMessage.value = `Successfully registered ${result.registeredCount} items`;
+      // Reload data to show updated state
+      await loadData();
+    } else {
+      error.value = result.errorMessage || 'Registration failed';
+    }
+  } catch (err) {
+    error.value = err instanceof Error ? err.message : String(err);
+    console.error('[AdminRegisterQuestions] Registration failed:', err);
+  } finally {
+    registering.value = false;
+  }
+}
+
+// Lifecycle
+onMounted(() => {
+  if (!isStaticMode.value) {
+    loadData();
+  }
+});
+</script>
+
+<style scoped>
+.v-code {
+  background-color: rgba(0, 0, 0, 0.05);
+  padding: 8px 12px;
+  border-radius: 4px;
+  font-family: 'Courier New', monospace;
+}
+
+:deep(.v-theme--dark) .v-code {
+  background-color: rgba(255, 255, 255, 0.05);
+}
+</style>

package/dist/studio-ui-src/main.ts

@@ -125,7 +125,7 @@ const vuetify = createVuetify({
       const courseDB = getDataLayer().getCourseDB(studioConfig.database.name);
       const courseConfig = await courseDB.getCourseConfig();
 
-      const { registerCustomQuestionTypes } = await import('./utils/courseConfigRegistration');
+      const { registerCustomQuestionTypes } = await import('@vue-skuilder/db');
       const registrationResult = await registerCustomQuestionTypes(
         customQuestions,
         courseConfig,
@@ -156,7 +156,7 @@ const vuetify = createVuetify({
     const courseConfig = await courseDB.getCourseConfig();
 
     const { BlanksCard, BlanksCardDataShapes } = await import('@vue-skuilder/courseware');
-    const { registerBlanksCard } = await import('./utils/courseConfigRegistration');
+    const { registerBlanksCard } = await import('@vue-skuilder/db');
     
     const blanksRegistrationResult = await registerBlanksCard(
       BlanksCard,

package/dist/studio-ui-src/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.22",
+  "version": "0.1.23",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -32,5 +32,5 @@
     "vite": "^7.0.0",
     "vue-tsc": "^1.8.0"
   },
-  "stableVersion": "0.1.22"
+  "stableVersion": "0.1.23"
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.22",
+  "version": "0.1.23",
   "type": "module",
   "description": "CLI scaffolding tool for vue-skuilder projects",
   "bin": {
@@ -45,13 +45,13 @@
   ],
   "dependencies": {
     "@mdi/font": "^7.3.67",
-    "@vue-skuilder/common": "0.1.22",
-    "@vue-skuilder/common-ui": "0.1.22",
-    "@vue-skuilder/courseware": "0.1.22",
-    "@vue-skuilder/db": "0.1.22",
-    "@vue-skuilder/edit-ui": "0.1.22",
-    "@vue-skuilder/express": "0.1.22",
-    "@vue-skuilder/mcp": "0.1.22",
+    "@vue-skuilder/common": "0.1.23",
+    "@vue-skuilder/common-ui": "0.1.23",
+    "@vue-skuilder/courseware": "0.1.23",
+    "@vue-skuilder/db": "0.1.23",
+    "@vue-skuilder/edit-ui": "0.1.23",
+    "@vue-skuilder/express": "0.1.23",
+    "@vue-skuilder/mcp": "0.1.23",
     "chalk": "^5.3.0",
     "commander": "^11.0.0",
     "fs-extra": "^11.2.0",
@@ -70,7 +70,7 @@
     "@types/node": "^22",
     "@types/serve-static": "^1.15.0",
     "@vitejs/plugin-vue": "^6.0.0",
-    "@vue-skuilder/studio-ui": "0.1.22",
+    "@vue-skuilder/studio-ui": "0.1.23",
     "cypress": "^15.6.0",
     "typescript": "~5.9.3",
     "vite": "^7.0.0",
@@ -81,5 +81,5 @@
     "node": ">=18.0.0"
   },
   "packageManager": "yarn@4.12.0",
-  "stableVersion": "0.1.22"
+  "stableVersion": "0.1.23"
 }

package/dist/studio-ui-src/utils/courseConfigRegistration.ts

@@ -1,416 +0,0 @@
-import { CourseConfig, DataShape, NameSpacer, toZodJSON } from '@vue-skuilder/common';
-import { CourseDBInterface } from '@vue-skuilder/db';
-import { Displayable, getCurrentUser, ViewComponent } from '@vue-skuilder/common-ui';
-import { CourseWare } from '@vue-skuilder/courseware';
-
-/**
- * Interface for custom questions data structure returned by allCustomQuestions()
- */
-export interface CustomQuestionsData {
-  courses: CourseWare[]; // Course instances with question instances
-  questionClasses: Displayable[]; // Question class constructors
-  dataShapes: DataShape[]; // DataShape definitions for studio-ui
-  views: ViewComponent[]; // Vue components for rendering
-  meta: {
-    questionCount: number;
-    dataShapeCount: number;
-    viewCount: number;
-    courseCount: number;
-    packageName: string;
-    sourceDirectory: string;
-  };
-}
-
-/**
- * Interface for processed question data for registration
- */
-export interface ProcessedQuestionData {
-  name: string;
-  course: string;
-  questionClass: any;
-  dataShapes: any[];
-  views: any[];
-}
-
-/**
- * Interface for processed data shape for registration
- */
-export interface ProcessedDataShape {
-  name: string;
-  course: string;
-  dataShape: any;
-}
-
-/**
- * Check if a data shape is already registered in the course config with valid schema
- */
-export function isDataShapeRegistered(
-  dataShape: ProcessedDataShape,
-  courseConfig: CourseConfig
-): boolean {
-  const namespacedName = NameSpacer.getDataShapeString({
-    dataShape: dataShape.name,
-    course: dataShape.course,
-  });
-
-  const existingDataShape = courseConfig.dataShapes.find((ds) => ds.name === namespacedName);
-
-  // existence sufficient to be considered "registered"
-  return existingDataShape !== undefined;
-}
-
-export function isDataShapeSchemaAvailable(
-  dataShape: ProcessedDataShape,
-  courseConfig: CourseConfig
-): boolean {
-  const namespacedName = NameSpacer.getDataShapeString({
-    dataShape: dataShape.name,
-    course: dataShape.course,
-  });
-
-  const existingDataShape = courseConfig.dataShapes.find((ds) => ds.name === namespacedName);
-
-  return existingDataShape !== undefined && existingDataShape.serializedZodSchema !== undefined;
-}
-
-/**
- * Check if a question type is already registered in the course config
- */
-export function isQuestionTypeRegistered(
-  question: ProcessedQuestionData,
-  courseConfig: CourseConfig
-): boolean {
-  const namespacedName = NameSpacer.getQuestionString({
-    course: question.course,
-    questionType: question.name,
-  });
-
-  return courseConfig.questionTypes.some((qt) => qt.name === namespacedName);
-}
-
-/**
- * Process custom questions data into registration-ready format
- */
-export function processCustomQuestionsData(customQuestions: CustomQuestionsData): {
-  dataShapes: ProcessedDataShape[];
-  questions: ProcessedQuestionData[];
-} {
-  const processedDataShapes: ProcessedDataShape[] = [];
-  const processedQuestions: ProcessedQuestionData[] = [];
-
-  // Extract course names from the custom questions
-  const courseNames = customQuestions.courses.map((course) => course.name);
-
-  // Process each question class
-  customQuestions.questionClasses.forEach((questionClass) => {
-    // Determine the course name (use first course or default to meta.packageName)
-    const courseName = courseNames.length > 0 ? courseNames[0] : customQuestions.meta.packageName;
-
-    // Process data shapes from this question class (static property)
-    if (questionClass.dataShapes && Array.isArray(questionClass.dataShapes)) {
-      questionClass.dataShapes.forEach((dataShape) => {
-        processedDataShapes.push({
-          name: dataShape.name,
-          course: courseName,
-          dataShape: dataShape,
-        });
-      });
-    }
-
-    // Process the question itself
-    processedQuestions.push({
-      name: questionClass.name,
-      course: courseName,
-      questionClass: questionClass,
-      dataShapes: questionClass.dataShapes || [],
-      views: questionClass.views || [],
-    });
-  });
-
-  return { dataShapes: processedDataShapes, questions: processedQuestions };
-}
-
-/**
- * Register a data shape in the course config
- */
-export function registerDataShape(
-  dataShape: ProcessedDataShape,
-  courseConfig: CourseConfig
-): boolean {
-  const namespacedName = NameSpacer.getDataShapeString({
-    dataShape: dataShape.name,
-    course: dataShape.course,
-  });
-
-  // Generate JSON Schema for the DataShape
-  let serializedZodSchema: string | undefined;
-  try {
-    serializedZodSchema = toZodJSON(dataShape.dataShape);
-  } catch (error) {
-    console.warn(`   ⚠️  Failed to generate schema for ${namespacedName}:`, error);
-    serializedZodSchema = undefined;
-  }
-
-  // Check if DataShape already exists
-  const existingIndex = courseConfig.dataShapes.findIndex((ds) => ds.name === namespacedName);
-
-  if (existingIndex !== -1) {
-    const existingDataShape = courseConfig.dataShapes[existingIndex];
-
-    // If existing schema matches new schema, no update needed
-    if (existingDataShape.serializedZodSchema === serializedZodSchema) {
-      console.log(
-        `   ℹ️  DataShape '${dataShape.name}' from '${dataShape.course}' already registered with identical schema`
-      );
-      return false;
-    }
-
-    // Schema has changed or was missing - update it
-    if (existingDataShape.serializedZodSchema) {
-      console.log(
-        `   🔄 DataShape '${dataShape.name}' from '${dataShape.course}' schema has changed, updating...`
-      );
-    } else {
-      console.log(
-        `   ℹ️  DataShape '${dataShape.name}' from '${dataShape.course}' already registered, but with no schema` +
-          `\n   ℹ️  Adding schema to existing entry`
-      );
-    }
-
-    // Update the existing entry
-    courseConfig.dataShapes[existingIndex] = {
-      name: namespacedName,
-      questionTypes: existingDataShape.questionTypes, // Preserve existing question type associations
-      serializedZodSchema,
-    };
-
-    console.log(`   ✅ Updated DataShape: ${namespacedName}`);
-    return true;
-  }
-
-  courseConfig.dataShapes.push({
-    name: namespacedName,
-    questionTypes: [],
-    serializedZodSchema,
-  });
-
-  console.log(`   ✅ Registered DataShape: ${namespacedName}`);
-  return true;
-}
-
-/**
- * Register a question type in the course config
- */
-export function registerQuestionType(
-  question: ProcessedQuestionData,
-  courseConfig: CourseConfig
-): boolean {
-  if (isQuestionTypeRegistered(question, courseConfig)) {
-    console.log(
-      `   ℹ️  QuestionType '${question.name}' from '${question.course}' already registered`
-    );
-    return false;
-  }
-
-  const namespacedQuestionName = NameSpacer.getQuestionString({
-    course: question.course,
-    questionType: question.name,
-  });
-
-  // Build view list
-  const viewList = question.views.map((view) => {
-    if (view.name) {
-      return view.name;
-    } else {
-      return 'unnamedComponent';
-    }
-  });
-
-  // Build data shape list
-  const dataShapeList = question.dataShapes.map((dataShape) =>
-    NameSpacer.getDataShapeString({
-      course: question.course,
-      dataShape: dataShape.name,
-    })
-  );
-
-  // Add question type to course config
-  courseConfig.questionTypes.push({
-    name: namespacedQuestionName,
-    viewList: viewList,
-    dataShapeList: dataShapeList,
-  });
-
-  // Cross-reference: Add this question type to its data shapes
-  question.dataShapes.forEach((dataShape) => {
-    const namespacedDataShapeName = NameSpacer.getDataShapeString({
-      course: question.course,
-      dataShape: dataShape.name,
-    });
-
-    for (const ds of courseConfig.dataShapes) {
-      if (ds.name === namespacedDataShapeName) {
-        ds.questionTypes.push(namespacedQuestionName);
-      }
-    }
-  });
-
-  console.log(`   ✅ Registered QuestionType: ${namespacedQuestionName}`);
-  return true;
-}
-
-/**
- * Register seed data for a question type (similar to ComponentRegistration)
- */
-export async function registerSeedData(
-  question: ProcessedQuestionData,
-  courseDB: CourseDBInterface
-  // courseName: string
-): Promise<void> {
-  if (question.questionClass.seedData && Array.isArray(question.questionClass.seedData)) {
-    console.log(`   📦 Registering seed data for question: ${question.name}`);
-
-    try {
-      const currentUser = await getCurrentUser();
-
-      question.questionClass.seedData.forEach((seedDataItem: unknown) => {
-        if (question.dataShapes.length > 0) {
-          courseDB.addNote(
-            question.course,
-            question.dataShapes[0],
-            seedDataItem,
-            currentUser.getUsername(),
-            []
-          );
-        }
-      });
-
-      console.log(`   ✅ Seed data registered for question: ${question.name}`);
-    } catch (error) {
-      console.warn(
-        `   ⚠️  Failed to register seed data for question '${question.name}': ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-}
-
-/**
- * Register BlanksCard (markdown fillIn) question type specifically
- */
-export async function registerBlanksCard(
-  BlanksCard: any,
-  BlanksCardDataShapes: any[],
-  courseConfig: CourseConfig,
-  courseDB: CourseDBInterface
-): Promise<{ success: boolean; errorMessage?: string }> {
-  try {
-    console.log('   📋 Registering BlanksCard data shapes and question type...');
-
-    let registeredCount = 0;
-    const courseName = 'default'; // BlanksCard comes from the default course
-
-    // Register BlanksCard data shapes
-    for (const dataShapeClass of BlanksCardDataShapes) {
-      const processedDataShape: ProcessedDataShape = {
-        name: dataShapeClass.name,
-        course: courseName,
-        dataShape: dataShapeClass,
-      };
-
-      if (registerDataShape(processedDataShape, courseConfig)) {
-        registeredCount++;
-      }
-    }
-
-    // Register BlanksCard question type
-    const processedQuestion: ProcessedQuestionData = {
-      name: BlanksCard.name,
-      course: courseName,
-      questionClass: BlanksCard,
-      dataShapes: BlanksCardDataShapes,
-      views: BlanksCard.views || [],
-    };
-
-    if (registerQuestionType(processedQuestion, courseConfig)) {
-      registeredCount++;
-    }
-
-    // Update the course config in the database
-    console.log('   💾 Updating course configuration with BlanksCard...');
-    const updateResult = await courseDB.updateCourseConfig(courseConfig);
-
-    if (!updateResult.ok) {
-      throw new Error(`Failed to update course config: ${JSON.stringify(updateResult)}`);
-    }
-
-    // Register seed data if BlanksCard has any
-    await registerSeedData(processedQuestion, courseDB);
-
-    console.log(`   ✅ BlanksCard registration complete: ${registeredCount} items registered`);
-
-    return { success: true };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`   ❌ BlanksCard registration failed: ${errorMessage}`);
-    return { success: false, errorMessage };
-  }
-}
-
-/**
- * Main function to register all custom question types and data shapes
- */
-export async function registerCustomQuestionTypes(
-  customQuestions: CustomQuestionsData,
-  courseConfig: CourseConfig,
-  courseDB: CourseDBInterface
-  // courseName: string
-): Promise<{ success: boolean; registeredCount: number; errorMessage?: string }> {
-  try {
-    console.log('🎨 Studio Mode: Beginning custom question registration');
-    console.log(`   📊 Processing ${customQuestions.questionClasses.length} question classes`);
-
-    const { dataShapes, questions } = processCustomQuestionsData(customQuestions);
-
-    console.log(`   📊 Found ${dataShapes.length} data shapes and ${questions.length} questions`);
-
-    let registeredCount = 0;
-
-    // First, register all data shapes
-    console.log('   📋 Registering data shapes...');
-    for (const dataShape of dataShapes) {
-      if (registerDataShape(dataShape, courseConfig)) {
-        registeredCount++;
-      }
-    }
-
-    // Then, register all question types
-    console.log('   🔧 Registering question types...');
-    for (const question of questions) {
-      if (registerQuestionType(question, courseConfig)) {
-        registeredCount++;
-      }
-    }
-
-    // Update the course config in the database
-    console.log('   💾 Updating course configuration...');
-    const updateResult = await courseDB.updateCourseConfig(courseConfig);
-
-    if (!updateResult.ok) {
-      throw new Error(`Failed to update course config: ${JSON.stringify(updateResult)}`);
-    }
-
-    // Register seed data for questions that have it
-    console.log('   🌱 Registering seed data...');
-    for (const question of questions) {
-      await registerSeedData(question, courseDB /*, courseName */);
-    }
-
-    console.log(`   ✅ Custom question registration complete: ${registeredCount} items registered`);
-
-    return { success: true, registeredCount };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`   ❌ Custom question registration failed: ${errorMessage}`);
-    return { success: false, registeredCount: 0, errorMessage };
-  }
-}