Repository navigation
Expand file tree
/
Copy pathSetupLab.lua
More file actions
5320 lines (5104 loc) · 267 KB
/
Copy pathSetupLab.lua
File metadata and controls
5320 lines (5104 loc) · 267 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
-- SetupLab — colle CSP : construit l'hôte injecté, enregistre les rappels du manifest,
-- applique les garde-fous globaux (§5, §16) et pilote les tâches de fond (D6).
-- Seul fichier à lire les globales CSP ; les modules reçoivent l'hôte en paramètre (D5).
local Util = require('src/util')
local Config = require('src/config')
local Caps = require('src/caps')
local Datasource = require('src/datasource')
local Ui = require('src/ui')
local Exporter = require('src/exporter')
local TrackModel = require('src/track_model')
local Explain = require('src/explain')
local CarModel = require('src/car_model')
local SetupSpace = require('src/setup_space')
local Sim = require('src/laptime_sim')
local Optimizer = require('src/optimizer')
local Recorder = require('src/recorder')
local Store = require('src/store')
local Calibration = require('src/calibration')
local L = require('src/i18n')
local Updater = require('src/updater')
local K = Config.K
-- Rechargement du script : l'instance précédente est libérée avant tout (§16.7).
local previous = rawget(_G, 'SETUPLAB')
if type(previous) == 'table' and type(previous.release) == 'function' then pcall(previous.release) end
local okFfi, ffi = pcall(require, 'ffi')
-- horloge officielle de CSP, seule fonction os.* utilisée (accord de Vincent du 29/10/2026, A2 amendé) ; absente
-- (CSP 0.2.11) ou os indisponible : nil
local okClock, preciseClock = pcall(function() return os.preciseClock end)
-- heure locale de Windows, en lecture seule, pour les noms des fichiers enregistrés : seconde exception à l'interdiction
-- d'os.* (accord de Vincent du 03/11/2026), car CSP 0.3.1 et plus bloque GetLocalTime par FFI ; absente : nil
local okDate, osDate = pcall(function() return os.date end)
-- réseau : seulement pour la mise à jour en jeu (demande de Vincent du 02/11/2026), depuis src/updater.lua
local okWeb, webLib = pcall(function() return web end)
local host = {
ac = ac, physics = physics, io = io, ui = ui,
vec2 = vec2, vec3 = vec3, rgbm = rgbm,
ffi = okFfi and ffi or nil,
preciseClock = okClock and preciseClock or nil,
osDate = okDate and type(osDate) == 'function' and osDate or nil,
web = okWeb and type(webLib) == 'table' and webLib or nil,
}
-- Polices de la refonte Racing 26 (fonts/, licence OFL), livrées avec l'app : absentes, le thème garde Segoe UI
do
local okD, scriptDir = pcall(function() return ac.getFolder(ac.FolderID.ScriptOrigin) end)
local okE, present = pcall(function()
return type(scriptDir) == 'string' and scriptDir ~= '' and io.fileExists(scriptDir .. '/fonts/barlow/Barlow-Regular.ttf')
end)
host.fontDir = okD and okE and present == true and 'fonts' or nil
end
local app = {
settings = Config.defaults(),
log = Util.logNew(K.logCapacity, K.logMinInterval, K.logMaxChars),
scheduler = Util.schedulerNew(K.unitDecay),
clock = nil, clockReason = nil, clockSource = nil,
utcOffset = nil, utcOffsetReason = nil, utcOffsetSource = nil, -- décalage heure locale - UTC (noms des fichiers)
static = nil,
context = nil, contextKey = nil, nextContextAt = 0,
conditionsKey = nil, pendingSessionKey = nil, -- séance de la découverte ; nouvelle séance vue une fois
inert = nil,
updateSource = nil, otherSourceCalls = 0,
discovery = nil, discoveryState = 'idle', discoveryError = nil,
report = nil, reportTruncated = false,
writeTest = nil, -- dernier test d'écriture (copie du setup courant, D17)
loadCheck = nil, -- chargement demandé : vérification du setup en cours (signature en direct)
loadTest = nil, -- issue du dernier appel à ac.loadSetup : vérifié, écart, refus, non concluant
loadVerified = nil, -- dernier chargement vérifié (capacité setup_load)
pendingComputes = {}, -- genres de calcul demandés pendant une découverte (lancés à sa fin)
updater = Updater.new(), -- mise à jour en jeu (1.5.3) : idle, checking, current, available, downloading…
updaterSeen = nil,
saved = {}, -- genre -> dernier setup enregistré : chemin, texte, signature, voiture (chargement)
refine = nil, -- mode affinage : genre, phase, tours comptés, versions enregistrées (historique)
auto = false, -- SetupLab actif (case à cocher, décision de Vincent du 21/10/2026) : affinage automatique du
-- genre de la séance ; pour ce lancement d'AC seulement (rien d'écrit avant le clic)
names = { quali = '', race = '' }, -- nom choisi pour les fichiers de chaque genre (vide : « SetupLab »)
backups = {}, -- copies « Avant chargement » écrites pendant ce lancement : nom, empreinte, valeurs
fileOps = {}, -- rangement des fichiers en attente (voiture arrêtée) : Corbeille, meilleur tour dans le nom
filesNote = nil, -- dernier rangement fait (affiché sous le nom du setup)
written = {}, -- nom de fichier -> empreinte du contenu écrit par SetupLab (chargeable, D8 amendé)
writtenGen = 0, -- compteur des changements de written (relecture des setups de qualification)
-- lectures réussies de la voiture et du circuit, gardées pendant le lancement d'AC (décision de Vincent du 12/11/2026) :
-- une découverte ne relit plus les fichiers ni la ligne IA (appels de CSP longs, à-coups en roulant)
readCache = {},
memory = {}, -- « séance|état » -> setup validé de ce circuit (figé ou non), fichier relu et vérifié
memoryFiles = {}, -- chemin -> fichier de la mémoire relu (empreinte, texte, signature, instant de la relecture)
loaded = {}, -- genre -> valeurs du dernier setup chargé par SetupLab (retouches du pilote)
pins = { quali = {}, race = {} }, -- genre -> cran retouché à la main après un chargement -> { value, from }
start = {}, -- genre -> point de départ de l'affinage choisi : { mode, signature?, file?, ready }
refines = {}, -- genre -> dernier affinage de la séance (repris tel quel : versions et essais gardés)
manualKind = nil, -- genre lancé à la main depuis un onglet (SetupLab actif ne le remplace pas)
identityMisses = 0, -- relectures d'affilée sans voiture ni circuit identifiés
proposalOrigins = {}, -- genre -> signature du setup d'origine du setup proposé (validation, §14.1)
quali = nil, -- calcul de qualification : état, progression, résultat (§10.6)
race = nil, -- calcul course : état, progression, résultat (§10.6, §8.7)
recorder = Recorder.new(), -- tours enregistrés (§9.1)
knownSetups = {}, -- signature des crans -> setup physique connu (découverte, setup proposé)
knownOrder = {}, -- ordre d'arrivée des setups connus (éviction)
reconnaissanceTries = 0, -- reconnaissances tentées dans ce contexte
proposals = {}, -- genre (quali, race) -> signature du dernier setup enregistré
calibration = nil, -- dernière calibration lancée : état, résultat (§9.2)
calibrations = {}, -- calibration par composé (index CSP) et état de piste (calKey), facteurs (§9.2)
wet = { state = 'sec' }, -- état de la piste (D16 amendé) : « sec » ou « pluie », avec hystérésis
proposalBuckets = {}, -- genre -> état de piste du calcul du setup proposé (validation, §14.1)
validations = {}, -- genre -> validation du setup proposé (§14.1) : gain prévu contre gain mesuré
liveConditions = {}, -- conditions de piste courantes (contexte, 1 Hz)
recordContext = {},
reconnaissance = nil, -- ligne reconstituée depuis un tour (sans ligne IA, A14)
measureOnly = nil, -- mode « mesure uniquement » (§9.4) : modèle estimé sur un tour
perf = { lastMs = 0, avgMs = 0, maxMs = 0, guardSkips = 0, slowFrames = 0, slowSlices = 0, errors = 0, skipNext = false },
now = 0,
released = false,
disposers = {},
ui = Ui.new(),
}
local frameCost = 0
-- Persistance (§13) : réglages de l'app relus et validés au chargement (aucune confiance dans le stockage).
app.store = Store.open(host)
do
local stored = Store.get(app.store, 'settings')
if stored then
for _, key in ipairs(Config.EDITABLE) do
if stored[key] ~= nil then app.settings[key] = stored[key] end
end
app.settings = Config.validate(app.settings)
end
end
-- Horodatage (s) des entrées stockées : temps système du contexte.
local function stamp()
return app.context and app.context.systemTime or nil
end
-- Clé d'une calibration (§9.2) : index CSP du composé sur piste sèche (clé d'avant la pluie), « index#pluie »
-- sur piste mouillée (D16 amendé le 21/10/2026, décision de Vincent : facteurs propres au mouillé, jamais
-- mélangés avec ceux du sec).
local function calKey(index, bucket)
if bucket == 'pluie' then return tostring(index) .. '#pluie' end
return index
end
-- Horodatage des noms de fichiers : heure locale de Windows (demande de Vincent du 21/10/2026 : l'heure
-- de l'enregistrement se lit dans la liste des setups d'AC) ; sans elle, heure universelle, dite dans le
-- nom. Deux enregistrements dans la même seconde : suffixe -2, -3… (Exporter.freeName).
local function fileStamp()
local t = app.context and app.context.systemTime or 0
local offset = app.utcOffset and app.utcOffset() or nil
if offset then return Util.formatFileStamp(t + offset) end
return Util.formatFileStamp(t) .. 'UTC'
end
-- Séance de la mémoire (décision de Vincent du 21/10/2026 : mémoire par circuit et par type de séance) :
-- « course » pour un setup course ; « qualif » pour un setup tour rapide en qualification ; « essai » sinon
-- (essai ou journée circuit, hotlap, time attack).
local function memoryGroup(kind)
if kind == 'race' then return 'course' end
if app.context and app.context.sessionType == K.sessionTypeQuali then return 'qualif' end
return 'essai'
end
-- Genre affiné quand SetupLab est actif : course en séance de course, tour rapide sinon (décision de Vincent) ; un
-- affinage lancé à la main depuis un onglet garde son genre jusqu'à la séance suivante (relecture du 29/10/2026 : en
-- séance de course sans qualification validée, l'affinage du tour rapide était remplacé à l'image suivante).
local function sessionKind()
return (app.context and app.context.sessionType == K.sessionTypeRace) and 'race' or 'quali'
end
local function autoKind()
return app.manualKind or sessionKind()
end
-- Séance de course (demande de Vincent du 05/11/2026 : « quand on fait des courses, on arrive sur la partie et on est
-- directement positionné sur la grille… à la fin de la course on propose un setup adapté par rapport à cette course ») :
-- l'affinage de la course part du setup en place et analyse vos tours de course, trafic compris ; rien n'est chargé avant
-- l'arrivée ; le setup proposé l'est à l'arrivée, pour votre prochaine course.
local function raceSession()
return app.context ~= nil and app.context.sessionType == K.sessionTypeRace
end
-- Arrivée passée : votre voiture a vu le drapeau ; la fin de la séance seulement si ce champ est illisible (la séance
-- peut finir avec la voiture de tête, avant votre propre arrivée).
local function raceOver()
local okC, car = Util.call(Util.get(host.ac, 'getCar'), 0)
local finished = nil
if okC and car ~= nil then finished = Util.get(car, 'isRaceFinished') end
if type(finished) == 'boolean' then return finished end
local okS, sim = Util.call(Util.get(host.ac, 'getSim'))
return okS and sim ~= nil and Util.get(sim, 'isSessionFinished') == true
end
-- Séance de course, arrivée pas encore passée (grille avant le départ comprise) : le setup proposé l'est à l'arrivée.
local function raceIn()
return raceSession() and not raceOver()
end
-- Course lancée : séance de course, départ donné (séance commencée ; illisible : lancée, par prudence), arrivée pas encore
-- passée. Rien ne se charge alors dans la voiture, arrêt au stand compris. Avant le départ, tout reste comme avant
-- (partir de sa qualification, essayer la v1 de course au stand).
local function raceRunning()
if not raceIn() then return false end
local okS, sim = Util.call(Util.get(host.ac, 'getSim'))
return not (okS and sim ~= nil and Util.get(sim, 'isSessionStarted') == false)
end
-- Grille avant le départ (constat de Vincent du 09/11/2026 : « il me dit qu'il faut que je sois dans les stands » en
-- reprenant sa course, ou en partant de sa qualif sur la grille d'un week-end) : séance de course, départ pas encore donné
-- (séance lue non commencée ; illisible : pas de grille, par prudence). AC y laisse modifier le setup : le chargement y est
-- permis comme au stand (D8 amendé), menu de setup ouvert et voiture arrêtée.
local function raceGrid()
return raceIn() and not raceRunning()
end
app.raceSession, app.raceOver, app.raceIn, app.raceRunning = raceSession, raceOver, raceIn, raceRunning
app.raceGrid = raceGrid
-- État du stand pour le chargement, lu en une fois (la garde, l'affichage près de « Charger » et le journal d'un refus
-- disent la même chose) : au stand, voie des stands, grille avant le départ (place : l'un ou l'autre), vitesse (km/h),
-- voiture arrêtée, menu de setup ouvert, séance commencée.
local function pitState()
local okC, car = Util.call(Util.get(host.ac, 'getCar'), 0)
local okS, sim = Util.call(Util.get(host.ac, 'getSim'))
local okE, editable = Util.call(Util.get(host.ac, 'isSetupAvailableToEdit'))
local hasCar = okC and car ~= nil
local speed = hasCar and Util.get(car, 'speedMs') or nil
local s = { car = hasCar, inPit = hasCar and Util.get(car, 'isInPit') == true,
pitlane = hasCar and Util.get(car, 'isInPitlane') == true, grid = hasCar and raceGrid(),
kmh = Util.isFinite(speed) and math.abs(speed) * 3.6 or nil, menu = okE and editable == true,
started = nil }
if okS and sim ~= nil then s.started = Util.get(sim, 'isSessionStarted') end
s.place = s.inPit or s.grid
s.stopped = s.kmh ~= nil and s.kmh <= K.loadMaxSpeedKmh
return s
end
-- Où se charge le setup, pour les messages : « sur la grille » avant le départ d'une course, sinon « au stand ».
local function loadPlace()
return raceGrid() and 'sur la grille' or 'au stand'
end
-- Tours de la course de la séance en cours : ceux de la séance ; course au temps : estimés d'après sa durée et le temps
-- au tour simulé du setup en place (tour supplémentaire compris) ; nil hors course ou sans donnée.
local function sessionRaceLaps(d)
local s = d and d.session and d.session.session
if not (s and s.type == K.sessionTypeRace) then return nil end
if Util.isFinite(s.laps) and s.laps >= 1 and s.isTimedRace ~= true then return math.min(math.floor(s.laps), K.raceMaxLaps) end
local lap = d.simCurrent and d.simCurrent.time
-- vos tours avec ce setup (audit du 14/11/2026) : le tour simulé non calibré est souvent plus lent que vous, donc trop
-- peu de tours et trop peu de carburant ; le plus rapide des deux est pris
local f = app.recorder and d.family and app.recorder.laps.family[Recorder.bestKey(d.family, app.wet and app.wet.state or 'sec')]
-- (relecture du 15/11/2026 : best nil en course, tous les tours en trafic ; acBest lu quand même)
for _, t in pairs({ best = f and f.best, ac = f and f.acBest }) do
if Util.isFinite(t) and t > 0 and (not Util.isFinite(lap) or t < lap) then lap = t end
end
if Util.isFinite(s.durationMinutes) and s.durationMinutes > 0 and Util.isFinite(lap) and lap > 0 then
-- + 1 comme M.raceLaps (relecture du 15/11/2026 : un tour de moins que la même course réglée en durée)
local n = math.ceil(s.durationMinutes * 60 / lap) + 1 + (s.hasAdditionalLap and 1 or 0)
return math.max(1, math.min(n, K.raceMaxLaps))
end
return nil
end
app.sessionRaceLaps = sessionRaceLaps
-- Nom de fichier choisi pour un genre (sans accent ni espace) ; '' si aucun.
local function customName(kind)
return Util.fileNameFrom(app.names[kind], K.nameMaxChars)
end
-- Base des noms de fichiers (décision de Vincent du 22/10/2026 : « on a du mal à les différencier ») : nom
-- choisi, sinon « SetupLab », puis le genre (Qualif, Course ; pas répété si le nom choisi finit déjà par lui)
-- et « Pluie » sous la pluie.
-- Mots dans la langue choisie (Qualif / Quali, Course / Race, Pluie / Wet) ; le genre n'est pas ajouté si le nom
-- choisi finit déjà par lui, dans une langue ou l'autre.
local function fileWords()
return Config.fileWordsFor(app.settings.language)
end
app.fileWords = fileWords
local function fileBase(kind, bucket)
local custom = customName(kind)
local words = fileWords()
local base = custom ~= '' and custom or Config.fileDefaultName
local low = base:lower()
local has = false
for _, w in pairs(Config.fileWords) do
local genre = w[kind]:lower()
has = has or low == genre or low:sub(-#genre - 1) == '_' .. genre
end
if not has then base = base .. '_' .. words[kind] end
return base .. (bucket == 'pluie' and ('_' .. words.wet) or '')
end
app.fileBase = fileBase
-- Clés stockées de la voiture et du circuit (disposition comprise) de la découverte.
local function storeKey(kind, d, ...)
-- pendant une découverte (app.discovery à nil) : la dernière terminée ; sans elle, un « Valider » ou un « Figer » cliqué
-- pendant la découverte relancée après un chargement n'était pas gardé (relecture du 02/11/2026)
d = d or app.lastDiscovery
if not (d and d.car and d.trackFiles and type(d.trackFiles.fullId) == 'string') then return nil end
-- identifiant complet « circuit/disposition » : la disposition est une partie de la clé (§13), « - » sans
local track, layout = d.trackFiles.fullId:match('^([^/]+)/([^/]+)$')
if track == nil then track, layout = d.trackFiles.fullId, '-' end
return Store.entryKey(kind, d.car.id, track, layout, ...)
end
app.storeKey = storeKey
-- Chaque ligne gardée au journal est aussi recopiée dans le log de CSP (Documents\Assetto Corsa\logs\
-- custom_shaders_patch.log, lignes « [Lua: App: SetupLab] »), au même débit et sur une seule ligne : ce qui s'est
-- passé se relit après la séance, sans rapport J0 (accord de Vincent du 02/11/2026). Sans ac.log, rien ne change.
local function log(level, code, message)
if Util.logAdd(app.log, app.now, level, code, message) then
local e = app.log.lines[app.log.head]
Util.call(Util.get(host.ac, 'log'), level .. ' ' .. tostring(code) .. ' : ' .. (e.text:gsub('%s*[\r\n]+%s*', ' | ')))
end
end
-- Mémoire du circuit (décision de Vincent du 21/10/2026) : setup validé par voiture, circuit, disposition,
-- séance et état de piste ; figé (cadenas) ou non. Le fichier est désigné par son nom et l'empreinte de son
-- contenu (le dossier se déduit de la voiture et du circuit).
-- Champs d'une case de la mémoire gardés d'un lancement à l'autre (schéma « mem » de src/store.lua).
local MEM_FIELDS = { 'file', 'hash', 'version', 'gain', 'time', 'locked', 'best', 'mean', 'laps' }
local function memoryPut(m)
app.memory[m.group .. '|' .. m.bucket] = m
local key = storeKey('mem', app.discovery, m.group, m.bucket)
if key == nil then return false end
local fields = {}
for _, name in ipairs(MEM_FIELDS) do fields[name] = m[name] end
fields.locked = m.locked == true
return Store.put(app.store, key, fields, stamp())
end
-- Versions de qualification validées de ce circuit, gardées d'un lancement d'AC à l'autre (1.5.3) : la course peut partir
-- de l'une d'elles. Liste { key, file, hash, version, stamp }, la plus récente d'abord.
local function validatedEntries(d)
local base = storeKey('ver', d or app.discovery, 'qualif')
local list = {}
if base == nil then return list end
local prefix = base .. ':'
for key, entry in pairs(app.store.entries or {}) do
if key:sub(1, #prefix) == prefix and type(entry.file) == 'string' and entry.hash then
list[#list + 1] = { key = key, file = entry.file, hash = entry.hash, version = entry.version, stamp = entry.stamp or 0 }
end
end
table.sort(list, function(x, y)
if x.stamp ~= y.stamp then return x.stamp > y.stamp end
return x.key < y.key
end)
return list
end
local function validatedPut(file, hash, version)
local key = storeKey('ver', app.discovery, 'qualif', hash)
if key == nil then return false end
Store.put(app.store, key, { file = file, hash = hash, version = version }, stamp())
local list = validatedEntries()
for i = #list, K.validatedMax + 1, -1 do Store.remove(app.store, list[i].key) end
return true
end
-- Exécute fn sous pcall et ajoute sa durée au coût de la frame courante.
local function measure(fn, ...)
local started = app.clock and app.clock() or nil
local ok, err = pcall(fn, ...)
if started then frameCost = frameCost + (app.clock() - started) * 1000 end
return ok, err
end
-- ---------------------------------------------------------------------------
-- Découverte J0 : lecture de toutes les sources puis évaluation des capacités
-- ---------------------------------------------------------------------------
-- Signature d'un setup : noms et valeurs des crans, dans l'ordre de CSP (overrides : valeurs
-- remplacées, pour le setup proposé), et composé de pneus (index CSP ; ce n'est pas un cran).
-- Les crans viennent toujours de Datasource.copySpinner (mêmes règles d'assainissement à la
-- découverte et en roulant) ; le carburant n'en fait pas partie (mesuré à part, il change entre deux
-- relais sans changer le setup).
local function signatureOf(spinners, overrides, compoundIndex, ignored)
ignored = ignored or K.signatureIgnored
local parts = { 'TYRES=' .. tostring(compoundIndex) }
for _, sp in ipairs(spinners) do
if not ignored[sp.name] then
local value = sp.value
if overrides and overrides[sp.name] ~= nil then value = overrides[sp.name] end
parts[#parts + 1] = sp.name .. '=' .. tostring(value)
end
end
return tostring(Util.hashString(table.concat(parts, ';')))
end
-- Signature et famille d'un setup lu dans un fichier (crans du fichier) : composé du fichier (TYRES), sinon celui de la
-- découverte d.
local function fileSignatures(d, values)
local tyres = Util.isFinite(values.TYRES) and values.TYRES or d.compoundIndex
return signatureOf(d.setup.spinners, values, tyres), signatureOf(d.setup.spinners, values, tyres, K.familyIgnored)
end
-- Composé monté (index CSP), lu en direct ; nil si illisible.
local function liveCompound()
local ok, car = Util.call(Util.get(host.ac, 'getCar'), 0)
local index = ok and Util.get(car, 'compoundIndex') or nil
if type(index) == 'cdata' then index = tonumber(index) end
if Util.isFinite(index) and index >= 0 and index == math.floor(index) then return index end
return nil
end
-- Signature du setup du jeu, lue au passage de la ligne seulement, et sa famille (sans les réglages changés
-- en roulant, K.familyIgnored : vos temps par setup) ; nil si les crans sont illisibles.
local function liveSignature()
local d = app.discovery or app.lastDiscovery
local spinners = Datasource.readSpinners(host, nil, d and d.car and d.car.ini['setup.ini'], d and d.car and d.car.ratios)
if spinners == nil or #spinners == 0 then return nil end
local compound = liveCompound()
return signatureOf(spinners, nil, compound), signatureOf(spinners, nil, compound, K.familyIgnored)
end
-- Setups connus de la calibration : bornés (K.recorderMaxKnownSetups) ; le setup de la découverte et
-- le setup proposé ne sont jamais évincés, ni de cette liste, ni des meilleurs tours de l'enregistreur.
local function protectedSignatures()
local list = {}
if app.discovery and app.discovery.signature then list[app.discovery.signature] = true end
for _, signature in pairs(app.proposals) do list[signature] = true end
for _, signature in pairs(app.proposalOrigins) do list[signature] = true end
return list
end
local function rememberSetup(signature, entry)
if app.knownSetups[signature] == nil then app.knownOrder[#app.knownOrder + 1] = signature end
app.knownSetups[signature] = entry
local protected = protectedSignatures()
app.recorder.protected = protected
while #app.knownOrder > K.recorderMaxKnownSetups do
local evicted = false
for i, old in ipairs(app.knownOrder) do
if not protected[old] then
table.remove(app.knownOrder, i)
app.knownSetups[old] = nil
evicted = true
break
end
end
if not evicted then break end
end
end
-- Setup physique (une seule définition pour la simulation, l'optimisation et la calibration) : crans
-- de la découverte plus écarts deltas, composé monté (ou slot, position dans d.carBase.compounds).
local function physicalSetup(d, deltas, slot)
local setup = SetupSpace.apply(d.space, CarModel.defaultSetup(d.carBase), deltas or {})
setup.compound = slot or d.compoundSlot or setup.compound
return setup
end
app.physicalSetup = physicalSetup
-- Conditions de calcul (§11) : températures et grip de la session, grip de la chaussée.
local function conditionsOf(d)
local v = d.session and d.session.values or {}
local assists = d.session and d.session.assists or {}
-- taux de consommation et d'usure de la session (1 = normal) : état de simulation, sinon assistances
local function rate(simValue, assistValue)
if Util.isFinite(simValue) and simValue >= 0 then return simValue end
if Util.isFinite(assistValue) and assistValue >= 0 then return assistValue end
return nil
end
-- échelle des taux non confirmée en jeu (le SDK annonce 0…1) : le taux de consommation ne réduit
-- jamais la consommation du modèle (§0.6, prudence : jamais de panne sèche)
local fuelRate = rate(v.fuelConsumptionRate, assists.fuelRate)
-- grip de la piste (relecture du 29/10/2026) : 0 donnait un tour de 6 h sans avertissement, 98 un tour trop rapide
local grip, gripIgnored = TrackModel.normalizeGrip(v.roadGrip)
return { airTemp = v.ambientTemperature, roadTemp = v.roadTemperature, roadGrip = grip, roadGripIgnored = gripIgnored,
surfaceGrip = d.trackModel and d.trackModel.surfaceGrip or 1,
fuelRate = fuelRate and math.max(1, fuelRate) or nil, wearRate = rate(v.tyreConsumptionRate, assists.tyresWear),
-- ABS du moment (1.5.11) : le temps du setup actuel affiché est simulé comme le calcul le simule
absActive = app.absActiveOf and app.absActiveOf(d) or nil }
end
-- Profil du circuit sur le tour simulé avec le setup actuel : virages par vitesse d'apex (lents, moyens, rapides),
-- chicanes, lignes droites, part du tour à pleine charge, au freinage, en virage rapide ou lent.
local function trackProfile(t, buf, tick)
if not (t and t.segments and buf and buf.v) then return nil end
tick()
TrackModel.annotate(t, buf)
tick()
local p = { lent = 0, moyen = 0, rapide = 0, chicanes = 0, corners = 0, straights = 0, longest = 0 }
for _, seg in ipairs(t.segments) do
if seg.kind == 'corner' then
p.corners = p.corners + 1
p[seg.class or 'moyen'] = (p[seg.class or 'moyen'] or 0) + 1
if seg.chicane then p.chicanes = p.chicanes + 1 end
else
p.straights = p.straights + 1
if seg.length > p.longest then p.longest = seg.length end
end
end
tick()
local ok, stats = pcall(Explain.trackStats, t, buf)
if ok then p.stats = stats end
tick()
p.length = t.length
return p
end
-- Tour simulé avec le setup actuel (§8.2, profil de vitesse du J3) ; mesure le temps de calcul d'une
-- évaluation, hors rendus de main, pour estimer la durée d'un calcul avant son lancement (A13).
local function simulateCurrent(d, ctx)
local cpu, mark = 0, ctx.now()
local function tick(weight)
local now = ctx.now()
if now and mark then cpu = cpu + (now - mark) end
ctx.tick(weight)
mark = ctx.now()
end
local setup = physicalSetup(d, nil)
local eff, why = CarModel.configure(d.carBase, setup, d.conditions, tick)
if eff == nil then return { reason = why } end
local result, buf = Sim.run(d.trackModel, eff, nil, { tick = tick })
local now = ctx.now()
if now and mark then cpu = cpu + (now - mark) end
local evalMs = ctx.now() and cpu * 1000 or nil
d.trackProfile = trackProfile(d.trackModel, buf, tick)
mark = ctx.now()
-- coût avec le DRS (qualification : volet ouvert dans toutes les zones), pour le budget tenu en temps
-- et la durée estimée (relecture J6b, m8 : sans lui, sous-estimée de moitié)
local evalMsDrs = nil
if d.drs and d.drs.enabled and evalMs then
local conditions = {}
for key, value in pairs(d.conditions) do conditions[key] = value end
conditions.drs = true
cpu, mark = 0, ctx.now()
local effDrs = CarModel.configure(d.carBase, setup, conditions, tick)
if effDrs then Sim.run(d.trackModel, effDrs, nil, { tick = tick }) end
now = ctx.now()
if now and mark then cpu = cpu + (now - mark) end
evalMsDrs = effDrs and cpu * 1000 or nil
end
return {
time = result.time, vMax = result.vMax, vMin = result.vMin, balance = result.balanceMean, fuel = result.fuel,
profile = Optimizer.profile(d.trackModel, buf), evalMs = evalMs, evalMsDrs = evalMsDrs,
}
end
-- DRS simulé (§8.9) : aile et EFFECT lisibles (drs.ini), annoncé par AC (drsPresent), zones sur le
-- circuit. Sinon, la raison.
local function drsStatus(d)
local drs = d.carBase and d.carBase.drs
if drs == nil then return { enabled = false, reason = 'pas de DRS (drs.ini sans section WING_n)' } end
local out = { enabled = false, wing = drs.wing, effect = drs.effect, limitG = drs.limitG, notes = drs.notes }
local zones = d.trackModel and #d.trackModel.drsZones or 0
if not drs.usable then
out.reason = drs.reason
elseif d.carState.ok and d.carState.flags.drsPresent == false then
out.reason = 'AC n\'annonce pas de DRS pour cette voiture (drsPresent)'
elseif zones == 0 then
out.reason = 'aucune zone DRS sur ce circuit'
else
out.enabled, out.zones = true, zones
end
return out
end
-- ERS simulé (§8.9) : ers.ini lisible et modélisé, ERS annoncé par AC (kersPresent) ; sinon la raison.
local function ersStatus(d)
local ers = d.carBase and d.carBase.ers
if ers == nil then return { enabled = false, reason = 'pas d\'ERS (ni ers.ini ni kers.ini)' } end
if not ers.usable then return { enabled = false, reason = ers.reason, notes = ers.notes } end
if d.carState.ok and d.carState.flags.kersPresent == false then
return { enabled = false, reason = 'AC n\'annonce pas d\'ERS pour cette voiture (kersPresent)', notes = ers.notes }
end
return { enabled = true, notes = ers.notes }
end
local function discover(ctx)
local d = { static = app.static, clockOk = app.clock ~= nil, clockReason = app.clockReason, clockSource = app.clockSource,
writeTest = app.writeTest,
loadTest = app.loadTest, loadVerified = app.loadVerified, pitStrategy = app.pitStrategy,
-- menu d'arrêt rapide (lu et réglé après un chargement de course, D8 amendé le 02/11/2026)
pitApi = Caps.pitApiPresent(host) }
d.session = Datasource.readSession(host)
ctx.tick()
local cache = app.readCache
local _, carId = Util.callHost(Util.get(host.ac, 'getCarID'), 0)
if cache.car and type(carId) == 'string' and cache.carId == carId then
d.car, d.fingerprint, d.carCached = cache.car, cache.fingerprint, true
else
d.car = Datasource.readCar(host, 0, ctx)
d.fingerprint = Datasource.fingerprint(d.car, ctx.tick)
-- seulement une lecture complète (fichiers de base lus) : une lecture en échec est refaite à la découverte suivante
if type(carId) == 'string' and d.car.id == carId and d.car.ini['car.ini'] and d.car.ini['tyres.ini'] then
cache.car, cache.carId, cache.fingerprint = d.car, carId, d.fingerprint
end
end
d.carState = Datasource.readCarState(host, 0)
ctx.tick()
d.telemetry = Datasource.telemetryCheck(host, 0)
ctx.tick()
d.setup = Datasource.readSetup(host, ctx, d.car.ini['setup.ini'], d.car.ratios)
local compoundIndex = d.carState.ok and d.carState.values.compoundIndex or nil
if not (Util.isFinite(compoundIndex) and compoundIndex >= 0 and compoundIndex == math.floor(compoundIndex)) then
compoundIndex = nil
end
d.compoundIndex = compoundIndex
d.signature = signatureOf(d.setup.spinners, nil, compoundIndex)
d.family = signatureOf(d.setup.spinners, nil, compoundIndex, K.familyIgnored)
-- Modèle de voiture (paramètres de base) et espace de setup vérifié contre l'état du jeu (§10.3).
-- D7 : une voiture inattendue ne doit pas faire perdre la découverte ni le rapport J0.
if d.car then
local okCar, why = pcall(function()
-- rendus de main entre les étapes : modèle de voiture (DRS, ERS compris), espace de tous les crans
d.carBase, d.carBaseMissing = CarModel.build(d.car, d.carState, ctx.tick)
ctx.tick()
d.space = SetupSpace.build({ setupIni = d.car.ini['setup.ini'], spinners = d.setup.spinners, ratios = d.car.ratios,
tick = ctx.tick })
ctx.tick()
d.verifyRows = SetupSpace.verify(d.space, d.carState, d.carBase)
ctx.tick()
SetupSpace.attach(d.space, d.carBase)
ctx.tick()
-- repère de hauteur de l'aéro vérifié au stand : hauteur de caisse optimisable (recherche réduite)
d.rideFrame = CarModel.verifyRideFrame(d.carBase, d.carState)
local frame = d.rideFrame.status
if frame == 'vérifié' or frame == 'corrigé' or frame == 'sans objet' then
if frame == 'corrigé' then d.carBase.wingHeightOffset = d.rideFrame.offsets end
SetupSpace.release(d.space, 'rod', SetupSpace.REDUCED, 'repère de hauteur de l\'aéro ' .. frame
.. (frame == 'corrigé' and ' par la mesure au stand (à confirmer)' or ''))
end
d.optimizable = SetupSpace.optimizable(d.space)
-- composé monté (D18) : retrouvé par son index CSP ; illisible -> composé par défaut, signalé
if d.compoundIndex ~= nil then
d.compoundSlot = CarModel.compoundSlot(d.carBase, d.compoundIndex)
if d.compoundSlot == nil then
d.compoundProblem = 'composé monté (index ' .. d.compoundIndex .. ') absent ou illisible dans tyres.ini'
end
else
d.compoundAssumed = true
end
end)
if not okCar then
d.carBase, d.carBaseMissing, d.space, d.verifyRows, d.optimizable = nil, nil, nil, nil, nil
d.carModelError = Util.truncate(tostring(why), K.textMax.error)
log('ERROR', 'car_model', d.carModelError)
end
ctx.tick()
end
local _, fullId = Util.callHost(Util.get(host.ac, 'getTrackFullID'), '/')
local trackKey = type(fullId) == 'string' and (fullId .. '|' .. tostring(app.settings.ds)) or nil
if cache.track and trackKey and cache.trackKey == trackKey then
d.trackFiles, d.track, d.trackCached = cache.trackFiles, cache.track, true
else
d.trackFiles = Datasource.readTrackFiles(host, ctx)
d.track = Datasource.sampleTrack(host, app.settings.ds, ctx)
-- sans ligne IA : ligne reconstituée depuis un tour enregistré (reconnaissance, A14)
if not d.track.ok and app.reconnaissance and app.reconnaissance.ok then d.track = app.reconnaissance end
Datasource.probeBank(host, d.track, ctx)
-- ligne IA lue en entier : gardée (une ligne reconstituée d'un tour, ou une lecture en échec, ne l'est jamais)
if d.track.ok and trackKey and d.track.source == 'ligne IA' then
cache.trackFiles, cache.track, cache.trackKey = d.trackFiles, d.track, trackKey
end
end
-- D7 : une erreur du modèle de circuit ne doit pas faire échouer toute la découverte.
local okModel, model, why = pcall(TrackModel.build, d.track, d.trackFiles, app.settings.ds, ctx.tick)
if okModel then
d.trackModel, d.trackModelReason = model, why
else
d.trackModel, d.trackModelReason = nil, 'erreur du modèle de circuit : ' .. tostring(model)
end
d.raycast = Datasource.probeRaycast(host, 0)
ctx.tick()
d.drs = drsStatus(d)
d.ers = ersStatus(d)
d.store = { status = app.store.status, loaded = app.store.loaded, reason = app.store.reason }
if d.trackModel and d.carBase and #d.carBaseMissing == 0 and d.space then
d.conditions = conditionsOf(d)
local okSim, sim = pcall(simulateCurrent, d, ctx)
d.simCurrent = okSim and sim or { reason = 'erreur de simulation : ' .. tostring(sim) }
end
d.caps = Caps.evaluate(app.static, d)
return d
end
-- Rapport J0 construit en tâche découpée (aucun travail long hors tranche).
local function scheduleReport(d)
local date = app.context and app.context.systemTime and Util.formatDate(app.context.systemTime) or '—'
local stats = app.scheduler.stats
local info = {
appVersion = Config.version, milestone = Config.milestone, date = date, updateSource = app.updateSource,
perf = {
slices = stats.slices, maxSliceMs = stats.maxSliceMs, maxUnitMs = stats.maxUnitMs,
slowSlices = app.perf.slowSlices, avgMs = app.perf.avgMs, clock = app.clock ~= nil, clockSource = app.clockSource,
},
-- mode en ligne (test du 03/11/2026) : de quoi régler les seuils d'après le rapport
online = {
session = app.context and app.context.online == true, active = app.settings.onlineActive == true,
sessionType = app.context and app.context.sessionType, cars = app.context and app.context.carsCount,
trafficRejects = app.trafficRejects or 0,
},
}
local entries = Util.logEntries(app.log)
Util.schedulerAdd(app.scheduler, 'report', function(ctx)
local text, truncated = Caps.buildReport(info, d, entries, ctx.tick)
return { text = text, truncated = truncated }
end, function(ok, result)
if ok and app.discovery == d then
app.report, app.reportTruncated = result.text, result.truncated
elseif not ok and result ~= 'cancelled' then
-- une erreur du rapport se reproduirait à l'identique : pas de nouvel essai à chaque seconde
d.reportFailed = true
log('ERROR', 'report', result)
end
end)
end
-- Réglages de suspension libérés par la rugosité mesurée (H17) ; butées et course avant butée restent
-- conservées (H16 à confirmer).
local SUSPENSION_KINDS = { 'spring', 'heave', 'damperSlow', 'damperFast' }
-- Pneus de la voiture avec sensibilité à la charge (LS_EXPY) : sinon la suspension n'est pas libérée par la rugosité.
local function tyresLoadSensitive(d)
for _, c in ipairs(d.carBase and d.carBase.compounds or {}) do
if not (c.front and c.front.lsExpY and c.rear and c.rear.lsExpY) then return false end
end
return true
end
local NO_LOAD_SENSITIVITY = 'conservé : pneus sans sensibilité à la charge (ancien format de tyres.ini), effet de la '
.. 'rugosité non modélisable'
-- Raison de ne pas reprendre une entrée stockée par une autre version du modèle ou pour d'autres fichiers
-- de la voiture (D9), ou nil.
local function staleReason(entry, d)
if entry.model ~= K.modelVersion then return 'modèle de l\'app changé depuis' end
if entry.data == nil or entry.data ~= d.fingerprint then return 'fichiers de la voiture changés depuis' end
return nil
end
local function restoreCalibration(d, cal, index, bucket)
for _, key in ipairs(Calibration.KEYS) do
if cal[key] == nil then return 'incomplète' end
-- producteur : une calibration utilisable n'a aucun facteur en butée (D11 : rien d'autre n'est cru)
local b = K.calibBounds[key]
if cal[key] <= b[1] + 1e-9 or cal[key] >= b[2] - 1e-9 then return 'facteur en butée' end
end
local stale = staleReason(cal, d)
if stale then return stale end
local road = d.conditions and d.conditions.roadTemp
if not Util.isFinite(cal.roadTemp) then return 'température de piste inconnue' end
if Util.isFinite(road) and math.abs(cal.roadTemp - road) > K.storeCalTempTol then
return 'piste à ' .. Util.fmt(cal.roadTemp, 0) .. ' °C contre ' .. Util.fmt(road, 0) .. ' °C aujourd\'hui'
end
local factors, identified = {}, {}
for _, key in ipairs(Calibration.KEYS) do factors[key], identified[key] = cal[key], cal['id_' .. key] == true end
local key = calKey(index, bucket)
app.calibrations[key] = { state = 'done', compoundIndex = index, bucket = bucket, runs = 0, result = { factors = factors,
usable = true, stored = true, atBound = {}, identified = identified, runs = {},
compoundIndex = index } }
if bucket == app.wet.state then app.calibration = app.calibrations[key] end
return nil
end
local function restoreRoughness(d, rough)
local stale = staleReason(rough, d)
if stale then return stale end
if not (rough.G0 and rough.G0 > 0 and rough.front and rough.front > 0 and rough.rear and rough.rear > 0) then
return 'incomplète'
end
if math.max(rough.front, rough.rear) / math.min(rough.front, rough.rear) > K.roughConsistency then
return 'avant et arrière incohérents'
end
d.conditions.roughness = rough.G0
app.roughness = { G0 = rough.G0, front = rough.front, rear = rough.rear, speed = rough.speed, consistent = true,
stored = true }
if not tyresLoadSensitive(d) then
for _, var in ipairs(d.space.vars) do
for _, kind in ipairs(SUSPENSION_KINDS) do
if var.kind == kind and var.class == SetupSpace.EXCLUDED then var.reason = NO_LOAD_SENSITIVITY end
end
end
return nil
end
for _, kind in ipairs(SUSPENSION_KINDS) do
SetupSpace.release(d.space, kind, SetupSpace.REDUCED, 'rugosité mesurée lors d\'une séance précédente')
end
d.optimizable = SetupSpace.optimizable(d.space)
return nil
end
-- Fichier renommé (meilleur tour dans le nom) avant que CSP n'écrive le stockage (AC quitté juste après, relecture
-- du 22/10/2026) : retrouvé par son nom sans temps au tour et, si connue, l'empreinte de son contenu. Renvoie le
-- nouveau nom et le contenu, ou nil.
local function findRenamed(folder, name, hash)
local list = Util.listOf(Util.call(Util.get(host.io, 'scanDir'), folder, '*.ini'))
if not list then return nil end
local root = Util.fileRoot(name)
for i = 1, math.min(#list, K.scanMaxFiles) do
local candidate = list[i]
if type(candidate) == 'string' and candidate ~= name and Util.fileRoot(candidate) == root then
if hash == nil then return candidate, nil end
local okL, text = Util.call(Util.get(host.io, 'load'), folder .. '/' .. candidate)
if okL and type(text) == 'string' and Util.hashString(text) == hash then return candidate, text end
end
end
return nil
end
-- Données d'une séance précédente (§13), validées et datées : calibration du composé monté (piste à
-- K.storeCalTempTol près), rugosité de la piste, derniers setups enregistrés.
local function restoreStored(d)
local now = stamp()
local index = d.compoundIndex or -1
local notes = {}
local cal = Store.get(app.store, storeKey('cal', d, index), now)
if cal and app.calibrations[index] == nil then
local why = restoreCalibration(d, cal, index, 'sec')
if why then notes[#notes + 1] = 'calibration d\'une séance précédente ignorée (' .. why .. ')' end
end
-- calibration sur piste mouillée : clé à part (D16 amendé), même règle de température de piste
local wetCal = Store.get(app.store, storeKey('calwet', d, index), now)
if wetCal and app.calibrations[calKey(index, 'pluie')] == nil then
local why = restoreCalibration(d, wetCal, index, 'pluie')
if why then notes[#notes + 1] = 'calibration pluie d\'une séance précédente ignorée (' .. why .. ')' end
end
local rough = Store.get(app.store, storeKey('rough', d), now)
if rough and d.conditions and d.space and not d.conditions.roughness then
local why = restoreRoughness(d, rough)
if why then notes[#notes + 1] = 'rugosité d\'une séance précédente ignorée (' .. why .. ')' end
end
app.storeNote = #notes > 0 and (table.concat(notes, ' ; ') .. '.') or nil
if app.storeNote then
app.storeNote = app.storeNote:sub(1, 1):upper() .. app.storeNote:sub(2)
log('INFO', 'store', app.storeNote)
end
-- nombre de tours de la course saisi pour ce circuit
local rlaps = Store.get(app.store, storeKey('rlaps', d), now)
app.raceLaps = rlaps and rlaps.laps or nil
-- séance de course (05/11/2026) : le nombre de tours de cette course, lu dans la séance (estimé pour une course au temps),
-- sauf s'il a été saisi pendant elle
if raceSession() and app.raceLapsTyped ~= app.conditionsKey then
local n = app.sessionRaceLaps and app.sessionRaceLaps(d) or nil
if n then app.raceLaps = n end
end
app.lastSaved = {}
local folder = Exporter.targetFolder(host)
for _, kind in ipairs({ 'quali', 'race' }) do
local last = Store.get(app.store, storeKey('last', d, kind), now)
-- renommé depuis (meilleur tour dans le nom) : le nom affiché suit
if last and last.file and folder then
local okE, exists = Util.call(Util.get(host.io, 'fileExists'), folder .. '/' .. last.file)
local renamed = okE and exists ~= true and findRenamed(folder, last.file, nil)
if renamed then last.file = renamed end
end
app.lastSaved[kind] = last
end
if app.refreshMemory then app.refreshMemory() end
end
local function onDiscovered(ok, result, cpuMs)
if ok then
result.durationMs = cpuMs
app.discovery, app.lastDiscovery = result, result
app.discoveryState = 'done'
-- courbes de pneu non lues (1.5.11) : dites une fois par découverte
local ignored = {}
for _, c in ipairs(result.carBase and result.carBase.compounds or {}) do
for _, tyre in ipairs({ c.front, c.rear }) do
for _, key in ipairs(tyre and tyre.ignoredCurves or {}) do ignored[key] = true end
end
end
local names = {}
for key in pairs(ignored) do names[#names + 1] = key end
table.sort(names)
if #names > 0 then
log('WARN', 'tyre_curves', 'Courbes de pneu non lues par le modèle (' .. table.concat(names, ', ')
.. ") : adhérence d'après DY_REF, LS_EXPY et DCAMBER, à confirmer par la calibration")
end
-- setup physique de la découverte, conservé pour la calibration (même voiture, même circuit)
if result.space and result.carBase and #result.carBaseMissing == 0 then
local known = app.knownSetups[result.signature] or { label = 'setup de la découverte' }
known.setup = physicalSetup(result, nil)
known.compoundIndex = result.compoundIndex
known.predicted = known.predicted or (result.simCurrent and result.simCurrent.time)
rememberSetup(result.signature, known)
end
app.recorder.protected = protectedSignatures()
-- vos temps avec le setup de départ : jamais évincés (gain des versions, tours analysés)
app.recorder.laps.protectedFamilies = result.family and { [result.family] = true } or {}
if app.detectPins and (app.discoverySeq or 0) == (app.loadSeq or 0) then app.detectPins(result) end
restoreStored(result)
scheduleReport(result)
local counts = Caps.countByStatus(result.caps)
log('INFO', 'discovery', 'Découverte terminée : ' .. counts.available .. ' disponibles, ' .. counts.pending
.. ' à confirmer, ' .. counts.unavailable .. ' indisponibles')
for _, entry in ipairs(result.caps.list) do
if entry.status == Caps.UNAVAILABLE then log('WARN', 'cap_' .. entry.id, entry.label .. ' : ' .. entry.detail) end
end
elseif result == 'cancelled' then
app.discoveryState = 'idle'
else
app.discoveryState = 'failed'
app.discoveryError = Util.truncate(tostring(result), K.textMax.error)
log('ERROR', 'discovery', app.discoveryError)
end
end
local function startDiscovery()
Util.schedulerCancel(app.scheduler)
app.discovery, app.report, app.discoveryError, app.quali, app.race = nil, nil, nil, nil, nil
app.discoveryState = 'running'
app.discoverySeq = app.loadSeq or 0
app.conditionsKey = app.context and app.context.conditionsKey or nil
app.pendingSessionKey = nil
-- lectures de la découverte faites une fois ici, sur le fil principal, pour le rapport J0 (issue n° 2) ; jamais en
-- ligne en pause ni en replay (la découverte ne démarre pas alors)
if app.static and app.static.mainProbe == nil then
local okP, probe = pcall(Caps.probeMain, host)
app.static.mainProbe = okP and probe or {}
end
Util.schedulerAdd(app.scheduler, 'discovery', discover, onDiscovered)
end
-- ---------------------------------------------------------------------------
-- Boucle (§5)
-- ---------------------------------------------------------------------------
-- Conditions d'un calcul : copie des conditions de la découverte, températures et adhérence de la piste
-- relues au lancement (valeurs finies seulement). Chaque calcul garde sa propre copie : un calcul en
-- cours ne change jamais de conditions (reproductibilité, §10.5).
local function computeConditions(d)
local out = {}
for key, value in pairs(d.conditions or {}) do out[key] = value end
-- relues à l'instant du lancement (le contexte n'est relu qu'à 1 Hz)
local c = Datasource.readContext(host)
if not c.ok then c = app.context or {} end
for _, key in ipairs({ 'airTemp', 'roadTemp', 'roadGrip' }) do
if Util.isFinite(c[key]) then out[key] = c[key] end
end
-- état de la piste figé au lancement (hystérésis, D16 amendé) ; humidité et eau de la piste ; eau sous
-- les pneus mesurée sur le dernier tour valide mouillé, sinon estimée par le modèle (H26)
out.bucket = app.wet.state
out.wetness = Util.isFinite(c.rainWetness) and Util.clamp(c.rainWetness, 0, 1) or nil
out.water = Util.isFinite(c.rainWater) and Util.clamp(c.rainWater, 0, 1) or nil
out.waterMm = nil
local last = app.recorder.laps.last
if out.bucket == 'pluie' and last and last.valid and last.bucket == 'pluie' and Util.isFinite(last.waterMm) then
out.waterMm = last.waterMm
end
if out.bucket ~= 'pluie' then out.wetness, out.water = 0, 0 end
return out
end
-- Écart des conditions de piste actuelles à celles d'un calcul (K.conditionsTempStep, K.conditionsGripStep) :
-- texte, ou nil s'il est en deçà.
local function conditionsDrift(ref)
local c = app.context
if not (ref and c) then return nil end
if ref.bucket and ref.bucket ~= app.wet.state then
return ref.bucket == 'pluie' and 'piste mouillée -> sèche' or 'piste sèche -> mouillée'
end
if ref.bucket == 'pluie' and Util.isFinite(ref.water) and Util.isFinite(c.rainWater)
and math.abs(c.rainWater - ref.water) >= K.conditionsWaterStep - K.conditionsEps then
return 'eau sur la piste ' .. Util.fmt(ref.water * 100, 0) .. ' -> ' .. Util.fmt(c.rainWater * 100, 0) .. ' %'
end
local function moved(key, step)
return Util.isFinite(ref[key]) and Util.isFinite(c[key]) and math.abs(c[key] - ref[key]) >= step - K.conditionsEps
end
if moved('roadTemp', K.conditionsTempStep) then
return 'piste ' .. Util.fmt(ref.roadTemp, 1) .. ' -> ' .. Util.fmt(c.roadTemp, 1) .. ' °C'
end
if moved('airTemp', K.conditionsTempStep) then
return 'air ' .. Util.fmt(ref.airTemp, 1) .. ' -> ' .. Util.fmt(c.airTemp, 1) .. ' °C'
end
if moved('roadGrip', K.conditionsGripStep) then
return 'adhérence ' .. Util.fmt(ref.roadGrip * 100, 1) .. ' -> ' .. Util.fmt(c.roadGrip * 100, 1) .. ' %'
end
return nil
end
-- Mode en ligne (demande de Vincent du 03/11/2026 : « exactement pareil que le mode hors ligne ») : seule décision de la
-- pause en ligne, prise à l'image (inertNow, chargement) comme à la relecture du contexte. Réglage « Actif en ligne »
-- coché (par défaut) : en ligne comme hors ligne, toutes les séances ; décoché : pause. Renvoie sa raison, ou nil.
local function onlinePause(online)
if online and not app.settings.onlineActive then
return 'Session en ligne : SetupLab est en pause (« Actif en ligne » décoché, onglet RÉGLAGES).'
end
return nil
end
-- Horloge de la séance revenue en arrière (séance recommencée : sim.time repart du début) : les échéances et les instants
-- retenus sont décalés d'autant, rien ne reste bloqué jusqu'à ce que l'horloge rattrape l'ancienne valeur (relecture du
-- contexte, nouvelle tentative de l'affinage, arrivée, setup surveillé, fichiers de la mémoire).
local function clockRewound()
local last = app.lastNow
app.lastNow = app.now
if last == nil or app.now >= last - K.contextPeriod then return end
local back = last - app.now
app.nextContextAt = math.min(app.nextContextAt - back, app.now)
local r = app.refine
if r and r.nextAt then r.nextAt = r.nextAt - back end
if r and r.minClock then r.minClock = nil end
if app.raceFinishAt then app.raceFinishAt = app.raceFinishAt - back end
if app.setupWatch and app.setupWatch.since then app.setupWatch.since = app.setupWatch.since - back end
for _, m in pairs(app.memoryFiles or {}) do
if m.at then m.at = m.at - back end