@ecopages/core 0.2.0-beta.8 → 0.2.0-rc.0

package/src/hmr/strategies/server-rendered-template-hmr-strategy.d.ts

@@ -0,0 +1,17 @@
+/**
+ * HMR strategy for server-rendered include templates and explicit server views.
+ *
+ * These files affect SSR output (head, layout shell, explicit views) but are not
+ * client HMR entrypoints. Broadcast a layout-update so the active navigation
+ * runtime can refresh the current page without a full document reload.
+ */
+import { HmrStrategy, type HmrAction } from '../hmr-strategy.js';
+import type { DevelopmentInvalidationService } from '../../services/invalidation/development-invalidation.service.js';
+export declare class ServerRenderedTemplateHmrStrategy extends HmrStrategy {
+    private readonly invalidationService;
+    readonly type: 100;
+    readonly priorityOffset = 50;
+    constructor(invalidationService: DevelopmentInvalidationService);
+    matches(filePath: string): boolean;
+    process(filePath: string): Promise<HmrAction>;
+}

package/src/hmr/strategies/server-rendered-template-hmr-strategy.js

@@ -0,0 +1,35 @@
+/**
+ * HMR strategy for server-rendered include templates and explicit server views.
+ *
+ * These files affect SSR output (head, layout shell, explicit views) but are not
+ * client HMR entrypoints. Broadcast a layout-update so the active navigation
+ * runtime can refresh the current page without a full document reload.
+ */
+import { HmrStrategy, HmrStrategyType } from '../hmr-strategy.js';
+/** Outranks integration-owned strategies that may also match shared dependencies. */
+const SERVER_RENDERED_TEMPLATE_PRIORITY_OFFSET = 50;
+export class ServerRenderedTemplateHmrStrategy extends HmrStrategy {
+    invalidationService;
+    type = HmrStrategyType.INTEGRATION;
+    priorityOffset = SERVER_RENDERED_TEMPLATE_PRIORITY_OFFSET;
+    constructor(invalidationService) {
+        super();
+        this.invalidationService = invalidationService;
+    }
+    matches(filePath) {
+        return (this.invalidationService.isIncludeSourceFile(filePath) ||
+            this.invalidationService.isExplicitServerViewFile(filePath));
+    }
+    async process(filePath) {
+        return {
+            type: 'broadcast',
+            events: [
+                {
+                    type: 'layout-update',
+                    path: filePath,
+                    timestamp: Date.now(),
+                },
+            ],
+        };
+    }
+}

package/src/index.browser.d.ts

@@ -1,3 +1,4 @@
 export type * from './types/public-types.js';
 export type * from './eco/eco.types.js';
 export { eco } from './eco/eco.browser.js';
+export { bindComponentIdentity, getComponentIdentity, type ComponentIdentity } from './eco/component-identity.js';

package/src/index.browser.js

@@ -1,4 +1,2 @@
-import { eco } from "./eco/eco.browser.js";
-export {
-  eco
-};
+export { eco } from './eco/eco.browser.js';
+export { bindComponentIdentity, getComponentIdentity } from './eco/component-identity.js';

package/src/index.d.ts

@@ -1,6 +1,9 @@
 export type * from './types/public-types.js';
 export type * from './eco/eco.types.js';
 export { eco } from './eco/eco.js';
-export { defineApiHandler, defineGroupHandler, type GroupHandler } from './adapters/shared/define-api-handler.js';
+export { defineApiHandler, defineGroupHandler, defineGet, definePost, definePut, defineDelete, definePatch, defineOptions, defineHead, json, html, redirect, type GroupHandler, } from './adapters/shared/http/define-api-handler.js';
 export { createEcoBuildPluginFromSourceTransform, createVitePluginsFromAppSourceTransforms, getAppSourceTransforms, createVitePluginFromSourceTransform, normalizeTransformId, type EcoSourceTransform, type EcoSourceTransformResult, type EcoViteCompatiblePlugin, } from './plugins/source-transform.js';
 export { createEcoComponentMetaTransform } from './plugins/eco-component-meta-plugin.js';
+export { bindComponentIdentity, getComponentIdentity, type ComponentIdentity } from './eco/component-identity.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/index.js

