@ecopages/core 0.2.0-alpha.52 → 0.2.0-alpha.54

package/src/services/runtime-state/dev-graph.service.js

@@ -1,162 +0,0 @@
-import {
-  CounterServerInvalidationState,
-  getAppServerInvalidationState,
-  setAppServerInvalidationState
-} from "./server-invalidation-state.service.js";
-import {
-  getAppEntrypointDependencyGraph,
-  InMemoryEntrypointDependencyGraph,
-  NoopEntrypointDependencyGraph,
-  setAppEntrypointDependencyGraph
-} from "./entrypoint-dependency-graph.service.js";
-class NoopDevGraphService {
-  invalidationState = new CounterServerInvalidationState();
-  dependencyGraph = new NoopEntrypointDependencyGraph();
-  /**
-   * Returns the current coarse invalidation version.
-   */
-  getServerInvalidationVersion() {
-    return this.invalidationState.getServerInvalidationVersion();
-  }
-  /**
-   * Invalidates all server-side module state by incrementing the shared version.
-   */
-  invalidateServerModules(changedFiles) {
-    this.invalidationState.invalidateServerModules(changedFiles);
-  }
-  /**
-   * Indicates that this graph cannot target invalidation to one entrypoint set.
-   */
-  supportsSelectiveInvalidation() {
-    return this.dependencyGraph.supportsSelectiveInvalidation();
-  }
-  /**
-   * Returns an empty entrypoint set because this implementation stores no
-   * dependency graph metadata.
-   */
-  getDependencyEntrypoints(filePath) {
-    return this.dependencyGraph.getDependencyEntrypoints(filePath);
-  }
-  /**
-   * Accepts dependency updates to preserve interface compatibility, but stores no
-   * graph state in the noop implementation.
-   */
-  setEntrypointDependencies(entrypointPath, dependencies) {
-    this.dependencyGraph.setEntrypointDependencies(entrypointPath, dependencies);
-  }
-  /**
-   * Clears one entrypoint from the graph.
-   *
-   * @remarks
-   * There is no stored graph state in this implementation, so this is a no-op.
-   */
-  clearEntrypointDependencies(entrypointPath) {
-    this.dependencyGraph.clearEntrypointDependencies(entrypointPath);
-  }
-  /**
-   * Resets graph-owned state for a fresh runtime cycle.
-   */
-  reset() {
-    this.invalidationState.reset();
-    this.dependencyGraph.reset();
-  }
-}
-class InMemoryDevGraphService {
-  invalidationState = new CounterServerInvalidationState();
-  dependencyGraph = new InMemoryEntrypointDependencyGraph();
-  /**
-   * Returns the current app-local server invalidation version.
-   */
-  getServerInvalidationVersion() {
-    return this.invalidationState.getServerInvalidationVersion();
-  }
-  /**
-   * Invalidates the current server-module cache generation.
-   *
-   * @remarks
-   * The current implementation still uses a coarse generation bump for server
-   * modules. Selective dependency lookups are used by callers that need to limit
-   * browser rebuild work.
-   */
-  invalidateServerModules(changedFiles) {
-    this.invalidationState.invalidateServerModules(changedFiles);
-  }
-  /**
-   * Indicates that this graph can answer dependency-to-entrypoint lookups.
-   */
-  supportsSelectiveInvalidation() {
-    return this.dependencyGraph.supportsSelectiveInvalidation();
-  }
-  /**
-   * Returns all known entrypoints that currently depend on the given file.
-   */
-  getDependencyEntrypoints(filePath) {
-    return this.dependencyGraph.getDependencyEntrypoints(filePath);
-  }
-  /**
-   * Replaces the stored dependency set for one entrypoint.
-   *
-   * @remarks
-   * The entrypoint itself is always included in its own dependency set so reverse
-   * lookups can map a changed entry file back to that same entrypoint.
-   */
-  setEntrypointDependencies(entrypointPath, dependencies) {
-    this.dependencyGraph.setEntrypointDependencies(entrypointPath, dependencies);
-  }
-  /**
-   * Removes one entrypoint and all of its reverse dependency edges.
-   */
-  clearEntrypointDependencies(entrypointPath) {
-    this.dependencyGraph.clearEntrypointDependencies(entrypointPath);
-  }
-  /**
-   * Clears all graph state and starts a fresh invalidation generation.
-   */
-  reset() {
-    this.invalidationState.reset();
-    this.dependencyGraph.reset();
-  }
-}
-function getAppDevGraphService(appConfig) {
-  if (appConfig.runtime?.devGraphService) {
-    return appConfig.runtime.devGraphService;
-  }
-  const serverInvalidationState = getAppServerInvalidationState(appConfig);
-  const entrypointDependencyGraph = getAppEntrypointDependencyGraph(appConfig);
-  return {
-    getServerInvalidationVersion: () => serverInvalidationState.getServerInvalidationVersion(),
-    invalidateServerModules: (changedFiles) => serverInvalidationState.invalidateServerModules(changedFiles),
-    supportsSelectiveInvalidation: () => entrypointDependencyGraph.supportsSelectiveInvalidation(),
-    getDependencyEntrypoints: (filePath) => entrypointDependencyGraph.getDependencyEntrypoints(filePath),
-    setEntrypointDependencies: (entrypointPath, dependencies) => entrypointDependencyGraph.setEntrypointDependencies(entrypointPath, dependencies),
-    clearEntrypointDependencies: (entrypointPath) => entrypointDependencyGraph.clearEntrypointDependencies(entrypointPath),
-    reset: () => {
-      serverInvalidationState.reset();
-      entrypointDependencyGraph.reset();
-    }
-  };
-}
-function setAppDevGraphService(appConfig, devGraphService) {
-  setAppServerInvalidationState(appConfig, {
-    getServerInvalidationVersion: () => devGraphService.getServerInvalidationVersion(),
-    invalidateServerModules: (changedFiles) => devGraphService.invalidateServerModules(changedFiles),
-    reset: () => devGraphService.reset()
-  });
-  setAppEntrypointDependencyGraph(appConfig, {
-    supportsSelectiveInvalidation: () => devGraphService.supportsSelectiveInvalidation(),
-    getDependencyEntrypoints: (filePath) => devGraphService.getDependencyEntrypoints(filePath),
-    setEntrypointDependencies: (entrypointPath, dependencies) => devGraphService.setEntrypointDependencies(entrypointPath, dependencies),
-    clearEntrypointDependencies: (entrypointPath) => devGraphService.clearEntrypointDependencies(entrypointPath),
-    reset: () => devGraphService.reset()
-  });
-  appConfig.runtime = {
-    ...appConfig.runtime ?? {},
-    devGraphService
-  };
-}
-export {
-  InMemoryDevGraphService,
-  NoopDevGraphService,
-  getAppDevGraphService,
-  setAppDevGraphService
-};

