lilac-cli 0.2.0

data/lib/lilac/cli/subcommand/build.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "base"
+require_relative "../config"
+require_relative "../build/builder"
+
+module Lilac
+  module CLI
+    module Subcommand
+      class Build < Base
+        def run
+          opts = parse_opts
+
+          config = Config.load(
+            root: opts[:root],
+            components_dir: opts[:components],
+            pages_dir: opts[:pages],
+            output_dir: opts[:output],
+            public_dir: opts[:public],
+            build_target: opts[:target],
+            mrbc_path: opts[:mrbc_path],
+            lilac_compiled_path: opts[:lilac_compiled_path],
+            lilac_full_path: opts[:lilac_full_path],
+            mruby_wasm_js_path: opts[:mruby_wasm_js_path],
+          )
+
+          # Default to clean: stale per-page `.mrb` (whose content hash
+          # changed across builds) would otherwise accumulate, and most
+          # modern build tools (Vite / Next / Eleventy / Webpack 5)
+          # follow the same convention. Opt out with `--no-clean` for
+          # incremental inspection or when something outside Lilac
+          # populates the same dist directory.
+          clean_output_dir!(config.output_dir, project_root: config.root) unless opts[:clean] == false
+
+          result = Builder.from_config(config).build
+          public_suffix = result[:public_files].positive? ? " + #{result[:public_files]} static file(s)" : ""
+          @out.puts "Built #{result[:pages]} page(s) from #{result[:components]} component(s)#{public_suffix} " \
+                    "→ #{relative(config.output_dir)} (target: #{config.build_target})"
+          0
+        end
+
+        private
+
+        def opts_parser(opts = {})
+          OptionParser.new do |o|
+            o.banner = "Usage: lilac build [options]"
+            OptionHelpers.add_path_options(o, opts)
+            OptionHelpers.add_target_options(o, opts)
+            o.on("--[no-]clean", "Remove the output dir before building (default: true)") do |v|
+              opts[:clean] = v
+            end
+            o.on("-h", "--help", "Show help") { @out.puts o; exit 0 }
+          end
+        end
+
+        # `--clean` wipes the output dir before building so old artefacts
+        # (e.g. stale per-page `.mrb` bundles whose content hash changed)
+        # don't accumulate. We refuse to wipe paths that look dangerous —
+        # the project root (so `output_dir = "."` doesn't nuke the source),
+        # a filesystem root, the user's home dir. Raises `Builder::Error`
+        # (caught by the top-level `Command#run` rescue) rather than
+        # exiting, so tests and embedders see the error as a normal
+        # non-zero return.
+        def clean_output_dir!(output_dir, project_root:)
+          path = File.expand_path(output_dir.to_s)
+          forbidden = [
+            "/",
+            File.expand_path(Dir.home),
+            File.expand_path(project_root.to_s),
+          ]
+          if forbidden.include?(path)
+            raise Builder::Error,
+                  "--clean refused: output_dir #{output_dir.inspect} resolves to a root / home / project dir " \
+                  "(this would delete your project). Set `output_dir` to a dedicated subdir like `dist/`."
+          end
+          FileUtils.rm_rf(path) if File.exist?(path)
+        end
+      end
+    end
+  end
+end

