@zarex/next 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kodjogbe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,116 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CLOUDFLARE_RANGES: () => import_core2.CLOUDFLARE_RANGES,
+  PRIVATE_NETWORKS: () => import_core2.PRIVATE_NETWORKS,
+  createZarex: () => import_core2.createZarex,
+  detectBot: () => import_core2.detectBot,
+  emailValidation: () => import_core2.emailValidation,
+  phoneValidation: () => import_core2.phoneValidation,
+  promptInjection: () => import_core2.promptInjection,
+  rateLimit: () => import_core2.rateLimit,
+  requestFilter: () => import_core2.requestFilter,
+  secureHeaders: () => import_core2.secureHeaders,
+  sensitiveInfo: () => import_core2.sensitiveInfo,
+  shield: () => import_core2.shield,
+  tokenBucket: () => import_core2.tokenBucket,
+  withSecureHeaders: () => import_core2.withSecureHeaders,
+  withZarex: () => withZarex,
+  zarexNext: () => zarexNext
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@zarex/core");
+var import_core2 = require("@zarex/core");
+function build(options, extra) {
+  const isInstance = typeof options.protect === "function";
+  return isInstance ? { instance: options, opts: extra } : { instance: (0, import_core.createZarex)(options), opts: options };
+}
+function callOf(opts, request) {
+  try {
+    return opts.call?.(request);
+  } catch {
+    return void 0;
+  }
+}
+function buildGuard(options, extra, warnAboutMiddlewareFinalize) {
+  const { instance, opts } = build(options, extra);
+  const finalizer = (0, import_core.createWebFinalizer)({ secureHeaders: opts.secureHeaders, responseGuard: opts.responseGuard });
+  if (finalizer && warnAboutMiddlewareFinalize) {
+    console.warn(
+      "[zarex] next: `secureHeaders`/`responseGuard` is configured. In middleware.ts, call `guard.finalize(NextResponse.next(), request)` on the ALLOWED path too (not just on a denial) \u2014 otherwise it is never applied to allowed traffic: return (await guard(request)) ?? guard.finalize(NextResponse.next(), request)."
+    );
+  }
+  const finalize = async (response, request) => {
+    try {
+      return finalizer ? await finalizer(response, request) : response;
+    } catch {
+      return response;
+    }
+  };
+  async function guard(request) {
+    try {
+      const call = callOf(opts, request);
+      const { deny } = await (0, import_core.guardWebRequest)(instance, request, {
+        ...opts.inspectBody ? { inspectBody: true } : {},
+        ...opts.onDeny ? { onDeny: opts.onDeny } : {},
+        ...opts.onDegraded ? { onDegraded: opts.onDegraded } : {},
+        ...call ? { call } : {}
+      });
+      return deny ? await finalize(deny, request) : null;
+    } catch {
+      return null;
+    }
+  }
+  return Object.assign(guard, { finalize });
+}
+function zarexNext(options, extra = {}) {
+  return buildGuard(options, extra, true);
+}
+function withZarex(options, handler, extra = {}) {
+  const guard = buildGuard(options, extra, false);
+  return async (request, ...args) => {
+    const denied = await guard(request);
+    if (denied) return denied;
+    const out = await handler(request, ...args);
+    return out instanceof Response ? await guard.finalize(out, request) : out;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLOUDFLARE_RANGES,
+  PRIVATE_NETWORKS,
+  createZarex,
+  detectBot,
+  emailValidation,
+  phoneValidation,
+  promptInjection,
+  rateLimit,
+  requestFilter,
+  secureHeaders,
+  sensitiveInfo,
+  shield,
+  tokenBucket,
+  withSecureHeaders,
+  withZarex,
+  zarexNext
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { createWebFinalizer, createZarex, guardWebRequest, type ResponseGuardOptions, type SecureHeadersOptions, type Decision, type ProtectCall, type WebGuardOptions, type Zarex, type ZarexOptions } from \"@zarex/core\";\r\n\r\n/**\r\n * Next.js — fonctionne dans le middleware (runtime edge) ET dans les route handlers.\r\n * Aucune importation de `next` : on utilise la `Request` standard, donc aucun risque de\r\n * version incompatible et rien de propre à Node dans le middleware.\r\n *\r\n *   // middleware.ts\r\n *   import { NextResponse } from \"next/server\";\r\n *   import { zarexNext, shield, rateLimit } from \"@zarex/next\";\r\n *   const guard = zarexNext({ key: process.env.ZAREX_KEY!, baseUrl: process.env.ZAREX_URL!, ipSource: \"vercel\",\r\n *                             rules: [shield(), rateLimit({ max: 100, window: \"1m\" })] });\r\n *   export async function middleware(request: Request) {\r\n *     // guard.finalize(...) sur la réponse autorisée AUSSI, pas seulement sur un refus : sans cet appel,\r\n *     // `secureHeaders`/`responseGuard` ne s'appliqueraient JAMAIS au trafic autorisé (trouvé lors de\r\n *     // l'audit du 04-05/11/2026 — `guard()` ne peut pas le faire elle-même : importer next/server ici\r\n *     // romprait la garantie « aucune dépendance à next » de ce fichier, voir l'en-tête ci-dessus).\r\n *     return (await guard(request)) ?? guard.finalize(NextResponse.next(), request);\r\n *   }\r\n *\r\n * LIMITE IMPORTANTE : le middleware Next.js ne voit pas l'adresse de la connexion TCP. Seules les sources\r\n * qui lisent un en-tête posé par la plateforme fonctionnent donc : \"vercel\", \"fly\", \"auto\". Hébergé ailleurs\r\n * (nginx, Docker…), utilisez un route handler avec `withZarex` n'y change rien non plus : voir la documentation.\r\n */\r\nexport interface NextZarexOptions extends ZarexOptions {\r\n  inspectBody?: boolean;\r\n  /** En-têtes de sécurité (true = défauts prudents). Voir `guard.finalize` pour le middleware. */\r\n  secureHeaders?: SecureHeadersOptions | boolean;\r\n  /** Surveille les réponses des route handlers (withZarex) : masque les cartes bancaires, clés d'API, etc. */\r\n  responseGuard?: ResponseGuardOptions | boolean;\r\n  onDeny?: WebGuardOptions[\"onDeny\"];\r\n  onDegraded?: WebGuardOptions[\"onDegraded\"];\r\n  /** Identifiants / jetons propres à chaque requête (ex. userId). Une erreur dans cette fonction est ignorée. */\r\n  call?: (request: Request) => ProtectCall | undefined;\r\n}\r\ntype Extra = Pick<NextZarexOptions, \"inspectBody\" | \"onDeny\" | \"onDegraded\" | \"call\" | \"secureHeaders\" | \"responseGuard\">;\r\n\r\nexport type NextGuard = ((request: Request) => Promise<Response | null>) & {\r\n  /** Ajoute les en-têtes de sécurité (et surveille la réponse) : `return guard.finalize(NextResponse.next(), request)`. */\r\n  finalize(response: Response, request?: Request): Promise<Response>;\r\n};\r\n\r\nfunction build(options: NextZarexOptions | Zarex, extra: Extra): { instance: Zarex; opts: Extra } {\r\n  const isInstance = typeof (options as Zarex).protect === \"function\";\r\n  return isInstance\r\n    ? { instance: options as Zarex, opts: extra }\r\n    : { instance: createZarex(options as NextZarexOptions), opts: options as NextZarexOptions };\r\n}\r\n\r\nfunction callOf(opts: Extra, request: Request): ProtectCall | undefined {\r\n  try {\r\n    return opts.call?.(request);\r\n  } catch {\r\n    return undefined;\r\n  }\r\n}\r\n\r\n// warnAboutMiddlewareFinalize : seul `zarexNext()` appelé directement (usage middleware) a besoin du\r\n// rappel ci-dessous — `withZarex` (route handlers) applique déjà `finalize()` lui-même sur le chemin\r\n// autorisé (voir plus bas), le même avertissement y serait un faux positif systématique.\r\nfunction buildGuard(options: NextZarexOptions | Zarex, extra: Extra, warnAboutMiddlewareFinalize: boolean): NextGuard {\r\n  const { instance, opts } = build(options, extra);\r\n  const finalizer = createWebFinalizer({ secureHeaders: opts.secureHeaders, responseGuard: opts.responseGuard });\r\n  // Rappel au démarrage (pas par requête) : `guard()` renvoie `null` quand la requête est autorisée et ne\r\n  // peut pas construire elle-même la réponse de continuation (NextResponse.next(), propre à next/server —\r\n  // voir l'en-tête du fichier). Sans `guard.finalize(...)` explicite sur cette réponse-là dans le\r\n  // middleware, `secureHeaders`/`responseGuard` ne s'appliqueraient JAMAIS au trafic autorisé. Trouvé lors\r\n  // de l'audit du 04-05/11/2026 : ce piège n'était signalé nulle part à l'exécution.\r\n  if (finalizer && warnAboutMiddlewareFinalize) {\r\n    console.warn(\r\n      '[zarex] next: `secureHeaders`/`responseGuard` is configured. In middleware.ts, call `guard.finalize(NextResponse.next(), request)` ' +\r\n        \"on the ALLOWED path too (not just on a denial) — otherwise it is never applied to allowed traffic: \" +\r\n        'return (await guard(request)) ?? guard.finalize(NextResponse.next(), request).'\r\n    );\r\n  }\r\n  const finalize = async (response: Response, request?: Request): Promise<Response> => {\r\n    try {\r\n      return finalizer ? await finalizer(response, request) : response;\r\n    } catch {\r\n      return response;\r\n    }\r\n  };\r\n  async function guard(request: Request): Promise<Response | null> {\r\n    try {\r\n      const call = callOf(opts, request);\r\n      const { deny } = await guardWebRequest(instance, request, {\r\n        ...(opts.inspectBody ? { inspectBody: true } : {}),\r\n        ...(opts.onDeny ? { onDeny: opts.onDeny } : {}),\r\n        ...(opts.onDegraded ? { onDegraded: opts.onDegraded } : {}),\r\n        ...(call ? { call } : {}),\r\n      });\r\n      return deny ? await finalize(deny, request) : null;\r\n    } catch {\r\n      return null;\r\n    }\r\n  }\r\n  return Object.assign(guard, { finalize });\r\n}\r\n\r\n/**\r\n * Renvoie une Response de refus, ou null si la requête peut continuer. Ne lève jamais.\r\n * `guard.finalize(response, request)` ajoute les en-têtes de sécurité demandés à n'importe quelle réponse —\r\n * y compris la réponse AUTORISÉE en usage middleware, sinon jamais appliqués à ce trafic (voir l'exemple\r\n * en tête de fichier).\r\n */\r\nexport function zarexNext(options: NextZarexOptions | Zarex, extra: Extra = {}): NextGuard {\r\n  return buildGuard(options, extra, true);\r\n}\r\n\r\n/** Enveloppe un route handler : `export const POST = withZarex(options, async (req) => …)`. */\r\nexport function withZarex<A extends unknown[], R>(\r\n  options: NextZarexOptions | Zarex,\r\n  handler: (request: Request, ...args: A) => R | Promise<R>,\r\n  extra: Extra = {}\r\n): (request: Request, ...args: A) => Promise<R | Response> {\r\n  const guard = buildGuard(options, extra, false); // applique déjà finalize() lui-même ci-dessous, pas de rappel nécessaire\r\n  return async (request, ...args) => {\r\n    const denied = await guard(request);\r\n    if (denied) return denied;\r\n    const out = await handler(request, ...args);\r\n    return out instanceof Response ? await guard.finalize(out, request) : out;\r\n  };\r\n}\r\n\r\nexport {\r\n  shield,\r\n  rateLimit,\r\n  tokenBucket,\r\n  detectBot,\r\n  requestFilter,\r\n  sensitiveInfo,\r\n  emailValidation,\r\n  phoneValidation,\r\n  promptInjection,\r\n  secureHeaders,\r\n  withSecureHeaders,\r\n  createZarex,\r\n  PRIVATE_NETWORKS,\r\n  CLOUDFLARE_RANGES,\r\n} from \"@zarex/core\";\r\nexport type { SecureHeadersOptions, ResponseGuardOptions, ResponseGuardEvent } from \"@zarex/core\";\r\nexport type { Decision, Zarex, ZarexOptions, IpSource, Rule, ProtectCall } from \"@zarex/core\";"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA6M;AA4H7M,IAAAA,eAeO;AAjGP,SAAS,MAAM,SAAmC,OAAgD;AAChG,QAAM,aAAa,OAAQ,QAAkB,YAAY;AACzD,SAAO,aACH,EAAE,UAAU,SAAkB,MAAM,MAAM,IAC1C,EAAE,cAAU,yBAAY,OAA2B,GAAG,MAAM,QAA4B;AAC9F;AAEA,SAAS,OAAO,MAAa,SAA2C;AACtE,MAAI;AACF,WAAO,KAAK,OAAO,OAAO;AAAA,EAC5B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAKA,SAAS,WAAW,SAAmC,OAAc,6BAAiD;AACpH,QAAM,EAAE,UAAU,KAAK,IAAI,MAAM,SAAS,KAAK;AAC/C,QAAM,gBAAY,gCAAmB,EAAE,eAAe,KAAK,eAAe,eAAe,KAAK,cAAc,CAAC;AAM7G,MAAI,aAAa,6BAA6B;AAC5C,YAAQ;AAAA,MACN;AAAA,IAGF;AAAA,EACF;AACA,QAAM,WAAW,OAAO,UAAoB,YAAyC;AACnF,QAAI;AACF,aAAO,YAAY,MAAM,UAAU,UAAU,OAAO,IAAI;AAAA,IAC1D,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACA,iBAAe,MAAM,SAA4C;AAC/D,QAAI;AACF,YAAM,OAAO,OAAO,MAAM,OAAO;AACjC,YAAM,EAAE,KAAK,IAAI,UAAM,6BAAgB,UAAU,SAAS;AAAA,QACxD,GAAI,KAAK,cAAc,EAAE,aAAa,KAAK,IAAI,CAAC;AAAA,QAChD,GAAI,KAAK,SAAS,EAAE,QAAQ,KAAK,OAAO,IAAI,CAAC;AAAA,QAC7C,GAAI,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC;AAAA,QACzD,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;AAAA,MACzB,CAAC;AACD,aAAO,OAAO,MAAM,SAAS,MAAM,OAAO,IAAI;AAAA,IAChD,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO,OAAO,OAAO,OAAO,EAAE,SAAS,CAAC;AAC1C;AAQO,SAAS,UAAU,SAAmC,QAAe,CAAC,GAAc;AACzF,SAAO,WAAW,SAAS,OAAO,IAAI;AACxC;AAGO,SAAS,UACd,SACA,SACA,QAAe,CAAC,GACyC;AACzD,QAAM,QAAQ,WAAW,SAAS,OAAO,KAAK;AAC9C,SAAO,OAAO,YAAY,SAAS;AACjC,UAAM,SAAS,MAAM,MAAM,OAAO;AAClC,QAAI,OAAQ,QAAO;AACnB,UAAM,MAAM,MAAM,QAAQ,SAAS,GAAG,IAAI;AAC1C,WAAO,eAAe,WAAW,MAAM,MAAM,SAAS,KAAK,OAAO,IAAI;AAAA,EACxE;AACF;","names":["import_core"]}

package/dist/index.d.cts

@@ -0,0 +1,52 @@
+import { ZarexOptions, SecureHeadersOptions, ResponseGuardOptions, WebGuardOptions, ProtectCall, Zarex } from '@zarex/core';
+export { CLOUDFLARE_RANGES, Decision, IpSource, PRIVATE_NETWORKS, ProtectCall, ResponseGuardEvent, ResponseGuardOptions, Rule, SecureHeadersOptions, Zarex, ZarexOptions, createZarex, detectBot, emailValidation, phoneValidation, promptInjection, rateLimit, requestFilter, secureHeaders, sensitiveInfo, shield, tokenBucket, withSecureHeaders } from '@zarex/core';
+
+/**
+ * Next.js — fonctionne dans le middleware (runtime edge) ET dans les route handlers.
+ * Aucune importation de `next` : on utilise la `Request` standard, donc aucun risque de
+ * version incompatible et rien de propre à Node dans le middleware.
+ *
+ *   // middleware.ts
+ *   import { NextResponse } from "next/server";
+ *   import { zarexNext, shield, rateLimit } from "@zarex/next";
+ *   const guard = zarexNext({ key: process.env.ZAREX_KEY!, baseUrl: process.env.ZAREX_URL!, ipSource: "vercel",
+ *                             rules: [shield(), rateLimit({ max: 100, window: "1m" })] });
+ *   export async function middleware(request: Request) {
+ *     // guard.finalize(...) sur la réponse autorisée AUSSI, pas seulement sur un refus : sans cet appel,
+ *     // `secureHeaders`/`responseGuard` ne s'appliqueraient JAMAIS au trafic autorisé (trouvé lors de
+ *     // l'audit du 04-05/11/2026 — `guard()` ne peut pas le faire elle-même : importer next/server ici
+ *     // romprait la garantie « aucune dépendance à next » de ce fichier, voir l'en-tête ci-dessus).
+ *     return (await guard(request)) ?? guard.finalize(NextResponse.next(), request);
+ *   }
+ *
+ * LIMITE IMPORTANTE : le middleware Next.js ne voit pas l'adresse de la connexion TCP. Seules les sources
+ * qui lisent un en-tête posé par la plateforme fonctionnent donc : "vercel", "fly", "auto". Hébergé ailleurs
+ * (nginx, Docker…), utilisez un route handler avec `withZarex` n'y change rien non plus : voir la documentation.
+ */
+interface NextZarexOptions extends ZarexOptions {
+    inspectBody?: boolean;
+    /** En-têtes de sécurité (true = défauts prudents). Voir `guard.finalize` pour le middleware. */
+    secureHeaders?: SecureHeadersOptions | boolean;
+    /** Surveille les réponses des route handlers (withZarex) : masque les cartes bancaires, clés d'API, etc. */
+    responseGuard?: ResponseGuardOptions | boolean;
+    onDeny?: WebGuardOptions["onDeny"];
+    onDegraded?: WebGuardOptions["onDegraded"];
+    /** Identifiants / jetons propres à chaque requête (ex. userId). Une erreur dans cette fonction est ignorée. */
+    call?: (request: Request) => ProtectCall | undefined;
+}
+type Extra = Pick<NextZarexOptions, "inspectBody" | "onDeny" | "onDegraded" | "call" | "secureHeaders" | "responseGuard">;
+type NextGuard = ((request: Request) => Promise<Response | null>) & {
+    /** Ajoute les en-têtes de sécurité (et surveille la réponse) : `return guard.finalize(NextResponse.next(), request)`. */
+    finalize(response: Response, request?: Request): Promise<Response>;
+};
+/**
+ * Renvoie une Response de refus, ou null si la requête peut continuer. Ne lève jamais.
+ * `guard.finalize(response, request)` ajoute les en-têtes de sécurité demandés à n'importe quelle réponse —
+ * y compris la réponse AUTORISÉE en usage middleware, sinon jamais appliqués à ce trafic (voir l'exemple
+ * en tête de fichier).
+ */
+declare function zarexNext(options: NextZarexOptions | Zarex, extra?: Extra): NextGuard;
+/** Enveloppe un route handler : `export const POST = withZarex(options, async (req) => …)`. */
+declare function withZarex<A extends unknown[], R>(options: NextZarexOptions | Zarex, handler: (request: Request, ...args: A) => R | Promise<R>, extra?: Extra): (request: Request, ...args: A) => Promise<R | Response>;
+
+export { type NextGuard, type NextZarexOptions, withZarex, zarexNext };

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+import { ZarexOptions, SecureHeadersOptions, ResponseGuardOptions, WebGuardOptions, ProtectCall, Zarex } from '@zarex/core';
+export { CLOUDFLARE_RANGES, Decision, IpSource, PRIVATE_NETWORKS, ProtectCall, ResponseGuardEvent, ResponseGuardOptions, Rule, SecureHeadersOptions, Zarex, ZarexOptions, createZarex, detectBot, emailValidation, phoneValidation, promptInjection, rateLimit, requestFilter, secureHeaders, sensitiveInfo, shield, tokenBucket, withSecureHeaders } from '@zarex/core';
+
+/**
+ * Next.js — fonctionne dans le middleware (runtime edge) ET dans les route handlers.
+ * Aucune importation de `next` : on utilise la `Request` standard, donc aucun risque de
+ * version incompatible et rien de propre à Node dans le middleware.
+ *
+ *   // middleware.ts
+ *   import { NextResponse } from "next/server";
+ *   import { zarexNext, shield, rateLimit } from "@zarex/next";
+ *   const guard = zarexNext({ key: process.env.ZAREX_KEY!, baseUrl: process.env.ZAREX_URL!, ipSource: "vercel",
+ *                             rules: [shield(), rateLimit({ max: 100, window: "1m" })] });
+ *   export async function middleware(request: Request) {
+ *     // guard.finalize(...) sur la réponse autorisée AUSSI, pas seulement sur un refus : sans cet appel,
+ *     // `secureHeaders`/`responseGuard` ne s'appliqueraient JAMAIS au trafic autorisé (trouvé lors de
+ *     // l'audit du 04-05/11/2026 — `guard()` ne peut pas le faire elle-même : importer next/server ici
+ *     // romprait la garantie « aucune dépendance à next » de ce fichier, voir l'en-tête ci-dessus).
+ *     return (await guard(request)) ?? guard.finalize(NextResponse.next(), request);
+ *   }
+ *
+ * LIMITE IMPORTANTE : le middleware Next.js ne voit pas l'adresse de la connexion TCP. Seules les sources
+ * qui lisent un en-tête posé par la plateforme fonctionnent donc : "vercel", "fly", "auto". Hébergé ailleurs
+ * (nginx, Docker…), utilisez un route handler avec `withZarex` n'y change rien non plus : voir la documentation.
+ */
+interface NextZarexOptions extends ZarexOptions {
+    inspectBody?: boolean;
+    /** En-têtes de sécurité (true = défauts prudents). Voir `guard.finalize` pour le middleware. */
+    secureHeaders?: SecureHeadersOptions | boolean;
+    /** Surveille les réponses des route handlers (withZarex) : masque les cartes bancaires, clés d'API, etc. */
+    responseGuard?: ResponseGuardOptions | boolean;
+    onDeny?: WebGuardOptions["onDeny"];
+    onDegraded?: WebGuardOptions["onDegraded"];
+    /** Identifiants / jetons propres à chaque requête (ex. userId). Une erreur dans cette fonction est ignorée. */
+    call?: (request: Request) => ProtectCall | undefined;
+}
+type Extra = Pick<NextZarexOptions, "inspectBody" | "onDeny" | "onDegraded" | "call" | "secureHeaders" | "responseGuard">;
+type NextGuard = ((request: Request) => Promise<Response | null>) & {
+    /** Ajoute les en-têtes de sécurité (et surveille la réponse) : `return guard.finalize(NextResponse.next(), request)`. */
+    finalize(response: Response, request?: Request): Promise<Response>;
+};
+/**
+ * Renvoie une Response de refus, ou null si la requête peut continuer. Ne lève jamais.
+ * `guard.finalize(response, request)` ajoute les en-têtes de sécurité demandés à n'importe quelle réponse —
+ * y compris la réponse AUTORISÉE en usage middleware, sinon jamais appliqués à ce trafic (voir l'exemple
+ * en tête de fichier).
+ */
+declare function zarexNext(options: NextZarexOptions | Zarex, extra?: Extra): NextGuard;
+/** Enveloppe un route handler : `export const POST = withZarex(options, async (req) => …)`. */
+declare function withZarex<A extends unknown[], R>(options: NextZarexOptions | Zarex, handler: (request: Request, ...args: A) => R | Promise<R>, extra?: Extra): (request: Request, ...args: A) => Promise<R | Response>;
+
+export { type NextGuard, type NextZarexOptions, withZarex, zarexNext };

package/dist/index.js

@@ -0,0 +1,91 @@
+// src/index.ts
+import { createWebFinalizer, createZarex, guardWebRequest } from "@zarex/core";
+import {
+  shield,
+  rateLimit,
+  tokenBucket,
+  detectBot,
+  requestFilter,
+  sensitiveInfo,
+  emailValidation,
+  phoneValidation,
+  promptInjection,
+  secureHeaders,
+  withSecureHeaders,
+  createZarex as createZarex2,
+  PRIVATE_NETWORKS,
+  CLOUDFLARE_RANGES
+} from "@zarex/core";
+function build(options, extra) {
+  const isInstance = typeof options.protect === "function";
+  return isInstance ? { instance: options, opts: extra } : { instance: createZarex(options), opts: options };
+}
+function callOf(opts, request) {
+  try {
+    return opts.call?.(request);
+  } catch {
+    return void 0;
+  }
+}
+function buildGuard(options, extra, warnAboutMiddlewareFinalize) {
+  const { instance, opts } = build(options, extra);
+  const finalizer = createWebFinalizer({ secureHeaders: opts.secureHeaders, responseGuard: opts.responseGuard });
+  if (finalizer && warnAboutMiddlewareFinalize) {
+    console.warn(
+      "[zarex] next: `secureHeaders`/`responseGuard` is configured. In middleware.ts, call `guard.finalize(NextResponse.next(), request)` on the ALLOWED path too (not just on a denial) \u2014 otherwise it is never applied to allowed traffic: return (await guard(request)) ?? guard.finalize(NextResponse.next(), request)."
+    );
+  }
+  const finalize = async (response, request) => {
+    try {
+      return finalizer ? await finalizer(response, request) : response;
+    } catch {
+      return response;
+    }
+  };
+  async function guard(request) {
+    try {
+      const call = callOf(opts, request);
+      const { deny } = await guardWebRequest(instance, request, {
+        ...opts.inspectBody ? { inspectBody: true } : {},
+        ...opts.onDeny ? { onDeny: opts.onDeny } : {},
+        ...opts.onDegraded ? { onDegraded: opts.onDegraded } : {},
+        ...call ? { call } : {}
+      });
+      return deny ? await finalize(deny, request) : null;
+    } catch {
+      return null;
+    }
+  }
+  return Object.assign(guard, { finalize });
+}
+function zarexNext(options, extra = {}) {
+  return buildGuard(options, extra, true);
+}
+function withZarex(options, handler, extra = {}) {
+  const guard = buildGuard(options, extra, false);
+  return async (request, ...args) => {
+    const denied = await guard(request);
+    if (denied) return denied;
+    const out = await handler(request, ...args);
+    return out instanceof Response ? await guard.finalize(out, request) : out;
+  };
+}
+export {
+  CLOUDFLARE_RANGES,
+  PRIVATE_NETWORKS,
+  createZarex2 as createZarex,
+  detectBot,
+  emailValidation,
+  phoneValidation,
+  promptInjection,
+  rateLimit,
+  requestFilter,
+  secureHeaders,
+  sensitiveInfo,
+  shield,
+  tokenBucket,
+  withSecureHeaders,
+  withZarex,
+  zarexNext
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { createWebFinalizer, createZarex, guardWebRequest, type ResponseGuardOptions, type SecureHeadersOptions, type Decision, type ProtectCall, type WebGuardOptions, type Zarex, type ZarexOptions } from \"@zarex/core\";\r\n\r\n/**\r\n * Next.js — fonctionne dans le middleware (runtime edge) ET dans les route handlers.\r\n * Aucune importation de `next` : on utilise la `Request` standard, donc aucun risque de\r\n * version incompatible et rien de propre à Node dans le middleware.\r\n *\r\n *   // middleware.ts\r\n *   import { NextResponse } from \"next/server\";\r\n *   import { zarexNext, shield, rateLimit } from \"@zarex/next\";\r\n *   const guard = zarexNext({ key: process.env.ZAREX_KEY!, baseUrl: process.env.ZAREX_URL!, ipSource: \"vercel\",\r\n *                             rules: [shield(), rateLimit({ max: 100, window: \"1m\" })] });\r\n *   export async function middleware(request: Request) {\r\n *     // guard.finalize(...) sur la réponse autorisée AUSSI, pas seulement sur un refus : sans cet appel,\r\n *     // `secureHeaders`/`responseGuard` ne s'appliqueraient JAMAIS au trafic autorisé (trouvé lors de\r\n *     // l'audit du 04-05/11/2026 — `guard()` ne peut pas le faire elle-même : importer next/server ici\r\n *     // romprait la garantie « aucune dépendance à next » de ce fichier, voir l'en-tête ci-dessus).\r\n *     return (await guard(request)) ?? guard.finalize(NextResponse.next(), request);\r\n *   }\r\n *\r\n * LIMITE IMPORTANTE : le middleware Next.js ne voit pas l'adresse de la connexion TCP. Seules les sources\r\n * qui lisent un en-tête posé par la plateforme fonctionnent donc : \"vercel\", \"fly\", \"auto\". Hébergé ailleurs\r\n * (nginx, Docker…), utilisez un route handler avec `withZarex` n'y change rien non plus : voir la documentation.\r\n */\r\nexport interface NextZarexOptions extends ZarexOptions {\r\n  inspectBody?: boolean;\r\n  /** En-têtes de sécurité (true = défauts prudents). Voir `guard.finalize` pour le middleware. */\r\n  secureHeaders?: SecureHeadersOptions | boolean;\r\n  /** Surveille les réponses des route handlers (withZarex) : masque les cartes bancaires, clés d'API, etc. */\r\n  responseGuard?: ResponseGuardOptions | boolean;\r\n  onDeny?: WebGuardOptions[\"onDeny\"];\r\n  onDegraded?: WebGuardOptions[\"onDegraded\"];\r\n  /** Identifiants / jetons propres à chaque requête (ex. userId). Une erreur dans cette fonction est ignorée. */\r\n  call?: (request: Request) => ProtectCall | undefined;\r\n}\r\ntype Extra = Pick<NextZarexOptions, \"inspectBody\" | \"onDeny\" | \"onDegraded\" | \"call\" | \"secureHeaders\" | \"responseGuard\">;\r\n\r\nexport type NextGuard = ((request: Request) => Promise<Response | null>) & {\r\n  /** Ajoute les en-têtes de sécurité (et surveille la réponse) : `return guard.finalize(NextResponse.next(), request)`. */\r\n  finalize(response: Response, request?: Request): Promise<Response>;\r\n};\r\n\r\nfunction build(options: NextZarexOptions | Zarex, extra: Extra): { instance: Zarex; opts: Extra } {\r\n  const isInstance = typeof (options as Zarex).protect === \"function\";\r\n  return isInstance\r\n    ? { instance: options as Zarex, opts: extra }\r\n    : { instance: createZarex(options as NextZarexOptions), opts: options as NextZarexOptions };\r\n}\r\n\r\nfunction callOf(opts: Extra, request: Request): ProtectCall | undefined {\r\n  try {\r\n    return opts.call?.(request);\r\n  } catch {\r\n    return undefined;\r\n  }\r\n}\r\n\r\n// warnAboutMiddlewareFinalize : seul `zarexNext()` appelé directement (usage middleware) a besoin du\r\n// rappel ci-dessous — `withZarex` (route handlers) applique déjà `finalize()` lui-même sur le chemin\r\n// autorisé (voir plus bas), le même avertissement y serait un faux positif systématique.\r\nfunction buildGuard(options: NextZarexOptions | Zarex, extra: Extra, warnAboutMiddlewareFinalize: boolean): NextGuard {\r\n  const { instance, opts } = build(options, extra);\r\n  const finalizer = createWebFinalizer({ secureHeaders: opts.secureHeaders, responseGuard: opts.responseGuard });\r\n  // Rappel au démarrage (pas par requête) : `guard()` renvoie `null` quand la requête est autorisée et ne\r\n  // peut pas construire elle-même la réponse de continuation (NextResponse.next(), propre à next/server —\r\n  // voir l'en-tête du fichier). Sans `guard.finalize(...)` explicite sur cette réponse-là dans le\r\n  // middleware, `secureHeaders`/`responseGuard` ne s'appliqueraient JAMAIS au trafic autorisé. Trouvé lors\r\n  // de l'audit du 04-05/11/2026 : ce piège n'était signalé nulle part à l'exécution.\r\n  if (finalizer && warnAboutMiddlewareFinalize) {\r\n    console.warn(\r\n      '[zarex] next: `secureHeaders`/`responseGuard` is configured. In middleware.ts, call `guard.finalize(NextResponse.next(), request)` ' +\r\n        \"on the ALLOWED path too (not just on a denial) — otherwise it is never applied to allowed traffic: \" +\r\n        'return (await guard(request)) ?? guard.finalize(NextResponse.next(), request).'\r\n    );\r\n  }\r\n  const finalize = async (response: Response, request?: Request): Promise<Response> => {\r\n    try {\r\n      return finalizer ? await finalizer(response, request) : response;\r\n    } catch {\r\n      return response;\r\n    }\r\n  };\r\n  async function guard(request: Request): Promise<Response | null> {\r\n    try {\r\n      const call = callOf(opts, request);\r\n      const { deny } = await guardWebRequest(instance, request, {\r\n        ...(opts.inspectBody ? { inspectBody: true } : {}),\r\n        ...(opts.onDeny ? { onDeny: opts.onDeny } : {}),\r\n        ...(opts.onDegraded ? { onDegraded: opts.onDegraded } : {}),\r\n        ...(call ? { call } : {}),\r\n      });\r\n      return deny ? await finalize(deny, request) : null;\r\n    } catch {\r\n      return null;\r\n    }\r\n  }\r\n  return Object.assign(guard, { finalize });\r\n}\r\n\r\n/**\r\n * Renvoie une Response de refus, ou null si la requête peut continuer. Ne lève jamais.\r\n * `guard.finalize(response, request)` ajoute les en-têtes de sécurité demandés à n'importe quelle réponse —\r\n * y compris la réponse AUTORISÉE en usage middleware, sinon jamais appliqués à ce trafic (voir l'exemple\r\n * en tête de fichier).\r\n */\r\nexport function zarexNext(options: NextZarexOptions | Zarex, extra: Extra = {}): NextGuard {\r\n  return buildGuard(options, extra, true);\r\n}\r\n\r\n/** Enveloppe un route handler : `export const POST = withZarex(options, async (req) => …)`. */\r\nexport function withZarex<A extends unknown[], R>(\r\n  options: NextZarexOptions | Zarex,\r\n  handler: (request: Request, ...args: A) => R | Promise<R>,\r\n  extra: Extra = {}\r\n): (request: Request, ...args: A) => Promise<R | Response> {\r\n  const guard = buildGuard(options, extra, false); // applique déjà finalize() lui-même ci-dessous, pas de rappel nécessaire\r\n  return async (request, ...args) => {\r\n    const denied = await guard(request);\r\n    if (denied) return denied;\r\n    const out = await handler(request, ...args);\r\n    return out instanceof Response ? await guard.finalize(out, request) : out;\r\n  };\r\n}\r\n\r\nexport {\r\n  shield,\r\n  rateLimit,\r\n  tokenBucket,\r\n  detectBot,\r\n  requestFilter,\r\n  sensitiveInfo,\r\n  emailValidation,\r\n  phoneValidation,\r\n  promptInjection,\r\n  secureHeaders,\r\n  withSecureHeaders,\r\n  createZarex,\r\n  PRIVATE_NETWORKS,\r\n  CLOUDFLARE_RANGES,\r\n} from \"@zarex/core\";\r\nexport type { SecureHeadersOptions, ResponseGuardOptions, ResponseGuardEvent } from \"@zarex/core\";\r\nexport type { Decision, Zarex, ZarexOptions, IpSource, Rule, ProtectCall } from \"@zarex/core\";"],"mappings":";AAAA,SAAS,oBAAoB,aAAa,uBAAmK;AA4H7M;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,eAAAA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAjGP,SAAS,MAAM,SAAmC,OAAgD;AAChG,QAAM,aAAa,OAAQ,QAAkB,YAAY;AACzD,SAAO,aACH,EAAE,UAAU,SAAkB,MAAM,MAAM,IAC1C,EAAE,UAAU,YAAY,OAA2B,GAAG,MAAM,QAA4B;AAC9F;AAEA,SAAS,OAAO,MAAa,SAA2C;AACtE,MAAI;AACF,WAAO,KAAK,OAAO,OAAO;AAAA,EAC5B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAKA,SAAS,WAAW,SAAmC,OAAc,6BAAiD;AACpH,QAAM,EAAE,UAAU,KAAK,IAAI,MAAM,SAAS,KAAK;AAC/C,QAAM,YAAY,mBAAmB,EAAE,eAAe,KAAK,eAAe,eAAe,KAAK,cAAc,CAAC;AAM7G,MAAI,aAAa,6BAA6B;AAC5C,YAAQ;AAAA,MACN;AAAA,IAGF;AAAA,EACF;AACA,QAAM,WAAW,OAAO,UAAoB,YAAyC;AACnF,QAAI;AACF,aAAO,YAAY,MAAM,UAAU,UAAU,OAAO,IAAI;AAAA,IAC1D,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACA,iBAAe,MAAM,SAA4C;AAC/D,QAAI;AACF,YAAM,OAAO,OAAO,MAAM,OAAO;AACjC,YAAM,EAAE,KAAK,IAAI,MAAM,gBAAgB,UAAU,SAAS;AAAA,QACxD,GAAI,KAAK,cAAc,EAAE,aAAa,KAAK,IAAI,CAAC;AAAA,QAChD,GAAI,KAAK,SAAS,EAAE,QAAQ,KAAK,OAAO,IAAI,CAAC;AAAA,QAC7C,GAAI,KAAK,aAAa,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC;AAAA,QACzD,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;AAAA,MACzB,CAAC;AACD,aAAO,OAAO,MAAM,SAAS,MAAM,OAAO,IAAI;AAAA,IAChD,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO,OAAO,OAAO,OAAO,EAAE,SAAS,CAAC;AAC1C;AAQO,SAAS,UAAU,SAAmC,QAAe,CAAC,GAAc;AACzF,SAAO,WAAW,SAAS,OAAO,IAAI;AACxC;AAGO,SAAS,UACd,SACA,SACA,QAAe,CAAC,GACyC;AACzD,QAAM,QAAQ,WAAW,SAAS,OAAO,KAAK;AAC9C,SAAO,OAAO,YAAY,SAAS;AACjC,UAAM,SAAS,MAAM,MAAM,OAAO;AAClC,QAAI,OAAQ,QAAO;AACnB,UAAM,MAAM,MAAM,QAAQ,SAAS,GAAG,IAAI;AAC1C,WAAO,eAAe,WAAW,MAAM,MAAM,SAAS,KAAK,OAAO,IAAI;AAAA,EACxE;AACF;","names":["createZarex"]}

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@zarex/next",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Zarex — Next.js (middleware edge et route handlers)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@zarex/core": "^0.1.0"
+  },
+  "peerDependencies": {
+    "next": ">=13"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsup"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.