package/src/services/runtime-state/entrypoint-dependency-graph.service.d.ts

@@ -1,41 +0,0 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-/**
- * App-owned dependency graph used to target browser entrypoint rebuilds.
- */
-export interface EntrypointDependencyGraph {
-    supportsSelectiveInvalidation(): boolean;
-    getDependencyEntrypoints(filePath: string): Set<string>;
-    setEntrypointDependencies(entrypointPath: string, dependencies: string[]): void;
-    clearEntrypointDependencies(entrypointPath: string): void;
-    reset(): void;
-}
-/**
- * Graph implementation for runtimes that rebuild every watched entrypoint.
- */
-export declare class NoopEntrypointDependencyGraph implements EntrypointDependencyGraph {
-    supportsSelectiveInvalidation(): boolean;
-    getDependencyEntrypoints(_filePath: string): Set<string>;
-    setEntrypointDependencies(_entrypointPath: string, _dependencies: string[]): void;
-    clearEntrypointDependencies(_entrypointPath: string): void;
-    reset(): void;
-}
-/**
- * In-memory entrypoint-to-dependency graph with reverse dependency lookups.
- */
-export declare class InMemoryEntrypointDependencyGraph implements EntrypointDependencyGraph {
-    private readonly dependencyEntrypoints;
-    private readonly entrypointDependencies;
-    supportsSelectiveInvalidation(): boolean;
-    getDependencyEntrypoints(filePath: string): Set<string>;
-    setEntrypointDependencies(entrypointPath: string, dependencies: string[]): void;
-    clearEntrypointDependencies(entrypointPath: string): void;
-    reset(): void;
-}
-/**
- * Returns the app-owned entrypoint dependency graph.
- */
-export declare function getAppEntrypointDependencyGraph(appConfig: EcoPagesAppConfig): EntrypointDependencyGraph;
-/**
- * Installs the dependency graph used by one app instance.
- */
-export declare function setAppEntrypointDependencyGraph(appConfig: EcoPagesAppConfig, entrypointDependencyGraph: EntrypointDependencyGraph): void;

