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

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,6 +1,8 @@
 export type { ResolveEffectTsgoCompilerOptions } from './build-config/public.js';
-export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment, } from './build-config/public.js';
-export type DeployTarget = 'node' | 'vercel' | 'netlify' | 'ghPages' | 'cloudflare';
+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;
@@ -27,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`.
@@ -71,6 +84,18 @@ export interface CloudflareWorkerServiceBindingConfig {
      */
     fragments?: CloudflareWorkerServiceBindingFragmentConfig[];
 }
+export interface CloudflareWorkerVpcServiceConfig {
+    /** Worker binding name exposed on the module worker `env` object. */
+    binding: string;
+    /** Workers VPC service id (`wrangler vpc service create`). */
+    serviceId: string;
+    /**
+     * Optional application path prefix that Modern.js should dispatch to this
+     * private origin with `env[binding].fetch(request)`, exactly like a
+     * prefixed Worker service binding.
+     */
+    prefix?: string;
+}
 export interface CloudflareWorkerServiceBindingFragmentConfig {
     /** Stable remote id used by the shell's composition contract. */
     remote: string;
@@ -161,17 +186,77 @@ export interface CloudflareWorkerSecurityConfig {
     };
     reason?: string;
 }
+export interface CloudflareWorkerDeployConfig {
+    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;
+    /**
+     * Raw Wrangler-compatible config merged into `.output/wrangler.json`.
+     * Framework-owned worker invariants still win for `main`, the assets
+     * binding/directory/run mode, and required compatibility flags.
+     */
+    wrangler?: Record<string, JsonValue>;
+    /**
+     * Additional app-root files or directories to stage under `.output`.
+     * Use this for provider resources such as migrations or generated config.
+     */
+    artifacts?: CloudflareWorkerArtifactConfig[];
+    /**
+     * Additional app-root files or directories to serve as Cloudflare Worker
+     * Static Assets under `.output/public`. Use `to: '.'` to copy a
+     * source directory's contents into the public asset root.
+     */
+    publicAssets?: CloudflareWorkerPublicAssetConfig[];
+    /**
+     * First-class Cloudflare D1 bindings. Modern.js writes these to
+     * `wrangler.json` as `d1_databases` and stages configured migration
+     * directories into `.output`.
+     */
+    d1Databases?: CloudflareWorkerD1DatabaseConfig[];
+    /**
+     * First-class Cloudflare service bindings. Modern.js writes these to
+     * `wrangler.json` as `services`; when a binding also has `prefix`,
+     * the generated Worker dispatches matching requests through
+     * `env[binding].fetch(request)`.
+     */
+    services?: CloudflareWorkerServiceBindingConfig[];
+    /**
+     * First-class Workers VPC service bindings to private origins reached
+     * through a Cloudflare Tunnel. Modern.js writes these to `wrangler.json`
+     * as `vpc_services`; a binding with `prefix` joins the prefix dispatch of
+     * `services`.
+     */
+    vpcServices?: CloudflareWorkerVpcServiceConfig[];
+    /**
+     * Dist output paths that must not be copied into Cloudflare public assets.
+     * Entries are slash-normalized path prefixes relative to the app dist root.
+     * Top-level `api` and `shared` dist directories are excluded when matching
+     * source directories exist in the app root because they conventionally
+     * contain server-only implementation code.
+     */
+    publicAssetExcludes?: string[];
+}
 export interface CloudflareDeployConfig {
-    worker?: {
-        name?: string;
-        compatibilityDate?: string;
-        ssr?: boolean;
-        security?: CloudflareWorkerSecurityConfig;
-        wrangler?: Record<string, JsonValue>;
-        artifacts?: CloudflareWorkerArtifactConfig[];
-        publicAssets?: CloudflareWorkerPublicAssetConfig[];
-        d1Databases?: CloudflareWorkerD1DatabaseConfig[];
-        services?: CloudflareWorkerServiceBindingConfig[];
-        publicAssetExcludes?: string[];
+    /** Release surface owned by this application, independent of federation production. */
+    releaseEnvelopeRole?: 'microvertical' | 'shell';
+    worker?: CloudflareWorkerDeployConfig;
+}
+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/plugin.d.ts

@@ -1,15 +1,35 @@
-import { type DeployOutputConfig } from './target.js';
+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(): {
-        appDirectory: string;
-        metaName: string;
-    };
-    getNormalizedConfig(): DeployOutputConfig;
+    getAppContext(): DeployOutputAppContext;
     onAfterDeploy(handler: () => Promise<void>): void;
 }
-export declare const createDeployOutputAliasesPlugin: ({ resolveDeployTarget, }?: {
-    resolveDeployTarget?: (config: DeployOutputConfig) => string;
-}) => {
+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;
+};

package/dist/types/deploy-output/public-assets.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Deploy output directory that receives declared public assets on every
+ * target: Cloudflare Worker Static Assets and the Node deploy output.
+ */
+export declare const DECLARED_PUBLIC_ASSET_DIRECTORY = "public";
+export interface DeclaredPublicAssetConfig {
+    from: string;
+    to: string;
+}
+export interface DeclaredPublicAssetScope {
+    /** Config path used in errors, for example `deploy.node.publicAssets`. */
+    label: string;
+    /** Output described in destination errors. */
+    output: string;
+}
+export interface DeclaredPublicAsset {
+    from: string;
+    to: string;
+    index: number;
+}
+export declare const CLOUDFLARE_PUBLIC_ASSET_SCOPE: DeclaredPublicAssetScope;
+export declare const NODE_PUBLIC_ASSET_SCOPE: DeclaredPublicAssetScope;
+export declare const normalizeDeclaredPublicAssets: (assets: readonly DeclaredPublicAssetConfig[] | undefined, scope: DeclaredPublicAssetScope) => DeclaredPublicAsset[];
+/**
+ * Resolve the files declared public assets add to a deploy output that was
+ * copied from `generatedRoot`, relative to the deploy output root. Declared
+ * files that replace a generated file are not part of the result, matching
+ * {@link stageDeclaredPublicAssets}.
+ */
+export declare const resolveAddedDeclaredPublicAssetPaths: ({ appDirectory, assets, generatedRoot, scope, }: {
+    appDirectory: string;
+    assets: readonly DeclaredPublicAsset[];
+    generatedRoot: string;
+    scope: DeclaredPublicAssetScope;
+}) => Promise<string[]>;
+/**
+ * Copy declared public assets into the deploy output after the framework has
+ * staged its own public files.
+ *
+ * A declared file may replace a generated public file, such as an app-owned
+ * `robots.txt`; the replaced file keeps its generated release classification.
+ *
+ * @returns the files the declarations added, relative to the deploy output
+ * root. The release envelope records these as declared public assets.
+ */
+export declare const stageDeclaredPublicAssets: ({ appDirectory, outputDirectory, assets, scope, }: {
+    appDirectory: string;
+    outputDirectory: string;
+    assets: readonly DeclaredPublicAsset[];
+    scope: DeclaredPublicAssetScope;
+}) => Promise<string[]>;

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

@@ -1,6 +1,29 @@
-export interface DeployOutputConfig {
-    deploy?: {
-        target?: string;
-    };
+export declare const DEPLOY_TARGETS: readonly ['node', 'vercel', 'netlify', 'ghPages', 'cloudflare'];
+export type DeployTarget = (typeof DEPLOY_TARGETS)[number];
+export declare const DEPLOY_TARGET_FLAG = "--deploy-target";
+export interface ResolvedDeployTarget {
+    target: DeployTarget;
+    /** The flag, `deploy.target` or `MODERNJS_DEPLOY` chose the target. */
+    explicit: boolean;
 }
-export declare const resolveDeployTarget: (config: DeployOutputConfig, envDeployTarget?: string | undefined, detectedProvider?: import("std-env").ProviderName) => string;
+export interface ResolveDeployTargetOptions {
+    argv?: readonly string[];
+    configTarget?: string;
+    env?: string;
+    provider?: string;
+}
+/**
+ * The one deploy-target resolver: `--deploy-target` > `deploy.target` >
+ * `MODERNJS_DEPLOY` > detected CI provider > `node`. app-tools stores the
+ * result in the app context once; config files that branch on the target call
+ * it without `configTarget`.
+ */
+export declare const resolveDeployTarget: ({ argv, configTarget, env, provider, }?: ResolveDeployTargetOptions) => ResolvedDeployTarget;
+/**
+ * The target `modern deploy` stages. Apps under another CLI meta name deploy
+ * only when a flag, config or env chose the target explicitly.
+ */
+export declare const getDeployingTarget: ({ deployTarget, metaName, }: {
+    deployTarget?: ResolvedDeployTarget;
+    metaName: string;
+}) => DeployTarget | undefined;

package/dist/types/deploy-output/trace-files.d.ts

@@ -0,0 +1,17 @@
+import type { NodeFileTraceResult } from '@vercel/nft';
+/**
+ * Builds the nft `ignore` predicate for a trace rooted at `base`: skip every
+ * path under a system root, and skip globs that would enumerate the file
+ * system root, the home directory or the temp directory as a whole. Files
+ * inside home or temp are still traced, since package stores can live there.
+ */
+export declare const createBuildHostIgnore: (base: string) => (relativePath: string) => boolean;
+/**
+ * `traceFiles` implementation for ndepe's `nodeDepEmit`, tracing with the
+ * `@vercel/nft` release app-tools-extensions depends on instead of the one ndepe pins.
+ */
+export declare const traceDeployFiles: ({ entryFiles, sourceDir, base, }: {
+    entryFiles: string[];
+    sourceDir: string;
+    base?: string;
+}) => Promise<NodeFileTraceResult>;

package/dist/types/module-federation-config/exposes.d.ts

@@ -0,0 +1,11 @@
+import type { ModuleFederationConfigInspection } from './types.js';
+/**
+ * Returns undefined when the app ships no Module Federation config, or when the
+ * config cannot be inspected statically, so callers keep their own expectation
+ * rather than inventing a surface path. `ultramodern mf-types` reports those
+ * configs separately, so staying quiet here never hides a broken config.
+ * Native deployment policy loads dynamic configs through Modern.js's loader.
+ */
+export declare function readModuleFederationConfigInspection(workspaceRoot: string, appDirectory: string): ModuleFederationConfigInspection | undefined;
+/** The literal source paths, independently of the complete expose-name list. */
+export declare function readModuleFederationExposePaths(workspaceRoot: string, appDirectory: string): Record<string, string> | undefined;

package/dist/types/module-federation-config/index.d.ts

@@ -0,0 +1,5 @@
+export { readModuleFederationConfigInspection, readModuleFederationExposePaths, } from './exposes.js';
+export { inspectModuleFederationConfigSource } from './inspect.js';
+export { parseArrayLiteral, parseLiteralString, parseObjectLiteral, } from './object-literal.js';
+export { findCreateModuleFederationConfigObject, findExportDefaultObject, locateCreateModuleFederationConfigObject, parseConfigModule, parseStaticExpression, } from './syntax.js';
+export type { LocatedObjectLiteral, ModuleFederationConfigInspection, ParsedObjectLiteral, } from './types.js';

package/dist/types/module-federation-config/inspect.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleFederationConfigInspection } from './types.js';
+export declare function inspectModuleFederationConfigSource(source: string, appDir: string, configPath: string): ModuleFederationConfigInspection;

package/dist/types/module-federation-config/object-literal.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedObjectLiteral } from './types.js';
+export declare function parseLiteralString(source: string | undefined): string | undefined;
+export declare function parseObjectLiteral(source: string | undefined): ParsedObjectLiteral | undefined;
+export declare function parseArrayLiteral(source: string | undefined): string[] | undefined;

package/dist/types/module-federation-config/syntax.d.ts

@@ -0,0 +1,7 @@
+import { type Expression, type File } from '@babel/parser';
+import type { LocatedObjectLiteral } from './types.js';
+export declare function parseStaticExpression(source: string | undefined): Expression | undefined;
+export declare function parseConfigModule(source: string): import("@babel/parser").ParseResult<File>;
+export declare function locateCreateModuleFederationConfigObject(source: string): LocatedObjectLiteral | undefined;
+export declare function findCreateModuleFederationConfigObject(source: string): string | undefined;
+export declare function findExportDefaultObject(source: string): string | undefined;

package/dist/types/module-federation-config/types.d.ts

@@ -0,0 +1,20 @@
+export type ModuleFederationConfigInspection = {
+    appDir: string;
+    configPath: string;
+    dts: {
+        compilerInstance?: string;
+        tsConfigPath?: string;
+    };
+    exposePaths: Record<string, string>;
+    exposes: string[];
+    hostOnlyNoExposes: boolean;
+};
+export type LocatedObjectLiteral = {
+    end: number;
+    source: string;
+    start: number;
+};
+export type ParsedObjectLiteral = {
+    hasSpread: boolean;
+    properties: Map<string, string>;
+};

package/dist/types/native-type-checker.d.ts

@@ -1,15 +1,38 @@
 import type { Rspack, RspackChain } from '@rsbuild/core';
+export interface NativeTypeCheckerCommand {
+    executable: string;
+    args: readonly string[];
+}
+/** Launch the selected stable package through its declared public compiler bin. */
+export declare function resolveNativeTypeCheckerCommand(packageJsonPath: string): NativeTypeCheckerCommand;
+interface TypeCheckerConfig {
+    compilerOptions?: Record<string, unknown>;
+    references?: Array<{
+        path: string;
+    }>;
+    [key: string]: unknown;
+}
+/**
+ * TS2875 means JSX compiles against a jsxImportSource whose runtime is not
+ * installed: usually components still authored for a previous renderer.
+ */
+export declare function missingJsxRuntimeHint(diagnostics: string): string;
 export declare class UltramodernNativeTypeChecker {
     private readonly options;
     constructor(options: {
-        compiler: () => string;
+        compiler: () => string | NativeTypeCheckerCommand;
         configFile: string;
         build: boolean;
+        configOverwrite?: TypeCheckerConfig;
     });
     check(): Promise<void>;
+    private projectConfigFile;
+    private removeProjection;
+    private checkProject;
     private run;
     private watchInputs;
     apply(compiler: Rspack.Compiler): void;
 }
-/** Preserve project-reference emit contracts in the native Effect compiler. */
-export declare function configureUltramodernTypeChecker(chain: RspackChain, pluginId: string, resolveCompiler: (configFile: string) => string): void;
+/** Preserve project-reference emit contracts in the selected native compiler. */
+export declare function configureUltramodernTypeChecker(chain: RspackChain, pluginId: string, resolveCompiler: (configFile: string) => string | NativeTypeCheckerCommand): void;
+export {};

package/dist/types/policy-defaults.d.ts

@@ -12,12 +12,22 @@
 export declare const RENDERER_EXTENSIONS_PACKAGE = "@modern-js/runtime-renderer-extensions";
 export declare const RENDERER_EXTENSIONS_PLUGIN_NAME = "rendererHead";
 export declare const SERVER_EXTENSIONS_PLUGIN_NAME = "@modern-js/app-tools/server-plugin";
+export declare const ULTRAMODERN_SERVER_EXTENSIONS_PLUGIN_NAME = "@modern-js/ultramodern-app-tools/server-plugin";
 export interface PolicyDefaultsOptions {
     /** Default `true`. Set to `false` to drop the fork's renderer policy. */
     rendererExtensions?: boolean;
     /** Default `true`. Set to `false` to drop the fork's server policy. */
     serverExtensions?: boolean;
 }
+/** The native package that explicitly composes the policy. */
+export interface PolicyDefaultsComposition {
+    pluginName?: string;
+    serverPluginName?: string;
+    /** Additional runtime packages that share the resolution fallback. */
+    runtimePackages?: readonly string[];
+    /** Resolve runtime packages from the composing package. */
+    registrarUrl?: string;
+}
 /**
  * The subset of the CLI plugin API these defaults use. Typed structurally, and
  * loosely at the hook boundary, so this package stays free of a dependency on
@@ -30,7 +40,7 @@ export interface PolicyDefaultsPluginApi {
 }
 export declare const POLICY_DEFAULTS_PLUGIN_NAME = "@modern-js/ultramodern-policy-defaults";
 /** Registers the fork's default renderer and server policy. */
-export declare const applyPolicyDefaults: (api: PolicyDefaultsPluginApi, options?: PolicyDefaultsOptions) => void;
+export declare const applyPolicyDefaults: (api: PolicyDefaultsPluginApi, options?: PolicyDefaultsOptions, composition?: PolicyDefaultsComposition) => void;
 /**
  * The fork defaults as a CLI plugin.
  *
@@ -40,7 +50,7 @@ export declare const applyPolicyDefaults: (api: PolicyDefaultsPluginApi, options
  * Ordering is settled on the runtime side instead: `rendererHeadPlugin`
  * declares the runtime plugins that run before it.
  */
-export declare const createPolicyDefaultsPlugin: (options?: PolicyDefaultsOptions) => {
+export declare const createPolicyDefaultsPlugin: (options?: PolicyDefaultsOptions, composition?: PolicyDefaultsComposition) => {
     name: string;
     setup(api: PolicyDefaultsPluginApi): void;
 };

package/dist/types/release-envelope/canonical.d.ts

@@ -1,5 +1,5 @@
-import type { MicroVerticalReleaseEnvelope, MicroVerticalReleaseEnvelopePayload } from './types.js';
-export declare const releaseEnvelopePayload: (envelope: MicroVerticalReleaseEnvelope) => MicroVerticalReleaseEnvelopePayload;
-export declare const canonicalSerializeMicroVerticalReleaseEnvelopePayload: (payload: MicroVerticalReleaseEnvelopePayload) => string;
-export declare const canonicalSerializeMicroVerticalReleaseEnvelope: (envelope: MicroVerticalReleaseEnvelope) => string;
-export declare const digestMicroVerticalReleaseEnvelopePayload: (payload: MicroVerticalReleaseEnvelopePayload) => string;
+import type { ReleaseEnvelope, ReleaseEnvelopePayload } from './types.js';
+export { releaseEnvelopePayload } from './contract.mjs';
+export declare const canonicalSerializeMicroVerticalReleaseEnvelopePayload: (payload: ReleaseEnvelopePayload) => string;
+export declare const canonicalSerializeMicroVerticalReleaseEnvelope: (envelope: ReleaseEnvelope) => string;
+export declare const digestMicroVerticalReleaseEnvelopePayload: (payload: ReleaseEnvelopePayload) => string;

package/dist/types/release-envelope/contract.d.mts

@@ -0,0 +1,8 @@
+export declare const MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION: 5;
+export declare const MICROVERTICAL_RELEASE_ENVELOPE_KIND: 'ultramodern-target-microvertical-release-envelope';
+export declare const SHELL_RELEASE_ENVELOPE_KIND: 'ultramodern-target-shell-release-envelope';
+/**
+ * @param {import('./types.js').ReleaseEnvelope} envelope
+ * @returns {import('./types.js').ReleaseEnvelopePayload}
+ */
+export declare const releaseEnvelopePayload: (envelope: import('./types.js').ReleaseEnvelope) => import('./types.js').ReleaseEnvelopePayload;

package/dist/types/release-envelope/framework-output.d.ts

@@ -1,32 +1,42 @@
-import type { MicroVerticalReleaseArtifact, MicroVerticalReleaseEnvelope, MicroVerticalReleaseTarget } from './types.js';
+import { type RendererProfile } from '@modern-js/backend-federation-contracts';
+import { type MicroVerticalReleaseArtifact, type MicroVerticalReleaseTarget, type ReleaseEnvelope } from './types.js';
 export declare const MICROVERTICAL_RELEASE_ENVELOPE_PATH = "release/microvertical-release-envelope.json";
 export declare const MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_PATH = "release/microvertical-release-identity-carriers.json";
-export declare const emitFrameworkMicroVerticalReleaseEnvelope: ({ apiOnly, distDirectory, target, }: {
+export declare const emitFrameworkMicroVerticalReleaseEnvelope: ({ apiOnly, appDirectory, distDirectory, requirePromotable, expectedRendererProfile, role, target, }: {
     apiOnly: boolean;
+    appDirectory?: string;
     distDirectory: string;
+    requirePromotable?: boolean;
+    expectedRendererProfile?: RendererProfile;
+    role?: 'microvertical' | 'shell';
     target: MicroVerticalReleaseTarget;
-}) => Promise<MicroVerticalReleaseEnvelope | undefined>;
-export declare const readFrameworkMicroVerticalReleaseEnvelope: ({ artifactRoot, expectedTarget, logicalPathForArtifact, required, }: {
+}) => Promise<ReleaseEnvelope | undefined>;
+export declare const readFrameworkMicroVerticalReleaseEnvelope: ({ artifactRoot, expectedTarget, logicalPathForArtifact, expectedRendererProfile, required, }: {
     artifactRoot: string;
     expectedTarget?: MicroVerticalReleaseTarget;
     logicalPathForArtifact?: (artifact: MicroVerticalReleaseArtifact) => string;
+    expectedRendererProfile?: RendererProfile;
     required?: boolean;
-}) => Promise<MicroVerticalReleaseEnvelope | undefined>;
-export declare const verifyBuildOutputReleaseEnvelope: (distDirectory: string, expectedTarget?: MicroVerticalReleaseTarget) => Promise<MicroVerticalReleaseEnvelope | undefined>;
+}) => Promise<ReleaseEnvelope | undefined>;
+export declare const verifyBuildOutputReleaseEnvelope: (distDirectory: string, expectedTarget?: MicroVerticalReleaseTarget) => Promise<ReleaseEnvelope | undefined>;
 export declare const verifyNodeReleaseEnvelopeStaging: ({ outputDirectory, }: {
     distDirectory?: string;
     outputDirectory: string;
-}) => Promise<MicroVerticalReleaseEnvelope | undefined>;
-export declare const emitNodeStagedReleaseEnvelope: ({ distDirectory, outputDirectory, }: {
+}) => Promise<ReleaseEnvelope | undefined>;
+export declare const emitNodeStagedReleaseEnvelope: ({ declaredPublicAssets, distDirectory, outputDirectory, }: {
+    /** Staged `deploy.node.publicAssets` files, relative to `outputDirectory`. */
+    declaredPublicAssets?: readonly string[];
     distDirectory: string;
     outputDirectory: string;
-}) => Promise<MicroVerticalReleaseEnvelope | undefined>;
+}) => Promise<ReleaseEnvelope | undefined>;
 export declare const stageCloudflareReleaseEnvelope: ({ distDirectory, outputDirectory, }: {
     distDirectory: string;
     outputDirectory: string;
-}) => Promise<MicroVerticalReleaseEnvelope | undefined>;
-export declare const emitCloudflareStagedReleaseEnvelope: ({ distDirectory, outputDirectory, }: {
+}) => Promise<ReleaseEnvelope | undefined>;
+export declare const emitCloudflareStagedReleaseEnvelope: ({ declaredPublicAssets, distDirectory, outputDirectory, }: {
+    /** Staged `deploy.worker.publicAssets` files, relative to `outputDirectory`. */
+    declaredPublicAssets?: readonly string[];
     distDirectory: string;
     outputDirectory: string;
-}) => Promise<MicroVerticalReleaseEnvelope | undefined>;
-export declare const verifyCloudflareReleaseEnvelopeStaging: (outputDirectory: string) => Promise<MicroVerticalReleaseEnvelope | undefined>;
+}) => Promise<ReleaseEnvelope | undefined>;
+export declare const verifyCloudflareReleaseEnvelopeStaging: (outputDirectory: string) => Promise<ReleaseEnvelope | undefined>;

package/dist/types/release-envelope/index.d.ts

@@ -1,6 +1,18 @@
 import { canonicalSerializeMicroVerticalReleaseEnvelope } from './canonical.js';
-import { type CreateMicroVerticalReleaseEnvelopeInput, MICROVERTICAL_RELEASE_ENVELOPE_KIND, MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION, MICROVERTICAL_RELEASE_TARGETS, type MicroVerticalReleaseEnvelope, type VerifyMicroVerticalReleaseEnvelopeOptions } from './types.js';
-export type { CreateMicroVerticalReleaseEnvelopeInput, MicroVerticalReleaseArtifact, MicroVerticalReleaseArtifactInput, MicroVerticalReleaseArtifactInputs, MicroVerticalReleaseEnvelope, MicroVerticalReleaseEnvelopePayload, MicroVerticalReleaseFileArtifact, MicroVerticalReleaseIdentity, MicroVerticalReleaseSurfaces, MicroVerticalReleaseSymbolicLinkArtifact, MicroVerticalReleaseTarget, VerifyMicroVerticalReleaseEnvelopeOptions, } from './types.js';
-export { canonicalSerializeMicroVerticalReleaseEnvelope, MICROVERTICAL_RELEASE_ENVELOPE_KIND, MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION, MICROVERTICAL_RELEASE_TARGETS, };
-export declare const createMicroVerticalReleaseEnvelope: (input: CreateMicroVerticalReleaseEnvelopeInput) => Promise<MicroVerticalReleaseEnvelope>;
-export declare const verifyMicroVerticalReleaseEnvelope: (value: unknown, options: VerifyMicroVerticalReleaseEnvelopeOptions) => Promise<MicroVerticalReleaseEnvelope>;
+import { type CreateMicroVerticalReleaseEnvelopeInput, MICROVERTICAL_RELEASE_ENVELOPE_KIND, MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION, MICROVERTICAL_RELEASE_TARGETS, type MicroVerticalReleaseEnvelope, type ReleaseEnvelope, SHELL_RELEASE_ENVELOPE_KIND, type ShellReleaseEnvelope, type VerifyMicroVerticalReleaseEnvelopeOptions } from './types.js';
+export type { CreateMicroVerticalReleaseEnvelopeInput, MicroVerticalReleaseArtifact, MicroVerticalReleaseArtifactInput, MicroVerticalReleaseArtifactInputs, MicroVerticalReleaseEnvelope, MicroVerticalReleaseEnvelopePayload, MicroVerticalReleaseFileArtifact, MicroVerticalReleaseIdentity, MicroVerticalReleaseSurfaces, MicroVerticalReleaseSymbolicLinkArtifact, MicroVerticalReleaseTarget, MicroVerticalReleaseUi, ReleaseEnvelope, ReleaseEnvelopeKind, ReleaseEnvelopePayload, ReleaseSurfaces, ShellReleaseEnvelope, ShellReleaseEnvelopePayload, ShellReleaseSurfaces, VerifyMicroVerticalReleaseEnvelopeOptions, } from './types.js';
+export { canonicalSerializeMicroVerticalReleaseEnvelope, MICROVERTICAL_RELEASE_ENVELOPE_KIND, MICROVERTICAL_RELEASE_ENVELOPE_SCHEMA_VERSION, MICROVERTICAL_RELEASE_TARGETS, SHELL_RELEASE_ENVELOPE_KIND, };
+export declare function createMicroVerticalReleaseEnvelope(input: CreateMicroVerticalReleaseEnvelopeInput & {
+    kind: typeof SHELL_RELEASE_ENVELOPE_KIND;
+}): Promise<ShellReleaseEnvelope>;
+export declare function createMicroVerticalReleaseEnvelope(input: CreateMicroVerticalReleaseEnvelopeInput & {
+    kind?: typeof MICROVERTICAL_RELEASE_ENVELOPE_KIND;
+}): Promise<MicroVerticalReleaseEnvelope>;
+export declare function createMicroVerticalReleaseEnvelope(input: CreateMicroVerticalReleaseEnvelopeInput): Promise<ReleaseEnvelope>;
+export declare function verifyMicroVerticalReleaseEnvelope(value: unknown, options: VerifyMicroVerticalReleaseEnvelopeOptions & {
+    expectedKind: typeof SHELL_RELEASE_ENVELOPE_KIND;
+}): Promise<ShellReleaseEnvelope>;
+export declare function verifyMicroVerticalReleaseEnvelope(value: unknown, options: VerifyMicroVerticalReleaseEnvelopeOptions & {
+    expectedKind: typeof MICROVERTICAL_RELEASE_ENVELOPE_KIND;
+}): Promise<MicroVerticalReleaseEnvelope>;
+export declare function verifyMicroVerticalReleaseEnvelope(value: unknown, options: VerifyMicroVerticalReleaseEnvelopeOptions): Promise<ReleaseEnvelope>;

package/dist/types/release-envelope/plugin.d.ts

@@ -1,7 +1,12 @@
-type ReleaseEnvelopeTarget = 'cloudflare' | 'node' | string;
+import type { RendererProfile } from '@modern-js/backend-federation-contracts';
+import type { NodePublicAssetConfig } from '../config.js';
+import { type ResolvedDeployTarget } from '../deploy-output/target.js';
 export interface ReleaseEnvelopeConfig {
     deploy?: {
-        target?: string;
+        releaseEnvelopeRole?: 'microvertical' | 'shell';
+        node?: {
+            publicAssets?: NodePublicAssetConfig[];
+        };
     };
 }
 export interface ReleaseEnvelopeAppContext {
@@ -9,6 +14,7 @@ export interface ReleaseEnvelopeAppContext {
     appDirectory: string;
     distDirectory: string;
     metaName: string;
+    deployTarget?: ResolvedDeployTarget;
 }
 export interface ReleaseEnvelopePluginApi<Config extends ReleaseEnvelopeConfig = ReleaseEnvelopeConfig> {
     getAppContext(): ReleaseEnvelopeAppContext;
@@ -23,8 +29,6 @@ export interface ReleaseEnvelopePlugin<Config extends ReleaseEnvelopeConfig = Re
     post: string[];
     setup(api: ReleaseEnvelopePluginApi<Config>): void;
 }
-export type ResolveDeployTarget<Config extends ReleaseEnvelopeConfig = ReleaseEnvelopeConfig> = (config: Config) => ReleaseEnvelopeTarget;
-export declare const createUltramodernReleaseEnvelopePlugin: <Config extends ReleaseEnvelopeConfig>({ resolveDeployTarget, }: {
-    resolveDeployTarget: ResolveDeployTarget<Config>;
+export declare const createUltramodernReleaseEnvelopePlugin: <Config extends ReleaseEnvelopeConfig>({ resolveRendererProfile, }?: {
+    resolveRendererProfile?: (config: Config) => RendererProfile;
 }) => ReleaseEnvelopePlugin<Config>;
-export {};

package/dist/types/release-envelope/renderer-output-stamp.d.ts

@@ -0,0 +1,34 @@
+import { type UltramodernBuildArtifact, type UltramodernBuildUiSurface } from '@modern-js/backend-federation-contracts';
+export type RendererBuildOutputContext = {
+    appDirectory: string;
+    distDirectory: string;
+    entrypoints: readonly {
+        entryName: string;
+        isMainEntry?: boolean;
+    }[];
+};
+export type FinalizedRendererBuildOutput = {
+    buildMarker: string;
+    sourceRevision: string;
+    ui: Pick<UltramodernBuildUiSurface, 'rendererIdentity' | 'rendererProfile' | 'routerBindings'>;
+};
+export type RendererBuildOutputOptions = {
+    resolveRendererBuild: (context: RendererBuildOutputContext) => Promise<FinalizedRendererBuildOutput>;
+    /** Exact metadata producer selected by the owning renderer composition. */
+    rendererBuildPlugin: string;
+};
+export declare const validateFinalizedRendererBuild: (output: FinalizedRendererBuildOutput, context: RendererBuildOutputContext, appId: string) => void;
+export declare const stampFinalizedRendererBuildArtifact: (artifact: UltramodernBuildArtifact, output: FinalizedRendererBuildOutput, context: RendererBuildOutputContext) => UltramodernBuildArtifact;
+export declare function emitRendererBuildArtifact(context: RendererBuildOutputContext, options: RendererBuildOutputOptions): Promise<UltramodernBuildArtifact | undefined>;
+/** Stamp generated UI carriers after their actual compiler manifest is committed. */
+export declare function rendererBuildArtifactStampPlugin(options: RendererBuildOutputOptions): {
+    name: string;
+    pre: string[];
+    required: string[];
+    setup(api: {
+        getAppContext(): RendererBuildOutputContext & {
+            apiOnly?: boolean;
+        };
+        onAfterBuild(handler: () => Promise<void>): void;
+    }): void;
+};