@bleedingdev/modern-js-app-tools-extensions 3.8.3-ultramodern.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# `@modern-js/app-tools-extensions`
+
+Fork-owned UltraModern.js app tooling for Cloudflare Worker delivery, output verification, and release-envelope identity enforcement.
+
+The package is composed into upstream app-tools through existing deploy/plugin extension seams. It must not depend on `@modern-js/app-tools`.

package/dist/cjs/cloudflare/artifacts.js

@@ -0,0 +1,127 @@
+"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__, {
+    copyCloudflareArtifacts: ()=>copyCloudflareArtifacts,
+    copyCloudflareD1Migrations: ()=>copyCloudflareD1Migrations,
+    copyCloudflarePublicAssets: ()=>copyCloudflarePublicAssets,
+    getCloudflareArtifacts: ()=>getCloudflareArtifacts,
+    getCloudflarePublicAssets: ()=>getCloudflarePublicAssets,
+    readRouteSpec: ()=>readRouteSpec
+});
+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_constants_js_namespaceObject = require("./constants.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const normalizeCloudflareArtifact = (artifact, index)=>{
+    const from = (0, external_utils_js_namespaceObject.normalizeRelativePath)(artifact.from, `deploy.worker.artifacts[${index}].from`, 'app root');
+    const to = (0, external_utils_js_namespaceObject.normalizeRelativePath)(artifact.to, `deploy.worker.artifacts[${index}].to`, 'Cloudflare output');
+    const [topLevelDestination] = to.split('/');
+    const reservedDestination = external_constants_js_namespaceObject.RESERVED_ARTIFACT_DESTINATION_FILES.has(to) ? to : topLevelDestination;
+    if (external_constants_js_namespaceObject.RESERVED_ARTIFACT_DESTINATION_FILES.has(to) || external_constants_js_namespaceObject.RESERVED_ARTIFACT_DESTINATION_DIRECTORIES.has(topLevelDestination)) throw new Error(`deploy.worker.artifacts[${index}].to must not target generated Cloudflare output path ${JSON.stringify(reservedDestination)}.`);
+    return {
+        from,
+        to,
+        index
+    };
+};
+const getCloudflareArtifacts = (modernConfig)=>(modernConfig.deploy?.worker?.artifacts ?? []).map(normalizeCloudflareArtifact);
+const normalizeCloudflarePublicAsset = (asset, index)=>{
+    const from = (0, external_utils_js_namespaceObject.normalizeRelativePath)(asset.from, `deploy.worker.publicAssets[${index}].from`, 'app root');
+    const to = (0, external_utils_js_namespaceObject.normalizeRelativePath)(asset.to, `deploy.worker.publicAssets[${index}].to`, 'Cloudflare public output', {
+        allowRoot: true
+    });
+    return {
+        from,
+        to,
+        index
+    };
+};
+const getCloudflarePublicAssets = (modernConfig)=>(modernConfig.deploy?.worker?.publicAssets ?? []).map(normalizeCloudflarePublicAsset);
+const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)=>{
+    for (const artifact of artifacts){
+        const sourcePath = external_node_path_default().join(appDirectory, artifact.from);
+        if (!await utils_namespaceObject.fs.pathExists(sourcePath)) throw new Error(`deploy.worker.artifacts[${artifact.index}].from does not exist: ${artifact.from}`);
+        await utils_namespaceObject.fs.copy(sourcePath, external_node_path_default().join(outputDirectory, artifact.to));
+    }
+};
+const copyCloudflarePublicAssets = async (appDirectory, publicDirectory, publicAssets)=>{
+    for (const asset of publicAssets){
+        const sourcePath = external_node_path_default().join(appDirectory, asset.from);
+        if (!await utils_namespaceObject.fs.pathExists(sourcePath)) throw new Error(`deploy.worker.publicAssets[${asset.index}].from does not exist: ${asset.from}`);
+        await utils_namespaceObject.fs.copy(sourcePath, external_node_path_default().join(publicDirectory, asset.to));
+    }
+};
+const copyCloudflareD1Migrations = async (appDirectory, outputDirectory, modernConfig)=>{
+    for (const [index, database] of (modernConfig.deploy?.worker?.d1Databases ?? []).entries()){
+        if (!database.migrationsDir) continue;
+        const migrationsDir = (0, external_utils_js_namespaceObject.normalizeRelativePath)(database.migrationsDir, `deploy.worker.d1Databases[${index}].migrationsDir`, 'app root');
+        const sourcePath = external_node_path_default().join(appDirectory, migrationsDir);
+        if (!await utils_namespaceObject.fs.pathExists(sourcePath)) throw new Error(`deploy.worker.d1Databases[${index}].migrationsDir does not exist: ${migrationsDir}`);
+        await utils_namespaceObject.fs.copy(sourcePath, external_node_path_default().join(outputDirectory, migrationsDir));
+    }
+};
+const readRouteSpec = async (outputDirectory)=>{
+    const routeSpecPath = external_node_path_default().join(outputDirectory, external_constants_js_namespaceObject.ROUTE_SPEC_OUTPUT);
+    if (!await utils_namespaceObject.fs.pathExists(routeSpecPath)) return {
+        routes: []
+    };
+    const routeSpec = await utils_namespaceObject.fs.readJSON(routeSpecPath);
+    return {
+        ...routeSpec,
+        routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : []
+    };
+};
+exports.copyCloudflareArtifacts = __webpack_exports__.copyCloudflareArtifacts;
+exports.copyCloudflareD1Migrations = __webpack_exports__.copyCloudflareD1Migrations;
+exports.copyCloudflarePublicAssets = __webpack_exports__.copyCloudflarePublicAssets;
+exports.getCloudflareArtifacts = __webpack_exports__.getCloudflareArtifacts;
+exports.getCloudflarePublicAssets = __webpack_exports__.getCloudflarePublicAssets;
+exports.readRouteSpec = __webpack_exports__.readRouteSpec;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "copyCloudflareArtifacts",
+    "copyCloudflareD1Migrations",
+    "copyCloudflarePublicAssets",
+    "getCloudflareArtifacts",
+    "getCloudflarePublicAssets",
+    "readRouteSpec"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cloudflare/constants.js

