macOS 终端配置（二）：主题美化

// Gentle glow + subtle chromatic aberration shader with transparency support
// Based on glow-rgbsplit-twitchy.glsl but with:
//   - Greatly reduced, smooth chromatic aberration (no twitchy jitter)
//   - Transparent background preserved (alpha passthrough)

// ======== 可调参数 ========

// 色散(RGB分离)强度，0.0 = 无色散，0.008 = 微弱，0.05 = 原版强度
const float ABERRATION_STRENGTH = 0.008;

// 色散抖动速度，越大越快；0.0 = 完全静止
const float ABERRATION_SPEED = 0.8;

// 色散抖动幅度，0.0 = 恒定不变，0.3 = 轻微波动
const float ABERRATION_AMPLITUDE = 0.3;

// 文字自身亮度增强倍数，1.0 = 不增强，1.2 = 默认，1.5 = 很亮
const float TEXT_BRIGHTNESS = 1.2;

// Glow 扩散半径，越大光晕越宽；1.414 = 默认，2.5 = 大范围，0.8 = 紧凑
const float GLOW_RADIUS = 1.414;

// Glow 色彩扩散强度，越大颜色光晕越浓；0.3 = 默认
const float GLOW_COLOR_STRENGTH = 0.3;

// 暗文字 glow 亮度权重；0.05 = 默认
const float GLOW_DIM_WEIGHT = 0.05;

// 亮文字 glow 亮度权重；0.10 = 默认
const float GLOW_BRIGHT_WEIGHT = 0.10;

// 暗/亮分界阈值 — 低于此值的像素接受 glow，高于的自身增亮
const float DIM_CUTOFF = 0.35;

// 亮度上限阈值 — 超过此值的邻居贡献更强 glow
const float BRIGHT_CUTOFF = 0.65;

// ======== 参数结束 ========

// sRGB linear -> nonlinear transform from https://bottosson.github.io/posts/colorwrong/
float f(float x) {
    if (x >= 0.0031308) {
        return 1.055 * pow(x, 1.0 / 2.4) - 0.055;
    } else {
        return 12.92 * x;
    }
}

float f_inv(float x) {
    if (x >= 0.04045) {
        return pow((x + 0.055) / 1.055, 2.4);
    } else {
        return x / 12.92;
    }
}

// Oklab <-> linear sRGB conversions from https://bottosson.github.io/posts/oklab/
vec4 toOklab(vec4 rgb) {
    vec3 c = vec3(f_inv(rgb.r), f_inv(rgb.g), f_inv(rgb.b));
    float l = 0.4122214708 * c.r + 0.5363325363 * c.g + 0.0514459929 * c.b;
    float m = 0.2119034982 * c.r + 0.6806995451 * c.g + 0.1073969566 * c.b;
    float s = 0.0883024619 * c.r + 0.2817188376 * c.g + 0.6299787005 * c.b;
    float l_ = pow(l, 1.0 / 3.0);
    float m_ = pow(m, 1.0 / 3.0);
    float s_ = pow(s, 1.0 / 3.0);
    return vec4(
        0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_,
        1.9779984951 * l_ - 2.4285922050 * m_ + 0.4505937099 * s_,
        0.0259040371 * l_ + 0.7827717662 * m_ - 0.8086757660 * s_,
        rgb.a
    );
}

vec4 toRgb(vec4 oklab) {
    vec3 c = oklab.rgb;
    float l_ = c.r + 0.3963377774 * c.g + 0.2158037573 * c.b;
    float m_ = c.r - 0.1055613458 * c.g - 0.0638541728 * c.b;
    float s_ = c.r - 0.0894841775 * c.g - 1.2914855480 * c.b;
    float l = l_ * l_ * l_;
    float m = m_ * m_ * m_;
    float s = s_ * s_ * s_;
    vec3 linear_srgb = vec3(
         4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
        -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
        -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s
    );
    return vec4(
        clamp(f(linear_srgb.r), 0.0, 1.0),
        clamp(f(linear_srgb.g), 0.0, 1.0),
        clamp(f(linear_srgb.b), 0.0, 1.0),
        oklab.a
    );
}

