@ecopages/core 0.2.0-beta.2 → 0.2.0-beta.20

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

@@ -15,8 +15,8 @@
  * Timestamped navigation intent captured from pointer or hover activity.
  */
 export type EcoPendingNavigationIntent = {
-	href: string;
-	timestamp: number;
+    href: string;
+    timestamp: number;
 };
 /**
  * Finds the nearest matching anchor within an event's composed path.
@@ -28,26 +28,16 @@ export type EcoPendingNavigationIntent = {
  * @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;
+export declare function getAnchorFromNavigationEvent(event: MouseEvent | PointerEvent, linkSelector: string): HTMLAnchorElement | null;
+/**
+ * Returns whether an href targets a static asset that should use a full document load.
+ */
+export declare function isStaticAssetHref(href: string): boolean;
 /**
  * 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`.
+ * @remarks
+ * Pending intents expire quickly because they bridge pointer or hover capture
+ * and the later click when the DOM changes during a rapid navigation sequence.
  */
-export declare function recoverPendingNavigationHref(
-	intent: EcoPendingNavigationIntent | null,
-	hasInFlightNavigation: boolean,
-	now: number,
-	maxAgeMs?: number,
-): string | null;
+export declare function recoverPendingNavigationHref(intent: EcoPendingNavigationIntent | null, hasInFlightNavigation: boolean, now: number, maxAgeMs?: number): string | null;

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

