@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/effects/shimmer-terminal.d.ts

@@ -1,66 +1,67 @@
 /**
- * @fileoverview Terminal renderer for the shimmer engine.
- *
- * Turns the engine's `RGB[]` output into a single ANSI-escaped string ready
- * to write to stdout/stderr. Uses 24-bit truecolor escape sequences
- * (`\x1b[38;2;R;G;Bm`) which most modern terminals (iTerm2, Terminal.app,
- * Windows Terminal, Alacritty, Ghostty, kitty, gnome-terminal) support
- * natively. Terminals that lack truecolor (basic `xterm`, some serial
- * consoles) will display the raw escape codes — call sites that need to
- * support those terminals should fall back to {@link colorsToAnsi}'s
- * "no colors" path or skip rendering entirely.
- *
- * The high-level {@link renderFrame} convenience runs the full pipeline
- * (engine → ANSI) in one call. {@link colorsToAnsi} is the lower-level
- * helper for when you already have an `RGB[]` from {@link frameColors}.
+ * @file Terminal renderer for the shimmer engine. Turns the engine's `RGB[]`
+ *   output into a single ANSI-escaped string ready to write to stdout/stderr.
+ *   Uses 24-bit truecolor escape sequences (`\x1b[38;2;R;G;Bm`) which most
+ *   modern terminals (iTerm2, Terminal.app, Windows Terminal, Alacritty,
+ *   Ghostty, kitty, gnome-terminal) support natively. Terminals that lack
+ *   truecolor (basic `xterm`, some serial consoles) will display the raw escape
+ *   codes — call sites that need to support those terminals should fall back to
+ *   {@link colorsToAnsi}'s "no colors" path or skip rendering entirely. The
+ *   high-level {@link renderFrame} convenience runs the full pipeline (engine →
+ *   ANSI) in one call. {@link colorsToAnsi} is the lower-level helper for when
+ *   you already have an `RGB[]` from {@link frameColors}.
  *
  * @example
- * ```ts
- * import { configToSpec } from '@socketsecurity/lib/effects/shimmer'
- * import { renderFrame } from '@socketsecurity/lib/effects/shimmer-terminal'
- * const spec = configToSpec({ color: [140, 82, 255], dir: 'ltr' }, 'Loading'.length)
- * process.stdout.write(renderFrame(spec, 'Loading', frame))
- * ```
+ *   ;```ts
+ *   import { configToSpec } from '@socketsecurity/lib/effects/shimmer'
+ *   import { renderFrame } from '@socketsecurity/lib/effects/shimmer-terminal'
+ *   const spec = configToSpec(
+ *     { color: [140, 82, 255], dir: 'ltr' },
+ *     'Loading'.length,
+ *   )
+ *   process.stdout.write(renderFrame(spec, 'Loading', frame))
+ *   ```
  */
