@bleedingdev/modern-js-app-tools-extensions 3.9.3-ultramodern.1 → 3.9.3-ultramodern.11

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

@@ -42,8 +42,8 @@ const owningManifest = (0, external_node_module_namespaceObject.findPackageJSON)
 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 } = (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.';
+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();
 function effectTsgoResolutionError(cause, stage, from) {
     const detail = cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause);
@@ -52,10 +52,10 @@ function effectTsgoResolutionError(cause, stage, from) {
     });
 }
 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 TS-Go compiler path is not a regular file: ${sourcePath}`);
+    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;
@@ -105,7 +105,9 @@ function getBuildConfigEnvironment(name) {
 function resolveEffectTsgoCompiler(options) {
     const configuredCompiler = getBuildConfigEnvironment('EFFECT_TSGO_BIN')?.trim();
     if (configuredCompiler) try {
-        return resolveExecutableEffectTsgoCompiler(configuredCompiler);
+        const compiler = resolveExecutableEffectTsgoCompiler(configuredCompiler);
+        validateConfiguredEffectCompiler(compiler, options.from);
+        return compiler;
     } catch (cause) {
         throw effectTsgoResolutionError(cause, 'Configured compiler validation', options.from);
     }

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

@@ -29,8 +29,10 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     effectCompilerDiscoveryFailureStage: ()=>effectCompilerDiscoveryFailureStage,
-    resolveInstalledEffectCompiler: ()=>resolveInstalledEffectCompiler
+    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");
@@ -41,7 +43,14 @@ 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;
 }
@@ -59,7 +68,7 @@ function resolveEffectTsgoPackage(from) {
         cliPath
     };
 }
-function isAbsentNativeTypeScriptPackage(projectRequire, from, packageName, error) {
+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 {
@@ -80,7 +89,7 @@ function resolveNativeTypeScriptPackage(from) {
         try {
             packageJsonPath = projectRequire.resolve(`${packageName}/package.json`);
         } catch (error) {
-            if (isAbsentNativeTypeScriptPackage(projectRequire, from, packageName, error)) continue;
+            if (isAbsentPackage(projectRequire, from, packageName, error)) continue;
             throw error;
         }
         const packageJson = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(packageJsonPath, 'utf-8'));
@@ -104,10 +113,85 @@ function readCompilerArtifact(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'));
@@ -125,8 +209,10 @@ function resolveInstalledEffectCompiler(from) {
         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];
-        if (5 !== metadata.schemaVersion || component?.provider !== "typescript-go" || component.gitHead !== native.gitHead) throw new Error(`Effect replacement metadata does not match the selected native TypeScript backend: ${metadataPath}`);
-        return readCompilerArtifact((0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(effectManifest), 'artifacts', "typescript", native.version, binaryName));
+        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;
@@ -134,9 +220,11 @@ function resolveInstalledEffectCompiler(from) {
 }
 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"
+    "resolveInstalledEffectCompiler",
+    "validateConfiguredEffectCompiler"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -45,7 +45,8 @@ var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObj
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_issues_js_namespaceObject = require("./issues.js");
-const SOURCE_SCAN_FILE_PATTERN = /\.(?:[cm]?[jt]s|json)$/u;
+const SOURCE_SCAN_FILE_PATTERN = /\.(?:[cm]?[jt]sx?)$/u;
+const DECLARATION_FILE_PATTERN = /\.d\.[cm]?ts$/u;
 const SOURCE_SCAN_IGNORED_DIRECTORY_NAMES = new Set([
     '.codex',
     '.fastcontext',
@@ -118,7 +119,7 @@ const walkFiles = async (root)=>{
             files.push(...await walkFiles(entryPath));
             continue;
         }
-        if (SOURCE_SCAN_FILE_PATTERN.test(entry.name)) files.push(entryPath);
+        if ('package.json' === entry.name || SOURCE_SCAN_FILE_PATTERN.test(entry.name) && !DECLARATION_FILE_PATTERN.test(entry.name)) files.push(entryPath);
     }
     return files;
 };
@@ -135,7 +136,26 @@ const verifyCloudflareOutputMutationPolicy = async (options)=>{
             if ('ENOENT' === error.code) continue;
             throw error;
         }
-        for (const forbidden of FORBIDDEN_MUTATION_PATTERNS)if (forbidden.pattern.test(source)) (0, external_issues_js_namespaceObject.addIssue)(issues, {
+        let executableSources = [
+            source
+        ];
+        if ('package.json' === external_node_path_default().basename(file)) try {
+            const manifest = JSON.parse(source);
+            if (!isRecord(manifest)) throw new TypeError('Package metadata must be an object.');
+            const scripts = Object.hasOwn(manifest, "scripts") ? manifest.scripts : {};
+            if (!isRecord(scripts)) throw new TypeError("Package scripts must be an object.");
+            const commands = Object.values(scripts);
+            if (!commands.every((value)=>'string' == typeof value)) throw new TypeError("Package scripts must contain only strings.");
+            executableSources = commands;
+        } catch  {
+            (0, external_issues_js_namespaceObject.addIssue)(issues, {
+                code: 'invalid-package',
+                message: "Cannot verify executable package lifecycle scripts: invalid package metadata.",
+                path: file
+            });
+            continue;
+        }
+        for (const forbidden of FORBIDDEN_MUTATION_PATTERNS)if (executableSources.some((value)=>forbidden.pattern.test(value))) (0, external_issues_js_namespaceObject.addIssue)(issues, {
             code: forbidden.code,
             message: forbidden.message,
             path: file
@@ -146,6 +166,7 @@ const verifyCloudflareOutputMutationPolicy = async (options)=>{
         issues
     };
 };
+const isRecord = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
 exports.verifyCloudflareOutputMutationPolicy = __webpack_exports__.verifyCloudflareOutputMutationPolicy;
 exports.walkFiles = __webpack_exports__.walkFiles;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/native-type-checker.js

@@ -45,30 +45,60 @@ __webpack_require__.d(__webpack_exports__, {
 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_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_node_util_namespaceObject = require("node:util");
 const builder_namespaceObject = require("@modern-js/builder");
 const external_jsonc_parser_namespaceObject = require("jsonc-parser");
+const build_environment_js_namespaceObject = require("./build-config/build-environment.js");
 const execute = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
 const native_type_checker_name = 'UltramodernNativeTypeChecker';
-function resolveNativeTypeCheckerCommand(packageJsonPath) {
-    const manifestFile = (0, external_node_fs_namespaceObject.realpathSync)(packageJsonPath);
-    const directory = external_node_path_default().dirname(manifestFile);
-    const manifest = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(manifestFile, 'utf8'));
-    if ("typescript" !== manifest.name || '7.0.2' !== manifest.version) throw new Error(`${native_type_checker_name} requires typescript@7.0.2; found ${String(manifest.name)}@${String(manifest.version)} at ${manifestFile}.`);
-    const bin = manifest.bin?.tsc;
-    if ('string' != typeof bin || !bin || external_node_path_default().isAbsolute(bin)) throw new Error(`${native_type_checker_name} requires the selected package's public tsc bin.`);
-    const launcher = (0, external_node_fs_namespaceObject.realpathSync)(external_node_path_default().resolve(directory, bin));
-    const relative = external_node_path_default().relative(directory, launcher);
-    if (!relative || external_node_path_default().isAbsolute(relative) || '..' === relative || relative.startsWith(`..${external_node_path_default().sep}`) || !(0, external_node_fs_namespaceObject.statSync)(launcher).isFile()) throw new Error(`${native_type_checker_name} public tsc bin must belong to its selected package.`);
+function resolveNativeTypeCheckerCommand(from) {
+    const executable = (0, build_environment_js_namespaceObject.resolveEffectTsgoCompiler)({
+        from
+    });
+    const version = (0, external_node_child_process_namespaceObject.execFileSync)(executable, [
+        '--version'
+    ], {
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            TSRS_CHECKER_ASSIGNMENT: process.env.TSRS_CHECKER_ASSIGNMENT || 'go'
+        },
+        timeout: 10000
+    });
+    if (version.includes('(tsrs ')) return {
+        executable,
+        args: [],
+        configApi: (0, external_node_module_namespaceObject.createRequire)(from).resolve('tsrs/sync')
+    };
     return {
-        executable: process.execPath,
-        args: [
-            launcher
-        ]
+        executable,
+        args: []
     };
 }
