@ecopages/core 0.2.0-rc.4 → 0.2.0-rc.5

package/src/index.js

@@ -1,7 +1,10 @@
 export { eco } from './eco/eco.js';
 export { defineApiHandler, defineGroupHandler, defineGet, definePost, definePut, defineDelete, definePatch, defineOptions, defineHead, json, html, redirect, } from './adapters/shared/http/define-api-handler.js';
 export { createEcoBuildPluginFromSourceTransform, createVitePluginsFromAppSourceTransforms, getAppSourceTransforms, createVitePluginFromSourceTransform, normalizeTransformId, } from './plugins/source-transform.js';
-export { createEcoComponentMetaTransform } from './plugins/eco-component-meta-plugin.js';
+export { attributeComponentIdentity, attributeMdxComponentIdentity, createEcoComponentMetaTransform, } from './plugins/eco-component-meta-plugin.js';
 export { bindComponentIdentity, getComponentIdentity } from './eco/component-identity.js';
+export { attachDiscoveredDependencies, registerDiscoveredDependencies, getInferredStylesheets, } from './eco/discovered-dependencies.js';
+export { listFileOwnedDependencyContributions, mergePageDependencies } from './eco/page-dependency-contributions.js';
+export { mergeLayoutDependencies } from './eco/page-layout-normalization.js';
 export { SchemaError, validateStandardSchema } from './services/validation/validate-standard-schema.js';
 export { buildIslandHostAttributes, ECO_ISLAND_HOST_ATTRIBUTE, ECO_ISLAND_INTEGRATION_ATTRIBUTE, finalizeIslandComponentRender, isIslandHostElement, mergeIslandHostAttributes, } from './islands/island-host.js';

package/src/plugins/README.md

@@ -20,7 +20,8 @@ These contracts are responsible for:
 - `processor.ts`: asset-transformation contract for processors, including generated `@types` package helpers for virtual modules
 - `runtime-capability.ts`: runtime compatibility declaration types
 - `source-transform.ts`: bundler-neutral source-transform primitive with Ecopages adapters plus app-level Vite plugin composition helpers
-- `eco-component-meta-plugin.ts`: component-identity attribution transform that uses a lexical `eco.` gate, then an Oxc `CallExpression` rewrite
+- `component-import-discovery.ts`: resolves direct local factory exports, named `export { X } from` barrels (imported binding only), relative CSS imports, and aliased CSS imports; records successful named re-export hops as watch files; excludes `export *`, type imports, package imports, and ordinary helpers.
+- `eco-component-meta-plugin.ts`: component-identity attribution transform for `eco.*()` factories and `attributeMdxComponentIdentity` for compiled MDX modules
 
 ## Ownership Rules
 
@@ -28,6 +29,7 @@ These contracts are responsible for:
 - Processors own asset semantics, cache ownership, and processor-specific watch behavior.
 - Core owns lifecycle ordering, startup orchestration, and manifest assembly.
 - The transform wraps native `eco.page()`, `eco.component()`, `eco.layout()`, and `eco.html()` factory options with `bindComponentIdentity()`. Factories retain the resulting `options.identity` on `config`, and runtime consumers read it through `getComponentIdentity()`. Browser, HMR, and server builds use the same source transform, so ownership and dependency diagnostics retain stable file attribution without a loader duplicate.
+- MDX modules compiled by `@ecopages/mdx/core` use `attributeMdxComponentIdentity()` to strip bare CSS imports, attach live component accessors to `config.dependencies`, keep inferred stylesheets on identity, and assign `MDXContent.config = config`. The loader requires `projectRoot` from app config. Markdown code blocks and dynamic imports within functions are distinguished and left unaffected.
 
 ## Lifecycle Summary
 
@@ -35,3 +37,7 @@ These contracts are responsible for:
 2. Core seals the app-owned build manifest.
 3. Runtime startup calls runtime-only setup hooks.
 4. Request-time rendering and development invalidation reuse those finalized contracts.
+
+## Discovered dependency metadata
+
+The identity transform passes a deferred Component accessor and resolved stylesheet paths to `bindComponentIdentity`. Factories attach the deferred Component accessor to `config.dependencies`; inferred stylesheets stay keyed by identity for the collector. Import bindings are read during graph traversal, after module initialization. Supported relative and aliased CSS imports are removed from all transformed outputs so the asset pipeline owns CSS delivery. Explicit styles override discovery. Discovery follows named `export { X } from` barrels for the imported binding only. Successful named re-export hops are recorded as watch files on the discovering identity so a barrel retarget invalidates HTML and Page Browser Graph caches without editing the importing Page. It does not follow `export *`, dynamic imports, namespace imports, package Components/CSS, CSS Modules, or custom import attributes. The transform uses the same discovery rules in Bun and Vite/Rolldown. Imported source changes are reparsed through the content-keyed parser cache.

