File size: 74,067 Bytes
4bd8362
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 UtopiaIA
// Elffuss Runtime · el modelo: carga de pesos y forward de qwen35.
// ─────────────────────────────────────────────────────────────────────────────
// Aquí se encadenan las piezas que ya están verificadas una a una. Esa
// verificación por piezas NO garantiza que el conjunto funcione: puede fallar el
// orden, el layout que espera la siguiente operación, o un residual sumado en el
// sitio equivocado. Por eso el forward está escrito para poder pararse en
// cualquier capa y comparar contra el volcado de un forward real.
//
// Dos tipos de bloque, y el reparto sale del propio fichero:
//   · SSM (18 de 24 en el 0.8B, 48 de 65 en el 27B): qkv fusionado → conv causal
//     → silu → q/k/v → delta net con estado recurrente → norm con puerta.
//   · Atención (el resto): Q y puerta INTERCALADOS en el mismo tensor, QK-norm
//     antes de RoPE, RoPE parcial, GQA, y la puerta multiplicando la salida.
// Los dos acaban igual: residual, norm, SwiGLU, residual.
//
// Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas.

import { parseGGUF } from './gguf.js';
import { leeRotacion } from './hadamard.js';
import { createOps, ROPE_NEOX, ROPE_NORM } from './ops.js';
import { createFlashOps } from './ops.flash.js';
import { readHParams, createState } from './state.js';
import {
  copyIntoShader, convWindowShader, convSaveShader, siluShader, mulCabezaShader,
} from './kernels.model.wgsl.js';
import { QUANT_TYPES } from './kernels.wgsl.js';
// Q8_0/Q4_0 reordenados al subir (`__ELFFUSS_REPACK`, apagado por defecto).
import {
  reordenActivo, tipoReordenado, comoReordenado, bloquesDe, reordena,
  creaBufferR, subeReordenadoPorTrozos,
} from './repack.js';
import { createFusionOps, fusionActiva, puedeGatherNorma } from './ops.fusion.js';

const MiB = 1024 ** 2;

// Sube todos los tensores del fichero al dispositivo, uno por buffer.
// PENDIENTE consciente: un tensor por buffer exige que cada uno quepa en
// maxStorageBufferBindingSize. En escritorio el límite suele sobrar; en otros
// navegadores es mucho menor y la tabla de embeddings, de los tensores más
// grandes del modelo, puede no caber. Ahí hará falta que el matmul lea varios shards, que es
// trabajo del kernel, no de aquí. Se comprueba y se falla claro en vez de
// devolver ceros.
// El tamaño de lote del prefill. Es un `let` con gancho SOLO para poder
// medirlo: comparar dos valores exige cambiarlo en caliente, dentro de la misma
// sesión y alternando el orden. Editando el fichero entre pasadas, lo que se
// mueve la medida de una sesión a otra se mezcla con lo que se compara, y luego
// no hay forma de separar una cosa de la otra.
// 32 y no 128: medido, un lote más corto va algo MÁS rápido (menos posiciones
// enmascaradas que se calculan para tirar) y —lo que importa aquí— cada despacho
// dura menos, que es media defensa contra el cuelgue. La otra media es
// trocear el forward en varios command buffers (ver `cede`/`ctx.corta`).
let loteActual = 32;
// El reparto de la última carga. Lo consume una prueba interna y puede
// consumirlo la UI: es la espera más larga del producto.
let medidaCarga = null;
export function ultimaCarga() { return medidaCarga; }

// Cuántos tensores DEBÍAN subirse en la última carga. No es lo mismo que los del
// fichero: la cabeza MTP (`nextn_predict_layers`) no pertenece al forward y no
// se sube — en el modelo pequeño son 15 de 335. Un banco que compare contra
// `g.tensorCount` falla por construcción, que es lo que pasaba.
let subidosEsperados = 0;
export function ultimosSubidos() { return subidosEsperados; }

export function _setLote(n) { loteActual = Math.max(1, n | 0); }
export function _getLote() { return loteActual; }

// Cada cuántas capas se le da al dispositivo un respiro real para que el compositor
// del sistema pinte. Un forward del 27B son 64 capas; sin trocear, iban todas
// en un solo despacho larguísimo y la pantalla se quedaba sin pintar mientras
// tanto. Ver `ctx.corta`.
let cederCada = 2;
export function _setCeder(n) { cederCada = Math.max(1, n | 0); }
export function _getCeder() { return cederCada; }

// El respiro se cobra por RELOJ, no por capas. Lo que se persigue —que el
// compositor del sistema pinte— es un asunto de milisegundos de pared: da igual
// si en ese rato han pasado dos capas o cuarenta. Contándolo por capas se pagaba
// un frame entero cada dos capas aunque esas dos capas durasen medio frame, y
// como un rAF no se puede partir, el prefill acababa cuantizado al refresco del
// monitor: el reloj lo marcaba la pantalla y no el modelo.
// `cederCada` sigue siendo la granularidad mínima (solo se mira el reloj en esas
// capas) y esto es el límite de frecuencia. A 0 se recupera exactamente el
// comportamiento anterior, que es lo que usan los bancos para el A/B.
let cederMs = 100;
export function _setCederMs(ms) { cederMs = Math.max(0, +ms || 0); }
export function _getCederMs() { return cederMs; }

// Cada cuántas capas se CIERRA y envía el command buffer del prefill. Es otra
// cosa que `cederCada`: eso es cuándo se drena la cola y se cede un frame, esto
// es solo cuántos submits se parten. Va con gancho porque la nota de al lado
// afirmaba que trocear en cada capa es «GRATIS» y eso nadie lo había medido:
// una tanda de prefill aprovecha el ancho de banda de pesos 6,6 veces peor que
// un token suelto (medido con una prueba interna) y el prefill es justo el único
// camino que trocea. A 1 se recupera el comportamiento de siempre.
let cortaCada = 1;
export function _setCorta(n) { cortaCada = Math.max(1, n | 0); }
// Lo mismo para el DECODE (ver el bucle de capas). Con gancho para el A/B.
// En CADA capa por defecto. Medido en la misma sesión, tres rondas alternadas:
// ×1,30 en LFM3 y ×1,52 en Qwen3.5-0.8B. Un solo envío al
// final del token dejaba el dispositivo parado mientras la CPU grababa cientos
// de despachos; cortando, empieza con la primera capa. Cortar cada 2, 4 u 8
// capas queda en medio. No cambia la numérica: la cola respeta el orden.
let cortaDecode = globalThis.__ELFFUSS_CORTA_DECODE ?? 1;
export function _setCortaDecode(n) { cortaDecode = Math.max(0, n | 0); }
export function _getCorta() { return cortaCada; }
// Cede un frame al bucle de eventos: en el navegador deja que el compositor
// del sistema componga; fuera del DOM (tests) basta un turno de macrotarea.
//
// Y vuelve TAMBIÉN en cuanto se pide parar. No es un adorno: con la pestaña en
// segundo plano el navegador deja de dar frames —el rAF no llega hasta que la
// pestaña se vuelve a ver—, y un prefill esperando aquí no podría atender un
// «para» hasta entonces. Con la señal, parar no depende de que haya pantalla.
const nuevoFrame = (senal = null) => new Promise((r) => {
  if (senal?.aborted) { r(); return; }
  let id = null, hecho = false;
  const fin = () => {
    if (hecho) return;
    hecho = true;
    senal?.removeEventListener?.('abort', fin);
    if (id !== null && typeof cancelAnimationFrame === 'function') cancelAnimationFrame(id);
    r();
  };
  senal?.addEventListener?.('abort', fin, { once: true });
  if (typeof requestAnimationFrame === 'function') id = requestAnimationFrame(() => fin());
  else setTimeout(fin, 0);
});

// El error de «se pidió parar». Lleva el NOMBRE estándar, AbortError, para que
// quien llama lo distinga de un fallo de verdad sin leer el texto: un turno
// parado no es un modelo roto, y enseñarlo como «el modelo falló» sería mentir.
export function errorParado(mensaje = 'parado a petición') {
  if (typeof DOMException === 'function') return new DOMException(mensaje, 'AbortError');
  const e = new Error(mensaje);
  e.name = 'AbortError';
  return e;
}

