tebako 0.14.0 → 0.15.0

data/lib/tebako/cli_helpers.rb

@@ -33,7 +33,9 @@ require "rbconfig"
 require_relative "codegen"
 require_relative "error"
 require_relative "options_manager"
+require_relative "runtime_manager"
 require_relative "scenario_manager"
+require_relative "stitcher"
 require_relative "packager_lite"
 
 # Tebako - an executable packager
@@ -85,10 +87,32 @@ module Tebako
       check_warnings(options_manager)
       puts options_manager.press_announce(scenario_manager.msys?)
 
+      if options_manager.prebuilt_runtime?
+        do_press_prebuilt(options_manager, scenario_manager)
+      else
+        do_press_source(options_manager, scenario_manager)
+      end
+    end
+
+    def do_press_source(options_manager, scenario_manager)
       do_press_runtime(options_manager, scenario_manager)
       do_press_application(options_manager, scenario_manager)
     end
 
+    # Press onto a prebuilt runtime package: resolve (download/verify/cache)
+    # the runtime, deploy the application image, stitch, re-sign on macOS.
+    def do_press_prebuilt(options_manager, scenario_manager)
+      Tebako::Packager.check_prebuilt_env!(options_manager.stash_dir, options_manager.deps_bin_dir)
+      runtime_path = Tebako::RuntimeManager.resolve(options_manager.ruby_ver, options_manager.host_platform)
+      app_image = Tebako::Packager.build_app_image(options_manager, scenario_manager)
+
+      images = [{ path: app_image, mount_point: scenario_manager.fs_mount_point,
+                  format_id: Tebako::Stitcher::FORMAT_DWARFS }] + options_manager.images
+      package = "#{options_manager.package}#{scenario_manager.exe_suffix}"
+      Tebako::Stitcher.stitch(runtime_path, images: images, output: package)
+      puts "Created tebako #{options_manager.output_type_first} at \"#{package}\""
+    end
+
     def do_press_application(options_manager, scenario_manager)
       return unless %w[both application].include?(options_manager.mode)
 

data/lib/tebako/error.rb

@@ -47,6 +47,16 @@ module Tebako
     117 => "Failed to load Gemfile.lock",
     118 => "Bundler version in Gemfile.lock does satisfy minimal Tebako version requirememnts",
     119 => "Failed to find compatible bundler version",
+    120 => "No prebuilt tebako runtime package for the requested Ruby/platform combination",
+    121 => "SHA256 checksum mismatch for downloaded tebako runtime package",
+    122 => "Failed to download tebako runtime package",
+    123 => "TEBAKO_OFFLINE is set and the requested tebako runtime package is not cached",
+    124 => "Runtime package release carries no usable package index",
+    125 => "Timed out waiting for the runtime package cache lock",
+    126 => "Invalid stitch specification",
+    127 => "Stitch input file is not accessible",
+    128 => "Prebuilt runtime press requires the packaging environment (run 'tebako setup' first)",
+    130 => "Option combination is not supported",
     201 => "Warning. Could not create cache version file"
   }.freeze
 

