@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.1 → 3.5.0-ultramodern.100

package/dist/cjs/plugins/deploy/platforms/cloudflare/worker-manifest.js

@@ -0,0 +1,208 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createWorkerManifest: ()=>createWorkerManifest,
+    createWorkerModuleLoaders: ()=>createWorkerModuleLoaders,
+    getPublicAssetExcludes: ()=>getPublicAssetExcludes,
+    shouldCopyToPublicAssets: ()=>shouldCopyToPublicAssets,
+    shouldCopyToWorkerBundle: ()=>shouldCopyToWorkerBundle
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const external_artifacts_js_namespaceObject = require("./artifacts.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_i18n_worker_js_namespaceObject = require("./i18n-worker.js");
+const external_security_policies_js_namespaceObject = require("./security-policies.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const external_wrangler_config_js_namespaceObject = require("./wrangler-config.js");
+const createMissingEffectBffWorkerError = (outputDirectory, worker)=>new Error(`Cloudflare Effect API runtime is configured, but the BFF worker bundle is missing: ${external_node_path_default().join(outputDirectory, worker)}. ${external_constants_js_namespaceObject.EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE}`);
+const createModuleFederationWorkerManifest = async (outputDirectory)=>{
+    const manifestPath = external_node_path_default().join(outputDirectory, external_constants_js_namespaceObject.PUBLIC_ASSETS_DIRECTORY, 'mf-manifest.json');
+    if (!await utils_namespaceObject.fs.pathExists(manifestPath)) return;
+    const manifest = await utils_namespaceObject.fs.readJson(manifestPath);
+    const name = (0, external_utils_js_namespaceObject.isRecord)(manifest) && 'string' == typeof manifest.name ? manifest.name : void 0;
+    const manifestExposes = (0, external_utils_js_namespaceObject.isRecord)(manifest) && Array.isArray(manifest.exposes) ? manifest.exposes : [];
+    const exposes = manifestExposes.filter(external_utils_js_namespaceObject.isRecord).flatMap((expose)=>{
+        if ('string' != typeof expose.path) return [];
+        const assets = (0, external_utils_js_namespaceObject.isRecord)(expose.assets) ? expose.assets : void 0;
+        const css = assets && (0, external_utils_js_namespaceObject.isRecord)(assets.css) ? assets.css : void 0;
+        return [
+            {
+                path: expose.path,
+                css: [
+                    ...css && Array.isArray(css.sync) ? css.sync : [],
+                    ...css && Array.isArray(css.async) ? css.async : []
+                ].filter((asset)=>'string' == typeof asset && asset.endsWith('.css'))
+            }
+        ];
+    });
+    return name && exposes.length > 0 ? {
+        name,
+        exposes
+    } : void 0;
+};
+const createWorkerManifest = async (outputDirectory, modernConfig, appContext, deliveryUnitStamp)=>{
+    const routeSpec = await (0, external_artifacts_js_namespaceObject.readRouteSpec)(outputDirectory);
+    const routes = await Promise.all(routeSpec.routes.map(async (route)=>{
+        const worker = 'string' == typeof route.worker ? route.worker : void 0;
+        return {
+            urlPath: route.urlPath,
+            entryName: route.entryName,
+            entryPath: route.entryPath,
+            isSSR: Boolean(route.isSSR),
+            worker,
+            workerExists: worker ? await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, worker)) : false
+        };
+    }));
+    const bffPrefix = modernConfig.bff?.prefix;
+    const primaryBffPrefix = Array.isArray(bffPrefix) ? bffPrefix[0] : bffPrefix;
+    const isEffectApi = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
+    const effectApiWorkerExists = await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, external_constants_js_namespaceObject.BFF_EFFECT_WORKER_ENTRY));
+    const serviceBindings = (0, external_wrangler_config_js_namespaceObject.createWorkerManifestServiceBindings)((0, external_wrangler_config_js_namespaceObject.createWorkerServiceBindings)(modernConfig, void 0));
+    const moduleFederation = await createModuleFederationWorkerManifest(outputDirectory);
+    if (isEffectApi && primaryBffPrefix && !effectApiWorkerExists) throw createMissingEffectBffWorkerError(outputDirectory, external_constants_js_namespaceObject.BFF_EFFECT_WORKER_ENTRY);
+    return {
+        version: 1,
+        runtime: {
+            type: external_constants_js_namespaceObject.CLOUDFLARE_RUNTIME_TYPE,
+            entry: external_constants_js_namespaceObject.WORKER_ENTRY,
+            fetchExport: true,
+            nodeListen: false
+        },
+        assets: {
+            binding: external_constants_js_namespaceObject.ASSETS_BINDING,
+            directory: `./${external_constants_js_namespaceObject.PUBLIC_ASSETS_DIRECTORY}`,
+            runWorkerFirst: true
+        },
+        routeSpec: {
+            file: external_constants_js_namespaceObject.ROUTE_SPEC_OUTPUT,
+            routes
+        },
+        workerBundles: {
+            directory: external_constants_js_namespaceObject.WORKER_BUNDLE_DIRECTORY,
+            format: external_constants_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_FORMAT,
+            importableFromModuleWorker: true,
+            requestHandlerExport: 'requestHandler'
+        },
+        resources: {
+            loadableStats: external_constants_js_namespaceObject.LOADABLE_STATS_FILE,
+            routeManifest: external_constants_js_namespaceObject.ROUTE_MANIFEST_FILE
+        },
+        security: (0, external_security_policies_js_namespaceObject.createCloudflareWorkerSecurityPolicy)(modernConfig),
+        ...void 0 === moduleFederation ? {} : {
+            moduleFederation
+        },
+        ...deliveryUnitStamp ? {
+            deliveryUnit: deliveryUnitStamp
+        } : {},
+        i18n: (0, external_i18n_worker_js_namespaceObject.createI18nWorkerManifest)(routeSpec, appContext),
+        bff: isEffectApi && primaryBffPrefix && effectApiWorkerExists ? {
+            dispatcherExport: external_constants_js_namespaceObject.BFF_EFFECT_WORKER_DISPATCHER_EXPORT,
+            runtimeFramework: 'effect',
+            prefix: primaryBffPrefix,
+            worker: external_constants_js_namespaceObject.BFF_EFFECT_WORKER_ENTRY
+        } : void 0,
+        ...void 0 === serviceBindings ? {} : {
+            serviceBindings
+        }
+    };
+};
+const createWorkerModuleLoaders = (manifest)=>{
+    const imports = new Map();
+    for (const route of manifest.routeSpec.routes)if (route.worker && route.workerExists) {
+        const importPath = `../${String(route.worker).replace(/^\/+/u, '')}`;
+        imports.set(route.worker, `() => import(${JSON.stringify(importPath)})`);
+    }
+    if (manifest.bff?.worker) {
+        const importPath = `../${String(manifest.bff.worker).replace(/^\/+/u, '')}`;
+        imports.set(manifest.bff.worker, `() => import(${JSON.stringify(importPath)})`);
+    }
+    if (0 === imports.size) return '{}';
+    const loaders = [
+        ...imports.entries()
+    ].map(([worker, loader])=>`${JSON.stringify(worker)}: ${loader}`);
+    return `{\n${loaders.join(',\n')}\n}`;
+};
+const getPublicAssetExcludes = (appDirectory, modernConfig)=>[
+        ...external_constants_js_namespaceObject.DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES.filter((directory)=>{
+            try {
+                return utils_namespaceObject.fs.statSync(external_node_path_default().join(appDirectory, directory)).isDirectory();
+            } catch  {
+                return false;
+            }
+        }),
+        ...modernConfig.deploy?.worker?.publicAssetExcludes ?? []
+    ].map((entry)=>(0, external_utils_js_namespaceObject.normalizeRelativePath)(entry, 'deploy.worker.publicAssetExcludes'));
+const shouldCopyToPublicAssets = (src, distDirectory, publicAssetExcludes)=>{
+    const relativePath = external_node_path_default().relative(distDirectory, src);
+    if (!relativePath) return true;
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    const [topLevelDirectory] = normalizedRelativePath.split('/');
+    const basename = normalizedRelativePath.split('/').pop() ?? '';
+    return normalizedRelativePath !== external_constants_js_namespaceObject.ROUTE_SPEC_FILE && topLevelDirectory !== external_constants_js_namespaceObject.WORKER_BUNDLE_DIRECTORY && topLevelDirectory !== external_constants_js_namespaceObject.SERVER_BUNDLE_DIRECTORY && '.env' !== basename && !basename.startsWith('.env.') && !publicAssetExcludes.some((exclude)=>normalizedRelativePath === exclude || normalizedRelativePath.startsWith(`${exclude}/`));
+};
+const shouldCopyToWorkerBundle = (src, workerBundleDirectory)=>{
+    const relativePath = external_node_path_default().relative(workerBundleDirectory, src);
+    if (!relativePath) return true;
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    const basename = external_node_path_default().basename(normalizedRelativePath);
+    if (basename.startsWith('.') || normalizedRelativePath.includes('/.')) return false;
+    if (utils_namespaceObject.fs.statSync(src).isDirectory()) return true;
+    return [
+        '.cjs',
+        '.js',
+        '.mjs'
+    ].includes(external_node_path_default().extname(normalizedRelativePath));
+};
+exports.createWorkerManifest = __webpack_exports__.createWorkerManifest;
+exports.createWorkerModuleLoaders = __webpack_exports__.createWorkerModuleLoaders;
+exports.getPublicAssetExcludes = __webpack_exports__.getPublicAssetExcludes;
+exports.shouldCopyToPublicAssets = __webpack_exports__.shouldCopyToPublicAssets;
+exports.shouldCopyToWorkerBundle = __webpack_exports__.shouldCopyToWorkerBundle;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createWorkerManifest",
+    "createWorkerModuleLoaders",
+    "getPublicAssetExcludes",
+    "shouldCopyToPublicAssets",
+    "shouldCopyToWorkerBundle"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/platforms/cloudflare/wrangler-config.js

