dabke 0.83.0 → 0.84.0

package/src/cpsat/rules/resolver.ts

@@ -5,19 +5,24 @@ import {
   type ParsedEntityScope,
   type ParsedTimeScope,
 } from "./scope.types.js";
-import { builtInCpsatRuleFactories } from "./registry.js";
+import {
+  assertNoBuiltInCpsatRuleOverrides,
+  assertValidCpsatRuleRegistry,
+  builtInCpsatRuleRegistry,
+} from "./registry.js";
 import type {
+  AnyCpsatRuleConfigEntry,
+  BuiltInCpsatRuleRegistry,
   CpsatRuleConfigEntry,
-  CpsatRuleFactories,
-  CpsatRuleName,
+  CpsatRuleConfigEntryFor,
   CpsatRuleRegistry,
 } from "./rules.types.js";
-import type { CompilationRule } from "../model-builder.js";
+import type { CompiledRule, RuleCompileContext } from "../rule-descriptor.js";
+import { compileRuleDescriptor } from "../rule-descriptor.js";
 
 type InternalEntry = {
   index: number;
-  name: CpsatRuleName;
-  config: CpsatRuleRegistry[CpsatRuleName];
+  entry: AnyCpsatRuleConfigEntry;
   entityScope: ParsedEntityScope;
   timeScope: ParsedTimeScope;
 };