// Bloom samples from https://gist.github.com/qwerasd205/c3da6c610c8ffe17d6d2d3cc7068f17f
const vec3[24] samples = {
  vec3(0.1693761725038636, 0.9855514761735895, 1),
  vec3(-1.333070830962943, 0.4721463328627773, 0.7071067811865475),
  vec3(-0.8464394909806497, -1.51113870578065, 0.5773502691896258),
  vec3(1.554155680728463, -1.2588090085709776, 0.5),
  vec3(1.681364377589461, 1.4741145918052656, 0.4472135954999579),
  vec3(-1.2795157692199817, 2.088741103228784, 0.4082482904638631),
  vec3(-2.4575847530631187, -0.9799373355024756, 0.3779644730092272),
  vec3(0.5874641440200847, -2.7667464429345077, 0.35355339059327373),
  vec3(2.997715703369726, 0.11704939884745152, 0.3333333333333333),
  vec3(0.41360842451688395, 3.1351121305574803, 0.31622776601683794),
  vec3(-3.167149933769243, 0.9844599011770256, 0.30151134457776363),
  vec3(-1.5736713846521535, -3.0860263079123245, 0.2886751345948129),
  vec3(2.888202648340422, -2.1583061557896213, 0.2773500981126146),
  vec3(2.7150778983300325, 2.5745586041105715, 0.2672612419124244),
  vec3(-2.1504069972377464, 3.2211410627650165, 0.2581988897471611),
  vec3(-3.6548858794907493, -1.6253643308191343, 0.25),
  vec3(1.0130775986052671, -3.9967078676335834, 0.24253562503633297),
  vec3(4.229723673607257, 0.33081361055181563, 0.23570226039551587),
  vec3(0.40107790291173834, 4.340407413572593, 0.22941573387056174),
  vec3(-4.319124570236028, 1.159811599693438, 0.22360679774997896),
  vec3(-1.9209044802827355, -4.160543952132907, 0.2182178902359924),
  vec3(3.8639122286635708, -2.6589814382925123, 0.21320071635561041),
  vec3(3.3486228404946234, 3.4331800232609, 0.20851441405707477),
  vec3(-2.8769733643574344, 3.9652268864187157, 0.20412414523193154)
};

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    vec2 uv = fragCoord.xy / iResolution.xy;

    float amount = 1.0 + ABERRATION_AMPLITUDE * sin(iTime * ABERRATION_SPEED);

    // Sample original pixel alpha for transparency
    vec4 origSample = texture(iChannel0, uv);
    float alpha = origSample.a;

    // If fully transparent, pass through immediately
    if (alpha < 0.001) {
        fragColor = vec4(0.0);
        return;
    }

    // Subtle chromatic aberration
    vec3 col;
    col.r = texture(iChannel0, vec2(uv.x - ABERRATION_STRENGTH * amount / iResolution.x, uv.y)).r;
    col.g = origSample.g;
    col.b = texture(iChannel0, vec2(uv.x + ABERRATION_STRENGTH * amount / iResolution.x, uv.y)).b;

    vec4 splittedColor = vec4(col, alpha);
    vec4 source = toOklab(splittedColor);
    vec4 dest = source;

    if (source.x > DIM_CUTOFF) {
        dest.x *= TEXT_BRIGHTNESS;
    } else {
        vec2 step = vec2(GLOW_RADIUS) / iResolution.xy;
        vec3 glow = vec3(0.0);
        for (int i = 0; i < 24; i++) {
            vec3 s = samples[i];
            float weight = s.z;
            vec4 neighborTexel = texture(iChannel0, uv + s.xy * step);
            // Only glow from non-transparent neighbors
            if (neighborTexel.a < 0.001) continue;
            vec4 c = toOklab(neighborTexel);
            if (c.x > DIM_CUTOFF) {
                glow.yz += c.yz * weight * GLOW_COLOR_STRENGTH;
                if (c.x <= BRIGHT_CUTOFF) {
                    glow.x += c.x * weight * GLOW_DIM_WEIGHT;
                } else {
                    glow.x += c.x * weight * GLOW_BRIGHT_WEIGHT;
                }
            }
        }
        dest.xyz += glow.xyz;
    }

    vec4 result = toRgb(dest);
    // Preserve original alpha so Ghostty transparency works
    fragColor = vec4(result.rgb, alpha);
}

