redscript-mc 2.2.1 → 2.4.0

package/dist/src/tuner/engine.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * Nelder-Mead simplex optimization engine for hyperparameter tuning.
+ * Suitable for continuous parameter spaces without gradient information.
+ * Supports mixed-integer parameters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.search = search;
+exports.searchSA = searchSA;
+const metrics_1 = require("./metrics");
+/**
+ * Apply integer constraints to parameters.
+ */
+function applyIntegerConstraints(coords, specs) {
+    return coords.map((v, i) => {
+        const spec = specs[i];
+        // Clamp to range
+        const clamped = Math.max(spec.range[0], Math.min(spec.range[1], v));
+        return spec.integer ? Math.round(clamped) : clamped;
+    });
+}
+/**
+ * Convert coordinate array to params record.
+ */
+function coordsToParams(coords, specs) {
+    const params = {};
+    for (let i = 0; i < specs.length; i++) {
+        params[specs[i].name] = coords[i];
+    }
+    return params;
+}
+/**
+ * Evaluate a point using the adapter.
+ */
+function scorePoint(coords, specs, adapter) {
+    const constrained = applyIntegerConstraints(coords, specs);
+    const params = coordsToParams(constrained, specs);
+    const metrics = (0, metrics_1.evaluate)(adapter, params);
+    return metrics.maxError;
+}
+/**
+ * Run Nelder-Mead optimization.
+ */
+function search(adapter, budget = 10000, onProgress) {
+    const specs = adapter.params;
+    const n = specs.length;
+    if (n === 0) {
+        // No params to optimize
+        const params = coordsToParams([], specs);
+        const metrics = (0, metrics_1.evaluate)(adapter, params);
+        return {
+            params,
+            maxError: metrics.maxError,
+            mae: metrics.mae,
+            rmse: metrics.rmse,
+            budgetUsed: 0,
+        };
+    }
+    // Nelder-Mead parameters
+    const alpha = 1.0; // reflection
+    const gamma = 2.0; // expansion
+    const rho = 0.5; // contraction
+    const sigma = 0.5; // shrink
+    // Initialize simplex with n+1 points
+    const simplex = [];
+    // Start point: midpoint of each parameter range
+    const startCoords = specs.map(s => (s.range[0] + s.range[1]) / 2);
+    simplex.push({
+        coords: startCoords,
+        score: scorePoint(startCoords, specs, adapter),
+    });
+    // Generate remaining n points by perturbing each dimension
+    for (let i = 0; i < n; i++) {
+        const coords = [...startCoords];
+        const span = specs[i].range[1] - specs[i].range[0];
+        // Perturb by 20% of the range
+        coords[i] = startCoords[i] + span * 0.2;
+        simplex.push({
+            coords,
+            score: scorePoint(coords, specs, adapter),
+        });
+    }
+    let iteration = 0;
+    while (iteration < budget) {
+        // Sort simplex by score (ascending = better)
+        simplex.sort((a, b) => a.score - b.score);
+        const best = simplex[0];
+        const worst = simplex[n];
+        const secondWorst = simplex[n - 1];
+        if (onProgress && iteration % 100 === 0) {
+            onProgress(iteration, best.score);
+        }
+        // Check convergence: if all scores are the same, we're stuck
+        if (simplex[n].score - simplex[0].score < 1e-15 &&
+            iteration > 100) {
+            break;
+        }
+        // Compute centroid of all but worst
+        const centroid = new Array(n).fill(0);
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+                centroid[j] += simplex[i].coords[j] / n;
+            }
+        }
+        // Reflection
+        const reflected = centroid.map((c, j) => c + alpha * (c - worst.coords[j]));
+        const reflectedScore = scorePoint(reflected, specs, adapter);
+        iteration++;
+        if (reflectedScore < best.score) {
+            // Expansion
+            const expanded = centroid.map((c, j) => c + gamma * (reflected[j] - c));
+            const expandedScore = scorePoint(expanded, specs, adapter);
+            iteration++;
+            if (expandedScore < reflectedScore) {
+                simplex[n] = { coords: expanded, score: expandedScore };
+            }
+            else {
+                simplex[n] = { coords: reflected, score: reflectedScore };
+            }
+        }
+        else if (reflectedScore < secondWorst.score) {
+            simplex[n] = { coords: reflected, score: reflectedScore };
+        }
+        else {
+            // Contraction
+            const useReflected = reflectedScore < worst.score;
+            const contractionBase = useReflected ? reflected : worst.coords;
+            const contracted = centroid.map((c, j) => c + rho * (contractionBase[j] - c));
+            const contractedScore = scorePoint(contracted, specs, adapter);
+            iteration++;
+            if (contractedScore < (useReflected ? reflectedScore : worst.score)) {
+                simplex[n] = { coords: contracted, score: contractedScore };
+            }
+            else {
+                // Shrink
+                for (let i = 1; i <= n; i++) {
+                    simplex[i].coords = simplex[0].coords.map((c, j) => c + sigma * (simplex[i].coords[j] - c));
+                    simplex[i].score = scorePoint(simplex[i].coords, specs, adapter);
+                    iteration++;
+                }
+            }
+        }
+    }
+    // Sort final simplex
+    simplex.sort((a, b) => a.score - b.score);
+    const bestCoords = applyIntegerConstraints(simplex[0].coords, specs);
+    const bestParams = coordsToParams(bestCoords, specs);
+    const finalMetrics = (0, metrics_1.evaluate)(adapter, bestParams);
+    return {
+        params: bestParams,
+        maxError: finalMetrics.maxError,
+        mae: finalMetrics.mae,
+        rmse: finalMetrics.rmse,
+        budgetUsed: iteration,
+    };
+}
+/**
+ * Simulated Annealing search strategy.
+ * More robust than Nelder-Mead for integer parameters and multimodal objectives.
+ * Uses 3 independent restarts, taking the global best.
+ */
+function searchSA(adapter, budget, onProgress) {
+    const RESTARTS = 3;
+    const budgetPerRun = Math.floor(budget / RESTARTS);
+    let globalBest = null;
+    for (let r = 0; r < RESTARTS; r++) {
+        // Random initialisation within param ranges
+        let current = {};
+        for (const p of adapter.params) {
+            current[p.name] = p.range[0] + Math.random() * (p.range[1] - p.range[0]);
+            if (p.integer)
+                current[p.name] = Math.round(current[p.name]);
+        }
+        // T: 1.0 → 1e-4 over budgetPerRun iterations
+        let T = 1.0;
+        const cooling = Math.pow(1e-4, 1 / budgetPerRun);
+        let currentError = (0, metrics_1.evaluate)(adapter, current).maxError;
+        let bestLocal = { params: { ...current }, error: currentError };
+        for (let i = 0; i < budgetPerRun; i++) {
+            T *= cooling;
+            // Perturb one random param by ±10% of its range
+            const neighbor = { ...current };
+            const spec = adapter.params[Math.floor(Math.random() * adapter.params.length)];
+            const step = (spec.range[1] - spec.range[0]) * 0.1 * (Math.random() * 2 - 1);
+            neighbor[spec.name] = Math.max(spec.range[0], Math.min(spec.range[1], neighbor[spec.name] + step));
+            if (spec.integer)
+                neighbor[spec.name] = Math.round(neighbor[spec.name]);
+            const neighborError = (0, metrics_1.evaluate)(adapter, neighbor).maxError;
+            const delta = neighborError - currentError;
+            if (delta < 0 || Math.random() < Math.exp(-delta / T)) {
+                current = neighbor;
+                currentError = neighborError;
+            }
+            if (currentError < bestLocal.error) {
+                bestLocal = { params: { ...current }, error: currentError };
+            }
+            const globalIter = r * budgetPerRun + i;
+            if (onProgress && globalIter % 100 === 0) {
+                onProgress(globalIter, globalBest?.error ?? bestLocal.error);
+            }
+        }
+        if (!globalBest || bestLocal.error < globalBest.error) {
+            globalBest = bestLocal;
+        }
+    }
+    const finalMetrics = (0, metrics_1.evaluate)(adapter, globalBest.params);
+    return {
+        params: globalBest.params,
+        maxError: finalMetrics.maxError,
+        mae: finalMetrics.mae,
+        rmse: finalMetrics.rmse,
+        budgetUsed: budget,
+    };
+}
+//# sourceMappingURL=engine.js.map

