sutra-dev 0.9.3__tar.gz → 0.10.0__tar.gz

{sutra_dev-0.9.3/sutra_dev.egg-info → sutra_dev-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sutra-dev
-Version: 0.9.3
+Version: 0.10.0
 Summary: Compiler for the Sutra programming language — tensor ops on frozen-LLM embedding vectors.
 Author: Emma Leonhart
 License-Expression: AGPL-3.0-only

{sutra_dev-0.9.3 → sutra_dev-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sutra-dev"
-version = "0.9.3"
+version = "0.10.0"
 description = "Compiler for the Sutra programming language — tensor ops on frozen-LLM embedding vectors."
 readme = "README.md"
 requires-python = ">=3.11"

{sutra_dev-0.9.3 → sutra_dev-0.10.0}/sutra_compiler/__init__.py

@@ -28,7 +28,7 @@ The compiler is intentionally liberal where the spec is still open
 forms and flags the clearly-forbidden ones.
 """
 
-__version__ = "0.9.3"
+__version__ = "0.10.0"
 
 from .diagnostics import Diagnostic, DiagnosticLevel, DiagnosticBag
 from .lexer import Lexer, Token, TokenKind

{sutra_dev-0.9.3 → sutra_dev-0.10.0}/sutra_compiler/__main__.py

@@ -367,7 +367,18 @@ def _decode_terminal_result(mod, result):
                 and result.ndim == 1 and result.shape[0] == vsa.dim):
             if vsa.is_string(result):
                 return vsa.string_to_python(result)
-            return float(result[vsa.semantic_dim + vsa.AXIS_REAL])
+            real = float(result[vsa.semantic_dim + vsa.AXIS_REAL])
+            truth = float(result[vsa.semantic_dim + vsa.AXIS_TRUTH])
+            # Truth-dominant result (a fuzzy/bool return — e.g.
+            # `(15 % 3) == 0`): its value lives on AXIS_TRUTH, and
+            # printing the real axis showed 0.0 for a TRUE comparison
+            # (round-25). Display the truth reading with its polarity
+            # named; number-vectors (real-dominant) keep the old face.
+            if abs(truth) > abs(real):
+                word = ("true" if truth >= 0.5
+                        else "false" if truth <= -0.5 else "neutral")
+                return f"{word} ({truth:+.2f})"
+            return real
     except Exception:
         pass
     return result
@@ -526,7 +537,7 @@ def main(argv: List[str] | None = None) -> int:
 
     parser = argparse.ArgumentParser(
         prog="sutrac",
-        description="Validate Sutra (.su) source files.",
+        description="The Sutra toolchain: validate .su source (default), compile (--emit), execute (--run), or explore interactively (sutrac repl).",
         epilog=(
             "interactive REPL:\n"
             "  sutrac repl          Launch the interactive evaluator (takes no\n"

{sutra_dev-0.9.3 → sutra_dev-0.10.0}/sutra_compiler/ast_nodes.py

@@ -156,6 +156,28 @@ class Call(Expr):
     args: List[Expr]
 
 
+@dataclass
+class LoopCallExpr(Expr):
+    """`loop name(cond_arg, state_expr, ...)` in EXPRESSION position —
+    invoke a loop function and evaluate to its FINAL state.
+
+    Distinct from `LoopCallStmt` (the by-reference statement form, where
+    state args are slot-variable identifiers mutated in place). Here the
+    state args are arbitrary expressions and the whole construct is a
+    value — `int x = loop addNumber(x0 < 11, x0);` and
+    `return loop f(...);` both work.
+
+    Stage 1 (2026-07-12) supports the SINGLE-state form only; a call to a
+    multi-state loop function raises a codegen diagnostic pointing at the
+    by-reference statement form (multi-state tuple-assign is a later
+    stage — see todo.md §"Make loops idiomatic"). `state_args` still
+    carries the full list so the diagnostic can report the real arity.
+    """
+    name: str
+    condition_arg: Expr
+    state_args: List[Expr]
+
+
 @dataclass
 class NewExpr(Expr):
     """`new ClassName(args)` — auto-constructor for a class with field
@@ -487,6 +509,22 @@ class LoopCallStmt(Stmt):
     state_arg_names: List[str]
 
 
+@dataclass
+class LoopDestructureStmt(Stmt):
+    """`(a, b, ...) = loop NAME(cond, s0, s1, ...);` — invoke a MULTI-state
+    loop in value position and bind its final state values to newly-declared
+    locals `a, b, ...`.
+
+    This is the multi-state counterpart of the single-state loop expression
+    form (`int x = loop f(...)`). Sutra has no general tuples, so a
+    parenthesised comma-list on the LHS of `=` is ONLY this loop-destructure
+    form — the RHS is always a `LoopCallExpr`. The names are new locals whose
+    types are the loop's state-param types.
+    """
+    names: List[str]
+    call: "LoopCallExpr"
+
+
 # ============================================================
 # Declarations
 # ============================================================

{sutra_dev-0.9.3 → sutra_dev-0.10.0}/sutra_compiler/codegen.py

@@ -246,6 +246,18 @@ class Codegen(BaseCodegen):
         meaningful signal there.
         """
         assert op in ("eq", "neq")
+        # Number-family operands (int/number, incl. arithmetic results
+        # like `n % 3`) route through the exact relu indicator (Emma
+        # 2026-07-08): cosine is degenerate at the zero vector, so a
+        # runtime zero could never == anything — zero-testing was
+        # unreachable. Torch-runtime only (the deprecated numpy backend
+        # keeps its old routing).
+        if (getattr(self, "supports_cast_lowering", False)
+                and self._CAST_FAMILY.get(
+                    self._infer_cast_operand_type(expr.left)) == "number"
+                and self._CAST_FAMILY.get(
+                    self._infer_cast_operand_type(expr.right)) == "number"):
+            return f"_VSA.num_{op}({left_src}, {right_src})"
         if (self._is_synthetic_axis_expr(expr.left)
                 and self._is_synthetic_axis_expr(expr.right)):
             return f"_VSA.{op}_synthetic({left_src}, {right_src})"
@@ -1127,34 +1139,34 @@ class Codegen(BaseCodegen):
         self._emit("return (base, base + 1)")
         self._indent -= 1
         self._emit()
-        self._emit("def slot_store(self, state, slot_idx, scalar):")
+        self._emit("def slot_state_new(self):")
         self._indent += 1
-        self._emit('"""Write scalar to slot slot_idx. Overwrites the slot\'s plane.')
-        self._emit('')
-        self._emit("The scalar lives on the real leg of the slot\'s 2D plane; the")
-        self._emit("imaginary leg is zeroed. A subsequent slot_load returns the scalar")
-        self._emit("exactly. This is the reversible-imperative-state primitive: a")
-        self._emit("variable assignment = one slot_store; the inverse is slot_store of")
-        self._emit("the previous value. State outside the slot\'s plane is unchanged.")
+        self._emit('"""A fresh slot store: `{slot_idx: value}`. Parity with the pytorch')
+        self._emit("backend's unified d-dim slot representation (rung 3). This backend")
+        self._emit("keeps numbers as host scalars (no num_* substrate ops), so a scalar")
+        self._emit("slot stores a host scalar and a String/vector slot stores its vector;")
+        self._emit("the dict just carries whichever, keyed by compile-time slot index.")
         self._emit('"""')
-        self._emit("i, j = self._slot_plane(slot_idx)")
-        self._emit("new = state.copy() if hasattr(state, 'copy') else _np.asarray(state).copy()")
-        self._emit("new[i] = float(scalar)")
-        self._emit("new[j] = 0.0")
+        self._emit("return {}")
+        self._indent -= 1
+        self._emit()
+        self._emit("def slot_store(self, state, slot_idx, scalar):")
+        self._indent += 1
+        self._emit('"""Store the value for slot slot_idx (functional update — returns a')
+        self._emit("new dict). Stores the value as-is: a host scalar for number slots, a")
+        self._emit("full vector for String/vector slots. Reversible-imperative-state")
+        self._emit('primitive: a variable assignment = one slot_store."""')
+        self._emit("new = dict(state)")
+        self._emit("new[int(slot_idx)] = scalar")
         self._emit("return new")
         self._indent -= 1
         self._emit()
         self._emit("def slot_load(self, state, slot_idx):")
         self._indent += 1
-        self._emit('"""Read the scalar stored at slot slot_idx (the real leg).')
-        self._emit('')
-        self._emit("Returns a substrate scalar (numpy 0-dim from state[i]) rather than a")
-        self._emit("Python float — downstream arithmetic stays in substrate land. Other")
-        self._emit("slots and semantic content do not contribute; the disjoint-plane")
-        self._emit("allocation makes this a projection, not a noisy readout.")
-        self._emit('"""')
-        self._emit("i, _j = self._slot_plane(slot_idx)")
-        self._emit("return state[i]")
+        self._emit('"""Read the value stored at slot slot_idx (0.0 if never stored — the')
+        self._emit('zero-initialised scalar this backend defaults numbers to)."""')
+        self._emit("v = state.get(int(slot_idx))")
+        self._emit("return v if v is not None else 0.0")
         self._indent -= 1
         self._emit()
         self._emit("def rotate_slot(self, state, slot_idx, angle):")
@@ -1475,6 +1487,18 @@ class Codegen(BaseCodegen):
         self._emit("return v")
         self._indent -= 1
         self._emit()
+        self._emit("def _scalar(self, x):")
+        self._indent += 1
+        self._emit('"""Coerce a number to an int-able scalar: a full number-vector')
+        self._emit("projects to its AXIS_REAL coordinate; a host scalar / 0-d passes")
+        self._emit("through. Mirrors the pytorch backend so the SHARED codegen's")
+        self._emit("`int(_VSA._scalar(count))` (the iterative-loop count read) works on")
+        self._emit("this backend too. Vector-loop-state rung 3 B1a: this backend keeps")
+        self._emit("numbers as host scalars, so today it is a passthrough — the guard")
+        self._emit('is in place for when a loop count arrives as a number-vector."""')
+        self._emit("return self._re(x)")
+        self._indent -= 1
+        self._emit()
         self._emit("def _num_re(self, v):")
         self._indent += 1
         self._emit('"""Real-axis scalar of a number value — mirrors the pytorch backend\'s')

{sutra_dev-0.9.3 → sutra_dev-0.10.0}/sutra_compiler/codegen_base.py

@@ -702,6 +702,19 @@ class BaseCodegen:
     def translate(self, module: ast.Module) -> str:
         self._emit_prelude()
         self._emit()
+        # Pre-pass 0: record every top-level user function's declared
+        # return type, so expression-type checks (e.g. the text-concat
+        # dispatch asking "does f(x) return a string?") can resolve
+        # FORWARD references — a call site is often translated before
+        # its callee. _resolved_return_type only knows class methods and
+        # the stdlib; without this map, `f(1) + " "` with a user
+        # `function string f` fell to the numeric path and crashed at
+        # runtime (round-23 audit).
+        self._user_fn_return_types: dict[str, str] = {}
+        for item in module.items:
+            if (isinstance(item, ast.FunctionDecl)
+                    and item.return_type is not None):
+                self._user_fn_return_types[item.name] = item.return_type.name
         # Pre-pass A: pull in stdlib class intrinsics (e.g.
         # `Tensor.MatrixMul`, `Tensor.matmul`, etc.) so namespaced
         # stdlib calls dispatch to `_VSA.<name>` even though the
@@ -1243,7 +1256,7 @@ class BaseCodegen:
                 self._var_type[p.name] = p.type_ref.name
         self._emit("_program_halt = 1.0")
         if _has_slot_decl(decl.body):
-            self._emit("_slot_state = _VSA.zero_vector()")
+            self._emit("_slot_state = _VSA.slot_state_new()")
         if not decl.body.statements:
             self._emit("pass")
         else:
@@ -1373,7 +1386,7 @@ class BaseCodegen:
         self._nonhalting_slot_var = nonhalting_slot_var
         self._emit("_program_halt = 1.0")
         if _has_slot_decl(decl.body):
-            self._emit("_slot_state = _VSA.zero_vector()")
+            self._emit("_slot_state = _VSA.slot_state_new()")
         if not decl.body.statements:
             self._emit("pass")
         else:
@@ -1846,9 +1859,16 @@ class BaseCodegen:
             self._emit(f"# iterative_loop: tick = _t+1, halt when tick > count.")
             self._emit(f"_iterator = _t + 1")
             # Heaviside of (count - iterator + 1): positive while iterator
-            # <= count; zero or negative once past. Substrate-pure scalar.
+            # <= count; zero or negative once past. The count may be a
+            # slot-threaded state param, which under rung 3's unified d-dim
+            # slot representation arrives as a number-vector — `_scalar`
+            # projects it to its real-axis value before the int() count
+            # read. A no-op on the current 0-d/host-int form (rung 3 B1a:
+            # pre-project the one codegen scalar consumer of a slot value so
+            # the later representation flip does not break it).
             self._emit(
-                f"_keep = _VSA.heaviside(int({count_src}) - _iterator + 1)"
+                f"_keep = _VSA.heaviside(int(_VSA._scalar({count_src})) "
+                f"- _iterator + 1)"
             )
         elif decl.kind == "foreach_loop":
             # foreach: array is an explicit step parameter (`arr_param_name`).
@@ -2112,6 +2132,151 @@ class BaseCodegen:
         # this loop's completion gates the function's return value.
         self._emit("_program_halt = _program_halt * _loopret_halt")
 
+    def _translate_loop_call_expr(self, expr: "ast.LoopCallExpr") -> str:
+        """Lower `loop NAME(cond, state_expr)` in EXPRESSION position to the
+        loop's FINAL state value.
+
+        Reuses the exact driver function the by-reference statement form
+        emits (`_loop_NAME`), which returns a `(state..., halted)` tuple;
+        the expression value is the single state slot (`[0]`). No slot
+        writeback and no by-reference identifiers — the state arg is an
+        arbitrary expression passed straight in as the init value.
+
+        Stage 1 (2026-07-12): single-state, non-`this`-threading loops
+        only. Multi-state and non-static class loops raise a diagnostic
+        pointing at the by-reference statement form.
+        """
+        decl = self._loop_decls.get(expr.name)
+        if decl is None:
+            raise CodegenNotSupported(
+                expr,
+                f"loop function `{expr.name}` is not declared. Loop "
+                f"functions must be declared with one of `do_while`, "
+                f"`while_loop`, `iterative_loop`, `foreach_loop` before "
+                f"being invoked with `loop NAME(...)`.",
+            )
+        # Non-static class-bodied loops return `this` first and rebind the
+        # caller instance — that has no meaning as a pure value. Defer.
+        if "." in expr.name and not getattr(decl, "is_static", False):
+            raise CodegenNotSupported(
+                expr,
+                f"loop `{expr.name}` is a non-static class loop; its "
+                f"expression form is not supported yet. Use the "
+                f"by-reference statement form: `loop {expr.name}"
+                f"(instance, ...);`.",
+            )
+        n_state = len(decl.state_params)
+        if n_state != 1:
+            raise CodegenNotSupported(
+                expr,
+                f"the single-value loop expression form supports "
+                f"single-state loops only; `{expr.name}` has {n_state} "
+                f"state parameters. Use the tuple-destructure form for "
+                f"multi-state loops — `(a, b) = loop {expr.name}(cond, "
+                f"...);` — or the by-reference statement form (`slot` vars "
+                f"+ `loop {expr.name}(cond, a, b);`).",
+            )
+        if len(expr.state_args) != 1:
+            raise CodegenNotSupported(
+                expr,
+                f"loop `{expr.name}` takes 1 state argument, got "
+                f"{len(expr.state_args)}.",
+            )
+        state_src = self._translate_expr(expr.state_args[0])
+        py_loop_name = f"_loop_{expr.name.replace('.', '_')}"
+        if decl.kind == "foreach_loop":
+            # The array (condition_arg) is consumed as the first driver
+            # arg — mirror the statement form's array_from_literal path.
+            if isinstance(expr.condition_arg, ast.ArrayLiteral):
+                elem_srcs = [
+                    self._translate_expr(e)
+                    for e in expr.condition_arg.elements
+                ]
+                arr_src = f"_VSA.array_from_literal({', '.join(elem_srcs)})"
+            else:
+                arr_src = self._translate_expr(expr.condition_arg)
+            return f"{py_loop_name}({arr_src}, {state_src})[0]"
+        # Other kinds: the runtime uses the loop's decl-time condition, so
+        # the cond arg's value is unused. Evaluate it for side-effect
+        # parity with the statement form, then yield the final state.
+        cond_src = self._translate_expr(expr.condition_arg)
+        return f"(({cond_src}), {py_loop_name}({state_src})[0])[-1]"
+
+    def _translate_loop_destructure(self, stmt: "ast.LoopDestructureStmt") -> None:
+        """Lower `(a, b, ...) = loop NAME(cond, s0, s1, ...);` — the
+        multi-state counterpart of the single-state loop expression form.
+
+        Reuses the same driver the statement/expression forms emit
+        (`_loop_NAME`), which returns `(state0, ..., stateK, halted)`, and
+        binds the state slots to the newly-declared locals `a, b, ...`. Like
+        the single-state expression form it drops the halt slot (the driver
+        loops until halt saturates, so it is ~1.0 at return) — the value
+        forms take the state, not the completion flag.
+        """
+        call = stmt.call
+        decl = self._loop_decls.get(call.name)
+        if decl is None:
+            raise CodegenNotSupported(
+                stmt,
+                f"loop function `{call.name}` is not declared. Loop "
+                f"functions must be declared with one of `do_while`, "
+                f"`while_loop`, `iterative_loop`, `foreach_loop` before "
+                f"being invoked with `loop NAME(...)`.",
+            )
+        if "." in call.name and not getattr(decl, "is_static", False):
+            raise CodegenNotSupported(
+                stmt,
+                f"loop `{call.name}` is a non-static class loop; the "
+                f"destructure form is not supported for it. Use the "
+                f"by-reference statement form.",
+            )
+        n_state = len(decl.state_params)
+        if len(stmt.names) != n_state:
+            raise CodegenNotSupported(
+                stmt,
+                f"loop `{call.name}` has {n_state} state parameter(s) but "
+                f"the destructure binds {len(stmt.names)} name(s) — they "
+                f"must match one-to-one.",
+            )
+        if len(call.state_args) != n_state:
+            raise CodegenNotSupported(
+                stmt,
+                f"loop `{call.name}` takes {n_state} state argument(s), got "
+                f"{len(call.state_args)}.",
+            )
+        # Register each bound name's declared type from the loop's state
+        # params so downstream type-dependent codegen (string/complex ops)
+        # routes correctly.
+        for name, sp in zip(stmt.names, decl.state_params):
+            sp_type = getattr(getattr(sp, "type_ref", None), "name", None)
+            if sp_type is not None:
+                self._var_type[name] = sp_type
+        state_srcs = [self._translate_expr(a) for a in call.state_args]
+        py_loop_name = f"_loop_{call.name.replace('.', '_')}"
+        targets = ", ".join(stmt.names)
+        self._emit(f"# loop destructure: ({targets}) = loop {call.name}(...)")
+        if decl.kind == "foreach_loop":
+            if isinstance(call.condition_arg, ast.ArrayLiteral):
+                elem_srcs = [
+                    self._translate_expr(e)
+                    for e in call.condition_arg.elements
+                ]
+                arr_src = f"_VSA.array_from_literal({', '.join(elem_srcs)})"
+            else:
+                arr_src = self._translate_expr(call.condition_arg)
+            all_args = [arr_src] + state_srcs
+            self._emit(
+                f"({targets}, _) = {py_loop_name}({', '.join(all_args)})"
+            )
+            return
+        # Non-foreach: cond value is unused at runtime (the loop uses its
+        # decl-time condition); evaluate it once for side-effect parity.
+        cond_src = self._translate_expr(call.condition_arg)
+        self._emit(f"_ = {cond_src}")
+        self._emit(
+            f"({targets}, _) = {py_loop_name}({', '.join(state_srcs)})"
+        )
+
     # -- statements -------------------------------------------------------
 
     def _axon_add_parts(self, stmt):
@@ -2248,18 +2413,46 @@ class BaseCodegen:
                     f"state parameter `{', '.join(state_names)}`), got "
                     f"{len(stmt.values)}",
                 )
