@swimmingliu/autovpn 1.6.5 → 1.6.7

package/dist/pipeline/obfuscate.js

@@ -1,6 +1,3 @@
-import path from 'node:path';
-import { spawn as defaultSpawn } from 'node:child_process';
-import { mergeProjectEnv } from '../runtime/env.js';
 const DEFAULT_WORKER_BUILD_CONFIG = {
     environment_name: 'production',
     entry_filename: '_worker.js',
@@ -15,26 +12,6 @@ const DEFAULT_WORKER_BUILD_CONFIG = {
     enable_identifier_randomization: true,
     emit_sidecar_modules: true
 };
-const PYTHON_OBFUSCATE_HELPER = `
-import json
-import sys
-from vpn_automation.config.models import WorkerBuildConfig
-from vpn_automation.pipeline.worker_build import build_worker_artifacts
-
-payload = json.load(sys.stdin)
-config = WorkerBuildConfig(**(payload.get("config") or {}))
-artifacts = build_worker_artifacts(payload["rendered_source"], config, payload["secret_query"])
-json.dump(
-    {
-        "transformed_source": artifacts.transformed_source,
-        "modules": artifacts.modules,
-        "manifest": artifacts.manifest,
-    },
-    sys.stdout,
-    ensure_ascii=False,
-)
-sys.stdout.write("\\n")
-`;
 function jsonStringLiteral(value) {
     return JSON.stringify(value);
 }
@@ -139,63 +116,7 @@ export function buildWorkerArtifacts(renderedSource, configInput = {}, secretQue
         }
     };
 }
