storm-lua-minify 0.3.0 → 0.9.1

package/dist/minifier.js

@@ -7,18 +7,78 @@ exports.Minifier = void 0;
 const luaparse_1 = __importDefault(require("luaparse"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const source_map_1 = require("source-map");
 const ast2lua_1 = require("./ast2lua");
 const linker_1 = require("./linker");
 const resolver_1 = require("./resolver");
 const renamer_1 = require("./renamer");
 const globalRename_1 = require("./globalRename");
 const transform_1 = require("./transform");
+const sourceMetadata_1 = require("./sourceMetadata");
+const removeUnused_1 = require("./removeUnused");
+const constantFold_1 = require("./constantFold");
+const generatedAst_1 = require("./generatedAst");
+const statementScheduler_1 = require("./statementScheduler");
+const optimizerPass_1 = require("./optimizerPass");
+const runtimeEnvironment_1 = require("./runtimeEnvironment");
+const optimizerDiagnostics_1 = require("./optimizerDiagnostics");
+const optimizerFacts_1 = require("./optimizerFacts");
+const optimizerAnalysis_1 = require("./optimizerAnalysis");
+const interproceduralConstants_1 = require("./interproceduralConstants");
+const functionRewrites_1 = require("./functionRewrites");
+const wholeProgramObjects_1 = require("./wholeProgramObjects");
+const wholeProgramFields_1 = require("./wholeProgramFields");
+const aggregateSpecialization_1 = require("./aggregateSpecialization");
+const wholeProgramExports_1 = require("./wholeProgramExports");
+const wholeProgramFieldRenames_1 = require("./wholeProgramFieldRenames");
+const options_1 = require("./options");
 const NO_RENAME = {
     nameOf: () => undefined,
     usedNames: new Set(),
 };
+class CostVariantProgress {
+    target;
+    pendingSteps = 0;
+    constructor(target) {
+        this.target = target;
+    }
+    addSteps(count) {
+        this.pendingSteps += count;
+        this.target.addSteps(count);
+    }
+    startStep(label) {
+        if (this.pendingSteps > 0)
+            this.pendingSteps--;
+        this.target.startStep(label);
+    }
+    tick() {
+        this.target.tick();
+    }
+    finishFailedCandidate() {
+        while (this.pendingSteps > 0) {
+            this.pendingSteps--;
+            this.target.startStep("Skip remaining failed cost-gate work");
+        }
+    }
+}
+// Remove consumers before producers. A producer is therefore measured while
+// every downstream transformation that may expose its savings is still active.
+const COST_GATE_ABLATION_ORDER = [
+    "fieldRename",
+    "scheduler",
+    "exportDce",
+    "fieldFact",
+    "aggregateSpecialization",
+    "functionRewrite",
+];
+function sourceRangeOf(node) {
+    return node.range;
+}
+function copyMap(source, target) {
+    target.clear();
+    source.forEach((value, key) => target.set(key, value));
+}
 class Minifier {
+    entryFilePath;
     identifiersInUse;
     moduleSourceText;
     moduleAST;
@@ -35,44 +95,915 @@ class Minifier {
     renameCache = new Map();
     // #8a: プログラム全体を横断して決定された「内部グローバル名 -> 短縮名」の対応
     globalRenames = new Map();
-    constructor(entryFilePath, luaParseSettings, mode) {
+    moduleMetadata = new Map();
+    diagnosticCollector;
+    schedulerVariant;
+    functionRewriteVariant;
+    fieldFactVariant;
+    aggregateSpecializationVariant;
+    exportDceVariant;
+    fieldRenameVariant;
+    progress;
+    // Transactional variants mutate independent AST copies, but their source
+    // bytes and initial parse are identical. Keep one untouched parse template
+    // for the whole variant tree and clone it at each link boundary.
+    inputCache;
+    linkedAstGeneration = 0;
+    wholeProgramObjectsValue;
+    wholeProgramFieldsValue;
+    wholeProgramExportsValue;
+    wholeProgramFieldRenamesValue;
+    constructor(entryFilePath, luaParseSettings, mode, schedulerVariantOrProgress, functionRewriteVariant, fieldFactVariant, aggregateSpecializationVariant, exportDceVariant, fieldRenameVariant, progress, inputCache) {
+        this.schedulerVariant =
+            typeof schedulerVariantOrProgress === "string"
+                ? schedulerVariantOrProgress
+                : undefined;
+        this.functionRewriteVariant = functionRewriteVariant;
+        this.fieldFactVariant = fieldFactVariant;
+        this.aggregateSpecializationVariant = aggregateSpecializationVariant;
+        this.exportDceVariant = exportDceVariant;
+        this.fieldRenameVariant = fieldRenameVariant;
+        this.progress =
+            typeof schedulerVariantOrProgress === "object"
+                ? schedulerVariantOrProgress
+                : progress;
+        this.inputCache = inputCache ?? new Map();
+        this.entryFilePath = entryFilePath;
         this.identifiersInUse = new Set();
         this.moduleSourceText = new Map();
         this.moduleAST = new Map();
         this.moduleNameAndFileName = new Map();
-        this.luaParseSettings = luaParseSettings;
-        this.mode = mode;
+        // コメントの所有関係と自己再帰参照の判定は位置情報を不変条件とする。
+        // 呼び出し側が省略・無効化しても、内部パスに必要な情報は常に収集する。
+        this.luaParseSettings = {
+            ...luaParseSettings,
+            comments: true,
+            locations: true,
+            ranges: true,
+        };
+        this.mode = (0, options_1.resolveMinifierMode)(mode);
+        if (mode.collectOptimizationDiagnostics) {
+            this.diagnosticCollector = new optimizerDiagnostics_1.OptimizationDiagnosticCollector();
+        }
         const pn = path_1.default.parse(entryFilePath);
         this.dir = pn.dir;
         this.entryModule = pn.name;
     }
+    get optimizationDiagnostics() {
+        return this.diagnosticCollector?.diagnostics ?? [];
+    }
+    get wholeProgramObjects() {
+        return this.wholeProgramObjectsValue;
+    }
+    get wholeProgramFields() {
+        return this.wholeProgramFieldsValue;
+    }
+    get wholeProgramExports() {
+        return this.wholeProgramExportsValue;
+    }
+    get wholeProgramFieldRenames() {
+        return this.wholeProgramFieldRenamesValue;
+    }
     parse() {
+        if (this.costGatesToSelect().length > 0)
+            return this.parseWithCostGateSelection();
+        return this.parseOnce();
+    }
+    /**
+     * Evaluate cost-gated transforms as one coalition, then remove a gate only
+     * when its absence makes the complete final output strictly shorter.
+     *
+     * An arbitrary final-byte cost function still requires 2^N evaluations to
+     * find its global minimum. This deterministic backward sweep deliberately
+     * chooses a narrower contract: it keeps interactions present in the full
+     * trial and finds the best point on one monotonic deletion path in at most
+     * N+2 evaluations. The all-off baseline remains the final upper bound.
+     */
+    parseWithCostGateSelection() {
+        const gates = this.costGatesToSelect();
+        const evaluated = new Map();
+        const baseline = this.evaluateCostVariant(this.costGateVariants("baseline"), "Evaluate cost-gated baseline", evaluated);
+        let fullTrial;
+        try {
+            fullTrial = this.evaluateCostVariant(this.costGateVariants("trial"), "Evaluate joint cost-gated trial", evaluated);
+        }
+        catch {
+            this.copyDiagnosticsFrom(baseline.minifier);
+            gates.forEach((gate) => {
+                this.recordFinalGateDecision(gate, "rejected", "trial-failed");
+            });
+            this.recordFinalCostDecision("rejected", "trial-failed");
+            return this.adoptVariant(baseline.minifier, baseline.output);
+        }
+        let current = fullTrial;
+        for (const gate of COST_GATE_ABLATION_ORDER) {
+            if (!gates.includes(gate) || current.variants[gate] === "baseline")
+                continue;
+            const variants = {
+                ...current.variants,
+                [gate]: "baseline",
+                // Specialization is executed inside the function-rewrite pipeline;
+                // keep the mask and final diagnostics closed over that dependency.
+                ...(gate === "functionRewrite"
+                    ? { aggregateSpecialization: "baseline" }
+                    : {}),
+            };
+            let withoutGate;
+            try {
+                withoutGate = this.evaluateCostVariant(variants, `Evaluate joint trial without ${this.costGateLabel(gate)}`, evaluated);
+            }
+            catch {
+                continue;
+            }
+            // Keep ties in the joint trial: a gate whose isolated contribution is
+            // hidden can still participate in a later transformation's savings.
+            if (withoutGate.byteLength < current.byteLength)
+                current = withoutGate;
+        }
+        const accepted = current.byteLength < baseline.byteLength;
+        const selected = accepted ? current : baseline;
+        // Successful trial diagnostics describe attempted opportunities even when
+        // the corresponding AST is not selected, matching the former gate policy.
+        this.copyDiagnosticsFrom(fullTrial.minifier);
+        gates.forEach((gate) => {
+            this.recordFinalGateDecision(gate, accepted && current.variants[gate] === "trial"
+                ? "accepted"
+                : "rejected", accepted && current.variants[gate] === "trial"
+                ? "final-output-shorter"
+                : "final-output-not-shorter");
+        });
+        this.recordFinalCostDecision(accepted ? "accepted" : "rejected", accepted ? "final-output-shorter" : "final-output-not-shorter", accepted ? baseline.byteLength - current.byteLength : undefined);
+        return this.adoptVariant(selected.minifier, selected.output);
+    }
+    evaluateCostVariant(variants, label, evaluated) {
+        const key = COST_GATE_ABLATION_ORDER.map((gate) => variants[gate] === "trial" ? "1" : "0").join("");
+        const cached = evaluated.get(key);
+        if (cached)
+            return cached;
+        this.progress?.addSteps(1);
+        this.progress?.startStep(label);
+        const candidateProgress = this.progress
+            ? new CostVariantProgress(this.progress)
+            : undefined;
+        const minifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, variants.scheduler, variants.functionRewrite, variants.fieldFact, variants.aggregateSpecialization, variants.exportDce, variants.fieldRename, candidateProgress, this.inputCache);
+        let output;
+        try {
+            output = minifier.parseOnce();
+        }
+        catch (error) {
+            candidateProgress?.finishFailedCandidate();
+            throw error;
+        }
+        const result = {
+            minifier,
+            output,
+            byteLength: new TextEncoder().encode(output.toString()).length,
+            variants,
+        };
+        evaluated.set(key, result);
+        return result;
+    }
+    costGateVariants(fallback) {
+        const selected = new Set(this.costGatesToSelect());
+        const variant = (gate, explicit) => explicit ?? (selected.has(gate) ? fallback : "baseline");
+        const functionRewrite = variant("functionRewrite", this.functionRewriteVariant);
+        return {
+            fieldRename: variant("fieldRename", this.fieldRenameVariant),
+            scheduler: variant("scheduler", this.schedulerVariant),
+            exportDce: variant("exportDce", this.exportDceVariant),
+            fieldFact: variant("fieldFact", this.fieldFactVariant),
+            aggregateSpecialization: functionRewrite === "baseline"
+                ? "baseline"
+                : variant("aggregateSpecialization", this.aggregateSpecializationVariant),
+            functionRewrite,
+        };
+    }
+    costGatesToSelect() {
+        return COST_GATE_ABLATION_ORDER.filter((gate) => {
+            switch (gate) {
+                case "fieldRename":
+                    return (this.fieldRenameVariant === undefined && this.fieldRenamesEnabled());
+                case "scheduler":
+                    return (this.schedulerVariant === undefined &&
+                        this.requiresSchedulerSelection());
+                case "exportDce":
+                    return this.exportDceVariant === undefined && this.exportDceEnabled();
+                case "fieldFact":
+                    return (this.fieldFactVariant === undefined && this.fieldFactsEnabled());
+                case "aggregateSpecialization":
+                    return (this.aggregateSpecializationVariant === undefined &&
+                        this.functionSpecializationEnabled());
+                case "functionRewrite":
+                    return (this.functionRewriteVariant === undefined &&
+                        this.functionRewritesEnabled());
+            }
+        });
+    }
+    costGateLabel(gate) {
+        switch (gate) {
+            case "fieldRename":
+                return "field renaming";
+            case "scheduler":
+                return "statement scheduling";
+            case "exportDce":
+                return "unused export removal";
+            case "fieldFact":
+                return "field optimization";
+            case "aggregateSpecialization":
+                return "function specialization";
+            case "functionRewrite":
+                return "function rewrites";
+        }
+    }
+    recordFinalGateDecision(gate, decision, reason) {
+        switch (gate) {
+            case "fieldRename":
+                this.recordFinalFieldRenameDecision(decision, reason);
+                return;
+            case "scheduler":
+                this.recordFinalSchedulerDecision(decision, reason);
+                return;
+            case "exportDce":
+                this.recordFinalExportDceDecision(decision, reason);
+                return;
+            case "fieldFact":
+                this.recordFinalFieldFactDecision(decision, reason);
+                return;
+            case "aggregateSpecialization":
+                this.recordFinalAggregateSpecializationDecision(decision, reason);
+                return;
+            case "functionRewrite":
+                this.recordFinalFunctionRewriteDecision(decision, reason);
+        }
+    }
+    parseOnce() {
+        this.progress?.addSteps(11);
+        this.progress?.startStep("Load and parse modules");
         this.link();
+        this.progress?.tick();
+        // #85 consumes #84 function-valued field facts before field DCE can remove
+        // callback storage. The field pass then sees specialized calls and includes
+        // storage/wrapper cleanup in the same final-output trial.
+        this.progress?.startStep("Rewrite functions");
+        this.rewriteFunctionsAll();
+        this.progress?.tick();
+        this.progress?.startStep("Analyze and rewrite fields");
+        this.rewriteWholeProgramFieldsAll();
+        this.progress?.tick();
+        this.progress?.startStep("Fold constants");
+        this.foldConstantsAll();
+        this.progress?.tick();
+        this.progress?.startStep("Remove unused exports");
+        this.rewriteWholeProgramExportsAll();
+        this.progress?.tick();
+        this.progress?.startStep("Remove unused code");
+        this.removeUnusedAll();
+        this.progress?.tick();
+        this.progress?.startStep("Plan global names");
+        this.rebuildIdentifiersInUse();
         this.computeGlobalRenames();
+        this.progress?.tick();
+        this.progress?.startStep("Transform statements");
         this.transformAll();
-        this.renameAll();
-        const parts = [];
-        const entryComments = this.moduleAST.get(this.entryModule)?.comments;
-        if (entryComments) {
-            entryComments
-                .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
-                .forEach((comment) => {
-                parts.push(new source_map_1.SourceNode(comment.loc?.start.line ?? null, comment.loc?.start.column ?? null, this.moduleNameAndFileName.get(this.entryModule) ?? null, comment.raw), "\n");
+        this.progress?.tick();
+        this.progress?.startStep("Finalize whole-program analyses");
+        if (this.functionRewritesEnabled() ||
+            this.fieldFactsEnabled() ||
+            this.fieldRenamesEnabled()) {
+            // fold/remove/schedule may have changed any module after method rewrites. Publish only a
+            // snapshot rebuilt from the complete linked AST generation consumed by final Rename/Print.
+            this.linkedAstGeneration++;
+            this.wholeProgramObjectsValue = this.analyzeWholeProgramObjects();
+            this.wholeProgramFieldsValue = (0, wholeProgramFields_1.analyzeWholeProgramFields)(this.wholeProgramObjectsValue, {
+                trustAnnotations: this.mode.assumeAnnotations === true,
+                metadataOf: (moduleName) => this.getSourceMetadata(moduleName),
             });
+            this.wholeProgramExportsValue = (0, wholeProgramExports_1.analyzeWholeProgramExports)(this.wholeProgramObjectsValue, this.entryModule, (moduleName) => this.getSourceMetadata(moduleName));
+            if (this.fieldRenameVariant === "trial") {
+                this.wholeProgramFieldRenamesValue = (0, wholeProgramFieldRenames_1.planWholeProgramFieldRenames)(this.wholeProgramObjectsValue, this.wholeProgramFieldsValue, this.wholeProgramExportsValue, this.entryModule, (moduleName) => this.getSourceMetadata(moduleName));
+                this.recordWholeProgramFieldRenameDiagnostics(this.wholeProgramFieldRenamesValue);
+            }
         }
-        if (this.mode.moduleLikeLua) {
-            parts.push(this.buildRequireWrapper());
-        }
-        parts.push(this.printModule(this.entryModule));
-        const result = new source_map_1.SourceNode(null, null, null, parts);
+        this.progress?.tick();
+        this.progress?.startStep("Rename identifiers");
+        this.renameAll();
+        this.progress?.tick();
+        this.progress?.startStep("Generate Lua and source map");
+        const result = this.mode.requireWrapper
+            ? this.printModuleWithRequireWrapper()
+            : this.printModule(this.entryModule);
         this.moduleSourceText.forEach((v, k) => {
             const fileName = this.moduleNameAndFileName.get(k);
             if (fileName) {
                 result.setSourceContent(fileName, v);
             }
+            this.progress?.tick();
         });
         return result;
     }
+    rewriteWholeProgramExportsAll() {
+        if (this.exportDceVariant !== "trial" || !this.exportDceEnabled())
+            return;
+        const objectAnalysis = this.analyzeWholeProgramObjects();
+        const exportAnalysis = (0, wholeProgramExports_1.analyzeWholeProgramExports)(objectAnalysis, this.entryModule, (moduleName) => this.getSourceMetadata(moduleName));
+        this.wholeProgramObjectsValue = objectAnalysis;
+        this.wholeProgramExportsValue = exportAnalysis;
+        exportAnalysis.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+            pass: "whole-program-export-reachability",
+            moduleName: diagnostic.moduleName,
+            fieldName: diagnostic.field,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: diagnostic.reason === "export-field-candidate" ||
+                diagnostic.reason === "field-live" ||
+                diagnostic.reason === "field-unreachable"
+                ? "accepted"
+                : "rejected",
+            reason: diagnostic.reason,
+            candidateSize: 1,
+            sourceRange: diagnostic.sourceRange,
+        }));
+        const analysisByModule = new Map(objectAnalysis.modules.map((module) => [module.name, module.analysis]));
+        const result = (0, wholeProgramExports_1.applyWholeProgramExportDce)(exportAnalysis, (moduleName) => this.getSourceMetadata(moduleName), (moduleName, expression) => analysisByModule.get(moduleName)?.facts.discardabilityOf(expression)
+            .discardable === true);
+        result.refusedEffectfulInitializerFields.forEach((field) => this.diagnosticCollector?.record({
+            pass: "whole-program-export-dce",
+            moduleName: field.moduleName,
+            fieldName: field.key,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: "rejected",
+            reason: "effectful-initializer",
+            candidateSize: 1,
+        }));
+        if (!result.changed)
+            return;
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            if (!ast)
+                throw new Error(moduleName + " is not found");
+            this.moduleResolve.set(moduleName, (0, resolver_1.resolveScopes)(ast));
+        });
+        this.linkedAstGeneration++;
+        this.wholeProgramObjectsValue = undefined;
+        this.wholeProgramFieldsValue = undefined;
+        this.wholeProgramExportsValue = undefined;
+        result.removedFields.forEach((field) => this.diagnosticCollector?.record({
+            pass: "whole-program-export-dce",
+            moduleName: field.moduleName,
+            fieldName: field.key,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: "accepted",
+            reason: "field-removed",
+            candidateSize: 1,
+        }));
+        result.preservedEffectFields.forEach((field) => this.diagnosticCollector?.record({
+            pass: "whole-program-export-dce",
+            moduleName: field.moduleName,
+            fieldName: field.key,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: "accepted",
+            reason: "field-effect-preserved",
+            candidateSize: 1,
+        }));
+    }
+    rewriteWholeProgramFieldsAll() {
+        if (this.fieldFactVariant === "baseline" || !this.fieldFactsEnabled())
+            return;
+        const objectAnalysis = this.analyzeWholeProgramObjects();
+        const fieldAnalysis = (0, wholeProgramFields_1.analyzeWholeProgramFields)(objectAnalysis, {
+            trustAnnotations: this.mode.assumeAnnotations === true,
+            metadataOf: (moduleName) => this.getSourceMetadata(moduleName),
+        });
+        this.wholeProgramObjectsValue = objectAnalysis;
+        this.wholeProgramFieldsValue = fieldAnalysis;
+        fieldAnalysis.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+            pass: "whole-program-constructor-fields",
+            moduleName: diagnostic.moduleName,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: diagnostic.reason === "field-fact" ? "accepted" : "rejected",
+            reason: diagnostic.reason,
+            candidateSize: 1,
+            sourceRange: diagnostic.sourceRange,
+        }));
+        const result = (0, wholeProgramFields_1.applyWholeProgramFieldRewrites)(objectAnalysis, fieldAnalysis, (moduleName) => this.getSourceMetadata(moduleName), {
+            replaceReads: this.mode.fieldValuePropagation,
+            removeInitializers: this.mode.unusedFieldInitializerRemoval,
+        });
+        if (!result.changed)
+            return;
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            if (!ast)
+                throw new Error(moduleName + " is not found");
+            const passes = new optimizerPass_1.PassOrchestrator(ast, (0, resolver_1.resolveScopes)(ast));
+            passes.runUntilStable("fold-constructor-field-constants", (resolved) => {
+                const facts = passes.analysis(optimizerFacts_1.OPTIMIZER_FACTS_CACHE_KEY, optimizerFacts_1.analyzeOptimizerFactsAtGeneration);
+                const changed = (0, constantFold_1.foldConstants)(ast, resolved, this.getSourceMetadata(moduleName), facts, {
+                    evaluateExpressions: this.mode.constantExpressionEvaluation,
+                    propagateLocals: this.mode.localConstantPropagation,
+                });
+                return { changed, invalidatesResolve: changed };
+            });
+            this.moduleResolve.set(moduleName, passes.resolved);
+        });
+        this.linkedAstGeneration++;
+        this.wholeProgramObjectsValue = undefined;
+        this.wholeProgramFieldsValue = undefined;
+        this.wholeProgramExportsValue = undefined;
+        this.diagnosticCollector?.record({
+            pass: "whole-program-constructor-field-rewrite",
+            moduleName: this.entryModule,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: "accepted",
+            reason: "field-rewrite-applied",
+            candidateSize: result.replacedReads + result.removedInitializers,
+        });
+        const recordRewrite = (reason, count) => {
+            if (count === 0)
+                return;
+            this.diagnosticCollector?.record({
+                pass: "whole-program-constructor-field-rewrite",
+                moduleName: this.entryModule,
+                runtimeProfile: this.mode.runtimeProfile,
+                decision: "accepted",
+                reason,
+                candidateSize: count,
+            });
+        };
+        recordRewrite("field-read-replaced", result.replacedReads);
+        recordRewrite("dead-field-write", result.removedInitializers);
+        recordRewrite("field-write-effect-preserved", result.preservedEffects);
+    }
+    /** Function-summary consumers run before scheduling and final rename/print. */
+    rewriteFunctionsAll() {
+        if (this.functionRewriteVariant === "baseline" ||
+            !this.functionRewritesEnabled())
+            return;
+        let initialWholeProgram = this.analyzeWholeProgramObjects();
+        this.recordWholeProgramObjectDiagnostics(initialWholeProgram);
+        const initiallyResolvedMethodDeclarations = new Set(initialWholeProgram.resolvedMethods.map((method) => method.target.declaration));
+        if (this.mode.functionSpecialization &&
+            this.aggregateSpecializationVariant !== "baseline") {
+            const initialFieldFacts = (0, wholeProgramFields_1.analyzeWholeProgramFields)(initialWholeProgram, {
+                trustAnnotations: this.mode.assumeAnnotations === true,
+                metadataOf: (moduleName) => this.getSourceMetadata(moduleName),
+            });
+            const specialization = (0, aggregateSpecialization_1.applyAggregateSpecialization)(initialWholeProgram, initialFieldFacts, this.linkOrder.map((name) => {
+                const chunk = this.moduleAST.get(name);
+                const resolved = this.moduleResolve.get(name);
+                if (!chunk || !resolved)
+                    throw new Error(name + " is not found");
+                const resources = (0, runtimeEnvironment_1.analyzeLocalResourceUsage)(chunk);
+                const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+                return {
+                    name,
+                    chunk,
+                    resolved,
+                    metadata: this.getSourceMetadata(name),
+                    maxIntroducedLocalsAt: (statement) => {
+                        const active = resources.activeLocalsBefore(statement);
+                        if (active === undefined)
+                            return 0;
+                        return Math.max(0, Math.min(runtime.resources.maxActiveLocalsPerFunction - active, runtime.resources.maxRegistersPerFunction - active));
+                    },
+                };
+            }));
+            specialization.diagnostics.forEach((diagnostic) => {
+                const module = initialWholeProgram.modules.find((candidate) => candidate.analysis.callGraph.functions.includes(diagnostic.callable));
+                this.diagnosticCollector?.record({
+                    pass: "aggregate-function-specialization",
+                    moduleName: module?.name,
+                    runtimeProfile: this.mode.runtimeProfile,
+                    decision: diagnostic.reason === "variant-created" ? "accepted" : "rejected",
+                    reason: diagnostic.reason,
+                    candidateSize: diagnostic.count,
+                    sourceRange: sourceRangeOf(diagnostic.callable.declaration),
+                });
+            });
+            if (specialization.changed) {
+                this.linkOrder.forEach((moduleName) => {
+                    const ast = this.moduleAST.get(moduleName);
+                    if (!ast)
+                        throw new Error(moduleName + " is not found");
+                    this.moduleResolve.set(moduleName, (0, resolver_1.resolveScopes)(ast));
+                });
+                this.linkedAstGeneration++;
+                this.wholeProgramObjectsValue = undefined;
+                this.wholeProgramFieldsValue = undefined;
+                this.wholeProgramExportsValue = undefined;
+                initialWholeProgram = this.analyzeWholeProgramObjects();
+                const specializedFields = (0, wholeProgramFields_1.analyzeWholeProgramFields)(initialWholeProgram, {
+                    trustAnnotations: this.mode.assumeAnnotations === true,
+                    metadataOf: (moduleName) => this.getSourceMetadata(moduleName),
+                });
+                const downstream = (0, wholeProgramFields_1.applyWholeProgramFieldRewrites)(initialWholeProgram, specializedFields, (moduleName) => this.getSourceMetadata(moduleName), {
+                    replaceReads: this.mode.fieldValuePropagation,
+                    removeInitializers: this.mode.unusedFieldInitializerRemoval,
+                });
+                if (downstream.removedInitializers > 0)
+                    this.diagnosticCollector?.record({
+                        pass: "aggregate-function-specialization",
+                        moduleName: this.entryModule,
+                        runtimeProfile: this.mode.runtimeProfile,
+                        decision: "accepted",
+                        reason: "dead-field-write",
+                        candidateSize: downstream.removedInitializers,
+                    });
+                if (downstream.changed) {
+                    this.linkOrder.forEach((moduleName) => {
+                        const ast = this.moduleAST.get(moduleName);
+                        if (!ast)
+                            throw new Error(moduleName + " is not found");
+                        this.moduleResolve.set(moduleName, (0, resolver_1.resolveScopes)(ast));
+                    });
+                    this.linkedAstGeneration++;
+                    this.wholeProgramObjectsValue = undefined;
+                    this.wholeProgramFieldsValue = undefined;
+                    this.wholeProgramExportsValue = undefined;
+                    initialWholeProgram = this.analyzeWholeProgramObjects();
+                }
+            }
+        }
+        const resolvedMethodDeclarations = new Set([
+            ...initiallyResolvedMethodDeclarations,
+            ...initialWholeProgram.resolvedMethods.map((method) => method.target.declaration),
+        ]);
+        if (this.mode.parameterPruning) {
+            initialWholeProgram = this.pruneWholeProgramParameters(initialWholeProgram, resolvedMethodDeclarations);
+        }
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            const resolved = this.moduleResolve.get(moduleName);
+            if (!ast || !resolved)
+                throw new Error(moduleName + " is not found");
+            const passes = new optimizerPass_1.PassOrchestrator(ast, resolved);
+            const runtimeProfile = this.mode.runtimeProfile;
+            const moduleRange = sourceRangeOf(ast) ??
+                [0, this.moduleSourceText.get(moduleName)?.length ?? 0];
+            const recordAccepted = (pass, count) => {
+                if (count === 0)
+                    return;
+                this.diagnosticCollector?.record({
+                    pass,
+                    moduleName,
+                    runtimeProfile,
+                    decision: "accepted",
+                    reason: "function-rewrite-applied",
+                    candidateSize: count,
+                    sourceRange: moduleRange,
+                });
+            };
+            const initialAnalysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+            const recursive = new Set(initialAnalysis.callGraph.sccs
+                .filter((scc) => scc.recursive)
+                .flatMap((scc) => scc.functions));
+            initialAnalysis.interprocedural.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+                pass: "interprocedural-summary",
+                moduleName,
+                runtimeProfile,
+                decision: diagnostic.reason === "unknown-call-target"
+                    ? "rejected"
+                    : "accepted",
+                reason: diagnostic.reason,
+                candidateSize: 1,
+                sourceRange: diagnostic.sourceRange ?? moduleRange,
+            }));
+            initialAnalysis.callGraph.functions.forEach((callable) => {
+                if (!callable.symbol || !callable.declaration.isLocal)
+                    return;
+                const calls = initialAnalysis.callGraph.calls.filter((call) => call.targets.has(callable)).length;
+                const reason = recursive.has(callable)
+                    ? "recursive-function"
+                    : callable.declaration.parameters.some((parameter) => parameter.type === "VarargLiteral")
+                        ? "vararg-function"
+                        : callable.symbol.references.length > calls
+                            ? "function-escape"
+                            : undefined;
+                if (!reason)
+                    return;
+                this.diagnosticCollector?.record({
+                    pass: "function-rewrite",
+                    moduleName,
+                    runtimeProfile,
+                    decision: "rejected",
+                    reason,
+                    candidateSize: 1,
+                    sourceRange: sourceRangeOf(callable.declaration),
+                });
+            });
+            if (this.mode.functionInlining)
+                passes.run("inline-closed-single-use-functions", (currentResolve) => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const result = (0, functionRewrites_1.inlineClosedSingleUseFunctions)(analysis.interprocedural, currentResolve, this.getSourceMetadata(moduleName));
+                    recordAccepted("inline-closed-single-use-functions", result.inlinedFunctions);
+                    return {
+                        changed: result.changed,
+                        invalidatesResolve: result.changed,
+                    };
+                });
+            if (this.mode.functionInlining)
+                passes.run("inline-literal-argument-functions", (currentResolve) => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const result = (0, functionRewrites_1.inlineLiteralArgumentFunctions)(analysis.interprocedural, currentResolve, this.getSourceMetadata(moduleName));
+                    recordAccepted("inline-literal-argument-functions", result.inlinedFunctions);
+                    return {
+                        changed: result.changed,
+                        invalidatesResolve: result.changed,
+                    };
+                });
+            if (this.mode.functionInlining)
+                passes.run("inline-tail-call-functions", (currentResolve) => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const localResources = (0, runtimeEnvironment_1.analyzeLocalResourceUsage)(ast);
+                    const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+                    const result = (0, functionRewrites_1.inlineTailCallFunctions)(ast, analysis.interprocedural, currentResolve, this.getSourceMetadata(moduleName), {
+                        maxIntroducedLocalsAt: (statement) => {
+                            const active = localResources.activeLocalsBefore(statement);
+                            if (active === undefined)
+                                return 0;
+                            return Math.max(0, Math.min(runtime.resources.maxActiveLocalsPerFunction - active, runtime.resources.maxRegistersPerFunction - active));
+                        },
+                    });
+                    recordAccepted("inline-tail-call-functions", result.inlinedFunctions);
+                    return {
+                        changed: result.changed,
+                        invalidatesResolve: result.changed,
+                    };
+                });
+            if (this.mode.functionInlining)
+                passes.run("inline-closed-statement-functions", (currentResolve) => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const result = (0, functionRewrites_1.inlineClosedStatementFunctions)(ast, analysis.interprocedural, currentResolve, this.getSourceMetadata(moduleName));
+                    recordAccepted("inline-closed-statement-functions", result.inlinedFunctions);
+                    return {
+                        changed: result.changed,
+                        invalidatesResolve: result.changed,
+                    };
+                });
+            if (this.mode.functionInlining)
+                passes.run("inline-bound-statement-functions", (currentResolve) => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const localResources = (0, runtimeEnvironment_1.analyzeLocalResourceUsage)(ast);
+                    const result = (0, functionRewrites_1.inlineBoundStatementFunctions)(ast, analysis.interprocedural, currentResolve, this.getSourceMetadata(moduleName), {
+                        maxIntroducedLocalsAt: (statement) => {
+                            const active = localResources.activeLocalsBefore(statement);
+                            if (active === undefined)
+                                return 0;
+                            return Math.max(0, Math.min((0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile).resources
+                                .maxActiveLocalsPerFunction - active, (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile).resources
+                                .maxRegistersPerFunction - active));
+                        },
+                    });
+                    recordAccepted("inline-bound-statement-functions", result.inlinedFunctions);
+                    return {
+                        changed: result.changed,
+                        invalidatesResolve: result.changed,
+                    };
+                });
+            this.moduleResolve.set(moduleName, passes.resolved);
+            if (passes.astGeneration > 0) {
+                this.linkedAstGeneration += passes.astGeneration;
+                this.wholeProgramObjectsValue = undefined;
+                this.wholeProgramFieldsValue = undefined;
+                this.wholeProgramExportsValue = undefined;
+            }
+            this.progress?.tick();
+        });
+        this.wholeProgramObjectsValue = this.analyzeWholeProgramObjects();
+        this.recordWholeProgramObjectDiagnostics(this.wholeProgramObjectsValue);
+    }
+    pruneWholeProgramParameters(analysis, resolvedMethodDeclarations) {
+        const functionsByModule = new Map(analysis.modules.map((module) => [
+            module.name,
+            new Set(module.analysis.callGraph.functions),
+        ]));
+        const changedModules = new Set();
+        this.linkOrder.forEach((moduleName) => {
+            const functions = functionsByModule.get(moduleName);
+            if (!functions)
+                return;
+            const result = (0, functionRewrites_1.pruneTrailingUnusedParameters)(analysis.callGraph, this.getSourceMetadata(moduleName), (callable) => functions.has(callable) &&
+                (callable.declaration.identifier?.type !== "MemberExpression" ||
+                    callable.declaration.identifier.indexer !== ":" ||
+                    resolvedMethodDeclarations.has(callable.declaration)));
+            if (!result.changed)
+                return;
+            changedModules.add(moduleName);
+            this.diagnosticCollector?.record({
+                pass: "prune-trailing-unused-parameters",
+                moduleName,
+                runtimeProfile: this.mode.runtimeProfile,
+                decision: "accepted",
+                reason: "function-rewrite-applied",
+                candidateSize: result.prunedParameters,
+                sourceRange: sourceRangeOf(this.moduleAST.get(moduleName) ?? {}),
+            });
+            if (result.prunedMethodParameters > 0)
+                this.diagnosticCollector?.record({
+                    pass: "whole-program-method-parameter-pruning",
+                    moduleName,
+                    runtimeProfile: this.mode.runtimeProfile,
+                    decision: "accepted",
+                    reason: "function-rewrite-applied",
+                    candidateSize: result.prunedMethodParameters,
+                    sourceRange: sourceRangeOf(this.moduleAST.get(moduleName) ?? {}),
+                });
+        });
+        if (changedModules.size === 0)
+            return analysis;
+        changedModules.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            if (!ast)
+                throw new Error(moduleName + " is not found");
+            this.moduleResolve.set(moduleName, (0, resolver_1.resolveScopes)(ast));
+        });
+        this.linkedAstGeneration++;
+        this.wholeProgramObjectsValue = undefined;
+        this.wholeProgramFieldsValue = undefined;
+        this.wholeProgramExportsValue = undefined;
+        return this.analyzeWholeProgramObjects();
+    }
+    analyzeWholeProgramObjects() {
+        const modules = this.linkOrder.map((name) => {
+            const chunk = this.moduleAST.get(name);
+            const resolved = this.moduleResolve.get(name);
+            if (!chunk || !resolved)
+                throw new Error(name + " is not found");
+            const module = {
+                name,
+                chunk,
+                resolved,
+                analysis: (0, optimizerAnalysis_1.analyzeOptimizer)(chunk, resolved, {
+                    generation: this.linkedAstGeneration,
+                }),
+            };
+            this.progress?.tick();
+            return module;
+        });
+        return (0, wholeProgramObjects_1.analyzeWholeProgramObjects)(modules, this.linkedAstGeneration);
+    }
+    recordWholeProgramObjectDiagnostics(analysis) {
+        analysis.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+            pass: "whole-program-method-resolution",
+            moduleName: diagnostic.moduleName,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: diagnostic.reason === "resolved-method-target"
+                ? "accepted"
+                : "rejected",
+            reason: diagnostic.reason,
+            candidateSize: 1,
+            sourceRange: diagnostic.sourceRange,
+        }));
+    }
+    requiresSchedulerSelection() {
+        if (this.mode.localDeclarationMerging)
+            return true;
+        const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+        const lifetimeAllowed = !runtime.semantics.debugLocalIntrospection ||
+            this.mode.allowIntrospectionChanges === true;
+        return (lifetimeAllowed &&
+            (this.mode.localDeclarationHoisting || this.mode.tableReadMerging));
+    }
+    functionRewritesEnabled() {
+        const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+        return ((this.mode.parameterPruning ||
+            this.mode.functionInlining ||
+            this.mode.functionSpecialization) &&
+            (!runtime.semantics.debugLocalIntrospection ||
+                this.mode.allowIntrospectionChanges === true));
+    }
+    functionSpecializationEnabled() {
+        if (!this.mode.functionSpecialization)
+            return false;
+        const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+        return (!runtime.semantics.debugLocalIntrospection ||
+            this.mode.allowIntrospectionChanges === true);
+    }
+    fieldFactsEnabled() {
+        return (this.mode.fieldValuePropagation || this.mode.unusedFieldInitializerRemoval);
+    }
+    fieldRenamesEnabled() {
+        return this.mode.fieldRenaming;
+    }
+    exportDceEnabled() {
+        return this.mode.unusedExportRemoval;
+    }
+    copyDiagnosticsFrom(minifier) {
+        minifier.optimizationDiagnostics.forEach((diagnostic) => this.diagnosticCollector?.record(diagnostic));
+    }
+    adoptVariant(minifier, output) {
+        this.identifiersInUse.clear();
+        minifier.identifiersInUse.forEach((name) => this.identifiersInUse.add(name));
+        copyMap(minifier.moduleSourceText, this.moduleSourceText);
+        copyMap(minifier.moduleAST, this.moduleAST);
+        copyMap(minifier.moduleNameAndFileName, this.moduleNameAndFileName);
+        this.linkOrder.splice(0, this.linkOrder.length, ...minifier.linkOrder);
+        copyMap(minifier.moduleResolve, this.moduleResolve);
+        copyMap(minifier.renameCache, this.renameCache);
+        this.globalRenames = new Map(minifier.globalRenames);
+        copyMap(minifier.moduleMetadata, this.moduleMetadata);
+        this.linkedAstGeneration = minifier.linkedAstGeneration;
+        this.wholeProgramObjectsValue = minifier.wholeProgramObjectsValue;
+        this.wholeProgramFieldsValue = minifier.wholeProgramFieldsValue;
+        this.wholeProgramExportsValue = minifier.wholeProgramExportsValue;
+        this.wholeProgramFieldRenamesValue = minifier.wholeProgramFieldRenamesValue;
+        return output;
+    }
+    recordFinalSchedulerDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "statement-scheduler-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalCostDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "optimizer-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalFunctionRewriteDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "function-rewrite-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalAggregateSpecializationDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "aggregate-specialization-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalFieldFactDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "constructor-field-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalExportDceDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "module-export-dce-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordFinalFieldRenameDecision(decision, reason, byteSavings) {
+        this.diagnosticCollector?.record({
+            pass: "whole-program-field-rename-final-cost",
+            decision,
+            reason,
+            candidateSize: 1,
+            estimatedByteSavings: byteSavings,
+            runtimeProfile: this.mode.runtimeProfile,
+            moduleName: this.entryModule,
+            sourceRange: [0, fs_1.default.readFileSync(this.entryFilePath, "utf8").length],
+        });
+    }
+    recordWholeProgramFieldRenameDiagnostics(plan) {
+        plan.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+            pass: "whole-program-field-rename",
+            moduleName: diagnostic.moduleName,
+            fieldName: diagnostic.field,
+            runtimeProfile: this.mode.runtimeProfile,
+            decision: diagnostic.accepted ? "accepted" : "rejected",
+            reason: diagnostic.reason,
+            candidateSize: 1,
+            sourceRange: diagnostic.sourceRange,
+        }));
+    }
     /**
      * dofileの呼び出し箇所ごとに、キャッシュ済みASTから新規にSourceNodeを作り直す。
      * 同じSourceNodeインスタンスを複数箇所へ挿入すると壊れるため、常に作り直す（#18）。
@@ -91,14 +1022,14 @@ class Minifier {
         if (!ast || !fileName) {
             throw new Error(moduleName + " is not found");
         }
-        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parseAsStatementsAndFinalExpression(moduleName === this.entryModule);
+        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parseAsStatementsAndFinalExpression();
     }
     /**
      * 指定モジュールのRenameパス結果を返す。`renameAll`で事前に計算済みの
      * ものをそのまま返すだけの参照用アクセサ。
      */
     getRenameResult(moduleName) {
-        if (this.mode.rename === false) {
+        if (!this.mode.localRenaming && !this.mode.globalRenaming) {
             return NO_RENAME;
         }
         const cached = this.renameCache.get(moduleName);
@@ -107,6 +1038,18 @@ class Minifier {
         }
         return cached;
     }
+    getFieldRename(node) {
+        const name = this.wholeProgramFieldRenamesValue?.nameOf(node);
+        const originalName = this.wholeProgramFieldRenamesValue?.originalNameOf(node);
+        return name && originalName ? { name, originalName } : undefined;
+    }
+    getSourceMetadata(moduleName) {
+        const metadata = this.moduleMetadata.get(moduleName);
+        if (!metadata) {
+            throw new Error(moduleName + " is not found");
+        }
+        return metadata;
+    }
     /**
      * Renameパス（#20）: linkOrder（依存されている側が先）の順にモジュールごとの
      * 短縮名を割り当てる。
@@ -120,17 +1063,25 @@ class Minifier {
      * 犠牲になるが、モジュール内でのスコープに基づく再利用は維持される）。
      */
     renameAll() {
-        if (this.mode.rename === false) {
+        if (!this.mode.localRenaming && !this.mode.globalRenaming) {
             return;
         }
         this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
             const resolved = this.moduleResolve.get(moduleName);
-            if (!resolved) {
+            if (!ast || !resolved) {
                 throw new Error(moduleName + " is not found");
             }
-            const result = (0, renamer_1.assignRenames)(resolved, this.identifiersInUse, this.globalRenames);
+            const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+            const result = this.renameCache.get(moduleName) ??
+                (0, renamer_1.assignRenames)(ast, resolved, this.identifiersInUse, this.globalRenames, new Set(resolved.symbols.filter((symbol) => this.getSourceMetadata(moduleName).annotationsOfIdentifier(symbol.declaration).keepName)), {
+                    allowLocalNameReuse: !runtime.semantics.debugLocalIntrospection ||
+                        this.mode.allowIntrospectionChanges === true,
+                    renameLocals: this.mode.localRenaming,
+                });
             this.renameCache.set(moduleName, result);
             result.usedNames.forEach((name) => this.identifiersInUse.add(name));
+            this.progress?.tick();
         });
     }
     /**
@@ -152,31 +1103,149 @@ class Minifier {
      * なり）、意味が壊れる（要修正が発覚した実例）。
      */
     transformAll() {
+        // Global bindings are shared across linked modules. A name written in one
+        // module is therefore program-owned even when another module only reads it;
+        // treating that reader as an external-global alias candidate can capture
+        // the value before the defining module runs (#102).
+        const programWrittenGlobals = (0, globalRename_1.collectProgramWrittenGlobals)(this.moduleResolve);
         // globalRenames.keys()は8aが実際にリネームした（=代入もされていた）名前のみ。
         // neverRenameGlobalsは代入されていない名前にも及ぶ保護指定なので、8bのエイリアス化
         // が誤ってそれらを書き換えてしまわないよう、必ず両方をあわせてexcludeNamesに渡す。
         const excludeGlobalNames = new Set([
+            ...programWrittenGlobals,
             ...this.globalRenames.keys(),
             ...(this.mode.neverRenameGlobals ?? []),
+            ...this.annotationProtectedGlobals(),
         ]);
+        // renameAllと同じmodule順・予約名更新で仮Renameを行い、plannerのbyte costを
+        // 実際の出力名長に対する保守的な見積りにする。
+        const plannedIdentifiersInUse = new Set(this.identifiersInUse);
         this.linkOrder.forEach((moduleName) => {
             const ast = this.moduleAST.get(moduleName);
             let resolved = this.moduleResolve.get(moduleName);
             if (!ast || !resolved) {
                 throw new Error(moduleName + " is not found");
             }
-            if (this.mode.rename !== false && this.mode.globalAlias !== false) {
-                (0, transform_1.insertGlobalAliases)(ast, resolved, {
-                    excludeNames: excludeGlobalNames,
+            const passes = new optimizerPass_1.PassOrchestrator(ast, resolved);
+            if (this.mode.globalAliasing) {
+                passes.run("global-alias", (currentResolve) => {
+                    const changed = (0, transform_1.insertGlobalAliases)(ast, currentResolve, {
+                        excludeNames: excludeGlobalNames,
+                    });
+                    return { changed, invalidatesResolve: changed };
                 });
-                resolved = (0, resolver_1.resolveScopes)(ast);
             }
-            if (this.mode.mergeLocals !== false) {
-                (0, transform_1.mergeLocalDeclarations)(ast, resolved, {
-                    preserveRequireSplice: !this.mode.moduleLikeLua,
+            resolved = passes.resolved;
+            const runtime = (0, runtimeEnvironment_1.runtimeEnvironmentOf)(this.mode.runtimeProfile);
+            const optimizerAnalysis = () => passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, (chunk, currentResolve, generation) => (0, optimizerAnalysis_1.analyzeOptimizer)(chunk, currentResolve, {
+                generation,
+                runtime,
+                assumptions: this.mode.allowObservableTableReadChanges === true
+                    ? new Map([
+                        [
+                            "allow-observable-table-read-changes",
+                            "explicit allowObservableTableReadChanges opt-in",
+                        ],
+                    ])
+                    : undefined,
+            }));
+            const localResources = (0, runtimeEnvironment_1.analyzeLocalResourceUsage)(ast);
+            const lifetimeChangesAllowed = !runtime.semantics.debugLocalIntrospection ||
+                this.mode.allowIntrospectionChanges === true;
+            const localNameReuseEnabled = this.mode.localNameReuse && lifetimeChangesAllowed;
+            const keepNames = new Set(resolved.symbols.filter((symbol) => this.getSourceMetadata(moduleName).annotationsOfIdentifier(symbol.declaration).keepName));
+            if (this.schedulerVariant !== "baseline" &&
+                (this.mode.localDeclarationMerging ||
+                    (lifetimeChangesAllowed &&
+                        (this.mode.localDeclarationHoisting || this.mode.tableReadMerging)))) {
+                const provisionalAnalysis = !this.mode.localRenaming && !this.mode.globalRenaming
+                    ? undefined
+                    : optimizerAnalysis();
+                const provisionalRenames = !this.mode.localRenaming && !this.mode.globalRenaming
+                    ? NO_RENAME
+                    : (0, renamer_1.assignRenames)(ast, resolved, plannedIdentifiersInUse, this.globalRenames, keepNames, {
+                        allowLocalNameReuse: localNameReuseEnabled,
+                        renameLocals: this.mode.localRenaming,
+                        analysis: provisionalAnalysis
+                            ? {
+                                facts: provisionalAnalysis.facts,
+                                liveness: provisionalAnalysis.statementDataflow.symbolLiveness,
+                            }
+                            : undefined,
+                    });
+                passes.run("statement-scheduler", (currentResolve) => {
+                    const analysis = optimizerAnalysis();
+                    analysis.interprocedural.diagnostics.forEach((diagnostic) => this.diagnosticCollector?.record({
+                        pass: "interprocedural-summary",
+                        moduleName,
+                        runtimeProfile: runtime.profile,
+                        decision: diagnostic.reason === "unknown-call-target"
+                            ? "rejected"
+                            : "accepted",
+                        reason: diagnostic.reason,
+                        candidateSize: 1,
+                        sourceRange: diagnostic.sourceRange,
+                    }));
+                    const metadata = this.getSourceMetadata(moduleName);
+                    const canMoveAnnotatedStatement = (statement) => {
+                        const annotations = metadata.annotationsOf(statement);
+                        return (metadata.beforeOf(statement).length === 0 &&
+                            metadata.trailingOf(statement).length === 0 &&
+                            !annotations.keep &&
+                            !annotations.keepName &&
+                            !annotations.exported);
+                    };
+                    const plan = (0, statementScheduler_1.planStatementSchedule)(ast, currentResolve, {
+                        facts: analysis.facts,
+                        dataflow: analysis.statementDataflow,
+                        outputNameLengthOf: (symbol) => (provisionalRenames.nameOf(symbol.declaration) ?? symbol.name)
+                            .length,
+                        preserveRequireSplice: !this.mode.requireWrapper,
+                        enableLocalPacking: lifetimeChangesAllowed && this.mode.localDeclarationHoisting,
+                        enableLexicalLocalMerge: this.mode.localDeclarationMerging,
+                        tableEffects: lifetimeChangesAllowed && this.mode.tableReadMerging
+                            ? analysis.tableEffects
+                            : undefined,
+                        dirtyGranularity: !this.mode.fieldSensitiveTableEffects
+                            ? "table"
+                            : "static-key",
+                        allowObservableTableValueChanges: this.mode.allowObservableTableReadChanges === true,
+                        maxTableMergeArity: runtime.resources.conservativeParallelValueLimit,
+                        maxTableMergeArityAt: (statement) => (0, runtimeEnvironment_1.checkParallelEvaluation)(runtime, {
+                            activeLocalsBefore: localResources.activeLocalsBefore(statement) ??
+                                runtime.resources.maxActiveLocalsPerFunction,
+                            parallelValueCount: runtime.resources.conservativeParallelValueLimit,
+                        }).limit,
+                        canMoveTableRead: canMoveAnnotatedStatement,
+                        maxHoistedLocalsAt: (statement) => {
+                            const active = localResources.activeLocalsBefore(statement);
+                            if (active === undefined)
+                                return 0;
+                            return Math.max(0, Math.min(runtime.resources.maxActiveLocalsPerFunction - active, runtime.resources.maxRegistersPerFunction - active));
+                        },
+                        canChangeLocalLifetime: canMoveAnnotatedStatement,
+                        diagnostics: this.diagnosticCollector,
+                        moduleName,
+                        runtimeProfile: runtime.profile,
+                    });
+                    return (0, statementScheduler_1.applyStatementSchedule)(plan, this.getSourceMetadata(moduleName));
                 });
             }
+            resolved = passes.resolved;
             this.moduleResolve.set(moduleName, resolved);
+            if (this.mode.localRenaming || this.mode.globalRenaming) {
+                const finalKeepNames = new Set(resolved.symbols.filter((symbol) => this.getSourceMetadata(moduleName).annotationsOfIdentifier(symbol.declaration).keepName));
+                // plannedIdentifiersInUse advances in the same link order as renameAll.
+                // Cache this final-generation result so Print does not rebuild the same
+                // facts, CFG, liveness, graph, and binding proof a second time.
+                const finalRename = (0, renamer_1.assignRenames)(ast, resolved, plannedIdentifiersInUse, this.globalRenames, finalKeepNames, {
+                    allowLocalNameReuse: localNameReuseEnabled,
+                    renameLocals: this.mode.localRenaming,
+                });
+                this.renameCache.set(moduleName, finalRename);
+                finalRename.usedNames.forEach((name) => plannedIdentifiersInUse.add(name));
+            }
+            this.progress?.tick();
         });
     }
     /**
@@ -191,10 +1260,13 @@ class Minifier {
      * ローカルの短縮名がグローバルの新しい短縮名と衝突しうる。
      */
     computeGlobalRenames() {
-        if (this.mode.rename === false || this.mode.globalRename === false) {
+        if (!this.mode.globalRenaming) {
             return;
         }
-        const neverRename = this.mode.neverRenameGlobals ?? new Set();
+        const neverRename = new Set([
+            ...(this.mode.neverRenameGlobals ?? []),
+            ...this.annotationProtectedGlobals(),
+        ]);
         this.globalRenames = (0, globalRename_1.classifyAndRenameGlobals)(this.moduleResolve, neverRename, this.identifiersInUse);
         this.globalRenames.forEach((shortName, originalName) => {
             this.identifiersInUse.add(shortName);
@@ -207,7 +1279,92 @@ class Minifier {
         if (!ast || !fileName) {
             throw new Error(moduleName + " is not found");
         }
-        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parse(moduleName === this.entryModule);
+        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parse();
+    }
+    annotationProtectedGlobals() {
+        const protectedNames = new Set();
+        this.moduleResolve.forEach((resolved, moduleName) => {
+            const metadata = this.getSourceMetadata(moduleName);
+            resolved.globals.forEach((binding) => {
+                if (binding.writes.some((write) => metadata.annotationsOfIdentifier(write).keepName)) {
+                    protectedNames.add(binding.name);
+                }
+            });
+        });
+        return protectedNames;
+    }
+    /**
+     * 定数畳み込みパス（#44）: opt-inオプション。既定では無効。
+     * link()の直後、removeUnusedAll()の前に実行する。伝搬で参照が消えたローカル
+     * 宣言はこのパス自身では消さず、直後に実行される（既定で有効な）未使用ローカル
+     * 削除に任せる。
+     */
+    foldConstantsAll() {
+        if (!this.mode.constantExpressionEvaluation &&
+            !this.mode.localConstantPropagation &&
+            !this.mode.interproceduralConstantPropagation)
+            return;
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            const resolved = this.moduleResolve.get(moduleName);
+            if (!ast || !resolved)
+                throw new Error(moduleName + " is not found");
+            const passes = new optimizerPass_1.PassOrchestrator(ast, resolved);
+            if (this.mode.interproceduralConstantPropagation)
+                passes.run("interprocedural-constants", () => {
+                    const analysis = passes.analysis(optimizerAnalysis_1.OPTIMIZER_ANALYSIS_CACHE_KEY, optimizerAnalysis_1.analyzeOptimizerAtGeneration);
+                    const changed = (0, interproceduralConstants_1.propagateInterproceduralConstants)(ast, analysis.interprocedural);
+                    return { changed, invalidatesResolve: changed };
+                });
+            if (this.mode.constantExpressionEvaluation ||
+                this.mode.localConstantPropagation)
+                passes.runUntilStable("fold-constants", (currentResolve) => {
+                    const facts = passes.analysis(optimizerFacts_1.OPTIMIZER_FACTS_CACHE_KEY, optimizerFacts_1.analyzeOptimizerFactsAtGeneration);
+                    const changed = (0, constantFold_1.foldConstants)(ast, currentResolve, this.getSourceMetadata(moduleName), facts, {
+                        evaluateExpressions: this.mode.constantExpressionEvaluation,
+                        propagateLocals: this.mode.localConstantPropagation,
+                    });
+                    return { changed, invalidatesResolve: changed };
+                });
+            this.moduleResolve.set(moduleName, passes.resolved);
+            this.progress?.tick();
+        });
+    }
+    removeUnusedAll() {
+        if (!this.mode.unusedLocalRemoval && !this.mode.unusedFunctionRemoval)
+            return;
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            const metadata = this.getSourceMetadata(moduleName);
+            const resolved = this.moduleResolve.get(moduleName);
+            if (!ast || !resolved)
+                throw new Error(moduleName + " is not found");
+            const passes = new optimizerPass_1.PassOrchestrator(ast, resolved);
+            passes.runUntilStable("remove-unused", (currentResolve) => {
+                const facts = passes.analysis(optimizerFacts_1.OPTIMIZER_FACTS_CACHE_KEY, optimizerFacts_1.analyzeOptimizerFactsAtGeneration);
+                const changed = (0, removeUnused_1.removeUnusedLocals)(ast, currentResolve, metadata, facts, (statement) => this.diagnosticCollector?.record({
+                    pass: "function-dce",
+                    moduleName,
+                    runtimeProfile: this.mode.runtimeProfile,
+                    decision: "accepted",
+                    reason: "unused-function",
+                    candidateSize: 1,
+                    sourceRange: sourceRangeOf(statement),
+                }), {
+                    removeLocals: this.mode.unusedLocalRemoval,
+                    removeFunctions: this.mode.unusedFunctionRemoval,
+                });
+                return { changed, invalidatesResolve: changed };
+            });
+            this.moduleResolve.set(moduleName, passes.resolved);
+            this.progress?.tick();
+        });
+    }
+    rebuildIdentifiersInUse() {
+        this.identifiersInUse.clear();
+        this.moduleResolve.forEach((resolved) => {
+            resolved.globals.forEach((binding) => this.identifiersInUse.add(binding.name));
+        });
     }
     /**
      * エントリファイルから到達可能な全モジュールをASTレベルで解決するLinkパス（#18）。
@@ -231,28 +1388,40 @@ class Minifier {
             visiting.add(moduleName);
             stack.push(moduleName);
             const fullResolvePath = path_1.default.join(this.dir, ...moduleName.split(".")) + ".lua";
-            if (!fs_1.default.existsSync(fullResolvePath)) {
-                throw new Error(moduleName + " is not found");
+            let input = this.inputCache.get(fullResolvePath);
+            if (!input) {
+                if (!fs_1.default.existsSync(fullResolvePath)) {
+                    throw new Error(moduleName + " is not found");
+                }
+                const sourceText = fs_1.default.readFileSync(fullResolvePath).toString();
+                const ast = luaparse_1.default.parse(sourceText, this.luaParseSettings);
+                input = {
+                    sourceText,
+                    ast,
+                    references: (0, linker_1.findModuleReferences)(ast),
+                };
+                this.inputCache.set(fullResolvePath, input);
             }
-            const code = fs_1.default.readFileSync(fullResolvePath).toString();
-            const ast = luaparse_1.default.parse(code, this.luaParseSettings);
+            const code = input.sourceText;
+            const ast = structuredClone(input.ast);
+            this.moduleMetadata.set(moduleName, new sourceMetadata_1.SourceMetadata(ast, code));
             // Resolveパス（#19）: このモジュールのスコープ/シンボルを解析し、Renameパスの
             // 入力として使い回せるようキャッシュする。グローバル参照はプログラム全体で
             // 予約すべき名前（identifiersInUse）としてここで集計する。
             const resolved = (0, resolver_1.resolveScopes)(ast);
             this.moduleResolve.set(moduleName, resolved);
-            resolved.globals.forEach((binding) => this.identifiersInUse.add(binding.name));
             this.moduleSourceText.set(moduleName, code);
             this.moduleAST.set(moduleName, ast);
             // Source Mapの`sources`はURLとして解釈されるため、OS依存のpath.sepではなく
             // 常に"/"区切りで保持する（Windows上でのビルドでも壊れないように）。
             this.moduleNameAndFileName.set(moduleName, moduleName.replaceAll(".", "/") + ".lua");
-            (0, linker_1.findModuleReferences)(ast).forEach((ref) => {
+            input.references.forEach((ref) => {
                 visit(ref.moduleName);
             });
             visiting.delete(moduleName);
             stack.pop();
             this.linkOrder.push(moduleName);
+            this.progress?.tick();
         };
         visit(this.entryModule);
     }
@@ -275,19 +1444,20 @@ class Minifier {
         });
         return targets;
     }
-    buildRequireWrapper() {
+    printModuleWithRequireWrapper() {
         const targets = this.collectRequireTargets();
-        const parts = [
-            "function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end\n",
+        const moduleNames = this.linkOrder.filter((moduleName) => moduleName !== this.entryModule && targets.has(moduleName));
+        const wrapperAst = (0, generatedAst_1.buildRequireWrapperAst)(moduleNames);
+        const entryAst = this.moduleAST.get(this.entryModule);
+        const entryFileName = this.moduleNameAndFileName.get(this.entryModule);
+        if (!entryAst || !entryFileName) {
+            throw new Error(this.entryModule + " is not found");
+        }
+        const statements = [
+            wrapperAst,
+            { type: "ModuleSplice", moduleName: this.entryModule },
         ];
-        this.linkOrder.forEach((moduleName) => {
-            if (moduleName === this.entryModule || !targets.has(moduleName)) {
-                return;
-            }
-            parts.push('if m=="', moduleName, '"then r=(function() ', this.printModule(moduleName), " end)()end\n");
-        });
-        parts.push("package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end\n");
-        return new source_map_1.SourceNode(null, null, null, parts);
+        return new ast2lua_1.MinifyFile(entryFileName, this.entryModule, entryAst, this, this.mode).printGeneratedStatements(statements);
     }
 }
 exports.Minifier = Minifier;