@ecopages/core 0.2.0-beta.21 → 0.2.0-beta.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/core",
-  "version": "0.2.0-beta.21",
+  "version": "0.2.0-beta.23",
   "description": "Core package for Ecopages",
   "keywords": [
     "ecopages",
@@ -17,7 +17,7 @@
     "directory": "packages/core"
   },
   "dependencies": {
-    "@ecopages/file-system": "0.2.0-beta.21",
+    "@ecopages/file-system": "0.2.0-beta.23",
     "@ecopages/logger": "^0.2.3",
     "@ecopages/scripts-injector": "^0.1.5",
     "@oxc-project/runtime": "0.134.0",
@@ -27,7 +27,9 @@
     "ghtml": "^4.0.2",
     "oxc-parser": "^0.124.0",
     "rolldown": "^1.1.0",
-    "ws": "^8.20.1"
+    "ws": "^8.20.1",
+    "@standard-schema/spec": "^1.1.0",
+    "@standard-schema/utils": "^0.3.0"
   },
   "exports": {
     ".": {

package/src/adapters/shared/server-adapter.d.ts

@@ -27,6 +27,7 @@ export declare abstract class SharedServerAdapter<TOptions extends ServerAdapter
         staticRoutes: StaticRoute[];
         hmrManager?: any;
     }): Promise<void>;
