@playcademy/vite-plugin 1.1.3-beta.8 → 1.2.0

package/dist/index.js

@@ -24314,7 +24314,7 @@ import path2 from "node:path";
 // package.json
 var package_default = {
   name: "@playcademy/vite-plugin",
-  version: "1.1.3-beta.8",
+  version: "1.2.0",
   type: "module",
   exports: {
     ".": {
@@ -25846,7 +25846,7 @@ var package_default2;
 var init_package = __esm(() => {
   package_default2 = {
     name: "@playcademy/sandbox",
-    version: "0.6.1-beta.8",
+    version: "0.7.0",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -36036,7 +36036,6 @@ var users;
 var accounts;
 var sessions;
 var verification;
-var ssoProvider;
 var init_table3 = __esm(() => {
   init_pg_core();
   userRoleEnum = pgEnum("user_role", ["admin", "player", "developer", "teacher"]);
@@ -36129,16 +36128,6 @@ var init_table3 = __esm(() => {
       withTimezone: true
     }).notNull()
   });
-  ssoProvider = pgTable("sso_provider", {
-    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-    issuer: text("issuer").notNull(),
-    oidcConfig: text("oidc_config"),
-    samlConfig: text("saml_config"),
-    userId: text("user_id").references(() => users.id, { onDelete: "cascade" }),
-    providerId: text("provider_id").notNull().unique(),
-    organizationId: text("organization_id"),
-    domain: text("domain").notNull()
-  });
 });
 var apikey;
 var init_table4 = __esm(() => {
@@ -36392,6 +36381,8 @@ var init_table6 = __esm(() => {
   }));
 });
 var gameTimebackIntegrationStatusEnum;
+var gameTimebackAssessmentPurposeEnum;
+var gameTimebackAssessmentStatusEnum;
 var gameTimebackIntegrations;
 var gameTimebackAssessmentTests;
 var gameTimebackMetricDiscrepancyVerifications;
@@ -36405,6 +36396,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" }),
@@ -36425,10 +36425,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)
   ]);