@@ -0,0 +1,141 @@
+"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__, {
+    ASSETS_BINDING: ()=>ASSETS_BINDING,
+    BFF_EFFECT_WORKER_DISPATCHER_EXPORT: ()=>BFF_EFFECT_WORKER_DISPATCHER_EXPORT,
+    BFF_EFFECT_WORKER_ENTRY: ()=>BFF_EFFECT_WORKER_ENTRY,
+    CLOUDFLARE_RUNTIME_TYPE: ()=>external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_RUNTIME_TYPE,
+    CLOUDFLARE_WORKER_BUNDLE_FORMAT: ()=>external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_FORMAT,
+    COMPATIBILITY_DATE_PATTERN: ()=>COMPATIBILITY_DATE_PATTERN,
+    DEFAULT_COMPATIBILITY_DATE: ()=>DEFAULT_COMPATIBILITY_DATE,
+    DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES: ()=>DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES,
+    EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE: ()=>EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE,
+    LOADABLE_STATS_FILE: ()=>LOADABLE_STATS_FILE,
+    OUTPUT_PACKAGE_FILE: ()=>OUTPUT_PACKAGE_FILE,
+    PUBLIC_ASSETS_DIRECTORY: ()=>PUBLIC_ASSETS_DIRECTORY,
+    REQUIRED_COMPATIBILITY_FLAGS: ()=>REQUIRED_COMPATIBILITY_FLAGS,
+    RESERVED_ARTIFACT_DESTINATION_DIRECTORIES: ()=>RESERVED_ARTIFACT_DESTINATION_DIRECTORIES,
+    RESERVED_ARTIFACT_DESTINATION_FILES: ()=>RESERVED_ARTIFACT_DESTINATION_FILES,
+    ROUTE_MANIFEST_FILE: ()=>ROUTE_MANIFEST_FILE,
+    ROUTE_SPEC_FILE: ()=>ROUTE_SPEC_FILE,
+    ROUTE_SPEC_OUTPUT: ()=>ROUTE_SPEC_OUTPUT,
+    SERVER_BUNDLE_DIRECTORY: ()=>SERVER_BUNDLE_DIRECTORY,
+    SERVER_OUTPUT_DIRECTORY: ()=>SERVER_OUTPUT_DIRECTORY,
+    WORKER_BUNDLE_DIRECTORY: ()=>WORKER_BUNDLE_DIRECTORY,
+    WORKER_ENTRY: ()=>WORKER_ENTRY,
+    WORKER_MANIFEST: ()=>WORKER_MANIFEST,
+    WRANGLER_CONFIG_FILE: ()=>WRANGLER_CONFIG_FILE
+});
+const external_cloudflare_output_contract_js_namespaceObject = require("../cloudflare-output-contract.js");
+const WORKER_ENTRY = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY;
+const WORKER_MANIFEST = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_MANIFEST;
+const WRANGLER_CONFIG_FILE = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WRANGLER_CONFIG_FILE;
+const OUTPUT_PACKAGE_FILE = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_OUTPUT_PACKAGE_FILE;
+const ASSETS_BINDING = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_ASSETS_BINDING;
+const ROUTE_SPEC_FILE = 'route.json';
+const ROUTE_SPEC_OUTPUT = `server/${ROUTE_SPEC_FILE}`;
+const LOADABLE_STATS_FILE = 'loadable-stats.json';
+const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
+const PUBLIC_ASSETS_DIRECTORY = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
+const WORKER_BUNDLE_DIRECTORY = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
+const SERVER_BUNDLE_DIRECTORY = 'bundles';
+const SERVER_OUTPUT_DIRECTORY = 'server';
+const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = [
+    'api',
+    'shared'
+];
+const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
+const BFF_EFFECT_WORKER_DISPATCHER_EXPORT = '__modern_create_effect_bff_dispatcher';
+const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = 'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.';
+const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
+const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+const REQUIRED_COMPATIBILITY_FLAGS = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+const RESERVED_ARTIFACT_DESTINATION_FILES = new Set([
+    WRANGLER_CONFIG_FILE,
+    OUTPUT_PACKAGE_FILE
+]);
+const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES = new Set([
+    PUBLIC_ASSETS_DIRECTORY,
+    SERVER_OUTPUT_DIRECTORY,
+    WORKER_BUNDLE_DIRECTORY
+]);
+exports.ASSETS_BINDING = __webpack_exports__.ASSETS_BINDING;
+exports.BFF_EFFECT_WORKER_DISPATCHER_EXPORT = __webpack_exports__.BFF_EFFECT_WORKER_DISPATCHER_EXPORT;
+exports.BFF_EFFECT_WORKER_ENTRY = __webpack_exports__.BFF_EFFECT_WORKER_ENTRY;
+exports.CLOUDFLARE_RUNTIME_TYPE = __webpack_exports__.CLOUDFLARE_RUNTIME_TYPE;
+exports.CLOUDFLARE_WORKER_BUNDLE_FORMAT = __webpack_exports__.CLOUDFLARE_WORKER_BUNDLE_FORMAT;
+exports.COMPATIBILITY_DATE_PATTERN = __webpack_exports__.COMPATIBILITY_DATE_PATTERN;
+exports.DEFAULT_COMPATIBILITY_DATE = __webpack_exports__.DEFAULT_COMPATIBILITY_DATE;
+exports.DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = __webpack_exports__.DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES;
+exports.EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = __webpack_exports__.EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE;
+exports.LOADABLE_STATS_FILE = __webpack_exports__.LOADABLE_STATS_FILE;
+exports.OUTPUT_PACKAGE_FILE = __webpack_exports__.OUTPUT_PACKAGE_FILE;
+exports.PUBLIC_ASSETS_DIRECTORY = __webpack_exports__.PUBLIC_ASSETS_DIRECTORY;
+exports.REQUIRED_COMPATIBILITY_FLAGS = __webpack_exports__.REQUIRED_COMPATIBILITY_FLAGS;
+exports.RESERVED_ARTIFACT_DESTINATION_DIRECTORIES = __webpack_exports__.RESERVED_ARTIFACT_DESTINATION_DIRECTORIES;
+exports.RESERVED_ARTIFACT_DESTINATION_FILES = __webpack_exports__.RESERVED_ARTIFACT_DESTINATION_FILES;
+exports.ROUTE_MANIFEST_FILE = __webpack_exports__.ROUTE_MANIFEST_FILE;
+exports.ROUTE_SPEC_FILE = __webpack_exports__.ROUTE_SPEC_FILE;
+exports.ROUTE_SPEC_OUTPUT = __webpack_exports__.ROUTE_SPEC_OUTPUT;
+exports.SERVER_BUNDLE_DIRECTORY = __webpack_exports__.SERVER_BUNDLE_DIRECTORY;
+exports.SERVER_OUTPUT_DIRECTORY = __webpack_exports__.SERVER_OUTPUT_DIRECTORY;
+exports.WORKER_BUNDLE_DIRECTORY = __webpack_exports__.WORKER_BUNDLE_DIRECTORY;
+exports.WORKER_ENTRY = __webpack_exports__.WORKER_ENTRY;
+exports.WORKER_MANIFEST = __webpack_exports__.WORKER_MANIFEST;
+exports.WRANGLER_CONFIG_FILE = __webpack_exports__.WRANGLER_CONFIG_FILE;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ASSETS_BINDING",
+    "BFF_EFFECT_WORKER_DISPATCHER_EXPORT",
+    "BFF_EFFECT_WORKER_ENTRY",
+    "CLOUDFLARE_RUNTIME_TYPE",
+    "CLOUDFLARE_WORKER_BUNDLE_FORMAT",
+    "COMPATIBILITY_DATE_PATTERN",
+    "DEFAULT_COMPATIBILITY_DATE",
+    "DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES",
+    "EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE",
+    "LOADABLE_STATS_FILE",
+    "OUTPUT_PACKAGE_FILE",
+    "PUBLIC_ASSETS_DIRECTORY",
+    "REQUIRED_COMPATIBILITY_FLAGS",
+    "RESERVED_ARTIFACT_DESTINATION_DIRECTORIES",
+    "RESERVED_ARTIFACT_DESTINATION_FILES",
+    "ROUTE_MANIFEST_FILE",
+    "ROUTE_SPEC_FILE",
+    "ROUTE_SPEC_OUTPUT",
+    "SERVER_BUNDLE_DIRECTORY",
+    "SERVER_OUTPUT_DIRECTORY",
+    "WORKER_BUNDLE_DIRECTORY",
+    "WORKER_ENTRY",
+    "WORKER_MANIFEST",
+    "WRANGLER_CONFIG_FILE"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cloudflare/delivery-unit.js

