@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.4 → 3.5.0-ultramodern.40

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

@@ -0,0 +1,91 @@
+"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_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_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_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_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
+});

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

@@ -0,0 +1,83 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    verifyDeliveryUnitIdentity: ()=>verifyDeliveryUnitIdentity
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_issues_js_namespaceObject = require("./issues.js");
+const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
+    const stamped = manifest?.deliveryUnit;
+    const hasStamp = Boolean(stamped) && 'object' == typeof stamped;
+    if (declared) {
+        if (!hasStamp) return void (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'missing-delivery-unit',
+            message: `Cloudflare worker manifest is missing the delivery-unit identity declared by the workspace topology (expected unitId ${declared.unitId}, buildMarker ${declared.buildMarker}).`,
+            path: manifestPath
+        });
+        for (const field of universal_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
+            const stampedValue = (0, universal_namespaceObject.deliveryUnitIdentityFieldValue)(stamped, field);
+            (0, external_issues_js_namespaceObject.assertEqual)(issues, stampedValue, declared[field], {
+                code: 'delivery-unit-drift',
+                message: `Cloudflare worker manifest deliveryUnit.${field} must match the topology delivery-unit record (expected ${declared[field]}, received ${stampedValue ?? 'undefined'}).`,
+                path: manifestPath
+            });
+        }
+    }
+    if (hasStamp && stamped.surfaces && 'object' == typeof stamped.surfaces) for (const surface of [
+        'ui',
+        'api'
+    ]){
+        const marker = stamped.surfaces[surface];
+        if (!marker || 'object' != typeof marker) {
+            (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'missing-delivery-unit',
+                message: `Cloudflare worker manifest is missing the ${surface} delivery-unit surface marker.`,
+                path: manifestPath
+            });
+            continue;
+        }
+        for (const field of universal_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
+            const markerValue = (0, universal_namespaceObject.deliveryUnitIdentityFieldValue)(marker, field);
+            const stampedValue = (0, universal_namespaceObject.deliveryUnitIdentityFieldValue)(stamped, field);
+            (0, external_issues_js_namespaceObject.assertEqual)(issues, markerValue, stampedValue, {
+                code: 'delivery-unit-drift',
+                message: `Cloudflare worker manifest ${surface} surface deliveryUnit.${field} must derive from one delivery-unit record (expected ${stampedValue ?? 'undefined'}, received ${markerValue ?? 'undefined'}).`,
+                path: manifestPath
+            });
+        }
+    }
+};
+exports.verifyDeliveryUnitIdentity = __webpack_exports__.verifyDeliveryUnitIdentity;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "verifyDeliveryUnitIdentity"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,184 @@
+"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__, {
+    assertCloudflareOutput: ()=>assertCloudflareOutput,
+    verifyCloudflareOutput: ()=>verifyCloudflareOutput,
+    verifyCloudflareOutputMutationPolicy: ()=>external_mutation_policy_js_namespaceObject.verifyCloudflareOutputMutationPolicy
+});
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+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_plan_js_namespaceObject = require("../cloudflare-output-plan.js");
+const external_identity_js_namespaceObject = require("./identity.js");
+const external_issues_js_namespaceObject = require("./issues.js");
+const external_manifest_js_namespaceObject = require("./manifest.js");
+const external_worker_bundles_js_namespaceObject = require("./worker-bundles.js");
+const external_mutation_policy_js_namespaceObject = require("./mutation-policy.js");
+const pathExists = async (filePath)=>{
+    try {
+        await promises_default().access(filePath);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+const readJson = async (filePath)=>JSON.parse(await promises_default().readFile(filePath, 'utf-8'));
+const verifyCloudflareOutput = async (options)=>{
+    const outputDirectory = external_node_path_default().resolve(options.outputDirectory);
+    const issues = [];
+    const outputPlan = (0, external_cloudflare_output_plan_js_namespaceObject.createCloudflareOutputPlan)(outputDirectory);
+    for (const relativePath of outputPlan.requiredFiles){
+        const filePath = external_node_path_default().join(outputDirectory, relativePath);
+        if (!await pathExists(filePath)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'missing-file',
+            message: `Cloudflare output is missing ${relativePath}.`,
+            path: filePath
+        });
+    }
+    const manifestPath = outputPlan.paths.workerManifest;
+    const wranglerPath = outputPlan.paths.wranglerConfig;
+    const packagePath = outputPlan.paths.outputPackage;
+    const workerPackagePath = outputPlan.paths.workerPackage;
+    const manifest = await pathExists(manifestPath) ? await readJson(manifestPath) : void 0;
+    const wrangler = await pathExists(wranglerPath) ? await readJson(wranglerPath) : void 0;
+    const outputPackage = await pathExists(packagePath) ? await readJson(packagePath) : void 0;
+    const workerPackage = await pathExists(workerPackagePath) ? await readJson(workerPackagePath) : void 0;
+    if (manifest) {
+        (0, external_manifest_js_namespaceObject.verifyManifestShape)(issues, manifest, manifestPath);
+        (0, external_identity_js_namespaceObject.verifyDeliveryUnitIdentity)(issues, manifest, manifestPath, options.deliveryUnit);
+        const workerReferences = (0, external_worker_bundles_js_namespaceObject.getWorkerBundleReferences)(manifest);
+        if (workerReferences.length > 0 && !await pathExists(workerPackagePath)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'missing-file',
+            message: 'Cloudflare output is missing worker/package.json for referenced worker bundles.',
+            path: workerPackagePath
+        });
+        if (manifest.bff?.runtimeFramework === 'effect' && !(0, external_worker_bundles_js_namespaceObject.getEffectBffWorker)(manifest)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'missing-worker-bundle',
+            message: 'Cloudflare Effect BFF manifest points to a missing worker bundle.'
+        });
+        for (const workerReference of workerReferences){
+            const resolvedWorker = (0, external_worker_bundles_js_namespaceObject.resolveWorkerBundleReference)(issues, outputDirectory, workerReference, manifestPath);
+            if (!resolvedWorker) continue;
+            const workerExists = await pathExists(resolvedWorker.path);
+            if (!workerExists) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'missing-worker-bundle',
+                message: (0, external_worker_bundles_js_namespaceObject.missingWorkerBundleMessage)(workerReference),
+                path: resolvedWorker.path
+            });
+            if (workerExists) {
+                const workerSource = await promises_default().readFile(resolvedWorker.path, 'utf-8');
+                (0, external_worker_bundles_js_namespaceObject.verifyWorkerBundleReferences)(issues, resolvedWorker, workerSource);
+                if ('effect-bff' === resolvedWorker.kind && (workerSource.includes(';entityKind;') || workerSource.includes(';entityKind,entityKind;'))) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'invalid-worker-bundle',
+                    message: 'Cloudflare Effect BFF worker bundle contains invalid Drizzle entityKind marker references.',
+                    path: resolvedWorker.path
+                });
+            }
+        }
+    }
+    if (wrangler) {
+        (0, external_issues_js_namespaceObject.assertEqual)(issues, wrangler.main, outputPlan.wrangler.main, {
+            code: 'invalid-wrangler',
+            message: `wrangler.json main must be ${outputPlan.wrangler.main}.`,
+            path: wranglerPath
+        });
+        (0, external_issues_js_namespaceObject.assertEqual)(issues, wrangler.assets?.binding, outputPlan.wrangler.assets.binding, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json assets.binding must be ASSETS.',
+            path: wranglerPath
+        });
+        (0, external_issues_js_namespaceObject.assertEqual)(issues, wrangler.assets?.directory, outputPlan.wrangler.assets.directory, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json assets.directory must be ./public.',
+            path: wranglerPath
+        });
+        (0, external_issues_js_namespaceObject.assertEqual)(issues, wrangler.assets?.run_worker_first, outputPlan.wrangler.assets.run_worker_first, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json assets.run_worker_first must be true.',
+            path: wranglerPath
+        });
+        for (const flag of outputPlan.wrangler.requiredCompatibilityFlags)(0, external_issues_js_namespaceObject.assertFlag)(issues, wrangler.compatibility_flags, flag, {
+            code: 'invalid-wrangler',
+            message: `wrangler.json compatibility_flags must include ${flag}.`,
+            path: wranglerPath
+        });
+    }
+    if (outputPackage) (0, external_issues_js_namespaceObject.assertEqual)(issues, outputPackage.type, outputPlan.packages.output.type, {
+        code: 'invalid-package',
+        message: '.output/package.json must declare type module.',
+        path: packagePath
+    });
+    if (workerPackage) (0, external_issues_js_namespaceObject.assertEqual)(issues, workerPackage.type, outputPlan.packages.worker.type, {
+        code: 'invalid-package',
+        message: '.output/worker/package.json must declare type commonjs.',
+        path: workerPackagePath
+    });
+    for (const leakedPath of outputPlan.publicLeakDirectories){
+        const publicPath = external_node_path_default().join(outputPlan.paths.publicAssets, leakedPath);
+        if (await pathExists(publicPath)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'public-output-leak',
+            message: `Framework-owned ${leakedPath} output leaked into public assets.`,
+            path: publicPath
+        });
+    }
+    if (false !== options.importWorker && await pathExists(outputPlan.paths.workerEntry)) await (0, external_worker_bundles_js_namespaceObject.verifyWorkerImport)(issues, outputPlan.paths.workerEntry);
+    return {
+        ok: 0 === issues.length,
+        issues
+    };
+};
+const assertCloudflareOutput = async (options)=>{
+    const result = await verifyCloudflareOutput(options);
+    if (!result.ok) throw new Error([
+        'Cloudflare output verification failed:',
+        ...result.issues.map((issue)=>`- ${issue.code}: ${issue.message}${issue.path ? ` (${issue.path})` : ''}`)
+    ].join('\n'));
+};
+exports.assertCloudflareOutput = __webpack_exports__.assertCloudflareOutput;
+exports.verifyCloudflareOutput = __webpack_exports__.verifyCloudflareOutput;
+exports.verifyCloudflareOutputMutationPolicy = __webpack_exports__.verifyCloudflareOutputMutationPolicy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertCloudflareOutput",
+    "verifyCloudflareOutput",
+    "verifyCloudflareOutputMutationPolicy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/{baseline.js → plugins/deploy/platforms/cloudflare-output-verifier/issues.js}

