@ecopages/core 0.2.0-alpha.2 → 0.2.0-alpha.21

package/src/route-renderer/{page-module-loader.js → page-loading/page-module-loader.js}

@@ -1,22 +1,36 @@
-import { invariant } from "../utils/invariant.js";
-import { PageModuleImportService } from "../services/page-module-import.service.js";
+import { invariant } from "../../utils/invariant.js";
+import { getAppModuleLoader } from "../../services/module-loading/app-server-module-transpiler.service.js";
+import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
 class PageModuleLoaderService {
+  appModuleLoader;
+  appConfig;
+  runtimeOrigin;
+  /**
+   * Creates the page-module loader for one app/runtime instance.
+   *
+   * @param appConfig Finalized app config that owns build and invalidation state.
+   * @param runtimeOrigin Runtime origin exposed to page data hooks.
+   */
   constructor(appConfig, runtimeOrigin) {
     this.appConfig = appConfig;
     this.runtimeOrigin = runtimeOrigin;
-    this.pageModuleImportService = new PageModuleImportService();
+    this.appModuleLoader = getAppModuleLoader(appConfig);
   }
-  pageModuleImportService;
   /**
-   * Imports a page module from source.
-   * Uses direct dynamic import in Bun and transpile+import fallback for other runtimes.
+   * Imports one page module through the shared server-side module loading path.
+   *
+   * @remarks
+   * The underlying transpiler keeps Bun and Node aligned on one framework-owned
+   * loading contract even though the runtime-specific execution transport differs.
    */
-  async importPageFile(file) {
+  async importPageFile(file, options) {
     try {
-      return await this.pageModuleImportService.importModule({
+      return await this.appModuleLoader.importModule({
         filePath: file,
         rootDir: this.appConfig.rootDir,
-        outdir: `${this.appConfig.absolutePaths.distDir}/.server-modules`,
+        outdir: `${resolveInternalExecutionDir(this.appConfig)}/.server-modules`,
+        bypassCache: options?.bypassCache,
+        cacheScope: options?.cacheScope,
         transpileErrorMessage: (details) => `Error transpiling page file: ${details}`,
         noOutputMessage: (targetFilePath) => `No transpiled output generated for page: ${targetFilePath}`
       });
@@ -25,8 +39,11 @@ class PageModuleLoaderService {
     }
   }
   /**
-   * Executes `getStaticProps` with Ecopages runtime context.
-   * Returns an empty props object when no static props function is defined.
+   * Executes the page's static-props hook with Ecopages runtime context.
+   *
+   * @remarks
+   * Pages without a static-props hook still return a normalized empty props
+   * object so downstream render preparation does not branch on hook presence.
    */
   async getStaticPropsForPage(options) {
     const { getStaticProps, params } = options;
@@ -42,8 +59,11 @@ class PageModuleLoaderService {
     };
   }
   /**
-   * Builds final page metadata using app-level defaults as a baseline.
-   * If `getMetadata` exists, its result overlays defaults so page-level fields take precedence.
+   * Builds the final page metadata object for one render request.
+   *
+   * @remarks
+   * App-level default metadata forms the baseline, then page-level metadata is
+   * overlaid so route-specific fields win without dropping global defaults.
    */
   async getMetadataPropsForPage(options) {
     const { getMetadata, context } = options;
@@ -79,7 +99,12 @@ class PageModuleLoaderService {
     };
   }
   /**
-   * Resolves render-time page data in order: static props first, then metadata derived from those props.
+   * Resolves the page data needed by the render pipeline.
+   *
+   * @remarks
+   * Static props are resolved first because page metadata may depend on those
+   * props. This preserves the same ordering whether data hooks are declared as
+   * component statics or module exports.
    */
   async resolvePageData(options) {
     const { props } = await this.getStaticPropsForPage({

package/src/route-renderer/route-renderer.d.ts

@@ -1,26 +1,67 @@
-import type { EcoPagesAppConfig } from '../internal-types.js';
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
 import type { IntegrationPlugin } from '../plugins/integration-plugin.js';
-import type { RouteRenderResult, RouteRendererOptions } from '../public-types.js';
-import type { IntegrationRenderer } from './integration-renderer.js';
+import type { EcoPageFile, RouteRenderResult, RouteRendererOptions } from '../types/public-types.js';
+import type { IntegrationRenderer, RouteModuleLoadOptions } from './orchestration/integration-renderer.js';
+/**
+ * Thin wrapper around one initialized integration renderer.
+ *
+ * @remarks
+ * This type exists so higher-level routing code can ask for a route renderer
+ * without depending on the full integration plugin lifecycle. It delegates all
+ * real work to the integration-specific renderer selected by the factory.
+ */
 export declare class RouteRenderer {
     private renderer;
+    /**
+     * Creates a route renderer bound to one integration renderer instance.
+     */
     constructor(renderer: IntegrationRenderer);
+    /**
+     * Executes the render pipeline for one matched route.
+     */
     createRoute(options: RouteRendererOptions): Promise<RouteRenderResult>;
+    /**
+     * Loads the route module through the owning integration renderer.
+     */
+    loadPageModule(filePath: string, options?: RouteModuleLoadOptions): Promise<EcoPageFile>;
 }
+/**
+ * Selects and caches integration renderers for route files and explicit views.
+ *
+ * @remarks
+ * The factory owns the policy that maps a route file or explicit integration
+ * name to one initialized integration renderer. Renderer instances are cached by
+ * integration name so repeated requests do not rebuild renderer state.
+ */
 export declare class RouteRendererFactory {
     private appConfig;
     runtimeOrigin: string;
+    private rendererModules?;
     private rendererCache;
-    constructor({ appConfig, runtimeOrigin }: {
+    /**
+     * Creates the route-renderer factory for one app/runtime instance.
+     */
+    constructor({ appConfig, rendererModules, runtimeOrigin, }: {
         appConfig: EcoPagesAppConfig;
+        rendererModules?: unknown;
         runtimeOrigin: string;
     });
+    /**
+     * Returns a route renderer for the supplied route file.
+     */
     createRenderer(filePath: string): RouteRenderer;
     /**
      * Get an integration renderer by its name.
      * Used for explicit routing where views specify their integration via __eco.integration.
      */
     getRendererByIntegration(integrationName: string): IntegrationRenderer | null;
+    /**
+     * Resolves the integration plugin that owns a given route file.
+     */
     getIntegrationPlugin(filePath: string): IntegrationPlugin;
+    /**
+     * Returns the cached renderer engine for the file's owning integration,
+     * creating it on first use.
+     */
     private getRouteRendererEngine;
 }

package/src/route-renderer/route-renderer.js

@@ -2,21 +2,45 @@ import { invariant } from "../utils/invariant.js";
 import { PathUtils } from "../utils/path-utils.module.js";
 class RouteRenderer {
   renderer;
+  /**
+   * Creates a route renderer bound to one integration renderer instance.
+   */
   constructor(renderer) {
     this.renderer = renderer;
   }
+  /**
+   * Executes the render pipeline for one matched route.
+   */
   async createRoute(options) {
     return this.renderer.execute(options);
   }
+  /**
+   * Loads the route module through the owning integration renderer.
+   */
+  async loadPageModule(filePath, options) {
+    return this.renderer.loadPageModule(filePath, options);
+  }
 }
 class RouteRendererFactory {
   appConfig;
   runtimeOrigin;
+  rendererModules;
   rendererCache = /* @__PURE__ */ new Map();
-  constructor({ appConfig, runtimeOrigin }) {
+  /**
+   * Creates the route-renderer factory for one app/runtime instance.
+   */
+  constructor({
+    appConfig,
+    rendererModules,
+    runtimeOrigin
+  }) {
     this.appConfig = appConfig;
+    this.rendererModules = rendererModules;
     this.runtimeOrigin = runtimeOrigin;
   }
+  /**
+   * Returns a route renderer for the supplied route file.
+   */
   createRenderer(filePath) {
     const integrationRenderer = this.getRouteRendererEngine(filePath);
     invariant(!!integrationRenderer, `No integration renderer found for file: ${filePath}`);
@@ -35,10 +59,15 @@ class RouteRendererFactory {
     if (cached) {
       return cached;
     }
-    const renderer = integrationPlugin.initializeRenderer();
+    const renderer = integrationPlugin.initializeRenderer({
+      rendererModules: this.rendererModules
+    });
     this.rendererCache.set(integrationName, renderer);
     return renderer;
   }
+  /**
+   * Resolves the integration plugin that owns a given route file.
+   */
   getIntegrationPlugin(filePath) {
     const templateExtension = PathUtils.getEcoTemplateExtension(filePath);
     const isIntegrationPlugin = (plugin) => {
@@ -51,13 +80,19 @@ class RouteRendererFactory {
     );
     return integrationPlugin;
   }
+  /**
+   * Returns the cached renderer engine for the file's owning integration,
+   * creating it on first use.
+   */
   getRouteRendererEngine(filePath) {
     const integrationPlugin = this.getIntegrationPlugin(filePath);
     const cached = this.rendererCache.get(integrationPlugin.name);
     if (cached) {
       return cached;
     }
-    const renderer = integrationPlugin.initializeRenderer();
+    const renderer = integrationPlugin.initializeRenderer({
+      rendererModules: this.rendererModules
+    });
     this.rendererCache.set(integrationPlugin.name, renderer);
     return renderer;
   }

package/src/router/README.md

@@ -0,0 +1,97 @@
+# Router Layer
+
+This directory contains route discovery, matching, and browser-side navigation infrastructure.
+
+## Purpose
+
+The router layer determines what route is being handled and how the client runtime coordinates navigation.
+
+It is responsible for:
+
+- filesystem route scanning and classification (`exact`, `dynamic`, `catch-all`)
+- matching incoming request URLs to discovered routes
+- server-side static-path expansion for dynamic routes
+- client-side navigation ownership and cross-runtime handoff
+- keeping route discovery separate from rendering execution
+
+## Directory Structure
+
+```
+router/
+├── server/                      # Server-side route scanning and matching
+│   ├── fs-router-scanner.ts     # Scans the filesystem and classifies routes
+│   └── fs-router.ts             # Matches request URLs to discovered routes
+└── client/                      # Browser-side navigation coordination
+    ├── navigation-coordinator.ts # Singleton runtime coordinator
+    └── link-intent.ts           # Shared anchor detection and intent recovery helpers
+```
+
+## `server/`
+
+### `FSRouterScanner`
+
+Walks the pages directory and builds a `Routes` map keyed by route pathname.
+
+File patterns determine route kind:
+
+| Pattern         | Kind        | Example           |
+| --------------- | ----------- | ----------------- |
+| `page.tsx`      | `exact`     | `/about`          |
+| `[slug].tsx`    | `dynamic`   | `/blog/[slug]`    |
+| `[...slug].tsx` | `catch-all` | `/docs/[...slug]` |
+
+For `dynamic` routes, the scanner checks whether the page module exports `getStaticPaths`. If present, every returned path is expanded into a concrete `exact`-style route at scan time. In build mode, both `getStaticPaths` and `getStaticProps` are required or an invariant is thrown.
+
+Catch-all routes are registered but skipped during static generation with a warning.
+
+### `FSRouter`
+
+Holds the scanned `Routes` map and exposes a `match(requestUrl)` method used by adapters.
+
+Match priority:
+
+1. `exact` — the pathname must equal the route pathname exactly.
+2. `dynamic` — the clean (bracket-stripped) prefix must appear in the pathname, and the segment counts must match.
+3. `catch-all` — the clean prefix must appear in the pathname.
+
+Additional helpers:
+
+- `getDynamicParams(route, pathname)` — extracts named and spread parameters from a matched dynamic or catch-all route.
+- `getSearchParams(url)` — converts `URLSearchParams` to a plain object.
+- `setOnReload(cb)` / `reload()` — re-scans routes and fires an optional callback, used during development HMR.
+
+## `client/`
+
+### Navigation Coordinator (`navigation-coordinator.ts`)
+
+A singleton browser-side runtime stored on `window.__ECO_PAGES__.navigation`.
+
+Access it with:
+
+```ts
+import { getEcoNavigationRuntime } from '@ecopages/core/router/client/navigation-coordinator';
+const runtime = getEcoNavigationRuntime();
+```
+
+The coordinator is framework-agnostic. Browser runtimes (e.g. `browser-router`, `react-router`) register themselves and the coordinator arbitrates:
+
+- **Ownership** — which runtime currently drives SPA navigation (`claimOwnership`, `releaseOwnership`, `setOwner`).
+- **Document owner marker** — an HTML attribute (`data-eco-document-owner`) written into rendered markup so the coordinator can `adoptDocumentOwner` on the incoming page.
+- **Navigation transactions** — each navigation begins a transaction with an `AbortSignal`; superseded navigations are automatically cancelled.
+- **Cross-runtime handoff** — `requestHandoff` passes a pre-fetched `Document` to the target runtime without tearing down the current page prematurely.
+- **Reload** — `reloadCurrentPage` delegates to whichever runtime currently owns the document.
+- **Events** — `subscribe` lets runtimes react to `owner-change` and `registration-change` events.
+
+### Link Intent (`link-intent.ts`)
+
+Shared helpers for locating anchors and recovering stale navigation intent.
+
+- `getAnchorFromNavigationEvent(event, linkSelector)` — finds the nearest matching anchor in the event's composed path, including across Shadow DOM boundaries.
+- `recoverPendingNavigationHref(intent, hasInFlightNavigation, now, maxAgeMs?)` — resolves a previously captured pointer or hover target when the DOM changes before the click lands. Intents expire after `maxAgeMs` (default 1000 ms).
+
+## Relationship To Rendering
+
+The router layer answers **which route should run**.
+The route-renderer layer answers **how that route gets rendered**.
+
+Keeping those seams separate avoids mixing route ownership, module loading, and component orchestration into one service.

package/src/router/client/link-intent.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared client-side navigation intent helpers.
+ *
+ * Browser runtimes use the same low-level mechanics to:
+ * - locate the anchor associated with a click, pointer, or hover event,
+ * - persist the last valid pointer or hover target while a navigation is in flight,
+ * - recover the final intended href when the DOM changes before the click lands.
+ *
+ * Keeping those mechanics here lets browser-router and react-router share one
+ * implementation while preserving their router-specific interception rules.
+ *
+ * @module
+ */
+/**
+ * Timestamped navigation intent captured from pointer or hover activity.
+ */
+export type EcoPendingNavigationIntent = {
+	href: string;
+	timestamp: number;
+};
+/**
+ * Finds the nearest matching anchor within an event's composed path.
+ *
+ * This works across Shadow DOM boundaries, which is required for delegated
+ * navigation handling when links are rendered inside custom elements.
+ *
+ * @param event - Pointer or mouse event being inspected.
+ * @param linkSelector - Selector that identifies navigable anchors.
+ * @returns The matched anchor element, or `null` when no matching anchor exists.
+ */
+export declare function getAnchorFromNavigationEvent(
+	event: MouseEvent | PointerEvent,
+	linkSelector: string,
+): HTMLAnchorElement | null;
+/**
+ * Resolves a previously captured intent while a navigation is still in flight.
+ *
+ * Pending intents expire quickly because they are only meant to bridge the gap
+ * between pointer or hover capture and the later click event when the DOM or
+ * active runtime changes during a rapid navigation sequence.
+ *
+ * @param intent - Previously captured pointer or hover intent.
+ * @param hasInFlightNavigation - Whether a router navigation is still active.
+ * @param now - Current monotonic timestamp, usually from `performance.now()`.
+ * @param maxAgeMs - Maximum allowed age for the recovered intent.
+ * @returns The intended href when still valid, otherwise `null`.
+ */
+export declare function recoverPendingNavigationHref(
+	intent: EcoPendingNavigationIntent | null,
+	hasInFlightNavigation: boolean,
+	now: number,
+	maxAgeMs?: number,
+): string | null;

package/src/router/client/link-intent.js

@@ -0,0 +1,34 @@
+function getAnchorFromNavigationEvent(event, linkSelector) {
+  const eventTarget = event.target;
+  if (eventTarget instanceof HTMLAnchorElement && eventTarget.matches(linkSelector)) {
+    return eventTarget;
+  }
+  if (eventTarget instanceof Element) {
+    const closestAnchor = eventTarget.closest(linkSelector);
+    if (closestAnchor instanceof HTMLAnchorElement) {
+      return closestAnchor;
+    }
+  }
+  if (eventTarget instanceof Text) {
+    const parentAnchor = eventTarget.parentElement?.closest(linkSelector);
+    if (parentAnchor instanceof HTMLAnchorElement) {
+      return parentAnchor;
+    }
+  }
+  return event.composedPath().find(
+    (target) => target instanceof HTMLAnchorElement && target.matches(linkSelector)
+  );
+}
+function recoverPendingNavigationHref(intent, hasInFlightNavigation, now, maxAgeMs = 1e3) {
+  if (!intent || !hasInFlightNavigation) {
+    return null;
+  }
+  if (now - intent.timestamp > maxAgeMs) {
+    return null;
+  }
+  return intent.href;
+}
+export {
+  getAnchorFromNavigationEvent,
+  recoverPendingNavigationHref
+};

package/src/router/client/link-intent.test.browser.d.ts

@@ -0,0 +1 @@
+export {};

package/src/router/client/link-intent.test.browser.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { getAnchorFromNavigationEvent, recoverPendingNavigationHref } from "./link-intent.js";
+describe("getAnchorFromNavigationEvent", () => {
+  it("returns the anchor when the event target is a text node inside it", () => {
+    const anchor = document.createElement("a");
+    anchor.href = "/fast";
+    anchor.setAttribute("data-eco-link", "true");
+    const textNode = document.createTextNode("fast-link");
+    anchor.append(textNode);
+    document.body.append(anchor);
+    const event = new MouseEvent("click", { bubbles: true, cancelable: true, composed: true });
+    Object.defineProperty(event, "target", {
+      configurable: true,
+      value: textNode
+    });
+    expect(getAnchorFromNavigationEvent(event, "a[data-eco-link]")).toBe(anchor);
+  });
+  it("returns the closest matching anchor for nested element targets", () => {
+    const anchor = document.createElement("a");
+    anchor.href = "/fast";
+    anchor.setAttribute("data-eco-link", "true");
+    const span = document.createElement("span");
+    span.textContent = "fast-link";
+    anchor.append(span);
+    document.body.append(anchor);
+    const event = new MouseEvent("click", { bubbles: true, cancelable: true, composed: true });
+    Object.defineProperty(event, "target", {
+      configurable: true,
+      value: span
+    });
+    expect(getAnchorFromNavigationEvent(event, "a[data-eco-link]")).toBe(anchor);
+  });
+});
+describe("recoverPendingNavigationHref", () => {
+  it("returns null for stale or missing pending intent state", () => {
+    expect(recoverPendingNavigationHref(null, true, 10)).toBeNull();
+    expect(recoverPendingNavigationHref({ href: "/fast", timestamp: 0 }, false, 10)).toBeNull();
+    expect(recoverPendingNavigationHref({ href: "/fast", timestamp: 0 }, true, 2e3, 1e3)).toBeNull();
+  });
+  it("returns the captured href while a navigation is still in flight", () => {
+    expect(recoverPendingNavigationHref({ href: "/fast", timestamp: 10 }, true, 20, 1e3)).toBe("/fast");
+  });
+});

package/src/router/client/navigation-coordinator.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Shared browser-side navigation coordinator.
+ *
+ * This module is the client runtime contract used by browser-router,
+ * react-router, and HMR code to coordinate ownership, cross-runtime handoff,
+ * current-page reloads, and stale-navigation cancellation.
+ *
+ * The coordinator stays framework-agnostic: browser runtimes register their
+ * capabilities here, and the coordinator arbitrates which runtime currently
+ * owns the document and which navigation transaction is still current.
+ *
+ * @module
+ */
+/** Logical owner name for a browser navigation runtime. */
+export type EcoNavigationOwner = 'none' | 'browser-router' | 'react-router' | (string & {});
+/** HTML attribute used to persist the rendered document owner across navigations. */
+export declare const ECO_DOCUMENT_OWNER_ATTRIBUTE = "data-eco-document-owner";
+/** High-level navigation direction understood by browser runtimes. */
+export type EcoNavigationDirection = 'forward' | 'back' | 'replace';
+/** Navigation request sent between browser runtimes. */
+export type EcoNavigationRequest = {
+    href: string;
+    direction?: EcoNavigationDirection;
+    source?: EcoNavigationOwner;
+};
+/** Navigation handoff request that includes a pre-fetched document. */
+export type EcoNavigationHandoffRequest = EcoNavigationRequest & {
+    finalHref?: string;
+    targetOwner: EcoNavigationOwner;
+    document: Document;
+    html?: string;
+    /**
+     * Reports whether the source runtime's original navigation has already been
+     * superseded.
+     *
+     * Target runtimes use this to ignore handoff work that arrives after a newer
+     * navigation has already claimed ownership.
+     */
+    isStaleSourceNavigation?: () => boolean;
+};
+/** Request to reload the current page through the active runtime. */
+export type EcoReloadRequest = {
+    clearCache?: boolean;
+    source?: EcoNavigationOwner;
+};
+/** Snapshot of the coordinator's current runtime ownership state. */
+export type EcoNavigationOwnerState = {
+    owner: EcoNavigationOwner;
+    canHandleSpaNavigation: boolean;
+};
+/**
+ * Coordinator-managed navigation transaction.
+ *
+ * Runtimes use this to determine whether async work has become stale and to
+ * cancel or complete the active navigation sequence.
+ */
+export type EcoNavigationTransaction = {
+    id: number;
+    signal: AbortSignal;
+    isCurrent: () => boolean;
+    cancel: () => void;
+    complete: () => void;
+};
+export type EcoNavigationRuntimeEvent = {
+    type: 'owner-change';
+    owner: EcoNavigationOwner;
+    previousOwner: EcoNavigationOwner;
+    reason: 'set' | 'claim' | 'release' | 'document' | 'unregister';
+} | {
+    type: 'registration-change';
+    owner: EcoNavigationOwner;
+    status: 'registered' | 'unregistered';
+};
+export type EcoNavigationRuntimeListener = (event: EcoNavigationRuntimeEvent) => void;
+export type EcoNavigationRuntimeRegistration = {
+    owner: EcoNavigationOwner;
+    navigate?: (request: EcoNavigationRequest) => Promise<boolean | void>;
+    handoffNavigation?: (request: EcoNavigationHandoffRequest) => Promise<boolean | void>;
+    reloadCurrentPage?: (request?: EcoReloadRequest) => Promise<void>;
+    /**
+     * Releases runtime-owned client state before another runtime commits a new
+     * document.
+     *
+     * This hook intentionally does not run as part of `requestHandoff()`. The
+     * accepting runtime decides when cleanup is safe so cross-runtime handoffs do
+     * not blank the current page before the incoming document is ready.
+     */
+    cleanupBeforeHandoff?: () => void | Promise<void>;
+};
+/** Public browser-side navigation coordinator interface. */
+export interface EcoNavigationRuntime {
+    /** Returns the currently active runtime owner and whether it can handle SPA navigation. */
+    getOwnerState(): EcoNavigationOwnerState;
+    /** Starts a new navigation transaction, invalidating the previously active one. */
+    beginNavigationTransaction(): EcoNavigationTransaction;
+    /** Reports whether a navigation transaction is still in flight. */
+    hasPendingNavigationTransaction(): boolean;
+    /** Cancels the active navigation transaction, if one exists. */
+    cancelCurrentNavigationTransaction(): void;
+    /** Forces the current owner value without checking registrations. */
+    setOwner(owner: EcoNavigationOwner): void;
+    /** Claims ownership for a runtime that is ready to drive SPA navigation. */
+    claimOwnership(owner: EcoNavigationOwner): void;
+    /** Releases ownership when the given runtime no longer controls the document. */
+    releaseOwnership(owner: EcoNavigationOwner): void;
+    /** Resolves document ownership from the rendered owner marker or fallback. */
+    resolveDocumentOwner(doc: Document, fallbackOwner?: EcoNavigationOwner): EcoNavigationOwner;
+    /** Reads and adopts the rendered document owner as the active runtime owner. */
+    adoptDocumentOwner(doc: Document, fallbackOwner?: EcoNavigationOwner): EcoNavigationOwner;
+    /** Returns whether the active owner is some runtime other than the given owner. */
+    isOwnedByAnotherRuntime(owner: EcoNavigationOwner): boolean;
+    /** Subscribes to ownership and registration change events. */
+    subscribe(listener: EcoNavigationRuntimeListener): () => void;
+    /** Registers a runtime implementation with the coordinator. */
+    register(runtime: EcoNavigationRuntimeRegistration): () => void;
+    /** Requests navigation through another eligible registered runtime. */
+    requestNavigation(request: EcoNavigationRequest): Promise<boolean>;
+    /**
+     * Hands a pre-fetched document to the target runtime.
+     *
+     * The coordinator delegates the document but does not clean up the current
+     * owner first. Cleanup timing belongs to the accepting runtime so a stale or
+     * superseded handoff cannot tear down the current page prematurely.
+     */
+    requestHandoff(request: EcoNavigationHandoffRequest): Promise<boolean>;
+    /** Requests the active runtime to reload the current page. */
+    reloadCurrentPage(request?: EcoReloadRequest): Promise<boolean>;
+    /** Runs a target runtime's cleanup hook before handoff. */
+    cleanupOwner(owner: EcoNavigationOwner): Promise<void>;
+    /** Runs cleanup for whichever runtime currently owns the document. */
+    cleanupCurrentOwner(): Promise<void>;
+}
+/**
+ * Reads the explicit browser document owner marker from a rendered HTML document.
+ *
+ * Documents without a marker return `null`, allowing runtimes to fall back to
+ * their local default behavior without scanning hydration scripts.
+ */
+export declare function getEcoDocumentOwner(doc: Document): EcoNavigationOwner | null;
+/**
+ * Returns the singleton browser-side navigation coordinator.
+ *
+ * The coordinator centralizes ownership, handoff, and current-page reload
+ * requests across browser runtimes through one internal protocol.
+ *
+ * @param windowObject - Window-like object that stores the singleton runtime.
+ * @returns The shared browser navigation coordinator.
+ */
+export declare function getEcoNavigationRuntime(windowObject?: Window & typeof globalThis): EcoNavigationRuntime;