+    private ensureRouteRendererFactory;
     protected createSharedWatchRefreshCallback(options: {
         staticRoutes: StaticRoute[];
         hmrManager?: any;

package/src/adapters/shared/server-adapter.js

@@ -29,9 +29,20 @@ class SharedServerAdapter extends AbstractServerAdapter {
   schemaValidator = new SchemaValidationService();
   hostOwnsDevClient = false;
   async initializeSharedRouteHandling(options) {
+    this.ensureRouteRendererFactory();
     await this.initSharedRouter();
     this.configureSharedResponseHandlers(options.staticRoutes, options.hmrManager);
   }
+  ensureRouteRendererFactory() {
+    if (this.routeRendererFactory) {
+      return;
+    }
+    this.routeRendererFactory = new RouteRendererFactory({
+      appConfig: this.appConfig,
+      rendererModules: this.appConfig.runtime?.rendererModuleContext,
+      runtimeOrigin: this.runtimeOrigin
+    });
+  }
   createSharedWatchRefreshCallback(options) {
     return async () => {
       try {
@@ -71,16 +82,10 @@ class SharedServerAdapter extends AbstractServerAdapter {
     await this.router.init();
   }
   createRouteRegistryPageModuleAdapter() {
-    const serverModuleTranspiler = getAppServerModuleTranspiler(this.appConfig);
+    this.ensureRouteRendererFactory();
     return {
       loadPageModule: async (filePath) => {
-        const module = await serverModuleTranspiler.importModule({
-          filePath,
-          outdir: path.join(resolveInternalExecutionDir(this.appConfig), ".server-route-modules"),
-          externalPackages: true,
-          transpileErrorMessage: (details) => `Error transpiling route module: ${details}`,
-          noOutputMessage: (targetFilePath) => `No transpiled output generated for route module: ${targetFilePath}`
-        });
+        const module = await this.routeRendererFactory.getPageRenderer(filePath).loadPageModule(filePath);
         const page = module.default;
         return {
           staticPaths: page?.staticPaths ?? module.getStaticPaths,
@@ -104,11 +109,7 @@ class SharedServerAdapter extends AbstractServerAdapter {
    * @param hmrManager - The runtime-specific Hot Module Replacement orchestrator (if watching).
    */
   configureSharedResponseHandlers(staticRoutes, hmrManager) {
-    this.routeRendererFactory = new RouteRendererFactory({
-      appConfig: this.appConfig,
-      rendererModules: this.appConfig.runtime?.rendererModuleContext,
-      runtimeOrigin: this.runtimeOrigin
-    });
+    this.ensureRouteRendererFactory();
     const { fileSystemResponseMatcher, explicitStaticRouteMatcher } = this.createSharedResponseHandlerDependencies(staticRoutes);
     this.fileSystemResponseMatcher = fileSystemResponseMatcher;
     this.routeHandler = new ServerRouteHandler({

package/src/hmr/hmr-entrypoint-output.d.ts

@@ -41,3 +41,9 @@ export declare function removeStaleHmrEntrypointOutput(outputPath: string, scope
  * fresher artifact than the edited source file.
  */
 export declare function isHmrOutputFresh(outputPath: string, sourcePath: string): boolean;
+/**
+ * @remarks
+ * Missing output is treated as a benign rebuild race. This helper isolates the
+ * post-build case where a bundle exists but is still older than its source.
+ */
+export declare function isHmrOutputOlderThanSource(outputPath: string, sourcePath: string): boolean;

package/src/hmr/hmr-entrypoint-output.js

@@ -43,10 +43,17 @@ function isHmrOutputFresh(outputPath, sourcePath) {
   const sourceMtimeMs = fs.statSync(sourcePath).mtimeMs;
   return outputMtimeMs >= sourceMtimeMs;
 }
+function isHmrOutputOlderThanSource(outputPath, sourcePath) {
+  if (!fileSystem.exists(outputPath) || !fileSystem.exists(sourcePath)) {
+    return false;
+  }
+  return fs.statSync(outputPath).mtimeMs < fs.statSync(sourcePath).mtimeMs;
+}
 export {
   encodeHmrDynamicSegments,
   isBrowserOnlyRegisteredScriptEntrypoint,
   isHmrOutputFresh,
+  isHmrOutputOlderThanSource,
   isRegisteredScriptEntrypoint,
   removeStaleHmrEntrypointOutput,
   resolveHmrEntrypointOutputPaths

package/src/hmr/strategies/js-hmr-strategy.js

@@ -6,7 +6,8 @@ import {
   removeStaleHmrEntrypointOutput,
   resolveHmrEntrypointOutputPaths,
   isRegisteredScriptEntrypoint,
-  isHmrOutputFresh
+  isHmrOutputFresh,
+  isHmrOutputOlderThanSource
 } from "../hmr-entrypoint-output.js";
 class JsHmrStrategy extends HmrStrategy {
   type = HmrStrategyType.SCRIPT;
@@ -200,7 +201,11 @@ class JsHmrStrategy extends HmrStrategy {
   async processOutput(filepath, url, sourcePath) {
     try {
       if (sourcePath && !isHmrOutputFresh(filepath, sourcePath)) {
-        appLogger.warn(`[JsHmrStrategy] Skipping broadcast for stale HMR output ${url}`);
+        if (isHmrOutputOlderThanSource(filepath, sourcePath)) {
+          appLogger.warn(
+            `[JsHmrStrategy] HMR output is older than source after rebuild; skipping broadcast for ${url}`
+          );
+        }
         return { success: false, requiresReload: false };
       }
       const code = await fileSystem.readFile(filepath);

package/src/index.d.ts

@@ -4,3 +4,4 @@ export { eco } from './eco/eco.js';
 export { defineApiHandler, defineGroupHandler, type GroupHandler } from './adapters/shared/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 { SchemaError, validateStandardSchema } from './services/validation/validate-standard-schema.js';

package/src/index.js

@@ -8,7 +8,9 @@ import {
   normalizeTransformId
 } from "./plugins/source-transform.js";
 import { createEcoComponentMetaTransform } from "./plugins/eco-component-meta-plugin.js";
+import { SchemaError, validateStandardSchema } from "./services/validation/validate-standard-schema.js";
 export {
+  SchemaError,
   createEcoBuildPluginFromSourceTransform,
   createEcoComponentMetaTransform,
   createVitePluginFromSourceTransform,
@@ -17,5 +19,6 @@ export {
   defineGroupHandler,
   eco,
   getAppSourceTransforms,
-  normalizeTransformId
+  normalizeTransformId,
+  validateStandardSchema
 };

package/src/plugins/processor.d.ts

@@ -1,5 +1,6 @@
 import type { EcoBuildPlugin } from '../build/build-types.js';
 import type { EcoPagesAppConfig, IClientBridge } from '../types/internal-types.js';
+import { GENERATED_BASE_PATHS } from '../config/constants.js';
 import type { RuntimeCapabilityDeclaration } from './runtime-capability.js';
 export type { RuntimeCapabilityDeclaration, RuntimeCapabilityTag } from './runtime-capability.js';
 export type { EcoBuildLoader, EcoBuildOnLoadArgs, EcoBuildOnLoadResult, EcoBuildOnResolveArgs, EcoBuildOnResolveResult, EcoBuildPlugin, EcoBuildPluginBuilder, } from '../build/build-types.js';
@@ -7,6 +8,11 @@ export declare const PROCESSOR_ERRORS: {
     readonly CACHE_DIRECTORY_NOT_SET: "Cache directory not set in context";
 };
 export declare function mergeProcessorOptions<TDefaults, TOverrides>(defaults: TDefaults, overrides: TOverrides): TDefaults & TOverrides;
+export declare function resolveGeneratedPath(type: keyof typeof GENERATED_BASE_PATHS, options: {
+    root: string;
+    module: string;
+    subPath?: string;
+}): string;
 export interface ProcessorWatchContext {
     path: string;
     bridge: IClientBridge;

package/src/plugins/processor.js

@@ -155,5 +155,6 @@ class Processor {
 export {
   PROCESSOR_ERRORS,
   Processor,
-  mergeProcessorOptions
+  mergeProcessorOptions,
+  resolveGeneratedPath
 };

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

@@ -113,10 +113,7 @@ export declare class SchemaValidationService {
     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 mapSchemaIssue;
     private validateWithSchema;
 }

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

@@ -1,3 +1,4 @@
+import { SchemaError, validateStandardSchema } from "./validate-standard-schema.js";
 class SchemaValidationService {
   /**
    * Validates request data against provided schemas.
@@ -65,26 +66,24 @@ class SchemaValidationService {
   }
   /**
    * 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
    */
+  mapSchemaIssue(issue) {
+    return {
+      message: issue.message,
+      path: issue.path?.map((p) => typeof p === "object" && "key" in p ? p.key : p)
+    };
+  }
   async validateWithSchema(schema, data) {
     try {
-      const resultOrPromise = schema["~standard"].validate(data);
-      const result = resultOrPromise instanceof Promise ? await resultOrPromise : resultOrPromise;
-      if (result.issues) {
+      const value = await validateStandardSchema(schema, data);
+      return { success: true, data: value };
+    } catch (error) {
+      if (error instanceof SchemaError) {
         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)
-          }))
+          errors: error.issues.map((issue) => this.mapSchemaIssue(issue))
         };
       }
-      return { success: true, data: result.value };
-    } catch (error) {
       return {
         success: false,
         errors: [

package/src/services/validation/standard-schema.types.d.ts

@@ -1,65 +1,12 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 /**
- * Standard Schema interface for universal validation.
- * Compatible with Zod, Valibot, ArkType, Effect Schema, and other validation libraries.
- *
+ * Ecopages aliases for the official Standard Schema V1 types.
  * @see https://standardschema.dev
- *
- * @example Using with Zod
- * ```typescript
- * import { z } from 'zod';
- *
- * const bodySchema = z.object({
- *   title: z.string().min(1),
- *   content: z.string()
- * });
- *
- * app.post('/posts', async (ctx) => {
- *   const { title, content } = ctx.body;
- *   return ctx.json({ id: 1, title, content });
- * }, {
- *   schema: { body: bodySchema }
- * });
- * ```
  */
-export interface StandardSchema<Input = unknown, Output = Input> {
-    readonly '~standard': {
-        readonly version: 1;
-        readonly vendor: string;
-        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
-        readonly types?: {
-            readonly input: Input;
-            readonly output: Output;
-        };
-    };
-}
-/**
- * Result of Standard Schema validation.
- */
-export type StandardSchemaResult<Output> = StandardSchemaSuccessResult<Output> | StandardSchemaFailureResult;
-/**
- * Successful validation result.
- */
-export interface StandardSchemaSuccessResult<Output> {
-    readonly value: Output;
-    readonly issues?: undefined;
-}
-/**
- * Failed validation result.
- */
-export interface StandardSchemaFailureResult {
-    readonly value?: undefined;
-    readonly issues: ReadonlyArray<StandardSchemaIssue>;
-}
-/**
- * Validation issue details.
- */
-export interface StandardSchemaIssue {
-    readonly message: string;
-    readonly path?: ReadonlyArray<PropertyKey | {
-        key: PropertyKey;
-    }>;
-}
-/**
- * Infers the output type from a Standard Schema.
- */
-export type InferOutput<T extends StandardSchema> = T extends StandardSchema<any, infer O> ? O : never;
+export type StandardSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output>;
+export type StandardSchemaResult<Output> = StandardSchemaV1.Result<Output>;
+export type StandardSchemaSuccessResult<Output> = StandardSchemaV1.SuccessResult<Output>;
+export type StandardSchemaFailureResult = StandardSchemaV1.FailureResult;
+export type StandardSchemaIssue = StandardSchemaV1.Issue;
+export type InferOutput<T extends StandardSchemaV1> = StandardSchemaV1.InferOutput<T>;
+export type { StandardSchemaV1 } from '@standard-schema/spec';

package/src/services/validation/validate-standard-schema.d.ts

@@ -0,0 +1,7 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export { SchemaError } from '@standard-schema/utils';
+/**
+ * Validates a value with any Standard Schema-compliant validator.
+ * Throws {@link SchemaError} when validation fails.
+ */
+export declare function validateStandardSchema<T>(schema: StandardSchemaV1<unknown, T>, value: unknown): Promise<T>;

package/src/services/validation/validate-standard-schema.js

@@ -0,0 +1,14 @@
+import { SchemaError } from "@standard-schema/utils";
+import { SchemaError as SchemaError2 } from "@standard-schema/utils";
+async function validateStandardSchema(schema, value) {
+  const resultOrPromise = schema["~standard"].validate(value);
+  const result = resultOrPromise instanceof Promise ? await resultOrPromise : resultOrPromise;
+  if (result.issues) {
+    throw new SchemaError(result.issues);
+  }
+  return result.value;
+}
+export {
+  SchemaError2 as SchemaError,
+  validateStandardSchema
+};

package/src/types/public-types.d.ts

@@ -89,8 +89,8 @@ export interface EcopagesWebSocketHandler<TContext = unknown, TParams extends Re
     onClose?(socket: EcopagesSocket<TContext, TParams>, event: WebSocketCloseInfo): void | Promise<void>;
     onError?(socket: EcopagesSocket<TContext, TParams>, error: unknown): void | Promise<void>;
 }
-import type { StandardSchema, StandardSchemaResult, StandardSchemaSuccessResult, StandardSchemaFailureResult, StandardSchemaIssue, InferOutput } from '../services/validation/standard-schema.types.js';
-export type { StandardSchema, StandardSchemaResult, StandardSchemaSuccessResult, StandardSchemaFailureResult, StandardSchemaIssue, InferOutput, ForeignChildRuntime, };
+import type { StandardSchema, StandardSchemaResult, StandardSchemaSuccessResult, StandardSchemaFailureResult, StandardSchemaIssue, InferOutput, StandardSchemaV1 } from '../services/validation/standard-schema.types.js';
+export type { StandardSchema, StandardSchemaResult, StandardSchemaSuccessResult, StandardSchemaFailureResult, StandardSchemaIssue, InferOutput, StandardSchemaV1, ForeignChildRuntime, };
 export type InteractionEventsString = ScriptsInjectorInteractionEventsString;
 export type DependencyLazyTrigger = {
     'on:idle': true;