package/src/services/runtime-state/entrypoint-dependency-graph.service.js

@@ -1,85 +0,0 @@
-import path from "node:path";
-class NoopEntrypointDependencyGraph {
-  supportsSelectiveInvalidation() {
-    return false;
-  }
-  getDependencyEntrypoints(_filePath) {
-    return /* @__PURE__ */ new Set();
-  }
-  setEntrypointDependencies(_entrypointPath, _dependencies) {
-  }
-  clearEntrypointDependencies(_entrypointPath) {
-  }
-  reset() {
-  }
-}
-class InMemoryEntrypointDependencyGraph {
-  dependencyEntrypoints = /* @__PURE__ */ new Map();
-  entrypointDependencies = /* @__PURE__ */ new Map();
-  supportsSelectiveInvalidation() {
-    return true;
-  }
-  getDependencyEntrypoints(filePath) {
-    return new Set(this.dependencyEntrypoints.get(path.resolve(filePath)) ?? []);
-  }
-  setEntrypointDependencies(entrypointPath, dependencies) {
-    const normalizedEntrypoint = path.resolve(entrypointPath);
-    this.clearEntrypointDependencies(normalizedEntrypoint);
-    const normalizedDependencies = /* @__PURE__ */ new Set([
-      normalizedEntrypoint,
-      ...dependencies.map((dependencyPath) => path.resolve(dependencyPath))
-    ]);
-    this.entrypointDependencies.set(normalizedEntrypoint, normalizedDependencies);
-    for (const dependencyPath of normalizedDependencies) {
-      const entrypoints = this.dependencyEntrypoints.get(dependencyPath) ?? /* @__PURE__ */ new Set();
-      entrypoints.add(normalizedEntrypoint);
-      this.dependencyEntrypoints.set(dependencyPath, entrypoints);
-    }
-  }
-  clearEntrypointDependencies(entrypointPath) {
-    const normalizedEntrypoint = path.resolve(entrypointPath);
-    const previousDependencies = this.entrypointDependencies.get(normalizedEntrypoint);
-    if (!previousDependencies) {
-      return;
-    }
-    for (const dependencyPath of previousDependencies) {
-      const entrypoints = this.dependencyEntrypoints.get(dependencyPath);
-      if (!entrypoints) {
-        continue;
-      }
-      entrypoints.delete(normalizedEntrypoint);
-      if (entrypoints.size === 0) {
-        this.dependencyEntrypoints.delete(dependencyPath);
-      }
-    }
-    this.entrypointDependencies.delete(normalizedEntrypoint);
-  }
-  reset() {
-    this.dependencyEntrypoints.clear();
-    this.entrypointDependencies.clear();
-  }
-}
-function isLegacyEntrypointDependencyGraph(value) {
-  return Boolean(value) && typeof value === "object" && typeof value.supportsSelectiveInvalidation === "function" && typeof value.getDependencyEntrypoints === "function" && typeof value.setEntrypointDependencies === "function" && typeof value.clearEntrypointDependencies === "function" && typeof value.reset === "function";
-}
-function getAppEntrypointDependencyGraph(appConfig) {
-  if (appConfig.runtime?.entrypointDependencyGraph) {
-    return appConfig.runtime.entrypointDependencyGraph;
-  }
-  if (isLegacyEntrypointDependencyGraph(appConfig.runtime?.devGraphService)) {
-    return appConfig.runtime.devGraphService;
-  }
-  return new NoopEntrypointDependencyGraph();
-}
-function setAppEntrypointDependencyGraph(appConfig, entrypointDependencyGraph) {
-  appConfig.runtime = {
-    ...appConfig.runtime ?? {},
-    entrypointDependencyGraph
-  };
-}
-export {
-  InMemoryEntrypointDependencyGraph,
-  NoopEntrypointDependencyGraph,
-  getAppEntrypointDependencyGraph,
-  setAppEntrypointDependencyGraph
-};

package/src/services/runtime-state/server-invalidation-state.service.d.ts