// cursor-catppuccin-trail.glsl
// Parallelogram cursor trail for Ghostty — works globally in all programs including Neovim.
//
// Why it works in Neovim (unlike cursor_blaze.glsl):
//   1. Uses UV coordinate system (0~1) from in-game-crt-cursor.glsl, which is
//      proven compatible with how Ghostty reports cursor position inside Neovim.
//   2. No hard distance cutoff — trail brightness scales proportionally with
//      movement distance, so even single h/j/k/l presses show a faint trail.
//      Large jumps (gg, G, /, w, b…) show a brighter, fuller trail.
//
// Shape: same parallelogram as cursor_blaze.glsl — same width as block cursor,
//        connecting previous position to current position as a straight streak.
//
// Blend: pure additive — only ever brightens pixels, NEVER darkens anything.
//
// Colors: Catppuccin Macchiato palette.


// ── Trail fill color ──────────────────────────────────────────────────────────
// Uncomment ONE line. The color that fills the parallelogram body.
const vec3 TRAIL_COLOR = vec3(0.792, 0.741, 0.973);  // Lavender-Mauve #caa0f8  ← default, soft purple-white
// const vec3 TRAIL_COLOR = vec3(0.788, 0.824, 0.961);  // Text         #c9d2f5  — near-white, closest to body text
// const vec3 TRAIL_COLOR = vec3(1.000, 1.000, 1.000);  // Pure white              — maximum contrast, classic neon
// const vec3 TRAIL_COLOR = vec3(0.694, 0.749, 0.973);  // Lavender     #b1bff8  — cool blue-white
// const vec3 TRAIL_COLOR = vec3(0.541, 0.678, 0.957);  // Blue         #8aadf4  — clearly blue, clean
// const vec3 TRAIL_COLOR = vec3(0.545, 0.835, 0.792);  // Teal         #8bd5ca  — cyan-green
// const vec3 TRAIL_COLOR = vec3(0.357, 0.839, 0.898);  // Sky          #5bd7e5  — bright cyan
// const vec3 TRAIL_COLOR = vec3(0.784, 0.627, 0.965);  // Mauve        #c6a0f6  — purple


// ── Settings ──────────────────────────────────────────────────────────────────

// How long the trail stays visible after the cursor stops (seconds).
const float DURATION = 0.5;

// Overall brightness of the trail (0.0 ~ 1.0).
const float BRIGHTNESS = 0.75;

// Minimum movement in UV units before any trail appears.
// 0.003 ≈ sub-pixel jitter filter — effectively shows on every character movement,
// including single h/j/k/l presses in Neovim.
// Raise to 0.01+ to only show on multi-character jumps.
const float MIN_DISTANCE = 0.003;


// ── SDF helpers ───────────────────────────────────────────────────────────────

float _seg(in vec2 p, in vec2 a, in vec2 b, inout float s, float d) {
    vec2 e = b - a, w = p - a;
    vec2 proj = a + e * clamp(dot(w, e) / (dot(e, e) + 1e-9), 0.0, 1.0);
    d = min(d, dot(p - proj, p - proj));
    float c0 = step(0.0, p.y - a.y);
    float c1 = 1.0 - step(0.0, p.y - b.y);
    float c2 = 1.0 - step(0.0, e.x * w.y - e.y * w.x);
    float allC  = c0 * c1 * c2;
    float noneC = (1.0 - c0) * (1.0 - c1) * (1.0 - c2);
    s *= mix(1.0, -1.0, step(0.5, allC + noneC));
    return d;
}

float sdfParallelogram(vec2 p, vec2 v0, vec2 v1, vec2 v2, vec2 v3) {
    float s = 1.0, d = dot(p - v0, p - v0);
    d = _seg(p, v0, v3, s, d);
    d = _seg(p, v1, v0, s, d);
    d = _seg(p, v2, v1, s, d);
    d = _seg(p, v3, v2, s, d);
    return s * sqrt(d);
}

// Anti-aliased edge: 1.0 inside shape, 0.0 outside, smooth over ~1.5 pixels.
float aaMask(float sdf) {
    float aaWidth = 1.5 / min(iResolution.x, iResolution.y);
    return 1.0 - smoothstep(0.0, aaWidth, sdf);
}

// Smooth s-curve for progress animation.
float blendCurve(float t) {
    float s = t * t;
    return s / (2.0 * (s - t) + 1.0);
}

// Returns 0.0 or 1.0 to pick which corner of the cursor block leads the trail,
// ensuring the parallelogram connects prev→curr cleanly for any movement direction.
float startCorner(vec2 curr, vec2 prev) {
    float c1 = step(curr.x, prev.x) * step(prev.y, curr.y);  // moved left+up
    float c2 = step(prev.x, curr.x) * step(curr.y, prev.y);  // moved right+down
    return 1.0 - max(c1, c2);
}


