import { Expr as ExprT, GpuFragmentParams } from '../../gpu/contract';
import { PropRef } from '../values';
/**
 * std/effects — the HUD-drawing vocabulary shared by the overlay-role shaders (ObjectTracker,
 * KeyFrames): premultiplied "over" compositing, round-rect signed distance, the corner-bracket
 * stroke mask, and the premultiplied→straight output convention. The part BODIES live in
 * kit/overlayParts (statement-level string builders — see the rationale there); this module is
 * the std-facing surface shader definitions import.
 *
 * Only multi-consumer vocabulary lives here (the pass-4 rule: single-consumer stages stay in
 * their shader file as named parts).
 */
export { overPremul, roundRectSD, cornerBracketMask, straightFromPremul } from '../../gpu/kit/overlayParts';
/** The prop roles the detection-overlay recipe binds. */
export interface DetectionOverlaySlots {
    detectionMode: PropRef;
    threshold: PropRef;
    layout: PropRef;
    cellSize: PropRef;
    maxDepth: PropRef;
    boxStyle: PropRef;
    lineWidth: PropRef;
    cornerRadius: PropRef;
    strokeColor: PropRef;
    fillColor: PropRef;
    labelColor: PropRef;
    labelBackgroundColor: PropRef;
    labelMode: PropRef;
    labelPosition: PropRef;
    labelInset: PropRef;
    labelRadius: PropRef;
    fontFamily: PropRef;
    fontWeight: PropRef;
    fontSize: PropRef;
    letterSpacing: PropRef;
}
/**
 * The detection-overlay recipe: each pixel walks a spatial partition of the canvas to its leaf
 * cell, scans that leaf for content (coverage + a content-tight bbox), and — if the leaf holds
 * an object — composites a bounding box + an optional glyph-pill label over the source. One
 * raw-WGSL builder over the kit's detection parts: the walk is JS-unrolled over compile-time
 * `maxDepth`, each cell scan a JS-unrolled N×N textureSampleLevel loop, bbox accumulation via
 * `select`-folds (uniform control flow, AA stays valid). Compile-time branches (detectionMode /
 * layout / maxDepth / boxStyle / labelMode / labelPosition) read propValues.
 */
export declare function detectionOverlay(slots: DetectionOverlaySlots): (params: GpuFragmentParams) => ExprT;
/** The prop roles the motion-tracker HUD recipe binds. */
export interface MotionTrackerHudSlots {
    trackers: PropRef;
    trail: PropRef;
    markerSize: PropRef;
    lineWidth: PropRef;
    markerColor: PropRef;
    keyframeColor: PropRef;
    pathColor: PropRef;
}
/**
 * The motion-tracker HUD fragment: ONE copy of the draw body in a runtime loop over the tracker
 * count, reading the pursuit sim's state rows (`trackState` compute output). Per pixel each
 * tracker costs 2 cache-resident loads (head + trail AABB) unless the pixel is inside its padded
 * box, where the trail-ring stamps (keyframe diamond + path segment) and the bracket gizmo run.
 * The AABB cull is an atomic raw-WGSL core: a runtime-count loop whose draw body sits behind a
 * per-tracker early-out, which no Expr-graph fold can express inside emitted control flow.
 */
export declare function motionTrackerHud(slots: MotionTrackerHudSlots): (params: GpuFragmentParams) => ExprT;
//# sourceMappingURL=overlay.d.ts.map