export async function loadModel(ranged, device, opts = {}) {
  const onProgress = opts.onProgress || (() => {});
  const g = await parseGGUF(ranged);
  const hp = readHParams(g.meta, g.tensors);
  const ops = createOps(device, { debug: opts.debug !== false, subgroupSize: opts.subgroupSize || 0 });
  // Atención fusionada (`__ELFFUSS_FLASH`): solo cierres, sin pipelines ni buffers hasta que se use.
  ops.flash = createFlashOps(device, { ctx: ops.ctx, despacha: ops.dispatchAny, subgroupSize: opts.subgroupSize || 0 });
  const limit = device.limits.maxStorageBufferBindingSize;

  // Antes de mover un solo byte: que TODOS los tipos del fichero tengan kernel.
  // Un tipo sin soporte descubierto a mitad del forward sería el modelo entero
  // ya subido y un error tres capas más abajo; aquí es una línea que dice cuál.
  const sinKernel = new Map();
  for (const t of g.tensors) {
    if (!QUANT_TYPES[t.typeName]) {
      if (!sinKernel.has(t.typeName)) sinKernel.set(t.typeName, t.name);
    }
  }
  if (sinKernel.size) {
    throw new Error('el fichero trae tipos sin kernel: ' +
      [...sinKernel].map(([k, n]) => `${k} (p.ej. «${n}»)`).join(', '));
  }
  // Las rejillas de los i-quants, subidas antes del primer forward.
  await ops.quant.prepare(g.tensors.map(t => t.typeName));

  const weights = new Map();
  let uploaded = 0;
  // LA CABEZA MTP NO SE SUBE. El fichero trae `nextn_predict_layers` bloques de
  // mas que el forward: state.js hace `nLayers = block_count - nextn` y nunca los
  // recorre. En el modelo grande son 15 tensores que se suben al dispositivo, se
  // quedan ahi y no se ejecutan NUNCA: memoria y tiempo de subida tirados en
  // cada sesion, sobre un modelo cuya carga ya es la espera mas larga del
  // producto.
  //
  // Se deriva de los METADATOS y no de un «blk.64» escrito a mano: si algun dia
  // se implementa la especulacion con esa cabeza, basta con quitar este filtro y
  // los pesos vuelven. Y se descuentan tambien de `total`, porque si no la barra
  // de progreso no llegaria nunca al 100%.
  const kNextn = Object.keys(g.meta).find((k) => k.endsWith('.nextn_predict_layers'));
  const kBloques = Object.keys(g.meta).find((k) => k.endsWith('.block_count'));
  const nextn = (kNextn && g.meta[kNextn]) || 0;
  const nBloques = (kBloques && g.meta[kBloques]) || 0;
  const saltados = nextn > 0 && nBloques > 0
    ? new Set(Array.from({ length: nextn }, (_, i) => `blk.${nBloques - nextn + i}.`))
    : new Set();
  const sobra = (t) => [...saltados].some((pre) => t.name.startsWith(pre));
  const suben = saltados.size ? g.tensors.filter((t) => !sobra(t)) : g.tensors;
  const total = suben.reduce((n, t) => n + t.nBytes, 0);

  // ── DÓNDE SE VA EL TIEMPO DE CARGA ─────────────────────────────────────────
  // Medido contra llama.cpp en la misma sesión y el mismo fichero, ellos cargan
  // x3,5 más rápido que nosotros. Es la espera más larga que paga el usuario y
  // nadie la había repartido nunca: «la carga tarda» tiene al menos tres causas
  // que desde fuera se ven idénticas —traer los bytes, subirlos al dispositivo, y el
  // número de viajes— y sin separarlas no se puede atacar ninguna.
  //
  // Se cuentan los TROZOS además del tiempo: este bucle pide un rango por
  // tensor como mínimo, y un modelo pequeño tiene cientos. Si el tiempo está en
  // la latencia de cientos de viajes en serie, el arreglo no es un kernel, es
  // dejar de esperar uno por uno.
  const ahoraC = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
  const tCarga0 = ahoraC();
  let msLeer = 0, msSubir = 0, trozos = 0;

  // ── TRAMOS: una lectura para MUCHOS tensores ────────────────────────────────
  // Esto pedía un rango por tensor. Medido en navegador limpio con el modelo
  // pequeño: un viaje por tensor, con el 99,9 % del tiempo en LEER, menos del
  // 1 % en encolar la subida y nada esperando al dispositivo. Y el coste por viaje
  // apenas dependía de su tamaño, que es la firma de la LATENCIA: no se estaba
  // llenando el enlace, se estaba esperando cientos de veces de una en una.
  //
  // En GGUF los tensores van CONTIGUOS, así que se agrupan en tramos de hasta
  // TRAMO bytes y cada tramo se trae de una sola lectura; después se reparte en
  // memoria, que sale gratis (encolar era el 0,1 %).
  //
  // Se agrupa SOLO si el tensor empieza justo donde acaba el anterior: si el
  // fichero trae relleno entre tensores, agrupar a ciegas no daría error, daría
  // pesos de otro sitio. Y un tensor más grande que TRAMO va en su propio tramo
  // y se lee a trozos de CHUNK, igual que antes.
  // Interruptor para poder medir el ANTES y el DESPUÉS en la MISMA sesión: una
  // razón sacada de comparar dos tiradas no vale, porque entre tiradas los
  // absolutos se mueven demasiado. A 1 byte cada tensor va en su propio tramo y
  // se recupera el comportamiento de una lectura por tensor.
  // El tramo por defecto, y no la mitad: barrido en la misma sesión, dos rondas
  // por candidato y orden alternado, con una prueba interna. Contra el camino
  // viejo —un viaje por tensor— agrupar da del orden de x7. Entre candidatos, de
  // la mitad al valor elegido hay una mejora pequeña que se repite en LAS DOS
  // rondas; al doble la diferencia cae dentro del ruido y pediría un buffer
  // transitorio el doble de grande para nada. Ahí la curva ya está saturada:
  // manda el enlace.
  const TRAMO = Math.max(1, (globalThis.__ELFFUSS_TRAMO | 0) || 128 * MiB);
  const CHUNK = 32 * MiB;
  const tramos = [];
  for (const t of suben) {
    if (t.nBytes > limit) {
      throw new Error(`«${t.name}» son ${(t.nBytes / MiB).toFixed(0)} MiB y el ` +
        `límite de binding es ${(limit / MiB).toFixed(0)} MiB: hace falta que el ` +
        `matmul lea varios shards`);
    }
    const ult = tramos[tramos.length - 1];
    if (ult && t.start === ult.fin && (ult.fin - ult.ini) + t.nBytes <= TRAMO) {
      ult.fin = t.start + t.nBytes; ult.ts.push(t);
    } else {
      tramos.push({ ini: t.start, fin: t.start + t.nBytes, ts: [t] });
    }
  }

  // Holgura de 4 bytes en el buffer: la descodificación de bloques de 34 lee la
  // palabra siguiente al recomponer los que no caen alineados.
  const nuevoBuf = (t) => device.createBuffer({
    label: t.name,
    size: Math.ceil((t.nBytes + 4) / 4) * 4,
    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
  });

  // FORMATO REORDENADO (`__ELFFUSS_REPACK`): los Q8_0/Q4_0 se suben con los
  // cuantos alineados y las escalas aparte, y su descriptor pasa a decir
  // Q8_0R/Q4_0R (ver repack.js). La foto del interruptor se toma UNA vez por
  // carga. Apagado, `tipoReordenado` da null siempre y todo lo de abajo hace
  // exactamente lo de antes.
  const conReorden = reordenActivo();
  let reordenados = 0;

  for (const tr of tramos) {
    const largo = tr.fin - tr.ini;
    if (largo > TRAMO) {
      // Tensor suelto demasiado grande: camino de trozos, uno solo en el tramo.
      const t = tr.ts[0];
      const tipoR = tipoReordenado(t, conReorden);
      if (tipoR) {
        // Los trozos van cortados en bloques enteros y cada uno se escribe en
        // sus dos regiones (cuantos y escalas).
        const buf = creaBufferR(device, t, tipoR);
        await subeReordenadoPorTrozos({
          device, ranged, t, buf, tipoR, trozo: CHUNK, ahora: ahoraC,
          cuenta: (leer, subir, n) => {
            msLeer += leer; msSubir += subir; trozos++;
            uploaded += n;
            onProgress(uploaded, total, t.name);
          },
        });
        weights.set(t.name, { buf, t: comoReordenado(t, tipoR) });
        reordenados++;
        continue;
      }
      const buf = nuevoBuf(t);
      for (let off = 0; off < t.nBytes; off += CHUNK) {
        const len = Math.min(CHUNK, t.nBytes - off);
        const tL = ahoraC();
        const raw = new Uint8Array(await ranged.slice(t.start + off, len));
        const tS = ahoraC(); msLeer += tS - tL; trozos++;
        const pad = len % 4 === 0 ? raw : (() => {
          const p = new Uint8Array(Math.ceil(len / 4) * 4); p.set(raw); return p;
        })();
        device.queue.writeBuffer(buf, off, pad, 0, pad.byteLength);
        msSubir += ahoraC() - tS;
        uploaded += len;
        onProgress(uploaded, total, t.name);
      }
      weights.set(t.name, { buf, t });
      continue;
    }

    const tL = ahoraC();
    const span = new Uint8Array(await ranged.slice(tr.ini, largo));
    msLeer += ahoraC() - tL; trozos++;
    // Un tramo corto se leería sin error y dejaría ceros dentro de un peso.
    if (span.byteLength !== largo) {
      throw new Error(`tramo incompleto: pedidos ${largo} bytes desde ${tr.ini} ` +
        `y llegaron ${span.byteLength}`);
    }
    for (const t of tr.ts) {
      const tipoR = tipoReordenado(t, conReorden);
      const buf = tipoR ? creaBufferR(device, t, tipoR) : nuevoBuf(t);
      const tS = ahoraC();
      const desde = t.start - tr.ini;
      const n4 = Math.ceil(t.nBytes / 4) * 4;
      const pad = new Uint8Array(n4);
      // Formato reordenado: se escribe DENTRO de la copia de relleno que ya se
      // hacía, en vez de copiar tal cual. Mismo tamaño, cero memoria extra.
      if (tipoR) reordena(tipoR, span.subarray(desde, desde + t.nBytes), bloquesDe(t), pad);
      else pad.set(span.subarray(desde, desde + t.nBytes));
      device.queue.writeBuffer(buf, 0, pad, 0, n4);
      msSubir += ahoraC() - tS;
      uploaded += t.nBytes;
      onProgress(uploaded, total, t.name);
      weights.set(t.name, { buf, t: tipoR ? comoReordenado(t, tipoR) : t });
      if (tipoR) reordenados++;
    }
  }
  // `onSubmittedWorkDone` se mide aparte: es donde se paga de verdad el trabajo
  // que `writeBuffer` solo había ENCOLADO. Sin separarlo, subir parecería
  // gratis y el tiempo aparecería como un hueco sin dueño.
  const tEspera = ahoraC();
  await device.queue.onSubmittedWorkDone();
  subidosEsperados = suben.length;
  medidaCarga = {
    tensores: suben.length, saltados: g.tensors.length - suben.length, trozos, bytes: total,
    leerMs: msLeer, subirMs: msSubir, esperaMs: ahoraC() - tEspera,
    totalMs: ahoraC() - tCarga0,
    // Cuántos tensores se subieron reordenados (0 con `__ELFFUSS_REPACK` apagado).
    reordenados,
  };
  console.log(`[engine] carga: ${suben.length} tensores en ${trozos} trozos · ` +
    `leer ${msLeer.toFixed(0)} ms · encolar ${msSubir.toFixed(0)} ms · ` +
    `esperar GPU ${medidaCarga.esperaMs.toFixed(0)} ms · total ${medidaCarga.totalMs.toFixed(0)} ms`);

  // `picoGPU` es el pico de memoria pedida al dispositivo sin reciclar dentro de un
  // solo forward. Un prefill largo acumula TODOS los intermedios de todas las
  // capas, y cada uno escala con el número de tokens.
  return { g, hp, ops, weights, device, bytes: total, picoGPU: () => ops.ctx.picoBytes };
}

