@ecopages/core 0.2.0-alpha.1 → 0.2.0-alpha.11

package/src/build/runtime-specifier-aliases.js

@@ -0,0 +1,95 @@
+import { parseSync } from "oxc-parser";
+const RUNTIME_SPECIFIER_ALIAS_MAP = /* @__PURE__ */ Symbol("ecopages.runtimeSpecifierAliasMap");
+function attachRuntimeSpecifierAliasMap(plugin, specifierMap) {
+  plugin[RUNTIME_SPECIFIER_ALIAS_MAP] = specifierMap;
+  return plugin;
+}
+function getRuntimeSpecifierAliasMap(plugin) {
+  return plugin[RUNTIME_SPECIFIER_ALIAS_MAP];
+}
+function collectRuntimeSpecifierAliasMap(plugins) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const plugin of plugins ?? []) {
+    const specifierMap = getRuntimeSpecifierAliasMap(plugin);
+    if (!specifierMap) {
+      continue;
+    }
+    for (const [specifier, mappedPath] of specifierMap.entries()) {
+      if (!merged.has(specifier)) {
+        merged.set(specifier, mappedPath);
+      }
+    }
+  }
+  return merged;
+}
+function rewriteRuntimeSpecifierAliases(code, specifierMap) {
+  if (specifierMap.size === 0) {
+    return code;
+  }
+  const edits = [];
+  try {
+    const result = parseSync("runtime-alias-output.js", code, {
+      sourceType: "module",
+      lang: "js"
+    });
+    const queueReplacement = (source) => {
+      if (typeof source.value !== "string") {
+        return;
+      }
+      const mappedPath = specifierMap.get(source.value);
+      if (!mappedPath) {
+        return;
+      }
+      const quote = code[source.start] === "'" ? "'" : '"';
+      edits.push({
+        start: source.start,
+        end: source.end,
+        replacement: `${quote}${mappedPath}${quote}`
+      });
+    };
+    const walk = (node) => {
+      if (!node || typeof node !== "object") {
+        return;
+      }
+      if (Array.isArray(node)) {
+        for (const child of node) {
+          walk(child);
+        }
+        return;
+      }
+      const candidate = node;
+      if (candidate.type === "ImportDeclaration" || candidate.type === "ExportNamedDeclaration" || candidate.type === "ExportAllDeclaration") {
+        if (candidate.source) {
+          queueReplacement(candidate.source);
+        }
+      }
+      if (candidate.type === "ImportExpression") {
+        const importNode = candidate;
+        if (importNode.source?.type === "StringLiteral" || importNode.source?.type === "Literal") {
+          queueReplacement(importNode.source);
+        }
+      }
+      for (const value of Object.values(candidate)) {
+        walk(value);
+      }
+    };
+    walk(result.program);
+  } catch {
+    return code;
+  }
+  if (edits.length === 0) {
+    return code;
+  }
+  edits.sort((left, right) => right.start - left.start);
+  let rewritten = code;
+  for (const edit of edits) {
+    rewritten = rewritten.slice(0, edit.start) + edit.replacement + rewritten.slice(edit.end);
+  }
+  return rewritten;
+}
+export {
+  attachRuntimeSpecifierAliasMap,
+  collectRuntimeSpecifierAliasMap,
+  getRuntimeSpecifierAliasMap,
+  rewriteRuntimeSpecifierAliases
+};

package/src/config/README.md

