@futdevpro/nts-dynamo 1.15.157 → 1.15.160

package/src/_collections/load-shed.util.ts

@@ -1,51 +0,0 @@
-import * as Express from 'express';
-
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_global_settings } from './global-settings.const';
-import { DyNTS_MemoryGuard } from '../_services/core/memory-guard.service';
-
-/**
- * Auto-load-shed Express-middleware (BFR-OVERSEER-009 maradék — a MemoryGuard self-heal rétege).
- *
- * CRITICAL memória-nyomásnál (`DyNTS_MemoryGuard.shouldShedLoad()` — heap-% VAGY GC-thrash küszöb
- * felett) az új, NEM-esszenciális kéréseket gyors **503 + Retry-After**-rel ejti, mielőtt azok
- * tovább terhelnék a heap-et — a GC levegőhöz jut, a death-spiral (2026-07-05 Overseer-eset:
- * GC 100%, event-loop blokk, restart-immún wedge) megelőzhető.
- *
- * - **Opt-in:** csak `memoryGuard.loadShedEnabled: true` esetén mountolódik (ops-döntés).
- * - **Esszenciális-kivétel:** a `loadShedExemptPathParts` path-részekre (healthcheck/readiness/
- *   status/diag) SOSEM shed-el — különben a restart-policy health-probe-ját ölné meg (öngól).
- * - A shed-döntés kérésenként olcsó (in-memory pressure-olvasás, nincs I/O).
- */
-export function DyNTS_createLoadShedMiddleware(): Express.Handler {
-  const exemptParts: string[] =
-    DyNTS_global_settings.memoryGuard?.loadShedExemptPathParts ?? ['/health', '/readiness', '/status', '/diag'];
-
-  let lastShedLogAt: number = 0;
-
-  return (req: Express.Request, res: Express.Response, next: Express.NextFunction): void => {
-    // esszenciális útvonal → soha nem shed-elünk
-    if (exemptParts.some((part: string): boolean => req.path.includes(part))) {
-      next();
-      return;
-    }
-
-    if (DyNTS_MemoryGuard.getInstance().shouldShedLoad()) {
-      // log-throttle: shed-viharban sem árasztjuk el a logot (10s-enként egy jelzés)
-      const now: number = Date.now();
-      if (now - lastShedLogAt > 10000) {
-        lastShedLogAt = now;
-        DyFM_Log.warn(
-          `[load-shed] CRITICAL memory pressure — shedding non-essential requests (503). path: ${req.path}`
-        );
-      }
-
-      res.status(503).setHeader('Retry-After', '10');
-      res.send({ message: 'Server is under critical memory pressure. Retry shortly.' });
-      return;
-    }
-
-    next();
-  };
-}

package/src/_collections/mongo-reconnect-guard.util.spec.ts