-import { ANSI_RESET } from '../ansi';
+import { ANSI_RESET } from '../ansi/constants';
 import { type RGB, type ShimmerSpec } from './shimmer';
 /**
  * ANSI "reset all attributes" sequence. Re-exported from `../ansi` for
- * convenience so callers don't need a separate import for the canonical
- * value. Identical to `ANSI_RESET` in `@socketsecurity/lib/ansi`.
+ * convenience so callers don't need a separate import for the canonical value.
+ * Identical to `ANSI_RESET` in `@socketsecurity/lib/ansi`.
  */
 export { ANSI_RESET };
 /**
  * Build the 24-bit truecolor foreground escape for an RGB tuple. Returns
- * `\x1b[38;2;R;G;Bm`. Exported so callers building ANSI by hand can use
- * the same helper.
+ * `\x1b[38;2;R;G;Bm`. Exported so callers building ANSI by hand can use the
+ * same helper.
  */
 export declare function ansiTruecolor([r, g, b]: RGB): string;
 /**
- * Wrap each char of `text` in a 24-bit truecolor ANSI escape using the
- * matching color from `colors`. Each char is followed by an ANSI reset so
- * adjacent uncolored output isn't tinted.
+ * Wrap each char of `text` in a 24-bit truecolor ANSI escape using the matching
+ * color from `colors`. Each char is followed by an ANSI reset so adjacent
+ * uncolored output isn't tinted.
+ *
+ * Caller is responsible for grapheme segmentation if the text contains complex
+ * graphemes (combining marks, ZWJ sequences). This function uses spread
+ * iteration which handles BMP code points and surrogate pairs but treats each
+ * grapheme cluster as multiple "chars."
  *
- * Caller is responsible for grapheme segmentation if the text contains
- * complex graphemes (combining marks, ZWJ sequences). This function uses
- * spread iteration which handles BMP code points and surrogate pairs but
- * treats each grapheme cluster as multiple "chars."
+ * If `colors.length` is shorter than the text's char count, surplus chars are
+ * emitted without color (uncolored tail).
  *
- * If `colors.length` is shorter than the text's char count, surplus chars
- * are emitted without color (uncolored tail).
+ * @param text Input string to color.
+ * @param colors Per-char colors; index `i` colors char `i`
  *
- * @param text input string to color
- * @param colors per-char colors; index `i` colors char `i`
  * @returns ANSI-escaped string
  */
 export declare function colorsToAnsi(text: string, colors: readonly RGB[]): string;
 /**
- * Render a single shimmer frame as ANSI-escaped text. Convenience wrapper
- * over {@link frameColors} + {@link colorsToAnsi} for callers that don't
- * need the intermediate `RGB[]`.
+ * Render a single shimmer frame as ANSI-escaped text. Convenience wrapper over
+ * {@link frameColors} + {@link colorsToAnsi} for callers that don't need the
+ * intermediate `RGB[]`.
  *
- * @param spec functional shimmer specification (see {@link ShimmerSpec})
- * @param text the string to colorize
- * @param frame caller-controlled frame counter
+ * @param spec Functional shimmer specification (see {@link ShimmerSpec})
+ * @param text The string to colorize.
+ * @param frame Caller-controlled frame counter.
  */
 export declare function renderFrame(spec: ShimmerSpec, text: string, frame: number): string;

package/dist/effects/shimmer-terminal.js

@@ -20,13 +20,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var shimmer_terminal_exports = {};
 __export(shimmer_terminal_exports, {
-  ANSI_RESET: () => import_ansi.ANSI_RESET,
+  ANSI_RESET: () => import_constants.ANSI_RESET,
   ansiTruecolor: () => ansiTruecolor,
   colorsToAnsi: () => colorsToAnsi,
   renderFrame: () => renderFrame
 });
 module.exports = __toCommonJS(shimmer_terminal_exports);
-var import_ansi = require("../ansi");
+var import_constants = require("../ansi/constants");
 var import_shimmer = require("./shimmer");
 function ansiTruecolor([r, g, b]) {
   return `\x1B[38;2;${r};${g};${b}m`;
@@ -40,7 +40,7 @@ function colorsToAnsi(text, colors) {
       out += chars[i];
       continue;
     }
-    out += `${ansiTruecolor(c)}${chars[i]}${import_ansi.ANSI_RESET}`;
+    out += `${ansiTruecolor(c)}${chars[i]}${import_constants.ANSI_RESET}`;
   }
   return out;
 }

package/dist/effects/shimmer.d.ts

