/**
 * Render job queue.
 *
 * Component render effects don't run inline on notification — they queue
 * here (deduplicated per component) and drain at the end of each
 * reactivity notification wave via `setFlushHandler`. Jobs run in mount
 * order (`id` = a monotonic uid minted per component): parents always
 * mount before their children and components never re-parent, so id
 * order guarantees parent-before-child. A parent render that writes a
 * child's props therefore merges with the child's own subscription into
 * ONE child render per wave.
 *
 * The flush is fully synchronous — by the time a signal write returns,
 * the DOM is updated, exactly as before this queue existed.
 */
export interface SchedulerJob {
    (): void;
    /** Mount-order uid: lower ids (ancestors) flush first. */
    id: number;
    /** Dedup flag: true while sitting in the queue. */
    queued?: boolean;
}
/** Mint a mount-order job id (one per component instance). */
export declare function nextJobId(): number;
/**
 * Enqueue a render job, keeping the queue sorted by id. Duplicate
 * enqueues of a queued job are no-ops. Jobs queued mid-flush are placed
 * after the currently flushing position so the running loop picks them
 * up in the same flush.
 */
export declare function queueJob(job: SchedulerJob): void;
/**
 * Drain the queue. Re-entrant calls return immediately — jobs queued
 * while flushing are handled by the already-running loop. A throwing
 * job propagates to the write site (matching pre-queue semantics); the
 * finally block resets state so the queue can't wedge.
 */
export declare function flushJobs(): void;
//# sourceMappingURL=scheduler.d.ts.map