@ecopages/core 0.2.0-alpha.8 → 0.2.1-beta.0

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

@@ -1,44 +1,34 @@
 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);
-  }
-}
 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;
   }
   /**
    * Returns a route renderer for the supplied route file.
    */
-  createRenderer(filePath) {
+  getPageRenderer(filePath) {
     const integrationRenderer = this.getRouteRendererEngine(filePath);
     invariant(!!integrationRenderer, `No integration renderer found for file: ${filePath}`);
-    return new RouteRenderer(integrationRenderer);
+    return integrationRenderer;
   }
   /**
-   * Get an integration renderer by its name.
-   * Used for explicit routing where views specify their integration via __eco.integration.
+   * Returns a renderer for an explicit view integration.
    */
-  getRendererByIntegration(integrationName) {
+  getExplicitViewRenderer(integrationName) {
     const integrationPlugin = this.appConfig.integrations.find((plugin) => plugin.name === integrationName);
     if (!integrationPlugin) {
       return null;
@@ -47,7 +37,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,12 +68,13 @@ 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;
   }
 }
 export {
-  RouteRenderer,
   RouteRendererFactory
 };

package/src/router/README.md

@@ -8,19 +8,87 @@ 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 discovery and classification (`exact`, `dynamic`, `catch-all`)
+- matching incoming request URLs to canonical template routes
+- server-side static-path expansion for dynamic template 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 discovery and matching
+│   └── route-registry.ts        # Owns template routes, request matching, static expansion, and reload
+└── client/                      # Browser-side navigation coordination
+    ├── navigation-coordinator.ts # Singleton runtime coordinator
+    └── link-intent.ts           # Shared anchor detection and intent recovery helpers
+```
+
+## `server/`
+
+### `RouteRegistry`
+
+Owns the canonical set of filesystem-discovered template routes for one application.
+
+File patterns determine route kind:
+
+| Pattern         | Kind        | Example           |
+| --------------- | ----------- | ----------------- |
+| `page.tsx`      | `exact`     | `/about`          |
+| `[slug].tsx`    | `dynamic`   | `/blog/[slug]`    |
+| `[...slug].tsx` | `catch-all` | `/docs/[...slug]` |
+
+The registry stores canonical template routes only. It compiles request-time matching metadata during `init()` and `reload()`, but it does not execute `staticPaths()` during discovery.
+
+Build-time static expansion is a separate operation. The registry invokes `staticPaths()` lazily through an injected page-module adapter and returns concrete static path expansions for the static generator.
+
+The public interface is intentionally small:
+
+- `templateRoutes` — ordered readonly template routes
+- `init()` / `reload()` — rebuild discovery state and match metadata
+- `matchRequest(requestUrl)` — request-time matching result with requested pathname, matched template route, params, and query
+- `listStaticPathExpansions()` — build-time expansion for dynamic routes
+- `listStaticGenerationRoutes()` — build-time route planning for static generation across exact and expanded routes
+
+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.
+
+## `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/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.d.ts

@@ -40,7 +40,21 @@ export type EcoNavigationHandoffRequest = EcoNavigationRequest & {
 };
 /** Request to reload the current page through the active runtime. */
 export type EcoReloadRequest = {
+    /**
+     * Clears runtime-owned caches before reloading.
+     *
+     * Runtimes use this when a reload must discard persisted client state such as
+     * cached layouts or route-local module instances.
+     */
     clearCache?: boolean;
+    /**
+     * Explicit page module URL to load for the reload.
+     *
+     * This is primarily used by HMR-aware runtimes so a current-page reload can
+     * reuse the active hot module entry instead of rediscovering the static page
+     * bootstrap asset from the fetched HTML document.
+     */
+    moduleUrl?: string;
     source?: EcoNavigationOwner;
 };
 /** Snapshot of the coordinator's current runtime ownership state. */
@@ -76,6 +90,12 @@ export type EcoNavigationRuntimeRegistration = {
     owner: EcoNavigationOwner;
     navigate?: (request: EcoNavigationRequest) => Promise<boolean | void>;
     handoffNavigation?: (request: EcoNavigationHandoffRequest) => Promise<boolean | void>;
+    /**
+     * Reloads the current page through the runtime's local navigation mechanism.
+     *
+     * Implementations may honor `request.moduleUrl` to force a specific page entry
+     * and `request.clearCache` to discard persisted runtime state before reloading.
+     */
     reloadCurrentPage?: (request?: EcoReloadRequest) => Promise<void>;
     /**
      * Releases runtime-owned client state before another runtime commits a new

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/route-registry.d.ts

@@ -0,0 +1,78 @@
+import type { EcoPagesAppConfig, RouteKind } from '../../types/internal-types.js';
+export type RouteParams = Record<string, string | string[]>;
+export type RouteQuery = Record<string, string>;
+export type TemplateRoute = {
+    readonly pathname: string;
+    readonly kind: RouteKind;
+    readonly filePath: string;
+    readonly paramNames: readonly string[];
+};
+export type RouteMatch = {
+    readonly requestedPathname: string;
+    readonly templateRoute: TemplateRoute;
+    readonly params: RouteParams;
+    readonly query: RouteQuery;
+};
+export type StaticPathExpansion = {
+    readonly pathname: string;
+    readonly templateRoute: TemplateRoute;
+    readonly params: RouteParams;
+};
+export type StaticGenerationRoute = {
+    readonly requestUrl: string;
+    readonly pathname: string;
+    readonly templateRoute: TemplateRoute;
+    readonly params: RouteParams;
+};
+export type StaticPathsContext = {
+    readonly appConfig: EcoPagesAppConfig;
+    readonly runtimeOrigin: string;
+};
+export type RouteRegistryPageModule = {
+    readonly staticPaths?: (context: StaticPathsContext) => Promise<{
+        paths: Array<{
+            params: RouteParams;
+        }>;
+    }>;
+    readonly staticProps?: unknown;
+};
+export interface RouteRegistryPageModuleAdapter {
+    loadPageModule(filePath: string): Promise<RouteRegistryPageModule>;
+}
+export type RouteRegistryOptions = {
+    pagesDir: string;
+    appConfig: EcoPagesAppConfig;
+    origin: string;
+    templatesExt: readonly string[];
+    buildMode: boolean;
+    pageModuleAdapter: RouteRegistryPageModuleAdapter;
+};
+export declare class RouteRegistry {
+    readonly origin: string;
+    readonly appConfig: EcoPagesAppConfig;
+    readonly pagesDir: string;
+    readonly templatesExt: readonly string[];
+    readonly buildMode: boolean;
+    private readonly pageModuleAdapter;
+    private templateRouteList;
+    private readonly reloadListeners;
+    constructor(options: RouteRegistryOptions);
+    get templateRoutes(): readonly TemplateRoute[];
+    init(): Promise<void>;
+    reload(): Promise<void>;
+    onReload(listener: () => void): () => void;
+    matchRequest(requestUrl: string): RouteMatch | null;
+    listStaticPathExpansions(input: {
+        runtimeOrigin: string;
+    }): Promise<readonly StaticPathExpansion[]>;
+    listStaticGenerationRoutes(input: {
+        runtimeOrigin: string;
+    }): Promise<readonly StaticGenerationRoute[]>;
+    private scanTemplateRoutes;
+    private getRoutePath;
+    private classifyRouteKind;
+    private getParamNames;
+    private tryExtractParams;
+    private getSearchParams;
+    private resolveTemplatePath;
+}

package/src/router/server/route-registry.js

@@ -0,0 +1,262 @@
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { fileSystem } from "@ecopages/file-system";
+import { appLogger } from "../../global/app-logger.js";
+import { invariant } from "../../utils/invariant.js";
+const ROUTE_PRIORITY = {
+  exact: 0,
+  dynamic: 1,
+  "catch-all": 2
+};
+class RouteRegistry {
+  origin;
+  appConfig;
+  pagesDir;
+  templatesExt;
+  buildMode;
+  pageModuleAdapter;
+  templateRouteList = [];
+  reloadListeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.origin = options.origin;
+    this.appConfig = options.appConfig;
+    this.pagesDir = options.pagesDir;
+    this.templatesExt = options.templatesExt;
+    this.buildMode = options.buildMode;
+    this.pageModuleAdapter = options.pageModuleAdapter;
+  }
+  get templateRoutes() {
+    return this.templateRouteList;
+  }
+  async init() {
+    this.templateRouteList = await this.scanTemplateRoutes();
+    appLogger.debug("RouteRegistry initialized", this.templateRouteList);
+  }
+  async reload() {
+    await this.init();
+    for (const listener of this.reloadListeners) {
+      listener();
+    }
+  }
+  onReload(listener) {
+    this.reloadListeners.add(listener);
+    return () => {
+      this.reloadListeners.delete(listener);
+    };
+  }
+  matchRequest(requestUrl) {
+    const url = new URL(requestUrl);
+    const requestedPathname = normalizePathname(url.pathname);
+    const query = this.getSearchParams(url);
+    for (const route of this.templateRouteList) {
+      if (route.kind !== "exact") {
+        continue;
+      }
+      if (requestedPathname === route.pathname || requestedPathname === `${route.pathname}/`) {
+        return {
+          requestedPathname,
+          templateRoute: route,
+          params: {},
+          query
+        };
+      }
+    }
+    for (const route of this.templateRouteList) {
+      if (route.kind !== "dynamic") {
+        continue;
+      }
+      const params = this.tryExtractParams(route, requestedPathname);
+      if (!params) {
+        continue;
+      }
+      return {
+        requestedPathname,
+        templateRoute: route,
+        params,
+        query
+      };
+    }
+    for (const route of this.templateRouteList) {
+      if (route.kind !== "catch-all") {
+        continue;
+      }
+      const params = this.tryExtractParams(route, requestedPathname);
+      if (!params) {
+        continue;
+      }
+      return {
+        requestedPathname,
+        templateRoute: route,
+        params,
+        query
+      };
+    }
+    return null;
+  }
+  async listStaticPathExpansions(input) {
+    const expansions = [];
+    for (const route of this.templateRouteList) {
+      if (route.kind === "exact") {
+        continue;
+      }
+      const pageModule = await this.pageModuleAdapter.loadPageModule(route.filePath);
+      const staticPaths = pageModule.staticPaths;
+      if (this.buildMode) {
+        invariant(staticPaths !== void 0, `[ecopages] Missing getStaticPaths in ${route.filePath}`);
+        invariant(
+          pageModule.staticProps !== void 0,
+          `[ecopages] Missing getStaticProps in ${route.filePath}`
+        );
+      }
+      if (!staticPaths) {
+        continue;
+      }
+      const result = await staticPaths({
+        appConfig: this.appConfig,
+        runtimeOrigin: input.runtimeOrigin
+      });
+      for (const { params } of result.paths) {
+        expansions.push({
+          pathname: this.resolveTemplatePath(route.pathname, params),
+          templateRoute: route,
+          params
+        });
+      }
+    }
+    return expansions;
+  }
+  async listStaticGenerationRoutes(input) {
+    const staticPathExpansions = await this.listStaticPathExpansions(input);
+    return [
+      ...this.templateRouteList.filter((route) => route.kind === "exact").map((route) => ({
+        requestUrl: `${input.runtimeOrigin}${route.pathname}`,
+        pathname: route.pathname,
+        templateRoute: route,
+        params: {}
+      })),
+      ...staticPathExpansions.map((route) => ({
+        requestUrl: `${input.runtimeOrigin}${route.pathname}`,
+        pathname: route.pathname,
+        templateRoute: route.templateRoute,
+        params: route.params
+      }))
+    ];
+  }
+  async scanTemplateRoutes() {
+    if (!existsSync(this.pagesDir)) {
+      return [];
+    }
+    const scannedFiles = await fileSystem.glob(
+      this.templatesExt.map((ext) => `**/*${ext}`),
+      {
+        cwd: this.pagesDir
+      }
+    );
+    const templateRoutes = [];
+    for await (const file of scannedFiles) {
+      if (file.includes(".ecopages-node.")) {
+        continue;
+      }
+      const routePathname = this.getRoutePath(file);
+      const filePath = path.join(this.pagesDir, file);
+      const kind = this.classifyRouteKind(filePath);
+      templateRoutes.push({
+        pathname: routePathname,
+        kind,
+        filePath,
+        paramNames: this.getParamNames(routePathname)
+      });
+    }
+    return templateRoutes.sort((left, right) => {
+      const priorityDifference = ROUTE_PRIORITY[left.kind] - ROUTE_PRIORITY[right.kind];
+      if (priorityDifference !== 0) {
+        return priorityDifference;
+      }
+      if (left.pathname === "/") {
+        return -1;
+      }
+      if (right.pathname === "/") {
+        return 1;
+      }
+      return left.pathname.localeCompare(right.pathname);
+    });
+  }
+  getRoutePath(file) {
+    const cleanedRoute = this.templatesExt.reduce((route, ext) => route.replace(ext, ""), file).replace(/\/?index$/, "");
+    return normalizePathname(`/${cleanedRoute}`);
+  }
+  classifyRouteKind(filePath) {
+    if (filePath.includes("[...")) {
+      return "catch-all";
+    }
+    if (filePath.includes("[") && filePath.includes("]")) {
+      return "dynamic";
+    }
+    return "exact";
+  }
+  getParamNames(routePathname) {
+    const matches = routePathname.match(/\[(?:\.\.\.)?([^\]]+)\]/g);
+    return matches ? matches.map((match) => match.replace(/^\[(?:\.\.\.)?/, "").replace(/\]$/, "")) : [];
+  }
+  tryExtractParams(route, requestedPathname) {
+    const routeParts = route.pathname.split("/");
+    const pathnameParts = requestedPathname.split("/");
+    if (route.kind === "dynamic" && routeParts.length !== pathnameParts.length) {
+      return null;
+    }
+    const params = {};
+    for (let i = 0; i < routeParts.length; i++) {
+      const routePart = routeParts[i];
+      const pathnamePart = pathnameParts[i];
+      if (!routePart) {
+        continue;
+      }
+      if (routePart.startsWith("[...") && routePart.endsWith("]")) {
+        const paramName = routePart.slice(4, -1);
+        params[paramName] = pathnameParts.slice(i).filter(Boolean);
+        return params;
+      }
+      if (routePart.startsWith("[") && routePart.endsWith("]")) {
+        if (pathnamePart === void 0) {
+          return null;
+        }
+        params[routePart.slice(1, -1)] = pathnamePart;
+        continue;
+      }
+      if (routePart !== pathnamePart) {
+        return null;
+      }
+    }
+    if (route.kind === "catch-all") {
+      const cleanPathname = route.pathname.replace(/\[.*?\]/g, "");
+      return requestedPathname.includes(cleanPathname) ? params : null;
+    }
+    return params;
+  }
+  getSearchParams(url) {
+    const query = {};
+    for (const [key, value] of url.searchParams) {
+      query[key] = value;
+    }
+    return query;
+  }
+  resolveTemplatePath(pathname, params) {
+    let resolvedPath = pathname;
+    for (const [key, value] of Object.entries(params)) {
+      const serializedValue = Array.isArray(value) ? value.join("/") : value;
+      resolvedPath = resolvedPath.replace(`[...${key}]`, serializedValue);
+      resolvedPath = resolvedPath.replace(`[${key}]`, serializedValue);
+    }
+    return normalizePathname(resolvedPath);
+  }
+}
+function normalizePathname(pathname) {
+  if (!pathname || pathname === "/") {
+    return "/";
+  }
+  const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+export {
+  RouteRegistry
+};

package/src/services/README.md

@@ -11,7 +11,6 @@ Typical responsibilities include:
 - server-module loading and transpilation
 - browser bundle coordination
 - asset processing and runtime asset declaration helpers
-- runtime specifier registry management
 - server invalidation state and entrypoint dependency graphs
 - HTML finalization and dependency injection
 
@@ -20,7 +19,7 @@ Typical responsibilities include:
 - `module-loading/`: framework-owned config/app bootstrap loading and server-side source loading
 - `assets/`: shared browser build coordination and processed asset pipelines
 - `invalidation/`: file-change classification and invalidation policy
-- `runtime-state/`: app-owned invalidation state, dependency graphs, and runtime specifier registry
+- `runtime-state/`: app-owned invalidation state and dependency graphs
 - `runtime-manifest/`: node runtime manifest derivation and persistence
 - `html/`: final HTML dependency injection and rewriter selection
 

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

@@ -0,0 +1,3 @@
+import type { AssetDefinition } from './assets.types.js';
+export declare function getAssetDependencyKey(dep: AssetDefinition): string;
+export declare function deduplicateAssetDependencies(deps: AssetDefinition[]): AssetDefinition[];

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

@@ -0,0 +1,56 @@
+import { rapidhash } from "../../../utils/hash.js";
+function generateHash(content) {
+  return rapidhash(content).toString();
+}
+function getScriptDependencyBuildSignature(dep) {
+  if (dep.kind !== "script") {
+    return void 0;
+  }
+  const pluginNames = dep.bundleOptions?.plugins?.map((plugin) => plugin.name) ?? [];
+  const signature = {
+    bundle: dep.bundle,
+    inline: dep.inline,
+    excludeFromHtml: dep.excludeFromHtml,
+    groupedBundle: dep.groupedBundle,
+    naming: dep.bundleOptions?.naming,
+    external: dep.bundleOptions?.external,
+    minify: dep.bundleOptions?.minify,
+    plugins: pluginNames
+  };
+  return generateHash(JSON.stringify(signature));
+}
+function getAssetDependencyKey(dep) {
+  const parts = [dep.kind, dep.source];
+  if ("filepath" in dep) {
+    parts.push(dep.filepath);
+  } else if ("content" in dep) {
+    parts.push(`content:${generateHash(dep.content)}`);
+  } else if ("importPath" in dep) {
+    parts.push(dep.importPath);
+  }
+  if ("position" in dep && dep.position) {
+    parts.push(dep.position);
+  }
+  if ("packageRole" in dep && dep.packageRole) {
+    parts.push(`package:${dep.packageRole}`);
+  }
+  const scriptBuildSignature = getScriptDependencyBuildSignature(dep);
+  if (scriptBuildSignature) {
+    parts.push(`build:${scriptBuildSignature}`);
+  }
+  return parts.join(":");
+}
+function deduplicateAssetDependencies(deps) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const dep of deps) {
+    const key = getAssetDependencyKey(dep);
+    if (!seen.has(key)) {
+      seen.set(key, dep);
+    }
+  }
+  return Array.from(seen.values());
+}
+export {
+  deduplicateAssetDependencies,
+  getAssetDependencyKey
+};

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.
  *
@@ -42,23 +42,6 @@ export declare class AssetProcessingService {
      * entries.
      */
     processDependencies(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]>;
-    /**
-     * Removes duplicate dependency declarations while preserving first-seen order.
-     */
-    private deduplicateDependencies;
-    /**
-     * Builds the cache signature fragment for script dependencies that can vary by
-     * bundling policy.
-     */
-    private getScriptDependencyBuildSignature;
-    /**
-     * Derives the stable cache key for one dependency declaration.
-     */
-    private getDependencyKey;
-    /**
-     * Hashes content used in dependency cache and signature keys.
-     */
-    private generateHash;
     /**
      * Processes deduplicated dependencies grouped by processor type.
      *