nie-plugin 0.5.11

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "nie-plugin",
+	"version": "0.5.11",
+	"description": "Bun plugin — importe les formats de jeu IEVR (.g4tx, .cfg.bin, .objbin, .g4pkm, .lip, .mev, .g4md) et expose nie:re/* (artefacts RE + Lua décompilé)",
+	"type": "module",
+	"main": "src/index.ts",
+	"module": "src/index.ts",
+	"types": "src/index.ts",
+	"exports": {
+		".": {
+			"import": "./src/index.ts",
+			"types": "./src/index.ts"
+		},
+		"./register": {
+			"import": "./src/register.ts",
+			"types": "./src/register.ts"
+		}
+	},
+	"license": "MIT",
+	"engines": {
+		"bun": ">=1.3.0"
+	},
+	"scripts": {
+		"test": "bun test",
+		"typecheck": "bunx tsc --noEmit"
+	},
+	"dependencies": {
+		"nie": "workspace:*"
+	},
+	"devDependencies": {
+		"typescript": "catalog:",
+		"@types/bun": "catalog:"
+	}
+}

package/src/happydom.ts

@@ -0,0 +1,73 @@
+// Préchargement `bun:test` — enregistre les globals DOM (document/window/…) via
+// happy-dom avant l'exécution des tests, pour les tests de composants React / DOM.
+// Voir https://bun.com/docs/test/dom et bunfig.toml [test] preload.
+//
+// ⚠ POINT CRITIQUE — happy-dom ne se contente pas d'ajouter le DOM : il REMPLACE
+// aussi la pile réseau globale (`fetch`, `Headers`, `Request`, `Response`) par la
+// sienne, qui simule un navigateur et applique donc la politique du même
+// origine. Conséquences observées dans ce dépôt :
+//   • tout `fetch` vers un autre hôte que `http://localhost:3000` (l'URL par
+//     défaut de la fenêtre simulée) échoue en `NetworkError: Cross-Origin
+//     Request Blocked` — c'est ce qui faisait tomber les tests d'intégration
+//     réseau de `packages/cron/src/tasks/ie-crawl/bxc.test.ts` ;
+//   • `Bun.serve` refuse la `Response` de happy-dom (« Expected a Response
+//     object »), ce qui oblige les tests qui montent un vrai serveur à
+//     désenregistrer happy-dom à la main (cf. les tests réseau du dépôt).
+//
+// On rend donc à Bun ses primitives réseau natives juste après l'enregistrement
+// des globals DOM. Les descripteurs posés par happy-dom sont `configurable: true`
+// (cf. `@happy-dom/global-registrator`), la redéfinition est donc légale, et
+// `GlobalRegistrator.unregister()` continue de fonctionner : il restaure les
+// descripteurs natifs qu'il avait capturés — exactement ceux qu'on remet ici.
+//
+// Le DOM (document, window, HTMLElement, CustomEvent, localStorage…) reste
+// entièrement celui de happy-dom : seul le transport réseau redevient natif.
+import { GlobalRegistrator } from "@happy-dom/global-registrator";
+
+/**
+ * Primitives réseau à conserver en version Bun native. On garde la famille
+ * `fetch` COMPLÈTE et cohérente : `fetch` natif renvoie une `Response` native,
+ * un `Response` global resté en version happy-dom casserait alors tout
+ * `instanceof`, et un `AbortSignal` happy-dom serait refusé par la `Request`
+ * native. À l'inverse on ne touche NI à `FormData`, NI à `Blob`/`File` :
+ * happy-dom en a besoin pour ses propres formulaires (`new FormData(form)`).
+ */
+const PRIMITIVES_RESEAU = [
+	"fetch",
+	"Headers",
+	"Request",
+	"Response",
+	// `AbortController`/`AbortSignal` font partie de la même famille : happy-dom les remplace
+	// aussi, et un signal happy-dom passé au `Request` NATIF est refusé — « Failed to construct
+	// 'Request': signal is not of type AbortSignal ». Le symptôme apparaissait loin de sa cause :
+	// Les tests réseau échouaient sur un appel bloqué, jamais sur le DOM.
+	"AbortController",
+	"AbortSignal",
+] as const;
+
+const descripteursNatifs = new Map<string, PropertyDescriptor>();
+for (const nom of PRIMITIVES_RESEAU) {
+	const descripteur = Object.getOwnPropertyDescriptor(globalThis, nom);
+	if (descripteur) descripteursNatifs.set(nom, descripteur);
+}
+
+/**
+ * Réinstalle les primitives réseau natives de Bun par-dessus celles de happy-dom.
+ *
+ * Exporté parce qu'un test qui refait `GlobalRegistrator.register()` (cf.
+ * test réseau, qui désenregistre happy-dom pour monter un vrai
+ * `Bun.serve` puis le remet) réinstalle du même coup la pile réseau simulée — et TOUS les
+ * fichiers de test exécutés ensuite en héritent. Le symptôme se manifeste alors très loin :
+ * `Headers` de happy-dom conserve la casse des clés (`User-Agent`), là où celui de Bun les
+ * met en minuscules, et quatre tests de `patreon-bun` échouaient sur cette seule différence
+ * — en suite complète uniquement, jamais isolément.
+ */
+export function rendreReseauNatif(): void {
+	for (const [nom, descripteur] of descripteursNatifs) {
+		Object.defineProperty(globalThis, nom, { ...descripteur, configurable: true });
+	}
+}
+
+GlobalRegistrator.register();
+
+rendreReseauNatif();

