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

package/dist/cjs/templates/cloudflare-worker-loadable-server.mjs

@@ -0,0 +1,281 @@
+import loadableComponent from '@loadable/component';
+import React from 'react';
+
+const internals =
+  loadableComponent?.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED || {};
+const LoadableContext = internals.Context || React.createContext(null);
+const getRequiredChunkKey =
+  internals.getRequiredChunkKey ||
+  (namespace => `${namespace}__LOADABLE_REQUIRED_CHUNKS__`);
+
+const scriptExtensions = new Set(['.js', '.mjs']);
+const styleExtensions = new Set(['.css']);
+
+function uniqByUrl(assets) {
+  const seen = new Set();
+
+  return assets.filter(asset => {
+    if (seen.has(asset.url)) {
+      return false;
+    }
+
+    seen.add(asset.url);
+    return true;
+  });
+}
+
+function extname(filePath) {
+  const basename = String(filePath).split('/').pop() || '';
+  const index = basename.lastIndexOf('.');
+
+  return index > 0 ? basename.slice(index) : '';
+}
+
+function isAutomaticPublicPath(publicPath) {
+  return publicPath === 'auto' || publicPath === 'auto/';
+}
+
+function joinUrl(publicPath, filename) {
+  const base =
+    !publicPath || isAutomaticPublicPath(publicPath) ? '/' : publicPath;
+
+  return `${base.replace(/\/+$/u, '')}/${String(filename).replace(/^\/+/u, '')}`;
+}
+
+function extraPropsToString(extraProps = {}) {
+  return Object.entries(extraProps)
+    .filter(([, value]) => value !== undefined && value !== false)
+    .map(([key, value]) => (value === true ? ` ${key}` : ` ${key}="${value}"`))
+    .join('');
+}
+
+function assetScriptType(filename) {
+  const extension = extname(filename);
+
+  if (scriptExtensions.has(extension)) {
+    return 'script';
+  }
+
+  if (styleExtensions.has(extension)) {
+    return 'style';
+  }
+}
+
+function getAssetName(asset) {
+  return typeof asset === 'object' && asset?.name ? asset.name : asset;
+}
+
+function getAssetIntegrity(asset) {
+  return typeof asset === 'object' && asset?.integrity ? asset.integrity : null;
+}
+
+function getChunkGroupAssets(chunkGroup) {
+  const assets = chunkGroup?.assets;
+
+  if (Array.isArray(assets)) {
+    return assets;
+  }
+
+  if (assets && typeof assets === 'object') {
+    return [...(assets.js || []), ...(assets.css || [])];
+  }
+
+  return [];
+}
+
+function getChunkGroupChildAssets(chunkGroup, type) {
+  const childAssets = chunkGroup?.childAssets?.[type];
+
+  return Array.isArray(childAssets) ? childAssets : [];
+}
+
+function chunkIncludesJs(chunkInfo) {
+  return (chunkInfo?.files || []).some(file =>
+    scriptExtensions.has(extname(file)),
+  );
+}
+
+export function ChunkExtractorManager({ extractor, children }) {
+  return React.createElement(
+    LoadableContext.Provider,
+    { value: extractor },
+    children,
+  );
+}
+
+export class ChunkExtractor {
+  constructor({
+    stats,
+    entrypoints = ['main'],
+    namespace = '',
+    outputPath = '/',
+    publicPath,
+  } = {}) {
+    this.namespace = namespace;
+    this.stats = stats || {};
+    const configuredPublicPath = publicPath || this.stats.publicPath;
+    this.publicPath =
+      !configuredPublicPath || isAutomaticPublicPath(configuredPublicPath)
+        ? '/'
+        : configuredPublicPath;
+    this.outputPath = outputPath || this.stats.outputPath || '/';
+    this.entrypoints = Array.isArray(entrypoints) ? entrypoints : [entrypoints];
+    this.chunks = [];
+  }
+
+  addChunk(chunk) {
+    if (!this.chunks.includes(chunk)) {
+      this.chunks.push(chunk);
+    }
+  }
+
+  collectChunks(app) {
+    return React.createElement(ChunkExtractorManager, { extractor: this }, app);
+  }
+
+  getChunkGroup(chunk) {
+    return (
+      this.stats.namedChunkGroups?.[chunk] || {
+        assets: [],
+        childAssets: {},
+        chunks: [],
+      }
+    );
+  }
+
+  getChunkInfo(chunkId) {
+    return (this.stats.chunks || []).find(chunk => chunk.id === chunkId);
+  }
+
+  resolvePublicUrl(filename) {
+    return joinUrl(this.publicPath, filename);
+  }
+
+  createChunkAsset({ filename, chunk, type, linkType }) {
+    const resolvedFilename = getAssetName(filename);
+    const scriptType = assetScriptType(resolvedFilename);
+
+    if (!scriptType) {
+      return undefined;
+    }
+
+    return {
+      filename: resolvedFilename,
+      integrity: getAssetIntegrity(filename),
+      scriptType,
+      chunk,
+      url: this.resolvePublicUrl(resolvedFilename),
+      path: String(resolvedFilename).replace(/^\/+/u, ''),
+      type,
+      linkType,
+    };
+  }
+
+  getChunkAssets(chunks) {
+    const one = chunk =>
+      getChunkGroupAssets(this.getChunkGroup(chunk))
+        .map(filename =>
+          this.createChunkAsset({
+            filename,
+            chunk,
+            type: 'mainAsset',
+            linkType: 'preload',
+          }),
+        )
+        .filter(Boolean);
+
+    return Array.isArray(chunks) ? uniqByUrl(chunks.flatMap(one)) : one(chunks);
+  }
+
+  getChunkChildAssets(chunks, type) {
+    const one = chunk =>
+      getChunkGroupChildAssets(this.getChunkGroup(chunk), type)
+        .map(filename =>
+          this.createChunkAsset({
+            filename,
+            chunk,
+            type: 'childAsset',
+            linkType: type,
+          }),
+        )
+        .filter(Boolean);
+
+    return Array.isArray(chunks) ? uniqByUrl(chunks.flatMap(one)) : one(chunks);
+  }
+
+  getChunkDependencies(chunks) {
+    const one = chunk =>
+      (this.getChunkGroup(chunk).chunks || []).filter(chunkId =>
+        chunkIncludesJs(this.getChunkInfo(chunkId)),
+      );
+
+    return Array.isArray(chunks)
+      ? [...new Set(chunks.flatMap(one))]
+      : one(chunks);
+  }
+
+  getRequiredChunksScriptContent() {
+    return JSON.stringify(this.getChunkDependencies(this.chunks));
+  }
+
+  getRequiredChunksNamesScriptContent() {
+    return JSON.stringify({ namedChunks: this.chunks });
+  }
+
+  getRequiredChunksScriptTag(extraProps = {}) {
+    const id = getRequiredChunkKey(this.namespace);
+    const props = `type="application/json"${extraPropsToString(extraProps)}`;
+
+    return [
+      `<script id="${id}" ${props}>${this.getRequiredChunksScriptContent()}</script>`,
+      `<script id="${id}_ext" ${props}>${this.getRequiredChunksNamesScriptContent()}</script>`,
+    ].join('');
+  }
+
+  getMainAssets(scriptType) {
+    const assets = this.getChunkAssets([...this.entrypoints, ...this.chunks]);
+
+    return scriptType
+      ? assets.filter(asset => asset.scriptType === scriptType)
+      : assets;
+  }
+
+  getScriptTags(extraProps = {}) {
+    const scripts = this.getMainAssets('script').map(
+      asset =>
+        `<script async data-chunk="${asset.chunk}" src="${asset.url}"${extraPropsToString(extraProps)}></script>`,
+    );
+
+    return [this.getRequiredChunksScriptTag(extraProps), ...scripts].join('');
+  }
+
+  getStyleTags(extraProps = {}) {
+    return this.getMainAssets('style')
+      .map(
+        asset =>
+          `<link data-chunk="${asset.chunk}" rel="stylesheet" href="${asset.url}"${extraPropsToString(extraProps)}>`,
+      )
+      .join('');
+  }
+
+  getLinkTags(extraProps = {}) {
+    const assets = [
+      ...this.getMainAssets(),
+      ...this.getChunkChildAssets(
+        [...this.entrypoints, ...this.chunks],
+        'preload',
+      ),
+      ...this.getChunkChildAssets(
+        [...this.entrypoints, ...this.chunks],
+        'prefetch',
+      ),
+    ];
+
+    return uniqByUrl(assets)
+      .map(
+        asset =>
+          `<link data-chunk="${asset.chunk}" rel="${asset.linkType}" as="${asset.scriptType}" href="${asset.url}"${extraPropsToString(extraProps)}>`,
+      )
+      .join('');
+  }
+}

