@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.99 → 3.4.0-ultramodern.0

package/dist/types/baseline.d.ts

@@ -1,46 +1,16 @@
-import type { AppUserConfig } from './types';
-export interface AppBaselineOptions {
-    /**
-     * Stable producer identity used by BFF cross-project clients.
-     * @default "app"
-     */
-    appId?: string;
-    /**
-     * Enable BFF requestId contract by default.
-     * @default true
-     */
-    enableBffRequestId?: boolean;
-    /**
-     * Enable telemetry contract by default.
-     * Exporters are still configured separately by applications.
-     * @default true
-     */
-    enableTelemetry?: boolean;
-    /**
-     * Enable telemetry exporters by default.
-     * @default true
-     */
-    enableTelemetryExporters?: boolean;
-    /**
-     * OTLP exporter endpoint.
-     * @default process.env.MODERN_TELEMETRY_OTLP_ENDPOINT || 'http://127.0.0.1:4318/v1/logs'
-     */
-    otlpEndpoint?: string;
-    /**
-     * VictoriaMetrics exporter endpoint.
-     * @default process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT || 'http://127.0.0.1:8428/api/v1/import/prometheus'
-     */
-    victoriaMetricsEndpoint?: string;
-    /**
-     * Enable fail-loud startup probing for telemetry exporters.
-     * @default true
-     */
-    telemetryFailLoudStartup?: boolean;
-    /**
-     * Enable app-level Module Federation SSR handshake by default.
-     * @default true
-     */
-    enableModuleFederationSSR?: boolean;
-}
-export declare const createAppBaselineConfig: (options?: AppBaselineOptions) => AppUserConfig;
-export declare const withAppBaseline: (config: AppUserConfig, options?: AppBaselineOptions) => AppUserConfig;
+import { type PresetUltramodernOptions } from './presetUltramodern';
+/**
+ * @deprecated Use `PresetUltramodernOptions` from `@modern-js/app-tools`
+ * instead. This alias will be removed in a future release.
+ */
+export type AppBaselineOptions = PresetUltramodernOptions;
+/**
+ * @deprecated Use `createPresetUltramodernConfig` from `@modern-js/app-tools`
+ * instead. This alias will be removed in a future release.
+ */
+export declare const createAppBaselineConfig: (options?: PresetUltramodernOptions) => import("./types").AppUserConfig;
+/**
+ * @deprecated Use `presetUltramodern` from `@modern-js/app-tools` instead.
+ * This alias will be removed in a future release.
+ */
+export declare const withAppBaseline: (config: import("./types").AppUserConfig, options?: PresetUltramodernOptions) => import("./types").AppUserConfig;

package/dist/types/builder/builder-rspack/index.d.ts

@@ -1,2 +1,2 @@
 import type { BuilderOptions } from '../shared';
-export declare function createRspackBuilderForModern(options: BuilderOptions): Promise<any>;
+export declare function createRspackBuilderForModern(options: BuilderOptions): Promise<import("@rsbuild/core").RsbuildInstance>;

package/dist/types/builder/generator/index.d.ts

@@ -5,4 +5,4 @@ import type { BuilderOptions } from '../shared';
  * @param bundlerType BundlerType
  * @returns BuilderInstance
  */
-export declare function generateBuilder(options: BuilderOptions, bundlerType: BundlerType): Promise<any>;
+export declare function generateBuilder(options: BuilderOptions, bundlerType: BundlerType): Promise<import("@rsbuild/core").RsbuildInstance>;

package/dist/types/builder/shared/bundlerPlugins/RouterPlugin.d.ts