@@ -25,9 +30,9 @@ type InternalEntry = {
 /**
  * Extract the config portion from a flat rule entry (everything except `name`).
  */
-function entryConfig(entry: CpsatRuleConfigEntry): CpsatRuleRegistry[CpsatRuleName] {
+function entryConfig(entry: AnyCpsatRuleConfigEntry): Record<string, unknown> {
   const { name: _name, ...config } = entry;
-  return config as CpsatRuleRegistry[CpsatRuleName];
+  return config;
 }
 
 /**
@@ -97,7 +102,9 @@ function timeScopeKey(time: ParsedTimeScope): string {
 }
 
 /**
- * Rules that don't use standard scoping and should pass through unchanged.
+ * Built-in rules that don't use standard scoping and should pass through unchanged.
+ * Custom rules also pass through unchanged so they can receive their declared
+ * scope fields directly.
  */
 const NON_SCOPED_RULES = new Set<string>(["assign-together"]);
 
@@ -105,22 +112,22 @@ const NON_SCOPED_RULES = new Set<string>(["assign-together"]);
  * Resolves overlapping scopes so that more specific scopes override broader ones.
  *
  * Resolution rules:
- * 1. Rules in NON_SCOPED_RULES pass through unchanged (they handle their own logic)
- * 2. Rules with different time scopes coexist (different time windows don't compete)
+ * 1. Custom rules and built-in rules in NON_SCOPED_RULES pass through unchanged
+ * 2. Built-in rules with different time scopes coexist (different time windows don't compete)
  * 3. Within the same time scope, rules are sorted by specificity (person > role > skill > global)
  *    and then by insertion order (later wins for same specificity, i.e., last insert overrides)
  * 4. More specific rules claim their IDs first; less specific rules get the remainder
  * 5. All scope types (person, role, skill, global) are expanded to explicit IDs
  */
 export function resolveRuleScopes(
-  entries: CpsatRuleConfigEntry[],
+  entries: readonly AnyCpsatRuleConfigEntry[],
   members: SchedulingMember[],
-): CpsatRuleConfigEntry[] {
-  const resolved: CpsatRuleConfigEntry[] = [];
-  const scopedEntries: Array<{ entry: CpsatRuleConfigEntry; index: number }> = [];
+): AnyCpsatRuleConfigEntry[] {
+  const resolved: AnyCpsatRuleConfigEntry[] = [];
+  const scopedEntries: Array<{ entry: AnyCpsatRuleConfigEntry; index: number }> = [];
 
   entries.forEach((entry, index) => {
-    if (NON_SCOPED_RULES.has(entry.name)) {
+    if (NON_SCOPED_RULES.has(entry.name) || !(entry.name in builtInCpsatRuleRegistry)) {
       resolved.push(entry);
     } else {
       scopedEntries.push({ entry, index });
@@ -141,8 +148,7 @@ export function resolveRuleScopes(
     const list = grouped.get(groupKey) ?? [];
     list.push({
       index,
-      name: entry.name,
-      config,
+      entry,
       entityScope: entity,
       timeScope: time,
     });
@@ -159,8 +165,8 @@ export function resolveRuleScopes(
 
     const assignedMembers = new Set<string>();
 
-    for (const entry of sorted) {
-      const targetIds = getMemberIdsForScope(entry.entityScope, members);
+    for (const item of sorted) {
+      const targetIds = getMemberIdsForScope(item.entityScope, members);
       const remaining = subtractIds(targetIds, assignedMembers);
       if (remaining.length === 0) continue;
 
@@ -171,12 +177,12 @@ export function resolveRuleScopes(
         roleIds: _roleIds,
         skillIds: _skillIds,
         ...configWithoutEntityScope
-      } = entry.config as Record<string, unknown>;
+      } = entryConfig(item.entry);
       resolved.push({
-        name: entry.name,
+        name: item.entry.name,
         ...configWithoutEntityScope,
         memberIds: remaining,
-      } as CpsatRuleConfigEntry);
+      });
     }
   }
 
@@ -184,22 +190,44 @@ export function resolveRuleScopes(
 }
 
 /**
- * Builds CompilationRule instances from named configs, applying scoping resolution.
+ * Builds compiled rules from named configs, applying scoping resolution.
  */
 export function buildCpsatRules(
-  entries: CpsatRuleConfigEntry[],
+  entries: readonly CpsatRuleConfigEntry[],
+  members: SchedulingMember[],
+  compileContext: RuleCompileContext,
+  ruleRegistry?: BuiltInCpsatRuleRegistry,
+): CompiledRule[];
+export function buildCpsatRules<Registry extends CpsatRuleRegistry>(
+  entries: readonly CpsatRuleConfigEntryFor<Registry>[],
+  members: SchedulingMember[],
+  compileContext: RuleCompileContext,
+  ruleRegistry: Registry,
+): CompiledRule[];
+export function buildCpsatRules(
+  entries: readonly AnyCpsatRuleConfigEntry[],
   members: SchedulingMember[],
-  factories: CpsatRuleFactories = builtInCpsatRuleFactories,
-): CompilationRule[] {
+  compileContext: RuleCompileContext,
+  ruleRegistry: CpsatRuleRegistry,
+): CompiledRule[];
+export function buildCpsatRules(
+  entries: readonly AnyCpsatRuleConfigEntry[],
+  members: SchedulingMember[],
+  compileContext: RuleCompileContext,
+  ruleRegistry: CpsatRuleRegistry = builtInCpsatRuleRegistry,
+): CompiledRule[] {
   if (entries.length === 0) return [];
 
+  assertValidCpsatRuleRegistry(ruleRegistry);
+  assertNoBuiltInCpsatRuleOverrides(ruleRegistry);
+
   const resolved = resolveRuleScopes(entries, members);
 
   return resolved.map((entry) => {
-    const factory = factories[entry.name];
-    if (!factory) {
+    const descriptor = ruleRegistry[entry.name];
+    if (!descriptor) {
       throw new Error(`Unknown CP-SAT rule "${entry.name}"`);
     }
-    return factory(entryConfig(entry));
+    return compileRuleDescriptor(descriptor, entryConfig(entry), compileContext);
   });
 }

package/src/cpsat/rules/role-preference.ts

@@ -0,0 +1,92 @@
+import * as z from "zod";
+import { defineRuleDescriptor } from "../rule-descriptor.js";
+import type { RuleArtifact } from "../rule-descriptor.js";
+import { PREFERENCE_WEIGHTS } from "../utils.js";
+import {
+  PrioritySchema,
+  entityScope,
+  parseEntityScope,
+  resolveMembersFromScope,
+} from "./scope.types.js";
+import { assignmentVar } from "./variables.js";
+import { canAssignMemberToPattern, isPatternAvailableOnDay } from "./pattern-eligibility.js";
+
+export const RolePreferenceSchema = z
+  .object({
+    roleId: z.string(),
+    priority: PrioritySchema,
+  })
+  .and(entityScope(["members", "roles", "skills"]));
+
+/**
+ * Configuration for {@link rolePreferenceRuleDescriptor}.
+ */
+export type RolePreferenceConfig = z.infer<typeof RolePreferenceSchema>;
+
+/**
+ * Low-level descriptor for role preference rules.
+ *
+ * @category Rules
+ */
+export const rolePreferenceRuleDescriptor = defineRuleDescriptor({
+  name: "role-preference",
+  schema: RolePreferenceSchema,
+  compile(config, ctx) {
+    const scope = parseEntityScope(config);
+    const { roleId } = config;
+    const weight = PREFERENCE_WEIGHTS[config.priority as keyof typeof PREFERENCE_WEIGHTS] ?? 0;
+    if (weight === 0) {
+      return { rule: "role-preference", artifacts: [] };
+    }
+
+    const members = resolveMembersFromScope(scope, [...ctx.members]);
+    if (members.length === 0) {
+      return { rule: "role-preference", artifacts: [] };
+    }
+
+    const membersWithRole = members.filter((member) => member.roleIds.includes(roleId));
+    const artifacts: RuleArtifact[] = [];
+
+    if (membersWithRole.length === 0) {
+      artifacts.push({
+        kind: "pre-solve-feedback",
+        run(_precheckContext, reporter) {
+          const ids = members.map((member) => member.id).join(", ");
+          reporter.reportRuleError({
+            rule: "role-preference",
+            message:
+              `None of the targeted members (${ids}) have role "${roleId}". ` +
+              `Add "${roleId}" to their roleIds, or remove this preferRole rule.`,
+            context: { memberIds: members.map((member) => member.id) },
+          });
+        },
+      });
+      return { rule: "role-preference", artifacts };
+    }
+
+    const terms = membersWithRole.flatMap((member) =>
+      ctx.shiftPatterns.flatMap((pattern) => {
+        if (!canAssignMemberToPattern(member, pattern)) return [];
+        if (pattern.roleIds?.includes(roleId)) return [];
+        return ctx.days
+          .filter((day) => isPatternAvailableOnDay(pattern, day))
+          .map((day) => ({ var: assignmentVar(member.id, pattern.id, day.iso), coeff: weight }));
+      }),
+    );
+
+    artifacts.push({
+      kind: "objective",
+      terms,
+      validation: {
+        strategy: "skip",
+        category: "no-meaningful-feedback",
+        rationale:
+          terms.length === 0
+            ? `Role preference for "${roleId}" produced no objective terms.`
+            : "Preference rules influence the objective but do not emit validation feedback.",
+      },
+    });
+
+    return { rule: "role-preference", artifacts };
+  },
+});

package/src/cpsat/rules/rules.types.ts

@@ -1,12 +1,23 @@
-import type { CompilationRule } from "../model-builder.js";
+import type { RuleDescriptor } from "../rule-descriptor.js";
 
-export type CreateCpsatRuleFunction<TConfig = any> = (config: TConfig) => CompilationRule;
-
-// Registry of built-in rule names to their config types
-export interface CpsatRuleRegistry {
+/**
+ * Maps built-in CP-SAT rule names to their validated config types.
+ *
+ * @remarks
+ * Use this when you need the exact config shape for a known built-in rule.
+ * For registry-driven APIs, prefer `CpsatRuleRegistry`, `CpsatRuleConfigByName`,
+ * and `CpsatRuleConfigEntryFor`.
+ *
+ * @category Rules
+ */
+export interface BuiltInCpsatRuleConfigRegistry {
   "assign-together": import("./assign-together.js").AssignTogetherConfig;
   "assignment-priority": import("./assignment-priority.js").AssignmentPriorityConfig;
   "location-preference": import("./location-preference.js").LocationPreferenceConfig;
+  "role-preference": import("./role-preference.js").RolePreferenceConfig;
+  "max-concurrent-assignments": import("./max-concurrent-assignments.js").MaxConcurrentAssignmentsConfig;
+  "target-peak-concurrent-assignments": import("./target-peak-concurrent-assignments.js").TargetPeakConcurrentAssignmentsConfig;
+  "target-days-week": import("./target-days-week.js").TargetDaysWeekConfig;
   "max-consecutive-days": import("./max-consecutive-days.js").MaxConsecutiveDaysConfig;
   "max-days-week": import("./max-days-week.js").MaxDaysWeekConfig;
   "max-hours-day": import("./max-hours-day.js").MaxHoursDayConfig;
@@ -28,25 +39,85 @@ export interface CpsatRuleRegistry {
   "overtime-daily-multiplier": import("./overtime-daily-multiplier.js").OvertimeDailyMultiplierConfig;
   "overtime-daily-surcharge": import("./overtime-daily-surcharge.js").OvertimeDailySurchargeConfig;
   "overtime-tiered-multiplier": import("./overtime-tiered-multiplier.js").OvertimeTieredMultiplierConfig;
+  "max-days-of-week-per-period": import("./max-days-of-week-per-period.js").MaxDaysOfWeekPerPeriodConfig;
+  "min-days-of-week-per-period": import("./min-days-of-week-per-period.js").MinDaysOfWeekPerPeriodConfig;
 }
 
-export type CpsatRuleName = keyof CpsatRuleRegistry;
+/**
+ * The union of all built-in CP-SAT rule names.
+ *
+ * @category Rules
+ */
+export type CpsatRuleName = keyof BuiltInCpsatRuleConfigRegistry;
 
-export type CpsatRuleFactories = {
-  [ruleName: string]: CreateCpsatRuleFunction<any>;
-};
+/**
+ * A registry of CP-SAT rule descriptors keyed by rule name.
+ *
+ * @remarks
+ * The registry key must exactly match each descriptor's `name` field.
+ * Use `createCpsatRuleRegistry` to validate that invariant when building
+ * custom registries.
+ *
+ * @category Rules
+ */
+export type CpsatRuleRegistry = Record<string, RuleDescriptor<string, unknown>>;
 
-export type BuiltInCpsatRuleFactories = {
-  [K in CpsatRuleName]: CreateCpsatRuleFunction<CpsatRuleRegistry[K]>;
+/**
+ * The built-in CP-SAT rule registry shape.
+ *
+ * @category Rules
+ */
+export type BuiltInCpsatRuleRegistry = {
+  [K in CpsatRuleName]: RuleDescriptor<K, BuiltInCpsatRuleConfigRegistry[K]>;
 };
 
+/**
+ * Extracts the config type from a rule descriptor.
+ *
+ * @category Rules
+ */
 export type InferCpsatRuleConfig<T> =
-  T extends CreateCpsatRuleFunction<infer Config> ? Config : never;
+  T extends RuleDescriptor<string, infer Config> ? Config : never;
 
-export type CpsatRuleRegistryFromFactories<F extends CpsatRuleFactories> = {
-  [K in keyof F]: InferCpsatRuleConfig<F[K]>;
+/**
+ * Maps a rule registry to a name-to-config lookup type.
+ *
+ * @example
+ * ```ts
+ * type ConfigByName = CpsatRuleConfigByName<typeof builtInCpsatRuleRegistry>;
+ * //    ^? { "max-hours-day": MaxHoursDayConfig; ... }
+ * ```
+ *
+ * @category Rules
+ */
+export type CpsatRuleConfigByName<Registry extends CpsatRuleRegistry> = {
+  [K in keyof Registry & string]: InferCpsatRuleConfig<Registry[K]>;
 };
 
+/**
+ * Builds the discriminated rule-entry union for a rule registry.
+ *
+ * @remarks
+ * This preserves the pairing between each `name` value and the config fields
+ * allowed for that rule.
+ *
+ * @category Rules
+ */
+export type CpsatRuleConfigEntryFor<Registry extends CpsatRuleRegistry> = {
+  [K in keyof Registry & string]: { name: K } & InferCpsatRuleConfig<Registry[K]>;
+}[keyof Registry & string];
+
+/**
+ * A normalized rule entry with an unconstrained string rule name.
+ *
+ * @remarks
+ * This is used internally at points where the specific registry is no longer
+ * known at the type level.
+ *
+ * @category Rules
+ */
+export type AnyCpsatRuleConfigEntry = { name: string } & Record<string, unknown>;
+
 /**
  * A named rule configuration entry.
  *
@@ -62,7 +133,8 @@ export type CpsatRuleRegistryFromFactories<F extends CpsatRuleFactories> = {
  *   { name: "time-off", memberIds: ["alice"], dayOfWeek: ["monday"], priority: "MANDATORY" },
  * ];
  * ```
+ *
+ * @category Rules
  */
-export type CpsatRuleConfigEntry = {
-  [K in CpsatRuleName]: { name: K } & CpsatRuleRegistry[K];
-}[CpsatRuleName];
+export type CpsatRuleConfigEntry<Registry extends CpsatRuleRegistry = BuiltInCpsatRuleRegistry> =
+  CpsatRuleConfigEntryFor<Registry>;

package/src/cpsat/rules/scope.types.ts

@@ -34,10 +34,13 @@
  */
 
 import * as z from "zod";
-import { DayOfWeekSchema, type DayOfWeek } from "../../types.js";
-import { toDayOfWeekUTC } from "../../datetime.utils.js";
-import type { SchedulingMember } from "../types.js";
-import { parseDayString } from "../utils.js";
+import {
+  DayOfWeekSchema,
+  type DateString,
+  type DayOfWeek,
+  type SchedulingDay,
+} from "../../types.js";
+import { PRIORITY_VALUES, SOFT_PRIORITY_VALUES, type SchedulingMember } from "../types.js";
 import { assertSafeKeySegments, type ValidationGroup } from "../validation.types.js";
 
 // ============================================================================
@@ -50,9 +53,12 @@ import { assertSafeKeySegments, type ValidationGroup } from "../validation.types
  * Rules that use priority should include this in their schema so the
  * default is co-located with the rule system, not injected externally.
  */
-export const PrioritySchema = z
-  .union([z.literal("LOW"), z.literal("MEDIUM"), z.literal("HIGH"), z.literal("MANDATORY")])
-  .default("MANDATORY");
+export const PrioritySchema = z.enum(PRIORITY_VALUES).default("MANDATORY");
+
+/**
+ * Zod schema for soft-only priorities.
+ */
+export const SoftPrioritySchema = z.enum(SOFT_PRIORITY_VALUES);
 
 // ============================================================================
 // Scope Keys
@@ -104,8 +110,8 @@ export interface RecurringPeriod {
  * The field shape when a time scope variant is active (selected).
  */
 type ActiveTimeFields = {
-  dateRange: { dateRange: { start: string; end: string } };
-  specificDates: { specificDates: NonEmptyArray<string> };
+  dateRange: { dateRange: { start: DateString; end: DateString } };
+  specificDates: { specificDates: NonEmptyArray<DateString> };
   dayOfWeek: { dayOfWeek: NonEmptyArray<DayOfWeek> };
   recurring: { recurringPeriods: NonEmptyArray<RecurringPeriod> };
 };
@@ -407,7 +413,7 @@ export type ParsedEntityScope =
 export type ParsedTimeScope =
   | { type: "none" }
   | { type: "dateRange"; start: string; end: string }
-  | { type: "specificDates"; dates: string[] }
+  | { type: "specificDates"; dates: DateString[] }
   | { type: "dayOfWeek"; days: DayOfWeek[] }
   | { type: "recurring"; periods: RecurringPeriod[] };
 
@@ -421,8 +427,8 @@ export interface EntityScopeInput {
 
 /** Input shape accepted by {@link parseTimeScope}. */
 export interface TimeScopeInput {
-  dateRange?: { start: string; end: string };
-  specificDates?: string[];
+  dateRange?: { start: DateString; end: DateString };
+  specificDates?: DateString[];
   dayOfWeek?: DayOfWeek[];
   recurringPeriods?: RecurringPeriod[];
   [key: string]: unknown;
@@ -488,28 +494,27 @@ export function resolveMembersFromScope(
 /**
  * Resolves which days a rule applies to based on time scope.
  */
-export function resolveActiveDaysFromScope(scope: ParsedTimeScope, allDays: string[]): string[] {
+export function resolveActiveDaysFromScope(
+  scope: ParsedTimeScope,
+  allDays: SchedulingDay[],
+): SchedulingDay[] {
   switch (scope.type) {
     case "none":
       return allDays;
     case "dateRange":
-      return allDays.filter((day) => day >= scope.start && day <= scope.end);
-    case "specificDates":
-      return allDays.filter((day) => scope.dates.includes(day));
+      return allDays.filter((day) => day.iso >= scope.start && day.iso <= scope.end);
+    case "specificDates": {
+      const dateSet = new Set(scope.dates);
+      return allDays.filter((day) => dateSet.has(day.iso));
+    }
     case "dayOfWeek": {
       const targetDays = new Set(scope.days);
-      return allDays.filter((day) => {
-        const date = parseDayString(day);
-        return targetDays.has(toDayOfWeekUTC(date));
-      });
+      return allDays.filter((day) => targetDays.has(day.dayOfWeek));
     }
     case "recurring":
-      return allDays.filter((day) => {
-        const date = parseDayString(day);
-        const month = date.getUTCMonth() + 1;
-        const dayOfMonth = date.getUTCDate();
-        return scope.periods.some((period) => isDateInRecurringPeriod(month, dayOfMonth, period));
-      });
+      return allDays.filter((day) =>
+        scope.periods.some((period) => isDateInRecurringPeriod(day.month, day.dayOfMonth, period)),
+      );
   }
 }
 

package/src/cpsat/rules/target-days-week.ts

@@ -0,0 +1,105 @@
+import * as z from "zod";
+import { DayOfWeekSchema } from "../../types.js";
+import { defineRuleDescriptor } from "../rule-descriptor.js";
+import { priorityToPenalty, splitIntoWeeks } from "../utils.js";
+import {
+  entityScope,
+  parseEntityScope,
+  resolveMembersFromScope,
+  ruleGroup,
+  SoftPrioritySchema,
+} from "./scope.types.js";
+import { assignmentVarsForDay } from "./assignment-terms.js";
+import { assignedDayVariableName } from "./variables.js";
+import { reportValidation, softConstraint } from "./artifacts.js";
+import { buildAssignedDayIndicator } from "./assigned-day.js";
+
+const TargetDaysWeekBase = z.object({
+  days: z.number().int().min(0),
+  priority: SoftPrioritySchema.default("HIGH"),
+  weekStartsOn: DayOfWeekSchema.optional(),
+});
+
+export const TargetDaysWeekSchema = TargetDaysWeekBase.and(
+  entityScope(["members", "roles", "skills"]),
+);
+
+/**
+ * Configuration for {@link targetDaysWeekRuleDescriptor}.
+ */
+export type TargetDaysWeekConfig = z.infer<typeof TargetDaysWeekSchema>;
+
+/**
+ * Low-level descriptor for the `target-days-week` rule.
+ *
+ * @remarks
+ * Softly targets assigned days per scheduling week. Deviations in either
+ * direction are penalized, so working fewer than the target or more than the
+ * target both count as misses. Use this for stated weekly patterns like
+ * "works a 4-day week" when that pattern should remain flexible.
+ *
+ * @category Rules
+ */
+export const targetDaysWeekRuleDescriptor = defineRuleDescriptor({
+  name: "target-days-week",
+  schema: TargetDaysWeekSchema,
+  compile(config, ctx) {
+    const scope = parseEntityScope(config);
+    const { days, priority, weekStartsOn } = config;
+    const group = ruleGroup(`target-days-week:${days}`, `Target ${days}d per week`, scope);
+    const members = resolveMembersFromScope(scope, [...ctx.members]);
+    const weeks = splitIntoWeeks([...ctx.days], weekStartsOn ?? ctx.weekStartsOn);
+
+    const artifacts = members.flatMap((member) =>
+      weeks.flatMap((weekDays) => {
+        const weekStart = weekDays[0];
+        if (!weekStart) return [];
+
+        const supportArtifacts = weekDays.flatMap(
+          (day) =>
+            buildAssignedDayIndicator({
+              memberId: member.id,
+              day,
+              assignmentVars: assignmentVarsForDay(member, day, ctx.shiftPatterns),
+            }).artifacts,
+        );
+
+        const assignedDayVars = weekDays.map((day) => assignedDayVariableName(member.id, day.iso));
+
+        const context = { memberIds: [member.id], days: weekDays.map((day) => day.iso) };
+        const terms = assignedDayVars.map((varName) => ({ var: varName, coeff: 1 }));
+        const penalty = priorityToPenalty(priority);
+
+        return supportArtifacts.concat([
+          softConstraint({
+            group,
+            description: `${member.id} target ${days}d per week starting ${weekStart.iso} (under)`,
+            context,
+            validation: reportValidation(),
+            terms,
+            comparator: ">=",
+            targetValue: days,
+            penalty,
+            constraintId: `target-days-week:under:${member.id}:${weekStart.iso}`,
+          }),
+          softConstraint({
+            group,
+            description: `${member.id} target ${days}d per week starting ${weekStart.iso} (over)`,
+            context,
+            validation: reportValidation(),
+            terms,
+            comparator: "<=",
+            targetValue: days,
+            penalty,
+            constraintId: `target-days-week:over:${member.id}:${weekStart.iso}`,
+          }),
+        ]);
+      }),
+    );
+
+    return {
+      rule: "target-days-week",
+      artifacts,
+    };
+  },
+});