@@ -1,26 +0,0 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-/**
- * App-owned coarse invalidation state for server-executed modules.
- */
-export interface ServerInvalidationState {
-    getServerInvalidationVersion(): number;
-    invalidateServerModules(changedFiles?: string[]): void;
-    reset(): void;
-}
-/**
- * Minimal app-local invalidation state backed by a single generation counter.
- */
-export declare class CounterServerInvalidationState implements ServerInvalidationState {
-    private serverInvalidationVersion;
-    getServerInvalidationVersion(): number;
-    invalidateServerModules(_changedFiles?: string[]): void;
-    reset(): void;
-}
-/**
- * Returns the app-owned server invalidation state.
- */
-export declare function getAppServerInvalidationState(appConfig: EcoPagesAppConfig): ServerInvalidationState;
-/**
- * Installs the invalidation state used by one app instance.
- */
-export declare function setAppServerInvalidationState(appConfig: EcoPagesAppConfig, serverInvalidationState: ServerInvalidationState): void;

package/src/services/runtime-state/server-invalidation-state.service.js

@@ -1,35 +0,0 @@
-class CounterServerInvalidationState {
-  serverInvalidationVersion = 0;
-  getServerInvalidationVersion() {
-    return this.serverInvalidationVersion;
-  }
-  invalidateServerModules(_changedFiles) {
-    this.serverInvalidationVersion += 1;
-  }
-  reset() {
-    this.serverInvalidationVersion += 1;
-  }
-}
-function isLegacyServerInvalidationState(value) {
-  return Boolean(value) && typeof value === "object" && typeof value.getServerInvalidationVersion === "function" && typeof value.invalidateServerModules === "function" && typeof value.reset === "function";
-}
-function getAppServerInvalidationState(appConfig) {
-  if (appConfig.runtime?.serverInvalidationState) {
-    return appConfig.runtime.serverInvalidationState;
-  }
-  if (isLegacyServerInvalidationState(appConfig.runtime?.devGraphService)) {
-    return appConfig.runtime.devGraphService;
-  }
-  return new CounterServerInvalidationState();
-}
-function setAppServerInvalidationState(appConfig, serverInvalidationState) {
-  appConfig.runtime = {
-    ...appConfig.runtime ?? {},
-    serverInvalidationState
-  };
-}
-export {
-  CounterServerInvalidationState,
-  getAppServerInvalidationState,
-  setAppServerInvalidationState
-};

package/src/services/validation/schema-validation-service.d.ts

@@ -1,122 +0,0 @@
-import type { StandardSchema } from './standard-schema.types.js';
-export interface ValidationResult<T = unknown> {
-    success: boolean;
-    data?: T;
-    errors?: Array<{
-        message: string;
-        path?: Array<string | number>;
-    }>;
-}
-export interface ValidationSource {
-    body?: unknown;
-    query?: Record<string, string>;
-    headers?: Record<string, string>;
-    params?: Record<string, string>;
-}
-export interface ValidationSchemas {
-    body?: StandardSchema;
-    query?: StandardSchema;
-    headers?: StandardSchema;
-    params?: StandardSchema;
-}
-export interface ValidatedData {
-    body?: unknown;
-    query?: unknown;
-    headers?: unknown;
-    params?: unknown;
-}
-/**
- * Service for validating request data using Standard Schema compliant validators.
- *
- * This service provides a unified interface for validating HTTP request data (body, query parameters, headers)
- * using any validation library that implements the Standard Schema specification.
- *
- * @example Using with Zod
- * ```typescript
- * import { z } from 'zod';
- * import { SchemaValidationService } from './schema-validation-service.js';
- *
- * const service = new SchemaValidationService();
- * const result = await service.validateRequest(
- *   { body: { title: 'Hello', count: 42 } },
- *   { body: z.object({ title: z.string(), count: z.number() }) }
- * );
- *
- * if (result.success) {
- *   console.log(result.data.body);
- * }
- * ```
- *
- * @example Using with Valibot
- * ```typescript
- * import * as v from 'valibot';
- *
- * const result = await service.validateRequest(
- *   { query: { page: '1' } },
- *   { query: v.object({ page: v.string() }) }
- * );
- * ```
- *
- * @example Using with ArkType
- * ```typescript
- * import { type } from 'arktype';
- *
- * const result = await service.validateRequest(
- *   { headers: { 'authorization': 'Bearer token' } },
- *   { headers: type({ authorization: 'string' }) }
- * );
- * ```
- *
- * @example Multiple sources
- * ```typescript
- * const result = await service.validateRequest(
- *   {
- *     body: { title: 'Post' },
- *     query: { format: 'json' },
- *     headers: { 'content-type': 'application/json' }
- *   },
- *   {
- *     body: z.object({ title: z.string() }),
- *     query: v.object({ format: v.string() }),
- *     headers: type({ 'content-type': 'string' })
- *   }
- * );
- * ```
- *
- * Supported libraries: Zod, Valibot, ArkType, Effect Schema (with standardSchemaV1 wrapper)
- */
-export declare class SchemaValidationService {
-    /**
-     * Validates request data against provided schemas.
-     *
-     * Validates body, query parameters, and headers against their respective schemas.
-     * All validations are performed, and errors are aggregated from all sources.
-     *
-     * @param source - The data to validate (body, query, headers)
-     * @param schemas - The Standard Schema validators for each source
-     * @returns Validation result with validated data or aggregated errors
-     *
-     * @example
-     * ```typescript
-     * const result = await service.validateRequest(
-     *   { body: { name: 'John', age: 30 } },
-     *   { body: z.object({ name: z.string(), age: z.number() }) }
-     * );
-     *
-     * if (result.success) {
-     *   const validated = result.data.body;
-     * } else {
-     *   console.error(result.errors);
-     * }
-     * ```
-     */
-    validateRequest(source: ValidationSource, schemas: ValidationSchemas): Promise<ValidationResult<ValidatedData>>;
-    /**
-     * Validates a single value against a Standard Schema.
-     *
-     * @param schema - The Standard Schema validator
-     * @param data - The data to validate
-     * @returns Validation result with validated data or errors
-     */
-    private validateWithSchema;
-}

