aura-lang 1.3.0

data/lib/aura/codegen.rb

@@ -0,0 +1,636 @@
+# frozen_string_literal: true
+
+require_relative "emitter"
+
+module Aura
+  # Generates runnable Ruby from the semantic node list. Torch models become
+  # Torch::NN::Module subclasses with a real forward pass (shapes tracked so
+  # Linear in-features are computed correctly); LLM models become HTTP client
+  # methods; routes become classic-Sinatra handlers.
+  class CodeGen
+    OPTIMIZERS = { adam: "Adam", adamw: "AdamW", sgd: "SGD", rmsprop: "RMSprop", adagrad: "Adagrad" }.freeze
+    LOSSES     = { cross_entropy: "CrossEntropyLoss", mse: "MSELoss", bce: "BCELoss",
+                   bce_with_logits: "BCEWithLogitsLoss", nll: "NLLLoss" }.freeze
+    SCHEDULERS = { step_lr: "StepLR", exponential_lr: "ExponentialLR",
+                   cosine_annealing_lr: "CosineAnnealingLR" }.freeze
+
+    def self.generate(nodes)
+      new(nodes).generate
+    end
+
+    def initialize(nodes)
+      @nodes = nodes
+      @e = Emitter.new
+      @registry = build_registry
+    end
+
+    def generate
+      header
+      @nodes.each { |node| emit(node) }
+      @e.to_s
+    end
+
+    private
+
+    def build_registry
+      @nodes.select { |n| n[:type] == :model }
+            .each_with_object({}) { |m, h| h[m[:name]] = m }
+    end
+
+    def llm?
+      @registry.values.any? { |m| m[:kind] == :llm }
+    end
+
+    def transfer?
+      @registry.values.any? { |m| m[:kind] == :transfer }
+    end
+
+    # True when the program trains or evaluates, i.e. needs the dataset loader.
+    def needs_dataset?
+      @nodes.any? { |n| %i[train evaluate].include?(n[:type]) }
+    end
+
+    # True when the generated app actually depends on Torch -- a torch/transfer
+    # model, or a training/evaluation loop. LLM-only and text apps don't, so we
+    # skip the torch require/DEVICE (which also keeps them Vercel-deployable).
+    def torch?
+      @registry.values.any? { |m| %i[torch transfer].include?(m[:kind]) } || needs_dataset?
+    end
+
+    # The `device` from an `environment` block, if any (:cpu / :cuda).
+    def environment_device
+      env = @nodes.find { |n| n[:type] == :environment }
+      env && env[:settings] && env[:settings][:device]
+    end
+
+    def header
+      @e.comment "Generated by Aura v#{Aura::VERSION}"
+      @e.line %(begin; require "dotenv/load"; rescue LoadError; end)
+      @e.line %(require "sinatra")
+      @e.line %(require "json")
+      if llm?
+        @e.line %(require "net/http")
+        @e.line %(require "uri")
+      end
+      if torch?
+        @e.line %(begin; require "torch"; rescue LoadError; end)
+        @e.line %(begin; require "torchvision"; rescue LoadError; end) if transfer?
+        if needs_dataset?
+          @e.line %(begin; require "datasets"; rescue LoadError; end)
+          @e.line %(require "csv")
+        end
+        if environment_device == :cpu
+          @e.line %(DEVICE = "cpu")
+        else
+          @e.line %(DEVICE = (defined?(Torch::CUDA) && Torch::CUDA.available?) ? "cuda" : "cpu")
+        end
+      end
+      @e.blank
+      emit_input_tensor_helper if torch?
+      emit_dataset_helper if needs_dataset?
+    end
+
+    # Build a model-ready tensor from JSON request input. Shared by every torch
+    # route so inference reshapes the payload to the model's input dims instead
+    # of crashing on a bare array.
+    def emit_input_tensor_helper
+      @e.comment "Build a model-ready tensor from JSON input. Accepts a single sample"
+      @e.comment "or a batch and reshapes to the model's input dims. Adjust the"
+      @e.comment "normalization to match how the model was trained."
+      @e.block("def aura_input_tensor(data, reshape)") do
+        @e.line "tensor = Torch.tensor(data, dtype: :float32)"
+        @e.line "tensor = tensor.reshape([-1] + reshape) if reshape"
+        @e.line "tensor.to(DEVICE)"
+      end
+      @e.blank
+    end
+
+    def emit(node)
+      case node[:type]
+      when :environment then emit_environment(node)
+      when :dataset     then emit_dataset(node)
+      when :model       then emit_model(node)
+      when :train       then emit_train(node)
+      when :evaluate    then emit_evaluate(node)
+      when :route       then emit_route(node)
+      when :run_web     then emit_run_web(node)
+      end
+    end
+
+    # ---- environment ---------------------------------------------------------
+    def emit_environment(node)
+      pairs = node[:settings].map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+      @e.block("class AuraConfig") do
+        @e.line "SETTINGS = { #{pairs} }.freeze"
+      end
+      @e.blank
+    end
+
+    # ---- dataset -------------------------------------------------------------
+    def emit_dataset(node)
+      @e.comment %(Dataset: #{node[:name]} (#{node[:source]} "#{node[:path]}"))
+      @e.line "#{const(node[:name])}_DATASET = { source: #{node[:source].inspect}, " \
+              "path: #{node[:path].inspect}, options: #{node[:options].inspect} }.freeze"
+      @e.blank
+    end
+
+    # A shared loader, emitted once when the program trains or evaluates. It
+    # streams a dataset as [inputs, targets] tensor batches. Built-in loaders
+    # cover the red-datasets sets (MNIST / Fashion-MNIST / CIFAR); any other
+    # source raises a clear error so you can drop in your own loader.
+    def emit_dataset_helper
+      @e.block("def aura_each_batch(name, batch_size: 32, reshape: nil)") do
+        @e.line "return enum_for(:aura_each_batch, name, batch_size: batch_size, reshape: reshape) unless block_given?"
+        @e.comment "CSV: last column is the label, the rest are float features."
+        @e.block("if name.to_s =~ /\\.csv\\z/i") do
+          @e.line "rows = CSV.read(name.to_s)"
+          @e.line "rows.shift if rows.first && rows.first.any? { |c| c.to_s =~ /[A-Za-z]/ }"
+          @e.block("rows.each_slice(batch_size) do |slice|") do
+            @e.line "xs = slice.map { |r| r[0..-2].map(&:to_f) }"
+            @e.line "ys = slice.map { |r| r[-1].to_i }"
+            @e.line "yield aura_batch_tensors(xs, ys, reshape)"
+          end
+          @e.line "return"
+        end
+        @e.line %(type = name.to_s.include?("test") ? :test : :train)
+        @e.block("source = case name.to_s") do
+          @e.line "when /fashion/i then Datasets::FashionMNIST.new(type: type)"
+          @e.line "when /mnist/i   then Datasets::MNIST.new(type: type)"
+          @e.line "when /cifar/i   then Datasets::CIFAR.new(type: type)"
+          @e.line "else"
+          @e.indent do
+            @e.line %q{raise "Aura: no built-in loader for dataset '#{name}' [supported: mnist, fashion-mnist, cifar]. Add a loader here that yields [inputs, targets] tensors."}
+          end
+        end
+        @e.line "xs = []"
+        @e.line "ys = []"
+        @e.block("source.each do |record|") do
+          @e.line "xs << Array(record.pixels).map { |px| px / 255.0 }"
+          @e.line "ys << record.label"
+          @e.block("if xs.length == batch_size") do
+            @e.line "yield aura_batch_tensors(xs, ys, reshape)"
+            @e.line "xs = []; ys = []"
+          end
+        end
+        @e.line "yield aura_batch_tensors(xs, ys, reshape) unless xs.empty?"
+      end
+      @e.blank
+      @e.block("def aura_batch_tensors(xs, ys, reshape)") do
+        @e.line "inputs = Torch.tensor(xs, dtype: :float32)"
+        @e.line "inputs = inputs.reshape([inputs.size(0)] + reshape) if reshape"
+        @e.line "[inputs.to(DEVICE), Torch.tensor(ys, dtype: :int64).to(DEVICE)]"
+      end
+      @e.blank
+    end
+
+    # ---- models --------------------------------------------------------------
+    def emit_model(node)
+      case node[:kind]
+      when :torch    then emit_torch_model(node)
+      when :transfer then emit_transfer_model(node)
+      when :llm      then emit_llm_model(node)
+      when :text     then emit_text_model(node)
+      end
+      @e.blank
+    end
+
+    def emit_torch_model(node)
+      cls = "#{camel(node[:name])}Model"
+      init_lines, fwd_lines = plan_layers(node[:layers])
+
+      emit_input_preprocessing(node)
+      @e.block("class #{cls} < Torch::NN::Module") do
+        @e.block("def initialize") do
+          @e.line "super"
+          init_lines.each { |l| @e.line l }
+        end
+        @e.block("def forward(x)") do
+          fwd_lines.each { |l| @e.line l }
+          @e.line "x"
+        end
+      end
+      accessor(node[:name], "#{cls}.new.to(DEVICE)")
+      emit_weight_io(node)
+    end
+
+    # Persistence directives declared in the model body (`load weights from` /
+    # `save weights to`) become real load calls and a save helper.
+    def emit_weight_io(node)
+      node[:layers].each do |layer|
+        case layer[:type]
+        when :load_weights
+          @e.line "#{node[:name]}_model.load_state_dict(Torch.load(#{layer[:path].inspect})) if File.exist?(#{layer[:path].inspect})"
+        when :save_weights
+          @e.line "def #{node[:name]}_save_weights; Torch.save(#{node[:name]}_model.state_dict, #{layer[:path].inspect}); end"
+        end
+      end
+    end
+
+    # Walk the layers once, tracking the running tensor shape so Conv2d
+    # in-channels and Linear in-features come out right. Returns [init, forward].
+    def plan_layers(layers)
+      init = []
+      fwd  = []
+      spatial = false
+      channels = h = w = nil
+      flat = nil
+      counts = Hash.new(0)
+
+      if (input = layers.find { |l| l[:type] == :input })
+        dims = input[:shape]
+        if dims.length == 3
+          h, w, channels = dims # Aura uses (H, W, C); Torch is channels-first
+          spatial = true
+        else
+          flat = dims.empty? ? nil : dims.reduce(:*)
+        end
+      end
+
+      flatten = lambda do
+        if spatial
+          flat = channels * h * w
+          spatial = false
+          fwd << "x = x.view(x.size(0), -1)"
+        end
+      end
+
+      layers.each do |layer|
+        case layer[:type]
+        when :conv2d
+          iv = "@conv#{counts[:conv] += 1}"
+          channels ||= 1 # no `input shape` declared -> assume 1 channel (keeps Ruby valid)
+          pad = (layer[:kernel] - 1) / 2
+          init << "#{iv} = Torch::NN::Conv2d.new(#{channels}, #{layer[:filters]}, #{layer[:kernel]}, padding: #{pad})"
+          fwd  << "x = Torch::NN::F.relu(#{iv}.call(x))"
+          channels = layer[:filters]
+        when :maxpool2d
+          iv = "@pool#{counts[:pool] += 1}"
+          init << "#{iv} = Torch::NN::MaxPool2d.new(#{layer[:size]})"
+          fwd  << "x = #{iv}.call(x)"
+          h = h / layer[:size] if h
+          w = w / layer[:size] if w
+        when :batchnorm
+          iv = "@bn#{counts[:bn] += 1}"
+          init << if spatial
+                    "#{iv} = Torch::NN::BatchNorm2d.new(#{channels})"
+                  else
+                    "#{iv} = Torch::NN::BatchNorm1d.new(#{flat})"
+                  end
+          fwd << "x = #{iv}.call(x)"
+        when :flatten
+          flatten.call
+        when :dropout
+          iv = "@drop#{counts[:drop] += 1}"
+          init << "#{iv} = Torch::NN::Dropout.new(p: #{layer[:rate]})"
+          fwd  << "x = #{iv}.call(x)"
+        when :embedding
+          iv = "@emb#{counts[:emb] += 1}"
+          init << "#{iv} = Torch::NN::Embedding.new(#{layer[:vocab]}, #{layer[:dim]})"
+          fwd  << "x = #{iv}.call(x)"
+          flat = layer[:dim]
+          spatial = false
+        when :lstm, :gru
+          klass = layer[:type] == :lstm ? "LSTM" : "GRU"
+          iv = "@rnn#{counts[:rnn] += 1}"
+          init << "#{iv} = Torch::NN::#{klass}.new(#{flat || 1}, #{layer[:units]}, batch_first: true)"
+          fwd  << "x, _ = #{iv}.call(x)"
+          fwd  << "x = x[0.., -1, 0..] # last timestep (best-effort; verify vs torch-rb)"
+          flat = layer[:units]
+          spatial = false
+        when :dense
+          flatten.call
+          iv = "@fc#{counts[:fc] += 1}"
+          init << "#{iv} = Torch::NN::Linear.new(#{flat || 1}, #{layer[:units]})"
+          fwd  << "x = #{activation_expr("#{iv}.call(x)", layer[:activation])}"
+          flat = layer[:units]
+        when :output
+          flatten.call
+          init << "@out = Torch::NN::Linear.new(#{flat || 1}, #{layer[:units]})"
+          fwd  << "x = #{activation_expr("@out.call(x)", layer[:activation])}"
+          flat = layer[:units]
+        end
+      end
+
+      [init, fwd]
+    end
+
+    def activation_expr(call_expr, activation)
+      case activation
+      when :softmax        then "Torch::NN::F.softmax(#{call_expr}, dim: 1)"
+      when :linear, nil    then call_expr
+      else                      "Torch::NN::F.#{activation}(#{call_expr})"
+      end
+    end
+
+    def emit_transfer_model(node)
+      cls      = "#{camel(node[:name])}Model"
+      layers   = Array(node[:layers])
+      output   = layers.find { |l| l[:type] == :output }
+      freeze   = layers.any? { |l| l[:type] == :freeze }
+      unfreeze = layers.any? { |l| l[:type] == :unfreeze_all }
+
+      @e.block("class #{cls} < Torch::NN::Module") do
+        @e.block("def initialize") do
+          @e.line "super"
+          @e.line "@base = TorchVision::Models.#{node[:base_model]}(pretrained: true)"
+          if unfreeze
+            @e.line "@base.parameters.each { |p| p.requires_grad = true }"
+          elsif freeze
+            @e.comment "Freeze the pretrained backbone; only the new head trains."
+            @e.line "@base.parameters.each { |p| p.requires_grad = false }"
+          end
+          if output
+            @e.comment "New classification head. 1000 = ImageNet logit width of the"
+            @e.comment "base; adjust if your base model exposes a different size."
+            @e.line "@head = Torch::NN::Linear.new(1000, #{output[:units]})"
+          end
+        end
+        if output
+          @e.block("def forward(x)") do
+            @e.line "x = @base.call(x)"
+            @e.line "x = #{activation_expr('@head.call(x)', output[:activation])}"
+            @e.line "x"
+          end
+        else
+          @e.line "def forward(x); @base.call(x); end"
+        end
+      end
+      accessor(node[:name], "#{cls}.new.to(DEVICE)")
+      emit_weight_io(node)
+    end
+
+    def emit_llm_model(node)
+      case node[:provider]
+      when :openai then emit_openai(node)
+      when :ollama then emit_ollama(node)
+      else              emit_openai(node)
+      end
+    end
+
+    def emit_openai(node)
+      @e.block("def #{node[:name]}_predict(prompt)") do
+        @e.line %(api_key = ENV["OPENAI_API_KEY"])
+        @e.line %(uri = URI("https://api.openai.com/v1/chat/completions"))
+        @e.line "http = Net::HTTP.new(uri.host, uri.port)"
+        @e.line "http.use_ssl = true"
+        @e.line "http.open_timeout = 10"
+        @e.line "http.read_timeout = 60"
+        @e.line "request = Net::HTTP::Post.new(uri)"
+        @e.line %(request["Content-Type"] = "application/json")
+        @e.line %(request["Authorization"] = "Bearer #{'#{api_key}'}")
+        if node[:system]
+          @e.line "messages = [{ role: \"system\", content: #{node[:system].inspect} }, { role: \"user\", content: prompt }]"
+        else
+          @e.line "messages = [{ role: \"user\", content: prompt }]"
+        end
+        parts = ["model: #{node[:model_id].inspect}", "messages: messages"]
+        parts << "temperature: #{node[:temperature]}" if node[:temperature]
+        parts << "max_tokens: #{node[:max_tokens]}" if node[:max_tokens]
+        @e.line "request.body = { #{parts.join(', ')} }.to_json"
+        @e.line "response = http.request(request)"
+        @e.line %(return { error: "upstream " + response.code.to_s } unless response.is_a?(Net::HTTPSuccess))
+        @e.line %(JSON.parse(response.body).dig("choices", 0, "message", "content"))
+        @e.line "rescue => e"
+        @e.indent { @e.line "{ error: e.message }" }
+      end
+    end
+
+    def emit_ollama(node)
+      @e.block("def #{node[:name]}_predict(prompt)") do
+        @e.line %(uri = URI("http://localhost:11434/api/generate"))
+        @e.line "http = Net::HTTP.new(uri.host, uri.port)"
+        @e.line "http.open_timeout = 10"
+        @e.line "http.read_timeout = 120"
+        @e.line "request = Net::HTTP::Post.new(uri)"
+        @e.line %(request["Content-Type"] = "application/json")
+        parts = ["model: #{node[:model_id].inspect}", "prompt: prompt", "stream: false"]
+        parts << "system: #{node[:system].inspect}" if node[:system]
+        opts = []
+        opts << "temperature: #{node[:temperature]}" if node[:temperature]
+        opts << "num_predict: #{node[:max_tokens]}" if node[:max_tokens]
+        parts << "options: { #{opts.join(', ')} }" unless opts.empty?
+        @e.line "request.body = { #{parts.join(', ')} }.to_json"
+        @e.line "response = http.request(request)"
+        @e.line %(return { error: "upstream " + response.code.to_s } unless response.is_a?(Net::HTTPSuccess))
+        @e.line %(JSON.parse(response.body)["response"])
+        @e.line "rescue => e"
+        @e.indent { @e.line "{ error: e.message }" }
+      end
+    end
+
+    def emit_text_model(node)
+      @e.line "def #{node[:name]}_greeting; #{node[:greeting].inspect}; end"
+    end
+
+    # ---- training ------------------------------------------------------------
+    # Training only runs in training mode (AURA_TRAIN=1, via `aura train`), so it
+    # does not re-run on every server boot. `aura run` loads weights and serves.
+    def emit_train(node)
+      cfg        = node[:config]
+      model      = node[:model]
+      model_node = @registry[model]
+      epochs     = cfg[:epochs] || 1
+      batch_size = cfg[:batch_size] || 32
+      reshape    = input_reshape(model_node)
+      track_acc  = Array(cfg[:metrics]).include?(:accuracy)
+      has_sched  = cfg[:scheduler] && SCHEDULERS.key?(cfg[:scheduler])
+      batch_call = %(aura_each_batch(#{node[:dataset].inspect}, batch_size: #{batch_size}, reshape: #{reshape.inspect}))
+
+      @e.comment %(Training: #{model} on "#{node[:dataset]}" (runs only when AURA_TRAIN=1))
+      @e.block(%(if ENV["AURA_TRAIN"] == "1")) do
+        @e.line "#{model}_model.train"
+        @e.line "optimizer = Torch::Optim::#{OPTIMIZERS.fetch(cfg[:optimizer], 'Adam')}.new(#{model}_model.parameters, lr: #{cfg[:lr] || 0.001})"
+        @e.line "criterion = Torch::NN::#{LOSSES.fetch(cfg[:loss], 'CrossEntropyLoss')}.new"
+        @e.line "scheduler = #{scheduler_ctor(cfg[:scheduler], epochs)}" if has_sched
+
+        @e.block("#{epochs}.times do |epoch|") do
+          @e.line "running_loss = 0.0"
+          if track_acc
+            @e.line "correct = 0"
+            @e.line "total = 0"
+          end
+          @e.block("#{batch_call} do |inputs, targets|") do
+            @e.line "optimizer.zero_grad"
+            @e.line "outputs = #{model}_model.call(inputs)"
+            @e.line "loss = criterion.call(outputs, targets)"
+            @e.line "loss.backward"
+            @e.line "optimizer.step"
+            @e.line "running_loss += loss.item"
+            if track_acc
+              @e.line "correct += outputs.argmax(1).eq(targets).sum.item"
+              @e.line "total += targets.size(0)"
+            end
+          end
+          @e.line "scheduler.step" if has_sched
+          if track_acc
+            @e.line %(puts "Epoch " + (epoch + 1).to_s + "/#{epochs} - loss: " + running_loss.round(4).to_s + " - accuracy: " + (total.zero? ? 0.0 : (correct.to_f / total).round(4)).to_s)
+          else
+            @e.line %(puts "Epoch " + (epoch + 1).to_s + "/#{epochs} - loss: " + running_loss.round(4).to_s)
+          end
+        end
+        @e.line "#{model}_save_weights" if saves_weights?(model_node)
+      end
+      @e.blank
+    end
+
+    # Each LR scheduler takes different constructor arguments; emit the right
+    # ones (defaults chosen sensibly). Verify against your torch-rb version.
+    def scheduler_ctor(scheduler, epochs)
+      args = case scheduler
+             when :exponential_lr      then "gamma: 0.9"
+             when :cosine_annealing_lr then "t_max: #{epochs}"
+             else                           "step_size: 1, gamma: 0.1" # step_lr
+             end
+      "Torch::Optim::LRScheduler::#{SCHEDULERS[scheduler]}.new(optimizer, #{args})"
+    end
+
+    # ---- evaluation ----------------------------------------------------------
+    def emit_evaluate(node)
+      model      = node[:model]
+      reshape    = input_reshape(@registry[model])
+      batch_call = %(aura_each_batch(#{node[:dataset].inspect}, reshape: #{reshape.inspect}))
+
+      @e.comment %(Evaluation: #{model} on "#{node[:dataset]}" (runs only when AURA_TRAIN=1))
+      @e.block(%(if ENV["AURA_TRAIN"] == "1")) do
+        @e.line "#{model}_model.eval"
+        @e.line "eval_correct = 0"
+        @e.line "eval_total = 0"
+        @e.block("Torch.no_grad do") do
+          @e.block("#{batch_call} do |inputs, targets|") do
+            @e.line "outputs = #{model}_model.call(inputs)"
+            @e.line "eval_correct += outputs.argmax(1).eq(targets).sum.item"
+            @e.line "eval_total += targets.size(0)"
+          end
+        end
+        @e.line %(puts "Eval accuracy (#{model}): " + (eval_total.zero? ? 0.0 : (eval_correct.to_f / eval_total).round(4)).to_s)
+      end
+      @e.blank
+    end
+
+    # Channels-first [C, H, W] reshape hint for a model whose input is a 3-D
+    # (H, W, C) image, so flat dataset rows can be folded back into images.
+    # nil for flat inputs. A `resize N` input transform overrides the spatial
+    # dimensions.
+    def input_reshape(model_node)
+      return nil unless model_node
+
+      input = Array(model_node[:layers]).find { |l| l[:type] == :input }
+      return nil unless input && Array(input[:shape]).length == 3
+
+      h, w, c = input[:shape]
+      if (resize = Array(input[:transforms]).find { |t| t[:transform] == :resize })
+        h = w = resize[:value]
+      end
+      [c, h, w]
+    end
+
+    def saves_weights?(model_node)
+      model_node && Array(model_node[:layers]).any? { |l| l[:type] == :save_weights }
+    end
+
+    # Surface declared `input shape(...) do resize N; to_tensor end` preprocessing
+    # in the output. `resize` feeds the dataset loader's reshape (see
+    # input_reshape); the rest is documented for the data pipeline.
+    def emit_input_preprocessing(node)
+      input = Array(node[:layers]).find { |l| l[:type] == :input }
+      transforms = input && Array(input[:transforms])
+      return if transforms.nil? || transforms.empty?
+
+      desc = transforms.map { |t| t[:value] ? "#{t[:transform]} #{t[:value]}" : t[:transform].to_s }.join(", ")
+      @e.comment "Input preprocessing: #{desc}"
+    end
+
+    # ---- routes --------------------------------------------------------------
+    def emit_route(node)
+      verb = node[:method].downcase
+      model = @registry[node[:model]]
+      @e.block("#{verb} #{node[:path].inspect} do") do
+        emit_auth if node[:auth]
+        @e.line "content_type :json" if node[:format] == :json || node[:format].nil?
+        emit_route_body(model, node[:input_var], node[:postprocess])
+      end
+      @e.blank
+    end
+
+    # Constant-time bearer-token check against AURA_API_TOKEN; refuses outright
+    # when the server token isn't configured.
+    def emit_auth
+      @e.comment "Bearer-token auth; set AURA_API_TOKEN in the environment (.env)."
+      @e.line %(auth_token = ENV["AURA_API_TOKEN"].to_s)
+      @e.line %(halt 401, { error: "auth not configured" }.to_json if auth_token.empty?)
+      @e.line %(provided = request.env["HTTP_AUTHORIZATION"].to_s.sub(/\\ABearer /, ""))
+      @e.line "halt 401 unless Rack::Utils.secure_compare(auth_token, provided)"
+    end
+
+    # `input_var` is the variable named in the DSL's `model.predict(<var>)`, used
+    # as the JSON key the handler reads the request payload from.
+    def emit_route_body(model, input_var, post_process = nil)
+      key  = (input_var || "input").to_s
+      kind = model && model[:kind]
+      case kind
+      when :llm
+        @e.line "payload = JSON.parse(request.body.read) rescue {}"
+        @e.line "result = #{model[:name]}_predict(payload[#{key.inspect}])"
+        @e.line "{ response: result }.to_json"
+      when :text
+        @e.line "{ greeting: #{model[:name]}_greeting }.to_json"
+      when :torch, :transfer
+        @e.line "payload = JSON.parse(request.body.read) rescue {}"
+        @e.line "input = payload[#{key.inspect}]"
+        @e.line %(halt 400, { error: "missing '#{key}' in request body" }.to_json if input.nil?)
+        @e.line "begin"
+        @e.indent do
+          @e.line "tensor = aura_input_tensor(input, #{input_reshape(model).inspect})"
+          @e.block("result = Torch.no_grad do") do
+            @e.line "#{model[:name]}_model.eval"
+            @e.line "#{model[:name]}_model.call(tensor)"
+          end
+          if post_process == :label
+            @e.line "{ label: result.argmax(1).to_a }.to_json"
+          else
+            @e.line "{ prediction: result.to_a }.to_json"
+          end
+        end
+        @e.line "rescue => e"
+        @e.indent { @e.line %(halt 500, { error: e.message }.to_json) }
+        @e.line "end"
+      else
+        @e.line "{ status: \"ok\" }.to_json"
+      end
+    end
+
+    # ---- run -----------------------------------------------------------------
+    # In training mode (AURA_TRAIN=1) the app trains and exits without serving;
+    # otherwise `set :run, true` boots the server (classic Sinatra starts at exit
+    # even when loaded via eval/require).
+    def emit_run_web(node)
+      unless @nodes.any? { |n| n[:type] == :route && n[:path] == "/health" }
+        @e.comment "Auto health check."
+        @e.block(%(get "/health" do)) do
+          @e.line "content_type :json"
+          @e.line %({ status: "ok" }.to_json)
+        end
+        @e.blank
+      end
+      @e.comment "Serve unless we're in training mode (then train and exit)."
+      @e.line "set :port, #{node[:port]}"
+      @e.line %(set :bind, "0.0.0.0")
+      @e.line %(set :run, ENV["AURA_TRAIN"] != "1")
+    end
+
+    # ---- helpers -------------------------------------------------------------
+    # A memoized, top-level accessor so the model is reachable from inside
+    # Sinatra route blocks (which run in their own context).
+    def accessor(name, expression)
+      @e.line "def #{name}_model; $aura_#{name}_model ||= #{expression}; end"
+    end
+
+    def camel(name)
+      name.to_s.split(/[_\s]+/).map { |p| p.empty? ? p : p[0].upcase + p[1..] }.join
+    end
+
+    def const(name)
+      name.to_s.gsub(/[^a-zA-Z0-9]/, "_").upcase
+    end
+  end
+end