export function createSession(model, opts = {}) {
  const { device, hp, ops, weights } = model;
  // Sonda de diagnostico: cuando esta puesta, cada intermedio con nombre se
  // ofrece al llamador. Es lo que permite comparar contra el volcado nodo a
  // nodo de un forward real y localizar el paso exacto donde algo se desvia,
  // en vez de ver solo que la capa entera no cuadra.
  const probe = opts.probe || null;
  let capaActual = -1;
  // Buffers que una sonda ha pedido CONSERVAR hasta el final del forward. Sin
  // esto el mecanismo solo servía para la última capa, y de la forma más
  // traicionera que hay: `ctx.recycleDesde` recicla los intermedios en cuanto
  // la capa termina —protege los de `tap`, pero no los que se entregan por
  // `probe`—, así que leer uno después del forward devolvía el trozo de memoria
  // REUTILIZADO por las capas siguientes. Un banco que sondeó nueve capas sacó
  // la misma cifra en ocho de ellas, idéntica hasta el decimal, y solo la última
  // era real. No fallaba nada: contestaba otra cosa.
  // El contrato: si la sonda devuelve `true`, ese buffer no se recicla.
  let conservadas = new Set();
  const P = (name, buf, n) => {
    if (probe && probe(name, buf, n, capaActual) === true) conservadas.add(buf);
    return buf;
  };
  const { quant, nn, ssm: ssmOps, attn, ctx } = ops;
  // ── FUSIÓN DE KERNELS DE FILA (`__ELFFUSS_FUSION`, apagada por defecto) ─────
  // Cuatro cadenas de despachos pequeños pasan a uno cada una, con la MISMA
  // aritmética en el mismo orden (ver `kernels.fusion.wgsl.js`): post-norma +
  // residual + norma siguiente (F1), embedding + primera norma (F2), la
  // convolución corta tras `in_proj` (F4) y QK-norm + RoPE + escritura en la
  // caché (F6). Se decide por PASADA (`fusionPase`), no por sesión: un A/B
  // alterna en la misma sesión sin recargar el modelo. Apagada, nada de esto
  // se toca y el forward es el de siempre, despacho a despacho.
  const fus = createFusionOps(ops);
  let fusionPase = false;
  // La norma de ENTRADA que ya dejó hecha la capa anterior (F1) o el embedding
  // (F2): { capa, peso, buf }, con `capa` el índice de la capa que la consume o
  // 'salida' para la norma final, y `peso` el tensor con el que se hizo. Se
  // consume una vez: quien la pide la borra. Quien la pide dice además QUÉ peso
  // usaría él: si no coincide, no se usa y se calcula la de siempre.
  let nrmPendiente = null;
  const normaHecha = (capa, peso) => {
    const n = nrmPendiente;
    nrmPendiente = null;
    return n && n.capa === capa && n.peso === peso ? n.buf : null;
  };
  // Qué norma va DESPUÉS de cada capa: la de entrada de la siguiente o la final.
  // Todos los bloques (ssm, conv, atención) empiezan por su `attn_norm`.
  const normaSiguiente = new Map((hp.layers || []).map((l, k) => {
    const sig = hp.layers[k + 1];
    return [l.index, sig ? { capa: sig.index, peso: `blk.${sig.index}.attn_norm.weight` }
      : { capa: 'salida', peso: 'output_norm.weight' }];
  }));
  const state = createState(device, hp, opts);
  const W = (name) => {
    const w = weights.get(name);
    if (!w) throw new Error('falta el tensor «' + name + '»');
    return w;
  };
  const get = (name) => W(name).buf;
  const has = (name) => weights.has(name);

  // Una proyección. El tipo de cuantización lo pone el FICHERO, no esta función:
  // el 0.8B lo trae todo en Q8_0, otros ficheros mezclan varios tipos, y el
  // forward es el mismo. Este es el único punto donde el modelo toca la
  // cuantización; de aquí en adelante todo es f32.
  // ROTACIÓN DE HADAMARD. Si el fichero la declara, las activaciones que entran
  // a los tensores enumerados hay que girarlas antes del matmul. No aplicarla no
  // falla: carga, ejecuta y devuelve ruido con cara de respuesta.
  const rot = leeRotacion((model.g && model.g.meta) || {});
  const bufSignos = new Map();      // anchura -> buffer subido una sola vez
  const signosDe = (ancho) => {
    if (!bufSignos.has(ancho)) {
      const v = rot.signos.get(ancho);
      if (!v) throw new Error(`la rotación no trae signos para la anchura ${ancho}`);
      // NO se pide al pozo de buffers: `ctx.alloc` entrega memoria reciclable y
      // `recycle()` la devuelve, así que el mismo buffer acababa siendo el
      // DESTINO de otra operación dentro del mismo pase — y WebGPU lo rechaza
      // con «includes writable usage and another usage in the same
      // synchronization scope», que no dice ni una palabra de reciclaje. Los
      // signos viven lo que vive el modelo, como los pesos.
      const buf = device.createBuffer({
        label: `signos.${ancho}`, size: v.byteLength,
        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
      });
      device.queue.writeBuffer(buf, 0, v);
      bufSignos.set(ancho, buf);
    }
    return bufSignos.get(ancho);
  };
  // Varios tensores comparten la MISMA activación de entrada (por ejemplo la
  // proyección fusionada y la puerta, las dos tras la misma norma). Sin memoria
  // se giraría lo mismo dos veces: correcto y tirado a la basura.
  let memoRot = new Map();
  // Geometría del reordenado de rasgos que pide `gdn_v_grouped`. Solo lo lleva
  // la salida del SSM: su activación llega por teselas [hd, nk, rep] y el peso
  // se guardó agrupado [hd, rep, nk]. Los nombres salen de la cabecera, no de
  // constantes: n_v es el rango del paso temporal y n_k el número de grupos.
  const meta = (model.g && model.g.meta) || {};
  const clave = (suf) => Object.keys(meta).find((k) => k.endsWith(suf));
  const nV = Number(meta[clave('.ssm.time_step_rank')] || 0);
  const nK = Number(meta[clave('.ssm.group_count')] || 0);
  const permDe = (name, ancho) => {
    if (!rot || !rot.vGrouped || !name.includes('.ssm_out.')) return null;
    if (!nV || !nK || nV % nK !== 0 || ancho % nV !== 0) {
      throw new Error(`geometría de cabezas incompatible con el reordenado: ancho ${ancho}, n_v ${nV}, n_k ${nK}`);
    }
    return { hd: ancho / nV, nk: nK, rep: nV / nK };
  };
  const giraEntrada = async (x, ancho, tokens, perm) => {
    // La clave lleva el reordenado: `ssm_out` comparte la activación de entrada
    // con otros tensores pero su transformada NO es la misma, y compartir la
    // memoria entre los dos daría el resultado del primero que pasara.
    const k = perm ? `${perm.hd}:${perm.nk}:${perm.rep}` : 'llana';
    // La MISMA activación alimenta varios tensores —`nrm` va a siete matmuls en
    // una capa— y para todos salvo `ssm_out` la rotación es idéntica. Sin
    // memoria se calcula una vez por matmul: cientos de veces por token, y cada
    // una escribe su resultado a memoria para que el matmul lo lea de vuelta.
    //
    // La memoria estuvo APAGADA por una razón buena: se indexaba por el buffer,
    // y los buffers se reciclan, así que el que fue una activación podía ser
    // otra distinta más adelante y la segunda recibía la rotación de la primera.
    // No fallaba, no avisaba, y el modelo decía ruido.
    //
    // Ahora la clave es la MARCA DE REPARTO (`ctx.marcaDe`): el pozo le pone un
    // número distinto a cada buffer cada vez que lo entrega, de modo que un
    // buffer reciclado es un valor nuevo y no puede alias con el anterior.
    // Sin marca —un buffer que no salió del pozo— no se memoriza nada: es
    // preferible repetir el trabajo a arriesgarse a devolver lo que no es.
    const marca = ops.ctx.marcaDe?.get(x);
    if (marca === undefined || globalThis.__ELFFUSS_ROT_MEMO === false) {
      return await nn.hadamard(x, signosDe(ancho), { rows: tokens, ancho, bloque: rot.bloque, perm });
    }
    const clave = `${marca}:${k}`;
    // Diagnóstico: sin contar aciertos no se sabe si la memoria sirve. Un x1,00
    // puede ser «no hay nada que ahorrar» o «no está acertando», y son cosas
    // muy distintas.
    ops.ctx.rotStats = ops.ctx.rotStats || { acierto: 0, fallo: 0 };
    if (memoRot.has(clave)) { ops.ctx.rotStats.acierto++; return memoRot.get(clave); }
    ops.ctx.rotStats.fallo++;
    const y = await nn.hadamard(x, signosDe(ancho), { rows: tokens, ancho, bloque: rot.bloque, perm });
    memoRot.set(clave, y);
    return y;
  };
  // Cuenta cuántos tensores rotados se han visto de verdad. Si el fichero
  // declara 401 y el forward toca 12, algo no encaja y hay que enterarse.
  const rotVistos = new Set();

  // GEMV2: proyecciones que ya dejó hechas el despacho fusionado de Q/K/V/puerta
  // (ver `qkvFusion`), por nombre de peso. Sin el interruptor está siempre vacío.
  const hechas = new Map();
  const mm = async (name, x, rows, k, tokens) => {
    // Una proyección ya hecha se entrega UNA vez, y solo a quien la pide sobre
    // la MISMA entrada: misma marca de reparto, así que un búfer reciclado no
    // vale aunque sea el mismo objeto.
    if (hechas.size) {
      const h = hechas.get(name);
      if (h) {
        hechas.delete(name);
        if (h.marca === ctx.marcaDe?.get(x) && h.rows === rows && h.tokens === tokens) return h.y;
      }
    }
    const w = W(name);
    let xin = x;
    if (rot && rot.pesos.has(name)) {
      rotVistos.add(name);
      xin = await giraEntrada(x, k, tokens, permDe(name, k));
    }
    return quant.matmul(w.t.typeName, w.buf, xin, rows, k, tokens);
  };

  // Los pesos F32 (normas, ssm_a, dt) se usan tal cual; los cuantizados pasan
  // por el matmul, que descuantiza dentro del shader.
  const pipe = ctx.pipeline;
  const eps = hp.eps;
  const D = hp.headDim, H = hp.heads, KVH = hp.kvHeads, E = hp.embd;
  const SH = hp.ssmHeads;              // cabezas de CLAVE (q, k)
  const SV = hp.ssmVHeads;             // cabezas de VALOR (v, alpha, beta, salida)
  const SS = hp.ssmState, CC = hp.convChannels, CK = hp.convKernel;
  const KEY = SH * SS;                 // key_dim = value_dim = 2048 en el 0.8B

  // GEMV fusionados del decode (`__ELFFUSS_GEMV2`, apagado por defecto): gate+up
  // con la SwiGLU en el epílogo, y Q/K/V/puerta en un despacho. Están hechos para
  // dar bit a bit lo mismo que las matrices sueltas con el GEMV nuevo: el orden
  // de la suma de cada fila es el mismo (ver kernels.gemv.wgsl.js).
  // Si no aplican —más de 3 tokens, tipos distintos, rotación de Hadamard,
  // dispositivo sin subgrupos de 32— no hacen nada y el bloque sigue como siempre.
  const gemv2 = quant.gemv || null;
  const conRotacion = (name) => !!(rot && (rot.pesos.has(name) || rot.inversos.has(name)));
  async function gateUpFusion(i, nrm, tokens) {
    if (!gemv2 || tokens > 3) return null;
    const ng = `blk.${i}.ffn_gate.weight`, nu = `blk.${i}.ffn_up.weight`;
    if (conRotacion(ng) || conRotacion(nu)) return null;
    const wg = W(ng), wu = W(nu);
    if (wg.t.typeName !== wu.t.typeName) return null;
    return gemv2.gateUp(wg.t.typeName, wg.buf, wu.buf, nrm, hp.ffnLength, E, tokens);
  }
  // Q, K, V y la puerta de una capa de atención en UN despacho. Las salidas no
  // se devuelven: se dejan en `hechas`, por nombre de peso, y `mm` las entrega
  // cuando el bloque pide esas proyecciones sobre la misma entrada. Así el
  // bloque sigue igual línea a línea, y cualquier variante que pida las
  // proyecciones en otro orden o desde otro sitio las encuentra hechas.
  // Con el mínimo de búferes por etapa las cuatro no caben (nueve búferes):
  // entonces van Q/K/V juntas (siete) y la puerta por su GEMV suelto.
  async function qkvFusion(i, nrm, tokens) {
    hechas.clear();
    if (!gemv2 || tokens > 3) return;
    const marca = ctx.marcaDe?.get(nrm);
    if (marca === undefined) return;
    const nombres = [`blk.${i}.attn_q.weight`, `blk.${i}.attn_k.weight`, `blk.${i}.attn_v.weight`];
    const filas = [(hp.qGate ? 2 : 1) * H * D, KVH * D, KVH * D];
    // La puerta por cabeza solo la usa el bloque cuando no hay puerta en Q.
    if (!hp.qGate && hp.headGate) { nombres.push(`blk.${i}.attn_gate.weight`); filas.push(H); }
    if (nombres.some(conRotacion)) return;
    const ws = nombres.map(W);
    const tipo = ws[0].t.typeName;
    if (ws.some((w) => w.t.typeName !== tipo)) return;
    let n = nombres.length;
    let ys = await gemv2.secciones(tipo, ws.map((w) => w.buf), nrm, filas, E, tokens);
    if (!ys && n === 4) {
      n = 3;
      ys = await gemv2.secciones(tipo, ws.slice(0, 3).map((w) => w.buf), nrm, filas.slice(0, 3), E, tokens);
    }
    if (!ys) return;
    for (let j = 0; j < n; j++) hechas.set(nombres[j], { y: ys[j], marca, rows: filas[j], tokens });
  }

  async function gather(idsBuf, tokens) {
    const w = W('token_embd.weight');
    const z = await quant.gather(w.t.typeName, w.buf, idsBuf, E, tokens);
    // La tabla guarda las filas YA giradas, así que aquí se deshace: h = s ⊙ (H z).
    // Los signos van DESPUÉS, al revés que en el camino normal — es la inversa,
    // y confundir el orden no falla, da ruido.
    if (rot && rot.inversos.has('token_embd.weight')) {
      rotVistos.add('token_embd.weight');
      return await nn.hadamard(z, signosDe(E), { rows: tokens, ancho: E, bloque: rot.bloque, inverso: true });
    }
    return z;
  }

  // FUSIÓN (F2): el embedding y la norma de entrada de la primera capa en un
  // despacho, que deja la norma para esa capa (`nrmPendiente`). Solo con el
  // lector de bloques de siempre y sin rotación inversa: una tabla girada,
  // o con rejilla va por `gather` y la norma de siempre (una reordenada al cargar
  // sí entra: ver `puedeGatherNorma`).
  async function gatherFusion(idsBuf, tokens) {
    const w = W('token_embd.weight');
    const l0 = hp.layers[0];
    if (!l0 || (rot && rot.inversos.has('token_embd.weight')) || !puedeGatherNorma(w)) {
      return await gather(idsBuf, tokens);
    }
    const { x, nrm } = await fus.gatherNorma(w.t.typeName, w.buf, idsBuf,
      get(`blk.${l0.index}.attn_norm.weight`), E, tokens, eps);
    nrmPendiente = { capa: l0.index, peso: `blk.${l0.index}.attn_norm.weight`, buf: nrm };
    return x;
  }

  const raw = (label, p, buffers, groups) => ops.dispatchAny(label, p, buffers, groups);

  async function silu(src, n) {
    const p = await pipe('silu', siluShader());
    const dst = ctx.alloc(n * 4, 'silu');
    const params = ctx.uniform([new Uint32Array([n, 0, 0, 0])]);
    await raw('silu', p, [src, dst, params], Math.ceil(n / 256));
    return dst;
  }

  // `dstF16` va en la CLAVE del pipeline, no solo en el shader: con una sola
  // clave, la primera llamada fijaría el compilado y la segunda escribiría con
  // el tipo de la primera. La caché saldría escrita a medias y sin un error.
  async function copyInto(src, dst, dstOffset, n, srcOffset = 0, dstF16 = false) {
    const p = await pipe(`copy_into${dstF16 ? '_h' : ''}`, copyIntoShader(256, dstF16));
    const params = ctx.uniform([new Uint32Array([n, dstOffset, srcOffset, 0])]);
    await raw('copy_into', p, [src, dst, params], Math.ceil(n / 256));
  }

  // Corte contiguo de una fila ancha: q, k y v salen del mismo tensor de 6144.
  const slice = (src, offset, width, tokens, rowWidth) =>
    attn.strideCopy(src, { headDim: width, heads: 1, tokens, stride: rowWidth, offset });

  // El cierre común de los dos tipos de bloque: residual, norm, SwiGLU, residual.
  // Con `postNorms` (lfm3) la salida del bloque y la del FFN pasan por su propia
  // RMSNorm ANTES de sumarse al residual.
  async function feedForward(x, layerOut, i, tokens) {
    const n = tokens * E;
    // FUSIÓN (F1): post-norma + residual + norma del FFN en un despacho. Sin
    // fusión `f1` es null y lo de abajo es exactamente lo de siempre.
    const f1 = fusionPase ? await fus.normaResidual(layerOut, x,
      hp.postNorms ? get(`blk.${i}.post_attention_norm.weight`) : null,
      get(`blk.${i}.${hp.ffnNorm}.weight`), tokens, E, eps) : null;
    if (hp.postNorms && !f1) {
      layerOut = await nn.rmsnorm(layerOut, get(`blk.${i}.post_attention_norm.weight`), tokens, E, eps);
    }
    const res = f1 ? f1.res : await nn.add(x, layerOut, n);
    // El nombre sale del perfil, no de `has(...)`: si se decidiera por presencia
    // del tensor, un modelo al que le faltara dejaría de fallar y empezaría a
    // mentir con una norma menos.
    const nrm = f1 ? f1.nrm : await nn.rmsnorm(res, get(`blk.${i}.${hp.ffnNorm}.weight`), tokens, E, eps);
    // gate+up+SwiGLU en un despacho (`__ELFFUSS_GEMV2`); null = camino de siempre.
    const f3 = globalThis.__ELFFUSS_GEMV2 === true ? await gateUpFusion(i, nrm, tokens) : null;
    const gate = f3 ? null : await mm(`blk.${i}.ffn_gate.weight`, nrm, hp.ffnLength, E, tokens);
    const up = f3 ? null : await mm(`blk.${i}.ffn_up.weight`, nrm, hp.ffnLength, E, tokens);
    // La intermedia del FFN lleva sonda. No es simetría con los otros nodos:
    // las tres matrices del FFN son dos tercios de los pesos del modelo, y si
    // esta activación es dispersa, las columnas de `ffn_down` que multiplican a
    // un canal despreciable no hace falta ni LEERLAS. Medir eso exige poder
    // verla, y sin sonda no se puede.
    const sw = P('ffn_sw', f3 || await nn.swiglu(gate, up, tokens * hp.ffnLength), tokens * hp.ffnLength);
    let down = await mm(`blk.${i}.ffn_down.weight`, sw, E, hp.ffnLength, tokens);
    if (f1) return await cierreFusion(down, res, i, tokens);
    if (hp.postNorms) down = await nn.rmsnorm(down, get(`blk.${i}.post_ffw_norm.weight`), tokens, E, eps);
    return await nn.add(res, down, n);
  }

  // FUSIÓN (F1), el cierre del bloque: post-norma del FFN + residual + la norma
  // de lo que viene después (la `attn_norm` de la capa siguiente o la final),
  // que se deja hecha en `nrmPendiente` para quien la consuma. Esa norma nace
  // con los intermedios del FFN de esta capa aún sin reciclar: en un modelo sin
  // post-normas el pico de memoria puede llevar una fila de activaciones más;
  // con ellas (lfm3) baja, porque las post-normas ya no se materializan.
  async function cierreFusion(down, res, i, tokens) {
    const sig = normaSiguiente.get(i);
    const r = await fus.normaResidual(down, res,
      hp.postNorms ? get(`blk.${i}.post_ffw_norm.weight`) : null, get(sig.peso), tokens, E, eps);
    nrmPendiente = { capa: sig.capa, peso: sig.peso, buf: r.nrm };
    return r.res;
  }

  // ── LA ÚLTIMA CAPA, SOLO PARA EL ÚLTIMO TOKEN (interruptor GEMM2_COLA) ─────
  // De la última capa de un prompt solo se usa la fila del último token: es la
  // única que llega a la cabeza. Sus cachés (KV, ventana de la convolución,
  // estado recurrente) sí necesitan TODOS los tokens, y se escriben antes de la
  // proyección de salida. Así que el corte va justo ahí: la mezcla se calcula
  // entera, y la proyección de salida, las normas sándwich, el FFN y las sumas
  // residuales se hacen para UNA fila.
  //
  // Tiene que dar los MISMOS bits. Las normas, las sumas y SwiGLU van fila a
  // fila o elemento a elemento, así que una fila sola sale igual que dentro del
  // lote. Los matmuls no: con un token caerían en el matvec, que suma en otro
  // orden. Por eso van por `quant.gemm2.cola`, que usa el mismo kernel y la misma
  // forma que habría tocado al lote entero. Si alguno de los cuatro pesos no
  // puede ir así, la capa se calcula como siempre (ver `colaReproducible`).
  //
  // `colaLote` vale el tamaño del lote SOLO mientras se calcula la última capa
  // con el corte puesto; se fija antes de cada capa y se borra al empezar cada
  // pasada, para que un forward que lanzó a medias no deje el corte armado.
  // `colaCortada` lo pone `colaFinal`: dice que el bloque llegó de verdad al
  // corte, que es lo que `unaPasada` exige antes de dar la capa por cortada.
  let colaLote = 0;
  let colaCortada = false;
  const mmCola = async (name, x1, rows, k, lote) => {
    const w = W(name);
    let xin = x1;
    if (rot && rot.pesos.has(name)) {
      rotVistos.add(name);
      xin = await giraEntrada(x1, k, 1, permDe(name, k));
    }
    const y = await quant.gemm2.cola(w.t.typeName, w.buf, xin, rows, k, lote);
    // `colaReproducible` lo comprobó antes de empezar: si aun así no aplica es
    // un fallo de programación, y se dice. Caer al matvec daría otros bits.
    if (!y) throw new Error(`cola: «${name}» no se puede calcular con el kernel del lote`);
    return y;
  };
  async function feedForwardCola(x1, out1, i, lote) {
    let layerOut = out1;
    if (hp.postNorms) {
      layerOut = await nn.rmsnorm(layerOut, get(`blk.${i}.post_attention_norm.weight`), 1, E, eps);
    }
    const res = await nn.add(x1, layerOut, E);
    const nrm = await nn.rmsnorm(res, get(`blk.${i}.${hp.ffnNorm}.weight`), 1, E, eps);
    const gate = await mmCola(`blk.${i}.ffn_gate.weight`, nrm, hp.ffnLength, E, lote);
    const up = await mmCola(`blk.${i}.ffn_up.weight`, nrm, hp.ffnLength, E, lote);
    const sw = await nn.swiglu(gate, up, hp.ffnLength);
    let down = await mmCola(`blk.${i}.ffn_down.weight`, sw, E, hp.ffnLength, lote);
    if (hp.postNorms) down = await nn.rmsnorm(down, get(`blk.${i}.post_ffw_norm.weight`), 1, E, eps);
    return await nn.add(res, down, E);
  }
  // `mezcla` es la salida del bloque ANTES de su proyección de salida, con
  // `ancho` columnas; `x` la entrada del bloque (el residual). Devuelve UNA fila.
  async function colaFinal(x, mezcla, nombreSalida, ancho, i, tokens) {
    colaCortada = true;
    const mezclaFila = ctx.alloc(ancho * 4, 'cola.mezcla');
    await copyInto(mezcla, mezclaFila, 0, ancho, (tokens - 1) * ancho);
    const x1 = ctx.alloc(E * 4, 'cola.x');
    await copyInto(x, x1, 0, E, (tokens - 1) * E);
    const out1 = await mmCola(nombreSalida, mezclaFila, E, ancho, tokens);
    return await feedForwardCola(x1, out1, i, tokens);
  }
  function colaReproducible(l, tokens) {
    const i = l.index;
    const salida = l.kind === 'conv' ? [`blk.${i}.shortconv.out_proj.weight`, E, E]
      : l.kind === 'ssm' ? [`blk.${i}.ssm_out.weight`, E, hp.ssmInner]
      : [`blk.${i}.attn_output.weight`, E, H * D];
    return [salida,
      [`blk.${i}.ffn_gate.weight`, hp.ffnLength, E],
      [`blk.${i}.ffn_up.weight`, hp.ffnLength, E],
      [`blk.${i}.ffn_down.weight`, E, hp.ffnLength],
    ].every(([n, r, k]) => has(n) && quant.gemm2.reproducible(W(n).t.typeName, r, k, tokens));
  }

  // La convolución CORTA de lfm3. Mismo andamio que la conv del SSM (ventana con
  // el estado de los tokens anteriores, conv depthwise causal, guardar el
  // estado), pero sin silu y entre dos puertas:
  //   in_proj → [B | C | x] → B·x → conv(K) → C·y → out_proj
  // El orden de los tres trozos es el de llama.cpp (`build_lfm_shortconv`):
  // B primero, luego C, luego x. Cambiarlo no peta, da ruido con cara de texto.
  async function convBlock(x, i, tokens) {
    capaActual = i;
    const nrm = P('attn_norm', normaHecha(i, `blk.${i}.attn_norm.weight`) ?? await nn.rmsnorm(x, get(`blk.${i}.attn_norm.weight`), tokens, E, eps), tokens * E);
    const bcx = P('in_proj', await mm(`blk.${i}.shortconv.in_proj.weight`, nrm, 3 * E, E, tokens), tokens * 3 * E);
    let y;
    if (fusionPase && fus.convCabe(CK)) {
      // FUSIÓN (F4): de `in_proj` a la entrada de `out_proj` en un despacho —los
      // tres cortes, B·x, la ventana, la conv, guardar el estado y C·y—. Solo
      // sustituye esa fontanería y deja `y` donde la deja la cadena: la cola del
      // bloque (`out_proj` y el FFN) es UNA para los dos caminos, y lo que se le
      // cuelgue a esa cola lo ven los dos. Los intermedios `bx` y `conv` no
      // llegan a existir, así que esas dos sondas no se ofrecen. Un kernel de
      // conv más largo que la tesela del kernel fusionado va por la cadena.
      y = await fus.convCorta(bcx, state.ssm.get(i).conv, get(`blk.${i}.shortconv.conv.weight`), E, tokens, CK);
    } else {
      const b = await slice(bcx, 0, E, tokens, 3 * E);
      const c = await slice(bcx, E, E, tokens, 3 * E);
      const xs = await slice(bcx, 2 * E, E, tokens, 3 * E);
      const bx = P('bx', await attn.mul(b, xs, tokens * E), tokens * E);

      const st = state.ssm.get(i);
      const window = CK - 1 + tokens;
      const pw = await pipe('conv_window', convWindowShader());
      const win = ctx.alloc(E * window * 4, 'convwin');
      const pwp = ctx.uniform([new Uint32Array([E, tokens, CK - 1, window])]);
      await raw('conv_window', pw, [st.conv, bx, win, pwp], Math.ceil(E * window / 256));
      const conv = P('conv', await ssmOps.conv(win, get(`blk.${i}.shortconv.conv.weight`), E, tokens, CK), tokens * E);
      const ps = await pipe('conv_save', convSaveShader());
      const psp = ctx.uniform([new Uint32Array([E, tokens, CK - 1, window])]);
      await raw('conv_save', ps, [win, st.conv, psp], Math.ceil(E * (CK - 1) / 256));

      y = await attn.mul(c, conv, tokens * E);
    }
    if (colaLote) return await colaFinal(x, y, `blk.${i}.shortconv.out_proj.weight`, E, i, tokens);
    const out = P('conv_out', await mm(`blk.${i}.shortconv.out_proj.weight`, y, E, E, tokens), tokens * E);
    return await feedForward(x, out, i, tokens);
  }

  async function ssmBlock(x, i, tokens) {
    capaActual = i;
    const nrm = P('attn_norm', normaHecha(i, `blk.${i}.attn_norm.weight`) ?? await nn.rmsnorm(x, get(`blk.${i}.attn_norm.weight`), tokens, E, eps), tokens * E);

    // qkv fusionado → ventana de conv (transposición + concatenación con el
    // estado del token anterior) → conv depthwise causal → silu.
    const qkv = P('qkv', await mm(`blk.${i}.attn_qkv.weight`, nrm, CC, E, tokens), tokens * CC);
    const st = state.ssm.get(i);
    const window = CK - 1 + tokens;
    const pw = await pipe('conv_window', convWindowShader());
    const win = ctx.alloc(CC * window * 4, 'convwin');
    const pwp = ctx.uniform([new Uint32Array([CC, tokens, CK - 1, window])]);
    await raw('conv_window', pw, [st.conv, qkv, win, pwp], Math.ceil(CC * window / 256));

    const conv = P('conv_raw', await ssmOps.conv(win, get(`blk.${i}.ssm_conv1d.weight`), CC, tokens), tokens * CC);
    const act = P('conv_silu', await silu(conv, CC * tokens), tokens * CC);

    // El estado de conv se guarda DESPUÉS de leer la ventana, no antes.
    const ps = await pipe('conv_save', convSaveShader());
    const psp = ctx.uniform([new Uint32Array([CC, tokens, CK - 1, window])]);
    await raw('conv_save', ps, [win, st.conv, psp], Math.ceil(CC * (CK - 1) / 256));

    const qRawS = P('q_conv', await slice(act, 0, KEY, tokens, CC), tokens * KEY);
    const kRawS = P('k_conv', await slice(act, KEY, KEY, tokens, CC), tokens * KEY);
    const q = P('q_l2', await ssmOps.l2norm(qRawS, tokens * SH, SS, eps), tokens * KEY);
    const k = P('k_l2', await ssmOps.l2norm(kRawS, tokens * SH, SS, eps), tokens * KEY);
    const v = P('v_conv', await slice(act, 2 * KEY, hp.ssmInner, tokens, CC), tokens * hp.ssmInner);

    // alpha y beta salen de la ENTRADA normalizada, no del qkv ni de la conv.
    const alpha = P('alpha', await mm(`blk.${i}.ssm_alpha.weight`, nrm, SV, E, tokens), tokens * SV);
    const gdecay = P('gate', await ssmOps.decayGate(alpha, get(`blk.${i}.ssm_dt.bias`),
      get(`blk.${i}.ssm_a`), SV, tokens), tokens * SV);
    const betaRaw = await mm(`blk.${i}.ssm_beta.weight`, nrm, SV, E, tokens);
    const beta = P('beta', await ssmOps.sigmoid(betaRaw, SV * tokens), tokens * SV);

    const o = P('gdn_out', await ssmOps.gatedDeltaNet(q, k, v, gdecay, beta, st.state, SV, tokens, SH), tokens * hp.ssmInner);

    // La puerta del norm final sale de su propia proyección.
    //
    // Los tres nodos que van de aquí al residual llevan sonda porque son el
    // último tramo del bloque donde el recuento de cabezas de VALOR vuelve a
    // importar: la norma con puerta normaliza por filas de SS sobre tokens×SV.
    // Sin sonda, un fallo aquí no aparecía como «la norma con puerta está mal»,
    // aparecía como una escalera que se desvía desde el bloque 0 sin decir en
    // qué operación.
    const z = P('z', await mm(`blk.${i}.attn_gate.weight`, nrm, hp.ssmInner, E, tokens), tokens * hp.ssmInner);
    const gn = P('gated_norm',
      await ssmOps.gatedNorm(o, get(`blk.${i}.ssm_norm.weight`), z, tokens * SV, SS, eps),
      tokens * hp.ssmInner);
    if (colaLote) return await colaFinal(x, gn, `blk.${i}.ssm_out.weight`, hp.ssmInner, i, tokens);
    const out = P('ssm_out', await mm(`blk.${i}.ssm_out.weight`, gn, E, hp.ssmInner, tokens), tokens * E);
    return await feedForward(x, out, i, tokens);
  }

  // `rope_freqs` (lfm3): un solo tensor para todas las capas globales.
  const factoresRope = has('rope_freqs.weight') ? get('rope_freqs.weight') : null;

  async function attnBlock(x, l, tokens, posBuf) {
    const i = l.index;
    capaActual = i;
    // Base de RoPE y ventana POR CAPA (lfm3); en el resto, las del modelo.
    const ropeBase = l.ropeBase ?? hp.ropeFreqBase;
    const factores = l.ropeFactores ? factoresRope : null;
    if (l.ropeFactores && !factores) throw new Error(`la capa ${i} pide rope_freqs y el fichero no lo trae`);
    const nrm = normaHecha(i, `blk.${i}.attn_norm.weight`) ?? await nn.rmsnorm(x, get(`blk.${i}.attn_norm.weight`), tokens, E, eps);

    // En qwen35 `attn_q` proyecta al DOBLE —Q y una puerta INTERCALADOS por
    // cabeza— y hay que partirlo. En llama proyecta a H*D y ya está, así que no
    // hay nada que partir: el matmul deja [T][H*D], que es justo [T][H][D], la
    // forma que esperan RoPE y los scores. Ni una copia de por medio.
    // GEMV2: Q, K, V y la puerta en un despacho; las recoge `mm` (ver `qkvFusion`).
    if (globalThis.__ELFFUSS_GEMV2 === true) await qkvFusion(i, nrm, tokens);
    let qRaw, gRaw = null;
    if (hp.qGate) {
      const qfull = await mm(`blk.${i}.attn_q.weight`, nrm, 2 * H * D, E, tokens);
      qRaw = await attn.strideCopy(qfull, { headDim: D, heads: H, tokens, stride: 2 * D, offset: 0 });
      gRaw = await attn.strideCopy(qfull, { headDim: D, heads: H, tokens, stride: 2 * D, offset: D });
    } else {
      qRaw = await mm(`blk.${i}.attn_q.weight`, nrm, H * D, E, tokens);
    }

    // QK-norm ANTES de RoPE.
    //
    // Y el RoPE va en NEOX aunque la referencia use MRoPE intercalado (qwen35
    // declara IMROPE, con cuatro secciones de dimensiones). NO es una
    // simplificación: para texto puro las dos son la MISMA función, y conviene
    // dejar por qué, porque parece un bug cada vez que se lee.
    //   1. El MRoPE reparte las dimensiones entre cuatro ejes de posición
    //      (t, h, w y uno extra) — de ahí que sea multimodal.
    //   2. Con tokens de texto, llama.cpp escribe la MISMA posición en las
    //      cuatro ranuras, así que los cuatro ángulos valen lo mismo y da igual
    //      qué eje toque a cada dimensión.
    //   3. Los cuatro avanzan en bloque: `indep_sects` sale de `is_vision`, que
    //      es falso aquí, o sea que ninguna sección reinicia su ángulo.
    //   4. Y el emparejamiento de elementos es literalmente la misma llamada
    //      que el NEOX, `rotate_pairs(n_dims, n_dims/2)`.
    // Deja de valer en cuanto entre una imagen: ahí las posiciones dejan de ser
    // iguales y hace falta el MRoPE de verdad.
    // ⚠️ EL MODO DE RoPE SALE DEL PERFIL, y es el cambio que más miedo da de
    // toda esta lista: equivocarse NO peta. Sale texto gramatical que se
    // degrada al crecer el contexto, o sea el fallo más caro de detectar que
    // hay. qwen35 empareja como NEOX; llama usa NORM porque su conversor a GGUF
    // ya permuta los pesos. Ver `state.js`, ARQUITECTURAS.
    const modoRope = hp.ropeMode === 'norm' ? ROPE_NORM : ROPE_NEOX;
    // A la caché, a partir de nPast: nunca se pisa lo ya cacheado.
    const cache = state.kv.get(i);
    const per = KVH * D;
    // UNA sola fuente de verdad para la precisión de la caché, leída del estado
    // que la reservó. Escribirla y leerla con precisiones distintas no lanza:
    // devuelve basura, y por eso el dato no se repite en cuatro sitios.
    const kvF16 = !!state.kvF16;
    let q;
    if (fusionPase && fus.qkvCabe(D, hp.ropeDims, { norma: !!hp.qkNorm, factores: !!factores })) {
      // FUSIÓN (F6): QK-norm + RoPE de q y k + K y V a la caché, en un despacho.
      // Las proyecciones de k y v se piden aquí, antes, porque el kernel quiere
      // las tres a la vez; el orden entre proyecciones independientes no cambia
      // ningún resultado. La misma precisión de caché que la cadena (`kvF16`).
      // Si el dispositivo no admite tantos buffers por despacho, va partido en
      // dos (consulta, y clave con valor); si ni así, por la cadena.
      const kRaw = await mm(`blk.${i}.attn_k.weight`, nrm, KVH * D, E, tokens);
      const v = await mm(`blk.${i}.attn_v.weight`, nrm, KVH * D, E, tokens);
      q = await fus.qkNormaRopeCache({
        q: qRaw, k: kRaw, v, pos: posBuf,
        wq: hp.qkNorm ? get(`blk.${i}.attn_q_norm.weight`) : null,
        wk: hp.qkNorm ? get(`blk.${i}.attn_k_norm.weight`) : null,
        cacheK: cache.k, cacheV: cache.v,
        heads: H, kvHeads: KVH, headDim: D, tokens, nPast: state.nPast,
        nDims: hp.ropeDims, mode: modoRope, freqBase: ropeBase, factores, kvF16, eps,
      });
    } else {
      // La QK-norm tampoco es universal: llama no trae `attn_q_norm` siquiera.
      const qn = hp.qkNorm
        ? await nn.rmsnorm(qRaw, get(`blk.${i}.attn_q_norm.weight`), tokens * H, D, eps)
        : qRaw;
      q = await nn.rope(qn, posBuf,
        { rows: tokens * H, ne0: D, heads: H, nDims: hp.ropeDims, mode: modoRope, freqBase: ropeBase, factores });

      const kRaw = await mm(`blk.${i}.attn_k.weight`, nrm, KVH * D, E, tokens);
      const kn = hp.qkNorm
        ? await nn.rmsnorm(kRaw, get(`blk.${i}.attn_k_norm.weight`), tokens * KVH, D, eps)
        : kRaw;
      const k = await nn.rope(kn, posBuf,
        { rows: tokens * KVH, ne0: D, heads: KVH, nDims: hp.ropeDims, mode: modoRope, freqBase: ropeBase, factores });
      const v = await mm(`blk.${i}.attn_v.weight`, nrm, KVH * D, E, tokens);

      await copyInto(k, cache.k, state.nPast * per, tokens * per, 0, kvF16);
      await copyInto(v, cache.v, state.nPast * per, tokens * per, 0, kvF16);
    }

    const nKv = state.nPast + tokens;
    const cfg = { headDim: D, heads: H, kvHeads: KVH, tokens, nKv, nPast: state.nPast, kvF16 };
    // ── Atención FUSIONADA (`__ELFFUSS_FLASH`, ver ops.flash.js) ────────────
    // Puntuaciones, softmax con la máscara causal y de ventana y combinación en
    // uno o dos despachos, sin materializar las puntuaciones, y con la puerta
    // por cabeza de lfm3 dentro de su epílogo. Misma matemática salvo redondeo.
    // Sustituye SOLO al núcleo: lo de después (la puerta de Q de qwen35, la
    // proyección de salida, el residual) es el mismo código para las dos rutas,
    // y así lo que se añada ahí vale también para esta. Si la forma no se puede
    // atender, `fusionada` queda en null y va la cadena de siempre, que da lo
    // mismo más despacio. La puerta de cabeza va dentro solo si no hay la de Q:
    // la misma precedencia que abajo. `puede` recibe la misma forma (con la
    // puerta) que `atencion`: si no, preguntaría por otro kernel.
    const fusionada = globalThis.__ELFFUSS_FLASH === true && ops.flash?.puede({ ...cfg, ventana: l.ventana || 0, puerta: !hp.qGate && !!hp.headGate })
      ? await ops.flash.atencion(q, cache.k, cache.v, { ...cfg, ventana: l.ventana || 0,
        puerta: !hp.qGate && hp.headGate ? await mm(`blk.${i}.attn_gate.weight`, nrm, H, E, tokens) : null })
      : null;
    const scores = fusionada ? null : await attn.scores(q, cache.k, cfg);
    const probs = fusionada ? null : await nn.softmax(scores,
      { rows: H * tokens, nKv, nQ: tokens, nPast: state.nPast, scale: 1 / Math.sqrt(D), ventana: l.ventana || 0 });
    const att = fusionada || await attn.combine(probs, cache.v, cfg);

    // La puerta multiplica la salida ANTES de la proyección — cuando la hay.
    // En llama la atención va directa a la proyección de salida.
    let gated = att;
    if (hp.qGate) {
      const gsig = await ssmOps.sigmoid(gRaw, tokens * H * D);
      gated = await attn.mul(att, gsig, tokens * H * D);
    } else if (hp.headGate && !fusionada) {
      // lfm3: un escalar por cabeza, de la ENTRADA normalizada (no de Q).
      const gh = await mm(`blk.${i}.attn_gate.weight`, nrm, H, E, tokens);
      const p = await pipe('mul_cabeza', mulCabezaShader());
      gated = ctx.alloc(tokens * H * D * 4, 'gated');
      const pp = ctx.uniform([new Uint32Array([tokens * H * D, D, 0, 0])]);
      await raw('mul_cabeza', p, [att, gh, gated, pp], Math.ceil(tokens * H * D / 256));
    }
    if (colaLote) return await colaFinal(x, gated, `blk.${i}.attn_output.weight`, H * D, i, tokens);
    const out = await mm(`blk.${i}.attn_output.weight`, gated, E, H * D, tokens);
    return await feedForward(x, out, i, tokens);
  }

  // El reloj del respiro de un prefill troceado, con `__ELFFUSS_PLAN` (si no,
  // null y todo como siempre). Sin él, cada pasada arrancaba en «ya toca» y
  // pagaba, tras su segunda capa, un frame entero con el dispositivo parado:
  // uno por lote. Dos cosas lo evitan sin perder para qué existe el respiro
  // (que el compositor pinte):
  //   · el reloj se COMPARTE entre las pasadas del mismo forward, como si
  //     fueran una sola: un respiro cada `cederMs` como mucho;
  //   · un frame PINTADO cuenta como respiro. Un latido con rAF apunta cuándo
  //     se pintó el último; si el compositor está pintando mientras esperamos
  //     al dispositivo entre lotes, forzar otro hueco no compra nada. Si deja de
  //     pintar, el latido se para y el respiro vuelve a entrar igual que antes.
  // El PRIMERO del forward sigue entrando en cuanto se puede (lo que busca es
  // que lo último de la pantalla se vea antes de que el dispositivo se ocupe),
  // pero con PLAN cede el frame SIN vaciar la cola (`respiroSinVaciar`): en ese
  // momento el dispositivo solo tiene en cola las capas recién enviadas, el
  // compositor entra entre un envío y el siguiente, y el dispositivo sigue
  // trabajando mientras llega el frame en vez de esperarlo parado. Esto vale
  // también para el prefill de una sola pasada, que era un frame ocioso por
  // forward. Los respiros siguientes, si hacen falta (si no se ve pintar),
  // vacían la cola como siempre: ahí el hueco es lo que garantiza el frame.
  // Con `cederMs = 0` (el A/B) nada cambia: respira cada `cederCada` capas y
  // vaciando siempre.
  let relojRespiro = null;
  let respiroSinVaciar = false;
  const nuevoRelojRespiro = () => {
    const r = { t: -Infinity, frame: -Infinity, actividad: performance.now() };
    if (typeof requestAnimationFrame === 'function') {
      const late = () => {
        // Se apaga solo cuando el forward deja de dar señales (acabó o se paró).
        if (performance.now() - r.actividad > 2000 || typeof requestAnimationFrame !== 'function') return;
        r.frame = performance.now();
        requestAnimationFrame(late);
      };
      requestAnimationFrame(late);
    }
    return r;
  };

  // UNA pasada: la implementación de siempre, intacta. La trocea `forward`.
  //
  // `signal` se mira en cada FRONTERA DE CAPA, y parar no rompe el lote a
  // medias: se deja de grabar, el callback devuelve null y `ctx.batch` cierra y
  // envía lo grabado por su camino normal (ops.js no sabe nada de parar). Lo que
  // sí hay que hacer antes de lanzar es esperar al dispositivo: los uniformes del lote
  // solo se pueden reciclar después de una sincronización —ver `forward`—, y
  // quien recibe el error va a reciclar. `state.advance` NO se llama: el lote no
  // terminó, así que nPast sigue donde estaba y lo que se escribió en la caché
  // por encima queda tapado por la máscara causal. El estado recurrente sí quedó
  // a medias, y por eso todo turno empieza con `restaura()` o `reset()`.
  const unaPasada = async (tokenIds, { tap = null, todosLosLogits = false, signal = null } = {}) => {
    let logitsTokens = 1;
    let parado = false;
    const tokens = tokenIds.length;
    const taps = new Map();
    const idsBuf = ctx.alloc(tokens * 4, 'ids');
    device.queue.writeBuffer(idsBuf, 0, new Uint32Array(tokenIds));
    const posBuf = ctx.alloc(tokens * 4, 'pos');
    device.queue.writeBuffer(posBuf, 0,
      Int32Array.from({ length: tokens }, (_, i) => state.nPast + i));

    memoRot = new Map();   // la memoria de rotación vale para UN forward
    conservadas = new Set();   // y lo que las sondas pidan conservar, también
    // FUSIÓN: el interruptor se lee UNA vez por pasada, y una norma pendiente de
    // una pasada anterior (parada a medias) no vale para esta.
    fusionPase = fusionActiva();
    nrmPendiente = null;
    // GEMM2_COLA (ver `colaFinal`). Nunca con sondas, taps ni todos los logits:
    // ahí se leen las filas de todos los tokens de la última capa.
    colaLote = 0;
    colaCortada = false;
    const ultimaCapa = hp.layers[hp.layers.length - 1];
    const cola = globalThis.__ELFFUSS_GEMM2 === true && globalThis.__ELFFUSS_GEMM2_COLA === true &&
      tokens > 1 && !tap && !todosLosLogits && !probe && !!quant.gemm2 && colaReproducible(ultimaCapa, tokens);
    let colaHecha = false;
    const logits = await ops.batch('forward', async () => {
      let x = fusionPase ? await gatherFusion(idsBuf, tokens) : await gather(idsBuf, tokens);
      // El índice −1 es el embedding, antes de la primera capa. No es un
      // capricho de simetría: si los ids o la tabla se leen mal, TODAS las
      // capas se desvían y la escalera señala la 0 sin distinguir «entré mal»
      // de «la capa 0 calcula mal». Con este ancla esa duda se resuelve.
      if (tap && tap.has(-1)) taps.set(-1, x);
      let capaN = 0;
      // Arranca en «ya toca»: la primera capa de un prefill largo es un buen
      // momento para dejar pintar, y no depender del reloj del forward anterior.
      // Con PLAN, las pasadas siguientes del MISMO forward siguen su reloj.
      let ultimoRespiro = relojRespiro ? relojRespiro.t : -Infinity;
      for (const l of hp.layers) {
        if (signal?.aborted) { parado = true; break; }
        // Se recicla lo de CADA capa en cuanto termina, en vez de guardarlo
        // todo hasta el final del forward. Sin esto el pico de memoria del dispositivo
        // crecía con capas × tokens, o sea que con un prompt normal llegaba a
        // pedir varias veces lo que pesa el modelo entero — y el factor empeora
        // cuantas más capas tiene.
        const marca = ctx.scratch.length;
        // FUSIÓN: la norma que dejó hecha la capa anterior muere al acabar ESTA,
        // como la norma que sustituye (ver `reciclableDesde`). Sin fusión no hay
        // pendiente y la marca es la de siempre.
        const marcaCapa = nrmPendiente ? fus.reciclableDesde(nrmPendiente.buf, marca) : marca;
        const previo = x;
        colaLote = cola && l === ultimaCapa ? tokens : 0;
        x = l.kind === 'ssm' ? await ssmBlock(x, l.index, tokens)
          : l.kind === 'conv' ? await convBlock(x, l.index, tokens)
          : await attnBlock(x, l, tokens, posBuf);
        if (colaLote) {
          // Que el corte estuviera armado no basta: el bloque tiene que haber
          // pasado por `colaFinal`. Un camino del bloque que vuelva antes del
          // corte (otra variante del mismo bloque, una fusión) devuelve TODAS
          // las filas, y la cabeza de una fila leería la del PRIMER token:
          // logits de otro token, sin un error. Se dice aquí, antes de la cabeza.
          if (!colaCortada) throw new Error(`cola: la capa ${l.index} volvió sin pasar por el corte (colaFinal)`);
          colaHecha = true; colaLote = 0;   // x es ya UNA fila
        }
        if (tap && tap.has(l.index)) taps.set(l.index, x);
        // Vivos: la salida de esta capa (entra en la siguiente), la entrada si
        // el bloque la devolvió tal cual, y cualquier tensor con sonda puesta,
        // que el llamador va a leer DESPUÉS del forward.
        // Con fusión, también la norma que esta capa deja hecha para la siguiente.
        ctx.recycleDesde(marcaCapa, x, previo, ...taps.values(), ...conservadas,
          ...(nrmPendiente ? [nrmPendiente.buf] : []));
        // Trocear el forward para no colgar el ordenador. SOLO en prefill
        // (tokens>1): el decode es 1 token y nunca colgó, y trocearlo lo
        // ralentizaría sin motivo. Se corta el command buffer en CADA capa
        // (barato: solo un submit más) y de vez en cuando se drena la cola y se
        // cede un frame, para que el compositor tenga su hueco. No cambia la
        // numérica: el orden de la cola se respeta. Ver ctx.corta.
        //
        // El troceo es GRATIS y va en todas las capas; el respiro es CARO (drena
        // la cola, que mata el solape entre la CPU y el dispositivo, y encima espera
        // al refresco) y va
        // limitado por reloj. Ver `cederMs`: antes iba atado al contador de capas
        // y era lo que fijaba el techo del prefill.
        // DECODE: cortar el command buffer cada `cortaDecode` capas deja que el
        // dispositivo empiece mientras la CPU sigue grabando el resto del token.
        // Sin respiro (no hace falta: un token no cuelga nada). 0 = no cortar.
        if (tokens === 1 && cortaDecode > 0 && (capaN + 1) % cortaDecode === 0 && capaN + 1 < hp.layers.length) ctx.corta();
        if (tokens === 1) capaN++;
        if (tokens > 1) {
          if (relojRespiro) {
            relojRespiro.actividad = performance.now();
            if (relojRespiro.frame > ultimoRespiro) ultimoRespiro = relojRespiro.frame;
          }
          const toca = (capaN + 1) % cortaCada === 0;
          // El respiro drena la cola; si el pase sigue abierto, lo que drena es
          // una cola VACÍA —el trabajo ni se ha enviado— y se paga el frame sin
          // conseguir el hueco que se buscaba. Así que cuando el respiro va a
          // entrar, se corta aunque no tocase por intervalo.
          const respira = (capaN + 1) % cederCada === 0 && performance.now() - ultimoRespiro >= cederMs;
          if (toca || respira) ctx.corta();
          capaN++;
          if (respira) {
            // Con PLAN, el primero del forward no vacía la cola (ver arriba).
            if (!(respiroSinVaciar && cederMs > 0 && ultimoRespiro === -Infinity)) await device.queue.onSubmittedWorkDone();
            await nuevoFrame(signal);
            ultimoRespiro = performance.now();
            if (relojRespiro) relojRespiro.t = ultimoRespiro;
          }
        }
      }
      // La última frontera: tras la última capa solo queda la cabeza, y unos
      // logits que nadie va a leer no merecen la espera.
      if (signal?.aborted) parado = true;
      if (parado) return null;
      if (colaHecha) {
        // La última capa ya dejó solo la fila del último token: la misma norma
        // y la misma cabeza que abajo, sin el recorte (ya está hecho).
        const nrm1 = await nn.rmsnorm(x, get('output_norm.weight'), 1, E, eps);
        const cabeza = has('output.weight') ? 'output.weight' : 'token_embd.weight';
        logitsTokens = 1;
        return await mm(cabeza, nrm1, model.g.meta['tokenizer.ggml.tokens'].length, E, 1);
      }
      // Con fusión, la norma final ya la dejó hecha la última capa (F1).
      const nrm = normaHecha('salida', 'output_norm.weight') ?? await nn.rmsnorm(x, get('output_norm.weight'), tokens, E, eps);
      // SOLO EL ÚLTIMO TOKEN. La cabeza es la matriz más grande del modelo
      // (vocabulario × embedding) y para generar solo hace falta la última fila:
      // calcularla para todo el prompt costaba cientos de veces más, y se pagaba
      // por N−1 vectores de logits que se descartan enteros.
      let entradaCabeza = nrm, tokensCabeza = tokens;
      if (!todosLosLogits && tokens > 1) {
        const fila = ctx.alloc(E * 4, 'ultimo');
        await copyInto(nrm, fila, 0, E, (tokens - 1) * E);
        entradaCabeza = fila; tokensCabeza = 1;
      }
      const head = has('output.weight') ? 'output.weight' : 'token_embd.weight';
      logitsTokens = tokensCabeza;
      return await mm(head, entradaCabeza, model.g.meta['tokenizer.ggml.tokens'].length,
        E, tokensCabeza);
    });

    if (parado) {
      // La espera va ANTES de lanzar, no es opcional: ver arriba.
      await device.queue.onSubmittedWorkDone();
      throw errorParado();
    }
    state.advance(tokens);
    // `logitsTokens` dice para CUÁNTOS tokens hay logits: casi siempre 1,
    // aunque `tokens` sea el prompt entero. Sin este dato, quien deduzca el
    // tamaño del vocabulario dividiendo por `tokens` se equivoca.
    return { logits, tokens, logitsTokens, taps };
  };

  // DIAGNÓSTICO DE COBERTURA. El fichero enumera cuántos tensores llevan
  // rotación; si el forward toca muchos menos, hay un camino que se la salta —
  // y eso no falla, devuelve ruido.
  const _rotacion = () => (rot ? {
    declarados: rot.pesos.size, inversos: rot.inversos.size,
    aplicados: rotVistos.size, bloque: rot.bloque,
    faltan: [...rot.pesos, ...rot.inversos].filter((n) => !rotVistos.has(n)),
  } : null);

  return {
    _rotacion,
    state,
    hp,

    // Ejecuta el forward y devuelve los logits del ÚLTIMO token.
    // `tap` permite pedir el residual de una capa concreta para compararlo con
    // el oráculo: es la diferencia entre «el texto suena raro» y «el bloque 7
    // se desvía y los seis anteriores cuadran».
    // Prefill TROCEADO. La máscara causal se aplica en el softmax, DESPUÉS de
    // calcular los scores, así que una pasada de N tokens calcula la matriz
    // N×N entera y tira la mitad. Troceando, cada lote solo se mide contra lo
    // que ya hay: para 1347 tokens en lotes de 512 son 1,22 M de posiciones en
    // vez de 1,81 M, y la diferencia CRECE con la longitud (×1,6 a 2048, ×1,78
    // a 4096). Es la parte «superlineal» que la medida del prefill detectó y la
    // razón de que llama.cpp —que trocea por defecto— fuera 58× más rápido.
    //
    // No toca ningún kernel ni la numérica: es la misma maquinaria del decode,
    // con nPast avanzando entre lotes. Lo que cambia es cuánto trabajo inútil
    // se hace, no el resultado.
    //
    // PARAR: `opts.signal` (un AbortSignal) se mira al entrar, entre lotes y en
    // cada frontera de capa dentro de un lote. Al entrar no se toca nada; entre
    // lotes, nPast queda al final del último lote completo; dentro de uno, donde
    // empezó ese lote. Las tres salidas lanzan un AbortError y dejan el
    // dispositivo en reposo, así que `recycle()` es seguro justo después. Todo lote terminado
    // se avisa por `onProgress`, también el último antes del «para»: lo que se
    // cuenta es trabajo hecho, y nPast lo incluye.
    async forward(tokenIds, opts = {}) {
      const senal = opts.signal || null;
      if (senal?.aborted) throw errorParado();
      // 128 y no 512, y la razón NO es la memoria: es que el dispositivo tiene que poder
      // ATENDER AL ESCRITORIO entre despacho y despacho. El bucle del SSM recorre
      // todos los tokens del lote DENTRO de un solo despacho, sin ceder; con 512
      // ese núcleo corre largo, y el sistema puede matar la sesión gráfica cuando
      // el compositor no consigue pintar dentro del plazo de su vigilante.
      //
      // Trocear más fino además REDUCE trabajo: la máscara causal se aplica en el
      // softmax, o sea que cada lote calcula su matriz entera; a lotes más cortos,
      // menos posiciones enmascaradas se calculan para tirarlas.
      const LOTE = loteActual;
      // Con `tap` NO se trocea: la referencia contra la que se compara sale de
      // UNA pasada, y comparar 64 escalones contra tres pasadas concatenadas no
      // significa nada. Con `todosLosLogits`
      // tampoco, porque troceando solo sobreviven los del último lote.
      // `onProgress(hechos, total)` se llama DESPUÉS de cada lote, que es justo
      // después de esperar a que el dispositivo lo termine. Así lo que se reporta es
      // trabajo HECHO y no encolado: una barra que avanza por encolado llega al
      // 100 % y se queda ahí mientras el dispositivo sigue, que es peor que no tenerla.
      const avisa = typeof opts.onProgress === 'function' ? opts.onProgress : null;
      // Un reloj nuevo por forward troceado (ver `relojRespiro`): nunca se
      // hereda el de otro forward.
      relojRespiro = globalThis.__ELFFUSS_PLAN === true && !opts.tap && !opts.todosLosLogits &&
        tokenIds.length > LOTE ? nuevoRelojRespiro() : null;
      respiroSinVaciar = globalThis.__ELFFUSS_PLAN === true && !opts.tap && !opts.todosLosLogits;
      if (opts.tap || opts.todosLosLogits || tokenIds.length <= LOTE) {
        const r = await unaPasada(tokenIds, opts);
        avisa?.(tokenIds.length, tokenIds.length);
        return r;
      }
      let ultimo = null;
      for (let i = 0; i < tokenIds.length; i += LOTE) {
        ultimo = await unaPasada(tokenIds.slice(i, i + LOTE), opts);
        // ESPERAR a que el lote termine en el dispositivo antes de encolar el siguiente.
        // Los buffers uniform se reciclan ENTRE lotes (ops.js lo dice: «se
        // reciclan entre lotes, no dentro»), y eso solo es seguro si hay una
        // sincronización en medio. El bucle de decode la tiene sin buscarla,
        // porque lee los logits en cada paso; aquí no había ninguna, así que el
        // lote siguiente reutilizaba uniformes que el anterior todavía no había
        // consumido. El resultado no era un error: era OTRO token (197 en vez
        // de 62), que es la peor forma de fallar porque sale texto plausible.
        await device.queue.onSubmittedWorkDone();
        // El aviso va JUSTO DESPUÉS de esa espera y ANTES de mirar la señal: el
        // lote ya está hecho y nPast lo incluye, así que se cuenta aunque el
        // prefill se pare aquí mismo. Callarlo dejaría el progreso un lote por
        // detrás de lo que de verdad entró. Quien no quiera avisos después de
        // un «para» los filtra él: el proveedor deja de pasarlos a `onPrefill`
        // en cuanto nota la señal.
        avisa?.(Math.min(i + LOTE, tokenIds.length), tokenIds.length);
        // Y ahora la señal, con el dispositivo parado y nPast al final del último lote
        // completo. Tras el último lote no se mira: el trabajo ya está hecho y
        // tirarlo no ahorra nada, así que el forward termina y el «para» lo
        // nota quien llama en su siguiente comprobación.
        if (senal?.aborted && i + LOTE < tokenIds.length) throw errorParado();
      }
      // `tokens` se corrige al total: quien lo lea espera cuántos entraron, no
      // cuántos traía el último lote.
      return { ...ultimo, tokens: tokenIds.length };
    },


    recycle: () => ctx.recycle(),
    destroy: () => state.destroy(),
  };
}