package/dist/src/tuner/metrics.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Error metrics for tuner adapters.
+ */
+import { TunerAdapter } from './types';
+export interface EvaluationResult {
+    maxError: number;
+    mae: number;
+    rmse: number;
+}
+/**
+ * Evaluate an adapter with given params across all sample inputs.
+ * Returns max_error, mae, and rmse relative to the reference function.
+ * Penalizes overflow by returning Infinity for all metrics.
+ */
+export declare function evaluate(adapter: TunerAdapter, params: Record<string, number>): EvaluationResult;

package/dist/src/tuner/metrics.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Error metrics for tuner adapters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluate = evaluate;
+/**
+ * Evaluate an adapter with given params across all sample inputs.
+ * Returns max_error, mae, and rmse relative to the reference function.
+ * Penalizes overflow by returning Infinity for all metrics.
+ */
+function evaluate(adapter, params) {
+    const inputs = adapter.sampleInputs();
+    let maxError = 0;
+    let sumAbsError = 0;
+    let sumSqError = 0;
+    let count = 0;
+    for (const input of inputs) {
+        const simResult = adapter.simulate(input, params);
+        const refResult = adapter.reference(input);
+        // Penalize overflow or NaN
+        if (!isFinite(simResult) || isNaN(simResult)) {
+            return { maxError: Infinity, mae: Infinity, rmse: Infinity };
+        }
+        if (!isFinite(refResult) || isNaN(refResult)) {
+            continue; // skip degenerate reference points
+        }
+        // Both are in fixed-point; normalize to compare in floating-point units
+        const SCALE = 10000;
+        const simFloat = simResult / SCALE;
+        const refFloat = refResult / SCALE;
+        const absError = Math.abs(simFloat - refFloat);
+        if (absError === Infinity) {
+            return { maxError: Infinity, mae: Infinity, rmse: Infinity };
+        }
+        if (absError > maxError)
+            maxError = absError;
+        sumAbsError += absError;
+        sumSqError += absError * absError;
+        count++;
+    }
+    if (count === 0) {
+        return { maxError: Infinity, mae: Infinity, rmse: Infinity };
+    }
+    return {
+        maxError,
+        mae: sumAbsError / count,
+        rmse: Math.sqrt(sumSqError / count),
+    };
+}
+//# sourceMappingURL=metrics.js.map

