@playcademy/sandbox 0.12.2-beta.1 → 0.12.2-beta.3

package/dist/server.js

@@ -697,7 +697,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.12.2-beta.1",
+    version: "0.12.2-beta.3",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -12954,6 +12954,7 @@ var init_schema = __esm(() => {
     assessmentArtifactBucket: stringType().optional(),
     cdnOrigin: stringType().url().startsWith("https://").optional(),
     queueIngressSecret: stringType().optional(),
+    embedAdminToken: stringType().optional(),
     secretsManifestPepper: stringType().optional()
   }).superRefine((config, ctx) => {
     if (config.isLocal && !config.baseUrl) {
@@ -13120,6 +13121,17 @@ var init_table_utils = __esm(() => {
 });
 
 // ../../node_modules/.bun/drizzle-orm@0.45.3+c063d24bf874cbdc/node_modules/drizzle-orm/pg-core/foreign-keys.js
+function foreignKey(config) {
+  function mappedConfig() {
+    const { name: name2, columns, foreignColumns } = config;
+    return {
+      name: name2,
+      columns,
+      foreignColumns
+    };
+  }
+  return new ForeignKeyBuilder(mappedConfig);
+}
 var ForeignKeyBuilder, ForeignKey;
 var init_foreign_keys = __esm(() => {
   init_entity();
@@ -15992,6 +16004,16 @@ function ilike(column, value) {
 function notIlike(column, value) {
   return sql`${column} not ilike ${value}`;
 }
+function arrayContains(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      throw new Error("arrayContains requires at least one value");
+    }
+    const array = sql`${bindIfParam(values, column)}`;
+    return sql`${column} @> ${array}`;
+  }
+  return sql`${column} @> ${bindIfParam(values, column)}`;
+}
 var eq = (left, right) => {
   return sql`${left} = ${bindIfParam(right, left)}`;
 }, ne = (left, right) => {
@@ -18922,7 +18944,7 @@ var init_table6 = __esm(() => {
 });
 
 // ../data/src/domains/timeback/table.ts
-var gameTimebackIntegrationStatusEnum, gameTimebackAssessmentPurposeEnum, gameTimebackAssessmentStatusEnum, gameTimebackIntegrations, gameTimebackAssessmentTests, gameTimebackMetricDiscrepancyVerifications, gameTimebackActivityCompletions;
+var gameTimebackIntegrationStatusEnum, gameTimebackIntegrationKindEnum, gameTimebackAssessmentPurposeEnum, gameTimebackAssessmentStatusEnum, gameTimebackIntegrations, gameTimebackAssessmentTests, gameTimebackMetricDiscrepancyVerifications, gameTimebackActivityCompletions;
 var init_table7 = __esm(() => {
   init_drizzle_orm();
   init_pg_core();
@@ -18933,6 +18955,10 @@ var init_table7 = __esm(() => {
     "active",
     "deactivated"
   ]);
+  gameTimebackIntegrationKindEnum = pgEnum("game_timeback_integration_kind", [
+    "base",
+    "hole_filling"
+  ]);
   gameTimebackAssessmentPurposeEnum = pgEnum("game_timeback_assessment_purpose", ASSESSMENT_PURPOSES);
   gameTimebackAssessmentStatusEnum = pgEnum("game_timeback_assessment_status", [
     "draft",
@@ -18946,6 +18972,8 @@ var init_table7 = __esm(() => {
     grade: integer("grade").notNull(),
     subject: text("subject").notNull(),
     status: gameTimebackIntegrationStatusEnum("status"),
+    kind: gameTimebackIntegrationKindEnum("kind").notNull().default("base"),
+    baseIntegrationId: uuid("base_integration_id"),
     totalXp: integer("total_xp"),
     lastVerifiedAt: timestamp("last_verified_at", { withTimezone: true }),
     deactivatedAt: timestamp("deactivated_at", { withTimezone: true }),
@@ -18953,7 +18981,19 @@ var init_table7 = __esm(() => {
     createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
   }, (table) => [
-    uniqueIndex("game_timeback_integrations_game_grade_subject_idx").on(table.gameId, table.grade, table.subject).where(sql`${table.status} IS DISTINCT FROM 'deactivated'`)
+    uniqueIndex("game_timeback_integrations_game_grade_subject_idx").on(table.gameId, table.grade, table.subject).where(sql`${table.status} IS DISTINCT FROM 'deactivated' AND ${table.kind} = 'base'`),
+    uniqueIndex("game_timeback_integrations_hole_filling_course_idx").on(table.gameId, table.courseId).where(sql`${table.kind} = 'hole_filling'`),
+    index("game_timeback_integrations_base_integration_idx").on(table.baseIntegrationId),
+    foreignKey({
+      name: "game_timeback_integrations_base_integration_id_fk",
+      columns: [table.baseIntegrationId],
+      foreignColumns: [table.id]
+    }),
+    check("game_timeback_integrations_kind_base_check", sql`(
+                (${table.kind}::text = 'base' AND ${table.baseIntegrationId} IS NULL)
+                OR
+                (${table.kind}::text = 'hole_filling' AND ${table.baseIntegrationId} IS NOT NULL)
+            )`)
   ]);
   gameTimebackAssessmentTests = pgTable("game_timeback_assessment_tests", {
     id: uuid("id").primaryKey().defaultRandom(),
@@ -19035,7 +19075,7 @@ var init_table7 = __esm(() => {
 });
 
 // ../data/src/domains/embed/table.ts
-var embedPartners, embedPartnerGames, embedLaunches, embedPartnersRelations, embedPartnerGamesRelations, embedLaunchesRelations;
+var embedPartners, embedLaunches, embedLaunchesRelations;
 var init_table8 = __esm(() => {
   init_drizzle_orm();
   init_pg_core();
@@ -19050,15 +19090,6 @@ var init_table8 = __esm(() => {
     createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
   });
-  embedPartnerGames = pgTable("embed_partner_games", {
-    id: uuid("id").primaryKey().defaultRandom(),
-    partnerId: uuid("partner_id").notNull().references(() => embedPartners.id, { onDelete: "cascade" }),
-    gameId: uuid("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-  }, (table) => [
-    uniqueIndex("embed_partner_games_partner_game_idx").on(table.partnerId, table.gameId),
-    index("embed_partner_games_game_idx").on(table.gameId)
-  ]);
   embedLaunches = pgTable("embed_launches", {
     id: uuid("id").primaryKey().defaultRandom(),
     partnerId: uuid("partner_id").notNull().references(() => embedPartners.id, { onDelete: "restrict" }),
@@ -19077,19 +19108,6 @@ var init_table8 = __esm(() => {
     index("embed_launches_user_idx").on(table.userId),
     index("embed_launches_game_idx").on(table.gameId)
   ]);
-  embedPartnersRelations = relations(embedPartners, ({ many }) => ({
-    games: many(embedPartnerGames)
-  }));
-  embedPartnerGamesRelations = relations(embedPartnerGames, ({ one }) => ({
-    partner: one(embedPartners, {
-      fields: [embedPartnerGames.partnerId],
-      references: [embedPartners.id]
-    }),
-    game: one(games, {
-      fields: [embedPartnerGames.gameId],
-      references: [games.id]
-    })
-  }));
   embedLaunchesRelations = relations(embedLaunches, ({ one }) => ({
     partner: one(embedPartners, {
       fields: [embedLaunches.partnerId],
@@ -19120,10 +19138,7 @@ __export(exports_tables_index, {
   developerStatusEnum: () => developerStatusEnum,
   embedLaunches: () => embedLaunches,
   embedLaunchesRelations: () => embedLaunchesRelations,
-  embedPartnerGames: () => embedPartnerGames,
-  embedPartnerGamesRelations: () => embedPartnerGamesRelations,
   embedPartners: () => embedPartners,
-  embedPartnersRelations: () => embedPartnersRelations,
   gameCustomHostnames: () => gameCustomHostnames,
   gameDashboardUserRoleEnum: () => gameDashboardUserRoleEnum,
   gameDashboardUsers: () => gameDashboardUsers,
@@ -19142,6 +19157,7 @@ __export(exports_tables_index, {
   gameTimebackAssessmentPurposeEnum: () => gameTimebackAssessmentPurposeEnum,
   gameTimebackAssessmentStatusEnum: () => gameTimebackAssessmentStatusEnum,
   gameTimebackAssessmentTests: () => gameTimebackAssessmentTests,
+  gameTimebackIntegrationKindEnum: () => gameTimebackIntegrationKindEnum,
   gameTimebackIntegrationStatusEnum: () => gameTimebackIntegrationStatusEnum,
   gameTimebackIntegrations: () => gameTimebackIntegrations,
   gameTimebackMetricDiscrepancyVerifications: () => gameTimebackMetricDiscrepancyVerifications,
@@ -21049,10 +21065,19 @@ var init_helpers = __esm(() => {
 });
 
 // ../data/src/domains/timeback/helpers.ts
+function isBaseGameTimebackIntegration() {
+  return sql`${gameTimebackIntegrations.kind} = ${BASE_GAME_TIMEBACK_INTEGRATION_KIND}`;
+}
+function isBaseGameTimebackIntegrationRow(integration) {
+  return integration.kind === BASE_GAME_TIMEBACK_INTEGRATION_KIND;
+}
 function isActiveGameTimebackIntegrationStatus(statusColumn = gameTimebackIntegrations.status) {
   return sql`${statusColumn} IS DISTINCT FROM ${DEACTIVATED_GAME_TIMEBACK_INTEGRATION_STATUS}`;
 }
-var ACTIVE_GAME_TIMEBACK_INTEGRATION_STATUS = "active", DEACTIVATED_GAME_TIMEBACK_INTEGRATION_STATUS = "deactivated";
+function isActiveBaseGameTimebackIntegration() {
+  return sql`(${isActiveGameTimebackIntegrationStatus()} AND ${isBaseGameTimebackIntegration()})`;
+}
+var ACTIVE_GAME_TIMEBACK_INTEGRATION_STATUS = "active", DEACTIVATED_GAME_TIMEBACK_INTEGRATION_STATUS = "deactivated", BASE_GAME_TIMEBACK_INTEGRATION_KIND = "base", HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND = "hole_filling";
 var init_helpers2 = __esm(() => {
   init_drizzle_orm();
   init_table7();
@@ -37629,12 +37654,12 @@ function resolveIntegrationSubject(patchSubject, liveSubject, storedSubject) {
 function filterEnrollmentsByGame(enrollments, gameId) {
   return enrollments.filter((enrollment) => enrollment.gameId === gameId).map(({ gameId: _, ...enrollment }) => enrollment);
 }
-function mapEnrollmentsToUserEnrollments(enrollments, integrations) {
+function mapEnrollmentsToUserEnrollments(enrollments, integrations, baseCourseIdByIntegrationId = new Map) {
   const enrollmentByCourse = new Map(enrollments.map((enrollment) => [enrollment.courseId, enrollment]));
   const courseToSchool = new Map(enrollments.filter((enrollment) => enrollment.school?.id).map((enrollment) => [enrollment.courseId, enrollment.school.id]));
   return integrations.map((integration) => {
     const enrollment = enrollmentByCourse.get(integration.courseId);
-    return {
+    const userEnrollment = {
       gameId: integration.gameId,
       grade: integration.grade,
       subject: integration.subject,
@@ -37642,6 +37667,17 @@ function mapEnrollmentsToUserEnrollments(enrollments, integrations) {
       orgId: courseToSchool.get(integration.courseId),
       ...enrollment ? { id: enrollment.sourcedId } : {}
     };
+    if (integration.kind !== HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND) {
+      return userEnrollment;
+    }
+    const baseCourseId = integration.baseIntegrationId ? baseCourseIdByIntegrationId.get(integration.baseIntegrationId) : undefined;
+    return {
+      ...userEnrollment,
+      kind: HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND,
+      ...baseCourseId && { baseCourseId },
+      ...enrollment?.beginDate !== undefined && { beginDate: enrollment.beginDate },
+      ...enrollment?.metadata && { enrollmentMetadata: enrollment.metadata }
+    };
   });
 }
 function buildGameTimebackSummaries(integrations) {
@@ -38124,7 +38160,7 @@ var init_game_service = __esm(() => {
       const db = this.deps.db;
       const integrations = await db.query.gameTimebackIntegrations.findMany({
         columns: { gameId: true, subject: true },
-        where: isActiveGameTimebackIntegrationStatus(),
+        where: isActiveBaseGameTimebackIntegration(),
         orderBy: [asc(gameTimebackIntegrations.createdAt)]
       });
       const subjectMap = {};
@@ -38148,9 +38184,7 @@ var init_game_service = __esm(() => {
       }
       const integrations = await db.query.gameTimebackIntegrations.findMany({
         columns: { gameId: true, subject: true, status: true },
-        ...accessibleGameIds && {
-          where: inArray(gameTimebackIntegrations.gameId, [...accessibleGameIds])
-        },
+        where: and(accessibleGameIds ? inArray(gameTimebackIntegrations.gameId, [...accessibleGameIds]) : undefined, isBaseGameTimebackIntegration()),
         orderBy: [asc(gameTimebackIntegrations.createdAt)]
       });
       return buildGameTimebackSummaries(integrations);
@@ -48581,7 +48615,7 @@ function rejectSystemManagedReview(input, context) {
     });
   }
 }
-var TimebackGradeSchema, TimebackSubjectSchema, CourseGoalsSchema, UpdateGameTimebackIntegrationRequestSchema, CreateGameTimebackIntegrationRequestSchema, TimebackActivityDataSchema, EndActivityRequestSchema, GameRunMetricsSchema, GameCourseMetricsSchema, GameMetricsResponseSchema, AdvanceCourseRequestSchema, UnenrollCourseRequestSchema, HeartbeatRequestSchema, PopulateStudentRequestSchema, DerivedPlatformCourseConfigSchema, TimebackBaseConfigSchema, PlatformTimebackSetupRequestSchema, AdminTimebackMutationBaseSchema, AdminAttributionDateSchema, ADMIN_GRANT_XP_MIN = -1e5, ADMIN_GRANT_XP_MAX = 1e5, ADMIN_GRANT_XP_AMOUNT_RANGE_MESSAGE, GrantTimebackXpRequestSchema, AdjustTimebackTimeRequestSchema, AdjustTimebackMasteryRequestSchema, ReconcileMasteryForConfigChangeSchema, EnrollStudentRequestSchema, UnenrollStudentRequestSchema, ReactivateEnrollmentRequestSchema, VerifyTimebackMetricDiscrepancyRequestSchema, AssessmentPurposeSchema, AssessmentStatusSchema, AssessmentKeySchema, DiagnosticKeySchema, DiagnosticRoutingManifestSchema, DiagnosticAssessmentDefinitionInputSchema, AssessmentStandardRefSchema3, CreateAssessmentRequestSchema, UpdateAssessmentRequestSchema, CopyAssessmentRequestSchema, ReviseAssessmentRequestSchema, AssessmentAssociationImportEntrySchema, AttachExistingAssessmentsRequestSchema, ReorderQuestionsRequestSchema;
+var TimebackGradeSchema, TimebackSubjectSchema, CourseGoalsSchema, UpdateGameTimebackIntegrationRequestSchema, CreateGameTimebackIntegrationRequestSchema, RESERVED_TIMEBACK_COURSE_SOURCED_IDS, TimebackCourseSourcedIdSchema, CreateGameTimebackHoleFillingCourseRequestSchema, TimebackActivityDataSchema, EndActivityRequestSchema, GameRunMetricsSchema, GameCourseMetricsSchema, GameMetricsResponseSchema, AdvanceCourseRequestSchema, UnenrollCourseRequestSchema, HeartbeatRequestSchema, PopulateStudentRequestSchema, DerivedPlatformCourseConfigSchema, TimebackBaseConfigSchema, PlatformTimebackSetupRequestSchema, AdminTimebackMutationBaseSchema, AdminAttributionDateSchema, ADMIN_GRANT_XP_MIN = -1e5, ADMIN_GRANT_XP_MAX = 1e5, ADMIN_GRANT_XP_AMOUNT_RANGE_MESSAGE, GrantTimebackXpRequestSchema, AdjustTimebackTimeRequestSchema, AdjustTimebackMasteryRequestSchema, ReconcileMasteryForConfigChangeSchema, EnrollStudentRequestSchema, UnenrollStudentRequestSchema, ReactivateEnrollmentRequestSchema, VerifyTimebackMetricDiscrepancyRequestSchema, AssessmentPurposeSchema, AssessmentStatusSchema, AssessmentKeySchema, DiagnosticKeySchema, DiagnosticRoutingManifestSchema, DiagnosticAssessmentDefinitionInputSchema, AssessmentStandardRefSchema3, CreateAssessmentRequestSchema, UpdateAssessmentRequestSchema, CopyAssessmentRequestSchema, ReviseAssessmentRequestSchema, AssessmentAssociationImportEntrySchema, AttachExistingAssessmentsRequestSchema, ReorderQuestionsRequestSchema;
 var init_schemas4 = __esm(() => {
   init_esm();
   init_src();
@@ -48617,6 +48651,26 @@ var init_schemas4 = __esm(() => {
     masterableUnits: numberType().int().nonnegative(),
     level: stringType().trim().min(1).optional()
   });
+  RESERVED_TIMEBACK_COURSE_SOURCED_IDS = new Set([
+    "hole-filling",
+    "removed",
+    "components",
+    "component-resources",
+    "structure"
+  ]);
+  TimebackCourseSourcedIdSchema = stringType().trim().min(3).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, {
+    message: "Use letters, numbers, dots, dashes, or underscores, starting with a letter or number"
+  }).refine((value) => !RESERVED_TIMEBACK_COURSE_SOURCED_IDS.has(value.toLowerCase()), {
+    message: "This course ID is reserved"
+  });
+  CreateGameTimebackHoleFillingCourseRequestSchema = objectType({
+    baseCourseId: stringType().trim().min(1),
+    title: stringType().trim().min(1),
+    courseCode: stringType().trim().min(1),
+    totalXp: numberType().int().positive(),
+    masterableUnits: numberType().int().nonnegative(),
+    courseId: TimebackCourseSourcedIdSchema.optional()
+  });
   TimebackActivityDataSchema = objectType({
     activityId: stringType().min(1),
     activityName: stringType().optional(),
@@ -48625,6 +48679,7 @@ var init_schemas4 = __esm(() => {
     appName: stringType().optional(),
     sensorUrl: stringType().url().optional(),
     courseId: stringType().min(1).optional(),
+    enrollmentId: stringType().min(1).optional(),
     courseName: stringType().optional(),
     studentEmail: stringType().email().optional()
   });
@@ -48948,21 +49003,20 @@ function isCanonicalOrigin(value) {
   }
   return url.protocol === "https:" || url.protocol === "http:" && isLocalHostname(url.hostname);
 }
-var LOCAL_HOSTNAMES, EmbedOriginSchema, CreateEmbedPartnerSchema, UpdateEmbedPartnerSchema, CreateEmbedLaunchSchema, RedeemEmbedPassSchema;
+var LOCAL_HOSTNAMES, EmbedOriginSchema, EmbedPartnerClientIdSchema, EnsureEmbedPartnerSchema, AddEmbedPartnerOriginSchema, CreateEmbedLaunchSchema, RedeemEmbedPassSchema;
 var init_schemas5 = __esm(() => {
   init_esm();
   LOCAL_HOSTNAMES = new Set(["localhost", "127.0.0.1"]);
   EmbedOriginSchema = stringType().refine(isCanonicalOrigin, {
     message: "Origin must be a bare https origin like https://example.com, with no path or slash"
   });
-  CreateEmbedPartnerSchema = objectType({
-    name: stringType().trim().min(1).max(100),
-    clientId: stringType().trim().min(1).max(200),
-    allowedOrigins: arrayType(EmbedOriginSchema).max(20).default([]),
-    allowedGameIds: arrayType(stringType().uuid().transform((id) => id.toLowerCase())).max(200).default([]),
-    enabled: booleanType().default(true)
+  EmbedPartnerClientIdSchema = stringType().trim().min(1).max(200);
+  EnsureEmbedPartnerSchema = objectType({
+    name: stringType().trim().min(1).max(100)
+  }).strict();
+  AddEmbedPartnerOriginSchema = objectType({
+    origin: EmbedOriginSchema
   }).strict();
-  UpdateEmbedPartnerSchema = CreateEmbedPartnerSchema.omit({ clientId: true }).partial();
   CreateEmbedLaunchSchema = objectType({
     timebackId: stringType().trim().min(1).max(200),
     gameSlug: stringType().trim().min(1).max(100),
@@ -76120,6 +76174,7 @@ class CourseAssessments {
 }
 function buildCoursePayload(config) {
   return {
+    ...config.course.sourcedId && { sourcedId: config.course.sourcedId },
     status: "active",
     title: config.course.title,
     courseCode: config.course.courseCode,
@@ -76166,6 +76221,16 @@ function buildComponentResourcePayload(config, sourcedIds) {
     lessonType: config.componentResource.lessonType
   };
 }
+async function findOrUndefined(request) {
+  try {
+    return await request;
+  } catch (error) {
+    if (isApiError(error) && error.statusCode === 404) {
+      return;
+    }
+    throw error;
+  }
+}
 
 class CourseIntegration {
   core;
@@ -76204,6 +76269,32 @@ class CourseIntegration {
       ...verboseData && { verboseData }
     };
   }
+  async findCourse(courseId) {
+    return findOrUndefined(this.core.api.oneroster.courses.get(courseId));
+  }
+  async resumeSetup(courseId, config) {
+    const oneroster = this.core.api.oneroster;
+    const sourcedIds = deriveSourcedIds(courseId);
+    if (!await findOrUndefined(oneroster.courses.getComponent(sourcedIds.component))) {
+      await oneroster.courses.createComponent(buildComponentPayload(config, sourcedIds));
+      addEvent("timeback.component_created", {
+        "app.timeback.component_id": sourcedIds.component
+      });
+    }
+    if (!await findOrUndefined(oneroster.resources.get(sourcedIds.resource))) {
+      await oneroster.resources.create(buildResourcePayload(config, sourcedIds.resource));
+      addEvent("timeback.resource_created", {
+        "app.timeback.resource_id": sourcedIds.resource
+      });
+    }
+    if (!await findOrUndefined(oneroster.courses.getComponentResource(sourcedIds.componentResource))) {
+      await oneroster.courses.createComponentResource(buildComponentResourcePayload(config, sourcedIds));
+      addEvent("timeback.component_resource_link_created", {
+        "app.timeback.component_resource_id": sourcedIds.componentResource
+      });
+    }
+    await this.update(courseId, config);
+  }
   async update(courseId, config) {
     const oneroster = this.core.api.oneroster;
     const sourcedIds = deriveSourcedIds(courseId);
@@ -76343,6 +76434,8 @@ function createCourseNamespace(core) {
     update: (courseId, config) => integration.update(courseId, config),
     verify: (courseId) => integration.verify(courseId),
     getConfig: (courseId) => integration.getConfig(courseId),
+    findCourse: (courseId) => integration.findCourse(courseId),
+    resumeSetup: (courseId, config) => integration.resumeSetup(courseId, config),
     cleanup: (courseId) => integration.cleanup(courseId),
     deactivateCourse: (courseId) => integration.updateCourseStatus(courseId, "tobedeleted"),
     reactivateCourse: (courseId) => integration.updateCourseStatus(courseId, "active"),
@@ -76427,7 +76520,9 @@ class RosterEnrollments {
         status: "active",
         grades,
         subjects,
-        school: enrollment.school
+        school: enrollment.school,
+        beginDate: enrollment.beginDate,
+        ...enrollment.metadata && { metadata: enrollment.metadata }
       };
     });
     this.core.caches.enrollments.set(studentId, enrollments);
@@ -87231,7 +87326,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     }) {
       await this.deps.validateDeveloperAccess(user, gameId);
       const integrations = await this.deps.db.query.gameTimebackIntegrations.findMany({
-        where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveGameTimebackIntegrationStatus())
+        where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveBaseGameTimebackIntegration())
       });
       const matchingIntegrations = new Map;
       for (const integration of integrations) {
@@ -87620,7 +87715,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     }) {
       await this.deps.validateDeveloperAccess(user, gameId);
       const integrations = await this.deps.db.query.gameTimebackIntegrations.findMany({
-        where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveGameTimebackIntegrationStatus())
+        where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveBaseGameTimebackIntegration())
       });
       const orderedIntegrations = integrations.toSorted((left, right) => {
         const subjectDifference = left.subject.localeCompare(right.subject);
@@ -87699,7 +87794,7 @@ var init_timeback_assessment_runtime_service = __esm(async () => {
     async candidateIntegrations(gameId, studentId, input, db = this.deps.db) {
       const filters = [
         eq(gameTimebackIntegrations.gameId, gameId),
-        isActiveGameTimebackIntegrationStatus()
+        isActiveBaseGameTimebackIntegration()
       ];
       if (input.subject) {
         filters.push(eq(gameTimebackIntegrations.subject, input.subject));
@@ -90599,6 +90694,22 @@ var init_timeback_assessments_service = __esm(async () => {
   await init_errors8();
 });
 
+// ../api-core/src/utils/timeback-attribution.util.ts
+function resolveRuntimeAttribution(base, holeFilling, requestedCourseId, recordedCourseId) {
+  const recorded = [base, ...holeFilling].find((integration) => integration.courseId === recordedCourseId);
+  if (recorded) {
+    return { integration: recorded, requestedCourseIdStatus: "pinned_by_run" };
+  }
+  if (requestedCourseId === undefined) {
+    return { integration: base, requestedCourseIdStatus: "absent" };
+  }
+  if (requestedCourseId === base.courseId) {
+    return { integration: base, requestedCourseIdStatus: "accepted" };
+  }
+  const requestedHoleFilling = holeFilling.find((integration) => integration.courseId === requestedCourseId);
+  return requestedHoleFilling ? { integration: requestedHoleFilling, requestedCourseIdStatus: "accepted_hole_filling" } : { integration: base, requestedCourseIdStatus: "ignored_mismatch" };
+}
+
 // ../api-core/src/utils/timeback-create-integration.util.ts
 function buildTimebackBaseConfigFromExistingConfig(config) {
   return {
@@ -90641,6 +90752,50 @@ function timebackConfigMatchesCreateIntegrationRequest(config, request) {
   const requestedLevel = request.level ?? deriveTimebackCourseLevelFromGrade(request.grade);
   return subject === request.subject && grade === request.grade && config.course.title === request.title && config.course.courseCode === request.courseCode && config.course.level === requestedLevel && (getTotalXpFromTimebackConfig(config) ?? null) === request.totalXp && (getMasterableUnitsFromTimebackConfig(config) ?? null) === request.masterableUnits;
 }
+function buildHoleFillingCourseConfig(baseConfig, request) {
+  const baseCourseMetadata = isRecord4(baseConfig.course.metadata) ? baseConfig.course.metadata : {};
+  const baseMetrics = isRecord4(baseCourseMetadata.metrics) ? baseCourseMetadata.metrics : {};
+  const baseResourceMetadata = isRecord4(baseConfig.resource.metadata) ? baseConfig.resource.metadata : {};
+  const basePlaycademy = isPlaycademyResourceMetadata(baseResourceMetadata.playcademy) ? baseResourceMetadata.playcademy : undefined;
+  return {
+    organization: baseConfig.organization,
+    course: {
+      ...baseConfig.course,
+      ...request.courseId && { sourcedId: request.courseId },
+      title: request.title,
+      courseCode: request.courseCode,
+      metadata: {
+        ...baseCourseMetadata,
+        courseType: HOLE_FILLING_COURSE_TYPE,
+        baseCourseSourcedId: request.baseCourseId,
+        metrics: {
+          ...baseMetrics,
+          totalXp: request.totalXp,
+          totalLessons: request.masterableUnits,
+          totalGrades: 1
+        }
+      }
+    },
+    component: { ...baseConfig.component, title: `${request.title} Activities` },
+    resource: {
+      ...baseConfig.resource,
+      title: `${request.title} Game`,
+      metadata: {
+        ...baseResourceMetadata,
+        xp: request.totalXp,
+        playcademy: {
+          ...basePlaycademy,
+          mastery: {
+            ...basePlaycademy?.mastery,
+            masterableUnits: request.masterableUnits
+          }
+        }
+      }
+    },
+    componentResource: { ...baseConfig.componentResource, title: `${request.title} Lesson` }
+  };
+}
+var HOLE_FILLING_COURSE_TYPE = "hole-filling";
 var init_timeback_create_integration_util = __esm(() => {
   init_constants2();
   init_types2();
@@ -90656,7 +90811,7 @@ async function promoteCompletedCourse({
   enrollments: prefetchedEnrollments
 }) {
   const subjectIntegrations = await db.query.gameTimebackIntegrations.findMany({
-    where: and(eq(gameTimebackIntegrations.gameId, currentIntegration.gameId), eq(gameTimebackIntegrations.subject, currentIntegration.subject), isActiveGameTimebackIntegrationStatus())
+    where: and(eq(gameTimebackIntegrations.gameId, currentIntegration.gameId), eq(gameTimebackIntegrations.subject, currentIntegration.subject), isActiveBaseGameTimebackIntegration())
   });
   const nextIntegration = subjectIntegrations.filter((integration) => integration.grade > currentIntegration.grade).toSorted((left, right) => left.grade - right.grade)[0];
   if (!nextIntegration) {
@@ -90723,6 +90878,8 @@ function toGameTimebackIntegration(integration) {
     courseId: integration.courseId,
     grade: integration.grade,
     subject: integration.subject,
+    kind: integration.kind,
+    baseIntegrationId: integration.baseIntegrationId,
     totalXp: integration.totalXp ?? null,
     status: integration.status ?? ACTIVE_GAME_TIMEBACK_INTEGRATION_STATUS,
     deactivatedAt: integration.deactivatedAt ?? null,
@@ -90760,6 +90917,9 @@ var init_timeback_removed_integration_util = __esm(() => {
 
 // ../api-core/src/services/timeback.service.ts
 import { createHash as createHash3 } from "node:crypto";
+function isUnregisteredHoleFillingOf(course, base) {
+  return course.metadata?.courseType === HOLE_FILLING_COURSE_TYPE && course.metadata.baseCourseSourcedId === base.courseId;
+}
 async function findGameTimebackIntegrationForUpdate(db, condition) {
   const [integration] = await db.select().from(gameTimebackIntegrations).where(condition).limit(1).for("update");
   return integration;
@@ -90809,13 +90969,13 @@ var init_timeback_service = __esm(async () => {
     static clearInFlightHeartbeatWindow(key) {
       this.inFlightHeartbeatWindows.delete(key);
     }
-    static buildCompletionCaliperEventId(key, kind, discriminator = "completion") {
+    static buildCompletionCaliperEventId(key, kind, baseCourseId, discriminator = "completion") {
       const hash = createHash3("sha256").update([
         "playcademy",
         "timeback",
         kind,
         key.gameId,
-        key.courseId,
+        baseCourseId,
         key.studentId,
         key.runId,
         key.activityId,
@@ -90881,11 +91041,14 @@ var init_timeback_service = __esm(async () => {
         } : null
       };
     }
-    static async acquireCompletionReservation(db, key) {
-      let reserveOutcome = await this.reserveCompletion(db, key);
+    static async acquireCompletionReservation(db, key, otherCourseIds = []) {
+      function reserve() {
+        return otherCourseIds.length > 0 ? TimebackService.reserveCompletionAcrossCourses(db, key, otherCourseIds) : TimebackService.reserveCompletion(db, key);
+      }
+      let reserveOutcome = await reserve();
       for (let settleAttempt = 0;reserveOutcome.status === "in_flight" && settleAttempt < this.COMPLETION_IN_FLIGHT_SETTLE_ATTEMPTS; settleAttempt++) {
         await sleep(this.COMPLETION_IN_FLIGHT_SETTLE_DELAY_MS);
-        reserveOutcome = await this.reserveCompletion(db, key);
+        reserveOutcome = await reserve();
       }
       if (reserveOutcome.status === "duplicate") {
         setAttribute("app.timeback.end_activity_status", "blocked_by_dedupe_guard");
@@ -90904,8 +91067,24 @@ var init_timeback_service = __esm(async () => {
       }
       return { status: "reserved", token: reserveOutcome.token };
     }
-    static async runWithCompletionReservation(db, key, emit, awardFromResult) {
-      const acquired = await this.acquireCompletionReservation(db, key);
+    static async reserveCompletionAcrossCourses(db, key, otherCourseIds) {
+      return db.transaction(async (tx) => {
+        const database = tx;
+        const runKey = `timeback-completion:${key.gameId.toLowerCase()}:${key.studentId}:${key.runId.toLowerCase()}:${key.activityId}`;
+        await database.execute(sql`SELECT pg_advisory_xact_lock(hashtextextended(${runKey}, 0))`);
+        const onOtherCourse = await database.query.gameTimebackActivityCompletions.findFirst({
+          columns: { id: true },
+          where: and(eq(gameTimebackActivityCompletions.gameId, key.gameId), eq(gameTimebackActivityCompletions.studentId, key.studentId), eq(gameTimebackActivityCompletions.runId, key.runId), eq(gameTimebackActivityCompletions.activityId, key.activityId), inArray(gameTimebackActivityCompletions.courseId, [...otherCourseIds]))
+        });
+        if (onOtherCourse) {
+          setAttribute("app.timeback.end_activity_status", "completion_reserved_on_other_course");
+          throw new ServiceUnavailableError("An end-activity submission for this run is already in flight — retry shortly");
+        }
+        return this.reserveCompletion(database, key);
+      });
+    }
+    static async runWithCompletionReservation(db, key, emit, awardFromResult, otherCourseIds = []) {
+      const acquired = await this.acquireCompletionReservation(db, key, otherCourseIds);
       if (acquired.status === "duplicate") {
         return acquired;
       }
@@ -90940,6 +91119,9 @@ var init_timeback_service = __esm(async () => {
       await db.delete(gameTimebackActivityCompletions).where(and(eq(gameTimebackActivityCompletions.id, token.id), eq(gameTimebackActivityCompletions.reservedAt, token.reservedAt), isNull(gameTimebackActivityCompletions.completedAt)));
     }
     static addResumeIdToExtensions(extensions, resumeId) {
+      return TimebackService.addPlaycademyExtensions(extensions, { resumeId });
+    }
+    static addPlaycademyExtensions(extensions, fields) {
       const base = extensions ?? {};
       const existingPlaycademy = base.playcademy;
       const playcademy = typeof existingPlaycademy === "object" && existingPlaycademy !== null && !Array.isArray(existingPlaycademy) ? existingPlaycademy : {};
@@ -90947,28 +91129,71 @@ var init_timeback_service = __esm(async () => {
         ...base,
         playcademy: {
           ...playcademy,
-          resumeId
+          ...fields
         }
       };
     }
-    static resolveRuntimeCourse(resolvedCourseId, requestedCourseId, courseName) {
-      let requestedCourseIdStatus = "absent";
-      if (requestedCourseId === resolvedCourseId) {
-        requestedCourseIdStatus = "accepted";
-      } else if (requestedCourseId !== undefined) {
-        requestedCourseIdStatus = "ignored_mismatch";
+    async resolveRuntimeCourse({
+      gameId,
+      studentId,
+      runId,
+      activityData,
+      extensions
+    }) {
+      const integrations = await this.deps.db.query.gameTimebackIntegrations.findMany({
+        where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, activityData.grade), eq(gameTimebackIntegrations.subject, activityData.subject), isActiveGameTimebackIntegrationStatus())
+      });
+      const base = integrations.find(isBaseGameTimebackIntegrationRow);
+      if (!base) {
+        throw new NotFoundError(`Timeback integration for game (grade ${activityData.grade}, subject ${activityData.subject})`);
       }
+      const holeFilling = integrations.filter((integration) => !isBaseGameTimebackIntegrationRow(integration));
+      const recordedCourseId = holeFilling.length > 0 && runId ? await this.findRecordedRunCourse({
+        gameId,
+        studentId,
+        runId,
+        activityId: activityData.activityId,
+        courseIds: integrations.map((i2) => i2.courseId)
+      }) : undefined;
+      const { integration, requestedCourseIdStatus } = resolveRuntimeAttribution(base, holeFilling, activityData.courseId, recordedCourseId);
+      const hintUsed = activityData.courseId === integration.courseId;
+      const enrollmentId = hintUsed ? activityData.enrollmentId : undefined;
+      const isHoleFilling = !isBaseGameTimebackIntegrationRow(integration);
       return {
-        courseId: resolvedCourseId,
-        courseName: requestedCourseIdStatus === "ignored_mismatch" ? undefined : courseName,
+        integration,
+        courseId: integration.courseId,
+        baseCourseId: base.courseId,
+        otherCourseIds: holeFilling.length > 0 ? integrations.map((other) => other.courseId).filter((courseId) => courseId !== integration.courseId) : [],
+        courseName: activityData.courseId === undefined || hintUsed ? activityData.courseName : undefined,
+        extensions: isHoleFilling ? TimebackService.addPlaycademyExtensions(extensions, {
+          courseKind: HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND,
+          baseCourseId: base.courseId,
+          ...enrollmentId && { enrollmentId }
+        }) : extensions,
         attributes: {
-          "app.timeback.course_id": resolvedCourseId,
-          "app.timeback.resolved_course_id": resolvedCourseId,
-          "app.timeback.requested_course_id": requestedCourseId,
-          "app.timeback.requested_course_id_status": requestedCourseIdStatus
+          "app.timeback.course_id": integration.courseId,
+          "app.timeback.resolved_course_id": integration.courseId,
+          "app.timeback.requested_course_id": activityData.courseId,
+          "app.timeback.requested_course_id_status": requestedCourseIdStatus,
+          "app.timeback.course_kind": integration.kind,
+          "app.timeback.enrollment_id": enrollmentId
         }
       };
     }
+    async findRecordedRunCourse({
+      gameId,
+      studentId,
+      runId,
+      activityId,
+      courseIds
+    }) {
+      const recorded = await this.deps.db.query.gameTimebackActivityCompletions.findFirst({
+        columns: { courseId: true },
+        where: and(eq(gameTimebackActivityCompletions.gameId, gameId), eq(gameTimebackActivityCompletions.studentId, studentId), eq(gameTimebackActivityCompletions.runId, runId), eq(gameTimebackActivityCompletions.activityId, activityId), inArray(gameTimebackActivityCompletions.courseId, courseIds)),
+        orderBy: (table, { asc }) => [asc(table.createdAt)]
+      });
+      return recorded?.courseId;
+    }
     static recordRuntimeContext({
       operation,
       studentId,
@@ -91166,13 +91391,29 @@ var init_timeback_service = __esm(async () => {
         const integrations = await db.query.gameTimebackIntegrations.findMany({
           where: and(inArray(gameTimebackIntegrations.courseId, courseIds), isActiveGameTimebackIntegrationStatus())
         });
-        return mapEnrollmentsToUserEnrollments(enrollments, integrations);
+        return mapEnrollmentsToUserEnrollments(enrollments, integrations, await this.loadBaseCourseIds(integrations));
       } catch (error) {
         setAttribute("app.timeback.enrollment_fetch", "failed");
         setAttribute("app.timeback.enrollment_fetch_error", errorMessage(error));
         return [];
       }
     }
+    async loadBaseCourseIds(integrations) {
+      const courseIdById = new Map(integrations.map((row) => [row.id, row.courseId]));
+      const missingBaseIds = [
+        ...new Set(integrations.map((row) => row.baseIntegrationId).filter((id) => id !== null && !courseIdById.has(id)))
+      ];
+      if (missingBaseIds.length > 0) {
+        const baseRows = await this.deps.db.query.gameTimebackIntegrations.findMany({
+          columns: { id: true, courseId: true },
+          where: inArray(gameTimebackIntegrations.id, missingBaseIds)
+        });
+        for (const row of baseRows) {
+          courseIdById.set(row.id, row.courseId);
+        }
+      }
+      return courseIdById;
+    }
     async setupIntegration(gameId, request, user) {
       return this.withClientTelemetry(async () => {
         const client = this.requireClient();
@@ -91183,7 +91424,7 @@ var init_timeback_service = __esm(async () => {
           "app.timeback.course_count": courses.length
         });
         const existing = await db.query.gameTimebackIntegrations.findMany({
-          where: eq(gameTimebackIntegrations.gameId, gameId)
+          where: and(eq(gameTimebackIntegrations.gameId, gameId), isBaseGameTimebackIntegration())
         });
         const integrations = [];
         const verboseData = [];
@@ -91331,13 +91572,13 @@ var init_timeback_service = __esm(async () => {
           "app.timeback.subject": request.subject
         });
         const activeConflict = await db.query.gameTimebackIntegrations.findFirst({
-          where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, request.grade), eq(gameTimebackIntegrations.subject, request.subject), isActiveGameTimebackIntegrationStatus())
+          where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, request.grade), eq(gameTimebackIntegrations.subject, request.subject), isActiveBaseGameTimebackIntegration())
         });
         if (activeConflict) {
           throw new ConflictError(`A TimeBack integration already exists for ${request.subject} Grade ${request.grade}`);
         }
         const removedCandidates = await db.query.gameTimebackIntegrations.findMany({
-          where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, request.grade), eq(gameTimebackIntegrations.subject, request.subject), eq(gameTimebackIntegrations.status, DEACTIVATED_GAME_TIMEBACK_INTEGRATION_STATUS))
+          where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, request.grade), eq(gameTimebackIntegrations.subject, request.subject), eq(gameTimebackIntegrations.status, DEACTIVATED_GAME_TIMEBACK_INTEGRATION_STATUS), isBaseGameTimebackIntegration())
         });
         for (const candidate of removedCandidates) {
           const config = await client.course.getConfig(candidate.courseId).catch((error) => {
@@ -91375,10 +91616,10 @@ var init_timeback_service = __esm(async () => {
           }
         }
         const reference = await db.query.gameTimebackIntegrations.findFirst({
-          where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveGameTimebackIntegrationStatus()),
+          where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveBaseGameTimebackIntegration()),
           orderBy: (table, { asc }) => [asc(table.createdAt)]
         }) ?? await db.query.gameTimebackIntegrations.findFirst({
-          where: eq(gameTimebackIntegrations.gameId, gameId),
+          where: and(eq(gameTimebackIntegrations.gameId, gameId), isBaseGameTimebackIntegration()),
           orderBy: (table, { asc }) => [asc(table.createdAt)]
         });
         if (!reference) {
@@ -91408,10 +91649,77 @@ var init_timeback_service = __esm(async () => {
         return integration;
       });
     }
+    async createHoleFillingCourse(gameId, user, request) {
+      return this.withClientTelemetry(async () => {
+        const client = this.requireClient();
+        const db = this.deps.db;
+        await this.deps.validateDeveloperAccess(user, gameId);
+        TimebackService.recordIntegrationOperation("create_hole_filling_course", {
+          "app.timeback.base_course_id": request.baseCourseId,
+          "app.timeback.custom_course_id": Boolean(request.courseId)
+        });
+        const integration = await db.transaction(async (tx) => {
+          const database = tx;
+          const base = await findGameTimebackIntegrationForUpdate(database, and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.courseId, request.baseCourseId), isActiveBaseGameTimebackIntegration()));
+          if (!base) {
+            throw new NotFoundError("Active base course", `${gameId}:${request.baseCourseId}`);
+          }
+          const config = buildHoleFillingCourseConfig(await client.course.getConfig(base.courseId), request);
+          let courseId = request.courseId;
+          if (courseId) {
+            const takenLocally = await database.query.gameTimebackIntegrations.findFirst({
+              columns: { id: true },
+              where: eq(gameTimebackIntegrations.courseId, courseId)
+            });
+            const remote = takenLocally ? undefined : await client.course.findCourse(courseId);
+            if (takenLocally || remote && !isUnregisteredHoleFillingOf(remote, base)) {
+              throw new ConflictError(`A Timeback course with ID "${courseId}" already exists`);
+            }
+            if (remote) {
+              setAttribute("app.timeback.course_create_mode", "resumed");
+              await client.course.resumeSetup(courseId, config);
+            } else {
+              courseId = undefined;
+            }
+          }
+          if (!courseId) {
+            const created = await client.course.setup(config);
+            courseId = created.courseId;
+          }
+          setAttribute("app.timeback.course_id", courseId);
+          const [inserted] = await database.insert(gameTimebackIntegrations).values({
+            gameId,
+            courseId,
+            grade: base.grade,
+            subject: base.subject,
+            totalXp: request.totalXp,
+            kind: HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND,
+            baseIntegrationId: base.id
+          }).returning();
+          return inserted;
+        });
+        if (!integration) {
+          throw new InternalError("Hole-filling course creation did not return an integration");
+        }
+        return toGameTimebackIntegration(integration);
+      });
+    }
+    async getHoleFillingCourses(gameId, user) {
+      await this.deps.validateGameManagementAccess(user, gameId);
+      const rows = await this.deps.db.query.gameTimebackIntegrations.findMany({
+        where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.kind, HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND), isActiveGameTimebackIntegrationStatus()),
+        orderBy: (table, { asc }) => [
+          asc(table.subject),
+          asc(table.grade),
+          asc(table.createdAt)
+        ]
+      });
+      return rows.map((row) => toGameTimebackIntegration(row));
+    }
     async getIntegrations(gameId, user) {
       await this.deps.validateGameManagementAccess(user, gameId);
       const rows = await this.deps.db.query.gameTimebackIntegrations.findMany({
-        where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveGameTimebackIntegrationStatus())
+        where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveBaseGameTimebackIntegration())
       });
       return rows.map((row) => toGameTimebackIntegration(row));
     }
@@ -91420,7 +91728,7 @@ var init_timeback_service = __esm(async () => {
         const client = this.requireClient();
         await this.deps.validateGameManagementAccess(user, gameId);
         const rows = await this.deps.db.query.gameTimebackIntegrations.findMany({
-          where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.status, DEACTIVATED_GAME_TIMEBACK_INTEGRATION_STATUS)),
+          where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.status, DEACTIVATED_GAME_TIMEBACK_INTEGRATION_STATUS), isBaseGameTimebackIntegration()),
           orderBy: (table, { asc }) => [asc(table.subject), asc(table.grade)]
         });
         setAttribute("app.timeback.removed_integration_count", rows.length);
@@ -91451,6 +91759,17 @@ var init_timeback_service = __esm(async () => {
           if (!integration) {
             throw new NotFoundError("Timeback course", `${gameId}:${courseId}`);
           }
+          if (integration.kind === HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND) {
+            throw new ConflictError("This is a hole-filling course and may be referenced by Timeback, so it can't be removed.");
+          }
+          const activeHoleFilling = await database.query.gameTimebackIntegrations.findFirst({
+            columns: { id: true },
+            where: and(eq(gameTimebackIntegrations.baseIntegrationId, integration.id), isActiveGameTimebackIntegrationStatus())
+          });
+          if (activeHoleFilling) {
+            setAttribute("app.timeback.removal_blocked", "hole_filling_courses");
+            throw new ConflictError("This course has hole-filling courses that may be referenced by Timeback, so it can't be removed.");
+          }
           const activeEnrollments = await client.roster.getCourseRoster(courseId, {
             role: "student",
             includeUsers: false
@@ -91488,11 +91807,18 @@ var init_timeback_service = __esm(async () => {
           if (!integration) {
             throw new NotFoundError("Removed Timeback course", `${gameId}:${courseId}`);
           }
-          const activeConflict = await database.query.gameTimebackIntegrations.findFirst({
-            where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, integration.grade), eq(gameTimebackIntegrations.subject, integration.subject), isActiveGameTimebackIntegrationStatus())
-          });
-          if (activeConflict) {
-            throw new ConflictError(`An active TimeBack course already exists for ${integration.subject} Grade ${integration.grade}`);
+          if (integration.kind === HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND) {
+            const base = integration.baseIntegrationId ? await findGameTimebackIntegrationForUpdate(database, and(eq(gameTimebackIntegrations.id, integration.baseIntegrationId), isActiveBaseGameTimebackIntegration())) : undefined;
+            if (!base) {
+              throw new ConflictError("Restore the base course first: a hole-filling course can only be active beside its base course.");
+            }
+          } else {
+            const activeConflict = await database.query.gameTimebackIntegrations.findFirst({
+              where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, integration.grade), eq(gameTimebackIntegrations.subject, integration.subject), isActiveBaseGameTimebackIntegration())
+            });
+            if (activeConflict) {
+              throw new ConflictError(`An active TimeBack course already exists for ${integration.subject} Grade ${integration.grade}`);
+            }
           }
           const now = new Date;
           const [updatedIntegration] = await database.update(gameTimebackIntegrations).set({
@@ -91531,52 +91857,66 @@ var init_timeback_service = __esm(async () => {
         TimebackService.recordIntegrationOperation("update_integration", {
           "app.timeback.course_id": courseId
         });
-        const integration = await this.deps.db.query.gameTimebackIntegrations.findFirst({
-          where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.courseId, courseId), isActiveGameTimebackIntegrationStatus())
-        });
-        if (!integration) {
-          throw new NotFoundError("Timeback integration", `${gameId}:${courseId}`);
-        }
-        const timebackConfig = await client.course.getConfig(courseId);
-        const liveSubject = timebackConfig.course.subjects[0];
-        const subject = resolveIntegrationSubject(patch.subject, liveSubject, integration.subject);
-        if (!isTimebackSubject(subject)) {
-          throw new ValidationError(`Invalid subject "${subject}"`);
-        }
-        setAttributes({
-          "app.timeback.grade": integration.grade,
-          "app.timeback.previous_subject": integration.subject,
-          "app.timeback.next_subject": subject
-        });
-        if (subject !== integration.subject) {
-          const subjectConflict = await this.deps.db.query.gameTimebackIntegrations.findFirst({
-            where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, integration.grade), eq(gameTimebackIntegrations.subject, subject), isActiveGameTimebackIntegrationStatus())
+        const updated = await this.deps.db.transaction(async (tx) => {
+          const database = tx;
+          const integration = await findGameTimebackIntegrationForUpdate(database, and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.courseId, courseId), isActiveGameTimebackIntegrationStatus()));
+          if (!integration) {
+            throw new NotFoundError("Timeback integration", `${gameId}:${courseId}`);
+          }
+          const timebackConfig = await client.course.getConfig(courseId);
+          const liveSubject = timebackConfig.course.subjects[0];
+          const subject = resolveIntegrationSubject(patch.subject, liveSubject, integration.subject);
+          if (!isTimebackSubject(subject)) {
+            throw new ValidationError(`Invalid subject "${subject}"`);
+          }
+          setAttributes({
+            "app.timeback.grade": integration.grade,
+            "app.timeback.previous_subject": integration.subject,
+            "app.timeback.next_subject": subject
           });
-          if (subjectConflict && subjectConflict.id !== integration.id) {
-            throw new ValidationError(`A TimeBack integration already exists for ${subject} Grade ${integration.grade}`);
+          if (subject !== integration.subject) {
+            if (integration.kind === HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND) {
+              throw new ValidationError("A hole-filling course must keep the subject of its base course");
+            }
+            const linkedHoleFilling = await database.query.gameTimebackIntegrations.findFirst({
+              columns: { id: true },
+              where: eq(gameTimebackIntegrations.baseIntegrationId, integration.id)
+            });
+            if (linkedHoleFilling) {
+              throw new ValidationError("This course has hole-filling courses, so its subject cannot change");
+            }
           }
-        }
-        const totalXp = "totalXp" in patch ? patch.totalXp ?? null : getTotalXpFromTimebackConfig(timebackConfig) ?? integration.totalXp ?? null;
-        const masterableUnits = "masterableUnits" in patch ? patch.masterableUnits ?? null : getMasterableUnitsFromTimebackConfig(timebackConfig);
-        setAttributes({
-          "app.timeback.total_xp": totalXp,
-          "app.timeback.masterable_units": masterableUnits
+          if (subject !== integration.subject) {
+            const subjectConflict = await database.query.gameTimebackIntegrations.findFirst({
+              where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, integration.grade), eq(gameTimebackIntegrations.subject, subject), isActiveBaseGameTimebackIntegration())
+            });
+            if (subjectConflict && subjectConflict.id !== integration.id) {
+              throw new ValidationError(`A TimeBack integration already exists for ${subject} Grade ${integration.grade}`);
+            }
+          }
+          const totalXp = "totalXp" in patch ? patch.totalXp ?? null : getTotalXpFromTimebackConfig(timebackConfig) ?? integration.totalXp ?? null;
+          const masterableUnits = "masterableUnits" in patch ? patch.masterableUnits ?? null : getMasterableUnitsFromTimebackConfig(timebackConfig);
+          setAttributes({
+            "app.timeback.total_xp": totalXp,
+            "app.timeback.masterable_units": masterableUnits
+          });
+          await client.course.update(courseId, TimebackService.patchTimebackConfig(timebackConfig, {
+            ...patch,
+            subject,
+            totalXp,
+            masterableUnits,
+            grade: integration.grade
+          }));
+          const [row] = await database.update(gameTimebackIntegrations).set({
+            subject,
+            totalXp,
+            updatedAt: new Date
+          }).where(eq(gameTimebackIntegrations.id, integration.id)).returning();
+          if (!row) {
+            throw new NotFoundError("Timeback integration", `${gameId}:${courseId}`);
+          }
+          return row;
         });
-        await client.course.update(courseId, TimebackService.patchTimebackConfig(timebackConfig, {
-          ...patch,
-          subject,
-          totalXp,
-          masterableUnits,
-          grade: integration.grade
-        }));
-        const [updated] = await this.deps.db.update(gameTimebackIntegrations).set({
-          subject,
-          totalXp,
-          updatedAt: new Date
-        }).where(eq(gameTimebackIntegrations.id, integration.id)).returning();
-        if (!updated) {
-          throw new NotFoundError("Timeback integration", `${gameId}:${courseId}`);
-        }
         return toGameTimebackIntegration(updated);
       });
     }
@@ -91587,7 +91927,7 @@ var init_timeback_service = __esm(async () => {
         await this.deps.validateDeveloperAccess(user, gameId);
         TimebackService.recordIntegrationOperation("verify_integration");
         const integrations = await db.query.gameTimebackIntegrations.findMany({
-          where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveGameTimebackIntegrationStatus())
+          where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveBaseGameTimebackIntegration())
         });
         if (integrations.length === 0) {
           throw new NotFoundError("Timeback integration", gameId);
@@ -91625,7 +91965,7 @@ var init_timeback_service = __esm(async () => {
         const client = this.requireClient();
         await this.deps.validateDeveloperAccess(user, gameId);
         const integration = await this.deps.db.query.gameTimebackIntegrations.findFirst({
-          where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveGameTimebackIntegrationStatus())
+          where: and(eq(gameTimebackIntegrations.gameId, gameId), isActiveBaseGameTimebackIntegration())
         });
         if (!integration) {
           throw new NotFoundError("Timeback integration", gameId);
@@ -91639,17 +91979,24 @@ var init_timeback_service = __esm(async () => {
         const db = this.deps.db;
         await this.deps.validateDeveloperAccess(user, gameId);
         TimebackService.recordIntegrationOperation("delete_integrations");
-        const integrations = await db.query.gameTimebackIntegrations.findMany({
-          where: eq(gameTimebackIntegrations.gameId, gameId)
+        await db.transaction(async (tx) => {
+          const database = tx;
+          await database.select({ id: gameTimebackIntegrations.id }).from(gameTimebackIntegrations).where(eq(gameTimebackIntegrations.gameId, gameId)).for("update");
+          const integrations = await database.select().from(gameTimebackIntegrations).where(eq(gameTimebackIntegrations.gameId, gameId));
+          if (integrations.length === 0) {
+            throw new NotFoundError("Timeback integration", gameId);
+          }
+          setAttribute("app.timeback.integration_count", integrations.length);
+          const holeFillingCount = integrations.filter((integration) => integration.kind === HOLE_FILLING_GAME_TIMEBACK_INTEGRATION_KIND).length;
+          if (holeFillingCount > 0) {
+            setAttribute("app.timeback.hole_filling_count", holeFillingCount);
+            throw new ConflictError(`This game has ${holeFillingCount} hole-filling course(s) that may be referenced by Timeback, so its Timeback courses can't be removed automatically. Contact a Playcademy admin.`);
+          }
+          for (const integration of integrations) {
+            await client.course.cleanup(integration.courseId);
+          }
+          await database.delete(gameTimebackIntegrations).where(eq(gameTimebackIntegrations.gameId, gameId));
         });
-        if (integrations.length === 0) {
-          throw new NotFoundError("Timeback integration", gameId);
-        }
-        setAttribute("app.timeback.integration_count", integrations.length);
-        for (const integration of integrations) {
-          await client.course.cleanup(integration.courseId);
-        }
-        await db.delete(gameTimebackIntegrations).where(eq(gameTimebackIntegrations.gameId, gameId));
       });
     }
     static patchCourseMetadata(metadata2, totalXp, options) {
@@ -91828,17 +92175,21 @@ var init_timeback_service = __esm(async () => {
           activityData
         });
         await this.deps.validateDeveloperAccess(user, gameId);
-        const integration = await db.query.gameTimebackIntegrations.findFirst({
-          where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, activityData.grade), eq(gameTimebackIntegrations.subject, activityData.subject), isActiveGameTimebackIntegrationStatus())
-        });
-        if (!integration) {
-          throw new NotFoundError(`Timeback integration for game (grade ${activityData.grade}, subject ${activityData.subject})`);
-        }
         const {
+          integration,
           courseId: runtimeCourseId,
+          baseCourseId,
+          otherCourseIds,
           courseName: runtimeCourseName,
+          extensions: runtimeExtensions,
           attributes: courseAttributes
-        } = TimebackService.resolveRuntimeCourse(integration.courseId, activityData.courseId, activityData.courseName);
+        } = await this.resolveRuntimeCourse({
+          gameId,
+          studentId,
+          runId,
+          activityData,
+          extensions: extensionsWithResumeId
+        });
         const scorePercentage = scoreData.totalQuestions > 0 ? scoreData.correctQuestions / scoreData.totalQuestions * 100 : 0;
         const dedupeKey = runId !== undefined ? {
           gameId,
@@ -91867,12 +92218,12 @@ var init_timeback_service = __esm(async () => {
           courseId: runtimeCourseId,
           courseName: runtimeCourseName,
           studentEmail: activityData.studentEmail,
-          extensions: extensionsWithResumeId,
+          extensions: runtimeExtensions,
           ...runId ? { runId } : {}
         };
-        const completionEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "completion") : undefined;
-        const sessionEndEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "session-end", effectiveResumeId) : undefined;
-        const completionHistoryEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "course-completed") : undefined;
+        const completionEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "completion", baseCourseId) : undefined;
+        const sessionEndEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "session-end", baseCourseId, effectiveResumeId) : undefined;
+        const completionHistoryEventId = dedupeKey ? TimebackService.buildCompletionCaliperEventId(dedupeKey, "course-completed", baseCourseId) : undefined;
         function emitRecord() {
           return client.activity.record(runtimeCourseId, studentId, {
             ...activityEventContext,
@@ -91896,7 +92247,7 @@ var init_timeback_service = __esm(async () => {
             xpAwarded: emitted.xpAwarded,
             masteredUnitsApplied: emitted.masteredUnitsApplied,
             pctCompleteApp: emitted.pctCompleteApp ?? null
-          }));
+          }), otherCourseIds);
           if (outcome.status === "duplicate") {
             blockedByDedupeGuard = true;
             duplicateAward = outcome.award;
@@ -91944,6 +92295,7 @@ var init_timeback_service = __esm(async () => {
           return {
             status: "ok",
             courseId: runtimeCourseId,
+            courseKind: integration.kind,
             xpAwarded: duplicateAward?.xpAwarded ?? 0,
             masteredUnits: duplicateAward?.masteredUnitsApplied ?? 0,
             ...duplicateAward?.pctCompleteApp != null ? { pctCompleteApp: duplicateAward.pctCompleteApp } : {},
@@ -91956,6 +92308,7 @@ var init_timeback_service = __esm(async () => {
         return {
           status: "ok",
           courseId: runtimeCourseId,
+          courseKind: integration.kind,
           xpAwarded: result.xpAwarded,
           masteredUnits: result.masteredUnitsApplied,
           pctCompleteApp: result.pctCompleteApp,
@@ -91972,7 +92325,7 @@ var init_timeback_service = __esm(async () => {
       const client = this.requireClient();
       const db = this.deps.db;
       const integrations = await db.query.gameTimebackIntegrations.findMany({
-        where: subject ? and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.subject, subject), isActiveGameTimebackIntegrationStatus()) : and(eq(gameTimebackIntegrations.gameId, gameId), isActiveGameTimebackIntegrationStatus())
+        where: and(eq(gameTimebackIntegrations.gameId, gameId), subject ? eq(gameTimebackIntegrations.subject, subject) : undefined, isActiveBaseGameTimebackIntegration())
       });
       if (integrations.length === 0) {
         throw new NotFoundError(subject ? `Timeback integrations for game (subject ${subject})` : "Timeback integrations for game");
@@ -92132,7 +92485,6 @@ var init_timeback_service = __esm(async () => {
     }) {
       return this.withClientTelemetry(async () => {
         const client = this.requireClient();
-        const db = this.deps.db;
         const hasWindowStartedAtMs = windowStartedAtMs !== undefined;
         const hasWindowSequence = windowSequence !== undefined;
         if (hasWindowStartedAtMs === hasWindowSequence) {
@@ -92160,17 +92512,17 @@ var init_timeback_service = __esm(async () => {
           return inFlightHeartbeat;
         }
         const pendingHeartbeat = (async () => {
-          const integration = await db.query.gameTimebackIntegrations.findFirst({
-            where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.grade, activityData.grade), eq(gameTimebackIntegrations.subject, activityData.subject), isActiveGameTimebackIntegrationStatus())
-          });
-          if (!integration) {
-            throw new NotFoundError(`Timeback integration for game (grade ${activityData.grade}, subject ${activityData.subject})`);
-          }
           const {
             courseId: runtimeCourseId,
             courseName: runtimeCourseName,
+            extensions: runtimeExtensions,
             attributes: courseAttributes
-          } = TimebackService.resolveRuntimeCourse(integration.courseId, activityData.courseId, activityData.courseName);
+          } = await this.resolveRuntimeCourse({
+            gameId,
+            studentId,
+            activityData,
+            extensions: TimebackService.addResumeIdToExtensions(undefined, effectiveResumeId)
+          });
           const activeTimeSeconds = timingData.activeMs / 1000;
           const inactiveTimeSeconds = timingData.pausedMs / 1000;
           if (activeTimeSeconds > 0 || inactiveTimeSeconds > 0) {
@@ -92186,7 +92538,7 @@ var init_timeback_service = __esm(async () => {
               courseId: runtimeCourseId,
               courseName: runtimeCourseName,
               studentEmail: activityData.studentEmail,
-              extensions: TimebackService.addResumeIdToExtensions(undefined, effectiveResumeId),
+              extensions: runtimeExtensions,
               ...runId ? { runId } : {}
             });
           }
@@ -92291,7 +92643,7 @@ var init_timeback_service = __esm(async () => {
         const db = this.deps.db;
         await this.deps.validateDeveloperAccess(user, options.gameId);
         const integration = await db.query.gameTimebackIntegrations.findFirst({
-          where: and(eq(gameTimebackIntegrations.gameId, options.gameId), eq(gameTimebackIntegrations.subject, options.subject), isActiveGameTimebackIntegrationStatus())
+          where: and(eq(gameTimebackIntegrations.gameId, options.gameId), eq(gameTimebackIntegrations.subject, options.subject), isActiveBaseGameTimebackIntegration())
         });
         if (!integration) {
           throw new ValidationError(`Subject "${options.subject}" is not configured for game ${options.gameId}`);
@@ -93160,9 +93512,47 @@ var init_account_service = __esm(async () => {
   await init_errors8();
 });
 
+// ../api-core/src/services/embed-partner.service.ts
+class EmbedPartnerService {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async ensurePartner(clientId, name2) {
+    const [partner] = await this.deps.db.insert(embedPartners).values({ clientId, name: name2 }).onConflictDoUpdate({
+      target: embedPartners.clientId,
+      set: { name: name2, updatedAt: new Date }
+    }).returning();
+    if (!partner) {
+      throw new InternalError("Failed to ensure embed partner");
+    }
+    return partner;
+  }
+  addOrigin(clientId, origin) {
+    return this.setOrigins(clientId, sql`CASE WHEN ${origin} = ANY(${embedPartners.allowedOrigins})
+                THEN ${embedPartners.allowedOrigins}
+                ELSE array_append(${embedPartners.allowedOrigins}, ${origin}) END`);
+  }
+  removeOrigin(clientId, origin) {
+    return this.setOrigins(clientId, sql`array_remove(${embedPartners.allowedOrigins}, ${origin})`);
+  }
+  async setOrigins(clientId, origins) {
+    const [partner] = await this.deps.db.update(embedPartners).set({ allowedOrigins: origins, updatedAt: new Date }).where(eq(embedPartners.clientId, clientId)).returning();
+    if (!partner) {
+      throw new NotFoundError("Embed partner", clientId);
+    }
+    return partner;
+  }
+}
+var init_embed_partner_service = __esm(() => {
+  init_drizzle_orm();
+  init_tables_index();
+  init_errors2();
+});
+
 // ../api-core/src/utils/embed.util.ts
-function canPartnerLaunch(partner, origin, gameId) {
-  return partner.enabled && partner.allowedOrigins.includes(origin) && partner.games.some((grant) => grant.gameId === gameId);
+function canPartnerLaunch(partner, origin) {
+  return partner.enabled && partner.allowedOrigins.includes(origin);
 }
 function embedPageUrl(hubOrigin, slug, parentOrigin) {
   const url = new URL(`${EMBED_PAGE_PATH}/${encodeURIComponent(slug)}`, hubOrigin);
@@ -93190,12 +93580,9 @@ class EmbedService {
     return partner;
   }
   async isFrameOriginAllowed(origin, slug) {
-    const grants = await this.deps.db.select({
-      enabled: embedPartners.enabled,
-      allowedOrigins: embedPartners.allowedOrigins,
-      gameId: embedPartnerGames.gameId
-    }).from(embedPartnerGames).innerJoin(embedPartners, eq(embedPartners.id, embedPartnerGames.partnerId)).innerJoin(games, eq(games.id, embedPartnerGames.gameId)).where(eq(games.slug, slug));
-    return grants.some((grant) => canPartnerLaunch({ ...grant, games: [grant] }, origin, grant.gameId));
+    const game = this.deps.db.select({ id: games.id }).from(games).where(eq(games.slug, slug));
+    const [partner] = await this.deps.db.select({ id: embedPartners.id }).from(embedPartners).where(and(eq(embedPartners.enabled, true), arrayContains(embedPartners.allowedOrigins, [origin]), exists(game))).limit(1);
+    return partner !== undefined;
   }
   async createLaunch(partner, input) {
     const game = await this.deps.db.query.games.findFirst({
@@ -93206,9 +93593,8 @@ class EmbedService {
       throw new NotFoundError("Game", input.gameSlug);
     }
     setAttributes({ "app.game.id": game.id, "app.game.slug": game.slug });
-    const grants = await this.grantsFor(partner.id, game.id);
-    if (!canPartnerLaunch({ ...partner, games: grants }, input.parentOrigin, game.id)) {
-      throw new AccessDeniedError("This partner may not launch that game into that origin");
+    if (!canPartnerLaunch(partner, input.parentOrigin)) {
+      throw new AccessDeniedError("This partner may not launch into that origin");
     }
     setAttributes({ "app.user.timeback_id": input.timebackId });
     const user = await this.deps.resolveTimebackStudent(input.timebackId);
@@ -93270,20 +93656,13 @@ class EmbedService {
       throw new NotFoundError("Embed launch", launchId);
     }
     setAttributes({ "app.game.id": launch.gameId, "app.user.id": launch.userId });
-    const grants = await this.grantsFor(partner.id, launch.gameId);
-    const outcome = renewalRefusal(launch, () => canPartnerLaunch({ ...partner, games: grants }, launch.parentOrigin, launch.gameId));
+    const outcome = renewalRefusal(launch, () => canPartnerLaunch(partner, launch.parentOrigin));
     setAttributes({ "app.embed.outcome": outcome ?? "renewed" });
     if (outcome) {
       throw new AccessDeniedError("This launch has ended");
     }
     return this.deps.mintGameToken(launch.gameId, launch.userId);
   }
-  grantsFor(partnerId, gameId) {
-    return this.deps.db.query.embedPartnerGames.findMany({
-      where: and(eq(embedPartnerGames.partnerId, partnerId), eq(embedPartnerGames.gameId, gameId)),
-      columns: { gameId: true }
-    });
-  }
   async endLaunch(launchId) {
     await this.deps.db.update(embedLaunches).set({ endedAt: sql`coalesce(${embedLaunches.endedAt}, now())`, passHash: null }).where(eq(embedLaunches.id, launchId));
   }
@@ -93300,15 +93679,12 @@ class EmbedService {
       "app.embed.partner_id": launch.partnerId,
       "app.user.id": launch.userId
     });
-    const [partner, grants] = await Promise.all([
-      this.deps.db.query.embedPartners.findFirst({
-        where: eq(embedPartners.id, launch.partnerId),
-        columns: { enabled: true, allowedOrigins: true }
-      }),
-      this.grantsFor(launch.partnerId, launch.gameId)
-    ]);
+    const partner = await this.deps.db.query.embedPartners.findFirst({
+      where: eq(embedPartners.id, launch.partnerId),
+      columns: { enabled: true, allowedOrigins: true }
+    });
     const originMatches = launch.parentOrigin === input.parentOrigin;
-    const stillAllowed = partner !== undefined && canPartnerLaunch({ ...partner, games: grants }, launch.parentOrigin, launch.gameId);
+    const stillAllowed = partner !== undefined && canPartnerLaunch(partner, launch.parentOrigin);
     if (!originMatches || !stillAllowed) {
       await this.endLaunch(launch.id);
       setAttributes({
@@ -93726,14 +94102,16 @@ function createStandaloneServices(deps) {
       return { ...profile, timeback: timebackData };
     }
   });
+  const embedPartner = new EmbedPartnerService({ db });
   const verify = new VerifyService({
     db,
     validateGameToken: auth.validateGameToken.bind(auth)
   });
-  return { account, embed, lti, session, user, verify };
+  return { account, embed, embedPartner, lti, session, user, verify };
 }
 var init_standalone = __esm(async () => {
   init_spans();
+  init_embed_partner_service();
   init_embed_service();
   init_lti_service();
   init_session_service();
@@ -110178,7 +110556,7 @@ function ilike2(column6, value) {
 function notIlike2(column6, value) {
   return sql4`${column6} not ilike ${value}`;
 }
-function arrayContains(column6, values) {
+function arrayContains2(column6, values) {
   if (Array.isArray(values)) {
     if (values.length === 0) {
       throw new Error("arrayContains requires at least one value");
@@ -133497,7 +133875,7 @@ params: ${params}`);
     and: () => and2,
     applyMixins: () => applyMixins2,
     arrayContained: () => arrayContained,
-    arrayContains: () => arrayContains,
+    arrayContains: () => arrayContains2,
     arrayOverlaps: () => arrayOverlaps,
     asc: () => asc2,
     avg: () => avg,
@@ -150067,15 +150445,36 @@ function requireUuidParam(value, name2) {
   }
   return value;
 }
+function bearerToken(request) {
+  const header = request.headers.get("Authorization");
+  return header?.startsWith("Bearer ") ? header.slice("Bearer ".length) : "";
+}
 async function requirePartner(ctx) {
-  const header = ctx.request.headers.get("Authorization");
-  const token = header?.startsWith("Bearer ") ? header.slice("Bearer ".length) : "";
+  const token = bearerToken(ctx.request);
   const verified = token ? await ctx.providers.auth.verifyEmbedPartnerToken(token) : null;
   if (!verified) {
     throw ApiError.unauthorized("A valid embed partner access token is required");
   }
   return ctx.services.embed.getPartnerByClientId(verified.clientId);
 }
+async function requireEmbedAdmin(ctx) {
+  const expected = ctx.config.embedAdminToken;
+  if (!expected) {
+    throw ApiError.serviceUnavailable("Embed partner management is not configured");
+  }
+  const token = bearerToken(ctx.request);
+  const [given, wanted] = token ? await Promise.all([sha256Hex(token), sha256Hex(expected)]) : [];
+  if (!given || given !== wanted) {
+    throw ApiError.unauthorized("A valid embed admin token is required");
+  }
+}
+function requireClientIdParam(ctx) {
+  const clientId = EmbedPartnerClientIdSchema.safeParse(ctx.params.clientId);
+  if (!clientId.success) {
+    throw ApiError.badRequest("Missing or invalid clientId");
+  }
+  return clientId.data;
+}
 async function createLaunch(ctx) {
   const partner = await requirePartner(ctx);
   const body2 = await parseRequestBody(ctx.request, CreateEmbedLaunchSchema);
@@ -150105,6 +150504,27 @@ async function redeemPass(ctx) {
     timeback: launch.profile.timeback
   };
 }
+async function ensurePartner(ctx) {
+  await requireEmbedAdmin(ctx);
+  const clientId = requireClientIdParam(ctx);
+  const body2 = await parseRequestBody(ctx.request, EnsureEmbedPartnerSchema);
+  return ctx.services.embedPartner.ensurePartner(clientId, body2.name);
+}
+async function addPartnerOrigin(ctx) {
+  await requireEmbedAdmin(ctx);
+  const clientId = requireClientIdParam(ctx);
+  const body2 = await parseRequestBody(ctx.request, AddEmbedPartnerOriginSchema);
+  return ctx.services.embedPartner.addOrigin(clientId, body2.origin);
+}
+async function removePartnerOrigin(ctx) {
+  await requireEmbedAdmin(ctx);
+  const clientId = requireClientIdParam(ctx);
+  const origin = EmbedOriginSchema.safeParse(ctx.url.searchParams.get("origin"));
+  if (!origin.success) {
+    throw ApiError.badRequest("Missing or invalid origin");
+  }
+  return ctx.services.embedPartner.removeOrigin(clientId, origin.data);
+}
 var embed2;
 var init_embed_controller = __esm(() => {
   init_src();
@@ -150114,8 +150534,11 @@ var init_embed_controller = __esm(() => {
   init_utils7();
   init_embed_util();
   embed2 = defineControllerNames("embed", {
+    addPartnerOrigin,
     createLaunch,
+    ensurePartner,
     redeemPass,
+    removePartnerOrigin,
     renewToken
   });
 });
@@ -150722,7 +151145,7 @@ function parseQtiLibraryParams(searchParams) {
     limit
   };
 }
-var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, prepareRuntimeAssessment, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, resumeRuntimeAssessment, saveRuntimeAssessment, recordRuntimeAssessmentProgress, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, reviseAssessment, synchronizeReviewBank, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
+var populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, getRemovedIntegrations, createIntegration, getHoleFillingCourses, createHoleFillingCourse, updateIntegration, deactivateCourse, reactivateCourse, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, prepareRuntimeAssessment, startRuntimeAssessment, getRuntimeAssessment, getLatestRuntimeAssessment, resumeRuntimeAssessment, saveRuntimeAssessment, recordRuntimeAssessmentProgress, submitRuntimeAssessmentItem, submitRuntimeAssessment, finalizeRuntimeAssessment, exportRuntimeAssessmentFixture, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getGradeLevelTestResults, getGradeLevelTestReview, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, attachExistingAssessments, updateAssessment, reviseAssessment, synchronizeReviewBank, reorderQuestions, removeAssessment, listQuestions, listQuestionLibrary, listTestLibrary, copyAssessment, createQuestion, updateQuestion, removeQuestion, timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
   init_src();
@@ -150801,6 +151224,27 @@ var init_timeback_controller = __esm(() => {
     const body2 = await parseRequestBody(ctx.request, CreateGameTimebackIntegrationRequestSchema);
     return ctx.services.timeback.createIntegration(gameId, ctx.user, body2);
   });
+  getHoleFillingCourses = requireGameManagementAccess(async (ctx) => {
+    const gameId = ctx.params.gameId;
+    if (!gameId) {
+      throw ApiError.badRequest("Missing gameId");
+    }
+    if (!isValidUUID(gameId)) {
+      throw ApiError.unprocessableEntity("Invalid gameId format");
+    }
+    return ctx.services.timeback.getHoleFillingCourses(gameId, ctx.user);
+  });
+  createHoleFillingCourse = requireDeveloper(async (ctx) => {
+    const gameId = ctx.params.gameId;
+    if (!gameId) {
+      throw ApiError.badRequest("Missing gameId");
+    }
+    if (!isValidUUID(gameId)) {
+      throw ApiError.unprocessableEntity("Invalid gameId format");
+    }
+    const body2 = await parseRequestBody(ctx.request, CreateGameTimebackHoleFillingCourseRequestSchema);
+    return ctx.services.timeback.createHoleFillingCourse(gameId, ctx.user, body2);
+  });
   updateIntegration = requireDeveloper(async (ctx) => {
     const { gameId, courseId } = ctx.params;
     if (!gameId || !courseId) {
@@ -151585,6 +152029,8 @@ var init_timeback_controller = __esm(() => {
     getIntegrations,
     getRemovedIntegrations,
     createIntegration,
+    getHoleFillingCourses,
+    createHoleFillingCourse,
     updateIntegration,
     deactivateCourse,
     reactivateCourse,