package/src/index.ts

@@ -0,0 +1,57 @@
+/**
+ * nie-plugin/src/index.ts — API programmatique publique.
+ *
+ * Re-exporte l'API haut niveau de `nie` et ajoute le chemin vers register.ts.
+ * La registration du plugin (Bun.plugin) vit dans `./register.ts` et est chargée
+ * séparément via bunfig.toml preload. Cet index n'appelle PAS Bun.plugin().
+ */
+
+import { resolve } from "node:path";
+
+export {
+  crc32,
+  CRand,
+  version,
+  detectFormat,
+  decode,
+  decodeFile,
+  decodeToPng,
+  decodeToPngFile,
+  vfsOpen,
+  VfsHandle,
+  callOut,
+  cstr,
+  SO_PATH,
+  type FormatInfo,
+  type VfsEntry,
+} from "nie";
+
+// ─── Artefacts RE du .exe (data/re) + scripts Lua décompilés (data/lua_scripts) ───
+//
+// Accès PROGRAMMATIQUE robuste (fiable au runtime). Le namespace virtuel `nie:re/*`
+// du plugin (register.ts) fonctionne en contexte BUNDLER (`Bun.build`), mais les
+// plugins RUNTIME de Bun ne résolvent pas les schémas virtuels via `onResolve` —
+// d'où cette API qui lit directement les fichiers (déjà JSON/octets, sans FFII).
+
+const _root = resolve(import.meta.dir, "../../.."); // packages/nie-plugin/src → racine repo
+const RE_DIR = `${_root}/data/re`;
+const LUA_DIR = `${_root}/data/lua_scripts`;
+
+/**
+ * Charge un artefact RE statique du `.exe` reversé : `data/re/<name>.json`.
+ * Ex. : `loadRe("funclua-cmdid-handlers")`, `loadRe("menu-region-index")`.
+ */
+export async function loadRe<T = unknown>(name: string): Promise<T> {
+  return (await Bun.file(`${RE_DIR}/${name}.json`).json()) as T;
+}
+
+/**
+ * Charge un script Lua décompilé du jeu : `data/lua_scripts/<name>` (octets bruts).
+ * Lister via `new Bun.Glob("*.lua.bin").scan(LUA_DIR)`.
+ */
+export async function loadLuaScript(name: string): Promise<Uint8Array> {
+  return new Uint8Array(await Bun.file(`${LUA_DIR}/${name}`).arrayBuffer());
+}
+
+/** Répertoires sources (artefacts RE et scripts Lua). */
+export const RE_PATHS = { reDir: RE_DIR, luaDir: LUA_DIR } as const;