package/src/plugins/component-import-discovery.d.ts

@@ -0,0 +1,19 @@
+export type DiscoveredImports = {
+    components: string[];
+    stylesheets: string[];
+    watchFiles: string[];
+    removals: Array<{
+        start: number;
+        end: number;
+        replacement: string;
+    }>;
+};
+/**
+ * Discovers local Eco Component imports and relative or aliased side-effect CSS.
+ *
+ * @remarks
+ * Named `export { X } from` barrels are followed for the imported binding only.
+ * Successful re-export hops are recorded in `watchFiles` so barrel edits invalidate caches.
+ * `export *`, dynamic imports, namespace imports, packages, and `.server` modules are not.
+ */
+export declare function discoverComponentImports(program: unknown, ownerFile: string, projectRoot: string): DiscoveredImports;

package/src/plugins/component-import-discovery.js

@@ -0,0 +1,203 @@
+import path from 'node:path';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { cachedParseSync } from '../cache/module-parse-cache.js';
+import { loadTsconfigPathPrefixes, matchesTsconfigPathPrefix, resolveProjectModulePath, } from './tsconfig-import-resolver.js';
+function node(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function nodes(value) {
+    return Array.isArray(value) ? value.map(node).filter((value) => value !== undefined) : [];
+}
+function identifierName(value) {
+    const named = node(value);
+    if (typeof named?.name === 'string')
+        return named.name;
+    if (typeof named?.value === 'string')
+        return named.value;
+    return undefined;
+}
+function isFactory(value) {
+    const call = node(value);
+    const callee = node(call?.callee);
+    return (call?.type === 'CallExpression' &&
+        callee?.type === 'MemberExpression' &&
+        node(callee.object)?.name === 'eco' &&
+        ['component', 'layout', 'html'].includes(String(node(callee.property)?.name)));
+}
+function isServerSpecifier(source) {
+    return /\.server(?:\.[cm]?[jt]sx?)?$/.test(source);
+}
+/**
+ * Indexes local `eco.*()` factory exports and named `export { X } from` re-exports.
+ *
+ * @remarks
+ * `export *` is ignored so a barrel cannot pull an entire kit into the graph.
+ */
+function indexModuleExports(file, cache) {
+    const cached = cache.get(file);
+    if (cached)
+        return cached;
+    const source = readFileSync(file, 'utf8');
+    const parsed = cachedParseSync(file, source, { sourceType: 'module' });
+    const body = nodes(parsed.program.body);
+    const declared = new Set();
+    const factories = new Set();
+    const namedReexports = new Map();
+    for (const statement of body) {
+        const declaration = statement.type === 'ExportNamedDeclaration' ? node(statement.declaration) : statement;
+        for (const variable of nodes(declaration?.declarations)) {
+            const name = identifierName(variable.id);
+            if (typeof name === 'string' && isFactory(variable.init)) {
+                declared.add(name);
+                if (statement.type === 'ExportNamedDeclaration')
+                    factories.add(name);
+            }
+        }
+        if (statement.type === 'ExportDefaultDeclaration' && isFactory(statement.declaration))
+            factories.add('default');
+    }
+    for (const statement of body) {
+        if (statement.type === 'ExportDefaultDeclaration' &&
+            declared.has(String(identifierName(statement.declaration)))) {
+            factories.add('default');
+        }
+        if (statement.type !== 'ExportNamedDeclaration' || statement.exportKind === 'type')
+            continue;
+        const from = node(statement.source)?.value;
+        if (typeof from === 'string') {
+            for (const specifier of nodes(statement.specifiers)) {
+                if (specifier.exportKind === 'type')
+                    continue;
+                const exported = identifierName(specifier.exported);
+                const imported = identifierName(specifier.local) ?? exported;
+                if (exported && imported)
+                    namedReexports.set(exported, { source: from, imported });
+            }
+            continue;
+        }
+        for (const specifier of nodes(statement.specifiers)) {
+            if (specifier.exportKind !== 'type' && declared.has(String(identifierName(specifier.local)))) {
+                const exported = identifierName(specifier.exported);
+                if (exported)
+                    factories.add(exported);
+            }
+        }
+    }
+    const indexed = { factories, namedReexports };
+    cache.set(file, indexed);
+    return indexed;
+}
+/**
+ * True when `exportName` is an `eco.*()` factory, including through named barrel re-exports.
+ *
+ * @remarks
+ * Completed answers are memoized on `resolved`. `path` is only the current walk, so a
+ * second alias of the same Component is not treated as a cycle miss.
+ */
+function isFactoryExport(file, exportName, projectRoot, pathPrefixes, state) {
+    const visitKey = `${file}\0${exportName}`;
+    const known = state.resolved.get(visitKey);
+    if (known !== undefined)
+        return known;
+    if (state.path.has(visitKey))
+        return false;
+    state.path.add(visitKey);
+    let result = false;
+    if (!file.includes(`${path.sep}node_modules${path.sep}`) && !isServerSpecifier(file)) {
+        const { factories, namedReexports } = indexModuleExports(file, state.moduleIndex);
+        if (factories.has(exportName)) {
+            result = true;
+        }
+        else {
+            const reexport = namedReexports.get(exportName);
+            if (reexport &&
+                !isServerSpecifier(reexport.source) &&
+                (reexport.source.startsWith('.') || matchesTsconfigPathPrefix(reexport.source, pathPrefixes))) {
+                const resolved = resolveProjectModulePath(projectRoot, file, reexport.source, { preserveBarrel: true });
+                if (!resolved) {
+                    throw new Error(`[ecopages] Cannot resolve import ${JSON.stringify(reexport.source)} from ${file}`);
+                }
+                if (/\.[jt]sx?$/.test(resolved) && !resolved.includes(`${path.sep}node_modules${path.sep}`)) {
+                    result = isFactoryExport(resolved, reexport.imported, projectRoot, pathPrefixes, state);
+                    if (result)
+                        state.watchFiles.add(file);
+                }
+            }
+        }
+    }
+    state.path.delete(visitKey);
+    state.resolved.set(visitKey, result);
+    return result;
+}
+function isCssImport(source) {
+    return source.endsWith('.css') && !source.endsWith('.module.css');
+}
+/**
+ * Discovers local Eco Component imports and relative or aliased side-effect CSS.
+ *
+ * @remarks
+ * Named `export { X } from` barrels are followed for the imported binding only.
+ * Successful re-export hops are recorded in `watchFiles` so barrel edits invalidate caches.
+ * `export *`, dynamic imports, namespace imports, packages, and `.server` modules are not.
+ */
+export function discoverComponentImports(program, ownerFile, projectRoot) {
+    const result = { components: [], stylesheets: [], watchFiles: [], removals: [] };
+    const pathPrefixes = loadTsconfigPathPrefixes(projectRoot);
+    const factoryState = {
+        moduleIndex: new Map(),
+        resolved: new Map(),
+        watchFiles: new Set(),
+    };
+    for (const statement of nodes(node(program)?.body)) {
+        if (statement.type !== 'ImportDeclaration' || statement.importKind === 'type')
+            continue;
+        if (nodes(statement.attributes).length || nodes(statement.assertions).length)
+            continue;
+        const source = node(statement.source)?.value;
+        if (typeof source !== 'string')
+            continue;
+        const specifiers = nodes(statement.specifiers);
+        if (isCssImport(source) && !specifiers.length) {
+            const isRelative = source.startsWith('.');
+            const isAlias = matchesTsconfigPathPrefix(source, pathPrefixes);
+            if (isRelative || isAlias) {
+                const resolved = isRelative
+                    ? existsSync(path.resolve(path.dirname(ownerFile), source))
+                        ? realpathSync(path.resolve(path.dirname(ownerFile), source))
+                        : undefined
+                    : resolveProjectModulePath(projectRoot, ownerFile, source, { preserveBarrel: true });
+                if (!resolved || !existsSync(resolved)) {
+                    throw new Error(`[ecopages] Cannot resolve stylesheet import ${JSON.stringify(source)} from ${ownerFile}`);
+                }
+                result.stylesheets.push(resolved);
+                result.removals.push({ start: statement.start, end: statement.end, replacement: '' });
+                continue;
+            }
+        }
+        const values = specifiers.filter((entry) => entry.importKind !== 'type' &&
+            (entry.type === 'ImportSpecifier' || entry.type === 'ImportDefaultSpecifier'));
+        if (!values.length || (!source.startsWith('.') && !matchesTsconfigPathPrefix(source, pathPrefixes)))
+            continue;
+        if (isServerSpecifier(source))
+            continue;
+        const resolved = resolveProjectModulePath(projectRoot, ownerFile, source, { preserveBarrel: true });
+        if (!resolved)
+            throw new Error(`[ecopages] Cannot resolve import ${JSON.stringify(source)} from ${ownerFile}`);
+        if (!/\.[jt]sx?$/.test(resolved) || resolved.includes(`${path.sep}node_modules${path.sep}`))
+            continue;
+        for (const specifier of values) {
+            const imported = specifier.type === 'ImportDefaultSpecifier' ? 'default' : identifierName(specifier.imported);
+            const local = identifierName(specifier.local);
+            if (typeof local === 'string' &&
+                imported &&
+                isFactoryExport(resolved, imported, projectRoot, pathPrefixes, {
+                    ...factoryState,
+                    path: new Set(),
+                })) {
+                result.components.push(local);
+            }
+        }
+    }
+    result.watchFiles.push(...factoryState.watchFiles);
+    return result;
+}

package/src/plugins/eco-component-meta-plugin.d.ts

@@ -5,7 +5,9 @@ export interface EcoComponentDirPluginOptions {
     config: EcoPagesAppConfig;
 }
 /** Attributes real `eco.*()` factory calls with canonical component identity. */
-export declare function attributeComponentIdentity(contents: string, filePath: string, integration: string): string;
+export declare function attributeComponentIdentity(contents: string, filePath: string, integration: string, projectRoot?: string): string;
+/** Attributes compiled MDX module with canonical component identity and discovered dependencies. */
+export declare function attributeMdxComponentIdentity(contents: string, filePath: string, integration: string, projectRoot: string): string;
 export declare function createEcoComponentMetaTransform(options: EcoComponentDirPluginOptions): EcoSourceTransform;
 export declare function createEcoComponentMetaVitePlugin(options: EcoComponentDirPluginOptions): EcoViteCompatiblePlugin;
 export declare function createEcoComponentMetaPlugin(options: EcoComponentDirPluginOptions): EcoBuildPlugin;

package/src/plugins/eco-component-meta-plugin.js

@@ -2,6 +2,7 @@ import { prependJsxImportSourceIfMissing } from './jsx-import-source.utils.js';
 import { createEcoBuildPluginFromSourceTransform, createVitePluginFromSourceTransform } from './source-transform.js';
 import { cachedParseSync } from '../cache/module-parse-cache.js';
 import { rapidhash } from '../utils/hash.js';
+import { discoverComponentImports } from './component-import-discovery.js';
 function integrationForFile(filePath, config) {
     const candidates = config.integrations
         .flatMap((integration) => integration.extensions.map((extension) => [extension, integration]))
@@ -12,6 +13,12 @@ function integrationForFile(filePath, config) {
 function isAstNode(value) {
     return typeof value === 'object' && value !== null;
 }
+function node(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function nodes(value) {
+    return Array.isArray(value) ? value.map(node).filter((value) => value !== undefined) : [];
+}
 function isEcoFactoryCall(node) {
     if (node.type !== 'CallExpression' || !isAstNode(node.callee))
         return false;
@@ -41,36 +48,52 @@ function walkAst(node, visit) {
     for (const value of Object.values(node))
         walkAst(value, visit);
 }
-function addIdentityBindingImport(contents, program) {
+function addNamedImport(contents, program, sourceModule, importedName) {
+    const importedNames = typeof importedName === 'string' ? [importedName] : [...importedName];
     const imports = program.body.filter((node) => isAstNode(node) &&
         node.type === 'ImportDeclaration' &&
         isAstNode(node.source) &&
-        node.source.value === '@ecopages/core');
+        node.source.value === sourceModule);
     const valueImport = imports.find((node) => node.importKind !== 'type');
     if (!valueImport)
-        return `import { bindComponentIdentity } from '@ecopages/core';\n${contents}`;
+        return `import { ${importedNames.join(', ')} } from '${sourceModule}';\n${contents}`;
     const specifiers = Array.isArray(valueImport.specifiers) ? valueImport.specifiers.filter(isAstNode) : [];
-    if (specifiers.some((specifier) => specifier.type === 'ImportSpecifier' &&
-        isAstNode(specifier.imported) &&
-        specifier.imported.name === 'bindComponentIdentity')) {
+    const existingNames = new Set(specifiers.flatMap((specifier) => {
+        if (specifier.type !== 'ImportSpecifier' || !isAstNode(specifier.imported))
+            return [];
+        const name = specifier.imported.name ?? specifier.imported.value;
+        return typeof name === 'string' ? [name] : [];
+    }));
+    const missing = importedNames.filter((name) => !existingNames.has(name));
+    if (missing.length === 0) {
         return contents;
     }
     const namedSpecifiers = specifiers.filter((specifier) => specifier.type === 'ImportSpecifier');
     if (namedSpecifiers.length > 0) {
         const lastSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
-        return `${contents.slice(0, lastSpecifier.end)}, bindComponentIdentity${contents.slice(lastSpecifier.end)}`;
+        return `${contents.slice(0, lastSpecifier.end)}, ${missing.join(', ')}${contents.slice(lastSpecifier.end)}`;
     }
     if (specifiers.some((specifier) => specifier.type === 'ImportNamespaceSpecifier')) {
-        return `import { bindComponentIdentity } from '@ecopages/core';\n${contents}`;
+        return `import { ${missing.join(', ')} } from '${sourceModule}';\n${contents}`;
     }
     const defaultSpecifier = specifiers.find((specifier) => specifier.type === 'ImportDefaultSpecifier');
     if (defaultSpecifier) {
-        return `${contents.slice(0, defaultSpecifier.end)}, { bindComponentIdentity }${contents.slice(defaultSpecifier.end)}`;
+        return `${contents.slice(0, defaultSpecifier.end)}, { ${missing.join(', ')} }${contents.slice(defaultSpecifier.end)}`;
+    }
+    return `import { ${missing.join(', ')} } from '${sourceModule}';\n${contents}`;
+}
+function addIdentityBindingImport(contents, program) {
+    return addNamedImport(contents, program, '@ecopages/core', 'bindComponentIdentity');
+}
+function serializeDiscoveryArgument(discovered) {
+    if (!discovered || (discovered.components.length === 0 && discovered.stylesheets.length === 0)) {
+        return '';
     }
-    return `import { bindComponentIdentity } from '@ecopages/core';\n${contents}`;
+    const watchFiles = discovered.watchFiles.length > 0 ? `, watchFiles: ${JSON.stringify(discovered.watchFiles)}` : '';
+    return `, { components: () => [${discovered.components.join(', ')}], stylesheets: ${JSON.stringify(discovered.stylesheets)}${watchFiles} }`;
 }
 /** Attributes real `eco.*()` factory calls with canonical component identity. */
-export function attributeComponentIdentity(contents, filePath, integration) {
+export function attributeComponentIdentity(contents, filePath, integration, projectRoot) {
     if (!contents.includes('eco.'))
         return contents;
     let program;
@@ -82,6 +105,13 @@ export function attributeComponentIdentity(contents, filePath, integration) {
     }
     const identityLiteral = `{ id: ${JSON.stringify(rapidhash(filePath).toString(36))}, file: ${JSON.stringify(filePath)}, integration: ${JSON.stringify(integration)} }`;
     const edits = [];
+    let hasFactory = false;
+    walkAst(program, (node) => {
+        if (isEcoFactoryCall(node))
+            hasFactory = true;
+    });
+    const discovered = hasFactory && projectRoot ? discoverComponentImports(program, filePath, projectRoot) : undefined;
+    const discoveryArgument = serializeDiscoveryArgument(discovered);
     walkAst(program, (node) => {
         if (!isEcoFactoryCall(node) || !Array.isArray(node.arguments))
             return;
@@ -93,16 +123,73 @@ export function attributeComponentIdentity(contents, filePath, integration) {
         edits.push({
             start: firstArgument.start,
             end: firstArgument.end,
-            replacement: `bindComponentIdentity(${identityLiteral}, ${contents.slice(firstArgument.start, firstArgument.end)})`,
+            replacement: `bindComponentIdentity(${identityLiteral}, ${contents.slice(firstArgument.start, firstArgument.end)}${discoveryArgument})`,
         });
     });
     if (edits.length === 0)
         return contents;
+    edits.push(...(discovered?.removals ?? []));
     let transformed = contents;
     for (const edit of edits.sort((left, right) => right.start - left.start)) {
         transformed = `${transformed.slice(0, edit.start)}${edit.replacement}${transformed.slice(edit.end)}`;
     }
-    return addIdentityBindingImport(transformed, program);
+    return addIdentityBindingImport(transformed, cachedParseSync(filePath, transformed, { sourceType: 'module' }).program);
+}
+/** Attributes compiled MDX module with canonical component identity and discovered dependencies. */
+export function attributeMdxComponentIdentity(contents, filePath, integration, projectRoot) {
+    if (!projectRoot) {
+        throw new Error(`[ecopages] Cannot process MDX dependencies for "${filePath}": projectRoot is required.`);
+    }
+    let program;
+    try {
+        program = cachedParseSync(filePath, contents, { lang: 'jsx', sourceType: 'module' })
+            .program;
+    }
+    catch {
+        return contents;
+    }
+    let configDeclarator;
+    for (const statement of nodes(program?.body)) {
+        if (statement.type === 'ExportNamedDeclaration' && statement.declaration) {
+            const decl = node(statement.declaration);
+            if (decl?.type === 'VariableDeclaration') {
+                for (const declarator of nodes(decl.declarations)) {
+                    if (node(declarator.id)?.name === 'config') {
+                        configDeclarator = declarator;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (configDeclarator && isIdentityBinding(configDeclarator.init)) {
+        return contents;
+    }
+    const discovered = discoverComponentImports(program, filePath, projectRoot);
+    const identityLiteral = `{ id: ${JSON.stringify(rapidhash(filePath).toString(36))}, file: ${JSON.stringify(filePath)}, integration: ${JSON.stringify(integration)} }`;
+    const discoveryArgument = serializeDiscoveryArgument(discovered);
+    const edits = [...discovered.removals];
+    if (configDeclarator && isAstNode(configDeclarator.init)) {
+        const init = configDeclarator.init;
+        if (typeof init.start === 'number' && typeof init.end === 'number') {
+            edits.push({
+                start: init.start,
+                end: init.end,
+                replacement: `bindComponentIdentity(${identityLiteral}, ${contents.slice(init.start, init.end)}${discoveryArgument})`,
+            });
+        }
+    }
+    let appended = '';
+    if (!configDeclarator) {
+        appended += `\nexport const config = bindComponentIdentity(${identityLiteral}, {}${discoveryArgument});\n`;
+    }
+    appended += `attachDiscoveredDependencies(config);\nif (typeof MDXContent === 'function') MDXContent.config = config;\n`;
+    let transformed = contents;
+    for (const edit of edits.sort((left, right) => right.start - left.start)) {
+        transformed = `${transformed.slice(0, edit.start)}${edit.replacement}${transformed.slice(edit.end)}`;
+    }
+    transformed = `${transformed}\n${appended}`;
+    return addNamedImport(transformed, cachedParseSync(filePath, transformed, { lang: 'jsx', sourceType: 'module' }).program, '@ecopages/core', ['bindComponentIdentity', 'attachDiscoveredDependencies']);
 }
 export function createEcoComponentMetaTransform(options) {
     const extensions = options.config.integrations
@@ -115,14 +202,12 @@ export function createEcoComponentMetaTransform(options) {
         enforce: 'pre',
         filter,
         transform(code, id) {
-            if (id.endsWith('.mdx'))
-                return { code };
             const integration = integrationForFile(id, options.config);
             if (!integration) {
                 return { code };
             }
             return {
-                code: prependJsxImportSourceIfMissing(attributeComponentIdentity(code, id, integration.name), integration.jsxImportSource),
+                code: prependJsxImportSourceIfMissing(attributeComponentIdentity(code, id, integration.name, options.config.rootDir), integration.jsxImportSource),
             };
         },
     };

package/src/plugins/tsconfig-import-resolver.d.ts

@@ -30,7 +30,9 @@ export declare function resolveRelativeModulePath(fromFile: string, specifier: s
 /**
  * Resolves a relative or tsconfig path alias import (via oxc-resolver).
  */
-export declare function resolveProjectModulePath(projectRoot: string, fromFile: string, specifier: string): string | undefined;
+export declare function resolveProjectModulePath(projectRoot: string, fromFile: string, specifier: string, options?: {
+    preserveBarrel?: boolean;
+}): string | undefined;
 /**
  * Resolves a TS path alias import using the app's tsconfig `paths` (via oxc-resolver).
  */

package/src/plugins/tsconfig-import-resolver.js

@@ -232,7 +232,7 @@ export function resolveRelativeModulePath(fromFile, specifier) {
 /**
  * Resolves a relative or tsconfig path alias import (via oxc-resolver).
  */
-export function resolveProjectModulePath(projectRoot, fromFile, specifier) {
+export function resolveProjectModulePath(projectRoot, fromFile, specifier, options) {
     const prefixes = loadTsconfigPathPrefixes(projectRoot);
     const isRelative = specifier.startsWith('.');
     const isPathAlias = matchesTsconfigPathPrefix(specifier, prefixes);
@@ -243,7 +243,9 @@ export function resolveProjectModulePath(projectRoot, fromFile, specifier) {
     if (resolver) {
         const result = resolver.sync(path.dirname(fromFile), specifier);
         if (result.path) {
-            return resolveAliasedBarrelTarget(realpathSync(result.path));
+            return options?.preserveBarrel
+                ? realpathSync(result.path)
+                : resolveAliasedBarrelTarget(realpathSync(result.path));
         }
     }
     if (isRelative) {

package/src/route-renderer/GRAPH.md

@@ -43,7 +43,7 @@ flowchart TD
   D --> E[resolvePageData]
   E --> F[ownershipValidationService.validate + throwIfOwnershipInvalid]
   F --> G[resolveDependencies + buildPageBrowserGraph]
-  G --> H[collect injector and eager SSR lazy assets]
+  G --> H[collect lazy injector assets]
   H --> I[build pagePackage and prepared render options]
   I --> J[IntegrationRenderer.render via document shell]
   J --> K[capture rendered body as html]

package/src/route-renderer/README.md

@@ -106,6 +106,8 @@ Mixed-integration component configs must declare every possible foreign child in
 
 At runtime, renderers still discover actual foreign children through the active component render context.
 
+Component renders always execute under a render context that names the rendering integration (`executeComponentRender` installs one when none is active). This lets ownership guards such as the content-processor's `getComponent()` detect a foreign render lane even when no foreign-child runtime is installed.
+
 ## Foreign Subtree Contract
 
 `renderComponentWithForeignChildren()` is the renderer entrypoint for mixed-integration trees. It is responsible for:
@@ -137,3 +139,9 @@ Not every integration needs queue-based handoff.
 
 - Different integrations still own different foreign-child runtime strategies, which is intentional where child transport or hydration behavior differs.
 - `integration-renderer.ts` remains the largest integration hook surface even after document-shell extraction.
+
+## Discovered Dependencies and loading policy
+
+Dependency collection reads declared `config.dependencies` plus identity-keyed inferred stylesheets, including deferred direct-import Component references. Traversal visits each config once; multiple Components in one file remain distinct. It collects explicit styles before inferred styles across the graph, suppressing inferred duplicates by resolved path. Page dependency results may include multiple file-owned contributions so relative assets keep the file that declared them. Source watch paths include discovered Components, their stylesheet files, and named barrel hops recorded during discovery.
+
+Lit preloads scripts marked `ssr: true` before server rendering, while the existing lazy-trigger manifest controls browser loading. The route pipeline does not emit a second eager script for these entries. Integration renderers refresh their resolved global assets after runtime activation so late setup cannot omit hydration support.

package/src/route-renderer/orchestration/foreign-child/foreign-subtree-execution.service.d.ts

@@ -126,6 +126,14 @@ export declare class ForeignSubtreeExecutionService {
         assets: ProcessedAsset[];
         html: string;
     }>;
+    /**
+     * Runs one component render under the current integration's render context and
+     * resolves any queued foreign subtrees captured during that render.
+     *
+     * @remarks
+     * Component renders always execute under a context that names the rendering
+     * integration, even when no foreign-child runtime is installed.
+     */
     executeComponentRender(options: ForeignSubtreeExecutionRenderOptions): Promise<ComponentRenderResult>;
     private getRendererCache;
     private withRendererCache;

package/src/route-renderer/orchestration/foreign-child/foreign-subtree-execution.service.js

@@ -221,6 +221,14 @@ export class ForeignSubtreeExecutionService {
             html: resolvedHtml,
         };
     }
+    /**
+     * Runs one component render under the current integration's render context and
+     * resolves any queued foreign subtrees captured during that render.
+     *
+     * @remarks
+     * Component renders always execute under a context that names the rendering
+     * integration, even when no foreign-child runtime is installed.
+     */
     async executeComponentRender(options) {
         const rendererCache = this.getRendererCache(options.input.integrationContext) ??
             new Map();
@@ -237,7 +245,7 @@ export class ForeignSubtreeExecutionService {
             this.requiresForeignChildRuntime(options.input);
         const activeRenderContext = getComponentRenderContext();
         if (!hasForeignChildren) {
-            if (!activeRenderContext || activeRenderContext.currentIntegration === options.currentIntegrationName) {
+            if (activeRenderContext && activeRenderContext.currentIntegration === options.currentIntegrationName) {
                 return options.normalizeComponentRenderOutput(await options.renderComponent(options.input));
             }
             const sameIntegrationExecution = await runWithComponentRenderContext({

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

@@ -4,7 +4,7 @@
  * @module
  */
 import type { EcoPagesAppConfig, IHmrManager } from '../../types/internal-types.js';
-import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, EcoComponentDependencies, EcoPageFile, EcoPagesElement, HtmlTemplateProps, IntegrationRendererRenderOptions, PageBrowserGraphContribution, PageBrowserGraphContributionContext, PageBrowserGraphResult, PageMetadataProps, RouteRendererBody, RouteRendererOptions, RouteRenderResult } from '../../types/public-types.js';
+import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, EcoPageFile, EcoPagesElement, HtmlTemplateProps, IntegrationRendererRenderOptions, PageBrowserGraphContribution, PageBrowserGraphContributionContext, PageBrowserGraphResult, PageMetadataProps, RouteRendererBody, RouteRendererOptions, RouteRenderResult } from '../../types/public-types.js';
 import { type AssetProcessingService, type ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
 import { HtmlTransformerService } from '../../services/html/html-transformer.service.js';
 import type { HtmlDocumentContribution } from '../../services/html/html-transformer.service.js';
@@ -281,7 +281,7 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
     protected resolveRouteRenderInputs(routeOptions: RouteRendererOptions): Promise<RouteRenderOrchestratorResolvedInputs>;
     protected buildPageBrowserGraphContributionContext(routeFile: string, routeOptions?: Pick<RouteRendererOptions, 'params' | 'query'>): Promise<PageBrowserGraphContributionContext>;
     protected resolvePageDependencies(context: PageBrowserGraphContributionContext): Promise<ResolvedPageDependencies | undefined>;
-    protected resolvePageBrowserGraphContributionFromDependencies(dependencies: EcoComponentDependencies, ownerFile: string): Promise<PageBrowserGraphContribution | undefined>;
+    protected resolvePageBrowserGraphContributionFromComponents(components: ReadonlyArray<EcoComponent | Partial<EcoComponent>>, ownerFile: string): Promise<PageBrowserGraphContribution | undefined>;
     protected resolveRouteDependencies(input: {
         components: (EcoComponent | Partial<EcoComponent>)[];
     }): Promise<{

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

@@ -15,7 +15,7 @@ import { RouteRenderOrchestrator, } from './route-pipeline/route-render-orchestr
 import { createIntegrationRouteRenderAdapter } from './route-pipeline/integration-route-render-adapter.js';
 import { createPageDependencyInstanceKey } from './page-browser-graph/route-instance-key.js';
 import { mergePageBrowserGraphContributions } from './page-browser-graph/page-browser-graph-contribution.merge.js';
-import { collectDependencyWatchPaths, collectFileScopedDependencyComponents, } from '../page-loading/file-scoped-dependency-components.js';
+import { collectDependencyWatchPaths } from '../page-loading/file-scoped-dependency-components.js';
 import { resolvePageDependenciesFromContext, } from '../page-loading/resolved-page-dependencies.js';
 import { createGroupedGraphBuildPlanKey, } from './page-browser-graph/grouped-graph-build-plan.js';
 import { normalizeUnresolvedMarkerArtifactHtml } from './route-pipeline/marker-artifact.utils.js';
@@ -68,6 +68,10 @@ export class IntegrationRenderer {
             integrationName: this.name,
             runtimeOrigin: this.runtimeOrigin,
         });
+        const integration = this.appConfig.integrations?.find((entry) => entry.name === this.name);
+        if (integration?.getResolvedIntegrationDependencies) {
+            this.resolvedIntegrationDependencies = integration.getResolvedIntegrationDependencies();
+        }
     }
     /**
      * Prebuilds the production Page Browser Graph for one route file and optional params.
@@ -586,19 +590,14 @@ export class IntegrationRenderer {
         };
     }
     async resolvePageDependencies(context) {
-        return resolvePageDependenciesFromContext(context, this.name, (dependencies, ownerFile) => this.resolvePageBrowserGraphContributionFromDependencies(dependencies, ownerFile));
+        return resolvePageDependenciesFromContext(context, this.name, (components, ownerFile) => this.resolvePageBrowserGraphContributionFromComponents(components, ownerFile));
     }
-    async resolvePageBrowserGraphContributionFromDependencies(dependencies, ownerFile) {
-        const components = collectFileScopedDependencyComponents({
-            ownerFile,
-            integrationName: this.name,
-            dependencies,
-        });
+    async resolvePageBrowserGraphContributionFromComponents(components, ownerFile) {
         if (components.length === 0) {
             return undefined;
         }
         return {
-            assets: await this.processComponentDependencies(components),
+            assets: await this.processComponentDependencies([...components]),
             watchPaths: collectDependencyWatchPaths(ownerFile, components),
         };
     }