group-planner 0.0.0-stage → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1599 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/constants.ts
+var EQUIPMENT_CLASSES = [
+  "HB",
+  // Heavy Bow
+  "LB",
+  // Light Bow  
+  "TR",
+  // Traditional Recurve
+  "BHR",
+  // Barebow Heavy Recurve
+  "BBR",
+  // Barebow Basic Recurve
+  "FSR",
+  // Freestyle Recurve
+  "BBC",
+  // Barebow Compound
+  "BL",
+  // Barebow Longbow
+  "BU",
+  // Barebow Unlimited
+  "FSC",
+  // Freestyle Compound
+  "FU"
+  // Freestyle Unlimited
+];
+var AGE_GROUPS = [
+  "C",
+  // Children
+  "J",
+  // Juniors
+  "YA",
+  // Young Adults
+  "A",
+  // Adults
+  "V",
+  // Veterans
+  "S"
+  // Seniors
+];
+var GENDERS = [
+  "F",
+  // Female
+  "M"
+  // Male
+];
+var EQUIPMENT_CLASS_DESCRIPTIONS = {
+  "HB": "Heavy Bow",
+  "LB": "Light Bow",
+  "TR": "Traditional Recurve",
+  "BHR": "Barebow Heavy Recurve",
+  "BBR": "Barebow Basic Recurve",
+  "FSR": "Freestyle Recurve",
+  "BBC": "Barebow Compound",
+  "BL": "Barebow Longbow",
+  "BU": "Barebow Unlimited",
+  "FSC": "Freestyle Compound",
+  "FU": "Freestyle Unlimited"
+};
+var AGE_GROUP_DESCRIPTIONS = {
+  "C": "Children",
+  "J": "Juniors",
+  "YA": "Young Adults",
+  "A": "Adults",
+  "V": "Veterans",
+  "S": "Seniors"
+};
+var GENDER_DESCRIPTIONS = {
+  "F": "Female",
+  "M": "Male"
+};
+function isValidEquipmentClass(value, allowed) {
+  return (allowed ?? EQUIPMENT_CLASSES).includes(value);
+}
+function isValidAgeGroup(value, allowed) {
+  return (allowed ?? AGE_GROUPS).includes(value);
+}
+function isValidGender(value, allowed) {
+  return (allowed ?? GENDERS).includes(value);
+}
+function getAgeGroupOrder(ageGroup) {
+  return AGE_GROUPS.indexOf(ageGroup);
+}
+function compareAgeGroups(a, b) {
+  return getAgeGroupOrder(a) - getAgeGroupOrder(b);
+}
+
+// src/subsetSize.ts
+var MINIMUM_SUBSET_SIZE = 3;
+function smallestAllowedSubset(requestedMin) {
+  return Math.max(MINIMUM_SUBSET_SIZE, requestedMin);
+}
+function isLinked(competitor, group) {
+  if (competitor.guardianId && group.some((member) => member.id === competitor.guardianId)) {
+    return true;
+  }
+  return group.some((member) => member.guardianId === competitor.id);
+}
+function takeUnlinked(group) {
+  for (let index = group.length - 1; index >= 0; index--) {
+    const competitor = group[index];
+    if (!isLinked(competitor, group)) {
+      group.splice(index, 1);
+      return competitor;
+    }
+  }
+  return void 0;
+}
+function undoMoves(short, moved) {
+  for (const move of moved.reverse()) {
+    const index = short.indexOf(move.person);
+    if (index >= 0) {
+      short.splice(index, 1);
+    }
+    move.donor.push(move.person);
+  }
+}
+function fillFromDonors(groups, shortIndex, min, max) {
+  const short = groups[shortIndex];
+  const need = min - short.length;
+  if (need <= 0 || short.length + need > max) {
+    return false;
+  }
+  const moved = [];
+  let remaining = need;
+  for (const group of groups) {
+    remaining = takeFromDonor(group, short, remaining, min, moved);
+  }
+  if (remaining === 0) {
+    return true;
+  }
+  undoMoves(short, moved);
+  return false;
+}
+function takeFromDonor(group, short, remaining, min, moved) {
+  let left = remaining;
+  while (left > 0 && group !== short && group.length > min) {
+    const person = takeUnlinked(group);
+    if (!person) {
+      return left;
+    }
+    short.push(person);
+    moved.push({ person, donor: group });
+    left -= 1;
+  }
+  return left;
+}
+function mergeIntoHost(groups, shortIndex, min, max) {
+  const short = groups[shortIndex];
+  const hostIndex = groups.findIndex((group, index) => {
+    if (index === shortIndex) {
+      return false;
+    }
+    const combined = group.length + short.length;
+    return combined >= min && combined <= max;
+  });
+  if (hostIndex < 0) {
+    return false;
+  }
+  groups[hostIndex].push(...short);
+  groups.splice(shortIndex, 1);
+  return true;
+}
+function absorbShortGroup(groups, min, max) {
+  const shortIndex = groups.findIndex((group) => group.length < min);
+  if (shortIndex < 0) {
+    return false;
+  }
+  if (fillFromDonors(groups, shortIndex, min, max)) {
+    return true;
+  }
+  if (mergeIntoHost(groups, shortIndex, min, max)) {
+    return true;
+  }
+  groups.splice(shortIndex, 1);
+  return true;
+}
+function retainLegalSubsets(subsets, min, max) {
+  const floor = smallestAllowedSubset(min);
+  const groups = subsets.map((subset) => [...subset]).filter((subset) => subset.length > 0);
+  let progressed = true;
+  let steps = 0;
+  const stepLimit = groups.length * groups.length + groups.length + 1;
+  while (progressed && steps < stepLimit) {
+    steps += 1;
+    progressed = absorbShortGroup(groups, floor, max);
+  }
+  return groups.filter((group) => group.length >= floor);
+}
+
+// src/utils.ts
+var DEFAULT_OPTIONS = {
+  algorithm: "auto",
+  groupByEquipmentClass: true,
+  maxSubsets: 28,
+  minSubsetSize: 3,
+  maxSubsetSize: 6,
+  preferredSubsetSize: 4,
+  genderWeight: 1,
+  ageCategoryWeight: 1,
+  equipmentClassWeight: 1,
+  closedGroupWeight: 0
+};
+function validatePartition(competitors, subsets, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const errors = [];
+  const assignedCompetitors = /* @__PURE__ */ new Set();
+  for (const subset of subsets) {
+    for (const competitor of subset) {
+      if (assignedCompetitors.has(competitor.id)) {
+        errors.push(`Competitor ${competitor.id} assigned to multiple subsets`);
+      }
+      assignedCompetitors.add(competitor.id);
+    }
+  }
+  if (assignedCompetitors.size !== competitors.length) {
+    errors.push(`Not all competitors assigned: ${assignedCompetitors.size}/${competitors.length}`);
+  }
+  for (let i = 0; i < subsets.length; i++) {
+    const size = subsets[i].length;
+    const minimum = smallestAllowedSubset(opts.minSubsetSize);
+    if (size < minimum) {
+      errors.push(`Subset ${i} too small: ${size} < ${minimum}`);
+    }
+    if (size > opts.maxSubsetSize) {
+      errors.push(`Subset ${i} too large: ${size} > ${opts.maxSubsetSize}`);
+    }
+  }
+  if (subsets.length > opts.maxSubsets) {
+    errors.push(`Too many subsets: ${subsets.length} > ${opts.maxSubsets}`);
+  }
+  const guardianValidation = validateGuardianConstraints(competitors, subsets);
+  errors.push(...guardianValidation.errors);
+  return { valid: errors.length === 0, errors };
+}
+function mean(total, count) {
+  return count === 0 ? 0 : total / count;
+}
+function countLabels(subset, label) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const competitor of subset) {
+    const key = label(competitor);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function largestShare(counts, size) {
+  return Math.max(...counts.values()) / size;
+}
+function evenShare(counts, size) {
+  let even = 0;
+  for (const count of counts.values()) {
+    if (count % 2 === 0) {
+      even += count;
+    }
+  }
+  return even / size;
+}
+function equipmentPoints(subset, options) {
+  const counts = countLabels(subset, (competitor) => competitor.equipmentClass);
+  const size = subset.length;
+  if (options.groupByEquipmentClass) {
+    return largestShare(counts, size) * 10 * options.equipmentClassWeight;
+  }
+  return counts.size / Math.min(size, 3) * 10 * options.equipmentClassWeight;
+}
+function scoreSubset(subset, options = {}) {
+  if (subset.length === 0) {
+    return { size: 0, closedGroup: 0, gender: 0, ageCategory: 0, equipmentClass: 0, total: 0 };
+  }
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const size = subset.length;
+  const sizeScore = Math.max(0, 10 - Math.abs(size - opts.preferredSubsetSize) * 2);
+  const closedGroup = size === opts.preferredSubsetSize ? 10 * opts.closedGroupWeight : 0;
+  const gender = evenShare(countLabels(subset, (competitor) => competitor.gender), size) * 10 * opts.genderWeight;
+  const ageCategory = largestShare(countLabels(subset, (competitor) => competitor.ageCategory), size) * 10 * opts.ageCategoryWeight;
+  const equipmentClass = equipmentPoints(subset, opts);
+  return {
+    size: sizeScore,
+    closedGroup,
+    gender,
+    ageCategory,
+    equipmentClass,
+    total: sizeScore + closedGroup + gender + ageCategory + equipmentClass
+  };
+}
+function calculateScore(subsets, options = {}) {
+  const totals = { size: 0, closedGroup: 0, gender: 0, ageCategory: 0, equipmentClass: 0 };
+  for (const subset of subsets) {
+    const parts = scoreSubset(subset, options);
+    totals.size += parts.size;
+    totals.closedGroup += parts.closedGroup;
+    totals.gender += parts.gender;
+    totals.ageCategory += parts.ageCategory;
+    totals.equipmentClass += parts.equipmentClass;
+  }
+  const breakdown = {
+    sizeScore: mean(totals.size, subsets.length),
+    closedGroupScore: mean(totals.closedGroup, subsets.length),
+    genderScore: mean(totals.gender, subsets.length),
+    ageCategoryScore: mean(totals.ageCategory, subsets.length),
+    equipmentClassScore: mean(totals.equipmentClass, subsets.length)
+  };
+  const score = breakdown.sizeScore + breakdown.closedGroupScore + breakdown.genderScore + breakdown.ageCategoryScore + breakdown.equipmentClassScore;
+  return { score, breakdown };
+}
+function createPartitionResult(subsets, options = {}) {
+  const totalCompetitors = subsets.reduce((sum, subset) => sum + subset.length, 0);
+  const { score, breakdown } = calculateScore(subsets, options);
+  return {
+    subsets,
+    score,
+    metadata: {
+      totalCompetitors,
+      totalSubsets: subsets.length,
+      averageSubsetSize: subsets.length === 0 ? 0 : totalCompetitors / subsets.length,
+      scoreBreakdown: breakdown
+    }
+  };
+}
+function getGuardianGroups(competitors) {
+  const guardianGroups = /* @__PURE__ */ new Map();
+  for (const competitor of competitors) {
+    if (competitor.guardianId) {
+      const key = competitor.guardianId;
+      if (!guardianGroups.has(key)) {
+        guardianGroups.set(key, []);
+      }
+      guardianGroups.get(key).push(competitor);
+      const guardian = competitors.find((c) => c.id === competitor.guardianId);
+      if (guardian && !guardianGroups.get(key).includes(guardian)) {
+        guardianGroups.get(key).push(guardian);
+      }
+    }
+  }
+  return guardianGroups;
+}
+function createGuardianFamilies(competitors) {
+  const families = [];
+  const processed = /* @__PURE__ */ new Set();
+  const guardianToDependents = /* @__PURE__ */ new Map();
+  const dependentToGuardian = /* @__PURE__ */ new Map();
+  for (const competitor of competitors) {
+    if (competitor.guardianId) {
+      if (!guardianToDependents.has(competitor.guardianId)) {
+        guardianToDependents.set(competitor.guardianId, []);
+      }
+      guardianToDependents.get(competitor.guardianId).push(competitor);
+      dependentToGuardian.set(competitor.id, competitor.guardianId);
+    }
+  }
+  for (const competitor of competitors) {
+    if (processed.has(competitor.id)) {
+      continue;
+    }
+    if (guardianToDependents.has(competitor.id)) {
+      const family = [competitor, ...guardianToDependents.get(competitor.id)];
+      families.push(family);
+      for (const member of family) {
+        processed.add(member.id);
+      }
+    } else if (dependentToGuardian.has(competitor.id)) {
+      continue;
+    } else {
+      families.push([competitor]);
+      processed.add(competitor.id);
+    }
+  }
+  return families;
+}
+function validateGuardianConstraints(competitors, subsets) {
+  const errors = [];
+  const competitorToSubset = /* @__PURE__ */ new Map();
+  for (let subsetIndex = 0; subsetIndex < subsets.length; subsetIndex++) {
+    for (const competitor of subsets[subsetIndex]) {
+      competitorToSubset.set(competitor.id, subsetIndex);
+    }
+  }
+  for (const competitor of competitors) {
+    if (competitor.guardianId) {
+      const competitorSubset = competitorToSubset.get(competitor.id);
+      const guardianSubset = competitorToSubset.get(competitor.guardianId);
+      if (competitorSubset === void 0) {
+        errors.push(`Competitor ${competitor.id} not assigned to any subset`);
+        continue;
+      }
+      if (guardianSubset === void 0) {
+        errors.push(`Guardian ${competitor.guardianId} for competitor ${competitor.id} not found in any subset`);
+        continue;
+      }
+      if (competitorSubset !== guardianSubset) {
+        errors.push(`Competitor ${competitor.id} and their guardian ${competitor.guardianId} are in different subsets (${competitorSubset} vs ${guardianSubset})`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function shuffle(array) {
+  const result = [...array];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isValidCompetitor(competitor, space) {
+  if (!isRecord(competitor)) {
+    return false;
+  }
+  const { id, equipmentClass, ageCategory, gender, guardianId } = competitor;
+  if (typeof id !== "string" || id.trim().length === 0) {
+    return false;
+  }
+  if (typeof equipmentClass !== "string" || !isValidEquipmentClass(equipmentClass, space?.equipmentClasses)) {
+    return false;
+  }
+  if (typeof ageCategory !== "string" || !isValidAgeGroup(ageCategory, space?.ageCategories)) {
+    return false;
+  }
+  if (typeof gender !== "string" || !isValidGender(gender, space?.genders)) {
+    return false;
+  }
+  if (guardianId !== void 0 && (typeof guardianId !== "string" || guardianId.trim().length === 0)) {
+    return false;
+  }
+  return true;
+}
+function validateCompetitors(competitors, space) {
+  const errors = [];
+  if (!Array.isArray(competitors)) {
+    errors.push("Competitors must be an array");
+    return { valid: false, errors };
+  }
+  if (competitors.length === 0) {
+    errors.push("At least one competitor is required");
+    return { valid: false, errors };
+  }
+  if (competitors.length > 168) {
+    errors.push("Maximum 168 competitors allowed");
+  }
+  const competitorIds = /* @__PURE__ */ new Set();
+  competitors.forEach((competitor, index) => {
+    if (!isValidCompetitor(competitor, space)) {
+      errors.push(`Competitor at index ${index} is invalid`);
+      return;
+    }
+    if (competitorIds.has(competitor.id)) {
+      errors.push(`Duplicate competitor ID: ${competitor.id}`);
+    } else {
+      competitorIds.add(competitor.id);
+    }
+  });
+  competitors.forEach((competitor) => {
+    if (competitor.guardianId && !competitors.some((c) => c.id === competitor.guardianId)) {
+      errors.push(`Guardian ${competitor.guardianId} for competitor ${competitor.id} not found`);
+    }
+  });
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  const hasCircularReference = (competitorId) => {
+    if (recursionStack.has(competitorId)) {
+      return true;
+    }
+    if (visited.has(competitorId)) {
+      return false;
+    }
+    visited.add(competitorId);
+    recursionStack.add(competitorId);
+    const competitor = competitors.find((c) => c.id === competitorId);
+    if (competitor?.guardianId) {
+      if (hasCircularReference(competitor.guardianId)) {
+        return true;
+      }
+    }
+    recursionStack.delete(competitorId);
+    return false;
+  };
+  for (const competitor of competitors) {
+    if (hasCircularReference(competitor.id)) {
+      errors.push(`Circular guardian reference detected involving competitor ${competitor.id}`);
+      break;
+    }
+  }
+  const guardianFamilySizes = /* @__PURE__ */ new Map();
+  competitors.forEach((competitor) => {
+    if (competitor.guardianId) {
+      guardianFamilySizes.set(competitor.guardianId, (guardianFamilySizes.get(competitor.guardianId) || 1) + 1);
+    } else {
+      if (!guardianFamilySizes.has(competitor.id)) {
+        guardianFamilySizes.set(competitor.id, 1);
+      }
+    }
+  });
+  guardianFamilySizes.forEach((familySize, guardianId) => {
+    if (familySize > 3) {
+      errors.push(`Family with guardian ${guardianId} has ${familySize} members, maximum allowed is 3 (1 guardian + 2 dependents)`);
+    }
+  });
+  return { valid: errors.length === 0, errors };
+}
+
+// src/common/options-validator.ts
+function validateAndSanitizeOptions(options, competitorCount) {
+  const explicitMax = options.maxSubsetSize !== void 0 && options.maxSubsetSize >= MINIMUM_SUBSET_SIZE;
+  const sanitizedOptions = { ...DEFAULT_OPTIONS, ...options };
+  swapInvertedSizes(sanitizedOptions);
+  applySizeFloors(sanitizedOptions);
+  applyDefaultFieldCap(sanitizedOptions, explicitMax, competitorCount);
+  clampPreferredSize(sanitizedOptions);
+  if (sanitizedOptions.closedGroupWeight < 0) {
+    sanitizedOptions.closedGroupWeight = 0;
+  }
+  return sanitizedOptions;
+}
+function swapInvertedSizes(options) {
+  if (options.minSubsetSize <= options.maxSubsetSize) {
+    return;
+  }
+  const previousMin = options.minSubsetSize;
+  options.minSubsetSize = options.maxSubsetSize;
+  options.maxSubsetSize = previousMin;
+}
+function applySizeFloors(options) {
+  if (options.minSubsetSize < MINIMUM_SUBSET_SIZE) {
+    options.minSubsetSize = MINIMUM_SUBSET_SIZE;
+  }
+  if (options.maxSubsetSize < options.minSubsetSize) {
+    options.maxSubsetSize = options.minSubsetSize;
+  }
+}
+function applyDefaultFieldCap(options, explicitMax, competitorCount) {
+  const useFieldCap = !explicitMax && competitorCount > 0 && competitorCount <= 112;
+  if (!useFieldCap) {
+    return;
+  }
+  options.maxSubsetSize = Math.min(options.maxSubsetSize, 4);
+  if (options.maxSubsetSize < options.minSubsetSize) {
+    options.maxSubsetSize = options.minSubsetSize;
+  }
+}
+function clampPreferredSize(options) {
+  if (options.preferredSubsetSize < options.minSubsetSize) {
+    options.preferredSubsetSize = options.minSubsetSize;
+  }
+  if (options.preferredSubsetSize > options.maxSubsetSize) {
+    options.preferredSubsetSize = options.maxSubsetSize;
+  }
+}
+
+// src/common/algorithm-base.ts
+function handleEmptyDataset(options, algorithmName) {
+  const validatedOptions = validateAndSanitizeOptions(options, 0);
+  return {
+    result: createPartitionResult([], validatedOptions),
+    executionTime: 0,
+    algorithmUsed: algorithmName
+  };
+}
+function createAlgorithmResult(competitors, subsets, options, algorithmName, startTime) {
+  const executionTime = performance.now() - startTime;
+  const legalSubsets = retainLegalSubsets(subsets, options.minSubsetSize, options.maxSubsetSize);
+  return {
+    result: createPartitionResult(legalSubsets, options),
+    executionTime,
+    algorithmUsed: algorithmName
+  };
+}
+
+// src/algorithms/mip-solver.ts
+function openSubsetFor(subsets, familySize, currentSubset, options, maxSubsets) {
+  const started = Math.min(currentSubset, subsets.length);
+  let bestIndex = -1;
+  let bestScore = -1;
+  for (let index = 0; index < started; index++) {
+    const available = options.maxSubsetSize - subsets[index].length;
+    if (available < familySize) {
+      continue;
+    }
+    const newSize = subsets[index].length + familySize;
+    const totalScore = 1e3 - Math.abs(newSize - options.preferredSubsetSize) + available;
+    if (totalScore > bestScore) {
+      bestScore = totalScore;
+      bestIndex = index;
+    }
+  }
+  if (bestIndex >= 0) {
+    return { index: bestIndex, nextSubset: currentSubset };
+  }
+  if (currentSubset >= maxSubsets) {
+    return null;
+  }
+  return { index: currentSubset, nextSubset: currentSubset + 1 };
+}
+var SimpleMIPSolver = class {
+  constructor(competitors, options) {
+    this.bestSolution = null;
+    this.bestObjective = -Infinity;
+    this.competitors = competitors;
+    this.options = validateAndSanitizeOptions(options, competitors.length);
+    this.numCompetitors = competitors.length;
+    this.maxSubsets = Math.min(this.options.maxSubsets, Math.ceil(competitors.length / this.options.minSubsetSize));
+    this.variables = [];
+    this.constraints = [];
+    this.initializeVariables();
+    this.initializeConstraints();
+  }
+  initializeVariables() {
+    for (let i = 0; i < this.numCompetitors; i++) {
+      for (let j = 0; j < this.maxSubsets; j++) {
+        this.variables.push({
+          competitorIndex: i,
+          subsetIndex: j,
+          value: 0
+        });
+      }
+    }
+  }
+  initializeConstraints() {
+    for (let i = 0; i < this.numCompetitors; i++) {
+      const constraint = {
+        variables: [],
+        operator: "=",
+        rhs: 1,
+        name: `competitor_${i}_assignment`
+      };
+      for (let j = 0; j < this.maxSubsets; j++) {
+        constraint.variables.push({
+          competitorIndex: i,
+          subsetIndex: j,
+          coefficient: 1
+        });
+      }
+      this.constraints.push(constraint);
+    }
+    for (let j = 0; j < this.maxSubsets; j++) {
+      const minConstraint = {
+        variables: [],
+        operator: ">=",
+        rhs: 0,
+        // Will be adjusted based on subset usage
+        name: `subset_${j}_min_size`
+      };
+      const maxConstraint = {
+        variables: [],
+        operator: "<=",
+        rhs: this.options.maxSubsetSize,
+        name: `subset_${j}_max_size`
+      };
+      for (let i = 0; i < this.numCompetitors; i++) {
+        minConstraint.variables.push({
+          competitorIndex: i,
+          subsetIndex: j,
+          coefficient: 1
+        });
+        maxConstraint.variables.push({
+          competitorIndex: i,
+          subsetIndex: j,
+          coefficient: 1
+        });
+      }
+      this.constraints.push(maxConstraint);
+    }
+  }
+  calculateObjectiveValue(solution) {
+    const subsets = Array(this.maxSubsets).fill(null).map(() => []);
+    for (const variable of solution) {
+      if (variable.value === 1) {
+        subsets[variable.subsetIndex].push(this.competitors[variable.competitorIndex]);
+      }
+    }
+    const nonEmptySubsets = subsets.filter((subset) => subset.length > 0);
+    const validation = validatePartition(this.competitors, nonEmptySubsets, this.options);
+    if (!validation.valid) {
+      return -Infinity;
+    }
+    const result = createPartitionResult(nonEmptySubsets, this.options);
+    return result.score;
+  }
+  isSolutionValid(solution) {
+    const competitorAssignments = new Array(this.numCompetitors).fill(0);
+    for (const variable of solution) {
+      if (variable.value === 1) {
+        competitorAssignments[variable.competitorIndex]++;
+      }
+    }
+    return competitorAssignments.every((count) => count === 1);
+  }
+  solveGreedy() {
+    const solution = this.variables.map((v) => ({ ...v, value: 0 }));
+    const subsets = Array(this.maxSubsets).fill(null).map(() => []);
+    const families = createGuardianFamilies(this.competitors);
+    const unassignedFamilies = [...families];
+    let currentSubset = 0;
+    while (unassignedFamilies.length > 0 && currentSubset < this.maxSubsets) {
+      const subset = subsets[currentSubset];
+      let canAddMore = true;
+      while (canAddMore && unassignedFamilies.length > 0) {
+        let bestFamilyIndex = -1;
+        let bestScore = -Infinity;
+        for (let i = 0; i < unassignedFamilies.length; i++) {
+          const family = unassignedFamilies[i];
+          if (subset.length + family.length <= this.options.maxSubsetSize) {
+            const testSubset = [...subset, ...family];
+            const testScore = this.calculateSubsetScore(testSubset);
+            if (testScore > bestScore) {
+              bestScore = testScore;
+              bestFamilyIndex = i;
+            }
+          }
+        }
+        if (bestFamilyIndex >= 0) {
+          const family = unassignedFamilies.splice(bestFamilyIndex, 1)[0];
+          for (const competitor of family) {
+            subset.push(competitor);
+            const competitorIndex = this.competitors.findIndex((c) => c.id === competitor.id);
+            const variableIndex = competitorIndex * this.maxSubsets + currentSubset;
+            solution[variableIndex].value = 1;
+          }
+        } else {
+          canAddMore = false;
+        }
+      }
+      if (subset.length >= this.options.minSubsetSize || !canAddMore) {
+        currentSubset++;
+      } else if (unassignedFamilies.length === 0) {
+        break;
+      }
+    }
+    while (unassignedFamilies.length > 0) {
+      const family = unassignedFamilies[0];
+      const placement = openSubsetFor(subsets, family.length, currentSubset, this.options, this.maxSubsets);
+      if (!placement) {
+        break;
+      }
+      unassignedFamilies.shift();
+      currentSubset = placement.nextSubset;
+      for (const competitor of family) {
+        subsets[placement.index].push(competitor);
+        const competitorIndex = this.competitors.findIndex((c) => c.id === competitor.id);
+        const variableIndex = competitorIndex * this.maxSubsets + placement.index;
+        solution[variableIndex].value = 1;
+      }
+    }
+    return solution;
+  }
+  calculateSubsetScore(subset) {
+    return scoreSubset(subset, this.options).total;
+  }
+  solve() {
+    const greedySolution = this.solveGreedy();
+    if (this.isSolutionValid(greedySolution)) {
+      const objective = this.calculateObjectiveValue(greedySolution);
+      if (objective > this.bestObjective) {
+        this.bestObjective = objective;
+        this.bestSolution = greedySolution;
+      }
+    }
+    return this.bestSolution || greedySolution;
+  }
+  getBestSolution() {
+    return {
+      solution: this.bestSolution || [],
+      objective: this.bestObjective
+    };
+  }
+};
+function solveMIP(competitors, options = {}) {
+  const startTime = performance.now();
+  if (competitors.length === 0) {
+    return handleEmptyDataset(options, "Mixed Integer Programming");
+  }
+  const opts = validateAndSanitizeOptions(options, competitors.length);
+  const solver = new SimpleMIPSolver(competitors, opts);
+  const solution = solver.solve();
+  const subsets = Array(opts.maxSubsets).fill(null).map(() => []);
+  for (const variable of solution) {
+    if (variable.value === 1) {
+      subsets[variable.subsetIndex].push(competitors[variable.competitorIndex]);
+    }
+  }
+  const nonEmptySubsets = subsets.filter((subset) => subset.length > 0);
+  return createAlgorithmResult(competitors, nonEmptySubsets, opts, "Mixed Integer Programming", startTime);
+}
+
+// src/algorithms/mip-solver-lp.ts
+function loadHighs() {
+  const highs = __require("highs");
+  return highs();
+}
+var HiGHSMIPSolver = class {
+  constructor(competitors, options) {
+    this.competitors = competitors;
+    this.families = createGuardianFamilies(competitors);
+    this.options = options;
+    this.maxSubsets = Math.min(this.options.maxSubsets, Math.ceil(competitors.length / this.options.minSubsetSize));
+  }
+  /**
+   * Creates a MIP model for the HiGHS solver
+   */
+  createMIPModel() {
+    const model = {
+      sense: "maximize",
+      variables: [],
+      constraints: []
+    };
+    const variableMap = /* @__PURE__ */ new Map();
+    let varIndex = 0;
+    for (let i = 0; i < this.families.length; i++) {
+      for (let j = 0; j < this.maxSubsets; j++) {
+        const varName = `x_${i}_${j}`;
+        variableMap.set(varName, varIndex++);
+        const cost = this.calculateObjectiveCoefficient(i, j);
+        model.variables.push({
+          name: varName,
+          lower: 0,
+          upper: 1,
+          type: "binary",
+          cost
+        });
+      }
+    }
+    for (let i = 0; i < this.families.length; i++) {
+      const entries = [];
+      for (let j = 0; j < this.maxSubsets; j++) {
+        const varName = `x_${i}_${j}`;
+        entries.push({ variable: varName, coefficient: 1 });
+      }
+      model.constraints.push({
+        name: `assign_family_${i}`,
+        lower: 1,
+        upper: 1,
+        entries
+      });
+    }
+    for (let j = 0; j < this.maxSubsets; j++) {
+      const entries = [];
+      for (let i = 0; i < this.families.length; i++) {
+        const varName = `x_${i}_${j}`;
+        const familySize = this.families[i].length;
+        entries.push({ variable: varName, coefficient: familySize });
+      }
+      model.constraints.push({
+        name: `max_size_subset_${j}`,
+        lower: 0,
+        upper: this.options.maxSubsetSize,
+        entries
+      });
+    }
+    for (let j = 0; j < this.maxSubsets; j++) {
+      const indicatorVarName = `y_${j}`;
+      variableMap.set(indicatorVarName, varIndex++);
+      model.variables.push({
+        name: indicatorVarName,
+        lower: 0,
+        upper: 1,
+        type: "binary",
+        cost: -0.1
+        // Small penalty for using more subsets
+      });
+      const linkEntries = [];
+      linkEntries.push({ variable: indicatorVarName, coefficient: -this.options.maxSubsetSize });
+      for (let i = 0; i < this.families.length; i++) {
+        const varName = `x_${i}_${j}`;
+        linkEntries.push({ variable: varName, coefficient: 1 });
+      }
+      model.constraints.push({
+        name: `link_subset_${j}`,
+        lower: -Infinity,
+        upper: 0,
+        entries: linkEntries
+      });
+      const minSizeEntries = [];
+      minSizeEntries.push({ variable: indicatorVarName, coefficient: -this.options.minSubsetSize });
+      for (let i = 0; i < this.families.length; i++) {
+        const varName = `x_${i}_${j}`;
+        const familySize = this.families[i].length;
+        minSizeEntries.push({ variable: varName, coefficient: familySize });
+      }
+      model.constraints.push({
+        name: `min_size_subset_${j}`,
+        lower: 0,
+        upper: Infinity,
+        entries: minSizeEntries
+      });
+    }
+    return model;
+  }
+  /**
+   * Calculates the objective coefficient for a family-subset assignment
+   */
+  calculateObjectiveCoefficient(familyIndex, subsetIndex) {
+    const family = this.families[familyIndex];
+    const familySize = family.length;
+    let coefficient = 10;
+    if (familySize === this.options.preferredSubsetSize) {
+      coefficient += 5 + 10 * this.options.closedGroupWeight;
+    } else if (familySize <= this.options.preferredSubsetSize) {
+      coefficient += 3;
+    }
+    const hasMultipleGenders = new Set(family.map((c) => c.gender)).size > 1;
+    if (hasMultipleGenders) {
+      coefficient += 2 * this.options.genderWeight;
+    }
+    const uniqueAges = new Set(family.map((c) => c.ageCategory)).size;
+    if (uniqueAges === 1) {
+      coefficient += 2 * this.options.ageCategoryWeight;
+    }
+    const uniqueEquipment = new Set(family.map((c) => c.equipmentClass)).size;
+    if (this.options.groupByEquipmentClass && uniqueEquipment === 1) {
+      coefficient += 2 * this.options.equipmentClassWeight;
+    } else if (!this.options.groupByEquipmentClass && uniqueEquipment > 1) {
+      coefficient += 1 * this.options.equipmentClassWeight;
+    }
+    return coefficient;
+  }
+  /**
+   * Solves the MIP model using HiGHS and returns the solution
+   */
+  async solve() {
+    const model = this.createMIPModel();
+    if (this.families.length <= 5) {
+      console.log(`HiGHS model: ${model.variables.length} variables, ${model.constraints.length} constraints`);
+    }
+    const lpModel = this.convertToLPFormat(model);
+    const solver = await loadHighs();
+    const solution = solver.solve(lpModel);
+    if (this.families.length <= 5) {
+      console.log("HiGHS solution status:", solution.Status);
+    }
+    if (!solution) {
+      throw new Error("HiGHS solver returned no solution");
+    }
+    if (solution.Status !== "Optimal") {
+      throw new Error(`HiGHS solver failed with status: ${solution.Status}`);
+    }
+    const subsets = Array(this.maxSubsets).fill(null).map(() => []);
+    for (let i = 0; i < this.families.length; i++) {
+      for (let j = 0; j < this.maxSubsets; j++) {
+        const varName = `x_${i}_${j}`;
+        const column = solution.Columns[varName];
+        if (column && column.Primal > 0.5) {
+          subsets[j].push(...this.families[i]);
+          break;
+        }
+      }
+    }
+    const nonEmptySubsets = subsets.filter((subset) => subset.length > 0);
+    if (!this.validateSolution(nonEmptySubsets)) {
+      throw new Error("HiGHS solution validation failed - constraints not met");
+    }
+    return nonEmptySubsets;
+  }
+  /**
+   * Converts our HiGHS model to LP format string that HiGHS can understand
+   */
+  convertToLPFormat(model) {
+    let lp = "";
+    lp += model.sense === "maximize" ? "Maximize\n" : "Minimize\n";
+    lp += "obj: ";
+    const objTerms = [];
+    for (const variable of model.variables) {
+      if (variable.cost !== 0) {
+        const sign = variable.cost >= 0 ? "+" : "";
+        objTerms.push(`${sign}${variable.cost} ${variable.name}`);
+      }
+    }
+    lp += objTerms.join(" ") + "\n\n";
+    lp += "Subject To\n";
+    for (const constraint of model.constraints) {
+      let constraintStr = `${constraint.name}: `;
+      const terms = [];
+      for (const entry of constraint.entries) {
+        const sign = entry.coefficient >= 0 ? "+" : "";
+        terms.push(`${sign}${entry.coefficient} ${entry.variable}`);
+      }
+      constraintStr += terms.join(" ");
+      if (constraint.lower === constraint.upper) {
+        constraintStr += ` = ${constraint.lower}`;
+      } else {
+        if (constraint.lower > -Infinity) {
+          constraintStr += ` >= ${constraint.lower}`;
+        }
+        if (constraint.upper < Infinity) {
+          if (constraint.lower > -Infinity) {
+            lp += constraintStr + "\n";
+            constraintStr = `${constraint.name}_upper: ${terms.join(" ")} <= ${constraint.upper}`;
+          } else {
+            constraintStr += ` <= ${constraint.upper}`;
+          }
+        }
+      }
+      lp += constraintStr + "\n";
+    }
+    lp += "\nBounds\n";
+    const binaryVars = [];
+    for (const variable of model.variables) {
+      if (variable.type === "binary") {
+        binaryVars.push(variable.name);
+      } else {
+        if (variable.lower !== 0 || variable.upper !== Infinity) {
+          lp += `${variable.lower} <= ${variable.name} <= ${variable.upper}
+`;
+        }
+      }
+    }
+    if (binaryVars.length > 0) {
+      lp += "\nBinary\n";
+      lp += binaryVars.join(" ") + "\n";
+    }
+    lp += "\nEnd\n";
+    if (this.families.length <= 3) {
+      console.log("Generated LP model:");
+      console.log(lp);
+    }
+    return lp;
+  }
+  /**
+   * Validates that the solution meets all constraints
+   */
+  validateSolution(subsets) {
+    const assignedIds = /* @__PURE__ */ new Set();
+    for (const subset of subsets) {
+      for (const competitor of subset) {
+        if (assignedIds.has(competitor.id)) {
+          return false;
+        }
+        assignedIds.add(competitor.id);
+      }
+    }
+    if (assignedIds.size !== this.competitors.length) {
+      return false;
+    }
+    for (const subset of subsets) {
+      if (subset.length < this.options.minSubsetSize || subset.length > this.options.maxSubsetSize) {
+        return false;
+      }
+    }
+    for (const subset of subsets) {
+      const subsetIds = new Set(subset.map((c) => c.id));
+      for (const competitor of subset) {
+        if (competitor.guardianId && !subsetIds.has(competitor.guardianId)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+};
+async function solveMIPWithLP(competitors, options = {}) {
+  const startTime = performance.now();
+  const opts = validateAndSanitizeOptions(options, competitors.length);
+  if (competitors.length === 0) {
+    return {
+      result: createPartitionResult([], opts),
+      executionTime: 0,
+      algorithmUsed: "Mixed Integer Programming (HiGHS)"
+    };
+  }
+  const solver = new HiGHSMIPSolver(competitors, opts);
+  const subsets = await solver.solve();
+  const legalSubsets = retainLegalSubsets(subsets, opts.minSubsetSize, opts.maxSubsetSize);
+  const result = createPartitionResult(legalSubsets, opts);
+  const executionTime = performance.now() - startTime;
+  return {
+    result,
+    executionTime,
+    algorithmUsed: "Mixed Integer Programming (HiGHS)"
+  };
+}
+
+// src/algorithms/clustering.ts
+function encodeCompetitor(competitor, allCompetitors) {
+  const uniqueGenders = [...new Set(allCompetitors.map((c) => c.gender))];
+  const uniqueAgeCategories = [...new Set(allCompetitors.map((c) => c.ageCategory))];
+  const uniqueEquipmentClasses = [...new Set(allCompetitors.map((c) => c.equipmentClass))];
+  const features = [];
+  for (const gender of uniqueGenders) {
+    features.push(competitor.gender === gender ? 1 : 0);
+  }
+  for (const ageCategory of uniqueAgeCategories) {
+    features.push(competitor.ageCategory === ageCategory ? 1 : 0);
+  }
+  for (const equipmentClass of uniqueEquipmentClasses) {
+    features.push(competitor.equipmentClass === equipmentClass ? 1 : 0);
+  }
+  features.push(competitor.guardianId ? 1 : 0);
+  return features;
+}
+function calculateDistance(features1, features2) {
+  let sum = 0;
+  for (let i = 0; i < features1.length; i++) {
+    const diff = features1[i] - features2[i];
+    sum += diff * diff;
+  }
+  return Math.sqrt(sum);
+}
+function calculateWeightedDistance(features1, features2, options, featureWeights) {
+  let sum = 0;
+  for (let i = 0; i < features1.length; i++) {
+    const diff = features1[i] - features2[i];
+    let weight = 1;
+    if (i >= featureWeights.genderStart && i < featureWeights.ageStart) {
+      weight = options.genderWeight;
+    } else if (i >= featureWeights.ageStart && i < featureWeights.equipmentStart) {
+      weight = options.ageCategoryWeight;
+    } else if (i >= featureWeights.equipmentStart) {
+      weight = options.equipmentClassWeight;
+    }
+    sum += weight * diff * diff;
+  }
+  return Math.sqrt(sum);
+}
+function initializeClusterCenters(familyFeatures, numClusters, options) {
+  const centers = [];
+  const families = [...familyFeatures];
+  const firstCenter = families[Math.floor(Math.random() * families.length)];
+  centers.push({
+    id: 0,
+    features: [...firstCenter.features],
+    members: []
+  });
+  for (let i = 1; i < numClusters; i++) {
+    const distances = families.map((family) => {
+      const minDist = Math.min(...centers.map(
+        (center) => calculateDistance(family.features, center.features)
+      ));
+      return minDist * minDist;
+    });
+    const totalDistance = distances.reduce((sum, dist) => sum + dist, 0);
+    const randomValue = Math.random() * totalDistance;
+    let cumulativeDistance = 0;
+    let selectedIndex = 0;
+    for (let j = 0; j < distances.length; j++) {
+      cumulativeDistance += distances[j];
+      if (cumulativeDistance >= randomValue) {
+        selectedIndex = j;
+        break;
+      }
+    }
+    centers.push({
+      id: i,
+      features: [...families[selectedIndex].features],
+      members: []
+    });
+  }
+  return centers;
+}
+function createFamilyFeatures(families, allCompetitors) {
+  return families.map((family, familyIndex) => {
+    const familyMemberFeatures = family.map(
+      (competitor) => encodeCompetitor(competitor, allCompetitors)
+    );
+    const avgFeatures = new Array(familyMemberFeatures[0].length).fill(0);
+    for (const memberFeatures of familyMemberFeatures) {
+      for (let i = 0; i < memberFeatures.length; i++) {
+        avgFeatures[i] += memberFeatures[i];
+      }
+    }
+    for (let i = 0; i < avgFeatures.length; i++) {
+      avgFeatures[i] /= familyMemberFeatures.length;
+    }
+    return {
+      family,
+      features: avgFeatures,
+      clusterId: -1
+    };
+  });
+}
+function assignToClusters(familyFeatures, centers, options, featureWeights) {
+  centers.forEach((center) => center.members = []);
+  for (const family of familyFeatures) {
+    let minDistance = Infinity;
+    let bestCluster = 0;
+    for (let i = 0; i < centers.length; i++) {
+      const distance = calculateWeightedDistance(
+        family.features,
+        centers[i].features,
+        options,
+        featureWeights
+      );
+      if (distance < minDistance) {
+        minDistance = distance;
+        bestCluster = i;
+      }
+    }
+    family.clusterId = bestCluster;
+    centers[bestCluster].members.push(family);
+  }
+}
+function updateClusterCenters(centers) {
+  let changed = false;
+  for (const center of centers) {
+    if (center.members.length === 0) continue;
+    const newFeatures = new Array(center.features.length).fill(0);
+    for (const member of center.members) {
+      for (let i = 0; i < member.features.length; i++) {
+        newFeatures[i] += member.features[i];
+      }
+    }
+    for (let i = 0; i < newFeatures.length; i++) {
+      newFeatures[i] /= center.members.length;
+    }
+    for (let i = 0; i < center.features.length; i++) {
+      if (Math.abs(center.features[i] - newFeatures[i]) > 1e-6) {
+        changed = true;
+        break;
+      }
+    }
+    center.features = newFeatures;
+  }
+  return changed;
+}
+function adjustClusterSizes(centers, options, maxAllowedClusters) {
+  const effectiveMaxSubsets = maxAllowedClusters || options.maxSubsets;
+  const validCenters = [];
+  const redistributeFamilies = [];
+  for (const center of centers) {
+    if (center.members.length === 0) {
+      continue;
+    }
+    const totalCompetitors = center.members.reduce((sum, family) => sum + family.family.length, 0);
+    if (totalCompetitors <= options.maxSubsetSize && totalCompetitors >= options.minSubsetSize) {
+      validCenters.push(center);
+    } else if (totalCompetitors > options.maxSubsetSize) {
+      const shuffledFamilies = shuffle([...center.members]);
+      let currentCluster = [];
+      let currentSize = 0;
+      for (const family of shuffledFamilies) {
+        const familySize = family.family.length;
+        if (currentSize + familySize > options.maxSubsetSize) {
+          if (currentSize >= options.minSubsetSize) {
+            validCenters.push({
+              id: validCenters.length,
+              features: center.features,
+              members: [...currentCluster]
+            });
+          } else {
+            redistributeFamilies.push(...currentCluster);
+          }
+          currentCluster = [family];
+          currentSize = familySize;
+        } else {
+          currentCluster.push(family);
+          currentSize += familySize;
+        }
+      }
+      if (currentCluster.length > 0) {
+        if (currentSize >= options.minSubsetSize) {
+          validCenters.push({
+            id: validCenters.length,
+            features: center.features,
+            members: currentCluster
+          });
+        } else {
+          redistributeFamilies.push(...currentCluster);
+        }
+      }
+    } else {
+      redistributeFamilies.push(...center.members);
+    }
+  }
+  while (redistributeFamilies.length > 0) {
+    let placed = false;
+    for (const center of validCenters) {
+      if (redistributeFamilies.length === 0) break;
+      const currentSize = center.members.reduce((sum, family) => sum + family.family.length, 0);
+      for (let i = redistributeFamilies.length - 1; i >= 0; i--) {
+        const family = redistributeFamilies[i];
+        if (currentSize + family.family.length <= options.maxSubsetSize) {
+          center.members.push(family);
+          redistributeFamilies.splice(i, 1);
+          placed = true;
+          break;
+        }
+      }
+    }
+    if (!placed && redistributeFamilies.length > 0 && validCenters.length < effectiveMaxSubsets) {
+      const newCluster = [];
+      let newClusterSize = 0;
+      while (redistributeFamilies.length > 0 && newClusterSize < options.preferredSubsetSize) {
+        const family = redistributeFamilies.shift();
+        if (newClusterSize + family.family.length <= options.maxSubsetSize) {
+          newCluster.push(family);
+          newClusterSize += family.family.length;
+        } else {
+          redistributeFamilies.unshift(family);
+          break;
+        }
+      }
+      if (newCluster.length > 0) {
+        const newFeatures = new Array(newCluster[0].features.length).fill(0);
+        for (const family of newCluster) {
+          for (let i = 0; i < family.features.length; i++) {
+            newFeatures[i] += family.features[i];
+          }
+        }
+        for (let i = 0; i < newFeatures.length; i++) {
+          newFeatures[i] /= newCluster.length;
+        }
+        validCenters.push({
+          id: validCenters.length,
+          features: newFeatures,
+          members: newCluster
+        });
+      }
+      if (redistributeFamilies.length > 0 && (newCluster.length === 0 || validCenters.length >= effectiveMaxSubsets)) {
+        while (redistributeFamilies.length > 0) {
+          let smallestCenter = validCenters[0];
+          let smallestSize = smallestCenter.members.reduce((sum, family2) => sum + family2.family.length, 0);
+          for (const center of validCenters) {
+            const size = center.members.reduce((sum, family2) => sum + family2.family.length, 0);
+            if (size < smallestSize) {
+              smallestCenter = center;
+              smallestSize = size;
+            }
+          }
+          const family = redistributeFamilies.shift();
+          smallestCenter.members.push(family);
+        }
+      }
+    }
+    if (!placed && redistributeFamilies.length > 0) {
+      const family = redistributeFamilies.shift();
+      placeFamilyInSmallestCenter(validCenters, family);
+    }
+  }
+  return validCenters;
+}
+function placeFamilyInSmallestCenter(validCenters, family) {
+  if (validCenters.length === 0) {
+    validCenters.push({ id: 0, features: [...family.features], members: [family] });
+    return;
+  }
+  let smallestCenter = validCenters[0];
+  let smallestSize = centerSize(smallestCenter);
+  for (const center of validCenters) {
+    const size = centerSize(center);
+    if (size < smallestSize) {
+      smallestCenter = center;
+      smallestSize = size;
+    }
+  }
+  smallestCenter.members.push(family);
+}
+function centerSize(center) {
+  return center.members.reduce((sum, family) => sum + family.family.length, 0);
+}
+function solveClustering(competitors, options = {}) {
+  const startTime = performance.now();
+  if (competitors.length === 0) {
+    return handleEmptyDataset(options, "K-means Clustering");
+  }
+  const opts = validateAndSanitizeOptions(options, competitors.length);
+  const families = createGuardianFamilies(competitors);
+  const familyFeatures = createFamilyFeatures(families, competitors);
+  const uniqueGenders = [...new Set(competitors.map((c) => c.gender))];
+  const uniqueAgeCategories = [...new Set(competitors.map((c) => c.ageCategory))];
+  const featureWeights = {
+    genderStart: 0,
+    ageStart: uniqueGenders.length,
+    equipmentStart: uniqueGenders.length + uniqueAgeCategories.length
+  };
+  const totalCompetitors = competitors.length;
+  const minClusters = Math.ceil(totalCompetitors / opts.maxSubsetSize);
+  const maxClusters = Math.min(opts.maxSubsets, Math.floor(totalCompetitors / opts.minSubsetSize));
+  const preferredClusters = Math.round(totalCompetitors / opts.preferredSubsetSize);
+  const numClusters = Math.min(
+    maxClusters,
+    Math.max(minClusters, Math.min(preferredClusters, families.length))
+  );
+  let centers = initializeClusterCenters(familyFeatures, numClusters, opts);
+  const maxIterations = 100;
+  for (let iteration = 0; iteration < maxIterations; iteration++) {
+    assignToClusters(familyFeatures, centers, opts, featureWeights);
+    const centersChanged = updateClusterCenters(centers);
+    if (!centersChanged) {
+      break;
+    }
+  }
+  const adjustedCenters = adjustClusterSizes(centers, opts, numClusters);
+  let subsets = adjustedCenters.map((center) => {
+    const subset = [];
+    for (const family of center.members) {
+      subset.push(...family.family);
+    }
+    return subset;
+  });
+  while (subsets.length > opts.maxSubsets) {
+    let bestMerge = null;
+    let bestScore = -1;
+    for (let i = 0; i < subsets.length - 1; i++) {
+      for (let j = i + 1; j < subsets.length; j++) {
+        const combinedSize = subsets[i].length + subsets[j].length;
+        let score = 0;
+        if (combinedSize <= opts.maxSubsetSize) {
+          score = 1e3 - combinedSize;
+        } else if (combinedSize <= opts.maxSubsetSize + 1) {
+          score = 50 - combinedSize;
+        } else {
+          score = 10 - combinedSize;
+        }
+        if (score > bestScore) {
+          bestScore = score;
+          bestMerge = { i, j, combinedSize };
+        }
+      }
+    }
+    if (bestMerge) {
+      subsets[bestMerge.i].push(...subsets[bestMerge.j]);
+      subsets.splice(bestMerge.j, 1);
+    } else {
+      let smallestIdx1 = 0, smallestIdx2 = 1;
+      for (let i = 0; i < subsets.length; i++) {
+        if (subsets[i].length < subsets[smallestIdx1].length) {
+          smallestIdx2 = smallestIdx1;
+          smallestIdx1 = i;
+        } else if (i !== smallestIdx1 && subsets[i].length < subsets[smallestIdx2].length) {
+          smallestIdx2 = i;
+        }
+      }
+      subsets[smallestIdx1].push(...subsets[smallestIdx2]);
+      subsets.splice(smallestIdx2, 1);
+    }
+  }
+  if (subsets.length === opts.maxSubsets) {
+    const totalCompetitors2 = subsets.reduce((sum, subset) => sum + subset.length, 0);
+    const targetSize = Math.floor(totalCompetitors2 / opts.maxSubsets);
+    const remainder = totalCompetitors2 % opts.maxSubsets;
+    const oversized = subsets.filter((s) => s.length > opts.maxSubsetSize);
+    const undersized = subsets.filter((s) => s.length < opts.minSubsetSize);
+    if (oversized.length > 0 || undersized.length > 0) {
+      const familiesInSubsets = families.map((family) => {
+        const familyIds = new Set(family.map((c) => c.id));
+        for (let i = 0; i < subsets.length; i++) {
+          const subsetIds = new Set(subsets[i].map((c) => c.id));
+          if (family.every((c) => subsetIds.has(c.id))) {
+            return { family, subsetIndex: i };
+          }
+        }
+        return { family, subsetIndex: -1 };
+      });
+      subsets.length = 0;
+      const sortedFamilies = familiesInSubsets.sort((a, b) => b.family.length - a.family.length);
+      for (const { family } of sortedFamilies) {
+        let bestSubsetIndex = -1;
+        let bestScore = -1;
+        for (let i = 0; i < Math.min(subsets.length, opts.maxSubsets); i++) {
+          const newSize = subsets[i].length + family.length;
+          if (newSize <= opts.maxSubsetSize) {
+            const score = 1e3 - Math.abs(newSize - targetSize);
+            if (score > bestScore) {
+              bestScore = score;
+              bestSubsetIndex = i;
+            }
+          }
+        }
+        if (bestSubsetIndex === -1 && subsets.length < opts.maxSubsets) {
+          subsets.push([]);
+          bestSubsetIndex = subsets.length - 1;
+        }
+        if (bestSubsetIndex !== -1) {
+          subsets[bestSubsetIndex].push(...family);
+        } else {
+          let smallestIndex = 0;
+          for (let i = 1; i < subsets.length; i++) {
+            if (subsets[i].length < subsets[smallestIndex].length) {
+              smallestIndex = i;
+            }
+          }
+          subsets[smallestIndex].push(...family);
+        }
+      }
+    }
+  }
+  let finalUndersized = subsets.filter((s) => s.length < opts.minSubsetSize);
+  let maxCleanupIterations = subsets.length;
+  let cleanupIterations = 0;
+  while (finalUndersized.length > 0 && cleanupIterations < maxCleanupIterations) {
+    cleanupIterations++;
+    let smallestUndersized = finalUndersized[0];
+    let smallestIdx = subsets.indexOf(smallestUndersized);
+    for (const undersized of finalUndersized) {
+      if (undersized.length < smallestUndersized.length) {
+        smallestUndersized = undersized;
+        smallestIdx = subsets.indexOf(undersized);
+      }
+    }
+    let bestMergeIdx = -1;
+    let bestMergeSize = Infinity;
+    for (let i = 0; i < subsets.length; i++) {
+      if (i === smallestIdx) continue;
+      const combinedSize = subsets[i].length + smallestUndersized.length;
+      if (combinedSize <= opts.maxSubsetSize && subsets[i].length < bestMergeSize) {
+        bestMergeSize = subsets[i].length;
+        bestMergeIdx = i;
+      }
+    }
+    if (bestMergeIdx === -1) {
+      bestMergeIdx = 0;
+      for (let i = 1; i < subsets.length; i++) {
+        if (i !== smallestIdx && subsets[i].length < subsets[bestMergeIdx].length) {
+          bestMergeIdx = i;
+        }
+      }
+    }
+    if (bestMergeIdx !== -1 && bestMergeIdx !== smallestIdx) {
+      subsets[bestMergeIdx].push(...smallestUndersized);
+      subsets.splice(smallestIdx, 1);
+      finalUndersized = subsets.filter((s) => s.length < opts.minSubsetSize);
+    } else {
+      break;
+    }
+  }
+  return createAlgorithmResult(competitors, subsets, opts, "K-means Clustering", startTime);
+}
+
+// src/index.ts
+async function solve(competitors, options = {}) {
+  const algorithm = options.algorithm || "auto";
+  switch (algorithm) {
+    case "mip":
+      return solveMIP(competitors, options);
+    case "mip-lp":
+      return await solveMIPWithLP(competitors, options);
+    case "clustering":
+      return solveClustering(competitors, options);
+    case "auto":
+    default:
+      const results = [
+        solveMIP(competitors, options),
+        await solveMIPWithLP(competitors, options),
+        solveClustering(competitors, options)
+      ];
+      const bestResult = results.reduce(
+        (best, current) => current.result.score > best.result.score ? current : best
+      );
+      return {
+        ...bestResult,
+        algorithmUsed: `${bestResult.algorithmUsed} (auto-selected)`
+      };
+  }
+}
+async function compareAlgorithms(competitors, options = {}) {
+  const { algorithm, ...algorithmOptions } = options;
+  const results = [
+    solveMIP(competitors, algorithmOptions),
+    await solveMIPWithLP(competitors, algorithmOptions),
+    solveClustering(competitors, algorithmOptions)
+  ];
+  const bestResult = results.reduce(
+    (best, current) => current.result.score > best.result.score ? current : best
+  );
+  return {
+    bestResult,
+    allResults: results
+  };
+}
+var version = "0.1.0";
+export {
+  AGE_GROUPS,
+  AGE_GROUP_DESCRIPTIONS,
+  DEFAULT_OPTIONS,
+  EQUIPMENT_CLASSES,
+  EQUIPMENT_CLASS_DESCRIPTIONS,
+  GENDERS,
+  GENDER_DESCRIPTIONS,
+  MINIMUM_SUBSET_SIZE,
+  calculateScore,
+  compareAgeGroups,
+  compareAlgorithms,
+  createGuardianFamilies,
+  createPartitionResult,
+  getAgeGroupOrder,
+  getGuardianGroups,
+  isValidAgeGroup,
+  isValidCompetitor,
+  isValidEquipmentClass,
+  isValidGender,
+  retainLegalSubsets,
+  smallestAllowedSubset,
+  solve,
+  solveClustering,
+  solveMIP,
+  solveMIPWithLP,
+  validateCompetitors,
+  validateGuardianConstraints,
+  validatePartition,
+  version
+};
+//# sourceMappingURL=index.mjs.map