-export function selectPipelineStageBackend(stage, env = process.env) {
-    void stage;
-    void env;
-    return 'node';
-}
-async function defaultResolvePythonCli(env) {
-    // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.
-    const runner = await import('../../lib/runner.mjs');
-    return runner.resolveOrInstallPythonCli({ env });
-}
-function pythonCommandFor(resolved) {
-    const command = resolved.command;
-    const name = path.basename(command).toLowerCase();
-    if (['autovpn', 'autovpn.exe'].includes(name)) {
-        const executable = process.platform === 'win32' ? 'python.exe' : 'python';
-        return path.join(path.dirname(command), executable);
-    }
-    return process.platform === 'win32' ? 'python.exe' : 'python3';
-}
-async function obfuscateWithPython(input, options) {
-    const env = mergeProjectEnv(options.cwd ?? process.cwd(), options.env ?? process.env);
-    const resolved = options.resolvePythonCli ? await options.resolvePythonCli() : await defaultResolvePythonCli(env);
-    const child = (options.spawn ?? defaultSpawn)(pythonCommandFor(resolved), ['-c', PYTHON_OBFUSCATE_HELPER], {
-        cwd: options.cwd ?? process.cwd(),
-        env,
-        stdio: ['pipe', 'pipe', 'pipe']
-    });
-    let stdout = '';
-    let stderr = '';
-    child.stdout?.on('data', (chunk) => {
-        stdout += String(chunk);
-    });
-    child.stderr?.on('data', (chunk) => {
-        stderr += String(chunk);
-    });
-    const completion = new Promise((resolve, reject) => {
-        child.on('error', reject);
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Python obfuscate backend failed with exit code ${code}: ${stderr.trim()}`));
-                return;
-            }
-            try {
-                resolve(JSON.parse(stdout));
-            }
-            catch (error) {
-                reject(new Error(`Python obfuscate backend returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`));
-            }
-        });
-    });
-    child.stdin?.write(JSON.stringify(input));
-    child.stdin?.end();
-    return completion;
-}
 export async function buildWorkerArtifactsWithBackend(input, options = {}) {
-    if (selectPipelineStageBackend('obfuscate', options.env ?? process.env) === 'python') {
-        return options.pythonObfuscate ? options.pythonObfuscate(input) : obfuscateWithPython(input, options);
-    }
+    void options;
     return buildWorkerArtifacts(input.rendered_source, input.config, input.secret_query);
 }

package/dist/pipeline/orchestrator.js

@@ -5,6 +5,7 @@ import { parse } from '@iarna/toml';
 import { mergeProjectEnv } from '../runtime/env.js';
 import { resolveArtifactsRoot, resolveProfilePath } from '../runtime/paths.js';
 import { redactText } from '../runtime/redaction.js';
+import { resolveWorkerTemplatePath } from '../runtime/templates.js';
 import { fetchSourceLinksWithBackend } from './extract.js';
 import { canonicalVmessKey, dedupeVmessLinksWithBackend, parseVmessLink } from './dedupe.js';
 import { normalizeSpeedTestConfig, probeSpeedtestLinksInNode, selectSpeedtestCandidates, speedtestLinksWithBackend, testSpeedtestLinkInNode } from './speedtest.js';
@@ -284,32 +285,28 @@ async function restoreResumeSpeedResults(artifactDir, eventLog, passedLinks) {
 }
 async function forEachWithConcurrency(items, concurrency, mapper) {
     let nextIndex = 0;
+    let failed = false;
+    let firstError;
     const workerCount = Math.max(1, Math.min(Math.max(1, Math.floor(concurrency)), items.length));
-    await Promise.all(Array.from({ length: workerCount }, async () => {
-        while (nextIndex < items.length) {
+    const workers = Array.from({ length: workerCount }, async () => {
+        while (nextIndex < items.length && !failed) {
             const index = nextIndex;
             nextIndex += 1;
-            await mapper(items[index]);
-        }
-    }));
-}
-function createLimiter(concurrency) {
-    const limit = Math.max(1, Math.trunc(concurrency));
-    let active = 0;
-    const queue = [];
-    return async (task) => {
-        if (active >= limit) {
-            await new Promise((resolve) => queue.push(resolve));
-        }
-        active += 1;
-        try {
-            return await task();
-        }
-        finally {
-            active -= 1;
-            queue.shift()?.();
+            try {
+                await mapper(items[index]);
+            }
+            catch (error) {
+                if (!failed) {
+                    failed = true;
+                    firstError = error;
+                }
+            }
         }
-    };
+    });
+    await Promise.allSettled(workers);
+    if (failed) {
+        throw firstError;
+    }
 }
 async function speedtestResumeStateFromEventLog(eventLog) {
     const probes = new Map();
@@ -417,98 +414,6 @@ export async function runNodePipeline(options, context = {}) {
         let availabilityResults = [];
         let availableLinks = [];
         const streamedDeduped = new Set();
-        const speedTasks = [];
-        const availabilityTasks = [];
-        const limitSpeedtest = createLimiter(Number(speedConfig.concurrency ?? 1));
-        const limitAvailability = createLimiter(Number(speedConfig.concurrency ?? 1));
-        let speedCompleted = 0;
-        let availabilityCompleted = 0;
-        let speedArtifactFlush = Promise.resolve();
-        let availabilityArtifactFlush = Promise.resolve();
-        const flushStreamingSpeedArtifacts = async () => {
-            const resultSnapshot = [...speedResults];
-            const linkSnapshot = [...passedSpeedLinks];
-            speedArtifactFlush = speedArtifactFlush.catch(() => undefined).then(async () => {
-                summary.counts.speedtest_links = linkSnapshot.length;
-                await writeLines(artifactDir, 'vpn_node_speedtest.txt', linkSnapshot);
-                await writeJson(artifactDir, 'vpn_node_speedtest_report.json', resultSnapshot);
-                await writeReport();
-            });
-            await speedArtifactFlush;
-        };
-        const flushStreamingAvailabilityArtifacts = async () => {
-            const resultSnapshot = [...availabilityResults];
-            const linkSnapshot = resultSnapshot.filter((result) => result.all_passed).map((result) => result.link);
-            availabilityArtifactFlush = availabilityArtifactFlush.catch(() => undefined).then(async () => {
-                summary.counts.availability_links = linkSnapshot.length;
-                await writeLines(artifactDir, 'vpn_node_availability.txt', linkSnapshot);
-                await writeJson(artifactDir, 'vpn_node_availability_report.json', resultSnapshot);
-                await writeReport();
-            });
-            await availabilityArtifactFlush;
-        };
-        const runStreamingAvailability = (speedResult) => {
-            const task = limitAvailability(async () => {
-                const results = context.stages?.availability
-                    ? await context.stages.availability([speedResult], profile.speed_test ?? {}, runtimePath, profile.availability_targets)
-                    : await checkLinkAvailabilityBatchWithBackend({
-                        results: [speedResult],
-                        config: profile.speed_test ?? {},
-                        runtime_path: runtimePath,
-                        targets: profile.availability_targets
-                    }, { cwd: projectRoot, env: runtimeStageEnv });
-                for (const result of results) {
-                    availabilityResults.push(result);
-                    availabilityCompleted += 1;
-                    await flushStreamingAvailabilityArtifacts();
-                    emit('availability_link_result', {
-                        completed: availabilityCompleted,
-                        total: passedSpeedLinks.length,
-                        link: result.link,
-                        all_passed: result.all_passed,
-                        provider_results: result.provider_results
-                    });
-                }
-            });
-            availabilityTasks.push(task);
-            task.catch(() => undefined);
-        };
-        const runStreamingSpeedtest = (link) => {
-            const task = limitSpeedtest(async () => {
-                const result = context.stages?.speedtestLink
-                    ? await context.stages.speedtestLink(link, profile.speed_test ?? {}, runtimePath)
-                    : await testSpeedtestLinkInNode({ link, config: profile.speed_test, runtime_path: runtimePath }, {
-                        cwd: projectRoot,
-                        env: runtimeStageEnv
-                    });
-                speedResults.push(result);
-                speedCompleted += 1;
-                const passed = result.reachable && result.average_download_mb_s >= speedConfig.min_download_mb_s;
-                emit('speedtest_result', {
-                    completed: speedCompleted,
-                    total: dedupedLinks.length,
-                    link: result.link,
-                    reachable: result.reachable,
-                    average_download_mb_s: result.average_download_mb_s,
-                    latency_ms: result.latency_ms,
-                    passed_threshold: passed,
-                    error: result.error ?? ''
-                });
-                emit('log', {
-                    message: `[speedtest] ${speedCompleted}/${dedupedLinks.length} reachable=${result.reachable} speed=${result.average_download_mb_s}MB/s`
-                });
-                if (passed) {
-                    passedSpeedLinks.push(result.link);
-                    await flushStreamingSpeedArtifacts();
-                    runStreamingAvailability(result);
-                }
-                else if (useStreamingStages) {
-                    await flushStreamingSpeedArtifacts();
-                }
-            });
-            speedTasks.push(task);
-            task.catch(() => undefined);
-        };
         const onExtractedLinks = async (links) => {
             for (const link of links) {
                 rawLinks.push(link);
@@ -518,7 +423,6 @@ export async function runNodePipeline(options, context = {}) {
                 }
                 streamedDeduped.add(key);
                 dedupedLinks.push(link);
-                runStreamingSpeedtest(link);
             }
         };
         await setStage('extract', 'running');
@@ -593,8 +497,81 @@ export async function runNodePipeline(options, context = {}) {
             emit('log', {
                 message: `[speedtest] runtime_core=${requestedRuntime === 'direct' ? 'direct' : 'mihomo'} probe_url=${speedConfig.probe_url}`
             });
-            await Promise.all(speedTasks);
-            await Promise.all(availabilityTasks);
+            const probes = context.stages?.speedtestProbe
+                ? await context.stages.speedtestProbe(dedupedLinks, profile.speed_test ?? {}, runtimePath)
+                : await probeSpeedtestLinksInNode({ links: dedupedLinks, config: profile.speed_test, runtime_path: runtimePath }, {
+                    cwd: projectRoot,
+                    env: runtimeStageEnv
+                });
+            for (let index = 0; index < probes.length; index += 1) {
+                const result = probes[index];
+                emit('log', { message: `[speedtest:probe] ${index + 1}/${dedupedLinks.length} reachable=${result.reachable} latency=${result.latency_ms}ms` });
+                emit('speedtest_probe_result', {
+                    completed: index + 1,
+                    total: dedupedLinks.length,
+                    link: result.link,
+                    reachable: result.reachable,
+                    latency_ms: result.latency_ms,
+                    error: result.error ?? ''
+                });
+            }
+            const candidateLinks = selectSpeedtestCandidates(probes, speedConfig.max_download_candidates);
+            const reachableCount = probes.filter((probe) => probe.reachable).length;
+            emit('log', { message: `[speedtest] selected ${candidateLinks.length}/${reachableCount} reachable links for full download test` });
+            emit('speedtest_selected', {
+                total_links: dedupedLinks.length,
+                reachable_count: reachableCount,
+                candidate_count: candidateLinks.length
+            });
+            const probeByLink = new Map(probes.map((probe) => [probe.link, probe]));
+            const resultByLink = new Map();
+            for (const probe of probes) {
+                if (!probe.reachable) {
+                    resultByLink.set(probe.link, {
+                        link: probe.link,
+                        reachable: false,
+                        average_download_mb_s: 0,
+                        latency_ms: probe.latency_ms,
+                        error: probe.error ?? ''
+                    });
+                }
+            }
+            let speedCompleted = 0;
+            await forEachWithConcurrency(candidateLinks, speedConfig.concurrency, async (link) => {
+                const result = context.stages?.speedtestLink
+                    ? await context.stages.speedtestLink(link, profile.speed_test ?? {}, runtimePath)
+                    : await testSpeedtestLinkInNode({ link, config: profile.speed_test, runtime_path: runtimePath }, {
+                        cwd: projectRoot,
+                        env: runtimeStageEnv
+                    });
+                if (result.reachable && result.latency_ms <= 0) {
+                    result.latency_ms = probeByLink.get(result.link)?.latency_ms ?? 0;
+                }
+                resultByLink.set(result.link, result);
+                speedCompleted += 1;
+                const passed = result.reachable && result.average_download_mb_s >= speedConfig.min_download_mb_s;
+                emit('speedtest_result', {
+                    completed: speedCompleted,
+                    total: candidateLinks.length,
+                    link: result.link,
+                    reachable: result.reachable,
+                    average_download_mb_s: result.average_download_mb_s,
+                    latency_ms: result.latency_ms,
+                    passed_threshold: passed,
+                    error: result.error ?? ''
+                });
+                emit('log', {
+                    message: `[speedtest] ${speedCompleted}/${candidateLinks.length} reachable=${result.reachable} speed=${result.average_download_mb_s}MB/s`
+                });
+            });
+            speedResults = [
+                ...probes.filter((probe) => !probe.reachable).map((probe) => resultByLink.get(probe.link)),
+                ...candidateLinks.map((link) => resultByLink.get(link)).filter((result) => Boolean(result))
+            ];
+            passedSpeedLinks = candidateLinks.filter((link) => {
+                const result = resultByLink.get(link);
+                return Boolean(result?.reachable && result.average_download_mb_s >= speedConfig.min_download_mb_s);
+            });
         }
         else {
             speedResults = context.stages?.speedtest
@@ -621,20 +598,22 @@ export async function runNodePipeline(options, context = {}) {
         }
         const speedResultByLink = new Map(speedResults.map((result) => [result.link, result]));
         const candidateSpeedResults = passedSpeedLinks.map((link) => speedResultByLink.get(link)).filter((result) => Boolean(result));
-        availabilityResults = useStreamingStages
-            ? availabilityResults
-            : context.stages?.availability
-                ? await context.stages.availability(candidateSpeedResults, profile.speed_test ?? {}, runtimePath, profile.availability_targets)
-                : await checkLinkAvailabilityBatchWithBackend({
-                    results: candidateSpeedResults,
-                    config: profile.speed_test ?? {},
-                    runtime_path: runtimePath,
-                    targets: profile.availability_targets
-                }, { cwd: projectRoot, env: runtimeStageEnv });
+        availabilityResults = context.stages?.availability
+            ? await context.stages.availability(candidateSpeedResults, profile.speed_test ?? {}, runtimePath, profile.availability_targets)
+            : await checkLinkAvailabilityBatchWithBackend({
+                results: candidateSpeedResults,
+                config: profile.speed_test ?? {},
+                runtime_path: runtimePath,
+                targets: profile.availability_targets
+            }, { cwd: projectRoot, env: runtimeStageEnv });
         availableLinks = availabilityResults.filter((result) => result.all_passed).map((result) => result.link);
         summary.counts.availability_links = availableLinks.length;
         await writeLines(artifactDir, 'vpn_node_availability.txt', availableLinks);
         await writeJson(artifactDir, 'vpn_node_availability_report.json', availabilityResults);
+        if (passedSpeedLinks.length > 0 && availableLinks.length === 0) {
+            await setStage('availability', 'failed');
+            throw new Error('No links passed availability');
+        }
         await setStage('availability', 'success', !useStreamingStages);
         await setStage('postprocess', 'running');
         const countryLookup = context.stages?.countryLookup ?? defaultCountryFor;
@@ -650,7 +629,7 @@ export async function runNodePipeline(options, context = {}) {
         await writeLines(artifactDir, 'vpn_node_emoji.txt', postprocessed.links);
         await setStage('postprocess', 'success');
         await setStage('render', 'running');
-        const template = await readFile(path.join(projectRoot, 'templates', 'vmess_node.js'), 'utf8');
+        const template = await readFile(resolveWorkerTemplatePath(projectRoot), 'utf8');
         const rendered = await renderMainDataWithBackend({ template, links: postprocessed.links }, { cwd: projectRoot, env });
         await setStage('render', 'success');
         await setStage('obfuscate', 'running');
@@ -819,6 +798,8 @@ export async function retryNodePipelineStage(options, context = {}) {
                 await writeReport();
                 throw new Error('No links passed availability');
             }
+            const availableLinkSet = new Set(availableLinks);
+            availabilityResults = availabilityResults.filter((result) => availableLinkSet.has(result.link));
             await setStage('availability', 'success');
         }
         else if (isStageAtOrAfter(stage, 'postprocess')) {
@@ -861,7 +842,7 @@ export async function retryNodePipelineStage(options, context = {}) {
                 throw new Error('No postprocess output available to retry render');
             }
             await setStage('render', 'running');
-            const template = await readFile(path.join(projectRoot, 'templates', 'vmess_node.js'), 'utf8');
+            const template = await readFile(resolveWorkerTemplatePath(projectRoot), 'utf8');
             const rendered = await renderMainDataWithBackend({ template, links: finalLinks }, { cwd: projectRoot, env });
             await writeFile(path.join(retryArtifactDir, 'vmess_node.js'), rendered.rendered_source, 'utf8');
             await setStage('render', 'success');
@@ -1185,7 +1166,7 @@ export async function resumeNodePipeline(options, context = {}) {
         }
         await setStage('postprocess', 'success');
         await setStage('render', 'running');
-        const template = await readFile(path.join(projectRoot, 'templates', 'vmess_node.js'), 'utf8');
+        const template = await readFile(resolveWorkerTemplatePath(projectRoot), 'utf8');
         const rendered = await renderMainDataWithBackend({ template, links: postprocessed.links }, { cwd: projectRoot, env });
         await writeFile(path.join(artifactDir, 'vmess_node.js'), rendered.rendered_source, 'utf8');
         await setStage('render', 'success');

package/dist/pipeline/postprocess.js

@@ -1,6 +1,3 @@
-import path from 'node:path';
-import { spawn as defaultSpawn } from 'node:child_process';
-import { mergeProjectEnv } from '../runtime/env.js';
 const EMOJI_MAP = {
     AE: '🇦🇪',
     AR: '🇦🇷',
@@ -46,30 +43,6 @@ const DEFAULT_FILTERS = {
     per_country_limit: {}
 };
 const LEADING_EMOJI_AND_COUNTRY_PATTERN = /^(?:\S+\s+)?([A-Za-z]{2})\s+(.*)$/;
-const PYTHON_POSTPROCESS_HELPER = `
-import json
-import sys
-from vpn_automation.config.models import FilterConfig
-from vpn_automation.pipeline.postprocess import decorate_link_with_country, select_links_by_country_limit
-
-payload = json.load(sys.stdin)
-filters = payload.get("filters")
-ranked_links = payload.get("ranked_links") or []
-filter_config = FilterConfig() if filters is None else FilterConfig(
-    excluded_country_codes=list(filters.get("excluded_country_codes") or []),
-    per_country_limit=dict(filters.get("per_country_limit") or {}),
-)
-selected = select_links_by_country_limit(
-    [(item["link"], {}, item.get("country_code") or item.get("countryCode") or "") for item in ranked_links],
-    filter_config,
-)
-country_by_link = {
-    item["link"]: item.get("country_code") or item.get("countryCode") or ""
-    for item in ranked_links
-}
-json.dump({"links": [decorate_link_with_country(link, country_by_link[link]) for link in selected]}, sys.stdout, ensure_ascii=False)
-sys.stdout.write("\\n")
-`;
 export function parseVmessLink(link) {
     const encoded = link.replace(/^vmess:\/\//, '');
     const padded = encoded + '='.repeat((4 - (encoded.length % 4)) % 4);
@@ -149,64 +122,7 @@ export function runPostprocess(input) {
         links: selected.map((link) => decorateLinkWithCountry(link, countries.get(link) ?? ''))
     };
 }
-export function selectPipelineStageBackend(stage, env = process.env) {
-    void stage;
-    void env;
-    return 'node';
-}
-async function defaultResolvePythonCli(env) {
-    // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.
-    const runner = await import('../../lib/runner.mjs');
-    return runner.resolveOrInstallPythonCli({ env });
-}
-function pythonCommandFor(resolved) {
-    const command = resolved.command;
-    const name = path.basename(command).toLowerCase();
-    if (['autovpn', 'autovpn.exe'].includes(name)) {
-        const executable = process.platform === 'win32' ? 'python.exe' : 'python';
-        return path.join(path.dirname(command), executable);
-    }
-    return process.platform === 'win32' ? 'python.exe' : 'python3';
-}
-async function postprocessWithPython(input, options) {
-    const env = mergeProjectEnv(options.cwd ?? process.cwd(), options.env ?? process.env);
-    const resolved = options.resolvePythonCli ? await options.resolvePythonCli() : await defaultResolvePythonCli(env);
-    const helperInput = { ...input, filters: resolveFilters(input.filters) };
-    const child = (options.spawn ?? defaultSpawn)(pythonCommandFor(resolved), ['-c', PYTHON_POSTPROCESS_HELPER], {
-        cwd: options.cwd ?? process.cwd(),
-        env,
-        stdio: ['pipe', 'pipe', 'pipe']
-    });
-    let stdout = '';
-    let stderr = '';
-    child.stdout?.on('data', (chunk) => {
-        stdout += String(chunk);
-    });
-    child.stderr?.on('data', (chunk) => {
-        stderr += String(chunk);
-    });
-    const completion = new Promise((resolve, reject) => {
-        child.on('error', reject);
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Python postprocess backend failed with exit code ${code}: ${stderr.trim()}`));
-                return;
-            }
-            try {
-                resolve(JSON.parse(stdout));
-            }
-            catch (error) {
-                reject(new Error(`Python postprocess backend returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`));
-            }
-        });
-    });
-    child.stdin?.write(JSON.stringify(helperInput));
-    child.stdin?.end();
-    return completion;
-}
 export async function postprocessLinksWithBackend(input, options = {}) {
-    if (selectPipelineStageBackend('postprocess', options.env ?? process.env) === 'python') {
-        return options.pythonPostprocess ? options.pythonPostprocess(input) : postprocessWithPython(input, options);
-    }
+    void options;
     return runPostprocess(input);
 }