+const inspectNativeConfig = `
+  import { pathToFileURL } from 'node:url';
+  const [modulePath, compiler, configFile] = process.argv.slice(1);
+  const { API, formatDiagnostics } = await import(pathToFileURL(modulePath).href);
+  const api = new API({ tsserverPath: compiler });
+  try {
+    const config = api.parseConfigFile(configFile);
+    if (config.errors.length) {
+      process.stdout.write(formatDiagnostics(config.errors, api));
+      process.exitCode = 1;
+    } else {
+      process.stdout.write(JSON.stringify({
+        compilerOptions: config.options,
+        files: config.fileNames,
+        references: config.projectReferences,
+      }));
+    }
+  } finally {
+    api.close();
+  }
+`;
 const watchDependencyPath = (file)=>{
     if ('win32' !== process.platform) return file;
     try {
@@ -180,19 +210,37 @@ class UltramodernNativeTypeChecker {
                 executable: selected,
                 args: []
             } : selected;
-            const result = await execute(command.executable, [
+            const inspect = '--showConfig' === args[0] && command.configApi;
+            const result = await execute(inspect ? process.execPath : command.executable, inspect ? [
+                '--input-type=module',
+                '--eval',
+                inspectNativeConfig,
+                command.configApi,
+                command.executable,
+                args[args.indexOf('--project') + 1]
+            ] : [
                 ...command.args,
                 ...args
             ], {
                 cwd: external_node_path_default().dirname(this.options.configFile),
-                maxBuffer: 16777216
+                env: {
+                    ...process.env,
+                    TSRS_CHECKER_ASSIGNMENT: process.env.TSRS_CHECKER_ASSIGNMENT || 'go'
+                },
+                maxBuffer: 16777216,
+                ...inspect ? {
+                    timeout: 10000
+                } : {}
             });
             return result.stdout;
         } catch (cause) {
             const output = cause;
             const diagnostics = `${output.stdout ?? ''}${output.stderr ?? ''}`;
-            throw new Error(`${native_type_checker_name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}${missingJsxRuntimeHint(diagnostics)}`, {
+            throw Object.assign(new Error(`${native_type_checker_name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}${missingJsxRuntimeHint(diagnostics)}`, {
                 cause
+            }), {
+                code: output.code,
+                signal: output.signal
             });
         }
     }
@@ -254,9 +302,7 @@ class UltramodernNativeTypeChecker {
                         this.removeProjection(configFile);
                     }
                 } catch (cause) {
-                    compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {
-                        cause
-                    }));
+                    compilation.errors.push(cause instanceof Error ? cause : new Error(String(cause)));
                 }
             });
         });