@@ -1,52 +0,0 @@
-import { shouldForceMongoReconnect, MongoReconnectState } from './mongo-reconnect-guard.util';
-
-/**
- * A Mongo reconnect-guard PURE döntés-magjának unit-tesztjei. A helyesség kritikus, mert ez dönti
- * el, hogy egy futó service force-reconnectolja-e a Mongo-kapcsolatát (disconnect+connect →
- * re-resolve). Healthy connection-t SOHA nem szabad bántani; csak tartós nem-connected + grace +
- * cooldown letelt esetén szabad force-reconnectolni.
- */
-describe('| mongo-reconnect-guard shouldForceMongoReconnect', () => {
-  const base: MongoReconnectState = {
-    readyState: 0,
-    msSinceUnhealthy: 60_000,         // 60s unhealthy (a 30s grace fölött)
-    unhealthyGraceMs: 30_000,
-    reconnectInFlight: false,
-    msSinceLastReconnect: Number.POSITIVE_INFINITY,
-    reconnectCooldownMs: 20_000,
-  };
-
-  it('| connected (readyState=1) → SOHA nem reconnect (a healthy connection-t nem bántjuk)', () => {
-    expect(shouldForceMongoReconnect({ ...base, readyState: 1 }).reconnect).toBe(false);
-  });
-
-  it('| connecting (readyState=2) → nem reconnect (hagyjuk a drivert befejezni)', () => {
-    expect(shouldForceMongoReconnect({ ...base, readyState: 2 }).reconnect).toBe(false);
-  });
-
-  it('| disconnected + grace + cooldown letelt + nincs in-flight → RECONNECT', () => {
-    const d = shouldForceMongoReconnect({ ...base, readyState: 0 });
-    expect(d.reconnect).toBe(true);
-    expect(d.reason).toContain('re-resolve');
-  });
-
-  it('| disconnecting (readyState=3) ugyanígy → RECONNECT (tartós nem-connected)', () => {
-    expect(shouldForceMongoReconnect({ ...base, readyState: 3 }).reconnect).toBe(true);
-  });
-
-  it('| grace-en BELÜL → nem reconnect (hagyjuk a driver saját reconnect-jét előbb)', () => {
-    expect(shouldForceMongoReconnect({ ...base, msSinceUnhealthy: 10_000 }).reconnect).toBe(false);
-  });
-
-  it('| cooldown-on belül (frissen reconnectoltunk) → nem reconnect (anti-thrash)', () => {
-    expect(shouldForceMongoReconnect({ ...base, msSinceLastReconnect: 5_000 }).reconnect).toBe(false);
-  });
-
-  it('| már van in-flight reconnect → nem indítunk másikat', () => {
-    expect(shouldForceMongoReconnect({ ...base, reconnectInFlight: true }).reconnect).toBe(false);
-  });
-
-  it('| pontosan a grace-küszöbön (msSinceUnhealthy === grace) → RECONNECT', () => {
-    expect(shouldForceMongoReconnect({ ...base, msSinceUnhealthy: 30_000, unhealthyGraceMs: 30_000 }).reconnect).toBe(true);
-  });
-});

package/src/_collections/mongo-reconnect-guard.util.ts