// ── Main ──────────────────────────────────────────────────────────────────────

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    // UV coordinate system — same convention as in-game-crt-cursor.glsl.
    // Both fragCoord and iCurrentCursor use OpenGL pixel space (y=0 at bottom),
    // so dividing by iResolution gives a consistent [0,1] UV for both.
    vec2 uv = fragCoord.xy / iResolution.xy;
    fragColor = texture(iChannel0, uv);

    // Cursor positions in UV space.
    // xy = top edge of cursor block; center = top + (halfWidth, -halfHeight).
    vec2 currPos  = iCurrentCursor.xy  / iResolution.xy;
    vec2 currSize = iCurrentCursor.zw  / iResolution.xy;
    vec2 prevPos  = iPreviousCursor.xy / iResolution.xy;
    vec2 prevSize = iPreviousCursor.zw / iResolution.xy;

    vec2 currCenter = currPos + currSize * vec2( 0.5, -0.5);
    vec2 prevCenter = prevPos + prevSize * vec2( 0.5, -0.5);

    float dist = distance(currCenter, prevCenter);
    if (dist < MIN_DISTANCE) return;

    // Exponential fade after cursor stops.
    float age   = iTime - iTimeCursorChange;
    float tFade = exp(-age * (4.5 / DURATION));
    if (tFade < 0.002) return;

    // Progress along animation curve (0→1 over DURATION seconds).
    float progress = blendCurve(clamp(age / DURATION, 0.0, 1.0));

    // Parallelogram corners — same width as the block cursor.
    // Top of cursor in OpenGL coords = currPos.y; bottom = currPos.y - currSize.y.
    float cf  = startCorner(currCenter, prevCenter);
    float icf = 1.0 - cf;

    vec2 v0 = vec2(currPos.x + currSize.x * cf,  currPos.y - currSize.y);  // curr bottom-A
    vec2 v1 = vec2(currPos.x + currSize.x * icf, currPos.y);               // curr top-B
    vec2 v2 = vec2(prevPos.x + currSize.x * icf, prevPos.y);               // prev top-B
    vec2 v3 = vec2(prevPos.x + currSize.x * cf,  prevPos.y - prevSize.y);  // prev bottom-A

    float sdfTrail = sdfParallelogram(uv, v0, v1, v2, v3);
    float bodyMask = aaMask(sdfTrail);

    // headFade: bright at new cursor position, fades toward old position.
    float headFade = 1.0 - clamp(distance(uv, currCenter) / (dist + 1e-9), 0.0, 1.0);

    // distScale: tiny movements produce a faint trail; large jumps produce full brightness.
    // Saturates at ~8-character jump distance. Minimum 0.15 so even h/l shows something.
    float distScale = clamp(dist / (currSize.x * 8.0), 0.15, 1.0);

    // ── Additive blend — only brightens, never darkens ────────────────────────
    vec3 glow = TRAIL_COLOR * bodyMask * BRIGHTNESS * tFade * headFade * distScale;
    fragColor.rgb = min(fragColor.rgb + glow, vec3(1.0));
}

#!/opt/homebrew/bin/bash
set -euo pipefail

# Resolve the directory where this script (and the shaders) live
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Ghostty config path — override with GHOSTTY_CONFIG env var if needed
GHOSTTY_CONFIG="${GHOSTTY_CONFIG:-$HOME/.config/ghostty/config}"

# ---------- Shader discovery ----------

discover_shaders() {
    local shaders=()
    # .glsl files
    for f in "$SCRIPT_DIR"/*.glsl; do
        [[ -f "$f" ]] && shaders+=("$(basename "$f")")
    done
    # Extensionless files containing mainImage (e.g. auto-tracking-spotlight)
    for f in "$SCRIPT_DIR"/*; do
        [[ -f "$f" ]] || continue
        local name
        name="$(basename "$f")"
        # Skip .glsl (already found), skip dotfiles, skip known non-shaders
        [[ "$name" == *.* ]] && continue
        if grep -q 'mainImage' "$f" 2>/dev/null; then
            shaders+=("$name")
        fi
    done
    printf '%s\n' "${shaders[@]}" | sort
}

# ---------- Config helpers ----------

ensure_config() {
    local dir
    dir="$(dirname "$GHOSTTY_CONFIG")"
    if [[ ! -d "$dir" ]]; then
        mkdir -p "$dir"
    fi
    if [[ ! -f "$GHOSTTY_CONFIG" ]]; then
        touch "$GHOSTTY_CONFIG"
    fi
}

# Return ALL custom-shader paths from config, one per line, in order.
get_current_shaders() {
    if [[ ! -f "$GHOSTTY_CONFIG" ]]; then
        return
    fi
    grep '^custom-shader' "$GHOSTTY_CONFIG" | sed 's/^custom-shader[[:space:]]*=[[:space:]]*//' || true
}