@@ -36469,7 +36470,6 @@ __export(exports_tables_index, {
   verification: () => verification,
   users: () => users,
   userRoleEnum: () => userRoleEnum,
-  ssoProvider: () => ssoProvider,
   sessions: () => sessions,
   games: () => games,
   gameVisibilityEnum: () => gameVisibilityEnum,
@@ -36478,6 +36478,8 @@ __export(exports_tables_index, {
   gameTimebackIntegrations: () => gameTimebackIntegrations,
   gameTimebackIntegrationStatusEnum: () => gameTimebackIntegrationStatusEnum,
   gameTimebackAssessmentTests: () => gameTimebackAssessmentTests,
+  gameTimebackAssessmentStatusEnum: () => gameTimebackAssessmentStatusEnum,
+  gameTimebackAssessmentPurposeEnum: () => gameTimebackAssessmentPurposeEnum,
   gameTimebackActivityCompletions: () => gameTimebackActivityCompletions,
   gameScoresRelations: () => gameScoresRelations,
   gameScores: () => gameScores,
@@ -52987,7 +52989,7 @@ function evaluateBaselineGuardrails(input) {
   }
   return "ok";
 }
-function planMigrations(journal, ledger) {
+function planMigrations2(journal, ledger) {
   const ledgerByTag = new Map(ledger.map((row) => [row.tag, row]));
   const journalTags = new Set(journal.map((entry2) => entry2.tag));
   const pendingTags = [];
@@ -53566,7 +53568,7 @@ class DeployService {
     await this.assertNoSchemaDrift(databaseId, state);
     await cf.d1.ensureMigrationLedger(databaseId);
     const ledger = await cf.d1.readMigrationLedger(databaseId);
-    const plan = planMigrations(migrations.map((migration) => ({ tag: migration.tag, checksum: migration.checksum })), ledger.map((row) => ({
+    const plan = planMigrations2(migrations.map((migration) => ({ tag: migration.tag, checksum: migration.checksum })), ledger.map((row) => ({
       tag: row.tag,
       checksum: row.checksum,
       checksumAlgo: row.checksum_algo
@@ -53919,7 +53921,7 @@ class DeployService {
       }
       await cf.d1.ensureMigrationLedger(databaseId);
       const ledger = await cf.d1.readMigrationLedger(databaseId);
-      const plan = planMigrations(slice, ledger.map((row) => ({
+      const plan = planMigrations2(slice, ledger.map((row) => ({
         tag: row.tag,
         checksum: row.checksum,
         checksumAlgo: row.checksum_algo
@@ -54578,6 +54580,25 @@ function sleep(ms) {
   }
   return new Promise((resolve2) => setTimeout(resolve2, 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;
+}
 function isObject(value) {
   return typeof value === "object" && value !== null;
 }
@@ -56094,7 +56115,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,
@@ -56160,7 +56181,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);
@@ -56337,25 +56358,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;
 var DEFAULT_NAMESPACE_CONCURRENCY = 2;
@@ -58718,12 +58720,14 @@ var EnrollStudentRequestSchema;
 var UnenrollStudentRequestSchema;
 var ReactivateEnrollmentRequestSchema;
 var VerifyTimebackMetricDiscrepancyRequestSchema;
-var InsertAssessmentTestSchema;
+var AssessmentPurposeSchema;
+var AssessmentStatusSchema;
 var CreateAssessmentRequestSchema;
+var UpdateAssessmentRequestSchema;
+var CopyAssessmentRequestSchema;
 var ReorderAssessmentsRequestSchema;
 var 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];
@@ -58976,15 +58980,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({
@@ -80449,7 +80464,7 @@ var INITIAL_RETRY_DELAY_MS2 = 1000;
 var DEFAULT_LIMIT2 = 100;
 var DEFAULT_MAX_ITEMS2 = 1e4;
 var Paginator6;
-var init_chunk_m54fefpq = __esm(async () => {
+var init_chunk_pt7w63g2 = __esm(async () => {
   init_chunk_6jf1natv();
   ApiError3 = class ApiError32 extends Error {
     statusCode;
@@ -95770,8 +95785,7 @@ function resolveToProvider23(config4, registry3 = DEFAULT_PROVIDER_REGISTRY2) {
 function translateParams2(params) {
   const {
     orderBy,
-    filter: _2,
-    fields: __,
+    fields: _2,
     ...rest
   } = params;
   return {
@@ -95779,6 +95793,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;
@@ -95787,19 +95818,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 = {}) {
@@ -95922,20 +95942,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 path3 = `/assessment-tests/${encodeURIComponent(this.testId)}/test-parts/${encodeURIComponent(this.testPartId)}/sections`;
     return this.transport.request(path3, {
-      params: queryParams
+      params: buildListQueryParams(params)
     });
   }
   get(identifier) {
@@ -95982,19 +95991,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 path3 = `/assessment-tests/${encodeURIComponent(this.testId)}/test-parts`;
-    return this.transport.request(path3, { params: queryParams });
+    return this.transport.request(path3, {
+      params: buildListQueryParams(params)
+    });
   }
   get(identifier) {
     validateNonEmptyString2(identifier, "testPartId");
@@ -96037,19 +96037,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 = {}) {
@@ -96155,19 +96144,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 = {}) {
@@ -96540,7 +96518,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"],
@@ -103667,13 +103645,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");
@@ -104962,59 +104933,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`;
@@ -105049,18 +104983,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 {
@@ -105290,9 +105212,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) {
@@ -105796,13 +105718,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;
 var RESOURCE_DEFAULTS4;
 var init_utils6 = __esm(() => {
@@ -105836,6 +105751,96 @@ var init_utils6 = __esm(() => {
     componentResource: TIMEBACK_COMPONENT_RESOURCE_DEFAULTS
   };
 });
+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";
@@ -105879,6 +105884,14 @@ function parseTimebackDiscrepancyQueueMetrics(values) {
 }
 var TIMEBACK_DISCREPANCY_QUEUE_WINDOWS;
 var TIMEBACK_DISCREPANCY_QUEUE_METRICS;
+var PLAYCADEMY_QTI_OWNER_SYSTEM = "playcademy";
+var PLAYCADEMY_QTI_OWNER_TEST_IDENTIFIER_KEY = "ownerTestIdentifier";
+var PLAYCADEMY_QTI_EDITOR_MODE_KEY = "playcademyEditorMode";
+var PLAYCADEMY_SUPPORTED_QTI_INTERACTION_TYPES;
+var PLAYCADEMY_SUPPORTED_QTI_INTERACTION_TYPE_SET;
+var INTEGER_ANSWER_PATTERN;
+var FLOAT_ANSWER_PATTERN;
+var INLINE_CHOICE_BLANK = "_____";
 var DEFAULT_TIMEBACK_DISCREPANCY_QUEUE_WINDOW = "this-week";
 var TIMEBACK_DISCREPANCY_QUEUE_WINDOW_VALUES;
 var TIMEBACK_DISCREPANCY_QUEUE_METRIC_VALUES;
@@ -105892,6 +105905,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);
 });
@@ -107122,7 +107146,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) {
@@ -107303,7 +107327,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,
@@ -107397,7 +107421,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,
@@ -107430,7 +107454,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,
@@ -108430,7 +108454,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,
@@ -108651,28 +108675,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();
@@ -108698,8 +108703,874 @@ var init_timeback_admin_service = __esm(async () => {
     init_timeback_mastery_completion_util()
   ]);
 });
+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();
+});
+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";
+var QTI_AUTHORING_FIELDS;
+var 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
+  ];
+});
+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-";
+var PLAYCADEMY_QTI_SOURCE_UPPER_BOUND = "playcademy-test.";
 
 class TimebackAssessmentsService {
+  static QTI_HYDRATION_CONCURRENCY = 8;
   deps;
   constructor(deps) {
     this.deps = deps;
@@ -108716,33 +109587,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", {
@@ -108751,319 +109608,420 @@ class TimebackAssessmentsService {
           "app.error.message": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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": errorMessage2(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) {
@@ -109071,8 +110029,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) {
@@ -109080,6 +110048,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))
@@ -109089,27 +110068,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": errorMessage2(error88)
+        });
+      }
+    }
+    if (!testDeleted) {
+      return;
+    }
+    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": errorMessage2(error88)
+        });
+      }
     }
-    return Math.max(...rows.map((r) => r.sortOrder));
+  }
+  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();
 });
 function buildTimebackBaseConfigFromExistingConfig(config4) {
   return {
@@ -111181,10 +112258,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()
   ]);
 });
@@ -170393,16 +171470,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);
@@ -171587,6 +172654,26 @@ var init_session_controller = __esm(() => {
     mintToken
   });
 });
+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;
 var getUser;
 var getUserEnrollments;
@@ -171628,17 +172715,17 @@ var unenrollStudent;
 var reactivateEnrollment;
 var listAssessments;
 var createAssessment;
-var deleteAssessment;
+var updateAssessment;
 var reorderAssessments;
 var reorderQuestions;
-var activateAssessment;
-var deactivateAssessment;
+var removeAssessment;
 var listQuestions;
+var listQuestionLibrary;
+var listTestLibrary;
+var copyAssessment;
 var createQuestion;
 var updateQuestion;
-var deleteQuestion;
-var getAssessmentBankStatus;
-var destroyAssessmentBank;
+var removeQuestion;
 var timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
@@ -172154,7 +173241,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");
@@ -172162,40 +173249,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");
@@ -172205,33 +173292,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");
@@ -172240,7 +173345,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");
@@ -172249,30 +173354,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", {
@@ -172317,17 +173405,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
   });
 });
 var initiate;