-            for state_name, value in zip(state_names, stmt.values):
+            # PARALLEL assignment (2026-07-13 reach-audit fix): every pass
+            # value is evaluated against the CURRENT (pre-assignment)
+            # environment, THEN the state locals update together — the RNN
+            # cell semantics `state ← f(state)`. The old sequential
+            # emission clobbered earlier states before later values read
+            # them: `pass b, a + b` (fibonacci) emitted `a = b` then
+            # `b = num_add(a, b)` with the NEW a, degenerating into
+            # doubling (measured: fib after 8 ticks read 128 = 2^7
+            # instead of 34). Staging through `_passN` temporaries makes
+            # the two-phase update explicit; single-value passes skip the
+            # temporary (nothing to clobber).
+            if len(stmt.values) == 1:
+                value = stmt.values[0]
+                if isinstance(value, ast.ReplaceMarker):
+                    self._emit(f"{state_names[0]} = _init_{state_names[0]}")
+                else:
+                    self._emit(
+                        f"{state_names[0]} = "
+                        f"{self._translate_expr(value)}"
+                    )
+                return
+            tmp_names: list[str] = []
+            for idx, value in enumerate(stmt.values):
+                tmp = f"_pass{idx}"
+                tmp_names.append(tmp)
                 if isinstance(value, ast.ReplaceMarker):
                     # `replace` keyword: restore the parameter's input value.