package/dist/src/tuner/simulator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * MC int32 arithmetic simulation.
+ * Minecraft scoreboards use 32-bit signed integers (Java int).
+ */
+export declare const INT32_MAX = 2147483647;
+export declare const INT32_MIN = -2147483648;
+/**
+ * Truncate to int32 using JavaScript bitwise (same as Java int cast).
+ */
+export declare function i32(x: number): number;
+/**
+ * Check if a value is within int32 range (before truncation).
+ */
+export declare function isOverflow(x: number): boolean;
+/**
+ * Fixed-point multiply: compute i32(i32(a * b) / scale).
+ * Returns Infinity if overflow is detected before truncation.
+ */
+export declare function fixedMul(a: number, b: number, scale: number): number;
+/**
+ * Safe i32 addition - returns Infinity on overflow.
+ */
+export declare function safeAdd(a: number, b: number): number;
+/**
+ * Safe i32 subtraction - returns Infinity on overflow.
+ */
+export declare function safeSub(a: number, b: number): number;
+/**
+ * Safe i32 multiply - returns Infinity on overflow.
+ */
+export declare function safeMul(a: number, b: number): number;
+/**
+ * Safe i32 division - returns Infinity on division by zero.
+ */
+export declare function safeDiv(a: number, b: number): number;