data/lib/tebako/launcher_abi.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2026 [Ribose Inc](https://www.ribose.com).
+# All rights reserved.
+# This file is a part of the Tebako project.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
+# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+module Tebako
+  # Launcher ABI v1 — the bootstrap → runtime handoff contract of the
+  # three-part package model (spec §4.4).
+  #
+  # A lean package is [tebako-bootstrap][.tfs image slots][tpkg trailer].
+  # The bootstrap (tamatebako/tebako-bootstrap) parses the trailer of its own
+  # executable, resolves the language runtime into the shared cache, and
+  # execs it as:
+  #
+  #   <runtime> --tebako-image <file>:<slot>:<mount-point> ...
+  #             --tebako-entry <argv0> <user args...>
+  #
+  # The runtime (a tebako-packaged interpreter built from this repo) consumes
+  # that handoff in src/tebako-main.cpp:
+  #
+  #   --tebako-image <file>:<slot>:<mount-point>
+  #       Repeatable, one per image slot, in slot order. <file> is a package
+  #       file carrying a tpkg manifest trailer (spec §4.3); <slot> is the
+  #       0-based index into that file's slot table; <mount-point> is the
+  #       memfs path the image is mounted at. The runtime reads the trailer
+  #       of <file>, takes the slot's recorded offset/size, and mounts the
+  #       image directly out of <file> — no extraction, no temp copies.
+  #       The image whose mount point equals the runtime's compiled-in
+  #       fs_mount_point becomes the root filesystem (fallback: the first
+  #       image given); the remaining images are mounted as extra slots.
+  #
+  #   --tebako-entry <argv0>
+  #       Not repeatable. <argv0> is the lean package's original argv[0] (a
+  #       host path as invoked by the user — not a path inside the memfs);
+  #       the runtime presents it as the application program name. Every
+  #       argument after <argv0> is application argv and is passed through
+  #       to the interpreter untouched; tebako option scanning stops here.
+  #       The runtime then runs its compiled-in entry point (for prebuilt
+  #       runtimes, the /local/stub.rb dispatcher inside the root image).
+  #
+  #   --tebako-launcher-abi <n>
+  #       Not repeatable, optional. States the launcher ABI version the
+  #       bootstrap speaks; the runtime refuses the handoff when <n> exceeds
+  #       the ABI it supports, naming both versions. tebako-bootstrap v1 does
+  #       not emit this option — it validates the trailer's launcher_abi
+  #       field itself and encodes the ABI in the runtime name it resolves
+  #       (runtime_ref "...;tebako=<abi>") — but the runtime accepts the
+  #       option so the check exists on both sides of the handoff.
+  #
+  # The three option spellings above are exactly what tebako-bootstrap
+  # v1 emits (space-separated values, images before --tebako-entry); the
+  # runtime additionally accepts the --opt=value form of each.
+  #
+  # Versioning: VERSION is bumped whenever the handoff changes incompatibly.
+  # This file is the Ruby-side constant set; src/tebako-main.cpp carries the
+  # matching C++ constants — keep the two in sync.
+  module LauncherAbi
+    # Launcher ABI version implemented by this gem and by tebako-main.cpp
+    VERSION = 1
+
+    # Repeatable: hand one image slot of a package file to the runtime
+    IMAGE_ARG = "--tebako-image"
+
+    # Separator: value is the package argv[0]; the rest is application argv
+    ENTRY_ARG = "--tebako-entry"
+
+    # Optional: launcher ABI version the bootstrap speaks
+    VERSION_ARG = "--tebako-launcher-abi"
+
+    # Format one --tebako-image value per the ABI: "<file>:<slot>:<mount-point>".
+    # (The parser splits on the last two colons, so <file> may itself contain
+    # colons — e.g. Windows drive prefixes.)
+    def self.image_spec(file, slot, mount_point)
+      "#{file}:#{slot}:#{mount_point}"
+    end
+  end
+end

data/lib/tebako/options_manager.rb

@@ -33,6 +33,7 @@ require "rbconfig"
 require_relative "codegen"
 require_relative "error"
 require_relative "ruby_version"
+require_relative "stitcher"
 require_relative "version"
 
 # Tebako - an executable packager
@@ -159,6 +160,39 @@ module Tebako
       @mode ||= @options["mode"].nil? ? "bundle" : @options["mode"]
     end
 
+    # Runtime provenance: "prebuilt" (resolve/download a prebuilt runtime
+    # package and stitch the application image onto it) or "source" (the
+    # Stage-2 source build). Default is "prebuilt" for the bundle mode;
+    # other modes always build from source, and --build-runtime forces the
+    # source path everywhere (back-compat alias for '--runtime source').
+    def runtime_source
+      @runtime_source ||= checked_runtime_source(requested_runtime_source)
+    end
+
+    def prebuilt_runtime?
+      runtime_source == "prebuilt"
+    end
+
+    # Additional images for the stitched package, from repeatable
+    # '--image <path>:<mount-point>' (split on the last colon so Windows
+    # drive-letter paths survive)
+    def images
+      @images ||= Array(@options["image"]).map do |spec|
+        path, _sep, mount = spec.to_s.rpartition(":")
+        if path.empty? || mount.empty?
+          Tebako.packaging_error(130, "invalid --image specification '#{spec}' ('<path>:<mount-point>' expected)")
+        end
+
+        { path: path, mount_point: mount, format_id: Tebako::Stitcher::FORMAT_DWARFS }
+      end
+    end
+
+    # Platform id of the host, as used by tebako-runtime-ruby package names
+    # (e.g. "macos-arm64", "linux-gnu-x86_64")
+    def host_platform(ostype = RUBY_PLATFORM, arch = RbConfig::CONFIG["host_cpu"])
+      @host_platform ||= "#{host_os_id(ostype)}-#{host_arch_id(arch)}"
+    end
+
     def output_folder
       @output_folder ||= File.join(prefix, "o")
     end
@@ -334,5 +368,42 @@ module Tebako
     def stash_dir_all
       @stash_dir_all ||= File.join(deps, "stash")
     end
+
+    private
+
+    def requested_runtime_source
+      explicit = @options["runtime"]
+      return "source" if @options["build-runtime"]
+      return mode == "bundle" ? "prebuilt" : "source" if explicit.nil?
+
+      explicit
+    end
+
+    def checked_runtime_source(source)
+      if source == "prebuilt" && mode != "bundle"
+        Tebako.packaging_error(130, "--runtime prebuilt is supported in bundle mode only (mode: '#{mode}')")
+      end
+      source
+    end
+
+    def host_os_id(ostype)
+      case ostype
+      when /msys|mingw|cygwin/ then "windows"
+      when /darwin/ then "macos"
+      when /linux-musl/ then "linux-musl"
+      when /linux/ then "linux-gnu"
+      else
+        Tebako.packaging_error(112, ostype)
+      end
+    end
+
+    def host_arch_id(arch)
+      case arch
+      when /^(x86_64|amd64)$/ then "x86_64"
+      when /^(aarch64|arm64)$/ then "arm64"
+      else
+        Tebako.packaging_error(112, arch)
+      end
+    end
   end
 end

data/lib/tebako/packager/patch_libraries.rb

@@ -36,37 +36,52 @@ module Tebako
         # rubocop:disable Style/WordArray
         DARWIN_BREW_LIBS = [
           ["zlib", "z"],              ["gdbm", "gdbm"],           ["readline", "readline"], ["libffi", "ffi"],
-          ["ncurses", "ncurses"],     ["lz4", "lz4"],             ["xz", "lzma"],           ["libyaml", "yaml"],
-          ["boost", "boost_chrono"],  ["double-conversion", "double-conversion"]
+          ["ncurses", "ncurses"],     ["lz4", "lz4"],             ["xz", "lzma"],           ["libyaml", "yaml"]
         ].freeze
 
         DARWIN_BREW_LIBS_PRE_31 = [["openssl@1.1", "ssl"], ["openssl@1.1", "crypto"]].freeze
 
         DARWIN_BREW_LIBS_31 = [["openssl@3", "ssl"], ["openssl@3", "crypto"]].freeze
 
-        DARWIN_DEP_LIBS_1 = ["folly", "fsst",   "metadata_thrift", "thrift_light", "xxhash",       "zstd"].freeze
-        DARWIN_DEP_LIBS_2 = ["glog",  "gflags", "brotlienc",       "brotlidec",    "brotlicommon", "fmt"].freeze
+        DARWIN_DEP_LIBS_1 = ["tfs", "tebako_dirent_helper_c"].freeze
+        # Referenced by full path from the vcpkg triplet lib dir (see
+        # darwin_libraries): Apple ld does not implement the GNU-style
+        # -l:<filename> library search, so -l:libX.a refs do not resolve.
+        DARWIN_DEP_LIBS_2 = ["dwarfs_reader", "dwarfs_common", "dwarfs_metadata_legacy",
+                             "dwarfs_decompressor", "flatbuffers", "zip",
+                             "fmt", "xxhash", "zstd",
+                             "brotlidec", "brotlienc", "brotlicommon",
+                             "bz2", "boost_filesystem", "boost_chrono"].freeze
         # rubocop:enable Style/WordArray
 
-        LIBTEBAKOFS = "-Wl,--push-state,--whole-archive -l:libtebako-fs.a -Wl,--pop-state"
-
+        # --start-group/--end-group around the libtfs + transitive static archives:
+        # the dwarfs reader set has circular member-level references that trip GNU
+        # ld's single-pass scanning when built with clang (compression registrar).
+        # libtfs (libtfs.a + its pure-C dirent helper) and the transitive static
+        # set resolved by vcpkg into deps/vcpkg_installed/<triplet>/lib: the
+        # dwarfs reader side, flatbuffers, zip and the C++ support libs.
+        # Compression codecs register explicitly (compression_registry ctor),
+        # so no --whole-archive compression lib is needed anymore.
         COMMON_LINUX_LIBRARIES = [
-          LIBTEBAKOFS,            "-l:libdwarfs-wr.a",          "-l:libdwarfs.a",             "LIBCOMPRESSION",
-          "-l:libfolly.a",        "-l:libfsst.a",               "-l:libmetadata_thrift.a",    "-l:libthrift_light.a",
-          "-l:libxxhash.a",       "-l:libfmt.a",                "-l:libdouble-conversion.a",  "-l:libglog.a",
-          "-l:libgflags.a",       "-l:libevent.a"
+          "-Wl,--push-state,--whole-archive -l:libtebako-fs.a -Wl,--pop-state",
+          "-l:libtfs.a", "-l:libtebako_dirent_helper_c.a",
+          "-l:libdwarfs_reader.a", "-l:libdwarfs_common.a", "-l:libdwarfs_metadata_legacy.a",
+          "-l:libdwarfs_decompressor.a", "-l:libflatbuffers.a", "-l:libzip.a",
+          "-l:libfmt.a", "-l:libxxhash.a", "-l:libboost_filesystem.a",
+          "-l:libboost_chrono.a"
         ].freeze
 
         COMMON_ARCHIEVE_LIBRARIES = [
-          "-l:libarchive.a",     "-l:liblz4.a",        "-l:libz.a",             "-l:libzstd.a",
-          "-l:libbrotlienc.a",   "-l:libbrotlidec.a",  "-l:libbrotlicommon.a",  "-l:liblzma.a"
+          "-l:liblz4.a",           "-l:libz.a",         "-l:libzstd.a",
+          "-l:libbrotlienc.a",     "-l:libbrotlidec.a", "-l:libbrotlicommon.a",
+          "-l:liblzma.a",          "-l:libbz2.a"
         ].freeze
 
         LINUX_GNU_LIBRARIES = [
           "-l:libiberty.a",      "-l:libacl.a",          "-l:libssl.a",           "-l:libcrypto.a",
           "-l:libgdbm.a",        "-l:libreadline.a",     "-l:libtinfo.a",         "-l:libffi.a",
           "-l:libncurses.a",     "-l:libjemalloc.a",     "-l:libcrypt.a",         "-l:libanl.a",
-          "LIBYAML",             "-l:libboost_system.a", "-l:libboost_chrono.a",  "-l:libutil.a",
+          "LIBYAML",             "-l:libutil.a",
           "-l:libstdc++.a",      "-lgcc_eh",             "-l:libunwind.a",        "-l:liblzma.a",
           "-l:librt.a",          "-ldl",                 "-lpthread",             "-lm"
         ].freeze
@@ -74,15 +89,15 @@ module Tebako
         LINUX_MUSL_LIBRARIES = [
           "-l:libiberty.a",       "-l:libacl.a",          "-l:libssl.a",          "-l:libcrypto.a",
           "-l:libreadline.a",     "-l:libgdbm.a",         "-l:libffi.a",          "-l:libncurses.a",
-          "-l:libjemalloc.a",     "-l:libcrypt.a",        "LIBYAML",              "-l:libboost_system.a",
-          "-l:libboost_chrono.a", "-l:librt.a",           "-l:libstdc++.a",       "-lgcc_eh",
-          " -l:libunwind.a",      "-l:liblzma.a",         "-ldl",                 "-lpthread"
+          "-l:libjemalloc.a",     "-l:libcrypt.a",        "LIBYAML",
+          "-l:librt.a",           "-l:libstdc++.a",       "-lgcc_eh",
+          " -l:libunwind.a",      "-l:liblzma.a",         "-ldl", "-lpthread"
         ].freeze
 
         MSYS_LIBRARIES = [
           "-l:liblz4.a",             "-l:libz.a",               "-l:libzstd.a",            "-l:liblzma.a",
           "-l:libncurses.a",         "-l:liblzma.a",            "-l:libiberty.a",          "LIBYAML",
-          "-l:libffi.a",             "-l:libboost_chrono-mt.a", "-l:libstdc++.a",          "-l:libdl.a",
+          "-l:libffi.a",             "-l:libstdc++.a",          "-l:libdl.a",
           "-static-libgcc",          "-static-libstdc++",       "-l:libssl.a",             "-l:libcrypto.a",
           "-l:libz.a",               "-l:libwinpthread.a",      "-lcrypt32",               "-lshlwapi",
           "-lwsock32",               "-liphlpapi",              "-limagehlp",              "-lbcrypt",
@@ -90,21 +105,21 @@ module Tebako
         ].freeze
 
         def linux_gnu_libraries(ruby_ver, with_compression)
-          libraries = COMMON_LINUX_LIBRARIES + COMMON_ARCHIEVE_LIBRARIES + LINUX_GNU_LIBRARIES
+          libraries = ["-Wl,--start-group"] + COMMON_LINUX_LIBRARIES + COMMON_ARCHIEVE_LIBRARIES +
+                      ["-Wl,--end-group"] + LINUX_GNU_LIBRARIES
           linux_libraries(libraries, ruby_ver, with_compression)
         end
 
         def linux_musl_libraries(ruby_ver, with_compression)
-          libraries = COMMON_LINUX_LIBRARIES + COMMON_ARCHIEVE_LIBRARIES + LINUX_MUSL_LIBRARIES
+          libraries = ["-Wl,--start-group"] + COMMON_LINUX_LIBRARIES + COMMON_ARCHIEVE_LIBRARIES +
+                      ["-Wl,--end-group"] + LINUX_MUSL_LIBRARIES
           linux_libraries(libraries, ruby_ver, with_compression)
         end
 
-        def linux_libraries(libraries, ruby_ver, with_compression)
+        def linux_libraries(libraries, ruby_ver, _with_compression)
           libraries.map! do |lib|
             if lib == "LIBYAML"
               PatchHelpers.yaml_reference(ruby_ver)
-            elsif lib == "LIBCOMPRESSION"
-              with_compression ? "-Wl,--push-state,--whole-archive -l:libdwarfs_compression.a -Wl,--pop-state" : ""
             else
               lib
             end
@@ -122,17 +137,22 @@ module Tebako
           brew_libs.each { |lib| libs << "#{PatchHelpers.get_prefix_macos(lib[0]).chop}/lib/lib#{lib[1]}.a " }
         end
 
-        def darwin_libraries(deps_lib_dir, ruby_ver, with_compression)
+        def darwin_libraries(deps_lib_dir, ruby_ver, _with_compression)
           libs = String.new
 
           DARWIN_DEP_LIBS_1.each { |lib| libs << "#{deps_lib_dir}/lib#{lib}.a " }
           process_brew_libs!(libs, ruby_ver.ruby31? ? DARWIN_BREW_LIBS_31 : DARWIN_BREW_LIBS_PRE_31)
           process_brew_libs!(libs, DARWIN_BREW_LIBS)
 
-          DARWIN_DEP_LIBS_2.each { |lib| libs << "#{deps_lib_dir}/lib#{lib}.a " }
-
-          compression_lib = with_compression ? "-force_load #{deps_lib_dir}/libdwarfs_compression.a" : ""
-          "-ltebako-fs -ldwarfs-wr -ldwarfs #{compression_lib} #{libs} -ljemalloc -lc++ -lc++abi"
+          # The vcpkg set by full path: Apple ld does not implement -l:<filename>
+          vcpkg_lib_dir = Dir.glob(File.join(deps_lib_dir, "..", "vcpkg_installed", "*", "lib")).min
+          DARWIN_DEP_LIBS_2.each { |lib| libs << "#{vcpkg_lib_dir}/lib#{lib}.a " }
+          # No allocator link: brew's static libjemalloc.a crashes tebako
+          # binaries at startup on the XCode 15.4 runners (je_arena_ralloc
+          # SEGV at builtin init), and the dylib fails the test_101
+          # no-shared-libs assertion. System malloc until a properly built
+          # static jemalloc ships with libtfs-deps.
+          "-ltebako-fs #{libs}-lc++ -lc++abi"
         end
 
         # .....................................................

data/lib/tebako/packager.rb

@@ -68,7 +68,7 @@ module Tebako
       win32/file.c
     ].freeze
 