-                    self._emit(f"{state_name} = _init_{state_name}")
+                    self._emit(f"{tmp} = _init_{state_names[idx]}")
                 else:
-                    value_src = self._translate_expr(value)
-                    self._emit(f"{state_name} = {value_src}")
+                    self._emit(f"{tmp} = {self._translate_expr(value)}")
+            for state_name, tmp in zip(state_names, tmp_names):
+                self._emit(f"{state_name} = {tmp}")
             return
         # LoopCallStmt: invoke a loop function and write back state.
         if isinstance(stmt, ast.LoopCallStmt):
             self._translate_loop_call(stmt)
             return
+        if isinstance(stmt, ast.LoopDestructureStmt):
+            self._translate_loop_destructure(stmt)
+            return
         if isinstance(stmt, ast.VarDecl):
             self._translate_var_decl(stmt, at_top_level=False)
             return
@@ -2634,10 +2827,21 @@ class BaseCodegen:
                 f"unroll by hand.",
             )
         if isinstance(stmt, ast.IfStmt):
+            # Design commitment, not a gap (control-flow.md § "`if` /
+            # `else` is parsed but rejected at codegen"): Sutra
+            # conditionals are weighted superpositions, not discrete
+            # branches. The message must hand the newcomer the actual
+            # rewrite, not just the philosophy (round-23 audit).
             raise CodegenNotSupported(
                 stmt,
-                "if/else is not supported by the V1 codegen — the whole "
-                "point is to compile it away into a prototype-table lookup",
+                "`if`/`else` never compiles — by design, Sutra "
+                "conditionals are weighted superpositions, not discrete "
+                "branches. Write `select([score_a, score_b, ...], "
+                "[result_a, result_b, ...])`: the highest score's result "
+                "dominates the output. A boolean two-way branch is "
+                "`select([is_true(cond), is_true(!cond)], [then_value, "
+                "else_value])`. See the control-flow docs and "
+                "examples/fuzzy_dispatch.su for the idiom.",
             )
         if isinstance(stmt, ast.TryStmt):
             self._translate_try_catch(stmt)
