fusion-lang 0.0.1.alpha2 → 0.0.1

data/docs/user/tutorial.md

@@ -16,7 +16,7 @@ Fusion programs read JSON on standard input and write JSON on standard output. L
 create our first program. Create a file `lesson.fsn` containing exactly:
 
 ```fusion
-(n => [n, 2] | @multiply)
+(n => [n, 2] | @OP.product)
 ```
 
 Now run it:
@@ -32,10 +32,11 @@ being told:
   statements. The file *is* the program.
 - The input `21` was piped *into* the function. That is what `|` means: **`value |
   function`** applies the function to the value.
-- `[n, 2] | @multiply` built a two-element array and piped it into the built-in
-  `@multiply`. Fusion has no `*` operator (yet); arithmetic is done by piping a pair
-  into a named function. **Built-ins are reached with an `@` prefix**, just like files
-  — `@multiply`, `@add`, and so on. (You'll see why `@` is used for both in Step 8.)
+- `[n, 2] | @OP.product` built a two-element array and piped it into `@OP.product`, a
+  member of the built-in operator object `@OP`. Fusion has no `*` operator (yet);
+  arithmetic is done by piping a pair into a built-in. **Built-ins are reached with an
+  `@` prefix**, just like files — `@OP.product`, `@OP.sum`, and so on. (You'll see why
+  `@` is used for both in Step 8.)
 
 Note: on the right side of `=>` you can use regular parentheses `()` to group
 expressions and influence execution order.
@@ -126,8 +127,8 @@ number's absolute value:
 
 ```fusion
 (n =>
-  [n, 0] | @lessThan | (
-    true  => [0, n] | @subtract,
+  [n, 0] | @OP.compare | @lt | (
+    true  => n | @OP.negate,
     false => n
   )
 )
@@ -140,9 +141,10 @@ echo '-5' | fusion lesson.fsn    # => 5
 echo '5'  | fusion lesson.fsn    # => 5
 ```
 
-Read the middle line carefully: `[n, 0] | @lessThan` produces `true` or `false`. That
-boolean is then piped into a *second, inline function* whose two clauses are the two
-branches. **An `if` is just a function with a `true` clause and a `false` clause.**
+Read the middle line carefully: `[n, 0] | @OP.compare` orders the pair as `-1`/`0`/`1`,
+and `@lt` turns that into `true`/`false`. That boolean is then piped into a *second,
+inline function* whose two clauses are the two branches. **An `if` is just a function
+with a `true` clause and a `false` clause.**
 
 Note: you don't need to restrict yourself to the two values `true` and `false` as
 an intermediate result. Don't use it purely as an `if / else`. Use it like a `case`
@@ -161,7 +163,7 @@ To make recursion easier, `@` always means *the current file*. Create a new file
 ```fusion
 (
   [] => 0,
-  [x, ...rest] => [x, rest | @ ] | @add
+  [x, ...rest] => [x, rest | @ ] | @OP.sum
 )
 ```
 
@@ -198,7 +200,7 @@ Let's compute the factorial:
 ```fusion
 (
   0 => 1,
-  n ? @Integer => [n, [n, 1] | @subtract | @] | @multiply
+  n ? @Integer => [n, [n, -1] | @OP.sum | @] | @OP.product
 )
 ```
 
@@ -214,7 +216,7 @@ Create a function that sorts a pair of values:
 
 ```fusion
 (
-  [a, b] ? @lessThan => [a, b],
+  [a, b] ? (p => p | @OP.compare | @lt) => [a, b],
   [a, b] => [b, a]
 )
 ```
@@ -232,7 +234,7 @@ standard library and are reached with a plain `@name` — the same `@map` you'd
 a sibling file. The classic `map` is in the standard library. Create `doubler.fsn`:
 
 ```fusion
-(xs => {"f": (n => [n, 2] | @multiply), "xs": xs} | @map)
+(xs => {"f": (n => [n, 2] | @OP.product), "c": xs} | @map)
 ```
 
 ```sh
@@ -240,7 +242,7 @@ echo '[1, 2, 3]' | fusion doubler.fsn    # => [2, 4, 6]
 ```
 
 Because every Fusion function takes exactly one argument, `map` takes an *object*
-bundling the function `f` and the list `xs`. You just passed a function as a value
+bundling the function `f` and the collection `c`. You just passed a function as a value
 nested within an object — functions are values like any other.
 
 Now the payoff for using `@` everywhere. A bare `@name` is resolved in the following
@@ -249,7 +251,7 @@ order:
 2. A **built-in** called `name`.
 3. A **standard-library** file `name.fsn`.
 
-The first match wins. So `@multiply` finds the built-in and `@map` falls through to
+The first match wins. So `@OP` finds the built-in and `@map` falls through to
 the standard library. And if *you* put a `map.fsn` next to your program, *your* `map`
 shadows the standard one — but only for files in that directory.
 
@@ -264,7 +266,7 @@ So far you have written programs that succeed. What happens when something goes
 wrong? Try dividing by zero. Save as `boom.fsn`:
 
 ```fusion
-(n => [n, 0] | @divide)
+(n => [n, 0] | @math.divide)
 ```
 
 ```sh
@@ -307,7 +309,7 @@ Catching is done with an error pattern:
 Here's `safeDivide` that returns `null` instead of failing:
 
 ```fusion
-(p => p | @divide | (! => null, n => n))
+(p => p | @math.divide | (! => null, n => n))
 ```
 
 Run `echo '[10, 0]' | fusion safeDivide.fsn` and you get `null` rather than an
@@ -331,7 +333,7 @@ In about an hour you have used every major feature of the language:
 - `if` is a function matching `true`/`false`; a loop is recursion via `@` (a bare
   `@` means "this file").
 - `?` attaches a predicate to refine a match, and predicates double as types.
-- Everything reachable lives in one `@` namespace: built-ins (`@add`, `@Integer`),
+- Everything reachable lives in one `@` namespace: built-ins (`@OP`, `@Integer`),
   the standard library (`@map`), sibling files (`@helper`), and the current file
   (`@`). A bare `@name` checks sibling → built-in → standard library, so you can
   locally shadow a built-in or stdlib function per directory.

data/examples/double.fsn

@@ -1,4 +1,4 @@
 (
   [] => [],
-  [first, ...rest] => [[first, first] | @add, ...rest | @]
+  [first, ...rest] => [2 * first, ...rest|@]
 )

data/examples/factorial.fsn

@@ -1,6 +1,6 @@
 # Factorial: n! for a non-negative integer.
 (
-  _ ? (i ? @Integer => [i, 0] | @lessThan, _ => true) => !"Only non-negative integers, please!",
+  _ ? (i ? @Integer => (i ?? 0)|@lt, _ => true) => !"Only non-negative integers, please!",
   0 => 1,
-  n => [n, [n, 1] | @subtract | @] | @multiply
+  n => n * (n - 1)|@
 )

data/examples/fizzbuzz.fsn

@@ -1,10 +1,7 @@
 # FizzBuzz for a single integer
 (
   n =>
-    [
-      [n, 3] | @mod,
-      [n, 5] | @mod,
-    ]
+    [n % 3, n % 5]
       |
     (
       [0, 0] => "FizzBuzz",

data/examples/json_test.fsn

@@ -0,0 +1,4 @@
+# JSON with comments, trailing commas and inline computation.
+{
+  "duration": 24 * 60,
+}

data/examples/palindrome.fsn

@@ -4,6 +4,6 @@
   s ? @String => s | @chars | @,
   []  => "palindrome",
   [_] => "palindrome",
-  [_, ...rest, _] ? @ends | @equals => rest | @,
+  [_, ...rest, _] ? @ends | @OP.equal => rest | @,
   _   => "not a palindrome"
 )

data/exe/fusion

@@ -5,10 +5,10 @@
 #
 # Usage:
 #   echo '[1,2,3]' | fusion path/to/main.fsn
-#   fusion path/to/main.fsn '<json-input>'        # input as an argument
-#   fusion -e '(n => [n,2] | @multiply)' '21'     # inline program
-#   fusion --stream path/to/main.fsn              # NDJSON in, NDJSON out
-#   fusion --repl                                 # interactive expressions/statements
+#   fusion path/to/main.fsn                            # no input: the file's value is the result
+#   echo '21' | fusion -e '(n => [n,2] | @multiply)'   # inline program
+#   fusion --stream path/to/main.fsn                   # NDJSON in, NDJSON out
+#   fusion --repl                                      # interactive expressions/statements
 #
 # Run `fusion --help` for the input/output modes (--input / --output / -!).
 
@@ -19,12 +19,12 @@ if ARGV.intersect?(["--help", "-h"])
   exit 0
 end
 
-options = begin
-  Fusion::CLI::Options.parse(ARGV)
+begin
+  options = Fusion::CLI::Options.parse(ARGV)
+  Fusion::CLI.run(options)
 rescue Fusion::CLI::Options::UsageError => err
-  # A command-line misuse happens before the input/output contract begins, so
-  # it is plain text on stderr, not a payloaded error.
+  # A command-line misuse is plain text on stderr, not a payloaded Fusion error,
+  # whether caught while parsing options or early during execution, e.g. by
+  # detecting empty stdin plus "-!".
   abort("fusion: #{err.message}\n\n#{Fusion::CLI::Options::USAGE}")
 end
-
-Fusion::CLI.run(options)

data/lib/fusion/ast.rb

@@ -48,10 +48,11 @@ module Fusion
       })
       FuncLit   = TypedData.define(clauses: ->(v) { v.is_a?(Array) && v.all? { |c| Clause === c } }) # [] = the empty function
       Ident     = TypedData.define(name: Identifier)                                                 # read a builtin/bound name
-      FileRef   = TypedData.define(variety: ->(v) { %i[self name path].include?(v) }, path: ->(v) { String === v || v.nil? })
+      FileRef   = TypedData.define(variety: ->(v) { %i[self super super_name name path].include?(v) }, path: ->(v) { String === v || v.nil? })
       Pipe      = TypedData.define(left: Expression, right: Expression)                              # left | right
       Member    = TypedData.define(obj: Expression, key: Identifier)                                 # obj.key
       Index     = TypedData.define(obj: Expression, idx: Expression)                                 # obj[expr]
+      IndexSet  = TypedData.define(obj: Expression, idx: Expression, value: Expression)              # obj[expr = expr]
 
       constants.each do |name|
         node = const_get(name)

data/lib/fusion/cli/decoder.rb

@@ -10,9 +10,9 @@ module Fusion
     module Decoder
       extend self
 
-      ENVELOPE_SHAPES = {
-        array: "[0, _] or [1, _]",
-        object: '{"value": _} or {"error": _}',
+      EXPECTED_ENVELOPE_SHAPES = {
+        array: ["[0, _]", "[1, _]"],
+        object: ['{"value": _}', '{"error": _}'],
       }.freeze
 
       # String -> WirePair
@@ -50,6 +50,10 @@ module Fusion
         return WirePair.new(status: 0, data: text) unless stripped.start_with?("!")
 
         payload = stripped.delete_prefix("!")
+        # TODO: BUG? should we really convert "" to "null"?
+        # Feels inconsistent with '-!' flag, but might be slightly different case.
+        # Also, definitely inconsistent with non-error case above.
+        # Also, the "!" == "!null" leniency holds only in code, not in input/output JSON.
         WirePair.new(status: 1, data: payload.strip.empty? ? "null" : payload)
       end
 
@@ -65,10 +69,11 @@ module Fusion
 
         WirePair.new(status: 1, data: JSON.generate(
           "kind" => "argument_error",
-          "location" => "input",
+          "origin" => "input",
           "operation" => "decoding input",
+          "status" => 0,
           "input" => raw,
-          "message" => "expected #{ENVELOPE_SHAPES.fetch(mode)}"
+          "expected" => EXPECTED_ENVELOPE_SHAPES.fetch(mode)
         ))
       rescue JSON::ParserError
         # TODO: BUG ???

data/lib/fusion/cli/options.rb

@@ -6,8 +6,11 @@
 # Output: Options (use case, input/output modes, program, input)
 #
 # A misuse of the command line is a UsageError, reported as plain text on
-# stderr by exe/fusion — it happens before the input/output contract begins,
-# so it is not a payloaded Fusion error.
+# stderr by exe/fusion, never a payloaded Fusion error. Most surface here while
+# parsing options; `-!` with empty stdin is the one caught later, while reading
+# input.
+
+require "optparse"
 
 module Fusion
   module CLI
@@ -15,104 +18,178 @@ module Fusion
       class UsageError < StandardError; end
 
       USAGE = <<~TEXT
-        usage: fusion [options] <file.fsn> [json-input]
-               fusion [options] -e '<source>' [json-input]
+        usage: fusion [options] <file.fsn>
+               fusion [options] -e '<source>'
                fusion --repl
 
-        use cases:
-          (default)       pipe: apply the program to one input
-          --stream        apply the program to each line of an NDJSON stream
-          --repl          interactive expressions and `identifier = expression`
+        use cases (default: --repl with no arguments, otherwise --pipe):
+          -p, --pipe      apply the program to stdin; with no input, the
+                          program's own value is the result
+          -s, --stream    apply the program to each line of an NDJSON stream
+          -r, --repl      interactive expressions and `identifier = expression`
 
         options:
-          -e '<source>'   inline program instead of a file
-          --input MODE    how the input marks an error value
-          --output MODE   how the output marks an error value
+          -e, --execute '<source>'
+                          inline program instead of a file
+          -i, --input MODE
+                          how the input marks an error value
+          -o, --output MODE
+                          how the output marks an error value
+          -j, --jail DIR  confine @-references to DIR and its subtree
+                          (default: the program's directory; the stdlib is
+                          always reachable, stdin never contains @-references;
+                          use '*' to disable confinement)
           -!              treat the input as an error value (unix input mode only)
+          -b, --skip-blank-lines
+                          drop blank input lines instead of echoing them (--stream only)
 
         modes: unix, bang, array, object
           unix    pipe only (default there): plain JSON; output: stdout/exit 0
                   for values, stderr/exit 1 for error payloads
-          bang    a leading "!" marks an error value (default for --stream)
-          array   [0, value] marks a value, [1, payload] an error
+          bang    a leading "!" marks an error value; cheapest encoding, but not
+                  valid JSON — prefer it only between Fusion programs
+          array   [0, value] marks a value, [1, payload] an error (default for --stream)
           object  {"value": _} marks a value, {"error": _} an error
       TEXT
 
       MODES = %w[unix bang array object].freeze
 
-      attr_reader :use_case, :input_mode, :output_mode, :inline_source, :program_path, :explicit_input
+      attr_reader :use_case, :input_mode, :output_mode, :inline_source, :program_path, :jail
 
-      def initialize(use_case:, input_mode:, output_mode:, inline_source:, program_path:, explicit_input:, error_input:)
+      def initialize(use_case:, input_mode:, output_mode:, inline_source:, program_path:, error_input:, skip_blank_lines:, jail:)
         @use_case = use_case
         @input_mode = input_mode
         @output_mode = output_mode
         @inline_source = inline_source
         @program_path = program_path
-        @explicit_input = explicit_input
         @error_input = error_input
+        @skip_blank_lines = skip_blank_lines
+        @jail = jail
       end
 
       def error_input?
         @error_input
       end
 
+      def skip_blank_lines?
+        @skip_blank_lines
+      end
+
       def self.parse(argv)
-        arguments = argv.dup
-        use_case = :pipe
-        input_mode = nil
-        output_mode = nil
+        pipe = false
+        stream = false
+        repl = false
+        input_modes = []
+        output_modes = []
         error_input = false
+        skip_blank_lines = false
         inline_source = nil
-        positional = []
-
-        until arguments.empty?
-          argument = arguments.shift
-          case argument
-          when "--stream" then use_case = :stream
-          when "--repl" then use_case = :repl
-          when "--input" then input_mode = shift_mode(arguments, "--input")
-          when "--output" then output_mode = shift_mode(arguments, "--output")
-          when "-!" then error_input = true
-          when "-e"
-            inline_source = arguments.shift
-            raise UsageError, "-e requires a source argument" if inline_source.nil?
-          when /\A--/
-            raise UsageError, "unknown option #{argument}"
-          else
-            # Anything else is positional. A single leading "-" stays positional
-            # so negative numbers work as the json-input argument: fusion f.fsn -5
-            positional << argument
-          end
+        jail = nil
+
+        parser = OptionParser.new do |option|
+          option.on("-p", "--pipe") { pipe = true }
+          option.on("-s", "--stream") { stream = true }
+          option.on("-r", "--repl") { repl = true }
+          option.on("-i", "--input MODE") { |mode| input_modes << check_mode!(mode, "--input") }
+          option.on("-o", "--output MODE") { |mode| output_modes << check_mode!(mode, "--output") }
+          option.on("-e", "--execute SOURCE") { |source| inline_source = source }
+          option.on("-j", "--jail DIR") { |dir| jail = dir }
+          option.on("-!") { error_input = true }
+          option.on("-b", "--skip-blank-lines") { skip_blank_lines = true }
+        end
+        parser.require_exact = true # no abbreviations: "--s" is not a stand-in for "--stream"
+
+        # Whatever survives option parsing is positional: the program path.
+        positional = run_parser(parser, argv)
+
+        use_case = resolve_use_case(pipe: pipe, stream: stream, repl: repl, no_arguments: argv.empty?)
+        input_mode = resolve_mode(input_modes, "--input")
+        output_mode = resolve_mode(output_modes, "--output")
+
+        validate(use_case, input_mode, output_mode, error_input, skip_blank_lines, inline_source, jail, positional)
+      end
+
+      # Collapse the use-case flags into one use case; more than one is a misuse.
+      # With none: a bare `fusion` (no arguments) starts the REPL, while any other
+      # invocation is a pipe run.
+      def self.resolve_use_case(pipe:, stream:, repl:, no_arguments:)
+        selected = [(:pipe if pipe), (:stream if stream), (:repl if repl)].compact
+
+        case selected.length
+        when 0 then no_arguments ? :repl : :pipe
+        when 1 then selected.first
+        else raise UsageError, "choose one use case: --pipe, --stream, or --repl"
+        end
+      end
+
+      # The single mode for one direction, or nil if unset. Repeats of the same
+      # mode are fine; two different modes for the same flag are a misuse.
+      def self.resolve_mode(modes, flag)
+        distinct = modes.uniq
+
+        case distinct.length
+        when 0 then nil
+        when 1 then distinct.first
+        else raise UsageError, "conflicting #{flag} modes: #{distinct.join(', ')}"
         end
+      end
 
-        validate(use_case, input_mode, output_mode, error_input, inline_source, positional)
+      # Run OptionParser, translating its parse errors into our UsageError so
+      # exe/fusion reports them as plain usage text (never a payloaded error).
+      def self.run_parser(parser, argv)
+        parser.parse(argv)
+      rescue OptionParser::InvalidOption => error
+        raise UsageError, "unknown option #{error.args.join(' ')}"
+      rescue OptionParser::MissingArgument => error
+        raise UsageError, missing_argument_message(error.args.first)
+      rescue OptionParser::ParseError => error
+        raise UsageError, error.message
+      end
+
+      # A MODE value -> its symbol, or a UsageError naming the valid modes.
+      def self.check_mode!(value, flag)
+        return value.to_sym if MODES.include?(value)
+
+        raise UsageError, "#{flag} expects one of: #{MODES.join(', ')} (got #{value})"
+      end
+
+      # Mirror the old per-flag wording when a value-taking option has no value.
+      # OptionParser reports whichever alias the user typed, so match both.
+      def self.missing_argument_message(flag)
+        case flag
+        when "-e", "--execute" then "-e/--execute requires a source argument"
+        when "-i", "--input" then "--input expects one of: #{MODES.join(', ')} (got nothing)"
+        when "-o", "--output" then "--output expects one of: #{MODES.join(', ')} (got nothing)"
+        when "-j", "--jail" then "-j/--jail requires a directory argument"
+        else "#{flag} requires an argument"
+        end
       end
 
       # Check the flag combination against the use case and fill in defaults.
-      def self.validate(use_case, input_mode, output_mode, error_input, inline_source, positional)
+      def self.validate(use_case, input_mode, output_mode, error_input, skip_blank_lines, inline_source, jail, positional)
+        raise UsageError, "--skip-blank-lines is only for --stream" if skip_blank_lines && use_case != :stream
+
         case use_case
         when :repl
           unless input_mode.nil? && output_mode.nil? && !error_input && inline_source.nil? && positional.empty?
             raise UsageError, "--repl takes no program, no input, and no modes"
           end
-          program_path = explicit_input = nil
+          program_path = nil
         when :stream
-          input_mode ||= :bang
-          output_mode ||= :bang
+          input_mode ||= :array
+          output_mode ||= :array
           raise UsageError, "--stream does not support the unix mode" if input_mode == :unix || output_mode == :unix
           raise UsageError, "-! requires the unix input mode" if error_input
           program_path = inline_source ? nil : positional.shift
           raise UsageError, "missing program (a .fsn file or -e)" unless inline_source || program_path
-          raise UsageError, "--stream reads its input from stdin, not an argument" unless positional.empty?
-          explicit_input = nil
+          raise UsageError, "too many positional arguments" unless positional.empty?
         when :pipe
           input_mode ||= :unix
           output_mode ||= :unix
           raise UsageError, "-! requires the unix input mode" if error_input && input_mode != :unix
           program_path = inline_source ? nil : positional.shift
           raise UsageError, "missing program (a .fsn file or -e)" unless inline_source || program_path
-          explicit_input = positional.shift
-          raise UsageError, "too many arguments: #{positional.join(' ')}" unless positional.empty?
+          raise UsageError, "too many positional arguments" unless positional.empty?
         else
           raise Unreachable, "Unknown use case #{use_case}"
         end
@@ -123,20 +200,13 @@ module Fusion
           output_mode: output_mode,
           inline_source: inline_source,
           program_path: program_path,
-          explicit_input: explicit_input,
-          error_input: error_input
+          error_input: error_input,
+          skip_blank_lines: skip_blank_lines,
+          jail: jail
         )
       end
 
-      def self.shift_mode(arguments, flag)
-        mode = arguments.shift
-        unless MODES.include?(mode)
-          raise UsageError, "#{flag} expects one of: #{MODES.join(', ')} (got #{mode.nil? ? 'nothing' : mode})"
-        end
-        mode.to_sym
-      end
-
-      private_class_method :validate, :shift_mode
+      private_class_method :validate, :resolve_use_case, :resolve_mode, :run_parser, :check_mode!, :missing_argument_message
     end
   end
 end

data/lib/fusion/cli/parser.rb

@@ -14,10 +14,10 @@ module Fusion
         value = convert(JSON.parse(wire_pair.data))
         wire_pair.status == 1 ? Interpreter::ErrorVal.new(value) : value
       rescue JSON::ParserError
-        Interpreter::ErrorVal.internal(
+        Interpreter::ErrorVal.from_runtime(
           kind: "syntax_error",
-          location: "input",
-          operation: "parsing input as JSON",
+          origin: "input",
+          operation: "parsing JSON",
           input: wire_pair.data,
           message: "input is not valid JSON"
         )

data/lib/fusion/cli/repl.rb

@@ -9,21 +9,35 @@ require_relative "../interpreter/env"
 module Fusion
   module CLI
     class Repl
-      PROMPT = "fsn> "
-      CONTINUATION_PROMPT = "...> "
+      RESET      = "\e[0m"
+      LIGHT_BLUE = "\e[94m"
+      GREEN      = "\e[32m"
+      RED        = "\e[31m"
 
-      # REPL entries report errors with the same location as inline (`-e`) code.
-      LOCATION = "code <inline>"
+      PROMPT              = "#{LIGHT_BLUE}fsn> #{RESET}"
+      CONTINUATION_PROMPT = "#{LIGHT_BLUE}...> #{RESET}"
+      VALUE_MARKER        = "#{GREEN}✔ #{RESET}"
+      ERROR_MARKER        = "#{RED}✗ #{RESET}"
+
+      # REPL entries report errors with the same site as inline (`-e`) code.
+      SITE = { origin: "code", file: "<inline>" }.freeze
+
+      def initialize(root_env:)
+        @root_env = root_env
+      end
 
       def run
+        CLI.prepare!
+
         require "reline"
-        $stdout.sync = true
         Reline.output = $stderr
         Reline.prompt_proc = proc do |lines|
           lines.each_index.map { |i| i.zero? ? PROMPT : CONTINUATION_PROMPT }
         end
 
-        environment = Interpreter::Env.new.define("__dir__", Dir.pwd)
+        # The session env is a child of the run's root, so it carries the jail;
+        # bindings accumulate here while loaded files stay isolated at the root.
+        environment = @root_env.child.set_context(:dir, Dir.pwd)
 
         loop do
           buffer = begin
@@ -36,38 +50,29 @@ module Fusion
           break if buffer.nil? # Ctrl-D on an empty line ends the session
           next if buffer.strip.empty?
 
-          $stdout.puts(handle(buffer, environment))
+          output = handle(buffer, environment)
+
+          marker = output.start_with?("!") ? ERROR_MARKER : VALUE_MARKER
+          $stderr.print(marker) # decoration on stderr
+          $stdout.puts(output)  # the clean value on stdout
         end
       end
 
+      # String -> yes/no
       def complete?(buffer)
         return true if buffer.strip.empty?
 
-        ast = Fusion::Parser.parse_repl(buffer, location: LOCATION)
+        ast = Fusion::Parser.parse_repl(buffer, site: SITE)
         ast.is_a?(AST::Expression) || ast.is_a?(AST::Statement::Assignment)
       end
 
+      # String (+ Env) -> String
       def handle(buffer, environment)
-        ast = Fusion::Parser.parse_repl(buffer, location: LOCATION)
-        runtime_value = evaluate(ast, environment)
+        ast = Fusion::Parser.parse_repl(buffer, site: SITE)
+        runtime_value = CLI.evaluate(ast, environment)
         wire_pair = Serializer.serialize(runtime_value, lenient: true)
         Encoder.encode(wire_pair, mode: :bang)
       end
-
-      private
-
-      def evaluate(ast, environment)
-        case ast
-        when AST::Expression
-          Interpreter.safe_evaluate(ast, environment)
-        when AST::Statement::Assignment
-          value = Interpreter.safe_evaluate(ast.expression, environment)
-          environment.define(ast.name, value)
-          value
-        else
-          raise Unreachable, "Unhandled AST node #{ast.class}"
-        end
-      end
     end
   end
 end