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

package/dist/cjs/build-config/build-environment.js

@@ -29,153 +29,33 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     getBuildConfigEnvironment: ()=>getBuildConfigEnvironment,
-    resolveEffectTsgoCompiler: ()=>resolveEffectTsgoCompiler,
-    withBuildConfigEnvironment: ()=>withBuildConfigEnvironment
+    resolveEffectTsgoCompiler: ()=>resolveEffectTsgoCompiler
 });
-const external_node_child_process_namespaceObject = require("node:child_process");
 const external_node_crypto_namespaceObject = require("node:crypto");
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_module_namespaceObject = require("node:module");
 const external_node_os_namespaceObject = require("node:os");
 const external_node_path_namespaceObject = require("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.';
+const external_node_url_namespaceObject = require("node:url");
+const owningModuleUrl = (0, external_node_url_namespaceObject.pathToFileURL)(__filename).href;
+const owningManifest = (0, external_node_module_namespaceObject.findPackageJSON)(owningModuleUrl, owningModuleUrl);
+if (!owningManifest) throw new Error('Cannot find owning build-config package manifest');
+const owningName = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(owningManifest, 'utf8')).name;
+if ('string' != typeof owningName || 0 === owningName.length) throw new Error(`Invalid owning build-config package name: ${owningManifest}`);
+const { effectCompilerDiscoveryFailureStage, resolveInstalledEffectCompiler, validateConfiguredEffectCompiler } = (0, external_node_module_namespaceObject.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 = (0, external_node_module_namespaceObject.createRequire)(from);
-    const packageJsonPath = projectRequire.resolve(`${EFFECT_TSGO_PACKAGE}/package.json`);
-    const packageJson = JSON.parse((0, external_node_fs_namespaceObject.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 (0, external_node_path_namespaceObject.resolve)((0, external_node_path_namespaceObject.dirname)(packageJsonPath), bin);
 }
 function resolveExecutableEffectTsgoCompiler(compilerPath) {
-    if ('win32' === process.platform) return compilerPath;
     const sourcePath = (0, external_node_fs_namespaceObject.realpathSync)(compilerPath);
     const source = (0, external_node_fs_namespaceObject.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 {
         (0, external_node_fs_namespaceObject.accessSync)(sourcePath, external_node_fs_namespaceObject.constants.X_OK);
         return compilerPath;
@@ -222,46 +102,31 @@ 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 = (0, external_node_child_process_namespaceObject.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);
+    }
 }
 exports.getBuildConfigEnvironment = __webpack_exports__.getBuildConfigEnvironment;
 exports.resolveEffectTsgoCompiler = __webpack_exports__.resolveEffectTsgoCompiler;
-exports.withBuildConfigEnvironment = __webpack_exports__.withBuildConfigEnvironment;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getBuildConfigEnvironment",
-    "resolveEffectTsgoCompiler",
-    "withBuildConfigEnvironment"
+    "resolveEffectTsgoCompiler"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/build-config/internal-effect-discovery.js

@@ -0,0 +1,231 @@
+"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__, {
+    effectCompilerDiscoveryFailureStage: ()=>effectCompilerDiscoveryFailureStage,
+    resolveInstalledEffectCompiler: ()=>resolveInstalledEffectCompiler,
+    validateConfiguredEffectCompiler: ()=>validateConfiguredEffectCompiler
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_url_namespaceObject = require("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 = (0, external_node_module_namespaceObject.createRequire)(from);
+    const packageJsonPath = projectRequire.resolve(`${EFFECT_TSGO_PACKAGE}/package.json`);
+    const packageJson = JSON.parse((0, external_node_fs_namespaceObject.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 = (0, external_node_fs_namespaceObject.realpathSync)((0, external_node_path_namespaceObject.resolve)((0, external_node_path_namespaceObject.dirname)(packageJsonPath), bin));
+    if (!(0, external_node_fs_namespaceObject.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:') ? (0, external_node_url_namespaceObject.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 {
+        (0, external_node_fs_namespaceObject.lstatSync)((0, external_node_path_namespaceObject.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 = (0, external_node_module_namespaceObject.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((0, external_node_fs_namespaceObject.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 = (0, external_node_path_namespaceObject.dirname)(packageJsonPath);
+    const discoveryPackage = resolveNativeTypeScriptPackage((0, external_node_path_namespaceObject.join)(directory, '__ultramodern_effect_backend__.cjs'));
+    if ((0, external_node_fs_namespaceObject.realpathSync)(discoveryPackage) !== (0, external_node_fs_namespaceObject.realpathSync)(packageJsonPath)) throw new Error(`Effect discovery would select a different native TypeScript installation from ${directory}: ${discoveryPackage}`);
+    return packageJsonPath;
+}
+function readCompilerArtifact(filename) {
+    const canonicalPath = (0, external_node_fs_namespaceObject.realpathSync)(filename);
+    const stats = (0, external_node_fs_namespaceObject.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 = (0, external_node_module_namespaceObject.createRequire)(from);
+    try {
+        return projectRequire.resolve('tsrs/package.json');
+    } catch (error) {
+        if (isAbsentPackage(projectRequire, from, 'tsrs', error)) return;
+        throw error;
+    }
+}
+function compilerVersion(compiler) {
+    return (0, external_node_child_process_namespaceObject.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((0, external_node_fs_namespaceObject.readFileSync)(manifestPath, 'utf8'));
+    const { getPlatformPackageName } = (0, external_node_module_namespaceObject.createRequire)(manifestPath)((0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.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 = (0, external_node_module_namespaceObject.createRequire)(effect.cliPath).resolve(`${effectName}/package.json`);
+    const platform = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(effectManifest, 'utf8'));
+    const metadataPath = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(effectManifest), 'lib/upstream.json');
+    const metadata = JSON.parse((0, external_node_fs_namespaceObject.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 ?? (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.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((0, external_node_fs_namespaceObject.readFileSync)(typeScriptManifest, 'utf8'));
+        const nativeName = `@typescript/typescript-${process.platform}-${process.arch}`;
+        const nativeManifest = (0, external_node_module_namespaceObject.createRequire)(typeScriptManifest).resolve(`${nativeName}/package.json`);
+        const native = JSON.parse((0, external_node_fs_namespaceObject.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((0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(nativeManifest), 'lib', binaryName));
+        stage = 'Compiler backend lookup';
+        const effectName = `@effect/tsgo-${process.platform}-${process.arch}`;
+        const effectManifest = (0, external_node_module_namespaceObject.createRequire)(effect.cliPath).resolve(`${effectName}/package.json`);
+        const platform = JSON.parse((0, external_node_fs_namespaceObject.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 = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(effectManifest), 'lib', 'upstream.json');
+        const metadata = JSON.parse((0, external_node_fs_namespaceObject.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 ? (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(effectManifest), 'lib') : (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(effectManifest), 'artifacts', "typescript", native.version);
+        return readCompilerArtifact((0, external_node_path_namespaceObject.join)(compilerDirectory, binaryName));
+    } catch (error) {
+        if (error && 'object' == typeof error && !failureStages.has(error)) failureStages.set(error, stage);
+        throw error;
+    }
+}
+exports.effectCompilerDiscoveryFailureStage = __webpack_exports__.effectCompilerDiscoveryFailureStage;
+exports.resolveInstalledEffectCompiler = __webpack_exports__.resolveInstalledEffectCompiler;
+exports.validateConfiguredEffectCompiler = __webpack_exports__.validateConfiguredEffectCompiler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "effectCompilerDiscoveryFailureStage",
+    "resolveInstalledEffectCompiler",
+    "validateConfiguredEffectCompiler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/build-config/public.js

@@ -29,17 +29,14 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     getBuildConfigEnvironment: ()=>external_build_environment_js_namespaceObject.getBuildConfigEnvironment,
-    resolveEffectTsgoCompiler: ()=>external_build_environment_js_namespaceObject.resolveEffectTsgoCompiler,
-    withBuildConfigEnvironment: ()=>external_build_environment_js_namespaceObject.withBuildConfigEnvironment
+    resolveEffectTsgoCompiler: ()=>external_build_environment_js_namespaceObject.resolveEffectTsgoCompiler
 });
 const external_build_environment_js_namespaceObject = require("./build-environment.js");
 exports.getBuildConfigEnvironment = __webpack_exports__.getBuildConfigEnvironment;
 exports.resolveEffectTsgoCompiler = __webpack_exports__.resolveEffectTsgoCompiler;
-exports.withBuildConfigEnvironment = __webpack_exports__.withBuildConfigEnvironment;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getBuildConfigEnvironment",
-    "resolveEffectTsgoCompiler",
-    "withBuildConfigEnvironment"
+    "resolveEffectTsgoCompiler"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/build-config/remote-address.js

@@ -0,0 +1,58 @@
+"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__, {
+    createRemoteManifestUrl: ()=>createRemoteManifestUrl
+});
+const surface_resolution_namespaceObject = require("@modern-js/surface-resolution");
+const target_js_namespaceObject = require("../deploy-output/target.js");
+const external_build_environment_js_namespaceObject = require("./build-environment.js");
+function createRemoteManifestUrl(options) {
+    const env = {
+        ...Object.fromEntries([
+            options.manifestEnv,
+            options.publicUrlEnv,
+            'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN'
+        ].map((name)=>[
+                name,
+                (0, external_build_environment_js_namespaceObject.getBuildConfigEnvironment)(name)
+            ])),
+        MODERNJS_DEPLOY: (0, target_js_namespaceObject.resolveDeployTarget)().target
+    };
+    const address = (0, surface_resolution_namespaceObject.resolveBrowserManifestAddress)(env, options, (0, external_build_environment_js_namespaceObject.getBuildConfigEnvironment)('NODE_ENV') ?? 'production');
+    if (!address.ok) throw new Error(`Remote ${options.mfName}: ${address.reason}`);
+    return env[options.manifestEnv]?.trim() || `${options.mfName}@${address.manifestUrl}`;
+}
+exports.createRemoteManifestUrl = __webpack_exports__.createRemoteManifestUrl;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRemoteManifestUrl"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cloudflare/artifacts.js

@@ -47,6 +47,7 @@ __webpack_require__.d(__webpack_exports__, {
 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 public_assets_js_namespaceObject = require("../deploy-output/public-assets.js");
 const external_constants_js_namespaceObject = require("./constants.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const normalizeCloudflareArtifact = (artifact, index)=>{
@@ -62,18 +63,7 @@ const normalizeCloudflareArtifact = (artifact, 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 getCloudflarePublicAssets = (modernConfig)=>(0, public_assets_js_namespaceObject.normalizeDeclaredPublicAssets)(modernConfig.deploy?.worker?.publicAssets, public_assets_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSET_SCOPE);
 const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)=>{
     for (const artifact of artifacts){
         const sourcePath = external_node_path_default().join(appDirectory, artifact.from);
@@ -81,13 +71,12 @@ const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)
         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 copyCloudflarePublicAssets = async (appDirectory, outputDirectory, publicAssets)=>(0, public_assets_js_namespaceObject.stageDeclaredPublicAssets)({
+        appDirectory,
+        outputDirectory,
+        assets: publicAssets,
+        scope: public_assets_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSET_SCOPE
+    });
 const copyCloudflareD1Migrations = async (appDirectory, outputDirectory, modernConfig)=>{
     for (const [index, database] of (modernConfig.deploy?.worker?.d1Databases ?? []).entries()){
         if (!database.migrationsDir) continue;