@bleedingdev/modern-js-app-tools 3.8.2-ultramodern.9 → 3.8.3-ultramodern.2

package/dist/esm/plugins/deploy/platforms/cloudflare/artifacts.mjs

@@ -1,64 +0,0 @@
-import node_path from "node:path";
-import { fs } from "@modern-js/utils";
-import { RESERVED_ARTIFACT_DESTINATION_DIRECTORIES, RESERVED_ARTIFACT_DESTINATION_FILES, ROUTE_SPEC_OUTPUT } from "./constants.mjs";
-import { normalizeRelativePath } from "./utils.mjs";
-const normalizeCloudflareArtifact = (artifact, index)=>{
-    const from = normalizeRelativePath(artifact.from, `deploy.worker.artifacts[${index}].from`, 'app root');
-    const to = normalizeRelativePath(artifact.to, `deploy.worker.artifacts[${index}].to`, 'Cloudflare output');
-    const [topLevelDestination] = to.split('/');
-    const reservedDestination = RESERVED_ARTIFACT_DESTINATION_FILES.has(to) ? to : topLevelDestination;
-    if (RESERVED_ARTIFACT_DESTINATION_FILES.has(to) || RESERVED_ARTIFACT_DESTINATION_DIRECTORIES.has(topLevelDestination)) throw new Error(`deploy.worker.artifacts[${index}].to must not target generated Cloudflare output path ${JSON.stringify(reservedDestination)}.`);
-    return {
-        from,
-        to,
-        index
-    };
-};
-const getCloudflareArtifacts = (modernConfig)=>(modernConfig.deploy?.worker?.artifacts ?? []).map(normalizeCloudflareArtifact);
-const normalizeCloudflarePublicAsset = (asset, index)=>{
-    const from = normalizeRelativePath(asset.from, `deploy.worker.publicAssets[${index}].from`, 'app root');
-    const to = normalizeRelativePath(asset.to, `deploy.worker.publicAssets[${index}].to`, 'Cloudflare public output', {
-        allowRoot: true
-    });
-    return {
-        from,
-        to,
-        index
-    };
-};
-const getCloudflarePublicAssets = (modernConfig)=>(modernConfig.deploy?.worker?.publicAssets ?? []).map(normalizeCloudflarePublicAsset);
-const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)=>{
-    for (const artifact of artifacts){
-        const sourcePath = node_path.join(appDirectory, artifact.from);
-        if (!await fs.pathExists(sourcePath)) throw new Error(`deploy.worker.artifacts[${artifact.index}].from does not exist: ${artifact.from}`);
-        await fs.copy(sourcePath, node_path.join(outputDirectory, artifact.to));
-    }
-};
-const copyCloudflarePublicAssets = async (appDirectory, publicDirectory, publicAssets)=>{
-    for (const asset of publicAssets){
-        const sourcePath = node_path.join(appDirectory, asset.from);
-        if (!await fs.pathExists(sourcePath)) throw new Error(`deploy.worker.publicAssets[${asset.index}].from does not exist: ${asset.from}`);
-        await fs.copy(sourcePath, node_path.join(publicDirectory, asset.to));
-    }
-};
-const copyCloudflareD1Migrations = async (appDirectory, outputDirectory, modernConfig)=>{
-    for (const [index, database] of (modernConfig.deploy?.worker?.d1Databases ?? []).entries()){
-        if (!database.migrationsDir) continue;
-        const migrationsDir = normalizeRelativePath(database.migrationsDir, `deploy.worker.d1Databases[${index}].migrationsDir`, 'app root');
-        const sourcePath = node_path.join(appDirectory, migrationsDir);
-        if (!await fs.pathExists(sourcePath)) throw new Error(`deploy.worker.d1Databases[${index}].migrationsDir does not exist: ${migrationsDir}`);
-        await fs.copy(sourcePath, node_path.join(outputDirectory, migrationsDir));
-    }
-};
-const readRouteSpec = async (outputDirectory)=>{
-    const routeSpecPath = node_path.join(outputDirectory, ROUTE_SPEC_OUTPUT);
-    if (!await fs.pathExists(routeSpecPath)) return {
-        routes: []
-    };
-    const routeSpec = await fs.readJSON(routeSpecPath);
-    return {
-        ...routeSpec,
-        routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : []
-    };
-};
-export { copyCloudflareArtifacts, copyCloudflareD1Migrations, copyCloudflarePublicAssets, getCloudflareArtifacts, getCloudflarePublicAssets, readRouteSpec };

