@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/dist/esm/build-config/build-environment.mjs

@@ -1,147 +1,28 @@
-import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { accessSync, chmodSync, constants, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
+import { createRequire, findPackageJSON } from "node:module";
 import { tmpdir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
-const EFFECT_TSGO_PACKAGE = '@effect/tsgo';
-const EFFECT_TSGO_BIN = 'effect-tsgo';
-const EFFECT_TSGO_RESOLUTION_ERROR = 'Unable to resolve the Effect TS-Go compiler. Install "@effect/tsgo" and a native TypeScript backend for this build config, or set EFFECT_TSGO_BIN.';
+import { basename, join } from "node:path";
+import "node:url";
+const owningModuleUrl = import.meta.url;
+const owningManifest = findPackageJSON(owningModuleUrl, owningModuleUrl);
+if (!owningManifest) throw new Error('Cannot find owning build-config package manifest');
+const owningName = JSON.parse(readFileSync(owningManifest, 'utf8')).name;
+if ('string' != typeof owningName || 0 === owningName.length) throw new Error(`Invalid owning build-config package name: ${owningManifest}`);
+const { effectCompilerDiscoveryFailureStage: effectCompilerDiscoveryFailureStage, resolveInstalledEffectCompiler: resolveInstalledEffectCompiler, validateConfiguredEffectCompiler: validateConfiguredEffectCompiler } = createRequire(owningModuleUrl)(`${owningName}/internal-effect-discovery`);
+const EFFECT_TSGO_RESOLUTION_ERROR = 'Unable to resolve the Effect TS-Go compiler. Install "@effect/tsgo" and a native TypeScript backend for this build config, or set EFFECT_TSGO_BIN. Bundled tsrs requires matching installed tsrs metadata.';
 const executableEffectTsgoCompilers = new Map();
-const BUILD_CONFIG_ENVIRONMENT_PLUGIN = 'ModernJsBuildConfigEnvironmentLeasePlugin';
-const ENVIRONMENT_LEASE_REGISTRY_KEY = Symbol.for('@modern-js/app-tools/build-config-environment-lease-registry/v1');
-const ENVIRONMENT_LEASE_REGISTRY_BRAND = Symbol.for('@modern-js/app-tools/build-config-environment-lease-registry-brand/v1');
-const LIFECYCLE_HOOK_NAMES = [
-    'run',
-    'watchRun',
-    'afterDone',
-    'failed',
-    'shutdown',
-    'watchClose'
-];
-function restoreEnvironment(name, value) {
-    if (void 0 === value) delete process.env[name];
-    else process.env[name] = value;
-}
-function createEnvironmentLeaseRegistry() {
-    const environmentLeases = new Map();
-    return Object.freeze({
-        acquire (name, value) {
-            let lease = environmentLeases.get(name);
-            if (lease) {
-                if (lease.value !== value) throw new Error(`Build config environment "${name}" already has an active lease for a different value.`);
-                if (process.env[name] !== lease.value) throw new Error(`Build config environment lease for "${name}" lost ownership before another lease was acquired.`);
-            } else {
-                lease = {
-                    originalValue: process.env[name],
-                    owners: new Set(),
-                    value
-                };
-                process.env[name] = value;
-                environmentLeases.set(name, lease);
-            }
-            const owner = Symbol(name);
-            lease.owners.add(owner);
-            let released = false;
-            return ()=>{
-                if (released) return;
-                if (environmentLeases.get(name) !== lease || !lease.owners.has(owner)) throw new Error(`Build config environment lease for "${name}" cannot be restored because its ownership record was lost.`);
-                released = true;
-                const lostOwnership = process.env[name] !== lease.value;
-                lease.owners.delete(owner);
-                if (0 === lease.owners.size) {
-                    environmentLeases.delete(name);
-                    restoreEnvironment(name, lease.originalValue);
-                } else if (lostOwnership) process.env[name] = lease.value;
-                if (lostOwnership) throw new Error(`Build config environment lease for "${name}" lost ownership before restoration.`);
-            };
-        },
-        brand: ENVIRONMENT_LEASE_REGISTRY_BRAND
-    });
-}
-function getEnvironmentLeaseRegistry() {
-    const descriptor = Object.getOwnPropertyDescriptor(process, ENVIRONMENT_LEASE_REGISTRY_KEY);
-    if (descriptor) {
-        const registry = descriptor.value;
-        if (descriptor.configurable || descriptor.enumerable || descriptor.writable || registry?.brand !== ENVIRONMENT_LEASE_REGISTRY_BRAND || 'function' != typeof registry.acquire) throw new Error('The process-global build config environment lease registry is occupied by an incompatible value.');
-        return registry;
-    }
-    const registry = createEnvironmentLeaseRegistry();
-    Object.defineProperty(process, ENVIRONMENT_LEASE_REGISTRY_KEY, {
-        configurable: false,
-        enumerable: false,
-        value: registry,
-        writable: false
+function effectTsgoResolutionError(cause, stage, from) {
+    const detail = cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause);
+    return new Error(`${EFFECT_TSGO_RESOLUTION_ERROR}\n${stage} failed for ${String(from)}: ${detail}`, {
+        cause
     });
-    return registry;
-}
-function acquireEnvironmentLease(name, value) {
-    return getEnvironmentLeaseRegistry().acquire(name, value);
-}
-function releaseAfterFailure(release, originalError) {
-    try {
-        release();
-    } catch (restorationError) {
-        throw new AggregateError([
-            originalError,
-            restorationError
-        ], 'Build config environment setup and restoration both failed.');
-    }
-    throw originalError;
-}
-class BuildConfigEnvironmentLeasePlugin {
-    apply(compiler) {
-        const hooks = compiler.hooks;
-        try {
-            const lifecycleHooks = {};
-            for (const hookName of LIFECYCLE_HOOK_NAMES){
-                const hook = hooks[hookName];
-                if (!hook || 'function' != typeof hook.tap) throw new Error(`Rspack does not expose the "${hookName}" lifecycle hook required to restore build config environment leases.`);
-                lifecycleHooks[hookName] = hook;
-            }
-            let mode = 'pending';
-            const modeTap = {
-                name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
-                stage: Number.MIN_SAFE_INTEGER
-            };
-            const releaseTap = {
-                name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
-                stage: Number.MAX_SAFE_INTEGER
-            };
-            const releaseAfterOneShot = ()=>{
-                if ('watch' !== mode && true !== compiler.watchMode) this.release();
-            };
-            lifecycleHooks.run.tap(modeTap, ()=>{
-                mode = 'run';
-            });
-            lifecycleHooks.watchRun.tap(modeTap, ()=>{
-                mode = 'watch';
-            });
-            lifecycleHooks.afterDone.tap(releaseTap, releaseAfterOneShot);
-            lifecycleHooks.failed.tap(releaseTap, releaseAfterOneShot);
-            lifecycleHooks.shutdown.tap(releaseTap, this.release);
-            lifecycleHooks.watchClose.tap(releaseTap, this.release);
-        } catch (error) {
-            releaseAfterFailure(this.release, error);
-        }
-    }
-    constructor(release){
-        this.release = release;
-    }
-}
-function resolveEffectTsgoCli(from) {
-    const projectRequire = createRequire(from);
-    const packageJsonPath = projectRequire.resolve(`${EFFECT_TSGO_PACKAGE}/package.json`);
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-    const bin = 'string' == typeof packageJson.bin ? packageJson.bin : packageJson.bin?.[EFFECT_TSGO_BIN];
-    if (!bin) throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
-    return resolve(dirname(packageJsonPath), bin);
 }
 function resolveExecutableEffectTsgoCompiler(compilerPath) {
-    if ('win32' === process.platform) return compilerPath;
     const sourcePath = realpathSync(compilerPath);
     const source = lstatSync(sourcePath);
-    if (!source.isFile()) throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    if (!source.isFile() || 0 === source.size) throw new Error(`Effect TS-Go compiler path is not a nonempty regular file: ${sourcePath}`);
+    if ('win32' === process.platform) return compilerPath;
     try {
         accessSync(sourcePath, constants.X_OK);
         return compilerPath;
@@ -188,37 +69,24 @@ function resolveExecutableEffectTsgoCompiler(compilerPath) {
 function getBuildConfigEnvironment(name) {
     return process.env[name];
 }
-function withBuildConfigEnvironment(name, value, setup) {
-    return async (config, ...args)=>{
-        const release = acquireEnvironmentLease(name, value);
-        try {
-            const configured = await setup(config, ...args) ?? config;
-            configured.plugins = [
-                ...configured.plugins ?? [],
-                new BuildConfigEnvironmentLeasePlugin(release)
-            ];
-            return configured;
-        } catch (error) {
-            releaseAfterFailure(release, error);
-        }
-    };
-}
 function resolveEffectTsgoCompiler(options) {
     const configuredCompiler = getBuildConfigEnvironment('EFFECT_TSGO_BIN')?.trim();
     if (configuredCompiler) try {
-        return resolveExecutableEffectTsgoCompiler(configuredCompiler);
-    } catch  {
-        throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+        const compiler = resolveExecutableEffectTsgoCompiler(configuredCompiler);
+        validateConfiguredEffectCompiler(compiler, options.from);
+        return compiler;
+    } catch (cause) {
+        throw effectTsgoResolutionError(cause, 'Configured compiler validation', options.from);
     }
+    let stage = 'Package CLI resolution';
     try {
-        const compiler = execFileSync(process.execPath, [
-            resolveEffectTsgoCli(options.from),
-            'get-exe-path'
-        ], {
-            encoding: 'utf-8'
-        }).trim();
-        if (compiler) return resolveExecutableEffectTsgoCompiler(compiler);
-    } catch  {}
-    throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+        const compiler = resolveInstalledEffectCompiler(options.from).trim();
+        stage = 'Compiler backend lookup';
+        if (!compiler) throw new Error('Effect TS-Go discovery returned an empty compiler path');
+        stage = 'Compiler executable validation';
+        return resolveExecutableEffectTsgoCompiler(compiler);
+    } catch (cause) {
+        throw effectTsgoResolutionError(cause, effectCompilerDiscoveryFailureStage(cause) ?? stage, options.from);
+    }
 }
-export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment };
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler };

package/dist/esm/build-config/internal-effect-discovery.mjs

@@ -0,0 +1,187 @@
+import { execFileSync } from "node:child_process";
+import { lstatSync, readFileSync, realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const EFFECT_TSGO_PACKAGE = '@effect/tsgo';
+const EFFECT_TSGO_BIN = 'effect-tsgo';
+const NATIVE_TYPESCRIPT_PACKAGES = [
+    "typescript",
+    "@typescript/native"
+];
+const EFFECT_TSRS_PROVIDER_VERSION = '0.59.0';
+const EFFECT_TSRS_TARGETS = new Set([
+    '@tsrs/darwin-arm64',
+    '@tsrs/linux-x64-gnu',
+    '@tsrs/linux-arm64-gnu'
+]);
+const failureStages = new WeakMap();
+const reportedUnsupportedTsrsTargets = new Set();
+function effectCompilerDiscoveryFailureStage(error) {
+    return error && 'object' == typeof error ? failureStages.get(error) : void 0;
+}
+function resolveEffectTsgoPackage(from) {
+    const projectRequire = createRequire(from);
+    const packageJsonPath = projectRequire.resolve(`${EFFECT_TSGO_PACKAGE}/package.json`);
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const bin = 'string' == typeof packageJson.bin ? packageJson.bin : packageJson.bin?.[EFFECT_TSGO_BIN];
+    if (!bin) throw new Error(`Resolved ${EFFECT_TSGO_PACKAGE} package has no ${EFFECT_TSGO_BIN} bin: ${packageJsonPath}`);
+    const cliPath = realpathSync(resolve(dirname(packageJsonPath), bin));
+    if (!lstatSync(cliPath).isFile()) throw new Error(`Effect TS-Go CLI is not a regular file: ${cliPath}`);
+    return {
+        packageJsonPath,
+        packageJson,
+        cliPath
+    };
+}
+function isAbsentPackage(projectRequire, from, packageName, error) {
+    const filename = 'string' != typeof from || from.startsWith('file:') ? fileURLToPath(from) : from;
+    if (!(error instanceof Error) || !('code' in error) || 'MODULE_NOT_FOUND' !== error.code || 'path' in error && void 0 !== error.path || error.message.split('\n')[0] !== `Cannot find module '${packageName}/package.json'` || !('requireStack' in error) || !Array.isArray(error.requireStack) || error.requireStack[0] !== filename) return false;
+    for (const searchDirectory of projectRequire.resolve.paths(packageName) ?? [])try {
+        lstatSync(join(searchDirectory, packageName));
+        return false;
+    } catch (presenceError) {
+        if (!(presenceError instanceof Error) || !('code' in presenceError) || ![
+            'ENOENT',
+            'ENOTDIR'
+        ].includes(String(presenceError.code))) throw presenceError;
+    }
+    return true;
+}
+function resolveNativeTypeScriptPackage(from) {
+    const projectRequire = createRequire(from);
+    for (const packageName of NATIVE_TYPESCRIPT_PACKAGES){
+        let packageJsonPath;
+        try {
+            packageJsonPath = projectRequire.resolve(`${packageName}/package.json`);
+        } catch (error) {
+            if (isAbsentPackage(projectRequire, from, packageName, error)) continue;
+            throw error;
+        }
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        const major = packageJson.version?.match(/^(\d+)\.\d+\.\d+(?:[-+].*)?$/u)?.[1];
+        if (!major) throw new Error(`Resolved TypeScript package has no valid version: ${packageJsonPath}`);
+        if (Number(major) >= 7) return packageJsonPath;
+    }
+    throw new Error(`No native TypeScript backend is installed for ${String(from)}. Install typescript >=7 or @typescript/native.`);
+}
+function resolveNativeTypeScriptManifest(from) {
+    const packageJsonPath = resolveNativeTypeScriptPackage(from);
+    const directory = dirname(packageJsonPath);
+    const discoveryPackage = resolveNativeTypeScriptPackage(join(directory, '__ultramodern_effect_backend__.cjs'));
+    if (realpathSync(discoveryPackage) !== realpathSync(packageJsonPath)) throw new Error(`Effect discovery would select a different native TypeScript installation from ${directory}: ${discoveryPackage}`);
+    return packageJsonPath;
+}
+function readCompilerArtifact(filename) {
+    const canonicalPath = realpathSync(filename);
+    const stats = lstatSync(canonicalPath);
+    if (!stats.isFile()) throw new Error(`Compiler artifact is not a regular file: ${filename}`);
+    if (0 === stats.size) throw new Error(`Compiler artifact is empty: ${filename}`);
+    return canonicalPath;
+}
+function resolveTsrsManifest(from) {
+    const projectRequire = createRequire(from);
+    try {
+        return projectRequire.resolve('tsrs/package.json');
+    } catch (error) {
+        if (isAbsentPackage(projectRequire, from, 'tsrs', error)) return;
+        throw error;
+    }
+}
+function compilerVersion(compiler) {
+    return execFileSync(compiler, [
+        '--version'
+    ], {
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            TSRS_CHECKER_ASSIGNMENT: process.env.TSRS_CHECKER_ASSIGNMENT || 'go'
+        },
+        timeout: 10000,
+        maxBuffer: 1048576
+    }).trim();
+}
+function tsrsPlatform(manifestPath) {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    const { getPlatformPackageName } = createRequire(manifestPath)(join(dirname(manifestPath), 'lib/platform.js'));
+    const nativeName = getPlatformPackageName();
+    const embedded = manifest.tsrs;
+    if ('string' != typeof nativeName || !nativeName || !manifest.optionalDependencies || 'object' != typeof manifest.optionalDependencies || Array.isArray(manifest.optionalDependencies) || 0 === Object.keys(manifest.optionalDependencies).length) throw new Error(`Invalid native tsrs capability metadata: ${manifestPath}`);
+    if ('string' != typeof manifest.name || !manifest.name || 'string' != typeof manifest.version || !/^\d+\.\d+\.\d+-ts[\w.-]+$/u.test(manifest.version) || 'string' != typeof embedded?.typescriptVersion || !/^7\.\d+\.\d+(?:[-+][\w.-]+)?$/u.test(embedded.typescriptVersion) || !manifest.version.endsWith(`-ts${embedded.typescriptVersion}`) || 'string' != typeof embedded.typescriptCommit || !/^[a-f\d]{40}$/u.test(embedded.typescriptCommit)) throw new Error(`Invalid native tsrs metadata: ${manifestPath}`);
+    const supported = Object.hasOwn(manifest.optionalDependencies, nativeName);
+    if (supported && manifest.optionalDependencies[nativeName] !== manifest.version) throw new Error(`Native tsrs target version does not match its selected package: ${manifestPath}`);
+    return {
+        manifest: manifest,
+        nativeName,
+        supported
+    };
+}
+function resolveTsrsCompiler(manifestPath, effect, configuredCompiler, configuredVersion) {
+    const { manifest } = tsrsPlatform(manifestPath);
+    const embedded = manifest.tsrs;
+    const effectName = `@effect/tsgo-${process.platform}-${process.arch}`;
+    const effectManifest = createRequire(effect.cliPath).resolve(`${effectName}/package.json`);
+    const platform = JSON.parse(readFileSync(effectManifest, 'utf8'));
+    const metadataPath = join(dirname(effectManifest), 'lib/upstream.json');
+    const metadata = JSON.parse(readFileSync(metadataPath, 'utf8'));
+    const component = metadata.components?.tsrs?.[manifest.version];
+    if (platform.name !== effectName || platform.version !== effect.packageJson.version || 5 !== metadata.schemaVersion || !/^[a-f\d]{40}$/u.test(component?.gitHead ?? '') || component?.typescript?.version !== embedded.typescriptVersion || component.typescript.gitHead !== embedded.typescriptCommit) throw new Error(`Effect replacement metadata does not match tsrs: ${metadataPath}`);
+    const compiler = readCompilerArtifact(configuredCompiler ?? join(dirname(effectManifest), 'artifacts/tsrs', manifest.version, 'win32' === process.platform ? 'tsrs.exe' : 'tsrs'));
+    const version = configuredVersion ?? compilerVersion(compiler);
+    const stamp = /\+effect-tsgo\.([\d.]+)\s+\(tsrs ([^,]+), microsoft\/TypeScript@([a-f\d]+)\)$/u.exec(version);
+    if (!stamp || stamp[1] !== effect.packageJson.version || stamp[2] !== manifest.version || stamp[3].length < 12 || !embedded.typescriptCommit.startsWith(stamp[3])) throw new Error(`Effect-enabled tsrs matching ${manifest.version} and @effect/tsgo@${effect.packageJson.version} is required: ${compiler}. Install matching packages or select a matching Effect-enabled candidate with EFFECT_TSGO_BIN.`);
+    return compiler;
+}
+function validateConfiguredEffectCompiler(compiler, from) {
+    const version = compilerVersion(compiler);
+    if (!/^Version \d+\.\d+\.\d+[\w.-]*\+effect-tsgo\.\d+\.\d+\.\d+(?:\s|$)/u.test(version)) throw new Error(`EFFECT_TSGO_BIN must select an Effect-enabled native compiler: ${compiler}`);
+    if (version.includes('(tsrs ')) {
+        const manifest = resolveTsrsManifest(from);
+        if (!manifest) throw new Error(`Cannot validate tsrs without its installed package metadata for ${String(from)}`);
+        resolveTsrsCompiler(manifest, resolveEffectTsgoPackage(from), compiler, version);
+    }
+}
+function resolveInstalledEffectCompiler(from) {
+    let stage = 'Package CLI resolution';
+    try {
+        const effect = resolveEffectTsgoPackage(from);
+        stage = 'Native tsrs package resolution';
+        const tsrsManifest = resolveTsrsManifest(from);
+        const tsrsTarget = tsrsManifest ? tsrsPlatform(tsrsManifest) : void 0;
+        if (tsrsTarget && effect.packageJson.version !== EFFECT_TSRS_PROVIDER_VERSION) throw new Error(`Unreviewed Effect tsrs capability contract: ${effect.packageJson.version}`);
+        const configuredTsrsCompiler = process.env.TSRS_BINARY || void 0;
+        if (tsrsManifest && tsrsTarget?.supported && (configuredTsrsCompiler || EFFECT_TSRS_TARGETS.has(tsrsTarget.nativeName))) {
+            stage = 'Native tsrs validation';
+            return resolveTsrsCompiler(tsrsManifest, effect, configuredTsrsCompiler);
+        }
+        if (tsrsTarget && !reportedUnsupportedTsrsTargets.has(tsrsTarget.nativeName)) {
+            reportedUnsupportedTsrsTargets.add(tsrsTarget.nativeName);
+            console.warn(`[UltraModern] ${tsrsTarget.supported ? `@effect/tsgo@${effect.packageJson.version} does not provide a tsrs replacement for ${tsrsTarget.nativeName}` : `tsrs does not declare ${tsrsTarget.nativeName}`}; selecting the Effect-enabled TypeScript-Go compiler.`);
+        }
+        stage = 'Native TypeScript package resolution';
+        const typeScriptManifest = resolveNativeTypeScriptManifest(from);
+        const typeScript = JSON.parse(readFileSync(typeScriptManifest, 'utf8'));
+        const nativeName = `@typescript/typescript-${process.platform}-${process.arch}`;
+        const nativeManifest = createRequire(typeScriptManifest).resolve(`${nativeName}/package.json`);
+        const native = JSON.parse(readFileSync(nativeManifest, 'utf8'));
+        if (native.name !== nativeName || native.version !== typeScript.version || 'string' != typeof native.version || !/^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/u.test(native.version) || 'string' != typeof native.gitHead || !/^[a-f\d]{40}$/u.test(native.gitHead) || native.gitHead !== typeScript.gitHead) throw new Error(`Native TypeScript platform does not match its selected package: ${nativeManifest}`);
+        const binaryName = 'win32' === process.platform ? 'tsc.exe' : 'tsc';
+        readCompilerArtifact(join(dirname(nativeManifest), 'lib', binaryName));
+        stage = 'Compiler backend lookup';
+        const effectName = `@effect/tsgo-${process.platform}-${process.arch}`;
+        const effectManifest = createRequire(effect.cliPath).resolve(`${effectName}/package.json`);
+        const platform = JSON.parse(readFileSync(effectManifest, 'utf8'));
+        if (platform.name !== effectName || 'string' != typeof effect.packageJson.version || platform.version !== effect.packageJson.version) throw new Error(`Effect platform does not match its selected provider: ${effectManifest}`);
+        const metadataPath = join(dirname(effectManifest), 'lib', 'upstream.json');
+        const metadata = JSON.parse(readFileSync(metadataPath, 'utf8'));
+        const component = metadata.components?.typescript?.[native.version];
+        const latestTypeScript = metadata.tags?.typescript?.latest;
+        if (5 !== metadata.schemaVersion || 'string' != typeof latestTypeScript || component?.provider !== "typescript-go" || component.gitHead !== native.gitHead) throw new Error(`Effect replacement metadata does not match the selected native TypeScript backend: ${metadataPath}`);
+        const compilerDirectory = native.version === latestTypeScript ? join(dirname(effectManifest), 'lib') : join(dirname(effectManifest), 'artifacts', "typescript", native.version);
+        return readCompilerArtifact(join(compilerDirectory, binaryName));
+    } catch (error) {
+        if (error && 'object' == typeof error && !failureStages.has(error)) failureStages.set(error, stage);
+        throw error;
+    }
+}
+export { effectCompilerDiscoveryFailureStage, resolveInstalledEffectCompiler, validateConfiguredEffectCompiler };

package/dist/esm/build-config/public.mjs

@@ -1 +1 @@
-export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment } from "./build-environment.mjs";
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler } from "./build-environment.mjs";

package/dist/esm/build-config/remote-address.mjs

@@ -0,0 +1,20 @@
+import { resolveBrowserManifestAddress } from "@modern-js/surface-resolution";
+import { resolveDeployTarget } from "../deploy-output/target.mjs";
+import { getBuildConfigEnvironment } from "./build-environment.mjs";
+function createRemoteManifestUrl(options) {
+    const env = {
+        ...Object.fromEntries([
+            options.manifestEnv,
+            options.publicUrlEnv,
+            'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN'
+        ].map((name)=>[
+                name,
+                getBuildConfigEnvironment(name)
+            ])),
+        MODERNJS_DEPLOY: resolveDeployTarget().target
+    };
+    const address = resolveBrowserManifestAddress(env, options, getBuildConfigEnvironment('NODE_ENV') ?? 'production');
+    if (!address.ok) throw new Error(`Remote ${options.mfName}: ${address.reason}`);
+    return env[options.manifestEnv]?.trim() || `${options.mfName}@${address.manifestUrl}`;
+}
+export { createRemoteManifestUrl };

package/dist/esm/cloudflare/artifacts.mjs

@@ -1,5 +1,6 @@
 import node_path from "node:path";
 import { fs } from "@modern-js/utils";
+import { CLOUDFLARE_PUBLIC_ASSET_SCOPE, normalizeDeclaredPublicAssets, stageDeclaredPublicAssets } from "../deploy-output/public-assets.mjs";
 import { RESERVED_ARTIFACT_DESTINATION_DIRECTORIES, RESERVED_ARTIFACT_DESTINATION_FILES, ROUTE_SPEC_OUTPUT } from "./constants.mjs";
 import { normalizeRelativePath } from "./utils.mjs";
 const normalizeCloudflareArtifact = (artifact, index)=>{
@@ -15,18 +16,7 @@ const normalizeCloudflareArtifact = (artifact, 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 getCloudflarePublicAssets = (modernConfig)=>normalizeDeclaredPublicAssets(modernConfig.deploy?.worker?.publicAssets, CLOUDFLARE_PUBLIC_ASSET_SCOPE);
 const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)=>{
     for (const artifact of artifacts){
         const sourcePath = node_path.join(appDirectory, artifact.from);
@@ -34,13 +24,12 @@ const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)
         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 copyCloudflarePublicAssets = async (appDirectory, outputDirectory, publicAssets)=>stageDeclaredPublicAssets({
+        appDirectory,
+        outputDirectory,
+        assets: publicAssets,
+        scope: CLOUDFLARE_PUBLIC_ASSET_SCOPE
+    });
 const copyCloudflareD1Migrations = async (appDirectory, outputDirectory, modernConfig)=>{
     for (const [index, database] of (modernConfig.deploy?.worker?.d1Databases ?? []).entries()){
         if (!database.migrationsDir) continue;