@ecopages/core 0.2.0-beta.22 → 0.2.0-beta.24

package/src/services/assets/asset-processing-service/ungrouped-dependency-processing.js

@@ -1,8 +1,8 @@
 import { fileSystem } from "@ecopages/file-system";
+import { finalizeProcessedAsset } from "./finalize-processed-asset.js";
 async function processUngroupedDependency(options) {
   const {
     dep,
-    key,
     depKey,
     getCachedAsset,
     getProcessor,
@@ -14,7 +14,7 @@ async function processUngroupedDependency(options) {
   } = options;
   const cached = getCachedAsset(dep, depKey);
   if (cached) {
-    return { key, ...cached };
+    return finalizeProcessedAsset(cached, resolveProcessedAssetSrcUrl);
   }
   const processor = getProcessor(dep);
   if (!processor) {
@@ -27,14 +27,9 @@ async function processUngroupedDependency(options) {
   }
   try {
     const processed = await processor.process(dep);
-    const srcUrl = resolveProcessedAssetSrcUrl(processed);
-    const processedWithKey = {
-      key,
-      ...processed,
-      srcUrl
-    };
-    setCachedAsset(dep, depKey, processedWithKey);
-    return processedWithKey;
+    const finalized = finalizeProcessedAsset(processed, resolveProcessedAssetSrcUrl);
+    setCachedAsset(dep, depKey, finalized);
+    return finalized;
   } catch (error) {
     logProcessingError(dep, error);
     return null;

package/src/services/assets/browser-bundle.service.js

@@ -2,6 +2,9 @@ import { getAppBrowserBuildPlugins, getAppTranspileOptions } from "../../build/b
 import { requireBuildRuntime } from "../../build/build-runtime.js";
 import { mergeEcoBuildPlugins } from "../../build/build-manifest.js";
 import { getAppSourceTransforms } from "../../plugins/source-transform.js";
+import { startupTrace } from "../../diagnostics/startup-trace.js";
+import { requestBuildDedupe } from "../../diagnostics/request-build-dedupe.js";
+import { createBuildOptionsDedupeKey } from "../../build/deduping-build-executor.js";
 function resolveBrowserBundleExecutor(appConfig, profile, executor) {
   const buildRuntime = requireBuildRuntime(appConfig);
   if (executor === "hmr" && (profile === "hmr-entrypoint" || profile === "hmr-runtime")) {
@@ -38,12 +41,17 @@ class BrowserBundleService {
       sourceTransforms: getAppSourceTransforms(this.appConfig)
     };
     const buildExecutor = resolveBrowserBundleExecutor(this.appConfig, profile, executor);
-    return await buildExecutor.build(request);
+    const dedupeKey = createBuildOptionsDedupeKey(request);
+    return requestBuildDedupe.dedupeBuild(dedupeKey, async () => {
+      const result = await buildExecutor.build(request);
+      startupTrace.recordBrowserBundle(result.outputs);
+      return result;
+    });
   }
   async bundleGroupedEntries(entries, options) {
     const request = {
       ...options,
-      entrypoints: entries.map((entry) => entry.entrypoint)
+      entrypoints: Object.fromEntries(entries.map((entry) => [entry.entryName, entry.entrypoint]))
     };
     return this.bundle(request);
   }

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;