dabke 0.82.0 → 0.84.0

package/src/cpsat/rules/overtime-weekly-surcharge.ts

@@ -1,27 +1,26 @@
 import * as z from "zod";
 import { DayOfWeekSchema } from "../../types.js";
-import type { CompilationRule, CostContribution } from "../model-builder.js";
-import type { ShiftPattern, SchedulingMember, Term } from "../types.js";
-import type { ShiftAssignment } from "../response.js";
+import { defineRuleDescriptor } from "../rule-descriptor.js";
+import type { CostArtifact } from "../rule-descriptor.js";
 import { COST_CATEGORY } from "../cost.js";
 import {
-  timeOfDayToMinutes,
+  OBJECTIVE_WEIGHTS,
   normalizeEndMinutes,
   splitIntoWeeks,
+  timeOfDayToMinutes,
   unionMinutes,
-  OBJECTIVE_WEIGHTS,
 } from "../utils.js";
 import {
   entityScope,
-  timeScope,
   parseEntityScope,
   parseTimeScope,
-  resolveMembersFromScope,
   resolveActiveDaysFromScope,
+  resolveMembersFromScope,
+  timeScope,
 } from "./scope.types.js";
-import { patternDurationMinutes } from "./cost-utils.js";
+import { patternDurationMinutes } from "./pattern-time.js";
 