@@ -0,0 +1,161 @@
+"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__, {
+    resolveTopologyDeliveryUnit: ()=>resolveTopologyDeliveryUnit,
+    resolveWorkerDeliveryUnitStamp: ()=>resolveWorkerDeliveryUnitStamp
+});
+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 universal_namespaceObject = require("@modern-js/utils/universal");
+const external_release_identity_js_namespaceObject = require("../release-identity.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const findWorkspaceRoot = async (appDirectory)=>{
+    let current = external_node_path_default().resolve(appDirectory);
+    for(;;){
+        if (await utils_namespaceObject.fs.pathExists(external_node_path_default().join(current, COMPACT_CONFIG_PATH))) return current;
+        const parent = external_node_path_default().dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+};
+const stampReleaseIdentity = (identity, workspaceRoot)=>{
+    if ('workspace' !== identity.sourceRevision) return identity;
+    return {
+        ...identity,
+        ...(0, external_release_identity_js_namespaceObject.resolveUltramodernReleaseIdentity)({
+            generationBuildMarker: identity.buildMarker,
+            unitId: identity.unitId,
+            workspaceRoot
+        })
+    };
+};
+const resolveCompactApp = async (appDirectory)=>{
+    const workspaceRoot = await findWorkspaceRoot(appDirectory);
+    if (!workspaceRoot) return;
+    let compactConfig;
+    try {
+        compactConfig = await utils_namespaceObject.fs.readJSON(external_node_path_default().join(workspaceRoot, COMPACT_CONFIG_PATH));
+    } catch  {
+        return {
+            workspaceRoot
+        };
+    }
+    if (!(0, external_utils_js_namespaceObject.isRecord)(compactConfig)) return {
+        workspaceRoot
+    };
+    const topology = (0, external_utils_js_namespaceObject.isRecord)(compactConfig.topology) ? compactConfig.topology : void 0;
+    const apps = Array.isArray(topology?.apps) ? topology.apps : void 0;
+    if (!apps) return {
+        app: compactConfig,
+        workspaceRoot
+    };
+    const resolvedAppDirectory = external_node_path_default().resolve(appDirectory);
+    const app = apps.find((candidate)=>{
+        if (!(0, external_utils_js_namespaceObject.isRecord)(candidate)) return false;
+        const appPath = (0, universal_namespaceObject.nonEmptyString)(candidate.path);
+        return void 0 !== appPath && external_node_path_default().resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory;
+    });
+    return {
+        ...(0, external_utils_js_namespaceObject.isRecord)(app) ? {
+            app
+        } : {},
+        workspaceRoot
+    };
+};
+const createDeliveryUnitStamp = (identity, app)=>{
+    const surfaceProfile = (0, universal_namespaceObject.nonEmptyString)(app?.surfaceProfile);
+    const emitsUi = 'api-only' !== surfaceProfile;
+    const emitsApi = 'ui-only' !== surfaceProfile;
+    return {
+        ...identity,
+        surfaces: {
+            ...emitsUi ? {
+                ui: {
+                    ...identity,
+                    surface: 'ui'
+                }
+            } : {},
+            ...emitsApi ? {
+                api: {
+                    ...identity,
+                    surface: 'api'
+                }
+            } : {}
+        }
+    };
+};
+const resolveTopologyDeliveryUnit = async (appDirectory)=>{
+    const resolved = await resolveCompactApp(appDirectory);
+    if (!resolved?.app) return;
+    const identity = (0, universal_namespaceObject.toDeliveryUnitIdentity)(resolved.app.deliveryUnit);
+    return identity ? createDeliveryUnitStamp(stampReleaseIdentity(identity, resolved.workspaceRoot), resolved.app) : void 0;
+};
+const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
+    const buildArtifactPath = external_node_path_default().join(appDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_PATH);
+    const buildModulePath = external_node_path_default().join(appDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_MODULE_PATH);
+    let identity;
+    if (await utils_namespaceObject.fs.pathExists(buildArtifactPath)) {
+        const artifact = await utils_namespaceObject.fs.readJSON(buildArtifactPath);
+        if (!(0, universal_namespaceObject.isUltramodernBuildArtifact)(artifact)) return;
+        identity = (0, universal_namespaceObject.toDeliveryUnitIdentity)(artifact.deliveryUnit);
+    } else if (await utils_namespaceObject.fs.pathExists(buildModulePath)) {
+        console.warn(`[cloudflare] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ultramodern-build.json.`);
+        const source = await utils_namespaceObject.fs.readFile(buildModulePath, 'utf8');
+        identity = (0, universal_namespaceObject.toDeliveryUnitIdentity)({
+            buildMarker: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
+            unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
+            sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1]
+        });
+    }
+    if (!identity) return;
+    const resolved = await resolveCompactApp(appDirectory);
+    if (resolved) identity = stampReleaseIdentity(identity, resolved.workspaceRoot);
+    return createDeliveryUnitStamp(identity, resolved?.app);
+};
+exports.resolveTopologyDeliveryUnit = __webpack_exports__.resolveTopologyDeliveryUnit;
+exports.resolveWorkerDeliveryUnitStamp = __webpack_exports__.resolveWorkerDeliveryUnitStamp;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveTopologyDeliveryUnit",
+    "resolveWorkerDeliveryUnitStamp"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cloudflare/i18n-worker.js

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