package/dist/cjs/templates/cloudflare-worker-mf-ssr-runtime-plugin.mjs

@@ -0,0 +1,14 @@
+/**
+ * Workerd cannot initialize Module Federation's Node-oriented SSR data-fetch
+ * runtime. Cloudflare workers do not load native MF remotes, so retain the
+ * runtime-plugin contract without installing its server data-fetch hooks.
+ */
+export const injectDataFetchFunctionPlugin = () => ({
+  name: '@module-federation/inject-data-fetch-function-plugin',
+  setup() {},
+});
+
+export const mfSSRDevPlugin = () => ({
+  name: '@module-federation/modern-js-v3',
+  setup() {},
+});

package/dist/cjs/templates/cloudflare-worker-path.mjs

@@ -0,0 +1,98 @@
+const trimSlashes = value => String(value).replace(/^\/+|\/+$/gu, '');
+const normalizeSeparators = value => String(value).replace(/\\+/gu, '/');
+
+export const sep = '/';
+export const delimiter = ':';
+
+export function isAbsolute(filePath) {
+  return normalizeSeparators(filePath).startsWith('/');
+}
+
+export function normalize(filePath) {
+  const normalized = normalizeSeparators(filePath);
+  const absolute = isAbsolute(normalized);
+  const parts = [];
+
+  for (const part of normalized.split('/')) {
+    if (!part || part === '.') {
+      continue;
+    }
+
+    if (part === '..') {
+      if (parts.length > 0 && parts[parts.length - 1] !== '..') {
+        parts.pop();
+      } else if (!absolute) {
+        parts.push(part);
+      }
+      continue;
+    }
+
+    parts.push(part);
+  }
+
+  const joined = parts.join('/');
+
+  if (absolute) {
+    return joined ? `/${joined}` : '/';
+  }
+
+  return joined || '.';
+}
+
+export function join(...segments) {
+  const joined = segments
+    .map(normalizeSeparators)
+    .filter(Boolean)
+    .map((segment, index) => (index === 0 ? segment : trimSlashes(segment)))
+    .filter(Boolean)
+    .join('/');
+
+  return joined ? normalize(joined) : '.';
+}
+
+export function resolve(...segments) {
+  const joined = join(...segments);
+
+  return joined.startsWith('/') ? joined : `/${joined}`;
+}
+
+export function dirname(filePath) {
+  const normalized = normalizeSeparators(filePath).replace(/\/+$/u, '');
+  const index = normalized.lastIndexOf('/');
+
+  if (index <= 0) {
+    return '/';
+  }
+
+  return normalized.slice(0, index);
+}
+
+export function basename(filePath, suffix = '') {
+  const normalized = normalizeSeparators(filePath).replace(/\/+$/u, '');
+  const base = normalized.slice(normalized.lastIndexOf('/') + 1);
+
+  return suffix && base.endsWith(suffix) ? base.slice(0, -suffix.length) : base;
+}
+
+export function extname(filePath) {
+  const base = basename(filePath);
+  const index = base.lastIndexOf('.');
+
+  if (index <= 0) {
+    return '';
+  }
+
+  return base.slice(index);
+}
+
+export default {
+  basename,
+  delimiter,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  normalize,
+  resolve,
+  sep,
+};

