@ecopages/core 0.2.0-beta.25 → 0.2.0-beta.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/core",
-  "version": "0.2.0-beta.25",
+  "version": "0.2.0-beta.26",
   "description": "Core package for Ecopages",
   "keywords": [
     "ecopages",
@@ -17,7 +17,7 @@
     "directory": "packages/core"
   },
   "dependencies": {
-    "@ecopages/file-system": "0.2.0-beta.25",
+    "@ecopages/file-system": "0.2.0-beta.26",
     "@ecopages/logger": "^0.2.3",
     "@ecopages/scripts-injector": "^0.1.5",
     "@oxc-project/runtime": "0.134.0",

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

@@ -1,3 +1,16 @@
 import type { AssetDefinition } from './assets.types.js';
+/**
+ * Stable identity for dependency deduplication and {@link AssetProcessingService} cache lookups.
+ *
+ * @remarks
+ * Script dependencies include a build signature derived from bundle flags, grouped-bundle
+ * metadata, and selected `bundleOptions` fields (`naming`, `external`, `minify`, plugin names).
+ * HTML-affecting script `attributes` are hashed into the key so dedupe and cache reuse do not
+ * collapse declarations that would emit different `<script>` tags. Full plugin objects and
+ * `NODE_ENV` are excluded from the key.
+ *
+ * Runtime minify in {@link ContentScriptProcessor} still follows `NODE_ENV` via
+ * `isProduction`, not `bundleOptions.minify`.
+ */
 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

@@ -34,6 +34,9 @@ function getAssetDependencyKey(dep) {
   if ("packageRole" in dep && dep.packageRole) {
     parts.push(`package:${dep.packageRole}`);
   }
+  if (dep.kind === "script" && dep.attributes) {
+    parts.push(`attrs:${generateHash(JSON.stringify(dep.attributes))}`);
+  }
   const scriptBuildSignature = getScriptDependencyBuildSignature(dep);
   if (scriptBuildSignature) {
     parts.push(`build:${scriptBuildSignature}`);

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

@@ -39,7 +39,9 @@ export declare class AssetProcessingService {
      * @remarks
      * Dependencies are deduplicated before processor execution so repeated
      * declarations across the render tree reuse the same emitted outputs and cache
-     * entries.
+     * entries. Returned asset order is unspecified — consumers must re-associate
+     * outputs with inputs via dependency metadata such as `groupedBundle`, not by
+     * array index alignment with the input list.
      */
     processDependencies(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]>;
     private prepareDependenciesForProcessing;

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

@@ -69,7 +69,9 @@ class AssetProcessingService {
    * @remarks
    * Dependencies are deduplicated before processor execution so repeated
    * declarations across the render tree reuse the same emitted outputs and cache
-   * entries.
+   * entries. Returned asset order is unspecified — consumers must re-associate
+   * outputs with inputs via dependency metadata such as `groupedBundle`, not by
+   * array index alignment with the input list.
    */
   async processDependencies(deps, key) {
     const depsDir = path.join(this.config.absolutePaths.distDir, RESOLVED_ASSETS_DIR);

package/src/services/assets/asset-processing-service/grouped-content-bundles.js

@@ -1,5 +1,8 @@
 import { isDevelopmentRuntime } from "../../../utils/runtime.js";
 import { finalizeProcessedAsset } from "./finalize-processed-asset.js";
+function getGroupedBundleAssetKey(groupedBundle) {
+  return `${groupedBundle.id}:${groupedBundle.entryName}`;
+}
 function ensureGroupedContentScriptsBundle(dependencies) {
   if (isDevelopmentRuntime()) {
     return;
@@ -54,12 +57,25 @@ async function processGroupedDependencyBundles(options) {
     }
     try {
       const processedResults = await processor.processGrouped(bundleDeps);
-      return processedResults.map((processed, index) => {
-        const dep = bundleDeps[index];
+      const processedByEntryKey = /* @__PURE__ */ new Map();
+      for (const processed of processedResults) {
+        if (!processed.groupedBundle) {
+          continue;
+        }
+        processedByEntryKey.set(getGroupedBundleAssetKey(processed.groupedBundle), processed);
+      }
+      return bundleDeps.flatMap((dep) => {
+        if (dep.kind !== "script" || dep.source !== "content" || !dep.groupedBundle) {
+          return [];
+        }
+        const processed = processedByEntryKey.get(getGroupedBundleAssetKey(dep.groupedBundle));
+        if (!processed) {
+          return [];
+        }
         const depKey = getDependencyKey(dep);
         const finalized = finalizeProcessedAsset(processed, resolveProcessedAssetSrcUrl);
         setCachedAsset(dep, depKey, finalized);
-        return finalized;
+        return [finalized];
       });
     } catch (error) {
       logError(error);

package/src/services/assets/asset-processing-service/inline-content-script-body.d.ts

@@ -0,0 +1,11 @@
+import type { ContentScriptAsset } from './assets.types.js';
+/**
+ * Resolves the script body to embed when a content script is marked inline.
+ *
+ * @remarks
+ * `inline` means embed in HTML, not "use declaration source." When bundling has
+ * already run, only the output file is valid browser script; `dep.content` may
+ * still contain build-time import paths. Processor emission and cache
+ * materialization must share this rule so they cannot drift.
+ */
+export declare function resolveInlineContentScriptBody(dep: Pick<ContentScriptAsset, 'inline' | 'bundle' | 'content'>, filepath: string): string | undefined;

package/src/services/assets/asset-processing-service/inline-content-script-body.js

@@ -0,0 +1,17 @@
+import { fileSystem } from "@ecopages/file-system";
+import { appLogger } from "../../../global/app-logger.js";
+function resolveInlineContentScriptBody(dep, filepath) {
+  if (!dep.inline) {
+    return void 0;
+  }
+  if (dep.bundle !== false && fileSystem.exists(filepath)) {
+    return fileSystem.readFileSync(filepath);
+  }
+  if (dep.bundle !== false) {
+    appLogger.warn(`Missing bundled inline script output at ${filepath}; falling back to declaration source.`);
+  }
+  return dep.content;
+}
+export {
+  resolveInlineContentScriptBody
+};

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

@@ -1,11 +1,9 @@
 import type { ContentScriptAsset, ProcessedAsset } from './assets.types.js';
 /**
- * Builds a processed content-script asset from one dependency declaration and a
- * previously emitted output file.
- *
  * @remarks
- * Dev disk cache entries store only output paths. Callers must materialize the
- * full processed asset from the originating dependency so HTML and page-browser
- * graph assembly receive grouped-bundle metadata and script attributes.
+ * {@link AssetProcessingService} cache and dev disk cache entries usually keep
+ * only an output path. Dependency declarations still carry the metadata HTML and
+ * page-browser graph assembly need (`groupedBundle`, attributes, roles), so cache
+ * hits must be rehydrated from both sources rather than returned verbatim.
  */
 export declare function materializeContentScriptAsset(dep: ContentScriptAsset, filepath: string): ProcessedAsset;

package/src/services/assets/asset-processing-service/materialize-content-script-asset.js

@@ -1,9 +1,10 @@
+import { resolveInlineContentScriptBody } from "./inline-content-script-body.js";
 function materializeContentScriptAsset(dep, filepath) {
   return {
     filepath,
     kind: "script",
     inline: dep.inline ?? false,
-    content: dep.inline ? dep.content : void 0,
+    content: resolveInlineContentScriptBody(dep, filepath),
     position: dep.position,
     attributes: dep.attributes,
     excludeFromHtml: dep.excludeFromHtml,

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

@@ -3,11 +3,12 @@ import { BaseScriptProcessor } from '../base/base-script-processor.js';
 export declare class ContentScriptProcessor extends BaseScriptProcessor<ContentScriptAsset> {
     private getContentScriptEntryDir;
     private getContentScriptEntryPath;
-    private createBundleConfigHash;
-    private createContentScriptCacheKey;
     private toProcessedAsset;
     private removeContentScriptEntry;
     processGrouped(deps: ContentScriptAsset[]): Promise<ProcessedAsset[]>;
     private getGroupedBundlerOptions;
+    /**
+     * Emits one content script asset. Cache reuse is owned by {@link AssetProcessingService}.
+     */
     process(dep: ContentScriptAsset): Promise<ProcessedAsset>;
 }

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

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
+import { resolveInlineContentScriptBody } from "../../inline-content-script-body.js";
 import { shouldUseDevBrowserScriptCache } from "../../../../../build/dev-browser-script-cache.js";
 import { BaseScriptProcessor } from "../base/base-script-processor.js";
 class ContentScriptProcessor extends BaseScriptProcessor {
@@ -11,24 +12,10 @@ class ContentScriptProcessor extends BaseScriptProcessor {
   getContentScriptEntryPath(contentHash) {
     return path.join(this.getContentScriptEntryDir(), `${contentHash}.js`);
   }
-  createBundleConfigHash(dep, shouldBundle) {
-    return this.generateHash(
-      JSON.stringify({
-        bundle: shouldBundle,
-        minify: shouldBundle && this.isProduction,
-        opts: dep.bundleOptions
-      })
-    );
-  }
-  createContentScriptCacheKey(dep, shouldBundle) {
-    const contentHash = this.generateHash(dep.content);
-    const configHash = this.createBundleConfigHash(dep, shouldBundle);
-    return `${this.buildCacheKey(`content-script:${contentHash}`, contentHash, dep)}:${configHash}`;
-  }
-  toProcessedAsset(dep, filepath, inlineContent) {
+  toProcessedAsset(dep, filepath) {
     return {
       filepath,
-      content: dep.inline ? inlineContent : void 0,
+      content: resolveInlineContentScriptBody(dep, filepath),
       kind: "script",
       position: dep.position,
       attributes: dep.attributes,
@@ -81,11 +68,7 @@ class ContentScriptProcessor extends BaseScriptProcessor {
         if (!bundledFilePath) {
           throw new Error(`Missing grouped bundle output for ${entryName}`);
         }
-        return this.toProcessedAsset(
-          dep,
-          bundledFilePath,
-          dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0
-        );
+        return this.toProcessedAsset(dep, bundledFilePath);
       });
     } finally {
       for (const { contentHash } of tempEntries) {
@@ -104,41 +87,37 @@ class ContentScriptProcessor extends BaseScriptProcessor {
     }
     return options;
   }
+  /**
+   * Emits one content script asset. Cache reuse is owned by {@link AssetProcessingService}.
+   */
   async process(dep) {
     const shouldBundle = this.shouldBundle(dep);
-    const cacheKey = this.createContentScriptCacheKey(dep, shouldBundle);
-    return this.getOrProcess(cacheKey, async () => {
-      const hash = this.generateHash(dep.content);
-      const filename = dep.name ? `${dep.name}.js` : `script-${hash}.js`;
-      const filepath = path.join(this.getAssetsDir(), "scripts", filename);
-      if (!shouldBundle) {
-        if (!dep.inline) {
-          fileSystem.write(filepath, dep.content);
-        }
-        return this.toProcessedAsset(dep, filepath, dep.inline ? dep.content : void 0);
+    const hash = this.generateHash(dep.content);
+    const filename = dep.name ? `${dep.name}.js` : `script-${hash}.js`;
+    const filepath = path.join(this.getAssetsDir(), "scripts", filename);
+    if (!shouldBundle) {
+      if (!dep.inline) {
+        fileSystem.write(filepath, dep.content);
       }
-      if (!dep.content) {
-        throw new Error("No content found for script asset");
-      }
-      const entryPath = this.getContentScriptEntryPath(hash);
-      fileSystem.write(entryPath, dep.content);
-      try {
-        const bundledFilePath = await this.bundleScript({
-          entrypoint: entryPath,
-          outdir: this.getAssetsDir(),
-          minify: this.isProduction,
-          naming: `${path.parse(filename).name}-[hash].[ext]`,
-          ...this.getBundlerOptions(dep)
-        });
-        return this.toProcessedAsset(
-          dep,
-          bundledFilePath,
-          dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0
-        );
-      } finally {
-        this.removeContentScriptEntry(hash);
-      }
-    });
+      return this.toProcessedAsset(dep, filepath);
+    }
+    if (!dep.content) {
+      throw new Error("No content found for script asset");
+    }
+    const entryPath = this.getContentScriptEntryPath(hash);
+    fileSystem.write(entryPath, dep.content);
+    try {
+      const bundledFilePath = await this.bundleScript({
+        entrypoint: entryPath,
+        outdir: this.getAssetsDir(),
+        minify: this.isProduction,
+        naming: `${path.parse(filename).name}-[hash].[ext]`,
+        ...this.getBundlerOptions(dep)
+      });
+      return this.toProcessedAsset(dep, bundledFilePath);
+    } finally {
+      this.removeContentScriptEntry(hash);
+    }
   }
 }
 export {