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

package/dist/cjs/cloudflare-output-contract.js

@@ -39,19 +39,76 @@ 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_ROUTE_DATA_HANDLER_EXPORT = 'handleRouteDataRequest';
+const getCloudflareWorkerRouteDataEntryName = (entryName)=>`${entryName}-server-loaders`;
 const CLOUDFLARE_WORKER_NODE_BUILTINS = [
+    '_http_agent',
+    '_http_client',
+    '_http_common',
+    '_http_incoming',
+    '_http_outgoing',
+    '_http_server',
+    '_tls_common',
+    '_tls_wrap',
+    'assert',
+    'assert/strict',
     'async_hooks',
     'buffer',
+    'child_process',
+    'cluster',
+    'console',
+    'constants',
     'crypto',
+    'dgram',
+    'diagnostics_channel',
+    'dns',
+    'dns/promises',
+    'domain',
     'events',
+    'fs',
     'fs/promises',
+    'http',
+    'http2',
+    'https',
+    'inspector',
+    'inspector/promises',
     'module',
+    'net',
+    'os',
     'path',
+    'path/posix',
+    'path/win32',
+    'perf_hooks',
     'process',
+    'punycode',
+    'querystring',
+    'readline',
+    'readline/promises',
+    'repl',
+    'sqlite',
     'stream',
+    'stream/consumers',
+    'stream/promises',
+    'stream/web',
     'string_decoder',
+    'sys',
+    'test',
+    'timers',
+    'timers/promises',
+    'tls',
+    'trace_events',
+    'tty',
     'url',
-    'util'
+    'util',
+    'util/types',
+    'v8',
+    'vm',
+    'wasi',
+    'worker_threads',
+    'zlib'
+];
+const CLOUDFLARE_WORKER_PLATFORM_MODULES = [
+    'cloudflare:sockets'
 ];
 const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = [
     'nodejs_compat',
@@ -63,6 +120,7 @@ __webpack_require__.d(__webpack_exports__, {}, {
     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_ROUTE_DATA_HANDLER_EXPORT: CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT,
     CLOUDFLARE_RUNTIME_TYPE: CLOUDFLARE_RUNTIME_TYPE,
     CLOUDFLARE_WORKER_BUNDLE_DIRECTORY: CLOUDFLARE_WORKER_BUNDLE_DIRECTORY,
     CLOUDFLARE_WORKER_BUNDLE_FORMAT: CLOUDFLARE_WORKER_BUNDLE_FORMAT,
@@ -71,13 +129,16 @@ __webpack_require__.d(__webpack_exports__, {}, {
     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
+    CLOUDFLARE_WORKER_PLATFORM_MODULES: CLOUDFLARE_WORKER_PLATFORM_MODULES,
+    CLOUDFLARE_WRANGLER_CONFIG_FILE: CLOUDFLARE_WRANGLER_CONFIG_FILE,
+    getCloudflareWorkerRouteDataEntryName: getCloudflareWorkerRouteDataEntryName
 });
 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_ROUTE_DATA_HANDLER_EXPORT = __webpack_exports__.CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT;
 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;
@@ -86,13 +147,16 @@ exports.CLOUDFLARE_WORKER_MANIFEST = __webpack_exports__.CLOUDFLARE_WORKER_MANIF
 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_WORKER_PLATFORM_MODULES = __webpack_exports__.CLOUDFLARE_WORKER_PLATFORM_MODULES;
 exports.CLOUDFLARE_WRANGLER_CONFIG_FILE = __webpack_exports__.CLOUDFLARE_WRANGLER_CONFIG_FILE;
+exports.getCloudflareWorkerRouteDataEntryName = __webpack_exports__.getCloudflareWorkerRouteDataEntryName;
 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_ROUTE_DATA_HANDLER_EXPORT",
     "CLOUDFLARE_RUNTIME_TYPE",
     "CLOUDFLARE_WORKER_BUNDLE_DIRECTORY",
     "CLOUDFLARE_WORKER_BUNDLE_FORMAT",
@@ -101,7 +165,9 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CLOUDFLARE_WORKER_NODE_BUILTINS",
     "CLOUDFLARE_WORKER_PACKAGE_FILE",
     "CLOUDFLARE_WORKER_PACKAGE_TYPE",
-    "CLOUDFLARE_WRANGLER_CONFIG_FILE"
+    "CLOUDFLARE_WORKER_PLATFORM_MODULES",
+    "CLOUDFLARE_WRANGLER_CONFIG_FILE",
+    "getCloudflareWorkerRouteDataEntryName"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/cloudflare-output-verifier/identity.js

@@ -30,7 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     verifyDeliveryUnitIdentity: ()=>verifyDeliveryUnitIdentity
 });
-const universal_namespaceObject = require("@modern-js/utils/universal");
+const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const external_issues_js_namespaceObject = require("./issues.js");
 const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
     const stamped = manifest?.deliveryUnit;
@@ -41,8 +41,8 @@ const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
             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);
