@ecopages/core 0.2.0-alpha.9 → 0.2.1

package/src/route-renderer/orchestration/render-output.utils.js

@@ -0,0 +1,65 @@
+import { buildInjectorMapScript } from "../../eco/lazy-injector-map.js";
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function addTriggerAttribute(content, triggerId) {
+  const str = String(content);
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] !== "<") {
+      i++;
+      continue;
+    }
+    const next = str[i + 1];
+    if (next === "!" || next === "?") {
+      const end = str.indexOf(">", i);
+      if (end === -1) break;
+      i = end + 1;
+      continue;
+    }
+    if (next && /[a-zA-Z]/.test(next)) {
+      const tagSlice = str.slice(i + 1);
+      const nameEnd = tagSlice.search(/[\s/>]/);
+      if (nameEnd === -1) break;
+      const insertAt = i + 1 + nameEnd;
+      return `${str.slice(0, insertAt)} data-eco-trigger="${triggerId}"${str.slice(insertAt)}`;
+    }
+    break;
+  }
+  return str;
+}
+function wrapWithScriptsInjector(content, lazyGroups) {
+  const wrappedContent = String(content);
+  const injectorMapScript = buildInjectorMapScript(lazyGroups ?? []);
+  return `<scripts-injector><script type="ecopages/injector-map">${injectorMapScript}<\/script>${wrappedContent}<\/scripts-injector>`;
+}
+function decodeHtmlEntities(value) {
+  let decoded = value;
+  let previous;
+  do {
+    previous = decoded;
+    decoded = decoded.replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&#x27;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+  } while (decoded !== previous);
+  return decoded;
+}
+function normalizeBoundaryArtifactHtml(html) {
+  return html.replace(
+    /&(?:amp;)?lt;eco-marker\b[\s\S]*?&(?:amp;)?gt;&(?:amp;)?lt;\/eco-marker&(?:amp;)?gt;/g,
+    (marker) => decodeHtmlEntities(marker)
+  );
+}
+function inspectBoundaryArtifactHtml(html) {
+  const normalizedHtml = normalizeBoundaryArtifactHtml(html);
+  return {
+    normalizedHtml,
+    hasUnresolvedBoundaryArtifacts: normalizedHtml.includes("<eco-marker")
+  };
+}
+export {
+  addTriggerAttribute,
+  decodeHtmlEntities,
+  inspectBoundaryArtifactHtml,
+  isThenable,
+  normalizeBoundaryArtifactHtml,
+  wrapWithScriptsInjector
+};

package/src/route-renderer/orchestration/render-preparation.service.d.ts

@@ -1,7 +1,6 @@
-import type { EcoPagesAppConfig } from '../../internal-types.js';
-import type { ComponentRenderResult, EcoComponent, EcoPageComponent, EcoPageFile, EcoPagesElement, GetMetadata, GetStaticProps, HtmlTemplateProps, IntegrationRendererRenderOptions, PageMetadataProps, RouteRendererOptions } from '../../public-types.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { ComponentRenderResult, EcoComponent, EcoPageComponent, EcoPageFile, EcoPagesElement, GetMetadata, GetStaticProps, HtmlTemplateProps, IntegrationRendererRenderOptions, PageMetadataProps, RouteRendererOptions } from '../../types/public-types.js';
 import { type AssetProcessingService, type ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
-import { type ComponentRenderBoundaryContext } from '../../eco/component-render-context.js';
 type ResolvedPageModule = {
     Page: EcoPageFile['default'] | EcoPageComponent<any>;
     getStaticProps?: GetStaticProps<Record<string, unknown>>;
@@ -29,11 +28,6 @@ export interface RenderPreparationCallbacks {
         component: EcoComponent;
         props: Record<string, unknown>;
     }): Promise<ComponentRenderResult>;
-    /**
-     * Returns the boundary policy context that should be active while rendering
-     * page-root component output during preparation.
-     */
-    getComponentRenderBoundaryContext(): ComponentRenderBoundaryContext;
     setProcessedDependencies(dependencies: ProcessedAsset[]): void;
     dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];
     createPageLocalsProxy(filePath: string): RouteRendererOptions['locals'];

package/src/route-renderer/orchestration/render-preparation.service.js

@@ -1,12 +1,10 @@
 import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import {
   AssetFactory
 } from "../../services/assets/asset-processing-service/index.js";
 import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../eco/global-injector-map.js";
-import {
-  runWithComponentRenderContext
-} from "../../eco/component-render-context.js";
-const coreRequire = createRequire(import.meta.url);
 class RenderPreparationService {
   appConfig;
   assetProcessingService;
@@ -51,13 +49,13 @@ class RenderPreparationService {
     const allDependencies = [...resolvedDependencies, ...usedIntegrationDependencies, ...pageDeps];
     let componentRender;
     if (callbacks.shouldRenderPageComponent({ Page, Layout, options: routeOptions })) {
-      componentRender = await this.renderPageRoot({
-        currentIntegrationName,
+      const pageRootRender = await this.renderPageRoot({
         Page,
         props,
         routeOptions,
         callbacks
       });
+      componentRender = pageRootRender.componentRender;
       if (componentRender.assets?.length) {
         allDependencies.push(...componentRender.assets);
       }
@@ -195,12 +193,8 @@ class RenderPreparationService {
    * @returns Structured component render result.
    */
   async renderPageRoot(input) {
-    const execution = await runWithComponentRenderContext(
-      {
-        currentIntegration: input.currentIntegrationName,
-        boundaryContext: input.callbacks.getComponentRenderBoundaryContext()
-      },
-      async () => input.callbacks.renderPageComponent({
+    return {
+      componentRender: await input.callbacks.renderPageComponent({
         component: input.Page,
         props: {
           ...input.props,
@@ -208,8 +202,7 @@ class RenderPreparationService {
           query: input.routeOptions.query || {}
         }
       })
-    );
-    return execution.value;
+    };
   }
   /**
    * Builds the runtime assets needed to bootstrap global lazy trigger execution.
@@ -218,7 +211,7 @@ class RenderPreparationService {
    * @returns Processed assets that should be merged into the final dependency set.
    */
   async buildGlobalInjectorAssets(triggers, currentIntegrationName) {
-    const globalInjectorImportPath = coreRequire.resolve("@ecopages/scripts-injector/global");
+    const globalInjectorImportPath = createRequire(import.meta.url).resolve("@ecopages/scripts-injector/global");
     const globalInjectorRuntimeAsset = AssetFactory.createNodeModuleScript({
       position: "head",
       name: "ecopages-scripts-injector-global",
@@ -275,7 +268,7 @@ class RenderPreparationService {
       visitedConfigs.add(config);
       const componentFile = config.__eco?.file;
       if (componentFile) {
-        const componentDir = coreRequire("node:path").dirname(componentFile);
+        const componentDir = path.dirname(componentFile);
         for (const script of config.dependencies?.scripts ?? []) {
           if (typeof script === "string" || !script.lazy || script.ssr !== true) {
             continue;
@@ -299,7 +292,7 @@ class RenderPreparationService {
           if (!script.src) {
             continue;
           }
-          const resolvedPath = coreRequire("node:path").resolve(componentDir, script.src);
+          const resolvedPath = path.resolve(componentDir, script.src);
           const key = `file:${resolvedPath}:${JSON.stringify(attributes)}`;
           if (seenKeys.has(key)) {
             continue;

package/src/route-renderer/orchestration/template-serialization.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Minimal template-result shape that core can serialize generically.
+ *
+ * @remarks
+ * Core intentionally models only the transport shape used during deferred
+ * cross-integration child passing: alternating static string segments plus
+ * interpolated runtime values. Concrete runtime markers that identify a given
+ * framework's template payload must stay outside core and be registered by the
+ * owning integration package.
+ */
+export type SerializableTemplateShape = {
+    strings: readonly string[];
+    values?: readonly unknown[];
+};
+/**
+ * Integration-owned adapter that teaches core how to serialize one deferred
+ * template payload shape.
+ *
+ * @remarks
+ * The separation here is intentional: core owns the HTML serialization logic,
+ * but integrations own runtime-shape detection. That keeps package-specific
+ * markers such as framework template sentinels out of core while still letting
+ * deferred children round-trip through mixed renderer boundaries.
+ */
+export type DeferredTemplateSerializer<TTemplate extends SerializableTemplateShape = SerializableTemplateShape> = {
+    matches(value: unknown): value is TTemplate;
+    serialize(template: TTemplate, serializeValue: (value: unknown) => string | undefined): string;
+};
+/**
+ * Serializes a generic template shape into HTML.
+ *
+ * @remarks
+ * This handles only HTML reconstruction semantics: quoted attribute values,
+ * boolean attributes, and omission of client-only event or property bindings.
+ * It does not decide whether an arbitrary value belongs to a framework-specific
+ * template runtime; integrations must make that decision before delegating here.
+ */
+export declare function serializeTemplateShape(template: SerializableTemplateShape, serializeValue: (value: unknown) => string | undefined): string;

package/src/route-renderer/orchestration/template-serialization.js

@@ -0,0 +1,45 @@
+import { escapeHtmlAttribute } from "../../utils/html-escaping.js";
+const ATTRIBUTE_TAIL_PATTERN = /(\s+)([@.?!]?)([^\s"'<>/=`@.?!]+)=$/;
+function getSerializableTemplateAttribute(stringPart) {
+  const match = ATTRIBUTE_TAIL_PATTERN.exec(stringPart);
+  if (!match) return void 0;
+  return {
+    leading: stringPart.slice(0, match.index),
+    whitespace: match[1],
+    prefix: match[2],
+    name: match[3]
+  };
+}
+function serializeTemplateShape(template, serializeValue) {
+  const values = template.values ?? [];
+  let html = "";
+  for (let index = 0; index < values.length; index += 1) {
+    const stringPart = template.strings[index] ?? "";
+    const serializedValue = serializeValue(values[index]);
+    const attribute = getSerializableTemplateAttribute(stringPart);
+    if (!attribute) {
+      html += stringPart;
+      html += serializedValue ?? "";
+      continue;
+    }
+    html += attribute.leading;
+    if (attribute.prefix === "@" || attribute.prefix === "!" || attribute.prefix === ".") {
+      continue;
+    }
+    if (attribute.prefix === "?") {
+      if (serializedValue) {
+        html += `${attribute.whitespace}${attribute.name}`;
+      }
+      continue;
+    }
+    if (serializedValue === void 0) {
+      continue;
+    }
+    html += `${attribute.whitespace}${attribute.name}="${escapeHtmlAttribute(serializedValue)}"`;
+  }
+  html += template.strings[values.length] ?? "";
+  return html;
+}
+export {
+  serializeTemplateShape
+};

package/src/route-renderer/page-loading/dependency-resolver.d.ts

@@ -1,5 +1,5 @@
-import type { EcoComponent } from '../../public-types.js';
-import type { EcoPagesAppConfig } from '../../internal-types.js';
+import type { EcoComponent } from '../../types/public-types.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
 import type { AssetProcessingService, ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
 export declare const DEPENDENCY_ERRORS: {
     readonly INVALID_STYLESHEET_ENTRY: "Invalid stylesheet dependency entry: expected src or content";

package/src/route-renderer/page-loading/dependency-resolver.js

@@ -34,7 +34,12 @@ function extractEcopagesVirtualImports(file) {
     const namedImports = [];
     for (const spec of node.specifiers ?? []) {
       if (spec.type === "ImportSpecifier") {
-        const importedName = spec.imported?.type === "Identifier" ? spec.imported.name : spec.imported?.type === "Literal" ? spec.imported.value : spec.local?.name;
+        let importedName = spec.local?.name;
+        if (spec.imported?.type === "Identifier") {
+          importedName = spec.imported.name;
+        } else if (spec.imported?.type === "Literal") {
+          importedName = spec.imported.value;
+        }
         namedImports.push(importedName);
       }
     }
@@ -62,7 +67,7 @@ function createModuleScriptName(from, imports) {
   return `module-${hash}`;
 }
 function createNamedImportModuleSource(from, imports) {
-  const namedImports = imports.join(", ");
+  const namedImports = [...new Set(imports)].sort().join(", ");
   return `export { ${namedImports} } from '${from}';`;
 }
 function createNamespaceImportModuleSource(from) {
@@ -259,14 +264,11 @@ class DependencyResolverService {
               }
               scriptDependencyKeys.add(depKey2);
               dependencies.push(
-                AssetFactory.createContentScript({
+                AssetFactory.createInlineContentScript({
                   position: "head",
                   content,
-                  attributes: {
-                    type: "module",
-                    defer: "",
-                    ...attributes
-                  }
+                  bundle: false,
+                  attributes
                 })
               );
               continue;

package/src/route-renderer/page-loading/page-module-loader.d.ts

@@ -1,5 +1,5 @@
-import type { EcoPageFile, GetMetadata, GetMetadataContext, GetStaticProps, PageMetadataProps, RouteRendererOptions, EcoPageComponent } from '../../public-types.js';
-import type { EcoPagesAppConfig } from '../../internal-types.js';
+import type { EcoPageFile, GetMetadata, GetMetadataContext, GetStaticProps, PageMetadataProps, RouteRendererOptions, EcoPageComponent } from '../../types/public-types.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
 /**
  * Loads route page modules and normalizes their data hooks for rendering.
  *
@@ -10,7 +10,7 @@ import type { EcoPagesAppConfig } from '../../internal-types.js';
  * page props and metadata into one renderer-facing shape.
  */
 export declare class PageModuleLoaderService {
-    private serverModuleTranspiler;
+    private appModuleLoader;
     private appConfig;
     private runtimeOrigin;
     /**
@@ -27,7 +27,9 @@ export declare class PageModuleLoaderService {
      * The underlying transpiler keeps Bun and Node aligned on one framework-owned
      * loading contract even though the runtime-specific execution transport differs.
      */
-    importPageFile(file: string): Promise<EcoPageFile>;
+    importPageFile(file: string, options?: {
+        bypassCache?: boolean;
+    }): Promise<EcoPageFile>;
     /**
      * Executes the page's static-props hook with Ecopages runtime context.
      *

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

@@ -1,8 +1,8 @@
 import { invariant } from "../../utils/invariant.js";
-import { getAppServerModuleTranspiler } from "../../services/module-loading/app-server-module-transpiler.service.js";
+import { getAppModuleLoader } from "../../services/module-loading/app-server-module-transpiler.service.js";
 import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
 class PageModuleLoaderService {
-  serverModuleTranspiler;
+  appModuleLoader;
   appConfig;
   runtimeOrigin;
   /**
@@ -14,7 +14,7 @@ class PageModuleLoaderService {
   constructor(appConfig, runtimeOrigin) {
     this.appConfig = appConfig;
     this.runtimeOrigin = runtimeOrigin;
-    this.serverModuleTranspiler = getAppServerModuleTranspiler(appConfig);
+    this.appModuleLoader = getAppModuleLoader(appConfig);
   }
   /**
    * Imports one page module through the shared server-side module loading path.
@@ -23,11 +23,13 @@ class PageModuleLoaderService {
    * 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.serverModuleTranspiler.importModule({
+      return await this.appModuleLoader.importModule({
         filePath: file,
+        rootDir: this.appConfig.rootDir,
         outdir: `${resolveInternalExecutionDir(this.appConfig)}/.server-modules`,
+        bypassCache: options?.bypassCache,
         transpileErrorMessage: (details) => `Error transpiling page file: ${details}`,
         noOutputMessage: (targetFilePath) => `No transpiled output generated for page: ${targetFilePath}`
       });

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

@@ -1,6 +1,6 @@
-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 { RouteRenderResult, RouteRendererOptions } from '../types/public-types.js';
 import type { IntegrationRenderer } from './orchestration/integration-renderer.js';
 /**
  * Thin wrapper around one initialized integration renderer.
@@ -32,12 +32,14 @@ export declare class RouteRenderer {
 export declare class RouteRendererFactory {
     private appConfig;
     runtimeOrigin: string;
+    private rendererModules?;
     private rendererCache;
     /**
      * Creates the route-renderer factory for one app/runtime instance.
      */
-    constructor({ appConfig, runtimeOrigin }: {
+    constructor({ appConfig, rendererModules, runtimeOrigin, }: {
         appConfig: EcoPagesAppConfig;
+        rendererModules?: unknown;
         runtimeOrigin: string;
     });
     /**

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

@@ -18,12 +18,18 @@ class RouteRenderer {
 class RouteRendererFactory {
   appConfig;
   runtimeOrigin;
+  rendererModules;
   rendererCache = /* @__PURE__ */ new Map();
   /**
    * Creates the route-renderer factory for one app/runtime instance.
    */
-  constructor({ appConfig, runtimeOrigin }) {
+  constructor({
+    appConfig,
+    rendererModules,
+    runtimeOrigin
+  }) {
     this.appConfig = appConfig;
+    this.rendererModules = rendererModules;
     this.runtimeOrigin = runtimeOrigin;
   }
   /**
@@ -47,7 +53,9 @@ class RouteRendererFactory {
     if (cached) {
       return cached;
     }
-    const renderer = integrationPlugin.initializeRenderer();
+    const renderer = integrationPlugin.initializeRenderer({
+      rendererModules: this.rendererModules
+    });
     this.rendererCache.set(integrationName, renderer);
     return renderer;
   }
@@ -76,7 +84,9 @@ class RouteRendererFactory {
     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

@@ -8,19 +8,90 @@ The router layer determines what route is being handled and how the client runti
 
 It is responsible for:
 
-- filesystem route scanning and matching
-- explicit-route support and response matching
-- client-side navigation coordination and ownership handoff
+- 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
 
-## Main Areas
+## Directory Structure
 
-- server-side route discovery and matchers used by adapters
-- `client/`: shared browser-side navigation coordination
+```
+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.
+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/navigation-coordinator.js

@@ -16,7 +16,7 @@ function getCandidateOwners(currentOwner, registrations, excludedOwner) {
   }
   return owners;
 }
-function createEcoNavigationRuntime(_windowObject) {
+function createEcoNavigationRuntime() {
   const registrations = /* @__PURE__ */ new Map();
   const listeners = /* @__PURE__ */ new Set();
   let owner = "none";
@@ -204,7 +204,7 @@ function getEcoNavigationRuntime(windowObject = window) {
   const runtimeWindow = windowObject;
   runtimeWindow.__ECO_PAGES__ = runtimeWindow.__ECO_PAGES__ || {};
   if (!runtimeWindow.__ECO_PAGES__.navigation) {
-    runtimeWindow.__ECO_PAGES__.navigation = createEcoNavigationRuntime(runtimeWindow);
+    runtimeWindow.__ECO_PAGES__.navigation = createEcoNavigationRuntime();
   }
   return runtimeWindow.__ECO_PAGES__.navigation;
 }

package/src/router/server/fs-router-scanner.d.ts

@@ -1,4 +1,4 @@
-import type { EcoPagesAppConfig, Routes } from '../../internal-types.js';
+import type { EcoPagesAppConfig, Routes } from '../../types/internal-types.js';
 type FSRouterScannerOptions = {
     buildMode: boolean;
 };

package/src/router/server/fs-router-scanner.js

@@ -113,7 +113,12 @@ class FSRouterScanner {
     const filePath = path.join(this.dir, file);
     const isCatchAll = filePath.includes("[...");
     const isDynamic = !isCatchAll && filePath.includes("[") && filePath.includes("]");
-    const kind = isCatchAll ? "catch-all" : isDynamic ? "dynamic" : "exact";
+    let kind = "exact";
+    if (isCatchAll) {
+      kind = "catch-all";
+    } else if (isDynamic) {
+      kind = "dynamic";
+    }
     return { route, routePath, filePath, kind };
   }
   async scan() {

package/src/router/server/fs-router.d.ts

@@ -1,4 +1,4 @@
-import type { MatchResult, Route, Routes } from '../../internal-types.js';
+import type { MatchResult, Route, Routes } from '../../types/internal-types.js';
 import type { FSRouterScanner } from './fs-router-scanner.js';
 /**
  * A class that manages the routes of the file system.

package/src/services/assets/asset-processing-service/asset-processing.service.d.ts

@@ -1,6 +1,6 @@
-import type { EcoPagesAppConfig, IHmrManager } from '../../../internal-types';
-import type { AssetDefinition, AssetKind, AssetSource, ProcessedAsset } from './assets.types';
-import { ProcessorRegistry } from './processor.registry';
+import type { EcoPagesAppConfig, IHmrManager } from '../../../types/internal-types.js';
+import type { AssetDefinition, AssetKind, AssetSource, ProcessedAsset } from './assets.types.js';
+import { ProcessorRegistry } from './processor.registry.js';
 /**
  * Processes declared component and page asset dependencies for one app instance.
  *

package/src/services/assets/asset-processing-service/asset-processing.service.js

@@ -1,17 +1,17 @@
 import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../../constants";
-import { appLogger } from "../../../global/app-logger";
-import { rapidhash } from "../../../utils/hash";
+import { RESOLVED_ASSETS_DIR } from "../../../config/constants.js";
+import { appLogger } from "../../../global/app-logger.js";
+import { rapidhash } from "../../../utils/hash.js";
 import { fileSystem } from "@ecopages/file-system";
-import { isHmrAware } from "./processor.interface";
-import { ProcessorRegistry } from "./processor.registry";
+import { isHmrAware } from "./processor.interface.js";
+import { ProcessorRegistry } from "./processor.registry.js";
 import {
   ContentScriptProcessor,
   ContentStylesheetProcessor,
   FileScriptProcessor,
   FileStylesheetProcessor,
   NodeModuleScriptProcessor
-} from "./processors";
+} from "./processors/index.js";
 class AssetProcessingService {
   static RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
   registry = new ProcessorRegistry();

package/src/services/assets/asset-processing-service/asset.factory.d.ts

@@ -1,4 +1,4 @@
-import type { ContentScriptAsset, ContentStylesheetAsset, FileScriptAsset, FileStylesheetAsset, InlineContentScriptAsset, InlineContentStylesheetAsset, InlineFileScriptAsset, JsonScriptAsset, NodeModuleScriptAsset } from './assets.types';
+import type { ContentScriptAsset, ContentStylesheetAsset, FileScriptAsset, FileStylesheetAsset, InlineContentScriptAsset, InlineContentStylesheetAsset, InlineFileScriptAsset, JsonScriptAsset, NodeModuleScriptAsset } from './assets.types.js';
 type CreateAssetOptions<T> = Omit<T, 'kind' | 'source' | 'inline'>;
 export declare class AssetFactory {
     static readonly RESOLVED_ASSETS_DIR = "assets";

package/src/services/assets/asset-processing-service/asset.factory.js

@@ -1,5 +1,5 @@
-import { RESOLVED_ASSETS_DIR, RESOLVED_ASSETS_VENDORS_DIR } from "../../../constants";
-import { deepMerge } from "../../../utils/deep-merge";
+import { RESOLVED_ASSETS_DIR, RESOLVED_ASSETS_VENDORS_DIR } from "../../../config/constants.js";
+import { deepMerge } from "../../../utils/deep-merge.js";
 class AssetFactory {
   static RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
   static RESOLVED_ASSETS_VENDORS_DIR = RESOLVED_ASSETS_VENDORS_DIR;

package/src/services/assets/asset-processing-service/index.d.ts

@@ -1,5 +1,5 @@
-export * from './asset.factory';
-export * from './asset-processing.service';
-export * from './assets.types';
-export * from './browser-runtime-asset.factory';
-export * from './browser-runtime-entry.factory';
+export * from './asset.factory.js';
+export * from './asset-processing.service.js';
+export * from './assets.types.js';
+export * from './browser-runtime-asset.factory.js';
+export * from './browser-runtime-entry.factory.js';