redscript-mc 1.2.26 → 1.2.28

package/dist/__tests__/stdlib-bigint.test.js

@@ -0,0 +1,428 @@
+"use strict";
+/**
+ * stdlib/bigint.mcrs — runtime behavioural tests
+ *
+ * Tests basic BigInt operations (base 10000, 8 limbs = 32 decimal digits).
+ * All arithmetic validated against known values.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const compile_1 = require("../compile");
+const runtime_1 = require("../runtime");
+const MATH_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8');
+const BIGINT_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/bigint.mcrs'), 'utf-8');
+function run(driver) {
+    const result = (0, compile_1.compile)(driver, {
+        namespace: 'bitest',
+        librarySources: [MATH_SRC, BIGINT_SRC],
+    });
+    if (!result.success)
+        throw new Error(result.error?.message ?? 'compile failed');
+    const rt = new runtime_1.MCRuntime('bitest');
+    for (const file of result.files ?? []) {
+        if (!file.path.endsWith('.mcfunction'))
+            continue;
+        const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/);
+        if (!match)
+            continue;
+        rt.loadFunction(`${match[1]}:${match[2]}`, file.content.split('\n'));
+    }
+    rt.load();
+    return rt;
+}
+function sc(rt, key) {
+    return rt.getScore('out', `bitest.${key}`) ?? 0;
+}
+// ── storage_set_int roundtrip ─────────────────────────────────────────────────
+describe('storage_set_int roundtrip', () => {
+    it('static index: write 99 to arr[2], read back', () => {
+        const rt = run(`fn test() {
+      storage_set_array("rs:t", "arr", "[10,20,30,40]");
+      storage_set_int("rs:t", "arr", 2, 99);
+      scoreboard_set("out", "r", storage_get_int("rs:t", "arr", 2));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(99);
+    });
+    it('runtime index: write 777 to arr[idx], read back', () => {
+        const rt = run(`fn test() {
+      storage_set_array("rs:t", "arr", "[1,2,3,4,5]");
+      let idx: int = 3;
+      storage_set_int("rs:t", "arr", idx, 777);
+      scoreboard_set("out", "r", storage_get_int("rs:t", "arr", idx));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(777);
+    });
+    it('loop write: fill arr[0..3] with 10,20,30,40', () => {
+        const rt = run(`fn test() {
+      storage_set_array("rs:t", "arr", "[0,0,0,0]");
+      let i: int = 0;
+      while (i < 4) {
+        storage_set_int("rs:t", "arr", i, (i + 1) * 10);
+        i = i + 1;
+      }
+      scoreboard_set("out", "a", storage_get_int("rs:t", "arr", 0));
+      scoreboard_set("out", "b", storage_get_int("rs:t", "arr", 1));
+      scoreboard_set("out", "c", storage_get_int("rs:t", "arr", 2));
+      scoreboard_set("out", "d", storage_get_int("rs:t", "arr", 3));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'a')).toBe(10);
+        expect(sc(rt, 'b')).toBe(20);
+        expect(sc(rt, 'c')).toBe(30);
+        expect(sc(rt, 'd')).toBe(40);
+    });
+});
+// ── bigint_init + from_int ────────────────────────────────────────────────────
+describe('bigint init and load', () => {
+    it('bigint_init zeros registers', () => {
+        const rt = run(`fn test() {
+      bigint_init();
+      scoreboard_set("out", "r", bigint_get_a(0));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(0);
+    });
+    it('bigint_from_int_a(12345678): limb0=5678, limb1=1234', () => {
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(12345678);
+      scoreboard_set("out", "l0", bigint_get_a(0));
+      scoreboard_set("out", "l1", bigint_get_a(1));
+      scoreboard_set("out", "l2", bigint_get_a(2));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(5678);
+        expect(sc(rt, 'l1')).toBe(1234);
+        expect(sc(rt, 'l2')).toBe(0);
+    });
+    it('bigint_from_int_a(2000000000): limb0=0, limb1=0, limb2=20', () => {
+        // 2000000000 = 20 × 10000^2 (not 2000: 20 × 10^8 = 2×10^9 ✓)
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(2000000000);
+      scoreboard_set("out", "l0", bigint_get_a(0));
+      scoreboard_set("out", "l1", bigint_get_a(1));
+      scoreboard_set("out", "l2", bigint_get_a(2));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(0);
+        expect(sc(rt, 'l1')).toBe(0);
+        expect(sc(rt, 'l2')).toBe(20);
+    });
+});
+// ── bigint_add ────────────────────────────────────────────────────────────────
+describe('bigint_add', () => {
+    it('1 + 1 = 2 (simple)', () => {
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(1);
+      bigint_from_int_b(1);
+      bigint_add();
+      scoreboard_set("out", "r", bigint_get_c(0));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(2);
+    });
+    it('9999 + 1 = 10000: carry across limb boundary', () => {
+        // a=[9999,0,...] + b=[1,0,...] = c=[0,1,0,...] (carry to limb1)
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(9999);
+      bigint_from_int_b(1);
+      bigint_add();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(0);
+        expect(sc(rt, 'l1')).toBe(1);
+    });
+    it('99990000 + 10000 = 100000000: multi-limb carry', () => {
+        // a=[0,9999,...] + b=[0,1,...] = c=[0,0,1,...] (carry to limb2)
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(99990000);
+      bigint_from_int_b(10000);
+      bigint_add();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+      scoreboard_set("out", "l2", bigint_get_c(2));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(0);
+        expect(sc(rt, 'l1')).toBe(0);
+        expect(sc(rt, 'l2')).toBe(1);
+    });
+    it('large add: 999999999 + 999999999', () => {
+        // 999999999 = [9999, 9999, 9, 0, ...]
+        // + same = [9998, 9999, 18, 0, ...] after carry
+        // = 1999999998: l0=9998, l1=9999, l2=19 (carry: 9+9=18, no carry from l2)
+        // Wait: l0=9999+9999=19998, carry=1, l0=9998
+        //       l1=9999+9999+1=19999, carry=1, l1=9999
+        //       l2=9+9+1=19, carry=0, l2=19
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(999999999);
+      bigint_from_int_b(999999999);
+      bigint_add();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+      scoreboard_set("out", "l2", bigint_get_c(2));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(9998); // 1999999998 % 10000 = 9998
+        expect(sc(rt, 'l1')).toBe(9999); // floor(1999999998 / 10000) % 10000 = 9999
+        expect(sc(rt, 'l2')).toBe(19); // floor(1999999998 / 100000000) = 19
+    });
+});
+// ── bigint_sub ────────────────────────────────────────────────────────────────
+describe('bigint_sub', () => {
+    it('10 - 3 = 7', () => {
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(10);
+      bigint_from_int_b(3);
+      bigint_sub();
+      scoreboard_set("out", "r", bigint_get_c(0));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(7);
+    });
+    it('10000 - 1 = 9999: borrow across limb boundary', () => {
+        // a=[0,1,...] - b=[1,0,...] = c=[9999,0,...] (borrow from limb1)
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(10000);
+      bigint_from_int_b(1);
+      bigint_sub();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(9999);
+        expect(sc(rt, 'l1')).toBe(0);
+    });
+});
+// ── bigint_compare ────────────────────────────────────────────────────────────
+describe('bigint_compare', () => {
+    it('1 == 1 → 0', () => {
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(1);
+      bigint_from_int_b(1);
+      scoreboard_set("out", "r", bigint_compare());
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(0);
+    });
+    it('2 > 1 → 1', () => {
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(2);
+      bigint_from_int_b(1);
+      scoreboard_set("out", "r", bigint_compare());
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(1);
+    });
+    it('1 < 2 → -1', () => {
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(1);
+      bigint_from_int_b(2);
+      scoreboard_set("out", "r", bigint_compare());
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(-1);
+    });
+});
+// ── bigint_mul_small ──────────────────────────────────────────────────────────
+describe('bigint_mul_small', () => {
+    it('12345 * 2 = 24690', () => {
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(12345);
+      bigint_mul_small(2);
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(4690);
+        expect(sc(rt, 'l1')).toBe(2);
+    });
+    it('9999 * 9999 = 99980001: carry', () => {
+        // c[0] = 99980001 % 10000 = 1
+        // c[1] = floor(99980001 / 10000) = 9998
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(9999);
+      bigint_mul_small(9999);
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(1); // 99980001 % 10000 = 1  (actually 0001)
+        expect(sc(rt, 'l1')).toBe(9998); // 9998
+    });
+});
+// ── bigint_mul ────────────────────────────────────────────────────────────────
+describe('bigint_mul', () => {
+    it('3 * 4 = 12', () => {
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(3);
+      bigint_from_int_b(4);
+      bigint_mul();
+      scoreboard_set("out", "r", bigint_get_c(0));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(12);
+    });
+    it('9999 * 9999 = 99980001', () => {
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(9999);
+      bigint_from_int_b(9999);
+      bigint_mul();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(1);
+        expect(sc(rt, 'l1')).toBe(9998);
+    });
+    it('100000 * 100000 = 10^10: spans 3 limbs', () => {
+        // 10^10 = [0, 0, 0, 1, 0, ...] in base 10000 (1 * 10000^3 = 10^12? no)
+        // 10^10 / 10000^0 % 10000 = 0
+        // 10^10 / 10000^1 % 10000 = 0
+        // 10^10 / 10000^2 % 10000 = 10000 → wait: 10^10 / 10^8 = 100, 100 % 10000 = 100
+        // Actually: 10^10 = 100 * 10^8 = 100 * (10^4)^2
+        //   l0 = 10^10 % 10^4 = 0
+        //   l1 = floor(10^10 / 10^4) % 10^4 = floor(10^6) % 10000 = 0
+        //   l2 = floor(10^10 / 10^8) % 10^4 = 100 % 10000 = 100
+        const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(100000);
+      bigint_from_int_b(100000);
+      bigint_mul();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+      scoreboard_set("out", "l2", bigint_get_c(2));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(0);
+        expect(sc(rt, 'l1')).toBe(0);
+        expect(sc(rt, 'l2')).toBe(100);
+    });
+});
+// ── bigint_fib ────────────────────────────────────────────────────────────────
+describe('bigint_fib', () => {
+    it('F(0) = 0', () => {
+        const rt = run(`fn test() {
+      bigint_fib(0);
+      scoreboard_set("out", "r", bigint_get_a(0));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(0);
+    });
+    it('F(1) = 1', () => {
+        const rt = run(`fn test() {
+      bigint_fib(1);
+      scoreboard_set("out", "r", bigint_get_a(0));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(1);
+    });
+    it('F(10) = 55', () => {
+        const rt = run(`fn test() {
+      bigint_fib(10);
+      scoreboard_set("out", "r", bigint_get_a(0));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(55);
+    });
+    it('F(20) = 6765', () => {
+        const rt = run(`fn test() {
+      bigint_fib(20);
+      scoreboard_set("out", "r", bigint_get_a(0));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'r')).toBe(6765);
+    });
+    it('F(50) = 12586269025: limb0=9025, limb1=8626, limb2=125', () => {
+        // F(50) = 12,586,269,025
+        // 12586269025 % 10000 = 9025
+        // floor(12586269025 / 10000) % 10000 = 1258626 % 10000 = 8626
+        // floor(12586269025 / 10^8) = 125
+        const rt = run(`fn test() {
+      bigint_fib(50);
+      scoreboard_set("out", "l0", bigint_get_a(0));
+      scoreboard_set("out", "l1", bigint_get_a(1));
+      scoreboard_set("out", "l2", bigint_get_a(2));
+    }`);
+        rt.execFunction('test');
+        expect(sc(rt, 'l0')).toBe(9025);
+        expect(sc(rt, 'l1')).toBe(8626);
+        expect(sc(rt, 'l2')).toBe(125);
+    });
+    it('F(100) low limbs check', () => {
+        // F(100) = 354224848179261915075
+        // % 10000 = 5075
+        // floor / 10000 % 10000 = floor(35422484817926191.5075) % 10000 = ...
+        // Let's compute:
+        // 354224848179261915075 % 10000 = 5075
+        // floor(354224848179261915075 / 10000) = 35422484817926191507 (JS BigInt)
+        // 35422484817926191507 % 10000 = 1507
+        // floor(35422484817926191507 / 10000) = 3542248481792619 (roughly)
+        // % 10000 = 2619
+        const rt = run(`fn test() {
+      bigint_fib(100);
+      scoreboard_set("out", "l0", bigint_get_a(0));
+      scoreboard_set("out", "l1", bigint_get_a(1));
+      scoreboard_set("out", "l2", bigint_get_a(2));
+    }`);
+        rt.execFunction('test');
+        const f100 = BigInt('354224848179261915075');
+        const b = BigInt(10000);
+        expect(sc(rt, 'l0')).toBe(Number(f100 % b));
+        expect(sc(rt, 'l1')).toBe(Number((f100 / b) % b));
+        expect(sc(rt, 'l2')).toBe(Number((f100 / b / b) % b));
+    });
+});
+//# sourceMappingURL=stdlib-bigint.test.js.map

package/dist/cli.js

@@ -60,7 +60,7 @@ function printUsage() {
 RedScript Compiler
 
 Usage:
-  redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--target <target>] [--no-dce]
+  redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--scoreboard <obj>] [--target <target>] [--no-dce]
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
   redscript check <file>
   redscript fmt <file.mcrs> [file2.mcrs ...]
@@ -85,6 +85,9 @@ Options:
   --target <target>      Output target: datapack (default), cmdblock, or structure
   --no-dce               Disable AST dead code elimination
   --no-mangle            Disable variable name mangling (use readable names)
+  --scoreboard <obj>     Scoreboard objective for variables (default: namespace).
+                         Each datapack automatically uses its namespace as the objective
+                         so multiple datapacks can coexist without collisions.
   --stats                Print optimizer statistics
   --hot-reload <url>     After each successful compile, POST to <url>/reload
                          (use with redscript-testharness; e.g. http://localhost:25561)
@@ -218,6 +221,10 @@ function parseArgs(args) {
             result.mangle = false;
             i++;
         }
+        else if (arg === '--scoreboard') {
+            result.scoreboardObjective = args[++i];
+            i++;
+        }
         else if (arg === '--hot-reload') {
             result.hotReload = args[++i];
             i++;
@@ -271,7 +278,7 @@ function printOptimizationStats(stats) {
     console.log(`  constant folding: ${stats.constantFolds} constants folded`);
     console.log(`  Total mcfunction commands: ${stats.totalCommandsBefore} -> ${stats.totalCommandsAfter} (${formatReduction(stats.totalCommandsBefore, stats.totalCommandsAfter)} reduction)`);
 }
-function compileCommand(file, output, namespace, target = 'datapack', showStats = false, dce = true, mangle = true) {
+function compileCommand(file, output, namespace, target = 'datapack', showStats = false, dce = true, mangle = true, scoreboardObjective = undefined) {
     // Read source file
     if (!fs.existsSync(file)) {
         console.error(`Error: File not found: ${file}`);
@@ -280,7 +287,7 @@ function compileCommand(file, output, namespace, target = 'datapack', showStats
     const source = fs.readFileSync(file, 'utf-8');
     try {
         if (target === 'cmdblock') {
-            const result = (0, index_1.compile)(source, { namespace, filePath: file, dce, mangle });
+            const result = (0, index_1.compile)(source, { namespace, filePath: file, dce, mangle, scoreboardObjective });
             printWarnings(result.warnings);
             // Generate command block JSON
             const hasTick = result.files.some(f => f.path.includes('__tick.mcfunction'));
@@ -309,7 +316,7 @@ function compileCommand(file, output, namespace, target = 'datapack', showStats
             }
         }
         else {
-            const result = (0, index_1.compile)(source, { namespace, filePath: file, dce, mangle });
+            const result = (0, index_1.compile)(source, { namespace, filePath: file, dce, mangle, scoreboardObjective });
             printWarnings(result.warnings);
             // Default: generate datapack
             // Create output directory
@@ -483,7 +490,8 @@ async function main() {
                 const output = target === 'structure'
                     ? (parsed.outputNbt ?? parsed.output ?? `./${namespace}.nbt`)
                     : (parsed.output ?? './dist');
-                compileCommand(parsed.file, output, namespace, target, parsed.stats, parsed.dce, parsed.mangle);
+                compileCommand(parsed.file, output, namespace, target, parsed.stats, parsed.dce, parsed.mangle, parsed.scoreboardObjective // undefined = derive from namespace in compile()
+                );
             }
             break;
         case 'watch':

package/dist/codegen/mcfunction/index.d.ts

@@ -30,6 +30,10 @@ export interface DatapackGenerationResult {
 export interface DatapackGenerationOptions {
     optimizeCommands?: boolean;
     mangle?: boolean;
+    /** Scoreboard objective used for all scoreboard variables.
+     *  Defaults to 'rs'. Override per-datapack to avoid collisions
+     *  when multiple RedScript datapacks are loaded simultaneously. */
+    scoreboardObjective?: string;
 }
 export declare function countMcfunctionCommands(files: DatapackFile[]): number;
 export declare function generateDatapackWithStats(module: IRModule, options?: DatapackGenerationOptions): DatapackGenerationResult;

