@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

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

@@ -0,0 +1,116 @@
+import type { BackendFederationEntryIntegrity } from '@modern-js/server-runtime-extensions/backend-federation-security';
+import { type BackendFederationApp } from './config.js';
+export declare const createBackendRemoteEntrySource: (workspaceRoot: string, app: BackendFederationApp, effectApiPath: string, entryPath: string) => Promise<string>;
+export declare const createBackendManifest: (workspaceRoot: string, distDirectory: string, app: BackendFederationApp, entryIntegrity: BackendFederationEntryIntegrity) => {
+    schemaVersion: number;
+    id: string;
+    name: string;
+    version: string | undefined;
+    buildVersion: string | undefined;
+    metaData: {
+        name: string;
+        type: string;
+        buildInfo: {
+            buildVersion: string | undefined;
+            buildName: string | undefined;
+        };
+        remoteEntry: {
+            name: string;
+            path: string;
+            type: string;
+        };
+        globalName: string;
+        publicPath: string;
+        ssrRemoteEntry: {
+            name: string;
+            path: string;
+            type: string;
+        };
+        ssrPublicPath: string;
+    };
+    entry: {
+        byteLength: number;
+        sha256: string;
+        file: string;
+        path: string;
+        type: string;
+        url: string;
+    };
+    exposes: {
+        id: string;
+        name: string;
+        path: string;
+        assets: {
+            js: {
+                async: never[];
+                sync: string[];
+            };
+            css: {
+                async: never[];
+                sync: never[];
+            };
+        };
+    }[];
+    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;
+        runtimeFramework: string;
+        strictEffectApproach: boolean;
+        contractVersion: string;
+        nodeAdapterVersion: string;
+        remoteType: string;
+        expose: string;
+        manifestUrl: string;
+        containerEntry: string;
+        source: {
+            module: string;
+        };
+        readinessPath: string;
+        openapiPath: 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;
+        };
+    };
+};

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

@@ -0,0 +1,121 @@
+import { type DeliveryUnitContractBlock, type UltramodernBuildArtifact } from '@modern-js/backend-federation-contracts';
+export declare const REFERENCE_TOPOLOGY_PATH = "topology/reference-topology.json";
+export declare const DEVELOPMENT_OVERLAY_PATH = "topology/local-overlays/development.json";
+export type TopologyApp = {
+    id?: unknown;
+    domain?: unknown;
+    kind?: unknown;
+    path?: unknown;
+    package?: unknown;
+    portEnv?: unknown;
+    cloudflare?: {
+        publicUrlEnv?: unknown;
+    };
+    api?: {
+        bff?: {
+            prefix?: unknown;
+        };
+        protocol?: unknown;
+        rpcPath?: unknown;
+        rpcSerialization?: 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;
+    };
+};
+export type DevelopmentOverlay = {
+    ports?: Record<string, unknown>;
+    manifests?: Record<string, unknown>;
+    serverExecution?: Record<string, {
+        node?: {
+            remoteName?: unknown;
+            manifestUrl?: unknown;
+            containerEntry?: unknown;
+            remoteType?: unknown;
+        };
+    }>;
+};
+export type ReferenceTopology = {
+    shell?: TopologyApp;
+    shells?: TopologyApp[];
+    verticals?: TopologyApp[];
+};
+export type BackendFederationApp = {
+    id: string;
+    directory: string;
+    packageName?: string;
+    version?: string;
+    buildVersion?: string;
+    unitId?: string;
+    sourceRevision?: string;
+    deliveryUnit?: DeliveryUnitContractBlock;
+    port: number;
+    apiPrefix: string;
+    apiProtocol: 'rest' | 'rpc';
+    rpcPath?: string;
+    apiStem: string;
+    backendName: string;
+    manifestUrl: string;
+    containerEntry: string;
+    remoteType: string;
+    uiManifestUrl?: string;
+    topologyDeliveryUnit?: {
+        unitId?: string;
+        buildMarker?: string;
+        sourceRevision?: string;
+        packageName?: string;
+        version?: string;
+    };
+};
+export type BackendFederationBuildIdentity = {
+    appId?: string;
+    packageName?: string;
+    version?: string;
+    buildVersion?: string;
+    unitId?: string;
+    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;
+    unitId?: string;
+    buildMarker?: string;
+    packageName?: string;
+    version?: string;
+    sourceRevision: string;
+}) => DeliveryUnitContractBlock | 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

