@orieljs/inertia 0.1.0-alpha.2

package/dist/index.js

@@ -0,0 +1,1412 @@
+// headers.ts
+var Header = {
+  INERTIA: "X-Inertia",
+  ERROR_BAG: "X-Inertia-Error-Bag",
+  LOCATION: "X-Inertia-Location",
+  REDIRECT: "X-Inertia-Redirect",
+  VERSION: "X-Inertia-Version",
+  PARTIAL_COMPONENT: "X-Inertia-Partial-Component",
+  PARTIAL_ONLY: "X-Inertia-Partial-Data",
+  PARTIAL_EXCEPT: "X-Inertia-Partial-Except",
+  RESET: "X-Inertia-Reset",
+  INFINITE_SCROLL_MERGE_INTENT: "X-Inertia-Infinite-Scroll-Merge-Intent",
+  EXCEPT_ONCE_PROPS: "X-Inertia-Except-Once-Props"
+};
+function parseList(value) {
+  const items = (value ?? "").split(",").filter((item) => item !== "");
+  return items.length === 0 ? void 0 : items;
+}
+
+// props/Prop.ts
+var Prop = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  mergeState = { merge: false, deep: false, append: true, appendPaths: [], prependPaths: [], matchOn: [] };
+  onceState = { once: false, fresh: false, key: void 0, ttlSeconds: void 0 };
+  deferred = false;
+  deferGroup;
+  /** Calls the callback, if the value is one. */
+  async resolve() {
+    return typeof this.value === "function" ? await this.value() : this.value;
+  }
+  /** Never sent on the first load (OptionalProp, DeferProp). */
+  ignoresFirstLoad() {
+    return false;
+  }
+  /** Sent even when a partial reload didn't ask for it (AlwaysProp). */
+  isAlways() {
+    return false;
+  }
+  /** Errors are reported and the prop is left out, instead of failing the page (defer(..., { rescue: true })). */
+  shouldRescue() {
+    return false;
+  }
+  // Once (honoured by OptionalProp, DeferProp, MergeProp and OnceProp) ------------------------------------
+  /** once(), once(false), once(true, { as: 'key', until: 3600 }). */
+  once(value = true, options = {}) {
+    this.onceState.once = value;
+    if (options.as !== void 0) this.onceState.key = options.as;
+    if (options.until !== void 0) this.onceState.ttlSeconds = secondsUntil(options.until);
+    return this;
+  }
+  /** A custom once key, so pages can share the prop under different names. */
+  as(key) {
+    this.onceState.key = key;
+    return this;
+  }
+  /** Send the prop again even though the client already has it. */
+  fresh(value = true) {
+    this.onceState.fresh = value;
+    return this;
+  }
+  /** Expire after a number of seconds, or at a Date. */
+  until(delay) {
+    this.onceState.ttlSeconds = secondsUntil(delay);
+    return this;
+  }
+  // Merging -------------------------------------------------------------------------------------------------
+  isMergeable() {
+    return false;
+  }
+  shouldMerge() {
+    return this.isMergeable() && this.mergeState.merge;
+  }
+  shouldDeepMerge() {
+    return this.mergeState.deep;
+  }
+  matchesOn() {
+    return [...this.mergeState.matchOn];
+  }
+  appendsAtRoot() {
+    return this.mergeState.append && this.mergesAtRoot();
+  }
+  prependsAtRoot() {
+    return !this.mergeState.append && this.mergesAtRoot();
+  }
+  appendsAtPaths() {
+    return [...this.mergeState.appendPaths];
+  }
+  prependsAtPaths() {
+    return [...this.mergeState.prependPaths];
+  }
+  mergesAtRoot() {
+    return this.mergeState.appendPaths.length === 0 && this.mergeState.prependPaths.length === 0;
+  }
+  // Deferring -----------------------------------------------------------------------------------------------
+  isDeferrable() {
+    return false;
+  }
+  shouldDefer() {
+    return this.isDeferrable() && this.deferred;
+  }
+  group() {
+    return this.deferGroup ?? "default";
+  }
+  // Once ----------------------------------------------------------------------------------------------------
+  isOnceable() {
+    return false;
+  }
+  shouldResolveOnce() {
+    return this.isOnceable() && this.onceState.once;
+  }
+  shouldBeRefreshed() {
+    return this.onceState.fresh;
+  }
+  getKey() {
+    return this.onceState.key;
+  }
+  /** Epoch milliseconds, or null when the prop never expires. */
+  expiresAt() {
+    return this.onceState.ttlSeconds === void 0 ? null : (Math.floor(Date.now() / 1e3) + this.onceState.ttlSeconds) * 1e3;
+  }
+};
+var MergeableProp = class extends Prop {
+  isMergeable() {
+    return true;
+  }
+  merge() {
+    this.mergeState.merge = true;
+    return this;
+  }
+  deepMerge() {
+    this.mergeState.deep = true;
+    return this.merge();
+  }
+  /** Match array items on these keys instead of appending duplicates: matchOn('id'). */
+  matchOn(keys) {
+    this.mergeState.matchOn = [keys].flat();
+    return this;
+  }
+  /** append() at the root, append('data') at a path, append('data', 'id') with a match key, or a map of both. */
+  append(path = true, matchOn) {
+    return this.#place("append", path, matchOn);
+  }
+  prepend(path = true, matchOn) {
+    return this.#place("prepend", path, matchOn);
+  }
+  #place(side, path, matchOn) {
+    if (typeof path === "boolean") {
+      this.mergeState.append = side === "append" ? path : !path;
+      return this;
+    }
+    if (Array.isArray(path)) {
+      for (const entry of path) this.#place(side, entry);
+      return this;
+    }
+    if (typeof path === "object") {
+      for (const [entry, key] of Object.entries(path)) this.#place(side, entry, key);
+      return this;
+    }
+    ;
+    (side === "append" ? this.mergeState.appendPaths : this.mergeState.prependPaths).push(path);
+    if (matchOn !== void 0 && matchOn !== "") this.mergeState.matchOn = [...this.mergeState.matchOn, `${path}.${matchOn}`];
+    return this;
+  }
+};
+function secondsUntil(delay) {
+  return delay instanceof Date ? Math.max(0, Math.round((delay.getTime() - Date.now()) / 1e3)) : delay;
+}
+
+// props/props.ts
+var AlwaysProp = class extends Prop {
+  kind = "always";
+  isAlways() {
+    return true;
+  }
+};
+var OptionalProp = class extends Prop {
+  kind = "optional";
+  constructor(callback) {
+    super(callback);
+  }
+  ignoresFirstLoad() {
+    return true;
+  }
+  isOnceable() {
+    return true;
+  }
+};
+var DeferProp = class extends MergeableProp {
+  kind = "defer";
+  #rescue;
+  constructor(callback, group, options = {}) {
+    super(callback);
+    this.deferred = true;
+    this.deferGroup = group;
+    this.#rescue = options.rescue ?? false;
+  }
+  ignoresFirstLoad() {
+    return true;
+  }
+  isDeferrable() {
+    return true;
+  }
+  isOnceable() {
+    return true;
+  }
+  shouldRescue() {
+    return this.#rescue;
+  }
+};
+var MergeProp = class extends MergeableProp {
+  kind = "merge";
+  constructor(value) {
+    super(value);
+    this.mergeState.merge = true;
+  }
+  isOnceable() {
+    return true;
+  }
+};
+var OnceProp = class extends Prop {
+  kind = "once";
+  constructor(callback) {
+    super(callback);
+    this.onceState.once = true;
+  }
+  isOnceable() {
+    return true;
+  }
+};
+var isCursorPaginator = (value) => typeof value === "object" && value !== null && typeof value.getCursorName === "function";
+var isPagedPaginator = (value) => typeof value === "object" && value !== null && typeof value.getPageName === "function" && typeof value.currentPage === "function" && typeof value.hasMorePages === "function";
+function scrollMetadataFrom(value) {
+  if (isCursorPaginator(value)) {
+    const current = value.cursor();
+    return {
+      pageName: value.getCursorName(),
+      previousPage: value.previousCursor()?.encode() ?? null,
+      nextPage: value.nextCursor()?.encode() ?? null,
+      currentPage: current === void 0 ? 1 : current.encode()
+    };
+  }
+  if (isPagedPaginator(value)) {
+    const current = value.currentPage();
+    return {
+      pageName: value.getPageName(),
+      previousPage: current > 1 ? current - 1 : null,
+      nextPage: value.hasMorePages() ? current + 1 : null,
+      currentPage: current
+    };
+  }
+  throw new TypeError("The given value is not a paginator. Pass a metadata callback to Inertia.scroll().");
+}
+var ScrollProp = class extends MergeableProp {
+  constructor(value, wrapper = "data", metadataResolver) {
+    super(value);
+    this.wrapper = wrapper;
+    this.metadataResolver = metadataResolver;
+    this.mergeState.merge = true;
+  }
+  wrapper;
+  metadataResolver;
+  kind = "scroll";
+  #resolved;
+  isDeferrable() {
+    return true;
+  }
+  /** Load the prop after the first render, like a deferred prop. */
+  defer(group) {
+    this.deferred = true;
+    this.deferGroup = group;
+    return this;
+  }
+  /** 'prepend' from the X-Inertia-Infinite-Scroll-Merge-Intent header prepends the wrapper; anything else appends. */
+  configureMergeIntent(intent) {
+    return intent === "prepend" ? this.prepend(this.wrapper) : this.append(this.wrapper);
+  }
+  /** Resolves once and caches, because both the value and its metadata need it. */
+  async resolve() {
+    this.#resolved ??= { value: await super.resolve() };
+    return this.#resolved.value;
+  }
+  async metadata() {
+    const value = await this.resolve();
+    return this.metadataResolver === void 0 ? scrollMetadataFrom(value) : this.metadataResolver(value);
+  }
+};
+var isProp = (value) => value instanceof Prop;
+
+// PropsResolver.ts
+import { Arr } from "@orieljs/support";
+var isContainer = (value) => {
+  if (Array.isArray(value)) return true;
+  if (typeof value !== "object" || value === null) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+var entriesOf = (value) => Array.isArray(value) ? value.map((item, index) => [String(index), item]) : Object.entries(value);
+var PropsResolver = class {
+  constructor(request, component, options = {}) {
+    this.options = options;
+    this.#isPartial = request.header(Header.PARTIAL_COMPONENT) === component;
+    const inertia2 = request.header(Header.INERTIA);
+    this.#isInertia = inertia2 !== void 0 && inertia2 !== "" && inertia2 !== "false";
+    this.#only = parseList(request.header(Header.PARTIAL_ONLY));
+    this.#except = parseList(request.header(Header.PARTIAL_EXCEPT));
+    this.#reset = parseList(request.header(Header.RESET)) ?? [];
+    this.#loadedOnce = parseList(request.header(Header.EXCEPT_ONCE_PROPS)) ?? [];
+    this.#mergeIntent = request.header(Header.INFINITE_SCROLL_MERGE_INTENT);
+  }
+  options;
+  #isPartial;
+  #isInertia;
+  #only;
+  #except;
+  #reset;
+  #loadedOnce;
+  #mergeIntent;
+  #deferred = {};
+  #rescued = [];
+  #merge = [];
+  #prepend = [];
+  #deepMerge = [];
+  #matchOn = [];
+  #scroll = {};
+  #once = {};
+  #observed = /* @__PURE__ */ new WeakSet();
+  #sharedKeys = [];
+  async resolve(shared, props) {
+    if (this.options.exposeSharedPropKeys ?? true) {
+      this.#sharedKeys = [...new Set(Object.keys(shared).map((key) => key.split(".")[0]))];
+    }
+    this.#observePromises(shared);
+    this.#observePromises(props);
+    const merged = await this.#unpackDotProps({ ...shared, ...props });
+    const resolved = await this.#resolveProps(merged, "", false);
+    return { props: resolved, metadata: this.#metadata() };
+  }
+  #metadata() {
+    const metadata = {};
+    if (this.#sharedKeys.length > 0) metadata.sharedProps = this.#sharedKeys;
+    if (this.#merge.length > 0) metadata.mergeProps = this.#merge;
+    if (this.#prepend.length > 0) metadata.prependProps = this.#prepend;
+    if (this.#deepMerge.length > 0) metadata.deepMergeProps = this.#deepMerge;
+    if (this.#matchOn.length > 0) metadata.matchPropsOn = this.#matchOn;
+    if (Object.keys(this.#deferred).length > 0) metadata.deferredProps = this.#deferred;
+    if (this.#rescued.length > 0) metadata.rescuedProps = this.#rescued;
+    if (Object.keys(this.#scroll).length > 0) metadata.scrollProps = this.#scroll;
+    if (Object.keys(this.#once).length > 0) metadata.onceProps = this.#once;
+    return metadata;
+  }
+  /**
+   * Marks every raw Promise in a container tree as handled. A promise the walk never awaits (filtered out by a
+   * partial reload, or after a prop that threw) would otherwise reject unobserved and could end the process.
+   * Awaiting the original promise still throws its error where it is used.
+   */
+  #observePromises(value) {
+    if (value instanceof Promise) {
+      value.catch(() => void 0);
+      return;
+    }
+    if (!isContainer(value) || this.#observed.has(value)) return;
+    this.#observed.add(value);
+    for (const [, child] of entriesOf(value)) this.#observePromises(child);
+  }
+  async #resolveProps(props, prefix, parentWasResolved) {
+    this.#observePromises(props);
+    const result = Array.isArray(props) ? [] : {};
+    for (const [key, original] of entriesOf(props)) {
+      const path = prefix === "" ? key : `${prefix}.${key}`;
+      let prop = original;
+      if (!this.#shouldIncludeInPartialResponse(prop, path, parentWasResolved)) continue;
+      if (!this.#isPartial && this.#excludeFromInitialResponse(prop, path)) continue;
+      let value = await this.#resolveValue(prop, path);
+      if (this.#rescued.includes(path)) continue;
+      if (value !== prop && isProp(value)) {
+        prop = value;
+        if (!this.#isPartial && this.#excludeFromInitialResponse(prop, path)) continue;
+        value = await this.#resolveValue(prop, path);
+        if (this.#rescued.includes(path)) continue;
+      }
+      await this.#collectMetadata(prop, path);
+      const child = isContainer(value) ? await this.#resolveProps(value, path, parentWasResolved || !isContainer(prop)) : value;
+      if (Array.isArray(result)) result.push(child);
+      else result[key] = child;
+    }
+    return result;
+  }
+  #shouldIncludeInPartialResponse(prop, path, parentWasResolved) {
+    if (!this.#isPartial || parentWasResolved || isProp(prop) && prop.isAlways()) return true;
+    if (this.#only !== void 0 && !this.#matchesOnly(path) && !this.#leadsToOnly(path)) return false;
+    if (this.#except !== void 0 && this.#matchesExcept(path)) return false;
+    return true;
+  }
+  #excludeFromInitialResponse(prop, path) {
+    if (!isProp(prop)) return false;
+    if (prop.ignoresFirstLoad()) {
+      if (prop.shouldDefer() && !this.#wasAlreadyLoadedByClient(prop, path)) this.#collectDeferred(path, prop);
+      if (prop.shouldMerge()) this.#collectMerge(path, prop);
+      if (prop.shouldResolveOnce()) this.#collectOnce(path, prop);
+      return true;
+    }
+    if (prop.shouldDefer()) {
+      this.#collectDeferred(path, prop);
+      if (prop.shouldMerge()) this.#collectMerge(path, prop);
+      return true;
+    }
+    if (this.#isInertia && this.#wasAlreadyLoadedByClient(prop, path)) {
+      this.#collectOnce(path, prop);
+      return true;
+    }
+    return false;
+  }
+  #wasAlreadyLoadedByClient(prop, path) {
+    return prop.shouldResolveOnce() && !prop.shouldBeRefreshed() && this.#loadedOnce.includes(prop.getKey() ?? path);
+  }
+  /** Callbacks and prop types run; objects with toJSON() (models, collections, paginators, dates) serialize. */
+  async #resolveValue(value, path) {
+    if (value instanceof ScrollProp) value.configureMergeIntent(this.#mergeIntent);
+    const rescue = isProp(value) && value.shouldRescue();
+    try {
+      let resolved = value;
+      if (isProp(resolved)) resolved = await resolved.resolve();
+      else if (typeof resolved === "function") resolved = await resolved();
+      else if (resolved instanceof Promise) resolved = await resolved;
+      if (!isProp(resolved) && typeof resolved === "object" && resolved !== null && !Array.isArray(resolved)) {
+        const serializable = resolved;
+        if (typeof serializable.toJSON === "function") resolved = serializable.toJSON();
+      }
+      return resolved;
+    } catch (error) {
+      if (!rescue) throw error;
+      await this.options.report?.(error);
+      this.#rescued.push(path);
+      return null;
+    }
+  }
+  async #collectMetadata(prop, path) {
+    if (!isProp(prop)) return;
+    if (prop.shouldMerge()) this.#collectMerge(path, prop);
+    if (prop instanceof ScrollProp) this.#scroll[path] = { ...await prop.metadata(), reset: this.#reset.includes(path) };
+    if (prop.shouldResolveOnce()) this.#collectOnce(path, prop);
+  }
+  #collectDeferred(path, prop) {
+    ;
+    (this.#deferred[prop.group()] ??= []).push(path);
+  }
+  #collectMerge(path, prop) {
+    if (this.#reset.includes(path)) return;
+    if (this.#isPartial && !this.#isIncludedInPartialMetadata(path)) return;
+    if (prop.shouldDeepMerge()) this.#deepMerge.push(path);
+    else if (prop.appendsAtRoot()) this.#merge.push(path);
+    else if (prop.prependsAtRoot()) this.#prepend.push(path);
+    else {
+      for (const append of prop.appendsAtPaths()) this.#merge.push(`${path}.${append}`);
+      for (const prepend of prop.prependsAtPaths()) this.#prepend.push(`${path}.${prepend}`);
+    }
+    for (const strategy of prop.matchesOn()) this.#matchOn.push(`${path}.${strategy}`);
+  }
+  #collectOnce(path, prop) {
+    if (!prop.shouldResolveOnce()) return;
+    if (this.#isPartial && !this.#isIncludedInPartialMetadata(path)) return;
+    this.#once[prop.getKey() ?? path] = { prop: path, expiresAt: prop.expiresAt() };
+  }
+  #isIncludedInPartialMetadata(path) {
+    if (this.#only !== void 0 && !this.#matchesOnly(path)) return false;
+    if (this.#except !== void 0 && this.#matchesExcept(path)) return false;
+    return true;
+  }
+  #matchesOnly(path) {
+    return this.#only.some((only) => path === only || path.startsWith(`${only}.`));
+  }
+  #leadsToOnly(path) {
+    return this.#only.some((only) => only.startsWith(`${path}.`));
+  }
+  #matchesExcept(path) {
+    return this.#except.some((except) => path === except || path.startsWith(`${except}.`));
+  }
+  /** 'auth.user' => value becomes { auth: { user: value } }; callbacks along the path are resolved first. */
+  async #unpackDotProps(props) {
+    const result = { ...props };
+    for (const [key, original] of Object.entries(props)) {
+      if (!key.includes(".")) continue;
+      let value = original;
+      if (typeof value === "function") value = await value();
+      await this.#ensurePathIsTraversable(result, key);
+      delete result[key];
+      Arr.set(result, key, value);
+    }
+    return result;
+  }
+  async #ensurePathIsTraversable(props, dotKey) {
+    let current = props;
+    for (const segment of dotKey.split(".").slice(0, -1)) {
+      if (current[segment] === void 0 || current[segment] === null) return;
+      if (typeof current[segment] === "function") current[segment] = await current[segment]();
+      const value = current[segment];
+      if (typeof value === "object" && value !== null && !isContainer(value) && typeof value.toJSON === "function") {
+        current[segment] = value.toJSON();
+      }
+      const walked = current[segment];
+      if (typeof walked !== "object" || walked === null) return;
+      current[segment] = Array.isArray(walked) ? [...walked] : Object.assign(Object.create(Object.getPrototypeOf(walked)), walked);
+      current = current[segment];
+    }
+  }
+};
+
+// context.ts
+import { HttpRequest, Session } from "@orieljs/contracts";
+import { currentContainer } from "@orieljs/container";
+function requestScope() {
+  const container = currentContainer();
+  return container !== void 0 && container.bound(HttpRequest) ? container : void 0;
+}
+function currentRequest() {
+  return requestScope()?.make(HttpRequest);
+}
+function optionalSession() {
+  const scope = requestScope();
+  return scope?.bound(Session) ? scope.make(Session) : void 0;
+}
+function isInertiaRequest(request) {
+  const value = request.header("X-Inertia");
+  return value !== void 0 && value !== "" && value !== "false";
+}
+function isPrefetch(request) {
+  return ["Purpose", "Sec-Purpose", "X-Moz"].some((name) => request.header(name)?.toLowerCase() === "prefetch");
+}
+function rebuild(response, changes) {
+  const headers = new Headers(response.headers);
+  for (const [name, value] of Object.entries(changes.headers ?? {})) headers.set(name, value);
+  const status = changes.status ?? response.status;
+  return new Response(response.body, {
+    status,
+    statusText: status === response.status ? response.statusText : "",
+    headers
+  });
+}
+function isRedirect(response) {
+  return [201, 301, 302, 303, 307, 308].includes(response.status) && response.headers.has("Location");
+}
+
+// errors.ts
+var ComponentNotFoundError = class extends Error {
+  constructor(component) {
+    super(`Inertia page component [${component}] not found.`);
+    this.component = component;
+    this.name = "ComponentNotFoundError";
+  }
+  component;
+  kind = "Server";
+  status = 500;
+};
+var InertiaError = class extends Error {
+  kind = "Server";
+  status = 500;
+  constructor(message) {
+    super(message);
+    this.name = "InertiaError";
+  }
+};
+var SsrError = class extends Error {
+  kind = "Server";
+  status = 500;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SsrError";
+  }
+};
+
+// Response.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import {
+  ConfigRepository,
+  ExceptionHandler,
+  ViewFactory
+} from "@orieljs/contracts";
+var SessionKey = {
+  CLEAR_HISTORY: "inertia.clear_history",
+  PRESERVE_FRAGMENT: "inertia.preserve_fragment",
+  FLASH_DATA: "inertia.flash_data"
+};
+function defaultUrl(request) {
+  const url = new URL(request.raw.url);
+  return `${url.pathname}${url.search}`;
+}
+var Response2 = class {
+  constructor(component, props, settings) {
+    this.component = component;
+    this.settings = settings;
+    this.#props = { ...props };
+    this.#rootView = settings.rootView;
+  }
+  component;
+  settings;
+  #props;
+  #viewData = {};
+  #rootView;
+  with(key, value) {
+    if (typeof key === "string") this.#props[key] = value;
+    else Object.assign(this.#props, key);
+    return this;
+  }
+  withViewData(key, value) {
+    if (typeof key === "string") this.#viewData[key] = value;
+    else Object.assign(this.#viewData, key);
+    return this;
+  }
+  rootView(view) {
+    this.#rootView = view;
+    return this;
+  }
+  flash(key, value) {
+    this.settings.flash(key, value);
+    return this;
+  }
+  /** The page object for this request. */
+  async toPage(request) {
+    const scope = requestScope();
+    this.#ensurePageExists(scope);
+    const resolver = new PropsResolver(request, this.component, {
+      exposeSharedPropKeys: this.#config(scope, "inertia.expose_shared_prop_keys", true),
+      report: async (error) => {
+        if (scope?.bound(ExceptionHandler)) await scope.make(ExceptionHandler).report(error);
+      }
+    });
+    const { props, metadata } = await resolver.resolve(this.settings.shared, this.#props);
+    const session = optionalSession();
+    const clearHistory = session?.pull(SessionKey.CLEAR_HISTORY, false) === true;
+    const preserveFragment = session?.pull(SessionKey.PRESERVE_FRAGMENT, false) === true;
+    const flash = session?.pull(SessionKey.FLASH_DATA, void 0);
+    const page = {
+      component: this.component,
+      props,
+      url: (this.settings.urlResolver ?? defaultUrl)(request),
+      version: await this.settings.version(),
+      ...metadata
+    };
+    if (clearHistory) page.clearHistory = true;
+    if (this.settings.encryptHistory) page.encryptHistory = true;
+    if (flash !== void 0 && flash !== null && Object.keys(flash).length > 0) page.flash = flash;
+    if (preserveFragment) page.preserveFragment = true;
+    return page;
+  }
+  async toResponse(request) {
+    const http = request;
+    if (typeof http?.header !== "function") throw new InertiaError("An Inertia response needs the HttpRequest.");
+    const page = await this.toPage(http);
+    if (isInertiaRequest(http)) {
+      return new globalThis.Response(JSON.stringify(page), {
+        status: 200,
+        headers: { "content-type": "application/json", "X-Inertia": "true" }
+      });
+    }
+    const scope = requestScope();
+    if (scope === void 0 || !scope.bound(ViewFactory)) {
+      throw new InertiaError(`Cannot render the Inertia root view [${this.#rootView}]: no ViewFactory is bound.`);
+    }
+    const html = await scope.make(ViewFactory).make(this.#rootView, { ...this.#viewData, page }).render();
+    return new globalThis.Response(html, { status: 200, headers: { "content-type": "text/html; charset=utf-8" } });
+  }
+  /** inertia.pages.ensure_pages_exist: the component must exist under one of the page paths. */
+  #ensurePageExists(scope) {
+    if (!this.#config(scope, "inertia.pages.ensure_pages_exist", false)) return;
+    const paths = this.#config(scope, "inertia.pages.paths", []);
+    const extensions = this.#config(scope, "inertia.pages.extensions", []);
+    if (!pageExists(this.component, paths, extensions)) throw new ComponentNotFoundError(this.component);
+  }
+  #config(scope, key, fallback) {
+    return scope?.bound(ConfigRepository) ? scope.make(ConfigRepository).get(key, fallback) : fallback;
+  }
+};
+function pageExists(component, paths, extensions) {
+  return paths.some((path) => extensions.some((extension) => existsSync(join(path, `${component}.${extension}`))));
+}
+
+// ResponseFactory.ts
+import {
+  ConfigRepository as ConfigRepository2,
+  Redirector
+} from "@orieljs/contracts";
+import { Arr as Arr2 } from "@orieljs/support";
+var ResponseFactory = class _ResponseFactory {
+  constructor(app, parent) {
+    this.app = app;
+    this.parent = parent;
+  }
+  app;
+  parent;
+  #shared = {};
+  #rootView;
+  #version;
+  #encryptHistory;
+  #urlResolver;
+  /** A per-request child of this (root) factory. */
+  forRequest() {
+    return new _ResponseFactory(this.app, this);
+  }
+  setRootView(view) {
+    this.#rootView = view;
+  }
+  getRootView() {
+    return this.#rootView ?? this.parent?.getRootView() ?? "app";
+  }
+  share(key, value) {
+    if (typeof key === "string") Arr2.set(this.#shared, key, value);
+    else Object.assign(this.#shared, key);
+  }
+  shareOnce(key, callback) {
+    const prop = new OnceProp(callback);
+    this.share(key, prop);
+    return prop;
+  }
+  getShared(key, defaultValue) {
+    const shared = { ...this.parent?.getShared(), ...this.#shared };
+    return key === void 0 ? shared : Arr2.get(shared, key, defaultValue);
+  }
+  flushShared() {
+    this.#shared = {};
+  }
+  version(version) {
+    this.#version = version;
+  }
+  /** The asset version as a string ('' when there is none), like Laravel's `(string) $version`. */
+  async getVersion() {
+    const version = this.#versionResolver();
+    const resolved = typeof version === "function" ? await version() : version;
+    return resolved === null || resolved === void 0 ? "" : String(resolved);
+  }
+  #versionResolver() {
+    return this.#version ?? (this.parent === void 0 ? void 0 : this.parent.#versionResolver());
+  }
+  #encrypts() {
+    return this.#encryptHistory ?? (this.parent === void 0 ? void 0 : this.parent.#encrypts());
+  }
+  #resolvesUrl() {
+    return this.#urlResolver ?? (this.parent === void 0 ? void 0 : this.parent.#resolvesUrl());
+  }
+  resolveUrlUsing(resolver) {
+    this.#urlResolver = resolver;
+  }
+  encryptHistory(encrypt = true) {
+    this.#encryptHistory = encrypt;
+  }
+  clearHistory() {
+    optionalSession()?.put(SessionKey.CLEAR_HISTORY, true);
+  }
+  preserveFragment() {
+    optionalSession()?.put(SessionKey.PRESERVE_FRAGMENT, true);
+  }
+  optional(callback) {
+    return new OptionalProp(callback);
+  }
+  defer(callback, group = "default", options = {}) {
+    return new DeferProp(callback, group, options);
+  }
+  always(value) {
+    return new AlwaysProp(value);
+  }
+  merge(value) {
+    return new MergeProp(value);
+  }
+  deepMerge(value) {
+    return new MergeProp(value).deepMerge();
+  }
+  once(callback) {
+    return new OnceProp(callback);
+  }
+  scroll(value, wrapper = "data", metadata) {
+    return new ScrollProp(value, wrapper, metadata);
+  }
+  /** Flashes page.flash data for the next Inertia response (stored in the session immediately). */
+  flash(key, value) {
+    const session = optionalSession();
+    if (session === void 0) return this;
+    const flash = typeof key === "string" ? { [key]: value } : key;
+    session.flash(SessionKey.FLASH_DATA, { ...session.get(SessionKey.FLASH_DATA, {}), ...flash });
+    return this;
+  }
+  back(fallback, status = 302) {
+    const scope = requestScope() ?? this.app;
+    return scope.make(Redirector).back(fallback, status);
+  }
+  /** 409 + X-Inertia-Location for Inertia requests (the client does a full visit), a plain 302 otherwise. */
+  location(url) {
+    const request = currentRequest();
+    if (request !== void 0 && isInertiaRequest(request)) {
+      return new globalThis.Response(null, { status: 409, headers: { [Header.LOCATION]: url } });
+    }
+    return new globalThis.Response(null, { status: 302, headers: { Location: url } });
+  }
+  render(component, props = {}) {
+    const config = this.app.bound(ConfigRepository2) ? this.app.make(ConfigRepository2) : void 0;
+    return new Response2(component, props, {
+      shared: this.getShared(),
+      rootView: this.getRootView(),
+      version: () => this.getVersion(),
+      encryptHistory: this.#encrypts() ?? config?.get("inertia.history.encrypt", false) ?? false,
+      urlResolver: this.#resolvesUrl(),
+      flash: (key, value) => void this.flash(key, value)
+    });
+  }
+};
+
+// helpers.ts
+import { Application, HttpRequest as HttpRequest2, InertiaFactory } from "@orieljs/contracts";
+import { ContainerNotAvailableError, currentContainer as currentContainer2 } from "@orieljs/container";
+function inertiaFactory() {
+  const container = currentContainer2();
+  if (container === void 0) throw new ContainerNotAvailableError("Inertia");
+  if (container.bound(HttpRequest2)) return container.make(InertiaFactory);
+  return container.make(Application).make(ResponseFactory);
+}
+function inertia(component, props = {}) {
+  const factory = inertiaFactory();
+  return component === void 0 ? factory : factory.render(component, props);
+}
+var Inertia = new Proxy({}, {
+  get(_target, property) {
+    if (typeof property === "symbol" || property === "then") return void 0;
+    const factory = inertiaFactory();
+    const value = Reflect.get(factory, property, factory);
+    return typeof value === "function" ? value.bind(factory) : value;
+  }
+});
+
+// html.ts
+import { InertiaSsrGateway } from "@orieljs/contracts";
+import { currentContainer as currentContainer3 } from "@orieljs/container";
+var InertiaHtml = class {
+  constructor(html) {
+    this.html = html;
+  }
+  html;
+  toHtml() {
+    return this.html;
+  }
+  toString() {
+    return this.html;
+  }
+};
+function pageJson(page) {
+  return JSON.stringify(page).replace(/\//g, "\\/").replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
+}
+function pageMarkup(page, id = "app") {
+  const safeId = id.replace(/[^A-Za-z0-9_-]/g, "");
+  return `<script data-page="${safeId}" type="application/json">${pageJson(page)}</script><div id="${safeId}"></div>`;
+}
+var dispatched = /* @__PURE__ */ new WeakMap();
+function ssr(page) {
+  let pending = dispatched.get(page);
+  if (pending === void 0) {
+    const container = currentContainer3();
+    pending = container?.bound(InertiaSsrGateway) ? container.make(InertiaSsrGateway).dispatch(page) : Promise.resolve(void 0);
+    dispatched.set(page, pending);
+  }
+  return pending;
+}
+function handled(promise) {
+  promise.catch(() => void 0);
+  return promise;
+}
+function inertiaHead(page) {
+  return handled(ssr(page).then((rendered) => new InertiaHtml(rendered?.head ?? "")));
+}
+function inertiaBody(page, id = "app") {
+  return handled(ssr(page).then((rendered) => new InertiaHtml(rendered?.body ?? pageMarkup(page, id))));
+}
+
+// Middleware.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import {
+  Application as Application2,
+  ConfigRepository as ConfigRepository3,
+  Container,
+  InertiaFactory as InertiaFactory2,
+  Redirector as Redirector2
+} from "@orieljs/contracts";
+import { inject } from "@orieljs/container";
+
+// ssr/requests.ts
+import { Str } from "@orieljs/support";
+var excluded = /* @__PURE__ */ new WeakSet();
+function withoutSsr(request, paths) {
+  const matches = paths.some((pattern) => {
+    const trimmed = pattern === "/" ? pattern : pattern.replace(/^\/+|\/+$/g, "");
+    return Str.is(trimmed, request.fullUrl()) || request.is(trimmed);
+  });
+  if (matches) excluded.add(request);
+}
+function isExcludedFromSsr(request) {
+  return excluded.has(request);
+}
+
+// Middleware.ts
+var InertiaMiddleware = class {
+  /** The root view rendered on the first visit: resources/views/app.tsx. */
+  rootViewName = "app";
+  /** Send every message per field instead of the first one. */
+  withAllErrors = false;
+  /** Paths (wildcards allowed) rendered without SSR. */
+  withoutSsr = [];
+  container = inject(Container);
+  /** The asset version: a hash of app.asset_url, else of public/build/manifest.json, else none. */
+  async version(_request) {
+    const config = this.container.bound(ConfigRepository3) ? this.container.make(ConfigRepository3) : void 0;
+    const assetUrl = config?.get("app.asset_url", null);
+    if (typeof assetUrl === "string" && assetUrl !== "") return md5(assetUrl);
+    const app = this.container.make(Application2);
+    const manifest = app.publicPath("build/manifest.json");
+    return existsSync2(manifest) ? md5(readFileSync(manifest)) : null;
+  }
+  /** Props shared with every page. Override and spread `await super.share(request)` into your own. */
+  async share(request) {
+    return { errors: new AlwaysProp(this.resolveValidationErrors(request)) };
+  }
+  /** Shared once props: sent on the first visit, then kept by the client. */
+  async shareOnce(_request) {
+    return {};
+  }
+  rootView(_request) {
+    return this.rootViewName;
+  }
+  /** How page.url is built; undefined keeps the default (path + query). */
+  urlResolver() {
+    return void 0;
+  }
+  async handle(request, next) {
+    const inertia2 = this.container.make(InertiaFactory2);
+    inertia2.version(() => this.version(request));
+    inertia2.share(await this.share(request));
+    for (const [key, value] of Object.entries(await this.shareOnce(request))) {
+      if (value instanceof OnceProp) inertia2.share(key, value);
+      else inertia2.shareOnce(key, value);
+    }
+    inertia2.setRootView(this.rootView(request));
+    const resolver = this.urlResolver();
+    if (resolver !== void 0) inertia2.resolveUrlUsing(resolver);
+    if (this.withoutSsr.length > 0) withoutSsr(request, this.withoutSsr);
+    let response = await next(request);
+    response = rebuild(response, { headers: { Vary: "X-Inertia" } });
+    const redirect = isRedirect(response);
+    const session = optionalSession();
+    if (redirect && session !== void 0) this.reflash(session);
+    if (!isInertiaRequest(request)) return response;
+    if (session !== void 0 && this.shouldStoreCurrentUrl(request, response)) session.setPreviousUrl(request.fullUrl());
+    if (request.method() === "GET" && request.header(Header.VERSION, "") !== await inertia2.getVersion()) {
+      response = await this.onVersionChange(request, response);
+    }
+    if (isEmpty(response)) response = await this.onEmptyResponse(request, response);
+    if (response.status === 302 && ["PUT", "PATCH", "DELETE"].includes(request.method())) response = rebuild(response, { status: 303 });
+    if (redirect && (response.headers.get("Location") ?? "").includes("#") && !isPrefetch(request)) {
+      response = await this.onRedirectWithFragment(request, response);
+    }
+    return response;
+  }
+  /** The session's flashed errors ({ [bag]: { field: string[] } }), shaped for the client. */
+  resolveValidationErrors(request) {
+    const flashed = optionalSession()?.get("errors", void 0);
+    if (flashed === void 0 || flashed === null || typeof flashed !== "object") return {};
+    const bags = Object.fromEntries(
+      Object.entries(flashed).map(([bag, fields]) => [
+        bag,
+        Object.fromEntries(
+          Object.entries(fields ?? {}).map(([field, messages]) => {
+            const list = Array.isArray(messages) ? messages.map(String) : [String(messages)];
+            return [field, this.withAllErrors ? list : list[0] ?? ""];
+          })
+        )
+      ])
+    );
+    const errorBag = request.header(Header.ERROR_BAG);
+    if (bags.default !== void 0 && errorBag !== void 0 && errorBag !== "") return { [errorBag]: bags.default };
+    if (bags.default !== void 0) return bags.default;
+    return bags;
+  }
+  /** inertia.store_previous_url: Inertia GET visits (not prefetches or same-page partial reloads) become previous(). */
+  shouldStoreCurrentUrl(request, _response) {
+    const config = this.container.bound(ConfigRepository3) ? this.container.make(ConfigRepository3) : void 0;
+    if (config?.get("inertia.store_previous_url", false) !== true) return false;
+    if (request.method() !== "GET" || !request.ajax() || isPrefetch(request)) return false;
+    const partial = request.header(Header.PARTIAL_COMPONENT);
+    return partial === void 0 || partial === "";
+  }
+  async onEmptyResponse(request, _response) {
+    return this.container.make(Redirector2).back().toResponse(request);
+  }
+  async onRedirectWithFragment(_request, response) {
+    return new Response(null, { status: 409, headers: { [Header.REDIRECT]: response.headers.get("Location") ?? "" } });
+  }
+  async onVersionChange(request, _response) {
+    optionalSession()?.reflash();
+    const inertia2 = this.container.make(InertiaFactory2);
+    const response = inertia2.location(request.fullUrl());
+    return rebuild(response, { headers: { [Header.VERSION]: await inertia2.getVersion() } });
+  }
+  /** Keeps Inertia flash data for the page the redirect leads to. */
+  reflash(session) {
+    const flashed = session.get(SessionKey.FLASH_DATA, void 0);
+    if (flashed !== void 0 && flashed !== null && Object.keys(flashed).length > 0) session.flash(SessionKey.FLASH_DATA, flashed);
+  }
+};
+function isEmpty(response) {
+  if (response.status === 204) return true;
+  return response.status === 200 && (response.body === null || response.headers.get("content-length") === "0");
+}
+function md5(value) {
+  return createHash("md5").update(value).digest("hex");
+}
+
+// EncryptHistory.ts
+import { Container as Container2, InertiaFactory as InertiaFactory3 } from "@orieljs/contracts";
+import { inject as inject2 } from "@orieljs/container";
+var EncryptHistory = class {
+  #container = inject2(Container2);
+  async handle(request, next) {
+    this.#container.make(InertiaFactory3).encryptHistory();
+    return next(request);
+  }
+};
+
+// InertiaServiceProvider.ts
+import { ConsoleKernel, InertiaFactory as InertiaFactory4, InertiaSsrGateway as InertiaSsrGateway2, Router as Router2 } from "@orieljs/contracts";
+import { ServiceProvider } from "@orieljs/support";
+
+// commands.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, isAbsolute, join as join2, relative } from "path";
+import { ConfigRepository as ConfigRepository4, Router } from "@orieljs/contracts";
+
+// routes.ts
+import { Str as Str2 } from "@orieljs/support";
+var PARAMETER = /\{([A-Za-z_][A-Za-z0-9_]*)(?::([A-Za-z_][A-Za-z0-9_]*))?(\?)?\}/g;
+function routeParameters(uri) {
+  return [...uri.matchAll(PARAMETER)].map((match) => ({ name: match[1], optional: match[3] === "?", field: match[2] }));
+}
+function routeTable(routes, except = []) {
+  const table = {};
+  const named = routes.map((route) => ({ route, name: route.getName() })).filter((entry) => entry.name !== void 0 && entry.name !== "").filter(({ name }) => !except.some((pattern) => Str2.is(pattern, name))).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  for (const { route, name } of named) table[name] = { uri: route.uri, methods: [...route.methods] };
+  return table;
+}
+var ESCAPES = { "\\": "\\\\", "'": "\\'", "\n": "\\n", "\r": "\\r", "\u2028": "\\u2028", "\u2029": "\\u2029" };
+var quote = (value) => `'${value.replace(/[\\\u0027\n\r\u2028\u2029]/g, (char) => ESCAPES[char])}'`;
+function parameterType(uri) {
+  const parameters = routeParameters(uri);
+  if (parameters.length === 0) return "Record<never, never>";
+  return `{ ${parameters.map(({ name, optional }) => `${name}${optional ? "?" : ""}: RouteParameter`).join("; ")} }`;
+}
+function renderRoutesModule(table, clientModule = "@orieljs/inertia-client") {
+  const names = Object.keys(table);
+  const entries = names.map((name) => {
+    const { uri, methods } = table[name];
+    return `  ${quote(name)}: { uri: ${quote(uri)}, methods: [${methods.map(quote).join(", ")}] },`;
+  });
+  const types = names.map((name) => `    ${quote(name)}: ${parameterType(table[name].uri)}`);
+  return [
+    "// Generated by `oriel route:types`. Do not edit: run `oriel route:types` again.",
+    // Built by concatenation so tools that scan source for imports don't mistake this template for one.
+    `import { defineRoutes, type RouteParameter } from ${quote(clientModule)}`,
+    "",
+    `export const routes = defineRoutes({${entries.length === 0 ? "" : `
+${entries.join("\n")}
+`}})`,
+    "",
+    `declare module ${quote(clientModule)} {`,
+    "  interface RouteList {",
+    ...types,
+    "  }",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderServerRouteTypes(table) {
+  const members = Object.keys(table).map((name) => `    ${quote(name)}: ${parameterType(table[name].uri).replace(/RouteParameter/g, "unknown")}`);
+  const block = (module) => [`declare module ${quote(module)} {`, "  interface RouteList {", ...members, "  }", "}"];
+  return [
+    "// Generated by `oriel route:types`. Do not edit: run `oriel route:types` again.",
+    "",
+    ...block("@orieljs/framework"),
+    "",
+    ...block("@orieljs/framework/contracts"),
+    "",
+    "export {}",
+    ""
+  ].join("\n");
+}
+
+// commands.ts
+var MIDDLEWARE_STUB = `import { InertiaMiddleware } from '@orieljs/framework'
+import type { HttpRequest } from '@orieljs/framework/contracts'
+
+export class {{ class }} extends InertiaMiddleware {
+  /** The root view loaded on the first page visit: resources/views/app.tsx. */
+  protected override rootViewName = 'app'
+
+  /** Props shared with every page (typed for the pages by \`oriel inertia:types\`). */
+  override async share(request: HttpRequest) {
+    return {
+      ...(await super.share(request)),
+    }
+  }
+}
+`;
+async function loadPageTypes() {
+  const specifier = "@orieljs/vite/types";
+  try {
+    return await import(
+      /* @vite-ignore */
+      specifier
+    );
+  } catch {
+    return void 0;
+  }
+}
+function registerInertiaCommands(kernel, app, gateway, options = {}) {
+  const config = (key, fallback) => app.bound(ConfigRepository4) ? app.make(ConfigRepository4).get(key, fallback) : fallback;
+  const absolute = (path) => isAbsolute(path) ? path : app.basePath(path);
+  kernel.command(
+    "route:types {--output= : Where to write the route module} {--server= : Where to write the server route name types}",
+    async function() {
+      if (!app.bound(Router)) {
+        this.error("The router is not available. Is the Routing service provider registered?");
+        return 1;
+      }
+      const output = absolute(optionText(this.option("output")) ?? config("inertia.types.routes", "resources/js/oriel/routes.ts"));
+      const server = absolute(optionText(this.option("server")) ?? config("inertia.types.server_routes", "types/routes.d.ts"));
+      const table = routeTable(app.make(Router).getRoutes(), config("inertia.types.except_routes", []));
+      await mkdir(dirname(output), { recursive: true });
+      await writeFile(output, renderRoutesModule(table));
+      await mkdir(dirname(server), { recursive: true });
+      await writeFile(server, renderServerRouteTypes(routeTable(app.make(Router).getRoutes())));
+      this.info(`Route types for ${Object.keys(table).length} named routes written to ${relative(app.basePath(), output)}.`);
+      return 0;
+    }
+  ).purpose("Generate the route table and route name types for the frontend");
+  kernel.command("inertia:types {--output= : Where to write the page types}", async function() {
+    const module = await (options.pageTypes ?? loadPageTypes)();
+    if (module === void 0) {
+      this.error("Generating page types needs @orieljs/vite: install it as a dev dependency.");
+      return 1;
+    }
+    const output = absolute(optionText(this.option("output")) ?? config("inertia.types.pages", "resources/js/oriel/pages.d.ts"));
+    const result = await module.generatePageTypes({ root: app.basePath(), output });
+    for (const warning of result.warnings) this.warn(warning);
+    this.info(`Page types for ${result.pages} pages written to ${relative(app.basePath(), result.output)}.`);
+    return 0;
+  }).purpose("Generate TypeScript types for the Inertia page props");
+  kernel.command("inertia:middleware {name=HandleInertiaRequests : The middleware class name} {--force : Overwrite an existing file}", async function() {
+    const name = String(this.argument("name") ?? "HandleInertiaRequests");
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+      this.error(`Middleware name [${name}] is not a valid class name.`);
+      return 1;
+    }
+    const file = app.appPath(join2("Http", "Middleware", `${name}.ts`));
+    if (existsSync3(file) && this.option("force") !== true) {
+      this.error(`Middleware [${relative(app.basePath(), file)}] already exists.`);
+      return 1;
+    }
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, MIDDLEWARE_STUB.replace("{{ class }}", () => name));
+    this.info(`Middleware [${relative(app.basePath(), file)}] created successfully.`);
+    return 0;
+  }).purpose("Create a new Inertia middleware");
+  kernel.command("inertia:start-ssr {--runtime= : The runtime that runs the SSR bundle (node or bun)}", async function() {
+    if (!config("inertia.ssr.enabled", true)) {
+      this.error("Inertia SSR is not enabled. Enable it via the `inertia.ssr.enabled` config option.");
+      return 1;
+    }
+    const bundle = gateway.bundle();
+    if (bundle === void 0) {
+      this.error("Inertia SSR bundle not found. Build it with `vite build --ssr`, or set `inertia.ssr.bundle`.");
+      return 1;
+    }
+    const runtime = optionText(this.option("runtime")) ?? config("inertia.ssr.runtime", "node");
+    const child = (options.spawn ?? spawn)(runtime, [bundle], { stdio: "inherit" });
+    return await new Promise((resolve) => {
+      child.on("exit", (code) => resolve(code ?? 0));
+      child.on("error", (error) => {
+        this.error(`Could not start the SSR server: ${error.message}`);
+        resolve(1);
+      });
+    });
+  }).purpose("Start the Inertia SSR server");
+  kernel.command("inertia:stop-ssr", async function() {
+    try {
+      await fetch(`${gateway.productionUrl()}/shutdown`);
+    } catch {
+    }
+    this.info("Inertia SSR server stopped.");
+    return 0;
+  }).purpose("Stop the Inertia SSR server");
+  kernel.command("inertia:check-ssr", async function() {
+    if (await gateway.isHealthy()) {
+      this.info("Inertia SSR server is running.");
+      return 0;
+    }
+    this.error("Inertia SSR server is not running.");
+    return 1;
+  }).purpose("Check the Inertia SSR server health status");
+}
+function optionText(value) {
+  return value === void 0 || value === null || value === false || value === "" ? void 0 : String(value);
+}
+
+// ssr/HttpGateway.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import {
+  ConfigRepository as ConfigRepository5,
+  EventDispatcher
+} from "@orieljs/contracts";
+import { Str as Str3 } from "@orieljs/support";
+var SSR_RENDER_FAILED = "inertia.ssr.failed";
+var HttpGateway = class {
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  #disabled;
+  #except = [];
+  disable(condition = true) {
+    this.#disabled = condition;
+  }
+  /** Paths (wildcards allowed) never rendered on the server. */
+  except(paths) {
+    this.#except.push(...[paths].flat());
+  }
+  async dispatch(page) {
+    if (!this.enabled(currentRequest())) return void 0;
+    const hot = this.hotUrl();
+    if (hot === void 0 && this.#config("inertia.ssr.ensure_bundle_exists", true) && this.bundle() === void 0) return void 0;
+    const url = hot === void 0 ? `${this.productionUrl()}/render` : `${hot}/__inertia_ssr`;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json", accept: "application/json" },
+        body: JSON.stringify(page),
+        signal: this.#signal()
+      });
+      const data = await response.json().catch(() => null);
+      if (!response.ok) {
+        await this.#failed({ page, error: String(data?.error ?? `SSR server responded with ${response.status}`), type: String(data?.type ?? "render"), ...details(data) });
+        return void 0;
+      }
+      if (data === null) return void 0;
+      return { head: (data.head ?? []).join("\n"), body: data.body ?? "" };
+    } catch (error) {
+      if (error instanceof SsrError) throw error;
+      await this.#failed({ page, error: error instanceof Error ? error.message : String(error), type: "connection" });
+      return void 0;
+    }
+  }
+  /** GET {inertia.ssr.url}/health: any 2xx is healthy. */
+  async isHealthy() {
+    try {
+      return (await fetch(`${this.productionUrl()}/health`, { signal: this.#signal() })).ok;
+    } catch {
+      return false;
+    }
+  }
+  productionUrl() {
+    return this.#config("inertia.ssr.url", "http://127.0.0.1:13714").replace(/\/+$/, "");
+  }
+  /** inertia.ssr.hot_url, else the Vite dev server URL in public/hot; undefined when Vite isn't running. */
+  hotUrl() {
+    const hotFile = this.app.publicPath("hot");
+    if (!existsSync4(hotFile)) return void 0;
+    const configured = this.#config("inertia.ssr.hot_url", null);
+    const url = configured !== null && configured !== "" ? configured : readFileSync2(hotFile, "utf8");
+    return url.trim().replace(/\/+$/, "");
+  }
+  /** inertia.ssr.bundle, else bootstrap/ssr/{ssr,app}.{js,mjs}, else public/js/{ssr,app}.js (BundleDetector). */
+  bundle() {
+    const configured = this.#config("inertia.ssr.bundle", null);
+    const candidates = [
+      configured,
+      this.app.basePath("bootstrap/ssr/ssr.js"),
+      this.app.basePath("bootstrap/ssr/app.js"),
+      this.app.basePath("bootstrap/ssr/ssr.mjs"),
+      this.app.basePath("bootstrap/ssr/app.mjs"),
+      this.app.publicPath("js/ssr.js"),
+      this.app.publicPath("js/app.js")
+    ];
+    return candidates.find((path) => typeof path === "string" && path !== "" && existsSync4(path));
+  }
+  enabled(request) {
+    const disabled = this.#disabled;
+    const enabled = disabled !== void 0 ? !(typeof disabled === "function" ? disabled() : disabled) : this.#config("inertia.ssr.enabled", true);
+    if (!enabled) return false;
+    if (request === void 0) return true;
+    if (isExcludedFromSsr(request)) return false;
+    return !this.#except.some((pattern) => {
+      const trimmed = pattern === "/" ? pattern : pattern.replace(/^\/+|\/+$/g, "");
+      return Str3.is(trimmed, request.fullUrl()) || request.is(trimmed);
+    });
+  }
+  async #failed(failure) {
+    const scope = requestScope() ?? this.app;
+    if (scope.bound(EventDispatcher)) await scope.make(EventDispatcher).dispatch(SSR_RENDER_FAILED, [failure]);
+    if (this.#config("inertia.ssr.throw_on_error", false)) throw new SsrError(`SSR render failed: ${failure.error}`);
+  }
+  #signal() {
+    const seconds = this.#config("inertia.ssr.timeout", null);
+    return typeof seconds === "number" && seconds > 0 ? AbortSignal.timeout(seconds * 1e3) : void 0;
+  }
+  #config(key, fallback) {
+    return this.app.bound(ConfigRepository5) ? this.app.make(ConfigRepository5).get(key, fallback) : fallback;
+  }
+};
+function details(data) {
+  const text = (key) => typeof data?.[key] === "string" ? data[key] : void 0;
+  return { hint: text("hint"), browserApi: text("browserApi"), stack: text("stack"), sourceLocation: text("sourceLocation") };
+}
+
+// InertiaServiceProvider.ts
+var InertiaServiceProvider = class extends ServiceProvider {
+  register() {
+    this.mergeConfigFrom(
+      {
+        ssr: {
+          enabled: true,
+          runtime: "node",
+          url: "http://127.0.0.1:13714",
+          hot_url: null,
+          timeout: null,
+          ensure_bundle_exists: true,
+          bundle: null,
+          throw_on_error: false
+        },
+        pages: {
+          ensure_pages_exist: false,
+          paths: [this.app.resourcePath("js/pages")],
+          extensions: ["js", "jsx", "svelte", "ts", "tsx", "vue", "component.ts"]
+        },
+        testing: { ensure_pages_exist: true },
+        expose_shared_prop_keys: true,
+        store_previous_url: false,
+        history: { encrypt: false },
+        types: { pages: "resources/js/oriel/pages.d.ts", routes: "resources/js/oriel/routes.ts", server_routes: "types/routes.d.ts", except_routes: [] }
+      },
+      "inertia"
+    );
+    this.app.singleton(ResponseFactory, () => new ResponseFactory(this.app));
+    this.app.scoped(InertiaFactory4, (container) => container.make(ResponseFactory).forRequest());
+    this.app.singleton(HttpGateway, () => new HttpGateway(this.app));
+    this.app.singleton(InertiaSsrGateway2, (container) => container.make(HttpGateway));
+  }
+  boot() {
+    if (this.app.bound(Router2)) this.app.make(Router2).aliasMiddleware("inertia.encrypt", EncryptHistory);
+    if (this.app.bound(ConsoleKernel)) registerInertiaCommands(this.app.make(ConsoleKernel), this.app, this.app.make(HttpGateway));
+  }
+};
+export {
+  AlwaysProp,
+  ComponentNotFoundError,
+  DeferProp,
+  EncryptHistory,
+  Header,
+  HttpGateway,
+  Inertia,
+  InertiaError,
+  InertiaHtml,
+  InertiaMiddleware,
+  Response2 as InertiaPageResponse,
+  ResponseFactory as InertiaResponseFactory,
+  InertiaServiceProvider,
+  MIDDLEWARE_STUB,
+  MergeProp,
+  MergeableProp,
+  OnceProp,
+  OptionalProp,
+  Prop,
+  PropsResolver,
+  SSR_RENDER_FAILED,
+  ScrollProp,
+  SessionKey,
+  SsrError,
+  currentRequest,
+  defaultUrl,
+  inertia,
+  inertiaBody,
+  inertiaFactory,
+  inertiaHead,
+  isExcludedFromSsr,
+  isInertiaRequest,
+  isPrefetch,
+  isProp,
+  isRedirect,
+  optionalSession,
+  pageExists,
+  pageJson,
+  pageMarkup,
+  parseList,
+  rebuild,
+  registerInertiaCommands,
+  renderRoutesModule,
+  renderServerRouteTypes,
+  requestScope,
+  routeParameters,
+  routeTable,
+  scrollMetadataFrom,
+  secondsUntil,
+  withoutSsr
+};
+//# sourceMappingURL=index.js.map