Module:GameSkills

Module:GameSkills

Module:GameSkills renders skill data from Data:skills.json into a reusable infobox-style table.

It is intended to be used via a template (for example Template:Skill) so that skills can be embedded on any page without creating individual skill pages.

This module:

• Loads data via Module:GameData → GameData.loadSkills().
• Looks up skills primarily by display "Name" (what editors use), with "Internal Name" as a fallback.
• Builds a table with only the fields that actually exist for that skill.

---

Data source

Skill data comes from Data:skills.json, which is a JSON page with this top-level structure (see Module:GameData/doc for full details):

{
  "version": "SpiritVale-0.8.2",
  "schema_version": 1,
  "generated_at": "2025-12-12T17:24:05.807675+00:00",
  "records": [
    {
      "Name": "Some Skill",
      "Internal Name": "SomeSkillInternalId",
      "...": "other fields specific to skills"
    }
  ]
}

Each record is a single skill. Important keys:

• "Name" – the display name (what players and editors will usually see and use).
• "Internal Name" – the stable ID used internally and available as an optional parameter for power users and tooling.

---

Output

For a given skill, the module renders a table with the CSS class spiritvale-skill-infobox.

Depending on what exists in the JSON record, the table may include:

• Header row with skill name (and icon, if present).
• Icon (from "Icon", as a file name like skill-example.webp).
• Description.
• Type information:
  • Damage Type
  • Element Type
  • Target Type
  • Cast Type
• Max Level.
• Users:
  • Classes
  • Summons
  • Monsters
  • Events
• Requirements:
  • Required Skills (with required level)
  • Required Weapons
  • Required Stances
• Mechanics:
  • Range
  • Cast Time / Cooldown / Duration
  • Mana Cost
• Damage and scaling:
  • Main Damage (base and per-level, where present)
  • Scaling (stat-based contributions)
• Status interactions:
  • Status Applications (status name, scope, basic duration/chance info)

Rows are only shown if the underlying field exists in the JSON for that skill.

---

Public interface

The module exposes a single entry point for templates:

GameSkills.infobox(frame)

This is usually called via #invoke from a template, not directly from pages.

It accepts the following parameters (either passed directly or via a wrapper template):

• 1 – unnamed parameter; treated as the skill "Name".
• name – explicit display "Name" of the skill (equivalent to 1).
• id – "Internal Name" of the skill (optional fallback / power use).

Lookup order:

1. If name or the first unnamed parameter is provided and matches a record’s "Name", that record is used.
2. Otherwise, if id is provided and matches an "Internal Name", that record is used.
3. If nothing is found, a small error message is returned and the page is categorized for tracking.

Example direct usage (not recommended; normally use a template):

No skills found for: GameSkills

or:

No skills found for: GameSkills

---

Template:Skill

The recommended way to use this module is via a small wrapper template, for example:

Template:Skill

 No skills found for: GameSkills

Typical usage on any page:

Bash
Delivers a crushing blow with a chance to stun the target.
Level Select Level 10 / 10 <input type="range" min="1" max="10" value="10" class="sv-level-range" aria-label="Skill level select" /> Damage Melee Element Neutral Target Enemy Cast Target Modifier Attack Damage 325% Scaling 2% Strength Range 0 Area None Cost 12 MP + 0 HP Cast Time 0s Cooldown 0s Duration 0s
Classes	Warrior, Weaver
Monsters	Ashrend, Goblin King
Required Skills	Axe Mastery (Lv.1)
Combo	Type: Ready, Duration: 4s
Special Mechanics	Backslide: 0 Chains: 0 Clone: 0 Hit Limit: 0 Hits: 0 Instances: 0 Knockback: 0 Leech: 0% Leech MP: 0% Max Instances: 0 Mount: 0 Pull: 0 Revive: 0% Spell Copy: 0 Summon: 0 Wall: 0
Flags	Special: Self Centered
Applies	Target – Stun (Duration: 3s, Chance: 30%)

or, explicitly:

Bash
Delivers a crushing blow with a chance to stun the target.
Level Select Level 10 / 10 <input type="range" min="1" max="10" value="10" class="sv-level-range" aria-label="Skill level select" /> Damage Melee Element Neutral Target Enemy Cast Target Modifier Attack Damage 325% Scaling 2% Strength Range 0 Area None Cost 12 MP + 0 HP Cast Time 0s Cooldown 0s Duration 0s
Classes	Warrior, Weaver
Monsters	Ashrend, Goblin King
Required Skills	Axe Mastery (Lv.1)
Combo	Type: Ready, Duration: 4s
Special Mechanics	Backslide: 0 Chains: 0 Clone: 0 Hit Limit: 0 Hits: 0 Instances: 0 Knockback: 0 Leech: 0% Leech MP: 0% Max Instances: 0 Mount: 0 Pull: 0 Revive: 0% Spell Copy: 0 Summon: 0 Wall: 0
Flags	Special: Self Centered
Applies	Target – Stun (Duration: 3s, Chance: 30%)

Internal IDs can still be used when needed:

Unknown Skill: Bash_InternalId

This keeps page wikitext simple while centralizing all JSON loading and formatting logic inside Lua.

---

-- Module:GameSkills
--
-- Renders active skill data (Data:skills.json) into an infobox-style table,
-- and can also list all skills for a given user/class (page name).
--
-- Standard Hero Layout (reused across the wiki):
--   1) hero-title-bar        (icon + name)
--   2) hero-description-bar  (description strip)
--   3) hero-modules row      (4 slots: hero-module-1..4)
--        - Slot 1: module-level-selector
--        - Slot 2: module-skill-type
--        - Slot 3: skill-source-module (Basis + Source + Scaling) OR blank
--        - Slot 4: module-quick-stats (Range/Area/Cost/Cast/Cooldown/Duration)
--
-- Requires Common.js logic that updates:
--   - .sv-dyn spans via data-series
--   - .sv-level-num + data-level on .sv-skill-card
--   - binds to input.sv-level-range inside each card

local GameData = require("Module:GameData")

local p = {}

----------------------------------------------------------------------
-- Data cache
----------------------------------------------------------------------

local skillsCache

local function getSkills()
	if not skillsCache then
		skillsCache = GameData.loadSkills()
	end
	return skillsCache
end

----------------------------------------------------------------------
-- Small utilities
----------------------------------------------------------------------