-    class << self
+    class << self # rubocop:disable Metrics/ClassLength
       # Create implib
       def create_implib(src_dir, package_src_dir, app_name, ruby_ver)
         a_name = File.basename(app_name, ".*")
@@ -115,6 +115,45 @@ module Tebako
         FileUtils.cp_r "#{stash_dir}/.", src_dir
       end
 
+      # Check that the packaging environment the prebuilt-runtime press
+      # needs (pristine Ruby stash + mkdwarfs) is in place
+      def check_prebuilt_env!(stash_dir, deps_bin_dir)
+        missing = []
+        missing << "Ruby environment stash (#{stash_dir})" unless Dir.exist?(stash_dir)
+        missing << "mkdwarfs (#{deps_bin_dir})" if Dir.glob(File.join(deps_bin_dir, "mkdwarfs*")).empty?
+        return if missing.empty?
+
+        Tebako.packaging_error(128, missing.join(", "))
+      end
+
+      # Deploy the application and build its DwarFS image for stitching onto
+      # a prebuilt runtime. Same layout as the bundle-mode image, plus an
+      # entry dispatcher at /local/stub.rb (the runtime's compiled-in entry).
+      def build_app_image(options_manager, scenario_manager) # rubocop:disable Metrics/AbcSize
+        init(options_manager.stash_dir, options_manager.data_src_dir, options_manager.data_pre_dir,
+             options_manager.data_bin_dir)
+        deploy(options_manager.data_src_dir, options_manager.data_pre_dir, options_manager.rv,
+               options_manager.root, scenario_manager.fs_entrance, options_manager.cwd)
+        write_entry_dispatcher(options_manager.data_src_dir, scenario_manager, options_manager.cwd)
+        mkdwarfs(options_manager.deps_bin_dir, options_manager.data_bundle_file, options_manager.data_src_dir)
+        options_manager.data_bundle_file
+      end
+
+      # The prebuilt runtime packages are pressed in 'runtime' mode, so their
+      # compiled-in entry point is /local/stub.rb. A stitched package mounts
+      # the application image as the root filesystem; the dispatcher written
+      # here receives control from the runtime and loads the real entry point
+      # (replicating the bundle-mode working directory when --cwd was given).
+      def write_entry_dispatcher(data_src_dir, scenario_manager, cwd)
+        dispatcher = +""
+        dispatcher << "Dir.chdir(\"#{scenario_manager.fs_mount_point}/#{cwd}\")\n" unless cwd.nil?
+        dispatcher << "load \"#{scenario_manager.fs_mount_point}#{scenario_manager.fs_entry_point}\"\n"
+
+        local_dir = File.join(data_src_dir, "local")
+        FileUtils.mkdir_p(local_dir)
+        File.write(File.join(local_dir, "stub.rb"), dispatcher)
+      end
+
       def mkdwarfs(deps_bin_dir, data_bin_file, data_src_dir, descriptor = nil)
         puts "-- Running mkdwarfs script"
         FileUtils.chmod("a+x", Dir.glob(File.join(deps_bin_dir, "mkdwarfs*")))