@ecopages/core 0.2.0-alpha.3 → 0.2.0-alpha.31

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

@@ -0,0 +1,118 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import { type ServerInvalidationState } from './server-invalidation-state.service.js';
+import { type EntrypointDependencyGraph } from './entrypoint-dependency-graph.service.js';
+/**
+ * Tracks development-time dependency relationships and invalidation state for
+ * one Ecopages app instance.
+ *
+ * @remarks
+ * The current contract stays intentionally small. It supports today's needs for
+ * server-module cache invalidation and entrypoint-to-dependency lookups without
+ * forcing the rest of the runtime to know about one specific graph
+ * implementation.
+ */
+export interface DevGraphService extends ServerInvalidationState, EntrypointDependencyGraph {
+}
+/**
+ * Minimal dev-graph implementation used when an app has no selective graph
+ * metadata available.
+ *
+ * @remarks
+ * This preserves correct behavior by using coarse invalidation version bumps.
+ * Callers still pass changed-file information through the interface now so a
+ * richer graph can become more selective later without changing call sites.
+ */
+export declare class NoopDevGraphService implements DevGraphService {
+    private readonly invalidationState;
+    private readonly dependencyGraph;
+    /**
+     * Returns the current coarse invalidation version.
+     */
+    getServerInvalidationVersion(): number;
+    /**
+     * Invalidates all server-side module state by incrementing the shared version.
+     */
+    invalidateServerModules(changedFiles?: string[]): void;
+    /**
+     * Indicates that this graph cannot target invalidation to one entrypoint set.
+     */
+    supportsSelectiveInvalidation(): boolean;
+    /**
+     * Returns an empty entrypoint set because this implementation stores no
+     * dependency graph metadata.
+     */
+    getDependencyEntrypoints(filePath: string): Set<string>;
+    /**
+     * Accepts dependency updates to preserve interface compatibility, but stores no
+     * graph state in the noop implementation.
+     */
+    setEntrypointDependencies(entrypointPath: string, dependencies: string[]): void;
+    /**
+     * Clears one entrypoint from the graph.
+     *
+     * @remarks
+     * There is no stored graph state in this implementation, so this is a no-op.
+     */
+    clearEntrypointDependencies(entrypointPath: string): void;
+    /**
+     * Resets graph-owned state for a fresh runtime cycle.
+     */
+    reset(): void;
+}
+/**
+ * In-memory development graph with entrypoint-to-dependency reverse lookups.
+ *
+ * @remarks
+ * This is the current selective graph implementation used by development flows
+ * that need to answer which entrypoints depend on a changed file while still
+ * keeping invalidation state app-local.
+ */
+export declare class InMemoryDevGraphService implements DevGraphService {
+    private readonly invalidationState;
+    private readonly dependencyGraph;
+    /**
+     * Returns the current app-local server invalidation version.
+     */
+    getServerInvalidationVersion(): number;
+    /**
+     * 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?: string[]): void;
+    /**
+     * Indicates that this graph can answer dependency-to-entrypoint lookups.
+     */
+    supportsSelectiveInvalidation(): boolean;
+    /**
+     * Returns all known entrypoints that currently depend on the given file.
+     */
+    getDependencyEntrypoints(filePath: string): Set<string>;
+    /**
+     * 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: string, dependencies: string[]): void;
+    /**
+     * Removes one entrypoint and all of its reverse dependency edges.
+     */
+    clearEntrypointDependencies(entrypointPath: string): void;
+    /**
+     * Clears all graph state and starts a fresh invalidation generation.
+     */
+    reset(): void;
+}
+/**
+ * Returns the dev-graph service owned by one app instance.
+ */
+export declare function getAppDevGraphService(appConfig: EcoPagesAppConfig): DevGraphService;
+/**
+ * Installs the dev-graph service that should back one app/runtime instance.
+ */
+export declare function setAppDevGraphService(appConfig: EcoPagesAppConfig, devGraphService: DevGraphService): void;

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

@@ -0,0 +1,162 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,35 @@
+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/{schema-validation-service.d.ts → validation/schema-validation-service.d.ts}

@@ -1,4 +1,4 @@
-import type { StandardSchema } from './validation/standard-schema.types.js';
+import type { StandardSchema } from './standard-schema.types.js';
 export interface ValidationResult<T = unknown> {
     success: boolean;
     data?: T;

package/src/static-site-generator/README.md

@@ -0,0 +1,26 @@
+# Static Site Generation
+
+This directory contains the static-build execution path used when Ecopages renders pages ahead of time.
+
+## Purpose
+
+The static-site generator reuses the same app-owned config, route matching, and rendering services that development and preview flows use, but drives them in a build-oriented loop.
+
+It is responsible for:
+
+- enumerating renderable routes
+- rendering static outputs through the normal rendering pipeline
+- respecting route-level constraints such as cache policy and unsupported dynamic server-only paths
+
+## Design Rule
+
+Static generation should follow the same ownership model as runtime rendering.
+
+That means it should reuse:
+
+- built app config
+- route matching
+- render orchestration
+- asset processing
+
+It should not invent a parallel rendering stack just for build mode.

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

@@ -1,7 +1,14 @@
-import type { EcoPagesAppConfig } from '../internal-types.js';
-import type { StaticRoute } from '../public-types.js';
-import type { RouteRendererFactory } from '../route-renderer/route-renderer.js';
-import type { FSRouter } from '../router/fs-router.js';
+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;
@@ -9,27 +16,70 @@ export declare const STATIC_SITE_GENERATOR_ERRORS: {
     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;
     /**
-     * Extracts dynamic parameters from the actual path based on the template path.
+     * Generates static output for all filesystem-discovered routes.
      *
-     * @param templatePath - The template path (e.g., "/blog/[slug]")
-     * @param actualPath - The actual path (e.g., "/blog/my-post")
-     * @returns A record of extracted parameters (e.g., { slug: "my-post" })
+     * @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.
      */
-    private extractParams;
-    generateStaticPages(router: FSRouter, baseUrl: string, routeRendererFactory?: RouteRendererFactory): Promise<void>;
     run({ router, baseUrl, routeRendererFactory, staticRoutes, }: {
-        router: FSRouter;
+        router: StaticGenerationRouteSource;
         baseUrl: string;
-        routeRendererFactory?: RouteRendererFactory;
+        routeRendererFactory?: StaticGenerationRendererFactory;
         staticRoutes?: StaticRoute[];
     }): Promise<void>;
     /**
@@ -37,14 +87,10 @@ export declare class StaticSiteGenerator {
      * These routes use eco.page views via loader functions for HMR support.
      */
     private generateExplicitStaticPages;
-    /**
-     * Generate a single static page for a non-dynamic route.
-     */
-    private generateSingleStaticRoute;
-    /**
-     * Generate static pages for a dynamic route using staticPaths.
-     */
-    private generateDynamicStaticRoute;
+    private generateExplicitStaticRoute;
+    private planExplicitStaticRoute;
+    private createExplicitStaticContents;
+    private listExplicitStaticRouteEntries;
     /**
      * Resolve a route path template with actual params.
      * Supports both :param and [param] syntax.
@@ -55,3 +101,4 @@ export declare class StaticSiteGenerator {
      */
     private getOutputPath;
 }
+export {};