local function getArgs(frame)
	local parent = frame:getParent()
	return (parent and parent.args) or frame.args
end

local function trim(s)
	if type(s) ~= "string" then
		return nil
	end
	s = mw.text.trim(s)
	return (s ~= "" and s) or nil
end

local function toNum(v)
	if type(v) == "number" then
		return v
	end
	if type(v) == "string" then
		return tonumber(v)
	end
	if type(v) == "table" and v.Value ~= nil then
		return toNum(v.Value)
	end
	return nil
end

local function clamp(n, lo, hi)
	if type(n) ~= "number" then
		return lo
	end
	if n < lo then return lo end
	if n > hi then return hi end
	return n
end

local function fmtNum(n)
	if type(n) ~= "number" then
		return (n ~= nil) and tostring(n) or nil
	end

	if math.abs(n - math.floor(n)) < 1e-9 then
		return tostring(math.floor(n))
	end

	local s = string.format("%.4f", n)
	s = mw.ustring.gsub(s, "0+$", "")
	s = mw.ustring.gsub(s, "%.$", "")
	return s
end

local function listToText(list, sep)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end
	return table.concat(list, sep or ", ")
end

-- Add a labeled infobox row (with optional hooks for future)
local function addRow(tbl, label, value, rowClass, dataKey)
	if value == nil or value == "" then
		return
	end

	local row = tbl:tag("tr")
	row:addClass("sv-row")
	if rowClass then
		row:addClass(rowClass)
	end
	if dataKey then
		row:attr("data-field", dataKey)
	end

	row:tag("th"):wikitext(label):done()
	row:tag("td"):wikitext(value):done()
end

-- Handles either a scalar OR { Value = ..., Unit = ... }
-- IMPORTANT: wikiprep often converts unit-wrapped pairs into strings already.
local function formatUnitValue(v)
	if type(v) == "table" and v.Value ~= nil then
		local unit = v.Unit
		local val  = v.Value

		if unit == "percent_decimal" or unit == "percent_whole" or unit == "percent" then
			return tostring(val) .. "%"
		elseif unit == "seconds" then
			return tostring(val) .. "s"
		elseif unit == "meters" then
			return tostring(val) .. "m"
		elseif unit == "tiles" then
			return tostring(val) .. " tiles"
		elseif unit and unit ~= "" then
			return tostring(val) .. " " .. tostring(unit)
		else
			return tostring(val)
		end
	end

	return (v ~= nil) and tostring(v) or nil
end

----------------------------------------------------------------------
-- Dynamic spans (JS-driven)
----------------------------------------------------------------------