package/dist/codegen/mcfunction/index.js

@@ -26,7 +26,8 @@ const var_allocator_1 = require("../var-allocator");
 // ---------------------------------------------------------------------------
 // Utilities
 // ---------------------------------------------------------------------------
-const OBJ = 'rs'; // scoreboard objective name
+// Default scoreboard objective — overridden per-compilation via DatapackGenerationOptions.scoreboardObjective
+let OBJ = 'rs';
 function operandToScore(op, alloc) {
     if (op.kind === 'var')
         return `${alloc.alloc(op.name)} ${OBJ}`;
@@ -335,7 +336,11 @@ function preAllocTerm(term, alloc) {
     }
 }
 function generateDatapackWithStats(module, options = {}) {
-    const { optimizeCommands = true, mangle = false } = options;
+    const { optimizeCommands = true, mangle = false, scoreboardObjective = 'rs' } = options;
+    // Set module-level OBJ so all helper functions in this module use the correct objective.
+    // This is safe because compilation is synchronous.
+    OBJ = scoreboardObjective;
+    (0, commands_1.setOptimizerObjective)(scoreboardObjective);
     const alloc = new var_allocator_1.VarAllocator(mangle);
     const files = [];
     const advancements = [];
@@ -375,10 +380,10 @@ function generateDatapackWithStats(module, options = {}) {
     for (const eventType of eventTypes) {
         const detection = types_1.EVENT_TYPES[eventType].detection;
         if (eventType === 'PlayerDeath') {
-            loadLines.push('scoreboard objectives add rs.deaths deathCount');
+            loadLines.push(`scoreboard objectives add ${OBJ}.deaths deathCount`);
         }
         else if (eventType === 'EntityKill') {
-            loadLines.push('scoreboard objectives add rs.kills totalKillCount');
+            loadLines.push(`scoreboard objectives add ${OBJ}.kills totalKillCount`);
         }
         else if (eventType === 'ItemUse') {
             loadLines.push('# ItemUse detection requires a project-specific objective/tag setup');

package/dist/compile.d.ts

@@ -13,6 +13,10 @@ export interface CompileOptions {
     optimize?: boolean;
     dce?: boolean;
     mangle?: boolean;
+    /** Scoreboard objective used for all variable slots.
+     *  Defaults to 'rs'. Set to a unique value (e.g. 'mypack_rs') when loading
+     *  multiple RedScript datapacks simultaneously to avoid variable collisions. */
+    scoreboardObjective?: string;
     /** Additional source files that should be treated as *library* code.
      *  Functions in these files are DCE-eligible: they are only compiled into
      *  the datapack when actually called from user code.  Each string is parsed

package/dist/compile.js

@@ -209,6 +209,11 @@ function compile(source, options = {}) {
         }
         const dceResult = shouldRunDce ? (0, dce_1.eliminateDeadCode)(parsedAst) : { program: parsedAst, warnings: [] };
         const ast = dceResult.program;
+        // Configure scoreboard objective for this compilation.
+        // Default: use the datapack namespace so each datapack gets its own objective
+        // automatically, preventing variable collisions when multiple datapacks coexist.
+        const scoreboardObj = options.scoreboardObjective ?? namespace;
+        (0, lowering_1.setScoreboardObjective)(scoreboardObj);
         // Lowering
         const ir = new lowering_1.Lowering(namespace, preprocessed.ranges).lower(ast);
         // Optimization
@@ -217,7 +222,10 @@ function compile(source, options = {}) {
             : ir;
         // Code generation — mangle=true by default to prevent cross-function
         // scoreboard variable collisions in the global MC scoreboard namespace.
-        const generated = (0, mcfunction_1.generateDatapackWithStats)(optimized, { mangle: options.mangle ?? true });
+        const generated = (0, mcfunction_1.generateDatapackWithStats)(optimized, {
+            mangle: options.mangle ?? true,
+            scoreboardObjective: scoreboardObj,
+        });
         return {
             success: true,
             files: [...generated.files, ...generated.advancements],

package/dist/data/arena/function/__load.mcfunction

@@ -0,0 +1,6 @@
+# RedScript runtime init
+scoreboard objectives add rs dummy
+scoreboard players set $const_1 rs 1
+scoreboard players set $const_200 rs 200
+scoreboard players set $const_0 rs 0
+scoreboard players set $const_0 rs 0

package/dist/data/arena/function/__tick.mcfunction

@@ -0,0 +1,2 @@
+# RedScript tick dispatcher
+function arena:arena_tick

package/dist/data/arena/function/announce_leaders/else_1.mcfunction

@@ -0,0 +1,3 @@
+# block: else_1
+say Arena update: no PvP kills yet.
+function arena:announce_leaders/merge_2

package/dist/data/arena/function/announce_leaders/foreach_0/merge_2.mcfunction

@@ -0,0 +1 @@
+# block: merge_2

package/dist/data/arena/function/announce_leaders/foreach_0/then_0.mcfunction

@@ -0,0 +1,3 @@
+# block: then_0
+scoreboard players operation $top_kills rs = $kills rs
+function arena:announce_leaders/foreach_0/merge_2

package/dist/data/arena/function/announce_leaders/foreach_0.mcfunction

@@ -0,0 +1,7 @@
+# block: entry
+execute store result score $t0 rs run scoreboard players get @s kills
+scoreboard players operation $kills rs = $t0 rs
+scoreboard players set $t1 rs 0
+execute if score $t0 rs > $top_kills rs run scoreboard players set $t1 rs 1
+execute if score $t1 rs matches 1.. run function arena:announce_leaders/foreach_0/then_0
+execute if score $t1 rs matches ..0 run function arena:announce_leaders/foreach_0/merge_2

package/dist/data/arena/function/announce_leaders/foreach_1/merge_2.mcfunction

@@ -0,0 +1 @@
+# block: merge_2

package/dist/data/arena/function/announce_leaders/foreach_1/then_0.mcfunction

@@ -0,0 +1,4 @@
+# block: then_0
+tellraw @s {"text":"You are leading the arena right now."}
+title @s title {"text":"Arena Leader"}
+function arena:announce_leaders/foreach_1/merge_2

package/dist/data/arena/function/announce_leaders/foreach_1.mcfunction

@@ -0,0 +1,6 @@
+# block: entry
+execute store result score $t0 rs run scoreboard players get @s kills
+scoreboard players set $t1 rs 0
+execute if score $t0 rs = $top_kills rs run scoreboard players set $t1 rs 1
+execute if score $t1 rs matches 1.. run function arena:announce_leaders/foreach_1/then_0
+execute if score $t1 rs matches ..0 run function arena:announce_leaders/foreach_1/merge_2

package/dist/data/arena/function/announce_leaders/merge_2.mcfunction

@@ -0,0 +1 @@
+# block: merge_2

package/dist/data/arena/function/announce_leaders/then_0.mcfunction

@@ -0,0 +1,4 @@
+# block: then_0
+say Arena update: current leader check complete.
+execute as @a run function arena:announce_leaders/foreach_1
+function arena:announce_leaders/merge_2

package/dist/data/arena/function/announce_leaders.mcfunction

@@ -0,0 +1,6 @@
+# block: entry
+execute as @a run function arena:announce_leaders/foreach_0
+scoreboard players set $t0 rs 0
+execute if score $const_0 rs > $const_0 rs run scoreboard players set $t0 rs 1
+execute if score $t0 rs matches 1.. run function arena:announce_leaders/then_0
+execute if score $t0 rs matches ..0 run function arena:announce_leaders/else_1

package/dist/data/arena/function/arena_tick/merge_2.mcfunction

@@ -0,0 +1 @@
+# block: merge_2

package/dist/data/arena/function/arena_tick/then_0.mcfunction

@@ -0,0 +1,4 @@
+# block: then_0
+function arena:announce_leaders
+scoreboard players operation $t5 rs = $ret rs
+function arena:arena_tick/merge_2