@@ -1,61 +1,55 @@
 /**
- * @fileoverview Shimmer animation engine — pure functions, zero deps.
+ * @file Shimmer animation engine — pure functions, zero deps. Animates a "wave"
+ *   of color sweeping across a string. Designed for terminal spinners but the
+ *   engine output is just `RGB[]`, so adapters can render to ANSI, SVG
+ *   keyframes, Ink components, or anything else. The engine is one function:
+ *   `frameColors(spec, length, frame) → RGB[]`. It is pure — same inputs
+ *   produce the same output, no shared state. A {@link ShimmerSpec} bundles
+ *   three orthogonal pieces:
  *
- * Animates a "wave" of color sweeping across a string. Designed for
- * terminal spinners but the engine output is just `RGB[]`, so adapters
- * can render to ANSI, SVG keyframes, Ink components, or anything else.
+ *   1. `positionAt(frame)` — the wave's center at frame N (in char units; negative
+ *      = off-screen left, > textLength = off-screen right). Built-ins:
+ *      {@link ltrSweep}, {@link rtlSweep}, {@link bidirectionalSweep},
+ *      {@link randomSweep}, {@link noSweep}.
+ *   2. `kernel(signedDistance, ctx)` — given a char's signed distance from the
+ *      wave center, produce its color. Built-ins: {@link blockKernel} (hard
+ *      on/off) and {@link smoothKernel} (soft glow).
+ *   3. `baseColor(i)` / `highlightColor(i)` — per-char palette anchors fed to the
+ *      kernel as `ctx.baseColor` and `ctx.highlightColor`. Build these with
+ *      {@link solidColor} (one color for every char) or {@link gradient} (cycle
+ *      through a palette). Most callers don't build a spec by hand.
+ *      {@link configToSpec} translates the flat {@link ShimmerConfig} (`{
+ *      color, dir, speed, … }`) into a spec using sensible defaults. The
+ *      spinner uses this internally. Adapters in `shimmer-terminal.ts` and
+ *      `shimmer-keyframes.ts` consume the engine's `RGB[]` output and render it
+ *      to ANSI escape sequences or SVG SMIL keyframes respectively.
  *
- * The engine is one function: `frameColors(spec, length, frame) → RGB[]`.
- * It is pure — same inputs produce the same output, no shared state.
- *
- * A {@link ShimmerSpec} bundles three orthogonal pieces:
- *
- *   1. `positionAt(frame)` — the wave's center at frame N (in char units;
- *      negative = off-screen left, > textLength = off-screen right).
- *      Built-ins: {@link ltrSweep}, {@link rtlSweep},
- *      {@link bidirectionalSweep}, {@link randomSweep}, {@link noSweep}.
- *
- *   2. `kernel(signedDistance, ctx)` — given a char's signed distance from
- *      the wave center, produce its color. Built-ins: {@link blockKernel}
- *      (hard on/off) and {@link smoothKernel} (soft glow).
- *
- *   3. `baseColor(i)` / `highlightColor(i)` — per-char palette anchors fed
- *      to the kernel as `ctx.baseColor` and `ctx.highlightColor`. Build
- *      these with {@link solidColor} (one color for every char) or
- *      {@link gradient} (cycle through a palette).
- *
- * Most callers don't build a spec by hand. {@link configToSpec} translates
- * the flat {@link ShimmerConfig} (`{ color, dir, speed, … }`) into a spec
- * using sensible defaults. The spinner uses this internally.
- *
- * Adapters in `shimmer-terminal.ts` and `shimmer-keyframes.ts` consume the
- * engine's `RGB[]` output and render it to ANSI escape sequences or SVG
- * SMIL keyframes respectively.
- *
- * @example Smooth socket-lib-style shimmer over a single color:
- * ```ts
- * import { configToSpec, frameColors } from '@socketsecurity/lib/effects/shimmer'
- * const spec = configToSpec({ color: [140, 82, 255], dir: 'ltr' }, 'Loading'.length)
- * const colorsAtFrame0 = frameColors(spec, 7, 0)
- * ```
+ * @example
+ *   Smooth socket-lib-style shimmer over a single color:
+ *   ```ts
+ *   import { configToSpec, frameColors } from '@socketsecurity/lib/effects/shimmer'
+ *   const spec = configToSpec({ color: [140, 82, 255], dir: 'ltr' }, 'Loading'.length)
+ *   const colorsAtFrame0 = frameColors(spec, 7, 0)
+ *   ```
  *
- * @example Discrete claude-code-style shimmer with a rainbow gradient:
- * ```ts
- * import { configToSpec } from '@socketsecurity/lib/effects/shimmer'
- * import { RAINBOW_GRADIENT } from '@socketsecurity/lib/themes/utils'
- * const spec = configToSpec(
+ * @example
+ *   Discrete claude-code-style shimmer with a rainbow gradient:
+ *   ```ts
+ *   import { configToSpec } from '@socketsecurity/lib/effects/shimmer'
+ *   import { RAINBOW_GRADIENT } from '@socketsecurity/lib/themes/resolve'
+ *   const spec = configToSpec(
  *   { color: RAINBOW_GRADIENT, dir: 'ltr', kernel: 'block' },
  *   'ultrathink'.length,
- * )
- * ```
+ *   )
+ *   ```
  */
 /**
  * RGB color tuple. Each channel is 0-255.
  */
 export type RGB = readonly [r: number, g: number, b: number];
 /**
- * Ordered palette of RGB colors. Indexed via `i % length` in
- * {@link gradient} so palettes shorter than the text wrap.
+ * Ordered palette of RGB colors. Indexed via `i % length` in {@link gradient} so
+ * palettes shorter than the text wrap.
  */
 export type Palette = readonly RGB[];
 /**
@@ -63,24 +57,28 @@ export type Palette = readonly RGB[];
  *
  * - `'ltr'` — wave moves left-to-right, restarts at left.
  * - `'rtl'` — wave moves right-to-left, restarts at right.
- * - `'bi'`  — alternates LTR and RTL each cycle.
+ * - `'bi'` — alternates LTR and RTL each cycle.
  * - `'random'` — re-rolls direction at each cycle boundary.
  * - `'none'` — wave never appears (every char shows base color).
  */
 export type ShimmerDirection = 'ltr' | 'rtl' | 'bi' | 'random' | 'none';
 /**
- * Context passed to a {@link Kernel} on each invocation. Holds the per-char
- * base and highlight colors so the kernel can blend between them.
+ * Context passed to a {@link Kernel} on each invocation. Holds the per-char base
+ * and highlight colors so the kernel can blend between them.
  */
 export type KernelContext = {
-    /** Color this char shows when the wave is far away. */
+    /**
+     * Color this char shows when the wave is far away.
+     */
     readonly baseColor: RGB;
-    /** Color this char shows when the wave is centered on it. */
+    /**
+     * Color this char shows when the wave is centered on it.
+     */
     readonly highlightColor: RGB;
 };
 /**
- * A {@link Kernel} maps a char's signed distance from the wave center to
- * a color. Negative distance = wave hasn't reached this char yet; positive
+ * A {@link Kernel} maps a char's signed distance from the wave center to a
+ * color. Negative distance = wave hasn't reached this char yet; positive
  * distance = wave has passed it.
  */
 export type Kernel = (signedDistance: number, ctx: KernelContext) => RGB;