package/dist/esm/plugins/deploy/platforms/cloudflare/constants.mjs

@@ -1,34 +0,0 @@
-import { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_FILE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_BUNDLE_FORMAT, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_MANIFEST, CLOUDFLARE_WRANGLER_CONFIG_FILE } from "../cloudflare-output-contract.mjs";
-const WORKER_ENTRY = CLOUDFLARE_WORKER_ENTRY;
-const WORKER_MANIFEST = CLOUDFLARE_WORKER_MANIFEST;
-const WRANGLER_CONFIG_FILE = CLOUDFLARE_WRANGLER_CONFIG_FILE;
-const OUTPUT_PACKAGE_FILE = CLOUDFLARE_OUTPUT_PACKAGE_FILE;
-const ASSETS_BINDING = CLOUDFLARE_ASSETS_BINDING;
-const ROUTE_SPEC_FILE = 'route.json';
-const ROUTE_SPEC_OUTPUT = `server/${ROUTE_SPEC_FILE}`;
-const LOADABLE_STATS_FILE = 'loadable-stats.json';
-const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
-const PUBLIC_ASSETS_DIRECTORY = CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
-const WORKER_BUNDLE_DIRECTORY = CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
-const SERVER_BUNDLE_DIRECTORY = 'bundles';
-const SERVER_OUTPUT_DIRECTORY = 'server';
-const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = [
-    'api',
-    'shared'
-];
-const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
-const BFF_EFFECT_WORKER_DISPATCHER_EXPORT = '__modern_create_effect_bff_dispatcher';
-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.';
-const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
-const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
-const REQUIRED_COMPATIBILITY_FLAGS = CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
-const RESERVED_ARTIFACT_DESTINATION_FILES = new Set([
-    WRANGLER_CONFIG_FILE,
-    OUTPUT_PACKAGE_FILE
-]);
-const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES = new Set([
-    PUBLIC_ASSETS_DIRECTORY,
-    SERVER_OUTPUT_DIRECTORY,
-    WORKER_BUNDLE_DIRECTORY
-]);
-export { ASSETS_BINDING, BFF_EFFECT_WORKER_DISPATCHER_EXPORT, BFF_EFFECT_WORKER_ENTRY, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT, COMPATIBILITY_DATE_PATTERN, DEFAULT_COMPATIBILITY_DATE, DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES, EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE, LOADABLE_STATS_FILE, OUTPUT_PACKAGE_FILE, PUBLIC_ASSETS_DIRECTORY, REQUIRED_COMPATIBILITY_FLAGS, RESERVED_ARTIFACT_DESTINATION_DIRECTORIES, RESERVED_ARTIFACT_DESTINATION_FILES, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, ROUTE_SPEC_OUTPUT, SERVER_BUNDLE_DIRECTORY, SERVER_OUTPUT_DIRECTORY, WORKER_BUNDLE_DIRECTORY, WORKER_ENTRY, WORKER_MANIFEST, WRANGLER_CONFIG_FILE };

package/dist/esm/plugins/deploy/platforms/cloudflare/delivery-unit.mjs

