@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/dist/esm-node/workspace-topology.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+import { existsSync } from "node:fs";
+import node_path from "node:path";
+const REFERENCE_TOPOLOGY_PATH = 'topology/reference-topology.json';
+const DEVELOPMENT_OVERLAY_PATH = 'topology/local-overlays/development.json';
+const normalizeRelativePath = (value)=>value.replace(/\\/gu, '/').replace(/^\.\/+/u, '');
+const distributedSsrFragmentSlug = (expose)=>{
+    const slug = expose.replace(/^\.\//u, '').trim().replace(/([a-z0-9])([A-Z])/gu, '$1-$2').replace(/[^a-zA-Z0-9._-]+/gu, '-').replace(/[._]+/gu, '-').toLowerCase().replace(/-+/gu, '-').replace(/^-+|-+$/gu, '');
+    if (!slug) throw new Error(`Invalid distributed SSR expose ${expose}.`);
+    return slug;
+};
+const distributedSsrFragmentRoute = (expose)=>`/{locale}/_mf/fragment/${distributedSsrFragmentSlug(expose)}`;
+const findWorkspaceRoot = (appDirectory)=>{
+    let current = appDirectory;
+    while(true){
+        if (existsSync(node_path.join(current, REFERENCE_TOPOLOGY_PATH))) return current;
+        const parent = node_path.dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+};
+export { DEVELOPMENT_OVERLAY_PATH, REFERENCE_TOPOLOGY_PATH, distributedSsrFragmentRoute, distributedSsrFragmentSlug, findWorkspaceRoot, normalizeRelativePath };

package/dist/types/backend-federation-build/codegen.d.ts

@@ -53,6 +53,36 @@ export declare const createBackendManifest: (workspaceRoot: string, distDirector
     }[];
     shared: never[];
     backendFederation: {
+        role: string;
+        appId: string;
+        name: string;
+        runtimeFramework: string;
+        strictEffectApproach: boolean;
+        contractVersion: string;
+        nodeAdapterVersion: string;
+        remoteType: string;
+        expose: string;
+        manifestUrl: string;
+        containerEntry: string;
+        source: {
+            module: string;
+        };
+        rpcPath: string | undefined;
+        rpcSerialization: string;
+        deliveryUnit?: import("@modern-js/backend-federation-contracts").DeliveryUnitContractBlock | undefined;
+        versionBoundary: {
+            invariant: string;
+            packageName: string | undefined;
+            version: string | undefined;
+            buildVersion: string | undefined;
+            uiManifestUrl?: string | undefined;
+            deliveryUnit?: {
+                unitId: string;
+                buildMarker: string;
+                sourceRevision: string;
+            } | undefined;
+        };
+    } | {
         role: string;
         appId: string;
         name: string;

package/dist/types/backend-federation-build/config.d.ts

@@ -1,56 +1,6 @@
 import { type DeliveryUnitContractBlock, type UltramodernBuildArtifact } from '@modern-js/backend-federation-contracts';
-export declare const COMPACT_CONFIG_PATH = ".modernjs/ultramodern.json";
-export type CompactApp = {
-    id?: unknown;
-    kind?: unknown;
-    path?: unknown;
-    package?: unknown;
-    port?: unknown;
-    api?: {
-        prefix?: unknown;
-        stem?: unknown;
-    };
-    moduleFederation?: {
-        name?: unknown;
-        manifestUrl?: unknown;
-    };
-    backendFederation?: {
-        name?: unknown;
-        versionBoundary?: {
-            ui?: {
-                manifestUrl?: unknown;
-            };
-        };
-        executionSurfaces?: {
-            node?: {
-                remoteName?: unknown;
-                manifestUrl?: unknown;
-                containerEntry?: unknown;
-                remoteType?: unknown;
-            };
-        };
-    };
-    deliveryUnit?: {
-        unitId?: unknown;
-        buildMarker?: unknown;
-        sourceRevision?: unknown;
-        packageName?: unknown;
-        version?: unknown;
-    };
-    serverExecution?: {
-        node?: {
-            remoteName?: unknown;
-            manifestUrl?: unknown;
-            containerEntry?: unknown;
-            remoteType?: unknown;
-        };
-    };
-};
-export type CompactConfig = {
-    topology?: {
-        apps?: CompactApp[];
-    };
-};
+import { type DevelopmentOverlay, type TopologyApp } from '../workspace-topology.js';
+export { DEVELOPMENT_OVERLAY_PATH, type DevelopmentOverlay, findWorkspaceRoot, normalizeRelativePath, REFERENCE_TOPOLOGY_PATH, type ReferenceTopology, type TopologyApp, } from '../workspace-topology.js';
 export type BackendFederationApp = {
     id: string;
     directory: string;
@@ -62,13 +12,15 @@ export type BackendFederationApp = {
     deliveryUnit?: DeliveryUnitContractBlock;
     port: number;
     apiPrefix: string;
+    apiProtocol: 'rest' | 'rpc';
+    rpcPath?: string;
     apiStem: string;
     backendName: string;
     manifestUrl: string;
     containerEntry: string;
     remoteType: string;
     uiManifestUrl?: string;
-    compactDeliveryUnit?: {
+    topologyDeliveryUnit?: {
         unitId?: string;
         buildMarker?: string;
         sourceRevision?: string;
@@ -85,10 +37,8 @@ export type BackendFederationBuildIdentity = {
     sourceRevision?: string;
     artifact?: UltramodernBuildArtifact;
 };
-export declare const normalizeRelativePath: (value: string) => string;
 export declare const buildArtifactPathFor: (appDirectory: string) => string;
 export declare const readBuildIdentity: (appDirectory: string) => Promise<BackendFederationBuildIdentity>;
-export declare const findWorkspaceRoot: (appDirectory: string) => string | undefined;
 export declare const resolveWorkspaceSourceRevision: (workspaceRoot: string) => Promise<string>;
 export declare const createStampedDeliveryUnit: (input: {
     appId: string;
@@ -98,5 +48,8 @@ export declare const createStampedDeliveryUnit: (input: {
     version?: string;
     sourceRevision: string;
 }) => DeliveryUnitContractBlock | undefined;
-export declare const createAppFromCompactMetadata: (workspaceRoot: string, appDirectory: string, compactApp: CompactApp) => BackendFederationApp | undefined;
-export declare const findBackendFederationApp: (workspaceRoot: string, appDirectory: string) => Promise<BackendFederationApp | undefined>;
+export declare const createAppFromTopology: (workspaceRoot: string, appDirectory: string, topologyApp: TopologyApp, overlay: DevelopmentOverlay, packageManifest: {
+    name?: unknown;
+    version?: unknown;
+}) => BackendFederationApp | undefined;
+export declare const findBackendFederationApp: (workspaceRoot: string, appDirectory: string) => Promise<BackendFederationApp>;

package/dist/types/backend-federation-build/emit.d.ts

@@ -1,3 +1,4 @@
+import { type RendererBuildOutputContext, type RendererBuildOutputOptions } from '../release-envelope/renderer-output-stamp.js';
 export type { BackendFederationBuildIdentity } from './config.js';
 export type BackendFederationArtifactResult = {
     appId: string;
@@ -7,14 +8,23 @@ export type BackendFederationArtifactResult = {
     remoteName: string;
     remoteType: string;
 };
-export declare const emitBackendFederationArtifacts: (appDirectory: string, distDirectory: string) => Promise<BackendFederationArtifactResult | undefined>;
+export type BackendFederationBuildOptions = {
+    resolveRendererBuild?: RendererBuildOutputOptions['resolveRendererBuild'];
+    rendererBuildPlugin?: RendererBuildOutputOptions['rendererBuildPlugin'];
+    entrypoints?: RendererBuildOutputContext['entrypoints'];
+};
+export declare const emitBackendFederationArtifacts: (appDirectory: string, distDirectory: string, options?: BackendFederationBuildOptions) => Promise<BackendFederationArtifactResult | undefined>;
 export default _default;
-declare function _default(): {
+declare function _default(options?: Omit<BackendFederationBuildOptions, 'entrypoints'>): {
     name: string;
+    pre: string[];
+    required: string[];
     setup(api: {
         getAppContext(): {
             appDirectory: string;
             distDirectory: string;
+            entrypoints?: RendererBuildOutputContext['entrypoints'];
+            apiOnly?: boolean;
         };
         onAfterBuild(handler: () => Promise<void>): void;
     }): void;

package/dist/types/backend-federation-build/index.d.ts

@@ -1,2 +1,2 @@
-export type { BackendFederationArtifactResult } from './emit.js';
+export type { BackendFederationArtifactResult, BackendFederationBuildOptions, } from './emit.js';
 export { default, emitBackendFederationArtifacts } from './emit.js';

package/dist/types/build-config/build-environment.d.ts

@@ -1,22 +1,16 @@
-import type { URL } from 'node:url';
-import type { Rspack } from '@rsbuild/core';
+import { type URL } from 'node:url';
 /**
  * Reads an environment variable while keeping generated build configs free of
  * direct process access.
  */
 export declare function getBuildConfigEnvironment(name: string): string | undefined;
-/**
- * Runs a Rspack config setup under a leased environment value. The lease is
- * restored when that compiler reaches any supported terminal hook.
- */
-export declare function withBuildConfigEnvironment<Config extends {
-    plugins?: Rspack.Plugin[];
-}, SetupArguments extends unknown[]>(name: string, value: string, setup: (config: Config, ...args: SetupArguments) => Config | void | Promise<Config | void>): (config: Config, ...args: SetupArguments) => Promise<Config>;
 export type ResolveEffectTsgoCompilerOptions = {
     /** Module URL or absolute filename used to resolve the consumer's compiler. */
     from: string | URL;
 };
 /**
- * Resolves the Effect TS-Go executable used by Module Federation DTS builds.
+ * Resolves the Effect-enabled native executable for checking and DTS builds.
+ * Use metadata-bound tsrs where both tsrs and the Effect provider support it.
+ * Unsupported targets use Effect-Go. Missing supported artifacts remain fatal.
  */
 export declare function resolveEffectTsgoCompiler(options: ResolveEffectTsgoCompilerOptions): string;

package/dist/types/build-config/internal-effect-discovery.d.ts

@@ -0,0 +1,6 @@
+import { type URL } from 'node:url';
+export declare function effectCompilerDiscoveryFailureStage(error: unknown): string | undefined;
+/** Explicit native binaries must still report Effect diagnostics support. */
+export declare function validateConfiguredEffectCompiler(compiler: string, from: string | URL): void;
+/** Selects the exact native replacement without invoking the provider CLI. */
+export declare function resolveInstalledEffectCompiler(from: string | URL): string;

package/dist/types/build-config/public.d.ts

@@ -1,2 +1,2 @@
 export type { ResolveEffectTsgoCompilerOptions } from './build-environment.js';
-export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment, } from './build-environment.js';
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, } from './build-environment.js';

package/dist/types/build-config/remote-address.d.ts

@@ -0,0 +1,3 @@
+import { type BrowserManifestAddressOptions } from '@modern-js/surface-resolution';
+/** Adapt build environment leases and MF's name@URL syntax to discovery policy. */
+export declare function createRemoteManifestUrl(options: BrowserManifestAddressOptions): string;

package/dist/types/cloudflare/artifacts.d.ts

@@ -4,12 +4,13 @@ export declare const getCloudflareArtifacts: (modernConfig: CloudflareModernConf
     to: string;
     index: number;
 }[];
-export declare const getCloudflarePublicAssets: (modernConfig: CloudflareModernConfig) => {
-    from: string;
-    to: string;
-    index: number;
-}[];
+export declare const getCloudflarePublicAssets: (modernConfig: CloudflareModernConfig) => import("../deploy-output/public-assets.js").DeclaredPublicAsset[];
 export declare const copyCloudflareArtifacts: (appDirectory: string, outputDirectory: string, artifacts: ReturnType<typeof getCloudflareArtifacts>) => Promise<void>;
-export declare const copyCloudflarePublicAssets: (appDirectory: string, publicDirectory: string, publicAssets: ReturnType<typeof getCloudflarePublicAssets>) => Promise<void>;
+/**
+ * Stage `deploy.worker.publicAssets` into Worker Static Assets.
+ *
+ * @returns the staged files relative to the Cloudflare output root.
+ */
+export declare const copyCloudflarePublicAssets: (appDirectory: string, outputDirectory: string, publicAssets: ReturnType<typeof getCloudflarePublicAssets>) => Promise<string[]>;
 export declare const copyCloudflareD1Migrations: (appDirectory: string, outputDirectory: string, modernConfig: CloudflareModernConfig) => Promise<void>;
 export declare const readRouteSpec: (outputDirectory: string) => Promise<any>;

package/dist/types/cloudflare/constants.d.ts

@@ -19,6 +19,6 @@ export declare const BFF_EFFECT_WORKER_DISPATCHER_EXPORT = "__modern_create_effe
 export declare const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = "Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/bff-effect/effect-edge instead of lambda/Hono server helpers.";
 export declare const DEFAULT_COMPATIBILITY_DATE = "2026-06-02";
 export declare const COMPATIBILITY_DATE_PATTERN: RegExp;
-export declare const REQUIRED_COMPATIBILITY_FLAGS: readonly ["nodejs_compat", "global_fetch_strictly_public"];
+export declare const REQUIRED_COMPATIBILITY_FLAGS: readonly ["nodejs_compat", "global_fetch_strictly_public", "enable_request_signal"];
 export declare const RESERVED_ARTIFACT_DESTINATION_FILES: Set<string>;
 export declare const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES: Set<string>;

package/dist/types/cloudflare/delivery-unit.d.ts

@@ -1,23 +1,54 @@
-import { type DeliveryUnitIdentity } from '@modern-js/backend-federation-contracts';
+import { type DeliveryUnitIdentity, type RendererIdentity, type RendererProfile, type RendererRouterBindings } from '@modern-js/backend-federation-contracts';
 export type DeliveryUnitStamp = DeliveryUnitIdentity & {
     surfaces: {
         ui?: DeliveryUnitIdentity & {
             surface: 'ui';
+            rendererIdentity: RendererIdentity;
+            rendererProfile: RendererProfile;
+            routerBindings: RendererRouterBindings;
         };
         api?: DeliveryUnitIdentity & {
             surface: 'api';
         };
     };
 };
+/**
+ * The topology's declaration of one delivery unit. A UI surface may omit the
+ * renderer projection entirely (a React workspace authored before renderer
+ * selection); the build then resolves its renderer identity from the app
+ * config alone, and there is no declared projection to verify it against.
+ */
+export type TopologyUiSurface = DeliveryUnitIdentity & {
+    surface: 'ui';
+} & ({
+    rendererIdentity: RendererIdentity;
+    rendererProfile: RendererProfile;
+    routerBindings: RendererRouterBindings;
+} | {
+    rendererIdentity?: undefined;
+    rendererProfile?: undefined;
+    routerBindings?: undefined;
+});
+export type TopologyDeliveryUnit = DeliveryUnitIdentity & {
+    /** The declaring topology app. */
+    appId: string;
+    surfaces: {
+        ui?: TopologyUiSurface;
+        api?: DeliveryUnitIdentity & {
+            surface: 'api';
+        };
+    };
+};
+/** Resolve the producer role from this app's authoritative topology membership. */
+export declare const resolveTopologyReleaseRole: (appDirectory: string) => Promise<'microvertical' | 'shell' | undefined>;
 /**
  * Resolve the delivery-unit record declared for this app by the workspace
- * compact config (`.modernjs/ultramodern.json`). This is the topology source
+ * reference topology. This is the topology source
  * of truth the Cloudflare worker snapshot is verified against.
  */
-export declare const resolveTopologyDeliveryUnit: (appDirectory: string) => Promise<DeliveryUnitStamp | undefined>;
+export declare const resolveTopologyDeliveryUnit: (appDirectory: string) => Promise<TopologyDeliveryUnit | undefined>;
 /**
- * Resolve the delivery-unit identity actually bundled into the worker by
- * reading the generated `shared/ultramodern-build.json` artifact. This is the
- * worker snapshot / declared surface source that gets stamped into the manifest.
+ * Preserve the finalized build artifact already stamped from renderer-build.json.
+ * The generation artifact cannot attest the compiled application.
  */
-export declare const resolveWorkerDeliveryUnitStamp: (appDirectory: string) => Promise<DeliveryUnitStamp | undefined>;
+export declare const resolveWorkerDeliveryUnitStamp: (appDirectory: string, distDirectory: string) => Promise<DeliveryUnitStamp | undefined>;

package/dist/types/cloudflare/native-renderer.d.ts

@@ -0,0 +1,30 @@
+import type { WorkerRendererBuild } from './renderer-identity.js';
+/**
+ * Build-validated native document inputs for each worker route. The Node host
+ * reads these from `dist`; a module worker has no filesystem, so the native
+ * build writes them beside its worker bundles and deploy inlines them.
+ */
+export declare const NATIVE_RENDERER_WORKER_RESOURCES_FILE = "worker/native-renderer.json";
+export interface NativeRendererWorkerEntry {
+    readonly assets: readonly unknown[];
+    readonly nativeManifest?: unknown;
+    readonly hydrationBuildId?: string;
+    readonly serverConfig: {
+        readonly ssr: boolean | 'stream';
+        readonly ssrByRouteIds?: readonly string[];
+    };
+    readonly csrFallbackHeader?: string;
+    readonly nonce?: string;
+}
+export interface NativeRendererWorkerResources {
+    readonly schema: 'ultramodern-native-worker-resources';
+    readonly version: 1;
+    /** The built renderer, whose adapter serves native documents. */
+    readonly renderer: string;
+    readonly entries: Readonly<Record<string, NativeRendererWorkerEntry>>;
+}
+/**
+ * Read the native worker resources for a built application. Every built entry
+ * of the resources' renderer must have validated document inputs.
+ */
+export declare function readNativeRendererWorkerResources(distDirectory: string, build: WorkerRendererBuild | undefined): Promise<NativeRendererWorkerResources | undefined>;

package/dist/types/cloudflare/renderer-identity.d.ts

@@ -0,0 +1,25 @@
+import { type RendererIdentity } from '@modern-js/backend-federation-contracts';
+import type { DeliveryUnitStamp } from './delivery-unit.js';
+export type WorkerRendererIdentities = Readonly<Record<string, RendererIdentity>>;
+/** The built renderer and how its adapter serves worker documents. */
+export interface WorkerRenderer {
+    readonly name: string;
+    /** Documents come only from the renderer's native server handler. */
+    readonly nativeDocuments: boolean;
+    readonly rsc: boolean;
+}
+export interface WorkerRendererBuild {
+    readonly renderer: WorkerRenderer;
+    readonly identities: WorkerRendererIdentities;
+}
+/** Bind response metadata to the finalized build and its generated entries. */
+export declare function readWorkerRendererBuild(distDirectory: string, routes: readonly {
+    entryName?: unknown;
+    entryPath?: unknown;
+    isApi?: unknown;
+    isSSR?: unknown;
+    worker?: unknown;
+    bundle?: unknown;
+    isRSC?: unknown;
+    isStream?: unknown;
+}[], deliveryUnit?: DeliveryUnitStamp): Promise<WorkerRendererBuild | undefined>;

package/dist/types/cloudflare/worker-manifest.d.ts

@@ -1,3 +1,4 @@
+import type { BffEffectDataPlatformUserConfig, BffEffectOpenApiUserConfig } from '@modern-js/server-runtime-extensions/server-config';
 import type { DeliveryUnitStamp } from './delivery-unit.js';
 import type { CloudflareAppContext, CloudflareModernConfig } from './types.js';
 export declare const createWorkerManifest: (outputDirectory: string, modernConfig: CloudflareModernConfig, appContext: CloudflareAppContext, deliveryUnitStamp: DeliveryUnitStamp | undefined) => Promise<{
@@ -84,8 +85,18 @@ export declare const createWorkerManifest: (outputDirectory: string, modernConfi
             path: string;
             css: string[];
         }[];
+        routeCss: string[];
     } | undefined;
     deliveryUnit?: DeliveryUnitStamp | undefined;
+    renderer?: import("./renderer-identity.js").WorkerRenderer | undefined;
+    rendererIdentities?: Readonly<Record<string, Readonly<{
+        renderer: import("@modern-js/backend-federation-contracts").RendererName;
+        appId: string;
+        entryName: string;
+        protocolVersion: typeof import("@modern-js/backend-federation-contracts").RENDERER_PROTOCOL_VERSION;
+        buildId: string;
+    }>>> | undefined;
+    nativeRenderer?: import("./native-renderer.js").NativeRendererWorkerResources | undefined;
     i18n: {
         entries: Record<string, {
             i18nextDetector: boolean;
@@ -108,8 +119,8 @@ export declare const createWorkerManifest: (outputDirectory: string, modernConfi
         prefix: string;
         worker: string;
         effect: {
-            openapi?: import("@modern-js/runtime-extensions/server-config").BffEffectOpenApiUserConfig | undefined;
-            dataPlatform?: import("@modern-js/runtime-extensions/server-config").BffEffectDataPlatformUserConfig | undefined;
+            openapi?: BffEffectOpenApiUserConfig | undefined;
+            dataPlatform?: BffEffectDataPlatformUserConfig | undefined;
             crossProjectPolicy: {
                 allowedNamespaces?: string[];
                 verifyProducerIdentity?: (headers: Record<string, unknown>) => string | undefined;
@@ -130,7 +141,12 @@ export declare const createWorkerManifest: (outputDirectory: string, modernConfi
             };
         } | undefined;
     } | undefined;
-    serviceBindings?: {
+    serviceBindings?: ({
+        binding: string;
+        interface: string;
+        prefix: string;
+        vpcServiceId: string;
+    } | {
         binding: string;
         service: string;
         interface: string;
@@ -141,7 +157,7 @@ export declare const createWorkerManifest: (outputDirectory: string, modernConfi
             boundaryId: string;
             path: string;
         }[] | undefined;
-    }[] | undefined;
+    })[] | undefined;
 }>;
 export declare const createWorkerModuleLoaders: (manifest: any) => string;
 export declare const getPublicAssetExcludes: (appDirectory: string, modernConfig: CloudflareModernConfig) => string[];

package/dist/types/cloudflare/worker-options.d.ts

@@ -0,0 +1,20 @@
+import type { RequestHandlerOptions } from '@modern-js/server-core';
+/** The native context supplied to a Cloudflare module worker's fetch method. */
+export interface CloudflareExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+}
+/** Worker request bindings follow the shared RequestPlatform kind/bindings shape. */
+export interface CloudflareWorkerPlatform<Bindings extends object = object> {
+    readonly kind: 'worker';
+    /** The original env object. Direct worker invocations may omit it. */
+    readonly bindings: Bindings | undefined;
+}
+/** Request-owned options for manifest HTML and Flight worker handlers. */
+export interface CloudflareWorkerRequestHandlerOptions<Bindings extends object = object> extends RequestHandlerOptions {
+    readonly platform: CloudflareWorkerPlatform<Bindings>;
+    /** The original context, including its native method receivers. */
+    readonly executionContext: CloudflareExecutionContext | undefined;
+}
+/** Narrow native handler options without replacing their worker references. */
+export declare function isCloudflareWorkerRequestHandlerOptions(options: RequestHandlerOptions): options is CloudflareWorkerRequestHandlerOptions;

package/dist/types/cloudflare/wrangler-config.d.ts

@@ -11,7 +11,22 @@ export declare const createWorkerServiceBindings: (modernConfig: CloudflareModer
         path: string;
     }[] | undefined;
 }[] | JsonValue | undefined;
-export declare const createWorkerManifestServiceBindings: (serviceBindings: ReturnType<typeof createWorkerServiceBindings>) => {
+/**
+ * The prefix the worker's Effect BFF dispatcher owns. It runs before any
+ * service binding, so it takes part in route-overlap checks.
+ */
+export declare const getWorkerEffectBffPrefix: (modernConfig: CloudflareModernConfig) => string | undefined;
+export declare const createWorkerVpcServiceBindings: (modernConfig: CloudflareModernConfig, configuredWranglerVpcServices: JsonValue | undefined, serviceBindings: ReturnType<typeof createWorkerServiceBindings>, workerBindingNames: ReadonlySet<string>) => {
+    binding: string;
+    serviceId: string;
+    prefix?: string | undefined;
+}[] | undefined;
+export declare const createWorkerManifestServiceBindings: (serviceBindings: ReturnType<typeof createWorkerServiceBindings>, vpcServiceBindings: ReturnType<typeof createWorkerVpcServiceBindings>) => ({
+    binding: string;
+    interface: string;
+    prefix: string;
+    vpcServiceId: string;
+} | {
     binding: string;
     service: string;
     interface: string;
@@ -22,7 +37,7 @@ export declare const createWorkerManifestServiceBindings: (serviceBindings: Retu
         boundaryId: string;
         path: string;
     }[] | undefined;
-}[] | undefined;
+})[] | undefined;
 export declare const createWranglerConfig: (appDirectory: string, modernConfig: CloudflareModernConfig) => {
     $schema: string;
     name: string;
@@ -34,6 +49,7 @@ export declare const createWranglerConfig: (appDirectory: string, modernConfig:
         binding: string;
         run_worker_first: boolean;
     };
+    env?: Record<string, Record<string, JsonValue>> | undefined;
     d1_databases?: {
         binding: string;
         database_name: string;
@@ -48,4 +64,41 @@ export declare const createWranglerConfig: (appDirectory: string, modernConfig:
     }[] | {
         [key: string]: JsonValue;
     } | null | undefined;
+} | {
+    $schema: string;
+    name: string;
+    compatibility_date: string;
+    main: string;
+    compatibility_flags: JsonValue[];
+    assets: {
+        directory: string;
+        binding: string;
+        run_worker_first: boolean;
+    };
+    env?: Record<string, Record<string, JsonValue>> | {
+        [k: string]: {
+            vpc_services: {
+                binding: string;
+                service_id: string;
+            }[];
+        };
+    } | undefined;
+    d1_databases?: {
+        binding: string;
+        database_name: string;
+        database_id: string;
+        migrations_dir?: string | undefined;
+        preview_database_id?: string | undefined;
+        remote?: boolean | undefined;
+    }[] | JsonValue | undefined;
+    services?: string | number | boolean | JsonValue[] | {
+        binding: string;
+        service: string;
+    }[] | {
+        [key: string]: JsonValue;
+    } | null | undefined;
+    vpc_services: {
+        binding: string;
+        service_id: string;
+    }[];
 };

package/dist/types/cloudflare-builder.d.ts

@@ -1,22 +1,27 @@
 import type { BffUserConfig } from '@modern-js/server-core';
-import type { EnvironmentConfig, ModifyBundlerChainFn } from '@rsbuild/core';
+import type { EnvironmentConfig, ModifyBundlerChainFn, Rspack } from '@rsbuild/core';
+import type { ResolvedDeployTarget } from './deploy-output/target.js';
 export interface CloudflareBuilderNormalizedConfig {
     bff?: BffUserConfig;
-    deploy?: {
-        target?: string;
+    server?: {
+        rsc?: unknown;
     };
 }
 export interface CloudflareBuilderAppContext {
+    apiOnly?: boolean;
+    deployTarget?: ResolvedDeployTarget;
     apiDirectory: string;
     appDirectory: string;
+    entrypoints?: ReadonlyArray<{
+        entryName: string;
+    }>;
+    internalDirectory?: string;
 }
 export interface CloudflareBuilderEnvironmentsOptions {
     appContext: CloudflareBuilderAppContext;
     environments: Record<string, EnvironmentConfig>;
     normalizedConfig: CloudflareBuilderNormalizedConfig;
-    resolveDeployProvider?: ResolveCloudflareDeployProvider;
 }
-export type ResolveCloudflareDeployProvider = () => string | undefined;
 export interface CloudflareWorkerRspackConfig {
     externals: Record<string, string>;
     externalsType: 'module-import';
@@ -51,9 +56,47 @@ export interface CloudflareBuilderPlugin {
     name: string;
     setup(api: CloudflareBuilderPluginApi): void;
 }
+type AliasField = string | readonly string[];
+/**
+ * Leaves an absent optional dependency missing at runtime, exactly as Node
+ * does, instead of failing the worker build. It applies only when the
+ * importing package itself declares the request as an optional peer
+ * (`peerDependenciesMeta.<name>.optional`) or an `optionalDependencies`
+ * entry, the package is not found in any `resolve.modules` directory, and
+ * neither the app (`resolve.alias`, `resolve.fallback`, `externals`) nor the
+ * importing package (an enabled `resolve.aliasFields` entry such as
+ * `browser`) redirects the request. The import
+ * then rejects with "Cannot find module" so the library's own fallback
+ * handles it (for example `@redis/client` guards `import('@node-rs/xxhash')`).
+ */
+export declare const createAbsentOptionalDependencyFilter: (isRedirected?: (request: string) => boolean, moduleDirectories?: readonly string[], aliasFields?: readonly AliasField[]) => (request: string, context: string) => boolean;
+type AliasOption = Record<string, unknown> | {
+    name: string;
+    onlyModule?: boolean;
+}[] | false | undefined;
+/**
+ * Reads the final resolved `resolve.alias`, `resolve.fallback` and
+ * `externals` so an app's own
+ * replacement for an optional package still wins over the absent-module
+ * fallback (the fallback runs before resolution).
+ */
+export declare const createRequestRedirectMatcher: (options: {
+    externals?: unknown;
+    resolve?: {
+        alias?: AliasOption;
+        fallback?: AliasOption;
+    };
+}) => (request: string) => boolean;
+type FunctionExternal = (data: Rspack.ExternalItemFunctionData, callback: (error?: Error | null, result?: unknown) => void) => unknown;
+/**
+ * Reports whether any function external claims the request. A function that
+ * throws is treated as claiming it, so the request goes through ordinary
+ * external processing and surfaces that error instead of being ignored.
+ */
+export declare const claimsByFunctionExternal: (externals: readonly FunctionExternal[], data: Rspack.ExternalItemFunctionData) => Promise<boolean>;
 export declare function getCloudflareWorkerRspackConfig(workerEntryNames: Iterable<string>): CloudflareWorkerRspackConfig;
 export declare function applyCloudflareWorkerRspackConfig(chain: Parameters<ModifyBundlerChainFn>[0], workerEntryNames: Iterable<string>): void;
-export declare function applyCloudflareWorkerMfRuntimeBoundary(chain: Parameters<ModifyBundlerChainFn>[0]): void;
-export declare function getCloudflareBuilderEnvironments({ appContext, environments, normalizedConfig, resolveDeployProvider, }: CloudflareBuilderEnvironmentsOptions): Record<string, EnvironmentConfig>;
+export declare function getCloudflareBuilderEnvironments({ appContext, environments, normalizedConfig, }: CloudflareBuilderEnvironmentsOptions): Record<string, EnvironmentConfig>;
 export declare function applyCloudflareBuilderEnvironments(options: CloudflareBuilderEnvironmentsOptions): CloudflareBuilderEnvironmentsResult;
-export declare const createCloudflareBuilderPlugin: (resolveDeployProvider?: ResolveCloudflareDeployProvider) => CloudflareBuilderPlugin;
+export declare const createCloudflareBuilderPlugin: () => CloudflareBuilderPlugin;
+export {};