redscript-mc 2.5.0 → 2.6.0

package/src/optimizer/coroutine.ts

@@ -168,6 +168,15 @@ function transformCoroutine(
   // Continuation N: from loop header → until next yield or exit
   const continuations = partitionIntoContinuations(fn, loopHeaders, backEdges)
 
+  // Compute the dispatcher name and the exact scoreboard player for the PC slot.
+  // The LIR lowerer prefixes each temp with the function name, so the PC slot
+  // used by the dispatcher (function = `${prefix}_tick`) is:
+  //   player = `$${prefix}_tick_${pcTemp}`, obj = objective
+  // We pass this pre-computed player string into builders so they can emit
+  // side-effectful `score_write` instructions that survive DCE.
+  const dispatcherName = `${prefix}_tick`
+  const pcPlayer = `$${dispatcherName}_${pcTemp}`
+
   // Step 4: Build continuation functions with batch counting and variable promotion
   const contFunctions: MIRFunction[] = []
 
@@ -186,16 +195,17 @@ function transformCoroutine(
       objective,
       info.onDone,
       fn.name,
+      pcPlayer,
     )
     contFunctions.push(contFn)
   }
 
   // Step 5: Build the init function (replaces original)
-  const initFn = buildInitFunction(fn, promoted, pcTemp, prefix, objective)
+  const initFn = buildInitFunction(fn, promoted, pcTemp, prefix, objective, pcPlayer)
 
   // Step 6: Build the @tick dispatcher
   const dispatcher = buildDispatcher(
-    `${prefix}_tick`,
+    dispatcherName,
     contFunctions,
     pcTemp,
     objective,
@@ -518,15 +528,16 @@ function buildContinuationFunction(
   objective: string,
   onDone: string | undefined,
   originalFnName: string,
+  pcPlayer: string,
 ): MIRFunction {
   if (cont.isLoopBody) {
     return buildLoopContinuation(
       name, cont, batch, contId, totalConts,
-      promoted, pcTemp, batchCountTemp, objective, onDone,
+      promoted, pcTemp, batchCountTemp, objective, onDone, pcPlayer,
     )
   } else {
     return buildPostLoopContinuation(
-      name, cont, contId, promoted, pcTemp, objective, onDone,
+      name, cont, contId, promoted, pcTemp, objective, onDone, pcPlayer,
     )
   }
 }
@@ -542,6 +553,7 @@ function buildLoopContinuation(
   batchCountTemp: Temp,
   objective: string,
   onDone: string | undefined,
+  pcPlayer: string,
 ): MIRFunction {
   // Build a new function that:
   // 1. Initializes batch_count = 0
@@ -625,11 +637,15 @@ function buildLoopContinuation(
       // Check if this block exits the loop
       const exitSuccs = succs.filter(s => !cont.blocks.some(b => b.id === s))
       if (exitSuccs.length > 0) {
-        // Redirect exit branch to an exit block that returns
+        // Redirect exit branch to an exit block that advances PC and returns.
+        // Setting PC to contId+1 tells the dispatcher to run the next continuation
+        // on the following tick (post-loop code / onDone).
         const exitBlockId = `${block.id}_exit`
         const exitBlock: MIRBlock = {
           id: exitBlockId,
-          instrs: [],
+          instrs: [
+            { kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: contId + 1 } },
+          ],
           term: { kind: 'return', value: null },
           preds: [block.id],
         }
@@ -689,6 +705,7 @@ function buildPostLoopContinuation(
   pcTemp: Temp,
   objective: string,
   onDone: string | undefined,
+  pcPlayer: string,
 ): MIRFunction {
   const blocks: MIRBlock[] = []
 
@@ -700,18 +717,19 @@ function buildPostLoopContinuation(
   // The entry is the first block in the continuation
   const entry = cont.blocks[0]?.id ?? 'entry'
 
-  // Add onDone call if this is the last continuation
-  if (onDone) {
-    // Find blocks with return terminators and add onDone call before them
-    for (let i = 0; i < blocks.length; i++) {
-      if (blocks[i].term.kind === 'return') {
-        blocks[i] = {
-          ...blocks[i],
-          instrs: [
-            ...blocks[i].instrs,
-            { kind: 'call', dst: null, fn: onDone, args: [] },
-          ],
-        }
+  // Add onDone call and PC reset on completion (this is the last continuation).
+  // Setting PC=0 marks the coroutine as done so the dispatcher stops running.
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].term.kind === 'return') {
+      const extraInstrs: MIRInstr[] = []
+      if (onDone) {
+        extraInstrs.push({ kind: 'call', dst: null, fn: onDone, args: [] })
+      }
+      // Reset PC to 0 → dispatcher will find no matching continuation → coroutine done
+      extraInstrs.push({ kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 0 } })
+      blocks[i] = {
+        ...blocks[i],
+        instrs: [...blocks[i].instrs, ...extraInstrs],
       }
     }
   }
@@ -735,25 +753,56 @@ function buildInitFunction(
   pcTemp: Temp,
   prefix: string,
   objective: string,
+  pcPlayer: string,
 ): MIRFunction {
   // The init function:
   // 1. Sets pc = 1 (start from continuation 1)
   // 2. Initializes promoted variables from the entry block's pre-loop code
+  //
+  // NOTE: We use `score_write` (side-effectful, not removed by DCE) to write
+  // directly to the dispatcher's PC scoreboard slot.  Using `const` would
+  // write to a function-local temp (prefixed with the init-function name) which
+  // is a *different* slot from the one the dispatcher reads.
 
   const instrs: MIRInstr[] = []
 
-  // Set pc = 1
-  instrs.push({ kind: 'const', dst: pcTemp, value: 1 })
-
-  // Initialize promoted variables from entry block instructions
-  // Walk the entry block and copy any const/copy instructions for promoted vars
+  // Set pc = 1 via score_write so DCE cannot eliminate it
+  instrs.push({ kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 1 } })
+
+  // Initialize promoted variables from entry block instructions.
+  // We must use score_write (side-effectful) rather than const/copy so that DCE
+  // does not eliminate these instructions (the dst is never read in the init fn).
+  // Continuations read promoted vars from `$${contName}_${promotedTemp}`, where
+  // contName = `${prefix}_cont_1` (the first continuation).
+  // We write to EACH continuation's slot so all continuations see the initial values.
+  // (In practice there is usually only one continuation with a loop.)
+  const dispatcherName = `${prefix}_cont_1`
   const entryBlock = originalFn.blocks.find(b => b.id === originalFn.entry)
   if (entryBlock) {
     for (const instr of entryBlock.instrs) {
       const dst = getDst(instr)
       if (dst && promoted.has(dst)) {
-        // Rewrite to use promoted name
-        instrs.push(rewriteInstr(instr, promoted))
+        const promotedTemp = promoted.get(dst)!
+        const player = `$${dispatcherName}_${promotedTemp}`
+        if (instr.kind === 'const') {
+          instrs.push({ kind: 'score_write', player, obj: objective, src: { kind: 'const', value: instr.value } })
+        } else if (instr.kind === 'copy') {
+          // src is an Operand; if it's a temp, resolve through promoted map
+          let src: { kind: 'temp'; name: string } | { kind: 'const'; value: number }
+          if (instr.src.kind === 'temp') {
+            const srcTemp = promoted.get(instr.src.name) ?? instr.src.name
+            src = { kind: 'temp', name: srcTemp }
+          } else {
+            src = instr.src
+          }
+          instrs.push({ kind: 'score_write', player, obj: objective, src })
+        } else {
+          // Fallback for other instruction types: rewrite and emit as-is.
+          // These will have the init-function prefix, which may be wrong, but they
+          // are uncommon — the promoted variable set only contains loop-carried vars
+          // that are initialised with const/copy in the entry block.
+          instrs.push(rewriteInstr(instr, promoted))
+        }
       }
     }
   }
@@ -863,13 +912,18 @@ function buildSingleContinuation(
 
   const contName = `${prefix}_cont_1`
 
-  // Continuation = entire original function body, plus set pc=-1 at the end
+  const dispatcherName = `${prefix}_tick`
+  const pcPlayer = `$${dispatcherName}_${pcTemp}`
+
+  // Continuation = entire original function body, plus onDone call and PC reset at the end
   const contBlocks = fn.blocks.map(block => {
     if (block.term.kind === 'return') {
       const instrs = [...block.instrs]
       if (info.onDone) {
         instrs.push({ kind: 'call', dst: null, fn: info.onDone, args: [] })
       }
+      // Reset PC to 0 so dispatcher stops after one run
+      instrs.push({ kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 0 } })
       return { ...block, instrs }
     }
     return block
@@ -883,11 +937,11 @@ function buildSingleContinuation(
     isMacro: false,
   }
 
-  // Init: set pc = 1
+  // Init: set pc = 1 via score_write (side-effectful, not removed by DCE)
   const initBlock: MIRBlock = {
     id: 'entry',
     instrs: [
-      { kind: 'const', dst: pcTemp, value: 1 },
+      { kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 1 } },
     ],
     term: { kind: 'return', value: null },
     preds: [],
@@ -901,7 +955,7 @@ function buildSingleContinuation(
   }
 
   const dispatcher = buildDispatcher(
-    `${prefix}_tick`,
+    dispatcherName,
     [contFn],
     pcTemp,
     objective,
@@ -952,6 +1006,10 @@ function rewriteInstr(instr: MIRInstr, promoted: Map<Temp, Temp>): MIRInstr {
       return { ...instr, src: rOp(instr.src) }
     case 'nbt_write_dynamic':
       return { ...instr, indexSrc: rOp(instr.indexSrc), valueSrc: rOp(instr.valueSrc) }
+    case 'score_read':
+      return { ...instr, dst: rTemp(instr.dst) }
+    case 'score_write':
+      return { ...instr, src: rOp(instr.src) }
     case 'call':
       return { ...instr, dst: instr.dst ? rTemp(instr.dst) : null, args: instr.args.map(rOp) }
     case 'call_macro':
@@ -1028,6 +1086,8 @@ function getUsedTemps(instr: MIRInstr): Temp[] {
       addOp(instr.indexSrc); addOp(instr.valueSrc); break
     case 'nbt_read_dynamic':
       addOp(instr.indexSrc); break
+    case 'score_write':
+      addOp(instr.src); break
     case 'call':
       instr.args.forEach(addOp); break
     case 'call_macro':

package/src/parser/index.ts

@@ -81,6 +81,8 @@ export class Parser {
    *  `librarySources` compile option, each source is parsed by its own fresh
    *  Parser instance, so this flag never bleeds into user code. */
   private inLibraryMode: boolean = false
+  /** Warnings accumulated during parsing (e.g. deprecated keyword usage). */
+  readonly warnings: string[] = []
 
   constructor(tokens: Token[], source?: string, filePath?: string) {
     this.tokens = tokens
@@ -183,7 +185,7 @@ export class Parser {
       this.advance()
       const name = this.expect('ident')
       namespace = name.value
-      this.expect(';')
+      this.match(';')
     }
 
     // Check for module declaration: `module library;` or `module <name>;`
@@ -200,7 +202,7 @@ export class Parser {
         // Named module declaration: `module math;`
         moduleName = modKind.value
       }
-      this.expect(';')
+      this.match(';')
     }
 
     // Parse struct, function, and import declarations
@@ -234,7 +236,7 @@ export class Parser {
         } else {
           symbol = this.expect('ident').value
         }
-        this.expect(';')
+        this.match(';')
         imports.push(this.withLoc({ moduleName: modName, symbol }, importToken))
       } else {
         declarations.push(this.parseFnDecl())
@@ -327,7 +329,7 @@ export class Parser {
     const inferredType: TypeNode = type ?? (
       value.kind === 'str_lit' ? { kind: 'named', name: 'string' } :
       value.kind === 'bool_lit' ? { kind: 'named', name: 'bool' } :
-      value.kind === 'float_lit' ? { kind: 'named', name: 'float' } :
+      value.kind === 'float_lit' ? { kind: 'named', name: 'fixed' } :
       { kind: 'named', name: 'int' }
     )
     return this.withLoc({ name, type: inferredType, value }, constToken)
@@ -340,7 +342,7 @@ export class Parser {
     const type = this.parseType()
     this.expect('=')
     const init = this.parseExpr()
-    this.expect(';')
+    this.match(';')
     return this.withLoc({ kind: 'global', name, type, init, mutable }, token)
   }
 
@@ -505,7 +507,7 @@ export class Parser {
       } else if (key === 'batch') {
         args.batch = parseInt(val, 10)
       } else if (key === 'onDone') {
-        args.onDone = val
+        args.onDone = val.replace(/^["']|["']$/g, '')
       } else if (key === 'trigger') {
         args.trigger = val
       } else if (key === 'advancement') {
@@ -570,8 +572,15 @@ export class Parser {
       return { kind: 'tuple', elements }
     }
 
-    if (token.kind === 'int' || token.kind === 'bool' ||
-        token.kind === 'float' || token.kind === 'string' || token.kind === 'void' ||
+    if (token.kind === 'float') {
+      this.advance()
+      const filePart = this.filePath ? `${this.filePath}:` : ''
+      this.warnings.push(
+        `[DeprecatedType] ${filePart}line ${token.line}, col ${token.col}: 'float' is deprecated, use 'fixed' instead (×10000 fixed-point)`
+      )
+      type = { kind: 'named', name: 'float' }
+    } else if (token.kind === 'int' || token.kind === 'bool' ||
+        token.kind === 'fixed' || token.kind === 'string' || token.kind === 'void' ||
         token.kind === 'BlockPos') {
       this.advance()
       type = { kind: 'named', name: token.kind }
@@ -589,6 +598,10 @@ export class Parser {
         const inner = this.parseType()
         this.expect('>')
         type = { kind: 'option', inner }
+      } else if (token.value === 'double' || token.value === 'byte' ||
+                 token.value === 'short' || token.value === 'long' ||
+                 token.value === 'format_string') {
+        type = { kind: 'named', name: token.value as any }
       } else {
         type = { kind: 'struct', name: token.value }
       }
@@ -729,7 +742,7 @@ export class Parser {
       }
       this.expect('=')
       const init = this.parseExpr()
-      this.expect(';')
+      this.match(';')
       return this.withLoc({ kind: 'let_destruct', names, type, init }, letToken)
     }
 
@@ -742,7 +755,7 @@ export class Parser {
 
     this.expect('=')
     const init = this.parseExpr()
-    this.expect(';')
+    this.match(';')
 
     return this.withLoc({ kind: 'let', name, type, init }, letToken)
   }
@@ -751,11 +764,11 @@ export class Parser {
     const returnToken = this.expect('return')
 
     let value: Expr | undefined
-    if (!this.check(';')) {
+    if (!this.check(';') && !this.check('}') && !this.check('eof')) {
       value = this.parseExpr()
     }
 
-    this.expect(';')
+    this.match(';')
     return this.withLoc({ kind: 'return', value }, returnToken)
   }
 
@@ -872,29 +885,48 @@ export class Parser {
 
     let start: Expr
     let end: Expr
+    let inclusive = false
 
     if (this.check('range_lit')) {
-      // Literal range: 0..10, 0..count, 0..=9
+      // Literal range: 0..10, 0..count, 0..=9, 0..=count
       const rangeToken = this.advance()
-      const range = this.parseRangeValue(rangeToken.value)
+      const raw = rangeToken.value
+      // Detect inclusive: ends with = after .. (e.g. "0..=" or "..=")
+      const incl = raw.includes('..=')
+      inclusive = incl
+      const range = this.parseRangeValue(raw)
       start = this.withLoc({ kind: 'int_lit', value: range.min ?? 0 }, rangeToken)
       if (range.max !== null && range.max !== undefined) {
-        // Fully numeric: 0..10
+        // Fully numeric: 0..10 or 0..=9
         end = this.withLoc({ kind: 'int_lit', value: range.max }, rangeToken)
       } else {
-        // Open-ended: "0.." — parse the end expression from next tokens
+        // Open-ended: "0.." or "0..=" — parse the end expression from next tokens
         end = this.parseUnaryExpr()
       }
     } else {
-      // Dynamic range: expr..expr (e.g. start..end) — not yet supported
-      // Fall back to: parse as int_lit 0..0 (safe default)
-      start = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek())
-      end   = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek())
-      this.error('Dynamic range start requires a literal integer (e.g. 0..count)')
+      // Dynamic range: expr..expr or expr..=expr
+      // parseExpr stops before range_lit (not in BINARY_OPS), so this is safe
+      start = this.parseExpr()
+      // Consume the range_lit token which should be ".." or "..="
+      if (this.check('range_lit')) {
+        const rangeOp = this.advance()
+        inclusive = rangeOp.value.includes('=')
+        // If the range_lit captured digits after .., use them as end
+        const afterOp = rangeOp.value.replace(/^\.\.=?/, '')
+        if (afterOp.length > 0) {
+          end = this.withLoc({ kind: 'int_lit', value: parseInt(afterOp, 10) }, rangeOp)
+        } else {
+          end = this.parseExpr()
+        }
+      } else {
+        this.error('Expected .. or ..= in for-range expression')
+        start = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek())
+        end = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek())
+      }
     }
 
     const body = this.parseBlock()
-    return this.withLoc({ kind: 'for_range', varName, start, end, body }, forToken)
+    return this.withLoc({ kind: 'for_range', varName, start, end, inclusive, body }, forToken)
   }
 
   private parseForeachStmt(): Stmt {
@@ -1140,7 +1172,7 @@ export class Parser {
 
   private parseExprStmt(): Stmt {
     const expr = this.parseExpr()
-    this.expect(';')
+    this.match(';')
     const exprToken = this.getLocToken(expr) ?? this.peek()
     return this.withLoc({ kind: 'expr', expr }, exprToken)
   }
@@ -1369,12 +1401,38 @@ export class Parser {
         continue
       }
 
+      // Type cast: expr as Type
+      // Only parse 'as' as a cast when followed by a type token (not a selector like @a)
+      if (this.check('as') && this.isTypeCastAs()) {
+        const asToken = this.advance() // consume 'as'
+        const targetType = this.parseType()
+        expr = this.withLoc(
+          { kind: 'type_cast', expr, targetType },
+          this.getLocToken(expr) ?? asToken
+        )
+        continue
+      }
+
       break
     }
 
     return expr
   }
 
+  /** Returns true if the current 'as' token is a type cast (not a context block) */
+  private isTypeCastAs(): boolean {
+    // Look ahead past 'as' to see if the next token looks like a type
+    const next = this.tokens[this.pos + 1]
+    if (!next) return false
+    const typeStartTokens = new Set(['int', 'bool', 'float', 'fixed', 'string', 'void', 'BlockPos', '('])
+    if (typeStartTokens.has(next.kind)) return true
+    if (next.kind === 'ident' && (
+      next.value === 'double' || next.value === 'byte' || next.value === 'short' ||
+      next.value === 'long' || next.value === 'selector' || next.value === 'Option'
+    )) return true
+    return false
+  }
+
   private parseArgs(): Expr[] {
     const args: Expr[] = []
 
@@ -1495,6 +1553,14 @@ export class Parser {
       }, token)
     }
 
+    // Named struct literal: TypeName { field: value, ... }
+    // Require at least one field (ident + :) to avoid ambiguity with blocks.
+    if (token.kind === 'ident' && this.peek(1).kind === '{' &&
+        this.peek(2).kind === 'ident' && this.peek(3).kind === ':') {
+      this.advance() // consume type name (used only for disambiguation, dropped from AST)
+      return this.parseStructLit()
+    }
+
     // Some(expr) — Option constructor
     if (token.kind === 'ident' && token.value === 'Some' && this.peek(1).kind === '(') {
       this.advance() // consume 'Some'
@@ -1873,6 +1939,7 @@ export class Parser {
       token.kind === 'int' ||
       token.kind === 'bool' ||
       token.kind === 'float' ||
+      token.kind === 'fixed' ||
       token.kind === 'string' ||
       token.kind === 'void' ||
       token.kind === 'BlockPos' ||
@@ -2136,24 +2203,42 @@ export class Parser {
 
   private parseRangeValue(value: string): RangeExpr {
     // ..5 → { max: 5 }
+    // ..=5 → { max: 5 }
     // 1.. → { min: 1 }
+    // 1..= → { min: 1 } (open-ended inclusive, end parsed separately)
     // 1..10 → { min: 1, max: 10 }
+    // 1..=10 → { min: 1, max: 10 }
     // 5 → { min: 5, max: 5 } (exact match)
 
+    if (value.startsWith('..=')) {
+      const rest = value.slice(3)
+      if (!rest) return {}  // open upper bound, no max
+      const max = parseInt(rest, 10)
+      return { max }
+    }
+
     if (value.startsWith('..')) {
-      const max = parseInt(value.slice(2), 10)
+      const rest = value.slice(2)
+      if (!rest) return {}  // open upper bound, no max
+      const max = parseInt(rest, 10)
       return { max }
     }
 
-    if (value.endsWith('..')) {
-      const min = parseInt(value.slice(0, -2), 10)
-      return { min }
+    const inclIdx = value.indexOf('..=')
+    if (inclIdx !== -1) {
+      const min = parseInt(value.slice(0, inclIdx), 10)
+      const rest = value.slice(inclIdx + 3)
+      if (!rest) return { min }  // open-ended inclusive
+      const max = parseInt(rest, 10)
+      return { min, max }
     }
 
     const dotIndex = value.indexOf('..')
     if (dotIndex !== -1) {
       const min = parseInt(value.slice(0, dotIndex), 10)
-      const max = parseInt(value.slice(dotIndex + 2), 10)
+      const rest = value.slice(dotIndex + 2)
+      if (!rest) return { min }  // open-ended
+      const max = parseInt(rest, 10)
       return { min, max }
     }
 

package/src/stdlib/advanced.mcrs

@@ -309,6 +309,53 @@ fn newton_sqrt(n: int) -> int {
     return x;
 }
 
+// ─── Category 3 (cont.): Higher-order Bezier curves ─────────────────────────
+
+// Quartic Bezier: 5-point curve using De Casteljau's algorithm.
+// t in [0, 1000].
+// bezier_quartic(0, 250, 500, 750, 1000, 0)    == 0    (t=0: start)
+// bezier_quartic(0, 250, 500, 750, 1000, 1000) == 1000 (t=1: end)
+// bezier_quartic(0, 250, 500, 750, 1000, 500)  == 500  (midpoint, uniform pts)
+fn bezier_quartic(p0: int, p1: int, p2: int, p3: int, p4: int, t: int) -> int {
+    let m0: int = lerp(p0, p1, t);
+    let m1: int = lerp(p1, p2, t);
+    let m2: int = lerp(p2, p3, t);
+    let m3: int = lerp(p3, p4, t);
+    let n0: int = lerp(m0, m1, t);
+    let n1: int = lerp(m1, m2, t);
+    let n2: int = lerp(m2, m3, t);
+    let o0: int = lerp(n0, n1, t);
+    let o1: int = lerp(n1, n2, t);
+    return lerp(o0, o1, t);
+}
+
+// bezier_n(pts, n, t): N-order Bezier curve via De Casteljau's algorithm.
+// pts: array of n control points (int[], will be modified in-place).
+// t in [0, 1000].
+// WARNING: modifies pts in-place. Call bezier_n_safe if you need to preserve pts.
+// bezier_n([0,333,667,1000], 4, 0)    == 0    (t=0: returns pts[0])
+// bezier_n([0,333,667,1000], 4, 1000) == 1000 (t=1: returns pts[n-1])
+fn bezier_n(pts: int[], n: int, t: int) -> int {
+    let r: int = 0;
+    while (r < n - 1) {
+        let i: int = 0;
+        while (i < n - 1 - r) {
+            pts[i] = lerp(pts[i], pts[i + 1], t);
+            i = i + 1;
+        }
+        r = r + 1;
+    }
+    return pts[0];
+}
+
+// bezier_n_safe(pts, work, n, t): N-order Bezier, non-destructive.
+// Copies pts into work (length >= n) then runs bezier_n on work.
+// pts is not modified.
+fn bezier_n_safe(pts: int[], work: int[], n: int, t: int) -> int {
+    bigint_copy(pts, work, n);
+    return bezier_n(work, n, t);
+}
+
 // Digital root: repeatedly sum digits until single digit.
 // digital_root(493) == 7  (4+9+3=16 → 1+6=7)
 // digital_root(9) == 9