storm-lua-minify 0.9.0 → 0.9.1

package/README.md

@@ -86,28 +86,28 @@ storm-lua-minify --config storm-lua-minify.json --no-function-inlining script.lu
 
 ### 個別スイッチ
 
-| スイッチ                               | 既定    | 説明                                              |
-| -------------------------------------- | ------- | ------------------------------------------------- |
-| `local-renaming`                       | ON      | local名を短くします                               |
-| `local-name-reuse`                     | ON      | 生存期間が重ならないlocalで同じ名前を再利用します |
-| `global-renaming`                      | **OFF** | 内部で使うglobal名を短くします（※1）              |
-| `field-renaming`                       | ON      | 安全に変更できるfield名を短くします               |
-| `global-aliasing`                      | ON      | 繰り返し参照するglobalへ短いlocal名を割り当てます |
-| `local-declaration-merging`            | ON      | 連続するlocal宣言をまとめます                     |
-| `local-declaration-hoisting`           | ON      | local宣言を移動してまとめやすくします             |
-| `table-read-merging`                   | ON      | tableを読み取るlocal宣言をまとめます              |
-| `field-sensitive-table-effects`        | ON      | tableへの書き込みの影響をfield単位で判定します    |
-| `constant-expression-evaluation`       | **OFF** | 定数だけからなる式を事前に計算します              |
-| `local-constant-propagation`           | **OFF** | 再代入されないlocalの定数を参照先へ伝えます       |
-| `interprocedural-constant-propagation` | **OFF** | 関数の呼び出しを越えて定数を伝えます              |
-| `parameter-pruning`                    | ON      | 使われない関数parameterを取り除きます             |
-| `function-inlining`                    | ON      | 関数呼び出しを関数本体で置き換えます              |
-| `function-specialization`              | ON      | 呼び出し方に合わせて関数を特殊化します            |
-| `field-value-propagation`              | ON      | 安定したfieldの値を参照先へ伝えます               |
-| `unused-local-removal`                 | ON      | 未使用のlocalを取り除きます                       |
-| `unused-function-removal`              | ON      | 未使用のlocal関数を取り除きます                   |
-| `unused-field-initializer-removal`     | ON      | 読み取られないfieldの初期化を取り除きます         |
-| `unused-export-removal`                | ON      | entryから到達できないmodule exportを取り除きます  |
+| スイッチ                               | 既定    | 説明                                                                        |
+| -------------------------------------- | ------- | --------------------------------------------------------------------------- |
+| `local-renaming`                       | ON      | local名を短くします                                                         |
+| `local-name-reuse`                     | ON      | 生存期間が重ならないlocalで同じ名前を再利用します                           |
+| `global-renaming`                      | **OFF** | 内部で使うglobal名を短くします（※1）                                        |
+| `field-renaming`                       | ON      | 安全に変更できるfield名を短くします                                         |
+| `global-aliasing`                      | ON      | プログラム内で代入されず、繰り返し参照するglobalへ短いlocal名を割り当てます |
+| `local-declaration-merging`            | ON      | 連続するlocal宣言をまとめます                                               |
+| `local-declaration-hoisting`           | ON      | local宣言を移動してまとめやすくします                                       |
+| `table-read-merging`                   | ON      | tableを読み取るlocal宣言をまとめます                                        |
+| `field-sensitive-table-effects`        | ON      | tableへの書き込みの影響をfield単位で判定します                              |
+| `constant-expression-evaluation`       | **OFF** | 定数だけからなる式を事前に計算します                                        |
+| `local-constant-propagation`           | **OFF** | 再代入されないlocalの定数を参照先へ伝えます                                 |
+| `interprocedural-constant-propagation` | **OFF** | 関数の呼び出しを越えて定数を伝えます                                        |
+| `parameter-pruning`                    | ON      | 使われない関数parameterを取り除きます                                       |
+| `function-inlining`                    | ON      | 関数呼び出しを関数本体で置き換えます                                        |
+| `function-specialization`              | ON      | 呼び出し方に合わせて関数を特殊化します                                      |
+| `field-value-propagation`              | ON      | 安定したfieldの値を参照先へ伝えます                                         |
+| `unused-local-removal`                 | ON      | 未使用のlocalを取り除きます                                                 |
+| `unused-function-removal`              | ON      | 未使用のlocal関数を取り除きます                                             |
+| `unused-field-initializer-removal`     | ON      | 読み取られないfieldの初期化を取り除きます                                   |
+| `unused-export-removal`                | ON      | entryから到達できないmodule exportを取り除きます                            |
 
 安全性の条件を満たさない候補は、スイッチが有効でも実行されません。
 