# Return only the last custom-shader path (backward compat wrapper).
get_current_shader() {
    get_current_shaders | tail -1
}

# Atomically update the config: remove all custom-shader lines, append new ones.
# Pass zero or more absolute paths as arguments. Zero args = remove all.
update_config() {
    ensure_config

    local tmpfile
    tmpfile="$(dirname "$GHOSTTY_CONFIG")/.config.tmp.$$"

    # Remove existing custom-shader lines
    grep -v '^custom-shader' "$GHOSTTY_CONFIG" > "$tmpfile" || true

    # Remove trailing blank lines from temp file, then ensure single trailing newline
    sed -i '' -e :a -e '/^\n*$/{$d;N;ba' -e '}' "$tmpfile" 2>/dev/null || true
    # Ensure file ends with newline
    if [[ -s "$tmpfile" ]] && [[ "$(tail -c 1 "$tmpfile" | wc -l)" -eq 0 ]]; then
        echo "" >> "$tmpfile"
    fi

    # Append new shader lines
    for path in "$@"; do
        if [[ -n "$path" ]]; then
            echo "custom-shader = $path" >> "$tmpfile"
        fi
    done

    mv "$tmpfile" "$GHOSTTY_CONFIG"
}

# ---------- Name resolution ----------

resolve_shader() {
    local input="$1"
    local shaders
    shaders="$(discover_shaders)"

    # 1. Exact filename match
    if echo "$shaders" | grep -qx "$input"; then
        echo "$input"
        return
    fi

    # 2. Append .glsl
    if echo "$shaders" | grep -qx "${input}.glsl"; then
        echo "${input}.glsl"
        return
    fi

    # 3. Case-insensitive exact match
    local ci_match
    ci_match="$(echo "$shaders" | grep -ix "$input" || true)"
    if [[ -n "$ci_match" ]]; then
        local count
        count="$(echo "$ci_match" | wc -l | tr -d ' ')"
        if [[ "$count" -eq 1 ]]; then
            echo "$ci_match"
            return
        fi
    fi

    # 3b. Case-insensitive with .glsl appended
    ci_match="$(echo "$shaders" | grep -ix "${input}.glsl" || true)"
    if [[ -n "$ci_match" ]]; then
        local count
        count="$(echo "$ci_match" | wc -l | tr -d ' ')"
        if [[ "$count" -eq 1 ]]; then
            echo "$ci_match"
            return
        fi
    fi

    # 4. Prefix match (case-insensitive)
    local prefix_matches
    prefix_matches="$(echo "$shaders" | grep -i "^${input}" || true)"
    if [[ -n "$prefix_matches" ]]; then
        local count
        count="$(echo "$prefix_matches" | wc -l | tr -d ' ')"
        if [[ "$count" -eq 1 ]]; then
            echo "$prefix_matches"
            return
        fi
        echo "error:Ambiguous prefix match for '$input'. Matches:" >&2
        echo "$prefix_matches" | sed 's/^/  /' >&2
        return 1
    fi

    # 5. Substring match (case-insensitive)
    local sub_matches
    sub_matches="$(echo "$shaders" | grep -i "${input}" || true)"
    if [[ -n "$sub_matches" ]]; then
        local count
        count="$(echo "$sub_matches" | wc -l | tr -d ' ')"
        if [[ "$count" -eq 1 ]]; then
            echo "$sub_matches"
            return
        fi
        echo "error:Ambiguous substring match for '$input'. Matches:" >&2
        echo "$sub_matches" | sed 's/^/  /' >&2
        return 1
    fi

    echo "error:No shader found matching '$input'" >&2
    return 1
}

# ---------- Preview helper ----------

preview_path() {
    local shader_name="$1"
    local base="${shader_name%.glsl}"
    for ext in png jpg gif; do
        if [[ -f "$SCRIPT_DIR/theme/${base}.${ext}" ]]; then
            echo "$SCRIPT_DIR/theme/${base}.${ext}"
            return
        fi
    done
    echo ""
}