@@ -1,172 +0,0 @@
-import { DyFM_Log, second } from '@futdevpro/fsm-dynamo';
-
-/**
- * DyNTS Mongo reconnect-guard (2026-06-20) — TÚLÉLI a Mongo-konténer IP-VÁLTÁSÁT.
- *
- * PROBLÉMA (élőben, 2026-06-19): a MongoDB-driver a hostnevet (`mongodb`) connect-kor EGYSZER
- * resolválja és cache-eli az IP-t (pl. 172.18.0.20); standalone-nál disconnect után UGYANAZT az
- * IP-t pingeli, NEM re-resolve-ol. Ha a Mongo-konténert recreate-elik (új docker-network IP), a
- * driver örökre a HALOTT IP-n lóg → `connect ECONNREFUSED <oldIp>:29017` + `buffering timed out`,
- * és a service magától SOHA nem áll vissza (csak külső restart-tal). Ez a 2026-06-19 incidens fél
- * test-stacket levitt (auth/ftp/helocia/futdevpro/… mind a régi Mongo-IP-n ragadt).
- *
- * MEGOLDÁS: a guard figyeli a `mongoose.connection.readyState`-et; ha TARTÓSAN nem-connected
- * (a driver saját reconnect-grace-e UTÁN is), **TELJES `disconnect()` + `connect()`-et** csinál
- * → ÚJ MongoClient → ÚJ DNS-resolve → új IP → reconnect. Így minden DyNTS_App-service magától
- * túléli a Mongo IP-váltását, KÜLSŐ beavatkozás nélkül. Best-effort, sose dob; csak konténer-IP-
- * frissítés, NEM törli/írja az adatot.
- *
- * SAFE always-on: egy app újracsatlakozása a SAJÁT DB-jéhez korrekt, nem-destruktív viselkedés
- * (nincs az infra-restart-érzékenység, ami a külső watchdog-oknál — FR-229/237). Csak akkor
- * avatkozik be, ha readyState !== 1 a grace + cooldown letelte UTÁN is; healthy connection-t (===1)
- * SOHA nem bánt.
- *
- * A döntés-mag (`shouldForceMongoReconnect`) PURE + unit-tesztelt; a futtató injektált dep-ekkel
- * dolgozik (readyState-olvasás / reconnect / log) a tesztelhetőségért.
- */
-
-/** A pure döntés inputja (minden numerikus → determinisztikus + tesztelhető). */
-export interface MongoReconnectState {
-  /** mongoose.connection.readyState: 0=disconnected, 1=connected, 2=connecting, 3=disconnecting. */
-  readyState: number;
-  /** Mióta (ms) nem-connected a readyState (0, ha épp connected). */
-  msSinceUnhealthy: number;
-  /** Grace: ennyi ideig hagyjuk a drivert SAJÁT magát visszahozni, mielőtt force-reconnectolnánk. */
-  unhealthyGraceMs: number;
-  /** Épp folyamatban van-e már egy force-reconnect (ne torlódjon). */
-  reconnectInFlight: boolean;
-  /** Mióta (ms) volt az utolsó force-reconnect (Infinity, ha még nem volt). */
-  msSinceLastReconnect: number;
-  /** Két force-reconnect közti minimum (anti-thrash). */
-  reconnectCooldownMs: number;
-}
-
-/** A pure döntés eredménye. */
-export interface MongoReconnectDecision {
-  reconnect: boolean;
-  reason: string;
-}
-
-/**
- * PURE döntés: kell-e force-reconnect. Healthy (===1) / connecting (===2) / in-flight / grace-en
- * vagy cooldown-on belül → NEM. Csak tartós nem-connected (disconnected/disconnecting) + grace és
- * cooldown letelt + nincs in-flight → IGEN.
- */
-export function shouldForceMongoReconnect(s: MongoReconnectState): MongoReconnectDecision {
-  if (s.readyState === 1) {
-    return { reconnect: false, reason: 'connected (readyState=1)' };
-  }
-  if (s.readyState === 2) {
-    return { reconnect: false, reason: 'connecting (readyState=2) — letting the driver finish' };
-  }
-  if (s.reconnectInFlight) {
-    return { reconnect: false, reason: 'a force-reconnect is already in flight' };
-  }
-  if (s.msSinceUnhealthy < s.unhealthyGraceMs) {
-    return {
-      reconnect: false,
-      reason: `unhealthy for ${Math.round(s.msSinceUnhealthy / 1000)}s (< ${Math.round(s.unhealthyGraceMs / 1000)}s grace) — letting the driver self-heal first`,
-    };
-  }
-  if (s.msSinceLastReconnect < s.reconnectCooldownMs) {
-    return {
-      reconnect: false,
-      reason: `last force-reconnect ${Math.round(s.msSinceLastReconnect / 1000)}s ago (< ${Math.round(s.reconnectCooldownMs / 1000)}s cooldown)`,
-    };
-  }
-  return {
-    reconnect: true,
-    reason: `Mongo connection unhealthy (readyState=${s.readyState}) for ${Math.round(s.msSinceUnhealthy / 1000)}s past grace — forcing disconnect+connect to re-resolve the host IP`,
-  };
-}
-
-/** Injektált függőségek a futtatóhoz (best-effort; a futtató sose dob). */
-export interface MongoReconnectGuardDeps {
-  /** A jelenlegi `mongoose.connection.readyState`. */
-  getReadyState: () => number;
-  /**
-   * Force-reconnect: `disconnect()` majd `connect(uri, opts)` — ÚJ MongoClient → ÚJ DNS-resolve.
-   * Dobhat (a connect elbukhat, ha a Mongo épp tényleg down) — a futtató elkapja.
-   */
-  reconnect: () => Promise<void>;
-  /** Log. */
-  log: (msg: string) => void;
-  /** Tick-intervallum (ms). Default 10s. */
-  intervalMs?: number;
-  /** Grace, amíg a driver saját reconnect-jét várjuk (ms). Default 30s. */
-  unhealthyGraceMs?: number;
-  /** Cooldown két force-reconnect közt (ms). Default 20s. */
-  reconnectCooldownMs?: number;
-}
-
-/**
- * Elindítja a periodikus reconnect-guard-ot. A visszaadott függvény leállítja (teszt/teardown).
- * `.unref()` — nem tartja életben az event-loop-ot.
- */
-export function startMongoReconnectGuard(deps: MongoReconnectGuardDeps): () => void {
-  const intervalMs: number = deps.intervalMs ?? 10 * second;
-  const unhealthyGraceMs: number = deps.unhealthyGraceMs ?? 30 * second;
-  const reconnectCooldownMs: number = deps.reconnectCooldownMs ?? 20 * second;
-
-  let unhealthySinceMs: number | null = null;
-  let lastReconnectAtMs: number | null = null;
-  let inFlight: boolean = false;
-  let ticking: boolean = false;
-
-  const tick = async (): Promise<void> => {
-    if (ticking) { return; }
-    ticking = true;
-    try {
-      const nowMs: number = Date.now();
-      const readyState: number = deps.getReadyState();
-
-      if (readyState === 1) {
-        if (unhealthySinceMs !== null) {
-          deps.log(`[mongo-reconnect-guard] Mongo connection healthy again (was unhealthy ${Math.round((nowMs - unhealthySinceMs) / 1000)}s)`);
-        }
-        unhealthySinceMs = null;
-        return;
-      }
-
-      // Nem-connected: indítsuk/folytassuk az unhealthy-órát.
-      if (unhealthySinceMs === null) { unhealthySinceMs = nowMs; }
-
-      const decision: MongoReconnectDecision = shouldForceMongoReconnect({
-        readyState: readyState,
-        msSinceUnhealthy: nowMs - unhealthySinceMs,
-        unhealthyGraceMs: unhealthyGraceMs,
-        reconnectInFlight: inFlight,
-        msSinceLastReconnect: lastReconnectAtMs === null ? Number.POSITIVE_INFINITY : nowMs - lastReconnectAtMs,
-        reconnectCooldownMs: reconnectCooldownMs,
-      });
-
-      if (!decision.reconnect) { return; }
-
-      deps.log(`[mongo-reconnect-guard] ${decision.reason}`);
-      inFlight = true;
-      lastReconnectAtMs = nowMs;
-      try {
-        await deps.reconnect();
-        deps.log('[mongo-reconnect-guard] force-reconnect dispatched ✓ (re-resolved host; awaiting connection open)');
-      } catch (e: unknown) {
-        // A connect elbukhat, ha a Mongo épp tényleg elérhetetlen — nem baj, a következő tick
-        // (cooldown után) újrapróbál; amint a Mongo új IP-n elérhető, a re-resolve becsatlakozik.
-        deps.log(`[mongo-reconnect-guard] force-reconnect attempt failed (will retry after cooldown): ${e instanceof Error ? e.message : String(e)}`);
-      } finally {
-        inFlight = false;
-      }
-    } catch (e: unknown) {
-      deps.log(`[mongo-reconnect-guard] tick error (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
-    } finally {
-      ticking = false;
-    }
-  };
-
-  const handle: NodeJS.Timeout = setInterval((): void => { void tick(); }, intervalMs);
-  if (typeof handle.unref === 'function') { handle.unref(); }
-  DyFM_Log.info(
-    `[mongo-reconnect-guard] started — check every ${Math.round(intervalMs / 1000)}s, `
-    + `force disconnect+reconnect after ${Math.round(unhealthyGraceMs / 1000)}s sustained-unhealthy (re-resolves host IP), cooldown ${Math.round(reconnectCooldownMs / 1000)}s`,
-  );
-  return (): void => { clearInterval(handle); };
-}

package/src/_collections/npm-token-check.util.spec.ts

@@ -1,218 +0,0 @@
-import {
-  classifyNpmTokenProbe,
-  extractTokenFromNpmrc,
-  classifyNpmTokenShape,
-  describeNpmTokenState,
-  DyNTS_NpmTokenShape,
-  DyNTS_NpmTokenState,
-} from './npm-token-check.util';
-
-/**
- * FR-320 spec — npm-token allapot-osztalyozo.
- *
- * MIERT SZAMIT (2026-08-20..22, valos incidens): a flotta npm-tokenje lejart, majd egy 2FA-bypass
- * jog NELKULI pot-token kerult be. A kovetkezmeny NAPOKIG tartott, es MINDENHOL `E404`-kent
- * jelentkezett — privat csomagnal ugyanis az npm a jogosulatlan kerest 404-gyel utasitja el, NEM
- * 401-gyel. Igy a "nincs ilyen csomag", a "lejart kulcs" es a "rossz jogu kulcs"
- * MEGKULONBOZTETHETETLEN volt.
- *
- * A kulcs-diszkriminator a `/-/whoami`: az NEM csomag-fuggo, ezert nem esik bele a privat-404
- * elrejtesbe.
- */
-describe('| FR-320 — npm-token allapot-osztalyozo', () => {
-
-  describe('| alak-ellenorzes (halozat NELKUL)', () => {
-    it('| ures / hianyzo ertek -> missing', () => {
-      expect(classifyNpmTokenShape(undefined)).toBe(DyNTS_NpmTokenShape.missing);
-      expect(classifyNpmTokenShape(null)).toBe(DyNTS_NpmTokenShape.missing);
-      expect(classifyNpmTokenShape('')).toBe(DyNTS_NpmTokenShape.missing);
-      expect(classifyNpmTokenShape('   ')).toBe(DyNTS_NpmTokenShape.missing);
-    });
-
-    /** A leggyakoribb operatori hiba: a TELJES .npmrc-sor kerul a token helyere. */
-    it('| a bemasolt .npmrc-sor -> malformed', () => {
-      expect(classifyNpmTokenShape('//registry.npmjs.org/:_authToken=npm_abcdefghijklmnopqrstuvwxyz'))
-        .toBe(DyNTS_NpmTokenShape.malformed);
-    });
-
-    it('| bennragadt idezojel / whitespace -> malformed', () => {
-      expect(classifyNpmTokenShape('"npm_abcdefghijklmnopqrstuvwxyz"')).toBe(DyNTS_NpmTokenShape.malformed);
-      expect(classifyNpmTokenShape('npm_abcdefghij klmnopqrstuvwxyz')).toBe(DyNTS_NpmTokenShape.malformed);
-    });
-
-    it('| nyilvanvaloan tul rovid ertek -> malformed', () => {
-      expect(classifyNpmTokenShape('changeme')).toBe(DyNTS_NpmTokenShape.malformed);
-    });
-
-    /**
-     * A regi, prefix NELKULI (UUID-alaku) tokenek MEG ervenyesek lehetnek. Inkabb engedjunk at egy
-     * kesobb 401-et kapo tokent, mint hogy egy jot elutasitsunk helyi heurisztikaval.
-     */
-    it('| npm_ prefixu ES prefix nelkuli hosszu ertek is plausible', () => {
-      expect(classifyNpmTokenShape('npm_0123456789abcdefghijklmnopqrstuvwxyz')).toBe(DyNTS_NpmTokenShape.plausible);
-      expect(classifyNpmTokenShape('01234567-89ab-cdef-0123-456789abcdef')).toBe(DyNTS_NpmTokenShape.plausible);
-    });
-  });
-
-  describe('| halozati osztalyozas', () => {
-    it('| 401 -> invalid (lejart / visszavont / rossz)', () => {
-      expect(classifyNpmTokenProbe({ whoamiStatus: 401 })).toBe(DyNTS_NpmTokenState.invalid);
-    });
-
-    /**
-     * A LENYEGI allitas: elo token (whoami 200) + scope-olt csomag 404 -> NEM "nincs ilyen csomag",
-     * hanem JOGOSULTSAG-hiany. Pontosan ez volt megkulonboztethetetlen az incidensben.
-     */
-    it('| elo token + csomag-404 -> no-scope-access (NEM invalid, NEM hianyzo csomag)', () => {
-      expect(classifyNpmTokenProbe({ whoamiStatus: 200, scopedPackageStatus: 404 }))
-        .toBe(DyNTS_NpmTokenState.noScopeAccess);
-      expect(classifyNpmTokenProbe({ whoamiStatus: 200, scopedPackageStatus: 403 }))
-        .toBe(DyNTS_NpmTokenState.noScopeAccess);
-    });
-
-    it('| elo token + csomag-200 -> ok', () => {
-      expect(classifyNpmTokenProbe({ whoamiStatus: 200, scopedPackageStatus: 200 }))
-        .toBe(DyNTS_NpmTokenState.ok);
-    });
-
-    it('| csomag-proba nelkul, elo tokennel -> ok', () => {
-      expect(classifyNpmTokenProbe({ whoamiStatus: 200 })).toBe(DyNTS_NpmTokenState.ok);
-    });
-
-    /** A 2FA-bypass hianya read-only probaval NEM latszik — csak egy mar elbukott publishbol. */
-    it('| elo token + EOTP publish-hiba -> missing-publish-right (a 2FA-bypass hianya)', () => {
-      expect(classifyNpmTokenProbe({ whoamiStatus: 200, publishErrorCode: 'EOTP' }))
-        .toBe(DyNTS_NpmTokenState.missingPublishRight);
-    });
-
-    /**
-     * NEGATIV allitas, ami a legfontosabb: ha a proba EL SEM JUTOTT a registryig, akkor NEM
-     * mondhatjuk, hogy a token rossz. A meres hianya nem bizonyitek.
-     */
-    it('| elerhetetlen registry -> unknown, NEM invalid', () => {
-      expect(classifyNpmTokenProbe({ whoamiStatus: null })).toBe(DyNTS_NpmTokenState.unknown);
-      expect(classifyNpmTokenProbe({ whoamiStatus: null })).not.toBe(DyNTS_NpmTokenState.invalid);
-    });
-
-    it('| 5xx / rate-limit -> unknown (nem allitunk semmit a tokenrol)', () => {
-      expect(classifyNpmTokenProbe({ whoamiStatus: 500 })).toBe(DyNTS_NpmTokenState.unknown);
-      expect(classifyNpmTokenProbe({ whoamiStatus: 429 })).toBe(DyNTS_NpmTokenState.unknown);
-    });
-  });
-
-  describe('| magyarazat', () => {
-    it('| MINDEN allapothoz ad kovetkezo-lepest', () => {
-      for (const state of Object.values(DyNTS_NpmTokenState)) {
-        const text: string = describeNpmTokenState(state);
-        expect(text.length).toBeGreaterThan(20);
-      }
-    });
-
-    /** Az `invalid` magyarazatnak KI KELL MONDANIA a 404-es elrejtest — ez vitte felre a diagnozist. */
-    it('| az invalid magyarazata figyelmeztet, hogy a hivoknal 404-kent latszik', () => {
-      expect(describeNpmTokenState(DyNTS_NpmTokenState.invalid)).toContain('404');
-    });
-
-    it('| a missing-publish-right magyarazata megnevezi a 2FA-bypass-t', () => {
-      expect(describeNpmTokenState(DyNTS_NpmTokenState.missingPublishRight)).toContain('2FA-bypass');
-    });
-  });
-});
-
-
-/**
- * FR-320b spec — a token FAJLBOL is feloldhato.
- *
- * MIERT (a sajat elso valtozatom hibaja): a util eloszor CSAK a `process.env.NPM_TOKEN`-t nezte, es
- * ezert a workstationomon `missing`-et adott — HOLOTT az npm ott mukodott, mert a token a
- * `~/.npmrc`-ben all. Ez HAMIS NEGATIV, es epp a legfontosabb helyeken (runner-kontener, hosztok)
- * sult volna el, ahol a token szinten FAJLBAN van.
- *
- * A `.npmrc`-t csak OLVASSUK — letrehozni tilos (flotta-szintu hard rule).
- */
-describe('| FR-320b — token kinyerese .npmrc-bol', () => {
-
-  it('| a valodi .npmrc-alakbol kinyeri az erteket', () => {
-    const content: string = '//registry.npmjs.org/:_authToken=npm_0123456789abcdefghijklmnop';
-    expect(extractTokenFromNpmrc(content)).toBe('npm_0123456789abcdefghijklmnop');
-  });
-
-  it('| tobbsoros fajlbol a MEGFELELO registry sorat valasztja', () => {
-    const content: string = [
-      '# megjegyzes',
-      '//npm.pkg.github.com/:_authToken=github_masik_token_ertek',
-      '//registry.npmjs.org/:_authToken=npm_ez_a_helyes_ertek_1234',
-      'engine-strict=true',
-    ].join('\n');
-    expect(extractTokenFromNpmrc(content)).toBe('npm_ez_a_helyes_ertek_1234');
-  });
-
-  it('| a bennragadt idezojeleket levagja', () => {
-    expect(extractTokenFromNpmrc('//registry.npmjs.org/:_authToken="npm_idezojelben_1234567890"'))
-      .toBe('npm_idezojelben_1234567890');
-  });
-
-  /** NEGATIV: ne talaljunk ki tokent ott, ahol nincs. */
-  it('| token nelkuli / megjegyzett tartalomra null', () => {
-    expect(extractTokenFromNpmrc('engine-strict=true')).toBeNull();
-    expect(extractTokenFromNpmrc('# //registry.npmjs.org/:_authToken=npm_megjegyzesben')).toBeNull();
-    expect(extractTokenFromNpmrc('')).toBeNull();
-  });
-
-  it('| MAS registry sorat NEM veszi el', () => {
-    expect(extractTokenFromNpmrc('//npm.pkg.github.com/:_authToken=github_token_ertek_123456')).toBeNull();
-  });
-});
-
-
-/**
- * FR-320c spec — ELO token mellett a publish-oldali hiba MINDIG jogosultsag-hiany.
- *
- * MERVE (2026-08-22, valos publish-kimenet):
- *   `npm error 404 Not Found - PUT https://registry.npmjs.org/@futdevpro%2fnts-dynamo`
- * — MIKOZBEN ugyanaz a token OLVASNI tudta a csomagot (a runner registry-auth probaja OK volt).
- *
- * Az npm a PUT-ra is 404-gyel valaszol, ha nincs IRASI jog (letezes-elrejtes). Enelkul a
- * megkulonboztetes nelkul ez "nincs ilyen csomag"-nak latszik — es epp ez vitte felre a diagnozist.
- */
-describe('| FR-320c — publish-oldali hibak elo token mellett', () => {
-
-  it('| EOTP -> missing-publish-right (2FA-bypass)', () => {
-    expect(classifyNpmTokenProbe({ whoamiStatus: 200, publishErrorCode: 'EOTP' }))
-      .toBe(DyNTS_NpmTokenState.missingPublishRight);
-  });
-
-  it('| E403 -> missing-publish-right', () => {
-    expect(classifyNpmTokenProbe({ whoamiStatus: 200, publishErrorCode: 'E403' }))
-      .toBe(DyNTS_NpmTokenState.missingPublishRight);
-  });
-
-  /** A LENYEGI uj eset: PUT-ra kapott 404 elo tokennel = nincs irasi jog, NEM hianyzo csomag. */
-  it('| E404 elo tokennel -> missing-publish-right, NEM hianyzo csomag', () => {
-    expect(classifyNpmTokenProbe({ whoamiStatus: 200, publishErrorCode: 'E404' }))
-      .toBe(DyNTS_NpmTokenState.missingPublishRight);
-  });
-
-  it('| kisbetus hibakodot is felismer', () => {
-    expect(classifyNpmTokenProbe({ whoamiStatus: 200, publishErrorCode: 'e404' }))
-      .toBe(DyNTS_NpmTokenState.missingPublishRight);
-  });
-
-  /** NEGATIV: publish-hiba NELKUL, olvasassal egyutt tovabbra is `ok`. */
-  it('| publish-hiba nelkul tovabbra is ok', () => {
-    expect(classifyNpmTokenProbe({ whoamiStatus: 200, scopedPackageStatus: 200 }))
-      .toBe(DyNTS_NpmTokenState.ok);
-  });
-
-  /** NEGATIV: HALOTT token mellett a publish-hiba NEM minositheto jog-hianynak. */
-  it('| 401-es tokennel a publish-hiba NEM missing-publish-right, hanem invalid', () => {
-    expect(classifyNpmTokenProbe({ whoamiStatus: 401, publishErrorCode: 'E404' }))
-      .toBe(DyNTS_NpmTokenState.invalid);
-  });
-
-  it('| a magyarazat KIMONDJA, hogy a PUT-404 nem hianyzo csomag', () => {
-    const text: string = describeNpmTokenState(DyNTS_NpmTokenState.missingPublishRight);
-    expect(text).toContain('404');
-    expect(text).toContain('NEM hianyzo csomagot');
-  });
-});