@gravito/ion 3.0.1 → 4.0.0

package/dist/index.js

@@ -1,158 +1,669 @@
+// src/errors.ts
+var InertiaError = class extends Error {
+  constructor(code, httpStatus = 500, details) {
+    super(code);
+    this.code = code;
+    this.httpStatus = httpStatus;
+    this.details = details;
+    this.name = "InertiaError";
+    Object.setPrototypeOf(this, new.target.prototype);
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      httpStatus: this.httpStatus,
+      message: this.message,
+      details: this.details
+    };
+  }
+};
+var InertiaConfigError = class extends InertiaError {
+  constructor(message, details) {
+    super("CONFIG_ERROR", 500, {
+      ...details,
+      message,
+      hint: details?.hint ?? "Check your OrbitIon configuration and ensure dependencies are loaded."
+    });
+    this.name = "InertiaConfigError";
+  }
+};
+var InertiaDataError = class extends InertiaError {
+  constructor(message, details) {
+    super("DATA_ERROR", 500, {
+      ...details,
+      message,
+      hint: details?.hint ?? "Ensure all props are JSON-serializable (no circular refs, BigInt, or functions)."
+    });
+    this.name = "InertiaDataError";
+  }
+};
+var InertiaTemplateError = class extends InertiaError {
+  constructor(message, details) {
+    super("TEMPLATE_ERROR", 500, {
+      ...details,
+      message,
+      hint: details?.hint ?? "Check if the root view template exists and is properly configured."
+    });
+    this.name = "InertiaTemplateError";
+  }
+};
+
 // src/InertiaService.ts
 var InertiaService = class {
   /**
-   * Create a new InertiaService instance
+   * Initializes a new instance of the Inertia service.
    *
-   * @param context - The Gravito request context
-   * @param config - Optional configuration
+   * @param context - The current Gravito request context.
+   * @param config - Instance configuration options.
    */
   constructor(context, config = {}) {
     this.context = context;
     this.config = config;
+    this.logLevel = config.logLevel ?? "info";
+    this.onRenderCallback = config.onRender;
   }
   sharedProps = {};
+  errorBags = {};
+  encryptHistoryFlag = false;
+  clearHistoryFlag = false;
+  logLevel;
+  onRenderCallback;
+  /**
+   * Creates a deferred prop that will be loaded after the initial render.
+   *
+   * @param factory - Function that resolves to the prop value.
+   * @param group - Optional group name for organizing deferred props.
+   * @returns A deferred prop definition.
+   *
+   * @example
+   * ```typescript
+   * props: {
+   *   user: { id: 1 },
+   *   stats: InertiaService.defer(() => fetchStats())
+   * }
+   * ```
+   */
+  static defer(factory, group = "default") {
+    return {
+      _type: "deferred",
+      factory,
+      group
+    };
+  }
   /**
-   * Escape a string for safe use in HTML attributes
+   * Marks a prop to be merged (shallow) with existing data during partial reloads.
    *
-   * Strategy: JSON.stringify already escapes special characters including
-   * quotes as \". We need to escape these for HTML attributes, but we must
-   * be careful not to break JSON escape sequences.
+   * @param value - The prop value to merge.
+   * @param matchOn - Optional key(s) to match on when merging arrays.
+   * @returns A merge prop definition.
+   */
+  static merge(value, matchOn) {
+    return {
+      _type: "merge",
+      value,
+      matchOn
+    };
+  }
+  /**
+   * Marks a prop to prepend to an array during partial reloads.
    *
-   * The solution: Escape backslash-quote sequences (\" from JSON.stringify)
-   * as \\" so they become \\" in HTML, which the browser decodes
-   * to \\" (valid JSON), not \" (invalid JSON).
+   * @param value - The prop value to prepend.
+   * @returns A prepend prop definition.
+   */
+  static prepend(value) {
+    return {
+      _type: "prepend",
+      value
+    };
+  }
+  /**
+   * Marks a prop to be deep-merged with existing data during partial reloads.
    *
-   * @param value - The string to escape.
-   * @returns The escaped string.
+   * @param value - The prop value to deep merge.
+   * @returns A deep merge prop definition.
+   */
+  static deepMerge(value) {
+    return {
+      _type: "deepMerge",
+      value
+    };
+  }
+  /**
+   * Internal logging helper that respects the configured log level.
+   *
+   * Routes logs to the Gravito context logger if available.
+   *
+   * @param level - Log severity level.
+   * @param message - Descriptive message.
+   * @param data - Optional metadata for the log.
+   */
+  log(level, message, data) {
+    const levels = ["debug", "info", "warn", "error", "silent"];
+    const currentLevelIndex = levels.indexOf(this.logLevel);
+    const messageLevelIndex = levels.indexOf(level);
+    if (this.logLevel === "silent" || messageLevelIndex < currentLevelIndex) {
+      return;
+    }
+    const logger = typeof this.context.get === "function" ? this.context.get("logger") : void 0;
+    if (logger && typeof logger[level] === "function") {
+      logger[level](message, data);
+    }
+  }
+  /**
+   * Escapes a string for safe embedding into a single-quoted HTML attribute.
+   *
+   * This ensures that JSON strings can be safely passed to the frontend
+   * via the `data-page` attribute without breaking the HTML structure or
+   * introducing XSS vulnerabilities.
+   *
+   * @param value - Raw JSON or text string.
+   * @returns Safely escaped HTML attribute value.
    */
   escapeForSingleQuotedHtmlAttribute(value) {
     return value.replace(/&/g, "&amp;").replace(/\\"/g, "\\&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&#039;");
   }
   /**
-   * Render an Inertia component
+   * Renders an Inertia component and returns the appropriate HTTP response.
+   *
+   * This method handles the entire Inertia lifecycle:
+   * - Detects if the request is an Inertia AJAX request.
+   * - Validates asset versions.
+   * - Resolves props (executes functions, handles partial reloads).
+   * - Performs SSR if configured.
+   * - Wraps the result in a JSON response or the root HTML template.
    *
-   * @param component - The component name to render
-   * @param props - Props to pass to the component
-   * @param rootVars - Additional variables for the root template
-   * @returns HTTP Response
+   * @param component - Frontend component name (e.g., 'Users/Profile').
+   * @param props - Data passed to the component. Can include functions for lazy evaluation.
+   * @param rootVars - Variables passed to the root HTML template (only used on initial load).
+   * @param status - Optional HTTP status code.
+   * @returns A promise that resolves to a Gravito HTTP Response.
+   *
+   * @throws {@link InertiaError}
+   * Thrown if:
+   * - The `ViewService` is missing from the context (required for initial load).
+   * - Prop serialization fails due to circular references or non-serializable data.
    *
    * @example
    * ```typescript
-   * return inertia.render('Users/Index', {
-   *   users: await User.all(),
-   *   filters: { search: ctx.req.query('search') }
-   * })
+   * // Standard render
+   * return await inertia.render('Welcome', { name: 'Guest' });
+   *
+   * // Partial reload support (only 'stats' will be resolved if requested)
+   * return await inertia.render('Dashboard', {
+   *   user: auth.user,
+   *   stats: () => db.getStats()
+   * });
    * ```
    */
-  render(component, props = {}, rootVars = {}) {
-    let pageUrl;
+  async render(component, props, rootVars = {}, status) {
+    const startTime = performance.now();
+    const isInertiaRequest = Boolean(this.context.req.header("X-Inertia"));
     try {
-      const reqUrl = new URL(this.context.req.url, "http://localhost");
-      pageUrl = reqUrl.pathname + reqUrl.search;
-    } catch {
-      pageUrl = this.context.req.url;
-    }
-    const resolveProps = (p) => {
-      const resolved = {};
-      for (const [key, value] of Object.entries(p)) {
-        resolved[key] = typeof value === "function" ? value() : value;
+      this.log("debug", "[InertiaService] Starting render", {
+        component,
+        isInertiaRequest,
+        propsCount: props ? Object.keys(props).length : 0
+      });
+      let pageUrl;
+      try {
+        const reqUrl = new URL(this.context.req.url, "http://localhost");
+        pageUrl = reqUrl.pathname + reqUrl.search;
+      } catch {
+        pageUrl = this.context.req.url;
       }
-      return resolved;
-    };
-    const page = {
-      component,
-      props: resolveProps({ ...this.sharedProps, ...props }),
-      url: pageUrl,
-      version: this.config.version
-    };
-    if (this.context.req.header("X-Inertia")) {
-      this.context.header("X-Inertia", "true");
-      this.context.header("Vary", "Accept");
-      return this.context.json(page);
-    }
-    const view = this.context.get("view");
-    const rootView = this.config.rootView ?? "app";
-    if (!view) {
-      throw new Error("OrbitPrism is required for the initial page load in OrbitIon");
+      const resolveProps = async (p) => {
+        const partialData = this.context.req.header("X-Inertia-Partial-Data");
+        const partialExcept = this.context.req.header("X-Inertia-Partial-Except");
+        const partialComponent = this.context.req.header("X-Inertia-Partial-Component");
+        const resetKeys = this.context.req.header("X-Inertia-Reset");
+        const isPartial = partialComponent === component;
+        const only = partialData && isPartial ? partialData.split(",") : [];
+        const except = partialExcept && isPartial ? partialExcept.split(",") : [];
+        const resetKeyList = resetKeys ? resetKeys.split(",") : [];
+        const resolved = {};
+        const deferredGroups2 = {};
+        const mergedKeys2 = [];
+        for (const [key, value] of Object.entries(p)) {
+          if (only.length > 0 && !only.includes(key)) {
+            continue;
+          }
+          if (except.length > 0 && except.includes(key)) {
+            continue;
+          }
+          if (value && typeof value === "object" && "_type" in value && value._type === "deferred") {
+            const deferred = value;
+            const group = deferred.group ?? "default";
+            if (!deferredGroups2[group]) {
+              deferredGroups2[group] = [];
+            }
+            deferredGroups2[group].push(key);
+            continue;
+          }
+          if (value && typeof value === "object" && "_type" in value && ["merge", "prepend", "deepMerge"].includes(value._type)) {
+            const merged = value;
+            const existing = mergedKeys2.find((m) => m.mode === merged._type);
+            if (existing) {
+              existing.keys.push(key);
+            } else {
+              mergedKeys2.push({
+                keys: [key],
+                mode: merged._type
+              });
+            }
+            resolved[key] = merged.value;
+            continue;
+          }
+          if (resetKeyList.includes(key)) {
+            resolved[key] = void 0;
+            continue;
+          }
+          if (typeof value === "function") {
+            const propStart = performance.now();
+            try {
+              resolved[key] = await value();
+              this.log("debug", `[InertiaService] Resolved lazy prop: ${key}`, {
+                duration: `${(performance.now() - propStart).toFixed(2)}ms`
+              });
+            } catch (err) {
+              this.log("error", `[InertiaService] Failed to resolve lazy prop: ${key}`, { err });
+              throw new InertiaDataError(`Failed to resolve lazy prop: ${key}`, { cause: err });
+            }
+          } else {
+            resolved[key] = value;
+          }
+        }
+        return { resolved, deferredGroups: deferredGroups2, mergedKeys: mergedKeys2 };
+      };
+      const resolveVersion = async () => {
+        if (typeof this.config.version === "function") {
+          return await this.config.version();
+        }
+        return this.config.version;
+      };
+      const version = await resolveVersion();
+      const getMergedProps = () => {
+        const propsToMerge = props ?? {};
+        if (Object.keys(propsToMerge).length === 0) {
+          return this.sharedProps;
+        }
+        return { ...this.sharedProps, ...propsToMerge };
+      };
+      const {
+        resolved: resolvedPropsData,
+        deferredGroups,
+        mergedKeys
+      } = await resolveProps(getMergedProps());
+      const page = {
+        component,
+        props: resolvedPropsData,
+        url: pageUrl,
+        version
+      };
+      if (Object.keys(deferredGroups).length > 0) {
+        page.deferredProps = deferredGroups;
+      }
+      if (mergedKeys.length > 0) {
+        page.mergeProps = mergedKeys;
+      }
+      if (this.encryptHistoryFlag) {
+        page.encryptHistory = true;
+      }
+      if (this.clearHistoryFlag) {
+        page.clearHistory = true;
+      }
+      if (Object.keys(this.errorBags).length > 0) {
+        page.errorBags = this.errorBags;
+      }
+      let pageJson;
+      try {
+        pageJson = JSON.stringify(page);
+      } catch (error) {
+        throw new InertiaDataError(
+          `Inertia page serialization failed for component: ${component}`,
+          {
+            cause: error
+          }
+        );
+      }
+      let response;
+      if (isInertiaRequest) {
+        const clientVersion = this.context.req.header("X-Inertia-Version");
+        if (version && clientVersion && clientVersion !== version) {
+          this.context.header("X-Inertia-Location", pageUrl);
+          return new Response("", { status: 409 });
+        }
+        this.context.header("X-Inertia", "true");
+        this.context.header("Vary", "Accept");
+        response = this.context.json(page, status);
+      } else {
+        const view = this.context.get("view");
+        const rootView = this.config.rootView ?? "app";
+        if (!view) {
+          throw new InertiaConfigError(
+            "ViewService (OrbitPrism) is required for initial page load but was not found in context.",
+            { hint: "Ensure OrbitPrism is loaded before OrbitIon in your orbit configuration" }
+          );
+        }
+        const isDev = process.env.NODE_ENV !== "production";
+        let ssrData = { head: [], body: "" };
+        if (this.config.ssr?.enabled && this.config.ssr.render) {
+          try {
+            ssrData = await this.config.ssr.render(page);
+          } catch (error) {
+            this.log("error", "[InertiaService] SSR rendering failed", { error });
+          }
+        }
+        response = this.context.html(
+          view.render(
+            rootView,
+            {
+              ...rootVars,
+              page: this.escapeForSingleQuotedHtmlAttribute(pageJson),
+              isDev,
+              ssrHead: ssrData.head.join("\n"),
+              ssrBody: ssrData.body
+            },
+            { layout: "" }
+          ),
+          status
+        );
+      }
+      const duration = performance.now() - startTime;
+      this.log("info", "[InertiaService] Render complete", {
+        component,
+        duration: `${duration.toFixed(2)}ms`,
+        isInertiaRequest,
+        status: status ?? 200
+      });
+      if (this.onRenderCallback) {
+        this.onRenderCallback({
+          component,
+          duration,
+          isInertiaRequest,
+          propsCount: props ? Object.keys(props).length : 0,
+          timestamp: Date.now(),
+          status
+        });
+      }
+      return response;
+    } catch (error) {
+      const duration = performance.now() - startTime;
+      if (error instanceof InertiaError) {
+        this.log("error", "[InertiaService] Render failed", {
+          component,
+          duration: `${duration.toFixed(2)}ms`,
+          errorCode: error.code,
+          errorDetails: error.details
+        });
+        throw error;
+      }
+      this.log("error", "[InertiaService] Unexpected render error", {
+        component,
+        duration: `${duration.toFixed(2)}ms`,
+        error
+      });
+      const isDev = process.env.NODE_ENV !== "production";
+      if (isDev && error instanceof Error) {
+        const errorHtml = `
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <meta charset="utf-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1">
+              <title>Inertia Render Error</title>
+              <style>
+                * { margin: 0; padding: 0; box-sizing: border-box; }
+                body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto; background: #f5f5f5; padding: 20px; }
+                .container { max-width: 800px; margin: 40px auto; background: white; border-radius: 8px; padding: 30px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }
+                h1 { color: #d32f2f; margin-bottom: 10px; font-size: 24px; }
+                .meta { color: #666; margin-bottom: 20px; font-size: 14px; }
+                .component { background: #f5f5f5; padding: 10px 15px; border-left: 3px solid #1976d2; margin-bottom: 20px; font-family: monospace; }
+                .error-message { background: #ffebee; border: 1px solid #ef5350; border-radius: 4px; padding: 15px; margin-bottom: 20px; color: #c62828; }
+                .stack { background: #f5f5f5; border: 1px solid #ddd; border-radius: 4px; padding: 15px; overflow-x: auto; font-family: monospace; font-size: 12px; color: #333; line-height: 1.5; }
+                .hint { background: #e8f5e9; border-left: 3px solid #4caf50; padding: 15px; margin-top: 20px; color: #2e7d32; }
+              </style>
+            </head>
+            <body>
+              <div class="container">
+                <h1>\u{1F6A8} Inertia Render Error</h1>
+                <div class="meta">Component: <span class="component">${component}</span></div>
+                <div class="error-message">${error.message || "Unknown error"}</div>
+                ${error.stack ? `<div><strong>Stack Trace:</strong><div class="stack">${error.stack.split("\n").map((line) => line.replace(/</g, "&lt;").replace(/>/g, "&gt;")).join("\n")}</div></div>` : ""}
+                <div class="hint">
+                  <strong>\u{1F4A1} Dev Mode Tip:</strong> This enhanced error page is only visible in development mode. In production, a generic error message is shown.
+                </div>
+              </div>
+            </body>
+          </html>
+        `;
+        return this.context.html(errorHtml, 500);
+      }
+      return new Response("Inertia Render Error", { status: 500 });
     }
-    const isDev = process.env.NODE_ENV !== "production";
-    return this.context.html(
-      view.render(
-        rootView,
-        {
-          ...rootVars,
-          page: this.escapeForSingleQuotedHtmlAttribute(JSON.stringify(page)),
-          isDev
-        },
-        { layout: "" }
-      )
-    );
   }
-  // ...
   /**
-   * Share data with all Inertia responses
+   * Registers a piece of data to be shared with all Inertia responses for the current request.
    *
-   * Shared props are merged with component-specific props on every render.
+   * Shared props are automatically merged with component-specific props during the render phase.
+   * This is the primary mechanism for providing global state like authentication details,
+   * flash messages, or configuration to the frontend.
    *
-   * @param key - The prop key
-   * @param value - The prop value
+   * @param key - Identifier for the shared prop.
+   * @param value - Value to share. Must be JSON serializable.
    *
    * @example
    * ```typescript
-   * // In middleware
-   * inertia.share('auth', { user: ctx.get('auth')?.user() })
-   * inertia.share('flash', ctx.get('session')?.getFlash('message'))
+   * inertia.share('appName', 'Gravito Store');
+   * inertia.share('auth', { user: ctx.get('user') });
    * ```
    */
   share(key, value) {
     this.sharedProps[key] = value;
   }
   /**
-   * Share multiple props at once
+   * Shares multiple props in a single operation.
+   *
+   * Merges the provided object into the existing shared props state. Existing keys
+   * with the same name will be overwritten.
    *
-   * @param props - Object of props to share
+   * @param props - Object containing key-value pairs to merge into the shared state.
+   *
+   * @example
+   * ```typescript
+   * inertia.shareAll({
+   *   version: '1.2.0',
+   *   environment: 'production',
+   *   features: ['chat', 'search']
+   * });
+   * ```
    */
   shareAll(props) {
-    Object.assign(this.sharedProps, props);
+    this.sharedProps = { ...this.sharedProps, ...props };
   }
   /**
-   * Get all shared props
+   * Returns a shallow copy of the current shared props.
+   *
+   * Useful for inspecting the shared state or for manual prop merging in advanced scenarios.
+   *
+   * @returns A dictionary containing all currently registered shared props.
    *
-   * @returns A shallow copy of the shared props object.
+   * @example
+   * ```typescript
+   * const shared = inertia.getSharedProps();
+   * if (!shared.auth) {
+   *   console.warn('Authentication data is missing from shared props');
+   * }
+   * ```
    */
   getSharedProps() {
     return { ...this.sharedProps };
   }
+  /**
+   * Instructs the Inertia client to navigate to a different URL.
+   *
+   * For Inertia AJAX requests, this returns a 409 Conflict with the `X-Inertia-Location` header.
+   * For regular page loads, this returns a 302 Found redirect.
+   *
+   * This is useful for server-side redirects triggered by authentication or authorization checks.
+   *
+   * @param url - The URL to redirect to.
+   * @returns A redirect response.
+   *
+   * @example
+   * ```typescript
+   * if (!ctx.get('user')) {
+   *   return inertia.location('/login');
+   * }
+   * ```
+   */
+  location(url) {
+    const isInertiaRequest = Boolean(this.context.req.header("X-Inertia"));
+    if (isInertiaRequest) {
+      this.context.header("X-Inertia-Location", url);
+      return new Response("", { status: 409 });
+    }
+    this.context.header("Location", url);
+    return new Response("", { status: 302 });
+  }
+  /**
+   * Controls whether the Inertia client should encrypt browser history.
+   *
+   * When enabled, history is not written to the browser's History API,
+   * preventing users from using the browser back button to return to previous pages.
+   *
+   * @param encrypt - Whether to encrypt history (defaults to true).
+   * @returns The service instance for method chaining.
+   *
+   * @example
+   * ```typescript
+   * return await inertia.encryptHistory(true).render('SecurePage');
+   * ```
+   */
+  encryptHistory(encrypt = true) {
+    this.encryptHistoryFlag = encrypt;
+    return this;
+  }
+  /**
+   * Clears the browser history after the page load.
+   *
+   * Useful for sensitive operations or multi-step wizards where you don't want
+   * users navigating back to previous states.
+   *
+   * @returns The service instance for method chaining.
+   *
+   * @example
+   * ```typescript
+   * return await inertia.clearHistory().render('SuccessPage');
+   * ```
+   */
+  clearHistory() {
+    this.clearHistoryFlag = true;
+    return this;
+  }
+  /**
+   * Registers form validation errors organized into named bags.
+   *
+   * Error bags allow multiple validation failure scenarios to coexist.
+   * For example, you might have 'default' errors and 'import' errors from different forms.
+   *
+   * @param errors - Validation errors, with field names as keys and error messages as values.
+   * @param bag - The error bag name (defaults to 'default').
+   * @returns The service instance for method chaining.
+   *
+   * @example
+   * ```typescript
+   * inertia.withErrors({
+   *   email: 'Email is required',
+   *   password: 'Must be 8+ characters'
+   * }, 'login');
+   *
+   * inertia.withErrors({
+   *   line_1: 'Invalid CSV format'
+   * }, 'import');
+   * ```
+   */
+  withErrors(errors, bag = "default") {
+    this.errorBags[bag] = errors;
+    return this;
+  }
 };
 
 // src/index.ts
 var OrbitIon = class {
+  /**
+   * Initializes the Orbit with custom configuration.
+   *
+   * @param options - Configuration overrides for the Inertia service.
+   */
   constructor(options = {}) {
     this.options = options;
   }
   /**
-   * Install the inertia orbit into PlanetCore
+   * Registers the Inertia middleware and service factory into PlanetCore.
+   *
+   * This method is called automatically by Gravito during the boot process.
+   * It sets up the `InertiaService` for each request and attaches
+   * the `InertiaHelper` proxy to the context.
+   *
+   * @param core - The Gravito micro-kernel instance.
+   *
+   * @example
+   * ```typescript
+   * const ion = new OrbitIon({ version: '1.0' });
+   * ion.install(core);
+   * ```
    */
   install(core) {
     core.logger.info("\u{1F6F0}\uFE0F Orbit Inertia installed (Callable Interface)");
     const appVersion = this.options.version ?? core.config.get("APP_VERSION", "1.0.0");
     const rootView = this.options.rootView ?? "app";
+    const csrfEnabled = this.options.csrf?.enabled !== false;
+    const csrfCookieName = this.options.csrf?.cookieName ?? "XSRF-TOKEN";
+    const VERSION_CACHE_TTL = 6e4;
+    let cachedVersion;
+    let versionCacheTime = 0;
+    const resolveAppVersion = async () => {
+      if (typeof appVersion !== "function") {
+        return appVersion;
+      }
+      const now = Date.now();
+      if (cachedVersion && now - versionCacheTime < VERSION_CACHE_TTL) {
+        return cachedVersion;
+      }
+      cachedVersion = await appVersion();
+      versionCacheTime = now;
+      return cachedVersion;
+    };
+    if (csrfEnabled) {
+      core.adapter.use("*", async (c, next) => {
+        const token = crypto.randomUUID();
+        const secure = process.env.NODE_ENV === "production";
+        const cookieValue = `${csrfCookieName}=${token}; Path=/; ${secure ? "Secure; " : ""}SameSite=Lax`;
+        c.header("Set-Cookie", cookieValue);
+        return await next();
+      });
+    }
     core.adapter.use("*", async (c, next) => {
       const service = new InertiaService(c, {
-        version: String(appVersion),
-        rootView
+        version: resolveAppVersion,
+        rootView,
+        ssr: this.options.ssr
       });
-      const inertiaProxy = (component, props = {}, rootVars = {}) => {
-        return service.render(component, props, rootVars);
+      const inertiaProxy = async (component, props = {}, rootVars = {}, status) => {
+        return await service.render(component, props, rootVars, status);
       };
       Object.assign(inertiaProxy, {
         share: service.share.bind(service),
         shareAll: service.shareAll.bind(service),
         getSharedProps: service.getSharedProps.bind(service),
         render: service.render.bind(service),
-        // Also allow .render()
+        location: service.location.bind(service),
+        encryptHistory: service.encryptHistory.bind(service),
+        clearHistory: service.clearHistory.bind(service),
+        withErrors: service.withErrors.bind(service),
         service
-        // Access to the raw service instance
       });
       c.set("inertia", inertiaProxy);
       return await next();
@@ -161,7 +672,11 @@ var OrbitIon = class {
 };
 var index_default = OrbitIon;
 export {
+  InertiaConfigError,
+  InertiaDataError,
+  InertiaError,
   InertiaService,
+  InertiaTemplateError,
   OrbitIon,
   index_default as default
 };