@@ -3042,6 +3246,10 @@ class BaseCodegen:
             return (self._is_text_expr(expr.left)
                     and self._is_text_expr(expr.right))
         if isinstance(expr, ast.Call):
+            if (isinstance(expr.callee, ast.Identifier)
+                    and getattr(self, "_user_fn_return_types", {}).get(
+                        expr.callee.name) in self._TEXT_TYPES):
+                return True
             return self._resolved_return_type(expr.callee) in self._TEXT_TYPES
         return False
 
@@ -3058,6 +3266,15 @@ class BaseCodegen:
             return self._var_type.get(expr.name) in self._SYNTHETIC_AXIS_TYPES
         if isinstance(expr, ast.Parenthesized):
             return self._is_synthetic_axis_expr(expr.inner)
+        # A call whose declared return type is synthetic-axis-encoded
+        # (2026-07-13 reach-audit defect #6): `make_string("cat") ==
+        # make_string("dog")` fell through to the general cosine `eq`,
+        # and two codepoint vectors are nearly parallel — ALL Strings
+        # read ~equal (measured +0.994). Same conservative
+        # Call-return-type pattern `_is_number_expr` already uses.
+        if isinstance(expr, ast.Call):
+            return (self._resolved_return_type(expr.callee)
+                    in self._SYNTHETIC_AXIS_TYPES)
         return False
 
     def _is_number_expr(self, expr: ast.Expr) -> bool:
@@ -3390,6 +3607,8 @@ class BaseCodegen:
             return f"{target_src}[{index_src}]"
         if isinstance(expr, ast.Call):
             return self._translate_call(expr)
+        if isinstance(expr, ast.LoopCallExpr):
+            return self._translate_loop_call_expr(expr)
         if isinstance(expr, ast.BinaryOp):
             left = self._translate_expr(expr.left)
             right = self._translate_expr(expr.right)
@@ -3653,29 +3872,34 @@ class BaseCodegen:
                         self._translate_expr(part, dest_type="string"))
                     continue
                 if part_t == "int":
-                    # strings.md § Integer formatting: the substrate
-                    # int→string formatter. int ONLY — a fractional
-                    # `number` rendering as its rounded integer would
-                    # silently lie, so it keeps rejecting below.
+                    # strings.md § Integer formatting: exact integer
+                    # rendering.
                     pieces.append(
                         f"_VSA.int_to_string("
                         f"{self._translate_expr(part)})")
                     continue
+                if self._CAST_FAMILY.get(part_t) == "number":
+                    # strings.md § Decimal formatting: fractional
+                    # number interpolants render via num_to_string
+                    # (shortest decimal, <=6 places).
+                    pieces.append(
+                        f"_VSA.num_to_string("
+                        f"{self._translate_expr(part)})")
+                    continue
                 if part_t is None:
                     raise CodegenNotSupported(
                         part,
                         "interpolated expression must be string- or "
-                        "int-typed and statically inferable — assign it "
-                        "to a `string` (or `int`) variable first, or "
-                        "build the text with make_string / string_concat."
+                        "number-typed and statically inferable — assign "
+                        "it to a typed variable first, or build the text "
+                        "with make_string / string_concat."
                     )
                 raise CodegenNotSupported(
                     part,
-                    f"cannot interpolate a `{part_t}` value: only string- "
-                    "and int-typed interpolants lower (int_to_string is "
-                    "integer-shaped; fractional rendering is not built). "
-                    "For an integer value, declare it `int`; otherwise "
-                    "build the text with make_string / string_concat."
+                    f"cannot interpolate a `{part_t}` value: string- and "
+                    "number-family interpolants lower (int_to_string / "
+                    "num_to_string); build other text with make_string / "
+                    "string_concat."
                 )
             if not pieces:
                 return "_VSA.make_string('')"
