@xforge-dev/forge-kit 0.18.1 → 0.19.0

package/README.md

@@ -106,6 +106,29 @@ the sign-in cookie, so a third-party script on one can read every user's session
 apps add Vercel Web Analytics (`<Analytics />` from `@vercel/analytics/next` in the root layout);
 it loads from the app's own origin, so the policy needs no extra sources.
 
+## Job catalog
+
+The kit ships a snapshot of `data/jobs.json` for sync lookups (`job()`, `allJobs()`, ...).
+`refreshJobCatalog()` (from `/server`) fetches the published copy at
+`https://cdn.xforge.dev/data/jobs.json`, caching it for an hour, and installs it. The root layout
+awaits it and passes the result to `ForgeJobsProvider` (from `/client`), so the browser gets the same
+catalog. Whenever `data/jobs.json` changes, set `updated` to a new full ISO-8601 UTC timestamp (for
+example `2026-10-29T18:30:00Z`). CI fails a content change that keeps the old stamp.
+
+- **New enum values need a kit release first.** A new `status`, branch or stat value has to ship in
+  a kit release, and every app has to bump to that release, before `data/jobs.json` can use the value.
+  An older parser rejects the whole file and keeps its snapshot, so no part of the edit reaches that app.
+- **Route handlers and server actions refresh the catalog themselves.** They don't run the root layout,
+  so any route handler or server action that looks up jobs must call `await refreshJobCatalog()`
+  before its first lookup. Otherwise it only ever sees the snapshot.
+
+## Legion board
+
+`/legion` holds the Legion board model BossForge and LegionForge share: the 5 presets of a world
+(`SharedBoard`: slots, placed name keys, grid, event blocks), the Artifact, and the rules both apps
+check a board with (`boardProblem`). A preset places characters by `legionNameKey(name)`, the md5 of
+the lowercased name without spaces, so a stored board never holds names.
+
 ## Exports
 
 `isForgeAuthConfigured` is exported from the root and `/client` entry points.

package/dist/jobs-provider.js

@@ -3,7 +3,7 @@ import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { getJobCatalog, setJobCatalog } from './jobs.js';
 /** Installs the server-fetched catalog before the children render, so client lookups agree with the server. */
 export function ForgeJobsProvider({ catalog, children }) {
-    if (catalog.updated !== getJobCatalog().updated)
+    if (catalog !== getJobCatalog())
         setJobCatalog(catalog);
     return _jsx(_Fragment, { children: children });
 }

package/dist/jobs-snapshot.js

