aura-lang 1.3.0

data/lib/aura/diagnostics.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Aura
+  # Raised when source text cannot be parsed. Carries the line/column of the
+  # failure plus a rendered snippet with a caret, so users get a real
+  # diagnostic instead of a raw Parslet backtrace.
+  class ParseError < StandardError
+    attr_reader :line, :column
+
+    def initialize(message, line: nil, column: nil)
+      @line = line
+      @column = column
+      super(message)
+    end
+  end
+
+  # Raised by the semantic analysis pass for problems a grammar cannot catch,
+  # e.g. training/serving a model that was never defined.
+  class SemanticError < StandardError; end
+
+  # Raised when a deployment target can't host the generated app -- e.g. asking
+  # to deploy a Torch model server to Vercel's serverless runtime.
+  class DeployError < StandardError; end
+
+  # Turns Parslet's internal failure cause tree into a human-friendly
+  # Aura::ParseError with line/column information and a source snippet.
+  module Diagnostics
+    module_function
+
+    # @param error  [Parslet::ParseFailed]
+    # @param source [String] the original source text
+    # @return [Aura::ParseError]
+    def from_parslet(error, source)
+      cause = deepest_cause(error.parse_failure_cause)
+      line, column = location_for(cause)
+      message = +"Parse error"
+      message << " at line #{line}, column #{column}" if line
+      message << ": #{cause.to_s}" if cause
+      snippet = snippet_for(source, line, column)
+      message << "\n\n#{snippet}" if snippet
+      ParseError.new(message, line: line, column: column)
+    end
+
+    # Walk to the most specific (deepest) cause so the reported position points
+    # at the actual offending token rather than the top-level rule.
+    def deepest_cause(cause)
+      return nil unless cause
+
+      current = cause
+      while current.respond_to?(:children) && current.children && !current.children.empty?
+        # Prefer the child with the furthest source position.
+        current = current.children.max_by { |c| position_of(c) || -1 }
+      end
+      current
+    end
+
+    def location_for(cause)
+      return [nil, nil] unless cause && cause.respond_to?(:source) && cause.source
+
+      pos = cause.respond_to?(:pos) ? cause.pos : nil
+      return [nil, nil] unless pos
+
+      line, column = cause.source.line_and_column(pos)
+      [line, column]
+    rescue StandardError
+      [nil, nil]
+    end
+
+    def position_of(cause)
+      cause.respond_to?(:pos) && cause.pos ? cause.pos.bytepos : nil
+    rescue StandardError
+      nil
+    end
+
+    def snippet_for(source, line, column)
+      return nil unless line && column
+
+      src_line = source.lines[line - 1]
+      return nil unless src_line
+
+      src_line = src_line.chomp
+      caret = "#{' ' * (column - 1)}^"
+      "  #{src_line}\n  #{caret}"
+    end
+  end
+end