data/lib/lilac/cli/subcommand/dev.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../config"
+require_relative "../dev_server"
+
+module Lilac
+  module CLI
+    module Subcommand
+      class Dev < Base
+        def run
+          opts = parse_opts
+
+          # `--target` for `lilac dev` controls the watch-rebuild path.
+          # Defaults to `c.dev_target` (Config DEFAULT is `:full`) — the
+          # `:compiled` path will fire `mrbc` on every change once the
+          # DevServer wiring lands (Phase 2 of the proposals.md entry).
+          config = Config.load(
+            root: opts[:root],
+            components_dir: opts[:components],
+            pages_dir: opts[:pages],
+            output_dir: opts[:output],
+            public_dir: opts[:public],
+            dev_host: opts[:host],
+            dev_port: opts[:port],
+            dev_target: opts[:target],
+            mrbc_path: opts[:mrbc_path],
+            lilac_compiled_path: opts[:lilac_compiled_path],
+            lilac_full_path: opts[:lilac_full_path],
+            mruby_wasm_js_path: opts[:mruby_wasm_js_path],
+          )
+
+          DevServer.new(
+            config,
+            host: config.dev_host,
+            port: config.dev_port,
+            out: @out,
+            err: @err,
+          ).start
+          0
+        end
+
+        private
+
+        def opts_parser(opts = {})
+          OptionParser.new do |o|
+            o.banner = "Usage: lilac dev [options]"
+            o.on("--host HOST", "Bind host (default: #{Config::DEFAULT_DEV_HOST})") { |v| opts[:host] = v }
+            o.on("--port PORT", Integer, "Bind port (default: #{Config::DEFAULT_DEV_PORT})") { |v| opts[:port] = v }
+            OptionHelpers.add_path_options(o, opts)
+            OptionHelpers.add_target_options(o, opts)
+            o.on("-h", "--help", "Show help") { @out.puts o; exit 0 }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lilac/cli/subcommand/doctor.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../config"
+require_relative "../doctor"
+
+module Lilac
+  module CLI
+    module Subcommand
+      class Doctor < Base
+        def run
+          opts = parse_opts
+
+          config = Config.load(
+            root: opts[:root],
+            components_dir: opts[:components],
+            pages_dir: opts[:pages],
+            output_dir: opts[:output],
+            public_dir: opts[:public],
+          )
+
+          # Fully qualify the outer Doctor class to disambiguate from
+          # the enclosing `Subcommand::Doctor` we're inside.
+          ::Lilac::CLI::Doctor.new(config, out: @out).run
+        end
+
+        private
+
+        def opts_parser(opts = {})
+          OptionParser.new do |o|
+            o.banner = "Usage: lilac doctor [options]"
+            OptionHelpers.add_path_options(o, opts)
+            o.on("-h", "--help", "Show help") { @out.puts o; exit 0 }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lilac/cli/subcommand/new.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../scaffold"
+
+module Lilac
+  module CLI
+    module Subcommand
+      class New < Base
+        def run
+          parse_opts
+          name = @argv.shift
+
+          if name.nil?
+            @err.puts "Usage: lilac new <project-name>"
+            return 1
+          end
+          unless @argv.empty?
+            @err.puts "lilac new takes exactly one argument; extra: #{@argv.inspect}"
+            return 1
+          end
+
+          files = Scaffold.new(name).run
+          print_creation_summary(name, files)
+          print_next_steps(name)
+          0
+        end
+
+        private
+
+        # `lilac new` currently has no flags beyond -h/--help, but the
+        # parser is kept here so future flags (e.g. --no-counter,
+        # --with-router) slot in symmetrically with `build` / `dev`.
+        # `order!` (not `parse!`) so positional `<project-name>` after
+        # `lilac new` doesn't get consumed as a flag value.
+        def parse_opts
+          opts = {}
+          opts_parser(opts).order!(@argv)
+          opts
+        end
+
+        def opts_parser(_opts = {})
+          OptionParser.new do |o|
+            o.banner = "Usage: lilac new <project-name>"
+            o.on("-h", "--help", "Show help") { @out.puts o; exit 0 }
+          end
+        end
+
+        def print_creation_summary(name, files)
+          @out.puts "Created #{name}/ (#{files.length} files):"
+          files.each { |f| @out.puts "  #{name}/#{f}" }
+        end
+
+        def print_next_steps(name)
+          @out.puts
+          @out.puts "Next steps:"
+          @out.puts "  cd #{name}"
+          @out.puts "  bundle install"
+          @out.puts
+          @out.puts "  # 1. Install the mruby-wasm runtime for `lilac dev` (one-time, ~5MB):"
+          @out.puts "  mkdir -p public/vendor/lilac-full/mruby-wasm-js"
+          @out.puts "  cp /path/to/lilac/build/lilac-full.wasm \\"
+          @out.puts "     public/vendor/lilac-full/lilac-full.wasm"
+          @out.puts "  cp -r /path/to/mruby-wasm-runtime/mrbgem/mruby-wasm-js/js/* \\"
+          @out.puts "        public/vendor/lilac-full/mruby-wasm-js/"
+          @out.puts
+          @out.puts "  # 2. Verify the setup:"
+          @out.puts "  bundle exec lilac doctor"
+          @out.puts
+          @out.puts "  # 3. Start the dev server (live reload at http://localhost:5173):"
+          @out.puts "  bundle exec lilac dev"
+          @out.puts
+          @out.puts "  # 4. When ready to ship, `lilac build` produces an optimized"
+          @out.puts "  #    --target compiled dist (smaller bundle; requires mrbc"
+          @out.puts "  #    discoverable via env / monorepo / npm — see README)."
+          @out.puts "  #    For an mrbc-free build, run: lilac build --target full"
+        end
+      end
+    end
+  end
+end

