All right, I figured out where I needed to make this change for it to take effect. The relevant script is publ-aut.lua. The code I needed to change was for the "oneauthor" function definition, which itself is located in the "btxauthor" function definition. My changes are detailed below:

```
        local function oneauthor(i,last,justone)
            local author = split[i]
            if index then
                ctx_btxstartauthor(i,1,0)
            elseif last then
                ctx_btxstartauthor(i,1,0)
                ctx_btxsetconcat(0)
                if combiner == "invertedfirst" then
                    if i == 1 then
                        ctx_btxsetauthorvariant("inverted")
                    else
                        ctx_btxsetauthorvariant("normal")
                    end
                else
                    ctx_btxsetauthorvariant(combiner)
                end
            else
                local state = author.state or 0
                ctx_btxstartauthor(i,max,state)
                ctx_btxsetconcat(concatstate(i,max))
                if combiner == "invertedfirst" then
                    if i == 1 then
                        ctx_btxsetauthorvariant("inverted")
                    else
                        ctx_btxsetauthorvariant("normal")
                    end
                else
                    ctx_btxsetauthorvariant(combiner)
                end
            end
            local initials = author.initials
            if initials and #initials > 0 then
                ctx_btxsetinitials() -- (concat(the_initials(initials,symbol)," "))
            end
            local firstnames = author.firstnames
            if firstnames and #firstnames > 0 then
                ctx_btxsetfirstnames() -- (concat(firstnames," "))
            end
            local vons = author.vons
            if vons and #vons > 0 then
                ctx_btxsetvons() -- (concat(vons," "))
            end
            local surnames = author.surnames
            if surnames and #surnames > 0 then
                ctx_btxsetsurnames() -- (concat(surnames," "))
            end
            local juniors = author.juniors
            if juniors and #juniors > 0 then
                ctx_btxsetjuniors() -- (concat(juniors," "))
            end
            if not index and i == max then
                if split.others then
                    ctx_btxsetoverflow(1)
                else
                    local overflow = #split - max
                    if overflow > 0 then
                        ctx_btxsetoverflow(overflow)
                    end
                end
            end
            if combiner == "invertedfirst" then
                if i == 1 then
                    ctx_btxsetup("inverted")
                else
                    ctx_btxsetup("normal")
                end
            else
                ctx_btxsetup(combiner)
            end
            ctx_btxstopauthor()
        end
```

I'll admit that the addition of entire if-else blocks around whether or not the combiner is a specific value may not be the best practice in terms of future maintenance (especially if similar index-dependent authorconversions are needed in the future). Alternatively, the "btxauthor" function could populate a "combiners" array of length "max" with a specific authorconversion for each author in the split; for most authorconversions, all entries in this array would be the same, but for authorconversions like "invertedfirst", the first entry would be different from the rest. Then, the "oneauthor" function could just reference combiners[i] instead of combiner.

Joey

On Fri, Sep 3, 2021 at 10:48 PM Joey McCollum <jmccollum20140511@gmail.com> wrote:
Hi,

I mentioned this in an earlier e-mail but thought that now might be a good time to describe this issue in detail. I'd like to define a new authorconversion that renders the first author in a list differently than the remaining authors in the list. Specifically, I'd like to use the "inverted" authorconversion for the first author and the "normal" authorconversion for the rest.

In the newer bibl-bib.lua file, I can see what I might have to modify to accomplish this (I added the  if combiner == "invertedfirst"  block):

```
function authors.concat(author,combiner,what,settings)
    if type(combiner) == "string" then
        combiner = authors[combiner or "normal"] or authors.normal
    end
    local split = splitauthors(author)
    local setting = settings[what]
    local etallimit, etaldisplay, etaltext = 1000, 1000, ""
    if setting then
        etallimit   = settings.etallimit   or 1000
        etaldisplay = settings.etaldisplay or etallimit
        etalltext   = settings.etaltext    or ""
    end
    local max = #split
    if max > etallimit and etaldisplay < max then
        max = etaldisplay
    end
    if combiner == "invertedfirst" then
        for i=1,max do
            if i == 1 then
                split[i] = authors.inverted(split[i],settings)
            else
                split[i] = authors.normal(split[i],settings)
            end
           
        end
    else
        for i=1,max do
            split[i] = combiner(split[i],settings)
        end
    end
    local result = bibtexconcat(split,settings)
    if max < #split then
        return result
    else
        return result .. etaltext
    end
end
```

Unfortunately, this doesn't seem to do anything. It's not clear to me how bibl-bib.lua and bibl-bib.mkiv are being used by the other publication support modules, if they're being used at all (publ-ini.mkiv doesn't appear to register it, anyway). Is there another file I'd have to change to make "invertedfirst" a working authorconversion? Is there a similar block of code in publ-ini.lua where I should be implementing this change instead?

Thanks!

Joey