data/lib/aura/docker.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aura
+  # Generates production deployment assets next to an .aura file: the
+  # transpiled standalone Ruby app, a Dockerfile, and a .dockerignore. Backs
+  # the `aura deploy` command.
+  module Docker
+    module_function
+
+    def build(filename)
+      source = File.read(filename)
+      ruby_code = Aura.transpile(source)
+      torch_app = ruby_code.include?("Torch::") # ML app needs torch-rb + LibTorch
+
+      dir  = File.dirname(filename)
+      base = File.basename(filename, ".aura")
+      app_file = File.join(dir, "#{base}.rb")
+
+      File.write(app_file, ruby_code)
+      File.write(File.join(dir, "Dockerfile"), dockerfile("#{base}.rb", torch: torch_app))
+      File.write(File.join(dir, ".dockerignore"), dockerignore)
+
+      puts "Generated deployment assets:"
+      puts "   - #{app_file}"
+      puts "   - #{File.join(dir, 'Dockerfile')}"
+      puts "   - #{File.join(dir, '.dockerignore')}"
+      puts "   Build with: docker build -t #{base} #{dir.empty? ? '.' : dir}"
+      puts "   NOTE: Torch apps need LibTorch in the image -- see the Dockerfile comment." if torch_app
+    end
+
+    def dockerfile(app_file, torch: false)
+      gems = "sinatra puma json dotenv"
+      gems += " torch-rb torchvision red-datasets" if torch
+      libtorch = +""
+      if torch
+        libtorch = <<~TORCH
+
+          # Torch apps need LibTorch (the native PyTorch C++ library). The simplest
+          # path is to base the image on one that already bundles it, or download it:
+          #   ENV LIBTORCH /opt/libtorch
+          #   RUN curl -L https://download.pytorch.org/libtorch/cpu/libtorch-cxx11-abi-shared-with-deps-latest.zip -o /tmp/lt.zip \\
+          #     && unzip /tmp/lt.zip -d /opt && rm /tmp/lt.zip
+          # Then build torch-rb against it: gem install torch-rb -- --with-torch-dir=$LIBTORCH
+        TORCH
+      end
+
+      <<~DOCKER
+        # Generated by Aura v#{Aura::VERSION}
+        FROM ruby:3.3-slim
+
+        WORKDIR /app
+
+        RUN apt-get update -qq \\
+          && apt-get install -y --no-install-recommends build-essential#{torch ? ' curl unzip' : ''} \\
+          && rm -rf /var/lib/apt/lists/*
+        #{libtorch}
+        RUN gem install #{gems}
+
+        COPY . .
+
+        ENV RACK_ENV=production
+        EXPOSE 3000
+
+        CMD ["ruby", "#{app_file}"]
+      DOCKER
+    end
+
+    def dockerignore
+      <<~IGNORE
+        .git
+        *.aura
+        models/*.pth
+        data/
+        tmp/
+        *.log
+      IGNORE
+    end
+  end
+end

data/lib/aura/emitter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Aura
+  # A tiny indentation-aware code builder. Replaces ad-hoc string
+  # concatenation in the code generator so emitted Ruby is consistently
+  # indented and blocks are hard to leave unbalanced.
+  #
+  #   e = Emitter.new
+  #   e.line "x = 1"
+  #   e.block("def forward(x)") { e.line "x" }
+  #   e.to_s
+  #
+  class Emitter
+    INDENT = "  "
+
+    def initialize
+      @lines = []
+      @depth = 0
+    end
+
+    # Append a line (or several "\n"-separated lines) at the current indent.
+    def line(text = "")
+      text.to_s.split("\n", -1).each do |raw|
+        @lines << (raw.empty? ? "" : "#{INDENT * @depth}#{raw}")
+      end
+      self
+    end
+
+    # Append a blank line.
+    def blank
+      @lines << ""
+      self
+    end
+
+    # Append a comment line.
+    def comment(text)
+      line("# #{text}")
+    end
+
+    # Emit `header` then an indented body produced by the block, then `footer`
+    # (defaults to `end`). Used for classes, methods, and Ruby blocks.
+    def block(header, footer = "end")
+      line(header)
+      indent { yield self }
+      line(footer)
+      self
+    end
+
+    # Increase indentation for the duration of the block.
+    def indent
+      @depth += 1
+      yield self
+    ensure
+      @depth -= 1
+    end
+
+    def to_s
+      "#{@lines.join("\n")}\n"
+    end
+  end
+end

data/lib/aura/parser.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Aura
+  # PEG grammar for the Aura DSL, built on Parslet. The grammar is whitespace-
+  # and blank-line tolerant; full-line `#` comments are stripped (and replaced
+  # by blank lines, preserving line numbers) before parsing -- see
+  # Aura.preprocess in lib/aura.rb.
+  class Parser < Parslet::Parser
+    # ---- lexical -------------------------------------------------------------
+    rule(:sp)  { match('[ \t]').repeat }
+    rule(:sp1) { match('[ \t]').repeat(1) }
+    rule(:nl)  { str("\r\n") | str("\n") | str("\r") }
+    # End of a content line: trailing spaces then a newline (or end of input).
+    rule(:eol) { sp >> (nl | any.absent?) }
+    # Zero or more whitespace-only lines.
+    rule(:blank_lines) { (sp >> nl).repeat }
+
+    rule(:identifier) { match('[a-zA-Z_]') >> match('[a-zA-Z0-9_]').repeat }
+    # Double-quoted string; `\X` escape pairs are consumed as a unit so a `\"`
+    # does not terminate the literal (unescaped by the Transformer).
+    rule(:string) do
+      str('"') >> ((str("\\") >> any) | (str('"').absent? >> any)).repeat.as(:str) >> str('"')
+    end
+    # Integer/float with optional leading sign and scientific notation
+    # (e.g. `-5`, `0.001`, `1e-4`, `3.2E+5`).
+    rule(:number) do
+      (str("-").maybe >> match('[0-9]').repeat(1) >>
+        (str(".") >> match('[0-9]').repeat(1)).maybe >>
+        (match('[eE]') >> match('[-+]').maybe >> match('[0-9]').repeat(1)).maybe).as(:number)
+    end
+    rule(:symbol)  { str(":") >> identifier.as(:sym) }
+    rule(:boolean) { (str("true") | str("false")).as(:bool) }
+    rule(:value)   { string | number | boolean | symbol }
+
+    # Comma separator that tolerates surrounding spaces.
+    rule(:comma) { sp >> str(",") >> sp }
+
+    # ---- helpers -------------------------------------------------------------
+    # A `do ... end` block whose body is zero or more `line_atom`s (blank lines
+    # between them are skipped). The collected lines are captured under `key`.
+    def block_body(line_atom, key)
+      str("do") >> eol >>
+        (blank_lines >> line_atom).repeat.as(key) >>
+        blank_lines >> sp >> str("end")
+    end
+
+    # ---- program -------------------------------------------------------------
+    rule(:program) { blank_lines >> (statement >> blank_lines).repeat >> sp }
+    rule(:statement) do
+      dataset_stmt | env_stmt | model_stmt | train_stmt |
+        evaluate_stmt | route_stmt | run_stmt
+    end
+    root :program
+
+    # ---- dataset -------------------------------------------------------------
+    rule(:dataset_stmt) do
+      str("dataset") >> sp1 >> string.as(:ds_name) >> sp1 >>
+        str("from") >> sp1 >> identifier.as(:ds_source) >> sp1 >> string.as(:ds_path) >>
+        (sp1 >> block_body(dataset_option, :ds_options)).maybe >> eol
+    end
+    rule(:dataset_option) do
+      sp >> identifier.as(:opt_key) >> sp1 >> value.as(:opt_value) >> eol
+    end
+
+    # ---- environment ---------------------------------------------------------
+    rule(:env_stmt) do
+      str("environment") >> sp1 >> identifier.as(:env_name) >> sp1 >>
+        block_body(env_line, :env_body) >> eol
+    end
+    rule(:env_line) do
+      sp >> identifier.as(:env_key) >> sp1 >> value.as(:env_value) >> eol
+    end
+
+    # ---- model ---------------------------------------------------------------
+    rule(:model_stmt) do
+      str("model") >> sp1 >> identifier.as(:model_name) >> sp1 >> (
+        (str("neural_network") >> sp1 >> block_body(model_line, :nn_body)) |
+        (str("from") >> sp1 >> identifier.as(:provider) >> sp1 >> string.as(:model_id) >>
+          (sp1 >> block_body(llm_option, :llm_body)).maybe) |
+        (str("transfer") >> sp1 >> str("from") >> sp1 >> symbol.as(:base_model) >>
+          (sp1 >> block_body(model_line, :nn_body)).maybe)
+      ) >> eol
+    end
+
+    # Optional config inside `model x from openai "id" do ... end`.
+    rule(:llm_option) do
+      sp >> (str("end") >> eol).absent? >> (
+        (str("system") >> sp1 >> string.as(:llm_system)) |
+        (str("temperature") >> sp1 >> number.as(:llm_temperature)) |
+        (str("max_tokens") >> sp1 >> number.as(:llm_max_tokens))
+      ) >> eol
+    end
+
+    rule(:model_line) do
+      sp >> (
+        m_input_shape | m_input_text | m_conv | m_maxpool | m_batchnorm |
+        m_flatten | m_embedding | m_lstm | m_gru | m_dense | m_dropout |
+        m_output | m_greeting | m_load | m_save | m_freeze | m_unfreeze
+      ) >> eol
+    end
+
+    rule(:m_embedding) do
+      str("layer") >> sp1 >> str("embedding") >> sp1 >>
+        str("vocab:") >> sp1 >> number.as(:embed_vocab) >> comma >>
+        str("dim:") >> sp1 >> number.as(:embed_dim)
+    end
+    rule(:m_lstm) do
+      str("layer") >> sp1 >> str("lstm") >> sp1 >> str("units:") >> sp1 >> number.as(:lstm_units)
+    end
+    rule(:m_gru) do
+      str("layer") >> sp1 >> str("gru") >> sp1 >> str("units:") >> sp1 >> number.as(:gru_units)
+    end
+
+    rule(:m_input_shape) do
+      str("input") >> sp1 >> str("shape(") >> sp >>
+        (number >> comma.maybe).repeat(1).as(:input_shape) >> sp >> str(")") >>
+        (sp1 >> block_body(input_transform, :input_transforms)).maybe
+    end
+    # A preprocessing directive inside an `input shape(...) do ... end` block,
+    # e.g. `resize 28` or `to_tensor`. The `end`-line guard stops the value-less
+    # form from swallowing the block terminator.
+    rule(:input_transform) do
+      sp >> (str("end") >> eol).absent? >> identifier.as(:tf_key) >>
+        (sp1 >> value.as(:tf_value)).maybe >> eol
+    end
+    rule(:m_input_text) { str("input") >> sp1 >> str("text").as(:input_text) }
+    rule(:m_conv) do
+      str("layer") >> sp1 >> str("conv2d") >> sp1 >>
+        str("filters:") >> sp1 >> number.as(:conv_filters) >> comma >>
+        str("kernel:") >> sp1 >> number.as(:conv_kernel)
+    end
+    rule(:m_maxpool) do
+      str("layer") >> sp1 >> str("maxpool2d") >> sp1 >> str("size:") >> sp1 >> number.as(:pool_size)
+    end
+    rule(:m_batchnorm) { str("layer") >> sp1 >> str("batchnorm").as(:batchnorm) }
+    rule(:m_flatten)   { str("layer") >> sp1 >> str("flatten").as(:flatten) }
+    rule(:m_dense) do
+      str("layer") >> sp1 >> str("dense") >> sp1 >> str("units:") >> sp1 >> number.as(:dense_units) >>
+        (comma >> str("activation:") >> sp1 >> symbol.as(:dense_activation)).maybe
+    end
+    rule(:m_dropout) do
+      str("layer") >> sp1 >> str("dropout") >> sp1 >> str("rate:") >> sp1 >> number.as(:dropout_rate)
+    end
+    rule(:m_output) do
+      str("output") >> sp1 >> str("units:") >> sp1 >> number.as(:out_units) >>
+        comma >> str("activation:") >> sp1 >> symbol.as(:out_activation)
+    end
+    rule(:m_greeting) do
+      str("output") >> sp1 >> str("greeting") >> sp1 >> string.as(:greeting)
+    end
+    rule(:m_save) do
+      str("save") >> sp1 >> str("weights") >> sp1 >> str("to") >> sp1 >> string.as(:save_path)
+    end
+    rule(:m_load) do
+      str("load") >> sp1 >> str("weights") >> sp1 >> str("from") >> sp1 >> string.as(:load_path)
+    end
+    rule(:m_freeze) do
+      str("freeze") >> sp1 >> str("until") >> sp1 >> symbol.as(:freeze_until)
+    end
+    rule(:m_unfreeze) { str("unfreeze") >> sp1 >> str("all").as(:unfreeze_all) }
+
+    # ---- train ---------------------------------------------------------------
+    rule(:train_stmt) do
+      str("train") >> sp1 >> identifier.as(:tr_model) >> sp1 >> str("on") >> sp1 >>
+        string.as(:tr_dataset) >> sp1 >> block_body(train_option, :tr_body) >> eol
+    end
+    rule(:train_option) do
+      sp >> (
+        (str("epochs") >> sp1 >> number.as(:epochs)) |
+        (str("batch_size") >> sp1 >> number.as(:batch_size)) |
+        (str("optimizer") >> sp1 >> symbol.as(:optimizer) >>
+          (comma >> str("learning_rate:") >> sp1 >> number.as(:lr)).maybe) |
+        (str("scheduler") >> sp1 >> symbol.as(:scheduler)) |
+        (str("loss") >> sp1 >> symbol.as(:loss)) |
+        (str("metrics") >> sp1 >> symbol.as(:metrics))
+      ) >> eol
+    end
+
+    # ---- evaluate ------------------------------------------------------------
+    rule(:evaluate_stmt) do
+      str("evaluate") >> sp1 >> identifier.as(:ev_model) >> sp1 >> str("on") >> sp1 >>
+        string.as(:ev_dataset) >> eol
+    end
+
+    # ---- route ---------------------------------------------------------------
+    rule(:route_stmt) do
+      str("route") >> sp1 >> string.as(:rt_path) >> sp1 >> identifier.as(:rt_method) >> sp1 >>
+        block_body(route_line, :rt_body) >> eol
+    end
+    rule(:route_line) do
+      sp >> (route_output | route_auth) >> eol
+    end
+    rule(:route_output) do
+      str("output prediction from") >> sp1 >> identifier.as(:route_model) >>
+        str(".predict(") >> identifier.as(:route_input) >> str(")") >>
+        (sp1 >> str("as") >> sp1 >> symbol.as(:route_as)).maybe >>
+        (sp1 >> str("format") >> sp1 >> symbol.as(:route_format)).maybe
+    end
+    rule(:route_auth) do
+      str("authenticate with") >> sp1 >> symbol.as(:auth)
+    end
+
+    # ---- run -----------------------------------------------------------------
+    rule(:run_stmt) { str("run web on port:") >> sp1 >> number.as(:port) >> eol }
+  end
+end

data/lib/aura/transformer.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Aura
+  # Pure helper functions for assembling semantic node hashes. Kept in a module
+  # (rather than Transformer instance methods) because Parslet::Transform
+  # evaluates rule blocks in their own context where instance methods aren't in
+  # scope -- constants like `Aura::Nodes` always are.
+  module Nodes
+    module_function
+
+    def list(value)
+      value.is_a?(Array) ? value : [value]
+    end
+
+    # Keep only real node hashes, discarding whitespace slices that Parslet may
+    # leave in a repeated body.
+    def clean(body)
+      list(body).select { |x| x.is_a?(Hash) }
+    end
+
+    def model(name, body)
+      layers = clean(body)
+      if layers.any? { |l| %i[greeting input_text].include?(l[:type]) }
+        greeting = layers.find { |l| l[:type] == :greeting }
+        { type: :model, kind: :text, name: name.to_s, layers: layers,
+          greeting: (greeting && greeting[:text]) || "Hello from Aura!" }
+      else
+        { type: :model, kind: :torch, name: name.to_s, layers: layers, torch_model: true }
+      end
+    end
+
+    def transfer(name, base, body)
+      { type: :model, kind: :transfer, name: name.to_s, base_model: base, layers: clean(body) }
+    end
+
+    def llm(name, provider, model_id, body)
+      cfg = clean(body).each_with_object({}) { |h, acc| acc.merge!(h) }
+      { type: :model, kind: :llm, name: name.to_s, provider: provider.to_s.to_sym,
+        model_id: model_id.to_s, system: cfg[:system],
+        temperature: cfg[:temperature], max_tokens: cfg[:max_tokens] }
+    end
+
+    def train(model, dataset, body)
+      config = clean(body).each_with_object({}) { |opt, h| h.merge!(opt) }
+      { type: :train, model: model.to_s, dataset: dataset.to_s, config: config }
+    end
+
+    def route(path, method, body)
+      lines = clean(body)
+      out   = lines.find { |l| l.key?(:route_model) }
+      auth  = lines.find { |l| l.key?(:auth) }
+      { type: :route, path: path.to_s, method: method.to_s,
+        model:       out && out[:route_model],
+        input_var:   (out && out[:route_input]) || "input",
+        format:      out && out[:route_format],
+        postprocess: out && out[:route_as],
+        auth:        auth && auth[:auth] }
+    end
+
+    def settings(body)
+      clean(body).each_with_object({}) { |kv, h| h.merge!(kv) }
+    end
+
+    def dataset(name, source, path, options)
+      { type: :dataset, name: name.to_s, source: source.to_s, path: path.to_s,
+        options: settings(options) }
+    end
+  end
+
+  # Walks the raw Parslet parse tree and rewrites it into a flat list of
+  # semantic node hashes, each tagged with a :type the code generator switches
+  # on. Numeric leaves are coerced to Integer/Float here (not String) so node
+  # values are directly usable.
+  class Transformer < Parslet::Transform
+    # ---- leaves --------------------------------------------------------------
+    rule(str: simple(:s)) do
+      s.to_s.gsub(/\\(.)/) do
+        case Regexp.last_match(1)
+        when "n" then "\n"
+        when "t" then "\t"
+        else Regexp.last_match(1) # \" -> ", \\ -> \, and any other \X -> X
+        end
+      end
+    end
+    rule(sym: simple(:s))    { s.to_s.to_sym }
+    rule(bool: simple(:b))   { b.to_s == "true" }
+    # Float when it has a decimal point or exponent (1e-4); Integer otherwise
+    # (including signed values like -5).
+    rule(number: simple(:n)) { (x = n.to_s).match?(/[.eE]/) ? x.to_f : x.to_i }
+
+    # ---- model body lines ----------------------------------------------------
+    rule(input_shape: subtree(:s)) { { type: :input, shape: Aura::Nodes.list(s) } }
+    rule(input_shape: subtree(:s), input_transforms: subtree(:t)) { { type: :input, shape: Aura::Nodes.list(s), transforms: Aura::Nodes.clean(t) } }
+    rule(tf_key: simple(:k), tf_value: simple(:v)) { { transform: k.to_s.to_sym, value: v } }
+    rule(tf_key: simple(:k)) { { transform: k.to_s.to_sym } }
+    rule(input_text: simple(:_x))  { { type: :input_text } }
+    rule(conv_filters: simple(:f), conv_kernel: simple(:k)) { { type: :conv2d, filters: f.to_i, kernel: k.to_i } }
+    rule(pool_size: simple(:s))    { { type: :maxpool2d, size: s.to_i } }
+    rule(batchnorm: simple(:_x))   { { type: :batchnorm } }
+    rule(flatten: simple(:_x))     { { type: :flatten } }
+    rule(dense_units: simple(:u), dense_activation: simple(:a)) { { type: :dense, units: u.to_i, activation: a } }
+    rule(dense_units: simple(:u))  { { type: :dense, units: u.to_i, activation: :linear } }
+    rule(dropout_rate: simple(:r)) { { type: :dropout, rate: r.to_f } }
+    rule(out_units: simple(:u), out_activation: simple(:a)) { { type: :output, units: u.to_i, activation: a } }
+    rule(greeting: simple(:g))     { { type: :greeting, text: g.to_s } }
+    rule(save_path: simple(:p))    { { type: :save_weights, path: p.to_s } }
+    rule(load_path: simple(:p))    { { type: :load_weights, path: p.to_s } }
+    rule(freeze_until: simple(:l))  { { type: :freeze, until: l } }
+    rule(unfreeze_all: simple(:_x)) { { type: :unfreeze_all } }
+    rule(embed_vocab: simple(:v), embed_dim: simple(:d)) { { type: :embedding, vocab: v.to_i, dim: d.to_i } }
+    rule(lstm_units: simple(:u)) { { type: :lstm, units: u.to_i } }
+    rule(gru_units: simple(:u))  { { type: :gru, units: u.to_i } }
+
+    # ---- LLM config body lines -----------------------------------------------
+    rule(llm_system: simple(:s))     { { system: s.to_s } }
+    rule(llm_temperature: simple(:t)) { { temperature: t } }
+    rule(llm_max_tokens: simple(:m))  { { max_tokens: m.to_i } }
+
+    # ---- route body lines ----------------------------------------------------
+    rule(route_model: simple(:m), route_input: simple(:i), route_as: simple(:a), route_format: simple(:f)) { { route_model: m.to_s, route_input: i.to_s, route_as: a, route_format: f } }
+    rule(route_model: simple(:m), route_input: simple(:i), route_as: simple(:a)) { { route_model: m.to_s, route_input: i.to_s, route_as: a, route_format: nil } }
+    rule(route_model: simple(:m), route_input: simple(:i), route_format: simple(:f)) { { route_model: m.to_s, route_input: i.to_s, route_format: f } }
+    rule(route_model: simple(:m), route_input: simple(:i)) { { route_model: m.to_s, route_input: i.to_s, route_format: nil } }
+    rule(auth: simple(:a)) { { auth: a } }
+
+    # ---- key/value lines (env + dataset options) -----------------------------
+    rule(env_key: simple(:k), env_value: simple(:v)) { { k.to_s.to_sym => v } }
+    rule(opt_key: simple(:k), opt_value: simple(:v)) { { k.to_s.to_sym => v } }
+
+    # ---- statements ----------------------------------------------------------
+    rule(ds_name: simple(:n), ds_source: simple(:s), ds_path: simple(:p), ds_options: subtree(:o)) { Aura::Nodes.dataset(n, s, p, o) }
+    rule(ds_name: simple(:n), ds_source: simple(:s), ds_path: simple(:p)) { Aura::Nodes.dataset(n, s, p, []) }
+
+    rule(env_name: simple(:n), env_body: subtree(:b)) { { type: :environment, name: n.to_s, settings: Aura::Nodes.settings(b) } }
+
+    rule(model_name: simple(:n), nn_body: subtree(:b)) { Aura::Nodes.model(n, b) }
+    rule(model_name: simple(:n), provider: simple(:pr), model_id: simple(:mid)) { Aura::Nodes.llm(n, pr, mid, []) }
+    rule(model_name: simple(:n), provider: simple(:pr), model_id: simple(:mid), llm_body: subtree(:b)) { Aura::Nodes.llm(n, pr, mid, b) }
+    rule(model_name: simple(:n), base_model: simple(:bm)) { { type: :model, kind: :transfer, name: n.to_s, base_model: bm, layers: [] } }
+    rule(model_name: simple(:n), base_model: simple(:bm), nn_body: subtree(:b)) { Aura::Nodes.transfer(n, bm, b) }
+
+    rule(tr_model: simple(:m), tr_dataset: simple(:d), tr_body: subtree(:b)) { Aura::Nodes.train(m, d, b) }
+
+    rule(ev_model: simple(:m), ev_dataset: simple(:d)) { { type: :evaluate, model: m.to_s, dataset: d.to_s } }
+
+    rule(rt_path: simple(:p), rt_method: simple(:m), rt_body: subtree(:b)) { Aura::Nodes.route(p, m, b) }
+
+    rule(port: simple(:p)) { { type: :run_web, port: p.to_i } }
+  end
+end

data/lib/aura/vercel.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aura
+  # Generates Vercel deployment assets for an .aura file whose generated app is
+  # a stateless Rack app -- i.e. LLM-only (no Torch). Torch model servers need
+  # LibTorch and a long-lived process, which exceed Vercel's serverless limits
+  # (function size, no GPU, short timeouts); for those use `aura deploy`
+  # (Dockerfile) with a container host. Backs `aura deploy <file> --target vercel`.
+  module Vercel
+    module_function
+
+    def build(filename)
+      nodes = Aura.to_nodes(File.read(filename))
+      refuse_torch!(filename) if uses_torch?(nodes)
+      ruby_code = Aura::CodeGen.generate(nodes)
+
+      dir     = File.dirname(filename)
+      base    = File.basename(filename, ".aura")
+      api_dir = File.join(dir, "api")
+      FileUtils.mkdir_p(api_dir)
+
+      app_file   = File.join(dir, "#{base}.rb")
+      index_file = File.join(api_dir, "index.rb")
+      json_file  = File.join(dir, "vercel.json")
+
+      File.write(app_file, ruby_code)
+      File.write(index_file, handler(base))
+      File.write(json_file, vercel_json)
+
+      puts "Generated Vercel assets (LLM-only app):"
+      puts "   - #{app_file}"
+      puts "   - #{index_file}"
+      puts "   - #{json_file}"
+      puts "   Set secrets in the Vercel dashboard (e.g. OPENAI_API_KEY, AURA_API_TOKEN),"
+      puts "   then deploy with: vercel deploy"
+    end
+
+    # Torch is in play when a model is a torch/transfer net, or when the program
+    # trains/evaluates (which pulls in LibTorch + datasets).
+    def uses_torch?(nodes)
+      nodes.any? do |n|
+        (n[:type] == :model && %i[torch transfer].include?(n[:kind])) ||
+          %i[train evaluate].include?(n[:type])
+      end
+    end
+
+    def refuse_torch!(filename)
+      raise DeployError,
+            "This app uses Torch, which exceeds Vercel's serverless limits (LibTorch " \
+            "size, no GPU, short timeouts). Use `aura deploy #{filename}` (Dockerfile) " \
+            "with a container host (Fly.io / Render / Cloud Run) instead."
+    end
+
+    # Vercel's Ruby runtime serves a `Handler` Rack app from api/*.rb. We load
+    # the transpiled app with the classic-Sinatra boot disabled and expose its
+    # Rack application object.
+    def handler(base)
+      <<~RUBY
+        # Generated by Aura v#{Aura::VERSION} -- Vercel Ruby serverless entrypoint.
+        ENV["RACK_ENV"] ||= "production"
+        require_relative "../#{base}"
+
+        # Do not boot a listening server inside the serverless function; Vercel
+        # invokes the Rack app directly.
+        Sinatra::Application.set(:run, false)
+
+        Handler = Sinatra::Application
+      RUBY
+    end
+
+    # Uses the long-standing `@vercel/ruby` builder. Ruby is a community runtime
+    # on Vercel; adjust the builder for your account if the identifier changes.
+    def vercel_json
+      <<~JSON
+        {
+          "builds": [
+            { "src": "api/index.rb", "use": "@vercel/ruby" }
+          ],
+          "routes": [
+            { "src": "/(.*)", "dest": "/api/index.rb" }
+          ]
+        }
+      JSON
+    end
+  end
+end