package/dist/src/tuner/simulator.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * MC int32 arithmetic simulation.
+ * Minecraft scoreboards use 32-bit signed integers (Java int).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INT32_MIN = exports.INT32_MAX = void 0;
+exports.i32 = i32;
+exports.isOverflow = isOverflow;
+exports.fixedMul = fixedMul;
+exports.safeAdd = safeAdd;
+exports.safeSub = safeSub;
+exports.safeMul = safeMul;
+exports.safeDiv = safeDiv;
+exports.INT32_MAX = 2147483647;
+exports.INT32_MIN = -2147483648;
+/**
+ * Truncate to int32 using JavaScript bitwise (same as Java int cast).
+ */
+function i32(x) {
+    return x | 0;
+}
+/**
+ * Check if a value is within int32 range (before truncation).
+ */
+function isOverflow(x) {
+    return x > exports.INT32_MAX || x < exports.INT32_MIN || !isFinite(x) || isNaN(x);
+}
+/**
+ * Fixed-point multiply: compute i32(i32(a * b) / scale).
+ * Returns Infinity if overflow is detected before truncation.
+ */
+function fixedMul(a, b, scale) {
+    const product = a * b;
+    if (isOverflow(product))
+        return Infinity;
+    const truncated = i32(product);
+    const divided = truncated / scale;
+    if (isOverflow(divided))
+        return Infinity;
+    return i32(divided);
+}
+/**
+ * Safe i32 addition - returns Infinity on overflow.
+ */
+function safeAdd(a, b) {
+    const result = a + b;
+    if (isOverflow(result))
+        return Infinity;
+    return i32(result);
+}
+/**
+ * Safe i32 subtraction - returns Infinity on overflow.
+ */
+function safeSub(a, b) {
+    const result = a - b;
+    if (isOverflow(result))
+        return Infinity;
+    return i32(result);
+}
+/**
+ * Safe i32 multiply - returns Infinity on overflow.
+ */
+function safeMul(a, b) {
+    const result = a * b;
+    if (isOverflow(result))
+        return Infinity;
+    return i32(result);
+}
+/**
+ * Safe i32 division - returns Infinity on division by zero.
+ */
+function safeDiv(a, b) {
+    if (b === 0)
+        return Infinity;
+    return i32(a / b);
+}
+//# sourceMappingURL=simulator.js.map

package/dist/src/tuner/types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared types for the redscript tuner system.
+ */
+export interface ParamSpec {
+    name: string;
+    range: [number, number];
+    integer: boolean;
+}
+export interface ResultMeta {
+    maxError: number;
+    mae: number;
+    rmse: number;
+    estimatedCmds: number;
+    tuneDate: string;
+    budgetUsed: number;
+}
+export interface TunerAdapter {
+    name: string;
+    description: string;
+    params: ParamSpec[];
+    simulate(input: number, params: Record<string, number>): number;
+    reference(input: number): number;
+    sampleInputs(): number[];
+    generateCode(params: Record<string, number>, meta: ResultMeta): string;
+}
+export interface SearchResult {
+    params: Record<string, number>;
+    maxError: number;
+    mae: number;
+    rmse: number;
+    budgetUsed: number;
+}

package/dist/src/tuner/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Shared types for the redscript tuner system.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/typechecker/index.js