@@ -90,51 +88,65 @@ export type Kernel = (signedDistance: number, ctx: KernelContext) => RGB;
  * piece can be replaced independently.
  */
 export type ShimmerSpec = {
-    /** Wave-center position at frame N. */
+    /**
+     * Wave-center position at frame N.
+     */
     readonly positionAt: (frame: number) => number;
-    /** Maps wave distance + per-char palette context to a color. */
+    /**
+     * Maps wave distance + per-char palette context to a color.
+     */
     readonly kernel: Kernel;
-    /** Per-char base color (when the wave is far away). */
+    /**
+     * Per-char base color (when the wave is far away).
+     */
     readonly baseColor: (charIndex: number) => RGB;
-    /** Per-char highlight color (when the wave is on the char). */
+    /**
+     * Per-char highlight color (when the wave is on the char).
+     */
     readonly highlightColor: (charIndex: number) => RGB;
 };
 /**
  * User-facing flat shimmer config. Translated to a {@link ShimmerSpec} by
- * {@link configToSpec}. Pass a `ShimmerSpec` directly when you need full
- * control over the wave's curve.
+ * {@link configToSpec}. Pass a `ShimmerSpec` directly when you need full control
+ * over the wave's curve.
  */
 export type ShimmerConfig = {
     /**
      * Base color (single RGB) or per-char palette (array of RGB).
+     *
      * @default [140, 82, 255] — Socket purple
      */
     readonly color?: RGB | Palette | undefined;
     /**
-     * Highlight color shown when the wave is on a char. Single RGB or
-     * per-char palette, same shape as `color`.
+     * Highlight color shown when the wave is on a char. Single RGB or per-char
+     * palette, same shape as `color`.
+     *
      * @default [255, 255, 255] — pure white
      */
     readonly highlight?: RGB | Palette | undefined;
     /**
      * Wave direction. See {@link ShimmerDirection}.
+     *
      * @default 'ltr'
      */
     readonly dir?: ShimmerDirection | undefined;
     /**
      * Steps the wave advances per frame. Lower values = slower wave.
+     *
      * @default 1/3 (≈0.333) — three frames advance the wave by one char.
      */
     readonly speed?: number | undefined;
     /**
-     * Off-screen padding in char units on each side. The wave starts and
-     * ends past the text by this much so it fades in/out cleanly.
+     * Off-screen padding in char units on each side. The wave starts and ends
+     * past the text by this much so it fades in/out cleanly.
+     *
      * @default 2
      */
     readonly padding?: number | undefined;
     /**
-     * Half-width of the wave in chars (used by `smoothKernel`). Higher =
-     * wider bright zone. Ignored when `kernel: 'block'`.
+     * Half-width of the wave in chars (used by `smoothKernel`). Higher = wider
+     * bright zone. Ignored when `kernel: 'block'`.
+     *
      * @default 2.5
      */
     readonly width?: number | undefined;
@@ -142,6 +154,7 @@ export type ShimmerConfig = {
      * Wave shape. `'block'` is a hard 3-char-wide highlight (claude-code
      * behavior). `'smooth'` is a power-curve glow (the previous library's
      * default).
+     *
      * @default 'smooth'
      */
     readonly kernel?: 'block' | 'smooth' | undefined;
@@ -157,137 +170,143 @@ export declare const DEFAULT_BASE_COLOR: RGB;
  */
 export declare const WHITE: RGB;
 /**
- * Linearly interpolate between two RGB colors. `t` is clamped to [0, 1].
+ * Build a position function for bidirectional motion: the wave does one
+ * left-to-right pass, then one right-to-left pass, then loops.
  *
- * @param a color at `t=0`
- * @param b color at `t=1`
- * @param t blend factor; values outside [0, 1] are clamped
- * @returns blended RGB with each channel rounded to integer
- */
-export declare function blendRgb(a: RGB, b: RGB, t: number): RGB;
-/**
- * Build a per-char palette function that cycles through a fixed palette:
- * `(i) => palette[i % palette.length]`.
+ * @default padding=2
  *
- * @throws {Error} if `palette` is empty
+ * @param textLength Number of chars in the target string.
+ * @param padding Off-screen chars on each side.
  */
-export declare function gradient(palette: Palette): (i: number) => RGB;
+export declare function bidirectionalSweep(textLength: number, padding?: number): (frame: number) => number;
 /**
- * Build a per-char palette function that returns the same color for every
- * char index. Useful when shimmering text with a single base color.
+ * Linearly interpolate between two RGB colors. `t` is clamped to [0, 1].
+ *
+ * @param a Color at `t=0`
+ * @param b Color at `t=1`
+ * @param t Blend factor; values outside [0, 1] are clamped.
+ *
+ * @returns Blended RGB with each channel rounded to integer
  */
-export declare function solidColor(color: RGB): (i: number) => RGB;
+export declare function blendRgb(a: RGB, b: RGB, t: number): RGB;
 /**
- * Discrete on/off kernel — each char is either fully `highlightColor`
- * (within `halfWidth` of the wave center) or fully `baseColor`. No blend.
+ * Discrete on/off kernel — each char is either fully `highlightColor` (within
+ * `halfWidth` of the wave center) or fully `baseColor`. No blend.
  *
  * Matches claude-code's spinner behavior at `halfWidth=1` (a 3-char bright
  * zone: the char at the wave center plus its left and right neighbors).
  *
- * @param halfWidth chars on each side of the wave center to highlight
  * @default halfWidth=1
+ *
+ * @param halfWidth Chars on each side of the wave center to highlight.
  */
 export declare function blockKernel(halfWidth?: number): Kernel;
 /**
- * Smooth blend kernel — char's color blends from `baseColor` toward
- * `highlightColor` as it approaches the wave center. Falloff curve is
- * `(1 - |d|/halfWidth)^falloff`, giving a soft glow with a wider radius
- * than `blockKernel`.
+ * Translate a flat {@link ShimmerConfig} into a {@link ShimmerSpec}. Applies
+ * defaults for omitted fields; resolves `color` and `highlight` (which may be a
+ * single RGB or a palette) into per-char palette functions.
  *
- * Matches socket-lib's previous default at `halfWidth=2.5, falloff=2.5`.
+ * The spinner uses this internally; callers who only need the standard shape
+ * can call this directly. Advanced callers can construct a `ShimmerSpec` by
+ * hand to plug in custom kernels or position generators.
+ */
+export declare function configToSpec(config: ShimmerConfig, textLength: number): ShimmerSpec;
+/**
+ * Translate a {@link ShimmerDirection} string to its position-generator
+ * function. Used by {@link configToSpec}; exported for callers that want to swap
+ * kernel or palette while keeping the standard sweep mapping.
+ */
+export declare function directionToSweep(dir: ShimmerDirection, textLength: number, padding: number): (frame: number) => number;
+/**
+ * Compute per-character colors for a single frame. This is the engine.
  *
- * @param halfWidth chars on each side affected by the wave
- * @param falloff intensity exponent (higher = sharper peak)
- * @default halfWidth=2.5, falloff=2.5
+ * @example
+ *   ;```ts
+ *   const colors = frameColors(spec, 'Loading'.length, frameCounter)
+ *   // colors[0] = the color of 'L' at this frame
+ *   // colors[6] = the color of 'g' at this frame
+ *   ```
+ *
+ * @param spec Functional shimmer specification.
+ * @param textLength Number of chars to color.
+ * @param frame Caller-controlled frame counter (any number; the position
+ *   generator handles wrapping)
+ *
+ * @returns One RGB tuple per char index, in order
  */
-export declare function smoothKernel(halfWidth?: number, falloff?: number): Kernel;
+export declare function frameColors(spec: ShimmerSpec, textLength: number, frame: number): RGB[];
 /**
- * Build a position function for bidirectional motion: the wave does one
- * left-to-right pass, then one right-to-left pass, then loops.
+ * Build a per-char palette function that cycles through a fixed palette: `(i)
+ * => palette[i % palette.length]`.
  *
- * @param textLength number of chars in the target string
- * @param padding off-screen chars on each side
- * @default padding=2
+ * @throws {Error} If `palette` is empty
  */
-export declare function bidirectionalSweep(textLength: number, padding?: number): (frame: number) => number;
+export declare function gradient(palette: Palette): (i: number) => RGB;
 /**
  * Build a position function for left-to-right motion: the wave starts at
- * `-padding` (off-screen left), advances by 1 per frame, exits at
- * `textLength + padding`, then wraps.
+ * `-padding` (off-screen left), advances by 1 per frame, exits at `textLength +
+ * padding`, then wraps.
  *
- * @param textLength number of chars in the target string
- * @param padding off-screen chars on each side
  * @default padding=2
+ *
+ * @param textLength Number of chars in the target string.
+ * @param padding Off-screen chars on each side.
  */
 export declare function ltrSweep(textLength: number, padding?: number): (frame: number) => number;
 /**
- * Build a position function that hides the wave forever. Returns
- * `-Infinity` for every frame so the kernel always sees `signedDistance` >
- * `halfWidth` and produces base colors. Used by `configToSpec` when
- * `dir: 'none'`.
+ * Build a position function that hides the wave forever. Returns `-Infinity`
+ * for every frame so the kernel always sees `signedDistance` > `halfWidth` and
+ * produces base colors. Used by `configToSpec` when `dir: 'none'`.
  */
 export declare function noSweep(): (frame: number) => number;
 /**
  * Build a position function that randomly picks LTR or RTL at each cycle
- * boundary. The PRNG is configurable (defaults to `Math.random`) so callers
- * can seed it for reproducible animations.
+ * boundary. The PRNG is configurable (defaults to `Math.random`) so callers can
+ * seed it for reproducible animations.
  *
- * @param textLength number of chars in the target string
- * @param padding off-screen chars on each side
- * @param random PRNG returning [0, 1); defaults to `Math.random`
  * @default padding=2, random=Math.random
+ *
+ * @param textLength Number of chars in the target string.
+ * @param padding Off-screen chars on each side.
+ * @param random PRNG returning [0, 1); defaults to `Math.random`
  */
 export declare function randomSweep(textLength: number, padding?: number, random?: () => number): (frame: number) => number;
 /**
- * Build a position function for right-to-left motion: the wave starts at
- * the right edge, decreases by 1 per frame, exits at `-padding` left of
- * char 0, then wraps.
+ * Resolve a {@link ShimmerConfig.color}-shaped input into a per-char palette
+ * function. Accepts a single RGB tuple, an ordered palette, or `undefined` (in
+ * which case `defaultColor` is used).
  *
- * @param textLength number of chars in the target string
- * @param padding off-screen chars on each side
- * @default padding=2
+ * Used internally by {@link configToSpec}; exported so callers can build partial
+ * specs that share the same input-shape rules.
  */
-export declare function rtlSweep(textLength: number, padding?: number): (frame: number) => number;
-/**
- * Translate a {@link ShimmerDirection} string to its position-generator
- * function. Used by {@link configToSpec}; exported for callers that want
- * to swap kernel or palette while keeping the standard sweep mapping.
- */
-export declare function directionToSweep(dir: ShimmerDirection, textLength: number, padding: number): (frame: number) => number;
+export declare function resolvePalette(source: RGB | Palette | undefined, defaultColor: RGB): (i: number) => RGB;
 /**
- * Translate a flat {@link ShimmerConfig} into a {@link ShimmerSpec}.
- * Applies defaults for omitted fields; resolves `color` and `highlight`
- * (which may be a single RGB or a palette) into per-char palette
- * functions.
+ * Build a position function for right-to-left motion: the wave starts at the
+ * right edge, decreases by 1 per frame, exits at `-padding` left of char 0,
+ * then wraps.
  *
- * The spinner uses this internally; callers who only need the standard
- * shape can call this directly. Advanced callers can construct a
- * `ShimmerSpec` by hand to plug in custom kernels or position generators.
- */
-export declare function configToSpec(config: ShimmerConfig, textLength: number): ShimmerSpec;
-/**
- * Resolve a {@link ShimmerConfig.color}-shaped input into a per-char
- * palette function. Accepts a single RGB tuple, an ordered palette, or
- * `undefined` (in which case `defaultColor` is used).
+ * @default padding=2
  *
- * Used internally by {@link configToSpec}; exported so callers can build
- * partial specs that share the same input-shape rules.
+ * @param textLength Number of chars in the target string.
+ * @param padding Off-screen chars on each side.
  */
-export declare function resolvePalette(source: RGB | Palette | undefined, defaultColor: RGB): (i: number) => RGB;
+export declare function rtlSweep(textLength: number, padding?: number): (frame: number) => number;
 /**
- * Compute per-character colors for a single frame. This is the engine.
+ * Smooth blend kernel — char's color blends from `baseColor` toward
+ * `highlightColor` as it approaches the wave center. Falloff curve is `(1 -
+ * |d|/halfWidth)^falloff`, giving a soft glow with a wider radius than
+ * `blockKernel`.
  *
- * @param spec functional shimmer specification
- * @param textLength number of chars to color
- * @param frame caller-controlled frame counter (any number; the position
- *   generator handles wrapping)
- * @returns one RGB tuple per char index, in order
+ * Matches socket-lib's previous default at `halfWidth=2.5, falloff=2.5`.
  *
- * @example
- * ```ts
- * const colors = frameColors(spec, 'Loading'.length, frameCounter)
- * // colors[0] = the color of 'L' at this frame
- * // colors[6] = the color of 'g' at this frame
- * ```
+ * @default halfWidth=2.5, falloff=2.5
+ *
+ * @param halfWidth Chars on each side affected by the wave.
+ * @param falloff Intensity exponent (higher = sharper peak)
  */
-export declare function frameColors(spec: ShimmerSpec, textLength: number, frame: number): RGB[];
+export declare function smoothKernel(halfWidth?: number, falloff?: number): Kernel;
+/**
+ * Build a per-char palette function that returns the same color for every char
+ * index. Useful when shimmering text with a single base color.
+ */
+export declare function solidColor(color: RGB): (i: number) => RGB;