package/dist/esm/cloudflare/artifacts.mjs

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

package/dist/esm/cloudflare/constants.mjs

@@ -0,0 +1,34 @@
+import { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_FILE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_BUNDLE_FORMAT, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_MANIFEST, CLOUDFLARE_WRANGLER_CONFIG_FILE } from "../cloudflare-output-contract.mjs";
+const WORKER_ENTRY = CLOUDFLARE_WORKER_ENTRY;
+const WORKER_MANIFEST = CLOUDFLARE_WORKER_MANIFEST;
+const WRANGLER_CONFIG_FILE = CLOUDFLARE_WRANGLER_CONFIG_FILE;
+const OUTPUT_PACKAGE_FILE = CLOUDFLARE_OUTPUT_PACKAGE_FILE;
+const ASSETS_BINDING = CLOUDFLARE_ASSETS_BINDING;
+const ROUTE_SPEC_FILE = 'route.json';
+const ROUTE_SPEC_OUTPUT = `server/${ROUTE_SPEC_FILE}`;
+const LOADABLE_STATS_FILE = 'loadable-stats.json';
+const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
+const PUBLIC_ASSETS_DIRECTORY = CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
+const WORKER_BUNDLE_DIRECTORY = CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
+const SERVER_BUNDLE_DIRECTORY = 'bundles';
+const SERVER_OUTPUT_DIRECTORY = 'server';
+const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = [
+    'api',
+    'shared'
+];
+const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
+const BFF_EFFECT_WORKER_DISPATCHER_EXPORT = '__modern_create_effect_bff_dispatcher';
+const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = 'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.';
+const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
+const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+const REQUIRED_COMPATIBILITY_FLAGS = CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+const RESERVED_ARTIFACT_DESTINATION_FILES = new Set([
+    WRANGLER_CONFIG_FILE,
+    OUTPUT_PACKAGE_FILE
+]);
+const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES = new Set([
+    PUBLIC_ASSETS_DIRECTORY,
+    SERVER_OUTPUT_DIRECTORY,
+    WORKER_BUNDLE_DIRECTORY
+]);
+export { ASSETS_BINDING, BFF_EFFECT_WORKER_DISPATCHER_EXPORT, BFF_EFFECT_WORKER_ENTRY, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT, COMPATIBILITY_DATE_PATTERN, DEFAULT_COMPATIBILITY_DATE, DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES, EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE, LOADABLE_STATS_FILE, OUTPUT_PACKAGE_FILE, PUBLIC_ASSETS_DIRECTORY, REQUIRED_COMPATIBILITY_FLAGS, RESERVED_ARTIFACT_DESTINATION_DIRECTORIES, RESERVED_ARTIFACT_DESTINATION_FILES, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, ROUTE_SPEC_OUTPUT, SERVER_BUNDLE_DIRECTORY, SERVER_OUTPUT_DIRECTORY, WORKER_BUNDLE_DIRECTORY, WORKER_ENTRY, WORKER_MANIFEST, WRANGLER_CONFIG_FILE };

package/dist/esm/cloudflare/delivery-unit.mjs

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