-const OvertimeWeeklySurchargeSchema = z
+export const OvertimeWeeklySurchargeSchema = z
   .object({
     after: z.number().min(0),
     amount: z.number().min(0),
@@ -30,156 +29,168 @@ const OvertimeWeeklySurchargeSchema = z
   .and(entityScope(["members", "roles", "skills"]))
   .and(timeScope(["dateRange", "specificDates", "dayOfWeek", "recurring"]));
 
-/** Configuration for {@link createOvertimeWeeklySurchargeRule}. */
+/** Configuration for {@link overtimeWeeklySurchargeRuleDescriptor}. */
 export type OvertimeWeeklySurchargeConfig = z.infer<typeof OvertimeWeeklySurchargeSchema>;
 
-/**
- * Creates a weekly overtime flat surcharge rule.
- *
- * Hours beyond the threshold per week get a flat surcharge per hour,
- * independent of the member's base rate.
- */
-export function createOvertimeWeeklySurchargeRule(
-  config: OvertimeWeeklySurchargeConfig,
-): CompilationRule {
-  const parsed = OvertimeWeeklySurchargeSchema.parse(config);
-  const { after, amount, weekStartsOn } = parsed;
-  const entityScopeValue = parseEntityScope(parsed);
-  const timeScopeValue = parseTimeScope(parsed);
-  const thresholdMinutes = after * 60;
-  let resolvedWeekStartsOn = weekStartsOn ?? "monday";
-
-  return {
-    compile(b) {
-      resolvedWeekStartsOn = weekStartsOn ?? b.weekStartsOn;
-      if (amount <= 0) return;
-
-      const targetMembers = resolveMembersFromScope(entityScopeValue, b.members);
-      const activeDays = resolveActiveDaysFromScope(timeScopeValue, b.days);
-
-      if (targetMembers.length === 0 || activeDays.length === 0) return;
-
-      const weeks = splitIntoWeeks(activeDays, weekStartsOn ?? b.weekStartsOn);
-
-      const hasCostContext = b.costContext?.active === true;
-      const surchargePerMinute = amount / 60;
-
-      for (const emp of targetMembers) {
-        for (const [weekIdx, weekDays] of weeks.entries()) {
-          let empWeekMaxMinutes = 0;
-          const terms: Term[] = [];
-          for (const day of weekDays) {
-            const dayRanges: Array<{ start: number; end: number }> = [];
-            for (const pattern of b.shiftPatterns) {
-              if (!b.canAssign(emp, pattern)) continue;
-              if (!b.patternAvailableOnDay(pattern, day)) continue;
-              const start = timeOfDayToMinutes(pattern.startTime);
-              dayRanges.push({
-                start,
-                end: normalizeEndMinutes(start, timeOfDayToMinutes(pattern.endTime)),
-              });
-              terms.push({
-                var: b.assignment(emp.id, pattern.id, day),
-                coeff: patternDurationMinutes(pattern),
-              });
+export const overtimeWeeklySurchargeRuleDescriptor = defineRuleDescriptor({
+  name: "overtime-weekly-surcharge",
+  schema: OvertimeWeeklySurchargeSchema,
+  compile(config) {
+    const { after, amount, weekStartsOn } = config;
+    const entityScopeValue = parseEntityScope(config);
+    const timeScopeValue = parseTimeScope(config);
+    const thresholdMinutes = after * 60;
+    let resolvedWeekStartsOn = weekStartsOn ?? "monday";
+
+    const costArtifact: CostArtifact = {
+      kind: "cost",
+      validation: {
+        strategy: "skip",
+        category: "no-meaningful-feedback",
+        rationale:
+          "Overtime cost artifacts influence optimization and post-solve accounting, not validation feedback.",
+      },
+      compileObjective(builder) {
+        resolvedWeekStartsOn = weekStartsOn ?? builder.weekStartsOn;
+        if (amount <= 0) return;
+
+        const targetMembers = resolveMembersFromScope(entityScopeValue, builder.members);
+        const activeDays = resolveActiveDaysFromScope(timeScopeValue, builder.days);
+        if (targetMembers.length === 0 || activeDays.length === 0) return;
+
+        const weeks = splitIntoWeeks(activeDays, weekStartsOn ?? builder.weekStartsOn);
+        const hasCostContext = builder.costContext?.active === true;
+        const surchargePerMinute = amount / 60;
+
+        for (const member of targetMembers) {
+          for (const [weekIndex, weekDays] of weeks.entries()) {
+            let memberWeekMaxMinutes = 0;
+            const terms = [] as Array<{ var: string; coeff: number }>;
+
+            for (const day of weekDays) {
+              const dayRanges: Array<{ start: number; end: number }> = [];
+              for (const pattern of builder.shiftPatterns) {
+                if (
+                  !builder.canAssign(member, pattern) ||
+                  !builder.patternAvailableOnDay(pattern, day)
+                ) {
+                  continue;
+                }
+                const start = timeOfDayToMinutes(pattern.startTime);
+                dayRanges.push({
+                  start,
+                  end: normalizeEndMinutes(start, timeOfDayToMinutes(pattern.endTime)),
+                });
+                terms.push({
+                  var: builder.assignment(member.id, pattern.id, day),
+                  coeff: patternDurationMinutes(pattern),
+                });
+              }
+              memberWeekMaxMinutes += unionMinutes(dayRanges);
             }
-            empWeekMaxMinutes += unionMinutes(dayRanges);
-          }
 
-          if (terms.length === 0) continue;
-
-          const maxOvertime = Math.max(0, empWeekMaxMinutes - thresholdMinutes);
-          if (maxOvertime === 0) continue;
-
-          const overtimeVar = b.intVar(`overtime:surcharge:${emp.id}:w${weekIdx}`, 0, maxOvertime);
-
-          b.addLinear(
-            [
-              { var: overtimeVar, coeff: 1 },
-              ...terms.map((t) => ({ var: t.var, coeff: -t.coeff })),
-            ],
-            ">=",
-            -thresholdMinutes,
-          );
-
-          if (hasCostContext) {
-            const totalOvertimeCost = surchargePerMinute * maxOvertime;
-            const normalizedMax = totalOvertimeCost / b.costContext!.normalizationFactor;
-            b.addPenalty(overtimeVar, Math.max(1, Math.round(normalizedMax / maxOvertime)));
-          } else {
-            b.addPenalty(
-              overtimeVar,
-              Math.max(1, Math.round(OBJECTIVE_WEIGHTS.COST / maxOvertime)),
+            if (terms.length === 0) continue;
+            const maxOvertime = Math.max(0, memberWeekMaxMinutes - thresholdMinutes);
+            if (maxOvertime === 0) continue;
+
+            const overtimeVar = builder.intVar(
+              `overtime:surcharge:${member.id}:w${weekIndex}`,
+              0,
+              maxOvertime,
             );
+            builder.addLinear(
+              [
+                { var: overtimeVar, coeff: 1 },
+                ...terms.map((term) => ({ var: term.var, coeff: -term.coeff })),
+              ],
+              ">=",
+              -thresholdMinutes,
+            );
+
+            if (hasCostContext) {
+              const totalOvertimeCost = surchargePerMinute * maxOvertime;
+              const normalizedMax = totalOvertimeCost / builder.costContext!.normalizationFactor;
+              builder.addPenalty(overtimeVar, Math.max(1, Math.round(normalizedMax / maxOvertime)));
+            } else {
+              builder.addPenalty(
+                overtimeVar,
+                Math.max(1, Math.round(OBJECTIVE_WEIGHTS.COST / maxOvertime)),
+              );
+            }
           }
         }
-      }
-    },
-
-    cost(
-      assignments: ShiftAssignment[],
-      members: ReadonlyArray<SchedulingMember>,
-      shiftPatterns: ReadonlyArray<ShiftPattern>,
-    ): CostContribution {
-      if (amount <= 0) return { entries: [] };
-
-      const patternMap = new Map(shiftPatterns.map((p) => [p.id, p]));
-      const allDays = [...new Set(assignments.map((a) => a.day))].toSorted();
-      const activeDays = new Set(resolveActiveDaysFromScope(timeScopeValue, allDays));
-      const targetEmpIds = new Set(
-        resolveMembersFromScope(entityScopeValue, [...members]).map((e) => e.id),
-      );
-
-      const activeDaysList = allDays.filter((d) => activeDays.has(d));
-      const weeks = splitIntoWeeks(activeDaysList, resolvedWeekStartsOn);
-
-      const entries: CostContribution["entries"] = [];
-
-      for (const weekDays of weeks) {
-        const weekDaySet = new Set(weekDays);
-
-        const empWeekData = new Map<
-          string,
-          { totalMinutes: number; dayMinutes: Map<string, number> }
-        >();
-
-        for (const a of assignments) {
-          if (!weekDaySet.has(a.day)) continue;
-          if (!activeDays.has(a.day)) continue;
-          if (!targetEmpIds.has(a.memberId)) continue;
-
-          const pattern = patternMap.get(a.shiftPatternId);
-          if (!pattern) continue;
-          const duration = patternDurationMinutes(pattern);
-
-          let data = empWeekData.get(a.memberId);
-          if (!data) {
-            data = { totalMinutes: 0, dayMinutes: new Map() };
-            empWeekData.set(a.memberId, data);
+      },
+      calculateCost(assignments, costContext) {
+        if (amount <= 0) return { entries: [] };
+
+        const patternMap = new Map(
+          costContext.shiftPatterns.map((pattern) => [pattern.id, pattern]),
+        );
+        const activeDays = new Set(
+          resolveActiveDaysFromScope(timeScopeValue, [...costContext.days]).map((day) => day.iso),
+        );
+        const targetMemberIds = new Set(
+          resolveMembersFromScope(entityScopeValue, [...costContext.members]).map(
+            (member) => member.id,
+          ),
+        );
+        const activeDaysList = costContext.days.filter((day) => activeDays.has(day.iso));
+        const weeks = splitIntoWeeks(activeDaysList, resolvedWeekStartsOn);
+
+        const entries = [] as Array<{
+          memberId: string;
+          day: string;
+          category: string;
+          amount: number;
+        }>;
+        for (const weekDays of weeks) {
+          const weekDaySet = new Set(weekDays.map((day) => day.iso));
+          const memberWeekData = new Map<
+            string,
+            { totalMinutes: number; dayMinutes: Map<string, number> }
+          >();
+
+          for (const assignment of assignments) {
+            if (!weekDaySet.has(assignment.day) || !activeDays.has(assignment.day)) continue;
+            if (!targetMemberIds.has(assignment.memberId)) continue;
+            const pattern = patternMap.get(assignment.shiftPatternId);
+            if (!pattern) continue;
+            const duration = patternDurationMinutes(pattern);
+            let data = memberWeekData.get(assignment.memberId);
+            if (!data) {
+              data = { totalMinutes: 0, dayMinutes: new Map() };
+              memberWeekData.set(assignment.memberId, data);
+            }
+            data.totalMinutes += duration;
+            data.dayMinutes.set(
+              assignment.day,
+              (data.dayMinutes.get(assignment.day) ?? 0) + duration,
+            );
           }
-          data.totalMinutes += duration;
-          data.dayMinutes.set(a.day, (data.dayMinutes.get(a.day) ?? 0) + duration);
-        }
 
-        for (const [empId, data] of empWeekData) {
-          const overtimeMinutes = Math.max(0, data.totalMinutes - thresholdMinutes);
-          if (overtimeMinutes <= 0) continue;
-
-          const totalOvertimeCost = (amount * overtimeMinutes) / 60;
-
-          for (const [day, dayMinutes] of data.dayMinutes) {
-            const proportion = dayMinutes / data.totalMinutes;
-            entries.push({
-              memberId: empId,
-              day,
-              category: COST_CATEGORY.OVERTIME,
-              amount: totalOvertimeCost * proportion,
-            });
+          for (const [memberId, data] of memberWeekData) {
+            const overtimeMinutes = Math.max(0, data.totalMinutes - thresholdMinutes);
+            if (overtimeMinutes <= 0) continue;
+            const totalOvertimeCost = (amount * overtimeMinutes) / 60;
+            for (const [day, dayMinutes] of data.dayMinutes) {
+              const proportion = dayMinutes / data.totalMinutes;
+              entries.push({
+                memberId,
+                day,
+                category: COST_CATEGORY.OVERTIME,
+                amount: totalOvertimeCost * proportion,
+              });
+            }
           }
         }
-      }
 
-      return { entries };
-    },
-  };
-}
+        return { entries };
+      },
+    };
+
+    return {
+      rule: "overtime-weekly-surcharge",
+      artifacts: [costArtifact],
+    };
+  },
+});

package/src/cpsat/rules/pattern-eligibility.ts

@@ -0,0 +1,26 @@
+import type { SchedulingDay } from "../../types.js";
+import type { SchedulingMember, ShiftPattern } from "../types.js";
+
+export function canAssignMemberToPattern(member: SchedulingMember, pattern: ShiftPattern): boolean {
+  if (!pattern.roleIds || pattern.roleIds.length === 0) {
+    return true;
+  }
+  return pattern.roleIds.some((role) => member.roleIds.includes(role));
+}
+
+export function isPatternAvailableOnDay(pattern: ShiftPattern, day: SchedulingDay): boolean {
+  if (!pattern.dayOfWeek || pattern.dayOfWeek.length === 0) {
+    return true;
+  }
+  return pattern.dayOfWeek.includes(day.dayOfWeek);
+}
+
+export function hasAnyAssignablePattern(
+  member: SchedulingMember,
+  day: SchedulingDay,
+  shiftPatterns: readonly ShiftPattern[],
+): boolean {
+  return shiftPatterns.some(
+    (pattern) => canAssignMemberToPattern(member, pattern) && isPatternAvailableOnDay(pattern, day),
+  );
+}

package/src/cpsat/rules/pattern-time.ts

@@ -0,0 +1,30 @@
+import type { SchedulingDay } from "../../types.js";
+import type { SchedulingMember, ShiftPattern } from "../types.js";
+import { normalizeEndMinutes, timeOfDayToMinutes, unionMinutes } from "../utils.js";
+import { canAssignMemberToPattern, isPatternAvailableOnDay } from "./pattern-eligibility.js";
+
+export function patternDurationMinutes(pattern: ShiftPattern): number {
+  const start = timeOfDayToMinutes(pattern.startTime);
+  const end = normalizeEndMinutes(start, timeOfDayToMinutes(pattern.endTime));
+  return end - start;
+}
+
+export function maxAssignableMinutesForDay(
+  member: SchedulingMember,
+  day: SchedulingDay,
+  shiftPatterns: readonly ShiftPattern[],
+): number {
+  const ranges = shiftPatterns
+    .filter(
+      (pattern) =>
+        canAssignMemberToPattern(member, pattern) && isPatternAvailableOnDay(pattern, day),
+    )
+    .map((pattern) => {
+      const start = timeOfDayToMinutes(pattern.startTime);
+      return {
+        start,
+        end: normalizeEndMinutes(start, timeOfDayToMinutes(pattern.endTime)),
+      };
+    });
+  return unionMinutes(ranges);
+}

package/src/cpsat/rules/registry.ts

@@ -1,67 +1,151 @@
 import {
-  createAssignTogetherRule,
-  createAssignmentPriorityRule,
-  createLocationPreferenceRule,
-  createMaxConsecutiveDaysRule,
-  createMaxHoursDayRule,
-  createMaxHoursWeekRule,
-  createMaxShiftsDayRule,
-  createMinConsecutiveDaysRule,
-  createMinHoursDayRule,
-  createMinHoursWeekRule,
-  createMinRestBetweenShiftsRule,
-  createTimeOffRule,
-  createMinimizeCostRule,
-  createDayCostMultiplierRule,
-  createDayCostSurchargeRule,
-  createTimeCostSurchargeRule,
-  createOvertimeWeeklyMultiplierRule,
-  createOvertimeWeeklySurchargeRule,
-  createOvertimeDailyMultiplierRule,
-  createOvertimeDailySurchargeRule,
-  createOvertimeTieredMultiplierRule,
+  assignTogetherRuleDescriptor,
+  assignmentPriorityRuleDescriptor,
+  dayCostMultiplierRuleDescriptor,
+  dayCostSurchargeRuleDescriptor,
+  locationPreferenceRuleDescriptor,
+  maxConcurrentAssignmentsRuleDescriptor,
+  maxConsecutiveDaysRuleDescriptor,
+  maxDaysOfWeekPerPeriodRuleDescriptor,
+  maxDaysWeekRuleDescriptor,
+  maxHoursDayRuleDescriptor,
+  maxHoursWeekRuleDescriptor,
+  maxShiftsDayRuleDescriptor,
+  minConsecutiveDaysRuleDescriptor,
+  minDaysOfWeekPerPeriodRuleDescriptor,
+  minDaysWeekRuleDescriptor,
+  minHoursDayRuleDescriptor,
+  minHoursWeekRuleDescriptor,
+  minRestBetweenShiftsRuleDescriptor,
+  minimizeCostRuleDescriptor,
+  mustAssignRuleDescriptor,
+  overtimeDailyMultiplierRuleDescriptor,
+  overtimeDailySurchargeRuleDescriptor,
+  overtimeTieredMultiplierRuleDescriptor,
+  overtimeWeeklyMultiplierRuleDescriptor,
+  overtimeWeeklySurchargeRuleDescriptor,
+  rolePreferenceRuleDescriptor,
+  targetDaysWeekRuleDescriptor,
+  targetPeakConcurrentAssignmentsRuleDescriptor,
+  timeCostSurchargeRuleDescriptor,
+  timeOffRuleDescriptor,
 } from "./index.js";
-import type {
-  BuiltInCpsatRuleFactories,
-  CpsatRuleFactories,
-  CpsatRuleName,
-} from "./rules.types.js";
+import type { BuiltInCpsatRuleRegistry, CpsatRuleName, CpsatRuleRegistry } from "./rules.types.js";
 
-export const builtInCpsatRuleFactories = {
-  "assign-together": createAssignTogetherRule,
-  "assignment-priority": createAssignmentPriorityRule,
-  "location-preference": createLocationPreferenceRule,
-  "max-consecutive-days": createMaxConsecutiveDaysRule,
-  "max-hours-day": createMaxHoursDayRule,
-  "max-hours-week": createMaxHoursWeekRule,
-  "max-shifts-day": createMaxShiftsDayRule,
-  "min-consecutive-days": createMinConsecutiveDaysRule,
-  "min-hours-day": createMinHoursDayRule,
-  "min-hours-week": createMinHoursWeekRule,
-  "min-rest-between-shifts": createMinRestBetweenShiftsRule,
-  "time-off": createTimeOffRule,
-  "minimize-cost": createMinimizeCostRule,
-  "day-cost-multiplier": createDayCostMultiplierRule,
-  "day-cost-surcharge": createDayCostSurchargeRule,
-  "time-cost-surcharge": createTimeCostSurchargeRule,
-  "overtime-weekly-multiplier": createOvertimeWeeklyMultiplierRule,
-  "overtime-weekly-surcharge": createOvertimeWeeklySurchargeRule,
-  "overtime-daily-multiplier": createOvertimeDailyMultiplierRule,
-  "overtime-daily-surcharge": createOvertimeDailySurchargeRule,
-  "overtime-tiered-multiplier": createOvertimeTieredMultiplierRule,
-} satisfies BuiltInCpsatRuleFactories;
+/**
+ * Validates that each rule registry key matches the descriptor name it points to.
+ *
+ * @remarks
+ * This enforces the invariant required by registry-driven config typing and by
+ * runtime rule resolution. A registry entry like `{ debug: descriptorNamedFoo }`
+ * is rejected because the key and descriptor identity diverge.
+ *
+ * @category Rules
+ */
+export function assertValidCpsatRuleRegistry<Registry extends CpsatRuleRegistry>(
+  ruleRegistry: Registry,
+): Registry {
+  for (const [key, descriptor] of Object.entries(ruleRegistry)) {
+    if (descriptor.name !== key) {
+      throw new Error(
+        `Registered CP-SAT rule descriptor key "${key}" must match descriptor.name "${descriptor.name}".`,
+      );
+    }
+  }
+
+  return ruleRegistry;
+}
 
 /**
- * Creates a rule factory map, preventing overriding built-in rules.
+ * Validates that a registry does not shadow built-in rule names with different descriptors.
+ *
+ * @remarks
+ * A registry may reuse the exact built-in descriptor instance under the same name,
+ * but it may not replace a built-in rule with an incompatible descriptor.
  */
-export function createCpsatRuleFactory<F extends CpsatRuleFactories>(factories: F): F {
-  for (const name in factories) {
+export function assertNoBuiltInCpsatRuleOverrides<Registry extends CpsatRuleRegistry>(
+  ruleRegistry: Registry,
+): Registry {
+  for (const name in ruleRegistry) {
     if (
-      name in builtInCpsatRuleFactories &&
-      factories[name] !== builtInCpsatRuleFactories[name as CpsatRuleName]
+      name in builtInCpsatRuleRegistry &&
+      ruleRegistry[name] !== builtInCpsatRuleRegistry[name as CpsatRuleName]
     ) {
-      throw new Error(`Cannot override built-in CP-SAT rule "${name}" in custom factory`);
+      throw new Error(`Cannot override built-in CP-SAT rule "${name}" in custom registry`);
     }
   }
-  return factories;
+
+  return ruleRegistry;
 }
+
+/**
+ * Creates a custom CP-SAT rule registry.
+ *
+ * @remarks
+ * Built-in rule names cannot be redefined unless the registry entry points to
+ * the exact same built-in descriptor instance.
+ *
+ * @example
+ * ```ts
+ * const debugRuleRegistry = createCpsatRuleRegistry({
+ *   debug: defineRuleDescriptor({
+ *     name: "debug",
+ *     schema: z.object({ flag: z.boolean() }),
+ *     compile() {
+ *       return { rule: "debug", artifacts: [] };
+ *     },
+ *   }),
+ * });
+ * ```
+ *
+ * @category Rules
+ */
+export function createCpsatRuleRegistry<Registry extends CpsatRuleRegistry>(
+  ruleRegistry: Registry,
+): Registry {
+  assertNoBuiltInCpsatRuleOverrides(ruleRegistry);
+  return assertValidCpsatRuleRegistry(ruleRegistry);
+}
+
+/**
+ * The built-in CP-SAT rule registry.
+ *
+ * @remarks
+ * Pass this to {@link defineRuleFor} when you want registry-bound authoring for
+ * built-in rules, or spread it into a larger registry when building a fully
+ * explicit descriptor set.
+ *
+ * @category Rules
+ */
+export const builtInCpsatRuleRegistry = assertValidCpsatRuleRegistry({
+  "assign-together": assignTogetherRuleDescriptor,
+  "assignment-priority": assignmentPriorityRuleDescriptor,
+  "location-preference": locationPreferenceRuleDescriptor,
+  "role-preference": rolePreferenceRuleDescriptor,
+  "max-concurrent-assignments": maxConcurrentAssignmentsRuleDescriptor,
+  "target-peak-concurrent-assignments": targetPeakConcurrentAssignmentsRuleDescriptor,
+  "target-days-week": targetDaysWeekRuleDescriptor,
+  "max-consecutive-days": maxConsecutiveDaysRuleDescriptor,
+  "max-days-week": maxDaysWeekRuleDescriptor,
+  "max-hours-day": maxHoursDayRuleDescriptor,
+  "max-hours-week": maxHoursWeekRuleDescriptor,
+  "max-shifts-day": maxShiftsDayRuleDescriptor,
+  "min-consecutive-days": minConsecutiveDaysRuleDescriptor,
+  "min-days-week": minDaysWeekRuleDescriptor,
+  "min-hours-day": minHoursDayRuleDescriptor,
+  "min-hours-week": minHoursWeekRuleDescriptor,
+  "min-rest-between-shifts": minRestBetweenShiftsRuleDescriptor,
+  "must-assign": mustAssignRuleDescriptor,
+  "time-off": timeOffRuleDescriptor,
+  "minimize-cost": minimizeCostRuleDescriptor,
+  "day-cost-multiplier": dayCostMultiplierRuleDescriptor,
+  "day-cost-surcharge": dayCostSurchargeRuleDescriptor,
+  "time-cost-surcharge": timeCostSurchargeRuleDescriptor,
+  "overtime-weekly-multiplier": overtimeWeeklyMultiplierRuleDescriptor,
+  "overtime-weekly-surcharge": overtimeWeeklySurchargeRuleDescriptor,
+  "overtime-daily-multiplier": overtimeDailyMultiplierRuleDescriptor,
+  "overtime-daily-surcharge": overtimeDailySurchargeRuleDescriptor,
+  "overtime-tiered-multiplier": overtimeTieredMultiplierRuleDescriptor,
+  "max-days-of-week-per-period": maxDaysOfWeekPerPeriodRuleDescriptor,
+  "min-days-of-week-per-period": minDaysOfWeekPerPeriodRuleDescriptor,
+} satisfies BuiltInCpsatRuleRegistry);