package/dist/pipeline/proxy-runtime.js

@@ -274,6 +274,11 @@ export async function openMihomoRuntime(link, options = {}) {
         child.off('error', onStartupError);
         child.on('error', () => { });
         await close();
+        if (error instanceof Error
+            && error.name !== 'AbortError'
+            && /^proxy port \d+ did not open in time$/.test(error.message)) {
+            error.code = 'AUTOVPN_INTERNAL_TIMEOUT';
+        }
         throw error;
     }
     return {

package/dist/pipeline/render.js

@@ -1,20 +1,4 @@
-import path from 'node:path';
-import { spawn as defaultSpawn } from 'node:child_process';
-import { mergeProjectEnv } from '../runtime/env.js';
 export const MAIN_DATA_PLACEHOLDER = '__MAIN_DATA__';
-const PYTHON_RENDER_HELPER = `
-import json
-import sys
-from vpn_automation.pipeline.render import replace_main_data
-
-payload = json.load(sys.stdin)
-json.dump(
-    {"rendered_source": replace_main_data(payload["template"], list(payload.get("links") or []))},
-    sys.stdout,
-    ensure_ascii=False,
-)
-sys.stdout.write("\\n")
-`;
 export function replaceMainData(template, links) {
     const occurrences = template.split(MAIN_DATA_PLACEHOLDER).length - 1;
     if (occurrences !== 1) {
@@ -27,63 +11,7 @@ export function runRender(input) {
         rendered_source: replaceMainData(input.template, input.links ?? [])
     };
 }
-export function selectPipelineStageBackend(stage, env = process.env) {
-    void stage;
-    void env;
-    return 'node';
-}
-async function defaultResolvePythonCli(env) {
-    // @ts-expect-error Phase 1 runner remains plain ESM JavaScript.
-    const runner = await import('../../lib/runner.mjs');
-    return runner.resolveOrInstallPythonCli({ env });
-}
-function pythonCommandFor(resolved) {
-    const command = resolved.command;
-    const name = path.basename(command).toLowerCase();
-    if (['autovpn', 'autovpn.exe'].includes(name)) {
-        const executable = process.platform === 'win32' ? 'python.exe' : 'python';
-        return path.join(path.dirname(command), executable);
-    }
-    return process.platform === 'win32' ? 'python.exe' : 'python3';
-}
-async function renderWithPython(input, options) {
-    const env = mergeProjectEnv(options.cwd ?? process.cwd(), options.env ?? process.env);
-    const resolved = options.resolvePythonCli ? await options.resolvePythonCli() : await defaultResolvePythonCli(env);
-    const child = (options.spawn ?? defaultSpawn)(pythonCommandFor(resolved), ['-c', PYTHON_RENDER_HELPER], {
-        cwd: options.cwd ?? process.cwd(),
-        env,
-        stdio: ['pipe', 'pipe', 'pipe']
-    });
-    let stdout = '';
-    let stderr = '';
-    child.stdout?.on('data', (chunk) => {
-        stdout += String(chunk);
-    });
-    child.stderr?.on('data', (chunk) => {
-        stderr += String(chunk);
-    });
-    const completion = new Promise((resolve, reject) => {
-        child.on('error', reject);
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Python render backend failed with exit code ${code}: ${stderr.trim()}`));
-                return;
-            }
-            try {
-                resolve(JSON.parse(stdout));
-            }
-            catch (error) {
-                reject(new Error(`Python render backend returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`));
-            }
-        });
-    });
-    child.stdin?.write(JSON.stringify(input));
-    child.stdin?.end();
-    return completion;
-}
 export async function renderMainDataWithBackend(input, options = {}) {
-    if (selectPipelineStageBackend('render', options.env ?? process.env) === 'python') {
-        return options.pythonRender ? options.pythonRender(input) : renderWithPython(input, options);
-    }
+    void options;
     return runRender(input);
 }