@@ -27,18 +27,27 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    createAppBaselineConfig: ()=>createAppBaselineConfig,
-    withAppBaseline: ()=>withAppBaseline
+const addIssue = (issues, issue)=>{
+    issues.push(issue);
+};
+const assertEqual = (issues, actual, expected, issue)=>{
+    if (actual !== expected) addIssue(issues, issue);
+};
+const assertFlag = (issues, flags, flag, issue)=>{
+    if (!Array.isArray(flags) || !flags.includes(flag)) addIssue(issues, issue);
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    addIssue: addIssue,
+    assertEqual: assertEqual,
+    assertFlag: assertFlag
 });
-const external_presetUltramodern_js_namespaceObject = require("./presetUltramodern.js");
-const createAppBaselineConfig = external_presetUltramodern_js_namespaceObject.createPresetUltramodernConfig;
-const withAppBaseline = external_presetUltramodern_js_namespaceObject.presetUltramodern;
-exports.createAppBaselineConfig = __webpack_exports__.createAppBaselineConfig;
-exports.withAppBaseline = __webpack_exports__.withAppBaseline;
+exports.addIssue = __webpack_exports__.addIssue;
+exports.assertEqual = __webpack_exports__.assertEqual;
+exports.assertFlag = __webpack_exports__.assertFlag;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createAppBaselineConfig",
-    "withAppBaseline"
+    "addIssue",
+    "assertEqual",
+    "assertFlag"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -0,0 +1,83 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    verifyManifestShape: ()=>verifyManifestShape
+});
+const external_cloudflare_output_contract_js_namespaceObject = require("../cloudflare-output-contract.js");
+const external_issues_js_namespaceObject = require("./issues.js");
+const verifyManifestShape = (issues, manifest, manifestPath)=>{
+    (0, external_issues_js_namespaceObject.assertEqual)(issues, manifest.runtime?.type, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_RUNTIME_TYPE, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest runtime.type must be cloudflare-module-worker.',
+        path: manifestPath
+    });
+    (0, external_issues_js_namespaceObject.assertEqual)(issues, manifest.runtime?.entry, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY, {
+        code: 'invalid-manifest',
+        message: `Cloudflare output manifest runtime.entry must be ${external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY}.`,
+        path: manifestPath
+    });
+    (0, external_issues_js_namespaceObject.assertEqual)(issues, manifest.runtime?.fetchExport, true, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest runtime.fetchExport must be true.',
+        path: manifestPath
+    });
+    (0, external_issues_js_namespaceObject.assertEqual)(issues, manifest.runtime?.nodeListen, false, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest runtime.nodeListen must be false.',
+        path: manifestPath
+    });
+    (0, external_issues_js_namespaceObject.assertEqual)(issues, manifest.assets?.binding, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_ASSETS_BINDING, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest assets.binding must be ASSETS.',
+        path: manifestPath
+    });
+    (0, external_issues_js_namespaceObject.assertEqual)(issues, manifest.assets?.directory, `./${external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY}`, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest assets.directory must be ./public.',
+        path: manifestPath
+    });
+    (0, external_issues_js_namespaceObject.assertEqual)(issues, manifest.assets?.runWorkerFirst, true, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest assets.runWorkerFirst must be true.',
+        path: manifestPath
+    });
+    if (!Array.isArray(manifest.routeSpec?.routes)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest routeSpec.routes must be array.',
+        path: manifestPath
+    });
+};
+exports.verifyManifestShape = __webpack_exports__.verifyManifestShape;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "verifyManifestShape"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});