@@ -535,6 +535,11 @@ class TypeChecker {
                 this.checkExpr(expr.obj);
                 this.checkExpr(expr.value);
                 break;
+            case 'index_assign':
+                this.checkExpr(expr.obj);
+                this.checkExpr(expr.index);
+                this.checkExpr(expr.value);
+                break;
             case 'index':
                 this.checkExpr(expr.obj);
                 this.checkExpr(expr.index);

package/docs/STDLIB_ROADMAP.md

@@ -0,0 +1,142 @@
+# RedScript Standard Library Roadmap
+
+> 目标：覆盖卡儿数学库（large_number）的所有核心功能，但以 RedScript 语言提供干净的 API。
+> 参考分析：`docs/LARGE_NUMBER_ANALYSIS.md`（本地，不追踪到 git）
+
+---
+
+## 当前 stdlib 状态（2026-03-17）
+
+| 文件 | 内容 | 状态 |
+|------|------|------|
+| `math.mcrs` | abs/sign/clamp/lerp/ln/sqrt_fx/exp_fx/sin_fixed/cos_fixed/isqrt/gcd/lcm... | ✅ |
+| `math_hp.mcrs` | sin_hp/cos_hp（实体旋转，高精度），init_trig | ✅框架/⚠️return值待修 |
+| `random.mcrs` | LCG: next_lcg/random_range/random_bool; PCG: pcg_next/pcg_output | ✅ |
+| `vec.mcrs` | 2D/3D dot/cross/length/distance/normalize/lerp/atan2/rotate/add/sub/scale | ✅ |
+| `color.mcrs` | rgb_pack/unpack, rgb_lerp, hsl_to_r/g/b, rgb_to_h/s/l | ✅ |
+| `bits.mcrs` | bit_and/or/xor/not, bit_shl/shr, bit_get/set/clear/toggle, popcount | ✅ |
+| `list.mcrs` | sort3, min/max/avg (3/5), weighted utilities | ✅ |
+| `geometry.mcrs` | AABB/sphere/cylinder contains, parabola, angle helpers, MC sun angle | ✅ |
+| `signal.mcrs` | uniform, normal_approx12, exp_dist, bernoulli, weighted2/3 | ✅ |
+| `bigint.mcrs` | 96-bit base-10000: add/sub/mul/div/cmp, int32↔bigint3 conversion | ✅ |
+| `combat.mcrs` | damage/kill-check | ✅（原有） |
+| `player.mcrs` | health/alive/range | ✅（原有） |
+| `cooldown.mcrs` | per-player cooldown tracking | ✅（原有） |
+| `timer.mcrs` | Timer static allocation | ✅（原有） |
+| `strings.mcrs` | string utilities | ✅（原有） |
+
+---
+
+## Batch 1 — 纯整数，无需新语言特性（当前可做）
+
+### `stdlib/math.mcrs` 补充
+- [x] `abs`, `sign`, `clamp`, `lerp`, `pow2`
+- [x] `ln(x: int): int` — SA-tuned atanh 级数，max_error 0.000557
+- [x] `sqrt_fx(x: int): int` — 基于 isqrt，固定点 ×10000
+- [x] `exp_fx(x: int): int` — Horner-form Taylor + 2^k 缩放，固定点 ×10000
+
+### `stdlib/math_hp.mcrs`（新建，框架就绪）
+- [x] `init_trig()` — 初始化 Marker 实体（用户在 `@load` 里调用）
+- [x] `sin_hp`, `cos_hp` — 框架 + `@require_on_load(init_trig)` 就绪
+- [ ] 真正实现 — 需要 `@raw` / `@builtin` 语言特性（emit 层内嵌 mcfunction）
+
+### `stdlib/random.mcrs`
+- [x] `next_lcg(seed: int): int`
+- [x] `random_range(seed, lo, hi)`
+- [x] `random_bool(seed: int): int`
+
+### `stdlib/random.mcrs`（已完成）
+- [x] `next_lcg(seed: int): int`
+- [x] `random_range(seed, lo, hi)`
+- [x] `random_bool(seed: int): int`
+
+### `stdlib/vec.mcrs` 补充
+- [x] `Vec2`, `Vec3`, `dot2`, `dot3`, `dist2_sq`, `dist3_sq`
+- [ ] `add2`, `sub2`, `scale2`（Vec2 加减缩放）
+- [ ] `add3`, `sub3`, `scale3`（Vec3 加减缩放）
+- [ ] `cross3(a, b: Vec3): Vec3` — 叉积
+
+### `stdlib/color.mcrs`（新建）
+- [ ] `rgb_to_int(r, g, b: int): int` — 打包成单个 int
+- [ ] `int_to_r/g/b(c: int): int` — 解包
+- [ ] `hsl_to_rgb(h, s, l: int): (int, int, int)` — 需要元组返回值
+
+---
+
+## Batch 2 — 需要位运算支持（语言特性 PR 先）
+
+> 依赖：编译器支持 `^`、`>>`、`<<` 运算符（目前 scoreboard 没有原生位运算，需要编译器层模拟或降级）
+
+### `stdlib/random.mcrs` 升级
+- [ ] `next_pcg(state: int): int` — PCG 算法（比 LCG 质量好，需要 `^` 和 `>>` ）
+- [ ] `next_xorshift(x: int): int` — Xorshift（仅需 `^`、`>>`、`<<`）
+
+### `stdlib/bits.mcrs`（新建）
+- [ ] `bit_and(a, b: int): int` — 用加法模拟（慢但正确）
+- [ ] `bit_or(a, b: int): int`
+- [ ] `bit_xor(a, b: int): int`
+- [ ] `bit_shift_left(x, n: int): int` — 乘以 2^n
+- [ ] `bit_shift_right(x, n: int): int` — 除以 2^n
+
+---
+
+## Batch 3 — 需要数组完整支持
+
+> 依赖：数组 literal 初始化完整实现（目前只有读取，写入走 workaround）
+
+### `stdlib/list.mcrs`（新建）
+- [ ] 基于 NBT list 的动态数组
+- [ ] `list_push`, `list_pop`, `list_get`, `list_set`, `list_len`
+- [ ] `list_sort_int` — 冒泡排序（整数）
+- [ ] `list_sum`, `list_min`, `list_max`
+
+### `stdlib/math.mcrs` — 查表升级
+- [ ] `ln` 升级为查表 + 插值（需要 `@precompute` 或 `@load` 初始化 NBT list）
+- [ ] `sin`/`cos` 高精度版（查表 + 和角公式）
+
+---
+
+## Batch 4 — 高级数学（长期）
+
+### `stdlib/bigint.mcrs`
+- [ ] 万进制 int 数组大数（基于 NBT int array）
+- [ ] 大数加减乘
+- [ ] 大数除以整数（竖式法）
+
+### `stdlib/geometry.mcrs`
+- [ ] `parabola_shoot` — 抛物线弹道（给定目标点和时间计算初速度）
+- [ ] `cone_select` — 圆锥选区
+- [ ] `midpoint3` — 三维中点
+
+### `stdlib/signal.mcrs`
+- [ ] `normal_dist_approx` — 正态分布近似（12个均匀分布相加）
+- [ ] `exponential_dist` — 指数分布随机变量
+
+---
+
+## Tuner 覆盖计划
+
+以下函数需要 `redscript tune` 生成最优系数：
+
+| 函数 | Adapter | 目标精度 |
+|------|---------|---------|
+| `ln` | `ln-polynomial`（已有） | < 0.001 |
+| `sqrt` | `sqrt-newton`（待写） | < 0.001 |
+| `exp` | `exp-polynomial`（待写） | < 0.001 |
+| `sin`/`cos` | `sincos-table`（待写） | < 0.0001 |
+
+---
+
+## 语言特性依赖清单
+
+| 特性 | 依赖的 stdlib | 难度 | 状态 |
+|------|-------------|------|------|
+| `@raw` / `@builtin` 内嵌 mcfunction | `sin_hp`/`cos_hp` 实现 | 中 | ❌ TODO |
+| 位运算 `^>><< ` | random PCG, bits | 中 | ❌ TODO |
+| 数组 literal 初始化 | list, bigint | 中 | ❌ TODO（读取已修，写入待做） |
+| 元组返回值 | color（hsl_to_rgb）| 中 | ❌ TODO |
+| `@precompute` 装饰器 | 高精度 sin/cos/ln | 高 | ❌ 长期 |
+
+---
+
+*生成于 2026-03-17 · 奇尔沙治*

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.2.17",
+  "version": "1.2.34",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.2.17",
+      "version": "1.2.34",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../",
@@ -24,7 +24,7 @@
     },
     "../..": {
       "name": "redscript-mc",
-      "version": "2.2.1",
+      "version": "2.4.0",
       "license": "MIT",
       "dependencies": {
         "vscode-languageserver": "^9.0.1",

package/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "redscript-vscode",
   "displayName": "RedScript for Minecraft",
   "description": "Syntax highlighting, error diagnostics, and language support for RedScript — a compiler targeting Minecraft Java Edition",
-  "version": "1.2.17",
+  "version": "1.2.34",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/src/index.js",
   "bin": {