@@ -0,0 +1,21 @@
+export type { BackendFederationBuildIdentity } from './config.js';
+export type BackendFederationArtifactResult = {
+    appId: string;
+    manifestPath: string;
+    containerPath: string;
+    deliveryUnitArtifactPath?: string;
+    remoteName: string;
+    remoteType: string;
+};
+export declare const emitBackendFederationArtifacts: (appDirectory: string, distDirectory: string) => Promise<BackendFederationArtifactResult | undefined>;
+export default _default;
+declare function _default(): {
+    name: string;
+    setup(api: {
+        getAppContext(): {
+            appDirectory: string;
+            distDirectory: string;
+        };
+        onAfterBuild(handler: () => Promise<void>): void;
+    }): void;
+};

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

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

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

@@ -0,0 +1,14 @@
+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;
+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.
+ */
+export declare function resolveEffectTsgoCompiler(options: ResolveEffectTsgoCompilerOptions): string;

package/dist/types/build-config/precompress/plugin.d.ts

@@ -0,0 +1,4 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { PrecompressConfig } from './types.js';
+export type { PrecompressCodecOptions, PrecompressConfig } from './types.js';
+export declare const builderPluginAdapterPrecompress: (precompress: boolean | PrecompressConfig | undefined) => RsbuildPlugin;

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

@@ -0,0 +1,19 @@
+import type { CompressionPluginOptions } from '../../precompress/index.js';
+export type PrecompressCodecOptions = boolean | Partial<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 {};

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

@@ -0,0 +1,2 @@
+export type { ResolveEffectTsgoCompilerOptions } 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

@@ -16,7 +16,7 @@ export declare const SERVER_OUTPUT_DIRECTORY = "server";
 export declare const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES: readonly ['api', 'shared'];
 export declare const BFF_EFFECT_WORKER_ENTRY = "worker/__modern_bff_effect.js";
 export declare const BFF_EFFECT_WORKER_DISPATCHER_EXPORT = "__modern_create_effect_bff_dispatcher";
-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/plugin-bff/effect-edge instead of lambda/Hono server helpers.";
+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"];

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

