@xforge-dev/forge-kit 0.24.0 → 0.24.2

package/README.md

@@ -132,11 +132,12 @@ the lowercased name without spaces, so a stored board never holds names.
 ### Legion Points (GMS v.272)
 
 v.272 removes the board. The points model sits beside it (the board stays for app versions still reading it):
-`legionPoints` (the automatic raid's ranks, B 1 … SSS 5, as many members as the Legion rank holds), stat levels
-(`LegionStats`, one point a level, `statCap` 15 for basic stats and up to 40 for expanded ones by Legion level),
+`legionPoints` (the automatic raid's ranks, B 1 … SSS 5, as many members as the Legion rank holds; `raidSplit` gives
+those and the bonus-only rest, since every member at rank B or higher gives its effect: `effectMembers`), stat levels
+(`LegionStats`, one point a level, what a grid square was: same values, caps 15 inner and 40 outer),
 `allocationProblem`, `statTotals`, `suggestStats`, the two highest event blocks (`appliedEventBlocks`), 10 named
 presets (`SharedPoints`, stored under `points` in the shared row so an older board write leaves it alone) and the 5th
-Champion slot (`championSlotsOpen`). Values not yet confirmed sit in one marked block in `src/legion.ts`.
+Champion slot (`championSlotsOpen`).
 
 ## Exports
 

package/dist/legion.d.ts

@@ -166,9 +166,9 @@ export declare function sharedBoardFrom(raw: unknown): SharedBoard | null;
 export declare function crystalsFrom(raw: unknown): ArtifactCrystal[];
 /** The Legion's 16 stats, keyed as the grid's areas were. */
 export type LegionStatKey = GridKey;
-/** Basic stats, open from the start (the patch notes' order). */
+/** Basic stats: the board's inner areas (the patch notes' order). */
 export declare const BASIC_STATS: readonly ["str", "dex", "int", "luk", "att", "matt", "hp", "mp"];
-/** Expanded stats, opening together at Legion level 2,000 (the patch notes' order). */
+/** Expanded stats: the board's outer areas (the patch notes' order). */
 export declare const EXPANDED_STATS: readonly ["critDamage", "boss", "ied", "critRate", "buffDuration", "normal", "exp", "statusResist"];
 export type ExpandedStat = (typeof EXPANDED_STATS)[number];
 export declare const LEGION_STATS: readonly GridKey[];
@@ -190,24 +190,15 @@ export declare const LEGION_LEVEL_RANKS: readonly LegionLevelRank[];
 export declare function legionLevelRank(level: number): LegionLevelRank | null;
 /** Members the automatic Legion Raid takes at this Legion level (Nameless I's 9 below it). */
 export declare const raidMembers: (level: number) => number;
-/** Each stat's highest level. */
-export declare const STAT_MAX_LEVEL: Record<GridKey, number>;
-/** The expanded stats' shared level cap by Legion level (the guide's 유니온 레벨별 확장 스탯 최대 레벨). */
-export declare const EXPANDED_CAPS: readonly {
-    level: number;
-    cap: number;
-}[];
-/** The expanded stats' level cap at this Legion level: 0 below 2,000. */
-export declare function expandedCap(legionLevel: number): number;
-/** What one level of each stat gives. */
+/** What one level of each stat gives: a grid square's value. */
 export declare const STAT_PER_LEVEL: Record<GridKey, number>;
-/** Points an applied event block gives. */
-export declare const eventBlockPoints: (_b: EventBlock) => number;
+/** Each stat's highest level: its grid area's size. */
+export declare const STAT_MAX_LEVEL: Record<GridKey, number>;
 /** Stat levels, one per point: absent or 0 when nothing is spent. */
 export type LegionStats = Partial<Record<GridKey, number>>;
 export declare const isExpandedStat: (k: GridKey) => k is ExpandedStat;
-/** A stat's level cap at this Legion level: basic stats 15, expanded stats as the Legion level allows. */
-export declare const statCap: (k: GridKey, legionLevel: number) => number;
+/** A stat's level cap at this Legion level: its grid area's size at every Legion level, as the board had it. */
+export declare const statCap: (k: GridKey, _legionLevel: number) => number;
 /** Whether a stat is open at this Legion level. */
 export declare const statUnlocked: (k: GridKey, legionLevel: number) => boolean;
 /** One member as the points model reads it: `rank` null below B (no points, no effect). */
@@ -220,10 +211,20 @@ export type PointsMember = {
  * The caller works out ranks (Zero's own levels) and Legion level.
  */
 export declare function raidComposition<M extends PointsMember>(members: readonly M[], legionLevel: number): M[];
+/**
+ * The Legion split in two: `counted`, the members the raid takes (their ranks are the Legion Points), and `bonus`, the
+ * other members at rank B or higher, whose effects apply too but who give no points. Members below B are in neither.
+ */
+export declare function raidSplit<M extends PointsMember>(members: readonly M[], legionLevel: number): {
+    counted: M[];
+    bonus: M[];
+};
+/** Members whose effects apply: every member at rank B or higher, counted by the raid or not. */
+export declare const effectMembers: <M extends PointsMember>(members: readonly M[]) => M[];
 /** The two event blocks that apply: the highest values among those owned. */
 export declare function appliedEventBlocks(owned: readonly EventBlock[]): EventBlock[];
-/** Legion Points to spend: the raid's ranks (and the applied event blocks', none as far as known). */
-export declare function legionPoints(members: readonly PointsMember[], legionLevel: number, owned?: readonly EventBlock[]): number;
+/** Legion Points to spend: the ranks of the members the raid counts. Event blocks add ATT, not points. */
+export declare function legionPoints(members: readonly PointsMember[], legionLevel: number): number;
 /** Points the stat levels spend. */
 export declare const pointsSpent: (stats: LegionStats) => number;
 /** What each stat gives at its level (only stats with a level). */

package/dist/legion.js

@@ -195,9 +195,9 @@ export function crystalsFrom(raw) {
         return { level, lines };
     });
 }
-/** Basic stats, open from the start (the patch notes' order). */
+/** Basic stats: the board's inner areas (the patch notes' order). */
 export const BASIC_STATS = ['str', 'dex', 'int', 'luk', 'att', 'matt', 'hp', 'mp'];
-/** Expanded stats, opening together at Legion level 2,000 (the patch notes' order). */
+/** Expanded stats: the board's outer areas (the patch notes' order). */
 export const EXPANDED_STATS = [
     'critDamage', 'boss', 'ied', 'critRate', 'buffDuration', 'normal', 'exp', 'statusResist',
 ];
@@ -226,37 +226,17 @@ export function legionLevelRank(level) {
 }
 /** Members the automatic Legion Raid takes at this Legion level (Nameless I's 9 below it). */
 export const raidMembers = (level) => (legionLevelRank(level) ?? LEGION_LEVEL_RANKS[0]).members;
-// Confirmed from KMS 1.2.416 (the same revamp, 2026-06-18; maplestory.nexon.com News/Update/806 and the official game
-// guide, Guide/N23GameInformation/Articles/407): basic stats go to level 15, expanded stats to 40; the 8 expanded stats
-// open together, their cap rising with Legion level (below); points are only the raid's ranks (a KMST screenshot:
-// Supreme I, 41 members, 202 points).
-/** Each stat's highest level. */
-export const STAT_MAX_LEVEL = Object.fromEntries(GRID_KEYS.map((k) => [k, gridMax(k)]));
-/** The expanded stats' shared level cap by Legion level (the guide's 유니온 레벨별 확장 스탯 최대 레벨). */
-export const EXPANDED_CAPS = [
-    { level: 2000, cap: 5 }, { level: 3000, cap: 10 }, { level: 4000, cap: 20 }, { level: 5000, cap: 30 }, { level: 6000, cap: 40 },
-];
-/** The expanded stats' level cap at this Legion level: 0 below 2,000. */
-export function expandedCap(legionLevel) {
-    let cap = 0;
-    for (const c of EXPANDED_CAPS)
-        if (legionLevel >= c.level)
-            cap = c.cap;
-    return cap;
-}
-// ┌─ ASSUMED VALUES ────────────────────────────────────────────────────────────────────────────────────────────────┐
-// │ Not in the v.272 notes nor any KMS source found: what a stat level gives. Each is taken as one old grid square    │
-// │ (KMS says the stats are "the same types as the old occupation effects", and the caps and 440 total match the      │
-// │ board). Nor whether event blocks give points: taken as none (the notes only say they apply automatically and      │
-// │ don't count as members). Change them here only; everything below reads them.                                      │
-// └─────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
-/** What one level of each stat gives. */
+// The rules are the board's, without the board: a stat level is what a grid square was (same value per level, the
+// same caps: inner stats 15, outer stats 40, open from the start as every area was). Every member at rank B or higher
+// gives its effect; only the members the raid counts (the top members by level, as many as the board's slots were)
+// give points.
+/** What one level of each stat gives: a grid square's value. */
 export const STAT_PER_LEVEL = { ...GRID_PER_SQUARE };
-/** Points an applied event block gives. */
-export const eventBlockPoints = (_b) => 0;
+/** Each stat's highest level: its grid area's size. */
+export const STAT_MAX_LEVEL = Object.fromEntries(GRID_KEYS.map((k) => [k, gridMax(k)]));
 export const isExpandedStat = (k) => EXPANDED_STATS.includes(k);
-/** A stat's level cap at this Legion level: basic stats 15, expanded stats as the Legion level allows. */
-export const statCap = (k, legionLevel) => (isExpandedStat(k) ? Math.min(expandedCap(legionLevel), STAT_MAX_LEVEL[k]) : STAT_MAX_LEVEL[k]);
+/** A stat's level cap at this Legion level: its grid area's size at every Legion level, as the board had it. */
+export const statCap = (k, _legionLevel) => STAT_MAX_LEVEL[k];
 /** Whether a stat is open at this Legion level. */
 export const statUnlocked = (k, legionLevel) => statCap(k, legionLevel) > 0;
 /**
@@ -266,14 +246,24 @@ export const statUnlocked = (k, legionLevel) => statCap(k, legionLevel) > 0;
 export function raidComposition(members, legionLevel) {
     return members.filter((m) => m.rank).sort((a, b) => b.level - a.level).slice(0, raidMembers(legionLevel));
 }
+/**
+ * The Legion split in two: `counted`, the members the raid takes (their ranks are the Legion Points), and `bonus`, the
+ * other members at rank B or higher, whose effects apply too but who give no points. Members below B are in neither.
+ */
+export function raidSplit(members, legionLevel) {
+    const counted = raidComposition(members, legionLevel);
+    const taken = new Set(counted);
+    return { counted, bonus: members.filter((m) => m.rank && !taken.has(m)).sort((a, b) => b.level - a.level) };
+}
+/** Members whose effects apply: every member at rank B or higher, counted by the raid or not. */
+export const effectMembers = (members) => members.filter((m) => m.rank);
 /** The two event blocks that apply: the highest values among those owned. */
 export function appliedEventBlocks(owned) {
     return [...owned].sort((a, b) => b.value - a.value).slice(0, MAX_EVENT_BLOCKS);
 }
-/** Legion Points to spend: the raid's ranks (and the applied event blocks', none as far as known). */
-export function legionPoints(members, legionLevel, owned = []) {
-    return raidComposition(members, legionLevel).reduce((t, m) => t + RANK_POINTS[m.rank], 0)
-        + appliedEventBlocks(owned).reduce((t, b) => t + eventBlockPoints(b), 0);
+/** Legion Points to spend: the ranks of the members the raid counts. Event blocks add ATT, not points. */
+export function legionPoints(members, legionLevel) {
+    return raidComposition(members, legionLevel).reduce((t, m) => t + RANK_POINTS[m.rank], 0);
 }
 /** Points the stat levels spend. */
 export const pointsSpent = (stats) => Object.values(stats).reduce((t, n) => t + (n ?? 0), 0);
@@ -292,11 +282,8 @@ export function allocationProblem(a) {
         if (!n)
             continue;
         const cap = statCap(k, a.legionLevel);
-        if (n > cap) {
-            if (!cap)
-                return `${STAT_LABELS[k]} opens at Legion level ${EXPANDED_CAPS[0].level.toLocaleString('en-US')}.`;
-            return `${STAT_LABELS[k]} goes up to level ${cap}${cap < STAT_MAX_LEVEL[k] ? ' at this Legion level' : ''}.`;
-        }
+        if (n > cap)
+            return `${STAT_LABELS[k]} goes up to level ${cap}.`;
     }
     const spent = pointsSpent(a.stats);
     if (spent > a.points)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xforge-dev/forge-kit",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "description": "Shared auth, app registry and UI for xForge apps",
   "license": "MIT",
   "repository": {