@ecopages/core 0.2.0-alpha.9 → 0.2.1

package/src/build/esbuild-build-adapter.js

@@ -1,8 +1,12 @@
-import path from "node:path";
+import { readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
+import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { fileSystem } from "@ecopages/file-system";
-const esbuildRequire = createRequire(import.meta.url);
+import { collectRuntimeSpecifierAliasMap, rewriteRuntimeSpecifierAliases } from "./runtime-specifier-aliases.js";
+const moduleRequire = createRequire(import.meta.url);
+const esbuildPath = moduleRequire.resolve("esbuild");
+const workspaceNodePathsCache = /* @__PURE__ */ new Map();
 function transpileProfileToOptions(profile) {
   switch (profile) {
     case "browser-script":
@@ -25,7 +29,78 @@ function transpileProfileToOptions(profile) {
       };
   }
 }
+const ESBUILD_ADAPTER_BRAND = /* @__PURE__ */ Symbol.for("EsbuildBuildAdapter");
 class EsbuildBuildAdapter {
+  ownership = "bun-native";
+  [ESBUILD_ADAPTER_BRAND] = true;
+  collectWorkspaceNodePaths(scanRoot, maxDepth = 3) {
+    const normalizedRoot = path.resolve(scanRoot);
+    const cached = workspaceNodePathsCache.get(normalizedRoot);
+    if (cached) {
+      return cached;
+    }
+    const nodePaths = /* @__PURE__ */ new Set();
+    const skippedDirectoryNames = /* @__PURE__ */ new Set([".git", ".turbo", "dist", "node_modules", "test-results"]);
+    const visit = (dirPath, depth) => {
+      if (depth > maxDepth) {
+        return;
+      }
+      const packageJsonPath = path.join(dirPath, "package.json");
+      const nodeModulesPath = path.join(dirPath, "node_modules");
+      if (fileSystem.exists(packageJsonPath) && fileSystem.exists(nodeModulesPath)) {
+        nodePaths.add(nodeModulesPath);
+      }
+      if (depth === maxDepth) {
+        return;
+      }
+      for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+        if (skippedDirectoryNames.has(entry.name) || entry.name.startsWith(".")) {
+          continue;
+        }
+        visit(path.join(dirPath, entry.name), depth + 1);
+      }
+    };
+    if (fileSystem.exists(normalizedRoot) && fileSystem.isDirectory(normalizedRoot)) {
+      visit(normalizedRoot, 0);
+    }
+    const resolvedNodePaths = Array.from(nodePaths);
+    workspaceNodePathsCache.set(normalizedRoot, resolvedNodePaths);
+    return resolvedNodePaths;
+  }
+  getFallbackNodePaths(contextRoot) {
+    const nodePaths = /* @__PURE__ */ new Set();
+    const contextNodeModulesPath = path.join(contextRoot, "node_modules");
+    if (fileSystem.exists(contextNodeModulesPath)) {
+      nodePaths.add(contextNodeModulesPath);
+    }
+    for (const workspaceNodePath of this.collectWorkspaceNodePaths(process.cwd())) {
+      nodePaths.add(workspaceNodePath);
+    }
+    return Array.from(nodePaths);
+  }
+  rewriteAliasedRuntimeSpecifiers(result, plugins) {
+    if (!result.success || result.outputs.length === 0) {
+      return result;
+    }
+    const aliasMap = collectRuntimeSpecifierAliasMap(plugins);
+    if (aliasMap.size === 0) {
+      return result;
+    }
+    for (const output of result.outputs) {
+      if (!/\.(?:[cm]?js)$/u.test(output.path)) {
+        continue;
+      }
+      const code = readFileSync(output.path, "utf-8");
+      const rewritten = rewriteRuntimeSpecifierAliases(code, aliasMap);
+      if (rewritten !== code) {
+        writeFileSync(output.path, rewritten);
+      }
+    }
+    return result;
+  }
   escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
@@ -211,7 +286,10 @@ class EsbuildBuildAdapter {
     const importedModule = await import("esbuild");
     const esbuildModule = typeof importedModule.build === "function" ? importedModule : importedModule.default ?? importedModule;
     if (moduleGeneration > 0 && !this.isMockedEsbuildModule(esbuildModule)) {
-      const freshModule = await import(`${pathToFileURL(esbuildRequire.resolve("esbuild")).href}?ecopages_esbuild=${moduleGeneration}`);
+      const freshModule = await import(
+        /* @vite-ignore */
+        `${pathToFileURL(esbuildPath).href}?ecopages_esbuild=${moduleGeneration}`
+      );
       const normalizedFreshModule = typeof freshModule.build === "function" ? freshModule : freshModule.default ?? freshModule;
       if (typeof normalizedFreshModule.build === "function") {
         return normalizedFreshModule;
@@ -251,6 +329,7 @@ class EsbuildBuildAdapter {
     const outdir = path.resolve(options.outdir ?? "dist/assets");
     const tsconfigPath = path.join(contextRoot, "tsconfig.json");
     const tsconfigExists = fileSystem.exists(tsconfigPath);
+    const nodePaths = this.getFallbackNodePaths(contextRoot);
     const plugins = this.getPluginsForBuild(options.plugins);
     const esbuildPlugins = [
       ...plugins.length > 0 ? [this.createEcoPluginBridge(plugins, contextRoot)] : []
@@ -270,6 +349,7 @@ class EsbuildBuildAdapter {
     };
     const result = await esbuild.build({
       absWorkingDir: contextRoot,
+      ...nodePaths.length > 0 ? { nodePaths } : {},
       entryPoints: options.entrypoints,
       bundle: options.bundle ?? true,
       ...outputOptions,
@@ -296,12 +376,15 @@ class EsbuildBuildAdapter {
     }));
     const logs = result.warnings.map((warning) => ({ message: warning.text }));
     const dependencyGraph = this.extractDependencyGraph(result.metafile, contextRoot);
-    return {
-      success: true,
-      logs,
-      outputs,
-      dependencyGraph
-    };
+    return this.rewriteAliasedRuntimeSpecifiers(
+      {
+        success: true,
+        logs,
+        outputs,
+        dependencyGraph
+      },
+      plugins
+    );
   }
   mapEsbuildSourcemap(value) {
     switch (value) {
@@ -407,8 +490,7 @@ class EsbuildBuildAdapter {
    * Resolves module specifiers from a project root.
    */
   resolve(importPath, rootDir) {
-    const localRequire = createRequire(path.join(rootDir, "package.json"));
-    return localRequire.resolve(importPath);
+    return moduleRequire.resolve(importPath, { paths: [rootDir] });
   }
   /**
    * Returns transpile defaults for a known transpile profile.
@@ -418,5 +500,6 @@ class EsbuildBuildAdapter {
   }
 }
 export {
+  ESBUILD_ADAPTER_BRAND,
   EsbuildBuildAdapter
 };

package/src/build/runtime-build-executor.d.ts

@@ -1,12 +1,13 @@
-import type { EcoPagesAppConfig } from '../internal-types.js';
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
 import { type BuildExecutor } from './build-adapter.js';
 /**
  * Installs the app-owned runtime build executor for one app instance.
  *
  * @remarks
- * This is the single coordinator boundary for runtime executor ownership across
- * adapters. It preserves an existing development coordinator when available and
- * always applies app server build plugins through one shared path.
+ * This is the single runtime executor boundary for adapter-owned startup.
+ * Bun-native ownership may reuse `DevBuildCoordinator` in development, while
+ * Vite-host ownership stays on a plain host-owned executor boundary with no
+ * Bun-specific coordination policy.
  */
 export declare function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig, options: {
     development: boolean;

package/src/build/runtime-build-executor.js

@@ -1,17 +1,19 @@
 import {
   getAppBuildAdapter,
   getAppBuildExecutor,
+  getAppBuildOwnership,
   getAppServerBuildPlugins,
   setAppBuildExecutor
 } from "./build-adapter.js";
-import { createOrReuseAppBuildExecutor } from "./dev-build-coordinator.js";
+import { createOrReuseAppBuildExecutor, withBuildExecutorPlugins } from "./dev-build-coordinator.js";
 function installAppRuntimeBuildExecutor(appConfig, options) {
-  const buildExecutor = createOrReuseAppBuildExecutor({
+  const buildOwnership = getAppBuildOwnership(appConfig);
+  const buildExecutor = buildOwnership === "bun-native" ? createOrReuseAppBuildExecutor({
     development: options.development,
     adapter: getAppBuildAdapter(appConfig),
     currentExecutor: getAppBuildExecutor(appConfig),
     getPlugins: () => getAppServerBuildPlugins(appConfig)
-  });
+  }) : withBuildExecutorPlugins(getAppBuildAdapter(appConfig), () => getAppServerBuildPlugins(appConfig));
   setAppBuildExecutor(appConfig, buildExecutor);
   return buildExecutor;
 }

package/src/build/runtime-specifier-alias-plugin.js

@@ -1,3 +1,4 @@
+import { attachRuntimeSpecifierAliasMap } from "./runtime-specifier-aliases.js";
 function toRuntimeSpecifierMap(specifierMap) {
   return specifierMap instanceof Map ? specifierMap : new Map(Object.entries(specifierMap));
 }
@@ -10,21 +11,24 @@ function createRuntimeSpecifierAliasPlugin(specifierMapInput, options) {
     return null;
   }
   const filter = new RegExp(`^(${Array.from(specifierMap.keys()).map(escapeRegExp).join("|")})$`);
-  return {
-    name: options?.name ?? "runtime-specifier-alias",
-    setup(build) {
-      build.onResolve({ filter }, (args) => {
-        const mappedPath = specifierMap.get(args.path);
-        if (!mappedPath) {
-          return void 0;
-        }
-        return {
-          path: mappedPath,
-          external: options?.external ?? true
-        };
-      });
-    }
-  };
+  return attachRuntimeSpecifierAliasMap(
+    {
+      name: options?.name ?? "runtime-specifier-alias",
+      setup(build) {
+        build.onResolve({ filter }, (args) => {
+          const mappedPath = specifierMap.get(args.path);
+          if (!mappedPath) {
+            return void 0;
+          }
+          return {
+            path: mappedPath,
+            external: options?.external ?? true
+          };
+        });
+      }
+    },
+    specifierMap
+  );
 }
 export {
   createRuntimeSpecifierAliasPlugin

package/src/build/runtime-specifier-aliases.d.ts

@@ -0,0 +1,5 @@
+import type { EcoBuildPlugin } from './build-types.js';
+export declare function attachRuntimeSpecifierAliasMap(plugin: EcoBuildPlugin, specifierMap: ReadonlyMap<string, string>): EcoBuildPlugin;
+export declare function getRuntimeSpecifierAliasMap(plugin: EcoBuildPlugin): ReadonlyMap<string, string> | undefined;
+export declare function collectRuntimeSpecifierAliasMap(plugins: EcoBuildPlugin[] | undefined): ReadonlyMap<string, string>;
+export declare function rewriteRuntimeSpecifierAliases(code: string, specifierMap: ReadonlyMap<string, string>): string;

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

@@ -12,8 +12,9 @@ It is responsible for:
 
 - validating integration, processor, and loader registration
 - resolving semantic paths such as `html` and `404` templates
-- creating app-owned runtime state such as the build adapter, build executor, build manifest, dev graph service, runtime specifier registry, and Node runtime manifest
+- 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
 
@@ -23,9 +24,11 @@ It is responsible for:
 ## Ownership Rules
 
 - Integrations and processors declare contributions.
-- `ConfigBuilder.build()` decides ordering and validates compatibility.
+- `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`.

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, 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";
@@ -51,6 +53,7 @@ type RuntimeKind = 'node' | 'bun';
  * @throws {Error} When adding duplicate processors or loaders
  */
 export declare class ConfigBuilder {
+    private buildOwnership;
     config: EcoPagesAppConfig;
     /**
      * Sets the base URL for the application.
@@ -68,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.
@@ -192,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.
      *
@@ -201,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.
      *

package/src/config/config-builder.js

@@ -4,7 +4,7 @@ import {
   DEFAULT_ECOPAGES_HOSTNAME,
   DEFAULT_ECOPAGES_PORT,
   DEFAULT_ECOPAGES_WORK_DIR
-} from "../constants.js";
+} from "../config/constants.js";
 import {
   collectConfiguredAppBuildManifestContributions,
   createBuildAdapter,
@@ -16,14 +16,11 @@ import {
 import { createAppBuildExecutor } from "../build/dev-build-coordinator.js";
 import { GHTML_PLUGIN_NAME, ghtmlPlugin } from "../integrations/ghtml/ghtml.plugin.js";
 import { createEcoComponentMetaPlugin } from "../plugins/eco-component-meta-plugin.js";
+import { createEcoComponentMetaTransform } from "../plugins/eco-component-meta-plugin.js";
 import {
   NoopEntrypointDependencyGraph,
   setAppEntrypointDependencyGraph
 } from "../services/runtime-state/entrypoint-dependency-graph.service.js";
-import {
-  createNodeRuntimeManifest,
-  setAppNodeRuntimeManifest
-} from "../services/runtime-manifest/node-runtime-manifest.service.js";
 import {
   InMemoryRuntimeSpecifierRegistry,
   setAppRuntimeSpecifierRegistry
@@ -47,6 +44,7 @@ const CONFIG_BUILDER_ERRORS = {
   invalidRuntimeVersion: (kind, name, version) => `Cannot validate ${kind} "${name}" runtimeCapability.minRuntimeVersion "${version}" because it is not a dot-separated numeric version`
 };
 class ConfigBuilder {
+  buildOwnership = "bun-native";
   config = {
     baseUrl: "",
     rootDir: ".",
@@ -86,6 +84,7 @@ class ConfigBuilder {
     },
     processors: /* @__PURE__ */ new Map(),
     loaders: /* @__PURE__ */ new Map(),
+    sourceTransforms: /* @__PURE__ */ new Map(),
     workDir: DEFAULT_ECOPAGES_WORK_DIR
   };
   /**
@@ -110,6 +109,18 @@ class ConfigBuilder {
     this.config.rootDir = rootDir;
     return 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) {
+    this.buildOwnership = buildOwnership;
+    return this;
+  }
   /**
    * Sets the source directory relative to the root directory.
    * This directory contains all the source files for the application.
@@ -289,6 +300,17 @@ class ConfigBuilder {
     }
     return this;
   }
+  /**
+   * Sets the source transforms to use for transform-first bundlers such as Vite.
+   * This replaces any existing source transforms.
+   */
+  setSourceTransforms(sourceTransforms) {
+    this.config.sourceTransforms.clear();
+    for (const sourceTransform of sourceTransforms) {
+      this.addSourceTransform(sourceTransform.name, sourceTransform);
+    }
+    return this;
+  }
   /**
    * Adds a loader to the application.
    *
@@ -304,6 +326,18 @@ class ConfigBuilder {
     this.config.loaders.set(name, loader);
     return this;
   }
+  /**
+   * Adds a source transform to the application.
+   *
+   * @throws Error if a source transform with the same name already exists.
+   */
+  addSourceTransform(name, sourceTransform) {
+    if (this.config.sourceTransforms.has(name)) {
+      throw new Error(CONFIG_BUILDER_ERRORS.duplicateLoaderName(name));
+    }
+    this.config.sourceTransforms.set(name, sourceTransform);
+    return this;
+  }
   /**
    * Sets the cache configuration for ISR and page caching.
    *
@@ -507,6 +541,10 @@ class ConfigBuilder {
    * This includes the eco-component-meta-plugin which auto-injects __eco metadata into component configs.
    */
   async initializeDefaultLoaders() {
+    const componentMetaTransform = createEcoComponentMetaTransform({ config: this.config });
+    if (!this.config.sourceTransforms.has(componentMetaTransform.name)) {
+      this.config.sourceTransforms.set(componentMetaTransform.name, componentMetaTransform);
+    }
     const componentMetaPlugin = createEcoComponentMetaPlugin({ config: this.config });
     if (!this.config.loaders.has(componentMetaPlugin.name)) {
       this.config.loaders.set(componentMetaPlugin.name, componentMetaPlugin);
@@ -541,7 +579,7 @@ class ConfigBuilder {
     await this.initializeDefaultLoaders();
     this.initializeProcessors();
     this.validateRuntimeCapabilities();
-    const buildAdapter = createBuildAdapter();
+    const buildAdapter = createBuildAdapter({ ownership: this.buildOwnership });
     setAppBuildAdapter(this.config, buildAdapter);
     updateAppBuildManifest(this.config, await collectConfiguredAppBuildManifestContributions(this.config));
     setAppServerInvalidationState(this.config, new CounterServerInvalidationState());
@@ -555,7 +593,6 @@ class ConfigBuilder {
         getPlugins: () => getAppServerBuildPlugins(this.config)
       })
     );
-    setAppNodeRuntimeManifest(this.config, createNodeRuntimeManifest(this.config));
     return this.config;
   }
 }

package/src/declarations.d.ts

@@ -1,4 +1,4 @@
-import type { EcoPagesAppConfig } from './internal-types';
+import type { EcoPagesAppConfig } from './types/internal-types';
 import type { EcoNavigationRuntime } from './router/client/navigation-coordinator';
 
 type HMRHandler = (url: string) => Promise<void>;

package/src/dev/sc-server.d.ts

@@ -1,5 +1,5 @@
 import type { Server } from 'bun';
-import type { EcoPagesAppConfig } from '../internal-types.js';
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
 type StaticContentServerOptions = {
     port?: number;
 };

package/src/dev/sc-server.js

@@ -1,5 +1,5 @@
 import { extname, join } from "node:path";
-import { STATUS_MESSAGE } from "../constants.js";
+import { STATUS_MESSAGE } from "../config/constants.js";
 import { fileSystem } from "@ecopages/file-system";
 import { ServerUtils } from "../utils/server-utils.module.js";
 import { getRequiredBunRuntime } from "../utils/runtime.js";

package/src/eco/eco.browser.d.ts

@@ -0,0 +1,2 @@
+import type { Eco } from './eco.types.js';
+export declare const eco: Eco;

package/src/eco/eco.browser.js

@@ -0,0 +1,83 @@
+function createComponentFactory(options) {
+  const component2 = ((props) => options.render(props));
+  component2.config = {
+    __eco: options.__eco,
+    integration: options.integration,
+    dependencies: options.dependencies
+  };
+  return component2;
+}
+function component(options) {
+  return createComponentFactory(options);
+}
+function html(options) {
+  return createComponentFactory(options);
+}
+function layout(options) {
+  return createComponentFactory(options);
+}
+function page(options) {
+  const {
+    layout: pageLayout,
+    dependencies,
+    render,
+    staticPaths: staticPaths2,
+    staticProps: staticProps2,
+    metadata: metadata2,
+    cache,
+    requires,
+    middleware
+  } = options;
+  const pageComponent = createComponentFactory({
+    __eco: options.__eco,
+    integration: options.integration,
+    dependencies: pageLayout ? {
+      ...dependencies,
+      components: [...dependencies?.components ?? [], pageLayout]
+    } : dependencies,
+    render
+  });
+  if (pageLayout && pageComponent.config) {
+    pageComponent.config.layout = pageLayout;
+  }
+  if (staticPaths2) {
+    pageComponent.staticPaths = staticPaths2;
+  }
+  if (staticProps2) {
+    pageComponent.staticProps = staticProps2;
+  }
+  if (metadata2) {
+    pageComponent.metadata = metadata2;
+  }
+  if (cache) {
+    pageComponent.cache = cache;
+  }
+  if (requires) {
+    pageComponent.requires = requires;
+  }
+  if (middleware) {
+    pageComponent.middleware = middleware;
+  }
+  return pageComponent;
+}
+function metadata(fn) {
+  return fn;
+}
+function staticPaths(fn) {
+  return fn;
+}
+function staticProps(fn) {
+  return fn;
+}
+const eco = {
+  component,
+  html,
+  layout,
+  page,
+  metadata,
+  staticPaths,
+  staticProps
+};
+export {
+  eco
+};