@org-design-studio/core 0.1.0

package/dist-core/core.mjs

@@ -0,0 +1,2280 @@
+import { hierarchy, tree } from 'd3-hierarchy';
+
+// src/lib/types.ts
+function positionStatus(e) {
+  return e.position_status === "vacant" || e.position_status === "tbh" ? e.position_status : "filled";
+}
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var DEFAULT_TITLE_NOISE_WORDS = [
+  "senior",
+  "sr",
+  "jr",
+  "junior",
+  "principal",
+  "i",
+  "ii",
+  "iii",
+  "iv",
+  "v",
+  "1",
+  "2",
+  "3"
+];
+var DEFAULT_ASSUMPTIONS = {
+  narrowSpanThreshold: 4,
+  wideSpanThreshold: 12,
+  targetSpansByLevel: [
+    { level: 1, label: "Executive (L1\u2013L2)", min: 5, max: 8 },
+    { level: 3, label: "Middle management (L3\u2013L4)", min: 6, max: 10 },
+    { level: 5, label: "Frontline management (L5+)", min: 8, max: 15 }
+  ],
+  targetMaxLayers: 7,
+  delayeringSavingPct: 50,
+  duplicateRoleSavingPct: 30,
+  spanOptPremiumPct: 20,
+  locationCostMultipliers: {
+    "New York": 1,
+    London: 0.95,
+    Singapore: 0.85,
+    Dublin: 0.8,
+    Warsaw: 0.45,
+    Bangalore: 0.35,
+    Manila: 0.3
+  },
+  currency: "USD",
+  currencySymbol: "$",
+  scoringWeights: {
+    financialImpact: 25,
+    spanImprovement: 15,
+    layerReduction: 15,
+    complexityReduction: 15,
+    changeRisk: 20,
+    implementationEase: 10
+  },
+  benchmarkLayersForSize: [
+    { maxHeadcount: 100, layers: 4 },
+    { maxHeadcount: 500, layers: 6 },
+    { maxHeadcount: 2e3, layers: 7 },
+    { maxHeadcount: 1e4, layers: 8 }
+  ],
+  transitionAssumptions: {
+    severanceMonthsByLevel: [
+      { maxLevel: 2, months: 12 },
+      { maxLevel: 4, months: 9 },
+      { maxLevel: 99, months: 6 }
+    ],
+    backfillPct: 20,
+    oneTimeChangeCostPerMove: 2e3,
+    effectiveMonth: 4,
+    countrySeveranceMultipliers: {}
+  },
+  aiAugmentationByRoleFamily: {},
+  titleNoiseWords: [...DEFAULT_TITLE_NOISE_WORDS],
+  highCostThreshold: 4e5
+};
+var REQUIRED_FIELDS = [
+  "employee_id",
+  "employee_name",
+  "role_title",
+  "manager_id",
+  "department",
+  "function",
+  "business_unit",
+  "location",
+  "country",
+  "grade",
+  "level",
+  "employment_type",
+  "fte",
+  "salary",
+  "bonus",
+  "total_cost",
+  "status"
+];
+var OPTIONAL_FIELDS = [
+  "manager_name",
+  "position_status",
+  "tenure",
+  "gender",
+  "age_band",
+  "performance_rating",
+  "potential_rating",
+  "critical_role",
+  "role_family",
+  "role_type",
+  "cost_center",
+  "legal_entity",
+  "contract_type",
+  "remote_status",
+  "skills",
+  "succession_risk",
+  "attrition_risk",
+  "change_impact",
+  "comments"
+];
+
+// src/lib/hierarchy.ts
+var ACTIVE = (e) => (e.status || "Active").toLowerCase() !== "inactive";
+function buildOrgTree(employees) {
+  const active = employees.filter(ACTIVE);
+  const byId = /* @__PURE__ */ new Map();
+  for (const e of active) byId.set(e.employee_id, e);
+  const nodes = /* @__PURE__ */ new Map();
+  const childrenOf = /* @__PURE__ */ new Map();
+  const roots = [];
+  const orphans = [];
+  for (const e of active) {
+    nodes.set(e.employee_id, {
+      employee: e,
+      layer: 0,
+      directReports: [],
+      span: 0,
+      filledSpan: 0,
+      downstreamHeadcount: 0,
+      downstreamCost: 0,
+      isManager: false,
+      isManagerOfOne: false,
+      managesOnlyManagers: false,
+      managerChain: []
+    });
+  }
+  for (const e of active) {
+    const mid = e.manager_id;
+    if (!mid || mid === e.employee_id) {
+      roots.push(e.employee_id);
+    } else if (!byId.has(mid)) {
+      orphans.push(e.employee_id);
+    } else {
+      (childrenOf.get(mid) ?? childrenOf.set(mid, []).get(mid)).push(e.employee_id);
+    }
+  }
+  const circular = /* @__PURE__ */ new Set();
+  const safe = new Set(roots);
+  for (const e of active) {
+    if (safe.has(e.employee_id) || circular.has(e.employee_id)) continue;
+    const path = [];
+    const onPath = /* @__PURE__ */ new Set();
+    let cur = e.employee_id;
+    while (cur) {
+      if (safe.has(cur)) break;
+      if (circular.has(cur)) {
+        path.forEach((p) => circular.add(p));
+        break;
+      }
+      if (onPath.has(cur)) {
+        const loopStart = path.indexOf(cur);
+        path.slice(loopStart).forEach((p) => circular.add(p));
+        break;
+      }
+      onPath.add(cur);
+      path.push(cur);
+      const mgr = byId.get(cur)?.manager_id ?? null;
+      if (!mgr || !byId.has(mgr) || mgr === cur) break;
+      cur = mgr;
+    }
+    if (!path.some((p) => circular.has(p))) path.forEach((p) => safe.add(p));
+  }
+  const startIds = [...roots, ...orphans];
+  let maxLayer = 0;
+  const queue = startIds.map((id) => ({
+    id,
+    layer: 1,
+    chain: []
+  }));
+  const visited = /* @__PURE__ */ new Set();
+  let head = 0;
+  while (head < queue.length) {
+    const { id, layer, chain } = queue[head++];
+    if (visited.has(id) || circular.has(id)) continue;
+    visited.add(id);
+    const node = nodes.get(id);
+    node.layer = layer;
+    node.managerChain = chain;
+    maxLayer = Math.max(maxLayer, layer);
+    const kids = (childrenOf.get(id) ?? []).filter((k) => !circular.has(k));
+    node.directReports = kids;
+    node.span = kids.length;
+    node.filledSpan = kids.filter((k) => positionStatus(byId.get(k)) === "filled").length;
+    node.isManager = kids.length > 0;
+    for (const kid of kids) queue.push({ id: kid, layer: layer + 1, chain: [...chain, id] });
+  }
+  const ordered = [...visited].sort((a, b) => nodes.get(b).layer - nodes.get(a).layer);
+  for (const id of ordered) {
+    const node = nodes.get(id);
+    let hc = 0;
+    let cost = 0;
+    for (const kid of node.directReports) {
+      const kn = nodes.get(kid);
+      hc += 1 + kn.downstreamHeadcount;
+      cost += (kn.employee.total_cost || 0) + kn.downstreamCost;
+    }
+    node.downstreamHeadcount = hc;
+    node.downstreamCost = cost;
+    node.isManagerOfOne = node.span === 1;
+    node.managesOnlyManagers = node.span > 0 && node.directReports.every((kid) => (nodes.get(kid)?.span ?? 0) > 0);
+  }
+  return { nodes, roots, maxLayer, orphans, circular: [...circular] };
+}
+function subtreeIds(tree2, id) {
+  const out = [];
+  const stack = [id];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    const node = tree2.nodes.get(cur);
+    if (!node) continue;
+    out.push(cur);
+    stack.push(...node.directReports);
+  }
+  return out;
+}
+function deepestChains(tree2, topN = 5) {
+  const chains = [];
+  for (const [id, node] of tree2.nodes) {
+    if (node.directReports.length === 0 && node.layer > 0) {
+      chains.push({ ids: [...node.managerChain, id], depth: node.layer });
+    }
+  }
+  chains.sort((a, b) => b.depth - a.depth);
+  return chains.slice(0, topN);
+}
+function wouldCreateCycle(tree2, employeeId, newManagerId) {
+  if (employeeId === newManagerId) return true;
+  return subtreeIds(tree2, employeeId).includes(newManagerId);
+}
+
+// src/lib/utils.ts
+function fmtMoney(value, symbol = "$") {
+  const abs = Math.abs(value);
+  const sign = value < 0 ? "-" : "";
+  if (abs >= 1e9) return `${sign}${symbol}${(abs / 1e9).toFixed(2)}B`;
+  if (abs >= 1e6) return `${sign}${symbol}${(abs / 1e6).toFixed(1)}M`;
+  if (abs >= 1e4) return `${sign}${symbol}${Math.round(abs / 1e3)}K`;
+  if (abs >= 1e3) return `${sign}${symbol}${(abs / 1e3).toFixed(1)}K`;
+  return `${sign}${symbol}${Math.round(abs)}`;
+}
+function fmtPct(value, decimals = 0) {
+  return `${(value * 100).toFixed(decimals)}%`;
+}
+function median(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function average(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+function sum(values) {
+  return values.reduce((a, b) => a + b, 0);
+}
+function groupBy(items, key) {
+  const out = {};
+  for (const item of items) {
+    const k = key(item) || "(blank)";
+    (out[k] ?? (out[k] = [])).push(item);
+  }
+  return out;
+}
+function sortedEntries(rec) {
+  return Object.entries(rec).sort((a, b) => b[1] - a[1]);
+}
+
+// src/lib/analytics.ts
+var STRUCTURAL_WORD = /(region|zone|area|tier|band|grade|level|market)$/;
+function normalizeTitle(title, noiseWords) {
+  const noise = new Set((noiseWords ?? DEFAULT_TITLE_NOISE_WORDS).map((w) => w.toLowerCase().trim()));
+  const base = title.toLowerCase().replace(/[^a-z0-9 ]/g, " ").replace(/\s+/g, " ").trim();
+  const kept = [];
+  for (const tok of base.split(" ")) {
+    if (!tok) continue;
+    const isNoise = noise.has(tok);
+    const prev = kept[kept.length - 1] ?? "";
+    if (isNoise && !STRUCTURAL_WORD.test(prev)) continue;
+    kept.push(tok);
+  }
+  return kept.join(" ").replace(/\s+/g, " ").trim();
+}
+function spanBandForLevel(level, assumptions) {
+  const bands = assumptions.targetSpansByLevel;
+  if (!bands || bands.length === 0) return void 0;
+  const sorted = [...bands].sort((a, b) => a.level - b.level);
+  let chosen = sorted[0];
+  for (const b of sorted) {
+    if (b.level <= level) chosen = b;
+    else break;
+  }
+  return chosen;
+}
+function classifySpan(span, level, assumptions) {
+  const band = level > 0 ? spanBandForLevel(level, assumptions) : void 0;
+  if (!band) {
+    return {
+      narrow: span < assumptions.narrowSpanThreshold,
+      wide: span > assumptions.wideSpanThreshold
+    };
+  }
+  const narrow = span < band.min && span < assumptions.narrowSpanThreshold;
+  const wide = span > band.max;
+  return { narrow, wide };
+}
+var AI_HIGH_KEYWORDS = ["processing", "support", "coordinator", "analyst", "specialist"];
+var AI_MEDIUM_KEYWORDS = ["engineer", "accountant", "recruiter", "marketing"];
+var AI_LOW_KEYWORDS = ["counsel", "director", "officer", "manager", "executive"];
+function classifyAiAugmentation(employee, assumptions) {
+  const fam = employee.role_family?.trim().toLowerCase();
+  if (fam && assumptions.aiAugmentationByRoleFamily[fam]) {
+    return assumptions.aiAugmentationByRoleFamily[fam];
+  }
+  if (employee.role_family && assumptions.aiAugmentationByRoleFamily[employee.role_family]) {
+    return assumptions.aiAugmentationByRoleFamily[employee.role_family];
+  }
+  const title = (employee.role_title || "").toLowerCase();
+  if (AI_LOW_KEYWORDS.some((k) => title.includes(k))) return "low";
+  if (AI_MEDIUM_KEYWORDS.some((k) => title.includes(k))) return "medium";
+  if (AI_HIGH_KEYWORDS.some((k) => title.includes(k))) return "high";
+  return "low";
+}
+function findDuplicateRoles(employees, assumptions) {
+  const seniors = employees.filter((e) => e.level >= 1 && e.level <= 4);
+  const unleveled = employees.filter((e) => !(e.level >= 1));
+  if (unleveled.length > 0) {
+    const costs = employees.map((e) => e.total_cost || 0).sort((a, b) => a - b);
+    const p75 = costs[Math.min(costs.length - 1, Math.floor(costs.length * 0.75))];
+    seniors.push(...unleveled.filter((e) => (e.total_cost || 0) >= p75));
+  }
+  const noiseWords = assumptions?.titleNoiseWords;
+  const byTitle = groupBy(seniors, (e) => normalizeTitle(e.role_title, noiseWords));
+  const groups = [];
+  for (const [normalizedTitle, emps] of Object.entries(byTitle)) {
+    if (!normalizedTitle || emps.length < 2) continue;
+    const units = [...new Set(emps.map((e) => e.business_unit))];
+    if (units.length < 2 && emps.length < 3) continue;
+    groups.push({
+      normalizedTitle,
+      employees: emps.map((e) => ({
+        id: e.employee_id,
+        name: e.employee_name,
+        title: e.role_title,
+        unit: e.business_unit,
+        cost: e.total_cost
+      })),
+      units,
+      totalCost: sum(emps.map((e) => e.total_cost)),
+      normalizedFrom: [...new Set(emps.map((e) => e.role_title))]
+    });
+  }
+  return groups.sort((a, b) => b.totalCost - a.totalCost);
+}
+var BUCKET_DEFS = [
+  { label: "1\u20132", min: 1, max: 2 },
+  { label: "3\u20135", min: 3, max: 5 },
+  { label: "6\u20138", min: 6, max: 8 },
+  { label: "9\u201312", min: 9, max: 12 },
+  { label: "13+", min: 13, max: Infinity }
+];
+function computeMetrics(employees, assumptions) {
+  const tree2 = buildOrgTree(employees);
+  return computeMetricsFromTree(employees, tree2, assumptions);
+}
+function computeMetricsFromTree(employees, tree2, assumptions) {
+  const active = employees.filter((e) => (e.status || "Active").toLowerCase() !== "inactive");
+  const nodes = [...tree2.nodes.values()].filter((n) => n.layer > 0);
+  const managers = nodes.filter((n) => n.isManager);
+  const ics = nodes.filter((n) => !n.isManager);
+  const headcount = nodes.length;
+  const totalFte = sum(nodes.map((n) => n.employee.fte || 1));
+  const totalCost = sum(nodes.map((n) => n.employee.total_cost || 0));
+  const managementCost = sum(managers.map((n) => n.employee.total_cost || 0));
+  const icCost = totalCost - managementCost;
+  const filledNodes = nodes.filter((n) => positionStatus(n.employee) === "filled");
+  const filledHeadcount = filledNodes.length;
+  const vacantSeats = nodes.filter((n) => positionStatus(n.employee) === "vacant").length;
+  const tbhSeats = nodes.filter((n) => positionStatus(n.employee) === "tbh").length;
+  const unfilledSeats = vacantSeats + tbhSeats;
+  const runRateCost = sum(filledNodes.map((n) => n.employee.total_cost || 0));
+  const unfilledSeatCost = totalCost - runRateCost;
+  const unfilledByFunction = {};
+  const unfilledByLayer = {};
+  for (const n of nodes) {
+    if (positionStatus(n.employee) === "filled") continue;
+    const f = n.employee.function || "(blank)";
+    unfilledByFunction[f] = (unfilledByFunction[f] || 0) + 1;
+    unfilledByLayer[n.layer] = (unfilledByLayer[n.layer] || 0) + 1;
+  }
+  const spans = managers.map((m) => m.span);
+  const filledSpans = managers.map((m) => m.filledSpan);
+  const narrow = managers.filter(
+    (m) => classifySpan(m.span, m.employee.level || 0, assumptions).narrow
+  );
+  const wide = managers.filter(
+    (m) => classifySpan(m.span, m.employee.level || 0, assumptions).wide
+  );
+  const spanBuckets = BUCKET_DEFS.map((b) => {
+    const inBucket = managers.filter((m) => m.span >= b.min && m.span <= b.max);
+    return { ...b, count: inBucket.length, managerIds: inBucket.map((m) => m.employee.employee_id) };
+  });
+  const layerStats = [];
+  for (let layer = 1; layer <= tree2.maxLayer; layer++) {
+    const atLayer = nodes.filter((n) => n.layer === layer);
+    if (atLayer.length === 0) continue;
+    const layerManagers = atLayer.filter((n) => n.isManager);
+    const layerSpans = layerManagers.map((m) => m.span);
+    layerStats.push({
+      layer,
+      headcount: atLayer.length,
+      managers: layerManagers.length,
+      ics: atLayer.length - layerManagers.length,
+      cost: sum(atLayer.map((n) => n.employee.total_cost || 0)),
+      managementCost: sum(layerManagers.map((n) => n.employee.total_cost || 0)),
+      avgSpan: average(layerSpans),
+      medianSpan: median(layerSpans),
+      unfilledSeats: atLayer.filter((n) => positionStatus(n.employee) !== "filled").length
+    });
+  }
+  const dim = (key) => {
+    const out = {};
+    for (const n of nodes) {
+      const k = key(n.employee) || "(blank)";
+      out[k] = (out[k] || 0) + (n.employee.total_cost || 0);
+    }
+    return out;
+  };
+  const dimCount = (key) => {
+    const out = {};
+    for (const n of nodes) {
+      const k = key(n.employee) || "(blank)";
+      out[k] = (out[k] || 0) + 1;
+    }
+    return out;
+  };
+  const dimMaxLayer = (key) => {
+    const out = {};
+    const minL = {};
+    for (const n of nodes) {
+      const k = key(n.employee) || "(blank)";
+      out[k] = Math.max(out[k] || 0, n.layer);
+      minL[k] = Math.min(minL[k] ?? Infinity, n.layer);
+    }
+    for (const k of Object.keys(out)) out[k] = out[k] - (minL[k] === Infinity ? 1 : minL[k]) + 1;
+    return out;
+  };
+  const dimAvgSpan = (key) => {
+    const out = {};
+    for (const m of managers) {
+      const k = key(m.employee) || "(blank)";
+      (out[k] ?? (out[k] = [])).push(m.span);
+    }
+    return Object.fromEntries(Object.entries(out).map(([k, v]) => [k, average(v)]));
+  };
+  const costByLayer = {};
+  const managementCostByLayer = {};
+  for (const ls of layerStats) {
+    costByLayer[ls.layer] = ls.cost;
+    managementCostByLayer[ls.layer] = ls.managementCost;
+  }
+  const layerTaxPerIC = ics.length ? managementCost / ics.length : 0;
+  const managerOfOneCount = managers.filter((m) => m.isManagerOfOne).length;
+  const managerOfManagersCount = managers.filter((m) => m.managesOnlyManagers).length;
+  const pureSupervisoryLayers = [];
+  for (let layer = 1; layer <= tree2.maxLayer; layer++) {
+    const atLayer = nodes.filter((n) => n.layer === layer);
+    if (atLayer.length === 0) continue;
+    if (atLayer.every((n) => n.isManager && n.managesOnlyManagers)) {
+      pureSupervisoryLayers.push(layer);
+    }
+  }
+  const aiBands = {
+    high: { headcount: 0, cost: 0 },
+    medium: { headcount: 0, cost: 0 },
+    low: { headcount: 0, cost: 0 }
+  };
+  for (const n of nodes) {
+    const band = classifyAiAugmentation(n.employee, assumptions);
+    aiBands[band].headcount += 1;
+    aiBands[band].cost += n.employee.total_cost || 0;
+  }
+  const aiExposure = ["high", "medium", "low"].map((band) => ({
+    band,
+    headcount: aiBands[band].headcount,
+    cost: aiBands[band].cost
+  }));
+  const duplicateRoles = findDuplicateRoles(active, assumptions);
+  const duplicateRoleCost = sum(
+    duplicateRoles.map((g) => g.totalCost - Math.max(...g.employees.map((e) => e.cost)))
+  );
+  const narrowSpanCost = sum(narrow.map((m) => m.employee.total_cost || 0));
+  const tinySpanMgrs = narrow.filter((m) => m.span <= 2);
+  const spanOptPremium = (assumptions.spanOptPremiumPct ?? 20) / 100;
+  const spanOptimizationOpportunity = sum(
+    tinySpanMgrs.map((m) => (m.employee.total_cost || 0) * spanOptPremium)
+  );
+  const delayerMgrs = narrow.filter((m) => m.span >= 3);
+  const delayerNarrowCost = sum(delayerMgrs.map((m) => m.employee.total_cost || 0));
+  const delayeringOpportunity = delayerNarrowCost * assumptions.delayeringSavingPct / 100;
+  const duplicationOpportunity = duplicateRoleCost * assumptions.duplicateRoleSavingPct / 100;
+  const orgHealth = computeOrgHealth(
+    {
+      maxLayers: tree2.maxLayer,
+      headcount,
+      narrowPct: managers.length ? narrow.length / managers.length : 0,
+      widePct: managers.length ? wide.length / managers.length : 0,
+      managerRatio: headcount ? managers.length / headcount : 0,
+      mgmtCostRatio: totalCost ? managementCost / totalCost : 0,
+      duplicateCost: duplicateRoleCost,
+      totalCost
+    },
+    assumptions
+  );
+  return {
+    headcount,
+    totalFte,
+    totalCost,
+    filledHeadcount,
+    vacantSeats,
+    tbhSeats,
+    unfilledSeats,
+    vacancyRate: headcount ? unfilledSeats / headcount : 0,
+    runRateCost,
+    unfilledSeatCost,
+    avgFilledSpan: average(filledSpans),
+    medianFilledSpan: median(filledSpans),
+    unfilledByFunction,
+    unfilledByLayer,
+    managerCount: managers.length,
+    icCount: ics.length,
+    managerRatio: headcount ? managers.length / headcount : 0,
+    managementCost,
+    icCost,
+    managementCostRatio: totalCost ? managementCost / totalCost : 0,
+    maxLayers: tree2.maxLayer,
+    avgSpan: average(spans),
+    medianSpan: median(spans),
+    narrowSpanManagers: narrow.map((m) => m.employee.employee_id),
+    wideSpanManagers: wide.map((m) => m.employee.employee_id),
+    narrowSpanPct: managers.length ? narrow.length / managers.length : 0,
+    wideSpanPct: managers.length ? wide.length / managers.length : 0,
+    narrowSpanCost,
+    spanBuckets,
+    layerStats,
+    costByFunction: dim((e) => e.function),
+    headcountByFunction: dimCount((e) => e.function),
+    layersByFunction: dimMaxLayer((e) => e.function),
+    avgSpanByFunction: dimAvgSpan((e) => e.function),
+    costByBU: dim((e) => e.business_unit),
+    headcountByBU: dimCount((e) => e.business_unit),
+    layersByBU: dimMaxLayer((e) => e.business_unit),
+    costByLocation: dim((e) => e.location),
+    headcountByLocation: dimCount((e) => e.location),
+    costByGrade: dim((e) => e.grade),
+    headcountByGrade: dimCount((e) => e.grade),
+    costByLayer,
+    managementCostByLayer,
+    layerTaxPerIC,
+    managerOfOneCount,
+    managerOfManagersCount,
+    pureSupervisoryLayers,
+    aiExposure,
+    duplicateRoles,
+    duplicateRoleCost,
+    deepestChains: deepestChains(tree2, 5),
+    delayeringOpportunity,
+    spanOptimizationOpportunity,
+    duplicationOpportunity,
+    totalOpportunity: delayeringOpportunity + duplicationOpportunity + spanOptimizationOpportunity,
+    orgHealth
+  };
+}
+function computeOrgHealth(inp, assumptions) {
+  const bench = assumptions.benchmarkLayersForSize.find((b) => inp.headcount <= b.maxHeadcount)?.layers ?? 8;
+  const excessLayers = Math.max(0, inp.maxLayers - bench);
+  const layerScore = Math.max(0, 100 - excessLayers * 15);
+  const spanScore = Math.max(0, 100 - inp.narrowPct * 120 - inp.widePct * 80);
+  const mr = inp.managerRatio;
+  const ratioScore = mr <= 0.2 && mr >= 0.08 ? 100 : Math.max(0, 100 - Math.abs(mr - 0.15) * 400);
+  const mcScore = inp.mgmtCostRatio <= 0.3 ? 100 : Math.max(0, 100 - (inp.mgmtCostRatio - 0.3) * 300);
+  const dupShare = inp.totalCost ? inp.duplicateCost / inp.totalCost : 0;
+  const dupScore = Math.max(0, 100 - dupShare * 600);
+  const components = [
+    {
+      name: "Layer health",
+      score: Math.round(layerScore),
+      weight: 25,
+      explanation: `${inp.maxLayers} layers vs ~${bench} benchmark for ${inp.headcount} employees${excessLayers > 0 ? ` (+${excessLayers} excess)` : ""}.`
+    },
+    {
+      name: "Span health",
+      score: Math.round(spanScore),
+      weight: 25,
+      explanation: `${Math.round(inp.narrowPct * 100)}% of managers below / ${Math.round(inp.widePct * 100)}% above their level's target span band (flat thresholds ${assumptions.narrowSpanThreshold}/${assumptions.wideSpanThreshold} for unleveled roles).`
+    },
+    {
+      name: "Management ratio",
+      score: Math.round(ratioScore),
+      weight: 20,
+      explanation: `${Math.round(mr * 100)}% of employees are managers (healthy band \u2248 8\u201320%).`
+    },
+    {
+      name: "Management cost",
+      score: Math.round(mcScore),
+      weight: 15,
+      explanation: `Managers account for ${Math.round(inp.mgmtCostRatio * 100)}% of total cost (target \u2264 30%).`
+    },
+    {
+      name: "Role duplication",
+      score: Math.round(dupScore),
+      weight: 15,
+      explanation: `Potential duplicate senior roles represent ${(dupShare * 100).toFixed(1)}% of total cost.`
+    }
+  ];
+  const totalWeight = sum(components.map((c) => c.weight));
+  const total = Math.round(sum(components.map((c) => c.score * c.weight / totalWeight)));
+  return { total, components };
+}
+
+// src/lib/validation.ts
+var issueSeq = 0;
+function issue(severity, category, message, employeeIds = []) {
+  issueSeq += 1;
+  return { id: `dq_${issueSeq}`, severity, category, message, employeeIds };
+}
+function validateEmployees(employees) {
+  const issues = [];
+  if (employees.length === 0) {
+    issues.push(issue("critical", "Empty dataset", "No employee rows were found."));
+    const counts = { critical: 1, warning: 0, info: 0 };
+    return { score: 0, band: "Poor", issues, counts };
+  }
+  const byId = groupBy(employees, (e) => e.employee_id);
+  const dups = Object.entries(byId).filter(([, v]) => v.length > 1);
+  if (dups.length > 0) {
+    issues.push(
+      issue(
+        "critical",
+        "Duplicate IDs",
+        `${dups.length} employee ID(s) appear more than once: ${dups.slice(0, 5).map(([k]) => k).join(", ")}${dups.length > 5 ? "\u2026" : ""}`,
+        dups.map(([k]) => k)
+      )
+    );
+  }
+  const missingName = employees.filter(
+    (e) => positionStatus(e) === "filled" && !e.employee_name?.trim()
+  );
+  if (missingName.length > 0)
+    issues.push(issue("critical", "Missing names", `${missingName.length} employee(s) have no name.`, missingName.map((e) => e.employee_id)));
+  const unfilled = employees.filter((e) => positionStatus(e) !== "filled");
+  if (unfilled.length > 0)
+    issues.push(
+      issue(
+        "info",
+        "Unfilled positions",
+        `${unfilled.length} position(s) are vacant or to-be-hired \u2014 included in designed cost and structure, excluded from run-rate cost.`,
+        unfilled.map((e) => e.employee_id)
+      )
+    );
+  const missingTitle = employees.filter((e) => !e.role_title?.trim());
+  if (missingTitle.length > 0)
+    issues.push(issue("warning", "Missing role titles", `${missingTitle.length} employee(s) have no role title.`, missingTitle.map((e) => e.employee_id)));
+  const blankDept = employees.filter((e) => !e.department?.trim());
+  if (blankDept.length > 0)
+    issues.push(issue("warning", "Blank departments", `${blankDept.length} employee(s) have a blank department.`, blankDept.map((e) => e.employee_id)));
+  const blankFunc = employees.filter((e) => !e.function?.trim());
+  if (blankFunc.length > 0)
+    issues.push(issue("warning", "Blank functions", `${blankFunc.length} employee(s) have a blank function.`, blankFunc.map((e) => e.employee_id)));
+  const blankLoc = employees.filter((e) => !e.location?.trim());
+  if (blankLoc.length > 0)
+    issues.push(issue("info", "Blank locations", `${blankLoc.length} employee(s) have a blank location.`, blankLoc.map((e) => e.employee_id)));
+  const badCost = employees.filter(
+    (e) => e.total_cost == null || isNaN(e.total_cost) || e.total_cost < 0
+  );
+  if (badCost.length > 0)
+    issues.push(issue("critical", "Invalid costs", `${badCost.length} employee(s) have missing/negative/non-numeric total cost.`, badCost.map((e) => e.employee_id)));
+  const zeroCost = employees.filter((e) => e.total_cost === 0);
+  if (zeroCost.length > 0)
+    issues.push(issue("warning", "Zero cost", `${zeroCost.length} employee(s) have zero total cost \u2014 cost analytics will undercount.`, zeroCost.map((e) => e.employee_id)));
+  const costBelowSalary = employees.filter(
+    (e) => e.total_cost > 0 && e.salary > 0 && e.total_cost < e.salary
+  );
+  if (costBelowSalary.length > 0)
+    issues.push(issue("warning", "Cost below salary", `${costBelowSalary.length} employee(s) have total cost lower than base salary.`, costBelowSalary.map((e) => e.employee_id)));
+  const badFte = employees.filter((e) => e.fte != null && (isNaN(e.fte) || e.fte <= 0 || e.fte > 2));
+  if (badFte.length > 0)
+    issues.push(issue("warning", "Suspicious FTE", `${badFte.length} employee(s) have FTE outside (0, 2].`, badFte.map((e) => e.employee_id)));
+  const tree2 = buildOrgTree(employees);
+  if (tree2.orphans.length > 0)
+    issues.push(
+      issue(
+        "critical",
+        "Invalid manager IDs",
+        `${tree2.orphans.length} employee(s) reference a manager_id that does not exist in the data (treated as detached roots).`,
+        tree2.orphans
+      )
+    );
+  if (tree2.circular.length > 0)
+    issues.push(
+      issue(
+        "critical",
+        "Circular reporting lines",
+        `${tree2.circular.length} employee(s) sit in circular reporting chains and are excluded from hierarchy analytics.`,
+        tree2.circular
+      )
+    );
+  if (tree2.roots.length > 1)
+    issues.push(
+      issue(
+        "warning",
+        "Multiple root nodes",
+        `${tree2.roots.length} employees have no manager (multiple CEOs/roots). Layer analytics use each root independently.`,
+        tree2.roots
+      )
+    );
+  if (tree2.roots.length === 0)
+    issues.push(issue("critical", "No root node", "No employee without a manager was found \u2014 cannot identify the CEO/top of the organization."));
+  const inconsistent = [...tree2.nodes.values()].filter(
+    (n) => n.layer > 0 && n.employee.level > 0 && Math.abs(n.employee.level - n.layer) >= 3
+  );
+  if (inconsistent.length > 0)
+    issues.push(
+      issue(
+        "info",
+        "Level/layer mismatch",
+        `${inconsistent.length} employee(s) have a stated level differing from their computed layer by 3+, suggesting grade data drift.`,
+        inconsistent.map((n) => n.employee.employee_id)
+      )
+    );
+  const titleVariants = groupBy(
+    employees.filter((e) => e.role_title),
+    (e) => e.role_title.toLowerCase().replace(/[^a-z]/g, "")
+  );
+  const messyTitles = Object.values(titleVariants).filter(
+    (v) => new Set(v.map((e) => e.role_title)).size > 1
+  );
+  if (messyTitles.length > 0)
+    issues.push(
+      issue(
+        "info",
+        "Inconsistent role titles",
+        `${messyTitles.length} title(s) appear with multiple spellings/capitalizations (e.g. ${[...new Set(messyTitles[0].map((e) => e.role_title))].slice(0, 3).join(" / ")}).`,
+        []
+      )
+    );
+  return finalize(issues, employees.length);
+}
+function finalize(issues, rowCount) {
+  const counts = {
+    critical: issues.filter((i) => i.severity === "critical").length,
+    warning: issues.filter((i) => i.severity === "warning").length,
+    info: issues.filter((i) => i.severity === "info").length
+  };
+  let score = 100;
+  for (const i of issues) {
+    const share = rowCount > 0 ? Math.min(1, (i.employeeIds.length || 1) / rowCount) : 1;
+    if (i.severity === "critical") score -= 15 + share * 25;
+    else if (i.severity === "warning") score -= 5 + share * 10;
+    else score -= 1 + share * 3;
+  }
+  score = Math.max(0, Math.round(score));
+  const band = score >= 90 ? "Strong" : score >= 75 ? "Usable" : score >= 50 ? "Needs cleanup" : "Poor";
+  return { score, band, issues, counts };
+}
+function num(v) {
+  if (v == null || v === "") return 0;
+  const n = typeof v === "number" ? v : parseFloat(String(v).replace(/[,$€£\s]/g, ""));
+  return isNaN(n) ? 0 : n;
+}
+function str(v) {
+  return v == null ? "" : String(v).trim();
+}
+function bool(v) {
+  const s = str(v).toLowerCase();
+  return s === "true" || s === "yes" || s === "y" || s === "1";
+}
+var VACANT_TOKENS = /* @__PURE__ */ new Set(["vacant", "open", "unfilled", "vacancy", "openposition", "openseat"]);
+var TBH_TOKENS = /* @__PURE__ */ new Set(["tbh", "tobehired", "planned", "hiring"]);
+var FILLED_TOKENS = /* @__PURE__ */ new Set(["filled", "active", "occupied"]);
+function normalizePositionStatus(v) {
+  const s = str(v).toLowerCase().replace(/[^a-z]/g, "");
+  if (!s) return void 0;
+  if (VACANT_TOKENS.has(s)) return "vacant";
+  if (TBH_TOKENS.has(s)) return "tbh";
+  if (FILLED_TOKENS.has(s)) return "filled";
+  return void 0;
+}
+function rowsToEmployees(rows, mapping) {
+  const get = (row, field) => {
+    const col = mapping[field];
+    return col ? row[col] : void 0;
+  };
+  return rows.filter((row) => str(get(row, "employee_id"))).map((row) => {
+    const salary = num(get(row, "salary"));
+    const bonus = num(get(row, "bonus"));
+    const totalCostRaw = num(get(row, "total_cost"));
+    const name2 = str(get(row, "employee_name"));
+    const posStatus = normalizePositionStatus(get(row, "position_status")) ?? (name2 ? void 0 : "vacant");
+    return {
+      employee_id: str(get(row, "employee_id")),
+      employee_name: name2,
+      role_title: str(get(row, "role_title")),
+      manager_id: str(get(row, "manager_id")) || null,
+      manager_name: str(get(row, "manager_name")) || void 0,
+      department: str(get(row, "department")),
+      function: str(get(row, "function")),
+      business_unit: str(get(row, "business_unit")),
+      location: str(get(row, "location")),
+      country: str(get(row, "country")),
+      grade: str(get(row, "grade")),
+      level: num(get(row, "level")) || 0,
+      employment_type: str(get(row, "employment_type")) || "Full-time",
+      fte: num(get(row, "fte")) || 1,
+      salary,
+      bonus,
+      total_cost: totalCostRaw || salary + bonus,
+      // fall back to salary+bonus
+      status: str(get(row, "status")) || "Active",
+      position_status: posStatus === "filled" ? void 0 : posStatus,
+      tenure: get(row, "tenure") != null ? num(get(row, "tenure")) : void 0,
+      gender: str(get(row, "gender")) || void 0,
+      age_band: str(get(row, "age_band")) || void 0,
+      performance_rating: str(get(row, "performance_rating")) || void 0,
+      critical_role: get(row, "critical_role") != null ? bool(get(row, "critical_role")) : void 0,
+      role_family: str(get(row, "role_family")) || void 0,
+      cost_center: str(get(row, "cost_center")) || void 0,
+      contract_type: str(get(row, "contract_type")) || void 0,
+      remote_status: str(get(row, "remote_status")) || void 0,
+      skills: str(get(row, "skills")) || void 0,
+      attrition_risk: str(get(row, "attrition_risk")) || void 0,
+      comments: str(get(row, "comments")) || void 0
+    };
+  });
+}
+function autoMapColumns(columns, fields, extraAliases) {
+  const norm = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const colNorm = columns.map((c) => ({ raw: c, norm: norm(c) }));
+  const ALIASES = {
+    employee_id: ["empid", "id", "workerid", "personid", "employeenumber"],
+    employee_name: ["name", "fullname", "employee", "workername"],
+    role_title: ["title", "jobtitle", "position", "role"],
+    manager_id: ["managerid", "supervisorid", "reportsto", "mgrid"],
+    manager_name: ["manager", "supervisor", "mgrname"],
+    position_status: ["positionstatus", "seatstatus", "vacancystatus", "vacancy"],
+    business_unit: ["bu", "division", "businessarea"],
+    total_cost: ["cost", "totalcomp", "totalcompensation", "fullycost", "loadedcost"],
+    employment_type: ["emptype", "workertype"],
+    fte: ["ftevalue", "workload"]
+  };
+  const mapping = {};
+  for (const field of fields) {
+    const fNorm = norm(field);
+    const base = [fNorm, ...(ALIASES[field] || []).map(norm)];
+    const extra = (extraAliases?.[field] ?? []).map(norm).filter(Boolean);
+    const exact = (aliases) => colNorm.find((c) => aliases.includes(c.norm));
+    const fuzzy = (aliases) => colNorm.find((c) => aliases.some((a) => c.norm.includes(a) || a.includes(c.norm)));
+    const hit = exact(extra) || exact(base) || fuzzy(extra) || fuzzy(base);
+    mapping[field] = hit?.raw ?? null;
+  }
+  return mapping;
+}
+
+// src/lib/scenario.ts
+function applyChanges(baseline, changes) {
+  let employees = baseline.map((e) => ({ ...e }));
+  const warnings = [];
+  for (const change of changes) {
+    const byId = new Map(employees.map((e) => [e.employee_id, e]));
+    switch (change.type) {
+      case "move": {
+        const target = byId.get(change.employeeId);
+        const newMgr = byId.get(change.newManagerId);
+        if (!target || !newMgr) {
+          warnings.push(`Move skipped: employee not found (${change.employeeId}).`);
+          break;
+        }
+        const tree2 = buildOrgTree(employees);
+        if (wouldCreateCycle(tree2, change.employeeId, change.newManagerId)) {
+          warnings.push(`Move skipped: moving ${target.employee_name} under ${newMgr.employee_name} would create a cycle.`);
+          break;
+        }
+        target.manager_id = change.newManagerId;
+        target.manager_name = newMgr.employee_name;
+        break;
+      }
+      case "remove_role": {
+        const target = byId.get(change.employeeId);
+        if (!target) {
+          warnings.push(`Remove skipped: ${change.employeeId} not found.`);
+          break;
+        }
+        const newMgrId = change.reportsTo === "specific" ? change.newManagerId ?? target.manager_id : change.reportsTo === "managers_manager" ? target.manager_id : null;
+        for (const e of employees) {
+          if (e.manager_id === change.employeeId) {
+            e.manager_id = newMgrId;
+            e.manager_name = newMgrId ? byId.get(newMgrId)?.employee_name : void 0;
+            if (!newMgrId) warnings.push(`${e.employee_name} is temporarily orphaned after removing ${target.employee_name}.`);
+          }
+        }
+        employees = employees.filter((e) => e.employee_id !== change.employeeId);
+        break;
+      }
+      case "add_role": {
+        if (byId.has(change.employee.employee_id)) {
+          warnings.push(`Add skipped: ID ${change.employee.employee_id} already exists.`);
+          break;
+        }
+        employees.push({ ...change.employee });
+        break;
+      }
+      case "merge_teams": {
+        const source = byId.get(change.sourceManagerId);
+        const target = byId.get(change.targetManagerId);
+        if (!source || !target) {
+          warnings.push("Merge skipped: manager not found.");
+          break;
+        }
+        if (change.sourceManagerId === change.targetManagerId) {
+          warnings.push(`Merge skipped: source and target manager are the same (${source.employee_name}).`);
+          break;
+        }
+        for (const e of employees) {
+          if (e.manager_id === change.sourceManagerId) {
+            e.manager_id = change.targetManagerId;
+            e.manager_name = target.employee_name;
+          }
+        }
+        employees = employees.filter((e) => e.employee_id !== change.sourceManagerId);
+        break;
+      }
+      case "delayer": {
+        const tree2 = buildOrgTree(employees);
+        const inScope = (e) => change.scope.field === "all" || change.scope.field === "function" && e.function === change.scope.value || change.scope.field === "business_unit" && e.business_unit === change.scope.value;
+        const toRemove = [...tree2.nodes.values()].filter(
+          (n) => n.layer === change.layer && n.isManager && inScope(n.employee)
+        );
+        if (toRemove.length === 0) {
+          warnings.push(`Delayer: no managers found at layer ${change.layer} in scope.`);
+          break;
+        }
+        const removeIds = new Set(toRemove.map((n) => n.employee.employee_id));
+        for (const e of employees) {
+          if (e.manager_id && removeIds.has(e.manager_id)) {
+            const removedMgr = byId.get(e.manager_id);
+            e.manager_id = removedMgr.manager_id;
+            e.manager_name = removedMgr.manager_id ? byId.get(removedMgr.manager_id)?.employee_name : void 0;
+          }
+        }
+        employees = employees.filter((e) => !removeIds.has(e.employee_id));
+        break;
+      }
+      case "location_shift": {
+        for (const id of change.employeeIds) {
+          const e = byId.get(id);
+          if (!e) continue;
+          e.location = change.targetLocation;
+          e.salary = Math.round(e.salary * change.costMultiplier);
+          e.bonus = Math.round(e.bonus * change.costMultiplier);
+          e.total_cost = Math.round(e.total_cost * change.costMultiplier);
+        }
+        break;
+      }
+      case "cost_change": {
+        const e = byId.get(change.employeeId);
+        if (!e) {
+          warnings.push(`Cost change skipped: ${change.employeeId} not found.`);
+          break;
+        }
+        e.total_cost = change.newTotalCost;
+        break;
+      }
+      case "fill_role": {
+        const e = byId.get(change.employeeId);
+        if (!e) {
+          warnings.push(`Fill seat skipped: ${change.employeeId} not found.`);
+          break;
+        }
+        if (positionStatus(e) === "filled") {
+          warnings.push(`Fill seat skipped: ${e.role_title || e.employee_id} is already filled.`);
+          break;
+        }
+        e.position_status = "filled";
+        if (change.employeeName.trim()) e.employee_name = change.employeeName.trim();
+        break;
+      }
+    }
+  }
+  return { employees, warnings };
+}
+function diffEmployees(baseline, scenario) {
+  const baseById = new Map(baseline.map((e) => [e.employee_id, e]));
+  const scenById = new Map(scenario.map((e) => [e.employee_id, e]));
+  const moved = [];
+  const removed = [];
+  const added = [];
+  const costChanged = [];
+  const locationChanged = [];
+  const seatsFilled = [];
+  for (const e of baseline) {
+    const s = scenById.get(e.employee_id);
+    if (!s) removed.push(e);
+    else {
+      if (s.manager_id !== e.manager_id) moved.push(s);
+      if (s.total_cost !== e.total_cost) costChanged.push(s);
+      if (s.location !== e.location) locationChanged.push(s);
+      if (positionStatus(e) !== "filled" && positionStatus(s) === "filled") seatsFilled.push(s);
+    }
+  }
+  for (const e of scenario) if (!baseById.has(e.employee_id)) added.push(e);
+  return { moved, removed, added, costChanged, locationChanged, seatsFilled };
+}
+function computeChangeRisk(baseline, scenarioEmployees, baselineMetrics, scenarioMetrics) {
+  const { moved, removed, added } = diffEmployees(baseline, scenarioEmployees);
+  const headcount = Math.max(1, baseline.length);
+  const seniorAffected = [...moved, ...removed].filter((e) => e.level <= 3).length;
+  const criticalAffected = [...moved, ...removed].filter((e) => e.critical_role).length;
+  const functionsImpacted = new Set([...moved, ...removed, ...added].map((e) => e.function)).size;
+  const locationsImpacted = new Set([...moved, ...removed, ...added].map((e) => e.location)).size;
+  const layerDelta = Math.abs(scenarioMetrics.maxLayers - baselineMetrics.maxLayers);
+  const costDeltaPct = baselineMetrics.totalCost ? Math.abs(scenarioMetrics.totalCost - baselineMetrics.totalCost) / baselineMetrics.totalCost : 0;
+  const factors = [
+    { name: "Employees moved", value: moved.length, contribution: Math.min(25, moved.length / headcount * 120) },
+    { name: "Roles eliminated", value: removed.length, contribution: Math.min(20, removed.length / headcount * 200) },
+    { name: "Senior leaders affected", value: seniorAffected, contribution: Math.min(15, seniorAffected * 3) },
+    { name: "Critical roles affected", value: criticalAffected, contribution: Math.min(15, criticalAffected * 5) },
+    { name: "Functions impacted", value: functionsImpacted, contribution: Math.min(10, functionsImpacted * 1.5) },
+    { name: "Locations impacted", value: locationsImpacted, contribution: Math.min(5, locationsImpacted * 1) },
+    { name: "Layer change", value: layerDelta, contribution: Math.min(5, layerDelta * 2.5) },
+    { name: "Cost change", value: `${(costDeltaPct * 100).toFixed(1)}%`, contribution: Math.min(5, costDeltaPct * 40) }
+  ];
+  const score = Math.min(100, Math.round(factors.reduce((a, f) => a + f.contribution, 0)));
+  const level = score < 20 ? "Low" : score < 45 ? "Medium" : score < 70 ? "High" : "Very High";
+  const recommendation = {
+    Low: "Suitable for quick implementation with standard communication.",
+    Medium: "Requires stakeholder alignment and a clear communication plan.",
+    High: "Requires a detailed change plan, consultation, and phased rollout.",
+    "Very High": "Requires a phased transformation program with executive sponsorship and workforce consultation."
+  }[level];
+  return { level, score, factors, recommendation };
+}
+var DEFAULT_EFFECTIVE_MONTH = 4;
+function year1CapturePct(assumptions) {
+  const raw = assumptions.transitionAssumptions?.effectiveMonth ?? DEFAULT_EFFECTIVE_MONTH;
+  const month = Number.isFinite(raw) && raw >= 1 && raw <= 12 ? Math.round(raw) : DEFAULT_EFFECTIVE_MONTH;
+  return (12 - month + 1) / 12;
+}
+function severanceCountryMultiplier(country, assumptions) {
+  const map = assumptions.transitionAssumptions?.countrySeveranceMultipliers ?? {};
+  const m = country ? map[country] : void 0;
+  return typeof m === "number" && Number.isFinite(m) && m > 0 ? m : 1;
+}
+function severanceMonthsForLevel(level, assumptions) {
+  const bands = assumptions.transitionAssumptions.severanceMonthsByLevel;
+  const sorted = [...bands].sort((a, b) => a.maxLevel - b.maxLevel);
+  const effectiveLevel = level > 0 ? level : 1;
+  for (const b of sorted) {
+    if (effectiveLevel <= b.maxLevel) return b.months;
+  }
+  return sorted.length ? sorted[sorted.length - 1].months : 0;
+}
+function computeTransitionCost(baseline, scenarioEmployees, assumptions) {
+  const ta = assumptions.transitionAssumptions;
+  const { moved, removed, costChanged, locationChanged, seatsFilled } = diffEmployees(
+    baseline,
+    scenarioEmployees
+  );
+  const baseById = new Map(baseline.map((e) => [e.employee_id, e]));
+  const isFilled = (e) => !!e && positionStatus(e) === "filled";
+  let severance = 0;
+  let backfill = 0;
+  for (const r of removed) {
+    if (!isFilled(r)) continue;
+    const months = severanceMonthsForLevel(r.level, assumptions) * severanceCountryMultiplier(r.country, assumptions);
+    severance += (r.total_cost || 0) / 12 * months;
+    backfill += (r.total_cost || 0) * ta.backfillPct / 100;
+  }
+  const filledLocationChanged = locationChanged.filter((s) => isFilled(baseById.get(s.employee_id)));
+  const locationChangedIds = new Set(locationChanged.map((e) => e.employee_id));
+  for (const s of filledLocationChanged) {
+    const base = baseById.get(s.employee_id);
+    const baseCost = base?.total_cost || 0;
+    const months = severanceMonthsForLevel(base?.level ?? 0, assumptions) * severanceCountryMultiplier(base?.country, assumptions);
+    severance += baseCost / 12 * months;
+    backfill += baseCost * ta.backfillPct / 100;
+  }
+  let hiring = 0;
+  for (const f of seatsFilled) hiring += (f.total_cost || 0) * ta.backfillPct / 100;
+  const costOnlyChanged = costChanged.filter(
+    (e) => !locationChangedIds.has(e.employee_id) && isFilled(e)
+  );
+  const filledMoved = moved.filter((e) => isFilled(e));
+  const changeCost = ta.oneTimeChangeCostPerMove * (filledMoved.length + filledLocationChanged.length + costOnlyChanged.length);
+  return Math.round(severance + backfill + hiring + changeCost);
+}
+function scoreScenario(baselineMetrics, scenarioMetrics, risk, assumptions, changeCount, netYear1Saving, affectedEmployees) {
+  const w = assumptions.scoringWeights;
+  const costDelta = baselineMetrics.totalCost - scenarioMetrics.totalCost;
+  const netSaving = netYear1Saving ?? costDelta;
+  const netPct = baselineMetrics.totalCost ? netSaving / baselineMetrics.totalCost : 0;
+  const financial = clamp(50 + netPct * 500);
+  const narrowDelta = baselineMetrics.narrowSpanPct - scenarioMetrics.narrowSpanPct;
+  const wideDelta = baselineMetrics.wideSpanPct - scenarioMetrics.wideSpanPct;
+  const spanImprovement = clamp(50 + narrowDelta * 250 + wideDelta * 150);
+  const layerDelta = baselineMetrics.maxLayers - scenarioMetrics.maxLayers;
+  const layerReduction = clamp(50 + layerDelta * 20);
+  const mgrRatioDelta = baselineMetrics.managerRatio - scenarioMetrics.managerRatio;
+  const dupDelta = baselineMetrics.duplicateRoleCost - scenarioMetrics.duplicateRoleCost;
+  const complexity = clamp(
+    50 + mgrRatioDelta * 400 + (baselineMetrics.totalCost ? dupDelta / baselineMetrics.totalCost * 800 : 0)
+  );
+  const changeRiskScore = clamp(100 - risk.score);
+  const affected = affectedEmployees ?? 0;
+  const implementationEase = clamp(100 - Math.min(40, affected * 0.8) - risk.score * 0.3);
+  const categories = [
+    { name: "Financial impact", score: Math.round(financial), weight: w.financialImpact },
+    { name: "Span improvement", score: Math.round(spanImprovement), weight: w.spanImprovement },
+    { name: "Layer reduction", score: Math.round(layerReduction), weight: w.layerReduction },
+    { name: "Operational simplicity", score: Math.round(complexity), weight: w.complexityReduction },
+    { name: "People / change risk", score: Math.round(changeRiskScore), weight: w.changeRisk },
+    { name: "Speed to execute", score: Math.round(implementationEase), weight: w.implementationEase }
+  ];
+  const totalWeight = categories.reduce((a, c) => a + c.weight, 0) || 1;
+  const total = Math.round(categories.reduce((a, c) => a + c.score * c.weight / totalWeight, 0));
+  return { total, categories };
+}
+function clamp(v) {
+  return Math.max(0, Math.min(100, v));
+}
+function evaluateScenario(baseline, scenario, baselineMetrics, assumptions) {
+  const { employees } = applyChanges(baseline, scenario.changes);
+  const metrics = computeMetrics(employees, assumptions);
+  const risk = computeChangeRisk(baseline, employees, baselineMetrics, metrics);
+  const { moved, removed, added, seatsFilled } = diffEmployees(baseline, employees);
+  const costDelta = metrics.totalCost - baselineMetrics.totalCost;
+  const runRateSaving = -costDelta;
+  const transitionCost = computeTransitionCost(baseline, employees, assumptions);
+  const capturePct = year1CapturePct(assumptions);
+  const netYear1Saving = runRateSaving * capturePct - transitionCost;
+  const affectedEmployees = moved.length + removed.length + added.length + seatsFilled.length;
+  const vacantSeatsRemoved = removed.filter((r) => positionStatus(r) !== "filled").length;
+  const score = scoreScenario(
+    baselineMetrics,
+    metrics,
+    risk,
+    assumptions,
+    scenario.changes.length,
+    netYear1Saving,
+    affectedEmployees
+  );
+  return {
+    scenarioId: scenario.id,
+    metrics,
+    risk,
+    score,
+    costDelta,
+    headcountDelta: metrics.headcount - baselineMetrics.headcount,
+    layerDelta: metrics.maxLayers - baselineMetrics.maxLayers,
+    employeesMoved: moved.length,
+    rolesRemoved: removed.length,
+    rolesAdded: added.length,
+    transitionCost,
+    netYear1Saving,
+    runRateSaving,
+    year1CapturePct: capturePct,
+    vacantSeatsRemoved,
+    seatsFilled: seatsFilled.length
+  };
+}
+function suggestConsolidations(employees, assumptions, scopeFunction) {
+  const tree2 = buildOrgTree(employees);
+  const out = [];
+  const nodes = [...tree2.nodes.values()].filter((n) => n.layer > 1);
+  const narrowMgrs = nodes.filter(
+    (n) => n.isManager && n.span < assumptions.narrowSpanThreshold && n.span <= 2 && (!scopeFunction || n.employee.function === scopeFunction)
+  );
+  const isSensitive = (e) => !!e.critical_role || e.attrition_risk === "High";
+  for (const mgr of narrowMgrs) {
+    const parent = mgr.employee.manager_id ? tree2.nodes.get(mgr.employee.manager_id) : void 0;
+    if (!parent) continue;
+    const peers = parent.directReports.map((id) => tree2.nodes.get(id)).filter(
+      (p) => p.employee.employee_id !== mgr.employee.employee_id && p.isManager && p.span + mgr.span <= assumptions.wideSpanThreshold && p.employee.function === mgr.employee.function
+    ).sort((a, b) => {
+      const aRisk = a.employee.attrition_risk === "High" ? 1 : 0;
+      const bRisk = b.employee.attrition_risk === "High" ? 1 : 0;
+      if (aRisk !== bRisk) return aRisk - bRisk;
+      return a.span - b.span;
+    });
+    const target = peers[0] ?? parent;
+    let rationale = `${mgr.employee.employee_name} (${mgr.employee.role_title}) manages only ${mgr.span} ${mgr.span === 1 ? "person" : "people"} \u2014 below the ${assumptions.narrowSpanThreshold}-report threshold.`;
+    const flags = [];
+    if (mgr.employee.critical_role) flags.push("flagged as a critical role");
+    if (mgr.employee.attrition_risk === "High") flags.push("at high attrition risk");
+    if (flags.length) {
+      rationale += ` Caution: this manager is ${flags.join(" and ")} \u2014 validate retention/continuity impact before acting (de-prioritized).`;
+    }
+    out.push({
+      change: {
+        type: "merge_teams",
+        sourceManagerId: mgr.employee.employee_id,
+        targetManagerId: target.employee.employee_id,
+        description: `Merge ${mgr.employee.employee_name}'s team (${mgr.span} report${mgr.span === 1 ? "" : "s"}) into ${target.employee.employee_name}`
+      },
+      rationale,
+      estimatedSaving: mgr.employee.total_cost
+    });
+  }
+  return out.sort((a, b) => {
+    const aMgr = tree2.nodes.get(a.change.type === "merge_teams" ? a.change.sourceManagerId : "")?.employee;
+    const bMgr = tree2.nodes.get(b.change.type === "merge_teams" ? b.change.sourceManagerId : "")?.employee;
+    const aSens = aMgr && isSensitive(aMgr) ? 1 : 0;
+    const bSens = bMgr && isSensitive(bMgr) ? 1 : 0;
+    if (aSens !== bSens) return aSens - bSens;
+    return b.estimatedSaving - a.estimatedSaving;
+  });
+}
+
+// src/lib/insights.ts
+var seq = 0;
+function insight(partial) {
+  seq += 1;
+  return { id: `ins_${seq}`, ...partial };
+}
+function generateInsights(ctx) {
+  const { metrics: m, assumptions: a, employees } = ctx;
+  const sym = a.currencySymbol;
+  const out = [];
+  const tree2 = buildOrgTree(employees);
+  if (m.headcount === 0) return [];
+  const bench = a.benchmarkLayersForSize.find((b) => m.headcount <= b.maxHeadcount)?.layers ?? 8;
+  if (m.maxLayers > bench) {
+    out.push(
+      insight({
+        title: `Organization has ${m.maxLayers} layers \u2014 ${m.maxLayers - bench} above benchmark`,
+        severity: m.maxLayers - bench >= 2 ? "high" : "medium",
+        category: "layer",
+        evidence: `The deepest reporting chain runs ${m.maxLayers} layers from CEO to frontline. For an organization of ${m.headcount} employees, a typical benchmark is ~${bench} layers.`,
+        impact: "Excess layers slow decision-making, dilute accountability and add management cost.",
+        recommendation: `Review the deepest chains (Diagnostics \u2192 deepest chains) and test a delayering scenario targeting layer ${Math.max(3, m.maxLayers - 2)}\u2013${m.maxLayers - 1} in the most layered functions.`,
+        relatedEntities: m.deepestChains[0]?.ids ?? [],
+        financialImpact: m.delayeringOpportunity,
+        employeesAffected: m.deepestChains[0]?.ids.length ?? 0,
+        confidence: "high",
+        easeOfAction: "moderate",
+        linkTo: "/diagnostics"
+      })
+    );
+  }
+  for (const [func, layers] of sortedEntries(m.layersByFunction).slice(0, 2)) {
+    if (layers > bench - 1 && func !== "(blank)") {
+      out.push(
+        insight({
+          title: `${func} spans ${layers} internal layers \u2014 the most layered function`,
+          severity: layers >= bench ? "high" : "medium",
+          category: "layer",
+          evidence: `${func} has ${layers} layers internally with ${m.headcountByFunction[func] ?? 0} employees and ${fmtMoney(m.costByFunction[func] ?? 0, sym)} total cost.`,
+          impact: "Deep functional hierarchies create approval bottlenecks and fragmented spans.",
+          recommendation: `Run a delayering scenario scoped to ${func} and compare before/after spans.`,
+          relatedEntities: [func],
+          financialImpact: 0,
+          employeesAffected: m.headcountByFunction[func] ?? 0,
+          confidence: "high",
+          easeOfAction: "moderate",
+          linkTo: "/diagnostics"
+        })
+      );
+    }
+  }
+  if (m.deepestChains[0]) {
+    const chain = m.deepestChains[0];
+    const top = tree2.nodes.get(chain.ids[1] ?? chain.ids[0]);
+    out.push(
+      insight({
+        title: `Deepest reporting chain has ${chain.depth} layers${top ? ` under ${top.employee.role_title}` : ""}`,
+        severity: chain.depth > bench ? "medium" : "low",
+        category: "structure",
+        evidence: `The longest path from the CEO to the frontline passes through ${chain.depth - 1} managers: ${chain.ids.map((id) => tree2.nodes.get(id)?.employee.role_title ?? id).slice(0, 5).join(" \u2192 ")}${chain.depth > 5 ? " \u2192 \u2026" : ""}.`,
+        impact: "Long chains mean frontline information passes through many filters before reaching leadership.",
+        recommendation: "Validate whether each intermediate manager adds distinct decision rights.",
+        relatedEntities: chain.ids,
+        financialImpact: 0,
+        employeesAffected: chain.ids.length,
+        confidence: "high",
+        easeOfAction: "moderate",
+        linkTo: "/org"
+      })
+    );
+  }
+  if (m.narrowSpanPct > 0.25) {
+    const tiny = m.spanBuckets.find((b) => b.label === "1\u20132");
+    out.push(
+      insight({
+        title: `${fmtPct(m.narrowSpanPct)} of managers fall below their level's target span band`,
+        severity: m.narrowSpanPct > 0.4 ? "high" : "medium",
+        category: "span",
+        evidence: `${m.narrowSpanManagers.length} of ${m.managerCount} managers fall below the target span band for their level (bands are set per level in Settings; the flat ${a.narrowSpanThreshold}-report threshold applies as fallback for unleveled employees); ${tiny?.count ?? 0} manage only 1\u20132 people. Combined cost of narrow-span managers: ${fmtMoney(m.narrowSpanCost, sym)}.`,
+        impact: "Fragmented spans suggest management capacity is underused and layers may be redundant.",
+        recommendation: "Use Scenario Modelling \u2192 Apply Target Spans to generate consolidation options for review.",
+        relatedEntities: m.narrowSpanManagers.slice(0, 10),
+        financialImpact: m.delayeringOpportunity,
+        employeesAffected: m.narrowSpanManagers.length,
+        confidence: "high",
+        easeOfAction: "moderate",
+        linkTo: "/diagnostics"
+      })
+    );
+  }
+  if (m.wideSpanManagers.length > 0) {
+    const widest = m.wideSpanManagers.map((id) => tree2.nodes.get(id)).sort((x, y) => y.span - x.span)[0];
+    out.push(
+      insight({
+        title: `${m.wideSpanManagers.length} manager(s) exceed their level's target span band (max ${a.wideSpanThreshold} for unleveled roles)`,
+        severity: widest.span >= a.wideSpanThreshold + 4 ? "high" : "medium",
+        category: "span",
+        evidence: `The widest span is ${widest.span} reports (${widest.employee.employee_name}, ${widest.employee.role_title}, ${widest.employee.function}). Target span bands are set per level in Settings; the flat ${a.wideSpanThreshold}-report ceiling applies as fallback for unleveled employees.`,
+        impact: "Overloaded managers risk supervision gaps, slower coaching and attrition in their teams.",
+        recommendation: "Consider splitting overloaded teams or adding a team-lead level only where supervision genuinely requires it.",
+        relatedEntities: m.wideSpanManagers,
+        financialImpact: 0,
+        employeesAffected: m.wideSpanManagers.length,
+        confidence: "high",
+        easeOfAction: "moderate",
+        linkTo: "/diagnostics"
+      })
+    );
+  }
+  if (m.managerOfOneCount >= 2) {
+    const m1Nodes = [...tree2.nodes.values()].filter((n) => n.isManagerOfOne);
+    const m1Cost = m1Nodes.reduce((s2, n) => s2 + (n.employee.total_cost || 0), 0);
+    const share = m.managerCount ? m.managerOfOneCount / m.managerCount : 0;
+    out.push(
+      insight({
+        title: `${m.managerOfOneCount} "manager of one" roles each oversee a single report`,
+        severity: share > 0.15 ? "high" : "medium",
+        category: "span",
+        evidence: `${m.managerOfOneCount} of ${m.managerCount} managers (${fmtPct(share)}) have exactly one direct report, with combined cost ${fmtMoney(m1Cost, sym)}. Single-report management layers are a primary target in 2025\u201326 flattening playbooks.`,
+        impact: "A manager with one report usually adds a hand-off and an approval step without widening coordination \u2014 a candidate to flatten by merging the role into player-coach or peer structures.",
+        recommendation: "Review each manager-of-one: convert to an individual contributor / player-coach, or consolidate the pair under a peer manager. Validate against development and succession intent before acting.",
+        relatedEntities: m1Nodes.map((n) => n.employee.employee_id).slice(0, 15),
+        financialImpact: m.spanOptimizationOpportunity,
+        employeesAffected: m.managerOfOneCount,
+        confidence: "high",
+        easeOfAction: "moderate",
+        linkTo: "/diagnostics"
+      })
+    );
+  }
+  if (m.pureSupervisoryLayers.length > 0) {
+    const layersList = m.pureSupervisoryLayers.join(", ");
+    const passThruNodes = [...tree2.nodes.values()].filter(
+      (n) => m.pureSupervisoryLayers.includes(n.layer) && n.isManager
+    );
+    const passCost = passThruNodes.reduce((s2, n) => s2 + (n.employee.total_cost || 0), 0);
+    out.push(
+      insight({
+        title: `Layer${m.pureSupervisoryLayers.length > 1 ? "s" : ""} ${layersList} ${m.pureSupervisoryLayers.length > 1 ? "are" : "is"} purely supervisory (managers managing managers)`,
+        severity: "medium",
+        category: "layer",
+        evidence: `Every role at layer ${layersList} is a manager whose direct reports are all themselves managers \u2014 a management-only pass-through with no ICs (${passThruNodes.length} role(s), ${fmtMoney(passCost, sym)} cost).`,
+        impact: "Pass-through layers add escalation distance and dilute accountability without owning delivery work.",
+        recommendation: "Test a delayering scenario targeting these layers; confirm each retained layer holds distinct decision rights.",
+        relatedEntities: passThruNodes.map((n) => n.employee.employee_id).slice(0, 15),
+        financialImpact: 0,
+        employeesAffected: passThruNodes.length,
+        confidence: "high",
+        easeOfAction: "moderate",
+        linkTo: "/diagnostics"
+      })
+    );
+  }
+  const aiHigh = m.aiExposure.find((b) => b.band === "high");
+  if (aiHigh && m.totalCost > 0 && aiHigh.cost / m.totalCost > 0.1) {
+    const costShare = aiHigh.cost / m.totalCost;
+    out.push(
+      insight({
+        title: `${fmtPct(costShare)} of workforce cost sits in roles with high AI-augmentation potential`,
+        severity: costShare > 0.25 ? "high" : "medium",
+        category: "cost",
+        evidence: `${aiHigh.headcount} role(s) (${fmtMoney(aiHigh.cost, sym)}) fall in the high AI-augmentation band \u2014 predominantly processing, support, coordination and analytical work. Banding is heuristic and indicative.`,
+        impact: "High-augmentation work is where AI-enabled productivity and role redesign can compound \u2014 but augmentation is not elimination; the lens is about reshaping work, not headcount cuts.",
+        recommendation: "Run a role-level assessment for the high-band population: identify tasks suited to augmentation, redesign workflows, and reinvest freed capacity. Treat as a productivity/redesign opportunity requiring validation, not an automatic reduction.",
+        relatedEntities: [],
+        financialImpact: 0,
+        employeesAffected: aiHigh.headcount,
+        confidence: "low",
+        easeOfAction: "hard",
+        linkTo: "/cost"
+      })
+    );
+  }
+  if (m.totalCost > 0 && m.unfilledSeatCost / m.totalCost >= 0.03) {
+    const gapShare = m.unfilledSeatCost / m.totalCost;
+    out.push(
+      insight({
+        title: `Designed cost runs ${fmtMoney(m.unfilledSeatCost, sym)} above current run-rate \u2014 ${m.unfilledSeats} unfilled seat${m.unfilledSeats === 1 ? "" : "s"}`,
+        severity: gapShare >= 0.08 ? "high" : "medium",
+        category: "cost",
+        evidence: `${m.unfilledSeats} budgeted seat${m.unfilledSeats === 1 ? " is" : "s are"} vacant or to-be-hired (${m.vacantSeats} vacant, ${m.tbhSeats} TBH), carrying ${fmtMoney(m.unfilledSeatCost, sym)} of budgeted cost \u2014 ${fmtPct(gapShare)} of the ${fmtMoney(m.totalCost, sym)} designed cost base. Run-rate today is ${fmtMoney(m.runRateCost, sym)}.`,
+        impact: "Every unfilled seat is a pending cost commitment. Closing vacancies instead of filling them avoids future cost with zero severance \u2014 the cheapest restructuring lever available.",
+        recommendation: "Review each open seat against the target structure before recruiting: model a scenario eliminating the vacancies that the future design doesn't need.",
+        relatedEntities: employees.filter((e) => e.position_status === "vacant" || e.position_status === "tbh").map((e) => e.employee_id).slice(0, 15),
+        financialImpact: m.unfilledSeatCost,
+        employeesAffected: m.unfilledSeats,
+        confidence: "high",
+        easeOfAction: "easy",
+        linkTo: "/scenarios"
+      })
+    );
+  }
+  if (m.vacancyRate > 0) {
+    const concentrated = Object.entries(m.unfilledByFunction).map(([func, count]) => ({
+      func,
+      count,
+      rate: count / Math.max(1, m.headcountByFunction[func] ?? 0)
+    })).filter((f) => f.count >= 3 && f.rate >= m.vacancyRate * 2).sort((x, y) => y.count - x.count)[0];
+    if (concentrated) {
+      out.push(
+        insight({
+          title: `${concentrated.func} concentrates ${concentrated.count} of the organization's ${m.unfilledSeats} unfilled seats`,
+          severity: concentrated.rate >= 0.25 ? "high" : "medium",
+          category: "structure",
+          evidence: `${fmtPct(concentrated.rate)} of ${concentrated.func}'s ${m.headcountByFunction[concentrated.func] ?? 0} seats are vacant or to-be-hired, versus ${fmtPct(m.vacancyRate)} organization-wide.`,
+          impact: "Concentrated vacancy signals either acute hiring exposure (delivery risk in that function) or phantom structure \u2014 seats budgeted for an organization that no longer matches the plan.",
+          recommendation: `Validate ${concentrated.func}'s open seats with its leadership: confirm which are genuinely needed in the target design, then either prioritize the hires or model eliminating the remainder.`,
+          relatedEntities: [concentrated.func],
+          financialImpact: 0,
+          employeesAffected: concentrated.count,
+          confidence: "high",
+          easeOfAction: "moderate",
+          linkTo: "/org"
+        })
+      );
+    }
+  }
+  const avgMgmtRatio = m.managementCostRatio;
+  const funcMgmtRatios = [];
+  for (const func of Object.keys(m.costByFunction)) {
+    const funcNodes = [...tree2.nodes.values()].filter((n) => n.layer > 0 && n.employee.function === func);
+    const funcCost = funcNodes.reduce((s2, n) => s2 + (n.employee.total_cost || 0), 0);
+    const funcMgmt = funcNodes.filter((n) => n.isManager).reduce((s2, n) => s2 + (n.employee.total_cost || 0), 0);
+    if (funcCost > 0 && funcNodes.length >= 5) funcMgmtRatios.push([func, funcMgmt / funcCost]);
+  }
+  funcMgmtRatios.sort((x, y) => y[1] - x[1]);
+  if (funcMgmtRatios[0] && funcMgmtRatios[0][1] > avgMgmtRatio + 0.08) {
+    const [func, ratio] = funcMgmtRatios[0];
+    out.push(
+      insight({
+        title: `${func} has the highest management cost ratio at ${fmtPct(ratio)}`,
+        severity: ratio > 0.45 ? "high" : "medium",
+        category: "cost",
+        evidence: `${fmtPct(ratio)} of ${func}'s cost sits with people managers, versus a company average of ${fmtPct(avgMgmtRatio)}.`,
+        impact: "A high management cost share can indicate over-layering or narrow spans within the function.",
+        recommendation: `Review ${func}'s structure in the Org Explorer and test span/layer scenarios.`,
+        relatedEntities: [func],
+        financialImpact: (ratio - avgMgmtRatio) * (m.costByFunction[func] ?? 0),
+        employeesAffected: m.headcountByFunction[func] ?? 0,
+        confidence: "medium",
+        easeOfAction: "moderate",
+        linkTo: "/cost"
+      })
+    );
+  }
+  const topFunc = sortedEntries(m.costByFunction)[0];
+  if (topFunc) {
+    out.push(
+      insight({
+        title: `${topFunc[0]} is the highest-cost function at ${fmtMoney(topFunc[1], sym)}`,
+        severity: "low",
+        category: "cost",
+        evidence: `${topFunc[0]} accounts for ${fmtPct(topFunc[1] / m.totalCost)} of total workforce cost with ${m.headcountByFunction[topFunc[0]] ?? 0} employees.`,
+        impact: "Cost concentration identifies where structural decisions have the largest financial leverage.",
+        recommendation: "Prioritize this function when evaluating delayering and span scenarios.",
+        relatedEntities: [topFunc[0]],
+        financialImpact: 0,
+        employeesAffected: m.headcountByFunction[topFunc[0]] ?? 0,
+        confidence: "high",
+        easeOfAction: "easy",
+        linkTo: "/cost"
+      })
+    );
+  }
+  if (m.duplicateRoles.length > 0) {
+    const top = m.duplicateRoles[0];
+    out.push(
+      insight({
+        title: `${m.duplicateRoles.length} potential duplicate senior role group(s) across business units`,
+        severity: m.duplicateRoleCost > m.totalCost * 0.02 ? "high" : "medium",
+        category: "duplication",
+        evidence: `Largest group: "${top.employees[0].title}" held by ${top.employees.length} people across ${top.units.join(", ")} (combined cost ${fmtMoney(top.totalCost, sym)}). Total cost of potential duplicates beyond one holder per group: ${fmtMoney(m.duplicateRoleCost, sym)}.`,
+        impact: "Duplicated leadership roles across units may indicate decentralization without deliberate design.",
+        recommendation: "Mark as potential duplication requiring review \u2014 consider a shared-services scenario to test consolidation. Duplication is not automatically bad; validate with business owners.",
+        relatedEntities: m.duplicateRoles.flatMap((g) => g.employees.map((e) => e.id)).slice(0, 15),
+        financialImpact: m.duplicationOpportunity,
+        employeesAffected: m.duplicateRoles.reduce((s2, g) => s2 + g.employees.length, 0),
+        confidence: "medium",
+        easeOfAction: "hard",
+        linkTo: "/insights"
+      })
+    );
+  }
+  const execNodes = [...tree2.nodes.values()].filter((n) => n.layer <= 2 && n.isManager);
+  const seniorIcs = execNodes.flatMap(
+    (ex) => ex.directReports.map((id) => tree2.nodes.get(id)).filter((n) => !n.isManager && (n.employee.total_cost || 0) > 35e4)
+  );
+  if (seniorIcs.length >= 2) {
+    const totalIcCost = seniorIcs.reduce((s2, n) => s2 + n.employee.total_cost, 0);
+    out.push(
+      insight({
+        title: `${seniorIcs.length} expensive individual contributors report directly to executives`,
+        severity: "medium",
+        category: "structure",
+        evidence: `${seniorIcs.length} ICs costing over ${fmtMoney(35e4, sym)} each (combined ${fmtMoney(totalIcCost, sym)}) sit at executive level: ${seniorIcs.slice(0, 3).map((n) => n.employee.role_title).join("; ")}.`,
+        impact: "Senior IC roles at the top consume executive attention and can blur accountability for delivery.",
+        recommendation: "Validate the mandate of each senior advisory role; consider anchoring them within functions.",
+        relatedEntities: seniorIcs.map((n) => n.employee.employee_id),
+        financialImpact: 0,
+        employeesAffected: seniorIcs.length,
+        confidence: "medium",
+        easeOfAction: "easy",
+        linkTo: "/org"
+      })
+    );
+  }
+  const locEntries = sortedEntries(m.costByLocation);
+  if (locEntries.length >= 2) {
+    const hqLoc = locEntries[0];
+    const avgCostByLoc = Object.entries(m.costByLocation).map(([loc, cost]) => ({
+      loc,
+      avg: cost / Math.max(1, m.headcountByLocation[loc] ?? 1),
+      hc: m.headcountByLocation[loc] ?? 0
+    }));
+    avgCostByLoc.sort((x, y) => y.avg - x.avg);
+    const high = avgCostByLoc[0];
+    const low = avgCostByLoc[avgCostByLoc.length - 1];
+    if (high && low && high.avg > low.avg * 2 && low.hc >= 5) {
+      out.push(
+        insight({
+          title: `Average cost per head in ${high.loc} is ${(high.avg / low.avg).toFixed(1)}\xD7 ${low.loc}`,
+          severity: "low",
+          category: "location",
+          evidence: `${high.loc}: ${fmtMoney(high.avg, sym)}/head across ${high.hc} employees vs ${low.loc}: ${fmtMoney(low.avg, sym)}/head across ${low.hc}. ${hqLoc[0]} carries the largest absolute cost (${fmtMoney(hqLoc[1], sym)}).`,
+          impact: "Location mix is a structural cost lever, particularly for transactional and delivery roles.",
+          recommendation: "Test a location-shift scenario for portable role families. Requires validation against service, regulatory and talent constraints.",
+          relatedEntities: [high.loc, low.loc],
+          financialImpact: 0,
+          employeesAffected: high.hc,
+          confidence: "medium",
+          easeOfAction: "hard",
+          linkTo: "/scenarios"
+        })
+      );
+    }
+  }
+  const gradeCounts = sortedEntries(m.headcountByGrade);
+  const seniorShare = (m.headcountByGrade["E1"] ?? 0) + (m.headcountByGrade["E2"] ?? 0) + (m.headcountByGrade["M1"] ?? 0);
+  if (m.headcount > 0 && seniorShare / m.headcount > 0.12 && gradeCounts.length >= 4) {
+    out.push(
+      insight({
+        title: `Senior grades represent ${fmtPct(seniorShare / m.headcount)} of headcount \u2014 top-heavy pyramid`,
+        severity: "medium",
+        category: "grade",
+        evidence: `${seniorShare} employees sit in the top three grades out of ${m.headcount} total.`,
+        impact: "A top-heavy grade mix inflates cost and can compress development paths for mid-level talent.",
+        recommendation: "Review the grade pyramid in Cost Analytics and validate spans at senior grades.",
+        relatedEntities: ["E1", "E2", "M1"],
+        financialImpact: 0,
+        employeesAffected: seniorShare,
+        confidence: "medium",
+        easeOfAction: "hard",
+        linkTo: "/cost"
+      })
+    );
+  }
+  const overloadedHighRisk = m.wideSpanManagers.map((id) => tree2.nodes.get(id)).filter((n) => n.directReports.some((rid) => tree2.nodes.get(rid)?.employee.attrition_risk === "High"));
+  if (overloadedHighRisk.length > 0) {
+    out.push(
+      insight({
+        title: `Overloaded teams contain high attrition-risk employees`,
+        severity: "high",
+        category: "risk",
+        evidence: `${overloadedHighRisk.length} overloaded manager(s) have direct reports flagged high attrition risk (e.g. ${overloadedHighRisk[0].employee.employee_name}'s team of ${overloadedHighRisk[0].span}).`,
+        impact: "Wide spans plus attrition risk compound: less manager attention precisely where retention is fragile.",
+        recommendation: "Prioritize span relief for these teams before broader restructuring.",
+        relatedEntities: overloadedHighRisk.map((n) => n.employee.employee_id),
+        financialImpact: 0,
+        employeesAffected: overloadedHighRisk.reduce((s2, n) => s2 + n.span, 0),
+        confidence: "medium",
+        easeOfAction: "moderate",
+        linkTo: "/diagnostics"
+      })
+    );
+  }
+  if (m.totalOpportunity > 0) {
+    out.push(
+      insight({
+        title: `Indicative simplification opportunity of ${fmtMoney(m.totalOpportunity, sym)}`,
+        severity: m.totalOpportunity > m.totalCost * 0.03 ? "high" : "medium",
+        category: "executive",
+        evidence: `Composed of three levers: delayering of narrow-span managers with 3+ reports (${fmtMoney(m.delayeringOpportunity, sym)}), span optimization of managers with only 1\u20132 reports who could be ICs (${fmtMoney(m.spanOptimizationOpportunity, sym)}) and duplicate-role consolidation (${fmtMoney(m.duplicationOpportunity, sym)}). The two span levers are disjoint (no manager counted in both); duplication is a separate lens that may overlap with delayering. Based on configurable assumptions (${a.delayeringSavingPct}% / ${a.duplicateRoleSavingPct}% capture rates, ${a.spanOptPremiumPct ?? 20}% management premium).`,
+        impact: `Equivalent to ${fmtPct(m.totalOpportunity / m.totalCost)} of total workforce cost. Indicative only \u2014 requires validation through detailed design.`,
+        recommendation: "Build 2\u20133 scenarios capturing different portions of this opportunity and compare them in From-To Comparison.",
+        relatedEntities: [],
+        financialImpact: m.totalOpportunity,
+        employeesAffected: m.narrowSpanManagers.length,
+        confidence: "medium",
+        easeOfAction: "moderate",
+        linkTo: "/scenarios"
+      })
+    );
+  }
+  for (const { name: name2, evaluation: ev } of ctx.scenarioEvaluations ?? []) {
+    const saving = -ev.costDelta;
+    out.push(
+      insight({
+        title: `Scenario "${name2}": ${saving >= 0 ? `${fmtMoney(saving, sym)} indicative saving` : `${fmtMoney(-saving, sym)} cost increase`}, ${ev.layerDelta === 0 ? "no layer change" : `${Math.abs(ev.layerDelta)} layer${Math.abs(ev.layerDelta) > 1 ? "s" : ""} ${ev.layerDelta < 0 ? "removed" : "added"}`}`,
+        severity: ev.risk.level === "High" || ev.risk.level === "Very High" ? "medium" : "low",
+        category: "scenario",
+        evidence: `Headcount ${ev.headcountDelta >= 0 ? "+" : ""}${ev.headcountDelta}; ${ev.employeesMoved} moved, ${ev.rolesRemoved} roles removed, ${ev.rolesAdded} added. Change risk: ${ev.risk.level} (${ev.risk.score}/100). Scenario score: ${ev.score.total}/100.`,
+        impact: ev.risk.recommendation,
+        recommendation: `Compare against other options in From-To Comparison before committing.`,
+        relatedEntities: [],
+        financialImpact: Math.max(0, saving),
+        employeesAffected: ev.employeesMoved + ev.rolesRemoved,
+        confidence: "high",
+        easeOfAction: ev.risk.level === "Low" ? "easy" : ev.risk.level === "Medium" ? "moderate" : "hard",
+        linkTo: "/compare"
+      })
+    );
+  }
+  return rankInsights(out);
+}
+function rankInsights(insights) {
+  const sevW = { high: 3, medium: 2, low: 1 };
+  const confW = { high: 1.2, medium: 1, low: 0.8 };
+  const easeW = { easy: 1.2, moderate: 1, hard: 0.85 };
+  const maxFin = Math.max(1, ...insights.map((i) => i.financialImpact));
+  const maxEmp = Math.max(1, ...insights.map((i) => i.employeesAffected));
+  const scored = insights.map((i) => ({
+    i,
+    s: sevW[i.severity] * 40 + i.financialImpact / maxFin * 30 + i.employeesAffected / maxEmp * 15 + confW[i.confidence] * 10 + easeW[i.easeOfAction] * 5
+  }));
+  scored.sort((a, b) => b.s - a.s);
+  return scored.map(({ i }, idx) => ({ ...i, rank: idx + 1 }));
+}
+function generateInsightsFromEmployees(employees, assumptions, scenarioEvaluations) {
+  const metrics = computeMetrics(employees, assumptions);
+  return generateInsights({ employees, metrics, assumptions, scenarioEvaluations });
+}
+var FULL_NODE = { nodeWidth: 224, nodeHeight: 104, gapX: 24, gapY: 56 };
+var COMPACT_NODE = { nodeWidth: 128, nodeHeight: 40, gapX: 14, gapY: 36 };
+function buildLayoutTree(orgTree, rootId, isExpanded) {
+  const rootNode = orgTree.nodes.get(rootId);
+  if (!rootNode) return null;
+  const root = { id: rootId, node: rootNode, collapsed: false };
+  const stack = [root];
+  while (stack.length > 0) {
+    const datum = stack.pop();
+    const open = isExpanded(datum.id);
+    datum.collapsed = datum.node.directReports.length > 0 && !open;
+    if (!open) continue;
+    const kids = [];
+    for (const id of datum.node.directReports) {
+      const node = orgTree.nodes.get(id);
+      if (!node) continue;
+      const kid = { id, node, collapsed: false };
+      kids.push(kid);
+      stack.push(kid);
+    }
+    if (kids.length > 0) datum.children = kids;
+  }
+  return root;
+}
+function layoutOrg(orgTree, rootIds, isExpanded, opts) {
+  const nodes = [];
+  const edges = [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let offsetX = 0;
+  for (const rootId of rootIds) {
+    const datum = buildLayoutTree(orgTree, rootId, isExpanded);
+    if (!datum) continue;
+    const root = hierarchy(datum, (d) => d.children);
+    const layout = tree().nodeSize([
+      opts.nodeWidth + opts.gapX,
+      opts.nodeHeight + opts.gapY
+    ]);
+    const positioned = layout(root);
+    let treeMinX = Infinity, treeMaxX = -Infinity;
+    positioned.each((n) => {
+      treeMinX = Math.min(treeMinX, n.x);
+      treeMaxX = Math.max(treeMaxX, n.x);
+    });
+    const shift = offsetX - treeMinX + opts.nodeWidth / 2;
+    positioned.each((n) => {
+      const x = n.x + shift;
+      const y = n.depth * (opts.nodeHeight + opts.gapY);
+      nodes.push({ id: n.data.id, x, y, node: n.data.node, collapsed: n.data.collapsed });
+      minX = Math.min(minX, x - opts.nodeWidth / 2);
+      maxX = Math.max(maxX, x + opts.nodeWidth / 2);
+      minY = Math.min(minY, y);
+      maxY = Math.max(maxY, y + opts.nodeHeight);
+      if (n.parent) {
+        const px = n.parent.x + shift;
+        const py = n.parent.depth * (opts.nodeHeight + opts.gapY);
+        edges.push({
+          id: `${n.parent.data.id}->${n.data.id}`,
+          sourceId: n.parent.data.id,
+          targetId: n.data.id,
+          path: elbowPath(px, py + opts.nodeHeight, x, y)
+        });
+      }
+    });
+    offsetX += treeMaxX - treeMinX + opts.nodeWidth + opts.gapX * 4;
+  }
+  if (nodes.length === 0) return { nodes, edges, bounds: { minX: 0, minY: 0, maxX: 0, maxY: 0 }, visibleCount: 0 };
+  return { nodes, edges, bounds: { minX, minY, maxX, maxY }, visibleCount: nodes.length };
+}
+function elbowPath(x1, y1, x2, y2) {
+  const midY = y1 + (y2 - y1) / 2;
+  if (Math.abs(x1 - x2) < 1) return `M${x1},${y1} L${x2},${y2}`;
+  const r = Math.min(8, Math.abs(x2 - x1) / 2, Math.abs(y2 - midY));
+  const dir = x2 > x1 ? 1 : -1;
+  return [
+    `M${x1},${y1}`,
+    `L${x1},${midY - r}`,
+    `Q${x1},${midY} ${x1 + r * dir},${midY}`,
+    `L${x2 - r * dir},${midY}`,
+    `Q${x2},${midY} ${x2},${midY + r}`,
+    `L${x2},${y2}`
+  ].join(" ");
+}
+function fitToBounds(bounds, containerW, containerH, padding = 48, maxK = 1, minK = 0.05) {
+  const bw = Math.max(1, bounds.maxX - bounds.minX);
+  const bh = Math.max(1, bounds.maxY - bounds.minY);
+  const k = Math.max(
+    minK,
+    Math.min(maxK, (containerW - padding * 2) / bw, (containerH - padding * 2) / bh)
+  );
+  return {
+    k,
+    x: (containerW - bw * k) / 2 - bounds.minX * k,
+    y: (containerH - bh * k) / 2 - bounds.minY * k
+  };
+}
+function zoomAround(vp, screenX, screenY, factor, minK = 0.08, maxK = 2) {
+  const k = Math.min(maxK, Math.max(minK, vp.k * factor));
+  const ratio = k / vp.k;
+  return { k, x: screenX - (screenX - vp.x) * ratio, y: screenY - (screenY - vp.y) * ratio };
+}
+function visibleNodes(nodes, vp, containerW, containerH, opts, overscan = 400) {
+  const left = (-vp.x - overscan) / vp.k;
+  const right = (containerW - vp.x + overscan) / vp.k;
+  const top = (-vp.y - overscan) / vp.k;
+  const bottom = (containerH - vp.y + overscan) / vp.k;
+  return nodes.filter(
+    (n) => n.x + opts.nodeWidth / 2 >= left && n.x - opts.nodeWidth / 2 <= right && n.y + opts.nodeHeight >= top && n.y <= bottom
+  );
+}
+
+// src/lib/demo-data.ts
+function mulberry32(seed) {
+  let a = seed;
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var rand = mulberry32(420042);
+var pick = (arr) => arr[Math.floor(rand() * arr.length)];
+var randint = (min, max) => min + Math.floor(rand() * (max - min + 1));
+var FIRST = ["James", "Mary", "Robert", "Patricia", "John", "Jennifer", "Michael", "Linda", "David", "Elena", "William", "Barbara", "Richard", "Susan", "Joseph", "Jessica", "Thomas", "Sarah", "Carlos", "Karen", "Daniel", "Nancy", "Matthew", "Lisa", "Anthony", "Betty", "Mark", "Maya", "Donald", "Sandra", "Steven", "Ashley", "Paul", "Kim", "Andrew", "Donna", "Joshua", "Emily", "Kenneth", "Priya", "Kevin", "Carol", "Brian", "Amanda", "George", "Melissa", "Timothy", "Deborah", "Ronald", "Stephanie", "Wei", "Rebecca", "Jason", "Sharon", "Edward", "Laura", "Jeffrey", "Cynthia", "Ryan", "Aisha", "Jacob", "Amy", "Gary", "Anna", "Nicholas", "Ingrid", "Eric", "Ruth", "Jonathan", "Fatima", "Stephen", "Olivia", "Larry", "Noor", "Justin", "Diane", "Scott", "Alice", "Brandon", "Julie", "Raj", "Heather", "Samuel", "Teresa", "Benjamin", "Gloria", "Hiroshi", "Sofia", "Frank", "Evelyn", "Gregory", "Joan", "Tomasz", "Lucia", "Alexander", "Judith", "Patrick", "Mei", "Jack", "Andrea"];
+var LAST = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis", "Rodriguez", "Martinez", "Hernandez", "Lopez", "Gonzalez", "Wilson", "Anderson", "Thomas", "Taylor", "Moore", "Jackson", "Martin", "Lee", "Perez", "Thompson", "White", "Harris", "Sanchez", "Clark", "Ramirez", "Lewis", "Robinson", "Walker", "Young", "Allen", "King", "Wright", "Scott", "Torres", "Nguyen", "Hill", "Flores", "Green", "Adams", "Nelson", "Baker", "Hall", "Rivera", "Campbell", "Mitchell", "Carter", "Roberts", "Sharma", "Patel", "Kowalski", "Tan", "Lim", "Murphy", "O'Brien", "Kelly", "Novak", "Kumar", "Singh", "Reyes", "Santos", "Cruz", "Mendoza", "Fischer", "Weber", "Meyer", "Wagner", "Becker"];
+var usedNames = /* @__PURE__ */ new Set();
+function name() {
+  for (let i = 0; i < 50; i++) {
+    const n = `${pick(FIRST)} ${pick(LAST)}`;
+    if (!usedNames.has(n)) {
+      usedNames.add(n);
+      return n;
+    }
+  }
+  return `${pick(FIRST)} ${pick(LAST)} ${randint(1, 99)}`;
+}
+var HQ = { city: "New York", country: "United States", mult: 1 };
+var LOCS = [
+  HQ,
+  { city: "London", country: "United Kingdom", mult: 0.95 },
+  { city: "Singapore", country: "Singapore", mult: 0.85 },
+  { city: "Dublin", country: "Ireland", mult: 0.8 },
+  { city: "Warsaw", country: "Poland", mult: 0.45 },
+  { city: "Bangalore", country: "India", mult: 0.35 },
+  { city: "Manila", country: "Philippines", mult: 0.3 }
+];
+var GRADES = ["E1", "E2", "M1", "M2", "M3", "P3", "P2", "P1"];
+var BASE_SALARY = [95e4, 52e4, 32e4, 23e4, 165e3, 125e3, 92e3, 62e3];
+var seq2 = 0;
+function emp(opts) {
+  seq2 += 1;
+  const id = `E${String(seq2).padStart(4, "0")}`;
+  const loc = opts.loc ?? (rand() < 0.55 ? HQ : pick(LOCS));
+  const lvlIdx = Math.min(opts.level, 8) - 1;
+  const base = BASE_SALARY[lvlIdx] * loc.mult * (0.85 + rand() * 0.3);
+  const salary = Math.round(base / 1e3) * 1e3;
+  const bonusPct = opts.level <= 2 ? 0.5 : opts.level <= 4 ? 0.25 : 0.1;
+  const bonus = Math.round(salary * bonusPct * (0.6 + rand() * 0.8) / 1e3) * 1e3;
+  const total = opts.costOverride ?? Math.round((salary + bonus) * 1.18);
+  return {
+    employee_id: id,
+    employee_name: opts.nameOverride ?? name(),
+    role_title: opts.title,
+    manager_id: opts.managerId,
+    manager_name: opts.managerName,
+    department: opts.dept,
+    function: opts.func,
+    business_unit: opts.bu,
+    location: loc.city,
+    country: loc.country,
+    grade: GRADES[lvlIdx],
+    level: opts.level,
+    employment_type: rand() < 0.93 ? "Full-time" : "Contractor",
+    fte: rand() < 0.95 ? 1 : 0.5,
+    salary,
+    bonus,
+    total_cost: total,
+    status: "Active",
+    tenure: randint(0, 18),
+    gender: rand() < 0.48 ? "Female" : rand() < 0.96 ? "Male" : "Non-binary",
+    performance_rating: pick(["Exceeds", "Meets", "Meets", "Meets", "Below"]),
+    critical_role: opts.critical ?? rand() < 0.06,
+    role_family: opts.roleFamily,
+    attrition_risk: pick(["Low", "Low", "Low", "Medium", "Medium", "High"])
+  };
+}
+function team(opts) {
+  const out = [];
+  const mgr = emp({
+    title: opts.mgrTitle,
+    managerId: opts.managerId,
+    dept: opts.dept,
+    func: opts.func,
+    bu: opts.bu,
+    loc: opts.loc,
+    level: opts.mgrLevel
+  });
+  out.push(mgr);
+  for (let i = 0; i < opts.size; i++) {
+    out.push(
+      emp({
+        title: opts.reportTitle,
+        managerId: mgr.employee_id,
+        managerName: mgr.employee_name,
+        dept: opts.dept,
+        func: opts.func,
+        bu: opts.bu,
+        loc: opts.loc,
+        level: Math.min(8, opts.mgrLevel + randint(1, 2))
+      })
+    );
+  }
+  return out;
+}
+function generateDemoData() {
+  seq2 = 0;
+  usedNames.clear();
+  rand = mulberry32(420042);
+  const all = [];
+  const add = (...es) => {
+    all.push(...es);
+    return es[0];
+  };
+  const ceo = add(emp({ nameOverride: "Margaret Chen", title: "Chief Executive Officer", managerId: null, dept: "Executive", func: "Executive", bu: "Corporate", loc: HQ, level: 1, critical: true }));
+  add(emp({ title: "Chief of Staff", managerId: ceo.employee_id, dept: "Executive", func: "Executive", bu: "Corporate", loc: HQ, level: 3, critical: true }));
+  add(emp({ title: "Executive Assistant", managerId: ceo.employee_id, dept: "Executive", func: "Executive", bu: "Corporate", loc: HQ, level: 7 }));
+  const exec = (title, func, bu = "Corporate") => add(emp({ title, managerId: ceo.employee_id, dept: func, func, bu, loc: HQ, level: 2, critical: true }));
+  const cfo = exec("Chief Financial Officer", "Finance");
+  const chro = exec("Chief Human Resources Officer", "HR");
+  const cto = exec("Chief Technology Officer", "Technology");
+  const coo = exec("Chief Operating Officer", "Operations");
+  const cro = exec("Chief Revenue Officer", "Sales");
+  const cmo = exec("Chief Marketing Officer", "Marketing");
+  const gc = exec("General Counsel", "Legal");
+  const cpo = exec("Chief Product Officer", "Product");
+  const cco = exec("Chief Customer Officer", "Customer Service");
+  const finVp = (t) => add(emp({ title: t, managerId: cfo.employee_id, dept: "Finance", func: "Finance", bu: "Corporate", loc: HQ, level: 3 }));
+  const vpFpa = finVp("VP Financial Planning & Analysis");
+  const vpCtrl = finVp("VP Controller");
+  const vpTreas = finVp("VP Treasury");
+  const vpTax = finVp("VP Tax");
+  add(emp({ title: "Senior Finance Advisor", managerId: cfo.employee_id, dept: "Finance", func: "Finance", bu: "Corporate", loc: HQ, level: 3 }));
+  add(...team({ mgrTitle: "Director, FP&A", reportTitle: "FP&A Analyst", managerId: vpFpa.employee_id, dept: "FP&A", func: "Finance", bu: "Corporate", mgrLevel: 4, size: 5 }));
+  add(...team({ mgrTitle: "Director, Business Finance", reportTitle: "Finance Business Partner", managerId: vpFpa.employee_id, dept: "FP&A", func: "Finance", bu: "Corporate", mgrLevel: 4, size: 4 }));
+  add(...team({ mgrTitle: "Director, Accounting", reportTitle: "Senior Accountant", managerId: vpCtrl.employee_id, dept: "Accounting", func: "Finance", bu: "Corporate", loc: LOCS[4], mgrLevel: 4, size: 6 }));
+  add(...team({ mgrTitle: "Director, Accounts Payable", reportTitle: "AP Specialist", managerId: vpCtrl.employee_id, dept: "Accounting", func: "Finance", bu: "Corporate", loc: LOCS[5], mgrLevel: 4, size: 5 }));
+  add(...team({ mgrTitle: "Treasury Manager", reportTitle: "Treasury Analyst", managerId: vpTreas.employee_id, dept: "Treasury", func: "Finance", bu: "Corporate", mgrLevel: 4, size: 1 }));
+  add(emp({ title: "Cash Management Analyst", managerId: vpTreas.employee_id, dept: "Treasury", func: "Finance", bu: "Corporate", level: 6 }));
+  add(emp({ title: "Tax Manager", managerId: vpTax.employee_id, dept: "Tax", func: "Finance", bu: "Corporate", level: 4 }));
+  const vpPeopleOps = add(emp({ title: "VP People Operations", managerId: chro.employee_id, dept: "HR", func: "HR", bu: "Corporate", loc: HQ, level: 3 }));
+  const vpTalent = add(emp({ title: "VP Talent Acquisition", managerId: chro.employee_id, dept: "HR", func: "HR", bu: "Corporate", loc: HQ, level: 3 }));
+  add(emp({ title: "Head of Total Rewards", managerId: chro.employee_id, dept: "HR", func: "HR", bu: "Corporate", loc: HQ, level: 3 }));
+  add(...team({ mgrTitle: "Manager, HR Business Partners", reportTitle: "HR Business Partner", managerId: vpPeopleOps.employee_id, dept: "HR", func: "HR", bu: "Corporate", mgrLevel: 4, size: 6 }));
+  add(...team({ mgrTitle: "Manager, HR Shared Services", reportTitle: "HR Operations Specialist", managerId: vpPeopleOps.employee_id, dept: "HR", func: "HR", bu: "Corporate", loc: LOCS[5], mgrLevel: 4, size: 7 }));
+  add(...team({ mgrTitle: "Manager, Recruiting", reportTitle: "Recruiter", managerId: vpTalent.employee_id, dept: "HR", func: "HR", bu: "Corporate", mgrLevel: 4, size: 5 }));
+  const svpEng = add(emp({ title: "SVP Engineering", managerId: cto.employee_id, dept: "Engineering", func: "Technology", bu: "Corporate", loc: HQ, level: 3, critical: true }));
+  const vpInfra = add(emp({ title: "VP Infrastructure", managerId: svpEng.employee_id, dept: "Infrastructure", func: "Technology", bu: "Corporate", loc: HQ, level: 3 }));
+  const vpApps = add(emp({ title: "VP Application Development", managerId: svpEng.employee_id, dept: "Engineering", func: "Technology", bu: "Corporate", loc: HQ, level: 3 }));
+  add(emp({ title: "Head of PMO", managerId: cto.employee_id, dept: "Technology PMO", func: "Technology", bu: "Corporate", loc: HQ, level: 3 }));
+  add(emp({ title: "Chief Architect", managerId: cto.employee_id, dept: "Architecture", func: "Technology", bu: "Corporate", loc: HQ, level: 3, costOverride: 72e4, critical: true }));
+  const vpSec = add(emp({ title: "VP Information Security", managerId: cto.employee_id, dept: "Security", func: "Technology", bu: "Corporate", loc: HQ, level: 3 }));
+  const srDirInfra = add(emp({ title: "Senior Director, Cloud Platform", managerId: vpInfra.employee_id, dept: "Infrastructure", func: "Technology", bu: "Corporate", level: 4 }));
+  const dirCloud = add(emp({ title: "Director, Cloud Operations", managerId: srDirInfra.employee_id, dept: "Infrastructure", func: "Technology", bu: "Corporate", level: 5 }));
+  add(...team({ mgrTitle: "Manager, Cloud Operations", reportTitle: "Cloud Engineer", managerId: dirCloud.employee_id, dept: "Infrastructure", func: "Technology", bu: "Corporate", loc: LOCS[5], mgrLevel: 6, size: 6 }));
+  add(...team({ mgrTitle: "Manager, Site Reliability", reportTitle: "SRE Engineer", managerId: dirCloud.employee_id, dept: "Infrastructure", func: "Technology", bu: "Corporate", loc: LOCS[4], mgrLevel: 6, size: 5 }));
+  add(...team({ mgrTitle: "Director, Network Engineering", reportTitle: "Network Engineer", managerId: srDirInfra.employee_id, dept: "Infrastructure", func: "Technology", bu: "Corporate", mgrLevel: 5, size: 2 }));
+  add(...team({ mgrTitle: "Director, Platform Engineering", reportTitle: "Software Engineer", managerId: vpApps.employee_id, dept: "Engineering", func: "Technology", bu: "Corporate", loc: LOCS[5], mgrLevel: 4, size: 8 }));
+  add(...team({ mgrTitle: "Director, Data Engineering", reportTitle: "Data Engineer", managerId: vpApps.employee_id, dept: "Engineering", func: "Technology", bu: "Corporate", mgrLevel: 4, size: 6 }));
+  const dirQa = add(emp({ title: "Director, Quality Engineering", managerId: vpApps.employee_id, dept: "Engineering", func: "Technology", bu: "Corporate", level: 4 }));
+  add(emp({ title: "Sr. Software Engineer", managerId: dirQa.employee_id, dept: "Engineering", func: "Technology", bu: "Corporate", level: 6 }));
+  add(emp({ title: "Senior Software Engineer", managerId: dirQa.employee_id, dept: "Engineering", func: "Technology", bu: "Corporate", level: 6 }));
+  add(emp({ title: "QA Engineer", managerId: dirQa.employee_id, dept: "Engineering", func: "Technology", bu: "Corporate", level: 7 }));
+  add(...team({ mgrTitle: "Manager, Security Operations", reportTitle: "Security Analyst", managerId: vpSec.employee_id, dept: "Security", func: "Technology", bu: "Corporate", mgrLevel: 5, size: 4 }));
+  const svpOps = add(emp({ title: "SVP Global Operations", managerId: coo.employee_id, dept: "Operations", func: "Operations", bu: "Corporate", loc: HQ, level: 3 }));
+  add(emp({ title: "Head of Operational Excellence", managerId: coo.employee_id, dept: "Operations", func: "Operations", bu: "Corporate", level: 3 }));
+  add(emp({ title: "Head of PMO", managerId: coo.employee_id, dept: "Operations PMO", func: "Operations", bu: "Corporate", level: 3 }));
+  const regions = [["Americas", HQ], ["EMEA", LOCS[1]], ["APAC", LOCS[2]]];
+  for (const [region, loc] of regions) {
+    const rh = add(emp({ title: `VP Operations, ${region}`, managerId: svpOps.employee_id, dept: "Operations", func: "Operations", bu: region, loc, level: 3 }));
+    add(emp({ title: "Head of Operational Excellence", managerId: rh.employee_id, dept: "Operations", func: "Operations", bu: region, loc, level: 4 }));
+    add(...team({ mgrTitle: `Director, Service Delivery ${region}`, reportTitle: "Operations Analyst", managerId: rh.employee_id, dept: "Service Delivery", func: "Operations", bu: region, loc, mgrLevel: 4, size: region === "Americas" ? 7 : 5 }));
+    if (region !== "APAC") {
+      add(...team({ mgrTitle: `Manager, Logistics ${region}`, reportTitle: "Logistics Coordinator", managerId: rh.employee_id, dept: "Logistics", func: "Operations", bu: region, loc, mgrLevel: 5, size: 4 }));
+    }
+  }
+  const bigOpsMgr = add(emp({ title: "Manager, Processing Center", managerId: svpOps.employee_id, dept: "Processing", func: "Operations", bu: "Americas", loc: LOCS[6], level: 5 }));
+  for (let i = 0; i < 15; i++) add(emp({ title: "Processing Associate", managerId: bigOpsMgr.employee_id, managerName: bigOpsMgr.employee_name, dept: "Processing", func: "Operations", bu: "Americas", loc: LOCS[6], level: 8 }));
+  const salesRegions = [["Americas", HQ], ["EMEA", LOCS[1]], ["APAC", LOCS[2]]];
+  for (const [region, loc] of salesRegions) {
+    const rvp = add(emp({ title: `RVP Sales, ${region}`, managerId: cro.employee_id, dept: "Sales", func: "Sales", bu: region, loc, level: 3 }));
+    add(...team({ mgrTitle: `Director, Enterprise Sales ${region}`, reportTitle: "Account Executive", managerId: rvp.employee_id, dept: "Sales", func: "Sales", bu: region, loc, mgrLevel: 4, size: region === "Americas" ? 8 : 6 }));
+    add(...team({ mgrTitle: `Manager, Sales Development ${region}`, reportTitle: "Sales Development Rep", managerId: rvp.employee_id, dept: "Sales", func: "Sales", bu: region, loc, mgrLevel: 5, size: 6 }));
+    add(emp({ title: "Head of Sales Operations", managerId: rvp.employee_id, dept: "Sales Ops", func: "Sales", bu: region, loc, level: 4 }));
+  }
+  add(emp({ title: "VP Strategic Accounts", managerId: cro.employee_id, dept: "Sales", func: "Sales", bu: "Corporate", loc: HQ, level: 3, costOverride: 68e4 }));
+  add(emp({ title: "Strategic Account Director", managerId: cro.employee_id, dept: "Sales", func: "Sales", bu: "Corporate", loc: HQ, level: 4 }));
+  const vpBrand = add(emp({ title: "VP Brand & Communications", managerId: cmo.employee_id, dept: "Marketing", func: "Marketing", bu: "Corporate", loc: HQ, level: 3 }));
+  const vpGrowth = add(emp({ title: "VP Growth Marketing", managerId: cmo.employee_id, dept: "Marketing", func: "Marketing", bu: "Corporate", loc: HQ, level: 3 }));
+  add(...team({ mgrTitle: "Director, Content & Creative", reportTitle: "Content Specialist", managerId: vpBrand.employee_id, dept: "Marketing", func: "Marketing", bu: "Corporate", mgrLevel: 4, size: 4 }));
+  add(...team({ mgrTitle: "Director, Digital Marketing", reportTitle: "Digital Marketing Manager", managerId: vpGrowth.employee_id, dept: "Marketing", func: "Marketing", bu: "Corporate", loc: LOCS[3], mgrLevel: 4, size: 5 }));
+  add(emp({ title: "Events Manager", managerId: vpBrand.employee_id, dept: "Marketing", func: "Marketing", bu: "Corporate", level: 5 }));
+  add(...team({ mgrTitle: "Deputy General Counsel", reportTitle: "Corporate Counsel", managerId: gc.employee_id, dept: "Legal", func: "Legal", bu: "Corporate", mgrLevel: 3, size: 3 }));
+  const vpRisk = add(emp({ title: "VP Risk & Compliance", managerId: gc.employee_id, dept: "Risk & Compliance", func: "Risk", bu: "Corporate", loc: HQ, level: 3 }));
+  add(...team({ mgrTitle: "Director, Compliance", reportTitle: "Compliance Officer", managerId: vpRisk.employee_id, dept: "Risk & Compliance", func: "Risk", bu: "Corporate", loc: LOCS[3], mgrLevel: 4, size: 4 }));
+  add(emp({ title: "Risk Analyst", managerId: vpRisk.employee_id, dept: "Risk & Compliance", func: "Risk", bu: "Corporate", level: 6 }));
+  const vpProd = add(emp({ title: "VP Product Management", managerId: cpo.employee_id, dept: "Product", func: "Product", bu: "Corporate", loc: HQ, level: 3 }));
+  const vpDesign = add(emp({ title: "VP Design", managerId: cpo.employee_id, dept: "Design", func: "Product", bu: "Corporate", loc: HQ, level: 3 }));
+  add(...team({ mgrTitle: "Director, Product \u2014 Core Platform", reportTitle: "Product Manager", managerId: vpProd.employee_id, dept: "Product", func: "Product", bu: "Corporate", mgrLevel: 4, size: 5 }));
+  add(...team({ mgrTitle: "Director, Product \u2014 New Ventures", reportTitle: "Product Manager", managerId: vpProd.employee_id, dept: "Product", func: "Product", bu: "Corporate", mgrLevel: 4, size: 3 }));
+  add(...team({ mgrTitle: "Manager, UX Design", reportTitle: "Product Designer", managerId: vpDesign.employee_id, dept: "Design", func: "Product", bu: "Corporate", mgrLevel: 5, size: 4 }));
+  add(emp({ title: "Principal Product Strategist", managerId: cpo.employee_id, dept: "Product", func: "Product", bu: "Corporate", level: 4, costOverride: 54e4 }));
+  const vpCs = add(emp({ title: "VP Customer Support", managerId: cco.employee_id, dept: "Customer Service", func: "Customer Service", bu: "Corporate", loc: LOCS[6], level: 3 }));
+  const vpCsm = add(emp({ title: "VP Customer Success", managerId: cco.employee_id, dept: "Customer Success", func: "Customer Service", bu: "Corporate", loc: HQ, level: 3 }));
+  const bigCsMgr = add(emp({ title: "Manager, Support Tier 1", managerId: vpCs.employee_id, dept: "Customer Service", func: "Customer Service", bu: "Corporate", loc: LOCS[6], level: 5 }));
+  for (let i = 0; i < 16; i++) add(emp({ title: "Support Agent", managerId: bigCsMgr.employee_id, managerName: bigCsMgr.employee_name, dept: "Customer Service", func: "Customer Service", bu: "Corporate", loc: LOCS[6], level: 8 }));
+  add(...team({ mgrTitle: "Manager, Support Tier 2", reportTitle: "Senior Support Specialist", managerId: vpCs.employee_id, dept: "Customer Service", func: "Customer Service", bu: "Corporate", loc: LOCS[6], mgrLevel: 5, size: 9 }));
+  add(...team({ mgrTitle: "Manager, Customer Success", reportTitle: "Customer Success Manager", managerId: vpCsm.employee_id, dept: "Customer Success", func: "Customer Service", bu: "Corporate", mgrLevel: 5, size: 7 }));
+  const ghost = emp({ title: "Business Analyst", managerId: "E9999", dept: "Operations", func: "Operations", bu: "EMEA", loc: LOCS[1], level: 6 });
+  all.push(ghost);
+  const zc = emp({ title: "Operations Coordinator", managerId: svpOps.employee_id, dept: "Operations", func: "Operations", bu: "Corporate", level: 7, costOverride: 0 });
+  zc.salary = 0;
+  zc.bonus = 0;
+  all.push(zc);
+  const byId = new Map(all.map((e) => [e.employee_id, e]));
+  for (const e of all) {
+    if (e.manager_id && !e.manager_name) e.manager_name = byId.get(e.manager_id)?.employee_name;
+  }
+  return all;
+}
+
+// src/lib/hris-templates.ts
+var HRIS_TEMPLATES = [
+  {
+    id: "workday",
+    name: "Workday",
+    aliases: {
+      employee_id: ["Employee ID", "Worker ID", "WID"],
+      employee_name: ["Worker", "Legal Name", "Preferred Name"],
+      role_title: ["Business Title", "Job Profile", "Job Title"],
+      manager_id: ["Manager Employee ID", "Worker's Manager ID", "Manager ID"],
+      business_unit: ["Supervisory Organization", "Cost Center Hierarchy"],
+      location: ["Location", "Work Location"],
+      country: ["Location Country", "Country"],
+      grade: ["Compensation Grade", "Pay Grade"],
+      level: ["Job Level", "Management Level"],
+      employment_type: ["Worker Type", "Employee Type", "Time Type"],
+      fte: ["FTE", "FTE %", "Scheduled Weekly Hours FTE"],
+      salary: ["Annual Base Pay", "Base Pay Annualized", "Primary Compensation"],
+      total_cost: ["Total Base Pay Annualized", "Total Compensation"],
+      status: ["Active Status", "Worker Status"]
+    },
+    exportInstructions: [
+      "Create or run a custom report on the Worker business object (typically under Reports/Analytics).",
+      "Include the fields: Employee ID, Worker, Business Title, Worker's Manager ID, Supervisory Organization, Location, Compensation Grade, Worker Type, FTE, Annual Base Pay and Total Base Pay Annualized.",
+      "Filter to active workers (or include terminations if you want leavers in the analysis).",
+      "Export the report output to XLSX or CSV and upload the file here."
+    ],
+    notes: "Workday reports are highly configurable \u2014 column labels follow your tenant's report definition, so review the mapping step carefully."
+  },
+  {
+    id: "successfactors",
+    name: "SAP SuccessFactors",
+    aliases: {
+      employee_id: ["userId", "Person ID External", "User/Employee ID"],
+      employee_name: ["Full Name", "Display Name", "defaultFullName"],
+      role_title: ["Job Title", "jobTitle"],
+      manager_id: ["Manager User Sys ID", "managerId", "Manager ID"],
+      function: ["Job Function"],
+      business_unit: ["Business Unit", "Division"],
+      location: ["Location", "Location Code"],
+      grade: ["Pay Grade", "payGrade"],
+      level: ["Job Level", "jobLevel"],
+      employment_type: ["Employee Class", "employeeClass", "Employment Type"],
+      fte: ["FTE", "Standard Hours FTE"],
+      salary: ["Annual Salary", "annualSalary", "Base Salary"],
+      total_cost: ["Total Target Cash", "Total Compensation"],
+      status: ["Employee Status", "emplStatus"]
+    },
+    exportInstructions: [
+      "Open the reporting area (typically Report Center / Report Story under Analytics).",
+      "Build a live-data report on Employee Profile / Job Information including userId, Manager User Sys ID, Department, Division, Location, Pay Grade and Annual Salary.",
+      "Alternatively, use an ad-hoc report or the Employee Export if your role allows it.",
+      "Run the report and download it as CSV or XLSX, then upload the file here."
+    ]
+  },
+  {
+    id: "bamboohr",
+    name: "BambooHR",
+    aliases: {
+      employee_id: ["Employee #", "employeeNumber", "EEID"],
+      employee_name: ["Full Name", "Display Name"],
+      role_title: ["Job Title", "jobTitle"],
+      manager_id: ["ReportsTo", "Reports To", "Manager ID"],
+      manager_name: ["Manager Name", "Reporting To"],
+      business_unit: ["Division"],
+      location: ["Location", "Work Location"],
+      country: ["Country"],
+      employment_type: ["Employment Status", "FLSA Code"],
+      fte: ["FTE"],
+      salary: ["Pay Rate", "Annual Salary", "payRate"],
+      total_cost: ["Total Annual Compensation"],
+      status: ["Status"],
+      tenure: ["Years of Service"]
+    },
+    exportInstructions: [
+      "Open the reports area (typically Reports in the main navigation).",
+      "Create a custom report (or copy a standard roster report) and add: Employee #, Full Name, Job Title, ReportsTo, Department, Division, Location, Employment Status and Pay Rate.",
+      "Filter to active employees if you only want the current organization.",
+      "Download the report as CSV or Excel and upload the file here."
+    ],
+    notes: "BambooHR's ReportsTo column often contains the manager's name rather than their ID \u2014 map it to manager_id only if your report exports IDs."
+  },
+  {
+    id: "adp",
+    name: "ADP Workforce Now",
+    aliases: {
+      employee_id: ["Associate ID", "Position ID", "File Number"],
+      employee_name: ["Payroll Name", "Legal Name", "Name"],
+      role_title: ["Job Title Description", "Position Description"],
+      manager_id: ["Reports To Associate ID", "Reports To Position ID"],
+      manager_name: ["Reports To Name"],
+      department: ["Home Department Description", "Department Description"],
+      business_unit: ["Business Unit Description", "Business Unit Code"],
+      location: ["Location Description", "Home Work Location"],
+      country: ["Work Country"],
+      grade: ["Pay Grade Code"],
+      employment_type: ["Worker Category Description", "Full Time/Part Time Code"],
+      salary: ["Annual Salary", "Regular Pay Amount"],
+      total_cost: ["Total Annual Compensation", "Annual Benefit Base Rate"],
+      status: ["Position Status Code", "Status Type"]
+    },
+    exportInstructions: [
+      "Open the reporting area (typically Reports & Analytics).",
+      "Run or build a worker-level report including: Associate ID, Payroll Name, Job Title Description, Reports To Associate ID, Home Department Description, Business Unit Description, Location Description and Annual Salary.",
+      "Filter to active associates unless you want terminated workers included.",
+      "Export the output to CSV or Excel and upload the file here."
+    ]
+  },
+  {
+    id: "dayforce",
+    name: "Dayforce",
+    aliases: {
+      employee_id: ["Employee Number", "XRefCode", "Employee XRefCode"],
+      employee_name: ["Display Name", "Employee Name"],
+      role_title: ["Job Assignment", "Job Name", "Position"],
+      manager_id: ["Manager XRefCode", "Manager Employee Number"],
+      department: ["Department", "Org Unit"],
+      business_unit: ["Business Unit"],
+      location: ["Location", "Site"],
+      country: ["Country Code"],
+      grade: ["Pay Grade"],
+      employment_type: ["Pay Class", "Employment Status Type"],
+      fte: ["FTE", "Normal Weekly Hours FTE"],
+      salary: ["Annual Salary", "Base Salary"],
+      total_cost: ["Total Remuneration", "Total Annual Compensation"],
+      status: ["Employment Status", "Status"]
+    },
+    exportInstructions: [
+      "Open the reporting area (typically Reporting / Reports and Analytics).",
+      "Run an employee or position report including: Employee Number (or XRefCode), Display Name, Job Assignment, Manager XRefCode, Department, Location, Pay Class and Annual Salary.",
+      "Filter to active employees as needed.",
+      "Export the report to CSV or Excel and upload the file here."
+    ]
+  },
+  {
+    id: "ukg",
+    name: "UKG Pro",
+    aliases: {
+      employee_id: ["Employee Number", "EmpNo", "Employee ID"],
+      employee_name: ["Employee Name", "Full Name"],
+      role_title: ["Job Description", "Job Title"],
+      manager_id: ["Supervisor Employee Number", "Supervisor ID"],
+      manager_name: ["Supervisor Name", "Supervisor"],
+      department: ["Department", "Org Level 2"],
+      business_unit: ["Org Level 1", "Division"],
+      location: ["Location", "Work Location Description"],
+      grade: ["Salary Grade", "Pay Grade"],
+      employment_type: ["Employee Type", "Full/Part Time"],
+      fte: ["Scheduled FTE", "FTE"],
+      salary: ["Annual Pay", "Annual Salary"],
+      total_cost: ["Total Annual Compensation"],
+      status: ["Employment Status", "Status Code"]
+    },
+    exportInstructions: [
+      "Open the reporting/BI area (typically under Administration > Reporting or People Analytics).",
+      "Run an employee roster report including: Employee Number, Employee Name, Job Description, Supervisor Employee Number, Org Levels, Location, Employee Type and Annual Pay.",
+      "Filter to active employment status if you only want the current organization.",
+      "Export the result to CSV or Excel and upload the file here."
+    ],
+    notes: "UKG Pro org levels are tenant-specific \u2014 confirm which Org Level corresponds to your business units before mapping."
+  },
+  {
+    id: "rippling",
+    name: "Rippling",
+    aliases: {
+      employee_id: ["Employee Id", "Work Email", "Employee Number"],
+      employee_name: ["Full Name", "Preferred Full Name", "Name"],
+      role_title: ["Job Title", "Title"],
+      manager_id: ["Manager Id", "Manager Email", "Manager's Work Email"],
+      manager_name: ["Manager", "Manager Name"],
+      department: ["Department"],
+      business_unit: ["Team", "Division"],
+      location: ["Work Location", "Office"],
+      country: ["Work Country", "Country"],
+      level: ["Level", "Job Level"],
+      employment_type: ["Employment Type", "Worker Type"],
+      salary: ["Annual Salary", "Base Salary", "Compensation Annual Salary"],
+      total_cost: ["Total Compensation"],
+      status: ["Employment Status", "Roster Status"]
+    },
+    exportInstructions: [
+      "Open the reports area (typically Reports in the left navigation).",
+      "Create a report on employee data including: Employee Id, Full Name, Job Title, Manager, Department, Work Location, Employment Type and Annual Salary.",
+      "Filter to active employees as needed.",
+      "Download the report as CSV and upload the file here."
+    ],
+    notes: "If your export identifies people by work email, map both employee_id and manager_id to the email columns \u2014 IDs just need to be consistent."
+  },
+  {
+    id: "hibob",
+    name: "HiBob",
+    aliases: {
+      employee_id: ["Employee ID", "Emp ID"],
+      employee_name: ["Display name", "Full name"],
+      role_title: ["Job title", "Title"],
+      manager_id: ["Manager ID", "Reports to ID"],
+      manager_name: ["Reports to", "Manager"],
+      business_unit: ["Division"],
+      location: ["Site", "Work site"],
+      country: ["Site country", "Country"],
+      level: ["Level", "Job level"],
+      employment_type: ["Employment type", "Employee type"],
+      fte: ["FTE", "Working pattern FTE"],
+      salary: ["Base salary", "Annual salary"],
+      total_cost: ["Total compensation"],
+      status: ["Lifecycle status", "Employment status"]
+    },
+    exportInstructions: [
+      "Open the analytics/reports area (typically Analytics > Reports).",
+      "Create a people report including: Employee ID, Display name, Job title, Reports to ID, Department, Site, Employment type and Base salary.",
+      "Filter the lifecycle status to Employed if you only want current staff.",
+      "Export the report to CSV or Excel and upload the file here."
+    ]
+  },
+  {
+    id: "personio",
+    name: "Personio",
+    aliases: {
+      employee_id: ["Employee ID", "ID"],
+      employee_name: ["Full name", "Name"],
+      role_title: ["Position", "Job title"],
+      manager_id: ["Supervisor ID", "Manager ID"],
+      manager_name: ["Supervisor", "Manager"],
+      business_unit: ["Subcompany", "Division"],
+      location: ["Office", "Location"],
+      country: ["Office country", "Country"],
+      employment_type: ["Employment type"],
+      contract_type: ["Contract type"],
+      fte: ["FTE", "Weekly hours FTE"],
+      salary: ["Fix salary", "Annual fixed salary"],
+      bonus: ["Variable salary", "Bonus"],
+      total_cost: ["Total compensation", "Total salary"]
+    },
+    exportInstructions: [
+      "Open the employee list (typically under People) or the reports area.",
+      "Choose the columns to include: Employee ID, Full name, Position, Supervisor ID, Department, Subcompany, Office, Employment type and Fix salary.",
+      "Filter to active employees as needed.",
+      "Use the export action to download CSV or Excel, then upload the file here."
+    ],
+    notes: "Personio often exports first and last name as separate columns \u2014 add a combined full-name column in the export or in your spreadsheet before uploading."
+  },
+  {
+    id: "gusto",
+    name: "Gusto",
+    aliases: {
+      employee_id: ["Employee ID", "Employee UUID"],
+      employee_name: ["Employee name", "Full name"],
+      role_title: ["Job title", "Title"],
+      manager_id: ["Manager", "Manager ID"],
+      manager_name: ["Manager name"],
+      department: ["Department"],
+      location: ["Work address", "Work location"],
+      country: ["Country"],
+      employment_type: ["Employment type", "Employee type"],
+      salary: ["Compensation rate", "Annual salary"],
+      total_cost: ["Total compensation"],
+      status: ["Employment status", "Status"]
+    },
+    exportInstructions: [
+      "Open the reports area (typically Reports in the main navigation).",
+      "Create a custom employee report including: Employee ID, Employee name, Job title, Manager, Department, Work address, Employment type and Compensation rate.",
+      "Filter to active employees if you only want the current organization.",
+      "Download the report as CSV and upload the file here."
+    ],
+    notes: "Gusto's Manager column usually contains a name, not an ID \u2014 if so, ensure manager names exactly match employee names, or add a manager-ID column before uploading."
+  }
+];
+function getHrisTemplate(id) {
+  return HRIS_TEMPLATES.find((t) => t.id === id);
+}
+
+export { COMPACT_NODE, DEFAULT_ASSUMPTIONS, DEFAULT_TITLE_NOISE_WORDS, FULL_NODE, HRIS_TEMPLATES, MONTH_NAMES, OPTIONAL_FIELDS, REQUIRED_FIELDS, applyChanges, autoMapColumns, buildOrgTree, classifyAiAugmentation, classifySpan, computeChangeRisk, computeMetrics, computeOrgHealth, computeTransitionCost, deepestChains, diffEmployees, elbowPath, evaluateScenario, findDuplicateRoles, fitToBounds, generateDemoData, generateInsights, generateInsightsFromEmployees, getHrisTemplate, layoutOrg, normalizePositionStatus, normalizeTitle, positionStatus, rankInsights, rowsToEmployees, scoreScenario, spanBandForLevel, subtreeIds, suggestConsolidations, validateEmployees, visibleNodes, wouldCreateCycle, year1CapturePct, zoomAround };
+//# sourceMappingURL=core.mjs.map
+//# sourceMappingURL=core.mjs.map