package/dist/cjs/release-identity.js

@@ -54,7 +54,7 @@ const gitOutput = (workspaceRoot, args)=>{
         return;
     }
 };
-const createUltramodernReleaseBuildMarker = ({ generationBuildMarker, sourceRevision, unitId })=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(`${BUILD_MARKER_NAMESPACE}:${unitId}:${generationBuildMarker}:${sourceRevision}`).digest('hex').slice(0, 16);
+const createUltramodernReleaseBuildMarker = ({ generationBuildMarker, sourceRevision, unitId })=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(`${BUILD_MARKER_NAMESPACE}:${unitId}:${generationBuildMarker}:${sourceRevision}`).digest('hex');
 const resolveUltramodernSourceRevision = (workspaceRoot = process.cwd(), configuredSourceRevision, environment = process.env)=>{
     const configuredArgumentValue = configuredSourceRevision?.trim();
     const configuredEnvironmentValue = environment.ULTRAMODERN_SOURCE_REVISION?.trim();

package/dist/cjs/renderer-build-identity.js

@@ -54,6 +54,7 @@ const LOCKFILES = [
     'bun.lock',
     'bun.lockb'
 ];
+const RELEASE_BUILD_MARKER_PATTERN = /^[a-f0-9]{64}$/u;
 const processNonce = (0, external_node_crypto_namespaceObject.randomUUID)();
 const sha256 = (value)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(value).digest('hex');
 function rendererProfileKey(profile) {
@@ -98,12 +99,21 @@ function resolveRendererBuildIdentities(options) {
     const projectRoot = external_node_path_default().resolve(options.projectRoot);
     const appId = options.appId ?? JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().join(projectRoot, 'package.json'), 'utf8')).name;
     if ('string' != typeof appId || !appId || appId.trim() !== appId) throw new Error('Renderer application identity requires a delivery artifact appId or a package name.');
+    const { deliveryUnit } = options;
+    if (void 0 !== deliveryUnit && ('string' != typeof deliveryUnit.unitId || !deliveryUnit.unitId || deliveryUnit.unitId.trim() !== deliveryUnit.unitId)) throw new Error('Renderer delivery-unit identity requires a nonempty trimmed unitId.');
     const profileKey = rendererProfileKey(options.profile);
-    const sourceRevision = (0, external_release_identity_js_namespaceObject.resolveUltramodernSourceRevision)(projectRoot, options.sourceRevision);
-    const buildId = sha256(JSON.stringify([
+    const sourceRevision = (0, external_release_identity_js_namespaceObject.resolveUltramodernSourceRevision)(projectRoot, deliveryUnit ? deliveryUnit.sourceRevision : options.sourceRevision);
+    const promotable = 'production' === options.mode && 'workspace' !== sourceRevision;
+    let buildId;
+    if (promotable && deliveryUnit) {
+        if (deliveryUnit.sourceRevision !== sourceRevision || !RELEASE_BUILD_MARKER_PATTERN.test(deliveryUnit.buildMarker)) throw new Error(`Renderer delivery unit ${deliveryUnit.unitId} must carry the release identity of source revision ${sourceRevision}.`);
+        buildId = deliveryUnit.buildMarker;
+    } else buildId = sha256(JSON.stringify([
+        appId,
+        deliveryUnit?.unitId ?? null,
         profileKey,
         lockfileHash(projectRoot),
-        'development' === options.mode || 'workspace' === sourceRevision ? processNonce : sourceRevision
+        promotable ? sourceRevision : processNonce
     ]));
     const identities = Object.fromEntries(entries.map((entryName)=>[
             entryName,

package/dist/cjs/templates/cloudflare-entry.005-worker-dispatch.mjs

@@ -306,7 +306,24 @@ async function invokeNativeRouteWorker(route, identity, request, env, ctx) {
   const resources =
     nativeRenderer?.renderer === identity.renderer &&
     Object.hasOwn(nativeRenderer.entries, route.entryName)
-      ? nativeRenderer.entries[route.entryName]
+      ? {
+          ...nativeRenderer.entries[route.entryName],
+          ...(Object.hasOwn(nativeRenderer, 'workerFederation')
+            ? { workerFederation: nativeRenderer.workerFederation }
+            : {}),
+          ...(Object.hasOwn(nativeRenderer, 'workerFederationManifestUrl')
+            ? {
+                workerFederationManifestUrl:
+                  nativeRenderer.workerFederationManifestUrl,
+              }
+            : {}),
+          ...(Object.hasOwn(nativeRenderer, 'workerFederationServices')
+            ? {
+                workerFederationServices:
+                  nativeRenderer.workerFederationServices,
+              }
+            : {}),
+        }
       : undefined;
   // Native renderers have no Flight transport. Reject before the bundle loads.
   if (

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

@@ -9,8 +9,8 @@ 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 } = 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.';
+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();
 function effectTsgoResolutionError(cause, stage, from) {
     const detail = cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause);
@@ -19,10 +19,10 @@ function effectTsgoResolutionError(cause, stage, from) {
     });
 }
 function resolveExecutableEffectTsgoCompiler(compilerPath) {
-    if ('win32' === process.platform) return compilerPath;
     const sourcePath = realpathSync(compilerPath);
     const source = lstatSync(sourcePath);
-    if (!source.isFile()) throw new Error(`Effect TS-Go compiler path is not a regular file: ${sourcePath}`);
+    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;
@@ -72,7 +72,9 @@ function getBuildConfigEnvironment(name) {
 function resolveEffectTsgoCompiler(options) {
     const configuredCompiler = getBuildConfigEnvironment('EFFECT_TSGO_BIN')?.trim();
     if (configuredCompiler) try {
-        return resolveExecutableEffectTsgoCompiler(configuredCompiler);
+        const compiler = resolveExecutableEffectTsgoCompiler(configuredCompiler);
+        validateConfiguredEffectCompiler(compiler, options.from);
+        return compiler;
     } catch (cause) {
         throw effectTsgoResolutionError(cause, 'Configured compiler validation', options.from);
     }

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

@@ -1,3 +1,4 @@
+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";
@@ -8,7 +9,14 @@ 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;
 }
@@ -26,7 +34,7 @@ function resolveEffectTsgoPackage(from) {
         cliPath
     };
 }
-function isAbsentNativeTypeScriptPackage(projectRequire, from, packageName, error) {
+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 {
@@ -47,7 +55,7 @@ function resolveNativeTypeScriptPackage(from) {
         try {
             packageJsonPath = projectRequire.resolve(`${packageName}/package.json`);
         } catch (error) {
-            if (isAbsentNativeTypeScriptPackage(projectRequire, from, packageName, error)) continue;
+            if (isAbsentPackage(projectRequire, from, packageName, error)) continue;
             throw error;
         }
         const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
@@ -71,10 +79,85 @@ function readCompilerArtifact(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'));
@@ -92,11 +175,13 @@ function resolveInstalledEffectCompiler(from) {
         const metadataPath = join(dirname(effectManifest), 'lib', 'upstream.json');
         const metadata = JSON.parse(readFileSync(metadataPath, 'utf8'));
         const component = metadata.components?.typescript?.[native.version];
-        if (5 !== metadata.schemaVersion || component?.provider !== "typescript-go" || component.gitHead !== native.gitHead) throw new Error(`Effect replacement metadata does not match the selected native TypeScript backend: ${metadataPath}`);
-        return readCompilerArtifact(join(dirname(effectManifest), 'artifacts', "typescript", native.version, binaryName));
+        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 };
+export { effectCompilerDiscoveryFailureStage, resolveInstalledEffectCompiler, validateConfiguredEffectCompiler };