package/src/services/validation/schema-validation-service.js

@@ -1,101 +0,0 @@
-class SchemaValidationService {
-  /**
-   * Validates request data against provided schemas.
-   *
-   * Validates body, query parameters, and headers against their respective schemas.
-   * All validations are performed, and errors are aggregated from all sources.
-   *
-   * @param source - The data to validate (body, query, headers)
-   * @param schemas - The Standard Schema validators for each source
-   * @returns Validation result with validated data or aggregated errors
-   *
-   * @example
-   * ```typescript
-   * const result = await service.validateRequest(
-   *   { body: { name: 'John', age: 30 } },
-   *   { body: z.object({ name: z.string(), age: z.number() }) }
-   * );
-   *
-   * if (result.success) {
-   *   const validated = result.data.body;
-   * } else {
-   *   console.error(result.errors);
-   * }
-   * ```
-   */
-  async validateRequest(source, schemas) {
-    const validated = {};
-    const allErrors = [];
-    if (schemas.body && source.body !== void 0) {
-      const result = await this.validateWithSchema(schemas.body, source.body);
-      if (!result.success) {
-        allErrors.push(...result.errors || []);
-      } else {
-        validated.body = result.data;
-      }
-    }
-    if (schemas.query && source.query) {
-      const result = await this.validateWithSchema(schemas.query, source.query);
-      if (!result.success) {
-        allErrors.push(...result.errors || []);
-      } else {
-        validated.query = result.data;
-      }
-    }
-    if (schemas.headers && source.headers) {
-      const result = await this.validateWithSchema(schemas.headers, source.headers);
-      if (!result.success) {
-        allErrors.push(...result.errors || []);
-      } else {
-        validated.headers = result.data;
-      }
-    }
-    if (schemas.params && source.params) {
-      const result = await this.validateWithSchema(schemas.params, source.params);
-      if (!result.success) {
-        allErrors.push(...result.errors || []);
-      } else {
-        validated.params = result.data;
-      }
-    }
-    if (allErrors.length > 0) {
-      return { success: false, errors: allErrors };
-    }
-    return { success: true, data: validated };
-  }
-  /**
-   * Validates a single value against a Standard Schema.
-   *
-   * @param schema - The Standard Schema validator
-   * @param data - The data to validate
-   * @returns Validation result with validated data or errors
-   */
-  async validateWithSchema(schema, data) {
-    try {
-      const resultOrPromise = schema["~standard"].validate(data);
-      const result = resultOrPromise instanceof Promise ? await resultOrPromise : resultOrPromise;
-      if (result.issues) {
-        return {
-          success: false,
-          errors: result.issues.map((issue) => ({
-            message: issue.message,
-            path: issue.path?.map((p) => typeof p === "object" && "key" in p ? p.key : p)
-          }))
-        };
-      }
-      return { success: true, data: result.value };
-    } catch (error) {
-      return {
-        success: false,
-        errors: [
-          {
-            message: error instanceof Error ? error.message : "Validation failed"
-          }
-        ]
-      };
-    }
-  }
-}
-export {
-  SchemaValidationService
-};

