@dudousxd/nestjs-inertia 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2314 @@
+const __importMetaUrl = require('url').pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/errors/exceptions.ts
+var import_common4, InvalidInertiaConfigException, InertiaServiceNotAvailableException, UnsupportedRootViewExtensionException, MissingTemplateEngineDepException, MissingCookieDepException, InvalidCsrfTokenException;
+var init_exceptions = __esm({
+  "src/errors/exceptions.ts"() {
+    "use strict";
+    import_common4 = require("@nestjs/common");
+    InvalidInertiaConfigException = class extends Error {
+      static {
+        __name(this, "InvalidInertiaConfigException");
+      }
+      constructor(message) {
+        super(`[nestjs-inertia] Invalid config: ${message}`);
+        this.name = "InvalidInertiaConfigException";
+      }
+    };
+    InertiaServiceNotAvailableException = class extends Error {
+      static {
+        __name(this, "InertiaServiceNotAvailableException");
+      }
+      constructor() {
+        super("[nestjs-inertia] req.inertia is not defined \u2014 middleware did not run. Ensure InertiaModule is imported and the middleware applies to this route.");
+        this.name = "InertiaServiceNotAvailableException";
+      }
+    };
+    UnsupportedRootViewExtensionException = class extends Error {
+      static {
+        __name(this, "UnsupportedRootViewExtensionException");
+      }
+      constructor(extension) {
+        super(`[nestjs-inertia] rootView extension "${extension}" is not supported. Supported extensions: .html, .htm, .hbs, .handlebars, .ejs, .pug, .liquid, .liquidjs. Or pass a (ctx) => string function for full control.`);
+        this.name = "UnsupportedRootViewExtensionException";
+      }
+    };
+    MissingTemplateEngineDepException = class extends Error {
+      static {
+        __name(this, "MissingTemplateEngineDepException");
+      }
+      constructor(engine, packageName) {
+        super(`[nestjs-inertia] Template engine "${engine}" requires "${packageName}" as a peer dependency. Install with: pnpm add ${packageName}`);
+        this.name = "MissingTemplateEngineDepException";
+      }
+    };
+    MissingCookieDepException = class extends Error {
+      static {
+        __name(this, "MissingCookieDepException");
+      }
+      constructor(platform) {
+        const dep = platform === "express" ? "cookie-parser" : "@fastify/cookie";
+        super(`[nestjs-inertia] CSRF requires "${dep}" as a peer dependency for ${platform}. Install with: pnpm add ${dep}`);
+        this.name = "MissingCookieDepException";
+      }
+    };
+    InvalidCsrfTokenException = class extends import_common4.ForbiddenException {
+      static {
+        __name(this, "InvalidCsrfTokenException");
+      }
+      constructor() {
+        super("[nestjs-inertia] CSRF token is missing or invalid.");
+      }
+    };
+  }
+});
+
+// src/shell/handlebars.adapter.ts
+var handlebars_adapter_exports = {};
+__export(handlebars_adapter_exports, {
+  handlebarsAdapter: () => handlebarsAdapter
+});
+function loadHandlebars() {
+  try {
+    return require2("handlebars");
+  } catch {
+    throw new MissingTemplateEngineDepException("Handlebars", "handlebars");
+  }
+}
+var import_node_module, require2, handlebarsAdapter;
+var init_handlebars_adapter = __esm({
+  "src/shell/handlebars.adapter.ts"() {
+    "use strict";
+    import_node_module = require("module");
+    init_exceptions();
+    require2 = (0, import_node_module.createRequire)(__importMetaUrl);
+    __name(loadHandlebars, "loadHandlebars");
+    handlebarsAdapter = {
+      extension: ".hbs",
+      packageName: "handlebars",
+      compile(templateSource) {
+        const hbs = loadHandlebars();
+        const compiled = hbs.compile(templateSource);
+        return (locals) => compiled(locals);
+      }
+    };
+  }
+});
+
+// src/shell/ejs.adapter.ts
+var ejs_adapter_exports = {};
+__export(ejs_adapter_exports, {
+  ejsAdapter: () => ejsAdapter
+});
+function loadEjs() {
+  try {
+    return require3("ejs");
+  } catch {
+    throw new MissingTemplateEngineDepException("EJS", "ejs");
+  }
+}
+var import_node_module2, require3, ejsAdapter;
+var init_ejs_adapter = __esm({
+  "src/shell/ejs.adapter.ts"() {
+    "use strict";
+    import_node_module2 = require("module");
+    init_exceptions();
+    require3 = (0, import_node_module2.createRequire)(__importMetaUrl);
+    __name(loadEjs, "loadEjs");
+    ejsAdapter = {
+      extension: ".ejs",
+      packageName: "ejs",
+      compile(templateSource, absPath) {
+        const ejs = loadEjs();
+        const compiled = ejs.compile(templateSource, {
+          filename: absPath,
+          async: false
+        });
+        return (locals) => compiled(locals);
+      }
+    };
+  }
+});
+
+// src/shell/pug.adapter.ts
+var pug_adapter_exports = {};
+__export(pug_adapter_exports, {
+  pugAdapter: () => pugAdapter
+});
+function loadPug() {
+  try {
+    return require4("pug");
+  } catch {
+    throw new MissingTemplateEngineDepException("Pug", "pug");
+  }
+}
+var import_node_module3, require4, pugAdapter;
+var init_pug_adapter = __esm({
+  "src/shell/pug.adapter.ts"() {
+    "use strict";
+    import_node_module3 = require("module");
+    init_exceptions();
+    require4 = (0, import_node_module3.createRequire)(__importMetaUrl);
+    __name(loadPug, "loadPug");
+    pugAdapter = {
+      extension: ".pug",
+      packageName: "pug",
+      compile(templateSource, absPath) {
+        const pug = loadPug();
+        const compiled = pug.compile(templateSource, {
+          filename: absPath
+        });
+        return (locals) => compiled(locals);
+      }
+    };
+  }
+});
+
+// src/shell/liquid.adapter.ts
+var liquid_adapter_exports = {};
+__export(liquid_adapter_exports, {
+  liquidAdapter: () => liquidAdapter
+});
+function loadLiquid() {
+  try {
+    const mod = require5("liquidjs");
+    return mod.Liquid;
+  } catch {
+    throw new MissingTemplateEngineDepException("Liquid", "liquidjs");
+  }
+}
+var import_node_module4, require5, liquidAdapter;
+var init_liquid_adapter = __esm({
+  "src/shell/liquid.adapter.ts"() {
+    "use strict";
+    import_node_module4 = require("module");
+    init_exceptions();
+    require5 = (0, import_node_module4.createRequire)(__importMetaUrl);
+    __name(loadLiquid, "loadLiquid");
+    liquidAdapter = {
+      extension: ".liquid",
+      packageName: "liquidjs",
+      compile(templateSource) {
+        const Liquid = loadLiquid();
+        const engine = new Liquid({
+          outputEscape: "escape"
+        });
+        return async (locals) => engine.parseAndRender(templateSource, locals);
+      }
+    };
+  }
+});
+
+// src/middleware/fastify-method-spoof.middleware.ts
+var fastify_method_spoof_middleware_exports = {};
+__export(fastify_method_spoof_middleware_exports, {
+  registerFastifyMethodSpoof: () => registerFastifyMethodSpoof
+});
+function registerFastifyMethodSpoof(app, options) {
+  if (options.methodSpoofing !== true) return;
+  app.addHook("preHandler", async (req) => {
+    const r = req;
+    if (r.method !== "POST") return;
+    const contentType = (r.headers["content-type"] ?? "").toString().toLowerCase();
+    if (!contentType.startsWith("multipart/")) return;
+    const spoofed = String(r.body?._method ?? "").toUpperCase();
+    if (ALLOWED2.has(spoofed)) {
+      r.method = spoofed;
+      if (r.body && typeof r.body === "object") {
+        r.body._method = void 0;
+      }
+    }
+  });
+}
+var ALLOWED2;
+var init_fastify_method_spoof_middleware = __esm({
+  "src/middleware/fastify-method-spoof.middleware.ts"() {
+    "use strict";
+    ALLOWED2 = /* @__PURE__ */ new Set([
+      "PUT",
+      "PATCH",
+      "DELETE"
+    ]);
+    __name(registerFastifyMethodSpoof, "registerFastifyMethodSpoof");
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CsrfCookieInterceptor: () => CsrfCookieInterceptor,
+  CsrfGuard: () => CsrfGuard,
+  ErrorBagInterceptor: () => ErrorBagInterceptor,
+  INERTIA_ASSET_VERSION: () => INERTIA_ASSET_VERSION,
+  INERTIA_DEFAULT_SCOPE: () => INERTIA_DEFAULT_SCOPE,
+  INERTIA_FEATURE_OPTIONS: () => INERTIA_FEATURE_OPTIONS,
+  INERTIA_MANIFEST: () => INERTIA_MANIFEST,
+  INERTIA_MODULE_OPTIONS: () => INERTIA_MODULE_OPTIONS,
+  INERTIA_RENDER_COMPONENT: () => INERTIA_RENDER_COMPONENT,
+  INERTIA_USE_SCOPE: () => INERTIA_USE_SCOPE,
+  Inertia: () => Inertia,
+  InertiaModule: () => InertiaModule,
+  InertiaRenderInterceptor: () => InertiaRenderInterceptor,
+  InertiaService: () => InertiaService,
+  InertiaServiceNotAvailableException: () => InertiaServiceNotAvailableException,
+  InvalidCsrfTokenException: () => InvalidCsrfTokenException,
+  InvalidInertiaConfigException: () => InvalidInertiaConfigException,
+  MethodSpoofMiddleware: () => MethodSpoofMiddleware,
+  MissingCookieDepException: () => MissingCookieDepException,
+  MissingTemplateEngineDepException: () => MissingTemplateEngineDepException,
+  RedirectInterceptor: () => RedirectInterceptor,
+  UnsupportedRootViewExtensionException: () => UnsupportedRootViewExtensionException,
+  UseInertia: () => UseInertia,
+  VERSION: () => VERSION,
+  featureToken: () => featureToken,
+  generateCsrfToken: () => generateCsrfToken,
+  rotateCsrfToken: () => rotateCsrfToken,
+  timingSafeEqualSafe: () => timingSafeEqualSafe,
+  verifyCsrfToken: () => verifyCsrfToken
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/interceptor/error-bag.interceptor.ts
+var import_common = require("@nestjs/common");
+var import_operators = require("rxjs/operators");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var ErrorBagInterceptor = class {
+  static {
+    __name(this, "ErrorBagInterceptor");
+  }
+  intercept(context, next) {
+    const req = context.switchToHttp().getRequest();
+    const bag = req.header("X-Inertia-Error-Bag");
+    if (!bag) return next.handle();
+    return next.handle().pipe((0, import_operators.map)((value) => {
+      if (typeof value !== "object" || value === null) return value;
+      const v = value;
+      if (v.errors === void 0) return value;
+      return {
+        ...v,
+        errors: {
+          [bag]: v.errors
+        }
+      };
+    }));
+  }
+};
+ErrorBagInterceptor = _ts_decorate([
+  (0, import_common.Injectable)()
+], ErrorBagInterceptor);
+
+// src/interceptor/redirect.interceptor.ts
+var import_common2 = require("@nestjs/common");
+var import_operators2 = require("rxjs/operators");
+
+// src/tokens.ts
+var INERTIA_MODULE_OPTIONS = /* @__PURE__ */ Symbol("INERTIA_MODULE_OPTIONS");
+var INERTIA_FEATURE_OPTIONS = /* @__PURE__ */ Symbol("INERTIA_FEATURE_OPTIONS");
+var INERTIA_MANIFEST = /* @__PURE__ */ Symbol("INERTIA_MANIFEST");
+var INERTIA_ASSET_VERSION = /* @__PURE__ */ Symbol("INERTIA_ASSET_VERSION");
+var INERTIA_DEFAULT_SCOPE = "default";
+var RESERVED_SCOPES = /* @__PURE__ */ new Set([
+  "default"
+]);
+var _featureTokenCache = /* @__PURE__ */ new Map();
+function featureToken(kind, scope, rootId) {
+  const key = rootId ? `${kind}:${scope}:${rootId}` : `${kind}:${scope}`;
+  const cached = _featureTokenCache.get(key);
+  if (cached) return cached;
+  const sym = /* @__PURE__ */ Symbol(`INERTIA_FEATURE_${kind}:${scope}${rootId ? `:${rootId}` : ""}`);
+  _featureTokenCache.set(key, sym);
+  return sym;
+}
+__name(featureToken, "featureToken");
+function assertScopeNotReserved(scope) {
+  if (RESERVED_SCOPES.has(scope)) {
+    throw new Error(`[nestjs-inertia] Scope "${scope}" is reserved. Use forRoot() for the default scope.`);
+  }
+}
+__name(assertScopeNotReserved, "assertScopeNotReserved");
+
+// src/interceptor/redirect.interceptor.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var SAFE_METHODS = /* @__PURE__ */ new Set([
+  "PUT",
+  "PATCH",
+  "DELETE"
+]);
+function getHeader(req, name) {
+  const r = req;
+  if (typeof r.header === "function") return r.header(name);
+  const v = r.headers?.[name.toLowerCase()];
+  return Array.isArray(v) ? v[0] : v;
+}
+__name(getHeader, "getHeader");
+var RedirectInterceptor = class {
+  static {
+    __name(this, "RedirectInterceptor");
+  }
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  intercept(context, next) {
+    if (this.options.autoUpgrade303 === false) return next.handle();
+    const req = context.switchToHttp().getRequest();
+    const res = context.switchToHttp().getResponse();
+    const method = req.method;
+    if (SAFE_METHODS.has(method) && getHeader(req, "X-Inertia")) {
+      if (typeof res.redirect === "function") {
+        const originalRedirect = res.redirect.bind(res);
+        res.redirect = /* @__PURE__ */ __name(function patchedRedirect(statusOrUrl, url) {
+          if (typeof statusOrUrl === "number" && statusOrUrl === 302) {
+            originalRedirect(303, url);
+          } else if (typeof statusOrUrl === "string") {
+            originalRedirect(303, statusOrUrl);
+          } else {
+            originalRedirect(statusOrUrl, url);
+          }
+        }, "patchedRedirect");
+      }
+      const resAny = res;
+      if (typeof resAny.code === "function") {
+        const originalCode = resAny.code.bind(res);
+        resAny.code = /* @__PURE__ */ __name(function patchedCode(n) {
+          return originalCode(n === 302 ? 303 : n);
+        }, "patchedCode");
+      }
+    }
+    return next.handle().pipe((0, import_operators2.tap)(() => {
+      if (res.statusCode === 302 && SAFE_METHODS.has(method) && getHeader(req, "X-Inertia")) {
+        res.statusCode = 303;
+      }
+    }));
+  }
+};
+RedirectInterceptor = _ts_decorate2([
+  (0, import_common2.Injectable)(),
+  _ts_param(0, (0, import_common2.Inject)(INERTIA_MODULE_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof InertiaModuleOptions === "undefined" ? Object : InertiaModuleOptions
+  ])
+], RedirectInterceptor);
+
+// src/middleware/method-spoof.middleware.ts
+var import_common3 = require("@nestjs/common");
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var ALLOWED = /* @__PURE__ */ new Set([
+  "PUT",
+  "PATCH",
+  "DELETE"
+]);
+var MethodSpoofMiddleware = class {
+  static {
+    __name(this, "MethodSpoofMiddleware");
+  }
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  use(req, _res, next) {
+    if (this.options.methodSpoofing !== true) return next();
+    if (req.method !== "POST") return next();
+    const contentType = (req.headers["content-type"] ?? "").toString().toLowerCase();
+    if (!contentType.startsWith("multipart/")) return next();
+    const spoofed = String(req.body?._method ?? "").toUpperCase();
+    if (ALLOWED.has(spoofed)) {
+      req.method = spoofed;
+      if (req.body && typeof req.body === "object") {
+        req.body._method = void 0;
+      }
+    }
+    next();
+  }
+};
+MethodSpoofMiddleware = _ts_decorate3([
+  (0, import_common3.Injectable)(),
+  _ts_param2(0, (0, import_common3.Inject)(INERTIA_MODULE_OPTIONS)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InertiaModuleOptions === "undefined" ? Object : InertiaModuleOptions
+  ])
+], MethodSpoofMiddleware);
+
+// src/index.ts
+init_exceptions();
+
+// src/decorator/inertia.decorator.ts
+var import_common5 = require("@nestjs/common");
+var INERTIA_RENDER_COMPONENT = /* @__PURE__ */ Symbol("INERTIA_RENDER_COMPONENT");
+function createInertiaDecorator(component) {
+  return (0, import_common5.SetMetadata)(INERTIA_RENDER_COMPONENT, component);
+}
+__name(createInertiaDecorator, "createInertiaDecorator");
+
+// src/markers.ts
+var MARKER = /* @__PURE__ */ Symbol("inertia.marker");
+function make(kind, value, meta = {}) {
+  return {
+    [MARKER]: true,
+    kind,
+    value,
+    meta
+  };
+}
+__name(make, "make");
+function inertiaDecorator(component) {
+  return createInertiaDecorator(component);
+}
+__name(inertiaDecorator, "inertiaDecorator");
+function always(fn) {
+  return make("always", fn);
+}
+__name(always, "always");
+function optional(fn) {
+  return make("optional", fn);
+}
+__name(optional, "optional");
+var _lazyWarned = false;
+function lazy(fn) {
+  if (!_lazyWarned) {
+    _lazyWarned = true;
+    console.warn("[nestjs-inertia] Inertia.lazy() is deprecated and will be removed in a future version. Use Inertia.optional() instead (Inertia v3).");
+  }
+  return optional(fn);
+}
+__name(lazy, "lazy");
+function defer(fn, group = "default") {
+  return make("defer", fn, {
+    group
+  });
+}
+__name(defer, "defer");
+function once(fn) {
+  return make("once", fn);
+}
+__name(once, "once");
+function merge(fn, opts) {
+  const meta = {
+    deep: opts?.deep ?? false
+  };
+  if (opts?.matchOn !== void 0) meta.matchOn = opts.matchOn;
+  return make("merge", fn, meta);
+}
+__name(merge, "merge");
+var Inertia = Object.assign(inertiaDecorator, {
+  always,
+  optional,
+  lazy,
+  defer,
+  once,
+  merge
+});
+function isMarker(value) {
+  return typeof value === "object" && value !== null && value[MARKER] === true;
+}
+__name(isMarker, "isMarker");
+function getMarkerKind(marker) {
+  return marker.kind;
+}
+__name(getMarkerKind, "getMarkerKind");
+function getMarkerValue(marker) {
+  return marker.value;
+}
+__name(getMarkerValue, "getMarkerValue");
+function getMarkerMeta(marker) {
+  return marker.meta;
+}
+__name(getMarkerMeta, "getMarkerMeta");
+
+// src/decorator/use-inertia.decorator.ts
+var import_common6 = require("@nestjs/common");
+var INERTIA_USE_SCOPE = "INERTIA_USE_SCOPE";
+function UseInertia(scope) {
+  return (0, import_common6.SetMetadata)(INERTIA_USE_SCOPE, scope);
+}
+__name(UseInertia, "UseInertia");
+
+// src/interceptor/render.interceptor.ts
+var import_common7 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+var import_rxjs = require("rxjs");
+var import_operators3 = require("rxjs/operators");
+init_exceptions();
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var InertiaRenderInterceptor = class {
+  static {
+    __name(this, "InertiaRenderInterceptor");
+  }
+  reflector;
+  constructor(reflector) {
+    this.reflector = reflector;
+  }
+  intercept(context, next) {
+    const component = this.reflector.get(INERTIA_RENDER_COMPONENT, context.getHandler());
+    if (!component) {
+      return next.handle();
+    }
+    const req = context.switchToHttp().getRequest();
+    const res = context.switchToHttp().getResponse();
+    return next.handle().pipe((0, import_operators3.switchMap)((returnValue) => {
+      if (res.headersSent) {
+        return (0, import_rxjs.of)(void 0);
+      }
+      if (!req.inertia) {
+        throw new InertiaServiceNotAvailableException();
+      }
+      const props = returnValue ?? {};
+      return (0, import_rxjs.from)(req.inertia.render(component, props)).pipe((0, import_operators3.switchMap)(() => (0, import_rxjs.of)(void 0)));
+    }));
+  }
+};
+InertiaRenderInterceptor = _ts_decorate4([
+  (0, import_common7.Injectable)(),
+  _ts_param3(0, (0, import_common7.Inject)(import_core.Reflector)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof import_core.Reflector === "undefined" ? Object : import_core.Reflector
+  ])
+], InertiaRenderInterceptor);
+
+// src/service.ts
+var import_common8 = require("@nestjs/common");
+
+// src/helpers/nullify-undefined.ts
+function nullifyUndefined(props) {
+  const out = {};
+  for (const [k, v] of Object.entries(props)) {
+    out[k] = v === void 0 ? null : v;
+  }
+  return out;
+}
+__name(nullifyUndefined, "nullifyUndefined");
+
+// src/helpers/set-nested.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+function assertSafeKey(key) {
+  if (FORBIDDEN_KEYS.has(key)) {
+    throw new Error(`[nestjs-inertia] Disallowed property key in nested path: "${key}"`);
+  }
+}
+__name(assertSafeKey, "assertSafeKey");
+function setNested(target, path, value) {
+  if (path.length === 0) return;
+  let cur = target;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    assertSafeKey(key);
+    const existing = cur[key];
+    if (existing === void 0) {
+      cur[key] = {};
+    } else if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+      throw new Error(`[nestjs-inertia] dot-notation conflict at key "${path.slice(0, i + 1).join(".")}": expected object, got ${Array.isArray(existing) ? "array" : typeof existing}`);
+    }
+    cur = cur[key];
+  }
+  const finalKey = path[path.length - 1];
+  assertSafeKey(finalKey);
+  cur[finalKey] = value;
+}
+__name(setNested, "setNested");
+function unpackDotKeys(props) {
+  const out = {};
+  const dotKeysParents = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(props)) {
+    if (key.includes(".")) {
+      dotKeysParents.add(key.split(".")[0]);
+    }
+  }
+  for (const parent of dotKeysParents) {
+    if (props[parent] !== void 0 && (typeof props[parent] !== "object" || props[parent] === null || Array.isArray(props[parent]))) {
+      throw new Error(`[nestjs-inertia] dot-notation conflict at key "${parent}": exists as scalar AND as parent of a dot key`);
+    }
+  }
+  for (const [key, value] of Object.entries(props)) {
+    if (key.includes(".")) {
+      setNested(out, key.split("."), value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+__name(unpackDotKeys, "unpackDotKeys");
+
+// src/service.ts
+function validateLocationUrl(url) {
+  if (url.startsWith("/")) return url;
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error(`[nestjs-inertia] location() rejected unsafe URL scheme: ${url}`);
+    }
+    throw new Error(`[nestjs-inertia] location() rejected absolute URL to external host: ${url}. Use a relative path (e.g. "/dashboard") instead.`);
+  } catch (err) {
+    if (err instanceof TypeError) {
+      return url;
+    }
+    throw err;
+  }
+}
+__name(validateLocationUrl, "validateLocationUrl");
+var OMIT = /* @__PURE__ */ Symbol("inertia.omit");
+function containsAlwaysMarker(value) {
+  if (isMarker(value)) {
+    return getMarkerKind(value) === "always";
+  }
+  if (Array.isArray(value)) {
+    return value.some(containsAlwaysMarker);
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.values(value).some(containsAlwaysMarker);
+  }
+  return false;
+}
+__name(containsAlwaysMarker, "containsAlwaysMarker");
+async function resolveNestedObjectValue(obj, topKey, subKeep, deferredProps) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const resolved = await resolveNestedValueInner(v, k, topKey, subKeep, deferredProps);
+    if (resolved !== OMIT) out[k] = resolved;
+  }
+  return out;
+}
+__name(resolveNestedObjectValue, "resolveNestedObjectValue");
+async function resolveNestedValueInner(value, relPath, topKey, subKeep, deferredProps) {
+  if (isMarker(value)) {
+    return resolveMarker(value, relPath, topKey, subKeep, deferredProps);
+  }
+  if (Array.isArray(value)) {
+    const out = [];
+    for (const item of value) {
+      const resolved = await resolveNestedValueInner(item, relPath, topKey, subKeep, deferredProps);
+      if (resolved !== OMIT) out.push(resolved);
+    }
+    return out;
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      const childPath = `${relPath}.${k}`;
+      const resolved = await resolveNestedValueInner(v, childPath, topKey, subKeep, deferredProps);
+      if (resolved !== OMIT) out[k] = resolved;
+    }
+    return out;
+  }
+  if (subKeep !== null) {
+    const included = subKeep.some((k) => k === relPath || k.startsWith(`${relPath}.`));
+    if (!included) return OMIT;
+  }
+  return value;
+}
+__name(resolveNestedValueInner, "resolveNestedValueInner");
+async function resolveMarker(marker, relPath, topKey, subKeep, deferredProps) {
+  const kind = getMarkerKind(marker);
+  const fullPath = `${topKey}.${relPath}`;
+  if (kind === "always") {
+    return getMarkerValue(marker)();
+  }
+  if (kind === "optional") {
+    if (subKeep?.includes(relPath)) {
+      return getMarkerValue(marker)();
+    }
+    return OMIT;
+  }
+  if (kind === "once") {
+    if (subKeep === null) {
+      return getMarkerValue(marker)();
+    }
+    return OMIT;
+  }
+  if (kind === "defer") {
+    if (subKeep !== null) {
+      if (subKeep.includes(relPath)) return getMarkerValue(marker)();
+      return OMIT;
+    }
+    const meta = getMarkerMeta(marker);
+    const group = meta.group;
+    const existing = deferredProps[group];
+    if (existing) existing.push(fullPath);
+    else deferredProps[group] = [
+      fullPath
+    ];
+    return OMIT;
+  }
+  if (kind === "merge") {
+    if (subKeep !== null && !subKeep.includes(relPath)) return OMIT;
+    return getMarkerValue(marker)();
+  }
+  return OMIT;
+}
+__name(resolveMarker, "resolveMarker");
+var InertiaService = class _InertiaService {
+  static {
+    __name(this, "InertiaService");
+  }
+  req;
+  res;
+  deps;
+  logger = new import_common8.Logger(_InertiaService.name);
+  shared = [];
+  encryptHistoryFlag;
+  clearHistoryFlag = false;
+  constructor(req, res, deps) {
+    this.req = req;
+    this.res = res;
+    this.deps = deps;
+  }
+  share(input) {
+    this.shared.push(input);
+    return this;
+  }
+  /**
+  * Perform an Inertia redirect. For Inertia XHR requests, issues a 409 with
+  * `X-Inertia-Location`; for plain browser visits, issues a 302 redirect.
+  *
+  * Only relative URLs (starting with `/`) or same-origin absolute URLs are
+  * accepted. Absolute URLs pointing to a different host are rejected to prevent
+  * open-redirect vulnerabilities.
+  *
+  * @param url Relative path (e.g. `/dashboard`) or same-origin absolute URL.
+  * @throws Error when `url` is an absolute URL pointing to a different origin.
+  */
+  location(url) {
+    const safeUrl = validateLocationUrl(url);
+    if (this.req.header("X-Inertia")) {
+      this.res.status(409).setHeader("X-Inertia-Location", safeUrl).end();
+    } else {
+      this.res.status(302).setHeader("Location", safeUrl).end();
+    }
+  }
+  encryptHistory(value = true) {
+    this.encryptHistoryFlag = value;
+    return this;
+  }
+  clearHistory() {
+    this.clearHistoryFlag = true;
+    return this;
+  }
+  async resolveShared() {
+    const sources = [];
+    if (this.deps.moduleShare !== void 0) sources.push(this.deps.moduleShare);
+    if (this.deps.featureShare !== void 0) sources.push(this.deps.featureShare);
+    sources.push(...this.shared);
+    const out = {};
+    for (const s of sources) {
+      const resolved = typeof s === "function" ? await s(this.req) : s;
+      Object.assign(out, resolved);
+    }
+    return out;
+  }
+  async render(component, props = {}) {
+    const clientVersion = this.req.header("X-Inertia-Version");
+    if (this.req.method === "GET" && this.req.header("X-Inertia") && clientVersion !== void 0 && clientVersion !== this.deps.assetVersion) {
+      this.res.status(409).setHeader("X-Inertia-Location", this.req.originalUrl).end();
+      return;
+    }
+    if (this.deps.flashStore && props.errors === void 0) {
+      try {
+        const flashed = await this.deps.flashStore.read(this.req.raw);
+        if (flashed && Object.keys(flashed).length > 0) {
+          this.share({
+            errors: flashed
+          });
+        }
+      } catch (err) {
+        this.logger.warn(`FlashStore.read() threw: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const sharedProps = await this.resolveShared();
+    const rawProps = {
+      ...sharedProps,
+      ...props
+    };
+    if (rawProps.errors === void 0) rawProps.errors = {};
+    const partialComponent = this.req.header("X-Inertia-Partial-Component");
+    const isPartial = partialComponent === component;
+    const partialDataHeader = this.req.header("X-Inertia-Partial-Data");
+    const keepList = isPartial && partialDataHeader ? partialDataHeader.split(",").filter(Boolean) : null;
+    const keep = keepList && keepList.length > 0 ? keepList : null;
+    const resetHeader = this.req.header("X-Inertia-Reset");
+    const resetKeys = (resetHeader ?? "").split(",").filter(Boolean);
+    const resetOnceHeader = this.req.header("X-Inertia-Reset-Once");
+    const resetOnceKeys = (resetOnceHeader ?? "").split(",").filter(Boolean);
+    const exceptHeader = this.req.header("X-Inertia-Partial-Except");
+    const exceptKeys = isPartial ? (exceptHeader ?? "").split(",").filter(Boolean) : [];
+    const finalProps = {};
+    const deferredProps = {};
+    const mergeProps = [];
+    const deepMergeProps = [];
+    const matchPropsOn = {};
+    for (const [key, value] of Object.entries(rawProps)) {
+      if (exceptKeys.includes(key) && key !== "errors") continue;
+      if (isMarker(value)) {
+        const kind = getMarkerKind(value);
+        if (kind === "always") {
+          finalProps[key] = await getMarkerValue(value)();
+          continue;
+        }
+        if (kind === "optional") {
+          if (keep?.includes(key)) {
+            finalProps[key] = await getMarkerValue(value)();
+          }
+          continue;
+        }
+        if (kind === "once") {
+          if (!keep || resetOnceKeys.includes(key)) {
+            finalProps[key] = await getMarkerValue(value)();
+          }
+          continue;
+        }
+        if (kind === "defer") {
+          if (keep) {
+            if (keep.includes(key)) finalProps[key] = await getMarkerValue(value)();
+            continue;
+          }
+          const meta = getMarkerMeta(value);
+          const group = meta.group;
+          const existing = deferredProps[group];
+          if (existing) existing.push(key);
+          else deferredProps[group] = [
+            key
+          ];
+          continue;
+        }
+        if (kind === "merge") {
+          const meta = getMarkerMeta(value);
+          if (keep && !keep.includes(key) && key !== "errors") continue;
+          const resolved2 = await getMarkerValue(value)();
+          finalProps[key] = resolved2;
+          if (!resetKeys.includes(key)) {
+            if (meta.deep) deepMergeProps.push(key);
+            else mergeProps.push(key);
+          }
+          if (meta.matchOn !== void 0) matchPropsOn[key] = meta.matchOn;
+          continue;
+        }
+      }
+      const hasNestedKeepPath = keep?.some((k) => k.startsWith(`${key}.`)) ?? false;
+      const hasNestedAlways = keep ? containsAlwaysMarker(value) : false;
+      if (keep && !keep.includes(key) && key !== "errors" && !hasNestedKeepPath && !hasNestedAlways) continue;
+      let resolved = value;
+      if (typeof value === "function") {
+        resolved = await value();
+      }
+      let nestedKeep = null;
+      if (keep !== null) {
+        if (keep.includes(key)) {
+          nestedKeep = null;
+        } else {
+          nestedKeep = keep.filter((k) => k.startsWith(`${key}.`)).map((k) => k.slice(key.length + 1));
+        }
+      }
+      if (typeof resolved === "object" && resolved !== null && !Array.isArray(resolved)) {
+        resolved = await resolveNestedObjectValue(resolved, key, nestedKeep, deferredProps);
+      }
+      finalProps[key] = resolved;
+    }
+    const unpackedProps = unpackDotKeys(finalProps);
+    const wireProps = nullifyUndefined(unpackedProps);
+    const page = {
+      component,
+      props: wireProps,
+      url: this.req.originalUrl,
+      version: this.deps.assetVersion
+    };
+    if (Object.keys(deferredProps).length > 0) page.deferredProps = deferredProps;
+    if (mergeProps.length > 0) page.mergeProps = mergeProps;
+    if (deepMergeProps.length > 0) page.deepMergeProps = deepMergeProps;
+    if (Object.keys(matchPropsOn).length > 0) page.matchPropsOn = matchPropsOn;
+    const encryptHistory = this.encryptHistoryFlag !== void 0 ? this.encryptHistoryFlag : this.deps.historyEncryptionDefault ?? false;
+    if (encryptHistory) page.encryptHistory = true;
+    if (this.clearHistoryFlag) page.clearHistory = true;
+    if (this.req.header("X-Inertia")) {
+      this.res.setHeader("X-Inertia", "true").setHeader("Vary", "X-Inertia").json(page);
+      return;
+    }
+    const ssrModule = await this.deps.ssrLoader.load();
+    const ssr = ssrModule ? await ssrModule.render(page) : null;
+    const html = await this.deps.rootViewRender({
+      page,
+      ssr,
+      manifest: this.deps.manifest,
+      assetVersion: this.deps.assetVersion,
+      ctx: {
+        req: this.req.raw,
+        res: this.res.raw
+      }
+    });
+    this.res.setHeader("Vary", "X-Inertia").html(html);
+  }
+};
+
+// src/module.ts
+var import_common12 = require("@nestjs/common");
+var import_core3 = require("@nestjs/core");
+
+// src/asset/version.provider.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var DEFAULT_MANIFEST_PATH = "dist/inertia/client/.vite/manifest.json";
+function assertManifestShape(parsed, path) {
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Vite manifest at ${path} has unexpected shape: expected a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+  }
+  for (const [key, entry] of Object.entries(parsed)) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      throw new Error(`Vite manifest at ${path} has unexpected shape: entry "${key}" is not an object`);
+    }
+    const e = entry;
+    if (typeof e.file !== "string") {
+      throw new Error(`Vite manifest at ${path} has unexpected shape: entry "${key}" is missing required string field "file"`);
+    }
+  }
+  return parsed;
+}
+__name(assertManifestShape, "assertManifestShape");
+function loadManifest(path) {
+  try {
+    const abs = (0, import_node_path.isAbsolute)(path) ? path : (0, import_node_path.resolve)(process.cwd(), path);
+    const raw = (0, import_node_fs.readFileSync)(abs, "utf8");
+    const parsed = JSON.parse(raw);
+    return assertManifestShape(parsed, abs);
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Vite manifest at")) {
+      throw err;
+    }
+    return null;
+  }
+}
+__name(loadManifest, "loadManifest");
+function computeAssetVersion(manifest) {
+  if (manifest) {
+    return (0, import_node_crypto.createHash)("sha1").update(JSON.stringify(manifest)).digest("hex").slice(0, 32);
+  }
+  return (0, import_node_crypto.randomUUID)().replace(/-/g, "");
+}
+__name(computeAssetVersion, "computeAssetVersion");
+var manifestProvider = {
+  provide: INERTIA_MANIFEST,
+  inject: [
+    INERTIA_MODULE_OPTIONS
+  ],
+  useFactory: /* @__PURE__ */ __name((opts) => {
+    if (process.env.NODE_ENV !== "production") return null;
+    const path = opts.vite?.manifestPath ?? DEFAULT_MANIFEST_PATH;
+    return loadManifest(path);
+  }, "useFactory")
+};
+var assetVersionProvider = {
+  provide: INERTIA_ASSET_VERSION,
+  inject: [
+    INERTIA_MANIFEST,
+    INERTIA_MODULE_OPTIONS
+  ],
+  useFactory: /* @__PURE__ */ __name(async (manifest, opts) => {
+    if (opts.version !== void 0) {
+      return typeof opts.version === "function" ? await opts.version() : opts.version;
+    }
+    return computeAssetVersion(manifest);
+  }, "useFactory")
+};
+
+// src/module.ts
+init_exceptions();
+
+// src/interceptor/scope-switcher.interceptor.ts
+var import_common9 = require("@nestjs/common");
+var import_core2 = require("@nestjs/core");
+
+// src/adapter/express.ts
+var expressAdapter = {
+  adaptRequest(raw) {
+    const r = raw;
+    const req = {
+      method: r.method,
+      originalUrl: r.originalUrl,
+      url: r.url,
+      header(name) {
+        if (typeof r.header === "function") return r.header(name);
+        const v = r.headers[name.toLowerCase()];
+        return Array.isArray(v) ? v[0] : v;
+      },
+      raw
+    };
+    if (r.body !== void 0) req.body = r.body;
+    if (r.query !== void 0) req.query = r.query;
+    return req;
+  },
+  adaptResponse(raw) {
+    const r = raw;
+    const wrapper = {
+      get statusCode() {
+        return r.statusCode;
+      },
+      get headersSent() {
+        return r.headersSent;
+      },
+      status(code) {
+        r.status(code);
+        return wrapper;
+      },
+      setHeader(name, value) {
+        r.setHeader(name, value);
+        return wrapper;
+      },
+      getHeader(name) {
+        return r.getHeader(name);
+      },
+      json(body) {
+        r.json(body);
+      },
+      html(body) {
+        r.setHeader("Content-Type", "text/html; charset=utf-8");
+        r.send(body);
+      },
+      end() {
+        r.end();
+      },
+      raw
+    };
+    return wrapper;
+  }
+};
+
+// src/adapter/fastify.ts
+var fastifyAdapter = {
+  adaptRequest(raw) {
+    const r = raw;
+    const req = {
+      method: r.method,
+      originalUrl: r.raw?.originalUrl ?? r.url,
+      url: r.url,
+      header(name) {
+        const v = r.headers[name.toLowerCase()];
+        return Array.isArray(v) ? v[0] : v;
+      },
+      raw
+    };
+    if (r.body !== void 0) req.body = r.body;
+    if (r.query !== void 0) req.query = r.query;
+    return req;
+  },
+  adaptResponse(raw) {
+    const r = raw;
+    const wrapper = {
+      get statusCode() {
+        return r.statusCode;
+      },
+      get headersSent() {
+        return r.sent;
+      },
+      status(code) {
+        r.code(code);
+        return wrapper;
+      },
+      setHeader(name, value) {
+        r.header(name, value);
+        return wrapper;
+      },
+      getHeader(name) {
+        return r.getHeader(name);
+      },
+      json(body) {
+        r.send(body);
+      },
+      html(body) {
+        r.header("Content-Type", "text/html; charset=utf-8");
+        r.send(body);
+      },
+      end() {
+        r.send("");
+      },
+      raw
+    };
+    return wrapper;
+  }
+};
+
+// src/interceptor/scope-switcher.interceptor.ts
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var InertiaScopeSwitcherInterceptor = class {
+  static {
+    __name(this, "InertiaScopeSwitcherInterceptor");
+  }
+  reflector;
+  moduleRef;
+  httpAdapterHost;
+  constructor(reflector, moduleRef, httpAdapterHost) {
+    this.reflector = reflector;
+    this.moduleRef = moduleRef;
+    this.httpAdapterHost = httpAdapterHost;
+  }
+  intercept(ctx, next) {
+    const scope = this.reflector.getAllAndOverride(INERTIA_USE_SCOPE, [
+      ctx.getHandler(),
+      ctx.getClass()
+    ]);
+    if (scope && scope !== "default") {
+      const opts = this.moduleRef.get(featureToken("OPTIONS", scope), {
+        strict: false
+      });
+      const manifest = this.moduleRef.get(featureToken("MANIFEST", scope), {
+        strict: false
+      });
+      const assetVersion = this.moduleRef.get(featureToken("ASSET_VERSION", scope), {
+        strict: false
+      });
+      const shellRenderer = this.moduleRef.get(featureToken("SHELL_RENDERER", scope), {
+        strict: false
+      });
+      const ssrLoader = this.moduleRef.get(featureToken("SSR_LOADER", scope), {
+        strict: false
+      });
+      const req = ctx.switchToHttp().getRequest();
+      const res = ctx.switchToHttp().getResponse();
+      const deps = {
+        assetVersion,
+        manifest,
+        ssrLoader,
+        rootViewRender: /* @__PURE__ */ __name((c) => shellRenderer.render(c), "rootViewRender"),
+        moduleShare: opts.share,
+        featureShare: void 0,
+        historyEncryptionDefault: opts.historyEncryption?.default ?? false,
+        flashStore: opts.flashStore
+      };
+      const platform = this.httpAdapterHost.httpAdapter?.getType();
+      const adapter = platform === "fastify" ? fastifyAdapter : expressAdapter;
+      req.inertia = new InertiaService(adapter.adaptRequest(req), adapter.adaptResponse(res), deps);
+    }
+    return next.handle();
+  }
+};
+InertiaScopeSwitcherInterceptor = _ts_decorate5([
+  (0, import_common9.Injectable)(),
+  _ts_param4(0, (0, import_common9.Inject)(import_core2.Reflector)),
+  _ts_param4(1, (0, import_common9.Inject)(import_core2.ModuleRef)),
+  _ts_param4(2, (0, import_common9.Inject)(import_core2.HttpAdapterHost)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof import_core2.Reflector === "undefined" ? Object : import_core2.Reflector,
+    typeof import_core2.ModuleRef === "undefined" ? Object : import_core2.ModuleRef,
+    typeof import_core2.HttpAdapterHost === "undefined" ? Object : import_core2.HttpAdapterHost
+  ])
+], InertiaScopeSwitcherInterceptor);
+
+// src/middleware/express.middleware.ts
+var import_common10 = require("@nestjs/common");
+
+// src/helpers/suppress-post-send-writes.ts
+var KEYS = [
+  "status",
+  "json",
+  "send",
+  "header",
+  "setHeader",
+  "end"
+];
+function suppressPostSendWrites(res) {
+  for (const key of KEYS) {
+    const original = res[key].bind(res);
+    res[key] = (...args) => res.headersSent ? res : original(...args);
+  }
+}
+__name(suppressPostSendWrites, "suppressPostSendWrites");
+
+// src/middleware/express.middleware.ts
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var InertiaMiddleware = class {
+  static {
+    __name(this, "InertiaMiddleware");
+  }
+  assetVersion;
+  manifest;
+  options;
+  shellRenderer;
+  ssrLoader;
+  constructor(assetVersion, manifest, options, shellRenderer, ssrLoader) {
+    this.assetVersion = assetVersion;
+    this.manifest = manifest;
+    this.options = options;
+    this.shellRenderer = shellRenderer;
+    this.ssrLoader = ssrLoader;
+  }
+  use(req, res, next) {
+    const adaptedReq = expressAdapter.adaptRequest(req);
+    const adaptedRes = expressAdapter.adaptResponse(res);
+    req.inertia = new InertiaService(adaptedReq, adaptedRes, {
+      assetVersion: this.assetVersion,
+      manifest: this.manifest,
+      ssrLoader: this.ssrLoader,
+      rootViewRender: /* @__PURE__ */ __name((ctx) => this.shellRenderer.render(ctx), "rootViewRender"),
+      moduleShare: this.options.share,
+      featureShare: void 0,
+      historyEncryptionDefault: this.options.historyEncryption?.default ?? false,
+      flashStore: this.options.flashStore
+    });
+    suppressPostSendWrites(res);
+    next();
+  }
+};
+InertiaMiddleware = _ts_decorate6([
+  (0, import_common10.Injectable)(),
+  _ts_param5(0, (0, import_common10.Inject)(INERTIA_ASSET_VERSION)),
+  _ts_param5(1, (0, import_common10.Inject)(INERTIA_MANIFEST)),
+  _ts_param5(2, (0, import_common10.Inject)(INERTIA_MODULE_OPTIONS)),
+  _ts_param5(3, (0, import_common10.Inject)("INERTIA_SHELL_RENDERER")),
+  _ts_param5(4, (0, import_common10.Inject)("INERTIA_SSR_LOADER")),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    String,
+    Object,
+    typeof InertiaModuleOptions === "undefined" ? Object : InertiaModuleOptions,
+    typeof ShellRenderer === "undefined" ? Object : ShellRenderer,
+    typeof SsrLoader === "undefined" ? Object : SsrLoader
+  ])
+], InertiaMiddleware);
+
+// src/middleware/fastify.middleware.ts
+function registerFastifyInertia(app, depsFactory) {
+  const appAsAny = app;
+  if (appAsAny._inertiaRegistered) return;
+  appAsAny._inertiaRegistered = true;
+  app.decorateRequest("inertia", null);
+  app.addHook("onRequest", async (req, reply) => {
+    const adaptedReq = fastifyAdapter.adaptRequest(req);
+    const adaptedRes = fastifyAdapter.adaptResponse(reply);
+    req.inertia = new InertiaService(adaptedReq, adaptedRes, depsFactory());
+  });
+}
+__name(registerFastifyInertia, "registerFastifyInertia");
+
+// src/shell/file-shell.renderer.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+init_exceptions();
+
+// src/shell/directives.ts
+var VITE_REFRESH_PREAMBLE = `<script type="module">
+import RefreshRuntime from "/@react-refresh"
+RefreshRuntime.injectIntoGlobalHook(window)
+window.$RefreshReg$ = () => {}
+window.$RefreshSig$ = () => (type) => type
+window.__vite_plugin_react_preamble_installed__ = true
+</script>`;
+function processDirectives(template, ctx) {
+  let out = template;
+  out = out.replace(/@inertiaHead\b/g, () => ctx.ssrHead);
+  out = out.replace(/@inertia(?![a-zA-Z(])/g, () => {
+    if (ctx.ssrBody) return ctx.ssrBody;
+    return `<div id="app"></div>
+<script id="inertia-page" type="application/json">${ctx.pageJson}</script>`;
+  });
+  out = out.replace(/@viteRefresh\b/g, () => ctx.isDev ? VITE_REFRESH_PREAMBLE : "");
+  out = out.replace(/@vite\(\s*['"]([^'"]+)['"]\s*\)/g, (_full, entry) => {
+    if (ctx.isDev) {
+      return `<script type="module" src="/@vite/client"></script>
+<script type="module" src="/${entry}"></script>`;
+    }
+    const entryRecord = ctx.manifest?.[entry];
+    if (!entryRecord) {
+      throw new Error(`[nestjs-inertia] manifest entry not found for "${entry}"`);
+    }
+    const scriptTag = `<script type="module" src="/${entryRecord.file}"></script>`;
+    const cssTags = (entryRecord.css ?? []).map((href) => `<link rel="stylesheet" href="/${href}" />`).join("\n");
+    return [
+      scriptTag,
+      cssTags
+    ].filter(Boolean).join("\n");
+  });
+  out = out.replace(/@asset\(\s*['"]([^'"]+)['"]\s*\)/g, (_full, path) => {
+    if (ctx.isDev) return `/${path}`;
+    const entry = ctx.manifest?.[path];
+    return entry ? `/${entry.file}` : `/${path}`;
+  });
+  return out;
+}
+__name(processDirectives, "processDirectives");
+
+// src/shell/serialize-page.ts
+var LS = "\u2028";
+var PS = "\u2029";
+var UNSAFE_CHARS = new RegExp(`[<>&${LS}${PS}]`, "g");
+function serializePageData(page) {
+  return JSON.stringify(page).replace(UNSAFE_CHARS, (c) => {
+    switch (c) {
+      case "<":
+        return "\\u003c";
+      case ">":
+        return "\\u003e";
+      case "&":
+        return "\\u0026";
+      case LS:
+        return "\\u2028";
+      case PS:
+        return "\\u2029";
+      default:
+        return c;
+    }
+  });
+}
+__name(serializePageData, "serializePageData");
+
+// src/shell/template-engine.registry.ts
+init_exceptions();
+var registry = {
+  ".hbs": /* @__PURE__ */ __name(() => Promise.resolve().then(() => (init_handlebars_adapter(), handlebars_adapter_exports)).then((m) => m.handlebarsAdapter), ".hbs"),
+  ".handlebars": /* @__PURE__ */ __name(() => Promise.resolve().then(() => (init_handlebars_adapter(), handlebars_adapter_exports)).then((m) => m.handlebarsAdapter), ".handlebars"),
+  ".ejs": /* @__PURE__ */ __name(() => Promise.resolve().then(() => (init_ejs_adapter(), ejs_adapter_exports)).then((m) => m.ejsAdapter), ".ejs"),
+  ".pug": /* @__PURE__ */ __name(() => Promise.resolve().then(() => (init_pug_adapter(), pug_adapter_exports)).then((m) => m.pugAdapter), ".pug"),
+  ".liquid": /* @__PURE__ */ __name(() => Promise.resolve().then(() => (init_liquid_adapter(), liquid_adapter_exports)).then((m) => m.liquidAdapter), ".liquid"),
+  ".liquidjs": /* @__PURE__ */ __name(() => Promise.resolve().then(() => (init_liquid_adapter(), liquid_adapter_exports)).then((m) => m.liquidAdapter), ".liquidjs")
+};
+async function resolveTemplateEngine(extension) {
+  const loader = registry[extension.toLowerCase()];
+  if (!loader) {
+    throw new UnsupportedRootViewExtensionException(extension);
+  }
+  return loader();
+}
+__name(resolveTemplateEngine, "resolveTemplateEngine");
+
+// src/shell/file-shell.renderer.ts
+var PLAIN_HTML = /* @__PURE__ */ new Set([
+  ".html",
+  ".htm"
+]);
+var TEMPLATE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".hbs",
+  ".handlebars",
+  ".ejs",
+  ".pug",
+  ".liquid",
+  ".liquidjs"
+]);
+var FileBasedShellRenderer = class {
+  static {
+    __name(this, "FileBasedShellRenderer");
+  }
+  cachedTemplate = null;
+  engineRenderer = null;
+  adapterPromise = null;
+  absPath;
+  ext;
+  constructor(rootViewPath) {
+    const ext = (0, import_node_path2.extname)(rootViewPath).toLowerCase();
+    if (!PLAIN_HTML.has(ext) && !TEMPLATE_EXTENSIONS.has(ext)) {
+      throw new UnsupportedRootViewExtensionException(ext);
+    }
+    this.ext = ext;
+    this.absPath = (0, import_node_path2.isAbsolute)(rootViewPath) ? rootViewPath : (0, import_node_path2.resolve)(process.cwd(), rootViewPath);
+  }
+  async render(ctx) {
+    if (this.cachedTemplate === null) {
+      this.cachedTemplate = (0, import_node_fs2.readFileSync)(this.absPath, "utf8");
+    }
+    const pageJson = serializePageData(ctx.page);
+    const ssrHead = ctx.ssr?.head.join("\n") ?? "";
+    const ssrBody = ctx.ssr?.body ?? null;
+    const isDev = process.env.NODE_ENV !== "production";
+    const manifest = ctx.manifest;
+    if (PLAIN_HTML.has(this.ext)) {
+      return processDirectives(this.cachedTemplate, {
+        pageJson,
+        ssrHead,
+        ssrBody,
+        manifest,
+        isDev
+      });
+    }
+    if (this.adapterPromise === null) {
+      this.adapterPromise = resolveTemplateEngine(this.ext);
+    }
+    if (this.engineRenderer === null) {
+      const adapter = await this.adapterPromise;
+      this.engineRenderer = adapter.compile(this.cachedTemplate, this.absPath);
+    }
+    const inertiaHtml = ssrBody ?? `<div id="app"></div>
+<script id="inertia-page" type="application/json">${pageJson}</script>`;
+    const directiveCtx = {
+      pageJson,
+      ssrHead,
+      ssrBody,
+      manifest,
+      isDev
+    };
+    const locals = {
+      page: ctx.page,
+      inertia: inertiaHtml,
+      inertiaHead: ssrHead,
+      vite: /* @__PURE__ */ __name((entry) => processDirectives(`@vite('${entry}')`, directiveCtx), "vite"),
+      viteRefresh: processDirectives("@viteRefresh", directiveCtx),
+      asset: /* @__PURE__ */ __name((p) => processDirectives(`@asset('${p}')`, directiveCtx), "asset")
+    };
+    let output = await this.engineRenderer(locals);
+    output = processDirectives(output, directiveCtx);
+    return output;
+  }
+};
+
+// src/shell/shell.ts
+var DefaultShellRenderer = class {
+  static {
+    __name(this, "DefaultShellRenderer");
+  }
+  async render(ctx) {
+    const pageJson = serializePageData(ctx.page);
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Inertia</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script id="inertia-page" type="application/json">${pageJson}</script>
+  </body>
+</html>`;
+  }
+};
+
+// src/ssr/ssr-loader.service.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+var import_node_url = require("url");
+var import_common11 = require("@nestjs/common");
+function _ts_decorate7(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_ts_param");
+function isVitest() {
+  return process.env.VITEST === "true" || process.env.NODE_ENV === "test";
+}
+__name(isVitest, "isVitest");
+var SsrLoaderService = class _SsrLoaderService {
+  static {
+    __name(this, "SsrLoaderService");
+  }
+  opts;
+  logger = new import_common11.Logger(_SsrLoaderService.name);
+  cached = null;
+  failed = false;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async load() {
+    if (!this.opts.ssr?.enabled) return null;
+    if (this.cached) return this.cached;
+    if (this.failed) return null;
+    try {
+      const bundlePath = (0, import_node_path3.resolve)(process.cwd(), this.opts.ssr.bundlePath ?? "dist/inertia/ssr/ssr.mjs");
+      let mod;
+      if (isVitest()) {
+        const code = (0, import_node_fs3.readFileSync)(bundlePath, "utf8");
+        const dataUrl = `data:text/javascript;base64,${Buffer.from(code, "utf8").toString("base64")}`;
+        mod = await import(
+          /* @vite-ignore */
+          dataUrl
+        );
+      } else {
+        const fileUrl = (0, import_node_url.pathToFileURL)(bundlePath).href;
+        mod = await import(
+          /* @vite-ignore */
+          fileUrl
+        );
+      }
+      if (mod.default && typeof mod.default.render === "function") {
+        this.cached = mod.default;
+      } else if (typeof mod.render === "function") {
+        this.cached = {
+          render: mod.render
+        };
+      } else {
+        if (this.opts.ssr.throwOnError) throw new Error("SSR bundle exports neither default nor render()");
+        this.failed = true;
+        this.logger.warn("SSR bundle missing required exports; falling back to CSR.");
+        return null;
+      }
+      return this.cached;
+    } catch (err) {
+      this.failed = true;
+      if (this.opts.ssr.throwOnError) throw err;
+      this.logger.warn(`SSR bundle not loaded, falling back to CSR: ${err.message}`);
+      return null;
+    }
+  }
+};
+SsrLoaderService = _ts_decorate7([
+  (0, import_common11.Injectable)(),
+  _ts_param6(0, (0, import_common11.Inject)(INERTIA_MODULE_OPTIONS)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof InertiaModuleOptions === "undefined" ? Object : InertiaModuleOptions
+  ])
+], SsrLoaderService);
+
+// src/module.ts
+function _ts_decorate8(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param7, "_ts_param");
+var InertiaModule = class _InertiaModule {
+  static {
+    __name(this, "InertiaModule");
+  }
+  httpAdapterHost;
+  options;
+  assetVersion;
+  manifest;
+  shellRenderer;
+  ssrLoader;
+  /**
+  * Shared provider set for both `forRoot` and `forRootAsync`.
+  * Does NOT include the options provider(s) — callers prepend those themselves.
+  */
+  static buildModuleProviders() {
+    const shellProvider = {
+      provide: "INERTIA_SHELL_RENDERER",
+      inject: [
+        INERTIA_MODULE_OPTIONS
+      ],
+      useFactory: /* @__PURE__ */ __name((opts) => {
+        const rv = opts.rootView;
+        if (typeof rv === "function") {
+          const fn = rv;
+          return {
+            render: /* @__PURE__ */ __name(async (ctx) => fn(ctx), "render")
+          };
+        }
+        if (typeof rv === "string") {
+          return new FileBasedShellRenderer(rv);
+        }
+        return new DefaultShellRenderer();
+      }, "useFactory")
+    };
+    const ssrProvider = {
+      provide: "INERTIA_SSR_LOADER",
+      useClass: SsrLoaderService
+    };
+    return [
+      manifestProvider,
+      assetVersionProvider,
+      shellProvider,
+      ssrProvider,
+      InertiaMiddleware,
+      MethodSpoofMiddleware,
+      {
+        provide: import_core3.APP_INTERCEPTOR,
+        useClass: InertiaScopeSwitcherInterceptor
+      },
+      {
+        provide: import_core3.APP_INTERCEPTOR,
+        useClass: InertiaRenderInterceptor
+      },
+      {
+        provide: import_core3.APP_INTERCEPTOR,
+        useClass: RedirectInterceptor
+      }
+    ];
+  }
+  static moduleExports = [
+    INERTIA_MODULE_OPTIONS,
+    INERTIA_MANIFEST,
+    INERTIA_ASSET_VERSION,
+    "INERTIA_SHELL_RENDERER",
+    "INERTIA_SSR_LOADER",
+    InertiaMiddleware
+  ];
+  static forRoot(options = {}) {
+    const optionsProvider = {
+      provide: INERTIA_MODULE_OPTIONS,
+      useValue: options
+    };
+    return {
+      module: _InertiaModule,
+      global: true,
+      providers: [
+        optionsProvider,
+        ..._InertiaModule.buildModuleProviders()
+      ],
+      exports: [
+        ..._InertiaModule.moduleExports
+      ]
+    };
+  }
+  static forRootAsync(asyncOptions) {
+    _InertiaModule.validateAsyncOptions(asyncOptions);
+    const optionsProviders = _InertiaModule.createAsyncOptionsProviders(asyncOptions);
+    const injectProviders = (asyncOptions.inject ?? []).filter((token) => typeof token === "function").map((token) => token);
+    return {
+      module: _InertiaModule,
+      global: true,
+      imports: asyncOptions.imports ?? [],
+      providers: [
+        ...injectProviders,
+        ...optionsProviders,
+        ..._InertiaModule.buildModuleProviders()
+      ],
+      exports: [
+        ..._InertiaModule.moduleExports
+      ]
+    };
+  }
+  static forFeature(options) {
+    assertScopeNotReserved(options.scope);
+    const optionsProvider = {
+      provide: featureToken("OPTIONS", options.scope),
+      useValue: options
+    };
+    return {
+      module: _InertiaModule,
+      global: true,
+      providers: [
+        optionsProvider,
+        ..._InertiaModule.createFeatureProviders(options.scope)
+      ],
+      exports: [
+        featureToken("OPTIONS", options.scope),
+        featureToken("MANIFEST", options.scope),
+        featureToken("ASSET_VERSION", options.scope),
+        featureToken("SHELL_RENDERER", options.scope),
+        featureToken("SSR_LOADER", options.scope)
+      ]
+    };
+  }
+  static forFeatureAsync(asyncOptions) {
+    assertScopeNotReserved(asyncOptions.scope);
+    const has = /* @__PURE__ */ __name((k) => asyncOptions[k] !== void 0, "has");
+    const declared = [
+      has("useFactory"),
+      has("useClass"),
+      has("useExisting")
+    ].filter(Boolean).length;
+    if (declared === 0) {
+      throw new InvalidInertiaConfigException("forFeatureAsync requires one of: useFactory, useClass, useExisting");
+    }
+    if (declared > 1) {
+      throw new InvalidInertiaConfigException("forFeatureAsync accepts exactly one of: useFactory, useClass, useExisting (got multiple)");
+    }
+    const scope = asyncOptions.scope;
+    const optionsToken = featureToken("OPTIONS", scope);
+    const injectProviders = (asyncOptions.inject ?? []).filter((token) => typeof token === "function").map((token) => token);
+    let optionsProviders;
+    if (asyncOptions.useFactory) {
+      optionsProviders = [
+        {
+          provide: optionsToken,
+          useFactory: /* @__PURE__ */ __name(async (...args) => {
+            const opts = await asyncOptions.useFactory(...args);
+            return {
+              ...opts,
+              scope
+            };
+          }, "useFactory"),
+          inject: asyncOptions.inject ?? []
+        }
+      ];
+    } else if (asyncOptions.useClass) {
+      optionsProviders = [
+        asyncOptions.useClass,
+        {
+          provide: optionsToken,
+          useFactory: /* @__PURE__ */ __name(async (factory) => ({
+            ...await factory.createInertiaOptions(),
+            scope
+          }), "useFactory"),
+          inject: [
+            asyncOptions.useClass
+          ]
+        }
+      ];
+    } else if (asyncOptions.useExisting) {
+      optionsProviders = [
+        {
+          provide: optionsToken,
+          useFactory: /* @__PURE__ */ __name(async (factory) => ({
+            ...await factory.createInertiaOptions(),
+            scope
+          }), "useFactory"),
+          inject: [
+            asyncOptions.useExisting
+          ]
+        }
+      ];
+    } else {
+      optionsProviders = [];
+    }
+    return {
+      module: _InertiaModule,
+      global: true,
+      imports: asyncOptions.imports ?? [],
+      providers: [
+        ...injectProviders,
+        ...optionsProviders,
+        ..._InertiaModule.createFeatureProviders(scope)
+      ],
+      exports: [
+        optionsToken,
+        featureToken("MANIFEST", scope),
+        featureToken("ASSET_VERSION", scope),
+        featureToken("SHELL_RENDERER", scope),
+        featureToken("SSR_LOADER", scope)
+      ]
+    };
+  }
+  static createFeatureProviders(scope) {
+    return [
+      {
+        provide: featureToken("MANIFEST", scope),
+        inject: [
+          featureToken("OPTIONS", scope)
+        ],
+        useFactory: /* @__PURE__ */ __name((opts) => {
+          if (process.env.NODE_ENV !== "production") return null;
+          return loadManifest(opts.vite?.manifestPath ?? "dist/inertia/client/.vite/manifest.json");
+        }, "useFactory")
+      },
+      {
+        provide: featureToken("ASSET_VERSION", scope),
+        inject: [
+          featureToken("MANIFEST", scope),
+          featureToken("OPTIONS", scope)
+        ],
+        useFactory: /* @__PURE__ */ __name(async (manifest, opts) => {
+          if (opts.version !== void 0) {
+            return typeof opts.version === "function" ? await opts.version() : opts.version;
+          }
+          return computeAssetVersion(manifest);
+        }, "useFactory")
+      },
+      {
+        provide: featureToken("SHELL_RENDERER", scope),
+        inject: [
+          featureToken("OPTIONS", scope)
+        ],
+        useFactory: /* @__PURE__ */ __name((opts) => {
+          const rv = opts.rootView;
+          if (typeof rv === "function") {
+            const fn = rv;
+            return {
+              render: /* @__PURE__ */ __name(async (ctx) => fn(ctx), "render")
+            };
+          }
+          if (typeof rv === "string") {
+            return new FileBasedShellRenderer(rv);
+          }
+          return new DefaultShellRenderer();
+        }, "useFactory")
+      },
+      {
+        provide: featureToken("SSR_LOADER", scope),
+        inject: [
+          featureToken("OPTIONS", scope)
+        ],
+        useFactory: /* @__PURE__ */ __name((opts) => new SsrLoaderService(opts), "useFactory")
+      }
+    ];
+  }
+  static validateAsyncOptions(asyncOptions) {
+    const has = /* @__PURE__ */ __name((k) => asyncOptions[k] !== void 0, "has");
+    const declared = [
+      has("useFactory"),
+      has("useClass"),
+      has("useExisting")
+    ].filter(Boolean).length;
+    if (declared === 0) {
+      throw new InvalidInertiaConfigException("forRootAsync requires one of: useFactory, useClass, useExisting");
+    }
+    if (declared > 1) {
+      throw new InvalidInertiaConfigException("forRootAsync accepts exactly one of: useFactory, useClass, useExisting (got multiple)");
+    }
+  }
+  static createAsyncOptionsProviders(asyncOptions) {
+    if (asyncOptions.useFactory) {
+      return [
+        {
+          provide: INERTIA_MODULE_OPTIONS,
+          useFactory: asyncOptions.useFactory,
+          inject: asyncOptions.inject ?? []
+        }
+      ];
+    }
+    if (asyncOptions.useClass) {
+      return [
+        asyncOptions.useClass,
+        {
+          provide: INERTIA_MODULE_OPTIONS,
+          useFactory: /* @__PURE__ */ __name(async (factory) => factory.createInertiaOptions(), "useFactory"),
+          inject: [
+            asyncOptions.useClass
+          ]
+        }
+      ];
+    }
+    return [
+      asyncOptions.useExisting,
+      {
+        provide: INERTIA_MODULE_OPTIONS,
+        useFactory: /* @__PURE__ */ __name(async (factory) => factory.createInertiaOptions(), "useFactory"),
+        inject: [
+          asyncOptions.useExisting
+        ]
+      }
+    ];
+  }
+  logger = new import_common12.Logger(_InertiaModule.name);
+  codegenWatcher = null;
+  constructor(httpAdapterHost, options, assetVersion, manifest, shellRenderer, ssrLoader) {
+    this.httpAdapterHost = httpAdapterHost;
+    this.options = options;
+    this.assetVersion = assetVersion;
+    this.manifest = manifest;
+    this.shellRenderer = shellRenderer;
+    this.ssrLoader = ssrLoader;
+  }
+  /**
+  * Test seam: override in a subclass or via `Object.defineProperty` to inject a stub
+  * codegen module without touching NestJS DI. Production callers never touch this.
+  *
+  * @internal
+  */
+  _resolveCodegenModule() {
+    const dynamicImport = new Function("s", "return import(s)");
+    return dynamicImport("@dudousxd/nestjs-inertia-codegen");
+  }
+  async onApplicationBootstrap() {
+    const adapter = this.httpAdapterHost.httpAdapter;
+    if (adapter) {
+      const platform = adapter.getType();
+      if (platform === "fastify") {
+        const fastifyApp = adapter.getInstance();
+        registerFastifyInertia(fastifyApp, () => ({
+          assetVersion: this.assetVersion,
+          manifest: this.manifest,
+          ssrLoader: this.ssrLoader,
+          rootViewRender: /* @__PURE__ */ __name((ctx) => this.shellRenderer.render(ctx), "rootViewRender"),
+          moduleShare: this.options.share,
+          featureShare: void 0,
+          historyEncryptionDefault: this.options.historyEncryption?.default ?? false,
+          flashStore: this.options.flashStore
+        }));
+        const { registerFastifyMethodSpoof: registerFastifyMethodSpoof2 } = await Promise.resolve().then(() => (init_fastify_method_spoof_middleware(), fastify_method_spoof_middleware_exports));
+        registerFastifyMethodSpoof2(fastifyApp, this.options);
+      }
+    }
+    await this._startCodegenWatcher();
+  }
+  /**
+  * Auto-starts the codegen file watcher in dev mode.
+  *
+  * Rules (all must pass for the watcher to start):
+  * 1. `process.env.NODE_ENV !== 'production'`
+  * 2. `options.codegen?.enabled !== false`
+  * 3. `@dudousxd/nestjs-inertia-codegen` is resolvable (peer-optional)
+  * 4. A `nestjs-inertia.config.ts` (or equivalent) is present in `process.cwd()`
+  *
+  * If the CLI watcher already holds the lock file, the codegen package returns a
+  * no-op watcher — no conflict occurs.
+  *
+  * This method NEVER throws; any unexpected error is logged as a warning.
+  */
+  async _startCodegenWatcher() {
+    try {
+      if (process.env.NODE_ENV === "production") return;
+      if (process.env.NESTJS_INERTIA_DISABLE_AUTO_CODEGEN === "1") return;
+      if (this.options.codegen?.enabled === false) return;
+      let codegen;
+      try {
+        codegen = await this._resolveCodegenModule();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.logger.warn(`Codegen auto-watch: failed to import @dudousxd/nestjs-inertia-codegen: ${message}`);
+        return;
+      }
+      let config;
+      try {
+        config = await codegen.loadConfig(process.cwd());
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.logger.warn(`Codegen auto-watch: failed to load config: ${message}`);
+        return;
+      }
+      this.codegenWatcher = await codegen.watch(config);
+      this.logger.log("Codegen auto-watch started (dev mode).");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.warn(`Codegen auto-watch failed to start: ${message}. Install @dudousxd/nestjs-inertia-codegen and add nestjs-inertia.config.ts to enable auto-watch, or set codegen: { enabled: false } to suppress this warning.`);
+    }
+  }
+  async onApplicationShutdown() {
+    await this.codegenWatcher?.close();
+    this.codegenWatcher = null;
+  }
+  configure(consumer) {
+    const adapter = this.httpAdapterHost.httpAdapter;
+    if (!adapter || adapter.getType() === "express") {
+      consumer.apply(MethodSpoofMiddleware).forRoutes({
+        path: "{*path}",
+        method: import_common12.RequestMethod.ALL
+      });
+      consumer.apply(InertiaMiddleware).forRoutes({
+        path: "{*path}",
+        method: import_common12.RequestMethod.ALL
+      });
+    }
+  }
+};
+InertiaModule = _ts_decorate8([
+  (0, import_common12.Module)({}),
+  _ts_param7(0, (0, import_common12.Inject)(import_core3.HttpAdapterHost)),
+  _ts_param7(1, (0, import_common12.Inject)(INERTIA_MODULE_OPTIONS)),
+  _ts_param7(2, (0, import_common12.Inject)(INERTIA_ASSET_VERSION)),
+  _ts_param7(3, (0, import_common12.Inject)(INERTIA_MANIFEST)),
+  _ts_param7(4, (0, import_common12.Inject)("INERTIA_SHELL_RENDERER")),
+  _ts_param7(5, (0, import_common12.Inject)("INERTIA_SSR_LOADER")),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof import_core3.HttpAdapterHost === "undefined" ? Object : import_core3.HttpAdapterHost,
+    typeof InertiaModuleOptions === "undefined" ? Object : InertiaModuleOptions,
+    String,
+    Object,
+    typeof ShellRenderer === "undefined" ? Object : ShellRenderer,
+    Object
+  ])
+], InertiaModule);
+
+// src/csrf/csrf-cookie.interceptor.ts
+var import_common13 = require("@nestjs/common");
+
+// src/csrf/csrf-token.ts
+var import_node_crypto2 = require("crypto");
+function generateCsrfToken(secret, context) {
+  const raw = (0, import_node_crypto2.randomBytes)(32).toString("base64url");
+  if (context !== void 0 && context !== "") {
+    const ctx = Buffer.from(context).toString("hex");
+    const sig2 = (0, import_node_crypto2.createHmac)("sha256", secret).update(`${raw}:${context}`).digest("base64url");
+    return `${raw}.${ctx}.${sig2}`;
+  }
+  const sig = (0, import_node_crypto2.createHmac)("sha256", secret).update(raw).digest("base64url");
+  return `${raw}.${sig}`;
+}
+__name(generateCsrfToken, "generateCsrfToken");
+function timingSafeEqualSafe(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  return (0, import_node_crypto2.timingSafeEqual)(a, b);
+}
+__name(timingSafeEqualSafe, "timingSafeEqualSafe");
+function verifyCsrfToken(token, secret, context) {
+  if (typeof token !== "string") return false;
+  const parts = token.split(".");
+  if (parts.length === 3) {
+    const [raw, ctxHex, sig] = parts;
+    if (!raw || !ctxHex || !sig) return false;
+    let storedContext;
+    try {
+      storedContext = Buffer.from(ctxHex, "hex").toString();
+    } catch {
+      return false;
+    }
+    if (context !== void 0 && context !== "" && storedContext !== context) return false;
+    const expectedContext = context !== void 0 && context !== "" ? context : storedContext;
+    const expected = (0, import_node_crypto2.createHmac)("sha256", secret).update(`${raw}:${expectedContext}`).digest("base64url");
+    return timingSafeEqualSafe(Buffer.from(sig), Buffer.from(expected));
+  }
+  if (parts.length === 2) {
+    const [raw, sig] = parts;
+    if (!raw || !sig) return false;
+    if (context !== void 0 && context !== "") return false;
+    const expected = (0, import_node_crypto2.createHmac)("sha256", secret).update(raw).digest("base64url");
+    return timingSafeEqualSafe(Buffer.from(sig), Buffer.from(expected));
+  }
+  return false;
+}
+__name(verifyCsrfToken, "verifyCsrfToken");
+
+// src/csrf/csrf-cookie.interceptor.ts
+function _ts_decorate9(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate9, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function writeCsrfCookie(res, cookieName, token, cookieOpts) {
+  if (typeof res.cookie === "function") {
+    res.cookie(cookieName, token, cookieOpts);
+  } else if (typeof res.setCookie === "function") {
+    res.setCookie(cookieName, token, cookieOpts);
+  }
+}
+__name(writeCsrfCookie, "writeCsrfCookie");
+function rotateCsrfToken(res, options, context) {
+  const cookieName = options.cookieName ?? "XSRF-TOKEN";
+  const token = generateCsrfToken(options.secret, context);
+  const cookieOpts = {
+    httpOnly: options.httpOnly ?? false,
+    sameSite: options.sameSite ?? "lax",
+    secure: options.secure ?? process.env.NODE_ENV === "production",
+    path: "/"
+  };
+  writeCsrfCookie(res, cookieName, token, cookieOpts);
+}
+__name(rotateCsrfToken, "rotateCsrfToken");
+var CsrfCookieInterceptor = class {
+  static {
+    __name(this, "CsrfCookieInterceptor");
+  }
+  options;
+  cookieName;
+  constructor(options) {
+    this.options = options;
+    this.cookieName = options.cookieName ?? "XSRF-TOKEN";
+  }
+  intercept(context, next) {
+    const req = context.switchToHttp().getRequest();
+    const res = context.switchToHttp().getResponse();
+    const ctx = this.options.tokenContext ? this.options.tokenContext(req) : void 0;
+    const existing = req.cookies?.[this.cookieName];
+    if (!existing || !verifyCsrfToken(existing, this.options.secret, ctx)) {
+      rotateCsrfToken(res, this.options, ctx);
+    }
+    return next.handle();
+  }
+};
+CsrfCookieInterceptor = _ts_decorate9([
+  (0, import_common13.Injectable)(),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof CsrfCookieOptions === "undefined" ? Object : CsrfCookieOptions
+  ])
+], CsrfCookieInterceptor);
+
+// src/csrf/csrf.guard.ts
+var import_common14 = require("@nestjs/common");
+init_exceptions();
+function _ts_decorate10(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+var SAFE = /* @__PURE__ */ new Set([
+  "GET",
+  "HEAD",
+  "OPTIONS"
+]);
+var CsrfGuard = class {
+  static {
+    __name(this, "CsrfGuard");
+  }
+  options;
+  cookieName;
+  headerName;
+  constructor(options) {
+    this.options = options;
+    this.cookieName = options.cookieName ?? "XSRF-TOKEN";
+    this.headerName = (options.headerName ?? "X-XSRF-TOKEN").toLowerCase();
+  }
+  canActivate(ctx) {
+    const req = ctx.switchToHttp().getRequest();
+    if (SAFE.has(req.method)) return true;
+    const cookieToken = req.cookies?.[this.cookieName];
+    const headerRaw = req.headers[this.headerName];
+    const headerToken = Array.isArray(headerRaw) ? headerRaw[0] : headerRaw;
+    if (!cookieToken || !headerToken) throw new InvalidCsrfTokenException();
+    if (!timingSafeEqualSafe(Buffer.from(cookieToken), Buffer.from(headerToken))) {
+      throw new InvalidCsrfTokenException();
+    }
+    const context = this.options.tokenContext ? this.options.tokenContext(req) : void 0;
+    if (!verifyCsrfToken(cookieToken, this.options.secret, context)) throw new InvalidCsrfTokenException();
+    return true;
+  }
+};
+CsrfGuard = _ts_decorate10([
+  (0, import_common14.Injectable)(),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof CsrfGuardOptions === "undefined" ? Object : CsrfGuardOptions
+  ])
+], CsrfGuard);
+
+// src/index.ts
+var VERSION = "1.0.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CsrfCookieInterceptor,
+  CsrfGuard,
+  ErrorBagInterceptor,
+  INERTIA_ASSET_VERSION,
+  INERTIA_DEFAULT_SCOPE,
+  INERTIA_FEATURE_OPTIONS,
+  INERTIA_MANIFEST,
+  INERTIA_MODULE_OPTIONS,
+  INERTIA_RENDER_COMPONENT,
+  INERTIA_USE_SCOPE,
+  Inertia,
+  InertiaModule,
+  InertiaRenderInterceptor,
+  InertiaService,
+  InertiaServiceNotAvailableException,
+  InvalidCsrfTokenException,
+  InvalidInertiaConfigException,
+  MethodSpoofMiddleware,
+  MissingCookieDepException,
+  MissingTemplateEngineDepException,
+  RedirectInterceptor,
+  UnsupportedRootViewExtensionException,
+  UseInertia,
+  VERSION,
+  featureToken,
+  generateCsrfToken,
+  rotateCsrfToken,
+  timingSafeEqualSafe,
+  verifyCsrfToken
+});
+//# sourceMappingURL=index.cjs.map