@@ -1,88 +0,0 @@
-import node_path from "node:path";
-import { fs } from "@modern-js/utils";
-import { ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, isUltramodernBuildArtifact, nonEmptyString, toDeliveryUnitIdentity } from "@modern-js/utils/universal";
-import { resolveUltramodernReleaseIdentity } from "../../../../ultramodern-release-identity.mjs";
-import { isRecord } from "./utils.mjs";
-const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
-const findWorkspaceRoot = async (appDirectory)=>{
-    let current = node_path.resolve(appDirectory);
-    for(;;){
-        if (await fs.pathExists(node_path.join(current, COMPACT_CONFIG_PATH))) return current;
-        const parent = node_path.dirname(current);
-        if (parent === current) return;
-        current = parent;
-    }
-};
-const stampReleaseIdentity = (identity, workspaceRoot)=>{
-    if ('workspace' !== identity.sourceRevision) return identity;
-    return {
-        ...identity,
-        ...resolveUltramodernReleaseIdentity({
-            generationBuildMarker: identity.buildMarker,
-            unitId: identity.unitId,
-            workspaceRoot
-        })
-    };
-};
-const resolveTopologyDeliveryUnit = async (appDirectory)=>{
-    const workspaceRoot = await findWorkspaceRoot(appDirectory);
-    if (!workspaceRoot) return;
-    let compactConfig;
-    try {
-        compactConfig = await fs.readJSON(node_path.join(workspaceRoot, COMPACT_CONFIG_PATH));
-    } catch  {
-        return;
-    }
-    if (!isRecord(compactConfig)) return;
-    const topology = isRecord(compactConfig.topology) ? compactConfig.topology : void 0;
-    const apps = Array.isArray(topology?.apps) ? topology.apps : void 0;
-    const resolvedAppDirectory = node_path.resolve(appDirectory);
-    if (apps) {
-        for (const app of apps){
-            if (!isRecord(app)) continue;
-            const appPath = nonEmptyString(app.path);
-            if (appPath && node_path.resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory) {
-                const identity = toDeliveryUnitIdentity(app.deliveryUnit);
-                return identity ? stampReleaseIdentity(identity, workspaceRoot) : void 0;
-            }
-        }
-        return;
-    }
-    const identity = toDeliveryUnitIdentity(compactConfig.deliveryUnit);
-    return identity ? stampReleaseIdentity(identity, workspaceRoot) : void 0;
-};
-const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
-    const buildArtifactPath = node_path.join(appDirectory, ULTRAMODERN_BUILD_ARTIFACT_PATH);
-    const buildModulePath = node_path.join(appDirectory, ULTRAMODERN_BUILD_MODULE_PATH);
-    let identity;
-    if (await fs.pathExists(buildArtifactPath)) {
-        const artifact = await fs.readJSON(buildArtifactPath);
-        if (!isUltramodernBuildArtifact(artifact)) return;
-        identity = toDeliveryUnitIdentity(artifact.deliveryUnit);
-    } else if (await fs.pathExists(buildModulePath)) {
-        console.warn(`[cloudflare] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ultramodern-build.json.`);
-        const source = await fs.readFile(buildModulePath, 'utf8');
-        identity = toDeliveryUnitIdentity({
-            buildMarker: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
-            unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
-            sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1]
-        });
-    }
-    if (!identity) return;
-    const workspaceRoot = await findWorkspaceRoot(appDirectory);
-    if (workspaceRoot) identity = stampReleaseIdentity(identity, workspaceRoot);
-    return {
-        ...identity,
-        surfaces: {
-            ui: {
-                ...identity,
-                surface: 'ui'
-            },
-            api: {
-                ...identity,
-                surface: 'api'
-            }
-        }
-    };
-};
-export { resolveTopologyDeliveryUnit, resolveWorkerDeliveryUnitStamp };

package/dist/esm/plugins/deploy/platforms/cloudflare/i18n-worker.mjs

