@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.6 → 3.5.0-ultramodern.75

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

@@ -0,0 +1,103 @@
+import { type DeliveryUnitContractBlock, type UltramodernBuildArtifact } from '@modern-js/utils/universal';
+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[];
+    };
+};
+export type BackendFederationApp = {
+    id: string;
+    directory: string;
+    packageName?: string;
+    version?: string;
+    buildVersion?: string;
+    unitId?: string;
+    sourceRevision?: string;
+    deliveryUnit?: DeliveryUnitContractBlock;
+    port: number;
+    apiPrefix: string;
+    apiStem: string;
+    backendName: string;
+    manifestUrl: string;
+    containerEntry: string;
+    remoteType: string;
+    uiManifestUrl?: string;
+    compactDeliveryUnit?: {
+        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 buildModulePathFor: (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 createAppFromCompactMetadata: (workspaceRoot: string, appDirectory: string, compactApp: CompactApp) => BackendFederationApp | undefined;
+export declare const findBackendFederationApp: (workspaceRoot: string, appDirectory: string) => Promise<BackendFederationApp | undefined>;

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

@@ -0,0 +1,13 @@
+import type { AppTools, CliPlugin } from '../../types';
+export type { BackendFederationBuildIdentity } from './config';
+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(): CliPlugin<AppTools>;

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

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

package/dist/types/plugins/deploy/platforms/cloudflare/artifacts.d.ts

@@ -0,0 +1,15 @@
+import type { CloudflareModernConfig } from './types';
+export declare const getCloudflareArtifacts: (modernConfig: CloudflareModernConfig) => {
+    from: string;
+    to: string;
+    index: number;
+}[];
+export declare const getCloudflarePublicAssets: (modernConfig: CloudflareModernConfig) => {
+    from: string;
+    to: string;
+    index: number;
+}[];
+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>;
+export declare const copyCloudflareD1Migrations: (appDirectory: string, outputDirectory: string, modernConfig: CloudflareModernConfig) => Promise<void>;
+export declare const readRouteSpec: (outputDirectory: string) => Promise<any>;

package/dist/types/plugins/deploy/platforms/cloudflare/constants.d.ts

@@ -0,0 +1,24 @@
+import { CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT } from '../cloudflare-output-contract';
+export { CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT };
+export declare const WORKER_ENTRY = "server/index.mjs";
+export declare const WORKER_MANIFEST = "server/modern-worker-manifest.json";
+export declare const WRANGLER_CONFIG_FILE = "wrangler.json";
+export declare const OUTPUT_PACKAGE_FILE = "package.json";
+export declare const ASSETS_BINDING = "ASSETS";
+export declare const ROUTE_SPEC_FILE = "route.json";
+export declare const ROUTE_SPEC_OUTPUT = "server/route.json";
+export declare const LOADABLE_STATS_FILE = "loadable-stats.json";
+export declare const ROUTE_MANIFEST_FILE = "routes-manifest.json";
+export declare const PUBLIC_ASSETS_DIRECTORY = "public";
+export declare const WORKER_BUNDLE_DIRECTORY = "worker";
+export declare const SERVER_BUNDLE_DIRECTORY = "bundles";
+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 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 RESERVED_ARTIFACT_DESTINATION_FILES: Set<string>;
+export declare const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES: Set<string>;

package/dist/types/plugins/deploy/platforms/cloudflare/delivery-unit.d.ts

@@ -0,0 +1,23 @@
+import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+export type DeliveryUnitStamp = DeliveryUnitIdentity & {
+    surfaces: {
+        ui: DeliveryUnitIdentity & {
+            surface: 'ui';
+        };
+        api: DeliveryUnitIdentity & {
+            surface: 'api';
+        };
+    };
+};
+/**
+ * Resolve the delivery-unit record declared for this app by the workspace
+ * compact config (`.modernjs/ultramodern.json`). This is the topology source
+ * of truth the Cloudflare worker snapshot is verified against.
+ */
+export declare const resolveTopologyDeliveryUnit: (appDirectory: string) => Promise<DeliveryUnitIdentity | undefined>;
+/**
+ * Resolve the delivery-unit identity actually bundled into the worker by
+ * parsing the generated `shared/ultramodern-build.ts` module. This is the
+ * worker snapshot / UI+API surface source that gets stamped into the manifest.
+ */
+export declare const resolveWorkerDeliveryUnitStamp: (appDirectory: string) => Promise<DeliveryUnitStamp | undefined>;

package/dist/types/plugins/deploy/platforms/cloudflare/i18n-worker.d.ts

@@ -0,0 +1,22 @@
+import type { CloudflareAppContext } from './types';
+type WorkerI18nDetection = {
+    order: string[];
+    lookupQuerystring: string;
+    lookupCookie: string;
+    lookupHeader: string;
+};
+type WorkerI18nEntry = {
+    i18nextDetector: boolean;
+    languages: string[];
+    fallbackLanguage: string;
+    detection: WorkerI18nDetection;
+    ignoreRedirectRoutes: string[];
+    staticRoutePrefixes: string[];
+    localisedUrls?: Record<string, Record<string, string>>;
+};
+export declare const createI18nWorkerManifest: (routeSpec: {
+    routes: Array<Record<string, unknown>>;
+}, appContext: CloudflareAppContext) => {
+    entries: Record<string, WorkerI18nEntry>;
+} | undefined;
+export {};

package/dist/types/plugins/deploy/platforms/{cloudflare.d.ts → cloudflare/index.d.ts}

@@ -1,2 +1,2 @@
-import type { CreatePreset } from './platform';
+import type { CreatePreset } from '../platform';
 export declare const createCloudflarePreset: CreatePreset;

package/dist/types/plugins/deploy/platforms/cloudflare/security-policies.d.ts

@@ -0,0 +1,51 @@
+export declare const createCloudflareWorkerSecurityPolicy: (modernConfig: Parameters<CreatePreset>[0]['modernConfig']) => {
+    enabled: boolean;
+    cors: {
+        assets: boolean;
+        allowedOrigins: string[];
+        allowedMethods: string[];
+        allowedHeaders: string[];
+        reason: string | undefined;
+    };
+    reason: any;
+    headers?: undefined;
+    contentSecurityPolicy?: undefined;
+    noindex?: undefined;
+} | {
+    enabled: boolean;
+    headers: {
+        referrerPolicy: any;
+        contentTypeOptions: any;
+        permissionsPolicy: any;
+    };
+    contentSecurityPolicy: {
+        mode: "off";
+        directives: {};
+        reason: string | undefined;
+    } | {
+        mode: "enforce" | "report-only";
+        directives: {
+            [k: string]: string[];
+        };
+        reason: string | undefined;
+    };
+    noindex: {
+        workersDev: boolean;
+        localhost: boolean;
+        previewHostnames: never[];
+        reason?: undefined;
+    } | {
+        workersDev: boolean;
+        localhost: boolean;
+        previewHostnames: string[];
+        reason: string | undefined;
+    };
+    cors: {
+        assets: boolean;
+        allowedOrigins: string[];
+        allowedMethods: string[];
+        allowedHeaders: string[];
+        reason: string | undefined;
+    };
+    reason: any;
+};

package/dist/types/plugins/deploy/platforms/cloudflare/types.d.ts

@@ -0,0 +1,5 @@
+import type { CreatePreset } from '../platform';
+type CloudflarePresetOptions = Parameters<CreatePreset>[0];
+export type CloudflareAppContext = CloudflarePresetOptions['appContext'];
+export type CloudflareModernConfig = CloudflarePresetOptions['modernConfig'];
+export {};

package/dist/types/plugins/deploy/platforms/cloudflare/utils.d.ts

@@ -0,0 +1,6 @@
+import type { JsonValue } from '../../../../types/config/deploy';
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const normalizeRelativePath: (value: unknown, label: string, scope?: string, options?: {
+    allowRoot?: boolean;
+}) => string;
+export declare const isJsonRecord: (value: unknown) => value is Record<string, JsonValue>;

package/dist/types/plugins/deploy/platforms/cloudflare/worker-manifest.d.ts

@@ -0,0 +1,122 @@
+import type { DeliveryUnitStamp } from './delivery-unit';
+import type { CloudflareAppContext, CloudflareModernConfig } from './types';
+export declare const createWorkerManifest: (outputDirectory: string, modernConfig: CloudflareModernConfig, appContext: CloudflareAppContext, deliveryUnitStamp: DeliveryUnitStamp | undefined) => Promise<{
+    version: number;
+    runtime: {
+        type: string;
+        entry: string;
+        fetchExport: boolean;
+        nodeListen: boolean;
+    };
+    assets: {
+        binding: string;
+        directory: string;
+        runWorkerFirst: boolean;
+    };
+    routeSpec: {
+        file: string;
+        routes: any[];
+    };
+    workerBundles: {
+        directory: string;
+        format: string;
+        importableFromModuleWorker: boolean;
+        requestHandlerExport: string;
+    };
+    resources: {
+        loadableStats: string;
+        routeManifest: string;
+    };
+    security: {
+        enabled: boolean;
+        cors: {
+            assets: boolean;
+            allowedOrigins: string[];
+            allowedMethods: string[];
+            allowedHeaders: string[];
+            reason: string | undefined;
+        };
+        reason: any;
+        headers?: undefined;
+        contentSecurityPolicy?: undefined;
+        noindex?: undefined;
+    } | {
+        enabled: boolean;
+        headers: {
+            referrerPolicy: any;
+            contentTypeOptions: any;
+            permissionsPolicy: any;
+        };
+        contentSecurityPolicy: {
+            mode: "off";
+            directives: {};
+            reason: string | undefined;
+        } | {
+            mode: "enforce" | "report-only";
+            directives: {
+                [k: string]: string[];
+            };
+            reason: string | undefined;
+        };
+        noindex: {
+            workersDev: boolean;
+            localhost: boolean;
+            previewHostnames: never[];
+            reason?: undefined;
+        } | {
+            workersDev: boolean;
+            localhost: boolean;
+            previewHostnames: string[];
+            reason: string | undefined;
+        };
+        cors: {
+            assets: boolean;
+            allowedOrigins: string[];
+            allowedMethods: string[];
+            allowedHeaders: string[];
+            reason: string | undefined;
+        };
+        reason: any;
+    };
+    moduleFederation?: {
+        name: string;
+        exposes: {
+            path: string;
+            css: string[];
+        }[];
+    } | undefined;
+    deliveryUnit?: DeliveryUnitStamp | undefined;
+    i18n: {
+        entries: Record<string, {
+            i18nextDetector: boolean;
+            languages: string[];
+            fallbackLanguage: string;
+            detection: {
+                order: string[];
+                lookupQuerystring: string;
+                lookupCookie: string;
+                lookupHeader: string;
+            };
+            ignoreRedirectRoutes: string[];
+            staticRoutePrefixes: string[];
+            localisedUrls?: Record<string, Record<string, string>>;
+        }>;
+    } | undefined;
+    bff: {
+        dispatcherExport: string;
+        runtimeFramework: string;
+        prefix: string;
+        worker: string;
+    } | undefined;
+    serviceBindings?: {
+        binding: any;
+        service: any;
+        interface: string;
+        prefix?: any;
+        fragments?: any;
+    }[] | undefined;
+}>;
+export declare const createWorkerModuleLoaders: (manifest: any) => string;
+export declare const getPublicAssetExcludes: (appDirectory: string, modernConfig: CloudflareModernConfig) => string[];
+export declare const shouldCopyToPublicAssets: (src: string, distDirectory: string, publicAssetExcludes: string[]) => boolean;
+export declare const shouldCopyToWorkerBundle: (src: string, workerBundleDirectory: string) => boolean;

package/dist/types/plugins/deploy/platforms/cloudflare/wrangler-config.d.ts

@@ -0,0 +1,46 @@
+import type { JsonValue } from '../../../../types/config/deploy';
+import type { CloudflareModernConfig } from './types';
+export declare const createWorkerServiceBindings: (modernConfig: CloudflareModernConfig, configuredWranglerServices: JsonValue | undefined) => {
+    binding: string;
+    service: string;
+    prefix?: string | undefined;
+    fragments?: {
+        remote: string;
+        expose: string;
+        boundaryId: string;
+        path: string;
+    }[] | undefined;
+}[] | JsonValue | undefined;
+export declare const createWorkerManifestServiceBindings: (serviceBindings: ReturnType<typeof createWorkerServiceBindings>) => {
+    binding: any;
+    service: any;
+    interface: string;
+    prefix?: any;
+    fragments?: any;
+}[] | undefined;
+export declare const createWranglerConfig: (appDirectory: string, modernConfig: CloudflareModernConfig) => {
+    $schema: string;
+    name: string;
+    compatibility_date: string;
+    main: string;
+    compatibility_flags: JsonValue[];
+    assets: {
+        directory: string;
+        binding: string;
+        run_worker_first: boolean;
+    };
+    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;
+};

package/dist/types/plugins/deploy/platforms/cloudflare-output-contract.d.ts

@@ -0,0 +1,14 @@
+export declare const CLOUDFLARE_WORKER_ENTRY = "server/index.mjs";
+export declare const CLOUDFLARE_WORKER_MANIFEST = "server/modern-worker-manifest.json";
+export declare const CLOUDFLARE_WRANGLER_CONFIG_FILE = "wrangler.json";
+export declare const CLOUDFLARE_OUTPUT_PACKAGE_FILE = "package.json";
+export declare const CLOUDFLARE_WORKER_PACKAGE_FILE = "worker/package.json";
+export declare const CLOUDFLARE_ASSETS_BINDING = "ASSETS";
+export declare const CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY = "public";
+export declare const CLOUDFLARE_WORKER_BUNDLE_DIRECTORY = "worker";
+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_REQUIRED_COMPATIBILITY_FLAGS: readonly ['nodejs_compat', 'global_fetch_strictly_public'];

package/dist/types/plugins/deploy/platforms/cloudflare-output-plan.d.ts

@@ -0,0 +1,34 @@
+import { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_TYPE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_PACKAGE_TYPE } from './cloudflare-output-contract';
+type CloudflareOutputPlan = {
+    outputDirectory: string;
+    requiredFiles: string[];
+    publicLeakDirectories: string[];
+    paths: {
+        workerEntry: string;
+        workerManifest: string;
+        wranglerConfig: string;
+        outputPackage: string;
+        workerPackage: string;
+        publicAssets: string;
+        workerBundle: string;
+    };
+    packages: {
+        output: {
+            type: typeof CLOUDFLARE_OUTPUT_PACKAGE_TYPE;
+        };
+        worker: {
+            type: typeof CLOUDFLARE_WORKER_PACKAGE_TYPE;
+        };
+    };
+    wrangler: {
+        main: typeof CLOUDFLARE_WORKER_ENTRY;
+        assets: {
+            binding: typeof CLOUDFLARE_ASSETS_BINDING;
+            directory: `./${typeof CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY}`;
+            run_worker_first: true;
+        };
+        requiredCompatibilityFlags: typeof CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+    };
+};
+export declare function createCloudflareOutputPlan(outputDirectory: string): CloudflareOutputPlan;
+export {};

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

@@ -0,0 +1,4 @@
+import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+import type { CloudflareOutputVerifierIssue, JsonObject } from './issues';
+export type CloudflareDeliveryUnitIdentity = DeliveryUnitIdentity;
+export declare const verifyDeliveryUnitIdentity: (issues: CloudflareOutputVerifierIssue[], manifest: JsonObject, manifestPath: string, declared: CloudflareDeliveryUnitIdentity | undefined) => void;

package/dist/types/plugins/deploy/platforms/cloudflare-output-verifier/index.d.ts

@@ -0,0 +1,18 @@
+import type { CloudflareDeliveryUnitIdentity } from './identity';
+import type { CloudflareOutputVerifierResult } from './issues';
+export type { CloudflareDeliveryUnitIdentity } from './identity';
+export type { CloudflareOutputVerifierIssue, CloudflareOutputVerifierIssueCode, CloudflareOutputVerifierResult, } from './issues';
+export { type VerifyCloudflareOutputMutationPolicyOptions, verifyCloudflareOutputMutationPolicy, } from './mutation-policy';
+export interface VerifyCloudflareOutputOptions {
+    outputDirectory: string;
+    importWorker?: boolean;
+    /**
+     * Topology-declared delivery-unit record (from the workspace compact config).
+     * When provided, the Cloudflare worker manifest must carry a matching
+     * `deliveryUnit` stamp so the deployed worker snapshot is proven to derive
+     * from the same delivery unit as the Node/API surfaces (ADR-0019 lane D).
+     */
+    deliveryUnit?: CloudflareDeliveryUnitIdentity;
+}
+export declare const verifyCloudflareOutput: (options: VerifyCloudflareOutputOptions) => Promise<CloudflareOutputVerifierResult>;
+export declare const assertCloudflareOutput: (options: VerifyCloudflareOutputOptions) => Promise<void>;

package/dist/types/plugins/deploy/platforms/cloudflare-output-verifier/issues.d.ts

@@ -0,0 +1,14 @@
+export type CloudflareOutputVerifierIssueCode = 'missing-file' | 'invalid-manifest' | 'invalid-wrangler' | 'invalid-package' | 'public-output-leak' | 'missing-worker-bundle' | 'invalid-worker-bundle' | 'worker-import-failed' | 'delivery-unit-drift' | 'missing-delivery-unit' | 'forbidden-mutation-pattern';
+export interface CloudflareOutputVerifierIssue {
+    code: CloudflareOutputVerifierIssueCode;
+    message: string;
+    path?: string;
+}
+export interface CloudflareOutputVerifierResult {
+    ok: boolean;
+    issues: CloudflareOutputVerifierIssue[];
+}
+export type JsonObject = Record<string, any>;
+export declare const addIssue: (issues: CloudflareOutputVerifierIssue[], issue: CloudflareOutputVerifierIssue) => void;
+export declare const assertEqual: (issues: CloudflareOutputVerifierIssue[], actual: unknown, expected: unknown, issue: CloudflareOutputVerifierIssue) => void;
+export declare const assertFlag: (issues: CloudflareOutputVerifierIssue[], flags: unknown, flag: string, issue: CloudflareOutputVerifierIssue) => void;

package/dist/types/plugins/deploy/platforms/cloudflare-output-verifier/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { CloudflareOutputVerifierIssue, JsonObject } from './issues';
+export declare const verifyManifestShape: (issues: CloudflareOutputVerifierIssue[], manifest: JsonObject, manifestPath: string) => void;

package/dist/types/plugins/deploy/platforms/cloudflare-output-verifier/mutation-policy.d.ts

@@ -0,0 +1,14 @@
+import type { CloudflareOutputVerifierResult } from './issues';
+export interface VerifyCloudflareOutputMutationPolicyOptions {
+    scanRoots: string[];
+    /**
+     * Absolute paths of framework-generated proof artifacts (e.g. the immutable
+     * workspace validation contract) that record generated-output path literals
+     * as contract data and never rewrite build output. These are exempt from the
+     * app-script mutation scan; every app-author script under the scan roots is
+     * still checked.
+     */
+    excludePaths?: string[];
+}
+export declare const walkFiles: (root: string) => Promise<string[]>;
+export declare const verifyCloudflareOutputMutationPolicy: (options: VerifyCloudflareOutputMutationPolicyOptions) => Promise<CloudflareOutputVerifierResult>;

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

@@ -0,0 +1,20 @@
+import type { CloudflareOutputVerifierIssue, JsonObject } from './issues';
+interface WorkerBundleReference {
+    dispatcherExport?: string;
+    kind: 'effect-bff' | 'route';
+    reference: string;
+}
+interface ResolvedWorkerBundleReference extends WorkerBundleReference {
+    path: string;
+}
+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.";
+interface WorkerBundleVerificationContract {
+    providedPackages: ReadonlySet<string>;
+    workerRoot: string;
+}
+export declare const verifyWorkerBundleReferences: (issues: CloudflareOutputVerifierIssue[], worker: ResolvedWorkerBundleReference, source: string, contract: WorkerBundleVerificationContract) => Promise<void>;
+export declare const verifyWorkerImport: (issues: CloudflareOutputVerifierIssue[], entryPath: string) => Promise<void>;
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/types/plugins/deploy/utils/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/plugins/ultramodernReleaseEnvelope.d.ts

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

package/dist/types/presetUltramodern.d.ts

@@ -5,6 +5,16 @@ export interface PresetUltramodernOptions {
      * @default "app"
      */
     appId?: string;
+    /**
+     * Generation-time identity root for a generated delivery unit. When set, the
+     * preset derives one build identity from the immutable source revision and
+     * injects it into every browser, SSR, API, and backend bundle.
+     */
+    deliveryUnit?: {
+        buildMarker: string;
+        unitId: string;
+        version: string;
+    };
     /**
      * Enable BFF requestId contract by default.
      * @default true

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

@@ -12,7 +12,7 @@ export interface RunOptions {
 export declare function createRunOptions({ cwd, initialLog, metaName, version, internalPlugins, configFile, }: RunOptions): Promise<{
     cwd: string | undefined;
     initialLog: string;
-    configFile: string;
+    configFile: any;
     metaName: string;
     internalPlugins: import("@modern-js/plugin").Plugin[];
     handleSetupResult: typeof handleSetupResult;