@@ -1,4 +1,4 @@
-import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+import { type DeliveryUnitIdentity } from '@modern-js/backend-federation-contracts';
 export type DeliveryUnitStamp = DeliveryUnitIdentity & {
     surfaces: {
         ui?: DeliveryUnitIdentity & {
@@ -11,13 +11,13 @@ export type DeliveryUnitStamp = DeliveryUnitIdentity & {
 };
 /**
  * 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>;
 /**
  * Resolve the delivery-unit identity actually bundled into the worker by
- * parsing the generated `shared/ultramodern-build.ts` module. This is the
+ * reading the generated `shared/ultramodern-build.json` artifact. This is the
  * worker snapshot / declared surface source that gets stamped into the manifest.
  */
 export declare const resolveWorkerDeliveryUnitStamp: (appDirectory: string) => Promise<DeliveryUnitStamp | undefined>;

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

@@ -108,8 +108,8 @@ export declare const createWorkerManifest: (outputDirectory: string, modernConfi
         prefix: string;
         worker: string;
         effect: {
-            openapi?: import("@modern-js/server-core").BffEffectOpenApiUserConfig | undefined;
-            dataPlatform?: import("@modern-js/server-core").BffEffectDataPlatformUserConfig | undefined;
+            openapi?: import("@modern-js/runtime-extensions/server-config").BffEffectOpenApiUserConfig | undefined;
+            dataPlatform?: import("@modern-js/runtime-extensions/server-config").BffEffectDataPlatformUserConfig | undefined;
             crossProjectPolicy: {
                 allowedNamespaces?: string[];
                 verifyProducerIdentity?: (headers: Record<string, unknown>) => string | undefined;

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

@@ -34,6 +34,12 @@ export declare const createWranglerConfig: (appDirectory: string, modernConfig:
         binding: string;
         run_worker_first: boolean;
     };
+    env?: {
+        [k: string]: {
+            compatibility_date?: string | undefined;
+            compatibility_flags?: JsonValue[] | undefined;
+        };
+    } | undefined;
     d1_databases?: {
         binding: string;
         database_name: string;

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

@@ -1,22 +1,24 @@
 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;
-    };
 }
 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 +53,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 {};

package/dist/types/cloudflare-output-contract.d.ts

@@ -10,5 +10,8 @@ export declare const CLOUDFLARE_RUNTIME_TYPE = "cloudflare-module-worker";
 export declare const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = "module";
 export declare const CLOUDFLARE_WORKER_PACKAGE_TYPE = "commonjs";
 export declare const CLOUDFLARE_WORKER_BUNDLE_FORMAT = "commonjs";
-export declare const CLOUDFLARE_WORKER_NODE_BUILTINS: readonly ['async_hooks', 'buffer', 'crypto', 'events', 'fs/promises', 'module', 'path', 'process', 'stream', 'string_decoder', 'url', 'util'];
+export declare const CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT = "handleRouteDataRequest";
+export declare const getCloudflareWorkerRouteDataEntryName: (entryName: string) => string;
+export declare const CLOUDFLARE_WORKER_NODE_BUILTINS: readonly ['_http_agent', '_http_client', '_http_common', '_http_incoming', '_http_outgoing', '_http_server', '_tls_common', '_tls_wrap', 'assert', 'assert/strict', 'async_hooks', 'buffer', 'child_process', 'cluster', 'console', 'constants', 'crypto', 'dgram', 'diagnostics_channel', 'dns', 'dns/promises', 'domain', 'events', 'fs', 'fs/promises', 'http', 'http2', 'https', 'inspector', 'inspector/promises', 'module', 'net', 'os', 'path', 'path/posix', 'path/win32', 'perf_hooks', 'process', 'punycode', 'querystring', 'readline', 'readline/promises', 'repl', 'sqlite', 'stream', 'stream/consumers', 'stream/promises', 'stream/web', 'string_decoder', 'sys', 'test', 'timers', 'timers/promises', 'tls', 'trace_events', 'tty', 'url', 'util', 'util/types', 'v8', 'vm', 'wasi', 'worker_threads', 'zlib'];
+export declare const CLOUDFLARE_WORKER_PLATFORM_MODULES: readonly ['cloudflare:sockets'];
 export declare const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS: readonly ['nodejs_compat', 'global_fetch_strictly_public'];

package/dist/types/cloudflare-output-verifier/identity.d.ts

@@ -1,4 +1,4 @@
-import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+import { type DeliveryUnitIdentity } from '@modern-js/backend-federation-contracts';
 import type { CloudflareOutputVerifierIssue, JsonObject } from './issues.js';
 export type CloudflareDeliveryUnitIdentity = DeliveryUnitIdentity & {
     surfaces?: Partial<Record<'api' | 'ui', DeliveryUnitIdentity & {

package/dist/types/cloudflare-output-verifier/worker-bundles.d.ts

@@ -1,7 +1,7 @@
 import type { CloudflareOutputVerifierIssue, JsonObject } from './issues.js';
 interface WorkerBundleReference {
     dispatcherExport?: string;
-    kind: 'effect-bff' | 'route';
+    kind: 'effect-bff' | 'route' | 'route-data';
     reference: string;
 }
 interface ResolvedWorkerBundleReference extends WorkerBundleReference {
@@ -10,7 +10,7 @@ interface ResolvedWorkerBundleReference extends WorkerBundleReference {
 export declare const getEffectBffWorker: (manifest: JsonObject) => any;
 export declare const getWorkerBundleReferences: (manifest: JsonObject) => WorkerBundleReference[];
 export declare const resolveWorkerBundleReference: (issues: CloudflareOutputVerifierIssue[], outputDirectory: string, reference: WorkerBundleReference, manifestPath: string) => ResolvedWorkerBundleReference | null;
-export declare const missingWorkerBundleMessage: (reference: WorkerBundleReference) => "Cloudflare Effect BFF manifest points to a missing worker bundle." | "Cloudflare route worker manifest points to a missing worker bundle.";
+export declare const missingWorkerBundleMessage: (reference: WorkerBundleReference) => "Cloudflare Effect BFF manifest points to a missing worker bundle." | "Cloudflare route data worker manifest points to a missing worker bundle." | "Cloudflare route worker manifest points to a missing worker bundle.";
 interface WorkerBundleVerificationContract {
     providedPackages: ReadonlySet<string>;
     workerRoot: string;

package/dist/types/config.d.ts

@@ -1,4 +1,8 @@
-export type DeployTarget = 'node' | 'vercel' | 'netlify' | 'ghPages' | 'cloudflare';
+export type { ResolveEffectTsgoCompilerOptions } from './build-config/public.js';
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, } from './build-config/public.js';
+export { createRemoteManifestUrl } from './build-config/remote-address.js';
+export type { DeployTarget } from './deploy-output/target.js';
+export { resolveDeployTarget } from './deploy-output/target.js';
 export type CloudflareWorkerSecurityCspMode = 'enforce' | 'report-only' | 'off';
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
@@ -25,6 +29,17 @@ export interface CloudflareWorkerPublicAssetConfig {
      */
     to: string;
 }
+export interface NodePublicAssetConfig {
+    /**
+     * Source file or directory, relative to the app root, to copy into the
+     * Node deploy output's public directory.
+     */
+    from: string;
+    /**
+     * Destination path relative to `.output/public`.
+     */
+    to: string;
+}
 export interface CloudflareWorkerD1DatabaseConfig {
     /**
      * Worker binding name, for example `DB`.
@@ -173,3 +188,16 @@ export interface CloudflareDeployConfig {
         publicAssetExcludes?: string[];
     };
 }
+export interface NodeDeployConfig {
+    node?: {
+        /**
+         * Additional app-root files or directories to stage under
+         * `.output/public` when `modern deploy` targets Node, the counterpart of
+         * `deploy.worker.publicAssets`. The Node server does not route these
+         * files; serve them from the app, for example from an API handler.
+         * Release envelopes record them as declared public assets, so API-only
+         * units may ship them.
+         */
+        publicAssets?: NodePublicAssetConfig[];
+    };
+}

package/dist/types/deploy-output/npmAliases.d.ts

@@ -0,0 +1,14 @@
+export type NpmAlias = {
+    aliasName: string;
+    targetName: string;
+    targetVersion: string;
+};
+export declare function readPackageIdentity(entryPath: string): Promise<{
+    name: string;
+    version: string;
+}>;
+export declare function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases, }: {
+    appDirectory: string;
+    outputDirectory: string;
+    implicitAliases?: NpmAlias[];
+}): Promise<void>;

package/dist/types/deploy-output/plugin.d.ts

@@ -0,0 +1,35 @@
+import type { NodePublicAssetConfig } from '../config.js';
+import { type ResolvedDeployTarget } from './target.js';
+export interface DeployOutputAppContext {
+    appDirectory: string;
+    metaName: string;
+    deployTarget?: ResolvedDeployTarget;
+}
+export interface DeployOutputPluginApi {
+    getAppContext(): DeployOutputAppContext;
+    onAfterDeploy(handler: () => Promise<void>): void;
+}
+export declare const createDeployOutputAliasesPlugin: () => {
+    name: string;
+    setup(api: DeployOutputPluginApi): void;
+};
+export interface DeployOutputPublicAssetsConfig {
+    deploy?: {
+        node?: {
+            publicAssets?: NodePublicAssetConfig[];
+        };
+    };
+}
+export interface DeployOutputPublicAssetsPluginApi {
+    getAppContext(): DeployOutputAppContext;
+    getNormalizedConfig(): DeployOutputPublicAssetsConfig;
+    onAfterDeploy(handler: () => Promise<void>): void;
+}
+/**
+ * Stage `deploy.node.publicAssets` into the Node deploy output. Cloudflare
+ * stages `deploy.worker.publicAssets` inside its deploy preset.
+ */
+export declare const createDeployOutputPublicAssetsPlugin: () => {
+    name: string;
+    setup(api: DeployOutputPublicAssetsPluginApi): void;
+};