local function dynSpan(series, level)
	if type(series) ~= "table" or #series == 0 then
		return nil
	end

	level = clamp(level or #series, 1, #series)

	local span = mw.html.create("span")
	span:addClass("sv-dyn")
	span:attr("data-series", mw.text.jsonEncode(series))
	span:wikitext(mw.text.nowiki(series[level] or ""))

	return tostring(span)
end

local function isFlatList(list)
	if type(list) ~= "table" or #list == 0 then
		return false
	end
	local first = tostring(list[1])
	for i = 2, #list do
		if tostring(list[i]) ~= first then
			return false
		end
	end
	return true
end

local function isNonZeroScalar(v)
	if v == nil then
		return false
	end
	if type(v) == "number" then
		return v ~= 0
	end
	if type(v) == "string" then
		local n = tonumber(v)
		if n == nil then
			return v ~= ""
		end
		return n ~= 0
	end
	if type(v) == "table" and v.Value ~= nil then
		return isNonZeroScalar(v.Value)
	end
	return true
end

-- Base/Per Level renderer:
-- - Per Level list -> dynamic span (or single value if flat)
-- - Per Level scalar -> "Base" + "Per Level" lines
local function valuePairDynamicLines(name, block, maxLevel, level)
	if type(block) ~= "table" then
		return {}
	end

	local base = block.Base
	local per  = block["Per Level"]

	-- Per Level list (expanded by wikiprep)
	if type(per) == "table" then
		if #per == 0 then
			local baseText = formatUnitValue(base)
			return baseText and { string.format("%s: %s", name, mw.text.nowiki(baseText)) } or {}
		end

		if isFlatList(per) then
			local baseText = formatUnitValue(base)
			local one = formatUnitValue(per[1]) or tostring(per[1])
			local show = baseText or one
			return show and { string.format("%s: %s", name, mw.text.nowiki(show)) } or {}
		end

		local series = {}
		for _, v in ipairs(per) do
			table.insert(series, formatUnitValue(v) or tostring(v))
		end

		local dyn = dynSpan(series, level)
		return dyn and { string.format("%s: %s", name, dyn) } or {}
	end

	-- scalar Per Level
	local lines = {}
	local baseText = formatUnitValue(base)
	local perText  = formatUnitValue(per)

	if baseText then
		table.insert(lines, string.format("%s: %s", name, mw.text.nowiki(baseText)))
	end
	if perText and isNonZeroScalar(per) then
		table.insert(lines, string.format("%s Per Level: %s", name, mw.text.nowiki(perText)))
	end

	return lines
end

local function valuePairDynamicText(name, block, maxLevel, level, sep)
	local lines = valuePairDynamicLines(name, block, maxLevel, level)
	return (#lines > 0) and table.concat(lines, sep or "<br />") or nil
end

local function valuePairRawText(block)
	if type(block) ~= "table" then
		return nil
	end

	local base = block.Base
	local per  = block["Per Level"]

	if type(per) == "table" then
		if #per == 0 then
			return formatUnitValue(base)
		end
		if isFlatList(per) then
			return formatUnitValue(base) or tostring(per[1])
		end

		local vals = {}
		for _, v in ipairs(per) do
			table.insert(vals, formatUnitValue(v) or tostring(v))
		end
		return (#vals > 0) and table.concat(vals, " / ") or nil
	end

	local baseText = formatUnitValue(base)
	local perText  = formatUnitValue(per)

	if baseText and perText and isNonZeroScalar(per) then
		return string.format("%s (Per Level: %s)", baseText, perText)
	end

	return baseText or perText
end

----------------------------------------------------------------------
-- Lookups
----------------------------------------------------------------------

local function getSkillById(id)
	id = trim(id)
	if not id then
		return nil
	end
	local dataset = getSkills()
	return (dataset.byId or {})[id]
end

local function findSkillByName(name)
	name = trim(name)
	if not name then
		return nil
	end

	local dataset = getSkills()
	local byName = dataset.byName or {}

	if byName[name] then
		return byName[name]
	end

	for _, rec in ipairs(dataset.records or {}) do
		if type(rec) == "table" then
			if rec["External Name"] == name or rec.Name == name or rec["Display Name"] == name then
				return rec
			end
		end
	end

	return nil
end

----------------------------------------------------------------------
-- Formatting helpers
----------------------------------------------------------------------

local function basisLabel(entry, isHealing)
	if isHealing then
		return "Healing"
	end

	local atk  = entry and entry["ATK-Based"]
	local matk = entry and entry["MATK-Based"]

	if atk and matk then
		return "Attack/Magic Attack"
	elseif atk then
		return "Attack"
	elseif matk then
		return "Magic Attack"
	end

	return "Damage"
end

local function valuePairDynamicValueOnly(block, maxLevel, level)
	if type(block) ~= "table" then
		return nil
	end

	local base = block.Base
	local per  = block["Per Level"]

	if type(per) == "table" then
		if #per == 0 then
			local baseText = formatUnitValue(base)
			return baseText and mw.text.nowiki(baseText) or nil
		end

		if isFlatList(per) then
			local one  = formatUnitValue(per[1]) or tostring(per[1])
			local show = formatUnitValue(base) or one
			return show and mw.text.nowiki(show) or nil
		end

		local series = {}
		for _, v in ipairs(per) do
			table.insert(series, formatUnitValue(v) or tostring(v))
		end
		return dynSpan(series, level)
	end

	local txt = valuePairRawText(block)
	return txt and mw.text.nowiki(txt) or nil
end

-- Source (new unified Damage/Flat/Reflect/Healing) formatter (for infobox rows)
local function formatSource(src, maxLevel, level)
	if type(src) ~= "table" then
		return nil
	end

	local kind = src.Type or "Damage"
	local isHealing = (kind == "Healing") or (src.Healing == true)

	local basis = basisLabel(src, isHealing)
	if basis and mw.ustring.lower(tostring(basis)) == mw.ustring.lower(tostring(kind)) then
		basis = nil
	end

	local val = valuePairDynamicValueOnly(src, maxLevel, level)
	if not val then
		return nil
	end

	local out = mw.text.nowiki(tostring(kind)) .. ": " .. val
	if basis then
		out = out .. " " .. mw.text.nowiki(tostring(basis))
	end

	return out
end

-- BACKCOMPAT: old damage list formatter (for infobox rows)
local function formatDamageEntry(entry, maxLevel, level)
	if type(entry) ~= "table" then
		return nil
	end

	local isHealing = (entry.Type == "Healing")
	local basis = isHealing and "Healing" or basisLabel(entry, false)

	local baseRaw = entry["Base %"]
	local perRaw  = entry["Per Level %"]

	local baseN = toNum(baseRaw)
	local perN  = toNum(perRaw)

	local function baseIsPresent()
		if baseN ~= nil then
			return baseN ~= 0
		end
		if baseRaw ~= nil then
			local s = tostring(baseRaw)
			return (s ~= "" and s ~= "0" and s ~= "0.0" and s ~= "0.00")
		end
		return false
	end

	local baseText
	if baseIsPresent() then
		baseText = (baseN ~= nil) and (fmtNum(baseN) .. "%") or (tostring(baseRaw) .. "%")
	end

	if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then
		return baseText and mw.text.nowiki(baseText .. " " .. basis) or nil
	end

	local series = {}
	for lv = 1, maxLevel do
		local perPart = perN * lv

		if baseText and baseN ~= nil then
			local total = baseN + perPart
			table.insert(series, string.format("%s%% %s", fmtNum(total), basis))
		elseif baseText then
			table.insert(series, string.format("%s + %s%% %s", baseText, fmtNum(perPart), basis))
		else
			table.insert(series, string.format("%s%% %s", fmtNum(perPart), basis))
		end
	end

	return dynSpan(series, level)
end

local function formatDamageList(list, maxLevel, level, includeTypePrefix)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end

	local parts = {}
	for _, d in ipairs(list) do
		if type(d) == "table" then
			local txt = formatDamageEntry(d, maxLevel, level)
			if txt then
				if includeTypePrefix and d.Type and d.Type ~= "" then
					table.insert(parts, mw.text.nowiki(tostring(d.Type) .. ": ") .. txt)
				else
					table.insert(parts, txt)
				end
			end
		end
	end

	return (#parts > 0) and table.concat(parts, "<br />") or nil
end

-- Scaling supports either a single dict or a list (for infobox rows)
local function formatScaling(scaling, basisOverride)
	if type(scaling) ~= "table" then
		return nil
	end

	local list = scaling
	if #list == 0 then
		if scaling.Percent ~= nil or scaling["Scaling ID"] or scaling["Scaling Name"] then
			list = { scaling }
		else
			return nil
		end
	end

	local parts = {}
	for _, s in ipairs(list) do
		if type(s) == "table" then
			local stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
			local pct  = s.Percent
			local pctN = toNum(pct)

			local basis = basisOverride or basisLabel(s, false)

			if pctN ~= nil and pctN ~= 0 then
				table.insert(parts, string.format("%s%% %s Per %s", fmtNum(pctN), basis, stat))
			elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then
				table.insert(parts, string.format("%s%% %s Per %s", tostring(pct), basis, stat))
			end
		end
	end

	return (#parts > 0) and table.concat(parts, "<br />") or nil
end

local function formatArea(area, maxLevel, level)
	if type(area) ~= "table" then
		return nil
	end

	local parts = {}

	local distLine = valuePairDynamicText("Distance", area["Area Distance"], maxLevel, level, "<br />")
	if distLine then
		table.insert(parts, distLine)
	end

	local size = area["Area Size"]
	if size and size ~= "" then
		table.insert(parts, "Size: " .. mw.text.nowiki(tostring(size)))
	end

	return (#parts > 0) and table.concat(parts, "<br />") or nil
end

local function formatTimingBlock(bt, maxLevel, level)
	if type(bt) ~= "table" then
		return nil
	end

	local parts = {}

	local function add(label, key)
		local block = bt[key]
		if type(block) ~= "table" then
			return
		end
		local lines = valuePairDynamicLines(label, block, maxLevel, level)
		for _, line in ipairs(lines) do
			table.insert(parts, line)
		end
	end

	add("Cast Time", "Cast Time")
	add("Cooldown",  "Cooldown")
	add("Duration",  "Duration")

	if bt["Effect Cast Time"] ~= nil then
		table.insert(parts, "Effect Cast Time: " .. mw.text.nowiki(tostring(bt["Effect Cast Time"])))
	end
	if bt["Damage Delay"] ~= nil then
		table.insert(parts, "Damage Delay: " .. mw.text.nowiki(tostring(bt["Damage Delay"])))
	end
	if bt["Effect Remove Delay"] ~= nil then
		table.insert(parts, "Effect Remove Delay: " .. mw.text.nowiki(tostring(bt["Effect Remove Delay"])))
	end

	return (#parts > 0) and table.concat(parts, "<br />") or nil
end

local function formatResourceCost(rc, maxLevel, level)
	if type(rc) ~= "table" then
		return nil
	end

	local parts = {}

	local manaLines = valuePairDynamicLines("MP", rc["Mana Cost"], maxLevel, level)
	for _, line in ipairs(manaLines) do
		table.insert(parts, line)
	end

	local hpLines = valuePairDynamicLines("HP", rc["Health Cost"], maxLevel, level)
	for _, line in ipairs(hpLines) do
		table.insert(parts, line)
	end

	return (#parts > 0) and table.concat(parts, "<br />") or nil
end

local function formatCombo(combo)
	if type(combo) ~= "table" then
		return nil
	end

	local parts = {}

	if combo.Type then
		table.insert(parts, "Type: " .. mw.text.nowiki(tostring(combo.Type)))
	end

	local durText = formatUnitValue(combo.Duration)
	if durText then
		table.insert(parts, "Duration: " .. mw.text.nowiki(durText))
	end

	if combo.Percent ~= nil then
		local pctText = formatUnitValue(combo.Percent)
		if pctText then
			table.insert(parts, "Bonus: " .. mw.text.nowiki(pctText))
		end
	end

	return (#parts > 0) and table.concat(parts, ", ") or nil
end

local function formatMechanicEffects(effects, maxLevel, level)
	if type(effects) ~= "table" then
		return nil
	end

	local keys = {}
	for k, _ in pairs(effects) do
		table.insert(keys, k)
	end
	table.sort(keys)

	local parts = {}

	local function effectAmount(block)
		if type(block) ~= "table" then
			return nil
		end

		local per = block["Per Level"]
		if type(per) == "table" and #per > 0 then
			if isFlatList(per) then
				return mw.text.nowiki(formatUnitValue(per[1]) or tostring(per[1]))
			end
			local series = {}
			for _, v in ipairs(per) do
				table.insert(series, formatUnitValue(v) or tostring(v))
			end
			return dynSpan(series, level)
		end

		local txt = valuePairRawText(block)
		return txt and mw.text.nowiki(txt) or nil
	end

	for _, name in ipairs(keys) do
		local block = effects[name]
		if type(block) == "table" then
			local t = block.Type

			if t ~= nil and tostring(t) ~= "" then
				local amt = effectAmount(block)
				local seg = mw.text.nowiki(tostring(t) .. " - " .. tostring(name))
				if amt then
					seg = seg .. " + " .. amt
				end
				table.insert(parts, seg)
			else
				local txt = valuePairDynamicText(name, block, maxLevel, level, ", ")
				if txt then
					table.insert(parts, txt)
				end
			end
		end
	end

	return (#parts > 0) and table.concat(parts, "<br />") or nil
end

local function formatModifiers(mods)
	if type(mods) ~= "table" then
		return nil
	end

	local parts = {}

	local function collect(label, sub)
		if type(sub) ~= "table" then
			return
		end

		local flags = {}
		for k, v in pairs(sub) do
			if v then
				table.insert(flags, k)
			end
		end
		table.sort(flags)

		if #flags > 0 then
			table.insert(parts, string.format("%s: %s", label, table.concat(flags, ", ")))
		end
	end

	collect("Movement", mods["Movement Modifiers"])
	collect("Combat",   mods["Combat Modifiers"])
	collect("Special",  mods["Special Modifiers"])

	return (#parts > 0) and table.concat(parts, "<br />") or nil
end

local function formatStatusApplications(list, maxLevel, level)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end

	local parts = {}
	for _, s in ipairs(list) do
		if type(s) == "table" then
			local typ  = s.Type or s.Scope or "Target"
			local name = s["Status External Name"] or s["Status Internal Name"] or "Unknown status"

			local seg = tostring(typ) .. " – " .. tostring(name)
			local detail = {}

			if type(s.Duration) == "table" then
				local t = valuePairDynamicText("Duration", s.Duration, maxLevel, level, "; ")
				if t then table.insert(detail, t) end
			end

			if type(s.Chance) == "table" then
				local t = valuePairDynamicText("Chance", s.Chance, maxLevel, level, "; ")
				if t then table.insert(detail, t) end
			end

			if #detail > 0 then
				seg = seg .. " (" .. table.concat(detail, ", ") .. ")"
			end

			table.insert(parts, seg)
		end
	end

	return (#parts > 0) and table.concat(parts, "<br />") or nil
end

local function formatStatusRemoval(list, maxLevel, level)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end

	local parts = {}
	for _, r in ipairs(list) do
		if type(r) == "table" then
			local names = r["Status External Name"]
			local label

			if type(names) == "table" then
				label = table.concat(names, ", ")
			elseif type(names) == "string" then
				label = names
			else
				label = "Status"
			end

			local amt
			if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
				local series = {}
				for _, v in ipairs(r["Per Level"]) do
					table.insert(series, formatUnitValue(v) or tostring(v))
				end
				amt = dynSpan(series, level)
			else
				amt = valuePairRawText(r)
				amt = amt and mw.text.nowiki(amt) or nil
			end

			local seg = mw.text.nowiki(label)
			if amt then
				seg = seg .. " – " .. amt
			end
			table.insert(parts, seg)
		end
	end

	return (#parts > 0) and table.concat(parts, "<br />") or nil
end

local function formatEvents(list)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end

	local parts = {}
	for _, ev in ipairs(list) do
		if type(ev) == "table" then
			local action = ev.Action or "On event"
			local name   = ev["Skill Internal Name"] or ev["Skill External Name"] or "Unknown skill"
			table.insert(parts, string.format("%s → %s", action, name))
		end
	end

	return (#parts > 0) and table.concat(parts, "<br />") or nil
end

----------------------------------------------------------------------
-- User matching (for auto lists on class pages)
----------------------------------------------------------------------

local function skillMatchesUser(rec, userName)
	if type(rec) ~= "table" or not userName or userName == "" then
		return false
	end

	local users = rec.Users
	if type(users) ~= "table" then
		return false
	end

	local userLower = mw.ustring.lower(userName)

	local function listHas(list)
		if type(list) ~= "table" then
			return false
		end
		for _, v in ipairs(list) do
			if type(v) == "string" and mw.ustring.lower(v) == userLower then
				return true
			end
		end
		return false
	end

	return listHas(users.Classes) or listHas(users.Summons) or listHas(users.Monsters) or listHas(users.Events)
end

----------------------------------------------------------------------
-- Direct page detection (hide Users on the skill's own page)
----------------------------------------------------------------------

local function isDirectSkillPage(rec)
	if type(rec) ~= "table" then
		return false
	end

	local pageTitle = mw.title.getCurrentTitle()
	local pageName  = pageTitle and pageTitle.text or ""
	pageName = trim(pageName)
	if not pageName then
		return false
	end

	pageName = mw.ustring.lower(pageName)

	local ext = trim(rec["External Name"] or rec.Name or rec["Display Name"])
	local internal = trim(rec["Internal Name"] or rec.InternalName or rec.InternalID)

	return (ext and mw.ustring.lower(ext) == pageName) or (internal and mw.ustring.lower(internal) == pageName) or false
end

----------------------------------------------------------------------
-- Hero modules (4-slot scaffold)
----------------------------------------------------------------------

local function moduleBox(slot, extraClasses, innerHtml, isEmpty)
	local box = mw.html.create("div")
	box:addClass("hero-module")
	box:addClass("hero-module-" .. tostring(slot))
	box:attr("data-hero-module", tostring(slot))

	if extraClasses then
		if type(extraClasses) == "string" then
			box:addClass(extraClasses)
		elseif type(extraClasses) == "table" then
			for _, c in ipairs(extraClasses) do
				box:addClass(c)
			end
		end
	end

	if isEmpty then
		box:addClass("hero-module-empty")
	end

	local body = box:tag("div"):addClass("hero-module-body")
	if innerHtml and innerHtml ~= "" then
		body:wikitext(innerHtml)
	end

	return tostring(box)
end

-- Helper: render an intentionally-empty hero module slot (keeps the 2x2 grid stable)
local function buildEmptyModule(slot)
	return moduleBox(slot, nil, "", true)
end

-- ------------------------------------------------------------
-- Module 1 – Level Selector
-- FIX: If maxLevel == 1, do NOT emit a range input (prevents JS edge-cases)
-- ------------------------------------------------------------
local function buildModuleLevelSelector(level, maxLevel)
	local inner = mw.html.create("div")
	inner:addClass("sv-level-ui")

	inner:tag("div")
		:addClass("sv-level-title")
		:wikitext("Level Select")

	inner:tag("div")
		:addClass("sv-level-label")
		:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))

	local slider = inner:tag("div"):addClass("sv-level-slider")

	if tonumber(maxLevel) and tonumber(maxLevel) > 1 then
		slider:tag("input")
			:attr("type", "range")
			:attr("min", "1")
			:attr("max", tostring(maxLevel))
			:attr("value", tostring(level))
			:addClass("sv-level-range")
			:attr("aria-label", "Skill level select")
	else
		-- single-level skills: keep layout but no <input>
		inner:addClass("sv-level-ui-single")
		slider:addClass("sv-level-slider-single")
	end

	return moduleBox(1, "module-level-selector", tostring(inner), false)
end

-- ------------------------------------------------------------
-- Module 2 – Skill Type
-- ------------------------------------------------------------
local function buildModuleSkillType(typeBlock)
	typeBlock = (type(typeBlock) == "table") and typeBlock or {}

	local function valName(x)
		if x == nil then
			return nil
		end
		if type(x) == "table" then
			if x.Name and x.Name ~= "" then return tostring(x.Name) end
			if x.ID and x.ID ~= "" then return tostring(x.ID) end
		end
		if type(x) == "string" and x ~= "" then
			return x
		end
		return nil
	end

	local grid = mw.html.create("div")
	grid:addClass("sv-type-grid")

	local added = false
	local function addChunk(label, rawVal)
		local v = valName(rawVal)
		if not v or v == "" then
			return
		end
		added = true

		local chunk = grid:tag("div"):addClass("sv-type-chunk")
		chunk:tag("div"):addClass("sv-type-label"):wikitext(mw.text.nowiki(label))
		chunk:tag("div"):addClass("sv-type-value"):wikitext(mw.text.nowiki(v))
	end

	addChunk("Damage",  typeBlock.Damage  or typeBlock["Damage Type"])
	addChunk("Element", typeBlock.Element or typeBlock["Element Type"])
	addChunk("Target",  typeBlock.Target  or typeBlock["Target Type"])
	addChunk("Cast",    typeBlock.Cast    or typeBlock["Cast Type"])

	local body = added and tostring(grid) or ""
	return moduleBox(2, "module-skill-type", body, false)
end

-- ============================================================
-- Module 3 – Skill Source (Modifier + Source + Scaling)
-- - Modifier column (optional): "Modifier" pill + Attack/Magic Attack/Hybrid
-- - Source column: Kind pill + big % value
-- - Scaling column: "Scaling" pill + compact lines
--
-- RULE: If BOTH Source and Scaling are missing -> return nil (slot stays blank)
-- - Supports BOTH new (rec.Source) and legacy (rec.Damage) formats.
-- ============================================================

local function formatScalingCompactLines(scaling)
	if type(scaling) ~= "table" then
		return {}
	end

	local list = scaling
	if #list == 0 then
		if scaling.Percent ~= nil or scaling["Scaling ID"] or scaling["Scaling Name"] then
			list = { scaling }
		else
			return {}
		end
	end

	local out = {}
	for _, s in ipairs(list) do
		if type(s) == "table" then
			local stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
			local pct  = s.Percent
			local pctN = toNum(pct)

			if pctN ~= nil and pctN ~= 0 then
				table.insert(out, string.format("%s%% %s", fmtNum(pctN), stat))
			elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then
				table.insert(out, string.format("%s%% %s", tostring(pct), stat))
			end
		end
	end

	return out
end

local function basisWordFromFlags(atkFlag, matkFlag)
	if atkFlag and matkFlag then
		return "Hybrid"
	elseif atkFlag then
		return "Attack"
	elseif matkFlag then
		return "Magic Attack"
	end
	return nil
end

-- Prefer the “current level value” (dynSpan when we have a series list)
local function sourceValueForLevel(src, maxLevel, level)
	if type(src) ~= "table" then
		return nil
	end

	local base = src.Base
	local per  = src["Per Level"]

	-- Preferred: expanded series list (wikiprep)
	if type(per) == "table" and #per > 0 then
		if isFlatList(per) then
			local one  = formatUnitValue(per[1]) or tostring(per[1])
			local show = formatUnitValue(base) or one
			return show and mw.text.nowiki(show) or nil
		end

		local series = {}
		for _, v in ipairs(per) do
			table.insert(series, formatUnitValue(v) or tostring(v))
		end
		return dynSpan(series, level)
	end

	-- Fallback: may show "X (Per Level: Y)" if not expanded
	return valuePairDynamicValueOnly(src, maxLevel, level)
end

-- Legacy (pre-Source) damage entry: compute a simple % at the current level
local function legacyPercentAtLevel(entry, level)
	if type(entry) ~= "table" then
		return nil
	end

	local baseRaw = entry["Base %"]
	local perRaw  = entry["Per Level %"]
	local baseN   = toNum(baseRaw)
	local perN    = toNum(perRaw)

	-- If Per Level exists, level 1 shows at least per*1 even when base is 0/missing.
	if perN ~= nil and perN ~= 0 then
		local total = (baseN or 0) + (perN * level)
		return fmtNum(total) .. "%"
	end

	if baseN ~= nil then
		return fmtNum(baseN) .. "%"
	end
	if baseRaw ~= nil and tostring(baseRaw) ~= "" then
		return tostring(baseRaw) .. "%"
	end

	return nil
end

local function buildModuleSkillSource(rec, level, maxLevel)
	local basisWord = nil
	local sourceKind = nil
	local sourceVal  = nil
	local scaling    = nil

	-- Preferred: new unified Source block
	if type(rec.Source) == "table" then
		local src = rec.Source

		local atkFlag  = (src["ATK-Based"] == true)
		local matkFlag = (src["MATK-Based"] == true)
		basisWord = basisWordFromFlags(atkFlag, matkFlag)

		sourceKind = src.Type or ((src.Healing == true) and "Healing") or "Damage"
		sourceVal  = sourceValueForLevel(src, maxLevel, level)
		scaling    = src.Scaling
	end

	-- Backcompat: legacy Damage block
	if (sourceVal == nil or sourceVal == "") and type(rec.Damage) == "table" then
		local dmg = rec.Damage
		scaling = scaling or dmg.Scaling

		local main = dmg["Main Damage"]
		local refl = dmg["Reflect Damage"]
		local flat = dmg["Flat Damage"]

		-- priority: Main Damage > Reflect > Flat
		if type(main) == "table" and #main > 0 then
			local pick = nil
			for _, d in ipairs(main) do
				if type(d) == "table" and d.Type ~= "Healing" then
					pick = d
					break
				end
			end
			pick = pick or main[1]

			if type(pick) == "table" then
				local atkFlag  = (pick["ATK-Based"] == true)
				local matkFlag = (pick["MATK-Based"] == true)
				basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)

				sourceKind = (pick.Type == "Healing") and "Healing" or "Damage"
				sourceVal  = legacyPercentAtLevel(pick, level)
			end
		elseif type(refl) == "table" and #refl > 0 and type(refl[1]) == "table" then
			local pick = refl[1]
			local atkFlag  = (pick["ATK-Based"] == true)
			local matkFlag = (pick["MATK-Based"] == true)
			basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)

			sourceKind = "Reflect"
			sourceVal  = legacyPercentAtLevel(pick, level)
		elseif type(flat) == "table" and #flat > 0 and type(flat[1]) == "table" then
			local pick = flat[1]
			local atkFlag  = (pick["ATK-Based"] == true)
			local matkFlag = (pick["MATK-Based"] == true)
			basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)

			sourceKind = "Flat"
			sourceVal  = legacyPercentAtLevel(pick, level)
		end
	end

	local scalingLines = formatScalingCompactLines(scaling)
	local hasSource    = (sourceVal ~= nil and tostring(sourceVal) ~= "")
	local hasScaling   = (type(scalingLines) == "table" and #scalingLines > 0)

	-- RULE: if neither exists, leave module 3 blank
	if (not hasSource) and (not hasScaling) then
		return nil
	end

	local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "")

	-- Classes drive grid layout in CSS
	local extra = { "skill-source-module" }
	table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod")

	if hasSource and (not hasScaling) then
		table.insert(extra, "sv-only-source")
	elseif hasScaling and (not hasSource) then
		table.insert(extra, "sv-only-scaling")
	end

	local wrap = mw.html.create("div")
	wrap:addClass("sv-source-grid")

	-- Column 1: Modifier (optional)
	if hasMod then
		local modCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-modifier")
		modCol:tag("div")
			:addClass("sv-source-pill")
			:wikitext("Modifier")
		modCol:tag("div")
			:addClass("sv-modifier-value")
			:wikitext(mw.text.nowiki(basisWord))
	end

	-- Column 2: Source (optional)
	if hasSource then
		local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main")
		sourceCol:tag("div")
			:addClass("sv-source-pill")
			:wikitext(mw.text.nowiki(sourceKind or "Source"))
		sourceCol:tag("div")
			:addClass("sv-source-value")
			:wikitext(sourceVal)
	end

	-- Column 3: Scaling (optional)
	if hasScaling then
		local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling")
		scalingCol:tag("div")
			:addClass("sv-source-pill")
			:wikitext("Scaling")

		local list = scalingCol:tag("div"):addClass("sv-scaling-list")
		for _, line in ipairs(scalingLines) do
			list:tag("div")
				:addClass("sv-scaling-item")
				:wikitext(mw.text.nowiki(line))
		end
	end

	return moduleBox(3, extra, tostring(wrap), false)
end

-- ------------------------------------------------------------
-- Module 4 – Quick Stats (3x2 grid)
-- Range / Area / Cost / Cast Time / Cooldown / Duration
-- (Shows em dash — when missing)
-- ------------------------------------------------------------
local function buildModuleQuickStats(rec, level, maxLevel)
	local mech = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
	local bt   = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
	local rc   = (type(mech["Resource Cost"]) == "table") and mech["Resource Cost"] or {}

	local function dash()
		return "—"
	end

	-- Accept either a value-pair block (Base/Per Level) OR a unit-wrapped scalar OR a plain scalar.
	local function renderAny(v)
		if type(v) == "table" and (v.Base ~= nil or v["Per Level"] ~= nil) then
			return valuePairDynamicValueOnly(v, maxLevel, level)
		end
		local t = formatUnitValue(v)
		return t and mw.text.nowiki(t) or nil
	end

	local function renderAreaSize(area)
		if type(area) ~= "table" then
			return nil
		end
		local size = area["Area Size"]
		if size == nil then
			return nil
		end
		if type(size) == "table" then
			size = size.Name or size.ID or size.Value or size[1] or size
		end
		local s = tostring(size or "")
		s = mw.text.trim(s)
		if s == "" then
			return nil
		end
		-- Expecting "Medium (4)"-style strings from wikiprep/dictionary formatting.
		return mw.text.nowiki(s)
	end

	local function renderCost()
		local mp = valuePairDynamicValueOnly(rc["Mana Cost"], maxLevel, level)
		local hp = valuePairDynamicValueOnly(rc["Health Cost"], maxLevel, level)

		if mp then mp = mp .. " MP" end
		if hp then hp = hp .. " HP" end

		if mp and hp then
			return mp .. " + " .. hp
		end
		return mp or hp
	end

	local rangeVal = renderAny(mech.Range)
	local areaVal  = renderAreaSize(mech.Area)
	local costVal  = renderCost()

	local castVal = valuePairDynamicValueOnly(bt["Cast Time"], maxLevel, level)
	local cdVal   = valuePairDynamicValueOnly(bt["Cooldown"],  maxLevel, level)
	local durVal  = valuePairDynamicValueOnly(bt["Duration"],  maxLevel, level)

	local grid = mw.html.create("div")
	grid:addClass("sv-m4-grid")

	local function addCell(label, val)
		local cell = grid:tag("div"):addClass("sv-m4-cell")
		cell:tag("div"):addClass("sv-m4-label"):wikitext(mw.text.nowiki(label))
		cell:tag("div"):addClass("sv-m4-value"):wikitext(val or dash())
	end

	addCell("Range",     rangeVal)
	addCell("Area",      areaVal)
	addCell("Cost",      costVal)
	addCell("Cast Time", castVal)
	addCell("Cooldown",  cdVal)
	addCell("Duration",  durVal)

	return moduleBox(4, "module-quick-stats", tostring(grid), false)
end

local function buildHeroModulesUI(rec, level, maxLevel)
	local grid = mw.html.create("div")
	grid:addClass("hero-modules-grid")

	grid:wikitext(buildModuleLevelSelector(level, maxLevel))
	grid:wikitext(buildModuleSkillType(rec.Type or {}))

	local m3 = buildModuleSkillSource(rec, level, maxLevel)
	grid:wikitext(m3 or buildEmptyModule(3))

	-- Slot 4: new Quick Stats module
	grid:wikitext(buildModuleQuickStats(rec, level, maxLevel))

	return tostring(grid)
end

local function addHeroModulesRow(tbl, modulesUI)
	if not modulesUI or modulesUI == "" then
		return
	end

	local row = tbl:tag("tr")
	row:addClass("hero-modules-row")

	local cell = row:tag("td")
	cell:attr("colspan", 2)
	cell:addClass("hero-modules-cell")
	cell:wikitext(modulesUI)
end

----------------------------------------------------------------------
-- Infobox builder
----------------------------------------------------------------------

local function buildInfobox(rec, opts)
	opts = opts or {}
	local showUsers = (opts.showUsers ~= false)

	local maxLevel = tonumber(rec["Max Level"]) or 1
	if maxLevel < 1 then maxLevel = 1 end
	local level = clamp(maxLevel, 1, maxLevel)

	local root = mw.html.create("table")
	root:addClass("spiritvale-skill-infobox")
	root:addClass("sv-skill-card")
	root:attr("data-max-level", tostring(maxLevel))
	root:attr("data-level", tostring(level))

	if opts.inList then
		root:addClass("sv-skill-inlist")
	end

	local internalId = trim(rec["Internal Name"] or rec.InternalID or rec.ID)
	if internalId then
		root:attr("data-skill-id", internalId)
	end

	local icon  = rec.Icon
	local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
	local desc  = rec.Description or ""

	local heroRow = root:tag("tr")
	heroRow:addClass("spiritvale-infobox-main")
	heroRow:addClass("sv-hero-title-row")
	heroRow:addClass("hero-title-bar")

	local heroCell = heroRow:tag("th")
	heroCell:attr("colspan", 2)
	heroCell:addClass("sv-hero-title-cell")

	local heroInner = heroCell:tag("div")
	heroInner:addClass("spiritvale-infobox-main-left-inner")

	if icon and icon ~= "" then
		heroInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
	end

	heroInner:tag("div")
		:addClass("spiritvale-infobox-title")
		:wikitext(title)

	if desc ~= "" then
		local descRow = root:tag("tr")
		descRow:addClass("spiritvale-infobox-main")
		descRow:addClass("sv-hero-desc-row")
		descRow:addClass("hero-description-bar")

		local descCell = descRow:tag("td")
		descCell:attr("colspan", 2)
		descCell:addClass("sv-hero-desc-cell")

		local descInner = descCell:tag("div")
		descInner:addClass("spiritvale-infobox-main-right-inner")

		descInner:tag("div")
			:addClass("spiritvale-infobox-description")
			:wikitext(string.format("''%s''", desc))
	end

	addHeroModulesRow(root, buildHeroModulesUI(rec, level, maxLevel))

	if showUsers then
		local users = rec.Users or {}
		addRow(root, "Classes",  listToText(users.Classes),  "sv-row-users", "Users.Classes")
		addRow(root, "Summons",  listToText(users.Summons),  "sv-row-users", "Users.Summons")
		addRow(root, "Monsters", listToText(users.Monsters), "sv-row-users", "Users.Monsters")
		addRow(root, "Events",   listToText(users.Events),   "sv-row-users", "Users.Events")
	end

	local req = rec.Requirements or {}
	local hasReq =
		(type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0) or
		(type(req["Required Weapons"]) == "table" and #req["Required Weapons"] > 0) or
		(type(req["Required Stances"]) == "table" and #req["Required Stances"] > 0)

	if hasReq then
		if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
			local skillParts = {}
			for _, rs in ipairs(req["Required Skills"]) do
				local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
				local lvlReq  = rs["Required Level"]
				if lvlReq then
					table.insert(skillParts, string.format("%s (Lv.%s)", nameReq, lvlReq))
				else
					table.insert(skillParts, nameReq)
				end
			end
			addRow(root, "Required Skills", table.concat(skillParts, ", "), "sv-row-req", "Requirements.Required Skills")
		end

		addRow(root, "Required Weapons", listToText(req["Required Weapons"]), "sv-row-req", "Requirements.Required Weapons")
		addRow(root, "Required Stances", listToText(req["Required Stances"]), "sv-row-req", "Requirements.Required Stances")
	end

	local mech = rec.Mechanics or {}
	if next(mech) ~= nil then
		-- NOTE: Range / Area / Timing / Resource Cost rows have been removed
		-- because they are now displayed in Module 4 (Quick Stats).

		if mech["Autocast Multiplier"] ~= nil then
			addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]), "sv-row-mech", "Mechanics.Autocast Multiplier")
		end

		addRow(root, "Combo",             formatCombo(mech.Combo), "sv-row-mech", "Mechanics.Combo")
		addRow(root, "Special Mechanics", formatMechanicEffects(mech.Effects, maxLevel, level), "sv-row-mech", "Mechanics.Effects")
	end

	-- Source + Scaling are displayed in Module 3 now, so we do NOT repeat them as body rows.
	-- Keep the detailed legacy damage breakdown rows only (Main/Flat/Reflect/Healing).
	if type(rec.Source) ~= "table" then
		local dmg = rec.Damage or {}
		if next(dmg) ~= nil then
			local main = dmg["Main Damage"]
			local mainNonHeal, healOnly = {}, {}

			if type(main) == "table" then
				for _, d in ipairs(main) do
					if type(d) == "table" and d.Type == "Healing" then
						table.insert(healOnly, d)
					else
						table.insert(mainNonHeal, d)
					end
				end
			end

			local flatList = dmg["Flat Damage"]
			local reflList = dmg["Reflect Damage"]

			addRow(root, "Main Damage",    formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)), "sv-row-source", "Damage.Main Damage")
			addRow(root, "Flat Damage",    formatDamageList(flatList, maxLevel, level, false), "sv-row-source", "Damage.Flat Damage")
			addRow(root, "Reflect Damage", formatDamageList(reflList, maxLevel, level, false), "sv-row-source", "Damage.Reflect Damage")
			addRow(root, "Healing",        formatDamageList(healOnly, maxLevel, level, false), "sv-row-source", "Damage.Healing")
		end
	end

	local modsText = formatModifiers(rec.Modifiers)
	if modsText then
		addRow(root, "Flags", modsText, "sv-row-meta", "Modifiers")
	end

	local statusApps = formatStatusApplications(rec["Status Applications"], maxLevel, level)
	local statusRem  = formatStatusRemoval(rec["Status Removal"], maxLevel, level)
	if statusApps or statusRem then
		addRow(root, "Applies", statusApps, "sv-row-status", "Status Applications")
		addRow(root, "Removes", statusRem,  "sv-row-status", "Status Removal")
	end

	local eventsText = formatEvents(rec.Events)
	if eventsText then
		addRow(root, "Triggers", eventsText, "sv-row-meta", "Events")
	end

	if type(rec.Notes) == "table" and #rec.Notes > 0 then
		addRow(root, "Notes", table.concat(rec.Notes, "<br />"), "sv-row-meta", "Notes")
	end

	return tostring(root)
end

----------------------------------------------------------------------
-- Public: list all skills for a given user/class
----------------------------------------------------------------------

function p.listForUser(frame)
	local args = getArgs(frame)

	local userName = args.user or args[1]
	if not userName or userName == "" then
		userName = mw.title.getCurrentTitle().text
	end

	if not userName or userName == "" then
		return "<strong>No user name provided to Skill list.</strong>"
	end

	local dataset = getSkills()
	local matches = {}

	for _, rec in ipairs(dataset.records or {}) do
		if skillMatchesUser(rec, userName) then
			table.insert(matches, rec)
		end
	end

	if #matches == 0 then
		return string.format("<strong>No skills found for:</strong> %s", mw.text.nowiki(userName))
	end

	local root = mw.html.create("div")
	root:addClass("sv-skill-collection")

	for _, rec in ipairs(matches) do
		local item = root:tag("div"):addClass("sv-skill-item")
		item:wikitext(buildInfobox(rec, { showUsers = false, inList = true }))
	end

	return tostring(root)
end

----------------------------------------------------------------------
-- Public: single-skill or auto-list dispatcher
----------------------------------------------------------------------

function p.infobox(frame)
	local args = getArgs(frame)

	local raw1 = args[1]
	local name = args.name or raw1
	local id   = args.id

	local rec
	if name and name ~= "" then
		rec = findSkillByName(name)
	end
	if not rec and id and id ~= "" then
		rec = getSkillById(id)
	end

	if not rec then
		local pageTitle = mw.title.getCurrentTitle()
		local pageName  = pageTitle and pageTitle.text or ""

		local noExplicitArgs =
			(not raw1 or raw1 == "") and
			(not args.name or args.name == "") and
			(not id or id == "")

		if noExplicitArgs then
			return p.listForUser(frame)
		end

		if name and name ~= "" and name == pageName and (not id or id == "") then
			return p.listForUser(frame)
		end

		local label = name or id or "?"
		return string.format(
			"<strong>Unknown Skill:</strong> %s[[Category:Pages with unknown skill|%s]]",
			mw.text.nowiki(label),
			label
		)
	end

	local showUsers = not isDirectSkillPage(rec)
	return buildInfobox(rec, { showUsers = showUsers })
end

return p