@@ -1,97 +0,0 @@
-import { isRecord } from "./utils.mjs";
-const I18N_SERVER_PLUGIN_NAME = 'plugin-i18n/server';
-const DEFAULT_I18NEXT_DETECTION_OPTIONS = {
-    order: [
-        'querystring',
-        'cookie',
-        'localStorage',
-        'header',
-        'navigator',
-        'htmlTag',
-        'path',
-        'subdomain'
-    ],
-    lookupQuerystring: 'lng',
-    lookupCookie: 'i18next',
-    lookupHeader: 'accept-language'
-};
-const SERVER_SIDE_I18N_DETECTORS = new Set([
-    'querystring',
-    'cookie',
-    'header'
-]);
-const toStringArray = (value)=>Array.isArray(value) ? value.filter((entry)=>'string' == typeof entry) : [];
-const getI18nServerPlugin = (appContext)=>appContext.serverPlugins?.find((plugin)=>plugin.name.includes(I18N_SERVER_PLUGIN_NAME));
-const removeLocaleDetectionByEntry = (config)=>{
-    const { localeDetectionByEntry: _localeDetectionByEntry, ...rest } = config;
-    return rest;
-};
-const getEntryLocaleDetection = (entryName, localeDetection)=>{
-    const byEntry = isRecord(localeDetection.localeDetectionByEntry) ? localeDetection.localeDetectionByEntry : void 0;
-    const entryConfig = byEntry?.[entryName];
-    const globalConfig = removeLocaleDetectionByEntry(localeDetection);
-    return isRecord(entryConfig) ? {
-        ...globalConfig,
-        ...entryConfig
-    } : globalConfig;
-};
-const normalizeI18nDetection = (detection)=>{
-    const configured = isRecord(detection) ? detection : {};
-    const rawOrder = Array.isArray(configured.order) ? configured.order : DEFAULT_I18NEXT_DETECTION_OPTIONS.order;
-    const order = rawOrder.filter((entry)=>'string' == typeof entry && SERVER_SIDE_I18N_DETECTORS.has(entry));
-    return {
-        order: order.length > 0 ? order : [
-            'querystring',
-            'cookie',
-            'header'
-        ],
-        lookupQuerystring: 'string' == typeof configured.lookupQuerystring && configured.lookupQuerystring ? configured.lookupQuerystring : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring,
-        lookupCookie: 'string' == typeof configured.lookupCookie && configured.lookupCookie ? configured.lookupCookie : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie,
-        lookupHeader: 'string' == typeof configured.lookupHeader && configured.lookupHeader ? configured.lookupHeader : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader
-    };
-};
-const normalizeLocalisedUrls = (localisedUrls)=>{
-    if (!isRecord(localisedUrls) || 0 === Object.keys(localisedUrls).length) return;
-    const normalized = {};
-    for (const [canonicalPath, languageMap] of Object.entries(localisedUrls)){
-        if (!isRecord(languageMap)) continue;
-        const normalizedLanguageMap = Object.fromEntries(Object.entries(languageMap).filter((entry)=>'string' == typeof entry[1] && entry[1].length > 0));
-        if (Object.keys(normalizedLanguageMap).length > 0) normalized[canonicalPath] = normalizedLanguageMap;
-    }
-    return Object.keys(normalized).length > 0 ? normalized : void 0;
-};
-const normalizeWorkerI18nEntry = (entryName, localeDetection, staticRoutePrefixes)=>{
-    const entryConfig = getEntryLocaleDetection(entryName, localeDetection);
-    const languages = toStringArray(entryConfig.languages);
-    if (true !== entryConfig.localePathRedirect || 0 === languages.length) return;
-    const fallbackLanguage = 'string' == typeof entryConfig.fallbackLanguage && entryConfig.fallbackLanguage ? entryConfig.fallbackLanguage : 'en';
-    const ignoreRedirectRoutes = Array.isArray(entryConfig.ignoreRedirectRoutes) ? toStringArray(entryConfig.ignoreRedirectRoutes) : [];
-    const localisedUrls = normalizeLocalisedUrls(entryConfig.localisedUrls);
-    return {
-        i18nextDetector: false !== entryConfig.i18nextDetector,
-        languages,
-        fallbackLanguage,
-        detection: normalizeI18nDetection(entryConfig.detection),
-        ignoreRedirectRoutes,
-        staticRoutePrefixes,
-        ...localisedUrls ? {
-            localisedUrls
-        } : {}
-    };
-};
-const createI18nWorkerManifest = (routeSpec, appContext)=>{
-    const i18nServerPlugin = getI18nServerPlugin(appContext);
-    const localeDetection = i18nServerPlugin?.options?.localeDetection;
-    if (!isRecord(localeDetection)) return;
-    const staticRoutePrefixes = toStringArray(i18nServerPlugin?.options?.staticRoutePrefixes);
-    const entries = {};
-    for (const route of routeSpec.routes){
-        if ('string' != typeof route.entryName || entries[route.entryName]) continue;
-        const entry = normalizeWorkerI18nEntry(route.entryName, localeDetection, staticRoutePrefixes);
-        if (entry) entries[route.entryName] = entry;
-    }
-    return Object.keys(entries).length > 0 ? {
-        entries
-    } : void 0;
-};
-export { createI18nWorkerManifest };