package/dist/cliOptions.js

@@ -10,7 +10,7 @@ function addBooleanSwitch(command, name, description, shortName) {
 /** Build the v1 CLI surface without materializing inherited defaults. */
 function createCliProgram() {
     const command = new commander_1.Command()
-        .version("0.9.0")
+        .version("0.9.1")
         .description("A Lua minifier also outputs source map")
         .option("--config <path>", "JSON configuration file")
         .addOption(new commander_1.Option("--runtime-profile <profile>", "Target runtime semantics")

package/dist/globalRename.js

@@ -1,16 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectProgramWrittenGlobals = collectProgramWrittenGlobals;
 exports.classifyAndRenameGlobals = classifyAndRenameGlobals;
 const renamer_1 = require("./renamer");
 const linker_1 = require("./linker");
+/**
+ * Returns names whose shared global binding is written by any linked module.
+ * A module that only reads one of these names must not mistake it for a
+ * read-only value supplied by the runtime environment.
+ */
+function collectProgramWrittenGlobals(moduleResolve) {
+    const written = new Set();
+    moduleResolve.forEach((resolved) => {
+        resolved.globals.forEach((binding) => {
+            if (binding.writes.length > 0)
+                written.add(binding.name);
+        });
+    });
+    return written;
+}
 function classifyAndRenameGlobals(moduleResolve, neverRename, reserved) {
-    const everWritten = new Set();
+    const everWritten = collectProgramWrittenGlobals(moduleResolve);
     const totalReferenceCount = new Map();
     moduleResolve.forEach((resolved) => {
         resolved.globals.forEach((binding) => {
-            if (binding.writes.length > 0) {
-                everWritten.add(binding.name);
-            }
             totalReferenceCount.set(binding.name, (totalReferenceCount.get(binding.name) ?? 0) +
                 binding.references.length);
         });

package/dist/minifier.js

@@ -35,6 +35,41 @@ 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;
 }
@@ -69,13 +104,16 @@ class Minifier {
     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;
-    exportDceChanged = false;
-    constructor(entryFilePath, luaParseSettings, mode, schedulerVariantOrProgress, functionRewriteVariant, fieldFactVariant, aggregateSpecializationVariant, exportDceVariant, fieldRenameVariant, progress) {
+    constructor(entryFilePath, luaParseSettings, mode, schedulerVariantOrProgress, functionRewriteVariant, fieldFactVariant, aggregateSpecializationVariant, exportDceVariant, fieldRenameVariant, progress, inputCache) {
         this.schedulerVariant =
             typeof schedulerVariantOrProgress === "string"
                 ? schedulerVariantOrProgress
@@ -89,6 +127,7 @@ class Minifier {
             typeof schedulerVariantOrProgress === "object"
                 ? schedulerVariantOrProgress
                 : progress;
+        this.inputCache = inputCache ?? new Map();
         this.entryFilePath = entryFilePath;
         this.identifiersInUse = new Set();
         this.moduleSourceText = new Map();
@@ -126,206 +165,176 @@ class Minifier {
         return this.wholeProgramFieldRenamesValue;
     }
     parse() {
-        if (this.fieldRenameVariant === undefined && this.fieldRenamesEnabled()) {
-            return this.parseWithFieldRenameSelection();
-        }
-        if (this.exportDceVariant === undefined && this.exportDceEnabled()) {
-            return this.parseWithExportDceSelection();
-        }
-        if (this.fieldFactVariant === undefined && this.fieldFactsEnabled()) {
-            return this.parseWithFieldFactSelection();
-        }
-        if (this.aggregateSpecializationVariant === undefined &&
-            this.functionSpecializationEnabled()) {
-            return this.parseWithAggregateSpecializationSelection();
-        }
-        if (this.functionRewriteVariant === undefined &&
-            this.functionRewritesEnabled()) {
-            return this.parseWithFunctionRewriteSelection();
-        }
-        if (this.schedulerVariant === undefined &&
-            this.requiresSchedulerSelection()) {
-            return this.parseWithSchedulerSelection();
-        }
+        if (this.costGatesToSelect().length > 0)
+            return this.parseWithCostGateSelection();
         return this.parseOnce();
     }
-    parseWithFieldRenameSelection() {
-        this.progress?.addSteps(2);
-        this.progress?.startStep("Evaluate field renaming baseline");
-        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, undefined, undefined, undefined, "baseline", this.progress);
-        const baseline = baselineMinifier.parse();
-        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
-        let trialMinifier;
-        let trial;
+    /**
+     * 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 {
-            this.progress?.startStep("Evaluate field renaming trial");
-            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, undefined, undefined, undefined, "trial", this.progress);
-            trial = trialMinifier.parse();
+            fullTrial = this.evaluateCostVariant(this.costGateVariants("trial"), "Evaluate joint cost-gated trial", evaluated);
         }
         catch {
-            this.copyDiagnosticsFrom(baselineMinifier);
-            this.recordFinalFieldRenameDecision("rejected", "trial-failed");
-            return this.adoptVariant(baselineMinifier, baseline);
+            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);
         }
-        const trialBytes = new TextEncoder().encode(trial.toString()).length;
-        if (trialBytes >= baselineBytes) {
-            this.copyDiagnosticsFrom(trialMinifier);
-            this.recordFinalFieldRenameDecision("rejected", "final-output-not-shorter");
-            return this.adoptVariant(baselineMinifier, baseline);
+        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;
         }
-        this.copyDiagnosticsFrom(trialMinifier);
-        this.recordFinalFieldRenameDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
-        return this.adoptVariant(trialMinifier, trial);
+        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);
     }
-    parseWithExportDceSelection() {
+    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);
-        let trialMinifier;
-        let trial;
+        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 {
-            this.progress?.startStep("Evaluate unused export removal trial");
-            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, undefined, undefined, "trial", this.fieldRenameVariant, this.progress);
-            trial = trialMinifier.parse();
+            output = minifier.parseOnce();
         }
-        catch {
-            this.progress?.addSteps(1);
-            this.progress?.startStep("Evaluate unused export removal baseline");
-            const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, undefined, undefined, "baseline", this.fieldRenameVariant, this.progress);
-            const baseline = baselineMinifier.parse();
-            this.copyDiagnosticsFrom(baselineMinifier);
-            this.recordFinalExportDceDecision("rejected", "trial-failed");
-            return this.adoptVariant(baselineMinifier, baseline);
-        }
-        if (!trialMinifier.exportDceChanged) {
-            this.copyDiagnosticsFrom(trialMinifier);
-            this.recordFinalExportDceDecision("rejected", "final-output-not-shorter");
-            return this.adoptVariant(trialMinifier, trial);
-        }
-        this.progress?.addSteps(1);
-        this.progress?.startStep("Evaluate unused export removal baseline");
-        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, undefined, undefined, "baseline", this.fieldRenameVariant, this.progress);
-        const baseline = baselineMinifier.parse();
-        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
-        const trialBytes = new TextEncoder().encode(trial.toString()).length;
-        if (trialBytes >= baselineBytes) {
-            this.copyDiagnosticsFrom(trialMinifier);
-            this.recordFinalExportDceDecision("rejected", "final-output-not-shorter");
-            return this.adoptVariant(baselineMinifier, baseline);
+        catch (error) {
+            candidateProgress?.finishFailedCandidate();
+            throw error;
         }
-        this.copyDiagnosticsFrom(trialMinifier);
-        this.recordFinalExportDceDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
-        return this.adoptVariant(trialMinifier, trial);
+        const result = {
+            minifier,
+            output,
+            byteLength: new TextEncoder().encode(output.toString()).length,
+            variants,
+        };
+        evaluated.set(key, result);
+        return result;
     }
-    parseWithFieldFactSelection() {
-        this.progress?.addSteps(2);
-        this.progress?.startStep("Evaluate field optimization baseline");
-        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, "baseline", this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
-        const baseline = baselineMinifier.parse();
-        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
-        let trialMinifier;
-        let trial;
-        try {
-            this.progress?.startStep("Evaluate field optimization trial");
-            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, "trial", this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
-            trial = trialMinifier.parse();
-        }
-        catch {
-            this.copyDiagnosticsFrom(baselineMinifier);
-            this.recordFinalFieldFactDecision("rejected", "trial-failed");
-            return this.adoptVariant(baselineMinifier, baseline);
-        }
-        const trialBytes = new TextEncoder().encode(trial.toString()).length;
-        if (trialBytes >= baselineBytes) {
-            this.copyDiagnosticsFrom(trialMinifier);
-            this.recordFinalFieldFactDecision("rejected", "final-output-not-shorter");
-            return this.adoptVariant(baselineMinifier, baseline);
-        }
-        this.copyDiagnosticsFrom(trialMinifier);
-        this.recordFinalFieldFactDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
-        return this.adoptVariant(trialMinifier, trial);
+    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,
+        };
     }
-    parseWithAggregateSpecializationSelection() {
-        this.progress?.addSteps(2);
-        this.progress?.startStep("Evaluate function specialization baseline");
-        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, this.fieldFactVariant, "baseline", this.exportDceVariant, this.fieldRenameVariant, this.progress);
-        const baseline = baselineMinifier.parse();
-        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
-        let trialMinifier;
-        let trial;
-        try {
-            this.progress?.startStep("Evaluate function specialization trial");
-            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, undefined, this.fieldFactVariant, "trial", this.exportDceVariant, this.fieldRenameVariant, this.progress);
-            trial = trialMinifier.parse();
-        }
-        catch {
-            this.copyDiagnosticsFrom(baselineMinifier);
-            this.recordFinalAggregateSpecializationDecision("rejected", "trial-failed");
-            return this.adoptVariant(baselineMinifier, baseline);
-        }
-        const trialBytes = new TextEncoder().encode(trial.toString()).length;
-        if (trialBytes >= baselineBytes) {
-            this.copyDiagnosticsFrom(trialMinifier);
-            this.recordFinalAggregateSpecializationDecision("rejected", "final-output-not-shorter");
-            return this.adoptVariant(baselineMinifier, baseline);
-        }
-        this.copyDiagnosticsFrom(trialMinifier);
-        this.recordFinalAggregateSpecializationDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
-        return this.adoptVariant(trialMinifier, trial);
+    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());
+            }
+        });
     }
-    parseWithFunctionRewriteSelection() {
-        this.progress?.addSteps(2);
-        this.progress?.startStep("Evaluate function rewrites baseline");
-        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, "baseline", this.fieldFactVariant, this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
-        const baseline = baselineMinifier.parse();
-        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
-        let trialMinifier;
-        let trial;
-        try {
-            this.progress?.startStep("Evaluate function rewrites trial");
-            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, undefined, "trial", this.fieldFactVariant, this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
-            trial = trialMinifier.parse();
+    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";
         }
-        catch {
-            this.copyDiagnosticsFrom(baselineMinifier);
-            this.recordFinalFunctionRewriteDecision("rejected", "trial-failed");
-            return this.adoptVariant(baselineMinifier, baseline);
-        }
-        const trialBytes = new TextEncoder().encode(trial.toString()).length;
-        if (trialBytes >= baselineBytes) {
-            this.copyDiagnosticsFrom(trialMinifier);
-            this.recordFinalFunctionRewriteDecision("rejected", "final-output-not-shorter");
-            return this.adoptVariant(baselineMinifier, baseline);
-        }
-        this.copyDiagnosticsFrom(trialMinifier);
-        this.recordFinalFunctionRewriteDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
-        return this.adoptVariant(trialMinifier, trial);
     }
-    parseWithSchedulerSelection() {
-        this.progress?.addSteps(2);
-        this.progress?.startStep("Evaluate statement scheduling baseline");
-        const baselineMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, "baseline", this.functionRewriteVariant, this.fieldFactVariant, this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
-        const baseline = baselineMinifier.parseOnce();
-        const baselineBytes = new TextEncoder().encode(baseline.toString()).length;
-        let trialMinifier;
-        let trial;
-        try {
-            this.progress?.startStep("Evaluate statement scheduling trial");
-            trialMinifier = new Minifier(this.entryFilePath, this.luaParseSettings, this.mode, "trial", this.functionRewriteVariant, this.fieldFactVariant, this.aggregateSpecializationVariant, this.exportDceVariant, this.fieldRenameVariant, this.progress);
-            trial = trialMinifier.parseOnce();
-        }
-        catch {
-            this.copyDiagnosticsFrom(baselineMinifier);
-            this.recordFinalSchedulerDecision("rejected", "trial-failed");
-            return this.adoptVariant(baselineMinifier, baseline);
-        }
-        const trialBytes = new TextEncoder().encode(trial.toString()).length;
-        if (trialBytes >= baselineBytes) {
-            this.copyDiagnosticsFrom(trialMinifier);
-            this.recordFinalSchedulerDecision("rejected", "final-output-not-shorter");
-            return this.adoptVariant(baselineMinifier, baseline);
+    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);
         }
-        this.copyDiagnosticsFrom(trialMinifier);
-        this.recordFinalSchedulerDecision("accepted", "final-output-shorter", baselineBytes - trialBytes);
-        return this.adoptVariant(trialMinifier, trial);
     }
     parseOnce() {
         this.progress?.addSteps(11);
@@ -427,7 +436,6 @@ class Minifier {
         }));
         if (!result.changed)
             return;
-        this.exportDceChanged = true;
         this.linkOrder.forEach((moduleName) => {
             const ast = this.moduleAST.get(moduleName);
             if (!ast)
@@ -898,7 +906,6 @@ class Minifier {
         this.wholeProgramFieldsValue = minifier.wholeProgramFieldsValue;
         this.wholeProgramExportsValue = minifier.wholeProgramExportsValue;
         this.wholeProgramFieldRenamesValue = minifier.wholeProgramFieldRenamesValue;
-        this.exportDceChanged = minifier.exportDceChanged;
         return output;
     }
     recordFinalSchedulerDecision(decision, reason, byteSavings) {
@@ -913,6 +920,18 @@ class Minifier {
             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",
@@ -1084,10 +1103,16 @@ 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(),
@@ -1363,11 +1388,22 @@ 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パスの
             // 入力として使い回せるようキャッシュする。グローバル参照はプログラム全体で
@@ -1379,7 +1415,7 @@ class Minifier {
             // 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);

package/dist/optimizerValueDomain.js

@@ -22,16 +22,16 @@ exports.EMPTY_OPTIMIZER_TUPLE = Object.freeze({
     tail: Object.freeze({ kind: "none" }),
 });
 function finiteOptimizerValue(atoms = [], unknownReasons = [], limits = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS) {
-    validateLimits(limits);
+    validateCustomLimits(limits);
     const normalizedAtoms = uniqueSorted(atoms, atomKey);
     const normalizedReasons = uniqueSorted(unknownReasons, (reason) => reason);
     const atomOverflow = normalizedAtoms.length > limits.maxAtoms;
     const reasons = atomOverflow
-        ? [...normalizedReasons, "atom-cap-exceeded"]
-        : normalizedReasons;
+        ? capReasons([...normalizedReasons, "atom-cap-exceeded"], limits.maxUnknownReasons)
+        : capNormalizedReasons(normalizedReasons, limits.maxUnknownReasons);
     return Object.freeze({
         atoms: Object.freeze(normalizedAtoms.slice(0, limits.maxAtoms)),
-        unknownReasons: Object.freeze(capReasons(reasons, limits.maxUnknownReasons)),
+        unknownReasons: Object.freeze(reasons),
     });
 }
 function unknownOptimizerValue(reason, limits = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS) {
@@ -41,7 +41,7 @@ function joinOptimizerValues(values, limits = exports.DEFAULT_OPTIMIZER_VALUE_DO
     return finiteOptimizerValue(values.flatMap((value) => value.atoms), values.flatMap((value) => value.unknownReasons), limits);
 }
 function finiteOptimizerTuple(prefix, tail = { kind: "none" }, limits = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS) {
-    validateLimits(limits);
+    validateCustomLimits(limits);
     const normalizedPrefix = prefix
         .slice(0, limits.maxTuplePrefix)
         .map((value) => finiteOptimizerValue(value.atoms, value.unknownReasons, limits));
@@ -75,7 +75,7 @@ function valueAtOptimizerTupleSlot(tuple, index, limits = exports.DEFAULT_OPTIMI
     }
 }
 function joinOptimizerTuples(tuples, limits = exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS) {
-    validateLimits(limits);
+    validateCustomLimits(limits);
     if (tuples.length === 0)
         return exports.EMPTY_OPTIMIZER_TUPLE;
     const prefixLength = Math.min(Math.max(...tuples.map((tuple) => tuple.prefix.length)), limits.maxTuplePrefix);
@@ -151,6 +151,17 @@ function atomKey(atom) {
     }
 }
 function uniqueSorted(values, keyOf) {
+    if (values.length === 0)
+        return [];
+    if (values.length === 1)
+        return [values[0]];
+    if (values.length === 2) {
+        const firstKey = keyOf(values[0]);
+        const lastKey = keyOf(values[1]);
+        if (firstKey === lastKey)
+            return [values[1]];
+        return firstKey < lastKey ? [values[0], values[1]] : [values[1], values[0]];
+    }
     const byKey = new Map();
     values.forEach((value) => byKey.set(keyOf(value), value));
     return [...byKey.entries()]
@@ -159,6 +170,9 @@ function uniqueSorted(values, keyOf) {
 }
 function capReasons(reasons, maximum) {
     const normalized = uniqueSorted(reasons, (reason) => reason);
+    return capNormalizedReasons(normalized, maximum);
+}
+function capNormalizedReasons(normalized, maximum) {
     if (normalized.length <= maximum)
         return normalized;
     if (maximum === 0)
@@ -168,6 +182,12 @@ function capReasons(reasons, maximum) {
         "reason-cap-exceeded",
     ];
 }
+function validateCustomLimits(limits) {
+    // The default is a module-owned frozen literal that satisfies the invariants.
+    // Nearly every optimizer value uses it, so do not enumerate its fields again.
+    if (limits !== exports.DEFAULT_OPTIMIZER_VALUE_DOMAIN_LIMITS)
+        validateLimits(limits);
+}
 function validateLimits(limits) {
     Object.entries(limits).forEach(([name, value]) => {
         if (!Number.isInteger(value) || value < 0)

package/dist/renamer.js

@@ -124,9 +124,44 @@ function buildVariableInterference(chunk, resolved, symbols, allowLocalNameReuse
                 addEdge(graph, symbol, other);
         });
     });
+    // Liveness alone does not model Lua's lexical shadowing. An earlier local
+    // may be dead at a later declaration and then be assigned again; if both
+    // declarations receive one spelling, the later declaration captures that
+    // assignment and every following reference. Preserve reuse when all uses of
+    // the earlier binding precede the later declaration, but add an edge when
+    // any use follows it.
+    const declarationOrder = new Map(symbols.map((symbol) => [
+        symbol,
+        requireResolutionOrder(resolved, symbol.declaration),
+    ]));
+    const lastReferenceOrder = new Map(symbols.map((symbol) => [
+        symbol,
+        symbol.references.reduce((last, reference) => Math.max(last, requireResolutionOrder(resolved, reference)), -1),
+    ]));
+    for (let left = 0; left < symbols.length; left++) {
+        for (let right = left + 1; right < symbols.length; right++) {
+            const first = symbols[left];
+            const last = symbols[right];
+            if (first.scope !== last.scope)
+                continue;
+            const firstDeclarationOrder = declarationOrder.get(first) ?? -1;
+            const lastDeclarationOrder = declarationOrder.get(last) ?? -1;
+            const [earlier, laterDeclarationOrder] = firstDeclarationOrder < lastDeclarationOrder
+                ? [first, lastDeclarationOrder]
+                : [last, firstDeclarationOrder];
+            if ((lastReferenceOrder.get(earlier) ?? -1) > laterDeclarationOrder)
+                addEdge(graph, first, last);
+        }
+    }
     addLexicalEdges(graph, symbols, allowLocalNameReuse);
     return graph;
 }
+function requireResolutionOrder(resolved, identifier) {
+    const order = resolved.resolutionOrderOf(identifier);
+    if (order === undefined)
+        throw new Error("Resolved identifier has no resolution order");
+    return order;
+}
 function buildLexicalGraph(symbols, allowSameScopeReuse) {
     const graph = mutableGraph(symbols);
     addLexicalEdges(graph, symbols, allowSameScopeReuse);
@@ -170,35 +205,42 @@ function addEdge(graph, first, last) {
 /** Deterministic weighted DSATUR coloring. */
 function colorGraph(graph) {
     const colors = new Map();
+    // Keep the colored-neighbor set incrementally. Recomputing it inside the
+    // sort comparator makes dense module graphs dominate the whole pipeline.
+    const saturationColors = new Map([...graph.keys()].map((symbol) => [symbol, new Set()]));
     while (colors.size < graph.size) {
-        const remaining = [...graph.keys()].filter((symbol) => !colors.has(symbol));
-        remaining.sort((left, right) => {
-            const saturationDifference = saturation(graph, colors, right) - saturation(graph, colors, left);
-            if (saturationDifference !== 0)
-                return saturationDifference;
-            const weightDifference = weightOf(right) - weightOf(left);
-            if (weightDifference !== 0)
-                return weightDifference;
-            const degreeDifference = (graph.get(right)?.size ?? 0) - (graph.get(left)?.size ?? 0);
-            return degreeDifference !== 0 ? degreeDifference : left.id - right.id;
+        let symbol;
+        graph.forEach((_neighbors, candidate) => {
+            if (colors.has(candidate))
+                return;
+            if (symbol === undefined ||
+                coloringPriority(candidate, symbol, graph, saturationColors) < 0)
+                symbol = candidate;
         });
-        const symbol = remaining[0];
-        const unavailable = new Set([...(graph.get(symbol) ?? [])].flatMap((neighbor) => {
-            const color = colors.get(neighbor);
-            return color === undefined ? [] : [color];
-        }));
+        if (symbol === undefined)
+            throw new Error("Uncolored symbol not found");
+        const unavailable = saturationColors.get(symbol) ?? new Set();
         let color = 0;
         while (unavailable.has(color))
             color++;
         colors.set(symbol, color);
+        graph.get(symbol)?.forEach((neighbor) => {
+            if (!colors.has(neighbor))
+                saturationColors.get(neighbor)?.add(color);
+        });
     }
     return colors;
 }
-function saturation(graph, colors, symbol) {
-    return new Set([...(graph.get(symbol) ?? [])].flatMap((neighbor) => {
-        const color = colors.get(neighbor);
-        return color === undefined ? [] : [color];
-    })).size;
+function coloringPriority(left, right, graph, saturationColors) {
+    const saturationDifference = (saturationColors.get(right)?.size ?? 0) -
+        (saturationColors.get(left)?.size ?? 0);
+    if (saturationDifference !== 0)
+        return saturationDifference;
+    const weightDifference = weightOf(right) - weightOf(left);
+    if (weightDifference !== 0)
+        return weightDifference;
+    const degreeDifference = (graph.get(right)?.size ?? 0) - (graph.get(left)?.size ?? 0);
+    return degreeDifference !== 0 ? degreeDifference : left.id - right.id;
 }
 function weightOf(symbol) {
     return symbol.references.length + 1;
@@ -257,8 +299,17 @@ function validateBindings(chunk, original, names, globalRenames) {
             return;
         }
         [symbol.declaration, ...symbol.references].forEach((identifier) => {
-            if (recolored.symbolOf(identifier)?.declaration !== symbol.declaration)
-                throw new Error(`Identifier coloring changed binding for symbol ${String(symbol.id)}`);
+            const rebound = recolored.symbolOf(identifier);
+            if (rebound?.declaration !== symbol.declaration) {
+                const reboundOriginal = rebound
+                    ? original.symbolOf(rebound.declaration)
+                    : undefined;
+                throw new Error(`Identifier coloring changed binding for symbol ${String(symbol.id)} ` +
+                    `(${symbol.name} -> ${names.get(symbol) ?? symbol.name}, ` +
+                    `declaration ${formatIdentifierLocation(symbol.declaration)}, ` +
+                    `reference ${formatIdentifierLocation(identifier)}, ` +
+                    `rebound to ${reboundOriginal ? `symbol ${String(reboundOriginal.id)} (${reboundOriginal.name} -> ${names.get(reboundOriginal) ?? reboundOriginal.name}) at ${formatIdentifierLocation(reboundOriginal.declaration)}` : "global"})`);
+            }
         });
     });
     original.globals.forEach((binding) => {
@@ -268,3 +319,9 @@ function validateBindings(chunk, original, names, globalRenames) {
         });
     });
 }
+function formatIdentifierLocation(identifier) {
+    const location = identifier.loc?.start;
+    return location
+        ? `${String(location.line)}:${String(location.column)}`
+        : "unknown";
+}

package/dist/resolver.js

@@ -6,6 +6,8 @@ function resolveScopes(chunk, options = {}) {
     const allSymbols = [];
     const globals = new Map();
     const identifierSymbols = new WeakMap();
+    const identifierResolutionOrders = new WeakMap();
+    let nextResolutionOrder = 0;
     const globalReferenceNodes = new WeakSet();
     const functionScopes = new WeakMap();
     const identifierName = options.identifierName ??
@@ -23,6 +25,7 @@ function resolveScopes(chunk, options = {}) {
         return scope;
     }
     function declare(scope, node, kind, implicit = false) {
+        identifierResolutionOrders.set(node, nextResolutionOrder++);
         const name = identifierName(node);
         const symbol = {
             id: nextSymbolId++,
@@ -41,6 +44,7 @@ function resolveScopes(chunk, options = {}) {
         return symbol;
     }
     function declareLabel(scope, node) {
+        identifierResolutionOrders.set(node, nextResolutionOrder++);
         const name = identifierName(node);
         const symbol = {
             id: nextSymbolId++,
@@ -75,6 +79,7 @@ function resolveScopes(chunk, options = {}) {
         return undefined;
     }
     function reference(scope, node, isWrite = false) {
+        identifierResolutionOrders.set(node, nextResolutionOrder++);
         const name = identifierName(node);
         const symbol = lookupBinding(scope, name);
         if (symbol) {
@@ -195,6 +200,7 @@ function resolveScopes(chunk, options = {}) {
                 // hoistLabelsで宣言済みのため、ここでは何もしない
                 return;
             case "GotoStatement": {
+                identifierResolutionOrders.set(statement.label, nextResolutionOrder++);
                 const symbol = lookupLabel(scope, identifierName(statement.label));
                 if (symbol) {
                     symbol.references.push(statement.label);
@@ -319,6 +325,7 @@ function resolveScopes(chunk, options = {}) {
         chunkScope,
         symbols: allSymbols,
         globals,
+        resolutionOrderOf: (identifier) => identifierResolutionOrders.get(identifier),
         symbolOf: (identifier) => identifierSymbols.get(identifier),
         isGlobalReference: (identifier) => globalReferenceNodes.has(identifier),
         scopeOfFunction: (fn) => functionScopes.get(fn),

package/dist/statementScheduler.js

@@ -140,12 +140,15 @@ function applyStatementSchedule(schedule, metadata) {
     const actions = [
         ...schedule.localGroups.map((group) => ({ kind: "local", group })),
         ...schedule.tableGroups.map((group) => ({ kind: "table", group })),
-    ].sort((left, right) => {
-        if (left.group.body !== right.group.body)
-            return 0;
-        return right.group.indexes[0] - left.group.indexes[0];
-    });
+    ];
+    const actionsByBody = new Map();
     actions.forEach((action) => {
+        const bodyActions = actionsByBody.get(action.group.body) ?? [];
+        bodyActions.push(action);
+        actionsByBody.set(action.group.body, bodyActions);
+    });
+    const orderedActions = [...actionsByBody.values()].flatMap((bodyActions) => bodyActions.sort((left, right) => right.group.indexes[0] - left.group.indexes[0]));
+    orderedActions.forEach((action) => {
         if (action.kind === "table") {
             const group = action.group;
             const combined = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "storm-lua-minify",
   "description": "A Lua minifier also outputs source map",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "engines": {
     "node": ">=22"
   },