data/lib/lilac/cli/subcommand/option_helpers.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../config"
+
+module Lilac
+  module CLI
+    module Subcommand
+      # Shared OptionParser option groups. `build` / `dev` / `doctor` /
+      # `preview` accept the same path-config flags; `build` / `dev`
+      # additionally accept the target / mrbc / runtime flags. Keeping
+      # these here so the subcommand classes don't drift out of sync.
+      module OptionHelpers
+        module_function
+
+        # The path-config flags `build` / `dev` / `doctor` / `preview`
+        # all accept. `o.on` mutates the OptionParser passed in; `opts`
+        # collects the parsed values for the caller's later Config.load
+        # merge.
+        def add_path_options(o, opts)
+          o.on("--components DIR", "Components directory (default: components)") { |v| opts[:components] = v }
+          o.on("--pages DIR", "Pages directory (default: pages)") { |v| opts[:pages] = v }
+          o.on("--public DIR", "Static-passthrough directory (default: public)") { |v| opts[:public] = v }
+          o.on("--output DIR", "-o DIR", "Output directory (default: dist)") { |v| opts[:output] = v }
+          o.on("--root DIR", "Project root (default: cwd)") { |v| opts[:root] = v }
+        end
+
+        # Build / dev target selection. `--target full` produces dist HTML
+        # with inline Ruby + lilac-full wasm (original Lilac story).
+        # `--target compiled` invokes `mrbc` to produce `.mrb` bytecode +
+        # lilac-compiled wasm (smaller production bundle, ~32% brotli).
+        # `--mrbc-path` lets the user pin a specific mrbc binary when the
+        # auto-discovery would pick the wrong one.
+        def add_target_options(o, opts)
+          o.on("--target TARGET", Config::TARGET_VALUES.map(&:to_s),
+               "Build target (#{Config::TARGET_VALUES.join(' / ')}; default: full)") do |v|
+            opts[:target] = v.to_sym
+          end
+          o.on("--mrbc-path PATH",
+               "Path to the mrbc binary (default: auto-discover)") do |v|
+            opts[:mrbc_path] = v
+          end
+          o.on("--lilac-compiled-path PATH",
+               "Path to lilac-compiled.wasm (default: auto-discover; --target compiled only)") do |v|
+            opts[:lilac_compiled_path] = v
+          end
+          o.on("--lilac-full-path PATH",
+               "Path to lilac-full.wasm (default: auto-discover; --target full only)") do |v|
+            opts[:lilac_full_path] = v
+          end
+          o.on("--mruby-wasm-js-path PATH",
+               "Path to the mruby-wasm-js bridge directory (default: auto-discover)") do |v|
+            opts[:mruby_wasm_js_path] = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lilac/cli/subcommand/package_build.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../package_build"
+
+module Lilac
+  module CLI
+    module Subcommand
+      class PackageBuild < Base
+        def run
+          opts = parse_opts
+
+          if opts[:output].nil?
+            @err.puts "Usage: lilac package-build <input.rb>... -o <output.mrb>"
+            return 1
+          end
+          if @argv.empty?
+            @err.puts "lilac package-build: at least one input file required"
+            @err.puts "Usage: lilac package-build <input.rb>... -o <output.mrb>"
+            return 1
+          end
+
+          # Fully qualify the outer engine class to disambiguate from
+          # the enclosing `Subcommand::PackageBuild` we're inside.
+          package = ::Lilac::CLI::PackageBuild.new(
+            inputs: @argv.dup,
+            output: opts[:output],
+            mrbc_path: opts[:mrbc_path],
+          )
+          out_path = package.run
+          @out.puts "Built package bytecode: #{relative(out_path)} (#{File.size(out_path)} bytes)"
+          0
+        end
+
+        private
+
+        def opts_parser(opts = {})
+          OptionParser.new do |o|
+            o.banner = "Usage: lilac package-build <input.rb>... -o <output.mrb>"
+            o.on("-o", "--output PATH", "Output `.mrb` file (required)") { |v| opts[:output] = v }
+            o.on("--mrbc-path PATH",
+                 "Path to the mrbc binary (default: auto-discover via lilac-wasm-bin)") do |v|
+              opts[:mrbc_path] = v
+            end
+            o.on("-h", "--help", "Show help") { @out.puts o; exit 0 }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lilac/cli/subcommand/preview.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../config"
+require_relative "../preview_server"
+
+module Lilac
+  module CLI
+    module Subcommand
+      class Preview < Base
+        def run
+          opts = parse_opts
+
+          # `preview` only needs the output_dir resolved; target / mrbc /
+          # vendor paths are irrelevant because we're serving an already-
+          # built `dist/`. Reuse `Config.load` so `lilac.config.rb` is
+          # still consulted for `output_dir`.
+          config = Config.load(
+            root: opts[:root],
+            components_dir: opts[:components],
+            pages_dir: opts[:pages],
+            output_dir: opts[:output],
+            public_dir: opts[:public],
+          )
+
+          PreviewServer.new(
+            config.output_dir,
+            host: opts[:host] || PreviewServer::DEFAULT_HOST,
+            port: opts[:port] || PreviewServer::DEFAULT_PORT,
+            out: @out,
+            err: @err,
+          ).start
+          0
+        end
+
+        private
+
+        def opts_parser(opts = {})
+          OptionParser.new do |o|
+            o.banner = "Usage: lilac preview [options]"
+            o.on("--host HOST", "Bind host (default: #{PreviewServer::DEFAULT_HOST})") { |v| opts[:host] = v }
+            o.on("--port PORT", Integer, "Bind port (default: #{PreviewServer::DEFAULT_PORT})") { |v| opts[:port] = v }
+            OptionHelpers.add_path_options(o, opts)
+            o.on("-h", "--help", "Show help") { @out.puts o; exit 0 }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lilac/cli/templates/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+group :development do
+  gem "lilac-cli", "~> 0.1"
+end
+
+# Lilac wasm runtimes (full + compiled) + JS bridge, packaged as a Ruby
+# gem so `bundle install` is all you need. The lilac-cli soft-requires
+# this; absent gem falls through to npm / monorepo / explicit-path
+# discovery, but having it as a Gemfile dep is the simplest path.
+gem "lilac-wasm-bin", "~> 0.1"