@@ -0,0 +1,36 @@
+# Config Layer
+
+This directory contains the app-configuration finalization path for Ecopages.
+
+## Purpose
+
+The config layer answers one question:
+
+How does one `eco.config.ts` become one stable, app-owned runtime/build configuration?
+
+It is responsible for:
+
+- validating integration, processor, and loader registration
+- resolving semantic paths such as `html` and `404` templates
+- selecting explicit build ownership and creating app-owned runtime state such as the build adapter, build executor, build manifest, dev graph service, runtime specifier registry, and remaining compatibility-only runtime state
+- enforcing runtime capability requirements before startup
+- carrying host-injected runtime dependencies only through abstract slots such as host module loaders, never through bundler-specific core defaults
+
+## Main Files
+
+- `config-builder.ts`: the primary builder and config finalization boundary
+- `config-builder.test.ts`: coverage for validation, path resolution, and runtime capability checks
+
+## Ownership Rules
+
+- Integrations and processors declare contributions.
+- `ConfigBuilder.build()` decides ordering, validates compatibility, and seals build ownership for the finalized app config.
+- Runtime startup reuses finalized config/build state; it should not recompute manifest ownership.
+
+Bun-native is the default ownership path. Vite-host ownership is explicit and should be selected during config construction when a host-driven compatibility flow must avoid silently falling back to Bun build execution.
+
+## Output
+
+The result of this layer is a built `EcoPagesAppConfig` with resolved absolute paths and app-owned runtime services attached under `appConfig.runtime`.
+
+That built config is then consumed by server adapters, static generation, route rendering, and HMR.

package/src/config/config-builder.d.ts

@@ -2,11 +2,13 @@
  * This module contains the ConfigBuilder class, which is used to build the EcoPagesAppConfig object.
  * @module
  */
+import { type BuildOwnership } from '../build/build-adapter.js';
 import type { EcoBuildPlugin } from '../build/build-types.js';
-import type { EcoPagesAppConfig, IncludesTemplates, RobotsPreference } from '../internal-types.js';
+import type { EcoPagesAppConfig, RobotsPreference } from '../types/internal-types.js';
 import type { IntegrationPlugin } from '../plugins/integration-plugin.js';
 import type { Processor } from '../plugins/processor.js';