@@ -0,0 +1,204 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createWorkerManifestServiceBindings: ()=>createWorkerManifestServiceBindings,
+    createWorkerServiceBindings: ()=>createWorkerServiceBindings,
+    createWranglerConfig: ()=>createWranglerConfig
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const getCompatibilityDate = (modernConfig)=>{
+    const configuredDate = modernConfig.deploy?.worker?.compatibilityDate?.trim();
+    const compatibilityDate = configuredDate || external_constants_js_namespaceObject.DEFAULT_COMPATIBILITY_DATE;
+    if (!external_constants_js_namespaceObject.COMPATIBILITY_DATE_PATTERN.test(compatibilityDate)) throw new Error(`deploy.worker.compatibilityDate must use YYYY-MM-DD, received ${JSON.stringify(compatibilityDate)}.`);
+    return compatibilityDate;
+};
+const getWorkerName = (appDirectory)=>{
+    const basename = external_node_path_default().basename(appDirectory);
+    return basename.replace(/[^a-zA-Z0-9-_]/g, '-') || 'modern-cloudflare-worker';
+};
+const getConfiguredWorkerName = (appDirectory, modernConfig)=>{
+    const configuredName = modernConfig.deploy?.worker?.name?.trim();
+    return configuredName || getWorkerName(appDirectory);
+};
+const getConfiguredWrangler = (modernConfig)=>{
+    const wrangler = modernConfig.deploy?.worker?.wrangler;
+    if (void 0 === wrangler) return {};
+    if (!(0, external_utils_js_namespaceObject.isJsonRecord)(wrangler)) throw new Error('deploy.worker.wrangler must be a JSON object.');
+    return wrangler;
+};
+const createWranglerCompatibilityFlags = (configuredFlags)=>{
+    if (void 0 === configuredFlags) return [
+        ...external_constants_js_namespaceObject.REQUIRED_COMPATIBILITY_FLAGS
+    ];
+    if (!Array.isArray(configuredFlags) || configuredFlags.some((flag)=>'string' != typeof flag)) throw new Error('deploy.worker.wrangler.compatibility_flags must be an array of strings.');
+    return [
+        ...new Set([
+            ...configuredFlags,
+            ...external_constants_js_namespaceObject.REQUIRED_COMPATIBILITY_FLAGS
+        ])
+    ];
+};
+const createWranglerAssetsConfig = (configuredAssets)=>{
+    if (void 0 !== configuredAssets && !(0, external_utils_js_namespaceObject.isJsonRecord)(configuredAssets)) throw new Error('deploy.worker.wrangler.assets must be an object.');
+    return {
+        ...(0, external_utils_js_namespaceObject.isJsonRecord)(configuredAssets) ? configuredAssets : {},
+        directory: `./${external_constants_js_namespaceObject.PUBLIC_ASSETS_DIRECTORY}`,
+        binding: external_constants_js_namespaceObject.ASSETS_BINDING,
+        run_worker_first: true
+    };
+};
+const assertNonEmptyString = (value, label)=>{
+    if ('string' != typeof value || 0 === value.trim().length) throw new Error(`${label} must be a non-empty string.`);
+    return value.trim();
+};
+const normalizeD1Database = (database, index)=>{
+    const binding = assertNonEmptyString(database.binding, `deploy.worker.d1Databases[${index}].binding`);
+    const databaseName = assertNonEmptyString(database.databaseName, `deploy.worker.d1Databases[${index}].databaseName`);
+    const databaseId = assertNonEmptyString(database.databaseId, `deploy.worker.d1Databases[${index}].databaseId`);
+    const migrationsDir = void 0 === database.migrationsDir ? void 0 : (0, external_utils_js_namespaceObject.normalizeRelativePath)(database.migrationsDir, `deploy.worker.d1Databases[${index}].migrationsDir`, 'app root');
+    const previewDatabaseId = void 0 === database.previewDatabaseId ? void 0 : assertNonEmptyString(database.previewDatabaseId, `deploy.worker.d1Databases[${index}].previewDatabaseId`);
+    return {
+        binding,
+        database_name: databaseName,
+        database_id: databaseId,
+        ...void 0 === migrationsDir ? {} : {
+            migrations_dir: migrationsDir
+        },
+        ...void 0 === previewDatabaseId ? {} : {
+            preview_database_id: previewDatabaseId
+        },
+        ...void 0 === database.remote ? {} : {
+            remote: database.remote
+        }
+    };
+};
+const createWranglerD1Databases = (modernConfig, configuredWranglerD1)=>{
+    const d1Databases = modernConfig.deploy?.worker?.d1Databases;
+    if (void 0 === d1Databases) return configuredWranglerD1;
+    if (void 0 !== configuredWranglerD1) throw new Error('Use deploy.worker.d1Databases or deploy.worker.wrangler.d1_databases, not both.');
+    if (!Array.isArray(d1Databases)) throw new Error('deploy.worker.d1Databases must be an array.');
+    return d1Databases.map(normalizeD1Database);
+};
+const normalizeServiceBinding = (service, index)=>{
+    const binding = assertNonEmptyString(service.binding, `deploy.worker.services[${index}].binding`);
+    const serviceName = assertNonEmptyString(service.service, `deploy.worker.services[${index}].service`);
+    const prefix = void 0 === service.prefix ? void 0 : assertNonEmptyString(service.prefix, `deploy.worker.services[${index}].prefix`);
+    if (void 0 !== service.fragments && !Array.isArray(service.fragments)) throw new Error(`deploy.worker.services[${index}].fragments must be an array.`);
+    const fragments = void 0 === service.fragments ? void 0 : service.fragments.map((fragment, fragmentIndex)=>({
+            remote: assertNonEmptyString(fragment.remote, `deploy.worker.services[${index}].fragments[${fragmentIndex}].remote`),
+            expose: assertNonEmptyString(fragment.expose, `deploy.worker.services[${index}].fragments[${fragmentIndex}].expose`),
+            boundaryId: assertNonEmptyString(fragment.boundaryId, `deploy.worker.services[${index}].fragments[${fragmentIndex}].boundaryId`),
+            path: assertNonEmptyString(fragment.path, `deploy.worker.services[${index}].fragments[${fragmentIndex}].path`)
+        }));
+    return {
+        binding,
+        service: serviceName,
+        ...void 0 === prefix ? {} : {
+            prefix
+        },
+        ...void 0 === fragments ? {} : {
+            fragments
+        }
+    };
+};
+const createWorkerServiceBindings = (modernConfig, configuredWranglerServices)=>{
+    const services = modernConfig.deploy?.worker?.services;
+    if (void 0 === services) return configuredWranglerServices;
+    if (void 0 !== configuredWranglerServices) throw new Error('Use deploy.worker.services or deploy.worker.wrangler.services, not both.');
+    if (!Array.isArray(services)) throw new Error('deploy.worker.services must be an array.');
+    return services.map(normalizeServiceBinding);
+};
+const createWranglerServices = (serviceBindings)=>{
+    if (!Array.isArray(serviceBindings)) return serviceBindings;
+    if (!serviceBindings.every(external_utils_js_namespaceObject.isJsonRecord)) return serviceBindings;
+    return serviceBindings.map((service)=>{
+        const { prefix, fragments, ...wranglerService } = service;
+        return wranglerService;
+    });
+};
+const createWorkerManifestServiceBindings = (serviceBindings)=>{
+    if (!Array.isArray(serviceBindings)) return;
+    const manifestBindings = serviceBindings.filter((service)=>(0, external_utils_js_namespaceObject.isJsonRecord)(service) && 'string' == typeof service.binding && 'string' == typeof service.service && ('string' == typeof service.prefix || Array.isArray(service.fragments) && service.fragments.length > 0)).map((service)=>({
+            binding: service.binding,
+            service: service.service,
+            interface: 'fetch',
+            ...void 0 === service.prefix ? {} : {
+                prefix: service.prefix
+            },
+            ...void 0 === service.fragments ? {} : {
+                fragments: service.fragments
+            }
+        }));
+    return manifestBindings.length > 0 ? manifestBindings : void 0;
+};
+const createWranglerConfig = (appDirectory, modernConfig)=>{
+    const wrangler = getConfiguredWrangler(modernConfig);
+    const d1Databases = createWranglerD1Databases(modernConfig, wrangler.d1_databases);
+    const serviceBindings = createWorkerServiceBindings(modernConfig, wrangler.services);
+    const wranglerServices = createWranglerServices(serviceBindings);
+    return {
+        $schema: 'node_modules/wrangler/config-schema.json',
+        name: getConfiguredWorkerName(appDirectory, modernConfig),
+        compatibility_date: getCompatibilityDate(modernConfig),
+        ...wrangler,
+        main: external_constants_js_namespaceObject.WORKER_ENTRY,
+        compatibility_flags: createWranglerCompatibilityFlags(wrangler.compatibility_flags),
+        assets: createWranglerAssetsConfig(wrangler.assets),
+        ...void 0 === d1Databases ? {} : {
+            d1_databases: d1Databases
+        },
+        ...void 0 === wranglerServices ? {} : {
+            services: wranglerServices
+        }
+    };
+};
+exports.createWorkerManifestServiceBindings = __webpack_exports__.createWorkerManifestServiceBindings;
+exports.createWorkerServiceBindings = __webpack_exports__.createWorkerServiceBindings;
+exports.createWranglerConfig = __webpack_exports__.createWranglerConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createWorkerManifestServiceBindings",
+    "createWorkerServiceBindings",
+    "createWranglerConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/platforms/cloudflare-output-contract.js