package/dist/esm/plugins/deploy/platforms/cloudflare/index.mjs

@@ -1,102 +0,0 @@
-import node_path from "node:path";
-import { fs } from "@modern-js/utils";
-import { MICROVERTICAL_RELEASE_ENVELOPE_PATH, emitCloudflareStagedReleaseEnvelope, emitFrameworkMicroVerticalReleaseEnvelope, stageCloudflareReleaseEnvelope, verifyBuildOutputReleaseEnvelope, verifyCloudflareReleaseEnvelopeStaging } from "../../../../ultramodern-release-envelope/framework-output.mjs";
-import { readTemplate } from "../../utils/index.mjs";
-import { createCloudflareOutputPlan } from "../cloudflare-output-plan.mjs";
-import { assertCloudflareOutput } from "../cloudflare-output-verifier/index.mjs";
-import { copyCloudflareArtifacts, copyCloudflareD1Migrations, copyCloudflarePublicAssets, getCloudflareArtifacts, getCloudflarePublicAssets } from "./artifacts.mjs";
-import { ROUTE_SPEC_FILE, ROUTE_SPEC_OUTPUT, WORKER_BUNDLE_DIRECTORY } from "./constants.mjs";
-import { resolveTopologyDeliveryUnit, resolveWorkerDeliveryUnitStamp } from "./delivery-unit.mjs";
-import { createWorkerManifest, createWorkerModuleLoaders, getPublicAssetExcludes, shouldCopyToPublicAssets, shouldCopyToWorkerBundle } from "./worker-manifest.mjs";
-import { createWranglerConfig } from "./wrangler-config.mjs";
-const CLOUDFLARE_ENTRY_TEMPLATE_FRAGMENTS = [
-    'cloudflare-entry.001-bootstrap-security.mjs',
-    'cloudflare-entry.002-assets-routes.mjs',
-    'cloudflare-entry.003-i18n-locales.mjs',
-    'cloudflare-entry.004-rendering-css.mjs',
-    'cloudflare-entry.005-worker-dispatch.mjs',
-    'cloudflare-entry.006-fetch-handler.mjs'
-];
-const readCloudflareEntryTemplate = async ()=>(await Promise.all(CLOUDFLARE_ENTRY_TEMPLATE_FRAGMENTS.map((fragment)=>readTemplate(fragment)))).join('');
-const createCloudflarePreset = ({ appContext, modernConfig })=>{
-    const { apiOnly, appDirectory, distDirectory } = appContext;
-    const outputDirectory = node_path.join(appDirectory, '.output');
-    const outputPlan = createCloudflareOutputPlan(outputDirectory);
-    const publicDirectory = outputPlan.paths.publicAssets;
-    const workerEntryPath = outputPlan.paths.workerEntry;
-    const workerManifestPath = outputPlan.paths.workerManifest;
-    const routeSpecOutputPath = node_path.join(outputDirectory, ROUTE_SPEC_OUTPUT);
-    const wranglerConfigPath = outputPlan.paths.wranglerConfig;
-    const cloudflareArtifacts = getCloudflareArtifacts(modernConfig);
-    const publicAssetExcludes = getPublicAssetExcludes(appDirectory, modernConfig);
-    let hasReleaseEnvelope = false;
-    return {
-        async prepare () {
-            await fs.remove(outputDirectory);
-        },
-        async writeOutput () {
-            if (await fs.pathExists(node_path.join(distDirectory, MICROVERTICAL_RELEASE_ENVELOPE_PATH))) await emitFrameworkMicroVerticalReleaseEnvelope({
-                apiOnly,
-                distDirectory,
-                target: 'cloudflare'
-            });
-            await verifyBuildOutputReleaseEnvelope(distDirectory, 'cloudflare');
-            await fs.copy(distDirectory, publicDirectory, {
-                filter: (src)=>{
-                    const relativePath = node_path.relative(distDirectory, src).replace(/\\/gu, '/');
-                    return 'release' !== relativePath && !relativePath.startsWith('release/') && 'public' !== relativePath && !relativePath.startsWith('public/') && shouldCopyToPublicAssets(src, distDirectory, publicAssetExcludes);
-                }
-            });
-            const generatedPublicDirectory = node_path.join(distDirectory, 'public');
-            if (await fs.pathExists(generatedPublicDirectory)) await fs.copy(generatedPublicDirectory, publicDirectory);
-            await fs.ensureDir(node_path.dirname(workerEntryPath));
-            await fs.ensureDir(node_path.dirname(workerManifestPath));
-            const routeSpecSourcePath = node_path.join(distDirectory, ROUTE_SPEC_FILE);
-            if (await fs.pathExists(routeSpecSourcePath)) await fs.copy(routeSpecSourcePath, routeSpecOutputPath);
-            const workerBundleSourceDirectory = node_path.join(distDirectory, WORKER_BUNDLE_DIRECTORY);
-            const workerBundleOutputDirectory = outputPlan.paths.workerBundle;
-            if (await fs.pathExists(workerBundleSourceDirectory)) {
-                await fs.copy(workerBundleSourceDirectory, workerBundleOutputDirectory, {
-                    filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
-                });
-                await fs.writeJSON(outputPlan.paths.workerPackage, outputPlan.packages.worker);
-            }
-            await copyCloudflareArtifacts(appDirectory, outputDirectory, cloudflareArtifacts);
-            await copyCloudflarePublicAssets(appDirectory, publicDirectory, getCloudflarePublicAssets(modernConfig));
-            await copyCloudflareD1Migrations(appDirectory, outputDirectory, modernConfig);
-            await fs.writeJSON(wranglerConfigPath, createWranglerConfig(appDirectory, modernConfig), {
-                spaces: 2
-            });
-            const deliveryUnitStamp = await resolveWorkerDeliveryUnitStamp(appDirectory);
-            await fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig, appContext, deliveryUnitStamp), {
-                spaces: 2
-            });
-            await fs.writeJSON(outputPlan.paths.outputPackage, outputPlan.packages.output);
-            hasReleaseEnvelope = Boolean(await stageCloudflareReleaseEnvelope({
-                distDirectory,
-                outputDirectory
-            }));
-        },
-        async genEntry () {
-            const template = await readCloudflareEntryTemplate();
-            const manifest = await fs.readJSON(workerManifestPath);
-            await fs.writeFile(workerEntryPath, template.replace('p_workerManifest', JSON.stringify(manifest, null, 2)).replace('p_workerModuleLoaders', createWorkerModuleLoaders(manifest)));
-            const topologyDeliveryUnit = await resolveTopologyDeliveryUnit(appDirectory);
-            await assertCloudflareOutput({
-                outputDirectory,
-                importWorker: false,
-                ...topologyDeliveryUnit ? {
-                    deliveryUnit: topologyDeliveryUnit
-                } : {}
-            });
-            if (hasReleaseEnvelope) {
-                await emitCloudflareStagedReleaseEnvelope({
-                    distDirectory,
-                    outputDirectory
-                });
-                await verifyCloudflareReleaseEnvelopeStaging(outputDirectory);
-            } else if (await fs.pathExists(node_path.join(outputDirectory, MICROVERTICAL_RELEASE_ENVELOPE_PATH))) throw new Error('[ultramodern-release-envelope] Cloudflare staging contains an envelope not selected from this MicroVertical build.');
-        }
-    };
-};
-export { createCloudflarePreset };

