@spec build(
  atom(),
  keyword()
) :: {:ok, map()} | MobDev.Release.Errors.t()

Stage + tar the per-target OTP runtime tarball. Returns {:ok, info} naming the produced tarball + final size, or a tagged error.

Options:

• :otp_src — OTP source checkout (default: $OTP_SRC env or ~/code/otp)
• :otp_release — install tree from MobDev.Release.OTP.build/2 (default: target's default_otp_release)
• :openssl_prefix — OpenSSL install dir (default per-target)
• :exqlite_build — _build/dev/lib/exqlite in any project (required for Android targets; ignored for iOS)
• :android_otp_release — used by iOS targets to borrow crypto apps (default: /tmp/otp-android)
• :asn1rt_nif_arm32 — pre-built arm32 asn1rt_nif.a (Android arm32 only; default: /tmp/asn1rt_nif_arm32.a)
• :out_dir — tarball output (default: /tmp)
• :hash — release hash (default: detected from OTP source git)

@spec build_all(keyword()) :: [{atom(), {:ok, map()} | MobDev.Release.Errors.t()}]

Build all four tarballs in sequence. Each target picks up its own defaults. Returns [{target_id, result}, ...] in canonical order. Doesn't short-circuit.

@spec check_entries(binary(), [String.t()], Path.t()) ::
  :ok | MobDev.Release.Errors.t()

Scan a tar tzf listing and confirm every expected pattern matches at least one entry. Patterns are treated as regex (matching the shell's grep -q semantics). Public for tests.

@spec detect_exqlite_version(Path.t()) ::
  {:ok, String.t()} | MobDev.Release.Errors.t()

Detect the exqlite version by reading mix.lock (preferred) or <exqlite_build>/ebin/exqlite.app (fallback). Returns {:ok, vsn}.

exqlite_build is the path to _build/dev/lib/exqlite/ in any Mob project that has run mix deps.get && mix compile.

Project root lookup: mix.lock lives 4 levels up from _build/dev/lib/exqlite/ — that's the project root convention every Hex umbrella uses.

@spec parse_exqlite_version_from_app_file(binary()) ::
  {:ok, String.t()} | MobDev.Release.Errors.t()

Parse the vsn field out of an exqlite.app file's content. Fallback for when mix.lock isn't available (rare, but the shell version handled it). Returns {:ok, version} or a tagged error.

@spec parse_exqlite_version_from_lock(binary()) ::
  {:ok, String.t()} | MobDev.Release.Errors.t()

Parse the exqlite package version out of a mix.lock string. Returns {:ok, version} or a tagged error.

Public for testing — silent parse failures here would silently bundle no exqlite, then user apps die at runtime with :undef.

@spec required_entries(MobDev.Release.Tarball.Target.t(), map()) :: [String.t()]

Per-target required entries. Public for testing — pinning the list is the surface lock that prevents silent drops.

ERTS version interpolation happens against env.erts_vsn.

@spec tarball_path(MobDev.Release.Tarball.Target.t(), Path.t(), String.t()) ::
  Path.t()

Final tarball path: <out_dir>/<basename>-<hash>.tar.gz. Public for testing — basename drift breaks the downloader's cache.

@spec target_spec(atom()) :: MobDev.Release.Tarball.Target.t()

Per-target spec. Public for testing — surface lock-down for tarball naming (changing the basename breaks the downloader's cache), the iOS borrow-from-Android decision, and the per-target verify list.

@spec targets() :: [atom()]

All tarball targets, in canonical order.

@spec verify_tarball(
  MobDev.Release.Tarball.Target.t(),
  MobDev.Release.Shell.t() | module(),
  map(),
  Path.t()
) :: :ok | MobDev.Release.Errors.t()

Verify the produced tarball contains every required entry. Returns :ok or a precondition_failed naming the missing entry.

Universal entries (every target):

• erts-<vsn>/ directory entry
• lib/elixir/ebin/elixir.app
• erts-<vsn>/lib/crypto.a
• erts-<vsn>/lib/libcrypto.a

Per-target additions come from target.additional_verifies.