lilac-cli 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fe398ae7cd444978bcce0e26b56f755b7f75de66aa63e62a1cda3729c4bbba06
+  data.tar.gz: a0bfd3e47f5d61af27b30e0c362aaf3a24154a4f1fb27f56c2b1efd2154d66ec
+SHA512:
+  metadata.gz: b2edc6ad8d25033f378d941fd230134d11927f247d4e1eb8878f4b9e5c5a39cfd59ceee489864a8b697f730d6420392a21141f818c08281ef23091c8740b510f
+  data.tar.gz: 32e2e3ee8d5ef6e4dbb3763f7dbb8a9f67eeb6f1faeebd687773147a2db86349bbed58993190ae62f8da9e4e5c245d352df80ba90e96b35f30d824b18310b780

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 takahashim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,144 @@
+# lilac-cli
+
+Optional build tool for **Lilac single-file components** (`.lil`) —
+template + Ruby script in one file, compiled to static HTML for the
+Lilac component runtime on mruby-wasm.
+
+The runtime is the canonical interpreter of `data-*` directives, so
+Lilac apps can be shipped as plain HTML without this CLI (see the
+repo-root README's Quick start). What lilac-cli adds on top:
+
+- **Static lint** for directive grammar / undeclared signals / dead
+  methods, caught at build time with source positions.
+- **`.lil` single-file component** format + project structure
+  (`components/` + `pages/`) and `<div data-use="..."></div>`
+  placeholders.
+- **Pre-compiled bindings** (`codegen: :auto`, default) — directive
+  interpretation moves from mount time to build time; the generated
+  `Lilac::Bindings::<Class>#bind_template_hook` takes precedence over
+  the runtime scanner, so there's no double-binding when both paths
+  coexist on the same page. Set `codegen: :off` to validate the
+  runtime path against the same `.lil` source.
+- **Dev server** with live reload, `scaffold`, `doctor`.
+
+> [!WARNING]
+> Pre-alpha. API and CLI surface will change.
+
+## Status
+
+| Phase | Status |
+|---|---|
+| 1. `.lil` parser + `lilac build` (static output) | ✅ |
+| 2. `lilac dev` (file watch via `listen`) | ✅ |
+| 3. SSE live reload (via `Wsv::Response.sse`) | ✅ |
+| 4. `lilac new` scaffold | ✅ |
+| 5. `lilac doctor` setup verifier | ✅ |
+| 6. `lilac.config.rb` project config | ✅ |
+
+## What is a `.lil` file?
+
+A single-file component containing markup, optional sub-templates, and a
+Ruby script that defines a `Lilac::Component` subclass:
+
+```html
+<!-- components/counter.lil -->
+<template>
+  <div data-component="counter">
+    <button data-ref="inc">+</button>
+    <span data-ref="count">0</span>
+  </div>
+</template>
+
+<!-- Sub-templates use `data-template="..."` — same convention the
+     Lilac runtime uses for `bind_list` clone-targets. -->
+<template data-template="counter-banner">
+  <div class="banner"></div>
+</template>
+
+<script type="text/ruby">
+  class Counter < Lilac::Component
+    def setup
+      @count = signal(0)
+      refs.inc.on(:click) { @count.update(&:succ) }
+      bind refs.count, text: @count
+    end
+  end
+</script>
+```
+
+`.lil` is HTML5-valid (use a `.lil → text/html` association in your
+editor for syntax highlighting). The build tool extracts the top-level
+`<template>` and `<script type="text/ruby">` blocks; everything inside
+each block is preserved verbatim.
+
+`lilac build` reads `components/*.lil` + `pages/*.html`, inlines the
+referenced component templates and scripts into each page, and writes the
+result to `dist/`.
+
+The kebab-to-CamelCase autoregister feature in Lilac means
+`<div data-component="counter"></div>` resolves to the `Counter` class with
+no `Lilac.register` call needed.
+
+## Installation
+
+```sh
+gem install lilac-cli
+```
+
+Or in a Gemfile:
+
+```ruby
+group :development do
+  gem "lilac-cli"
+end
+```
+
+Requires Ruby 3.2 or later.
+
+## Usage
+
+```sh
+lilac new my-app         # scaffold a fresh project (Counter sample inside)
+cd my-app && bundle install
+
+lilac doctor             # check project setup (runtime, component refs, paths)
+
+lilac build              # produce dist/ (default --target compiled — requires mrbc)
+lilac build --target full # opt out: ship runtime parser in dist (mrbc-free)
+lilac build --output _site
+
+lilac dev                # build + serve + live reload at http://127.0.0.1:5173
+                         # (default --target full so no mrbc needed for iteration)
+lilac dev --port 8000    # bind to a different port
+
+lilac preview            # serve the built dist/ at http://127.0.0.1:4173
+                         # (no watch / no reload — use to verify production output)
+```
+
+### Configuration
+
+Project-wide defaults can live in `lilac.config.rb` at the project
+root (a commented template is generated by `lilac new`):
+
+```ruby
+Lilac::CLI.configure do |c|
+  c.components_dir = "src/components"
+  c.pages_dir   = "src/pages"
+  c.dev_port    = 3000
+  # c.codegen     = :off   # skip bind_template_hook codegen and let
+                           # the runtime scanner interpret directives
+                           # at mount time (parity-testing or
+                           # runtime-only deployment).
+end
+```
+
+Precedence (lowest to highest): built-in defaults → `lilac.config.rb`
+→ CLI flags (`--components`, `--port`, etc.).
+
+`lilac dev` watches `components/**/*.lil` and `pages/**/*.html` for
+changes, rebuilds on save, and pushes a `reload` event over SSE to every
+connected browser tab.
+
+## License
+
+MIT. See [`LICENSE.txt`](./LICENSE.txt).

data/exe/lilac

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/lilac/cli"
+
+exit Lilac::CLI::Command.new(ARGV).run

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lilac
+  module CLI
+    # Per-build shared state handed from `Builder` (orchestrator) to
+    # `PageCompiler` (per-page compiler). All fields are set before the
+    # page loop starts, so PageCompiler treats the struct as read-only;
+    # the cache / linter references inside it accumulate per-page state
+    # via their own APIs.
+    #
+    # Fields:
+    #   - `components`        — { name => SFC::Component }, .lil + synthesized
+    #   - `bundle_assets`     — BundleAssetWriter::BundleAssets or nil (:inline mode)
+    #   - `package_dist_urls` — Array<String> page-relative URLs for `.mrb` packages
+    #   - `template_cache`    — shared TemplateASTCache (parse once, reuse)
+    #   - `build_linter`      — BuildLinter accumulating cross-page diagnostics
+    #   - `bytecode_builder`  — BytecodeBuilder for compiled-target `.mrb` emission
+    #   - `target`            — :full | :compiled
+    #   - `delivery`          — :inline | :bundle
+    #   - `live_reload`       — boolean (dev path injects SSE client script)
+    #   - `output_dir`        — absolute dist path (relative refs in boot module need this)
+    #   - `pages_dir`         — absolute pages root (for computing output paths)
+    BuildContext = Struct.new(
+      :components, :bundle_assets, :package_dist_urls,
+      :template_cache, :build_linter, :bytecode_builder,
+      :target, :delivery, :live_reload,
+      :output_dir, :pages_dir,
+      keyword_init: true
+    )
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Lilac
+  module CLI
+    # Common base + formatter for build-time errors. Wraps a structured
+    # message into the multi-line shape:
+    #
+    #   lilac: build error in <file>:<line>
+    #     <snippet>          # optional
+    #     <message body>
+    #     <suggestion>       # optional
+    #
+    # The bare-string form (`raise BuildError, "..."`) is supported so
+    # callers that don't have a location on hand can still raise, but
+    # the formatted shape only kicks in when `at:` is provided.
+    #
+    # Subclassed by `Lilac::Directives::Lints::Error`.
+    class BuildError < StandardError
+      attr_reader :at, :snippet, :suggestion
+
+      def initialize(message = nil, at: nil, snippet: nil, suggestion: nil)
+        @at = at
+        @snippet = snippet
+        @suggestion = suggestion
+        @body = message
+        super(format)
+      end
+
+      private
+
+      # Two paths: structured (location known → spec header + indented
+      # body) vs bare (no location → return body verbatim, mostly used
+      # by code paths that have no source coordinates).
+      def format
+        return @body unless @at
+
+        parts = ["lilac: build error in #{@at}"]
+        parts << "  #{@snippet}" if @snippet
+        # Indent each body line so multi-line messages stay aligned.
+        if @body
+          @body.to_s.each_line do |l|
+            parts << "  #{l.chomp}"
+          end
+        end
+        parts << "  #{@suggestion}" if @suggestion
+        parts.join("\n")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+require_relative 'sfc'
+require_relative 'bytecode_builder'
+require_relative 'html_emitter'
+require_relative 'template_ast_cache'
+require_relative 'build_context'
+require_relative 'bundle_asset_writer'
+require_relative 'package_stager'
+require_relative 'vendor_writer'
+require_relative 'compiled_runtime_resolver'
+require_relative 'full_runtime_resolver'
+require_relative 'page_compiler'
+require_relative '../lint/build_linter'
+
+module Lilac
+  module CLI
+    # Orchestrates a full build: loads components, stages packages,
+    # writes the (optional) bundle file, compiles each page via
+    # `PageCompiler`, then vendors runtime assets into `dist/vendor/`.
+    #
+    # The per-page rewriting logic lives in `PageCompiler`; HTML helpers
+    # in `HtmlEmitter`; template parse caching in `TemplateASTCache`;
+    # all of those share state through the `BuildContext` value object
+    # this class assembles.
+    class Builder
+      class Error < StandardError; end
+
+      # Filenames that must not land in the build output even when they
+      # exist under `public/`. Add to this list as new conventions are
+      # encountered (e.g. `.DS_Store`, `Thumbs.db`).
+      EXCLUDED_BASENAMES = %w[.gitkeep].freeze
+
+      # Target-specific public/ subdirectories that should NOT be mirrored
+      # into dist/ for the inactive target. Both runtime variants live
+      # under their own namespace in `public/vendor/` so a project that
+      # ships both (e.g. dev=full, prod=compiled) can keep them side by
+      # side and let the CLI prune the inactive one at build time.
+      #
+      # Paths are relative to `public_dir`, POSIX style. The match is on
+      # path prefix + boundary, so `vendor/lilac-full` matches
+      # `vendor/lilac-full/lilac-full.wasm` but not `vendor/lilac-full-x`.
+      EXCLUDED_DIRS_FOR_TARGET = {
+        full: %w[vendor/lilac-compiled].freeze,
+        compiled: %w[vendor/lilac-full].freeze
+      }.freeze
+
+      # Construct a Builder from a resolved `Config`. Centralises the
+      # Config-attr → Builder-kwarg mapping so callers in `Command` and
+      # `DevServer` don't drift out of sync. Overridable kwargs cover
+      # the per-caller differences:
+      #
+      #   - `target:` — Command picks `config.build_target`, DevServer
+      #     picks `config.dev_target`. Defaults to the build target.
+      #   - `delivery:` — either caller can pin a value here; both
+      #     currently leave it unset so `config.delivery` wins (build
+      #     and dev share the same delivery path, matching what ships
+      #     to prod).
+      #   - `live_reload:` — DevServer turns it on for SSE-driven page
+      #     reload; `lilac build` leaves it off.
+      def self.from_config(config, live_reload: false,
+                           target: nil, delivery: nil)
+        new(
+          components_dir: config.components_dir,
+          pages_dir: config.pages_dir,
+          output_dir: config.output_dir,
+          public_dir: config.public_dir,
+          target: target || config.build_target,
+          mrbc_path: config.mrbc_path,
+          lilac_compiled_path: config.lilac_compiled_path,
+          lilac_full_path: config.lilac_full_path,
+          mruby_wasm_js_path: config.mruby_wasm_js_path,
+          packages: config.packages,
+          delivery: delivery || config.delivery,
+          live_reload: live_reload
+        )
+      end
+
+      def initialize(components_dir:, pages_dir:, output_dir:, public_dir: nil,
+                     live_reload: false,
+                     target: :full, mrbc_path: nil,
+                     lilac_compiled_path: nil, lilac_full_path: nil,
+                     mruby_wasm_js_path: nil,
+                     packages: [],
+                     disable_gem_discovery: false,
+                     delivery: :inline)
+        @components_dir = components_dir
+        @pages_dir = pages_dir
+        @output_dir = output_dir
+        # public_dir is optional. When nil or absent on disk, the
+        # mirroring step is skipped — projects that don't need static
+        # passthrough (no vendor bundle, no images) work fine without
+        # creating the directory.
+        @public_dir = public_dir
+        @live_reload = live_reload
+        # `:full` — dist HTML loads inline Ruby via lilac-full wasm
+        # (vm.evalScript). `:compiled` — Ruby is pre-compiled to
+        # `.mrb` bytecode via `mrbc` and loaded by lilac-compiled wasm
+        # (vm.loadBytecode). The compiled target shaves ~32% off the brotli
+        # bundle but requires `mrbc` available at build time. See
+        # `BytecodeBuilder` for path discovery.
+        @target = target
+        @mrbc_path = mrbc_path
+        # Discovery hints for the compiled runtime — wasm + boot helper
+        # + JS bridge. Used by `auto_vendor_compiled_runtime!` so the
+        # built dist is fully self-contained and no manual cp into
+        # `public/vendor/lilac-compiled/` is required.
+        @lilac_compiled_path = lilac_compiled_path
+        # Discovery hint for the full runtime wasm — parallel to
+        # `@lilac_compiled_path`. Used by `auto_vendor_full_runtime!`
+        # via `FullRuntimeResolver` so a `:full` build is reliably
+        # self-contained (offline-runnable) without the CDN.
+        @lilac_full_path     = lilac_full_path
+        @mruby_wasm_js_path  = mruby_wasm_js_path
+        # Pre-compiled Lilac package `.mrb` paths (absolute). For both
+        # `:compiled` and `:full` builds these get staged under
+        # `dist/packages/`; `:compiled` injects loadBytecode into the
+        # generated boot module directly, `:full` writes a
+        # `dist/lilac.packages.json` manifest the scaffold boot fetches.
+        # See decisions §25 / §26.
+        @packages            = Array(packages).map { |p| File.expand_path(p) }
+        # Mirrors `CompiledRuntimeResolver` / `BytecodeBuilder`'s
+        # `disable_gem_discovery:` — tests pass `true` so the gem-bundled
+        # wasm doesn't satisfy lookups they're trying to isolate. Plumbed
+        # through to both resolvers below.
+        @disable_gem_discovery = disable_gem_discovery
+        # `:inline` (default) — inject component definitions into each
+        # page's HTML. `:bundle` — emit a single dist/lilac.bundle.html
+        # referenced from pages via `<link rel="lilac-bundle">`. Runtime
+        # registry fetches the bundle and injects templates + evals
+        # scripts before mount.
+        @delivery = delivery
+      end
+
+      def build
+        components = load_components
+        pages = Dir.glob(File.join(@pages_dir, '**', '*.html'))
+        raise Error, "No pages found under #{@pages_dir.inspect}" if pages.empty?
+
+        public_files = mirror_public_files
+
+        template_cache = TemplateASTCache.new
+        build_linter = BuildLinter.new
+        # Resolve and stage package `.mrb` files once for the build —
+        # the URLs are stable across pages so each page's boot module
+        # can reference the same set. PackageStager owns both the
+        # discovered + explicit input channels and the :full-only
+        # `lilac.packages.json` manifest emission.
+        package_dist_urls = PackageStager.new(
+          packages: @packages,
+          target: @target,
+          output_dir: @output_dir,
+          bytecode_builder: bytecode_builder
+        ).run!
+
+        # In :bundle delivery mode, emit a single dist/lilac.bundle.html
+        # containing all components' templates + scripts. Pages then
+        # reference it via <link rel="lilac-bundle">. Done once before
+        # page processing so PageCompiler can inject the <link>.
+        bundle_assets =
+          if @delivery == :bundle
+            BundleAssetWriter.new(
+              components: components,
+              template_cache: template_cache,
+              target: @target,
+              output_dir: @output_dir,
+              bytecode_builder: bytecode_builder
+            ).write!
+          end
+
+        context = BuildContext.new(
+          components: components,
+          bundle_assets: bundle_assets,
+          package_dist_urls: package_dist_urls,
+          template_cache: template_cache,
+          build_linter: build_linter,
+          bytecode_builder: bytecode_builder,
+          target: @target,
+          delivery: @delivery,
+          live_reload: @live_reload,
+          output_dir: @output_dir,
+          pages_dir: @pages_dir,
+        )
+
+        compiler = PageCompiler.new(context)
+        pages.each { |page_path| compiler.compile(page_path) }
+
+        build_linter.warn_cross_page_signature_drift!
+
+        # `:compiled` target needs the runtime (wasm + bridge + boot
+        # helper) sitting under `dist/vendor/lilac-compiled/`. We emit
+        # it from the CLI directly so users don't have to vendor the
+        # npm package by hand. Skipped when no `.mrb` was actually
+        # produced — pages without any Ruby script don't reference the
+        # bootstrap module.
+        auto_vendor_compiled_runtime! if @target == :compiled && Dir.glob(File.join(@output_dir, '*.mrb')).any?
+        # :full vendor — symmetric to :compiled. Strict: raises with an
+        # actionable message when no runtime is discoverable (so an
+        # offline build can't silently ship without its wasm), unless the
+        # assets are already vendored (manual / public-mirror workflow).
+        auto_vendor_full_runtime! if @target == :full
+
+        { pages: pages.length, components: components.length, public_files: public_files }
+      end
+
+      private
+
+      # Mirror `public/**/*` → `output_dir/`. Preserves the relative
+      # directory structure (e.g. `public/vendor/x.js` →
+      # `output_dir/vendor/x.js`). Returns the number of files copied.
+      #
+      # `.gitkeep` is filtered so an empty placeholder file doesn't
+      # land in the build output. Other dot-prefixed files (e.g.
+      # `.well-known/`) are copied so users can publish standard web
+      # conventions.
+      def mirror_public_files
+        return 0 unless @public_dir && File.directory?(@public_dir)
+
+        excluded_dirs = EXCLUDED_DIRS_FOR_TARGET.fetch(@target, [])
+        copied = 0
+        Dir.glob(File.join(@public_dir, '**', '*'), File::FNM_DOTMATCH).each do |source|
+          # File.file? already filters out the `.` / `..` directory
+          # entries that FNM_DOTMATCH surfaces, so no extra guard needed.
+          next unless File.file?(source)
+          next if EXCLUDED_BASENAMES.include?(File.basename(source))
+
+          rel = Pathname.new(source).relative_path_from(Pathname.new(@public_dir)).to_s
+          next if excluded_dirs.any? { |prefix| rel == prefix || rel.start_with?("#{prefix}/") }
+
+          dest = File.join(@output_dir, rel)
+          FileUtils.mkdir_p(File.dirname(dest))
+          FileUtils.cp(source, dest)
+          copied += 1
+        end
+        copied
+      end
+
+      def load_components
+        Dir.glob(File.join(@components_dir, '**', '*.lil')).to_h do |path|
+          [File.basename(path, '.lil'), SFC.parse_file(path)]
+        end
+      end
+
+      # Lazily instantiated so `:full` builds incur no mrbc resolution
+      # cost (`BytecodeBuilder.new` itself is cheap, but keeping the
+      # creation lazy keeps the `:full` happy path obviously side-effect-free).
+      def bytecode_builder
+        @bytecode_builder ||= BytecodeBuilder.new(
+          mrbc_path: @mrbc_path,
+          output_dir: @output_dir,
+          disable_gem_discovery: @disable_gem_discovery
+        )
+      end
+
+      # Lazily resolves the lilac-compiled runtime (wasm + bridge + boot
+      # helper). Constructed only when target=:compiled actually emits a
+      # `.mrb`, mirroring `bytecode_builder`'s "no cost on the happy
+      # :full path" pattern.
+      def compiled_runtime_resolver
+        @compiled_runtime_resolver ||= CompiledRuntimeResolver.new(
+          lilac_compiled_path: @lilac_compiled_path,
+          mruby_wasm_js_path: @mruby_wasm_js_path,
+          disable_gem_discovery: @disable_gem_discovery
+        )
+      end
+
+      # Lazily resolves the lilac-full runtime (wasm + bridge), mirroring
+      # `compiled_runtime_resolver`.
+      def full_runtime_resolver
+        @full_runtime_resolver ||= FullRuntimeResolver.new(
+          lilac_full_path: @lilac_full_path,
+          mruby_wasm_js_path: @mruby_wasm_js_path,
+          disable_gem_discovery: @disable_gem_discovery
+        )
+      end
+
+      # :full target: vendor lilac-full.wasm + bridge into
+      # `dist/vendor/lilac-full/` so the scaffold-generated page
+      # (`import { createVM } from "/vendor/lilac-full/..."`) finds its
+      # runtime assets after `lilac build` — making the dist fully
+      # self-contained / offline-runnable with no CDN.
+      #
+      # Strict, symmetric with `auto_vendor_compiled_runtime!`: raises
+      # `FullRuntimeResolver::Error` (actionable message) when no runtime
+      # can be discovered, rather than silently shipping a dist missing
+      # its runtime. The one exception is the manual-vendor workflow: if
+      # the assets are already present under the vendor dir (e.g. mirrored
+      # from `public/vendor/lilac-full/` — `mirror_public_files` runs
+      # before this — or copied by hand), we skip resolution entirely so
+      # gem-less self-hosting still works.
+      def auto_vendor_full_runtime!
+        return if VendorWriter::REQUIRED_ASSETS[:full]
+                    .each_value.all? { |rel| File.file?(File.join(@output_dir, rel)) }
+
+        VendorWriter.copy!(
+          wasm_src: full_runtime_resolver.resolve_wasm!,
+          bridge_src: full_runtime_resolver.resolve_bridge!,
+          vendor_dir: File.join(@output_dir, 'vendor', 'lilac-full'),
+          wasm_name: 'lilac-full.wasm'
+        )
+      end
+
+      # Emits `dist/vendor/lilac-compiled/{lilac.wasm,mruby-wasm-js/...}`
+      # from the resolved runtime sources. The boot module itself is
+      # rendered inline in the page HTML (see PageCompiler's
+      # render_compiled_boot_module), so we don't need to vendor
+      # `index.js`: the page imports the bridge directly and calls
+      # `loadBytecode` itself.
+      #
+      # Raises `CompiledRuntimeResolver::Error` if a source is missing,
+      # with an actionable message — the caller (the build command) lets
+      # it propagate.
+      def auto_vendor_compiled_runtime!
+        VendorWriter.copy!(
+          wasm_src: compiled_runtime_resolver.resolve_wasm!,
+          bridge_src: compiled_runtime_resolver.resolve_bridge!,
+          vendor_dir: File.join(@output_dir, 'vendor', 'lilac-compiled'),
+          wasm_name: 'lilac.wasm'
+        )
+      end
+
+    end
+  end
+end