package/src/static-site-generator/static-site-generator.d.ts

@@ -1,104 +0,0 @@
-import type { EcoPagesAppConfig } from '../types/internal-types.js';
-import type { StaticRoute } from '../types/public-types.js';
-import type { PageRendererResolver, StaticGenerationRendererResolver } from '../route-renderer/route-renderer.js';
-import type { StaticGenerationRoute } from '../router/server/route-registry.js';
-type StaticGenerationRouteSource = {
-    listStaticGenerationRoutes(input: {
-        runtimeOrigin: string;
-    }): Promise<readonly StaticGenerationRoute[]>;
-};
-type StaticPageRouteRendererFactory = PageRendererResolver;
-type StaticGenerationRendererFactory = StaticGenerationRendererResolver;
-export declare const STATIC_SITE_GENERATOR_ERRORS: {
-    readonly ROUTE_RENDERER_FACTORY_REQUIRED: "RouteRendererFactory is required for render strategy";
-    readonly unsupportedBodyType: (bodyType: string) => string;
-    readonly missingIntegration: (routePath: string) => string;
-    readonly noRendererForIntegration: (integrationName: string) => string;
-    readonly dynamicRouteRequiresStaticPaths: (routePath: string) => string;
-};
-/**
- * Generates static output files from the finalized app config and route graph.
- *
- * @remarks
- * This class intentionally reuses the same routing, renderer, and server-module
- * loading seams used by runtime rendering. Static generation should be a build
- * loop over the normal app model, not a parallel rendering stack with different
- * semantics.
- */
-export declare class StaticSiteGenerator {
-    appConfig: EcoPagesAppConfig;
-    /**
-     * Creates the static-site generator for one app config.
-     */
-    constructor({ appConfig }: {
-        appConfig: EcoPagesAppConfig;
-    });
-    private getExportDir;
-    /**
-     * Logs the standardized warning emitted when a dynamic-cache page is skipped.
-     */
-    private warnDynamicPageSkipped;
-    /**
-     * Determines whether one filesystem-discovered page should be excluded from
-     * static generation.
-     */
-    private shouldSkipStaticPageFile;
-    /**
-     * Determines whether one explicit static route view should be excluded from
-     * static generation.
-     */
-    private shouldSkipStaticView;
-    /**
-     * Writes the robots.txt file declared by the app config.
-     */
-    generateRobotsTxt(): void;
-    /**
-     * Returns whether the input path points at the root directory.
-     */
-    isRootDir(path: string): boolean | null;
-    /**
-     * Collects parent directories that must exist for the generated route set.
-     */
-    getDirectories(routes: string[]): string[];
-    private writeStaticOutput;
-    private getStaticBuildStrategy;
-    private createFilesystemStaticContents;
-    /**
-     * Generates static output for all filesystem-discovered routes.
-     *
-     * @remarks
-     * Routes whose integrations opt into fetch-based static builds are rendered by
-     * issuing a request against the running server origin. Render-strategy routes
-     * go through the normal route renderer directly.
-     */
-    generateStaticPages(router: StaticGenerationRouteSource, baseUrl: string, routeRendererFactory?: StaticPageRouteRendererFactory): Promise<void>;
-    private resolveStaticFetchUrl;
-    /**
-     * Executes the full static-generation workflow for one app run.
-     */
-    run({ router, baseUrl, routeRendererFactory, staticRoutes, }: {
-        router: StaticGenerationRouteSource;
-        baseUrl: string;
-        routeRendererFactory?: StaticGenerationRendererFactory;
-        staticRoutes?: StaticRoute[];
-    }): Promise<void>;
-    /**
-     * Generates static pages from explicit static routes registered via app.static().
-     * These routes use eco.page views via loader functions for HMR support.
-     */
-    private generateExplicitStaticPages;
-    private generateExplicitStaticRoute;
-    private planExplicitStaticRoute;
-    private createExplicitStaticContents;
-    private listExplicitStaticRouteEntries;
-    /**
-     * Resolve a route path template with actual params.
-     * Supports both :param and [param] syntax.
-     */
-    private resolveRoutePath;
-    /**
-     * Get the output file path for a given route.
-     */
-    private getOutputPath;
-}
-export {};