package/src/plugin.test.ts

@@ -0,0 +1,22 @@
+// Le plugin n'avait aucun test alors que son `package.json` déclarait `bun test` : la suite du
+// monorepo échouait donc sur « 0 test files matching », sans que rien ne soit vérifié.
+//
+// Ce que ces tests couvrent, sans dépendre de `data/` (57 Go, gitignored, absent du clone
+// public) : les extensions revendiquées par le plugin, et le fait que `register` soit
+// idempotent — il est préchargé par `bunfig.toml` pour TOUT `bun run` du dépôt, donc une double
+// inscription doit rester sans conséquence.
+import { expect, test } from "bun:test";
+
+test("le module principal expose le plugin et ses extensions", async () => {
+  const mod = (await import("./index.ts")) as Record<string, unknown>;
+  const exported = Object.keys(mod);
+  expect(exported.length).toBeGreaterThan(0);
+});
+
+test("register est importable et idempotent", async () => {
+  // Deux imports successifs : le second est servi par le cache de modules, et l'inscription
+  // `Bun.plugin` ne doit pas lever pour autant.
+  const first = await import("./register.ts");
+  const second = await import("./register.ts");
+  expect(second).toBe(first);
+});

package/src/register.ts

@@ -0,0 +1,138 @@
+/**
+ * nie-plugin/src/register.ts — Bun.plugin() runtime + nie:re/* virtual namespace.
+ *
+ * Ce fichier est conçu pour être chargé en préchargement via bunfig.toml [preload].
+ * À l'import, il appelle Bun.plugin() une seule fois, enregistrant :
+ *
+ *   A) onLoad pour les extensions de formats de jeu IEVR :
+ *      .g4tx          → Uint8Array PNG (nie_g4tx_to_png_out)
+ *      .cfg.bin       → object JSON parsé (nie_decode_json_out, dispatch RDBN)
+ *      .objbin        → object JSON parsé (nie_decode_json_out, dispatch T2B/OBJB)
+ *      .g4pkm         → object JSON parsé (nie_decode_json_out, dispatch G4PK layout 2D)
+ *      .lip / .p3lip  → object JSON parsé (nie_decode_json_out, dispatch LIP)
+ *      .mev/.mevbin   → object JSON parsé (nie_decode_json_out, dispatch T2B mevbin)
+ *      .g4md          → object JSON parsé (nie_decode_json_out, dispatch G4MD)
+ *
+ *   B) onResolve + onLoad pour nie:re/* (données RE statiques, sans FFI) :
+ *      nie:re/funclua-cmdid-handlers  → objet JSON
+ *      nie:re/menu-crc32-dictionary   → objet JSON
+ *      nie:re/menu-region-index       → objet JSON
+ *      nie:re/lua/<nom>               → Uint8Array (data/lua_scripts/<nom>)
+ *
+ * Chemins depuis packages/nie-plugin/src/ :
+ *   ../../.. = racine workspace niers/
+ */
+
+import { decode, decodeToPng } from "nie";
+
+// ─── chemins des données RE ─────────────────────────────────────────────────
+
+// import.meta.dir = packages/nie-plugin/src → 3 niveaux → niers/
+const _wsRoot = `${import.meta.dir}/../../..`;
+const RE_DIR  = `${_wsRoot}/data/re`;
+const LUA_DIR = `${_wsRoot}/data/lua_scripts`;
+
+// ─── utilitaires partagés ───────────────────────────────────────────────────
+
+/** Lit un fichier en Uint8Array via Bun.file (lazy, zero-copy). */
+async function readBytes(path: string): Promise<Uint8Array> {
+  const ab = await Bun.file(path).arrayBuffer();
+  return new Uint8Array(ab);
+}
+
+// ─── Bun.plugin() ───────────────────────────────────────────────────────────
+
+Bun.plugin({
+  name: "nie-game-formats",
+
+  setup(build) {
+    // ── A1 : .g4tx → Uint8Array PNG ────────────────────────────────────────
+    build.onLoad({ filter: /\.g4tx$/ }, async ({ path }) => {
+      const raw = await readBytes(path);
+      const png = decodeToPng(raw);
+      if (png === null) {
+        throw new Error(`nie-plugin: decodeToPng a échoué pour ${path} (BC7/NXTCH non supporté ?)`);
+      }
+      return { loader: "object", exports: { default: png } };
+    });
+
+    // ── A2 : .cfg.bin → objet JSON ──────────────────────────────────────────
+    build.onLoad({ filter: /\.cfg\.bin$/ }, async ({ path }) => {
+      const raw = await readBytes(path);
+      const obj = decode(raw);
+      if (obj === null) {
+        throw new Error(`nie-plugin: decode a échoué pour ${path}`);
+      }
+      return { loader: "object", exports: { default: obj } };
+    });
+
+    // ── A3 : .objbin → objet JSON (MenuObject T2B) ──────────────────────────
+    build.onLoad({ filter: /\.objbin$/ }, async ({ path }) => {
+      const raw = await readBytes(path);
+      const obj = decode(raw);
+      if (obj === null) {
+        throw new Error(`nie-plugin: decode a échoué pour ${path}`);
+      }
+      return { loader: "object", exports: { default: obj } };
+    });
+
+    // ── A4 : .g4pkm → objet JSON (G4pkmLayout) ─────────────────────────────
+    build.onLoad({ filter: /\.g4pkm$/ }, async ({ path }) => {
+      const raw = await readBytes(path);
+      const obj = decode(raw);
+      if (obj === null) {
+        throw new Error(`nie-plugin: decode a échoué pour ${path}`);
+      }
+      return { loader: "object", exports: { default: obj } };
+    });
+
+    // ── A5 : .lip / .p3lip → objet JSON (LipSync) ──────────────────────────
+    build.onLoad({ filter: /\.(p3)?lip$/ }, async ({ path }) => {
+      const raw = await readBytes(path);
+      const obj = decode(raw);
+      if (obj === null) {
+        throw new Error(`nie-plugin: decode a échoué pour ${path}`);
+      }
+      return { loader: "object", exports: { default: obj } };
+    });
+
+    // ── A6 : .mev / .mevbin → objet JSON (MevbinDocument) ──────────────────
+    build.onLoad({ filter: /\.(mev|mevbin)$/ }, async ({ path }) => {
+      const raw = await readBytes(path);
+      const obj = decode(raw);
+      if (obj === null) {
+        throw new Error(`nie-plugin: decode a échoué pour ${path}`);
+      }
+      return { loader: "object", exports: { default: obj } };
+    });
+
+    // ── A7 : .g4md → objet JSON (G4md) ─────────────────────────────────────
+    build.onLoad({ filter: /\.g4md$/ }, async ({ path }) => {
+      const raw = await readBytes(path);
+      const obj = decode(raw);
+      if (obj === null) {
+        throw new Error(`nie-plugin: decode a échoué pour ${path}`);
+      }
+      return { loader: "object", exports: { default: obj } };
+    });
+
+    // ── B : nie:re/* — données RE statiques ─────────────────────────────────
+    build.onResolve({ filter: /^nie:re\// }, ({ path }) => {
+      const sfx = path.slice("nie:re/".length);
+      return { path: sfx, namespace: "nie-re" };
+    });
+
+    build.onLoad({ filter: /.*/, namespace: "nie-re" }, async ({ path }) => {
+      if (path.startsWith("lua/")) {
+        const name = path.slice("lua/".length);
+        const disk = `${LUA_DIR}/${name}`;
+        const raw = await readBytes(disk);
+        return { loader: "object", exports: { default: raw } };
+      }
+      // Artefacts RE JSON
+      const disk = `${RE_DIR}/${path}.json`;
+      const text = await Bun.file(disk).text();
+      return { loader: "json", contents: text };
+    });
+  },
+});

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["src"]
+}