@@ -0,0 +1,108 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const CLOUDFLARE_WORKER_ENTRY = 'server/index.mjs';
+const CLOUDFLARE_WORKER_MANIFEST = 'server/modern-worker-manifest.json';
+const CLOUDFLARE_WRANGLER_CONFIG_FILE = 'wrangler.json';
+const CLOUDFLARE_OUTPUT_PACKAGE_FILE = 'package.json';
+const CLOUDFLARE_WORKER_PACKAGE_FILE = 'worker/package.json';
+const CLOUDFLARE_ASSETS_BINDING = 'ASSETS';
+const CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY = 'public';
+const CLOUDFLARE_WORKER_BUNDLE_DIRECTORY = 'worker';
+const CLOUDFLARE_RUNTIME_TYPE = 'cloudflare-module-worker';
+const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = 'module';
+const CLOUDFLARE_WORKER_PACKAGE_TYPE = 'commonjs';
+const CLOUDFLARE_WORKER_BUNDLE_FORMAT = 'commonjs';
+const CLOUDFLARE_WORKER_NODE_BUILTINS = [
+    'async_hooks',
+    'buffer',
+    'crypto',
+    'events',
+    'fs/promises',
+    'module',
+    'path',
+    'process',
+    'stream',
+    'string_decoder',
+    'url',
+    'util'
+];
+const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = [
+    'nodejs_compat',
+    'global_fetch_strictly_public'
+];
+__webpack_require__.d(__webpack_exports__, {}, {
+    CLOUDFLARE_ASSETS_BINDING: CLOUDFLARE_ASSETS_BINDING,
+    CLOUDFLARE_OUTPUT_PACKAGE_FILE: CLOUDFLARE_OUTPUT_PACKAGE_FILE,
+    CLOUDFLARE_OUTPUT_PACKAGE_TYPE: CLOUDFLARE_OUTPUT_PACKAGE_TYPE,
+    CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY: CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY,
+    CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS: CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS,
+    CLOUDFLARE_RUNTIME_TYPE: CLOUDFLARE_RUNTIME_TYPE,
+    CLOUDFLARE_WORKER_BUNDLE_DIRECTORY: CLOUDFLARE_WORKER_BUNDLE_DIRECTORY,
+    CLOUDFLARE_WORKER_BUNDLE_FORMAT: CLOUDFLARE_WORKER_BUNDLE_FORMAT,
+    CLOUDFLARE_WORKER_ENTRY: CLOUDFLARE_WORKER_ENTRY,
+    CLOUDFLARE_WORKER_MANIFEST: CLOUDFLARE_WORKER_MANIFEST,
+    CLOUDFLARE_WORKER_NODE_BUILTINS: CLOUDFLARE_WORKER_NODE_BUILTINS,
+    CLOUDFLARE_WORKER_PACKAGE_FILE: CLOUDFLARE_WORKER_PACKAGE_FILE,
+    CLOUDFLARE_WORKER_PACKAGE_TYPE: CLOUDFLARE_WORKER_PACKAGE_TYPE,
+    CLOUDFLARE_WRANGLER_CONFIG_FILE: CLOUDFLARE_WRANGLER_CONFIG_FILE
+});
+exports.CLOUDFLARE_ASSETS_BINDING = __webpack_exports__.CLOUDFLARE_ASSETS_BINDING;
+exports.CLOUDFLARE_OUTPUT_PACKAGE_FILE = __webpack_exports__.CLOUDFLARE_OUTPUT_PACKAGE_FILE;
+exports.CLOUDFLARE_OUTPUT_PACKAGE_TYPE = __webpack_exports__.CLOUDFLARE_OUTPUT_PACKAGE_TYPE;
+exports.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY = __webpack_exports__.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
+exports.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = __webpack_exports__.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+exports.CLOUDFLARE_RUNTIME_TYPE = __webpack_exports__.CLOUDFLARE_RUNTIME_TYPE;
+exports.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY = __webpack_exports__.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
+exports.CLOUDFLARE_WORKER_BUNDLE_FORMAT = __webpack_exports__.CLOUDFLARE_WORKER_BUNDLE_FORMAT;
+exports.CLOUDFLARE_WORKER_ENTRY = __webpack_exports__.CLOUDFLARE_WORKER_ENTRY;
+exports.CLOUDFLARE_WORKER_MANIFEST = __webpack_exports__.CLOUDFLARE_WORKER_MANIFEST;
+exports.CLOUDFLARE_WORKER_NODE_BUILTINS = __webpack_exports__.CLOUDFLARE_WORKER_NODE_BUILTINS;
+exports.CLOUDFLARE_WORKER_PACKAGE_FILE = __webpack_exports__.CLOUDFLARE_WORKER_PACKAGE_FILE;
+exports.CLOUDFLARE_WORKER_PACKAGE_TYPE = __webpack_exports__.CLOUDFLARE_WORKER_PACKAGE_TYPE;
+exports.CLOUDFLARE_WRANGLER_CONFIG_FILE = __webpack_exports__.CLOUDFLARE_WRANGLER_CONFIG_FILE;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLOUDFLARE_ASSETS_BINDING",
+    "CLOUDFLARE_OUTPUT_PACKAGE_FILE",
+    "CLOUDFLARE_OUTPUT_PACKAGE_TYPE",
+    "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_WORKER_NODE_BUILTINS",
+    "CLOUDFLARE_WORKER_PACKAGE_FILE",
+    "CLOUDFLARE_WORKER_PACKAGE_TYPE",
+    "CLOUDFLARE_WRANGLER_CONFIG_FILE"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/platforms/cloudflare-output-plan.js

