redscript-mc 1.0.0

package/editors/vscode/syntaxes/redscript.tmLanguage.json

@@ -0,0 +1,357 @@
+{
+  "name": "RedScript",
+  "scopeName": "source.redscript",
+  "fileTypes": ["rs"],
+  "patterns": [{ "include": "#root" }],
+  "repository": {
+    "root": {
+      "patterns": [
+        { "include": "#comments" },
+        { "include": "#decorators" },
+        { "include": "#string-interpolation" },
+        { "include": "#strings" },
+        { "include": "#keywords" },
+        { "include": "#selectors" },
+        { "include": "#const-definition" },
+        { "include": "#constants-upper" },
+        { "include": "#fn-definition" },
+        { "include": "#struct-definition" },
+        { "include": "#enum-definition" },
+        { "include": "#fn-call" },
+        { "include": "#types" },
+        { "include": "#numbers" },
+        { "include": "#blockpos" },
+        { "include": "#mc-name" },
+        { "include": "#operators" },
+        { "include": "#punctuation" }
+      ]
+    },
+
+    "comments": {
+      "patterns": [
+        {
+          "name": "comment.line.double-slash.redscript",
+          "match": "//.*$"
+        },
+        {
+          "comment": "JSDoc block comment /** ... */",
+          "name": "comment.block.documentation.redscript",
+          "begin": "/\\*\\*",
+          "end": "\\*/",
+          "patterns": [
+            {
+              "name": "storage.type.class.jsdoc",
+              "match": "@(?:param|returns?|type|throws?|example|deprecated|since|see|todo)\\b"
+            },
+            {
+              "name": "variable.other.jsdoc",
+              "match": "\\{[^}]+\\}"
+            }
+          ]
+        },
+        {
+          "name": "comment.block.redscript",
+          "begin": "/\\*",
+          "end": "\\*/"
+        }
+      ]
+    },
+
+    "decorators": {
+      "patterns": [
+        {
+          "comment": "Decorator with arguments: @tick(rate=20)",
+          "begin": "(@(?:tick|on_advancement|on_craft|on_death|on_trigger|on_join_team|on_login))\\s*(\\()",
+          "beginCaptures": {
+            "1": { "name": "entity.name.function.decorator.redscript" },
+            "2": { "name": "punctuation.definition.parameters.redscript" }
+          },
+          "end": "\\)",
+          "endCaptures": {
+            "0": { "name": "punctuation.definition.parameters.redscript" }
+          },
+          "patterns": [
+            { "include": "#strings" },
+            { "include": "#numbers" },
+            {
+              "name": "variable.parameter.decorator.redscript",
+              "match": "\\b[a-z_][a-zA-Z0-9_]*\\b"
+            },
+            {
+              "name": "keyword.operator.assignment.redscript",
+              "match": "="
+            }
+          ]
+        },
+        {
+          "comment": "Bare decorator: @on_death",
+          "name": "entity.name.function.decorator.redscript",
+          "match": "@(?:tick|on_advancement|on_craft|on_death|on_trigger|on_join_team|on_login)\\b"
+        }
+      ]
+    },
+
+    "string-interpolation": {
+      "comment": "Interpolated string with ${expr} — highlight the expression inside",
+      "begin": "\"(?=[^\"]*\\$\\{)",
+      "end": "\"",
+      "name": "string.quoted.double.redscript",
+      "patterns": [
+        {
+          "begin": "\\$\\{",
+          "end": "\\}",
+          "beginCaptures": { "0": { "name": "punctuation.definition.template-expression.begin.redscript" } },
+          "endCaptures":   { "0": { "name": "punctuation.definition.template-expression.end.redscript" } },
+          "contentName": "meta.embedded.expression.redscript",
+          "patterns": [
+            { "include": "#selectors" },
+            { "include": "#numbers" },
+            {
+              "name": "variable.other.redscript",
+              "match": "[a-zA-Z_][a-zA-Z0-9_]*"
+            }
+          ]
+        },
+        { "name": "constant.character.escape.redscript", "match": "\\\\." }
+      ]
+    },
+
+    "strings": {
+      "patterns": [
+        {
+          "name": "string.quoted.double.redscript",
+          "begin": "\"",
+          "end": "\"",
+          "patterns": [
+            { "name": "constant.character.escape.redscript", "match": "\\\\." }
+          ]
+        }
+      ]
+    },
+
+    "keywords": {
+      "patterns": [
+        {
+          "name": "keyword.control.redscript",
+          "match": "\\b(if|else|while|for|foreach|return|match|in|execute|as|at|unless|run)\\b"
+        },
+        {
+          "name": "keyword.declaration.redscript",
+          "match": "\\b(fn|let|struct|enum|import|namespace|trigger)\\b"
+        },
+        {
+          "name": "keyword.declaration.const.redscript",
+          "match": "\\bconst\\b"
+        },
+        {
+          "name": "constant.language.boolean.redscript",
+          "match": "\\b(true|false)\\b"
+        }
+      ]
+    },
+
+    "types": {
+      "patterns": [
+        {
+          "comment": "Primitive types",
+          "name": "support.type.primitive.redscript",
+          "match": "\\b(int|float|bool|string|void|BlockPos|selector)\\b"
+        },
+        {
+          "comment": "Array type T[]",
+          "match": "\\b([A-Za-z][A-Za-z0-9_]*)\\s*(\\[\\])",
+          "captures": {
+            "1": { "name": "support.type.redscript" },
+            "2": { "name": "punctuation.definition.type.redscript" }
+          }
+        },
+        {
+          "comment": "User-defined types (PascalCase: starts uppercase, second char lowercase)",
+          "name": "entity.name.type.redscript",
+          "match": "\\b[A-Z][a-z][A-Za-z0-9]*\\b"
+        }
+      ]
+    },
+
+    "selectors": {
+      "patterns": [
+        {
+          "comment": "Selector WITH arguments: @e[type=minecraft:zombie,distance=..8]",
+          "begin": "(@[aesprnAESPRN])(\\[)",
+          "beginCaptures": {
+            "1": { "name": "keyword.other.selector.redscript" },
+            "2": { "name": "punctuation.section.selector.begin.redscript" }
+          },
+          "end": "\\]",
+          "endCaptures": {
+            "0": { "name": "punctuation.section.selector.end.redscript" }
+          },
+          "patterns": [
+            {
+              "comment": "Selector argument keys",
+              "name": "support.type.property-name.redscript",
+              "match": "\\b(type|name|tag|team|scores|nbt|predicate|gamemode|distance|level|x_rotation|y_rotation|x|y|z|dx|dy|dz|limit|sort|advancements|selector)\\b"
+            },
+            {
+              "comment": "Range operator: ..8, 1.., 1..10",
+              "name": "keyword.operator.range.selector.redscript",
+              "match": "\\.\\."
+            },
+            {
+              "comment": "Namespaced value e.g. minecraft:zombie",
+              "match": "\\b([a-z0-9_]+):([a-z0-9_./]+)",
+              "captures": {
+                "1": { "name": "entity.name.namespace.redscript" },
+                "2": { "name": "entity.name.type.entity.redscript" }
+              }
+            },
+            { "include": "#strings" },
+            { "include": "#numbers" },
+            {
+              "name": "keyword.operator.assignment.redscript",
+              "match": "="
+            },
+            {
+              "name": "keyword.operator.logical.redscript",
+              "match": "!"
+            }
+          ]
+        },
+        {
+          "comment": "Bare selector: @s @a @e @p @r @n (no arguments)",
+          "name": "keyword.other.selector.redscript",
+          "match": "@[aesprnAESPRN]\\b"
+        }
+      ]
+    },
+
+    "fn-definition": {
+      "comment": "fn name(...) — highlight function name",
+      "match": "\\b(fn)\\s+([a-z_][a-zA-Z0-9_]*)",
+      "captures": {
+        "1": { "name": "keyword.declaration.redscript" },
+        "2": { "name": "entity.name.function.redscript" }
+      }
+    },
+
+    "struct-definition": {
+      "comment": "struct Name { ... }",
+      "match": "\\b(struct)\\s+([A-Z][A-Za-z0-9_]*)",
+      "captures": {
+        "1": { "name": "keyword.declaration.redscript" },
+        "2": { "name": "entity.name.type.redscript" }
+      }
+    },
+
+    "enum-definition": {
+      "comment": "enum Name { ... }",
+      "match": "\\b(enum)\\s+([A-Z][A-Za-z0-9_]*)",
+      "captures": {
+        "1": { "name": "keyword.declaration.redscript" },
+        "2": { "name": "entity.name.type.redscript" }
+      }
+    },
+
+    "const-definition": {
+      "comment": "const NAME: type = value — highlight const name",
+      "match": "\\b(const)\\s+([A-Z_][A-Z0-9_]*)",
+      "captures": {
+        "1": { "name": "keyword.declaration.const.redscript" },
+        "2": { "name": "variable.other.constant.redscript" }
+      }
+    },
+
+    "fn-call": {
+      "comment": "Function call: name(...) — highlight callee",
+      "patterns": [
+        {
+          "comment": "Builtin functions",
+          "name": "support.function.builtin.redscript",
+          "match": "\\b(say|tell|announce|title|subtitle|actionbar|title_times|give|kill|effect|clear|kick|xp_add|xp_set|tp|tp_to|setblock|fill|clone|summon|particle|playsound|weather|time_set|time_add|gamerule|difficulty|tag_add|tag_remove|scoreboard_get|scoreboard_set|scoreboard_add|scoreboard_display|scoreboard_hide|scoreboard_add_objective|scoreboard_remove_objective|score|random|random_native|random_sequence|data_get|str_len|push|pop|bossbar_add|bossbar_set_value|bossbar_set_max|bossbar_set_color|bossbar_set_style|bossbar_set_visible|bossbar_set_players|bossbar_remove|bossbar_get_value|team_add|team_remove|team_join|team_leave|team_option|spawn_object|if_entity|unless_entity)(?=\\s*\\()"
+        },
+        {
+          "comment": "User-defined function calls",
+          "name": "entity.name.function.redscript",
+          "match": "\\b([a-z_][a-zA-Z0-9_]*)(?=\\s*\\()"
+        }
+      ]
+    },
+
+    "constants-upper": {
+      "comment": "SCREAMING_SNAKE_CASE constants and 2+ char ALL_CAPS (e.g. GAME_TIME, MAX, PI)",
+      "name": "variable.other.constant.redscript",
+      "match": "\\b(?:[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+|[A-Z]{2,})\\b"
+    },
+
+    "numbers": {
+      "patterns": [
+        {
+          "name": "constant.numeric.float.redscript",
+          "match": "-?\\b\\d+\\.\\d+\\b"
+        },
+        {
+          "name": "constant.numeric.integer.redscript",
+          "match": "-?\\b\\d+\\b"
+        }
+      ]
+    },
+
+    "blockpos": {
+      "comment": "BlockPos coordinates: ~5, ^3, ~-1",
+      "name": "constant.numeric.blockpos.redscript",
+      "match": "[~^]-?\\d*(?:\\.\\d+)?"
+    },
+
+    "mc-name": {
+      "comment": "#objective, #tag, #team — unquoted MC identifier literal",
+      "name": "variable.other.mc-name.redscript",
+      "match": "#[a-zA-Z_][a-zA-Z0-9_]*"
+    },
+
+    "operators": {
+      "patterns": [
+        {
+          "name": "keyword.operator.comparison.redscript",
+          "match": "(==|!=|<=|>=|<|>)"
+        },
+        {
+          "name": "keyword.operator.logical.redscript",
+          "match": "(&&|\\|\\||!(?!=))"
+        },
+        {
+          "name": "keyword.operator.assignment.redscript",
+          "match": "(\\+=|-=|\\*=|/=|%=|=(?!=))"
+        },
+        {
+          "name": "keyword.operator.arithmetic.redscript",
+          "match": "(\\+|-(?!>)|\\*|/|%)"
+        },
+        {
+          "name": "keyword.operator.arrow.redscript",
+          "match": "->"
+        },
+        {
+          "name": "keyword.operator.scope.redscript",
+          "match": "::"
+        },
+        {
+          "name": "keyword.operator.range.redscript",
+          "match": "\\.\\."
+        }
+      ]
+    },
+
+    "punctuation": {
+      "patterns": [
+        { "name": "punctuation.terminator.statement.redscript", "match": ";" },
+        { "name": "punctuation.separator.comma.redscript", "match": "," },
+        { "name": "punctuation.separator.colon.redscript", "match": ":" },
+        { "name": "punctuation.accessor.dot.redscript", "match": "\\." },
+        { "name": "punctuation.definition.block.begin.redscript", "match": "\\{" },
+        { "name": "punctuation.definition.block.end.redscript", "match": "\\}" },
+        { "name": "punctuation.definition.parameters.begin.redscript", "match": "\\(" },
+        { "name": "punctuation.definition.parameters.end.redscript", "match": "\\)" }
+      ]
+    }
+  }
+}