data/lib/lilac/cli/templates/README.md

@@ -0,0 +1,125 @@
+# {{name}}
+
+A Lilac app — Ruby in the browser via [mruby-wasm-runtime][1], composed
+from `.lil` single-file components by [lilac-cli][2].
+
+[1]: https://github.com/takahashim/mruby-wasm-runtime
+[2]: https://github.com/takahashim/lilac-cli
+
+## Setup
+
+```sh
+bundle install
+```
+
+Place the Lilac wasm runtime under `public/vendor/`. Everything in
+`public/` is mirrored verbatim into `dist/` at build time (Vite /
+Eleventy convention), so requests to `/vendor/...` resolve from there
+both in dev (`lilac dev`) and in production (`lilac build`).
+
+```sh
+mkdir -p public/vendor/lilac-full/mruby-wasm-js
+cp /path/to/lilac/build/lilac-full.wasm \
+   public/vendor/lilac-full/lilac-full.wasm
+cp -r /path/to/mruby-wasm-runtime/mrbgem/mruby-wasm-js/js/* \
+       public/vendor/lilac-full/mruby-wasm-js/
+```
+
+Add anything else you want passthrough-served (favicons, images, CSS
+without templating) directly under `public/`.
+
+## Development
+
+```sh
+bundle exec lilac dev
+```
+
+Open <http://localhost:5173>. Edit any `.lil` component or `.html` page and
+the browser reloads automatically (Server-Sent Events).
+
+## Build for production
+
+```sh
+bundle exec lilac build                # default --target compiled (smaller bundle, needs mrbc)
+bundle exec lilac build --target full  # opt out: ship runtime parser, no mrbc required
+bundle exec lilac preview              # serve dist/ at http://127.0.0.1:4173 (no watch / no reload)
+```
+
+Output goes to `dist/`, which is self-contained (HTML + everything from
+`public/`). Deploy `dist/` as your static site root. `lilac preview` is
+the recommended way to smoke-test the production build locally before
+deploy — it runs a plain static server with no live-reload injection,
+mirroring what a CDN or static host would do.
+
+### `--target compiled` (default for `lilac build`)
+
+`--target compiled` precompiles Ruby into `.mrb` bytecode (smaller
+bundle, no in-browser parser) and **automatically vendors the
+`lilac-compiled` runtime** into `dist/vendor/lilac-compiled/`. This
+is the default for `lilac build` — `lilac dev` keeps `--target full`
+so the development loop stays mrbc-free.
+
+You do not need to copy anything into `public/vendor/lilac-compiled/` —
+the CLI resolves the wasm + JS bridge from one of:
+
+1. `--lilac-compiled-path` / `--mruby-wasm-js-path` CLI flags
+2. `c.lilac_compiled_path` / `c.mruby_wasm_js_path` in `lilac.config.rb`
+3. `LILAC_COMPILED_WASM` / `MRUBY_WASM_JS_PATH` env vars
+4. The `lilac-wasm-bin` Ruby gem (canonical install path — your
+   scaffolded `Gemfile` declares it, so `bundle install` brings the
+   wasm + bridge in automatically)
+5. The Lilac monorepo (if you're working inside this repo)
+
+Most projects rely on path 4 — `bundle install` is all you need.
+
+## Configuration
+
+`lilac.config.rb` at the project root overrides built-in defaults
+for paths, host, and port. Every field is commented out by default;
+uncomment what you want to change. CLI flags (`lilac dev --port`)
+still take precedence over the file.
+
+## Components and `data-*` directives
+
+Templates wire DOM to reactive state via `data-*` attributes; the
+build extracts them and generates the equivalent Ruby bindings
+alongside your `<script>`, so the script holds only component logic.
+The scaffold's `components/counter.lil` shows the most common ones:
+
+```html
+<button data-on-click="decrement" type="button">-</button>
+<span   data-text="@count" class="count">0</span>
+<button data-on-click="increment" type="button">+</button>
+```
+
+```ruby
+class Counter < Lilac::Component
+  def setup
+    @count = signal(0)
+  end
+  def increment(_ev) = @count.update(&:succ)
+  def decrement(_ev) = @count.update(&:pred)
+end
+```
+
+Available directive families:
+
+| Directive | Purpose |
+|---|---|
+| `data-text="@x"` / `data-unsafe-html="@x"` | element body (escaped / raw) |
+| `data-show="@x"` / `data-hide="@x"` | visibility (toggles `.lil-hidden`) |
+| `data-class="{ active: @x, 'btn-primary': @y }"` | class toggles (bare ident or quoted key) |
+| `data-attr-href="@x"` | reactive HTML attribute (URLs auto-sanitized) |
+| `data-css-color="@x"` | reactive CSS custom property (`--color`) |
+| `data-on-click="m"` / `data-on-<event>="m"` | event handler → method on the component |
+| `data-each="@items" data-key="id"` | keyed list iteration |
+| `data-field="name"` / `data-button="name"` | input two-way binding / button action (form gem) |
+
+Values must be `@ivar` (a signal) or, inside `data-each`, `it` /
+`it.field`. Arbitrary Ruby expressions are rejected at build time so
+templates stay statically auditable.
+
+Build-time also runs a cross-reference linter that warns when a
+template references an undeclared `@signal` or `data-on-X` method
+(stderr, non-fatal). Typos get a "Did you mean?" suggestion based on
+edit distance against the declared names.

data/lib/lilac/cli/templates/components/counter.lil

@@ -0,0 +1,18 @@
+<template>
+  <div data-component="counter">
+    <button data-on-click="decrement" type="button">-</button>
+    <span data-text="@count" class="count">0</span>
+    <button data-on-click="increment" type="button">+</button>
+  </div>
+</template>
+
+<script type="text/ruby">
+class Counter < Lilac::Component
+  def setup
+    @count = signal(0)
+  end
+
+  def increment(_ev) = @count.update(&:succ)
+  def decrement(_ev) = @count.update(&:pred)
+end
+</script>

data/lib/lilac/cli/templates/gitignore

@@ -0,0 +1,5 @@
+/dist/
+/.bundle/
+/vendor/bundle/
+*.gem
+.DS_Store

data/lib/lilac/cli/templates/lilac.config.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Project-wide lilac-cli configuration. Uncomment any field to
+# override the corresponding built-in default. CLI flags (e.g.
+# `lilac dev --port 8000`) take precedence over values set here.
+
+Lilac::CLI.configure do |c|
+  # c.components_dir = "components"     # where .lil components live
+  # c.pages_dir   = "pages"       # where .html pages live
+  # c.public_dir  = "public"      # static-passthrough directory
+  # c.output_dir  = "dist"        # build output
+
+  # c.dev_host    = "127.0.0.1"   # `lilac dev` bind host
+  # c.dev_port    = 5173          # `lilac dev` bind port
+
+  # Runtime wasm + bridge discovery overrides. All default to nil, in
+  # which case the CLI auto-discovers via env vars, the `lilac-wasm-bin`
+  # gem (recommended — already in the scaffolded Gemfile), or a monorepo
+  # ancestor. Set these to vendor a specific wasm for a fully offline,
+  # CDN-free build.
+  # c.lilac_full_path     = "/abs/path/to/lilac-full.wasm"      # --target full
+  # c.lilac_compiled_path = "/abs/path/to/lilac-compiled.wasm"  # --target compiled
+  # c.mruby_wasm_js_path  = "/abs/path/to/mruby-wasm-js/"       # JS bridge (both targets)
+end

data/lib/lilac/cli/templates/pages/index.html

@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>{{name}}</title>
+  <style>
+    /* Reserved class used by data-show / data-hide directives.
+       `!important` so user-side display rules can't override. */
+    .lil-hidden { display: none !important; }
+
+    body { font-family: system-ui, sans-serif; max-width: 40rem; margin: 2rem auto; padding: 0 1rem; }
+    [data-component="counter"] { display: flex; gap: 0.5rem; align-items: center; }
+    .count { font-size: 1.5rem; min-width: 2rem; text-align: center; }
+    button { font-size: 1rem; padding: 0.25rem 0.75rem; }
+  </style>
+</head>
+<body>
+  <h1>{{name}}</h1>
+
+  <div data-use="counter"></div>
+
+  <script type="module">
+    import { createVM } from "/vendor/lilac-full/mruby-wasm-js/index.js";
+    const vm = await createVM({
+      wasm: "/vendor/lilac-full/lilac-full.wasm",
+    });
+    // If `lilac.config.rb` declares Lilac package gems via Bundler,
+    // `lilac build` stages them under `dist/packages/` and writes a
+    // `lilac.packages.json` manifest. Load each before evaluating the
+    // page's text/ruby scripts so package handler registrations / class
+    // definitions are ready before component mount (decisions §25/§26).
+    try {
+      const res = await fetch("/lilac.packages.json");
+      if (res.ok) {
+        const { packages = [] } = await res.json();
+        for (const url of packages) {
+          vm.loadBytecode(new Uint8Array(await (await fetch(url)).arrayBuffer()));
+        }
+      }
+    } catch { /* No manifest => no packages; harmless. */ }
+    document.querySelectorAll('script[type="text/ruby"]')
+      .forEach(s => vm.eval(s.textContent));
+    vm.eval("Lilac.start");
+  </script>
+</body>
+</html>

data/lib/lilac/cli/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lilac
+  module CLI
+    VERSION = "0.2.0"
+  end
+end