-import type { PageMetadataProps } from '../public-types.js';
+import type { EcoSourceTransform } from '../plugins/source-transform.js';
+import type { PageMetadataProps } from '../types/public-types.js';
 import type { CacheConfig } from '../services/cache/cache.types.js';
 export declare const CONFIG_BUILDER_ERRORS: {
     readonly DUPLICATE_INTEGRATION_NAMES: "Integrations names must be unique";
@@ -14,7 +16,12 @@ export declare const CONFIG_BUILDER_ERRORS: {
     readonly MIXED_JSX_ENGINES: "Both kitajs and react integrations are enabled. Use per-file JSX import source/pragma consistently (e.g. `/** @jsxImportSource react */` for React files and `/** @jsxImportSource @kitajs/html */` for Kita files).";
     readonly duplicateProcessorName: (name: string) => string;
     readonly duplicateLoaderName: (name: string) => string;
+    readonly duplicateSemanticTemplate: (kind: "html" | "404", matches: string[]) => string;
+    readonly incompatibleRuntimeCapability: (kind: "integration" | "processor", name: string, runtime: RuntimeKind, reason: string) => string;
+    readonly unsupportedRuntimeVersion: (kind: "integration" | "processor", name: string, runtime: RuntimeKind, current: string, min: string) => string;
+    readonly invalidRuntimeVersion: (kind: "integration" | "processor", name: string, version: string) => string;
 };
+type RuntimeKind = 'node' | 'bun';
 /**
  * A builder class for creating and configuring EcoPages application configuration.
  * Provides a fluent interface for setting various configuration options and managing
@@ -46,6 +53,7 @@ export declare const CONFIG_BUILDER_ERRORS: {
  * @throws {Error} When adding duplicate processors or loaders
  */
 export declare class ConfigBuilder {
+    private buildOwnership;
     config: EcoPagesAppConfig;
     /**
      * Sets the base URL for the application.
@@ -63,6 +71,15 @@ export declare class ConfigBuilder {
      * @returns The ConfigBuilder instance for method chaining
      */
     setRootDir(rootDir: string): this;
+    /**
+     * Sets which runtime path owns build execution for the finalized app config.
+     *
+     * @remarks
+     * Bun-native remains the default. Vite-host ownership should be selected only
+     * for host-driven compatibility flows where core must not silently fall back to
+     * Bun build execution.
+     */
+    setBuildOwnership(buildOwnership: BuildOwnership): this;
     /**
      * Sets the source directory relative to the root directory.
      * This directory contains all the source files for the application.
@@ -111,21 +128,6 @@ export declare class ConfigBuilder {
      * @returns The ConfigBuilder instance for method chaining
      */
     setPublicDir(publicDir: string): this;
-    /**
-     * Sets the templates used for includes.
-     * These templates are used to build the HTML structure of pages.
-     *
-     * @param includesTemplates - An object containing the template file names
-     * @returns The ConfigBuilder instance for method chaining
-     */
-    setIncludesTemplates(includesTemplates: IncludesTemplates): this;
-    /**
-     * Sets the template file for the 404 error page.
-     *
-     * @param error404Template - The file name of the 404 error template (default: '404.ghtml.ts')
-     * @returns The ConfigBuilder instance for method chaining
-     */
-    setError404Template(error404Template: string): this;
     /**
      * Sets the robots.txt configuration.
      * This determines which paths are allowed/disallowed for search engines.
@@ -147,10 +149,22 @@ export declare class ConfigBuilder {
     /**
      * Sets the output directory for the built application.
      *
-     * @param distDir - The distribution directory name (default: '.eco')
+     * @param distDir - The distribution directory name (default: 'dist')
      * @returns The ConfigBuilder instance for method chaining
      */
     setDistDir(distDir: string): this;
+    /**
+     * Sets the internal work directory for runtime-only artifacts.
+     *
+     * @remarks
+     * Use this when deployable output should stay clean while Ecopages still
+     * needs a separate workspace for server transpilation caches, runtime
+     * manifests, and other internal build products.
+     *
+     * @param workDir - The internal work directory name
+     * @returns The ConfigBuilder instance for method chaining
+     */
+    setWorkDir(workDir: string): this;
     /**
      * Sets the default metadata for pages.
      * This is used when a page doesn't specify its own metadata.
@@ -190,6 +204,11 @@ export declare class ConfigBuilder {
      * @returns The ConfigBuilder instance for method chaining
      */
     setLoaders(loaders: EcoBuildPlugin[]): this;
+    /**
+     * Sets the source transforms to use for transform-first bundlers such as Vite.
+     * This replaces any existing source transforms.
+     */
+    setSourceTransforms(sourceTransforms: EcoSourceTransform[]): this;
     /**
      * Adds a loader to the application.
      *
@@ -199,6 +218,12 @@ export declare class ConfigBuilder {
      * @throws Error if a loader with the same name already exists
      */
     addLoader(name: string, loader: EcoBuildPlugin): this;
+    /**
+     * Adds a source transform to the application.
+     *
+     * @throws Error if a source transform with the same name already exists.
+     */
+    addSourceTransform(name: string, sourceTransform: EcoSourceTransform): this;
     /**
      * Sets the cache configuration for ISR and page caching.
      *
@@ -208,8 +233,16 @@ export declare class ConfigBuilder {
     setCacheConfig(cacheConfig: CacheConfig): this;
     setExperimental(experimental: NonNullable<EcoPagesAppConfig['experimental']>): this;
     private createAbsolutePaths;
+    private resolveSemanticTemplatePath;
     private createIntegrationTemplatesExt;
     private initializeProcessors;
+    private validateRuntimeCapabilities;
+    private validateRuntimeCapability;
+    private detectRuntimeEnvironment;
+    private getBunVersion;
+    private describeUnsupportedRuntimeTag;
+    private parseVersion;
+    private compareVersions;
     /**
      * Initializes default loaders that are required for EcoPages to function.
      * This includes the eco-component-meta-plugin which auto-injects __eco metadata into component configs.
@@ -225,3 +258,4 @@ export declare class ConfigBuilder {
      */
     build(): Promise<EcoPagesAppConfig>;
 }
+export {};