@bleedingdev/modern-js-server-core 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

package/dist/esm-node/index.mjs

@@ -9,5 +9,5 @@ export { AGGRED_DIR } from "./constants.mjs";
 export { run, useHonoContext } from "./context.mjs";
 export { getLoaderCtx } from "./helper.mjs";
 export { createServerBase } from "./serverBase.mjs";
-export { ErrorDigest, createErrorHtml, createSafeFailureHttpResult, createSafeJsonFailureResponse, getSafeFailureStatus, onError } from "./utils/index.mjs";
+export { ErrorDigest, createErrorHtml, onError } from "./utils/index.mjs";
 export { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths } from "./utils/publicDir.mjs";

package/dist/esm-node/plugins/compat/index.mjs

@@ -4,6 +4,7 @@ import { getHookRunners, handleSetupResult } from "./hooks.mjs";
 const compatPlugin = ()=>({
         name: '@modern-js/server-compat',
         registryHooks: {
+            handleError: createAsyncPipelineHook(),
             prepareWebServer: createAsyncPipelineHook(),
             prepareApiServer: createAsyncPipelineHook(),
             afterMatch: createAsyncPipelineHook(),

package/dist/esm-node/plugins/render/ssrCache.mjs

@@ -2,54 +2,67 @@ import "node:module";
 import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
 import { X_RENDER_CACHE } from "../../constants.mjs";
 import { createTransformStream, getPathname } from "../../utils/index.mjs";
+const preventsSharedCaching = (headers)=>/(?:^|,)\s*(?:private|no-store|no-cache)\s*(?:[=,]|$)/i.test(headers.get('cache-control') || '');
+const isCacheableResponse = (response)=>200 === response.status && !preventsSharedCaching(response.headers) && !response.headers.has('set-cookie') && !response.headers.get('vary');
 const removeTailSlash = (s)=>s.replace(/\/+$/, '');
 const ZERO_RENDER_LEVEL = /"renderLevel":0/;
 const NO_SSR_CACHE = /<meta\s+[^>]*name=["']no-ssr-cache["'][^>]*>/i;
 async function processCache({ request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus }) {
     const response = await requestHandler(request, requestHandlerOptions);
     const { onError } = requestHandlerOptions;
-    const nonCacheableStatusCodes = [
-        204,
-        305,
-        404,
-        405,
-        500,
-        501,
-        502,
-        503,
-        504
-    ];
-    if (nonCacheableStatusCodes.includes(response.status)) return response;
+    const deleteCache = async ()=>{
+        try {
+            await container.delete(key);
+        } catch  {
+            (onError || console.error)('[render-cache] delete cache failed');
+        }
+    };
+    if (!isCacheableResponse(response) || !response.body) {
+        await deleteCache();
+        return response;
+    }
+    const headers = Object.fromEntries(response.headers);
     const decoder = new TextDecoder();
     if (response.body) {
         const stream = createTransformStream();
         const reader = response.body.getReader();
         const writer = stream.writable.getWriter();
         let html = '';
-        const push = ()=>reader.read().then(({ done, value })=>{
+        const push = ()=>reader.read().then(async ({ done, value })=>{
                 if (done) {
+                    html += decoder.decode();
                     const match = ZERO_RENDER_LEVEL.test(html) || NO_SSR_CACHE.test(html);
-                    if (match) return void writer.close();
+                    if (match) {
+                        await deleteCache();
+                        return writer.close();
+                    }
                     const current = Date.now();
                     const cache = {
                         val: html,
-                        cursor: current
+                        cursor: current,
+                        headers
                     };
                     container.set(key, JSON.stringify(cache), {
                         ttl
                     }).catch(()=>{
-                        if (onError) onError(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
-                        else console.error(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
+                        (onError || console.error)('[render-cache] set cache failed');
                     });
-                    writer.close();
-                    return;
+                    return writer.close();
                 }
-                const content = decoder.decode(value);
+                const content = decoder.decode(value, {
+                    stream: true
+                });
                 html += content;
-                writer.write(value);
-                push();
+                await writer.write(value);
+                return push();
             });
-        push();
+        push().catch(async (error)=>{
+            await Promise.allSettled([
+                writer.abort(error),
+                reader.cancel(error)
+            ]);
+            (onError || console.error)('[render-cache] response stream failed');
+        });
         cacheStatus && response.headers.set(X_RENDER_CACHE, cacheStatus);
         return new Response(stream.readable, {
             status: response.status,
@@ -64,9 +77,12 @@ function computedKey(req, cacheControl) {
     const pathname = getPathname(req);
     const { customKey } = cacheControl;
     const defaultKey = '/' === pathname ? pathname : removeTailSlash(pathname);
-    if (!customKey) return defaultKey;
-    if ('string' == typeof customKey) return customKey;
-    return customKey(defaultKey);
+    if (customKey) if ('string' == typeof customKey) return customKey;
+    else return customKey(defaultKey);
+    {
+        const url = new URL(req.url);
+        return `${url.origin}${defaultKey}${url.search}`;
+    }
 }
 function shouldUseCache(request) {
     const url = new URL(request.url);
@@ -96,13 +112,15 @@ function matchCacheControl(cacheOption, req) {
 async function getCacheResult(request, options) {
     const { cacheControl, container = storage, requestHandler, requestHandlerOptions } = options;
     const { onError } = requestHandlerOptions;
-    const key = computedKey(request, cacheControl);
+    const hasCredentials = request.headers.has('cookie') || request.headers.has('authorization');
+    if ('GET' !== request.method || !shouldUseCache(request) || preventsSharedCaching(request.headers) || hasCredentials && !cacheControl.customKey) return requestHandler(request, requestHandlerOptions);
+    const key = `${CACHE_NAMESPACE}:v2:${computedKey(request, cacheControl)}`;
     let value;
     try {
         value = await container.get(key);
     } catch (_) {
-        if (onError) onError(`[render-cache] get cache failed, key: ${key}`);
-        else console.error(`[render-cache] get cache failed, key: ${key}`);
+        if (onError) onError('[render-cache] get cache failed');
+        else console.error('[render-cache] get cache failed');
         value = void 0;
     }
     const { maxAge, staleWhileRevalidate } = cacheControl;
@@ -123,6 +141,7 @@ async function getCacheResult(request, options) {
             const cacheStatus = 'hit';
             return new Response(cache.val, {
                 headers: {
+                    ...cache.headers,
                     [X_RENDER_CACHE]: cacheStatus
                 }
             });
@@ -146,10 +165,13 @@ async function getCacheResult(request, options) {
                 container
             }).then(async (response)=>{
                 await response.text();
+            }).catch(()=>{
+                (onError || console.error)('[render-cache] revalidation failed');
             });
             const cacheStatus = 'stale';
             return new Response(cache.val, {
                 headers: {
+                    ...cache.headers,
                     [X_RENDER_CACHE]: cacheStatus
                 }
             });

package/dist/esm-node/serverBase.mjs

@@ -1,5 +1,6 @@
 import "node:module";
 import { server as server_server } from "@modern-js/plugin/server";
+import { logger } from "@modern-js/utils";
 import { Hono } from "hono";
 import { run } from "./context.mjs";
 import { handleSetupResult } from "./plugins/compat/hooks.mjs";
@@ -18,22 +19,54 @@ function _class_private_method_init(obj, privateSet) {
 var _applyMiddlewares = /*#__PURE__*/ new WeakSet();
 class ServerBase {
     async init() {
-        const { serverConfig, config: cliConfig } = this.serverOptions;
-        const mergedConfig = loadConfig({
-            cliConfig,
-            serverConfig: serverConfig || {}
-        });
-        const { serverContext } = await server_server.run({
-            plugins: this.plugins,
-            options: this.serverOptions,
-            config: mergedConfig,
-            handleSetupResult: handleSetupResult
-        });
-        serverContext.serverBase = this;
-        this.serverContext = serverContext;
-        await serverContext.hooks.onPrepare.call();
-        _class_private_method_get(this, _applyMiddlewares, applyMiddlewares).call(this);
-        return this;
+        try {
+            const { serverConfig, config: cliConfig } = this.serverOptions;
+            const mergedConfig = loadConfig({
+                cliConfig,
+                serverConfig: serverConfig || {}
+            });
+            const { serverContext } = await server_server.run({
+                plugins: this.plugins,
+                options: this.serverOptions,
+                config: mergedConfig,
+                handleSetupResult: handleSetupResult
+            });
+            serverContext.serverBase = this;
+            this.serverContext = serverContext;
+            await serverContext.hooks.onPrepare.call();
+            _class_private_method_get(this, _applyMiddlewares, applyMiddlewares).call(this);
+            return this;
+        } catch (error) {
+            await this.dispose().catch((disposeError)=>{
+                logger.error(disposeError);
+            });
+            throw error;
+        }
+    }
+    onDispose(disposer) {
+        if (this.disposePromise) throw new Error('Cannot register a disposer on a retired server.');
+        this.disposers.add(disposer);
+        return ()=>{
+            this.disposers.delete(disposer);
+        };
+    }
+    dispose() {
+        if (!this.disposePromise) {
+            const disposers = [
+                ...this.disposers
+            ].reverse();
+            this.disposers.clear();
+            this.disposePromise = Promise.resolve().then(async ()=>{
+                const errors = [];
+                for (const disposer of disposers)try {
+                    await disposer();
+                } catch (error) {
+                    errors.push(error);
+                }
+                if (errors.length > 0) throw new AggregateError(errors, 'Failed to dispose server.');
+            });
+        }
+        return this.disposePromise;
     }
     addPlugins(plugins) {
         this.plugins.push(...plugins);
@@ -79,7 +112,15 @@ class ServerBase {
     }
     constructor(options){
         _class_private_method_init(this, _applyMiddlewares);
-        this.plugins = [];
+        this.plugins = [
+            {
+                name: '@modern-js/server-lifecycle',
+                _registryApi: ()=>({
+                        onDispose: (disposer)=>this.onDispose(disposer)
+                    })
+            }
+        ];
+        this.disposers = new Set();
         this.serverContext = null;
         this.serverOptions = options;
         this.app = new Hono();

package/dist/esm-node/utils/error.mjs

@@ -51,5 +51,4 @@ function onError(digest, error, monitors, req) {
     else if (req) console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error}, req.url = ${req.url}, req.headers = ${JSON.stringify(headerData)}`);
     else console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error} `);
 }
-export { createSafeFailureHttpResult, createSafeJsonFailureResponse, getSafeFailureStatus } from "@modern-js/runtime-extensions/safe-failure";
 export { createErrorHtml, error_ErrorDigest as ErrorDigest, onError };

package/dist/types/adapters/node/index.d.ts

@@ -3,3 +3,5 @@ export type { ServerNodeContext, ServerNodeMiddleware } from './hono.js';
 export { connectMid2HonoMid, connectMockMid2HonoMid, httpCallBack2HonoMid, } from './hono.js';
 export { createNodeServer, createWebRequest, sendResponse, } from './node.js';
 export { getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, injectResourcePlugin, injectRscManifestPlugin, serverStaticPlugin, } from './plugins/index.js';
+export type { ServerStaticPluginOptions, ServeStaticAsset, StaticAsset, StaticAssetRequest, StaticAssetResponder, StaticPublicFallbackResponder, } from './plugins/static.js';
+export { serveStaticAsset } from './plugins/static.js';

package/dist/types/adapters/node/plugins/static.d.ts

@@ -1,12 +1,50 @@
 import type { ServerRoute } from '@modern-js/types';
 import type { HtmlNormalizedConfig, Middleware, OutputNormalizedConfig, ServerNormalizedConfig, ServerPlugin } from '../../../types/index.js';
-export declare const serverStaticPlugin: () => ServerPlugin;
+/** A selected file and the native response conventions to use for it. */
+export type StaticAsset = {
+    filename: string;
+    kind: 'static' | 'public';
+    /** An alternate representation retains the original resource's MIME type. */
+    mimeFilename?: string;
+    responseHeaders?: ServerRoute['responseHeaders'];
+    /** True uses the served byte length; omitted preserves native length defaults. */
+    contentLength?: boolean;
+    /** Optional lexical containment boundary. Use real paths to contain symlinks. */
+    root?: string;
+    /** Resolve symlinks before checking root. Implies a regular file is required. */
+    realpath?: boolean;
+};
+export type StaticAssetRequest = {
+    root: string;
+    pathPrefix: string;
+};
+/** Native serving of the selected file, optionally choosing another representation. */
+export type ServeStaticAsset = (representation?: Partial<Pick<StaticAsset, 'filename' | 'contentLength'>>) => Promise<Response | null>;
+/**
+ * Trusted server extension. Undefined uses the native file; null skips it.
+ * A returned response is final. Exceptions use the normal server error handler.
+ */
+export type StaticAssetResponder = (context: Parameters<Middleware>[0], asset: StaticAsset, serve: ServeStaticAsset, request: StaticAssetRequest) => Response | null | undefined | Promise<Response | null | undefined>;
+/**
+ * Handles requests outside the native static pattern. The continuation only
+ * tries native public routes; it returns null on a miss and never calls the next
+ * middleware. Returning null from this hook continues the middleware chain.
+ */
+export type StaticPublicFallbackResponder = (context: Parameters<Middleware>[0], respondPublic: () => Promise<Response | null>, request: StaticAssetRequest) => Response | null | Promise<Response | null>;
+/** Read a selected file using native readers, MIME, headers and body conversion. */
+export declare function serveStaticAsset(context: Parameters<Middleware>[0], asset: StaticAsset, respond?: (asset: StaticAsset, serve: ServeStaticAsset) => Promise<Response | null>): Promise<Response | null>;
+export type ServerStaticPluginOptions = {
+    respondAsset?: StaticAssetResponder;
+    respondPublicFallback?: StaticPublicFallbackResponder;
+};
+export declare const serverStaticPlugin: (options?: ServerStaticPluginOptions) => ServerPlugin;
 export type PublicMiddlwareOptions = {
     pwd: string;
     routes: ServerRoute[];
-};
-export declare function createPublicMiddleware({ pwd, routes, }: PublicMiddlwareOptions): Middleware;
-export interface ServerStaticOptions {
+    pathPrefix?: string;
+} & ServerStaticPluginOptions;
+export declare function createPublicMiddleware({ pwd, routes, pathPrefix, respondAsset, respondPublicFallback, }: PublicMiddlwareOptions): Middleware;
+export interface ServerStaticOptions extends ServerStaticPluginOptions {
     pwd: string;
     output: OutputNormalizedConfig;
     html: HtmlNormalizedConfig;

package/dist/types/index.d.ts

@@ -10,6 +10,5 @@ export * from './types/config/index.js';
 export * from './types/plugins/index.js';
 export * from './types/render.js';
 export * from './types/requestHandler.js';
-export type { SafeFailureEnvelope, SafeFailureHttpResult } from './utils/index.js';
-export { createErrorHtml, createSafeFailureHttpResult, createSafeJsonFailureResponse, ErrorDigest, getSafeFailureStatus, onError, } from './utils/index.js';
+export { createErrorHtml, ErrorDigest, onError, } from './utils/index.js';
 export { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths, } from './utils/publicDir.js';

package/dist/types/serverBase.d.ts

@@ -12,6 +12,8 @@ export declare class ServerBase<E extends Env = any> {
     serverOptions: ServerBaseOptions;
     private app;
     private plugins;
+    private disposers;
+    private disposePromise?;
     private serverContext;
     constructor(options: ServerBaseOptions);
     /**
@@ -20,6 +22,10 @@ export declare class ServerBase<E extends Env = any> {
      * - apply middlewares
      */
     init(): Promise<this>;
+    /** Register instance resources before initialization can fail. */
+    onDispose(disposer: () => void | Promise<void>): () => void;
+    /** Retire this instance and release every resource in reverse order once. */
+    dispose(): Promise<void>;
     addPlugins(plugins: ServerPlugin[]): void;
     get hooks(): ServerPluginHooks;
     get all(): import("hono/types").HandlerInterface<E, "all", import("hono/types").BlankSchema, "/", "/">;
@@ -30,7 +36,7 @@ export declare class ServerBase<E extends Env = any> {
     get put(): import("hono/types").HandlerInterface<E, "put", import("hono/types").BlankSchema, "/", "/">;
     get delete(): import("hono/types").HandlerInterface<E, "delete", import("hono/types").BlankSchema, "/", "/">;
     get patch(): import("hono/types").HandlerInterface<E, "patch", import("hono/types").BlankSchema, "/", "/">;
-    get handle(): (request: Request, Env?: {} | E["Bindings"] | undefined, executionCtx?: import("hono").ExecutionContext) => Response | Promise<Response>;
+    get handle(): (request: Request, env?: {} | E["Bindings"] | undefined, executionCtx?: import("hono").ExecutionContext) => Response | Promise<Response>;
     get request(): (input: Request | string | URL, requestInit?: RequestInit, Env?: {} | E["Bindings"] | undefined, executionCtx?: import("hono").ExecutionContext) => Response | Promise<Response>;
     get notFound(): (handler: import("hono").NotFoundHandler<E>) => import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema, "/", "/">;
     get onError(): (handler: import("hono").ErrorHandler<E>) => import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema, "/", "/">;

package/dist/types/types/config/bff.d.ts

@@ -1,6 +1,5 @@
+import type { BffRuntimeFramework } from '@modern-js/plugin/server';
 import type { HttpMethodDecider } from '@modern-js/types';
-import type { BffCrossProjectPolicyUserConfig, BffEffectUserConfig, BffRuntimeFramework } from './bffRuntime.js';
-export type { BffCrossProjectPolicyUserConfig, BffEffectDataPlatformBatchUserConfig, BffEffectDataPlatformSelectionUserConfig, BffEffectDataPlatformUserConfig, BffEffectOpenApiUserConfig, BffEffectUserConfig, BffRuntimeFramework, } from './bffRuntime.js';
 export interface BffUserConfig {
     prefix?: string | string[];
     httpMethodDecider?: HttpMethodDecider;
@@ -25,23 +24,13 @@ export interface BffUserConfig {
      * Custom request creator import path for generated BFF clients.
      */
     requestCreator?: string;
+    /** Node module exporting a generated-client transform. */
+    clientCodegenPlugin?: string;
     /**
      * Legacy custom fetcher import path for generated BFF clients.
      */
     fetcher?: string;
-    /**
-     * Selects the BFF runtime implementation.
-     *
-     * - `effect`: only `api/index` (or the configured `bff.effect.entry`) is served.
-     * - `hono`: only `api/lambda/**` handlers are served.
-     *
-     * @default 'effect'
-     */
+    /** Selects a registered BFF runtime implementation. */
     runtimeFramework?: BffRuntimeFramework;
-    /**
-     * Effect runtime configuration. Only applies when `runtimeFramework: 'effect'`.
-     */
-    effect?: BffEffectUserConfig;
-    crossProjectPolicy?: BffCrossProjectPolicyUserConfig;
 }
 export type BffNormalizedConfig = BffUserConfig;

package/dist/types/types/config/server.d.ts

@@ -1,7 +1,5 @@
 import type { SSRMode } from '@modern-js/types';
 import type { WatchOptions } from '@modern-js/utils';
-import type { ServerTelemetryUserConfig } from './serverTelemetry.js';
-export type { ServerTelemetryCanaryAutopilotStateStoreUserConfig, ServerTelemetryCanaryAutopilotUserConfig, ServerTelemetryCanaryContractGateUserConfig, ServerTelemetryCanaryRuntimeFallbackSignalAuthUserConfig, ServerTelemetryCanaryRuntimeFallbackSignalTrustPolicyUserConfig, ServerTelemetryCanaryRuntimeFallbackSignalUserConfig, ServerTelemetryCanaryUserConfig, ServerTelemetryExporterOptions, ServerTelemetrySloUserConfig, ServerTelemetryUserConfig, ServerTelemetryVictoriaMetricsOptions, } from './serverTelemetry.js';
 type Route = string | string[] | {
     route?: string | string[];
     disableSpa?: boolean;
@@ -50,7 +48,6 @@ export interface ServerUserConfig {
      */
     useJsonScript?: boolean;
     logger?: boolean | Record<string, unknown>;
-    telemetry?: ServerTelemetryUserConfig;
     /**
      * @description disable hook middleware for performance
      * @default false
@@ -66,3 +63,4 @@ export interface ServerUserConfig {
     tsconfigPath?: string;
 }
 export type ServerNormalizedConfig = ServerUserConfig;
+export {};

package/dist/types/types/plugins/plugin.d.ts

@@ -1,21 +1,35 @@
 import type { AsyncPipelineHook, ServerContext as BaseServerContext, ServerPlugin as BaseServerPlugin, ServerPluginAPI as BaseServerPluginAPI, ServerPluginExtends as BaseServerPluginExtends } from '@modern-js/plugin';
 import type { Hooks } from '@modern-js/plugin/server';
 import type { AfterMatchContext, AfterRenderContext, AfterStreamingRenderContext } from '@modern-js/types';
-import type { MiddlewareHandler } from 'hono';
+import type { Context, MiddlewareHandler } from 'hono';
+import type { ServerStaticPluginOptions } from '../../adapters/node/plugins/static.js';
 import type { APIServerStartInput, MiddlewareObj, ServerConfig, WebAdapter, WebServerStartInput } from './base.js';
 export type PrepareWebServerFn = (input: WebServerStartInput) => Promise<WebAdapter | null>;
 export type PrepareApiServerFn = (input: APIServerStartInput) => Promise<MiddlewareHandler>;
 export type AfterMatchFn = (ctx: AfterMatchContext) => Promise<any>;
 export type AfterRenderFn = (ctx: AfterRenderContext) => Promise<any>;
 export type AfterStreamingRenderContextFn = (ctx: AfterStreamingRenderContext) => Promise<AfterStreamingRenderContext>;
+export interface HandleErrorInput {
+    error: Error;
+    context: Context;
+    response?: Response;
+}
+export type HandleErrorFn = (input: HandleErrorInput, next?: (input: HandleErrorInput) => void) => Promise<HandleErrorInput>;
 export interface ServerPluginExtends extends BaseServerPluginExtends {
     config: ServerConfig;
+    extendApi: {
+        /** Release an instance resource on shutdown or failed initialization. */
+        onDispose: (disposer: () => void | Promise<void>) => () => void;
+    };
     extendContext: {
+        /** Node static response extensions registered during plugin setup. */
+        staticAssetResponders?: ServerStaticPluginOptions;
         middlewares: MiddlewareObj[];
         renderMiddlewares: MiddlewareObj[];
         [key: string]: any;
     };
     extendHooks: {
+        handleError: AsyncPipelineHook<HandleErrorFn>;
         prepareWebServer: AsyncPipelineHook<PrepareWebServerFn>;
         prepareApiServer: AsyncPipelineHook<PrepareApiServerFn>;
         afterMatch: AsyncPipelineHook<AfterMatchFn>;

package/dist/types/types/requestHandler.d.ts

@@ -1,4 +1,4 @@
-import type { Reporter, ServerRoute } from '@modern-js/types';
+import type { OnError, OnTiming, Reporter, ServerRoute } from '@modern-js/types';
 import type { Monitors, ClientManifest as RscClientManifest, ServerManifest as RscServerManifest, SSRManifest as RscSSRManifest } from '@modern-js/types/server';
 import type { ServerUserConfig, SourceUserConfig } from './config/index.js';
 export type Resource = {
@@ -22,8 +22,7 @@ export type RequestHandlerConfig = {
     enableAsyncEntry?: SourceUserConfig['enableAsyncEntry'];
 };
 export type LoaderContext = Map<string, any>;
-export type OnError = (err: unknown, key?: string) => void;
-export type OnTiming = (name: string, dur: number) => void;
+export type { OnError, OnTiming };
 export type RequestHandlerOptions = {
     resource: Resource;
     config: RequestHandlerConfig;

package/dist/types/utils/error.d.ts

@@ -1,6 +1,4 @@
 import type { Monitors } from '@modern-js/types';
-export type { SafeFailureEnvelope, SafeFailureHttpResult, } from '@modern-js/runtime-extensions/safe-failure';
-export { createSafeFailureHttpResult, createSafeJsonFailureResponse, getSafeFailureStatus, } from '@modern-js/runtime-extensions/safe-failure';
 export declare const createErrorHtml: (status: number) => string;
 export declare enum ErrorDigest {
     ENOTF = "Page could not be found",

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.9.0-ultramodern.1",
+  "version": "3.9.0-ultramodern.11",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -66,26 +66,25 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.1",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.1",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.1",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.1",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.11",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.11",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.11",
     "@swc/helpers": "^0.5.23",
     "@web-std/fetch": "^4.2.1",
     "@web-std/file": "^3.0.3",
     "@web-std/stream": "^1.0.3",
     "cloneable-readable": "^3.0.0",
     "flatted": "^3.4.4",
-    "hono": "^4.12.28",
+    "hono": "^4.13.7",
     "ts-deepmerge": "8.0.0"
   },
   "devDependencies": {
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.1",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.11",
     "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",
     "@types/cloneable-readable": "^2.0.3",
     "@types/merge-deep": "^3.0.3",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.1",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "http-proxy-middleware": "^4.2.0",
     "typescript": "^7.0.2"