@@ -0,0 +1,93 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createCloudflareOutputPlan: ()=>createCloudflareOutputPlan
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_cloudflare_output_contract_js_namespaceObject = require("./cloudflare-output-contract.js");
+const resolveOutput = (outputDirectory, relativePath)=>external_node_path_default().join(outputDirectory, relativePath);
+function createCloudflareOutputPlan(outputDirectory) {
+    return {
+        outputDirectory,
+        requiredFiles: [
+            external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY,
+            external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_MANIFEST,
+            external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WRANGLER_CONFIG_FILE,
+            external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_OUTPUT_PACKAGE_FILE
+        ],
+        publicLeakDirectories: [
+            'server',
+            external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY
+        ],
+        paths: {
+            workerEntry: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY),
+            workerManifest: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_MANIFEST),
+            wranglerConfig: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WRANGLER_CONFIG_FILE),
+            outputPackage: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_OUTPUT_PACKAGE_FILE),
+            workerPackage: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_PACKAGE_FILE),
+            publicAssets: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY),
+            workerBundle: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY)
+        },
+        packages: {
+            output: {
+                type: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_OUTPUT_PACKAGE_TYPE
+            },
+            worker: {
+                type: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_PACKAGE_TYPE
+            }
+        },
+        wrangler: {
+            main: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY,
+            assets: {
+                binding: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_ASSETS_BINDING,
+                directory: `./${external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY}`,
+                run_worker_first: true
+            },
+            requiredCompatibilityFlags: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS
+        }
+    };
+}
+exports.createCloudflareOutputPlan = __webpack_exports__.createCloudflareOutputPlan;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCloudflareOutputPlan"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});