import { GpuFragmentParams, KitTexture } from '../contract';

/**
 * Premultiplied Porter-Duff "over": composite one straight-alpha layer (`rgb`, `a`) on top of
 * the premultiplied accumulator `dst`, clamping the layer alpha. One statement, brace-scoped so
 * repeated composites in the same block don't collide on the temp.
 */
export declare function overPremul(dst: string, rgb: string, a: string): string;
/**
 * Signed distance to a (rounded) rectangle: emits the classic sdRoundRect `q`/`sd` pair for the
 * centre-relative point `pp` against half-extent `half`. With `radius` omitted the radius terms
 * are not emitted at all (a sharp box, not a zero-radius one).
 */
export declare function roundRectSD(names: {
    q: string;
    sd: string;
}, opts: {
    pp: string;
    half: string;
    radius?: string;
}): string[];
/**
 * The corner-bracket mask: keeps a box stroke only near its four corners (the "tracker
 * bracket" look). `blInit` is the bracket-length expression — the constant inside it is the
 * consumer's look and stays at the call site. Multiplies `stroke` in place.
 */
export declare function cornerBracketMask(names: {
    bl: string;
    inCorner: string;
}, opts: {
    blInit: string;
    px: string;
    py: string;
    hx: string;
    hy: string;
    stroke: string;
}): string[];
/**
 * The overlay output convention: the draw accumulator is premultiplied; the fragment returns
 * straight alpha. Returns the final expression string.
 */
export declare function straightFromPremul(dst: string): string;
export declare const GLYPH_ATLAS_GLYPHS = "0123456789x%";
export declare const GLYPH_ATLAS_SLOTS = 16;
export declare const GLYPH_ATLAS_CELL_W = 64;
export declare const GLYPH_ATLAS_CELL_H = 96;
export declare const DETECTION_WALK_SCAN = 3;
export declare const DETECTION_LEAF_SCAN = 4;
/**
 * A glyph-strip atlas: a fixed-size media texture rasterised on a CPU canvas, redrawn on
 * font-prop change (prop-keyed invalidation + fallback-then-real-font re-raster). Returns the
 * atlas texture the label part samples by digit slot.
 */
export declare function createGlyphStripAtlas(params: GpuFragmentParams, opts?: {
    glyphs?: string;
    label?: string;
    familyProp?: string;
    weightProp?: string;
}): KitTexture;
/** The shared frame every detection part writes against: prefix, emitters, statement sink. */
export interface DetectionEmitFrame {
    p: string;
    U: (name: string) => string;
    L: (n: number) => string;
    s: string[];
    /** The child RTT read (textureSampleLevel — samples sit in dynamic-value context). */
    sampleChild: (uvWgsl: string) => string;
    /** Resolved kit unpremultiplyAlpha fn name. */
    UN: string;
    /** Compile-time detection mode. */
    modeStr: string;
}
/** Content-test bool for a bound sample var (compile-time on detectionMode). */
export declare function contentPredicate(f: DetectionEmitFrame, sVar: string, uVar: string): string;
/** JS-unrolled N×N cell scan over runtime origin/size vars; accumulates coverage (+ bbox). */
export declare function cellScanStmts(f: DetectionEmitFrame, sfx: string, originX: string, originY: string, sizeV: string, N: number, wantBounds: boolean): void;
/** Walk to the leaf cell (JS-unrolled over compile-time D; grid/quadtree/mosaic split rule). */
export declare function partitionWalkStmts(f: DetectionEmitFrame, layoutStr: string, D: number): void;
/** Content-tight bbox, expanded by half the sample pitch then inset within the cell → `detected`. */
export declare function contentBBoxStmts(f: DetectionEmitFrame): void;
/** Box fill + stroke (uniform width; box is fully inside its cell), corner-bracket style optional. */
export declare function detectionBoxStmts(f: DetectionEmitFrame, cornerStyle: boolean): void;
export declare const digitsOf: (L: (n: number) => string, v: string) => string;
export declare const digitAt: (L: (n: number) => string, v: string, e: string) => string;
/** The label: a rounded pill anchored to a box corner + atlas digits ("W x H" or "NN %"). */
export declare function glyphPillLabelStmts(f: DetectionEmitFrame, opts: {
    labelStr: string;
    labelPos: number;
    atlasKey: string;
}): void;
/** The shared frame the HUD draw parts write against. */
export interface HudEmitFrame {
    p: string;
    U: (name: string) => string;
    L: (n: number) => string;
    s: string[];
}
/** One draw stage spliced into the trail ring / tracker loop. */
export type HudStage = (f: HudEmitFrame) => void;
/** The keyframe diamond dropped at a ring entry (reads the ring frame's `dp`/`fade`). */
export declare const diamondStamp: HudStage;
/** The motion-path segment from the previous ring entry (the seam's stamp gap drops its segment). */
export declare function pathSegmentStamp(every: number): HudStage;
/**
 * The trail-ring frame: a runtime ring walk with a rolling previous entry (ring-adjacent pairs
 * are chronological neighbors), owning the per-entry `valid`/`fade`/`ep`/`dp` locals the spliced
 * stages read.
 */
export declare function ringTrailStmts(f: HudEmitFrame, slots: {
    len: number;
    every: number;
    load: (col: string) => string;
    stages: HudStage[];
}): void;
/** The tracker gizmo: corner brackets + crosshair + center dot around the head position. */
export declare const bracketGizmo: HudStage;
//# sourceMappingURL=overlayParts.d.ts.map