package/editors/vscode/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2020",
+    "outDir": "out",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "out"]
+}

package/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "redscript-mc",
+  "version": "1.0.0",
+  "description": "A high-level programming language that compiles to Minecraft datapacks",
+  "main": "dist/index.js",
+  "bin": {
+    "redscript": "dist/cli.js",
+    "rsc": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "test": "jest",
+    "cli": "ts-node src/cli.ts",
+    "validate-mc": "jest src/__tests__/mc-syntax.test.ts --verbose"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.4.0"
+  },
+  "license": "MIT",
+  "keywords": [
+    "minecraft",
+    "datapack",
+    "mcfunction",
+    "compiler",
+    "redscript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bkmashiro/redscript.git"
+  },
+  "author": "bkmashiro"
+}

package/src/__tests__/cli.test.ts

@@ -0,0 +1,130 @@
+import { compile, check } from '../index'
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { execFileSync } from 'child_process'
+
+// Note: watch command is tested manually as it's an interactive long-running process
+
+describe('CLI API', () => {
+  describe('imports', () => {
+    it('compiles a file with imported helpers', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-imports-'))
+      const libPath = path.join(tempDir, 'lib.rs')
+      const mainPath = path.join(tempDir, 'main.rs')
+
+      fs.writeFileSync(libPath, 'fn double(x: int) -> int { return x + x; }\n')
+      fs.writeFileSync(mainPath, 'import "./lib.rs"\n\nfn main() { let value: int = double(2); }\n')
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'imports', filePath: mainPath })
+
+      expect(result.files.length).toBeGreaterThan(0)
+      expect(result.ir.functions.some(fn => fn.name === 'double')).toBe(true)
+      expect(result.ir.functions.some(fn => fn.name === 'main')).toBe(true)
+    })
+
+    it('deduplicates circular imports', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-circular-'))
+      const aPath = path.join(tempDir, 'a.rs')
+      const bPath = path.join(tempDir, 'b.rs')
+      const mainPath = path.join(tempDir, 'main.rs')
+
+      fs.writeFileSync(aPath, 'import "./b.rs"\n\nfn from_a() -> int { return 1; }\n')
+      fs.writeFileSync(bPath, 'import "./a.rs"\n\nfn from_b() -> int { return from_a(); }\n')
+      fs.writeFileSync(mainPath, 'import "./a.rs"\n\nfn main() { let value: int = from_b(); }\n')
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'circular', filePath: mainPath })
+
+      expect(result.ir.functions.filter(fn => fn.name === 'from_a')).toHaveLength(1)
+      expect(result.ir.functions.filter(fn => fn.name === 'from_b')).toHaveLength(1)
+    })
+  })
+
+  describe('compile()', () => {
+    it('compiles simple source', () => {
+      const source = 'fn test() { say("hello"); }'
+      const result = compile(source, { namespace: 'mypack' })
+      expect(result.files.length).toBeGreaterThan(0)
+      expect(result.ast.namespace).toBe('mypack')
+      expect(result.ir.functions.length).toBe(1)
+    })
+
+    it('uses default namespace', () => {
+      const source = 'fn test() {}'
+      const result = compile(source)
+      expect(result.ast.namespace).toBe('redscript')
+    })
+
+    it('generates correct file structure', () => {
+      const source = 'fn test() { say("hello"); }'
+      const result = compile(source, { namespace: 'game' })
+      
+      const paths = result.files.map(f => f.path)
+      expect(paths).toContain('pack.mcmeta')
+      expect(paths).toContain('data/game/function/__load.mcfunction')
+      expect(paths.some(p => p.includes('test.mcfunction'))).toBe(true)
+    })
+
+    it('collects optimizer stats', () => {
+      const source = `
+fn build() {
+  foreach (turret in @e[tag=turret]) {
+    let range: int = scoreboard_get("config", "turret_range");
+    if (range > 0) {
+      if (range > -1) {
+        say("ready");
+      }
+    }
+  }
+}
+`
+
+      const result = compile(source, { namespace: 'stats' })
+      expect(result.stats?.licmHoists).toBeGreaterThan(0)
+      expect(result.stats?.totalCommandsBefore).toBeGreaterThan(result.stats?.totalCommandsAfter ?? 0)
+      expect(result.stats?.deadCodeRemoved).toBeGreaterThanOrEqual(0)
+    })
+  })
+
+  describe('--stats flag', () => {
+    it('prints optimizer statistics', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stats-'))
+      const inputPath = path.join(tempDir, 'input.rs')
+      const outputDir = path.join(tempDir, 'out')
+
+      fs.writeFileSync(inputPath, 'fn build() { setblock((0, 64, 0), "minecraft:stone"); setblock((1, 64, 0), "minecraft:stone"); }')
+
+      const stdout = execFileSync(
+        process.execPath,
+        ['-r', 'ts-node/register', path.join(process.cwd(), 'src/cli.ts'), 'compile', inputPath, '-o', outputDir, '--stats'],
+        { cwd: process.cwd(), encoding: 'utf-8' }
+      )
+
+      expect(stdout).toContain('Optimizations applied:')
+      expect(stdout).toContain('setblock batching:')
+      expect(stdout).toContain('Total mcfunction commands:')
+    })
+  })
+
+  describe('check()', () => {
+    it('returns null for valid source', () => {
+      const source = 'fn test() { say("hello"); }'
+      const error = check(source)
+      expect(error).toBeNull()
+    })
+
+    it('returns error for invalid source', () => {
+      const source = 'fn test( { say("hello"); }'  // Missing )
+      const error = check(source)
+      expect(error).toBeInstanceOf(Error)
+    })
+
+    it('returns error for syntax errors', () => {
+      const source = 'fn test() { let x = ; }'  // Missing value
+      const error = check(source)
+      expect(error).toBeInstanceOf(Error)
+    })
+  })
+})

