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

package/dist/esm/cloudflare-output-verifier/mutation-policy.mjs

@@ -1,7 +1,8 @@
 import promises from "node:fs/promises";
 import node_path from "node:path";
 import { addIssue } from "./issues.mjs";
-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',
@@ -74,7 +75,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;
 };
@@ -91,7 +92,26 @@ const verifyCloudflareOutputMutationPolicy = async (options)=>{
             if ('ENOENT' === error.code) continue;
             throw error;
         }
-        for (const forbidden of FORBIDDEN_MUTATION_PATTERNS)if (forbidden.pattern.test(source)) addIssue(issues, {
+        let executableSources = [
+            source
+        ];
+        if ('package.json' === node_path.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  {
+            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))) addIssue(issues, {
             code: forbidden.code,
             message: forbidden.message,
             path: file
@@ -102,4 +122,5 @@ const verifyCloudflareOutputMutationPolicy = async (options)=>{
         issues
     };
 };
+const isRecord = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
 export { verifyCloudflareOutputMutationPolicy, walkFiles };

package/dist/esm/native-type-checker.mjs

@@ -1,29 +1,59 @@
-import { execFile } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { existsSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import node_path from "node:path";
 import { promisify } from "node:util";
 import { refreshTsgoCheckerConfig } from "@modern-js/builder";
 import { parse, printParseErrorCode } from "jsonc-parser";
+import { resolveEffectTsgoCompiler } from "./build-config/build-environment.mjs";
 const execute = promisify(execFile);
 const native_type_checker_name = 'UltramodernNativeTypeChecker';
-function resolveNativeTypeCheckerCommand(packageJsonPath) {
-    const manifestFile = realpathSync(packageJsonPath);
-    const directory = node_path.dirname(manifestFile);
-    const manifest = JSON.parse(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 || node_path.isAbsolute(bin)) throw new Error(`${native_type_checker_name} requires the selected package's public tsc bin.`);
-    const launcher = realpathSync(node_path.resolve(directory, bin));
-    const relative = node_path.relative(directory, launcher);
-    if (!relative || node_path.isAbsolute(relative) || '..' === relative || relative.startsWith(`..${node_path.sep}`) || !statSync(launcher).isFile()) throw new Error(`${native_type_checker_name} public tsc bin must belong to its selected package.`);
+function resolveNativeTypeCheckerCommand(from) {
+    const executable = resolveEffectTsgoCompiler({
+        from
+    });
+    const version = 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: 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 {
@@ -135,19 +165,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: node_path.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
             });
         }
     }
@@ -209,9 +257,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/esm/release-identity.mjs

@@ -20,7 +20,7 @@ const gitOutput = (workspaceRoot, args)=>{
         return;
     }
 };
-const createUltramodernReleaseBuildMarker = ({ generationBuildMarker, sourceRevision, unitId })=>createHash('sha256').update(`${BUILD_MARKER_NAMESPACE}:${unitId}:${generationBuildMarker}:${sourceRevision}`).digest('hex').slice(0, 16);
+const createUltramodernReleaseBuildMarker = ({ generationBuildMarker, sourceRevision, unitId })=>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/esm/renderer-build-identity.mjs

@@ -10,6 +10,7 @@ const LOCKFILES = [
     'bun.lock',
     'bun.lockb'
 ];
+const RELEASE_BUILD_MARKER_PATTERN = /^[a-f0-9]{64}$/u;
 const processNonce = randomUUID();
 const sha256 = (value)=>createHash('sha256').update(value).digest('hex');
 function rendererProfileKey(profile) {
@@ -54,12 +55,21 @@ function resolveRendererBuildIdentities(options) {
     const projectRoot = node_path.resolve(options.projectRoot);
     const appId = options.appId ?? JSON.parse(node_fs.readFileSync(node_path.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 = resolveUltramodernSourceRevision(projectRoot, options.sourceRevision);
-    const buildId = sha256(JSON.stringify([
+    const sourceRevision = 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/esm/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-node/build-config/build-environment.mjs

@@ -10,8 +10,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);
@@ -20,10 +20,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;
@@ -73,7 +73,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-node/build-config/internal-effect-discovery.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+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";
@@ -9,7 +10,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;
 }
@@ -27,7 +35,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 {
@@ -48,7 +56,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'));
@@ -72,10 +80,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'));
@@ -93,11 +176,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 };

package/dist/esm-node/cloudflare-output-verifier/mutation-policy.mjs

@@ -2,7 +2,8 @@ import "node:module";
 import promises from "node:fs/promises";
 import node_path from "node:path";
 import { addIssue } from "./issues.mjs";
-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',
@@ -75,7 +76,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;
 };
@@ -92,7 +93,26 @@ const verifyCloudflareOutputMutationPolicy = async (options)=>{
             if ('ENOENT' === error.code) continue;
             throw error;
         }
-        for (const forbidden of FORBIDDEN_MUTATION_PATTERNS)if (forbidden.pattern.test(source)) addIssue(issues, {
+        let executableSources = [
+            source
+        ];
+        if ('package.json' === node_path.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  {
+            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))) addIssue(issues, {
             code: forbidden.code,
             message: forbidden.message,
             path: file
@@ -103,4 +123,5 @@ const verifyCloudflareOutputMutationPolicy = async (options)=>{
         issues
     };
 };
+const isRecord = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
 export { verifyCloudflareOutputMutationPolicy, walkFiles };

package/dist/esm-node/native-type-checker.mjs

@@ -1,30 +1,60 @@
 import "node:module";
-import { execFile } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { existsSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import node_path from "node:path";
 import { promisify } from "node:util";
 import { refreshTsgoCheckerConfig } from "@modern-js/builder";
 import { parse, printParseErrorCode } from "jsonc-parser";
+import { resolveEffectTsgoCompiler } from "./build-config/build-environment.mjs";
 const execute = promisify(execFile);
 const native_type_checker_name = 'UltramodernNativeTypeChecker';
-function resolveNativeTypeCheckerCommand(packageJsonPath) {
-    const manifestFile = realpathSync(packageJsonPath);
-    const directory = node_path.dirname(manifestFile);
-    const manifest = JSON.parse(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 || node_path.isAbsolute(bin)) throw new Error(`${native_type_checker_name} requires the selected package's public tsc bin.`);
-    const launcher = realpathSync(node_path.resolve(directory, bin));
-    const relative = node_path.relative(directory, launcher);
-    if (!relative || node_path.isAbsolute(relative) || '..' === relative || relative.startsWith(`..${node_path.sep}`) || !statSync(launcher).isFile()) throw new Error(`${native_type_checker_name} public tsc bin must belong to its selected package.`);
+function resolveNativeTypeCheckerCommand(from) {
+    const executable = resolveEffectTsgoCompiler({
+        from
+    });
+    const version = 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: 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 {
@@ -136,19 +166,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: node_path.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
             });
         }
     }
@@ -210,9 +258,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/esm-node/release-identity.mjs

@@ -21,7 +21,7 @@ const gitOutput = (workspaceRoot, args)=>{
         return;
     }
 };
-const createUltramodernReleaseBuildMarker = ({ generationBuildMarker, sourceRevision, unitId })=>createHash('sha256').update(`${BUILD_MARKER_NAMESPACE}:${unitId}:${generationBuildMarker}:${sourceRevision}`).digest('hex').slice(0, 16);
+const createUltramodernReleaseBuildMarker = ({ generationBuildMarker, sourceRevision, unitId })=>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();