@@ -1,21 +1,7 @@
-import { eco } from "./eco/eco.js";
-import { defineApiHandler, defineGroupHandler } from "./adapters/shared/define-api-handler.js";
-import {
-  createEcoBuildPluginFromSourceTransform,
-  createVitePluginsFromAppSourceTransforms,
-  getAppSourceTransforms,
-  createVitePluginFromSourceTransform,
-  normalizeTransformId
-} from "./plugins/source-transform.js";
-import { createEcoComponentMetaTransform } from "./plugins/eco-component-meta-plugin.js";
-export {
-  createEcoBuildPluginFromSourceTransform,
-  createEcoComponentMetaTransform,
-  createVitePluginFromSourceTransform,
-  createVitePluginsFromAppSourceTransforms,
-  defineApiHandler,
-  defineGroupHandler,
-  eco,
-  getAppSourceTransforms,
-  normalizeTransformId
-};
+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 { bindComponentIdentity, getComponentIdentity } from './eco/component-identity.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/islands/README.md

@@ -0,0 +1,25 @@
+# Island host contract
+
+Hydratable component instances stamp a small, integration-agnostic attribute set on their SSR root so devtools (and future runtime features) can discover islands without integration-specific selectors.
+
+## Attributes
+
+| Attribute                     | Purpose                                              |
+| ----------------------------- | ---------------------------------------------------- |
+| `data-eco-island`             | Marks the element as an interactive island host      |
+| `data-eco-island-integration` | Owning integration (`react`, `lit`, `kitajs`, …)     |
+| `data-eco-component-id`       | Stable instance id from the render pipeline          |
+| `data-eco-component-key`      | Optional module key used by client hydration (React) |
+| `data-eco-props`              | Optional base64 JSON props snapshot for hydration    |
+
+React may still replace the SSR host with `<eco-island>` after hydration; the marker is applied at SSR time on the component root.
+
+## Where stamping happens
+
+`finalizeIslandComponentRender()` in `island-host.ts` is called from integration renderers when:
+
+1. `integrationContext.componentInstanceId` is present
+2. The render result can attach attributes to a single root element
+3. The render emits at least one client `script` asset
+
+Integrations with custom island metadata (for example React's component key) should build on `buildIslandHostAttributes()` rather than inventing per-demo selectors.

package/src/islands/island-host.d.ts

@@ -0,0 +1,37 @@
+export declare const ECO_ISLAND_HOST_ATTRIBUTE = "data-eco-island";
+export declare const ECO_ISLAND_INTEGRATION_ATTRIBUTE = "data-eco-island-integration";
+export declare const ECO_ISLAND_COMPONENT_ID_ATTRIBUTE = "data-eco-component-id";
+export declare const ECO_ISLAND_COMPONENT_KEY_ATTRIBUTE = "data-eco-component-key";
+export declare const ECO_ISLAND_PROPS_ATTRIBUTE = "data-eco-props";
+export type IslandHostAttributesInput = {
+    integrationName: string;
+    componentInstanceId: string;
+    componentKey?: string;
+    props?: Record<string, unknown>;
+    existing?: Record<string, string>;
+};
+/**
+ * @remarks Presence marker for hydratable component hosts, similar in spirit to Astro's `astro-island`.
+ */
+export declare function mergeIslandHostAttributes(input: {
+    integrationName: string;
+    componentInstanceId: string;
+    existing?: Record<string, string>;
+}): Record<string, string>;
+export declare function buildIslandHostAttributes(input: IslandHostAttributesInput): Record<string, string>;
+export declare function isIslandHostElement(element: Element): boolean;
+export declare function componentRenderHasIslandBootstrap(assets: Array<{
+    kind: string;
+}> | undefined): boolean;
+export declare function finalizeIslandComponentRender<T extends {
+    canAttachAttributes: boolean;
+    integrationName: string;
+    rootAttributes?: Record<string, string>;
+    assets?: Array<{
+        kind: string;
+    }>;
+}>(input: {
+    integrationContext?: {
+        componentInstanceId?: string;
+    };
+}, result: T): T;

package/src/islands/island-host.js

@@ -0,0 +1,55 @@
+export const ECO_ISLAND_HOST_ATTRIBUTE = 'data-eco-island';
+export const ECO_ISLAND_INTEGRATION_ATTRIBUTE = 'data-eco-island-integration';
+export const ECO_ISLAND_COMPONENT_ID_ATTRIBUTE = 'data-eco-component-id';
+export const ECO_ISLAND_COMPONENT_KEY_ATTRIBUTE = 'data-eco-component-key';
+export const ECO_ISLAND_PROPS_ATTRIBUTE = 'data-eco-props';
+/**
+ * @remarks Presence marker for hydratable component hosts, similar in spirit to Astro's `astro-island`.
+ */
+export function mergeIslandHostAttributes(input) {
+    return {
+        ...input.existing,
+        [ECO_ISLAND_HOST_ATTRIBUTE]: '',
+        [ECO_ISLAND_COMPONENT_ID_ATTRIBUTE]: input.existing?.[ECO_ISLAND_COMPONENT_ID_ATTRIBUTE] ?? input.componentInstanceId,
+        [ECO_ISLAND_INTEGRATION_ATTRIBUTE]: input.integrationName,
+    };
+}
+export function buildIslandHostAttributes(input) {
+    const attributes = mergeIslandHostAttributes(input);
+    if (input.componentKey) {
+        attributes[ECO_ISLAND_COMPONENT_KEY_ATTRIBUTE] = input.componentKey;
+    }
+    if (input.props !== undefined) {
+        attributes[ECO_ISLAND_PROPS_ATTRIBUTE] = btoa(JSON.stringify(input.props));
+    }
+    return attributes;
+}
+export function isIslandHostElement(element) {
+    if (element.hasAttribute(ECO_ISLAND_HOST_ATTRIBUTE)) {
+        return true;
+    }
+    if (element.hasAttribute(ECO_ISLAND_COMPONENT_KEY_ATTRIBUTE)) {
+        return true;
+    }
+    if (element.tagName.toLowerCase() === 'eco-island') {
+        return true;
+    }
+    return element.hasAttribute(ECO_ISLAND_COMPONENT_ID_ATTRIBUTE) && element.hasAttribute(ECO_ISLAND_PROPS_ATTRIBUTE);
+}
+export function componentRenderHasIslandBootstrap(assets) {
+    return (assets ?? []).some((asset) => asset.kind === 'script');
+}
+export function finalizeIslandComponentRender(input, result) {
+    const componentInstanceId = input.integrationContext?.componentInstanceId;
+    if (!componentInstanceId || !result.canAttachAttributes || !componentRenderHasIslandBootstrap(result.assets)) {
+        return result;
+    }
+    return {
+        ...result,
+        rootAttributes: mergeIslandHostAttributes({
+            integrationName: result.integrationName,
+            componentInstanceId,
+            existing: result.rootAttributes,
+        }),
+    };
+}

package/src/plugins/README.md

@@ -19,13 +19,14 @@ These contracts are responsible for:
 - `processor.ts`: asset-transformation contract for processors
 - `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`: shared metadata transform used by core loading/build paths
+- `eco-component-meta-plugin.ts`: component-identity attribution transform that uses a lexical `eco.` gate, then an Oxc `CallExpression` rewrite
 
 ## Ownership Rules
 
 - Integrations own rendering semantics, hydration behavior, and integration-specific HMR strategy.
 - 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.
 
 ## Lifecycle Summary
 

package/src/plugins/alias-resolver-cache.d.ts

@@ -1,17 +1,14 @@
 /**
- * Per-plugin cache for `@/...` alias resolution.
+ * Per-plugin cache for tsconfig path alias resolution.
  *
  * @remarks
- * The `ecopages-alias-resolver` plugin resolves project aliases like
- * `@/components/Button` to concrete file paths under the app's `srcDir`.
- * Each resolution can trigger up to 22 `existsSync` calls and (when
- * the resolved path is a barrel) a `readFileSync` to detect
- * `export * from './...'` forwarding.
+ * The `ecopages-alias-resolver` plugin resolves project path aliases to
+ * concrete file paths using the app's tsconfig `paths`. Each resolution goes
+ * through oxc-resolver and may read barrel re-export targets.
  *
- * This cache memoizes the result keyed by `(srcDir, specifier)`. It is
+ * This cache memoizes the result keyed by `(projectRoot, specifier)`. It is
  * process-local and not currently invalidated by the file watcher —
- * `srcDir` contents are assumed to be stable for the lifetime of the
- * process.
+ * project contents are assumed to be stable for the lifetime of the process.
  */
 export declare class AliasResolverCache {
     private readonly entries;

package/src/plugins/alias-resolver-cache.js

@@ -1,106 +1,123 @@
-import path from "node:path";
-const DEFAULT_MAX_ENTRIES = 2e3;
-class AliasResolverCache {
-  entries = /* @__PURE__ */ new Map();
-  maxEntries;
-  hits = 0;
-  misses = 0;
-  constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
-    if (maxEntries <= 0) {
-      throw new Error(`AliasResolverCache: maxEntries must be > 0, got ${maxEntries}`);
+/**
+ * Per-plugin cache for tsconfig path alias resolution.
+ *
+ * @remarks
+ * The `ecopages-alias-resolver` plugin resolves project path aliases to
+ * concrete file paths using the app's tsconfig `paths`. Each resolution goes
+ * through oxc-resolver and may read barrel re-export targets.
+ *
+ * This cache memoizes the result keyed by `(projectRoot, specifier)`. It is
+ * process-local and not currently invalidated by the file watcher —
+ * project contents are assumed to be stable for the lifetime of the process.
+ */
+import path from 'node:path';
+const DEFAULT_MAX_ENTRIES = 2_000;
+export class AliasResolverCache {
+    entries = new Map();
+    maxEntries;
+    hits = 0;
+    misses = 0;
+    constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+        if (maxEntries <= 0) {
+            throw new Error(`AliasResolverCache: maxEntries must be > 0, got ${maxEntries}`);
+        }
+        this.maxEntries = maxEntries;
     }
-    this.maxEntries = maxEntries;
-  }
-  /**
-   * Look up a previously-computed resolution for `(srcDir, specifier)`.
-   *
-   * Returns `{ hit: true, resolved }` on cache hit (resolved may be
-   * `undefined` for an unresolvable specifier), or `{ hit: false }` on
-   * miss. The caller is responsible for re-running the resolver and
-   * calling `set` to store the new entry.
-   */
-  get(srcDir, specifier) {
-    const key = makeKey(srcDir, specifier);
-    const existing = this.entries.get(key);
-    if (existing) {
-      this.hits += 1;
-      this.entries.delete(key);
-      this.entries.set(key, existing);
-      return { hit: true, resolved: existing.resolved };
+    /**
+     * Look up a previously-computed resolution for `(srcDir, specifier)`.
+     *
+     * Returns `{ hit: true, resolved }` on cache hit (resolved may be
+     * `undefined` for an unresolvable specifier), or `{ hit: false }` on
+     * miss. The caller is responsible for re-running the resolver and
+     * calling `set` to store the new entry.
+     */
+    get(srcDir, specifier) {
+        const key = makeKey(srcDir, specifier);
+        const existing = this.entries.get(key);
+        if (existing) {
+            this.hits += 1;
+            // Refresh LRU position.
+            this.entries.delete(key);
+            this.entries.set(key, existing);
+            return { hit: true, resolved: existing.resolved };
+        }
+        this.misses += 1;
+        return { hit: false };
     }
-    this.misses += 1;
-    return { hit: false };
-  }
-  /**
-   * Store a resolution result.
-   *
-   * Pass `undefined` for `resolved` to memoize the negative case
-   * (specifier did not resolve) and avoid repeating the FS walk on
-   * every `@/...` import.
-   */
-  set(srcDir, specifier, resolved) {
-    const key = makeKey(srcDir, specifier);
-    this.entries.set(key, { srcDir, resolved });
-    if (this.entries.size > this.maxEntries) {
-      const oldestKey = this.entries.keys().next().value;
-      if (oldestKey !== void 0) {
-        this.entries.delete(oldestKey);
-      }
+    /**
+     * Store a resolution result.
+     *
+     * Pass `undefined` for `resolved` to memoize the negative case
+     * (specifier did not resolve) and avoid repeating the FS walk on
+     * every `@/...` import.
+     */
+    set(srcDir, specifier, resolved) {
+        const key = makeKey(srcDir, specifier);
+        this.entries.set(key, { srcDir, resolved });
+        if (this.entries.size > this.maxEntries) {
+            const oldestKey = this.entries.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.entries.delete(oldestKey);
+            }
+        }
     }
-  }
-  /**
-   * Drop all entries whose `srcDir` is under `rootDir`. Use this from
-   * the file watcher when files are added or removed under the app's
-   * source tree.
-   *
-   * Path comparison is path-aware (handles both POSIX `/` and
-   * Windows `\` separators) via `path.relative` so cached entries
-   * normalized on one platform still match the watcher's `rootDir`
-   * on another. Without this, a Windows build that sees
-   * `entry.srcDir === 'C:\app\src'` would miss
-   * `entry.srcDir.startsWith('C:/app/src/')` and leave stale entries.
-   */
-  invalidateUnder(rootDir) {
-    const normalizedRoot = path.resolve(rootDir);
-    let removed = 0;
-    for (const [key, entry] of this.entries) {
-      if (isUnderDirectory(path.resolve(entry.srcDir), normalizedRoot)) {
-        this.entries.delete(key);
-        removed += 1;
-      }
+    /**
+     * Drop all entries whose `srcDir` is under `rootDir`. Use this from
+     * the file watcher when files are added or removed under the app's
+     * source tree.
+     *
+     * Path comparison is path-aware (handles both POSIX `/` and
+     * Windows `\` separators) via `path.relative` so cached entries
+     * normalized on one platform still match the watcher's `rootDir`
+     * on another. Without this, a Windows build that sees
+     * `entry.srcDir === 'C:\app\src'` would miss
+     * `entry.srcDir.startsWith('C:/app/src/')` and leave stale entries.
+     */
+    invalidateUnder(rootDir) {
+        const normalizedRoot = path.resolve(rootDir);
+        let removed = 0;
+        for (const [key, entry] of this.entries) {
+            if (isUnderDirectory(path.resolve(entry.srcDir), normalizedRoot)) {
+                this.entries.delete(key);
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+    /** Clear all entries. */
+    clear() {
+        this.entries.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    /** Current cache size. */
+    get size() {
+        return this.entries.size;
+    }
+    /** Hit/miss counters for observability. */
+    stats() {
+        const total = this.hits + this.misses;
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            size: this.entries.size,
+            hitRate: total === 0 ? 0 : this.hits / total,
+        };
     }
-    return removed;
-  }
-  /** Clear all entries. */
-  clear() {
-    this.entries.clear();
-    this.hits = 0;
-    this.misses = 0;
-  }
-  /** Current cache size. */
-  get size() {
-    return this.entries.size;
-  }
-  /** Hit/miss counters for observability. */
-  stats() {
-    const total = this.hits + this.misses;
-    return {
-      hits: this.hits,
-      misses: this.misses,
-      size: this.entries.size,
-      hitRate: total === 0 ? 0 : this.hits / total
-    };
-  }
 }
 function makeKey(srcDir, specifier) {
-  return `${srcDir} ${specifier}`;
+    return `${srcDir} ${specifier}`;
 }
+/**
+ * Returns true if `candidate` is the same as `parent` or a descendant
+ * of it. Uses `path.relative` so the comparison is path-aware and
+ * works across POSIX and Windows separators.
+ */
 function isUnderDirectory(candidate, parent) {
-  if (candidate === parent) return true;
-  const rel = path.relative(parent, candidate);
-  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return false;
-  return true;
+    if (candidate === parent)
+        return true;
+    const rel = path.relative(parent, candidate);
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+        return false;
+    return true;
 }
-export {
-  AliasResolverCache
-};

package/src/plugins/alias-resolver-plugin.d.ts

@@ -1,6 +1,6 @@
-import type { EcoBuildPlugin } from '../build/build-types.js';
+import type { EcoBuildPlugin } from '../build/contracts/build-types.js';
 import { AliasResolverCache } from './alias-resolver-cache.js';
-export declare function resolveAppSourceAliasPath(srcDir: string, specifier: string): string | undefined;
-export declare function createAliasResolverPlugin(srcDir: string, options?: {
+export declare function createAliasResolverPlugin(projectRoot: string, options?: {
     cache?: AliasResolverCache;
 }): EcoBuildPlugin;
+export { isBarePackageImportSpecifier, matchesTsconfigPathPrefix, loadTsconfigPathPrefixes, resolveProjectImportPath, resolveProjectModulePath, } from './tsconfig-import-resolver.js';

package/src/plugins/alias-resolver-plugin.js

@@ -1,65 +1,38 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { AliasResolverCache } from "./alias-resolver-cache.js";
-const RESOLVABLE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mdx", ".css", ".scss", ".sass", ".less"];
-function findResolvablePath(candidate) {
-  if (path.extname(candidate)) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  for (const extension of RESOLVABLE_EXTENSIONS) {
-    const fileCandidate = `${candidate}${extension}`;
-    if (existsSync(fileCandidate)) {
-      return fileCandidate;
-    }
-  }
-  for (const extension of RESOLVABLE_EXTENSIONS) {
-    const indexCandidate = path.join(candidate, `index${extension}`);
-    if (existsSync(indexCandidate)) {
-      return indexCandidate;
-    }
-  }
-  return void 0;
+import { AliasResolverCache } from './alias-resolver-cache.js';
+import { loadTsconfigPathPrefixes, resolveProjectImportPath } from './tsconfig-import-resolver.js';
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-function resolveAliasedBarrelTarget(resolvedPath) {
-  if (!path.basename(resolvedPath).startsWith("index.")) {
-    return resolvedPath;
-  }
-  const source = readFileSync(resolvedPath, "utf8").trim();
-  const match = source.match(/^export\s+\*\s+from\s+['"]([^'"]+)['"]\s*;?$/);
-  if (!match?.[1]?.startsWith(".")) {
-    return resolvedPath;
-  }
-  const target = findResolvablePath(path.resolve(path.dirname(resolvedPath), match[1]));
-  return target ?? resolvedPath;
-}
-function resolveAppSourceAliasPath(srcDir, specifier) {
-  if (!specifier.startsWith("@/")) {
-    return void 0;
-  }
-  const candidate = path.join(srcDir, specifier.slice(2));
-  const resolved = findResolvablePath(candidate);
-  return resolved ? resolveAliasedBarrelTarget(resolved) : void 0;
-}
-function createAliasResolverPlugin(srcDir, options) {
-  const cache = options?.cache ?? new AliasResolverCache();
-  return {
-    name: "ecopages-alias-resolver",
-    setup(build) {
-      build.onResolve({ filter: /^@\// }, (args) => {
-        const cached = cache.get(srcDir, args.path);
-        if (cached.hit) {
-          return cached.resolved ? { path: cached.resolved } : {};
-        }
-        const resolved = resolveAppSourceAliasPath(srcDir, args.path);
-        cache.set(srcDir, args.path, resolved);
-        return resolved ? { path: resolved } : {};
-      });
+function buildPathPrefixFilter(prefix) {
+    if (prefix.endsWith('/')) {
+        return new RegExp(`^${escapeRegExp(prefix)}`);
     }
-  };
+    return new RegExp(`^${escapeRegExp(prefix)}(?:/|$)`);
+}
+export function createAliasResolverPlugin(projectRoot, options) {
+    const cache = options?.cache ?? new AliasResolverCache();
+    const pathPrefixes = loadTsconfigPathPrefixes(projectRoot);
+    return {
+        name: 'ecopages-alias-resolver',
+        setup(build) {
+            if (pathPrefixes.length === 0) {
+                return;
+            }
+            for (const prefix of pathPrefixes) {
+                build.onResolve({ filter: buildPathPrefixFilter(prefix) }, (args) => {
+                    if (!args.importer) {
+                        return undefined;
+                    }
+                    const cached = cache.get(projectRoot, args.path);
+                    if (cached.hit) {
+                        return cached.resolved ? { path: cached.resolved } : undefined;
+                    }
+                    const resolved = resolveProjectImportPath(projectRoot, args.importer, args.path);
+                    cache.set(projectRoot, args.path, resolved);
+                    return resolved ? { path: resolved } : undefined;
+                });
+            }
+        },
+    };
 }
-export {
-  createAliasResolverPlugin,
-  resolveAppSourceAliasPath
-};
+export { isBarePackageImportSpecifier, matchesTsconfigPathPrefix, loadTsconfigPathPrefixes, resolveProjectImportPath, resolveProjectModulePath, } from './tsconfig-import-resolver.js';

package/src/plugins/define-integration.d.ts

@@ -0,0 +1,26 @@
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+import type { AssetProcessingService } from '../services/assets/asset-processing-service/asset-processing.service.js';
+import type { ProcessedAsset } from '../services/assets/asset-processing-service/assets.types.js';
+import type { EcoPagesElement } from '../types/public-types.js';
+import type { IntegrationRenderer } from '../route-renderer/orchestration/integration-renderer.js';
+import { IntegrationPlugin, type IntegrationPluginConfig } from './integration-plugin.js';
+type RendererClass<C> = new (options: {
+    appConfig: EcoPagesAppConfig;
+    assetProcessingService: AssetProcessingService;
+    resolvedIntegrationDependencies: ProcessedAsset[];
+    rendererModules?: unknown;
+    runtimeOrigin: string;
+}) => IntegrationRenderer<C>;
+export interface DefineIntegrationDefinition<C = EcoPagesElement> extends IntegrationPluginConfig {
+    renderer: RendererClass<C>;
+}
+export interface DefinedIntegration<C = EcoPagesElement> {
+    (options?: Omit<IntegrationPluginConfig, 'name'>): IntegrationPlugin<C>;
+    Plugin: new (options?: Omit<IntegrationPluginConfig, 'name'>) => IntegrationPlugin<C>;
+}
+/**
+ * Creates a typed integration plugin factory for integrations that only need
+ * declarative config and a renderer class.
+ */
+export declare function defineIntegration<C = EcoPagesElement>(definition: DefineIntegrationDefinition<C>): DefinedIntegration<C>;
+export {};