@@ -14,6 +14,7 @@ type Options = {
     disableFilenameHash?: boolean;
     scriptLoading?: ScriptLoading;
     nonce?: string;
+    useRsc?: boolean;
 };
 export declare class RouterPlugin {
     readonly name: string;
@@ -23,7 +24,8 @@ export declare class RouterPlugin {
     private disableFilenameHash?;
     private scriptLoading?;
     private nonce?;
-    constructor({ staticJsDir, HtmlBundlerPlugin, enableInlineRouteManifests, disableFilenameHash, scriptLoading, nonce, }: Options);
+    private useRsc;
+    constructor({ staticJsDir, HtmlBundlerPlugin, enableInlineRouteManifests, disableFilenameHash, scriptLoading, nonce, useRsc, }: Options);
     private isTargetNodeOrWebWorker;
     private getEntryChunks;
     private getEntryChunkFiles;

package/dist/types/builder/shared/createCopyInfo.d.ts

@@ -4,5 +4,5 @@ export declare function createCopyInfo(appContext: AppToolsContext, config: AppN
     configDir: string;
     uploadDir: string;
     publicDir: string;
-    customPublicDirs: any;
+    customPublicDirs: string[];
 };

package/dist/types/builder/shared/lazyCompilation.d.ts

@@ -0,0 +1,43 @@
+import { type EagerRouteComponentFilesByEntry } from '@modern-js/utils';
+export { collectRouteComponentFiles, type EagerRouteComponentFilesByEntry, normalizeModulePath, type RouteComponentFileCollection, } from '@modern-js/utils';
+type ModuleLike = {
+    resource?: string;
+};
+type LazyCompilationTestFn = (m: ModuleLike) => boolean;
+/** Matches Rspack's `LazyCompilationOptions['test']`. */
+type LazyCompilationTest = RegExp | LazyCompilationTestFn | undefined;
+export type EagerRouteComponentInfo = {
+    files: Set<string>;
+    /** Specifiers that could not be resolved, keyed by entry name. */
+    unresolvedByEntry: Map<string, string[]>;
+};
+/**
+ * Aggregate the per-entry route component data (collected by the router plugin
+ * during route generation and threaded in as
+ * `BuilderOptions.eagerRouteComponentFilesByEntry`) into the flat shape
+ * {@link planSSRLazyCompilation} expects: one Set of all route files plus the
+ * unresolved specifiers keyed by entry.
+ */
+export declare function aggregateEagerRouteComponentFiles(byEntry: EagerRouteComponentFilesByEntry | undefined): EagerRouteComponentInfo;
+/**
+ * Build a `lazyCompilation.test` that forces route component modules to compile
+ * eagerly (so SSR first-screen chunk/CSS injection has the assets it needs at
+ * render time), while delegating all other modules to the user's `test`
+ * (defaulting to lazy when the user did not provide one).
+ */
+export declare function buildSSRLazyCompilationTest(eagerRouteFiles: Set<string>, userTest?: LazyCompilationTest): LazyCompilationTestFn;
+export type SSRLazyPlan = {
+    apply: false;
+    unresolvedByEntry?: Map<string, string[]>;
+} | {
+    apply: true;
+    lazyCompilation: Record<string, unknown>;
+};
+/**
+ * Decide whether to apply the route-eager lazy compilation for an SSR project.
+ * Checks unresolved route components FIRST: if any exist we cannot guarantee
+ * they are eager, so we skip the optimization (and surface them so the caller
+ * can warn) rather than silently leaving a route lazy. `current` is the
+ * existing `dev.lazyCompilation` value (lazy must be enabled for this to apply).
+ */
+export declare function planSSRLazyCompilation(current: unknown, info: EagerRouteComponentInfo): SSRLazyPlan;

package/dist/types/builder/shared/types.d.ts

@@ -1,6 +1,16 @@
+import type { EagerRouteComponentFilesByEntry } from '@modern-js/utils';
 import type { AppNormalizedConfig } from '../../types';
 import type { AppToolsContext } from '../../types/plugin';
 export type BuilderOptions = {
     normalizedConfig: AppNormalizedConfig;
     appContext: AppToolsContext;
+    /**
+     * Route component files collected from the FINAL file-system routes (after
+     * all `modifyFileSystemRoutes` consumers ran), keyed by entry name. Populated
+     * by the router plugin during route generation and threaded in here (read
+     * FRESH from the app context AFTER `generateEntryCode` runs) so the SSR
+     * builder plugin can force route component chunks eager under lazy
+     * compilation. Explicit param instead of a direct `_internalContext` read.
+     */
+    eagerRouteComponentFilesByEntry?: EagerRouteComponentFilesByEntry;
 };

package/dist/types/commands/index.d.ts

@@ -7,4 +7,4 @@ export declare const serverCommand: (program: Command, api: CLIPluginAPI<AppTool
 export declare const deployCommand: (program: Command, api: CLIPluginAPI<AppTools>) => void;
 export declare const inspectCommand: (program: Command, api: CLIPluginAPI<AppTools>) => void;
 export declare const infoCommand: (program: Command, api: CLIPluginAPI<AppTools>) => void;
-export declare const runtimeOperationsCommand: (program: Command, api: CLIPluginAPI<AppTools>) => Promise<void>;
+export { runtimeCommand } from './runtime';

package/dist/types/commands/inspect.d.ts

@@ -1,4 +1,4 @@
 import type { CLIPluginAPI } from '@modern-js/plugin';
 import type { AppTools } from '../types';
 import type { InspectOptions } from '../utils/types';
-export declare const inspect: (api: CLIPluginAPI<AppTools>, options: InspectOptions) => Promise<any>;
+export declare const inspect: (api: CLIPluginAPI<AppTools>, options: InspectOptions) => Promise<import("@rsbuild/core").InspectConfigResult>;

package/dist/types/commands/runtime.d.ts

@@ -7,5 +7,6 @@ export declare const resolveToken: ({ token, tokenEnv, }: {
     token?: string;
     tokenEnv?: string;
 }) => string | undefined;
+export declare const formatRuntimeOutput: (payload: unknown, jsonOnly?: boolean) => string;
 export declare const createRuntimeFallbackSignalPayload: (options: RuntimeFallbackSignalOptions) => Record<string, unknown>;
 export declare const runtimeCommand: (program: Command, _api: CLIPluginAPI<AppTools>) => Promise<void>;

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

@@ -1,3 +1,9 @@
 import type { AppUserConfig } from '../types';
 import type { AppToolsContext } from '../types/plugin';
 export declare function createDefaultConfig(appContext: AppToolsContext): AppUserConfig;
+/**
+ * Default-enable lazy compilation for pure CSR and stream SSR. Stream SSR keeps
+ * first-screen route assets correct via the route-eager lazyCompilation.test
+ * injected by the SSR builder plugin. String SSR, RSC and SSG stay disabled.
+ */
+export declare function isLazyCompilationSafeByDefault(userConfig: Pick<AppUserConfig, 'server' | 'output'>): boolean;

package/dist/types/locale/index.d.ts

@@ -1,3 +1,90 @@
-declare const i18n: any;
-declare const localeKeys: any;
+import { I18n } from '@modern-js/i18n-utils';
+declare const i18n: I18n;
+declare const localeKeys: {
+    command: {
+        shared: {
+            analyze: string;
+            config: string;
+            skipBuild: string;
+            noNeedInstall: string;
+        };
+        dev: {
+            describe: string;
+            entry: string;
+            apiOnly: string;
+            webOnly: string;
+            selectEntry: string;
+            requireEntry: string;
+        };
+        build: {
+            describe: string;
+            watch: string;
+        };
+        serve: {
+            describe: string;
+        };
+        deploy: {
+            describe: string;
+        };
+        new: {
+            describe: string;
+            debug: string;
+            config: string;
+            distTag: string;
+            registry: string;
+            lang: string;
+        };
+        inspect: {
+            env: string;
+            output: string;
+            verbose: string;
+        };
+        info: {
+            describe: string;
+        };
+    };
+} | {
+    command: {
+        shared: {
+            analyze: string;
+            config: string;
+            skipBuild: string;
+            noNeedInstall: string;
+        };
+        dev: {
+            describe: string;
+            entry: string;
+            apiOnly: string;
+            webOnly: string;
+            selectEntry: string;
+            requireEntry: string;
+        };
+        build: {
+            describe: string;
+            watch: string;
+        };
+        serve: {
+            describe: string;
+        };
+        deploy: {
+            describe: string;
+        };
+        new: {
+            describe: string;
+            debug: string;
+            config: string;
+            distTag: string;
+            registry: string;
+            lang: string;
+        };
+        inspect: {
+            env: string;
+            output: string;
+            verbose: string;
+        };
+        info: {
+            describe: string;
+        };
+    };
+};
 export { i18n, localeKeys };

package/dist/types/plugins/analyze/getFileSystemEntry.d.ts

@@ -2,6 +2,6 @@ import type { Entrypoint } from '@modern-js/types';
 import type { AppNormalizedConfig } from '../../types';
 import type { AppToolsContext, AppToolsHooks } from '../../types/plugin';
 export type { Entrypoint };
-export declare const hasEntry: (dir: string) => any;
-export declare const hasServerEntry: (dir: string) => any;
+export declare const hasEntry: (dir: string) => string | false;
+export declare const hasServerEntry: (dir: string) => string | false;
 export declare const getFileSystemEntry: (hooks: AppToolsHooks, appContext: AppToolsContext, config: AppNormalizedConfig) => Promise<Entrypoint[]>;

package/dist/types/plugins/analyze/index.d.ts

@@ -1,3 +1,3 @@
 import type { AppTools, CliPlugin } from '../../types';
-declare const _default: () => CliPlugin<AppTools>;
 export default _default;
+declare function _default(): CliPlugin<AppTools>;

package/dist/types/plugins/analyze/utils.d.ts

@@ -1,5 +1,5 @@
 export declare const walkDirectory: (dir: string) => string[];
-export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => any;
+export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => string;
 export declare const parseModule: ({ source, filename, }: {
     source: string;
     filename: string;

package/dist/types/plugins/deploy/index.d.ts

@@ -2,5 +2,5 @@ import type { AppTools, AppToolsNormalizedConfig, CliPlugin } from '../../types'
 import type { DeployTarget } from '../../types/config/deploy';
 export declare const getSupportedDeployTargets: () => DeployTarget[];
 export declare const resolveDeployTarget: (modernConfig: AppToolsNormalizedConfig, envDeployTarget?: string | undefined, detectedProvider?: import("std-env").ProviderName) => string;
-declare const _default: () => CliPlugin<AppTools>;
 export default _default;
+declare function _default(): CliPlugin<AppTools>;

package/dist/types/plugins/deploy/platforms/templates/cloudflare-entry.d.mts

@@ -1,4 +1,4 @@
 declare const _default: {
-    fetch(request: any, env: any, ctx: any): Promise<Response>;
+    fetch(request: any, env: any, ctx: any): Promise<any>;
 };
 export default _default;

package/dist/types/plugins/deploy/platforms/templates/netlify-entry.d.cts

@@ -1,2 +1,2 @@
-declare const handler: (request: any, context: any) => Promise<any>;
 export { handler as default };
+declare const handler: (request: any, context: any) => Promise<any>;

package/dist/types/plugins/deploy/platforms/templates/vercel-entry.d.cts

@@ -1,2 +1,2 @@
-declare const handler: (req: any, res: any) => Promise<any>;
 export = handler;
+declare const handler: (req: any, res: any) => Promise<any>;

package/dist/types/plugins/deploy/utils/generator.d.ts

@@ -5,8 +5,8 @@ export declare const serverAppContextTemplate: (appContext: AppToolsContext) =>
     sharedDirectory: string;
     apiDirectory: string;
     lambdaDirectory: string;
-    metaName: any;
-    bffRuntimeFramework: any;
+    metaName: string;
+    bffRuntimeFramework: "effect" | "hono";
 };
 export type PluginItem = [string, Record<string, any> | undefined];
 export declare const genPluginImportsCode: (plugins: PluginItem[], isESM?: boolean) => string;

package/dist/types/plugins/deploy/utils/index.d.ts

@@ -12,5 +12,5 @@ export declare const getProjectUsage: (appDirectory: string, distDirectory: stri
     useWebServer: boolean;
 };
 export declare const getTemplatePath: (file: string) => string;
-export declare const readTemplate: (file: string) => Promise<any>;
+export declare const readTemplate: (file: string) => Promise<string>;
 export declare const resolveESMDependency: (entry: string) => Promise<string | undefined>;

package/dist/types/plugins/initialize/index.d.ts

@@ -1,3 +1,3 @@
 import type { AppTools, CliPlugin } from '../../types';
-declare const _default: () => CliPlugin<AppTools>;
 export default _default;
+declare function _default(): CliPlugin<AppTools>;

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

@@ -1,3 +1,3 @@
 import type { AppTools, CliPlugin } from '../types';
-declare const _default: () => CliPlugin<AppTools>;
 export default _default;
+declare function _default(): CliPlugin<AppTools>;

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

@@ -1,3 +1,3 @@
 import type { AppTools, CliPlugin } from '../types';
-declare const _default: () => CliPlugin<AppTools>;
 export default _default;
+declare function _default(): CliPlugin<AppTools>;

package/dist/types/presetUltramodern.d.ts

@@ -1,6 +1,56 @@
-import { type AppBaselineOptions } from './baseline';
 import type { AppUserConfig } from './types';
-export interface PresetUltramodernOptions extends AppBaselineOptions {
+export interface PresetUltramodernOptions {
+    /**
+     * Stable producer identity used by BFF cross-project clients.
+     * @default "app"
+     */
+    appId?: string;
+    /**
+     * Enable BFF requestId contract by default.
+     * @default true
+     */
+    enableBffRequestId?: boolean;
+    /**
+     * Enable telemetry contract by default.
+     * Exporters are still configured separately by applications.
+     * @default true
+     */
+    enableTelemetry?: boolean;
+    /**
+     * Enable telemetry exporters.
+     *
+     * By default each exporter is enabled only when its endpoint is explicitly
+     * configured (via the matching option or environment variable), so a bare
+     * preset app boots in production without local collectors.
+     * Set `true` to force both exporters on with their default localhost
+     * endpoints, or `false` to disable exporters entirely.
+     * @default undefined (endpoint-driven)
+     */
+    enableTelemetryExporters?: boolean;
+    /**
+     * OTLP exporter endpoint. Setting it (or the environment variable)
+     * enables the OTLP exporter unless `enableTelemetryExporters` is `false`.
+     * @default process.env.MODERN_TELEMETRY_OTLP_ENDPOINT || 'http://127.0.0.1:4318/v1/logs'
+     */
+    otlpEndpoint?: string;
+    /**
+     * VictoriaMetrics exporter endpoint. Setting it (or the environment
+     * variable) enables the VictoriaMetrics exporter unless
+     * `enableTelemetryExporters` is `false`.
+     * @default process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT || 'http://127.0.0.1:8428/api/v1/import/prometheus'
+     */
+    victoriaMetricsEndpoint?: string;
+    /**
+     * Enable fail-loud startup probing for telemetry exporters.
+     * Probes only run for exporters that are actually enabled.
+     * @default true
+     */
+    telemetryFailLoudStartup?: boolean;
+    /**
+     * Enable app-level Module Federation SSR handshake by default.
+     * @default true
+     */
+    enableModuleFederationSSR?: boolean;
 }
 export declare const createPresetUltramodernConfig: (options?: PresetUltramodernOptions) => AppUserConfig;
 export declare const presetUltramodern: (config: AppUserConfig, options?: PresetUltramodernOptions) => AppUserConfig;

package/dist/types/rsbuild.d.ts

@@ -7,6 +7,6 @@ type ResolveModernRsbuildConfigOptions = {
     modifyModernConfig?: (config: AppUserConfig) => AppUserConfig | Promise<AppUserConfig>;
 };
 export declare function resolveModernRsbuildConfig(options: ResolveModernRsbuildConfigOptions): Promise<{
-    rsbuildConfig: any;
+    rsbuildConfig: import("@rsbuild/core").RsbuildConfig;
 }>;
 export type { ResolveModernRsbuildConfigOptions };

package/dist/types/run/index.d.ts

@@ -14,7 +14,7 @@ export declare function createRunOptions({ cwd, initialLog, metaName, version, i
     initialLog: string;
     configFile: string;
     metaName: string;
-    internalPlugins: any;
+    internalPlugins: import("@modern-js/plugin").Plugin[];
     handleSetupResult: typeof handleSetupResult;
 }>;
 export declare function run(options: RunOptions): Promise<void>;

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

@@ -0,0 +1,79 @@
+export type DeployTarget = 'node' | 'vercel' | 'netlify' | 'ghPages' | 'cloudflare';
+export type CloudflareWorkerSecurityCspMode = 'enforce' | 'report-only' | 'off';
+export interface CloudflareWorkerSecurityCspConfig {
+    mode?: CloudflareWorkerSecurityCspMode;
+    directives?: Record<string, string[] | string | false>;
+    additionalScriptSrc?: string[];
+    additionalStyleSrc?: string[];
+    additionalConnectSrc?: string[];
+    additionalImgSrc?: string[];
+    frameAncestors?: string[] | false;
+    reportUri?: string;
+    reason?: string;
+}
+export interface CloudflareWorkerSecurityNoindexConfig {
+    workersDev?: boolean;
+    localhost?: boolean;
+    previewHostnames?: string[];
+    reason?: string;
+}
+export interface CloudflareWorkerSecurityCorsConfig {
+    /**
+     * Origins allowed to read application responses (BFF APIs, SSR HTML,
+     * route fallbacks) cross-origin. Accepts exact origins
+     * (e.g. `https://shell.example.com`) or `'*'`.
+     * When empty, application responses carry no CORS headers (same-origin).
+     * @default []
+     */
+    allowedOrigins?: string[];
+    /**
+     * Methods advertised on CORS preflight responses for application routes.
+     * @default ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']
+     */
+    allowedMethods?: string[];
+    /**
+     * Headers advertised on CORS preflight responses for application routes.
+     * @default ['*']
+     */
+    allowedHeaders?: string[];
+    /**
+     * Apply wildcard CORS to static asset responses so federated remotes
+     * (remote entries, manifests, CSS) can be loaded cross-origin.
+     * @default true
+     */
+    assets?: boolean;
+    reason?: string;
+}
+export interface CloudflareWorkerSecurityConfig {
+    /**
+     * Disable all Cloudflare worker security defaults for this app.
+     * Prefer narrower escape hatches when possible.
+     */
+    enabled?: boolean;
+    headers?: {
+        referrerPolicy?: string | false;
+        contentTypeOptions?: 'nosniff' | false;
+        permissionsPolicy?: string | false;
+    };
+    contentSecurityPolicy?: CloudflareWorkerSecurityCspConfig;
+    noindex?: boolean | CloudflareWorkerSecurityNoindexConfig;
+    /**
+     * Cross-origin resource sharing policy applied by the generated worker.
+     * Asset responses default to wildcard CORS for federated loading;
+     * application responses (BFF, SSR) default to no CORS headers.
+     */
+    cors?: CloudflareWorkerSecurityCorsConfig;
+    /**
+     * @deprecated Write-only: this option never had any runtime effect — the
+     * generated worker never mutates application `Set-Cookie` headers.
+     * Kept temporarily so configs emitted by existing `modern create`
+     * templates keep typechecking; will be removed once the generator stops
+     * emitting it. Use {@link CloudflareWorkerSecurityConfig.cors} for the
+     * worker's cross-origin policy.
+     */
+    cookies?: {
+        mutateSetCookie?: false;
+        reason?: string;
+    };
+    reason?: string;
+}

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

@@ -1,3 +1,5 @@
+import type { CloudflareWorkerSecurityConfig, DeployTarget } from './cloudflareDeploy';
+export type { CloudflareWorkerSecurityConfig, CloudflareWorkerSecurityCorsConfig, CloudflareWorkerSecurityCspConfig, CloudflareWorkerSecurityCspMode, CloudflareWorkerSecurityNoindexConfig, DeployTarget, } from './cloudflareDeploy';
 export interface MicroFrontend {
     /**
      * Specifies whether to enable the HTML entry.
@@ -11,22 +13,7 @@ export interface MicroFrontend {
      */
     externalBasicLibrary?: boolean;
     moduleApp?: string;
-    /**
-     * Runtime compatibility digest exposed in remote contracts (manifest / remote entry).
-     */
-    runtimeDigest?: string;
-    /**
-     * SRI-style integrity token for the remote entry contract.
-     * Example: `sha256-<base64Digest>`.
-     */
-    integrity?: string;
-    /**
-     * Opaque attestation token exposed in remote runtime metadata.
-     * Can be validated by the host via runtime `remoteTrust.attestations`.
-     */
-    attestation?: string;
 }
-export type DeployTarget = 'node' | 'vercel' | 'netlify' | 'ghPages' | 'cloudflare';
 export interface DeployUserConfig {
     /**
      * Selects the deploy output preset.
@@ -41,6 +28,13 @@ export interface DeployUserConfig {
     microFrontend?: boolean | MicroFrontend;
     worker?: {
         name?: string;
+        /**
+         * Cloudflare Workers compatibility date for generated wrangler config.
+         * Use YYYY-MM-DD. Defaults to the date validated against the bundled
+         * Wrangler version used by UltraModern generated workspaces.
+         */
+        compatibilityDate?: string;
         ssr?: boolean;
+        security?: CloudflareWorkerSecurityConfig;
     };
 }

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

@@ -1,25 +1,8 @@
 import type { BuilderConfig } from '@modern-js/builder';
 import type { SSGConfig, SSGMultiEntryOptions } from '@modern-js/types';
-import type CompressionPlugin from 'compression-webpack-plugin';
 import type { UnwrapBuilderConfig } from '../utils';
-type CompressionPluginOptions = NonNullable<ConstructorParameters<typeof CompressionPlugin>[0]>;
-export type PrecompressCodecOptions = boolean | CompressionPluginOptions;
-export interface PrecompressConfig {
-    /**
-     * Configure gzip precompression options.
-     * `true` means using default options.
-     * `false` means disabling gzip precompression.
-     * @default true
-     */
-    gzip?: PrecompressCodecOptions;
-    /**
-     * Configure brotli precompression options.
-     * `true` means using default options.
-     * `false` means disabling brotli precompression.
-     * @default true
-     */
-    brotli?: PrecompressCodecOptions;
-}
+import type { PrecompressConfig } from './precompress';
+export type { PrecompressCodecOptions, PrecompressConfig } from './precompress';
 export interface OutputUserConfig extends UnwrapBuilderConfig<BuilderConfig, 'output'> {
     /**
      * Enable SSG for self-controlled routing or conventional routing.
@@ -54,7 +37,8 @@ export interface OutputUserConfig extends UnwrapBuilderConfig<BuilderConfig, 'ou
     /**
      * Generate precompressed static assets by using compression-webpack-plugin.
      * `true` means enabling both gzip and brotli with default options.
-     * @default true
+     * Disabled unless explicitly configured; `presetUltramodern` enables it.
+     * @default false
      */
     precompress?: boolean | PrecompressConfig;
 }

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

@@ -0,0 +1,20 @@
+import type CompressionPlugin from 'compression-webpack-plugin';
+type CompressionPluginOptions = NonNullable<ConstructorParameters<typeof CompressionPlugin>[0]>;
+export type PrecompressCodecOptions = boolean | CompressionPluginOptions;
+export interface PrecompressConfig {
+    /**
+     * Configure gzip precompression options.
+     * `true` means using default options.
+     * `false` means disabling gzip precompression.
+     * @default true
+     */
+    gzip?: PrecompressCodecOptions;
+    /**
+     * Configure brotli precompression options.
+     * `true` means using default options.
+     * `false` means disabling brotli precompression.
+     * @default true
+     */
+    brotli?: PrecompressCodecOptions;
+}
+export {};