{"version":3,"file":"derive_distinct_labels.cjs","names":["derivePostfixes","throwError","readAnnotation","Annotation","parseJson","isNil","isFunction"],"sources":["../../src/labels/derive_distinct_labels.ts"],"sourcesContent":["import {\n  Annotation,\n  parseJson,\n  readAnnotation,\n  type AxisQualification,\n  type MatchQualifications,\n  type PColumnSpec,\n  type PObjectId,\n  type PObjectSpec,\n  type StringifiedJson,\n  type Trace,\n} from \"@milaboratories/pl-model-common\";\nimport { throwError } from \"@milaboratories/helpers\";\nimport { isFunction, isNil } from \"es-toolkit\";\nimport { derivePostfixes, type LinkerFormatter } from \"./linked_column_postfix\";\n\nexport type { Trace, TraceEntry } from \"@milaboratories/pl-model-common\";\n\nconst DISTANCE_PENALTY = 0.001;\nconst LABEL_TYPE = \"__LABEL__\";\nconst LABEL_TYPE_FULL = \"__LABEL__@1\";\nconst HIT_QUAL_TYPE = \"__HIT_QUAL__\";\nconst ANCHOR_QUAL_TYPE_PREFIX = \"__ANCHOR_QUAL__:\";\n\nfunction isAnchorQualType(t: string): boolean {\n  return t.startsWith(ANCHOR_QUAL_TYPE_PREFIX);\n}\n\nfunction isSyntheticType(t: string): boolean {\n  return t === HIT_QUAL_TYPE || isAnchorQualType(t);\n}\n\n/** SDK-internal trace shape — adds fields used by this algorithm only, not part of the on-disk contract. */\ntype ExtendedTraceEntry = Trace[number] & {\n  importance?: number;\n  position?: \"prefix\" | \"suffix\";\n};\n\nexport type LinkerStep = {\n  /** Linker column spec — its `axesSpec` yields the source axis (root); its `LinkLabel`/`Label` names it. */\n  spec: PColumnSpec;\n  /** Axis qualifications applied on this hop. Not yet consumed by the postfix (deferred). */\n  qualifications?: AxisQualification[];\n};\n\nexport type Entry =\n  | PObjectSpec\n  | {\n      spec: PObjectSpec;\n      /** Extra trace entries merged with the base trace from annotations. */\n      extraTrace?: ExtendedTraceEntry[];\n      /** Linker steps (`[0]` source-most) traversed to reach this column; rendered as a \"via …\"\n       *  postfix only when needed for uniqueness — see {@link derivePostfixes}. */\n      linkerPath?: LinkerStep[];\n      /** Axis qualifications applied to the hit column / already-bound anchors; rendered as \"[…]\" suffixes. */\n      qualifications?: MatchQualifications;\n      /** Something the UI shows beside the label, like a link icon. Columns with different markers\n       *  need no \"via\" postfix to tell them apart. */\n      marker?: string;\n    };\n\n/**\n * Per-zone formatters. Each one receives raw inputs and returns the rendered text for that zone,\n * or `undefined` to suppress the zone entirely (no synthetic injection → no minimization, no render).\n */\nexport type DeriveLabelsFormatters = {\n  /** Native column label. Default: identity. `undefined` → label entry not added (treated as if spec had no label). */\n  native?: (label: string, spec: PObjectSpec, index: number) => string | undefined;\n  /** Linker/source postfix zone (phase 2). Receives the distinguishing tokens (`{ root, linkers }`)\n   *  and returns the \"via …\" text, or `undefined` to suppress. */\n  linker?: LinkerFormatter;\n  /** Hit-axis qualifications block. Default: `[${formatQualifications(qs)}]`. */\n  hitQualification?: (\n    qualifications: AxisQualification[],\n    spec: PObjectSpec,\n    index: number,\n  ) => string | undefined;\n  /** Per-anchor qualifications block. Default: `[${anchorId}: ${formatQualifications(qs)}]`. */\n  anchorQualification?: (\n    anchorId: PObjectId,\n    qualifications: AxisQualification[],\n    spec: PObjectSpec,\n    index: number,\n  ) => string | undefined;\n};\n\nexport type DeriveLabelsOptions = {\n  /** Separator to use between label parts (\" / \" by default). */\n  separator?: string;\n  /** If true, native label is appended at the end of the trace zone. By default it is prepended (label is the most important name). */\n  addLabelAsSuffix?: boolean;\n  /** Force inclusion of native column label even when not needed for uniqueness. */\n  includeNativeLabel?: boolean;\n  /** Trace types that must be included in the label. */\n  forceTraceElements?: string[];\n  /** Per-zone custom formatters. Returning `undefined` from any formatter suppresses the corresponding zone. */\n  formatters?: DeriveLabelsFormatters;\n};\n\n/**\n * Distinct labels for a set of columns. Two phases:\n *  1. {@link deriveStems} — treats each column as a single entity (native label + trace + hit/anchor\n *     qualifications) and produces the minimal distinguishing \"stem\".\n *  2. {@link derivePostfixes} — for columns still colliding on their stem, appends a \"via …\" postfix\n *     describing the difference between their linker sources (root axis, then linker chain).\n */\nexport function deriveDistinctLabels(values: Entry[], options: DeriveLabelsOptions = {}): string[] {\n  const stems = deriveStems(values, options);\n  return derivePostfixes(\n    values.map((v, i) => {\n      const { spec, linkerPath, marker } = extractEntryParts(v);\n      return {\n        stem: stems[i],\n        marker,\n        // Hit columns are PColumns; the postfix reads their axesSpec to orient linkers.\n        hit: spec as PColumnSpec,\n        linkers: (linkerPath ?? []).map((s) => s.spec),\n      };\n    }),\n    options.formatters?.linker,\n  );\n}\n\n/** Phase 1: minimal per-column stem — native label + trace + hit/anchor qualifications, no linkers. */\nfunction deriveStems(values: Entry[], options: DeriveLabelsOptions): string[] {\n  const forceTraceElements =\n    options.forceTraceElements !== undefined && options.forceTraceElements.length > 0\n      ? new Set(options.forceTraceElements)\n      : undefined;\n  const separator = options.separator ?? \" / \";\n\n  const records = values.map((v, i) => enrichRecord(v, i, options));\n  const stats = collectTypeStats(records);\n\n  const hasAnySynthetic = records.some((r) => r.fullTrace.some((ft) => isSyntheticType(ft.type)));\n  const labelForced =\n    (options.includeNativeLabel === true || hasAnySynthetic) &&\n    stats.countByType.has(LABEL_TYPE_FULL);\n\n  const forcedSet = new Set<string>();\n  if (labelForced) forcedSet.add(LABEL_TYPE_FULL);\n\n  const { mainTypes, secondaryTypes } = classifyTypes(stats, values.length);\n\n  const build = (typeSet: Set<string>, force: boolean) =>\n    buildLabels(records, typeSet, forceTraceElements, separator, force);\n  const finalize = (minimized: Set<string>, rendered: string[]) =>\n    repairBareLabels(rendered, minimized, records, stats, forceTraceElements, separator);\n\n  if (mainTypes.length === 0) {\n    if (secondaryTypes.length !== 0)\n      throw new Error(\"Non-empty secondary types list while main types list is empty.\");\n\n    return (\n      build(new Set([LABEL_TYPE_FULL]), true) ??\n      throwError(\"Failed to derive labels using native column labels\")\n    );\n  }\n\n  let includedCount = 0;\n  let additionalType = -1;\n  while (includedCount < mainTypes.length) {\n    const currentSet = new Set<string>(forcedSet);\n    for (let i = 0; i < includedCount; ++i) currentSet.add(mainTypes[i]);\n    if (additionalType >= 0) currentSet.add(mainTypes[additionalType]);\n\n    const candidateResult = build(currentSet, false);\n    if (candidateResult !== undefined && countUniqueLabels(candidateResult) === values.length) {\n      const minimized = minimizeTypeSet(\n        currentSet,\n        records,\n        stats,\n        forceTraceElements,\n        forcedSet,\n        separator,\n      );\n      return finalize(\n        minimized,\n        build(minimized, false) ?? throwError(\"Failed to derive unique labels\"),\n      );\n    }\n\n    additionalType++;\n    if (additionalType >= mainTypes.length) {\n      includedCount++;\n      additionalType = includedCount;\n    }\n  }\n\n  const fallbackSet = new Set([...forcedSet, ...mainTypes, ...secondaryTypes]);\n  const minimized = minimizeTypeSet(\n    fallbackSet,\n    records,\n    stats,\n    forceTraceElements,\n    forcedSet,\n    separator,\n  );\n  return finalize(\n    minimized,\n    build(minimized, true) ?? throwError(\"Failed to derive unique labels\"),\n  );\n}\n\n// --- Pure helpers ---\ntype FullTraceEntry = ExtendedTraceEntry & { fullType: string; occurrenceIndex: number };\n\ntype EnrichedRecord = {\n  fullTrace: FullTraceEntry[];\n};\n\nfunction extractEntryParts(entry: Entry): {\n  spec: PObjectSpec;\n  extraTrace: ExtendedTraceEntry[] | undefined;\n  linkerPath: LinkerStep[] | undefined;\n  qualifications: MatchQualifications | undefined;\n  marker: string | undefined;\n} {\n  const isEnriched = \"spec\" in entry && typeof entry.spec === \"object\";\n  if (!isEnriched) {\n    return {\n      spec: entry as PObjectSpec,\n      extraTrace: undefined,\n      linkerPath: undefined,\n      qualifications: undefined,\n      marker: undefined,\n    };\n  }\n  return {\n    spec: entry.spec,\n    extraTrace: entry.extraTrace,\n    linkerPath: entry.linkerPath,\n    qualifications: entry.qualifications,\n    marker: entry.marker,\n  };\n}\n\nfunction formatQualification(q: AxisQualification): string {\n  const ctx = q.contextDomain ?? {};\n  const keys = Object.keys(ctx);\n  if (keys.length === 0) return q.axis.name;\n  const pairs = keys.map((k) => `${k}=${ctx[k]}`).join(\", \");\n  return Object.prototype.hasOwnProperty.call(ctx, q.axis.name) ? pairs : `${q.axis.name} ${pairs}`;\n}\n\nfunction formatQualifications(qs: AxisQualification[]): string {\n  return qs.map(formatQualification).join(\"; \");\n}\n\nfunction buildFullTrace(trace: ExtendedTraceEntry[]): FullTraceEntry[] {\n  const result: FullTraceEntry[] = [];\n  const occurrences = new Map<string, number>();\n\n  for (let i = trace.length - 1; i >= 0; --i) {\n    const entry = trace[i];\n    const occurrenceIndex = (occurrences.get(entry.type) ?? 0) + 1;\n    occurrences.set(entry.type, occurrenceIndex);\n    result.push({\n      ...entry,\n      fullType: `${entry.type}@${occurrenceIndex}`,\n      occurrenceIndex,\n    });\n  }\n\n  result.reverse();\n  return result;\n}\n\nfunction enrichRecord(value: Entry, index: number, options: DeriveLabelsOptions): EnrichedRecord {\n  const { spec, extraTrace, qualifications } = extractEntryParts(value);\n  const formatters = options.formatters;\n\n  const rawLabel = readAnnotation(spec, Annotation.Label);\n  const traceStr = readAnnotation(spec, Annotation.Trace);\n  const baseTrace = traceStr\n    ? (parseJson(traceStr as StringifiedJson<ExtendedTraceEntry[]>) ?? [])\n    : [];\n  const prefixExtra = extraTrace?.filter((e) => e.position === \"prefix\") ?? [];\n  const suffixExtra = extraTrace?.filter((e) => e.position !== \"prefix\") ?? [];\n  const trace: ExtendedTraceEntry[] = [...prefixExtra, ...baseTrace, ...suffixExtra];\n\n  if (!isNil(rawLabel)) {\n    const label = isFunction(formatters?.native)\n      ? formatters.native(rawLabel, spec, index)\n      : rawLabel;\n    if (!isNil(label)) {\n      const labelEntry = { label, type: LABEL_TYPE, importance: -2 };\n      if (options.addLabelAsSuffix === true) trace.push(labelEntry);\n      else trace.splice(0, 0, labelEntry);\n    }\n  }\n\n  if (qualifications !== undefined && qualifications.forQueries !== undefined) {\n    for (const [anchorId, qs] of Object.entries(qualifications.forQueries)) {\n      if (qs.length === 0) continue;\n      const anchorText = isFunction(formatters?.anchorQualification)\n        ? formatters.anchorQualification(anchorId as PObjectId, qs, spec, index)\n        : `[${anchorId}: ${formatQualifications(qs)}]`;\n      if (isNil(anchorText)) continue;\n      trace.push({\n        type: `${ANCHOR_QUAL_TYPE_PREFIX}${anchorId}`,\n        label: anchorText,\n        importance: -11,\n      });\n    }\n    if (qualifications.forHit !== undefined && qualifications.forHit.length > 0) {\n      const hitText = isFunction(formatters?.hitQualification)\n        ? formatters.hitQualification(qualifications.forHit, spec, index)\n        : `[${formatQualifications(qualifications.forHit)}]`;\n      if (!isNil(hitText)) {\n        trace.push({ type: HIT_QUAL_TYPE, label: hitText, importance: -12 });\n      }\n    }\n  }\n\n  return { fullTrace: buildFullTrace(trace) };\n}\n\ntype TypeStats = {\n  importances: Map<string, number>;\n  countByType: Map<string, number>;\n};\n\nfunction collectTypeStats(records: EnrichedRecord[]): TypeStats {\n  const importances = new Map<string, number>();\n  const countByType = new Map<string, number>();\n\n  for (const record of records) {\n    for (let i = 0; i < record.fullTrace.length; i++) {\n      const { fullType, importance: rawImportance } = record.fullTrace[i];\n      const importance = rawImportance ?? 0;\n      const distance = (record.fullTrace.length - i) * DISTANCE_PENALTY;\n\n      countByType.set(fullType, (countByType.get(fullType) ?? 0) + 1);\n      importances.set(\n        fullType,\n        Math.max(importances.get(fullType) ?? Number.NEGATIVE_INFINITY, importance - distance),\n      );\n    }\n  }\n\n  return { importances, countByType };\n}\n\nfunction classifyTypes(\n  stats: TypeStats,\n  totalRecords: number,\n): { mainTypes: string[]; secondaryTypes: string[] } {\n  const sorted = [...stats.importances].sort(([, i1], [, i2]) => i2 - i1);\n\n  const mainTypes: string[] = [];\n  const secondaryTypes: string[] = [];\n\n  for (const [typeName] of sorted) {\n    if (typeName.endsWith(\"@1\") || stats.countByType.get(typeName) === totalRecords)\n      mainTypes.push(typeName);\n    else secondaryTypes.push(typeName);\n  }\n\n  return { mainTypes, secondaryTypes };\n}\n\nfunction renderRecordLabel(\n  record: EnrichedRecord,\n  includedTypes: Set<string>,\n  forceTraceElements: Set<string> | undefined,\n  separator: string,\n): string | undefined {\n  const traceParts: string[] = [];\n  const anchorParts: string[] = [];\n  let hitLabel: string | undefined;\n\n  for (const ft of record.fullTrace) {\n    if (!(includedTypes.has(ft.fullType) || forceTraceElements?.has(ft.type))) continue;\n    if (ft.type === HIT_QUAL_TYPE) hitLabel = ft.label;\n    else if (isAnchorQualType(ft.type)) anchorParts.push(ft.label);\n    else traceParts.push(ft.label);\n  }\n\n  const isEmpty = traceParts.length === 0 && anchorParts.length === 0 && hitLabel === undefined;\n\n  if (isEmpty) return undefined;\n\n  let label = traceParts.join(separator);\n  const append = (part: string) => {\n    label = label.length === 0 ? part : `${label} ${part}`;\n  };\n  for (const a of anchorParts) append(a);\n  if (hitLabel !== undefined) append(hitLabel);\n\n  return label;\n}\n\nfunction buildLabels(\n  records: EnrichedRecord[],\n  includedTypes: Set<string>,\n  forceTraceElements: Set<string> | undefined,\n  separator: string,\n  force: boolean,\n): string[] | undefined {\n  const result: string[] = [];\n\n  for (const r of records) {\n    const rendered = renderRecordLabel(r, includedTypes, forceTraceElements, separator);\n    if (rendered === undefined) {\n      if (!force) return undefined;\n      result.push(\"Unlabeled\");\n      continue;\n    }\n    result.push(rendered);\n  }\n\n  return result;\n}\n\nfunction countUniqueLabels(result: string[] | undefined): number {\n  if (result === undefined) return 0;\n  return new Set(result).size;\n}\n\nfunction minimizeTypeSet(\n  typeSet: Set<string>,\n  records: EnrichedRecord[],\n  stats: TypeStats,\n  forceTraceElements: Set<string> | undefined,\n  forcedSet: Set<string>,\n  separator: string,\n): Set<string> {\n  const initialResult = buildLabels(records, typeSet, forceTraceElements, separator, false);\n  if (initialResult === undefined) return typeSet;\n\n  const targetCardinality = countUniqueLabels(initialResult);\n  const result = new Set(typeSet);\n\n  const removable = [...result]\n    .filter((t) => !forceTraceElements?.has(t.split(\"@\")[0]) && !forcedSet.has(t))\n    .sort((a, b) => (stats.importances.get(a) ?? 0) - (stats.importances.get(b) ?? 0));\n\n  for (const typeToRemove of removable) {\n    const candidate = new Set(result);\n    candidate.delete(typeToRemove);\n    const candidateResult = buildLabels(records, candidate, forceTraceElements, separator, false);\n    if (candidateResult !== undefined && countUniqueLabels(candidateResult) >= targetCardinality) {\n      result.delete(typeToRemove);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Repairs labels told apart only by what they lack: in a group with the same shown base, a\n * member is bare when its shown parts are a strict subset of a peer's. The group is re-labelled\n * from parts all members carry, or bare members add a hidden part (group-wide when labels stay\n * unique), whichever keeps the more important distinction; labels stay unique across the list.\n */\nfunction repairBareLabels(\n  labels: string[],\n  minimized: Set<string>,\n  records: EnrichedRecord[],\n  stats: TypeStats,\n  forceTraceElements: Set<string> | undefined,\n  separator: string,\n): string[] {\n  const traces = records.map((r) => new Map(r.fullTrace.map((ft) => [ft.fullType, ft.label])));\n  const isQualification = (t: string) => isSyntheticType(t.split(\"@\")[0]);\n  // Trace steps from the end of each column's trace, used to match parts of the same kind; the\n  // native label and qualification tags are not steps, so they don't shift the count.\n  const depths = records.map((r) => {\n    const steps = r.fullTrace.filter(\n      (ft) => ft.fullType !== LABEL_TYPE_FULL && !isQualification(ft.fullType),\n    );\n    return new Map(steps.map((ft, idx) => [ft.fullType, steps.length - idx]));\n  });\n  const isForced = (t: string) => forceTraceElements?.has(t.split(\"@\")[0]) === true;\n  const isDistinctionType = (t: string) => t !== LABEL_TYPE_FULL && !isQualification(t);\n  const importance = (t: string) => stats.importances.get(t) ?? 0;\n  const byImportance = (a: string, b: string) => importance(b) - importance(a);\n  const render = (i: number, types: Set<string>) =>\n    renderRecordLabel(records[i], types, forceTraceElements, separator);\n  const partKey = (t: string, l: string | undefined) => `${t}\\u0000${l}`;\n\n  const labelShown = minimized.has(LABEL_TYPE_FULL);\n  const baseTypes = new Set<string>(labelShown ? [LABEL_TYPE_FULL] : []);\n  const qualTypes = [...minimized].filter(isQualification);\n\n  // Group by the shown base; columns without one share a group and only get the bare fix.\n  const groups = new Map<string, number[]>();\n  records.forEach((_, i) => {\n    const key = render(i, baseTypes) ?? \"\";\n    const group = groups.get(key);\n    if (group) group.push(i);\n    else groups.set(key, [i]);\n  });\n\n  const patched = [...labels];\n  const counts = new Map<string, number>();\n  const addCount = (l: string, d: number) => counts.set(l, (counts.get(l) ?? 0) + d);\n  for (const l of patched) addCount(l, 1);\n\n  // Applies new labels to some columns unless one clashes with a label elsewhere.\n  const tryApply = (members: number[], next: string[]): boolean => {\n    if (new Set(next).size !== members.length) return false;\n    for (const i of members) addCount(patched[i], -1);\n    const clashes = next.some((l) => (counts.get(l) ?? 0) > 0);\n    members.forEach((i, k) => {\n      if (!clashes) patched[i] = next[k];\n      addCount(patched[i], 1);\n    });\n    return !clashes;\n  };\n\n  for (const [key, group] of groups) {\n    if (group.length < 2) continue;\n    const shown = group.map((i) =>\n      [...traces[i]].filter(([t]) => t !== LABEL_TYPE_FULL && (minimized.has(t) || isForced(t))),\n    );\n    const partKeys = shown.map((parts) => parts.map(([t, l]) => partKey(t, l)));\n    // Members showing the same parts are compared once, as one part set; identical columns\n    // then cost nothing. sigOf maps each member to its set, setMembers lists a set's members.\n    const sigIndex = new Map<string, number>();\n    const setKeys: string[][] = [];\n    const setMembers: number[][] = [];\n    const sigOf = partKeys.map((keys, k) => {\n      const sig = [...keys].sort().join(\"\\u0001\");\n      let s = sigIndex.get(sig);\n      if (s === undefined) {\n        s = setKeys.length;\n        sigIndex.set(sig, s);\n        setKeys.push(keys);\n        setMembers.push([]);\n      }\n      setMembers[s].push(k);\n      return s;\n    });\n    const setSets = setKeys.map((keys) => new Set(keys));\n    const postings = new Map<string, number[]>();\n    setKeys.forEach((keys, s) =>\n      keys.forEach((p) => {\n        const list = postings.get(p);\n        if (list) list.push(s);\n        else postings.set(p, [s]);\n      }),\n    );\n    // Superset sets: part sets holding all of a set's parts and more (non-empty means bare).\n    // Candidates come from the posting list of its rarest part.\n    const withParts = setKeys.map((_, s) => s).filter((s) => setKeys[s].length > 0);\n    const supersetSets = setKeys.map((keys, s) => {\n      if (keys.length === 0) return withParts;\n      const rarest = keys.reduce((a, b) =>\n        postings.get(a)!.length <= postings.get(b)!.length ? a : b,\n      );\n      return postings\n        .get(rarest)!\n        .filter(\n          (t) => t !== s && setSets[t].size > keys.length && keys.every((x) => setSets[t].has(x)),\n        );\n    });\n    const bare = group.map((_, k) => supersetSets[sigOf[k]].length > 0);\n    if (!bare.some(Boolean)) continue;\n\n    const typeCount = new Map<string, number>();\n    for (const i of group)\n      for (const t of traces[i].keys()) typeCount.set(t, (typeCount.get(t) ?? 0) + 1);\n    const isUneven = (t: string) => (typeCount.get(t) ?? 0) > 0 && typeCount.get(t)! < group.length;\n    const unevenMax = Math.max(\n      ...[...minimized]\n        .filter((t) => isDistinctionType(t) && !isForced(t) && isUneven(t))\n        .map(importance),\n    );\n\n    // Shared re-labelling, only when the base is a shown label so its text identifies the group.\n    // Parts are chosen without tags, so tags alone never stand in for a shared distinction.\n    let sharedLabels: string[] | undefined;\n    let sharedMax = Number.NEGATIVE_INFINITY;\n    if (labelShown && key !== \"\") {\n      const shared = [...typeCount]\n        .filter(([t, n]) => n === group.length && isDistinctionType(t))\n        .map(([t]) => t)\n        .sort(byImportance);\n      const chosen = new Set(baseTypes);\n      const distinctCount = (types: Set<string>) =>\n        new Set(group.map((i) => render(i, types) ?? \"\")).size;\n      let count = distinctCount(chosen);\n      for (const t of shared) {\n        if (count === group.length) break;\n        const next = distinctCount(new Set([...chosen, t]));\n        if (next > count) {\n          if (chosen.size === baseTypes.size) sharedMax = importance(t);\n          chosen.add(t);\n          count = next;\n        }\n      }\n      const withTags = new Set([...chosen, ...qualTypes]);\n      const rendered = group.map((i) => render(i, withTags));\n      const complete = rendered.filter((l): l is string => l !== undefined);\n      if (\n        count === group.length &&\n        complete.length === group.length &&\n        new Set(complete).size === group.length\n      )\n        sharedLabels = complete;\n    }\n\n    // Bare fix: each bare member picks a hidden part that differs from at least one peer making it\n    // bare, preferring the trace step those peers show extra, then importance.\n    const applyBareFix = (): boolean => {\n      const bareMembers = group.filter((_, k) => bare[k]);\n      const oldBare = new Map<string, number>();\n      for (const i of bareMembers) oldBare.set(patched[i], (oldBare.get(patched[i]) ?? 0) + 1);\n      const isFree = (l: string) => (counts.get(l) ?? 0) - (oldBare.get(l) ?? 0) === 0;\n      const shownTypes = (k: number) => [...baseTypes, ...shown[k].map(([t]) => t), ...qualTypes];\n\n      // Per part set: each type's labels among its members, and how many members carry it, so\n      // \"does some peer differ\" is answered per set without scanning every member.\n      const setLabels = new Map<number, Map<string, { labels: Set<string>; n: number }>>();\n      const labelsIn = (s: number) => {\n        let byType = setLabels.get(s);\n        if (byType) return byType;\n        byType = new Map();\n        for (const m of setMembers[s])\n          for (const [t, l] of traces[group[m]]) {\n            const entry = byType.get(t) ?? { labels: new Set<string>(), n: 0 };\n            entry.labels.add(l);\n            entry.n++;\n            byType.set(t, entry);\n          }\n        setLabels.set(s, byType);\n        return byType;\n      };\n      const someDiffers = (s: number, u: string, mine: string | undefined) => {\n        const entry = labelsIn(s).get(u);\n        if (entry === undefined) return mine !== undefined;\n        if (entry.n < setMembers[s].length) return true;\n        return entry.labels.size > 1 || !entry.labels.has(mine ?? \"\");\n      };\n      const extraDepthsOf = new Map<number, Set<number | undefined>>();\n      const extraDepths = (s: number) => {\n        let depthsSet = extraDepthsOf.get(s);\n        if (depthsSet) return depthsSet;\n        depthsSet = new Set(\n          supersetSets[s].flatMap((t) => {\n            const rep = setMembers[t][0];\n            return shown[rep]\n              .filter(([u, l]) => !isQualification(u) && !setSets[s].has(partKey(u, l)))\n              .map(([u]) => depths[group[rep]].get(u));\n          }),\n        );\n        extraDepthsOf.set(s, depthsSet);\n        return depthsSet;\n      };\n\n      const picks = new Map<number, { type: string; label: string }>();\n      group.forEach((i, k) => {\n        if (!bare[k]) return;\n        const peers = supersetSets[sigOf[k]];\n        const kindDepths = extraDepths(sigOf[k]);\n        const sameKind = (u: string) => (kindDepths.has(depths[i].get(u)) ? 1 : 0);\n        const candidates = [...traces[i].keys()]\n          .filter((u) => !minimized.has(u) && !isForced(u))\n          .filter((u) => peers.some((t) => someDiffers(t, u, traces[i].get(u))))\n          .sort((a, b) => sameKind(b) - sameKind(a) || byImportance(a, b));\n        for (const u of candidates) {\n          const label = render(i, new Set([...shownTypes(k), u]));\n          if (label !== undefined && isFree(label)) {\n            picks.set(i, { type: u, label });\n            break;\n          }\n        }\n      });\n      if (picks.size === 0) return false;\n\n      // Consistent first: every member shows the picked part types it carries. Only within a\n      // shown-label group; without one the group spans unrelated columns.\n      if (labelShown && key !== \"\") {\n        const picked = [...new Set([...picks.values()].map((p) => p.type))];\n        const consistent = group.map((i, k) => render(i, new Set([...shownTypes(k), ...picked])));\n        const full = consistent.filter((l): l is string => l !== undefined);\n        if (full.length === group.length && tryApply(group, full)) return true;\n      }\n\n      // Otherwise only bare members change. They may share a new label only if they shared the old\n      // one, and none may take the old label of a bare member that keeps it; repeat until stable.\n      const proposed = new Map([...picks].map(([i, p]) => [i, p.label]));\n      for (let changed = true; changed;) {\n        changed = false;\n        const firstOld = new Map<string, string>();\n        for (const [i, l] of proposed) {\n          const old = firstOld.get(l);\n          if (old === undefined) firstOld.set(l, patched[i]);\n          else if (old !== patched[i]) changed = proposed.delete(i);\n        }\n        const kept = new Set(bareMembers.filter((i) => !proposed.has(i)).map((i) => patched[i]));\n        for (const [i, l] of proposed) if (kept.has(l)) changed = proposed.delete(i);\n      }\n      for (const i of bareMembers) addCount(patched[i], -1);\n      for (const i of bareMembers) {\n        patched[i] = proposed.get(i) ?? patched[i];\n        addCount(patched[i], 1);\n      }\n      return proposed.size > 0;\n    };\n\n    if (sharedLabels && sharedMax >= unevenMax && tryApply(group, sharedLabels)) continue;\n    if (applyBareFix()) continue;\n    if (sharedLabels && sharedMax < unevenMax) tryApply(group, sharedLabels);\n  }\n\n  return patched;\n}\n"],"mappings":"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"}