package/dist/esm/plugins/deploy/platforms/cloudflare/security-policies.mjs

@@ -1,167 +0,0 @@
-const DEFAULT_SECURITY_HEADERS = {
-    referrerPolicy: 'strict-origin-when-cross-origin',
-    contentTypeOptions: 'nosniff',
-    permissionsPolicy: 'camera=(), geolocation=(), microphone=(), payment=(), usb=()'
-};
-const DEFAULT_CORS_ALLOWED_METHODS = [
-    'GET',
-    'HEAD',
-    'POST',
-    'PUT',
-    'PATCH',
-    'DELETE',
-    'OPTIONS'
-];
-const DEFAULT_CSP_DIRECTIVES = {
-    'base-uri': [
-        "'self'"
-    ],
-    'connect-src': [
-        "'self'",
-        'https:',
-        'http:',
-        'wss:',
-        'ws:'
-    ],
-    'default-src': [
-        "'self'"
-    ],
-    'font-src': [
-        "'self'",
-        'data:',
-        'https:',
-        'http:'
-    ],
-    'form-action': [
-        "'self'"
-    ],
-    'frame-ancestors': [
-        "'self'"
-    ],
-    'img-src': [
-        "'self'",
-        'data:',
-        'blob:',
-        'https:',
-        'http:'
-    ],
-    'manifest-src': [
-        "'self'",
-        'https:',
-        'http:'
-    ],
-    'object-src': [
-        "'none'"
-    ],
-    "script-src": [
-        "'self'",
-        "'unsafe-inline'",
-        "'unsafe-eval'",
-        'https:',
-        'http:',
-        'blob:'
-    ],
-    'style-src': [
-        "'self'",
-        "'unsafe-inline'",
-        'https:',
-        'http:'
-    ],
-    'worker-src': [
-        "'self'",
-        'blob:'
-    ]
-};
-const normalizeDirectiveValues = (value)=>{
-    const values = Array.isArray(value) ? value : [
-        value
-    ];
-    return [
-        ...new Set(values.map((entry)=>entry.trim()).filter(Boolean))
-    ];
-};
-const appendDirectiveValues = (directives, name, values)=>{
-    if (!values?.length) return;
-    directives[name] = normalizeDirectiveValues([
-        ...directives[name] ?? [],
-        ...values
-    ]);
-};
-const createContentSecurityPolicy = (config)=>{
-    const mode = config?.mode ?? 'report-only';
-    if ('off' === mode) return {
-        mode,
-        directives: {},
-        reason: config?.reason
-    };
-    const directives = Object.fromEntries(Object.entries(DEFAULT_CSP_DIRECTIVES).map(([name, values])=>[
-            name,
-            [
-                ...values
-            ]
-        ]));
-    for (const [name, value] of Object.entries(config?.directives ?? {}))if (false === value) delete directives[name];
-    else directives[name] = normalizeDirectiveValues(value);
-    if (config?.frameAncestors === false) delete directives['frame-ancestors'];
-    else if (config?.frameAncestors) directives['frame-ancestors'] = normalizeDirectiveValues(config.frameAncestors);
-    appendDirectiveValues(directives, "script-src", config?.additionalScriptSrc);
-    appendDirectiveValues(directives, 'style-src', config?.additionalStyleSrc);
-    appendDirectiveValues(directives, 'connect-src', config?.additionalConnectSrc);
-    appendDirectiveValues(directives, 'img-src', config?.additionalImgSrc);
-    if (config?.reportUri) directives['report-uri'] = [
-        config.reportUri
-    ];
-    return {
-        mode,
-        directives,
-        reason: config?.reason
-    };
-};
-const createNoindexPolicy = (noindex)=>{
-    if (false === noindex) return {
-        workersDev: false,
-        localhost: false,
-        previewHostnames: []
-    };
-    if (true === noindex || void 0 === noindex) return {
-        workersDev: true,
-        localhost: true,
-        previewHostnames: []
-    };
-    return {
-        workersDev: noindex.workersDev ?? true,
-        localhost: noindex.localhost ?? true,
-        previewHostnames: noindex.previewHostnames ?? [],
-        reason: noindex.reason
-    };
-};
-const createCloudflareWorkerCorsPolicy = (cors)=>({
-        assets: cors?.assets ?? true,
-        allowedOrigins: normalizeDirectiveValues(cors?.allowedOrigins ?? []),
-        allowedMethods: cors?.allowedMethods?.length ? normalizeDirectiveValues(cors.allowedMethods.map((method)=>method.toUpperCase())) : DEFAULT_CORS_ALLOWED_METHODS,
-        allowedHeaders: cors?.allowedHeaders?.length ? normalizeDirectiveValues(cors.allowedHeaders) : [
-            '*'
-        ],
-        reason: cors?.reason
-    });
-const createCloudflareWorkerSecurityPolicy = (modernConfig)=>{
-    const security = modernConfig.deploy?.worker?.security;
-    if (security?.enabled === false) return {
-        enabled: false,
-        cors: createCloudflareWorkerCorsPolicy(security.cors),
-        reason: security.reason
-    };
-    return {
-        enabled: true,
-        headers: {
-            referrerPolicy: security?.headers?.referrerPolicy ?? DEFAULT_SECURITY_HEADERS.referrerPolicy,
-            contentTypeOptions: security?.headers?.contentTypeOptions ?? DEFAULT_SECURITY_HEADERS.contentTypeOptions,
-            permissionsPolicy: security?.headers?.permissionsPolicy ?? DEFAULT_SECURITY_HEADERS.permissionsPolicy
-        },
-        contentSecurityPolicy: createContentSecurityPolicy(security?.contentSecurityPolicy),
-        noindex: createNoindexPolicy(security?.noindex),
-        cors: createCloudflareWorkerCorsPolicy(security?.cors),
-        reason: security?.reason
-    };
-};
-export { createCloudflareWorkerSecurityPolicy };

package/dist/esm/plugins/deploy/platforms/cloudflare/utils.mjs

@@ -1,12 +0,0 @@
-import node_path from "node:path";
-const isRecord = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
-const normalizeRelativePath = (value, label, scope = 'app output', options = {})=>{
-    if ('string' != typeof value) throw new Error(`${label} must be a relative path inside the ${scope}.`);
-    const normalized = value.trim().replace(/\\/g, '/').replace(/^\.\/+/u, '').replace(/\/+$/u, '');
-    const segments = normalized.split('/');
-    const isRootDestination = '.' === normalized;
-    if (!normalized || node_path.isAbsolute(normalized) || !options.allowRoot && isRootDestination || segments.includes('..')) throw new Error(`${label} must be a relative path inside the ${scope}.`);
-    return normalized;
-};
-const isJsonRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
-export { isJsonRecord, isRecord, normalizeRelativePath };