@@ -1,3 +1,4 @@
+import { hasKnownStaticExtension } from "../../utils/static-file-extensions.js";
 function getAnchorFromNavigationEvent(event, linkSelector) {
   const eventTarget = event.target;
   if (eventTarget instanceof HTMLAnchorElement && eventTarget.matches(linkSelector)) {
@@ -19,6 +20,14 @@ function getAnchorFromNavigationEvent(event, linkSelector) {
     (target) => target instanceof HTMLAnchorElement && target.matches(linkSelector)
   );
 }
+function isStaticAssetHref(href) {
+  try {
+    const url = new URL(href, "http://localhost");
+    return hasKnownStaticExtension(url.pathname);
+  } catch {
+    return false;
+  }
+}
 function recoverPendingNavigationHref(intent, hasInFlightNavigation, now, maxAgeMs = 1e3) {
   if (!intent || !hasInFlightNavigation) {
     return null;
@@ -30,5 +39,6 @@ function recoverPendingNavigationHref(intent, hasInFlightNavigation, now, maxAge
 }
 export {
   getAnchorFromNavigationEvent,
+  isStaticAssetHref,
   recoverPendingNavigationHref
 };

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { getAnchorFromNavigationEvent, recoverPendingNavigationHref } from "./link-intent.js";
+import { getAnchorFromNavigationEvent, isStaticAssetHref, 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");
@@ -31,6 +31,17 @@ describe("getAnchorFromNavigationEvent", () => {
     expect(getAnchorFromNavigationEvent(event, "a[data-eco-link]")).toBe(anchor);
   });
 });
+describe("isStaticAssetHref", () => {
+  it("returns true for known static asset paths", () => {
+    expect(isStaticAssetHref("/skill.txt")).toBe(true);
+    expect(isStaticAssetHref("/skill/reference/full-stack.md")).toBe(true);
+    expect(isStaticAssetHref("/assets/logo.png")).toBe(true);
+  });
+  it("returns false for application routes", () => {
+    expect(isStaticAssetHref("/docs/getting-started/introduction")).toBe(false);
+    expect(isStaticAssetHref("/")).toBe(false);
+  });
+});
 describe("recoverPendingNavigationHref", () => {
   it("returns null for stale or missing pending intent state", () => {
     expect(recoverPendingNavigationHref(null, true, 10)).toBeNull();

package/src/router/client/link-navigation-policy.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Canonical link interception, prefetch eligibility, and HTML fetch guards.
+ * @module
+ */
+export type LinkNavigationPolicyOptions = {
+    /** Attribute that forces a full document reload instead of SPA navigation. */
+    reloadAttribute?: string;
+    /** Attribute that opts a link out of prefetch. */
+    noPrefetchAttribute?: string;
+};
+export type LinkNavigationDecision = {
+    shouldIntercept: true;
+    href: string;
+} | {
+    shouldIntercept: false;
+    reason: 'modified-click' | 'non-left-click' | 'external-target' | 'explicit-reload' | 'download' | 'no-prefetch' | 'invalid-href' | 'cross-origin' | 'static-asset' | 'same-page-hash';
+};
+/**
+ * Returns whether an href only adds a hash fragment on the current page.
+ */
+export declare function isSamePageHashNavigationHref(href: string): boolean;
+/**
+ * Decides whether a pointer or click on an anchor should be handled as SPA navigation.
+ */
+export declare function getLinkNavigationDecision(event: MouseEvent | PointerEvent, link: HTMLAnchorElement, options: LinkNavigationPolicyOptions): LinkNavigationDecision;
+/**
+ * Returns the href when SPA navigation should intercept the click, otherwise `null`.
+ */
+export declare function getNavigableHrefFromClick(event: MouseEvent | PointerEvent, link: HTMLAnchorElement, options: LinkNavigationPolicyOptions): string | null;
+/**
+ * Returns whether a link is eligible for hover or viewport prefetch.
+ */
+export declare function shouldPrefetchLink(link: HTMLAnchorElement, options: LinkNavigationPolicyOptions): boolean;
+/**
+ * @remarks
+ * Prefetch and SPA fetches request HTML. Only explicit `text/html` and
+ * `application/xhtml+xml` responses are accepted; missing or asset types are rejected.
+ */
+export declare function isHtmlPageResponse(response: Response): boolean;
+/**
+ * @remarks
+ * Servers should send `text/html`. When the type is missing or the runtime
+ * defaults to `text/plain` (common in tests), a document-shaped body is accepted.
+ */
+export declare function assertHtmlPageResponse(response: Response): Promise<void>;

package/src/router/client/link-navigation-policy.js

@@ -0,0 +1,101 @@
+import { isStaticAssetHref } from "./link-intent.js";
+function getLinkIneligibilityReason(link, options) {
+  if (options.noPrefetchAttribute && link.hasAttribute(options.noPrefetchAttribute)) {
+    return "no-prefetch";
+  }
+  if (options.reloadAttribute && link.hasAttribute(options.reloadAttribute)) {
+    return "explicit-reload";
+  }
+  if (link.hasAttribute("download")) {
+    return "download";
+  }
+  const href = link.getAttribute("href");
+  if (!href || href.startsWith("#") || href.startsWith("javascript:")) {
+    return "invalid-href";
+  }
+  const url = new URL(href, window.location.origin);
+  if (url.origin !== window.location.origin) {
+    return "cross-origin";
+  }
+  if (isStaticAssetHref(href)) {
+    return "static-asset";
+  }
+  return null;
+}
+function isSamePageHashNavigationHref(href) {
+  if (!href) {
+    return false;
+  }
+  const currentUrl = new URL(window.location.href);
+  const targetUrl = new URL(href, currentUrl);
+  return targetUrl.origin === currentUrl.origin && targetUrl.hash.length > 0 && targetUrl.pathname === currentUrl.pathname && targetUrl.search === currentUrl.search;
+}
+function getLinkNavigationDecision(event, link, options) {
+  if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
+    return { shouldIntercept: false, reason: "modified-click" };
+  }
+  if (event.button !== 0) {
+    return { shouldIntercept: false, reason: "non-left-click" };
+  }
+  const target = link.getAttribute("target");
+  if (target && target !== "_self") {
+    return { shouldIntercept: false, reason: "external-target" };
+  }
+  const ineligibility = getLinkIneligibilityReason(link, options);
+  if (ineligibility) {
+    return { shouldIntercept: false, reason: ineligibility };
+  }
+  const href = link.getAttribute("href");
+  if (isSamePageHashNavigationHref(href)) {
+    return { shouldIntercept: false, reason: "same-page-hash" };
+  }
+  return { shouldIntercept: true, href };
+}
+function getNavigableHrefFromClick(event, link, options) {
+  const decision = getLinkNavigationDecision(event, link, options);
+  return decision.shouldIntercept ? decision.href : null;
+}
+function shouldPrefetchLink(link, options) {
+  if (getLinkIneligibilityReason(link, options)) {
+    return false;
+  }
+  const href = link.getAttribute("href");
+  try {
+    const url = new URL(href, window.location.origin);
+    const currentPath = window.location.pathname + window.location.search;
+    const targetPath = url.pathname + url.search;
+    return currentPath !== targetPath;
+  } catch {
+    return false;
+  }
+}
+function isHtmlPageResponse(response) {
+  const contentType = response.headers.get("Content-Type");
+  if (!contentType) {
+    return false;
+  }
+  const normalized = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return normalized === "text/html" || normalized === "application/xhtml+xml";
+}
+async function assertHtmlPageResponse(response) {
+  if (isHtmlPageResponse(response)) {
+    return;
+  }
+  const contentType = response.headers.get("Content-Type");
+  const normalized = contentType?.split(";")[0]?.trim().toLowerCase() ?? "";
+  if (normalized === "text/plain" || normalized === "") {
+    const sample = (await response.clone().text()).trimStart();
+    if (sample.startsWith("<")) {
+      return;
+    }
+  }
+  throw new Error(`Expected HTML page response, received ${contentType ?? "unknown content type"}`);
+}
+export {
+  assertHtmlPageResponse,
+  getLinkNavigationDecision,
+  getNavigableHrefFromClick,
+  isHtmlPageResponse,
+  isSamePageHashNavigationHref,
+  shouldPrefetchLink
+};

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

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

package/src/router/client/link-navigation-policy.test.browser.js

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import {
+  getLinkNavigationDecision,
+  getNavigableHrefFromClick,
+  isHtmlPageResponse,
+  isSamePageHashNavigationHref,
+  shouldPrefetchLink
+} from "./link-navigation-policy.js";
+function createLink(href, attributes = {}) {
+  const link = document.createElement("a");
+  link.href = href;
+  for (const [key, value] of Object.entries(attributes)) {
+    link.setAttribute(key, value);
+  }
+  document.body.append(link);
+  return link;
+}
+function createMouseEvent(button = 0, modifiers = {}) {
+  return new MouseEvent("click", { bubbles: true, cancelable: true, button, ...modifiers });
+}
+const policy = { reloadAttribute: "data-eco-reload", noPrefetchAttribute: "data-eco-no-prefetch" };
+describe("isSamePageHashNavigationHref", () => {
+  it("returns true for same pathname with a new hash", () => {
+    history.replaceState({}, "", "/docs/page");
+    expect(isSamePageHashNavigationHref("/docs/page#section")).toBe(true);
+  });
+});
+describe("getLinkNavigationDecision", () => {
+  it("allows same-origin page links", () => {
+    const link = createLink("/page");
+    const decision = getLinkNavigationDecision(createMouseEvent(), link, policy);
+    expect(decision).toEqual({ shouldIntercept: true, href: "/page" });
+  });
+  it("rejects static asset links", () => {
+    const link = createLink("/skill.txt");
+    expect(getLinkNavigationDecision(createMouseEvent(), link, policy)).toEqual({
+      shouldIntercept: false,
+      reason: "static-asset"
+    });
+  });
+  it("rejects explicit reload links", () => {
+    const link = createLink("/logout", { "data-eco-reload": "" });
+    expect(getLinkNavigationDecision(createMouseEvent(), link, policy)).toEqual({
+      shouldIntercept: false,
+      reason: "explicit-reload"
+    });
+  });
+});
+describe("getNavigableHrefFromClick", () => {
+  it("returns href when navigation should be intercepted", () => {
+    const link = createLink("/page");
+    expect(getNavigableHrefFromClick(createMouseEvent(), link, policy)).toBe("/page");
+  });
+  it("returns null for static assets", () => {
+    const link = createLink("/llms.txt");
+    expect(getNavigableHrefFromClick(createMouseEvent(), link, policy)).toBeNull();
+  });
+});
+describe("shouldPrefetchLink", () => {
+  it("prefetches internal page links", () => {
+    history.replaceState({}, "", "/");
+    const link = createLink("/docs/intro");
+    expect(shouldPrefetchLink(link, policy)).toBe(true);
+  });
+  it("skips static assets and opt-outs", () => {
+    history.replaceState({}, "", "/");
+    expect(shouldPrefetchLink(createLink("/skill.txt"), policy)).toBe(false);
+    expect(shouldPrefetchLink(createLink("/page", { "data-eco-no-prefetch": "" }), policy)).toBe(false);
+  });
+});
+describe("isHtmlPageResponse", () => {
+  it("accepts html content types", () => {
+    expect(isHtmlPageResponse(new Response("", { headers: { "Content-Type": "text/html; charset=utf-8" } }))).toBe(
+      true
+    );
+  });
+  it("rejects plain text responses", () => {
+    expect(isHtmlPageResponse(new Response("", { headers: { "Content-Type": "text/plain" } }))).toBe(false);
+  });
+});
+describe("isHtmlPageResponse", () => {
+  it("accepts html and xhtml content types", () => {
+    expect(isHtmlPageResponse(new Response("", { headers: { "Content-Type": "text/html" } }))).toBe(true);
+    expect(isHtmlPageResponse(new Response("", { headers: { "Content-Type": "application/xhtml+xml" } }))).toBe(
+      true
+    );
+  });
+  it("rejects plain text and markdown responses", () => {
+    expect(isHtmlPageResponse(new Response("text", { headers: { "Content-Type": "text/plain" } }))).toBe(false);
+    expect(isHtmlPageResponse(new Response("# doc", { headers: { "Content-Type": "text/markdown" } }))).toBe(false);
+  });
+});

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

@@ -96,7 +96,7 @@ export type EcoNavigationRuntimeRegistration = {
      * 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>;
+    reloadCurrentPage?: (request?: EcoReloadRequest) => Promise<boolean | void>;
     /**
      * Releases runtime-owned client state before another runtime commits a new
      * document.

package/src/router/client/navigation-coordinator.js

@@ -176,8 +176,8 @@ function createEcoNavigationRuntime() {
         if (!registration?.reloadCurrentPage) {
           continue;
         }
-        await registration.reloadCurrentPage(request);
-        return true;
+        const handled = await registration.reloadCurrentPage(request);
+        return handled !== false;
       }
       return false;
     },
@@ -198,6 +198,16 @@ function createEcoNavigationRuntime() {
       await runtime.cleanupOwner(owner);
     }
   };
+  if (typeof window !== "undefined") {
+    window.addEventListener("pageshow", (event) => {
+      if (event.persisted) {
+        runtime.cancelCurrentNavigationTransaction();
+      }
+    });
+    window.addEventListener("pagehide", () => {
+      runtime.cancelCurrentNavigationTransaction();
+    });
+  }
   return runtime;
 }
 function getEcoNavigationRuntime(windowObject = window) {

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

@@ -45,6 +45,7 @@ export declare function createBrowserRuntimeModuleAsset(options: {
     fileName: string;
     cacheDirName?: string;
     rootDir?: string;
+    workDir?: string;
     bundleOptions?: {
         define?: Record<string, string>;
         minify?: boolean;

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

@@ -31,6 +31,7 @@ function createBrowserRuntimeModuleAsset(options) {
     modules: options.modules,
     fileName: `${options.name}-entry.mjs`,
     rootDir: options.rootDir,
+    workDir: options.workDir,
     cacheDirName: options.cacheDirName
   });
   return createBrowserRuntimeScriptAsset({

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

@@ -9,12 +9,14 @@ export type BrowserRuntimeEntryModuleConfig = {
  * @remarks
  * Integrations use this helper when they need a browser runtime asset composed
  * from multiple bare specifiers but do not want to own temporary file assembly
- * logic themselves. The generated file lives under a cache directory inside the
- * consuming app root so repeated runs can reuse the same location.
+ * logic themselves. The generated file lives under the app work directory so
+ * repeated runs can reuse the same location without placing sources inside
+ * `node_modules`, which can cause bundlers to externalize bare imports.
  */
 export declare function createBrowserRuntimeEntryModule(options: {
     modules: BrowserRuntimeEntryModuleConfig[];
     fileName: string;
     rootDir?: string;
+    workDir?: string;
     cacheDirName?: string;
 }): string;

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

@@ -1,37 +1,57 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
+import { DEFAULT_ECOPAGES_WORK_DIR } from "../../../config/constants.js";
 function createBrowserRuntimeEntryModule(options) {
+  if (options.modules.some((module) => !module.specifier.startsWith("node:")) && !options.rootDir) {
+    throw new Error("createBrowserRuntimeEntryModule requires rootDir to resolve package specifiers");
+  }
   const rootDir = options.rootDir ?? process.cwd();
+  const workDir = options.workDir ?? path.join(rootDir, DEFAULT_ECOPAGES_WORK_DIR);
   const artifactsDir = path.join(
-    rootDir,
-    "node_modules",
-    ".cache",
+    workDir,
+    ".browser-runtime-entries",
     options.cacheDirName ?? "ecopages-browser-runtime"
   );
   fs.mkdirSync(artifactsDir, { recursive: true });
   const requireFromRoot = createRequire(path.join(rootDir, "package.json"));
   const seenExports = /* @__PURE__ */ new Set();
   const statements = [];
+  const filePath = path.join(artifactsDir, options.fileName);
+  const entryDir = path.dirname(filePath);
   for (const module of options.modules) {
+    const importSpecifier = resolveEntryImportSpecifier(module.specifier, requireFromRoot, entryDir);
     if (module.defaultExport) {
-      statements.push(`import __ecopages_default_export__ from '${module.specifier}';`);
+      statements.push(`import __ecopages_default_export__ from '${importSpecifier}';`);
       statements.push("export default __ecopages_default_export__;");
     }
     const exportNames = getModuleExportNames(module.specifier, requireFromRoot).filter(
       (name) => !seenExports.has(name)
     );
     if (exportNames.length > 0) {
-      statements.push(`export { ${exportNames.join(", ")} } from '${module.specifier}';`);
+      statements.push(`export { ${exportNames.join(", ")} } from '${importSpecifier}';`);
       for (const exportName of exportNames) {
         seenExports.add(exportName);
       }
     }
   }
-  const filePath = path.join(artifactsDir, options.fileName);
-  fs.writeFileSync(filePath, statements.join("\n"), "utf-8");
+  const content = statements.join("\n");
+  if (!fs.existsSync(filePath) || fs.readFileSync(filePath, "utf-8") !== content) {
+    fs.writeFileSync(filePath, content, "utf-8");
+  }
   return filePath;
 }
+function resolveEntryImportSpecifier(specifier, requireFromRoot, entryDir) {
+  if (specifier.startsWith("node:") || specifier.startsWith("file:")) {
+    return specifier;
+  }
+  const resolvedPath = requireFromRoot.resolve(specifier);
+  let relativePath = path.relative(entryDir, resolvedPath).replace(/\\/g, "/");
+  if (!relativePath.startsWith(".")) {
+    relativePath = `./${relativePath}`;
+  }
+  return relativePath;
+}
 function getModuleExportNames(specifier, requireFromRoot) {
   const moduleExports = requireFromRoot(specifier);
   return Object.keys(moduleExports).filter((name) => name !== "__esModule" && name !== "default").filter((name) => /^[$A-Z_a-z][$\w]*$/.test(name)).sort();

package/src/services/assets/asset-processing-service/processors/script/file-script.processor.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { RESOLVED_ASSETS_DIR } from "../../../../../config/constants.js";
 import { fileSystem } from "@ecopages/file-system";
+import { appLogger } from "../../../../../global/app-logger.js";
 import { BaseScriptProcessor } from "../base/base-script-processor.js";
 class FileScriptProcessor extends BaseScriptProcessor {
   hmrManager;
@@ -20,20 +21,41 @@ class FileScriptProcessor extends BaseScriptProcessor {
   }
   async process(dep) {
     if (this.hmrManager?.isEnabled() && !dep.inline) {
-      const outputUrl = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
-      const outputFilepath = this.resolveHmrOutputFilepath(dep.filepath);
-      return {
-        filepath: outputFilepath ?? dep.filepath,
-        sourceFilepath: dep.filepath,
-        srcUrl: outputUrl,
-        kind: "script",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: false,
-        excludeFromHtml: dep.excludeFromHtml,
-        packageRole: dep.packageRole,
-        bundledSourceFilepaths: dep.bundledSourceFilepaths
-      };
+      const resolvedOutput = this.hmrManager.getResolvedScriptOutput?.(dep.filepath);
+      if (resolvedOutput) {
+        return {
+          filepath: resolvedOutput.outputPath,
+          sourceFilepath: dep.filepath,
+          srcUrl: resolvedOutput.outputUrl,
+          kind: "script",
+          position: dep.position,
+          attributes: dep.attributes,
+          inline: false,
+          excludeFromHtml: dep.excludeFromHtml,
+          packageRole: dep.packageRole,
+          bundledSourceFilepaths: dep.bundledSourceFilepaths
+        };
+      }
+      try {
+        const outputUrl = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
+        const outputFilepath = this.resolveHmrOutputFilepath(dep.filepath);
+        return {
+          filepath: outputFilepath ?? dep.filepath,
+          sourceFilepath: dep.filepath,
+          srcUrl: outputUrl,
+          kind: "script",
+          position: dep.position,
+          attributes: dep.attributes,
+          inline: false,
+          excludeFromHtml: dep.excludeFromHtml,
+          packageRole: dep.packageRole,
+          bundledSourceFilepaths: dep.bundledSourceFilepaths
+        };
+      } catch (error) {
+        appLogger.warn(
+          `[FileScriptProcessor] HMR script registration failed for ${dep.filepath}, falling back to non-HMR asset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
     }
     const content = fileSystem.readFileSync(dep.filepath);
     const shouldBundle = this.shouldBundle(dep);

package/src/services/assets/asset-processing-service/processors/script/node-module-script.processor.js

@@ -8,19 +8,33 @@ class NodeModuleScriptProcessor extends BaseScriptProcessor {
     const modulePath = this.resolveModulePath(dep.importPath, this.appConfig.rootDir);
     const moduleName = path.basename(modulePath);
     const filename = dep.name ?? `nm-${moduleName}`;
+    const shouldBundle = this.shouldBundle(dep);
     const configHash = this.generateHash(
-      JSON.stringify({ inline: dep.inline, minify: !dep.inline && this.isProduction, opts: dep.bundleOptions })
+      JSON.stringify({
+        bundle: shouldBundle,
+        inline: dep.inline,
+        minify: shouldBundle && !dep.inline && this.isProduction,
+        opts: dep.bundleOptions
+      })
     );
     const cachekey = `${this.buildCacheKey(filename, this.generateHash(modulePath), dep)}:${configHash}`;
     return this.getOrProcess(cachekey, async () => {
-      if (dep.inline) {
+      if (dep.inline || !shouldBundle) {
         const content = fileSystem.readFileAsBuffer(modulePath).toString();
+        const filepath = dep.inline ? void 0 : path.join(this.getAssetsDir(), "vendors", filename);
+        if (filepath) {
+          fileSystem.ensureDir(path.dirname(filepath));
+          if (!fileSystem.exists(filepath) || fileSystem.readFileAsBuffer(filepath).toString() !== content) {
+            fileSystem.copyFile(modulePath, filepath);
+          }
+        }
         return {
+          filepath,
           content,
           kind: dep.kind,
           position: dep.position,
           attributes: dep.attributes,
-          inline: true,
+          inline: dep.inline,
           excludeFromHtml: dep.excludeFromHtml,
           packageRole: dep.packageRole,
           bundledSourceFilepaths: dep.bundledSourceFilepaths

package/src/services/assets/asset-processing-service/processors/stylesheet/content-stylesheet.processor.d.ts

@@ -1,8 +1,5 @@
 import type { ContentStylesheetAsset, ProcessedAsset } from '../../assets.types.js';
 import { BaseProcessor } from '../base/base-processor.js';
 export declare class ContentStylesheetProcessor extends BaseProcessor<ContentStylesheetAsset> {
-    private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS;
-    private isProcessableStylesheet;
-    private applyStylesheetProcessors;
     process(dep: ContentStylesheetAsset): Promise<ProcessedAsset>;
 }

package/src/services/assets/asset-processing-service/processors/stylesheet/content-stylesheet.processor.js

@@ -1,40 +1,11 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
 import { BaseProcessor } from "../base/base-processor.js";
+import { applyStylesheetProcessors } from "./stylesheet-processor-pipeline.js";
 class ContentStylesheetProcessor extends BaseProcessor {
-  static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
-  isProcessableStylesheet(filepath) {
-    return ContentStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
-  }
-  async applyStylesheetProcessors(content, filepath) {
-    if (!this.isProcessableStylesheet(filepath)) {
-      return content;
-    }
-    let transformedContent = content;
-    const processors = this.appConfig.processors ? Array.from(this.appConfig.processors.values()) : [];
-    for (const processor of processors) {
-      const hasCapabilities = processor.getAssetCapabilities().length > 0;
-      const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
-      if (!canProcessStylesheet && (hasCapabilities || !processor.getName().includes("postcss"))) {
-        continue;
-      }
-      if (!processor.matchesFileFilter(filepath)) {
-        continue;
-      }
-      const result = await processor.process(transformedContent, filepath);
-      if (typeof result === "string") {
-        transformedContent = result;
-        continue;
-      }
-      if (result instanceof Buffer) {
-        transformedContent = result.toString();
-      }
-    }
-    return transformedContent;
-  }
   async process(dep) {
     const virtualFilepath = path.join(this.appConfig.absolutePaths.distDir, "styles", "page-bundle.css");
-    const processedContent = await this.applyStylesheetProcessors(dep.content, virtualFilepath);
+    const processedContent = await applyStylesheetProcessors(this.appConfig, dep.content, virtualFilepath);
     const hash = this.generateHash(processedContent);
     const filename = `style-${hash}.css`;
     const cachekey = this.buildCacheKey(filename, hash, dep);

package/src/services/assets/asset-processing-service/processors/stylesheet/file-stylesheet.processor.d.ts

@@ -1,9 +1,6 @@
 import type { FileStylesheetAsset, ProcessedAsset } from '../../assets.types.js';
 import { BaseProcessor } from '../base/base-processor.js';
 export declare class FileStylesheetProcessor extends BaseProcessor<FileStylesheetAsset> {
-    private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS;
     getStyleContent: (srcUrl: string) => Buffer;
-    private isProcessableStylesheet;
-    private applyStylesheetProcessors;
     process(dep: FileStylesheetAsset): Promise<ProcessedAsset>;
 }