@@ -3743,6 +3967,20 @@ class BaseCodegen:
         exprs. None when unknown — the caller decides whether the
         target makes the relabel/axis-move distinction load-bearing."""
         from .symbol_table import _LITERAL_TYPES
+        # Inliner typing provenance (2026-07-13): a comparison that the
+        # operator-lowering inlined (`best >= e` → ge's body polynomial)
+        # carries `_truth_typed` on its TOP node — the expression's VALUE
+        # is a truth-axis fuzzy, so report "bool" for the cast decision.
+        #
+        # Do NOT read `_logical_truth` here: `_mark_logical_truth` sprays
+        # that flag over the ENTIRE inlined subtree including substituted
+        # ARGUMENT subtrees (it drives arithmetic routing, not typing).
+        # Reading it as type evidence made the `==` operands inside ge's
+        # body infer "bool", miss num_eq, and soften through eq_synthetic
+        # — the CI-caught le/ge regression (`2 >= 3` → −0.52 instead of
+        # the crisp −1.0 the 2026-07-08 tie fix guarantees).
+        if getattr(expr, "_truth_typed", False):
+            return "bool"
         kind = type(expr).__name__
         if kind in _LITERAL_TYPES:
             return _LITERAL_TYPES[kind]
@@ -3761,6 +3999,19 @@ class BaseCodegen:
                 if (self._CAST_FAMILY.get(lt) == "number"
                         and self._CAST_FAMILY.get(rt) == "number"):
                     return "number"
+        # Call whose declared return type is known (2026-07-13 reach-audit
+        # fix). Two silent failures traced here: (a) the inliner rewrites
+        # `<`/`<=`/`>=`/`!=` into stdlib Calls (`lt`/`le`/`ge`/`neq`,
+        # declared `fuzzy`), so `(number)(best >= e)` arrived as a Call,
+        # inferred None, and the cast DIED "static type can't be inferred";
+        # (b) `string_char_at(s, i) == 97` — char_at declares `int`, but
+        # with no Call inference the == routed to general vector `eq`,
+        # whose cosine reads ANY two number-vectors as equal (98 == 97 →
+        # true) — silently wrong counts. `_resolved_return_type` consults
+        # user-class methods + the stdlib symbol table; conservative (None
+        # when undeclared), same source `_is_complex_expr` already trusts.
+        if isinstance(expr, ast.Call):
+            return self._resolved_return_type(expr.callee)
         return None
 
     def _translate_cast(self, expr: ast.CastExpr) -> str:
@@ -3778,17 +4029,19 @@ class BaseCodegen:
         # --- text walls -------------------------------------------------
         if dst_family == "text" and src_family != "text":
             if src == "int":
-                # strings.md § Integer formatting: `(string) n` on an
-                # int is the integer formatter — the one number→text
-                # cast with a real substrate implementation.
+                # strings.md § Integer formatting: exact integer render.
                 return (f"_VSA.int_to_string("
                         f"{self._translate_expr(expr.expr)})")
+            if src_family == "number":
+                # strings.md § Decimal formatting: fractional numbers
+                # render via num_to_string (shortest decimal, <=6 places).
+                return (f"_VSA.num_to_string("
+                        f"{self._translate_expr(expr.expr)})")
             raise CodegenNotSupported(
                 expr,
-                f"cannot cast to `{dst}`: only `int` values format "
-                "(int_to_string — integer-shaped; fractional rendering is "
-                "not built). For a literal, use `make_string(\"...\")`; "
-                "join strings with `string_concat`."
+                f"cannot cast to `{dst}`: number-family values format via "
+                "int_to_string / num_to_string; for a literal use "
+                "`make_string(\"...\")`, join strings with `string_concat`."
             )
         if src_family == "text" and dst_family != "text":
             if dst_family == "geometric":