@playcademy/sandbox 0.6.1-beta.8 → 0.6.1-beta.9

package/dist/cli.js

@@ -1084,7 +1084,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.6.1-beta.8",
+    version: "0.6.1-beta.9",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -11587,7 +11587,7 @@ var init_table6 = __esm(() => {
 });
 
 // ../data/src/domains/timeback/table.ts
-var gameTimebackIntegrationStatusEnum, gameTimebackIntegrations, gameTimebackAssessmentTests, gameTimebackMetricDiscrepancyVerifications, gameTimebackActivityCompletions;
+var gameTimebackIntegrationStatusEnum, gameTimebackAssessmentPurposeEnum, gameTimebackAssessmentStatusEnum, gameTimebackIntegrations, gameTimebackAssessmentTests, gameTimebackMetricDiscrepancyVerifications, gameTimebackActivityCompletions;
 var init_table7 = __esm(() => {
   init_drizzle_orm();
   init_pg_core();
@@ -11597,6 +11597,15 @@ var init_table7 = __esm(() => {
     "active",
     "deactivated"
   ]);
+  gameTimebackAssessmentPurposeEnum = pgEnum("game_timeback_assessment_purpose", [
+    "end_of_course",
+    "diagnostic"
+  ]);
+  gameTimebackAssessmentStatusEnum = pgEnum("game_timeback_assessment_status", [
+    "draft",
+    "live",
+    "archived"
+  ]);
   gameTimebackIntegrations = pgTable("game_timeback_integrations", {
     id: uuid("id").primaryKey().defaultRandom(),
     gameId: uuid("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
@@ -11617,10 +11626,11 @@ var init_table7 = __esm(() => {
     id: uuid("id").primaryKey().defaultRandom(),
     integrationId: uuid("integration_id").notNull().references(() => gameTimebackIntegrations.id, { onDelete: "cascade" }),
     qtiTestIdentifier: text("qti_test_identifier").notNull(),
-    bankResourceId: text("bank_resource_id"),
-    bankActive: boolean("bank_active").notNull().default(false),
-    sortOrder: integer("sort_order").notNull().default(0),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+    purpose: gameTimebackAssessmentPurposeEnum("purpose").notNull().default("end_of_course"),
+    status: gameTimebackAssessmentStatusEnum("status").notNull().default("draft"),
+    sortOrder: integer("sort_order"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
   }, (table3) => [
     uniqueIndex("game_timeback_assessment_tests_integration_qti_idx").on(table3.integrationId, table3.qtiTestIdentifier)
   ]);
@@ -11672,6 +11682,8 @@ __export(exports_tables_index, {
   gameTimebackIntegrations: () => gameTimebackIntegrations,
   gameTimebackIntegrationStatusEnum: () => gameTimebackIntegrationStatusEnum,
   gameTimebackAssessmentTests: () => gameTimebackAssessmentTests,
+  gameTimebackAssessmentStatusEnum: () => gameTimebackAssessmentStatusEnum,
+  gameTimebackAssessmentPurposeEnum: () => gameTimebackAssessmentPurposeEnum,
   gameTimebackActivityCompletions: () => gameTimebackActivityCompletions,
   gameScoresRelations: () => gameScoresRelations,
   gameScores: () => gameScores,
@@ -30101,6 +30113,25 @@ function sleep(ms) {
   }
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+async function runWithConcurrency(items, concurrency, worker) {
+  if (items.length === 0) {
+    return [];
+  }
+  const effectiveConcurrency = Math.max(1, Math.min(concurrency, items.length));
+  const results = Array.from({ length: items.length });
+  let nextIndex = 0;
+  await Promise.all(Array.from({ length: effectiveConcurrency }, async () => {
+    while (true) {
+      const currentIndex = nextIndex;
+      nextIndex++;
+      if (currentIndex >= items.length) {
+        return;
+      }
+      results[currentIndex] = await worker(items[currentIndex]);
+    }
+  }));
+  return results;
+}
 
 // ../timeback/dist/types.js
 function isObject(value) {
@@ -31635,7 +31666,7 @@ class KVBackupService {
       "app.kv_backup.dry_run": dryRun,
       "app.kv_backup.game_slug": options.gameSlug
     });
-    const results = await KVBackupService.runWithConcurrency(targets, namespaceConcurrency, (target) => this.backupNamespace(target, {
+    const results = await runWithConcurrency(targets, namespaceConcurrency, (target) => this.backupNamespace(target, {
       bucketName,
       stage,
       runId,
@@ -31701,7 +31732,7 @@ class KVBackupService {
   }
   static async fetchNamespaceEntries(cloudflare2, namespaceId, keyConcurrency = DEFAULT_KEY_CONCURRENCY) {
     const keys = await KVBackupService.withRetries(`List KV keys for namespace ${namespaceId}`, () => cloudflare2.kv.listKeys(namespaceId));
-    return KVBackupService.runWithConcurrency(keys, keyConcurrency, async (key) => {
+    return runWithConcurrency(keys, keyConcurrency, async (key) => {
       const safeLabel = KVBackupService.redactKeyForLog(key.name);
       const value = await KVBackupService.withRetries(`Fetch KV value ${safeLabel}`, () => cloudflare2.kv.getValue(namespaceId, key.name));
       const metadata2 = KVBackupService.parseMetadata(key.metadata);
@@ -31878,25 +31909,6 @@ class KVBackupService {
     }
     throw lastError instanceof Error ? lastError : new Error(String(lastError));
   }
-  static async runWithConcurrency(items, concurrency, worker) {
-    if (items.length === 0) {
-      return [];
-    }
-    const effectiveConcurrency = Math.max(1, Math.min(concurrency, items.length));
-    const results = Array.from({ length: items.length });
-    let nextIndex = 0;
-    await Promise.all(Array.from({ length: effectiveConcurrency }, async () => {
-      while (true) {
-        const currentIndex = nextIndex;
-        nextIndex++;
-        if (currentIndex >= items.length) {
-          return;
-        }
-        results[currentIndex] = await worker(items[currentIndex]);
-      }
-    }));
-    return results;
-  }
 }
 var BACKUP_SCHEMA_VERSION = 1, DEFAULT_NAMESPACE_CONCURRENCY = 2, DEFAULT_KEY_CONCURRENCY = 10, DEFAULT_RETRY_ATTEMPTS = 3, RETRY_BASE_DELAY_MS = 500;
 var init_kv_backup_service = __esm(() => {
@@ -34203,9 +34215,8 @@ function isValidAdminAttributionDate(value) {
   const date3 = new Date(Date.UTC(year, month - 1, day, 12, 0, 0));
   return date3.getUTCFullYear() === year && date3.getUTCMonth() + 1 === month && date3.getUTCDate() === day;
 }
-var TIMEBACK_GRADES, TIMEBACK_SUBJECTS2, TimebackGradeSchema, TimebackSubjectSchema, CourseGoalsSchema, UpdateGameTimebackIntegrationRequestSchema, CreateGameTimebackIntegrationRequestSchema, TimebackActivityDataSchema, EndActivityRequestSchema, GameRunMetricsSchema, GameCourseMetricsSchema, GameMetricsResponseSchema, AdvanceCourseRequestSchema, UnenrollCourseRequestSchema, HeartbeatRequestSchema, PopulateStudentRequestSchema, DerivedPlatformCourseConfigSchema, TimebackBaseConfigSchema, PlatformTimebackSetupRequestSchema, AdminTimebackMutationBaseSchema, AdminAttributionDateSchema, ADMIN_GRANT_XP_MIN = -1e5, ADMIN_GRANT_XP_MAX = 1e5, ADMIN_GRANT_XP_AMOUNT_RANGE_MESSAGE, GrantTimebackXpRequestSchema, AdjustTimebackTimeRequestSchema, AdjustTimebackMasteryRequestSchema, ReconcileMasteryForConfigChangeSchema, EnrollStudentRequestSchema, UnenrollStudentRequestSchema, ReactivateEnrollmentRequestSchema, VerifyTimebackMetricDiscrepancyRequestSchema, InsertAssessmentTestSchema, CreateAssessmentRequestSchema, ReorderAssessmentsRequestSchema, ReorderQuestionsRequestSchema;
+var TIMEBACK_GRADES, TIMEBACK_SUBJECTS2, TimebackGradeSchema, TimebackSubjectSchema, CourseGoalsSchema, UpdateGameTimebackIntegrationRequestSchema, CreateGameTimebackIntegrationRequestSchema, TimebackActivityDataSchema, EndActivityRequestSchema, GameRunMetricsSchema, GameCourseMetricsSchema, GameMetricsResponseSchema, AdvanceCourseRequestSchema, UnenrollCourseRequestSchema, HeartbeatRequestSchema, PopulateStudentRequestSchema, DerivedPlatformCourseConfigSchema, TimebackBaseConfigSchema, PlatformTimebackSetupRequestSchema, AdminTimebackMutationBaseSchema, AdminAttributionDateSchema, ADMIN_GRANT_XP_MIN = -1e5, ADMIN_GRANT_XP_MAX = 1e5, ADMIN_GRANT_XP_AMOUNT_RANGE_MESSAGE, GrantTimebackXpRequestSchema, AdjustTimebackTimeRequestSchema, AdjustTimebackMasteryRequestSchema, ReconcileMasteryForConfigChangeSchema, EnrollStudentRequestSchema, UnenrollStudentRequestSchema, ReactivateEnrollmentRequestSchema, VerifyTimebackMetricDiscrepancyRequestSchema, AssessmentPurposeSchema, AssessmentStatusSchema, CreateAssessmentRequestSchema, UpdateAssessmentRequestSchema, CopyAssessmentRequestSchema, ReorderAssessmentsRequestSchema, ReorderQuestionsRequestSchema;
 var init_schemas4 = __esm(() => {
-  init_drizzle_zod();
   init_esm();
   init_table7();
   TIMEBACK_GRADES = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
@@ -34458,15 +34469,26 @@ var init_schemas4 = __esm(() => {
     runId: exports_external.string().uuid(),
     activityId: exports_external.string().min(1).optional()
   });
-  InsertAssessmentTestSchema = createInsertSchema(gameTimebackAssessmentTests).omit({
-    id: true,
-    createdAt: true
-  });
+  AssessmentPurposeSchema = exports_external.enum(gameTimebackAssessmentPurposeEnum.enumValues);
+  AssessmentStatusSchema = exports_external.enum(gameTimebackAssessmentStatusEnum.enumValues);
   CreateAssessmentRequestSchema = exports_external.object({
-    title: exports_external.string().min(1, "Assessment title is required")
+    title: exports_external.string().min(1, "Assessment title is required"),
+    purpose: AssessmentPurposeSchema
+  });
+  UpdateAssessmentRequestSchema = exports_external.object({
+    title: exports_external.string().trim().min(1, "Assessment title is required").optional(),
+    purpose: AssessmentPurposeSchema.optional(),
+    status: AssessmentStatusSchema.optional()
+  }).refine((input) => input.title !== undefined || input.purpose !== undefined || input.status !== undefined, {
+    message: "Title, purpose, or status is required"
+  });
+  CopyAssessmentRequestSchema = exports_external.object({
+    testIdentifier: exports_external.string().trim().min(1, "Assessment identifier is required"),
+    purpose: AssessmentPurposeSchema
   });
   ReorderAssessmentsRequestSchema = exports_external.object({
-    identifiers: exports_external.array(exports_external.string().min(1)).min(1, "At least one identifier is required")
+    purpose: AssessmentPurposeSchema,
+    testIdentifiers: exports_external.array(exports_external.string().trim().min(1, "Assessment identifier is required")).min(1, "At least one assessment is required")
   });
   ReorderQuestionsRequestSchema = exports_external.object({
     items: exports_external.array(exports_external.object({
@@ -53965,10 +53987,10 @@ var init_dist2 = __esm(async () => {
   };
 });
 
-// ../../node_modules/.bun/@timeback+qti@0.3.1+1fb4c65d43e298b9/node_modules/@timeback/qti/dist/chunk-6jf1natv.js
+// ../../node_modules/.bun/@timeback+qti@0.4.1-beta.20260717234944+1fb4c65d43e298b9/node_modules/@timeback/qti/dist/chunk-6jf1natv.js
 var init_chunk_6jf1natv = () => {};
 
-// ../../node_modules/.bun/@timeback+qti@0.3.1+1fb4c65d43e298b9/node_modules/@timeback/qti/dist/chunk-dd0pbbq3.js
+// ../../node_modules/.bun/@timeback+qti@0.4.1-beta.20260717234944+1fb4c65d43e298b9/node_modules/@timeback/qti/dist/chunk-dd0pbbq3.js
 var exports_chunk_dd0pbbq3 = {};
 __export(exports_chunk_dd0pbbq3, {
   types: () => types6,
@@ -54379,7 +54401,7 @@ var init_chunk_dd0pbbq3 = __esm(() => {
   util_default2 = { TextEncoder: TextEncoder3, TextDecoder: TextDecoder3, promisify: promisify2, log: log9, inherits: inherits2, _extend: _extend2, callbackifyOnRejected: callbackifyOnRejected2, callbackify: callbackify2 };
 });
 
-// ../../node_modules/.bun/@timeback+qti@0.3.1+1fb4c65d43e298b9/node_modules/@timeback/qti/dist/chunk-m54fefpq.js
+// ../../node_modules/.bun/@timeback+qti@0.4.1-beta.20260717234944+1fb4c65d43e298b9/node_modules/@timeback/qti/dist/chunk-pt7w63g2.js
 function createInputValidationError2(message, issues) {
   return new InputValidationError2(message, issues);
 }
@@ -55430,7 +55452,7 @@ var ApiError3, UnauthorizedError3, ForbiddenError2, NotFoundError3, ValidationEr
     console[method](label, style);
   }
 }, LOG_LEVELS2, GLOBAL_LOGGING_CONFIG_KEY2, BEYONDAI_PATHS2, LEARNWITHAI_PATHS2, PLATFORM_PATHS2, DEFAULT_PROVIDER_REGISTRY2, MODE_TRANSPORT2, MODE_PROVIDER2, MODE_ENV_CONFIG2, MODE_EXPLICIT_CONFIG2, MODE_ENV_FALLBACK_PLATFORM2, MODE_ENV_FALLBACK_EXPLICIT2, MODE_TOKEN_PROVIDER2, MODES2, MAX_RETRIES2 = 3, RETRY_STATUS_CODES2, INITIAL_RETRY_DELAY_MS2 = 1000, DEFAULT_LIMIT2 = 100, DEFAULT_MAX_ITEMS2 = 1e4, Paginator6;
-var init_chunk_m54fefpq = __esm(async () => {
+var init_chunk_pt7w63g2 = __esm(async () => {
   init_chunk_6jf1natv();
   ApiError3 = class ApiError3 extends Error {
     statusCode;
@@ -70576,15 +70598,14 @@ var init_v42 = __esm(() => {
   init_classic2();
 });
 
-// ../../node_modules/.bun/@timeback+qti@0.3.1+1fb4c65d43e298b9/node_modules/@timeback/qti/dist/index.js
+// ../../node_modules/.bun/@timeback+qti@0.4.1-beta.20260717234944+1fb4c65d43e298b9/node_modules/@timeback/qti/dist/index.js
 function resolveToProvider23(config4, registry3 = DEFAULT_PROVIDER_REGISTRY2) {
   return resolveToProvider10(config4, QTI_ENV_VARS2, registry3);
 }
 function translateParams2(params) {
   const {
     orderBy,
-    filter: _,
-    fields: __,
+    fields: _,
     ...rest
   } = params;
   return {
@@ -70592,6 +70613,23 @@ function translateParams2(params) {
     order: orderBy
   };
 }
+function buildListQueryParams(params) {
+  const queryParams = {};
+  const filter = params.where ? whereToFilter2(params.where) : undefined;
+  if (filter !== undefined)
+    queryParams.filter = filter;
+  if (params.query !== undefined)
+    queryParams.query = params.query;
+  if (params.page !== undefined)
+    queryParams.page = params.page;
+  if (params.limit !== undefined)
+    queryParams.limit = params.limit;
+  if (params.sort)
+    queryParams.sort = params.sort;
+  if (params.order)
+    queryParams.order = params.order;
+  return queryParams;
+}
 
 class AssessmentItemsResource2 {
   transport;
@@ -70600,19 +70638,8 @@ class AssessmentItemsResource2 {
   }
   list(params = {}) {
     validatePageListParams2(params);
-    const queryParams = {};
-    if (params.query !== undefined)
-      queryParams.query = params.query;
-    if (params.page !== undefined)
-      queryParams.page = params.page;
-    if (params.limit !== undefined)
-      queryParams.limit = params.limit;
-    if (params.sort)
-      queryParams.sort = params.sort;
-    if (params.order)
-      queryParams.order = params.order;
     return this.transport.request("/assessment-items", {
-      params: queryParams
+      params: buildListQueryParams(params)
     });
   }
   stream(params = {}) {
@@ -70735,20 +70762,9 @@ class TestPartSectionsHelper2 {
   }
   list(params = {}) {
     validatePageListParams2(params);
-    const queryParams = {};
-    if (params.query !== undefined)
-      queryParams.query = params.query;
-    if (params.page !== undefined)
-      queryParams.page = params.page;
-    if (params.limit !== undefined)
-      queryParams.limit = params.limit;
-    if (params.sort)
-      queryParams.sort = params.sort;
-    if (params.order)
-      queryParams.order = params.order;
     const path = `/assessment-tests/${encodeURIComponent(this.testId)}/test-parts/${encodeURIComponent(this.testPartId)}/sections`;
     return this.transport.request(path, {
-      params: queryParams
+      params: buildListQueryParams(params)
     });
   }
   get(identifier) {
@@ -70795,19 +70811,10 @@ class AssessmentTestPartsHelper2 {
   }
   list(params = {}) {
     validatePageListParams2(params);
-    const queryParams = {};
-    if (params.query !== undefined)
-      queryParams.query = params.query;
-    if (params.page !== undefined)
-      queryParams.page = params.page;
-    if (params.limit !== undefined)
-      queryParams.limit = params.limit;
-    if (params.sort)
-      queryParams.sort = params.sort;
-    if (params.order)
-      queryParams.order = params.order;
     const path = `/assessment-tests/${encodeURIComponent(this.testId)}/test-parts`;
-    return this.transport.request(path, { params: queryParams });
+    return this.transport.request(path, {
+      params: buildListQueryParams(params)
+    });
   }
   get(identifier) {
     validateNonEmptyString2(identifier, "testPartId");
@@ -70850,19 +70857,8 @@ class AssessmentTestsResource2 {
   }
   list(params = {}) {
     validatePageListParams2(params);
-    const queryParams = {};
-    if (params.query !== undefined)
-      queryParams.query = params.query;
-    if (params.page !== undefined)
-      queryParams.page = params.page;
-    if (params.limit !== undefined)
-      queryParams.limit = params.limit;
-    if (params.sort)
-      queryParams.sort = params.sort;
-    if (params.order)
-      queryParams.order = params.order;
     return this.transport.request("/assessment-tests", {
-      params: queryParams
+      params: buildListQueryParams(params)
     });
   }
   stream(params = {}) {
@@ -70968,19 +70964,8 @@ class StimuliResource2 {
   }
   list(params = {}) {
     validatePageListParams2(params);
-    const queryParams = {};
-    if (params.query !== undefined)
-      queryParams.query = params.query;
-    if (params.page !== undefined)
-      queryParams.page = params.page;
-    if (params.limit !== undefined)
-      queryParams.limit = params.limit;
-    if (params.sort)
-      queryParams.sort = params.sort;
-    if (params.order)
-      queryParams.order = params.order;
     return this.transport.request("/stimuli", {
-      params: queryParams
+      params: buildListQueryParams(params)
     });
   }
   stream(params = {}) {
@@ -71112,7 +71097,7 @@ var init_dist3 = __esm(async () => {
   init_v42();
   init_v42();
   init_v42();
-  await init_chunk_m54fefpq();
+  await init_chunk_pt7w63g2();
   QTI_ENV_VARS2 = {
     baseUrl: ["TIMEBACK_API_BASE_URL", "TIMEBACK_BASE_URL", "QTI_BASE_URL"],
     clientId: ["TIMEBACK_API_CLIENT_ID", "TIMEBACK_CLIENT_ID", "QTI_CLIENT_ID"],
@@ -77953,13 +77938,6 @@ function deriveSourcedIds(courseId) {
     componentResource: `${courseId}-cr`
   };
 }
-function deriveAssessmentBankIds(courseId) {
-  return {
-    component: `${courseId}-assessment-bank-component`,
-    resource: `${courseId}-assessment-bank-resource`,
-    componentResource: `${courseId}-assessment-bank-cr`
-  };
-}
 function validateProgressData(progressData) {
   if (!progressData.subject) {
     throw new ConfigurationError("subject", "Subject is required for Caliper events. Provide it in progressData.subject");
@@ -79248,59 +79226,22 @@ class CourseAssessments {
   constructor(core3) {
     this.core = core3;
   }
-  async ensureBank(input) {
-    const oneroster = this.core.api.oneroster;
-    const bankIds = deriveAssessmentBankIds(input.courseId);
-    try {
-      await oneroster.courses.createComponent({
-        sourcedId: bankIds.component,
-        status: "active",
-        title: "Test Out",
-        course: { sourcedId: input.courseId },
-        sortOrder: 9999,
-        metadata: { lessonType: "test-out" }
-      });
-    } catch (error88) {
-      if (!isAlreadyExists(error88)) {
-        throw error88;
-      }
-    }
-    try {
-      await oneroster.resources.create({
-        sourcedId: bankIds.resource,
-        status: "active",
-        title: "Assessment Bank",
-        vendorResourceId: "",
-        vendorId: undefined,
-        metadata: {
-          type: "assessment-bank",
-          resources: [],
-          lessonType: "test-out",
-          subject: input.subject,
-          grade: String(input.grade)
-        }
-      });
-    } catch (error88) {
-      if (!isAlreadyExists(error88)) {
-        throw error88;
-      }
-    }
-    try {
-      await oneroster.courses.createComponentResource({
-        sourcedId: bankIds.componentResource,
-        status: "active",
-        title: "Test Out",
-        resource: { sourcedId: bankIds.resource },
-        courseComponent: { sourcedId: bankIds.component },
-        sortOrder: 9999,
-        metadata: { lessonType: "test-out" },
-        lessonType: "test-out"
-      });
-    } catch (error88) {
-      if (!isAlreadyExists(error88)) {
-        throw error88;
+  createItemFromXml(input) {
+    return this.core.qti.assessmentItems.createFromXml({
+      format: "xml",
+      xml: input.xml,
+      ...input.metadata ? { metadata: input.metadata } : {}
+    });
+  }
+  updateItemFromXml(identifier, input) {
+    return this.core.qti.getTransport().request(`/assessment-items/${encodeURIComponent(identifier)}`, {
+      method: "PUT",
+      body: {
+        format: "xml",
+        xml: input.xml,
+        ...input.metadata ? { metadata: input.metadata } : {}
       }
-    }
+    });
   }
   async createTestScaffold(input) {
     const partId = `${input.identifier}-part1`;
@@ -79335,18 +79276,6 @@ class CourseAssessments {
       }
     }
   }
-  async teardownTest(qtiTestIdentifier) {
-    const qti = this.core.qti;
-    const partId = `${qtiTestIdentifier}-part1`;
-    const sectionId = `${qtiTestIdentifier}-section1`;
-    const questions = await qti.assessmentTests.getQuestions(qtiTestIdentifier);
-    const sectionItems = qti.assessmentTests.testParts(qtiTestIdentifier).sections(partId).items(sectionId);
-    for (const q of questions.questions ?? []) {
-      await sectionItems.remove(q.reference.identifier);
-      await qti.assessmentItems.delete(q.reference.identifier);
-    }
-    await qti.assessmentTests.delete(qtiTestIdentifier);
-  }
 }
 function buildCoursePayload(config4) {
   return {
@@ -79576,9 +79505,9 @@ function createCourseNamespace(core3) {
     cleanup: (courseId) => integration.cleanup(courseId),
     deactivateCourse: (courseId) => integration.updateCourseStatus(courseId, "tobedeleted"),
     reactivateCourse: (courseId) => integration.updateCourseStatus(courseId, "active"),
-    ensureAssessmentBank: (input) => assessments.ensureBank(input),
     createAssessmentTest: (input) => assessments.createTestScaffold(input),
-    teardownAssessmentTest: (qtiTestIdentifier) => assessments.teardownTest(qtiTestIdentifier)
+    createAssessmentItemXml: (input) => assessments.createItemFromXml(input),
+    updateAssessmentItemXml: (identifier, input) => assessments.updateItemFromXml(identifier, input)
   };
 }
 function recordTimebackClientSummary(outcome) {
@@ -80061,13 +79990,6 @@ function deriveSourcedIds2(courseId) {
     componentResource: `${courseId}-cr`
   };
 }
-function deriveAssessmentBankIds2(courseId) {
-  return {
-    component: `${courseId}-assessment-bank-component`,
-    resource: `${courseId}-assessment-bank-resource`,
-    componentResource: `${courseId}-assessment-bank-cr`
-  };
-}
 var CACHE_DEFAULTS4, RESOURCE_DEFAULTS4;
 var init_utils6 = __esm(() => {
   init_src();
@@ -80102,6 +80024,96 @@ var init_utils6 = __esm(() => {
 });
 
 // ../utils/src/timeback.ts
+function playcademySupportedQtiInteractionType(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim().toLowerCase().replaceAll("_", "-");
+  return PLAYCADEMY_SUPPORTED_QTI_INTERACTION_TYPE_SET.has(normalized) ? normalized : undefined;
+}
+function parseNumericTextEntry(input) {
+  const answer = typeof input.answer === "string" ? input.answer.trim() : "";
+  const comparison = input.comparison;
+  if (input.baseType !== "integer" && input.baseType !== "float") {
+    return { success: false, message: "Numeric answers must be integer or float responses" };
+  }
+  if (!answer || (input.baseType === "integer" ? !INTEGER_ANSWER_PATTERN.test(answer) : !FLOAT_ANSWER_PATTERN.test(answer) || !Number.isFinite(Number(answer)))) {
+    return { success: false, message: `The correct answer is not a valid ${input.baseType}` };
+  }
+  if (!comparison || typeof comparison !== "object" || !("kind" in comparison)) {
+    return { success: false, message: "Numeric comparison is required" };
+  }
+  if (comparison.kind === "equal") {
+    return {
+      success: true,
+      value: { baseType: input.baseType, answer, comparison: { kind: "equal" } }
+    };
+  }
+  if (input.baseType === "integer") {
+    return { success: false, message: "Integer answers cannot use decimal-place rounding" };
+  }
+  const figures = "figures" in comparison ? comparison.figures : undefined;
+  const roundingMode = "roundingMode" in comparison ? comparison.roundingMode : undefined;
+  if (comparison.kind !== "equal-rounded" || roundingMode !== "decimalPlaces" || !Number.isInteger(figures) || figures < 0 || figures > 15) {
+    return { success: false, message: "Decimal places must be a whole number from 0 to 15" };
+  }
+  return {
+    success: true,
+    value: {
+      baseType: "float",
+      answer,
+      comparison: { kind: "equal-rounded", roundingMode, figures }
+    }
+  };
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function hottextMaxChoices(selectableCount, multiple) {
+  return multiple ? selectableCount : 1;
+}
+function numericTextEntryXml(input) {
+  const comparison = input.numeric.comparison.kind === "equal-rounded" ? `<qti-equal-rounded rounding-mode="decimalPlaces" figures="${input.numeric.comparison.figures}">` : "<qti-equal>";
+  const closeComparison = input.numeric.comparison.kind === "equal-rounded" ? "</qti-equal-rounded>" : "</qti-equal>";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<qti-assessment-item xmlns="http://www.imsglobal.org/xsd/imsqtiasi_v3p0" identifier="${escapeXml(input.identifier)}" title="${escapeXml(input.title)}" adaptive="false" time-dependent="false">
+  <qti-response-declaration identifier="RESPONSE" cardinality="single" base-type="${input.numeric.baseType}">
+    <qti-correct-response><qti-value>${escapeXml(input.numeric.answer)}</qti-value></qti-correct-response>
+  </qti-response-declaration>
+  <qti-outcome-declaration identifier="SCORE" cardinality="single" base-type="float">
+    <qti-default-value><qti-value>0</qti-value></qti-default-value>
+  </qti-outcome-declaration>
+  <qti-item-body>
+    <p>${escapeXml(input.prompt)} <qti-text-entry-interaction response-identifier="RESPONSE" expected-length="15" /></p>
+  </qti-item-body>
+  <qti-response-processing>
+    <qti-response-condition>
+      <qti-response-if>
+        ${comparison}<qti-variable identifier="RESPONSE" /><qti-correct identifier="RESPONSE" />${closeComparison}
+        <qti-set-outcome-value identifier="SCORE"><qti-base-value base-type="float">1</qti-base-value></qti-set-outcome-value>
+      </qti-response-if>
+    </qti-response-condition>
+  </qti-response-processing>
+</qti-assessment-item>`;
+}
+function countQtiTestItems(test) {
+  let itemCount = 0;
+  for (const part of test["qti-test-part"] ?? []) {
+    for (const section of part["qti-assessment-section"] ?? []) {
+      itemCount += section["qti-assessment-item-ref"]?.length ?? 0;
+    }
+  }
+  return itemCount;
+}
+function isQtiItemOwnedByTest(item, testIdentifier) {
+  const hasOwnershipMetadata = Boolean(item.metadata && (("ownerSystem" in item.metadata) || (PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY in item.metadata)));
+  if (hasOwnershipMetadata) {
+    return item.metadata?.ownerSystem === PLAYCADEMY_QTI_OWNER_SYSTEM && item.metadata?.[PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY] === testIdentifier;
+  }
+  const identifierPrefix = `${testIdentifier}-q`;
+  const identifierSuffix = item.identifier?.startsWith(identifierPrefix) ? item.identifier.slice(identifierPrefix.length) : undefined;
+  return identifierSuffix !== undefined && /^[0-9a-f]{8}$/i.test(identifierSuffix);
+}
 function formatGradeLabel(grade) {
   if (grade === null || grade === undefined) {
     return "N/A";
@@ -80143,7 +80155,7 @@ function parseTimebackDiscrepancyQueueMetrics(values) {
   }
   return metrics;
 }
-var TIMEBACK_DISCREPANCY_QUEUE_WINDOWS, TIMEBACK_DISCREPANCY_QUEUE_METRICS, DEFAULT_TIMEBACK_DISCREPANCY_QUEUE_WINDOW = "this-week", TIMEBACK_DISCREPANCY_QUEUE_WINDOW_VALUES, TIMEBACK_DISCREPANCY_QUEUE_METRIC_VALUES;
+var TIMEBACK_DISCREPANCY_QUEUE_WINDOWS, TIMEBACK_DISCREPANCY_QUEUE_METRICS, PLAYCADEMY_QTI_OWNER_SYSTEM = "playcademy", PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY = "ownerTestIdentifier", PLAYCADEMY_QTI_EDITOR_MODE_KEY = "playcademyEditorMode", PLAYCADEMY_SUPPORTED_QTI_INTERACTION_TYPES, PLAYCADEMY_SUPPORTED_QTI_INTERACTION_TYPE_SET, INTEGER_ANSWER_PATTERN, FLOAT_ANSWER_PATTERN, INLINE_CHOICE_BLANK = "_____", DEFAULT_TIMEBACK_DISCREPANCY_QUEUE_WINDOW = "this-week", TIMEBACK_DISCREPANCY_QUEUE_WINDOW_VALUES, TIMEBACK_DISCREPANCY_QUEUE_METRIC_VALUES;
 var init_timeback3 = __esm(() => {
   TIMEBACK_DISCREPANCY_QUEUE_WINDOWS = [
     "today",
@@ -80154,6 +80166,17 @@ var init_timeback3 = __esm(() => {
     "custom"
   ];
   TIMEBACK_DISCREPANCY_QUEUE_METRICS = ["xp", "mastery", "time", "score"];
+  PLAYCADEMY_SUPPORTED_QTI_INTERACTION_TYPES = [
+    "choice",
+    "inline-choice",
+    "text-entry",
+    "order",
+    "match",
+    "hottext"
+  ];
+  PLAYCADEMY_SUPPORTED_QTI_INTERACTION_TYPE_SET = new Set(PLAYCADEMY_SUPPORTED_QTI_INTERACTION_TYPES);
+  INTEGER_ANSWER_PATTERN = /^[+-]?\d+$/;
+  FLOAT_ANSWER_PATTERN = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
   TIMEBACK_DISCREPANCY_QUEUE_WINDOW_VALUES = new Set(TIMEBACK_DISCREPANCY_QUEUE_WINDOWS);
   TIMEBACK_DISCREPANCY_QUEUE_METRIC_VALUES = new Set(TIMEBACK_DISCREPANCY_QUEUE_METRICS);
 });
@@ -81396,7 +81419,7 @@ class TimebackAdminService {
   }
   async getMasterableUnitsByCourse(courseIds) {
     const uniqueCourseIds = [...new Set(courseIds)];
-    const results = await TimebackAdminService.runWithConcurrency(uniqueCourseIds, TimebackAdminService.MASTERABLE_UNITS_CONCURRENCY, async (courseId) => [courseId, await this.getMasterableUnits(courseId)]);
+    const results = await runWithConcurrency(uniqueCourseIds, TimebackAdminService.MASTERABLE_UNITS_CONCURRENCY, async (courseId) => [courseId, await this.getMasterableUnits(courseId)]);
     return new Map(results);
   }
   deriveGameSensorUrl(game2) {
@@ -81577,7 +81600,7 @@ class TimebackAdminService {
   async loadEnrollmentAnalyticsSummaries(enrollmentIds) {
     const client = this.requireClient();
     const uniqueEnrollmentIds = [...new Set(enrollmentIds)];
-    const results = await TimebackAdminService.runWithConcurrency(uniqueEnrollmentIds, TimebackAdminService.ANALYTICS_CONCURRENCY, async (enrollmentId) => {
+    const results = await runWithConcurrency(uniqueEnrollmentIds, TimebackAdminService.ANALYTICS_CONCURRENCY, async (enrollmentId) => {
       try {
         const analytics = await client.api.edubridge.analytics.getEnrollmentFacts({
           enrollmentId,
@@ -81671,7 +81694,7 @@ class TimebackAdminService {
     if (options.runOwnersById.size === 0) {
       return { events: [], runIds: new Set };
     }
-    const hydratedRuns = await TimebackAdminService.runWithConcurrency([...options.runOwnersById.entries()], TimebackAdminService.DISCREPANCY_QUEUE_RUN_HYDRATION_CONCURRENCY, async ([runId, studentId]) => {
+    const hydratedRuns = await runWithConcurrency([...options.runOwnersById.entries()], TimebackAdminService.DISCREPANCY_QUEUE_RUN_HYDRATION_CONCURRENCY, async ([runId, studentId]) => {
       try {
         return {
           runId,
@@ -81704,7 +81727,7 @@ class TimebackAdminService {
     };
   }
   async buildMetricDiscrepancyQueueCandidates(user, options) {
-    const comparisonResults = await TimebackAdminService.runWithConcurrency(options.activityGroups, TimebackAdminService.DISCREPANCY_QUEUE_COMPARISON_CONCURRENCY, async (group) => {
+    const comparisonResults = await runWithConcurrency(options.activityGroups, TimebackAdminService.DISCREPANCY_QUEUE_COMPARISON_CONCURRENCY, async (group) => {
       try {
         return {
           group,
@@ -82704,7 +82727,7 @@ class TimebackAdminService {
       const action = context2.newMasterableUnits < context2.oldMasterableUnits ? "complete" : "revoke";
       const failed = [];
       let processed = 0;
-      await TimebackAdminService.runWithConcurrency(context2.affectedStudentIds, 8, async (studentId) => {
+      await runWithConcurrency(context2.affectedStudentIds, 8, async (studentId) => {
         try {
           await upsertMasteryCompletionEntry({
             client,
@@ -82925,28 +82948,9 @@ class TimebackAdminService {
   }
   async getCompletionStatusByCourse(client, courseIds, studentId) {
     const uniqueCourseIds = [...new Set(courseIds)];
-    const results = await TimebackAdminService.runWithConcurrency(uniqueCourseIds, TimebackAdminService.ANALYTICS_CONCURRENCY, async (courseId) => [courseId, await this.getCompletionStatus(client, courseId, studentId)]);
+    const results = await runWithConcurrency(uniqueCourseIds, TimebackAdminService.ANALYTICS_CONCURRENCY, async (courseId) => [courseId, await this.getCompletionStatus(client, courseId, studentId)]);
     return new Map(results);
   }
-  static async runWithConcurrency(items, concurrency, worker) {
-    if (items.length === 0) {
-      return [];
-    }
-    const effectiveConcurrency = Math.max(1, Math.min(concurrency, items.length));
-    const results = Array.from({ length: items.length });
-    let nextIndex = 0;
-    await Promise.all(Array.from({ length: effectiveConcurrency }, async () => {
-      while (true) {
-        const currentIndex = nextIndex;
-        nextIndex++;
-        if (currentIndex >= items.length) {
-          return;
-        }
-        results[currentIndex] = await worker(items[currentIndex]);
-      }
-    }));
-    return results;
-  }
 }
 var init_timeback_admin_service = __esm(async () => {
   init_drizzle_orm();
@@ -82973,8 +82977,877 @@ var init_timeback_admin_service = __esm(async () => {
   ]);
 });
 
+// ../api-core/src/utils/timeback-assessment-rules.util.ts
+function validateAssessmentStatusTransition(current, next) {
+  if (current === next) {
+    return;
+  }
+  const allowed = current === "draft" && next === "live" || current === "live" && next === "archived" || current === "archived" && next === "live";
+  if (!allowed) {
+    throw new ValidationError(`Assessment status cannot change from ${current} to ${next}`);
+  }
+}
+function isAssessmentPublicationTransition(current, next) {
+  return current !== "live" && next === "live";
+}
+function assertDraftAssessment(row) {
+  if (row.status !== "draft") {
+    throw new ValidationError("Only draft assessments can change QTI content or question membership");
+  }
+}
+function assertAllAssessmentAssociationsDraft(rows) {
+  if (rows.some((row) => row.status !== "draft")) {
+    throw new ValidationError("QTI content cannot change while any associated assessment is live or archived");
+  }
+}
+function assertAssessmentHasQuestions(questions) {
+  if (questions.length === 0) {
+    throw new ValidationError("An assessment must contain at least one question to publish");
+  }
+}
+function planAssessmentRemoval(status) {
+  if (status === "draft") {
+    return { kind: "delete", action: "discarded", operation: "discard_draft" };
+  }
+  if (status === "live") {
+    return { kind: "archive", action: "archived", operation: "archive" };
+  }
+  return { kind: "none", action: "archived" };
+}
+function buildAssessmentAssociationUpdates(row, input) {
+  const updates = {};
+  if (input.purpose !== undefined) {
+    updates.purpose = input.purpose;
+    if (row.status === "live" && input.purpose !== row.purpose) {
+      updates.sortOrder = null;
+    }
+  }
+  if (input.status !== undefined) {
+    updates.status = input.status;
+    if (input.status === "archived") {
+      updates.sortOrder = null;
+    }
+  }
+  return updates;
+}
+function validateUniqueAssessmentIdentifiers(testIdentifiers) {
+  if (new Set(testIdentifiers).size !== testIdentifiers.length) {
+    throw new ValidationError("Assessment order must contain unique identifiers");
+  }
+}
+function assertAssessmentOrderUpdateSucceeded(updatedRow) {
+  if (!updatedRow) {
+    throw new ValidationError("Assessment order changed while it was being saved. Refresh and try again.");
+  }
+  return updatedRow;
+}
+function lockOrderAssessmentRows(rows) {
+  return rows.toSorted((left, right) => left.id.localeCompare(right.id));
+}
+function orderLiveAssessmentRows(liveRows, purpose, testIdentifiers) {
+  const rowsByIdentifier = new Map(liveRows.map((row) => [row.qtiTestIdentifier, row]));
+  if (liveRows.length !== testIdentifiers.length || testIdentifiers.some((identifier) => !rowsByIdentifier.has(identifier))) {
+    throw new ValidationError(`Assessment order must include every live ${purpose} assessment exactly once`);
+  }
+  return testIdentifiers.map((identifier) => rowsByIdentifier.get(identifier));
+}
+var init_timeback_assessment_rules_util = __esm(() => {
+  init_errors();
+});
+
+// ../api-core/src/utils/timeback-qti-authoring.util.ts
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function qtiAuthoringSnapshot(input) {
+  if (!recordValue(input.interaction)) {
+    return;
+  }
+  return Object.fromEntries(QTI_AUTHORING_FIELDS.flatMap((field) => input[field] === undefined ? [] : [[field, input[field]]]));
+}
+function buildOwnedQtiQuestionMetadata(input, ownership, existingMetadata = {}) {
+  const inputMetadata = recordValue(input.metadata) ?? {};
+  const metadata2 = {
+    ...existingMetadata,
+    ...inputMetadata
+  };
+  const existingAuthoring = recordValue(existingMetadata[PLAYCADEMY_QTI_AUTHORING_METADATA_KEY]);
+  Reflect.deleteProperty(metadata2, PLAYCADEMY_QTI_AUTHORING_METADATA_KEY);
+  Reflect.deleteProperty(metadata2, PLAYCADEMY_QTI_EDITOR_MODE_KEY);
+  const authoring = qtiAuthoringSnapshot(input);
+  const shouldReplaceAuthoring = "interaction" in input || "numericTextEntry" in input;
+  const persistedAuthoring = authoring ?? (shouldReplaceAuthoring ? undefined : existingAuthoring);
+  return {
+    ...metadata2,
+    ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
+    ownerGameSlug: ownership.gameSlug,
+    [PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY]: ownership.testIdentifier,
+    ...persistedAuthoring ? { [PLAYCADEMY_QTI_AUTHORING_METADATA_KEY]: persistedAuthoring } : {}
+  };
+}
+function restoreQtiQuestionAuthoringData(item) {
+  const authoring = recordValue(item.metadata?.[PLAYCADEMY_QTI_AUTHORING_METADATA_KEY]);
+  if (!authoring) {
+    return item;
+  }
+  const restored = Object.fromEntries(QTI_AUTHORING_FIELDS.flatMap((field) => authoring[field] === undefined ? [] : [[field, authoring[field]]]));
+  return { ...item, ...restored };
+}
+function mergeQtiQuestionItem(item, fallbackItem, itemIdentifier, metadata2) {
+  return restoreQtiQuestionAuthoringData({
+    ...fallbackItem,
+    ...item,
+    identifier: itemIdentifier,
+    title: item.title || fallbackItem?.title || itemIdentifier,
+    type: item.type ?? fallbackItem?.type,
+    rawXml: item.rawXml ?? fallbackItem?.rawXml,
+    interaction: item.interaction ?? fallbackItem?.interaction,
+    responseDeclarations: item.responseDeclarations ?? fallbackItem?.responseDeclarations,
+    metadata: {
+      ...fallbackItem?.metadata,
+      ...item.metadata,
+      ...metadata2
+    }
+  });
+}
+function newPlaycademyQuestionIdentifier(testIdentifier) {
+  return `${testIdentifier}-q${crypto.randomUUID().slice(0, 8)}`;
+}
+function parseQtiQuestionCreationInput(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new ValidationError("Question creation input must be an object");
+  }
+  const rawInput = input;
+  if (rawInput.mode === undefined) {
+    return { kind: "authoring", input: rawInput };
+  }
+  if (rawInput.mode !== "copy") {
+    throw new ValidationError("Question creation mode is invalid");
+  }
+  const sourceItemIdentifier = typeof rawInput.sourceItemIdentifier === "string" ? rawInput.sourceItemIdentifier.trim() : "";
+  if (!sourceItemIdentifier) {
+    throw new ValidationError("A source question identifier is required to create a copy");
+  }
+  const unexpectedField = Object.keys(rawInput).find((field) => field !== "mode" && field !== "sourceItemIdentifier");
+  if (unexpectedField) {
+    throw new ValidationError(`Question copy input contains an unexpected “${unexpectedField}” field`);
+  }
+  return { kind: "copy", sourceItemIdentifier };
+}
+function nonEmptyMetadataString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function qtiQuestionOwnerTestIdentifier(item) {
+  if (item.metadata?.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
+    return;
+  }
+  return nonEmptyMetadataString(item.metadata[PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY]);
+}
+function qtiTestReferencesItem(test, itemIdentifier) {
+  return (test["qti-test-part"] ?? []).some((part) => (part["qti-assessment-section"] ?? []).some((section) => (section["qti-assessment-item-ref"] ?? []).some((reference) => reference.identifier === itemIdentifier)));
+}
+function resolveQtiQuestionOwnerGameSlug(item, ownerTest) {
+  if (item.metadata?.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
+    return;
+  }
+  if ("ownerGameSlug" in item.metadata) {
+    return nonEmptyMetadataString(item.metadata.ownerGameSlug);
+  }
+  const ownerTestIdentifier = qtiQuestionOwnerTestIdentifier(item);
+  if (!ownerTestIdentifier || !ownerTest || ownerTest.identifier !== ownerTestIdentifier || !qtiTestReferencesItem(ownerTest, item.identifier) || ownerTest.metadata?.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
+    return;
+  }
+  return nonEmptyMetadataString(ownerTest.metadata.ownerGameSlug);
+}
+function isQtiQuestionOwnedByGame(item, gameSlug, ownerTest) {
+  return resolveQtiQuestionOwnerGameSlug(item, ownerTest) === gameSlug;
+}
+function isQtiQuestionOwnedByContext(item, ownership, ownerTest) {
+  const declaredOwnerTest = qtiQuestionOwnerTestIdentifier(item);
+  if (declaredOwnerTest) {
+    return declaredOwnerTest === ownership.testIdentifier && isQtiQuestionOwnedByGame(item, ownership.gameSlug, ownerTest);
+  }
+  return isQtiItemOwnedByTest(item, ownership.testIdentifier);
+}
+function normalizedQtiInteractionType(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim().toLowerCase().replaceAll("_", "-");
+  return normalized || undefined;
+}
+function qtiXmlInteractionTypes(xml) {
+  const markup = xml.replaceAll(/<!--[\s\S]*?-->/g, "").replaceAll(/<!\[CDATA\[[\s\S]*?\]\]>/g, "");
+  const interactionPattern = /<(?!\/)(?:[A-Za-z_][\w.-]*:)?qti-([a-z][\w-]*)-interaction\b[^>]*>/gi;
+  return [...markup.matchAll(interactionPattern)].map((match) => match[1].toLowerCase());
+}
+function supportedQtiQuestionInteractionType(question) {
+  const interaction = recordValue(question.interaction);
+  const structuredTypes = [
+    normalizedQtiInteractionType(question.type),
+    normalizedQtiInteractionType(interaction?.type)
+  ].filter((type) => Boolean(type));
+  const distinctStructuredTypes = [...new Set(structuredTypes)];
+  if (distinctStructuredTypes.length > 1) {
+    return;
+  }
+  const rawXml = typeof question.rawXml === "string" ? question.rawXml : undefined;
+  if (rawXml) {
+    const xmlTypes = qtiXmlInteractionTypes(rawXml);
+    if (xmlTypes.length !== 1) {
+      return;
+    }
+    const [xmlType] = xmlTypes;
+    const [structuredType2] = distinctStructuredTypes;
+    if (structuredType2 && structuredType2 !== xmlType) {
+      return;
+    }
+    return playcademySupportedQtiInteractionType(xmlType);
+  }
+  const [structuredType] = distinctStructuredTypes;
+  return playcademySupportedQtiInteractionType(structuredType);
+}
+function assertSupportedQtiQuestionInteraction(question) {
+  if (!supportedQtiQuestionInteractionType(question)) {
+    throw new ValidationError("This QTI interaction type is not supported by the Playcademy question editor.");
+  }
+}
+function invalidQtiCopyXml() {
+  throw new ValidationError("The source question does not contain valid QTI item XML");
+}
+function markupEnd(xml, start2, allowInternalSubset) {
+  let quote = null;
+  let subsetDepth = 0;
+  for (let index2 = start2;index2 < xml.length; index2 += 1) {
+    const character = xml[index2];
+    if (quote) {
+      if (character === quote) {
+        quote = null;
+      }
+    } else if (character === '"' || character === "'") {
+      quote = character;
+    } else if (allowInternalSubset && character === "[") {
+      subsetDepth += 1;
+    } else if (allowInternalSubset && character === "]") {
+      subsetDepth = Math.max(0, subsetDepth - 1);
+    } else if (character === ">" && subsetDepth === 0) {
+      return index2;
+    }
+  }
+  return invalidQtiCopyXml();
+}
+function skipXmlWhitespace(xml, start2, end = xml.length) {
+  let cursor2 = start2;
+  while (cursor2 < end && /\s/.test(xml[cursor2] ?? "")) {
+    cursor2 += 1;
+  }
+  return cursor2;
+}
+function xmlPreambleEnd(xml, cursor2) {
+  if (xml.startsWith("<?", cursor2)) {
+    const end = xml.indexOf("?>", cursor2 + 2);
+    if (end === -1) {
+      return invalidQtiCopyXml();
+    }
+    return end + 2;
+  }
+  if (xml.startsWith("<!--", cursor2)) {
+    const end = xml.indexOf("-->", cursor2 + 4);
+    if (end === -1) {
+      return invalidQtiCopyXml();
+    }
+    return end + 3;
+  }
+  if (/^<!DOCTYPE\b/i.test(xml.slice(cursor2))) {
+    return markupEnd(xml, cursor2 + 2, true) + 1;
+  }
+  return null;
+}
+function qtiRootAttributes(xml, start2, end) {
+  const attributes = [];
+  let cursor2 = start2;
+  while (cursor2 < end) {
+    cursor2 = skipXmlWhitespace(xml, cursor2, end);
+    if (xml[cursor2] === "/") {
+      cursor2 += 1;
+    } else if (cursor2 < end) {
+      const nameMatch = /^[A-Za-z_][\w.:-]*/.exec(xml.slice(cursor2, end));
+      if (!nameMatch) {
+        return invalidQtiCopyXml();
+      }
+      const name3 = nameMatch[0];
+      cursor2 = skipXmlWhitespace(xml, cursor2 + name3.length, end);
+      if (xml[cursor2] !== "=") {
+        return invalidQtiCopyXml();
+      }
+      cursor2 = skipXmlWhitespace(xml, cursor2 + 1, end);
+      const quote = xml[cursor2];
+      if (quote !== '"' && quote !== "'") {
+        return invalidQtiCopyXml();
+      }
+      const valueStart = cursor2 + 1;
+      const valueEnd = xml.indexOf(quote, valueStart);
+      if (valueEnd === -1 || valueEnd > end) {
+        return invalidQtiCopyXml();
+      }
+      attributes.push({ name: name3, quote, valueStart, valueEnd });
+      cursor2 = valueEnd + 1;
+    }
+  }
+  return attributes;
+}
+function qtiItemStartTag(xml) {
+  let cursor2 = xml.charCodeAt(0) === 65279 ? 1 : 0;
+  while (cursor2 < xml.length) {
+    cursor2 = skipXmlWhitespace(xml, cursor2);
+    const preambleEnd = xmlPreambleEnd(xml, cursor2);
+    if (preambleEnd !== null) {
+      cursor2 = preambleEnd;
+    } else {
+      const root = /^<([A-Za-z_][\w.:-]*)/.exec(xml.slice(cursor2));
+      if (!root || root[1].split(":").at(-1) !== "qti-assessment-item") {
+        return invalidQtiCopyXml();
+      }
+      const attributesStart = cursor2 + root[0].length;
+      const end = markupEnd(xml, attributesStart, false);
+      const attributes = qtiRootAttributes(xml, attributesStart, end);
+      let insertionPoint = skipXmlWhitespaceBackward(xml, end);
+      if (xml[insertionPoint - 1] === "/") {
+        insertionPoint -= 1;
+      }
+      return { attributes, insertionPoint };
+    }
+  }
+  return invalidQtiCopyXml();
+}
+function skipXmlWhitespaceBackward(xml, start2) {
+  let cursor2 = start2;
+  while (/\s/.test(xml[cursor2 - 1] ?? "")) {
+    cursor2 -= 1;
+  }
+  return cursor2;
+}
+function escapeXmlAttribute(value, quote) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(quote, quote === '"' ? "&quot;" : "&apos;");
+}
+function rewriteQtiItemIdentity(xml, identifier, title) {
+  if (!xml.trim() || !identifier.trim() || !title.trim()) {
+    return invalidQtiCopyXml();
+  }
+  const root = qtiItemStartTag(xml);
+  const replacements = [];
+  const targetAttributes = new Map([
+    ["identifier", identifier],
+    ["title", title]
+  ]);
+  for (const [name3, value] of targetAttributes) {
+    const matches = root.attributes.filter((attribute2) => attribute2.name === name3);
+    if (matches.length > 1) {
+      return invalidQtiCopyXml();
+    }
+    const attribute = matches[0];
+    if (attribute) {
+      replacements.push({
+        start: attribute.valueStart,
+        end: attribute.valueEnd,
+        value: escapeXmlAttribute(value, attribute.quote)
+      });
+    } else {
+      replacements.push({
+        start: root.insertionPoint,
+        end: root.insertionPoint,
+        value: ` ${name3}="${escapeXmlAttribute(value, '"')}"`
+      });
+    }
+  }
+  return replacements.toSorted((left, right) => right.start - left.start).reduce((rewritten, replacement) => `${rewritten.slice(0, replacement.start)}${replacement.value}${rewritten.slice(replacement.end)}`, xml);
+}
+function buildQtiQuestionCopyInput(input) {
+  assertSupportedQtiQuestionInteraction(input.source);
+  const title = input.source.title?.trim() || input.source.identifier;
+  if (!input.source.rawXml) {
+    return invalidQtiCopyXml();
+  }
+  const sourceMetadata = { ...input.source.metadata };
+  if (sourceMetadata.ownerSystem !== PLAYCADEMY_QTI_OWNER_SYSTEM) {
+    Reflect.deleteProperty(sourceMetadata, PLAYCADEMY_QTI_AUTHORING_METADATA_KEY);
+  }
+  const metadata2 = buildOwnedQtiQuestionMetadata({
+    metadata: {
+      copiedFromItemIdentifier: input.source.identifier,
+      integrationId: input.integrationId
+    }
+  }, {
+    gameSlug: input.gameSlug,
+    testIdentifier: input.targetTestIdentifier
+  }, sourceMetadata);
+  return {
+    identifier: input.targetIdentifier,
+    title,
+    xml: rewriteQtiItemIdentity(input.source.rawXml, input.targetIdentifier, title),
+    metadata: metadata2
+  };
+}
+function assertQtiQuestionEditable(item, ownership, ownerTest) {
+  if (!isQtiQuestionOwnedByContext(item, ownership, ownerTest)) {
+    throw new ValidationError("Shared question references are read-only. Copy the question to create an editable independent item.");
+  }
+}
+function buildNumericQuestionXml(input, identifier, title) {
+  if (input.format === "xml") {
+    throw new ValidationError("Raw question XML is not accepted at this API boundary");
+  }
+  const candidate = input.numericTextEntry;
+  if (candidate === undefined) {
+    return null;
+  }
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+    throw new ValidationError("Numeric text-entry data is invalid");
+  }
+  const prompt = "prompt" in candidate ? candidate.prompt : undefined;
+  const numeric3 = parseNumericTextEntry({
+    baseType: "baseType" in candidate ? candidate.baseType : undefined,
+    answer: "answer" in candidate ? candidate.answer : undefined,
+    comparison: "comparison" in candidate ? candidate.comparison : undefined
+  });
+  if (!numeric3.success) {
+    throw new ValidationError(numeric3.message);
+  }
+  if (!title || typeof prompt !== "string" || !prompt.trim()) {
+    throw new ValidationError("Numeric questions require a title and prompt");
+  }
+  return numericTextEntryXml({ identifier, title, prompt: prompt.trim(), numeric: numeric3.value });
+}
+function buildExactMatchQuestionXml(input) {
+  const responseIdentifier = escapeXml(input.responseIdentifier);
+  const correctValues = input.correctIdentifiers.map((identifier) => `      <qti-value>${escapeXml(identifier)}</qti-value>`).join(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<qti-assessment-item xmlns="http://www.imsglobal.org/xsd/imsqtiasi_v3p0" identifier="${escapeXml(input.identifier)}" title="${escapeXml(input.title)}" adaptive="false" time-dependent="false">
+  <qti-response-declaration identifier="${responseIdentifier}" cardinality="${input.cardinality}" base-type="identifier">
+    <qti-correct-response>
+${correctValues}
+    </qti-correct-response>
+  </qti-response-declaration>
+  <qti-outcome-declaration identifier="FEEDBACK" cardinality="single" base-type="identifier" />
+  <qti-outcome-declaration identifier="SCORE" cardinality="single" base-type="float">
+    <qti-default-value><qti-value>0</qti-value></qti-default-value>
+  </qti-outcome-declaration>
+  <qti-item-body>
+${input.itemBody}
+  </qti-item-body>
+  <qti-response-processing>
+    <qti-response-condition>
+      <qti-response-if>
+        <qti-match><qti-variable identifier="${responseIdentifier}" /><qti-correct identifier="${responseIdentifier}" /></qti-match>
+        <qti-set-outcome-value identifier="FEEDBACK"><qti-base-value base-type="identifier">CORRECT</qti-base-value></qti-set-outcome-value>
+        <qti-set-outcome-value identifier="SCORE"><qti-base-value base-type="float">1</qti-base-value></qti-set-outcome-value>
+      </qti-response-if>
+      <qti-response-else>
+        <qti-set-outcome-value identifier="FEEDBACK"><qti-base-value base-type="identifier">INCORRECT</qti-base-value></qti-set-outcome-value>
+        <qti-set-outcome-value identifier="SCORE"><qti-base-value base-type="float">0</qti-base-value></qti-set-outcome-value>
+      </qti-response-else>
+    </qti-response-condition>
+  </qti-response-processing>
+</qti-assessment-item>`;
+}
+function parseInlineChoices(value) {
+  if (!Array.isArray(value) || value.length < 2) {
+    throw new ValidationError("Inline-choice questions require at least two choices");
+  }
+  const choices = value.map((choice) => {
+    const record3 = recordValue(choice);
+    const identifier = record3?.identifier;
+    const content = record3?.content;
+    if (typeof identifier !== "string" || !identifier.trim() || typeof content !== "string" || !content.trim()) {
+      throw new ValidationError("Inline-choice options are invalid");
+    }
+    return { identifier: identifier.trim(), content: content.trim() };
+  });
+  if (new Set(choices.map((choice) => choice.identifier)).size !== choices.length) {
+    throw new ValidationError("Inline-choice option identifiers must be unique");
+  }
+  return choices;
+}
+function inlineChoiceCorrectIdentifier(input, responseIdentifier, choiceIdentifiers) {
+  const declarations = Array.isArray(input.responseDeclarations) ? input.responseDeclarations : [];
+  const declaration = declarations.map(recordValue).find((candidate) => candidate?.identifier === responseIdentifier);
+  const correctResponse = recordValue(declaration?.correctResponse);
+  const rawValues = correctResponse?.value;
+  const values = Array.isArray(rawValues) ? rawValues.filter((value) => typeof value === "string") : [];
+  if (declaration?.cardinality !== "single" || declaration.baseType !== "identifier") {
+    throw new ValidationError("Inline-choice questions require a single-identifier response declaration");
+  }
+  if (values.length !== 1 || !choiceIdentifiers.has(values[0])) {
+    throw new ValidationError("Inline-choice questions require one valid correct option");
+  }
+  return values[0];
+}
+function buildInlineChoiceQuestionXml(input, identifier, title) {
+  const interaction = recordValue(input.interaction);
+  const interactionType = normalizedQtiInteractionType(interaction?.type ?? input.type);
+  if (interactionType !== "inline-choice") {
+    return null;
+  }
+  const responseIdentifier = interaction?.responseIdentifier;
+  const structure = recordValue(interaction?.questionStructure);
+  const prompt = structure?.prompt;
+  if (!structure || typeof responseIdentifier !== "string" || !responseIdentifier.trim()) {
+    throw new ValidationError("Inline-choice question data is invalid");
+  }
+  if (!title || typeof prompt !== "string" || !prompt.trim()) {
+    throw new ValidationError("Inline-choice questions require a title and prompt");
+  }
+  const normalizedPrompt = prompt.trim();
+  const promptParts = normalizedPrompt.split(INLINE_CHOICE_BLANK);
+  if (promptParts.length !== 2) {
+    throw new ValidationError("Inline-choice questions require exactly one blank");
+  }
+  const choices = parseInlineChoices(structure.inlineChoices);
+  const choiceIdentifiers = new Set(choices.map((choice) => choice.identifier));
+  const correctIdentifier = inlineChoiceCorrectIdentifier(input, responseIdentifier, choiceIdentifiers);
+  const choicesXml = choices.map((choice) => `        <qti-inline-choice identifier="${escapeXml(choice.identifier)}">${escapeXml(choice.content)}</qti-inline-choice>`).join(`
+`);
+  const [before = "", after = ""] = promptParts;
+  const itemBody = `    <p>${escapeXml(before)}<qti-inline-choice-interaction response-identifier="${escapeXml(responseIdentifier)}">
+${choicesXml}
+      </qti-inline-choice-interaction>${escapeXml(after)}</p>`;
+  return buildExactMatchQuestionXml({
+    identifier,
+    title,
+    responseIdentifier,
+    cardinality: "single",
+    correctIdentifiers: [correctIdentifier],
+    itemBody
+  });
+}
+function parseHottextSegments(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new ValidationError("Hottext questions require passage segments");
+  }
+  const segments = value.map((segment) => {
+    const record3 = recordValue(segment);
+    const identifier = record3?.identifier;
+    const content = record3?.content;
+    const mode = record3?.mode;
+    if (typeof identifier !== "string" || typeof content !== "string" || !content.trim() || !["plain", "option", "correct"].includes(String(mode))) {
+      throw new ValidationError("Hottext passage segments are invalid");
+    }
+    return {
+      identifier: identifier.trim(),
+      content: content.trim(),
+      mode
+    };
+  });
+  const selectable = segments.filter((segment) => segment.mode !== "plain");
+  const correct = selectable.filter((segment) => segment.mode === "correct");
+  const identifiers = selectable.map((segment) => segment.identifier);
+  if (selectable.length < 2) {
+    throw new ValidationError("Hottext questions require at least two selectable phrases");
+  }
+  if (identifiers.some((identifier) => !identifier)) {
+    throw new ValidationError("Hottext selectable phrases require identifiers");
+  }
+  if (new Set(identifiers).size !== identifiers.length) {
+    throw new ValidationError("Hottext selectable phrase identifiers must be unique");
+  }
+  if (correct.length === 0) {
+    throw new ValidationError("Hottext questions require a correct phrase");
+  }
+  return { segments, selectable, correct };
+}
+function buildHottextQuestionXml(input, identifier, title) {
+  const candidate = input.hottext;
+  if (candidate === undefined) {
+    return null;
+  }
+  const hottext = recordValue(candidate);
+  if (!hottext) {
+    throw new ValidationError("Hottext question data is invalid");
+  }
+  const prompt = hottext.prompt;
+  if (!title || typeof prompt !== "string" || !prompt.trim()) {
+    throw new ValidationError("Hottext questions require a title and prompt");
+  }
+  const { segments, selectable, correct } = parseHottextSegments(hottext.segments);
+  const multiple = correct.length > 1;
+  const maxChoices = hottextMaxChoices(selectable.length, multiple);
+  const passage = segments.map((segment) => segment.mode === "plain" ? escapeXml(segment.content) : `<qti-hottext identifier="${escapeXml(segment.identifier)}">${escapeXml(segment.content)}</qti-hottext>`).join(" ");
+  const itemBody = `    <qti-hottext-interaction response-identifier="RESPONSE" max-choices="${maxChoices}">
+      <qti-prompt>${escapeXml(prompt.trim())}</qti-prompt>
+      <p>${passage}</p>
+    </qti-hottext-interaction>`;
+  return buildExactMatchQuestionXml({
+    identifier,
+    title,
+    responseIdentifier: "RESPONSE",
+    cardinality: multiple ? "multiple" : "single",
+    correctIdentifiers: correct.map((segment) => segment.identifier),
+    itemBody
+  });
+}
+function buildQuestionXml(input, identifier, title) {
+  for (const build2 of QUESTION_XML_BUILDERS) {
+    const xml = build2(input, identifier, title);
+    if (xml !== null) {
+      return xml;
+    }
+  }
+  return null;
+}
+function buildCreatedQtiQuestionReference(input) {
+  return {
+    ownership: "owned",
+    reference: {
+      identifier: input.itemIdentifier,
+      href: input.href,
+      testPart: input.partIdentifier,
+      section: input.sectionIdentifier
+    },
+    question: mergeQtiQuestionItem(input.item, input.fallbackItem, input.itemIdentifier, input.metadata)
+  };
+}
+function buildHydratedQtiQuestionReference(input) {
+  const identifier = input.reference.reference.identifier;
+  const ownerGameSlug = resolveQtiQuestionOwnerGameSlug(input.item, input.ownerTest);
+  const authoritativeItem = ownerGameSlug ? {
+    ...input.item,
+    metadata: { ...input.item.metadata, ownerGameSlug }
+  } : input.item;
+  const question = mergeQtiQuestionItem(authoritativeItem, input.reference.question, identifier);
+  return {
+    ...input.reference,
+    ownership: isQtiQuestionOwnedByContext(question, { gameSlug: input.gameSlug, testIdentifier: input.testIdentifier }, input.ownerTest) ? "owned" : "shared",
+    question
+  };
+}
+function isQtiTestOwnedByGame(test, gameSlug) {
+  return test.metadata?.ownerSystem === PLAYCADEMY_QTI_OWNER_SYSTEM && test.metadata.ownerGameSlug === gameSlug;
+}
+function assertQtiTestOwnedByGame(test, gameSlug) {
+  if (!isQtiTestOwnedByGame(test, gameSlug)) {
+    throw new ValidationError("Shared assessment references are read-only. Copy the assessment to create an editable independent test.");
+  }
+}
+function qtiTestParts(test) {
+  const parts2 = test["qti-test-part"];
+  if (!Array.isArray(parts2) || parts2.length === 0) {
+    throw new ValidationError(`Assessment ${test.identifier} has no test parts`);
+  }
+  for (const [partIndex, part] of parts2.entries()) {
+    if (!part || typeof part !== "object" || Array.isArray(part)) {
+      throw new ValidationError(`Assessment ${test.identifier} contains an invalid test part at position ${partIndex + 1}`);
+    }
+    const sections = part["qti-assessment-section"];
+    if (!Array.isArray(sections)) {
+      throw new ValidationError(`Assessment ${test.identifier} test part ${partIndex + 1} has no section list`);
+    }
+  }
+  return parts2;
+}
+function qtiTestOptionalAttributes(test) {
+  return {
+    ...test.qtiVersion ? { qtiVersion: test.qtiVersion } : {},
+    ...test.timeLimit !== undefined ? { timeLimit: test.timeLimit } : {},
+    ...test.maxAttempts !== undefined ? { maxAttempts: test.maxAttempts } : {},
+    ...test.toolsEnabled !== undefined ? { toolsEnabled: test.toolsEnabled } : {}
+  };
+}
+function buildQtiAssessmentItemCopyPlan(test, targetTestIdentifier, hrefForIdentifier, createIdentifier = newPlaycademyQuestionIdentifier) {
+  const sourceIdentifiers = [];
+  const seen = new Set;
+  for (const part of qtiTestParts(test)) {
+    for (const section of part["qti-assessment-section"]) {
+      for (const reference of section["qti-assessment-item-ref"] ?? []) {
+        if (!seen.has(reference.identifier)) {
+          seen.add(reference.identifier);
+          sourceIdentifiers.push(reference.identifier);
+        }
+      }
+    }
+  }
+  return sourceIdentifiers.map((sourceIdentifier) => {
+    const targetIdentifier = createIdentifier(targetTestIdentifier);
+    return {
+      sourceIdentifier,
+      targetIdentifier,
+      href: hrefForIdentifier(targetIdentifier)
+    };
+  });
+}
+function buildQtiTestStructureInput(test, targetTestIdentifier, itemCopies) {
+  const outcomeDeclarations = test["qti-outcome-declaration"];
+  if (outcomeDeclarations !== undefined && !Array.isArray(outcomeDeclarations)) {
+    throw new ValidationError(`Assessment ${test.identifier} has an invalid outcome declaration list`);
+  }
+  return {
+    "qti-test-part": qtiTestParts(test).map((part, partIndex) => ({
+      identifier: targetTestIdentifier ? `${targetTestIdentifier}-part${partIndex + 1}` : part.identifier,
+      navigationMode: part.navigationMode,
+      submissionMode: part.submissionMode,
+      "qti-assessment-section": part["qti-assessment-section"].map((section, sectionIndex) => {
+        let sectionIdentifier = section.identifier;
+        if (targetTestIdentifier) {
+          sectionIdentifier = partIndex === 0 && sectionIndex === 0 ? `${targetTestIdentifier}-section1` : `${targetTestIdentifier}-part${partIndex + 1}-section${sectionIndex + 1}`;
+        }
+        return {
+          identifier: sectionIdentifier,
+          title: section.title,
+          visible: section.visible ?? true,
+          ...section.required !== undefined ? { required: section.required } : {},
+          ...section.fixed !== undefined ? { fixed: section.fixed } : {},
+          sequence: section.sequence ?? sectionIndex + 1,
+          ...section["qti-assessment-item-ref"] ? {
+            "qti-assessment-item-ref": section["qti-assessment-item-ref"].map((item, itemIndex) => {
+              const copy = itemCopies?.get(item.identifier);
+              if (itemCopies && !copy) {
+                throw new ValidationError(`Assessment copy is missing question ${item.identifier}`);
+              }
+              return {
+                identifier: copy?.targetIdentifier ?? item.identifier,
+                href: copy?.href ?? item.href,
+                sequence: item.sequence ?? itemIndex + 1
+              };
+            })
+          } : {}
+        };
+      })
+    })),
+    ...outcomeDeclarations ? {
+      "qti-outcome-declaration": outcomeDeclarations.map((declaration) => ({
+        identifier: declaration.identifier,
+        ...declaration.cardinality !== undefined ? { cardinality: declaration.cardinality } : {},
+        baseType: declaration.baseType,
+        ...declaration.normalMaximum !== undefined ? { normalMaximum: declaration.normalMaximum } : {},
+        ...declaration.normalMinimum !== undefined ? { normalMinimum: declaration.normalMinimum } : {},
+        ...declaration.defaultValue ? {
+          defaultValue: declaration.defaultValue.value !== undefined ? { value: declaration.defaultValue.value } : {}
+        } : {}
+      }))
+    } : {}
+  };
+}
+function buildQtiTestUpdateInput(test, title) {
+  return {
+    title,
+    ...qtiTestOptionalAttributes(test),
+    ...test.metadata ? { metadata: test.metadata } : {},
+    ...buildQtiTestStructureInput(test)
+  };
+}
+function buildQtiTestCopyInput(source, targetTestIdentifier, metadata2, itemCopies) {
+  const copiesBySourceIdentifier = new Map(itemCopies.map((copy) => [copy.sourceIdentifier, copy]));
+  return {
+    identifier: targetTestIdentifier,
+    title: `${source.title} (copy)`,
+    ...qtiTestOptionalAttributes(source),
+    metadata: metadata2,
+    ...buildQtiTestStructureInput(source, targetTestIdentifier, copiesBySourceIdentifier)
+  };
+}
+function validateUniqueQuestionIdentifiers(itemIdentifiers) {
+  if (itemIdentifiers.length === 0 || new Set(itemIdentifiers).size !== itemIdentifiers.length) {
+    throw new ValidationError("Question order must contain unique question identifiers");
+  }
+}
+function resolveQtiQuestionSection(test, qtiTestIdentifier, itemIdentifier, expectedItemIdentifiers) {
+  let selectedPart;
+  let selectedSection;
+  for (const part of qtiTestParts(test)) {
+    for (const section of part["qti-assessment-section"]) {
+      if (!itemIdentifier || section["qti-assessment-item-ref"]?.some((item) => item.identifier === itemIdentifier)) {
+        selectedPart = part;
+        selectedSection = section;
+        break;
+      }
+    }
+    if (selectedSection) {
+      break;
+    }
+  }
+  if (!selectedPart || !selectedSection) {
+    throw new ValidationError(itemIdentifier ? `Question ${itemIdentifier} is not referenced by assessment ${qtiTestIdentifier}` : `Assessment ${qtiTestIdentifier} has no section for questions`);
+  }
+  if (expectedItemIdentifiers) {
+    const sectionIdentifiers = selectedSection["qti-assessment-item-ref"]?.map((item) => item.identifier) ?? [];
+    const expectedIdentifiers = new Set(expectedItemIdentifiers);
+    if (expectedIdentifiers.size !== sectionIdentifiers.length || sectionIdentifiers.some((identifier) => !expectedIdentifiers.has(identifier))) {
+      throw new ValidationError("Questions can only be reordered within one complete assessment section");
+    }
+  }
+  return {
+    partIdentifier: selectedPart.identifier,
+    sectionIdentifier: selectedSection.identifier
+  };
+}
+var PLAYCADEMY_QTI_AUTHORING_METADATA_KEY = "playcademyAuthoring", QTI_AUTHORING_FIELDS, QUESTION_XML_BUILDERS;
+var init_timeback_qti_authoring_util = __esm(() => {
+  init_timeback3();
+  init_errors();
+  QTI_AUTHORING_FIELDS = [
+    "type",
+    "qtiVersion",
+    "timeDependent",
+    "adaptive",
+    "preInteraction",
+    "interaction",
+    "postInteraction",
+    "responseDeclarations",
+    "outcomeDeclarations",
+    "responseProcessing",
+    "modalFeedback",
+    "feedbackInline",
+    "feedbackBlock",
+    "rubrics",
+    "stimulus",
+    "content"
+  ];
+  QUESTION_XML_BUILDERS = [
+    buildNumericQuestionXml,
+    buildHottextQuestionXml,
+    buildInlineChoiceQuestionXml
+  ];
+});
+
+// ../api-core/src/utils/timeback-qti-library.util.ts
+function newPlaycademyTestIdentifier() {
+  return `${PLAYCADEMY_QTI_SOURCE_PREFIX}${crypto.randomUUID()}`;
+}
+function playcademySourceWhere() {
+  return {
+    identifier: {
+      gte: PLAYCADEMY_QTI_SOURCE_PREFIX,
+      lt: PLAYCADEMY_QTI_SOURCE_UPPER_BOUND
+    }
+  };
+}
+function buildQtiLibraryListPlan(params) {
+  const query = params.query?.trim() || undefined;
+  if (!params.source && !query) {
+    throw new Error("An exact QTI source identifier is required for a global lookup");
+  }
+  let where;
+  if (params.source) {
+    where = playcademySourceWhere();
+  } else if (query) {
+    where = { identifier: query };
+  }
+  return {
+    kind: "direct",
+    params: {
+      ...where ? { where } : {},
+      ...params.source && query ? { query } : {},
+      page: params.page,
+      limit: params.limit,
+      ...params.source ? { sort: "identifier", order: "asc" } : {}
+    }
+  };
+}
+var PLAYCADEMY_QTI_SOURCE_PREFIX = "playcademy-test-", PLAYCADEMY_QTI_SOURCE_UPPER_BOUND = "playcademy-test.";
+
 // ../api-core/src/services/timeback-assessments.service.ts
 class TimebackAssessmentsService {
+  static QTI_HYDRATION_CONCURRENCY = 8;
   deps;
   constructor(deps) {
     this.deps = deps;
@@ -82991,33 +83864,19 @@ class TimebackAssessmentsService {
   }
   async listAssessments(integrationId) {
     const client = this.requireClient();
-    await this.requireIntegration(integrationId);
+    const ownership = await this.requireQtiTestOwnershipContext(integrationId);
     const rows = await this.deps.db.query.gameTimebackAssessmentTests.findMany({
-      where: eq(gameTimebackAssessmentTests.integrationId, integrationId),
-      orderBy: asc(gameTimebackAssessmentTests.sortOrder)
+      where: eq(gameTimebackAssessmentTests.integrationId, integrationId)
     });
-    if (rows.length === 0) {
-      return [];
-    }
-    const assessments = await Promise.all(rows.map(async (row) => {
+    const assessments = await runWithConcurrency(rows, TimebackAssessmentsService.QTI_HYDRATION_CONCURRENCY, async (row) => {
       try {
         const test = await client.qtiApi.assessmentTests.get(row.qtiTestIdentifier);
-        let itemCount = 0;
-        for (const part of test["qti-test-part"] ?? []) {
-          for (const section of part["qti-assessment-section"] ?? []) {
-            itemCount += section["qti-assessment-item-ref"]?.length ?? 0;
-          }
-        }
         return {
-          id: row.id,
-          integrationId: row.integrationId,
-          qtiTestIdentifier: row.qtiTestIdentifier,
-          bankResourceId: row.bankResourceId,
-          bankActive: row.bankActive,
-          sortOrder: row.sortOrder,
+          ...this.associationSummary(row),
           title: test.title,
-          questionCount: itemCount,
-          isActive: row.bankActive
+          questionCount: countQtiTestItems(test),
+          available: true,
+          editable: isQtiTestOwnedByGame(test, ownership.gameSlug)
         };
       } catch (error88) {
         addEvent("assessment.qti_fetch_failed", {
@@ -83026,319 +83885,420 @@ class TimebackAssessmentsService {
           "app.error.message": errorMessage(error88)
         });
         return {
-          id: row.id,
-          integrationId: row.integrationId,
-          qtiTestIdentifier: row.qtiTestIdentifier,
-          bankResourceId: row.bankResourceId,
-          bankActive: row.bankActive,
-          sortOrder: row.sortOrder,
+          ...this.associationSummary(row),
           title: row.qtiTestIdentifier,
           questionCount: 0,
-          isActive: row.bankActive
+          available: false,
+          editable: false
         };
       }
-    }));
-    return assessments;
+    });
+    return assessments.toSorted((a, b) => a.title.localeCompare(b.title));
   }
   async createAssessment(integrationId, input) {
     const client = this.requireClient();
-    const integration = await this.requireIntegration(integrationId);
-    await client.course.ensureAssessmentBank({
-      courseId: integration.courseId,
-      subject: integration.subject,
-      grade: integration.grade
-    });
+    const ownership = await this.requireQtiTestOwnershipContext(integrationId);
+    const { integration } = ownership;
     await client.course.createAssessmentTest({
       identifier: input.qtiTestIdentifier,
       title: input.title,
       metadata: {
+        ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
+        ownerGameSlug: ownership.gameSlug,
         integrationId,
         subject: integration.subject,
         grade: String(integration.grade)
       }
     });
-    const maxSortOrder = await this.getMaxSortOrder(integrationId);
-    const [row] = await this.deps.db.insert(gameTimebackAssessmentTests).values({
-      integrationId,
-      qtiTestIdentifier: input.qtiTestIdentifier,
-      sortOrder: maxSortOrder + 1
-    }).returning();
-    setAttribute("app.assessment.operation", "create");
-    return row;
-  }
-  async deleteAssessment(integrationId, qtiTestIdentifier) {
-    const client = this.requireClient();
-    const row = await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
-    if (row.bankActive) {
-      await this.deactivateAssessment(integrationId, qtiTestIdentifier);
-    }
     try {
-      await client.course.teardownAssessmentTest(qtiTestIdentifier);
+      const [row] = await this.deps.db.insert(gameTimebackAssessmentTests).values({
+        integrationId,
+        qtiTestIdentifier: input.qtiTestIdentifier,
+        purpose: input.purpose,
+        status: "draft"
+      }).returning();
+      setAttribute("app.assessment.operation", "create");
+      return row;
     } catch (error88) {
-      addEvent("assessment.qti_cleanup_partial", {
-        "app.assessment.qti_test_identifier": qtiTestIdentifier,
-        "exception.type": errorType(error88),
-        "app.error.message": errorMessage(error88)
-      });
+      let committedRow;
+      try {
+        committedRow = await this.deps.db.query.gameTimebackAssessmentTests.findFirst({
+          where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, input.qtiTestIdentifier))
+        });
+      } catch (verificationError) {
+        addEvent("assessment.qti_test_create_commit_verification_failed", {
+          "app.assessment.qti_test_identifier": input.qtiTestIdentifier,
+          "exception.type": errorType(verificationError),
+          "app.error.message": errorMessage(verificationError)
+        });
+        throw error88;
+      }
+      if (committedRow) {
+        setAttribute("app.assessment.operation", "create");
+        return committedRow;
+      }
+      try {
+        await client.qtiApi.assessmentTests.delete(input.qtiTestIdentifier);
+      } catch (cleanupError) {
+        if (!isApiError(cleanupError) || cleanupError.statusCode !== 404) {
+          addEvent("assessment.qti_test_create_cleanup_failed", {
+            "app.assessment.qti_test_identifier": input.qtiTestIdentifier,
+            "exception.type": errorType(cleanupError),
+            "app.error.message": errorMessage(cleanupError)
+          });
+        }
+      }
+      throw error88;
     }
-    await this.deps.db.delete(gameTimebackAssessmentTests).where(eq(gameTimebackAssessmentTests.id, row.id));
-    setAttribute("app.assessment.operation", "delete");
   }
-  async reorderAssessments(integrationId, identifiers) {
-    await this.requireIntegration(integrationId);
-    await Promise.all(identifiers.map((identifier, i2) => this.deps.db.update(gameTimebackAssessmentTests).set({ sortOrder: i2 }).where(and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, identifier)))));
-  }
-  async listQuestions(integrationId, qtiTestIdentifier) {
-    const client = this.requireClient();
-    await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
-    return await client.qtiApi.assessmentTests.getQuestions(qtiTestIdentifier);
-  }
-  async createQuestion(integrationId, qtiTestIdentifier, input) {
-    const client = this.requireClient();
-    await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
-    const itemIdentifier = input.identifier;
-    if (typeof itemIdentifier !== "string" || !itemIdentifier) {
-      throw new ValidationError("Question identifier is required");
-    }
-    const item = await client.qtiApi.assessmentItems.create(input);
-    await this.qtiSectionItems(client, qtiTestIdentifier).add({
-      identifier: itemIdentifier,
-      href: `${client.getQtiBaseUrl()}/assessment-items/${itemIdentifier}`
+  async updateAssessment(integrationId, qtiTestIdentifier, input) {
+    return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx, associations) => {
+      const updates = buildAssessmentAssociationUpdates(row, input);
+      if (input.status !== undefined) {
+        validateAssessmentStatusTransition(row.status, input.status);
+        if (isAssessmentPublicationTransition(row.status, input.status)) {
+          await this.validateAssessmentHasQuestions(qtiTestIdentifier);
+        }
+      }
+      if (input.title !== undefined) {
+        assertDraftAssessment(row);
+        assertAllAssessmentAssociationsDraft(associations);
+        const client = this.requireClient();
+        const test = await client.qtiApi.assessmentTests.get(qtiTestIdentifier);
+        const ownership = await this.requireQtiTestOwnershipContext(integrationId, tx);
+        assertQtiTestOwnedByGame(test, ownership.gameSlug);
+        await client.qtiApi.assessmentTests.update(qtiTestIdentifier, buildQtiTestUpdateInput(test, input.title));
+      }
+      let updated = row;
+      if (Object.keys(updates).length > 0) {
+        const [updatedRow] = await tx.update(gameTimebackAssessmentTests).set({ ...updates, updatedAt: new Date }).where(eq(gameTimebackAssessmentTests.id, row.id)).returning();
+        updated = updatedRow ?? row;
+      }
+      setAttribute("app.assessment.operation", input.title !== undefined ? "update_test" : "update_association");
+      return updated;
     });
-    return item;
   }
-  async updateQuestion(integrationId, qtiTestIdentifier, itemIdentifier, input) {
-    const client = this.requireClient();
-    await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
-    return client.qtiApi.assessmentItems.update(itemIdentifier, input);
-  }
-  async deleteQuestion(integrationId, qtiTestIdentifier, itemIdentifier) {
-    const client = this.requireClient();
-    await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
-    await this.qtiSectionItems(client, qtiTestIdentifier).remove(itemIdentifier);
-    await client.qtiApi.assessmentItems.delete(itemIdentifier);
+  async removeAssessment(integrationId, qtiTestIdentifier) {
+    return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx) => {
+      const plan = planAssessmentRemoval(row.status);
+      if (plan.kind === "delete") {
+        await tx.delete(gameTimebackAssessmentTests).where(eq(gameTimebackAssessmentTests.id, row.id));
+      } else if (plan.kind === "archive") {
+        await tx.update(gameTimebackAssessmentTests).set({ status: "archived", sortOrder: null, updatedAt: new Date }).where(eq(gameTimebackAssessmentTests.id, row.id));
+      }
+      if (plan.kind !== "none") {
+        setAttribute("app.assessment.operation", plan.operation);
+      }
+      return { action: plan.action };
+    });
   }
-  async reorderQuestions(integrationId, qtiTestIdentifier, items) {
-    const client = this.requireClient();
-    await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
-    const qtiBaseUrl = client.getQtiBaseUrl();
-    return this.qtiSectionItems(client, qtiTestIdentifier).reorder({
-      items: items.map((item) => ({
-        identifier: item.identifier,
-        href: item.href ?? `${qtiBaseUrl}/assessment-items/${item.identifier}`,
-        sequence: item.sequence
-      }))
+  async reorderAssessments(integrationId, purpose, testIdentifiers) {
+    await this.requireIntegration(integrationId);
+    validateUniqueAssessmentIdentifiers(testIdentifiers);
+    const updatedAt = new Date;
+    await this.deps.db.transaction(async (tx) => {
+      const liveRows = await tx.query.gameTimebackAssessmentTests.findMany({
+        where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.purpose, purpose), eq(gameTimebackAssessmentTests.status, "live"))
+      });
+      const orderedRows = orderLiveAssessmentRows(liveRows, purpose, testIdentifiers);
+      const positionByRowId = new Map(orderedRows.map((row, index2) => [row.id, index2 + 1]));
+      for (const row of lockOrderAssessmentRows(orderedRows)) {
+        const testIdentifier = row.qtiTestIdentifier;
+        const [updatedRow] = await tx.update(gameTimebackAssessmentTests).set({ sortOrder: positionByRowId.get(row.id), updatedAt }).where(and(eq(gameTimebackAssessmentTests.id, row.id), eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, testIdentifier), eq(gameTimebackAssessmentTests.purpose, purpose), eq(gameTimebackAssessmentTests.status, "live"))).returning({ id: gameTimebackAssessmentTests.id });
+        assertAssessmentOrderUpdateSucceeded(updatedRow);
+      }
     });
+    setAttribute("app.assessment.operation", "reorder_live_assessments");
   }
-  async activateAssessment(integrationId, qtiTestIdentifier) {
+  async listQuestions(integrationId, qtiTestIdentifier) {
     const client = this.requireClient();
-    const integration = await this.requireIntegration(integrationId);
-    const row = await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
-    if (row.bankActive) {
-      throw new ValidationError("Assessment is already active");
-    }
-    const bankIds = deriveAssessmentBankIds2(integration.courseId);
-    const qtiTestUrl = `${client.getQtiBaseUrl()}/assessment-tests/${qtiTestIdentifier}`;
-    await client.course.ensureAssessmentBank({
-      courseId: integration.courseId,
-      subject: integration.subject,
-      grade: integration.grade
-    });
-    const parentResource = await client.api.oneroster.resources.get(bankIds.resource);
-    const currentResources = parentResource.metadata?.resources ?? [];
-    let childResourceId = row.bankResourceId;
-    if (childResourceId) {
+    await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
+    const { gameSlug } = await this.requireQtiTestOwnershipContext(integrationId);
+    const result = await client.qtiApi.assessmentTests.getQuestions(qtiTestIdentifier);
+    const ownerTests = new Map;
+    const questions = await runWithConcurrency(result.questions, TimebackAssessmentsService.QTI_HYDRATION_CONCURRENCY, async (reference) => {
+      let item;
       try {
-        await client.api.oneroster.resources.update(childResourceId, {
-          status: "active",
-          title: `Assessment Bank Test: ${qtiTestIdentifier}`,
-          vendorResourceId: "",
-          metadata: {
-            type: "qti",
-            subType: "qti-test",
-            url: qtiTestUrl
-          }
-        });
-        if (!currentResources.includes(childResourceId)) {
-          await client.api.oneroster.resources.update(bankIds.resource, {
-            status: "active",
-            title: parentResource.title,
-            vendorResourceId: parentResource.vendorResourceId,
-            vendorId: parentResource.vendorId,
-            metadata: {
-              ...parentResource.metadata,
-              resources: [...currentResources, childResourceId]
-            }
-          });
-        }
+        item = await client.qtiApi.assessmentItems.get(reference.reference.identifier);
       } catch (error88) {
-        addEvent("assessment.child_resource_reactivation_failed", {
-          "app.assessment.child_resource_id": childResourceId ?? "",
+        addEvent("assessment.qti_question_hydration_failed", {
+          "app.assessment.qti_test_identifier": qtiTestIdentifier,
+          "app.assessment.qti_item_identifier": reference.reference.identifier,
           "exception.type": errorType(error88),
           "app.error.message": errorMessage(error88)
         });
-        childResourceId = null;
+        return reference;
       }
-    }
-    if (!childResourceId) {
-      for (const resourceId of currentResources) {
-        try {
-          const resource = await client.api.oneroster.resources.get(resourceId);
-          const resourceUrl = resource.metadata?.url;
-          if (resourceUrl === qtiTestUrl) {
-            childResourceId = resourceId;
-            addEvent("assessment.child_resource_reused", {
-              "app.assessment.qti_test_identifier": qtiTestIdentifier,
-              "app.assessment.child_resource_id": resourceId
-            });
-            break;
-          }
-        } catch {}
-      }
-      if (!childResourceId) {
-        const childResult = await client.api.oneroster.resources.create({
-          status: "active",
-          title: `Assessment Bank Test: ${qtiTestIdentifier}`,
-          vendorResourceId: "",
-          vendorId: undefined,
-          metadata: {
-            type: "qti",
-            subType: "qti-test",
-            url: qtiTestUrl
-          }
-        });
-        childResourceId = childResult.sourcedIdPairs.allocatedSourcedId;
-        await client.api.oneroster.resources.update(bankIds.resource, {
-          status: "active",
-          title: parentResource.title,
-          vendorResourceId: parentResource.vendorResourceId,
-          vendorId: parentResource.vendorId,
-          metadata: {
-            ...parentResource.metadata,
-            resources: [...currentResources, childResourceId]
-          }
+      let ownerTest;
+      try {
+        ownerTest = await this.qtiQuestionOwnerTest(client, item, ownerTests);
+      } catch (error88) {
+        addEvent("assessment.qti_question_owner_test_fetch_failed", {
+          "app.assessment.qti_test_identifier": qtiTestIdentifier,
+          "app.assessment.qti_item_identifier": reference.reference.identifier,
+          "exception.type": errorType(error88),
+          "app.error.message": errorMessage(error88)
         });
       }
-    }
-    await this.deps.db.update(gameTimebackAssessmentTests).set({ bankResourceId: childResourceId, bankActive: true }).where(eq(gameTimebackAssessmentTests.id, row.id));
-    setAttributes({
-      "app.assessment.operation": "activate",
-      "app.assessment.child_resource_id": childResourceId ?? ""
+      return buildHydratedQtiQuestionReference({
+        reference,
+        item,
+        gameSlug,
+        ownerTest,
+        testIdentifier: qtiTestIdentifier
+      });
     });
+    return { ...result, questions };
   }
-  async deactivateAssessment(integrationId, qtiTestIdentifier) {
+  async listQuestionLibrary(integrationId, params) {
     const client = this.requireClient();
-    const integration = await this.requireIntegration(integrationId);
-    const row = await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
-    if (!row.bankActive) {
-      throw new ValidationError("Assessment is already in draft");
-    }
-    if (!row.bankResourceId) {
-      throw new ValidationError("Assessment has no bank resource — activate it first");
-    }
-    const childResourceId = row.bankResourceId;
-    const bankIds = deriveAssessmentBankIds2(integration.courseId);
-    try {
-      const parentResource = await client.api.oneroster.resources.get(bankIds.resource);
-      const currentResources = parentResource.metadata?.resources ?? [];
-      const filtered = currentResources.filter((id) => id !== childResourceId);
-      if (filtered.length !== currentResources.length) {
-        await client.api.oneroster.resources.update(bankIds.resource, {
-          status: "active",
-          title: parentResource.title,
-          vendorResourceId: parentResource.vendorResourceId,
-          vendorId: parentResource.vendorId,
-          metadata: {
-            ...parentResource.metadata,
-            resources: filtered
-          }
-        });
-      }
-    } catch (error88) {
-      addEvent("assessment.parent_resource_update_failed", {
-        "app.assessment.bank_resource_id": bankIds.resource,
-        "exception.type": errorType(error88),
-        "app.error.message": errorMessage(error88)
-      });
-    }
-    try {
-      await client.api.oneroster.resources.delete(childResourceId);
-    } catch (error88) {
-      addEvent("assessment.child_resource_delete_failed", {
-        "app.assessment.child_resource_id": childResourceId,
-        "exception.type": errorType(error88),
-        "app.error.message": errorMessage(error88)
-      });
-    }
-    await this.deps.db.update(gameTimebackAssessmentTests).set({ bankActive: false }).where(eq(gameTimebackAssessmentTests.id, row.id));
-    setAttribute("app.assessment.operation", "deactivate");
-  }
-  isAssessmentActive(row) {
-    return row.bankActive;
+    await this.requireIntegration(integrationId);
+    return this.listQtiLibrary(params, async (listParams) => await client.qtiApi.assessmentItems.list(listParams));
   }
-  async getBankStatus(integrationId) {
-    const integration = await this.requireIntegration(integrationId);
-    const bankIds = deriveAssessmentBankIds2(integration.courseId);
-    const rows = await this.deps.db.query.gameTimebackAssessmentTests.findMany({
-      where: eq(gameTimebackAssessmentTests.integrationId, integrationId)
-    });
-    const activeCount = rows.filter((r) => r.bankActive).length;
-    return {
-      bankIds,
-      totalAssessments: rows.length,
-      activeAssessments: activeCount,
-      draftAssessments: rows.length - activeCount
-    };
+  async listTestLibrary(integrationId, params) {
+    const client = this.requireClient();
+    await this.requireIntegration(integrationId);
+    return this.listQtiLibrary(params, async (listParams) => await client.qtiApi.assessmentTests.list(listParams));
   }
-  async destroyBank(integrationId) {
+  async copyAssessment(integrationId, sourceTestIdentifier, targetTestIdentifier, purpose) {
     const client = this.requireClient();
-    const integration = await this.requireIntegration(integrationId);
-    const bankIds = deriveAssessmentBankIds2(integration.courseId);
-    const activeRows = await this.deps.db.query.gameTimebackAssessmentTests.findMany({
-      where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId))
+    const ownership = await this.requireQtiTestOwnershipContext(integrationId);
+    const { integration } = ownership;
+    const source = await client.qtiApi.assessmentTests.get(sourceTestIdentifier);
+    const itemPlan = buildQtiAssessmentItemCopyPlan(source, targetTestIdentifier, (identifier) => this.qtiItemHref(client, identifier));
+    const itemCopies = await runWithConcurrency(itemPlan, TimebackAssessmentsService.QTI_HYDRATION_CONCURRENCY, async (plan) => {
+      const sourceItem = await client.qtiApi.assessmentItems.get(plan.sourceIdentifier);
+      return {
+        plan,
+        input: buildQtiQuestionCopyInput({
+          source: sourceItem,
+          targetIdentifier: plan.targetIdentifier,
+          targetTestIdentifier,
+          gameSlug: ownership.gameSlug,
+          integrationId
+        })
+      };
     });
+    const testInput = buildQtiTestCopyInput(source, targetTestIdentifier, {
+      ...source.metadata,
+      ownerSystem: PLAYCADEMY_QTI_OWNER_SYSTEM,
+      ownerGameSlug: ownership.gameSlug,
+      integrationId,
+      subject: integration.subject,
+      grade: String(integration.grade),
+      copiedFromTestIdentifier: sourceTestIdentifier
+    }, itemPlan);
+    const attemptedItemIdentifiers = [];
+    let testCreationAttempted = false;
+    let associationCreationAttempted = false;
     try {
-      await client.api.oneroster.courses.deleteComponentResource(bankIds.componentResource);
+      for (const copy of itemCopies) {
+        attemptedItemIdentifiers.push(copy.plan.targetIdentifier);
+        await client.course.createAssessmentItemXml({
+          xml: copy.input.xml,
+          metadata: copy.input.metadata
+        });
+      }
+      testCreationAttempted = true;
+      await client.qtiApi.assessmentTests.create(testInput);
+      associationCreationAttempted = true;
+      const [row] = await this.deps.db.insert(gameTimebackAssessmentTests).values({
+        integrationId,
+        qtiTestIdentifier: targetTestIdentifier,
+        purpose,
+        status: "draft"
+      }).returning();
+      setAttribute("app.assessment.operation", "copy_test");
+      return row;
     } catch (error88) {
-      addEvent("assessment.component_resource_delete_failed", {
-        "app.assessment.component_resource_id": bankIds.componentResource,
-        "exception.type": errorType(error88),
-        "app.error.message": errorMessage(error88)
-      });
-    }
-    for (const row of activeRows) {
-      if (row.bankResourceId) {
+      if (associationCreationAttempted) {
+        let committedRow;
         try {
-          await client.api.oneroster.resources.delete(row.bankResourceId);
-        } catch (error88) {
-          addEvent("assessment.child_resource_delete_failed", {
-            "app.assessment.child_resource_id": row.bankResourceId,
-            "exception.type": errorType(error88),
-            "app.error.message": errorMessage(error88)
+          committedRow = await this.deps.db.query.gameTimebackAssessmentTests.findFirst({
+            where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, targetTestIdentifier))
           });
+        } catch (verificationError) {
+          addEvent("assessment.qti_test_copy_commit_verification_failed", {
+            "app.assessment.qti_test_identifier": targetTestIdentifier,
+            "exception.type": errorType(verificationError),
+            "app.error.message": errorMessage(verificationError)
+          });
+          throw error88;
+        }
+        if (committedRow) {
+          setAttribute("app.assessment.operation", "copy_test");
+          return committedRow;
         }
       }
+      await this.cleanupQtiAssessmentCopy(client, testCreationAttempted ? targetTestIdentifier : undefined, attemptedItemIdentifiers);
+      throw error88;
     }
-    try {
-      await client.api.oneroster.resources.delete(bankIds.resource);
-    } catch (error88) {
-      addEvent("assessment.parent_resource_delete_failed", {
-        "app.assessment.bank_resource_id": bankIds.resource,
-        "exception.type": errorType(error88),
-        "app.error.message": errorMessage(error88)
+  }
+  async createQuestion(integrationId, qtiTestIdentifier, input) {
+    return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx, associations) => {
+      const client = this.requireClient();
+      assertAllAssessmentAssociationsDraft(associations);
+      const ownership = await this.requireOwnedDraftAssessment(integrationId, qtiTestIdentifier, row, tx);
+      const creation = parseQtiQuestionCreationInput(input);
+      const itemIdentifier = newPlaycademyQuestionIdentifier(qtiTestIdentifier);
+      let title;
+      let metadata2;
+      let xml;
+      let structuredInput;
+      let fallbackItem;
+      if (creation.kind === "copy") {
+        const source = await client.qtiApi.assessmentItems.get(creation.sourceItemIdentifier);
+        const copy = buildQtiQuestionCopyInput({
+          source,
+          targetIdentifier: itemIdentifier,
+          targetTestIdentifier: qtiTestIdentifier,
+          gameSlug: ownership.gameSlug,
+          integrationId
+        });
+        title = copy.title;
+        metadata2 = copy.metadata;
+        xml = copy.xml;
+        fallbackItem = {
+          ...source,
+          identifier: itemIdentifier,
+          title,
+          rawXml: xml,
+          metadata: metadata2
+        };
+      } else {
+        structuredInput = creation.input;
+        assertSupportedQtiQuestionInteraction(structuredInput);
+        title = typeof structuredInput.title === "string" ? structuredInput.title.trim() : "";
+        metadata2 = buildOwnedQtiQuestionMetadata(structuredInput, {
+          gameSlug: ownership.gameSlug,
+          testIdentifier: qtiTestIdentifier
+        });
+        xml = buildQuestionXml(structuredInput, itemIdentifier, title);
+        fallbackItem = {
+          ...structuredInput,
+          identifier: itemIdentifier,
+          title,
+          ...xml ? { rawXml: xml } : {}
+        };
+      }
+      const section = await this.qtiSectionItems(client, qtiTestIdentifier, undefined, undefined, ownership.test);
+      const href = this.qtiItemHref(client, itemIdentifier);
+      let item;
+      let itemCreationAttempted = false;
+      let referenceCreationAttempted = false;
+      try {
+        itemCreationAttempted = true;
+        item = xml ? await client.course.createAssessmentItemXml({ xml, metadata: metadata2 }) : await client.qtiApi.assessmentItems.create({
+          ...structuredInput,
+          identifier: itemIdentifier,
+          metadata: metadata2
+        });
+        referenceCreationAttempted = true;
+        await section.items.add({
+          identifier: itemIdentifier,
+          href
+        });
+      } catch (error88) {
+        let referenceRemoved = !referenceCreationAttempted;
+        const creationStatus = isApiError(error88) ? error88.statusCode : undefined;
+        const itemCreationDefinitelyRejected = !referenceCreationAttempted && typeof creationStatus === "number" && creationStatus >= 400 && creationStatus < 500 && creationStatus !== 408;
+        if (referenceCreationAttempted) {
+          try {
+            await section.items.remove(itemIdentifier);
+            referenceRemoved = true;
+          } catch (cleanupError) {
+            referenceRemoved = isApiError(cleanupError) && cleanupError.statusCode === 404;
+            addEvent("assessment.qti_question_reference_cleanup_failed", {
+              "app.assessment.qti_test_identifier": qtiTestIdentifier,
+              "app.assessment.qti_item_identifier": itemIdentifier,
+              "exception.type": errorType(cleanupError),
+              "app.error.message": errorMessage(cleanupError)
+            });
+          }
+        }
+        if (itemCreationAttempted && !itemCreationDefinitelyRejected && referenceRemoved) {
+          try {
+            await client.qtiApi.assessmentItems.delete(itemIdentifier);
+          } catch (cleanupError) {
+            addEvent("assessment.qti_question_cleanup_failed", {
+              "app.assessment.qti_test_identifier": qtiTestIdentifier,
+              "app.assessment.qti_item_identifier": itemIdentifier,
+              "exception.type": errorType(cleanupError),
+              "app.error.message": errorMessage(cleanupError)
+            });
+          }
+        }
+        throw error88;
+      }
+      setAttribute("app.assessment.operation", creation.kind === "copy" ? "copy_question" : "create_question");
+      return buildCreatedQtiQuestionReference({
+        item,
+        fallbackItem,
+        itemIdentifier,
+        href,
+        partIdentifier: section.partIdentifier,
+        sectionIdentifier: section.sectionIdentifier,
+        metadata: metadata2
       });
-    }
-    try {
-      await client.api.oneroster.courses.deleteComponent(bankIds.component);
-    } catch (error88) {
-      addEvent("assessment.course_component_delete_failed", {
-        "app.assessment.component_id": bankIds.component,
-        "exception.type": errorType(error88),
-        "app.error.message": errorMessage(error88)
+    });
+  }
+  async updateQuestion(integrationId, qtiTestIdentifier, itemIdentifier, input) {
+    return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx, associations) => {
+      const client = this.requireClient();
+      assertAllAssessmentAssociationsDraft(associations);
+      const ownership = await this.requireOwnedDraftAssessment(integrationId, qtiTestIdentifier, row, tx);
+      const [, item] = await Promise.all([
+        this.qtiSectionItems(client, qtiTestIdentifier, itemIdentifier, undefined, ownership.test),
+        client.qtiApi.assessmentItems.get(itemIdentifier)
+      ]);
+      const ownerTest = await this.qtiQuestionOwnerTest(client, item, undefined, ownership.test);
+      const replacesInteraction = "type" in input || "interaction" in input || "numericTextEntry" in input;
+      assertQtiQuestionEditable(item, { gameSlug: ownership.gameSlug, testIdentifier: qtiTestIdentifier }, ownerTest);
+      assertSupportedQtiQuestionInteraction(replacesInteraction ? input : item);
+      let title = typeof input.title === "string" ? input.title.trim() : "";
+      if (!title) {
+        title = item.title;
+      }
+      const metadata2 = buildOwnedQtiQuestionMetadata(input, { gameSlug: ownership.gameSlug, testIdentifier: qtiTestIdentifier }, item.metadata);
+      const xml = buildQuestionXml(input, itemIdentifier, title);
+      const updated = xml ? await client.course.updateAssessmentItemXml(itemIdentifier, { xml, metadata: metadata2 }) : await client.qtiApi.assessmentItems.update(itemIdentifier, {
+        ...input,
+        title,
+        metadata: metadata2
+      });
+      setAttribute("app.assessment.operation", "update_question");
+      return updated;
+    });
+  }
+  async removeQuestion(integrationId, qtiTestIdentifier, itemIdentifier) {
+    return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx, associations) => {
+      const client = this.requireClient();
+      assertAllAssessmentAssociationsDraft(associations);
+      const ownership = await this.requireOwnedDraftAssessment(integrationId, qtiTestIdentifier, row, tx);
+      const section = await this.qtiSectionItems(client, qtiTestIdentifier, itemIdentifier, undefined, ownership.test);
+      await section.items.remove(itemIdentifier);
+      setAttribute("app.assessment.operation", "remove_question");
+    });
+  }
+  async reorderQuestions(integrationId, qtiTestIdentifier, items) {
+    return this.withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, async (row, tx, associations) => {
+      const client = this.requireClient();
+      assertAllAssessmentAssociationsDraft(associations);
+      const ownership = await this.requireOwnedDraftAssessment(integrationId, qtiTestIdentifier, row, tx);
+      const identifiers = items.map((item) => item.identifier);
+      validateUniqueQuestionIdentifiers(identifiers);
+      const firstIdentifier = identifiers[0];
+      const section = await this.qtiSectionItems(client, qtiTestIdentifier, firstIdentifier, identifiers, ownership.test);
+      const result = await section.items.reorder({
+        items: items.map((item) => ({
+          identifier: item.identifier,
+          href: item.href ?? this.qtiItemHref(client, item.identifier),
+          sequence: item.sequence
+        }))
       });
-    }
-    await this.deps.db.update(gameTimebackAssessmentTests).set({ bankResourceId: null, bankActive: false }).where(eq(gameTimebackAssessmentTests.integrationId, integrationId));
-    setAttribute("app.assessment.operation", "destroy_bank");
+      setAttribute("app.assessment.operation", "reorder_questions");
+      return result;
+    });
   }
   requireClient() {
     if (!this.deps.timeback) {
@@ -83346,8 +84306,18 @@ class TimebackAssessmentsService {
     }
     return this.deps.timeback;
   }
-  async requireIntegration(integrationId) {
-    const integration = await this.deps.db.query.gameTimebackIntegrations.findFirst({
+  async withLockedAssessmentAssociations(integrationId, qtiTestIdentifier, action) {
+    return this.deps.db.transaction(async (tx) => {
+      const rows = await tx.select().from(gameTimebackAssessmentTests).where(eq(gameTimebackAssessmentTests.qtiTestIdentifier, qtiTestIdentifier)).orderBy(gameTimebackAssessmentTests.id).for("update");
+      const row = rows.find((candidate) => candidate.integrationId === integrationId);
+      if (!row) {
+        throw new NotFoundError(`Assessment not found: ${qtiTestIdentifier}`);
+      }
+      return action(row, tx, rows);
+    });
+  }
+  async requireIntegration(integrationId, db2 = this.deps.db) {
+    const integration = await db2.query.gameTimebackIntegrations.findFirst({
       where: and(eq(gameTimebackIntegrations.id, integrationId), isActiveGameTimebackIntegrationStatus())
     });
     if (!integration) {
@@ -83355,6 +84325,17 @@ class TimebackAssessmentsService {
     }
     return integration;
   }
+  async requireQtiTestOwnershipContext(integrationId, db2 = this.deps.db) {
+    const integration = await this.requireIntegration(integrationId, db2);
+    const game2 = await db2.query.games.findFirst({
+      where: eq(games.id, integration.gameId),
+      columns: { slug: true }
+    });
+    if (!game2) {
+      throw new NotFoundError(`Game not found for integration: ${integrationId}`);
+    }
+    return { integration, gameSlug: game2.slug };
+  }
   async requireAssessmentRow(integrationId, qtiTestIdentifier) {
     const row = await this.deps.db.query.gameTimebackAssessmentTests.findFirst({
       where: and(eq(gameTimebackAssessmentTests.integrationId, integrationId), eq(gameTimebackAssessmentTests.qtiTestIdentifier, qtiTestIdentifier))
@@ -83364,27 +84345,125 @@ class TimebackAssessmentsService {
     }
     return row;
   }
-  qtiSectionItems(client, qtiTestIdentifier) {
-    return client.qtiApi.assessmentTests.testParts(qtiTestIdentifier).sections(`${qtiTestIdentifier}-part1`).items(`${qtiTestIdentifier}-section1`);
+  async requireDraftAssessmentRow(integrationId, qtiTestIdentifier, lockedRow) {
+    const row = lockedRow ?? await this.requireAssessmentRow(integrationId, qtiTestIdentifier);
+    assertDraftAssessment(row);
+    return row;
   }
-  async getMaxSortOrder(integrationId) {
-    const rows = await this.deps.db.query.gameTimebackAssessmentTests.findMany({
-      where: eq(gameTimebackAssessmentTests.integrationId, integrationId),
-      columns: { sortOrder: true }
+  async requireOwnedDraftAssessment(integrationId, qtiTestIdentifier, lockedRow, db2 = this.deps.db) {
+    const client = this.requireClient();
+    await this.requireDraftAssessmentRow(integrationId, qtiTestIdentifier, lockedRow);
+    const test = await client.qtiApi.assessmentTests.get(qtiTestIdentifier);
+    const ownership = await this.requireQtiTestOwnershipContext(integrationId, db2);
+    assertQtiTestOwnedByGame(test, ownership.gameSlug);
+    return { ...ownership, test };
+  }
+  async qtiQuestionOwnerTest(client, item, cache, knownTest) {
+    if (item.metadata && "ownerGameSlug" in item.metadata) {
+      return;
+    }
+    const ownerTestIdentifier = qtiQuestionOwnerTestIdentifier(item);
+    if (!ownerTestIdentifier) {
+      return;
+    }
+    if (knownTest?.identifier === ownerTestIdentifier) {
+      return knownTest;
+    }
+    function loadOwnerTest(identifier) {
+      return client.qtiApi.assessmentTests.get(identifier);
+    }
+    if (!cache) {
+      return loadOwnerTest(ownerTestIdentifier);
+    }
+    let ownerTest = cache.get(ownerTestIdentifier);
+    if (!ownerTest) {
+      ownerTest = loadOwnerTest(ownerTestIdentifier);
+      cache.set(ownerTestIdentifier, ownerTest);
+    }
+    return ownerTest;
+  }
+  async assertQtiTestQuestionsSupported(client, qtiTestIdentifier, questions) {
+    const result = questions ?? await client.qtiApi.assessmentTests.getQuestions(qtiTestIdentifier);
+    await runWithConcurrency(result.questions, TimebackAssessmentsService.QTI_HYDRATION_CONCURRENCY, async (reference) => {
+      const item = await client.qtiApi.assessmentItems.get(reference.reference.identifier);
+      assertSupportedQtiQuestionInteraction(item);
     });
-    if (rows.length === 0) {
-      return -1;
+  }
+  async qtiSectionItems(client, qtiTestIdentifier, itemIdentifier, expectedItemIdentifiers, knownTest) {
+    const test = knownTest ?? await client.qtiApi.assessmentTests.get(qtiTestIdentifier);
+    const section = resolveQtiQuestionSection(test, qtiTestIdentifier, itemIdentifier, expectedItemIdentifiers);
+    return {
+      ...section,
+      items: client.qtiApi.assessmentTests.testParts(qtiTestIdentifier).sections(section.partIdentifier).items(section.sectionIdentifier)
+    };
+  }
+  qtiItemHref(client, itemIdentifier) {
+    return `${client.getQtiBaseUrl()}/assessment-items/${itemIdentifier}`;
+  }
+  async cleanupQtiAssessmentCopy(client, testIdentifier, itemIdentifiers) {
+    let testDeleted = !testIdentifier;
+    if (testIdentifier) {
+      try {
+        await client.qtiApi.assessmentTests.delete(testIdentifier);
+        testDeleted = true;
+      } catch (error88) {
+        testDeleted = isApiError(error88) && error88.statusCode === 404;
+        addEvent("assessment.qti_test_copy_cleanup_failed", {
+          "app.assessment.qti_test_identifier": testIdentifier,
+          "exception.type": errorType(error88),
+          "app.error.message": errorMessage(error88)
+        });
+      }
+    }
+    if (!testDeleted) {
+      return;
     }
-    return Math.max(...rows.map((r) => r.sortOrder));
+    for (const itemIdentifier of itemIdentifiers.toReversed()) {
+      try {
+        await client.qtiApi.assessmentItems.delete(itemIdentifier);
+      } catch (error88) {
+        addEvent("assessment.qti_question_cleanup_failed", {
+          ...testIdentifier ? { "app.assessment.qti_test_identifier": testIdentifier } : {},
+          "app.assessment.qti_item_identifier": itemIdentifier,
+          "exception.type": errorType(error88),
+          "app.error.message": errorMessage(error88)
+        });
+      }
+    }
+  }
+  associationSummary(row) {
+    return {
+      id: row.id,
+      integrationId: row.integrationId,
+      qtiTestIdentifier: row.qtiTestIdentifier,
+      purpose: row.purpose,
+      status: row.status,
+      sortOrder: row.sortOrder,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  async listQtiLibrary(params, list) {
+    const plan = buildQtiLibraryListPlan(params);
+    return list(plan.params);
+  }
+  async validateAssessmentHasQuestions(qtiTestIdentifier) {
+    const client = this.requireClient();
+    const result = await client.qtiApi.assessmentTests.getQuestions(qtiTestIdentifier);
+    assertAssessmentHasQuestions(result.questions);
+    await this.assertQtiTestQuestionsSupported(client, qtiTestIdentifier, result);
   }
 }
-var init_timeback_assessments_service = __esm(() => {
+var init_timeback_assessments_service = __esm(async () => {
   init_drizzle_orm();
   init_helpers_index();
   init_tables_index();
   init_spans();
-  init_utils6();
+  init_timeback3();
   init_errors();
+  init_timeback_assessment_rules_util();
+  init_timeback_qti_authoring_util();
+  await init_errors8();
 });
 
 // ../api-core/src/utils/timeback-create-integration.util.ts
@@ -85477,10 +86556,10 @@ var init_platform2 = __esm(async () => {
   init_kv_service();
   init_secrets_service();
   init_seed_service();
-  init_timeback_assessments_service();
   init_upload_service();
   await __promiseAll([
     init_timeback_admin_service(),
+    init_timeback_assessments_service(),
     init_timeback_service()
   ]);
 });
@@ -142099,16 +143178,6 @@ function requireAnonymous(handler) {
     return handler(ctx);
   };
 }
-function requireAdmin(handler) {
-  return async (ctx) => {
-    assertAuthenticatedRequest(ctx);
-    rejectDashboardWorkerKey(ctx);
-    if (ctx.user.role !== "admin") {
-      throw ApiError.forbidden("Admin access required");
-    }
-    return handler(ctx);
-  };
-}
 function requireDeveloper(handler) {
   return async (ctx) => {
     assertAuthenticatedRequest(ctx);
@@ -143272,7 +144341,27 @@ var init_session_controller = __esm(() => {
 });
 
 // ../api-core/src/controllers/timeback.controller.ts
-var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, deleteAssessment, reorderAssessments, reorderQuestions, activateAssessment, deactivateAssessment, listQuestions, createQuestion, updateQuestion, deleteQuestion, getAssessmentBankStatus, destroyAssessmentBank, timeback2;
+function parseQtiLibraryParams(searchParams) {
+  const requestedPage = Number(searchParams.get("page"));
+  const requestedLimit = Number(searchParams.get("limit"));
+  const page = Number.isInteger(requestedPage) && requestedPage > 0 ? requestedPage : 1;
+  const limit = Number.isInteger(requestedLimit) && requestedLimit > 0 ? Math.min(requestedLimit, 50) : 20;
+  const query = searchParams.get("q")?.trim() || undefined;
+  const requestedSource = searchParams.get("source");
+  if (requestedSource && requestedSource !== "playcademy") {
+    throw ApiError.badRequest("Unsupported QTI library source");
+  }
+  if (requestedSource !== "playcademy" && !query) {
+    throw ApiError.badRequest("An exact QTI source identifier is required for a global lookup");
+  }
+  return {
+    query,
+    source: requestedSource === "playcademy" ? "playcademy" : undefined,
+    page,
+    limit
+  };
+}
+var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, updateAssessment, reorderAssessments, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
   init_schemas_index();
@@ -143787,7 +144876,7 @@ var init_timeback_controller = __esm(() => {
     const body2 = await parseRequestBody(ctx.request, ReactivateEnrollmentRequestSchema);
     return ctx.services.timebackAdmin.reactivateEnrollment(body2, ctx.user);
   });
-  listAssessments = requireGameManagementAccess(async (ctx) => {
+  listAssessments = requireDeveloper(async (ctx) => {
     const { gameId, courseId } = ctx.params;
     if (!gameId || !courseId) {
       throw ApiError.badRequest("Missing gameId or courseId parameter");
@@ -143795,40 +144884,40 @@ var init_timeback_controller = __esm(() => {
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
     return ctx.services.timebackAssessments.listAssessments(integrationId);
   });
-  createAssessment = requireGameManagementAccess(async (ctx) => {
+  createAssessment = requireDeveloper(async (ctx) => {
     const { gameId, courseId } = ctx.params;
     if (!gameId || !courseId) {
       throw ApiError.badRequest("Missing gameId or courseId parameter");
     }
     const body2 = await parseRequestBody(ctx.request, CreateAssessmentRequestSchema);
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
-    const shortId = crypto.randomUUID().slice(0, 8);
-    const qtiTestIdentifier = `assessment-${shortId}`;
+    const qtiTestIdentifier = newPlaycademyTestIdentifier();
     return ctx.services.timebackAssessments.createAssessment(integrationId, {
       title: body2.title,
+      purpose: body2.purpose,
       qtiTestIdentifier
     });
   });
-  deleteAssessment = requireAdmin(async (ctx) => {
+  updateAssessment = requireDeveloper(async (ctx) => {
     const { gameId, courseId, testIdentifier } = ctx.params;
     if (!gameId || !courseId || !testIdentifier) {
       throw ApiError.badRequest("Missing gameId, courseId, or testIdentifier parameter");
     }
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
-    await ctx.services.timebackAssessments.deleteAssessment(integrationId, testIdentifier);
-    return { success: true };
+    const body2 = await parseRequestBody(ctx.request, UpdateAssessmentRequestSchema);
+    return ctx.services.timebackAssessments.updateAssessment(integrationId, testIdentifier, body2);
   });
-  reorderAssessments = requireGameManagementAccess(async (ctx) => {
+  reorderAssessments = requireDeveloper(async (ctx) => {
     const { gameId, courseId } = ctx.params;
     if (!gameId || !courseId) {
       throw ApiError.badRequest("Missing gameId or courseId parameter");
     }
     const body2 = await parseRequestBody(ctx.request, ReorderAssessmentsRequestSchema);
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
-    await ctx.services.timebackAssessments.reorderAssessments(integrationId, body2.identifiers);
+    await ctx.services.timebackAssessments.reorderAssessments(integrationId, body2.purpose, body2.testIdentifiers);
     return { success: true };
   });
-  reorderQuestions = requireGameManagementAccess(async (ctx) => {
+  reorderQuestions = requireDeveloper(async (ctx) => {
     const { gameId, courseId, testIdentifier } = ctx.params;
     if (!gameId || !courseId || !testIdentifier) {
       throw ApiError.badRequest("Missing gameId, courseId, or testIdentifier parameter");
@@ -143838,33 +144927,51 @@ var init_timeback_controller = __esm(() => {
     await ctx.services.timebackAssessments.reorderQuestions(integrationId, testIdentifier, body2.items);
     return { success: true };
   });
-  activateAssessment = requireGameManagementAccess(async (ctx) => {
+  removeAssessment = requireDeveloper(async (ctx) => {
     const { gameId, courseId, testIdentifier } = ctx.params;
     if (!gameId || !courseId || !testIdentifier) {
       throw ApiError.badRequest("Missing gameId, courseId, or testIdentifier parameter");
     }
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
-    await ctx.services.timebackAssessments.activateAssessment(integrationId, testIdentifier);
-    return { success: true };
+    return ctx.services.timebackAssessments.removeAssessment(integrationId, testIdentifier);
   });
-  deactivateAssessment = requireGameManagementAccess(async (ctx) => {
+  listQuestions = requireDeveloper(async (ctx) => {
     const { gameId, courseId, testIdentifier } = ctx.params;
     if (!gameId || !courseId || !testIdentifier) {
       throw ApiError.badRequest("Missing gameId, courseId, or testIdentifier parameter");
     }
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
-    await ctx.services.timebackAssessments.deactivateAssessment(integrationId, testIdentifier);
-    return { success: true };
+    return ctx.services.timebackAssessments.listQuestions(integrationId, testIdentifier);
   });
-  listQuestions = requireGameManagementAccess(async (ctx) => {
-    const { gameId, courseId, testIdentifier } = ctx.params;
-    if (!gameId || !courseId || !testIdentifier) {
-      throw ApiError.badRequest("Missing gameId, courseId, or testIdentifier parameter");
+  listQuestionLibrary = requireDeveloper(async (ctx) => {
+    const { gameId, courseId } = ctx.params;
+    if (!gameId || !courseId) {
+      throw ApiError.badRequest("Missing gameId or courseId parameter");
     }
+    const params = parseQtiLibraryParams(ctx.url.searchParams);
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
-    return ctx.services.timebackAssessments.listQuestions(integrationId, testIdentifier);
+    return ctx.services.timebackAssessments.listQuestionLibrary(integrationId, params);
+  });
+  listTestLibrary = requireDeveloper(async (ctx) => {
+    const { gameId, courseId } = ctx.params;
+    if (!gameId || !courseId) {
+      throw ApiError.badRequest("Missing gameId or courseId parameter");
+    }
+    const params = parseQtiLibraryParams(ctx.url.searchParams);
+    const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
+    return ctx.services.timebackAssessments.listTestLibrary(integrationId, params);
   });
-  createQuestion = requireGameManagementAccess(async (ctx) => {
+  copyAssessment = requireDeveloper(async (ctx) => {
+    const { gameId, courseId } = ctx.params;
+    if (!gameId || !courseId) {
+      throw ApiError.badRequest("Missing gameId or courseId parameter");
+    }
+    const body2 = await parseRequestBody(ctx.request, CopyAssessmentRequestSchema);
+    const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
+    const targetTestIdentifier = newPlaycademyTestIdentifier();
+    return ctx.services.timebackAssessments.copyAssessment(integrationId, body2.testIdentifier, targetTestIdentifier, body2.purpose);
+  });
+  createQuestion = requireDeveloper(async (ctx) => {
     const { gameId, courseId, testIdentifier } = ctx.params;
     if (!gameId || !courseId || !testIdentifier) {
       throw ApiError.badRequest("Missing gameId, courseId, or testIdentifier parameter");
@@ -143873,7 +144980,7 @@ var init_timeback_controller = __esm(() => {
     const body2 = await ctx.request.json();
     return ctx.services.timebackAssessments.createQuestion(integrationId, testIdentifier, body2);
   });
-  updateQuestion = requireGameManagementAccess(async (ctx) => {
+  updateQuestion = requireDeveloper(async (ctx) => {
     const { gameId, courseId, testIdentifier, itemIdentifier } = ctx.params;
     if (!gameId || !courseId || !testIdentifier || !itemIdentifier) {
       throw ApiError.badRequest("Missing gameId, courseId, testIdentifier, or itemIdentifier parameter");
@@ -143882,30 +144989,13 @@ var init_timeback_controller = __esm(() => {
     const body2 = await ctx.request.json();
     return ctx.services.timebackAssessments.updateQuestion(integrationId, testIdentifier, itemIdentifier, body2);
   });
-  deleteQuestion = requireGameManagementAccess(async (ctx) => {
+  removeQuestion = requireDeveloper(async (ctx) => {
     const { gameId, courseId, testIdentifier, itemIdentifier } = ctx.params;
     if (!gameId || !courseId || !testIdentifier || !itemIdentifier) {
       throw ApiError.badRequest("Missing gameId, courseId, testIdentifier, or itemIdentifier parameter");
     }
     const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
-    await ctx.services.timebackAssessments.deleteQuestion(integrationId, testIdentifier, itemIdentifier);
-    return { success: true };
-  });
-  getAssessmentBankStatus = requireGameManagementAccess(async (ctx) => {
-    const { gameId, courseId } = ctx.params;
-    if (!gameId || !courseId) {
-      throw ApiError.badRequest("Missing gameId or courseId parameter");
-    }
-    const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
-    return ctx.services.timebackAssessments.getBankStatus(integrationId);
-  });
-  destroyAssessmentBank = requireAdmin(async (ctx) => {
-    const { gameId, courseId } = ctx.params;
-    if (!gameId || !courseId) {
-      throw ApiError.badRequest("Missing gameId or courseId parameter");
-    }
-    const integrationId = await ctx.services.timebackAssessments.resolveIntegrationId(gameId, courseId, ctx.user);
-    await ctx.services.timebackAssessments.destroyBank(integrationId);
+    await ctx.services.timebackAssessments.removeQuestion(integrationId, testIdentifier, itemIdentifier);
     return { success: true };
   });
   timeback2 = defineControllerNames("timeback", {
@@ -143950,17 +145040,17 @@ var init_timeback_controller = __esm(() => {
     reactivateEnrollment,
     listAssessments,
     createAssessment,
-    deleteAssessment,
+    updateAssessment,
     reorderAssessments,
+    removeAssessment,
     reorderQuestions,
-    activateAssessment,
-    deactivateAssessment,
     listQuestions,
+    listTestLibrary,
+    copyAssessment,
+    listQuestionLibrary,
     createQuestion,
     updateQuestion,
-    deleteQuestion,
-    getAssessmentBankStatus,
-    destroyAssessmentBank
+    removeQuestion
   });
 });