+        for (const field of backend_federation_contracts_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
+            const stampedValue = (0, backend_federation_contracts_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'}).`,
@@ -56,30 +56,32 @@ const verifyDeliveryUnitIdentity = (issues, manifest, manifestPath, declared)=>{
     ]){
         const marker = stamped.surfaces[surface];
         const expected = declared?.surfaces?.[surface];
-        if (declared?.surfaces && !expected) {
-            if (marker) (0, external_issues_js_namespaceObject.addIssue)(issues, {
-                code: 'delivery-unit-drift',
-                message: `Cloudflare worker manifest declares an unexpected ${surface} delivery-unit surface for this topology profile.`,
-                path: manifestPath
-            });
-            continue;
-        }
-        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
-            });
+        if (expected || marker) {
+            if (declared?.surfaces && !expected) {
+                if (marker) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                    code: 'delivery-unit-drift',
+                    message: `Cloudflare worker manifest declares an unexpected ${surface} delivery-unit surface for this topology profile.`,
+                    path: manifestPath
+                });
+                continue;
+            }
+            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 backend_federation_contracts_namespaceObject.DELIVERY_UNIT_IDENTITY_FIELDS){
+                const markerValue = (0, backend_federation_contracts_namespaceObject.deliveryUnitIdentityFieldValue)(marker, field);
+                const stampedValue = (0, backend_federation_contracts_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
+                });
+            }
         }
     }
 };

package/dist/cjs/cloudflare-output-verifier/index.js

