@ecopages/core 0.2.0-beta.30 → 0.2.0-beta.32

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

@@ -1,115 +1,112 @@
-import path from "node:path";
-import { rapidhash } from "../../utils/hash.js";
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
-import { buildResolvedLazyTriggers } from "./lazy-trigger-planning.js";
-import { collectComponentDependencies } from "./component-dependency-collection.js";
-import { packagePageDependencies } from "./page-dependency-bundling.js";
-const DEPENDENCY_ERRORS = {
-  INVALID_STYLESHEET_ENTRY: "Invalid stylesheet dependency entry: expected src or content",
-  INVALID_SCRIPT_ENTRY: "Invalid script dependency entry: expected src or content",
-  LAZY_SCRIPT_MISSING_SRC: "Lazy script dependency entry in dependencies.scripts requires a src value"
+import path from 'node:path';
+import { rapidhash } from '../../utils/hash.js';
+import { AssetFactory } from '../../services/assets/asset-processing-service/index.js';
+import { buildResolvedLazyTriggers } from './lazy-trigger-planning.js';
+import { collectComponentDependencies } from './component-dependency-collection.js';
+import { packagePageDependencies } from './page-dependency-bundling.js';
+export const DEPENDENCY_ERRORS = {
+    INVALID_STYLESHEET_ENTRY: 'Invalid stylesheet dependency entry: expected src or content',
+    INVALID_SCRIPT_ENTRY: 'Invalid script dependency entry: expected src or content',
+    LAZY_SCRIPT_MISSING_SRC: 'Lazy script dependency entry in dependencies.scripts requires a src value',
 };
 function resolveLazyScripts(appConfig, componentDir, scripts) {
-  const getSafeFileName = (filepath) => {
-    const EXTENSIONS_TO_JS = ["ts", "tsx"];
-    const safe = filepath.replace(new RegExp(`\\.(${EXTENSIONS_TO_JS.join("|")})$`), ".js");
-    return safe.startsWith("./") ? safe.slice(2) : safe;
-  };
-  const baseDir = componentDir.split(appConfig.srcDir)[1] ?? "";
-  const resolvedPaths = scripts.map((script) => {
-    const relativePath = [AssetFactory.RESOLVED_ASSETS_DIR, baseDir, getSafeFileName(script)].filter(Boolean).join("/").replace(/\/+/g, "/");
-    return `/${relativePath.replace(/^\/+/, "")}`;
-  });
-  return resolvedPaths.join(",");
+    const getSafeFileName = (filepath) => {
+        const EXTENSIONS_TO_JS = ['ts', 'tsx'];
+        const safe = filepath.replace(new RegExp(`\\.(${EXTENSIONS_TO_JS.join('|')})$`), '.js');
+        return safe.startsWith('./') ? safe.slice(2) : safe;
+    };
+    const baseDir = componentDir.split(appConfig.srcDir)[1] ?? '';
+    const resolvedPaths = scripts.map((script) => {
+        const relativePath = [AssetFactory.RESOLVED_ASSETS_DIR, baseDir, getSafeFileName(script)]
+            .filter(Boolean)
+            .join('/')
+            .replace(/\/+/g, '/');
+        return `/${relativePath.replace(/^\/+/, '')}`;
+    });
+    return resolvedPaths.join(',');
 }
-const ECOPAGES_JSX_INTEGRATION_NAME = "ecopages-jsx";
+const ECOPAGES_JSX_INTEGRATION_NAME = 'ecopages-jsx';
 function isEcopagesJsxIntegration(integrationName) {
-  return integrationName === ECOPAGES_JSX_INTEGRATION_NAME;
+    return integrationName === ECOPAGES_JSX_INTEGRATION_NAME;
 }
 function createEcopagesJsxLazyEntryName(integrationName, key) {
-  return `ecopages-${integrationName}-lazy-${rapidhash(key).toString(16)}`;
+    return `ecopages-${integrationName}-lazy-${rapidhash(key).toString(16)}`;
 }
-class DependencyResolverService {
-  appConfig;
-  assetProcessingService;
-  /**
-   * Creates the dependency resolver used by route and component rendering.
-   *
-   * @remarks
-   * The resolver stays intentionally separate from HTML rendering so component
-   * dependency collection, lazy trigger grouping, and processed-asset generation
-   * can evolve without changing renderer implementations.
-   */
-  constructor(appConfig, assetProcessingService) {
-    this.appConfig = appConfig;
-    this.assetProcessingService = assetProcessingService;
-  }
-  /**
-   * Resolves one dependency path relative to the component that declared it.
-   */
-  resolveDependencyPath(componentDir, pathUrl) {
-    return path.join(componentDir, pathUrl);
-  }
-  /**
-   * Maps lazy script source entries to deterministic fallback public URLs
-   * used when bundling output URLs are unavailable.
-   */
-  resolveLazyScripts(componentDir, scripts) {
-    return resolveLazyScripts(this.appConfig, componentDir, scripts);
-  }
-  /**
-   * Collects and processes component dependencies (styles, scripts, modules, lazy scripts).
-   * Lazy dependencies are always resolved into global-injector trigger maps.
-   */
-  async processComponentDependencies(components, integrationName) {
-    if (!this.assetProcessingService?.processDependencies) return [];
-    const { dependencies, lazyScriptsByConfig } = collectComponentDependencies({
-      components,
-      integrationName,
-      resolveLazyScripts: (componentDir, scripts) => this.resolveLazyScripts(componentDir, scripts),
-      createEcopagesJsxLazyEntryName,
-      isEcopagesJsxIntegration,
-      errors: {
-        invalidStylesheetEntry: DEPENDENCY_ERRORS.INVALID_STYLESHEET_ENTRY,
-        invalidScriptEntry: DEPENDENCY_ERRORS.INVALID_SCRIPT_ENTRY,
-        lazyScriptMissingSrc: DEPENDENCY_ERRORS.LAZY_SCRIPT_MISSING_SRC
-      }
-    });
-    const packagedDependencies = packagePageDependencies(dependencies, integrationName);
-    const hasLazyDependencies = packagedDependencies.some(
-      (dep) => dep.kind === "script" && dep.excludeFromHtml === true
-    );
-    const processedDependencies = await this.assetProcessingService.processDependencies(
-      packagedDependencies,
-      integrationName
-    );
-    const lazyKeyToOutputUrl = /* @__PURE__ */ new Map();
-    for (const dependency of processedDependencies) {
-      if (dependency.kind === "script" && dependency.srcUrl) {
-        const lazyKey = dependency.attributes?.["data-eco-lazy-key"];
-        if (lazyKey) {
-          lazyKeyToOutputUrl.set(lazyKey, dependency.srcUrl);
-        }
-      }
+export class DependencyResolverService {
+    appConfig;
+    assetProcessingService;
+    /**
+     * Creates the dependency resolver used by route and component rendering.
+     *
+     * @remarks
+     * The resolver stays intentionally separate from HTML rendering so component
+     * dependency collection, lazy trigger grouping, and processed-asset generation
+     * can evolve without changing renderer implementations.
+     */
+    constructor(appConfig, assetProcessingService) {
+        this.appConfig = appConfig;
+        this.assetProcessingService = assetProcessingService;
+    }
+    /**
+     * Resolves one dependency path relative to the component that declared it.
+     */
+    resolveDependencyPath(componentDir, pathUrl) {
+        return path.join(componentDir, pathUrl);
     }
-    for (const [config, lazyGroupsMap] of lazyScriptsByConfig.entries()) {
-      const rawGroups = [];
-      for (const group of lazyGroupsMap.values()) {
-        const resolvedUrls = group.scripts.map(({ lazyKey, fallbackUrl }) => lazyKeyToOutputUrl.get(lazyKey) ?? fallbackUrl).filter((url) => Boolean(url && url.length > 0));
-        if (resolvedUrls.length === 0) {
-          continue;
+    /**
+     * Maps lazy script source entries to deterministic fallback public URLs
+     * used when bundling output URLs are unavailable.
+     */
+    resolveLazyScripts(componentDir, scripts) {
+        return resolveLazyScripts(this.appConfig, componentDir, scripts);
+    }
+    /**
+     * Collects and processes component dependencies (styles, scripts, modules, lazy scripts).
+     * Lazy dependencies are always resolved into global-injector trigger maps.
+     */
+    async processComponentDependencies(components, integrationName) {
+        if (!this.assetProcessingService?.processDependencies)
+            return [];
+        const { dependencies, lazyScriptsByConfig } = collectComponentDependencies({
+            components,
+            integrationName,
+            resolveLazyScripts: (componentDir, scripts) => this.resolveLazyScripts(componentDir, scripts),
+            createEcopagesJsxLazyEntryName,
+            isEcopagesJsxIntegration,
+            errors: {
+                invalidStylesheetEntry: DEPENDENCY_ERRORS.INVALID_STYLESHEET_ENTRY,
+                invalidScriptEntry: DEPENDENCY_ERRORS.INVALID_SCRIPT_ENTRY,
+                lazyScriptMissingSrc: DEPENDENCY_ERRORS.LAZY_SCRIPT_MISSING_SRC,
+            },
+        });
+        const packagedDependencies = packagePageDependencies(dependencies, integrationName);
+        const hasLazyDependencies = packagedDependencies.some((dep) => dep.kind === 'script' && dep.excludeFromHtml === true);
+        const processedDependencies = await this.assetProcessingService.processDependencies(packagedDependencies, integrationName);
+        const lazyKeyToOutputUrl = new Map();
+        for (const dependency of processedDependencies) {
+            if (dependency.kind === 'script' && dependency.srcUrl) {
+                const lazyKey = dependency.attributes?.['data-eco-lazy-key'];
+                if (lazyKey) {
+                    lazyKeyToOutputUrl.set(lazyKey, dependency.srcUrl);
+                }
+            }
+        }
+        for (const [config, lazyGroupsMap] of lazyScriptsByConfig.entries()) {
+            const rawGroups = [];
+            for (const group of lazyGroupsMap.values()) {
+                const resolvedUrls = group.scripts
+                    .map(({ lazyKey, fallbackUrl }) => lazyKeyToOutputUrl.get(lazyKey) ?? fallbackUrl)
+                    .filter((url) => Boolean(url && url.length > 0));
+                if (resolvedUrls.length === 0) {
+                    continue;
+                }
+                rawGroups.push({ lazy: group.lazy, scripts: Array.from(new Set(resolvedUrls)) });
+            }
+            if (hasLazyDependencies) {
+                config._resolvedLazyTriggers = buildResolvedLazyTriggers(config, rawGroups);
+                config._resolvedLazyScripts = undefined;
+            }
         }
-        rawGroups.push({ lazy: group.lazy, scripts: Array.from(new Set(resolvedUrls)) });
-      }
-      if (hasLazyDependencies) {
-        config._resolvedLazyTriggers = buildResolvedLazyTriggers(config, rawGroups);
-        config._resolvedLazyScripts = void 0;
-      }
+        return processedDependencies;
     }
-    return processedDependencies;
-  }
 }
-export {
-  DEPENDENCY_ERRORS,
-  DependencyResolverService
-};

package/src/route-renderer/page-loading/ecopages-virtual-imports.js

@@ -1,62 +1,76 @@
-import { readFileSync } from "node:fs";
-import { parseSync } from "oxc-parser";
+import { readFileSync } from 'node:fs';
+import { parseSync } from 'oxc-parser';
+/** Matches `ecopages:content/<collection>/server` — SSR-only MDX resolver modules. */
 const CONTENT_SERVER_VIRTUAL_MODULE_PATTERN = /^ecopages:content\/[a-z][a-z0-9-]+\/server$/;
-function isBrowserEcopagesVirtualImport(specifier) {
-  return specifier.startsWith("ecopages:") && !CONTENT_SERVER_VIRTUAL_MODULE_PATTERN.test(specifier);
+/**
+ * @remarks
+ * Content server modules static-import every MDX entry. They must never become
+ * browser module-script dependencies discovered from page or component sources.
+ */
+export function isBrowserEcopagesVirtualImport(specifier) {
+    return specifier.startsWith('ecopages:') && !CONTENT_SERVER_VIRTUAL_MODULE_PATTERN.test(specifier);
 }
-function extractEcopagesVirtualImports(file) {
-  let source;
-  try {
-    source = readFileSync(file, "utf-8");
-  } catch {
-    return [];
-  }
-  let result;
-  try {
-    result = parseSync(file, source, { sourceType: "module" });
-  } catch {
-    return [];
-  }
-  const found = /* @__PURE__ */ new Map();
-  for (const node of result.program.body ?? []) {
-    if (node.type !== "ImportDeclaration") continue;
-    if (node.importKind === "type") continue;
-    const specifier = node.source?.value ?? "";
-    if (!isBrowserEcopagesVirtualImport(specifier)) continue;
-    if (found.get(specifier) === null) {
-      continue;
+/**
+ * Extracts runtime `ecopages:` virtual-module imports from a component source file.
+ *
+ * Type-only imports are skipped and bare namespace imports are represented by an
+ * `undefined` import list so downstream module generation can preserve that shape.
+ */
+export function extractEcopagesVirtualImports(file) {
+    let source;
+    try {
+        source = readFileSync(file, 'utf-8');
     }
-    const namedImports = [];
-    for (const spec of node.specifiers ?? []) {
-      if (spec.type === "ImportSpecifier") {
-        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);
-      }
+    catch {
+        return [];
     }
-    if (namedImports.length === 0) {
-      found.set(specifier, null);
-      continue;
+    let result;
+    try {
+        result = parseSync(file, source, { sourceType: 'module' });
     }
-    const existing = found.get(specifier);
-    if (!existing) {
-      found.set(specifier, new Set(namedImports));
-      continue;
+    catch {
+        return [];
     }
-    for (const imported of namedImports) {
-      existing.add(imported);
+    const found = new Map();
+    for (const node of result.program.body ?? []) {
+        if (node.type !== 'ImportDeclaration')
+            continue;
+        if (node.importKind === 'type')
+            continue;
+        const specifier = node.source?.value ?? '';
+        if (!isBrowserEcopagesVirtualImport(specifier))
+            continue;
+        if (found.get(specifier) === null) {
+            continue;
+        }
+        const namedImports = [];
+        for (const spec of node.specifiers ?? []) {
+            if (spec.type === 'ImportSpecifier') {
+                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);
+            }
+        }
+        if (namedImports.length === 0) {
+            found.set(specifier, null);
+            continue;
+        }
+        const existing = found.get(specifier);
+        if (!existing) {
+            found.set(specifier, new Set(namedImports));
+            continue;
+        }
+        for (const imported of namedImports) {
+            existing.add(imported);
+        }
     }
-  }
-  return Array.from(found.entries()).map(([from, importsSet]) => ({
-    from,
-    imports: importsSet ? Array.from(importsSet) : void 0
-  }));
+    return Array.from(found.entries()).map(([from, importsSet]) => ({
+        from,
+        imports: importsSet ? Array.from(importsSet) : undefined,
+    }));
 }
-export {
-  extractEcopagesVirtualImports,
-  isBrowserEcopagesVirtualImport
-};

package/src/route-renderer/page-loading/lazy-entry-collection.js

@@ -1,105 +1,82 @@
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
-import { rapidhash } from "../../utils/hash.js";
-import { getLazyTriggerKey } from "./lazy-trigger-planning.js";
+import { AssetFactory } from '../../services/assets/asset-processing-service/index.js';
+import { rapidhash } from '../../utils/hash.js';
+import { getLazyTriggerKey } from './lazy-trigger-planning.js';
 function isDependencyEntryObject(entry) {
-  return typeof entry === "object" && entry !== null;
+    return typeof entry === 'object' && entry !== null;
 }
 function getDependencyEntrySrcOrThrow(entry, errorMessage) {
-  if (!entry.src) {
-    throw new Error(errorMessage);
-  }
-  return entry.src;
-}
-function collectLazyScriptEntries(options) {
-  const {
-    scriptEntries,
-    componentFile,
-    componentDir,
-    integrationName,
-    dependencies,
-    lazyDependencyKeys,
-    registerLazyScript,
-    resolveDependencyPath,
-    resolveLazyScripts,
-    createModuleScriptAttributes,
-    createEcopagesJsxLazyEntryName,
-    pushUniqueDependency,
-    getLazyScriptMissingSrcMessage,
-    isEcopagesJsxIntegration
-  } = options;
-  for (const [index, scriptEntry] of scriptEntries.entries()) {
-    if (!isDependencyEntryObject(scriptEntry) || !scriptEntry.lazy) {
-      continue;
-    }
-    const lazy = scriptEntry.lazy;
-    const content = scriptEntry.content;
-    const src = scriptEntry.src;
-    const attributes = scriptEntry.attributes;
-    if (content) {
-      const lazyKey2 = `lazy:${rapidhash(`${componentFile}:entry:${index}:${content}`).toString(16)}`;
-      const depKey2 = `lazy:entry:content:${getLazyTriggerKey(lazy)}:${content}:${JSON.stringify(attributes ?? {})}`;
-      pushUniqueDependency(
-        lazyDependencyKeys,
-        depKey2,
-        dependencies,
-        AssetFactory.createContentScript({
-          position: "head",
-          content,
-          excludeFromHtml: true,
-          attributes: {
-            ...createModuleScriptAttributes(attributes),
-            "data-eco-lazy-key": lazyKey2
-          }
-        })
-      );
-      registerLazyScript({
-        lazy,
-        lazyKey: lazyKey2
-      });
-      continue;
+    if (!entry.src) {
+        throw new Error(errorMessage);
     }
-    const script = src ?? getDependencyEntrySrcOrThrow(scriptEntry, getLazyScriptMissingSrcMessage());
-    const resolvedPath = resolveDependencyPath(componentDir, script);
-    const fallbackUrl = resolveLazyScripts(componentDir, [script]).split(",")[0] ?? "";
-    const lazyKey = `lazy:${rapidhash(`${resolvedPath}:${getLazyTriggerKey(lazy)}`).toString(16)}`;
-    const lazyEntryName = createEcopagesJsxLazyEntryName(
-      integrationName,
-      `${resolvedPath}:${getLazyTriggerKey(lazy)}`
-    );
-    const depKey = `lazy:entry:file:${getLazyTriggerKey(lazy)}:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
-    pushUniqueDependency(
-      lazyDependencyKeys,
-      depKey,
-      dependencies,
-      isEcopagesJsxIntegration(integrationName) ? AssetFactory.createContentScript({
-        name: lazyEntryName,
-        position: "head",
-        content: `import ${JSON.stringify(resolvedPath)};`,
-        excludeFromHtml: true,
-        bundleOptions: {
-          splitting: false
-        },
-        attributes: {
-          ...createModuleScriptAttributes(attributes),
-          "data-eco-lazy-key": lazyKey
+    return entry.src;
+}
+/**
+ * Collects lazy script dependency entries and emits their hidden bundle inputs.
+ *
+ * This helper also reports the trigger-to-script relationship back to the caller so
+ * later stages can build the lazy-trigger manifest without reparsing dependency config.
+ */
+export function collectLazyScriptEntries(options) {
+    const { scriptEntries, componentFile, componentDir, integrationName, dependencies, lazyDependencyKeys, registerLazyScript, resolveDependencyPath, resolveLazyScripts, createModuleScriptAttributes, createEcopagesJsxLazyEntryName, pushUniqueDependency, getLazyScriptMissingSrcMessage, isEcopagesJsxIntegration, } = options;
+    for (const [index, scriptEntry] of scriptEntries.entries()) {
+        if (!isDependencyEntryObject(scriptEntry) || !scriptEntry.lazy) {
+            continue;
         }
-      }) : AssetFactory.createFileScript({
-        filepath: resolvedPath,
-        position: "head",
-        excludeFromHtml: true,
-        attributes: {
-          ...createModuleScriptAttributes(attributes),
-          "data-eco-lazy-key": lazyKey
+        const lazy = scriptEntry.lazy;
+        const content = scriptEntry.content;
+        const src = scriptEntry.src;
+        const attributes = scriptEntry.attributes;
+        if (content) {
+            const lazyKey = `lazy:${rapidhash(`${componentFile}:entry:${index}:${content}`).toString(16)}`;
+            const depKey = `lazy:entry:content:${getLazyTriggerKey(lazy)}:${content}:${JSON.stringify(attributes ?? {})}`;
+            pushUniqueDependency(lazyDependencyKeys, depKey, dependencies, AssetFactory.createContentScript({
+                position: 'head',
+                content,
+                excludeFromHtml: true,
+                attributes: {
+                    ...createModuleScriptAttributes(attributes),
+                    'data-eco-lazy-key': lazyKey,
+                },
+            }));
+            registerLazyScript({
+                lazy,
+                lazyKey,
+            });
+            continue;
         }
-      })
-    );
-    registerLazyScript({
-      lazy,
-      lazyKey,
-      fallbackUrl
-    });
-  }
+        const script = src ?? getDependencyEntrySrcOrThrow(scriptEntry, getLazyScriptMissingSrcMessage());
+        const resolvedPath = resolveDependencyPath(componentDir, script);
+        const fallbackUrl = resolveLazyScripts(componentDir, [script]).split(',')[0] ?? '';
+        const lazyKey = `lazy:${rapidhash(`${resolvedPath}:${getLazyTriggerKey(lazy)}`).toString(16)}`;
+        const lazyEntryName = createEcopagesJsxLazyEntryName(integrationName, `${resolvedPath}:${getLazyTriggerKey(lazy)}`);
+        const depKey = `lazy:entry:file:${getLazyTriggerKey(lazy)}:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
+        pushUniqueDependency(lazyDependencyKeys, depKey, dependencies, isEcopagesJsxIntegration(integrationName)
+            ? AssetFactory.createContentScript({
+                name: lazyEntryName,
+                position: 'head',
+                content: `import ${JSON.stringify(resolvedPath)};`,
+                excludeFromHtml: true,
+                bundleOptions: {
+                    splitting: false,
+                },
+                attributes: {
+                    ...createModuleScriptAttributes(attributes),
+                    'data-eco-lazy-key': lazyKey,
+                },
+            })
+            : AssetFactory.createFileScript({
+                filepath: resolvedPath,
+                position: 'head',
+                excludeFromHtml: true,
+                attributes: {
+                    ...createModuleScriptAttributes(attributes),
+                    'data-eco-lazy-key': lazyKey,
+                },
+            }));
+        registerLazyScript({
+            lazy,
+            lazyKey,
+            fallbackUrl,
+        });
+    }
 }
-export {
-  collectLazyScriptEntries
-};

package/src/route-renderer/page-loading/lazy-trigger-planning.js

@@ -1,40 +1,50 @@
-import { rapidhash } from "../../utils/hash.js";
-function getLazyTriggerKey(lazy) {
-  if ("on:idle" in lazy) {
-    return "on:idle";
-  }
-  if ("on:interaction" in lazy) {
-    return `on:interaction:${lazy["on:interaction"]}`;
-  }
-  if ("on:visible" in lazy) {
-    const value = lazy["on:visible"];
-    return `on:visible:${value === true ? "true" : value}`;
-  }
-  return JSON.stringify(lazy);
-}
-function buildResolvedLazyTriggers(config, groups) {
-  if (groups.length === 0) return [];
-  const componentFile = config.__eco?.file ?? "";
-  const sortedUrls = groups.flatMap((group) => group.scripts).sort().join(",");
-  const triggerId = `eco-trigger-${rapidhash(`${componentFile}:${sortedUrls}`).toString(16)}`;
-  const rules = groups.map((group) => {
-    const { scripts, lazy } = group;
-    if ("on:idle" in lazy) {
-      return { "on:idle": { scripts } };
+import { rapidhash } from '../../utils/hash.js';
+/**
+ * Creates a stable grouping key for a lazy trigger declaration.
+ */
+export function getLazyTriggerKey(lazy) {
+    if ('on:idle' in lazy) {
+        return 'on:idle';
     }
-    if ("on:interaction" in lazy) {
-      return { "on:interaction": { value: lazy["on:interaction"], scripts } };
+    if ('on:interaction' in lazy) {
+        return `on:interaction:${lazy['on:interaction']}`;
     }
-    if ("on:visible" in lazy) {
-      const visibleSelector = lazy["on:visible"];
-      if (visibleSelector === true) return { "on:visible": { scripts } };
-      return { "on:visible": { value: String(visibleSelector), scripts } };
+    if ('on:visible' in lazy) {
+        const value = lazy['on:visible'];
+        return `on:visible:${value === true ? 'true' : value}`;
     }
-    throw new Error(`Unknown lazy trigger kind: ${JSON.stringify(lazy)}`);
-  });
-  return [{ triggerId, rules }];
+    return JSON.stringify(lazy);
+}
+/**
+ * Derives the public lazy-trigger manifest attached to a component config.
+ *
+ * The generated `triggerId` is stable for the same component file and set of
+ * resolved script URLs, independent of declaration order.
+ */
+export function buildResolvedLazyTriggers(config, groups) {
+    if (groups.length === 0)
+        return [];
+    const componentFile = config.__eco?.file ?? '';
+    const sortedUrls = groups
+        .flatMap((group) => group.scripts)
+        .sort()
+        .join(',');
+    const triggerId = `eco-trigger-${rapidhash(`${componentFile}:${sortedUrls}`).toString(16)}`;
+    const rules = groups.map((group) => {
+        const { scripts, lazy } = group;
+        if ('on:idle' in lazy) {
+            return { 'on:idle': { scripts } };
+        }
+        if ('on:interaction' in lazy) {
+            return { 'on:interaction': { value: lazy['on:interaction'], scripts } };
+        }
+        if ('on:visible' in lazy) {
+            const visibleSelector = lazy['on:visible'];
+            if (visibleSelector === true)
+                return { 'on:visible': { scripts } };
+            return { 'on:visible': { value: String(visibleSelector), scripts } };
+        }
+        throw new Error(`Unknown lazy trigger kind: ${JSON.stringify(lazy)}`);
+    });
+    return [{ triggerId, rules }];
 }
-export {
-  buildResolvedLazyTriggers,
-  getLazyTriggerKey
-};