# ---------- Interactive pickers ----------

# fzf-based multi-select shader picker.
# Active shaders are placed first and pre-selected via start binding.
# Outputs selected shader names, one per line.
fzf_pick_shaders() {
    local shaders
    shaders="$(discover_shaders)"

    # Build active shader lookup
    declare -A active_map
    local active_lines
    active_lines="$(get_current_shaders)"
    if [[ -n "$active_lines" ]]; then
        while IFS= read -r apath; do
            local aname
            aname="$(basename "$apath")"
            active_map["$aname"]=1
        done <<< "$active_lines"
    fi

    # Build ordered input: active shaders first, then inactive (each group sorted)
    local active_items=()
    local inactive_items=()
    while IFS= read -r shader; do
        if [[ -n "${active_map[$shader]+x}" ]]; then
            active_items+=("$shader")
        else
            inactive_items+=("$shader")
        fi
    done <<< "$shaders"

    local num_active=${#active_items[@]}
    local fzf_input=""
    for s in "${active_items[@]}"; do
        fzf_input+="$s"$'\n'
    done
    for s in "${inactive_items[@]}"; do
        fzf_input+="$s"$'\n'
    done
    fzf_input="${fzf_input%$'\n'}"

    # Build load action: toggle first N items to pre-select active shaders.
    # Uses 'load' event (fires after input is fully loaded) so toggle has items to act on.
    local load_action="first"
    if [[ $num_active -gt 0 ]]; then
        load_action=""
        for ((i=0; i<num_active; i++)); do
            load_action+="toggle+down+"
        done
        load_action+="first"
    fi

    local selections
    selections="$(echo "$fzf_input" | fzf \
        --multi \
        --no-sort \
        --preview "head -30 '$SCRIPT_DIR/{1}' 2>/dev/null || echo 'No preview available'" \
        --header 'Tab: select/deselect  Ctrl-A: all  Ctrl-D: deselect all  Enter: confirm  Esc: cancel' \
        --layout=reverse \
        --border \
        --border-label=' Ghostty Shaders ' \
        --bind 'ctrl-a:select-all,ctrl-d:deselect-all' \
        --bind "load:${load_action}" \
    )" || {
        echo "Selection cancelled." >&2
        return 1
    }

    if [[ -z "$selections" ]]; then
        echo "Selection cancelled." >&2
        return 1
    fi

    echo "$selections"
}

# Numbered-list fallback picker when fzf is not available.
# Outputs selected shader names, one per line.
fallback_pick_shaders() {
    local shaders
    shaders="$(discover_shaders)"

    # Build active shader lookup
    declare -A active_map
    local active_lines
    active_lines="$(get_current_shaders)"
    if [[ -n "$active_lines" ]]; then
        while IFS= read -r apath; do
            local aname
            aname="$(basename "$apath")"
            active_map["$aname"]=1
        done <<< "$active_lines"
    fi

    # Store shaders in array for index lookup
    local shader_arr=()
    mapfile -t shader_arr <<< "$shaders"

    echo "Available shaders:" >&2
    echo "" >&2
    local i=1
    for shader in "${shader_arr[@]}"; do
        local marker=" "
        if [[ -n "${active_map[$shader]+x}" ]]; then
            marker="*"
        fi
        printf "  %s%2d) %s\n" "$marker" "$i" "$shader" >&2
        ((i++))
    done
    echo "" >&2
    echo "  * = currently active" >&2
    echo "" >&2
    echo -n "Enter shader numbers (comma-separated, e.g. 1,3,5): " >&2
    local input
    read -r input

    if [[ -z "$input" ]]; then
        echo "Selection cancelled." >&2
        return 1
    fi

    # Parse comma-separated numbers, preserving selection order
    local IFS=','
    read -ra nums <<< "$input"
    local has_output=false
    for num in "${nums[@]}"; do
        # Trim whitespace
        num="$(echo "$num" | tr -d ' ')"
        if [[ ! "$num" =~ ^[0-9]+$ ]]; then
            echo "Invalid number: $num" >&2
            continue
        fi
        local idx=$((num - 1))
        if [[ $idx -lt 0 || $idx -ge ${#shader_arr[@]} ]]; then
            echo "Out of range: $num" >&2
            continue
        fi
        echo "${shader_arr[$idx]}"
        has_output=true
    done

    if [[ "$has_output" != true ]]; then
        echo "No valid selections." >&2
        return 1
    fi
}

# ---------- Subcommands ----------

cmd_list() {
    # Build active shader lookup with position numbers
    declare -A active_positions
    local active_lines
    active_lines="$(get_current_shaders)"
    local pos=1
    if [[ -n "$active_lines" ]]; then
        while IFS= read -r apath; do
            local aname
            aname="$(basename "$apath")"
            active_positions["$aname"]=$pos
            ((pos++))
        done <<< "$active_lines"
    fi
    local active_count=$((pos - 1))

    local shaders
    shaders="$(discover_shaders)"
    local count
    count="$(echo "$shaders" | wc -l | tr -d ' ')"

    echo "Available shaders ($count):"
    echo ""
    while IFS= read -r shader; do
        local line
        if [[ -n "${active_positions[$shader]+x}" ]]; then
            local p="${active_positions[$shader]}"
            line="  *${p}) $shader"
        else
            line="     $shader"
        fi
        local preview
        preview="$(preview_path "$shader")"
        if [[ -n "$preview" ]]; then
            line="$line  (preview: theme/$(basename "$preview"))"
        fi
        echo "$line"
    done <<< "$shaders"
    echo ""
    if [[ $active_count -gt 0 ]]; then
        echo "Active shaders marked with *N) showing pipeline order"
    else
        echo "No shader currently active"
    fi
}

cmd_set() {
    if [[ $# -eq 0 ]]; then
        # Interactive picker mode
        local selections
        if command -v fzf &>/dev/null; then
            selections="$(fzf_pick_shaders)" || return 1
        else
            selections="$(fallback_pick_shaders)" || return 1
        fi

        # Resolve and collect paths
        local paths=()
        local names=()
        while IFS= read -r name; do
            [[ -z "$name" ]] && continue
            local abs_path="$SCRIPT_DIR/$name"
            if [[ ! -f "$abs_path" ]]; then
                echo "Warning: Shader file not found: $abs_path — skipping" >&2
                continue
            fi
            paths+=("$abs_path")
            names+=("$name")
        done <<< "$selections"

        if [[ ${#paths[@]} -eq 0 ]]; then
            echo "No valid shaders selected."
            return 1
        fi

        update_config "${paths[@]}"

        if [[ ${#names[@]} -eq 1 ]]; then
            echo "Shader set to: ${names[0]}"
            echo "  Path: ${paths[0]}"
        else
            echo "Shaders set (${#names[@]} in pipeline):"
            local i=1
            for name in "${names[@]}"; do
                echo "  $i) $name"
                ((i++))
            done
        fi
        echo ""
        echo "Press Cmd+Shift+, in Ghostty to reload config."
        return
    fi

    # Resolve all arguments
    local paths=()
    local names=()
    for arg in "$@"; do
        local resolved
        resolved="$(resolve_shader "$arg")" || return 1
        local abs_path="$SCRIPT_DIR/$resolved"
        if [[ ! -f "$abs_path" ]]; then
            echo "Error: Shader file not found: $abs_path" >&2
            return 1
        fi
        paths+=("$abs_path")
        names+=("$resolved")
    done

    update_config "${paths[@]}"

    if [[ ${#names[@]} -eq 1 ]]; then
        echo "Shader set to: ${names[0]}"
        echo "  Path: ${paths[0]}"
        local preview
        preview="$(preview_path "${names[0]}")"
        if [[ -n "$preview" ]]; then
            echo "  Preview: $preview"
        fi
    else
        echo "Shaders set (${#names[@]} in pipeline):"
        local i=1
        for name in "${names[@]}"; do
            echo "  $i) $name"
            ((i++))
        done
    fi
    echo ""
    echo "Press Cmd+Shift+, in Ghostty to reload config."
}

cmd_add() {
    if [[ $# -eq 0 ]]; then
        echo "Usage: shader.sh add <name> [name2 ...]" >&2
        return 1
    fi

    # Get existing shader paths
    local existing_paths=()
    local existing_names=()
    local active_lines
    active_lines="$(get_current_shaders)"
    if [[ -n "$active_lines" ]]; then
        while IFS= read -r apath; do
            existing_paths+=("$apath")
            existing_names+=("$(basename "$apath")")
        done <<< "$active_lines"
    fi

    # Build lookup set for duplicate detection
    declare -A existing_set
    for name in "${existing_names[@]}"; do
        existing_set["$name"]=1
    done

    # Resolve and append new shaders
    local added=()
    for arg in "$@"; do
        local resolved
        resolved="$(resolve_shader "$arg")" || return 1
        if [[ -n "${existing_set[$resolved]+x}" ]]; then
            echo "$resolved is already active — skipping"
            continue
        fi
        local abs_path="$SCRIPT_DIR/$resolved"
        if [[ ! -f "$abs_path" ]]; then
            echo "Error: Shader file not found: $abs_path" >&2
            return 1
        fi
        existing_paths+=("$abs_path")
        existing_set["$resolved"]=1
        added+=("$resolved")
    done

    if [[ ${#added[@]} -eq 0 ]]; then
        echo "No new shaders to add."
        return
    fi

    update_config "${existing_paths[@]}"

    if [[ ${#added[@]} -eq 1 ]]; then
        echo "Added shader: ${added[0]}"
    else
        echo "Added ${#added[@]} shaders:"
        for name in "${added[@]}"; do
            echo "  + $name"
        done
    fi
    echo ""
    echo "Active pipeline (${#existing_paths[@]} shaders):"
    local i=1
    for p in "${existing_paths[@]}"; do
        echo "  $i) $(basename "$p")"
        ((i++))
    done
    echo ""
    echo "Press Cmd+Shift+, in Ghostty to reload config."
}

cmd_off() {
    update_config
    echo "Shader disabled (all custom-shader lines removed)."
    echo ""
    echo "Press Cmd+Shift+, in Ghostty to reload config."
}

cmd_current() {
    local active_lines
    active_lines="$(get_current_shaders)"
    if [[ -z "$active_lines" ]]; then
        echo "No shader currently active."
        return
    fi

    local count
    count="$(echo "$active_lines" | wc -l | tr -d ' ')"

    if [[ "$count" -eq 1 ]]; then
        local name
        name="$(basename "$active_lines")"
        echo "Current shader: $name"
        echo "  Path: $active_lines"
        if [[ ! -f "$active_lines" ]]; then
            echo "  Warning: shader file not found at this path"
        fi
    else
        echo "Active shaders ($count in pipeline):"
        local i=1
        while IFS= read -r shader_path; do
            local name
            name="$(basename "$shader_path")"
            echo "  $i) $name"
            echo "     Path: $shader_path"
            if [[ ! -f "$shader_path" ]]; then
                echo "     Warning: shader file not found at this path"
            fi
            ((i++))
        done <<< "$active_lines"
    fi
}

cmd_help() {
    cat <<'EOF'
shader.sh — Ghostty shader switcher (multi-shader support)

Usage:
  shader.sh <command> [args]

Commands:
  list, ls                 List available shaders (active marked with *N)
  set                      Interactive shader picker (fzf multi-select)
  set <name> [name2 ...]   Set one or more shaders (replaces all existing)
  add <name> [name2 ...]   Append shader(s) to existing pipeline
  off, disable, none       Remove all shaders from config
  current, status          Show all active shaders in pipeline order
  help, --help, -h         Show this help

Examples:
  shader.sh set                      # interactive picker (fzf or fallback)
  shader.sh set crt                  # single shader (matches crt.glsl)
  shader.sh set crt bloom            # multi-shader pipeline
  shader.sh add drunkard             # append to existing pipeline
  shader.sh list                     # show all, active marked *1) *2)
  shader.sh current                  # show active pipeline
  shader.sh off                      # remove all shaders

Interactive picker (fzf):
  Tab          Select/deselect shader
  Ctrl-A       Select all
  Ctrl-D       Deselect all
  Enter        Confirm selection
  Esc          Cancel

  Note: fzf outputs selections in alphabetical order, not selection order.
  Use CLI args for precise ordering: shader.sh set bloom crt drunkard

Environment:
  GHOSTTY_CONFIG    Override config path (default: ~/.config/ghostty/config)

After any change, press Cmd+Shift+, in Ghostty to reload config.
EOF
}

# ---------- Main ----------

main() {
    local cmd="${1:-help}"
    shift 2>/dev/null || true

    case "$cmd" in
        list|ls)          cmd_list "$@" ;;
        set|use)          cmd_set "$@" ;;
        add)              cmd_add "$@" ;;
        off|disable|none) cmd_off "$@" ;;
        current|status)   cmd_current "$@" ;;
        help|--help|-h)   cmd_help ;;
        *)
            echo "Unknown command: $cmd" >&2
            echo "Run 'shader.sh help' for usage." >&2
            return 1
            ;;
    esac
}

main "$@"