@@ -118,6 +118,16 @@ const verifyCloudflareOutput = async (options)=>{
         }
     }
     if (wrangler) {
+        if ('string' != typeof wrangler.name || 0 === wrangler.name.trim().length) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json name must be a non-empty worker name.',
+            path: wranglerPath
+        });
+        if ('string' != typeof wrangler.compatibility_date || !/^\d{4}-\d{2}-\d{2}$/u.test(wrangler.compatibility_date)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'invalid-wrangler',
+            message: 'wrangler.json compatibility_date must use YYYY-MM-DD.',
+            path: wranglerPath
+        });
         (0, external_issues_js_namespaceObject.assertEqual)(issues, wrangler.main, outputPlan.wrangler.main, {
             code: 'invalid-wrangler',
             message: `wrangler.json main must be ${outputPlan.wrangler.main}.`,

package/dist/cjs/cloudflare-output-verifier/manifest.js

@@ -74,6 +74,52 @@ const verifyManifestShape = (issues, manifest, manifestPath)=>{
         message: 'Cloudflare output manifest routeSpec.routes must be array.',
         path: manifestPath
     });
+    const security = manifest.security;
+    if (security && 'object' == typeof security && 'boolean' == typeof security.enabled) {
+        const cors = security.cors;
+        if (!cors || 'object' != typeof cors || 'boolean' != typeof cors.assets || !Array.isArray(cors.allowedOrigins) || !Array.isArray(cors.allowedMethods) || !Array.isArray(cors.allowedHeaders)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+            code: 'invalid-manifest',
+            message: 'Cloudflare output manifest security.cors is incomplete.',
+            path: manifestPath
+        });
+        if (security.enabled) {
+            const headers = security.headers;
+            const csp = security.contentSecurityPolicy;
+            const noindex = security.noindex;
+            if (!headers || 'object' != typeof headers || ![
+                'string',
+                'boolean'
+            ].includes(typeof headers.referrerPolicy) || ![
+                'string',
+                'boolean'
+            ].includes(typeof headers.contentTypeOptions) || ![
+                'string',
+                'boolean'
+            ].includes(typeof headers.permissionsPolicy)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'invalid-manifest',
+                message: 'Cloudflare output manifest security.headers is incomplete.',
+                path: manifestPath
+            });
+            if (!csp || ![
+                'off',
+                'report-only',
+                'enforce'
+            ].includes(csp.mode) || !csp.directives || 'object' != typeof csp.directives || Array.isArray(csp.directives) || Object.values(csp.directives).some((value)=>!Array.isArray(value) || value.some((entry)=>'string' != typeof entry))) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'invalid-manifest',
+                message: 'Cloudflare output manifest security.contentSecurityPolicy is invalid.',
+                path: manifestPath
+            });
+            if (!noindex || 'boolean' != typeof noindex.workersDev || 'boolean' != typeof noindex.localhost || !Array.isArray(noindex.previewHostnames)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'invalid-manifest',
+                message: 'Cloudflare output manifest security.noindex is incomplete.',
+                path: manifestPath
+            });
+        }
+    } else (0, external_issues_js_namespaceObject.addIssue)(issues, {
+        code: 'invalid-manifest',
+        message: 'Cloudflare output manifest security.enabled must be a boolean.',
+        path: manifestPath
+    });
     if (manifest.bff?.runtimeFramework === 'effect') (0, external_issues_js_namespaceObject.assertEqual)(issues, manifest.bff.dispatcherExport, constants_js_namespaceObject.BFF_EFFECT_WORKER_DISPATCHER_EXPORT, {
         code: 'invalid-manifest',
         message: `Cloudflare Effect BFF manifest dispatcherExport must be ${constants_js_namespaceObject.BFF_EFFECT_WORKER_DISPATCHER_EXPORT}.`,

package/dist/cjs/cloudflare-output-verifier/mutation-policy.js

@@ -128,7 +128,13 @@ const verifyCloudflareOutputMutationPolicy = async (options)=>{
     const files = (await Promise.all(options.scanRoots.map((scanRoot)=>walkFiles(external_node_path_default().resolve(scanRoot))))).flat();
     for (const file of files){
         if (excludedFiles.has(file)) continue;
-        const source = await promises_default().readFile(file, 'utf-8');
+        let source;
+        try {
+            source = await promises_default().readFile(file, 'utf-8');
+        } catch (error) {
+            if ('ENOENT' === error.code) continue;
+            throw error;
+        }
         for (const forbidden of FORBIDDEN_MUTATION_PATTERNS)if (forbidden.pattern.test(source)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
             code: forbidden.code,
             message: forbidden.message,

package/dist/cjs/cloudflare-output-verifier/worker-bundles.js

@@ -55,7 +55,7 @@ const traverse_namespaceObject = require("@babel/traverse");
 var traverse_default = /*#__PURE__*/ __webpack_require__.n(traverse_namespaceObject);
 const external_cloudflare_output_contract_js_namespaceObject = require("../cloudflare-output-contract.js");
 const external_issues_js_namespaceObject = require("./issues.js");
-const getReferencedRouteWorkers = (manifest)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.worker && route.worker.length > 0 ? route.worker : void 0).filter((worker)=>'string' == typeof worker) : [];
+const getReferencedRouteWorkers = (manifest, field)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.[field] && route[field].length > 0 ? route[field] : void 0).filter((worker)=>'string' == typeof worker) : [];
 const getEffectBffWorker = (manifest)=>manifest?.bff?.runtimeFramework === 'effect' && 'string' == typeof manifest.bff.worker ? manifest.bff.worker : void 0;
 const getWorkerBundleReferences = (manifest)=>{
     const effectBffWorker = getEffectBffWorker(manifest);
@@ -67,9 +67,14 @@ const getWorkerBundleReferences = (manifest)=>{
                 reference: effectBffWorker
             }
         ] : [],
-        ...getReferencedRouteWorkers(manifest).map((reference)=>({
+        ...getReferencedRouteWorkers(manifest, 'worker').map((reference)=>({
                 kind: 'route',
                 reference
+            })),
+        ...getReferencedRouteWorkers(manifest, 'routeDataWorker').map((reference)=>({
+                dispatcherExport: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT,
+                kind: 'route-data',
+                reference
             }))
     ];
 };
@@ -90,7 +95,7 @@ const resolveWorkerBundleReference = (issues, outputDirectory, reference, manife
         path: workerPath
     };
 };
-const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
+const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'route-data' === reference.kind ? 'Cloudflare route data worker manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
 const isAstNode = (value)=>null !== value && 'object' == typeof value && 'type' in value && 'string' == typeof value.type;
 const getNodeName = (node)=>{
     if (!isAstNode(node)) return;
@@ -223,7 +228,10 @@ const analyzeWorkerModule = (source)=>{
     };
 };
 const getPackageName = (specifier)=>specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
-const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set(external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`));
+const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set([
+    ...external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`),
+    ...external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_PLATFORM_MODULES
+]);
 const isInsideDirectory = (directory, filePath)=>{
     const relative = external_node_path_default().relative(directory, filePath);
     return 0 === relative.length || !relative.startsWith('..') && !external_node_path_default().isAbsolute(relative);
@@ -331,9 +339,9 @@ const verifyWorkerModuleClosure = async (issues, entryPath, entrySource, contrac
 };
 const verifyWorkerBundleReferences = async (issues, worker, source, contract)=>{
     const entryAnalysis = await verifyWorkerModuleClosure(issues, worker.path, source, contract);
-    if ('effect-bff' === worker.kind && 'string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+    if ('string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
         code: 'invalid-worker-bundle',
-        message: 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
+        message: 'route-data' === worker.kind ? `Cloudflare route data worker bundle must expose ${worker.dispatcherExport}.` : 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
         path: worker.path
     });
 };

package/dist/cjs/config.js

@@ -1,5 +1,20 @@
 "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, {
@@ -12,7 +27,25 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+__webpack_require__.d(__webpack_exports__, {
+    createRemoteManifestUrl: ()=>remote_address_js_namespaceObject.createRemoteManifestUrl,
+    getBuildConfigEnvironment: ()=>public_js_namespaceObject.getBuildConfigEnvironment,
+    resolveDeployTarget: ()=>target_js_namespaceObject.resolveDeployTarget,
+    resolveEffectTsgoCompiler: ()=>public_js_namespaceObject.resolveEffectTsgoCompiler
+});
+const public_js_namespaceObject = require("./build-config/public.js");
+const remote_address_js_namespaceObject = require("./build-config/remote-address.js");
+const target_js_namespaceObject = require("./deploy-output/target.js");
+exports.createRemoteManifestUrl = __webpack_exports__.createRemoteManifestUrl;
+exports.getBuildConfigEnvironment = __webpack_exports__.getBuildConfigEnvironment;
+exports.resolveDeployTarget = __webpack_exports__.resolveDeployTarget;
+exports.resolveEffectTsgoCompiler = __webpack_exports__.resolveEffectTsgoCompiler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRemoteManifestUrl",
+    "getBuildConfigEnvironment",
+    "resolveDeployTarget",
+    "resolveEffectTsgoCompiler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/cjs/deploy-output/npmAliases.js

@@ -0,0 +1,251 @@
+"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__, {
+    preserveNpmAliases: ()=>preserveNpmAliases,
+    readPackageIdentity: ()=>readPackageIdentity
+});
+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 dependencyKeys = [
+    'dependencies',
+    'optionalDependencies'
+];
+const rootDependencyKeys = [
+    ...dependencyKeys,
+    'devDependencies'
+];
+const exactVersionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
+async function readPackageJson(filePath) {
+    return JSON.parse(await promises_default().readFile(filePath, 'utf8'));
+}
+function parseNpmAlias(aliasName, specifier) {
+    if (!specifier.startsWith('npm:')) return;
+    const target = specifier.slice(4);
+    const versionSeparator = target.lastIndexOf('@');
+    if (versionSeparator <= 0 || versionSeparator === target.length - 1) throw new Error(`Invalid npm alias specifier for ${aliasName}: ${specifier}`);
+    return {
+        aliasName,
+        targetName: target.slice(0, versionSeparator),
+        targetVersion: target.slice(versionSeparator + 1)
+    };
+}
+function aliasesFromPackageJson(packageJson, keys = dependencyKeys) {
+    const aliases = [];
+    for (const dependencyKey of keys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+        const alias = parseNpmAlias(aliasName, specifier);
+        if (alias) aliases.push(alias);
+    }
+    return aliases;
+}
+async function catalogAliasesFromInstalledPackages(appDirectory, packageJson) {
+    const aliases = [];
+    for (const dependencyKey of rootDependencyKeys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+        if (!specifier.startsWith('catalog:')) continue;
+        let installedPackage;
+        try {
+            installedPackage = await readPackageJson(external_node_path_default().join(appDirectory, 'node_modules', aliasName, 'package.json'));
+        } catch (error) {
+            if ('ENOENT' === error.code) continue;
+            throw error;
+        }
+        if (!installedPackage.name || !installedPackage.version) throw new Error(`Installed catalog package ${aliasName} has no identity`);
+        if (installedPackage.name !== aliasName) aliases.push({
+            aliasName,
+            targetName: installedPackage.name,
+            targetVersion: installedPackage.version
+        });
+    }
+    return aliases;
+}
+async function collectPackageRecords(nodeModulesDirectory) {
+    const records = [];
+    const visitedNodeModules = new Set();
+    const visitPackage = async (directory)=>{
+        const packageJsonPath = external_node_path_default().join(directory, 'package.json');
+        try {
+            const packageJson = await readPackageJson(packageJsonPath);
+            if (packageJson.name && packageJson.version) records.push({
+                directory,
+                packageJson
+            });
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        await visitNodeModules(external_node_path_default().join(directory, 'node_modules'));
+    };
+    const visitScope = async (scopeDirectory)=>{
+        const entries = await promises_default().readdir(scopeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) await visitPackage(external_node_path_default().join(scopeDirectory, entry.name));
+    };
+    const visitNdepeStore = async (storeDirectory)=>{
+        const entries = await promises_default().readdir(storeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) {
+            const entryPath = external_node_path_default().join(storeDirectory, entry.name);
+            if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitNodeModules(external_node_path_default().join(entryPath, 'node_modules'));
+        }
+    };
+    const visitNodeModules = async (directory)=>{
+        const resolvedDirectory = external_node_path_default().resolve(directory);
+        if (visitedNodeModules.has(resolvedDirectory)) return;
+        visitedNodeModules.add(resolvedDirectory);
+        let entries;
+        try {
+            entries = await promises_default().readdir(directory, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        for (const entry of entries){
+            if (!entry.isDirectory()) continue;
+            const entryPath = external_node_path_default().join(directory, entry.name);
+            if ('.ndepe' === entry.name) await visitNdepeStore(entryPath);
+            else if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitPackage(entryPath);
+        }
+    };
+    await visitNodeModules(nodeModulesDirectory);
+    return records;
+}
+async function resolveAliasTarget(ownerDirectory, alias, outputDirectory) {
+    let directory = ownerDirectory;
+    const outputRoot = external_node_path_default().resolve(outputDirectory);
+    const resolvedOutputRoot = await promises_default().realpath(outputRoot);
+    while(directory === outputRoot || directory.startsWith(`${outputRoot}${external_node_path_default().sep}`)){
+        const candidate = external_node_path_default().join(directory, 'node_modules', alias.targetName);
+        try {
+            const resolvedCandidate = await promises_default().realpath(candidate);
+            if (resolvedCandidate !== resolvedOutputRoot && !resolvedCandidate.startsWith(`${resolvedOutputRoot}${external_node_path_default().sep}`)) throw new Error(`Cannot preserve npm alias ${alias.aliasName}: emitted target ${candidate} resolves outside deployment output to ${resolvedCandidate}`);
+            const packageJson = await readPackageJson(external_node_path_default().join(candidate, 'package.json'));
+            if (packageJson.name !== alias.targetName || !packageJson.version) throw new Error(`npm alias ${alias.aliasName} resolved ${candidate} to unexpected package ${String(packageJson.name)}`);
+            if (exactVersionPattern.test(alias.targetVersion) && packageJson.version !== alias.targetVersion) return;
+            return {
+                directory: candidate,
+                packageJson
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        if (directory === outputRoot) break;
+        directory = external_node_path_default().dirname(directory);
+    }
+}
+async function ensureAliasLink(ownerDirectory, alias, target) {
+    const aliasPath = external_node_path_default().join(ownerDirectory, 'node_modules', alias.aliasName);
+    await promises_default().mkdir(external_node_path_default().dirname(aliasPath), {
+        recursive: true
+    });
+    try {
+        const [existing, expected] = await Promise.all([
+            promises_default().realpath(aliasPath),
+            promises_default().realpath(target.directory)
+        ]);
+        if (existing === expected) return;
+        throw new Error(`Cannot preserve npm alias ${alias.aliasName}: ${aliasPath} already resolves to ${existing}, expected ${expected}`);
+    } catch (error) {
+        if ('ENOENT' !== error.code) throw error;
+    }
+    const linkTarget = external_node_path_default().relative(external_node_path_default().dirname(aliasPath), target.directory);
+    await promises_default().symlink(linkTarget, aliasPath, 'dir');
+}
+function aliasSpecifier(alias) {
+    return `npm:${alias.targetName}@${alias.targetVersion}`;
+}
+async function readPackageIdentity(entryPath) {
+    let directory = external_node_path_default().dirname(entryPath);
+    const root = external_node_path_default().parse(directory).root;
+    while(directory !== root){
+        try {
+            const packageJson = await readPackageJson(external_node_path_default().join(directory, 'package.json'));
+            if (packageJson.name && packageJson.version) return {
+                name: packageJson.name,
+                version: packageJson.version
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        directory = external_node_path_default().dirname(directory);
+    }
+    throw new Error(`Cannot find owning package for deployment entry ${entryPath}`);
+}
+async function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases = [] }) {
+    const records = await collectPackageRecords(external_node_path_default().join(outputDirectory, 'node_modules'));
+    const appPackageJson = await readPackageJson(external_node_path_default().join(appDirectory, 'package.json'));
+    const rootAliases = [
+        ...aliasesFromPackageJson(appPackageJson, rootDependencyKeys),
+        ...await catalogAliasesFromInstalledPackages(appDirectory, appPackageJson),
+        ...implicitAliases
+    ].filter((alias)=>alias.aliasName !== alias.targetName);
+    const emittedRootAliases = [];
+    for (const alias of rootAliases){
+        const target = await resolveAliasTarget(outputDirectory, alias, outputDirectory);
+        if (!target) {
+            if (implicitAliases.includes(alias)) throw new Error(`Cannot preserve implicit npm alias ${alias.aliasName}: emitted target ${alias.targetName}@${alias.targetVersion} is missing`);
+            continue;
+        }
+        await ensureAliasLink(outputDirectory, alias, target);
+        emittedRootAliases.push(alias);
+    }
+    for (const record of records)for (const alias of aliasesFromPackageJson(record.packageJson).filter((candidate)=>candidate.aliasName !== candidate.targetName)){
+        const target = await resolveAliasTarget(record.directory, alias, outputDirectory);
+        if (target) await ensureAliasLink(record.directory, alias, target);
+    }
+    const outputPackageJsonPath = external_node_path_default().join(outputDirectory, 'package.json');
+    const outputPackageJson = await readPackageJson(outputPackageJsonPath);
+    outputPackageJson.dependencies ??= {};
+    for (const alias of emittedRootAliases)outputPackageJson.dependencies[alias.aliasName] = aliasSpecifier(alias);
+    await promises_default().writeFile(outputPackageJsonPath, `${JSON.stringify(outputPackageJson, null, 2)}\n`);
+}
+exports.preserveNpmAliases = __webpack_exports__.preserveNpmAliases;
+exports.readPackageIdentity = __webpack_exports__.readPackageIdentity;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "preserveNpmAliases",
+    "readPackageIdentity"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});