package/src/__tests__/codegen.test.ts

@@ -0,0 +1,128 @@
+import { generateDatapack, generateDatapackWithStats } from '../codegen/mcfunction'
+import type { IRModule } from '../ir/types'
+
+describe('generateDatapack', () => {
+  it('generates pack.mcmeta', () => {
+    const mod: IRModule = { namespace: 'test', functions: [], globals: [] }
+    const files = generateDatapack(mod)
+    const meta = files.find(f => f.path === 'pack.mcmeta')
+    expect(meta).toBeDefined()
+    expect(JSON.parse(meta!.content).pack.pack_format).toBe(26)
+  })
+
+  it('generates __load.mcfunction with objective setup', () => {
+    const mod: IRModule = { namespace: 'mypack', functions: [], globals: ['counter'] }
+    const files = generateDatapack(mod)
+    const load = files.find(f => f.path.includes('__load.mcfunction'))
+    expect(load?.content).toContain('scoreboard objectives add rs dummy')
+    expect(load?.content).toContain('scoreboard players set $counter rs 0')
+  })
+
+  it('generates function file for simple add(a, b)', () => {
+    const mod: IRModule = {
+      namespace: 'mypack',
+      globals: [],
+      functions: [{
+        name: 'add',
+        params: ['a', 'b'],
+        locals: ['a', 'b', 'result'],
+        blocks: [{
+          label: 'entry',
+          instrs: [
+            { op: 'binop', dst: 'result', lhs: { kind: 'var', name: 'a' }, bop: '+', rhs: { kind: 'var', name: 'b' } },
+          ],
+          term: { op: 'return', value: { kind: 'var', name: 'result' } },
+        }],
+      }],
+    }
+    const files = generateDatapack(mod)
+    const fn = files.find(f => f.path.includes('add.mcfunction'))
+    expect(fn).toBeDefined()
+    // Should have param setup
+    expect(fn!.content).toContain('scoreboard players operation $a rs = $p0 rs')
+    expect(fn!.content).toContain('scoreboard players operation $b rs = $p1 rs')
+    // Should have add operation
+    expect(fn!.content).toContain('+=')
+  })
+
+  it('generates tick tag for tick loop function', () => {
+    const mod: IRModule = {
+      namespace: 'mypack',
+      globals: [],
+      functions: [{
+        name: 'game_loop',
+        params: [],
+        locals: [],
+        blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+        isTickLoop: true,
+      }],
+    }
+    const files = generateDatapack(mod)
+    
+    // tick.json should point to __tick
+    const tickTag = files.find(f => f.path.includes('tick.json'))
+    expect(tickTag).toBeDefined()
+    expect(JSON.parse(tickTag!.content).values).toContain('mypack:__tick')
+    
+    // __tick.mcfunction should call the game_loop function
+    const tickFn = files.find(f => f.path.includes('__tick.mcfunction'))
+    expect(tickFn).toBeDefined()
+    expect(tickFn!.content).toContain('function mypack:game_loop')
+  })
+
+  it('generates conditional branches with execute if/unless', () => {
+    const mod: IRModule = {
+      namespace: 'mypack',
+      globals: [],
+      functions: [{
+        name: 'check',
+        params: [],
+        locals: ['cond'],
+        blocks: [
+          {
+            label: 'entry',
+            instrs: [
+              { op: 'assign', dst: 'cond', src: { kind: 'const', value: 1 } },
+            ],
+            term: { op: 'jump_if', cond: 'cond', then: 'then_block', else_: 'else_block' },
+          },
+          {
+            label: 'then_block',
+            instrs: [{ op: 'raw', cmd: 'say hello' }],
+            term: { op: 'return' },
+          },
+          {
+            label: 'else_block',
+            instrs: [{ op: 'raw', cmd: 'say goodbye' }],
+            term: { op: 'return' },
+          },
+        ],
+      }],
+    }
+    const files = generateDatapack(mod)
+    const entry = files.find(f => f.path.endsWith('check.mcfunction'))
+    expect(entry?.content).toContain('execute if score $cond rs matches 1..')
+    expect(entry?.content).toContain('execute if score $cond rs matches ..0')
+  })
+
+  it('generates advancement json for event decorators', () => {
+    const mod: IRModule = {
+      namespace: 'mypack',
+      globals: [],
+      functions: [{
+        name: 'on_mine_diamond',
+        params: [],
+        locals: [],
+        blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+        eventTrigger: { kind: 'advancement', value: 'story/mine_diamond' },
+      }],
+    }
+
+    const result = generateDatapackWithStats(mod)
+    const advancement = result.advancements.find(f => f.path === 'data/mypack/advancements/on_advancement_on_mine_diamond.json')
+    expect(advancement).toBeDefined()
+    const json = JSON.parse(advancement!.content)
+    expect(json.criteria.trigger.trigger).toBe('minecraft:story/mine_diamond')
+    expect(json.rewards.function).toBe('mypack:on_mine_diamond')
+  })
+})