@@ -1,6 +1,6 @@
 export const JOBS_SNAPSHOT = {
     "version": 1,
-    "updated": "2026-10-29",
+    "updated": "2026-10-29T18:30:00Z",
     "jobs": [
         {
             "name": "Hero",

package/dist/jobs.js

@@ -115,7 +115,7 @@ export function jobName(name) { return job(name)?.name ?? null; }
 export function allJobs(opts = {}) {
     return catalog.jobs
         .filter((j) => opts.includeRetired || j.status !== 'retired')
-        .sort((a, b) => a.name.localeCompare(b.name));
+        .sort((a, b) => a.name.localeCompare(b.name, 'en'));
 }
 /** Highest Legion rank a character of this level has reached; null below rank B's level. */
 export function legionRankFor(j, level) {

package/dist/legion.d.ts

@@ -0,0 +1,166 @@
+/**
+ * The Legion board both BossForge and LegionForge edit: one per account and world (BossForge's legion_worlds), with
+ * 5 presets of placement, grid squares and event blocks, and one Artifact. Values from the MapleStory Wiki (Legion,
+ * Legion Artifact), read 2026-10-26.
+ */
+export declare const LEGION_RANKS: readonly ["B", "A", "S", "SS", "SSS"];
+export type LegionRank = (typeof LEGION_RANKS)[number];
+/** Squares a member's block covers on the board: 1 at rank B up to 5 at SSS. */
+export declare const blockSize: (rank: LegionRank) => number;
+/**
+ * Inner grid squares (Stat % applies) and outer grid squares, with each square's value. The full 22 × 20 board's
+ * inner 12 × 10 splits into 8 areas of 15 squares; the other 320 split into 8 outer areas of 40.
+ */
+export declare const GRID_KEYS: readonly ["str", "dex", "int", "luk", "hp", "mp", "att", "matt", "critRate", "boss", "normal", "buffDuration", "ied", "critDamage", "statusResist", "exp"];
+export type GridKey = (typeof GRID_KEYS)[number];
+export type LegionGrid = Partial<Record<GridKey, number>>;
+export declare const OUTER_GRID_KEYS: readonly GridKey[];
+export declare const GRID_MAX_OUTER = 40;
+export declare const GRID_MAX_INNER = 15;
+export declare const gridMax: (k: GridKey) => 40 | 15;
+export declare const GRID_PER_SQUARE: Record<GridKey, number>;
+export declare const GRID_LABELS: Record<GridKey, string>;
+/** Squares filled across the grid's areas. */
+export declare const gridTotal: (grid: LegionGrid) => number;
+/**
+ * Artifact lines: each of the 9 crystals (level 0–5) carries up to 3 different lines; a line's level is the sum of the
+ * levels of the crystals that carry it, capped at 10, and its value is level × max / 10. A line sits on at most 2
+ * crystals, which is all a Lv 10 line needs.
+ */
+export declare const ARTIFACT_KEYS: readonly ["allStat", "hpMp", "att", "damage", "boss", "ied", "buffDuration", "cooldownSkip", "critRate", "critDamage", "summonDuration", "finalAttack", "meso", "drop", "expTarget", "statusResist"];
+export type ArtifactKey = (typeof ARTIFACT_KEYS)[number];
+export declare const ARTIFACT_MAX_LEVEL = 10;
+export declare const ARTIFACT_CRYSTALS: readonly ["Orange Mushroom", "Slime", "Horny Mushroom", "Stump", "Stone Golem", "Balrog", "Zakum", "Pink Bean", "Papulatus"];
+export declare const CRYSTAL_MAX_LEVEL = 5;
+export declare const CRYSTAL_LINES = 3;
+export declare const ARTIFACT_LINE_MAX_CRYSTALS = 2;
+/** A crystal's icon on the CDN (legion/artifact, from the MapleStory Wiki). */
+export declare const crystalImageUrl: (i: number) => string;
+export declare const ARTIFACT_MAX: Record<ArtifactKey, number>;
+export declare const ARTIFACT_LABELS: Record<ArtifactKey, string>;
+export type ArtifactCrystal = {
+    level: number;
+    lines: ArtifactKey[];
+};
+/** Each line's level from the crystals: summed over the crystals carrying it, capped at 10. */
+export declare function artifactLevels(crystals: readonly ArtifactCrystal[]): Partial<Record<ArtifactKey, number>>;
+/** How many crystals carry each line. */
+export declare function artifactLineUses(crystals: readonly ArtifactCrystal[]): Partial<Record<ArtifactKey, number>>;
+export declare function artifactValue(key: ArtifactKey, level: number): number;
+/**
+ * Event Legion blocks (the wiki's Legion § Event Legion Blocks, GMS): ATT and Magic ATT only, flat (Stat % applies),
+ * in the board's two special slots, outside the member slots. Each covers squares like a member block of its rank
+ * (B 1 … SSS 5), so it also adds to what the grid can hold. Lab Server and Abyssal Expedition (Minar Forest, GMS's
+ * one run; its rank was how far the event went) blocks level by rank (B…SSS); Ride or Die came in several seasons,
+ * so `copies: 2` lets it fill both slots. Blocks without ranks count as SSS.
+ */
+export declare const EVENT_BLOCKS: readonly [{
+    readonly id: "labServer";
+    readonly name: "Lab Server Legion Block";
+    readonly values: readonly [5, 10, 15, 20, 25];
+    readonly ranked: true;
+    readonly copies: 1;
+}, {
+    readonly id: "enhancedLabServer";
+    readonly name: "Enhanced Lab Server Legion Block";
+    readonly values: readonly [7, 14, 21, 28, 35];
+    readonly ranked: true;
+    readonly copies: 1;
+}, {
+    readonly id: "abyssalExpedition";
+    readonly name: "Abyssal Expedition Legion Block";
+    readonly values: readonly [7, 14, 21, 28, 35];
+    readonly ranked: true;
+    readonly copies: 1;
+}, {
+    readonly id: "rideOrDie";
+    readonly name: "Ride or Die Legion Block";
+    readonly values: readonly [35];
+    readonly ranked: false;
+    readonly copies: 2;
+}];
+export type EventBlockId = (typeof EVENT_BLOCKS)[number]['id'];
+export type EventBlock = {
+    id: EventBlockId;
+    value: number;
+};
+export declare const MAX_EVENT_BLOCKS = 2;
+export declare const eventBlock: (id: string) => {
+    readonly id: "labServer";
+    readonly name: "Lab Server Legion Block";
+    readonly values: readonly [5, 10, 15, 20, 25];
+    readonly ranked: true;
+    readonly copies: 1;
+} | {
+    readonly id: "enhancedLabServer";
+    readonly name: "Enhanced Lab Server Legion Block";
+    readonly values: readonly [7, 14, 21, 28, 35];
+    readonly ranked: true;
+    readonly copies: 1;
+} | {
+    readonly id: "abyssalExpedition";
+    readonly name: "Abyssal Expedition Legion Block";
+    readonly values: readonly [7, 14, 21, 28, 35];
+    readonly ranked: true;
+    readonly copies: 1;
+} | {
+    readonly id: "rideOrDie";
+    readonly name: "Ride or Die Legion Block";
+    readonly values: readonly [35];
+    readonly ranked: false;
+    readonly copies: 2;
+} | undefined;
+/** Squares an event block covers: its rank's block size, or SSS's for a block without ranks. */
+export declare function eventBlockSquares(b: EventBlock): number;
+export declare const eventBlockUrl: (id: EventBlockId) => string;
+export declare const MAX_LEGION_SLOTS = 50;
+export declare const MAX_LEGION_MEMBERS = 60;
+export declare const LEGION_PRESETS = 5;
+/**
+ * A character's key on the board: md5 of its name, lowercased, with surrounding spaces stripped. It is what BossForge's
+ * character_legion returns for names (md5(lower(btrim(name)))), so a stored placement reveals no names.
+ */
+export declare const legionNameKey: (name: string) => string;
+/** One roster member as the board check sees it: `job` canonical in the caller's naming, `rank` null below B. */
+export type BoardMember = {
+    key?: string;
+    job: string;
+    level: number;
+    rank: LegionRank | null;
+    placed: boolean;
+};
+/**
+ * What's wrong with a preset's board, or null. With members entered: no more slots than the Legion level allows
+ * (`cap`, from Legion level `level`), no more placed members than slots, one member per job, and no more grid squares than the placed members
+ * (the highest `slots` with a rank) and event blocks cover.
+ */
+export declare function boardProblem(b: {
+    slots: number;
+    cap: number;
+    level?: number;
+    members: readonly BoardMember[];
+    grid: LegionGrid;
+    blocks?: readonly EventBlock[];
+}): string | null;
+/** A preset as stored for a world both apps share: who's placed (name keys), its slots, grid and event blocks. */
+export type SharedBoard = {
+    slots: number;
+    placed: string[];
+    grid: LegionGrid;
+    blocks?: EventBlock[];
+};
+/** The shared part of a world's Legion: 5 presets, the one in use (0-based) and the Artifact. */
+export type SharedLegion = {
+    presets: SharedBoard[];
+    active: number;
+    crystals: ArtifactCrystal[];
+};
+export declare const emptySharedBoard: () => SharedBoard;
+/** Valid grid squares: known areas, whole numbers within each area's size, empty areas dropped. */
+export declare function gridFrom(raw: unknown): LegionGrid;
+/** Valid event blocks: known blocks at one of their values, each within its copies, two at most. */
+export declare function blocksFrom(raw: unknown): EventBlock[];
+/** A stored shared preset as a valid one, or null when it isn't one (no `placed`: an older, member-shaped preset). */
+export declare function sharedBoardFrom(raw: unknown): SharedBoard | null;
+/** Valid crystals: nine at most, levels 0–5, up to 3 known lines each, a line on at most 2 crystals. */
+export declare function crystalsFrom(raw: unknown): ArtifactCrystal[];

package/dist/legion.js

@@ -0,0 +1,197 @@
+import { md5 } from './md5.js';
+/**
+ * The Legion board both BossForge and LegionForge edit: one per account and world (BossForge's legion_worlds), with
+ * 5 presets of placement, grid squares and event blocks, and one Artifact. Values from the MapleStory Wiki (Legion,
+ * Legion Artifact), read 2026-10-26.
+ */
+export const LEGION_RANKS = ['B', 'A', 'S', 'SS', 'SSS'];
+/** Squares a member's block covers on the board: 1 at rank B up to 5 at SSS. */
+export const blockSize = (rank) => LEGION_RANKS.indexOf(rank) + 1;
+/**
+ * Inner grid squares (Stat % applies) and outer grid squares, with each square's value. The full 22 × 20 board's
+ * inner 12 × 10 splits into 8 areas of 15 squares; the other 320 split into 8 outer areas of 40.
+ */
+export const GRID_KEYS = [
+    'str', 'dex', 'int', 'luk', 'hp', 'mp', 'att', 'matt',
+    'critRate', 'boss', 'normal', 'buffDuration', 'ied', 'critDamage', 'statusResist', 'exp',
+];
+export const OUTER_GRID_KEYS = ['critRate', 'boss', 'normal', 'buffDuration', 'ied', 'critDamage', 'statusResist', 'exp'];
+export const GRID_MAX_OUTER = 40;
+export const GRID_MAX_INNER = 15;
+export const gridMax = (k) => (OUTER_GRID_KEYS.includes(k) ? GRID_MAX_OUTER : GRID_MAX_INNER);
+export const GRID_PER_SQUARE = {
+    str: 5, dex: 5, int: 5, luk: 5, hp: 250, mp: 250, att: 1, matt: 1,
+    critRate: 1, boss: 1, normal: 1, buffDuration: 1, ied: 1, critDamage: 0.5, statusResist: 1, exp: 0.25,
+};
+export const GRID_LABELS = {
+    str: 'STR', dex: 'DEX', int: 'INT', luk: 'LUK', hp: 'Max HP', mp: 'Max MP', att: 'ATT', matt: 'Magic ATT',
+    critRate: 'Critical Rate', boss: 'Boss Damage', normal: 'Normal Monster Damage', buffDuration: 'Buff Duration',
+    ied: 'Ignore Enemy DEF', critDamage: 'Critical Damage', statusResist: 'Status Resistance', exp: 'EXP',
+};
+/** Squares filled across the grid's areas. */
+export const gridTotal = (grid) => Object.values(grid).reduce((t, n) => t + (n ?? 0), 0);
+/**
+ * Artifact lines: each of the 9 crystals (level 0–5) carries up to 3 different lines; a line's level is the sum of the
+ * levels of the crystals that carry it, capped at 10, and its value is level × max / 10. A line sits on at most 2
+ * crystals, which is all a Lv 10 line needs.
+ */
+export const ARTIFACT_KEYS = [
+    'allStat', 'hpMp', 'att', 'damage', 'boss', 'ied', 'buffDuration', 'cooldownSkip', 'critRate', 'critDamage',
+    'summonDuration', 'finalAttack', 'meso', 'drop', 'expTarget', 'statusResist',
+];
+export const ARTIFACT_MAX_LEVEL = 10;
+export const ARTIFACT_CRYSTALS = ['Orange Mushroom', 'Slime', 'Horny Mushroom', 'Stump', 'Stone Golem', 'Balrog', 'Zakum', 'Pink Bean', 'Papulatus'];
+export const CRYSTAL_MAX_LEVEL = 5;
+export const CRYSTAL_LINES = 3;
+export const ARTIFACT_LINE_MAX_CRYSTALS = 2;
+const CDN = 'https://cdn.xforge.dev';
+/** A crystal's icon on the CDN (legion/artifact, from the MapleStory Wiki). */
+export const crystalImageUrl = (i) => `${CDN}/legion/artifact/${ARTIFACT_CRYSTALS[i].toLowerCase().replace(/ /g, '-')}.png`;
+export const ARTIFACT_MAX = {
+    allStat: 150, hpMp: 7500, att: 30, damage: 15, boss: 15, ied: 20, buffDuration: 20, cooldownSkip: 7.5,
+    critRate: 20, critDamage: 4, summonDuration: 20, finalAttack: 30, meso: 12, drop: 12, expTarget: 12, statusResist: 12,
+};
+export const ARTIFACT_LABELS = {
+    allStat: 'All Stats', hpMp: 'Max HP/MP', att: 'ATT / Magic ATT', damage: 'Damage', boss: 'Boss Damage',
+    ied: 'Ignore Enemy DEF', buffDuration: 'Buff Duration', cooldownSkip: 'Cooldown Skip Chance', critRate: 'Critical Rate',
+    critDamage: 'Critical Damage', summonDuration: 'Summon Duration', finalAttack: 'Final Attack Damage', meso: 'Mesos Obtained',
+    drop: 'Item Drop Rate', expTarget: 'EXP and +1 Target', statusResist: 'Status Resistance',
+};
+/** Each line's level from the crystals: summed over the crystals carrying it, capped at 10. */
+export function artifactLevels(crystals) {
+    const out = {};
+    for (const c of crystals)
+        for (const k of c.lines)
+            out[k] = Math.min((out[k] ?? 0) + c.level, ARTIFACT_MAX_LEVEL);
+    return out;
+}
+/** How many crystals carry each line. */
+export function artifactLineUses(crystals) {
+    const out = {};
+    for (const c of crystals)
+        for (const k of c.lines)
+            out[k] = (out[k] ?? 0) + 1;
+    return out;
+}
+export function artifactValue(key, level) {
+    return (Math.min(Math.max(level, 0), ARTIFACT_MAX_LEVEL) * ARTIFACT_MAX[key]) / ARTIFACT_MAX_LEVEL;
+}
+/**
+ * Event Legion blocks (the wiki's Legion § Event Legion Blocks, GMS): ATT and Magic ATT only, flat (Stat % applies),
+ * in the board's two special slots, outside the member slots. Each covers squares like a member block of its rank
+ * (B 1 … SSS 5), so it also adds to what the grid can hold. Lab Server and Abyssal Expedition (Minar Forest, GMS's
+ * one run; its rank was how far the event went) blocks level by rank (B…SSS); Ride or Die came in several seasons,
+ * so `copies: 2` lets it fill both slots. Blocks without ranks count as SSS.
+ */
+export const EVENT_BLOCKS = [
+    { id: 'labServer', name: 'Lab Server Legion Block', values: [5, 10, 15, 20, 25], ranked: true, copies: 1 },
+    { id: 'enhancedLabServer', name: 'Enhanced Lab Server Legion Block', values: [7, 14, 21, 28, 35], ranked: true, copies: 1 },
+    { id: 'abyssalExpedition', name: 'Abyssal Expedition Legion Block', values: [7, 14, 21, 28, 35], ranked: true, copies: 1 },
+    { id: 'rideOrDie', name: 'Ride or Die Legion Block', values: [35], ranked: false, copies: 2 },
+];
+export const MAX_EVENT_BLOCKS = 2;
+export const eventBlock = (id) => EVENT_BLOCKS.find((b) => b.id === id);
+/** Squares an event block covers: its rank's block size, or SSS's for a block without ranks. */
+export function eventBlockSquares(b) {
+    const def = eventBlock(b.id);
+    if (!def?.ranked)
+        return blockSize('SSS');
+    return def.values.indexOf(b.value) + 1;
+}
+const BLOCK_ART = {
+    labServer: 'lab-server', enhancedLabServer: 'enhanced-lab-server', abyssalExpedition: 'abyssal-expedition', rideOrDie: 'ride-or-die',
+};
+export const eventBlockUrl = (id) => `${CDN}/legion/blocks/${BLOCK_ART[id]}.png`;
+export const MAX_LEGION_SLOTS = 50;
+export const MAX_LEGION_MEMBERS = 60;
+export const LEGION_PRESETS = 5;
+/**
+ * A character's key on the board: md5 of its name, lowercased, with surrounding spaces stripped. It is what BossForge's
+ * character_legion returns for names (md5(lower(btrim(name)))), so a stored placement reveals no names.
+ */
+export const legionNameKey = (name) => md5(name.replace(/^ +| +$/g, '').toLowerCase());
+/**
+ * What's wrong with a preset's board, or null. With members entered: no more slots than the Legion level allows
+ * (`cap`, from Legion level `level`), no more placed members than slots, one member per job, and no more grid squares than the placed members
+ * (the highest `slots` with a rank) and event blocks cover.
+ */
+export function boardProblem(b) {
+    if (!b.members.length)
+        return null;
+    if (b.slots > b.cap)
+        return `Legion level ${b.level !== undefined ? `${b.level.toLocaleString('en-US')} ` : ''}allows ${b.cap} members on the board.`;
+    const placed = b.members.filter((m) => m.placed);
+    if (placed.length > b.slots)
+        return `The board holds ${b.slots} members.`;
+    const jobs = new Set();
+    for (const m of placed) {
+        if (jobs.has(m.job))
+            return `Only one ${m.job} can be on the board.`;
+        jobs.add(m.job);
+    }
+    const squares = placed.filter((m) => m.rank).sort((x, y) => y.level - x.level).slice(0, b.slots)
+        .reduce((t, m) => t + blockSize(m.rank), 0) + (b.blocks ?? []).reduce((t, e) => t + eventBlockSquares(e), 0);
+    const used = gridTotal(b.grid);
+    if (used > squares)
+        return `The grid has ${used} squares filled, but your placed members and event blocks cover ${squares}.`;
+    return null;
+}
+export const emptySharedBoard = () => ({ slots: MAX_LEGION_SLOTS, placed: [], grid: {} });
+const isObject = (x) => !!x && typeof x === 'object' && !Array.isArray(x);
+const int = (x, min, max) => (typeof x === 'number' && Number.isFinite(x) ? Math.min(Math.max(Math.trunc(x), min), max) : null);
+/** Valid grid squares: known areas, whole numbers within each area's size, empty areas dropped. */
+export function gridFrom(raw) {
+    if (!isObject(raw))
+        return {};
+    const out = {};
+    for (const k of GRID_KEYS) {
+        const n = int(raw[k], 0, gridMax(k));
+        if (n)
+            out[k] = n;
+    }
+    return out;
+}
+/** Valid event blocks: known blocks at one of their values, each within its copies, two at most. */
+export function blocksFrom(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const x of raw) {
+        if (!isObject(x) || out.length >= MAX_EVENT_BLOCKS)
+            continue;
+        const def = eventBlock(String(x.id));
+        if (!def || !def.values.includes(x.value))
+            continue;
+        if (out.filter((b) => b.id === def.id).length >= def.copies)
+            continue;
+        out.push({ id: def.id, value: x.value });
+    }
+    return out;
+}
+/** A stored shared preset as a valid one, or null when it isn't one (no `placed`: an older, member-shaped preset). */
+export function sharedBoardFrom(raw) {
+    if (!isObject(raw) || !Array.isArray(raw.placed))
+        return null;
+    const placed = [...new Set(raw.placed.filter((k) => typeof k === 'string' && k.length > 0))].slice(0, MAX_LEGION_MEMBERS);
+    const blocks = blocksFrom(raw.blocks);
+    return { slots: int(raw.slots, 0, MAX_LEGION_SLOTS) ?? MAX_LEGION_SLOTS, placed, grid: gridFrom(raw.grid), ...(blocks.length ? { blocks } : {}) };
+}
+/** Valid crystals: nine at most, levels 0–5, up to 3 known lines each, a line on at most 2 crystals. */
+export function crystalsFrom(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const uses = {};
+    return raw.slice(0, ARTIFACT_CRYSTALS.length).map((c) => {
+        const level = isObject(c) ? int(c.level, 0, CRYSTAL_MAX_LEVEL) ?? 0 : 0;
+        const lines = [];
+        for (const k of isObject(c) && Array.isArray(c.lines) ? c.lines : []) {
+            if (!ARTIFACT_KEYS.includes(k) || lines.includes(k) || lines.length >= CRYSTAL_LINES)
+                continue;
+            if ((uses[k] ?? 0) >= ARTIFACT_LINE_MAX_CRYSTALS)
+                continue;
+            uses[k] = (uses[k] ?? 0) + 1;
+            lines.push(k);
+        }
+        return { level, lines };
+    });
+}

package/dist/md5.d.ts

@@ -0,0 +1,2 @@
+/** MD5 (RFC 1321) of a string's UTF-8 bytes, as lowercase hex: the same value as Postgres md5(). */
+export declare function md5(input: string): string;

package/dist/md5.js

@@ -0,0 +1,48 @@
+/** MD5 (RFC 1321) of a string's UTF-8 bytes, as lowercase hex: the same value as Postgres md5(). */
+const S = [7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21];
+const K = Array.from({ length: 64 }, (_, i) => Math.floor(Math.abs(Math.sin(i + 1)) * 2 ** 32) >>> 0);
+export function md5(input) {
+    const bytes = new TextEncoder().encode(input);
+    const words = new Uint32Array((((bytes.length + 8) >>> 6) + 1) * 16);
+    for (let i = 0; i < bytes.length; i++)
+        words[i >>> 2] |= bytes[i] << ((i % 4) * 8);
+    words[bytes.length >>> 2] |= 0x80 << ((bytes.length % 4) * 8);
+    const bits = bytes.length * 8;
+    words[words.length - 2] = bits >>> 0;
+    words[words.length - 1] = Math.floor(bits / 2 ** 32);
+    let a0 = 0x67452301, b0 = 0xefcdab89, c0 = 0x98badcfe, d0 = 0x10325476;
+    for (let off = 0; off < words.length; off += 16) {
+        let a = a0, b = b0, c = c0, d = d0;
+        for (let i = 0; i < 64; i++) {
+            let f, g;
+            if (i < 16) {
+                f = (b & c) | (~b & d);
+                g = i;
+            }
+            else if (i < 32) {
+                f = (d & b) | (~d & c);
+                g = (5 * i + 1) % 16;
+            }
+            else if (i < 48) {
+                f = b ^ c ^ d;
+                g = (3 * i + 5) % 16;
+            }
+            else {
+                f = c ^ (b | ~d);
+                g = (7 * i) % 16;
+            }
+            const t = d;
+            d = c;
+            c = b;
+            const x = (a + f + K[i] + words[off + g]) >>> 0;
+            const s = S[(i >>> 4) * 4 + (i % 4)];
+            b = (b + ((x << s) | (x >>> (32 - s)))) >>> 0;
+            a = t;
+        }
+        a0 = (a0 + a) >>> 0;
+        b0 = (b0 + b) >>> 0;
+        c0 = (c0 + c) >>> 0;
+        d0 = (d0 + d) >>> 0;
+    }
+    return [a0, b0, c0, d0].map((w) => Array.from({ length: 4 }, (_, i) => ((w >>> (i * 8)) & 0xff).toString(16).padStart(2, '0')).join('')).join('');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xforge-dev/forge-kit",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "description": "Shared auth, app registry and UI for xForge apps",
   "license": "MIT",
   "repository": {
@@ -24,6 +24,10 @@
       "types": "./dist/client.d.ts",
       "default": "./dist/client.js"
     },
+    "./legion": {
+      "types": "./dist/legion.d.ts",
+      "default": "./dist/legion.js"
+    },
     "./server": {
       "types": "./dist/server.d.ts",
       "default": "./dist/server.js"