@rootintf/protocol-subverseinfo 2.1.1-api.5 → 2.1.3-api.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/subverseinfo.cjs.js +618 -181
  2. package/dist/subverseinfo.es.mjs +618 -181
  3. package/package.json +1 -1
  4. package/schema/schema_SubverseInfo.json +33 -4
  5. package/src/subverseinfo.ts +1 -1
  6. package/src/validate-esm.mjs +1 -1
  7. package/tests/subverseinfo.spec.mjs +45 -12
package/dist/subverseinfo.es.mjs CHANGED
@@ -85,8 +85,8 @@ function validate19(data, { instancePath = "", parentData, parentDataProperty, r
85
85
  if (valid0) {
86
86
  if (data.subverse_info !== undefined) {
87
87
  const _errs9 = errors;
88
- if ("5" !== data.subverse_info) {
89
- validate19.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "5" }, message: "must be equal to constant" }];
88
+ if ("6" !== data.subverse_info) {
89
+ validate19.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "6" }, message: "must be equal to constant" }];
90
90
  return false;
91
91
  }
92
92
  var valid0 = _errs9 === errors;
@@ -263,20 +263,6 @@ function validate21(data, { instancePath = "", parentData, parentDataProperty, r
263
263
  else {
264
264
  var valid3 = true;
265
265
  }
266
- if (valid3) {
267
- if (data.info !== undefined) {
268
- let data5 = data.info;
269
- const _errs19 = errors;
270
- if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
271
- validate21.errors = [{ instancePath: instancePath + "/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
272
- return false;
273
- }
274
- var valid3 = _errs19 === errors;
275
- }
276
- else {
277
- var valid3 = true;
278
- }
279
- }
280
266
  }
281
267
  }
282
268
  else {
@@ -284,7 +270,7 @@ function validate21(data, { instancePath = "", parentData, parentDataProperty, r
284
270
  return false;
285
271
  }
286
272
  } validate21.errors = vErrors; return errors === 0; }
287
- validate21.evaluated = { "props": { "favicon": true, "hyperport": true, "info": true, "uri": true, "name": true }, "dynamicProps": false, "dynamicItems": false };
273
+ validate21.evaluated = { "props": { "favicon": true, "hyperport": true, "uri": true, "name": true }, "dynamicProps": false, "dynamicItems": false };
288
274
  function validate24(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate24.evaluated; if (evaluated0.dynamicProps) {
289
275
  evaluated0.props = undefined;
290
276
  } if (evaluated0.dynamicItems) {
@@ -444,20 +430,6 @@ function validate24(data, { instancePath = "", parentData, parentDataProperty, r
444
430
  else {
445
431
  var valid3 = true;
446
432
  }
447
- if (valid3) {
448
- if (data.info !== undefined) {
449
- let data5 = data.info;
450
- const _errs19 = errors;
451
- if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
452
- validate24.errors = [{ instancePath: instancePath + "/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
453
- return false;
454
- }
455
- var valid3 = _errs19 === errors;
456
- }
457
- else {
458
- var valid3 = true;
459
- }
460
- }
461
433
  }
462
434
  }
463
435
  else {
@@ -465,7 +437,7 @@ function validate24(data, { instancePath = "", parentData, parentDataProperty, r
465
437
  return false;
466
438
  }
467
439
  } validate24.errors = vErrors; return errors === 0; }
468
- validate24.evaluated = { "props": { "favicon": true, "hyperport": true, "info": true, "uri": true, "name": true }, "dynamicProps": false, "dynamicItems": false };
440
+ validate24.evaluated = { "props": { "favicon": true, "hyperport": true, "uri": true, "name": true }, "dynamicProps": false, "dynamicItems": false };
469
441
  function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate23.evaluated; if (evaluated0.dynamicProps) {
470
442
  evaluated0.props = undefined;
471
443
  } if (evaluated0.dynamicItems) {
@@ -483,10 +455,165 @@ function validate23(data, { instancePath = "", parentData, parentDataProperty, r
483
455
  }
484
456
  if (errors === _errs1) {
485
457
  if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
486
- for (const key0 in data0) {
487
- if (((((key0 !== "favicon") && (key0 !== "hyperport")) && (key0 !== "info")) && (key0 !== "uri")) && (key0 !== "name")) {
488
- validate23.errors = [{ instancePath: instancePath + "/" + i0, schemaPath: "#/items/unevaluatedProperties", keyword: "unevaluatedProperties", params: { unevaluatedProperty: key0 }, message: "must NOT have unevaluated properties" }];
489
- return false;
458
+ if (data0.info !== undefined) {
459
+ let data1 = data0.info;
460
+ const _errs4 = errors;
461
+ const _errs5 = errors;
462
+ if (errors === _errs5) {
463
+ if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
464
+ if (data1["age-restrictions"] !== undefined) {
465
+ let data2 = data1["age-restrictions"];
466
+ const _errs7 = errors;
467
+ if (errors === _errs7) {
468
+ if (!(data2 && typeof data2 == "object" && !Array.isArray(data2))) {
469
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/age-restrictions", schemaPath: "definitions#/definitions/info/properties/age-restrictions/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
470
+ return false;
471
+ }
472
+ }
473
+ var valid4 = _errs7 === errors;
474
+ }
475
+ else {
476
+ var valid4 = true;
477
+ }
478
+ if (valid4) {
479
+ if (data1["users-count"] !== undefined) {
480
+ let data3 = data1["users-count"];
481
+ const _errs9 = errors;
482
+ if (errors === _errs9) {
483
+ if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
484
+ if (data3.active !== undefined) {
485
+ let data4 = data3.active;
486
+ const _errs11 = errors;
487
+ if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
488
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/active", schemaPath: "definitions#/definitions/info/properties/users-count/properties/active/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
489
+ return false;
490
+ }
491
+ var valid5 = _errs11 === errors;
492
+ }
493
+ else {
494
+ var valid5 = true;
495
+ }
496
+ if (valid5) {
497
+ if (data3.DAU !== undefined) {
498
+ let data5 = data3.DAU;
499
+ const _errs13 = errors;
500
+ if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
501
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/DAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/DAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
502
+ return false;
503
+ }
504
+ var valid5 = _errs13 === errors;
505
+ }
506
+ else {
507
+ var valid5 = true;
508
+ }
509
+ if (valid5) {
510
+ if (data3.MAU !== undefined) {
511
+ let data6 = data3.MAU;
512
+ const _errs15 = errors;
513
+ if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
514
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/MAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/MAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
515
+ return false;
516
+ }
517
+ var valid5 = _errs15 === errors;
518
+ }
519
+ else {
520
+ var valid5 = true;
521
+ }
522
+ if (valid5) {
523
+ if (data3["concurrent-max"] !== undefined) {
524
+ let data7 = data3["concurrent-max"];
525
+ const _errs17 = errors;
526
+ if (!(((typeof data7 == "number") && (!(data7 % 1) && !isNaN(data7))) && (isFinite(data7)))) {
527
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/concurrent-max", schemaPath: "definitions#/definitions/info/properties/users-count/properties/concurrent-max/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
528
+ return false;
529
+ }
530
+ var valid5 = _errs17 === errors;
531
+ }
532
+ else {
533
+ var valid5 = true;
534
+ }
535
+ }
536
+ }
537
+ }
538
+ }
539
+ else {
540
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count", schemaPath: "definitions#/definitions/info/properties/users-count/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
541
+ return false;
542
+ }
543
+ }
544
+ var valid4 = _errs9 === errors;
545
+ }
546
+ else {
547
+ var valid4 = true;
548
+ }
549
+ if (valid4) {
550
+ if (data1.attributes !== undefined) {
551
+ let data8 = data1.attributes;
552
+ const _errs19 = errors;
553
+ if (errors === _errs19) {
554
+ if (Array.isArray(data8)) {
555
+ var valid6 = true;
556
+ const len1 = data8.length;
557
+ for (let i1 = 0; i1 < len1; i1++) {
558
+ const _errs21 = errors;
559
+ if (typeof data8[i1] !== "string") {
560
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes/" + i1, schemaPath: "definitions#/definitions/info/properties/attributes/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
561
+ return false;
562
+ }
563
+ var valid6 = _errs21 === errors;
564
+ if (!valid6) {
565
+ break;
566
+ }
567
+ }
568
+ if (valid6) {
569
+ let i2 = data8.length;
570
+ let j0;
571
+ if (i2 > 1) {
572
+ const indices0 = {};
573
+ for (; i2--;) {
574
+ let item0 = data8[i2];
575
+ if (typeof item0 !== "string") {
576
+ continue;
577
+ }
578
+ if (typeof indices0[item0] == "number") {
579
+ j0 = indices0[item0];
580
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/uniqueItems", keyword: "uniqueItems", params: { i: i2, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i2 + " are identical)" }];
581
+ return false;
582
+ }
583
+ indices0[item0] = i2;
584
+ }
585
+ }
586
+ }
587
+ }
588
+ else {
589
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
590
+ return false;
591
+ }
592
+ }
593
+ var valid4 = _errs19 === errors;
594
+ }
595
+ else {
596
+ var valid4 = true;
597
+ }
598
+ }
599
+ }
600
+ }
601
+ else {
602
+ validate23.errors = [{ instancePath: instancePath + "/" + i0 + "/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
603
+ return false;
604
+ }
605
+ }
606
+ var valid2 = _errs4 === errors;
607
+ }
608
+ else {
609
+ var valid2 = true;
610
+ }
611
+ if (valid2) {
612
+ for (const key0 in data0) {
613
+ if (((((key0 !== "info") && (key0 !== "favicon")) && (key0 !== "hyperport")) && (key0 !== "uri")) && (key0 !== "name")) {
614
+ validate23.errors = [{ instancePath: instancePath + "/" + i0, schemaPath: "#/items/unevaluatedProperties", keyword: "unevaluatedProperties", params: { unevaluatedProperty: key0 }, message: "must NOT have unevaluated properties" }];
615
+ return false;
616
+ }
490
617
  }
491
618
  }
492
619
  }
@@ -594,7 +721,7 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
594
721
  }
595
722
  if (valid4) {
596
723
  for (const key0 in data1) {
597
- if (((((((key0 !== "map-uri") && (key0 !== "instances")) && (key0 !== "favicon")) && (key0 !== "hyperport")) && (key0 !== "info")) && (key0 !== "uri")) && (key0 !== "name")) {
724
+ if ((((((key0 !== "map-uri") && (key0 !== "instances")) && (key0 !== "favicon")) && (key0 !== "hyperport")) && (key0 !== "uri")) && (key0 !== "name")) {
598
725
  validate20.errors = [{ instancePath: instancePath + "/expanse/subverse", schemaPath: "#/properties/expanse/properties/subverse/unevaluatedProperties", keyword: "unevaluatedProperties", params: { unevaluatedProperty: key0 }, message: "must NOT have unevaluated properties" }];
599
726
  return false;
600
727
  }
@@ -613,113 +740,151 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
613
740
  var valid2 = true;
614
741
  }
615
742
  if (valid2) {
616
- if (data0.platforms !== undefined) {
617
- let data4 = data0.platforms;
743
+ if (data0.info !== undefined) {
744
+ let data4 = data0.info;
618
745
  const _errs12 = errors;
619
746
  const _errs13 = errors;
620
747
  if (errors === _errs13) {
621
- if (Array.isArray(data4)) {
622
- var valid6 = true;
623
- const len0 = data4.length;
624
- for (let i0 = 0; i0 < len0; i0++) {
625
- let data5 = data4[i0];
748
+ if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
749
+ if (data4["age-restrictions"] !== undefined) {
750
+ let data5 = data4["age-restrictions"];
626
751
  const _errs15 = errors;
627
752
  if (errors === _errs15) {
628
- if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
629
- let missing3;
630
- if ((data5.id === undefined) && (missing3 = "id")) {
631
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0, schemaPath: "definitions#/definitions/platforms/items/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" }];
632
- return false;
633
- }
634
- else {
635
- if (data5.id !== undefined) {
636
- const _errs17 = errors;
637
- if (typeof data5.id !== "string") {
638
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0 + "/id", schemaPath: "definitions#/definitions/platforms/items/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
753
+ if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
754
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/age-restrictions", schemaPath: "definitions#/definitions/info/properties/age-restrictions/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
755
+ return false;
756
+ }
757
+ }
758
+ var valid6 = _errs15 === errors;
759
+ }
760
+ else {
761
+ var valid6 = true;
762
+ }
763
+ if (valid6) {
764
+ if (data4["users-count"] !== undefined) {
765
+ let data6 = data4["users-count"];
766
+ const _errs17 = errors;
767
+ if (errors === _errs17) {
768
+ if (data6 && typeof data6 == "object" && !Array.isArray(data6)) {
769
+ if (data6.active !== undefined) {
770
+ let data7 = data6.active;
771
+ const _errs19 = errors;
772
+ if (!(((typeof data7 == "number") && (!(data7 % 1) && !isNaN(data7))) && (isFinite(data7)))) {
773
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/users-count/active", schemaPath: "definitions#/definitions/info/properties/users-count/properties/active/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
639
774
  return false;
640
775
  }
641
- var valid7 = _errs17 === errors;
776
+ var valid7 = _errs19 === errors;
642
777
  }
643
778
  else {
644
779
  var valid7 = true;
645
780
  }
646
781
  if (valid7) {
647
- if (data5.archs !== undefined) {
648
- let data7 = data5.archs;
649
- const _errs19 = errors;
650
- if (errors === _errs19) {
651
- if (Array.isArray(data7)) {
652
- var valid8 = true;
653
- const len1 = data7.length;
654
- for (let i1 = 0; i1 < len1; i1++) {
655
- const _errs21 = errors;
656
- if (typeof data7[i1] !== "string") {
657
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0 + "/archs/" + i1, schemaPath: "definitions#/definitions/platforms/items/properties/archs/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
658
- return false;
659
- }
660
- var valid8 = _errs21 === errors;
661
- if (!valid8) {
662
- break;
663
- }
664
- }
665
- }
666
- else {
667
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0 + "/archs", schemaPath: "definitions#/definitions/platforms/items/properties/archs/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
668
- return false;
669
- }
782
+ if (data6.DAU !== undefined) {
783
+ let data8 = data6.DAU;
784
+ const _errs21 = errors;
785
+ if (!(((typeof data8 == "number") && (!(data8 % 1) && !isNaN(data8))) && (isFinite(data8)))) {
786
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/users-count/DAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/DAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
787
+ return false;
670
788
  }
671
- var valid7 = _errs19 === errors;
789
+ var valid7 = _errs21 === errors;
672
790
  }
673
791
  else {
674
792
  var valid7 = true;
675
793
  }
676
794
  if (valid7) {
677
- if (data5.agents !== undefined) {
678
- let data9 = data5.agents;
795
+ if (data6.MAU !== undefined) {
796
+ let data9 = data6.MAU;
679
797
  const _errs23 = errors;
680
- if (errors === _errs23) {
681
- if (Array.isArray(data9)) {
682
- var valid9 = true;
683
- const len2 = data9.length;
684
- for (let i2 = 0; i2 < len2; i2++) {
685
- const _errs25 = errors;
686
- if (typeof data9[i2] !== "string") {
687
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0 + "/agents/" + i2, schemaPath: "definitions#/definitions/platforms/items/properties/agents/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
688
- return false;
689
- }
690
- var valid9 = _errs25 === errors;
691
- if (!valid9) {
692
- break;
693
- }
694
- }
695
- }
696
- else {
697
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0 + "/agents", schemaPath: "definitions#/definitions/platforms/items/properties/agents/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
698
- return false;
699
- }
798
+ if (!(((typeof data9 == "number") && (!(data9 % 1) && !isNaN(data9))) && (isFinite(data9)))) {
799
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/users-count/MAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/MAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
800
+ return false;
700
801
  }
701
802
  var valid7 = _errs23 === errors;
702
803
  }
703
804
  else {
704
805
  var valid7 = true;
705
806
  }
807
+ if (valid7) {
808
+ if (data6["concurrent-max"] !== undefined) {
809
+ let data10 = data6["concurrent-max"];
810
+ const _errs25 = errors;
811
+ if (!(((typeof data10 == "number") && (!(data10 % 1) && !isNaN(data10))) && (isFinite(data10)))) {
812
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/users-count/concurrent-max", schemaPath: "definitions#/definitions/info/properties/users-count/properties/concurrent-max/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
813
+ return false;
814
+ }
815
+ var valid7 = _errs25 === errors;
816
+ }
817
+ else {
818
+ var valid7 = true;
819
+ }
820
+ }
821
+ }
822
+ }
823
+ }
824
+ else {
825
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/users-count", schemaPath: "definitions#/definitions/info/properties/users-count/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
826
+ return false;
827
+ }
828
+ }
829
+ var valid6 = _errs17 === errors;
830
+ }
831
+ else {
832
+ var valid6 = true;
833
+ }
834
+ if (valid6) {
835
+ if (data4.attributes !== undefined) {
836
+ let data11 = data4.attributes;
837
+ const _errs27 = errors;
838
+ if (errors === _errs27) {
839
+ if (Array.isArray(data11)) {
840
+ var valid8 = true;
841
+ const len0 = data11.length;
842
+ for (let i0 = 0; i0 < len0; i0++) {
843
+ const _errs29 = errors;
844
+ if (typeof data11[i0] !== "string") {
845
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/attributes/" + i0, schemaPath: "definitions#/definitions/info/properties/attributes/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
846
+ return false;
847
+ }
848
+ var valid8 = _errs29 === errors;
849
+ if (!valid8) {
850
+ break;
851
+ }
852
+ }
853
+ if (valid8) {
854
+ let i1 = data11.length;
855
+ let j0;
856
+ if (i1 > 1) {
857
+ const indices0 = {};
858
+ for (; i1--;) {
859
+ let item0 = data11[i1];
860
+ if (typeof item0 !== "string") {
861
+ continue;
862
+ }
863
+ if (typeof indices0[item0] == "number") {
864
+ j0 = indices0[item0];
865
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/uniqueItems", keyword: "uniqueItems", params: { i: i1, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i1 + " are identical)" }];
866
+ return false;
867
+ }
868
+ indices0[item0] = i1;
869
+ }
870
+ }
706
871
  }
707
872
  }
873
+ else {
874
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
875
+ return false;
876
+ }
708
877
  }
878
+ var valid6 = _errs27 === errors;
709
879
  }
710
880
  else {
711
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i0, schemaPath: "definitions#/definitions/platforms/items/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
712
- return false;
881
+ var valid6 = true;
713
882
  }
714
883
  }
715
- var valid6 = _errs15 === errors;
716
- if (!valid6) {
717
- break;
718
- }
719
884
  }
720
885
  }
721
886
  else {
722
- validate20.errors = [{ instancePath: instancePath + "/expanse/platforms", schemaPath: "definitions#/definitions/platforms/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
887
+ validate20.errors = [{ instancePath: instancePath + "/expanse/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
723
888
  return false;
724
889
  }
725
890
  }
@@ -729,111 +894,228 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
729
894
  var valid2 = true;
730
895
  }
731
896
  if (valid2) {
732
- if (data0.protocols !== undefined) {
733
- let data11 = data0.protocols;
734
- const _errs27 = errors;
735
- const _errs28 = errors;
736
- if (errors === _errs28) {
737
- if (Array.isArray(data11)) {
897
+ if (data0.platforms !== undefined) {
898
+ let data13 = data0.platforms;
899
+ const _errs31 = errors;
900
+ const _errs32 = errors;
901
+ if (errors === _errs32) {
902
+ if (Array.isArray(data13)) {
738
903
  var valid11 = true;
739
- const len3 = data11.length;
740
- for (let i3 = 0; i3 < len3; i3++) {
741
- let data12 = data11[i3];
742
- const _errs30 = errors;
743
- if (errors === _errs30) {
744
- if (data12 && typeof data12 == "object" && !Array.isArray(data12)) {
745
- let missing4;
746
- if (((data12.id === undefined) && (missing4 = "id")) || ((data12.attr === undefined) && (missing4 = "attr"))) {
747
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3, schemaPath: "definitions#/definitions/protocols/items/required", keyword: "required", params: { missingProperty: missing4 }, message: "must have required property '" + missing4 + "'" }];
904
+ const len1 = data13.length;
905
+ for (let i2 = 0; i2 < len1; i2++) {
906
+ let data14 = data13[i2];
907
+ const _errs34 = errors;
908
+ if (errors === _errs34) {
909
+ if (data14 && typeof data14 == "object" && !Array.isArray(data14)) {
910
+ let missing3;
911
+ if ((data14.id === undefined) && (missing3 = "id")) {
912
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2, schemaPath: "definitions#/definitions/platforms/items/required", keyword: "required", params: { missingProperty: missing3 }, message: "must have required property '" + missing3 + "'" }];
748
913
  return false;
749
914
  }
750
915
  else {
751
- if (data12.id !== undefined) {
752
- const _errs32 = errors;
753
- if (typeof data12.id !== "string") {
754
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3 + "/id", schemaPath: "definitions#/definitions/protocols/items/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
916
+ if (data14.id !== undefined) {
917
+ const _errs36 = errors;
918
+ if (typeof data14.id !== "string") {
919
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2 + "/id", schemaPath: "definitions#/definitions/platforms/items/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
755
920
  return false;
756
921
  }
757
- var valid12 = _errs32 === errors;
922
+ var valid12 = _errs36 === errors;
758
923
  }
759
924
  else {
760
925
  var valid12 = true;
761
926
  }
762
927
  if (valid12) {
763
- if (data12.name !== undefined) {
764
- const _errs34 = errors;
765
- if (typeof data12.name !== "string") {
766
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3 + "/name", schemaPath: "definitions#/definitions/protocols/items/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
767
- return false;
928
+ if (data14.archs !== undefined) {
929
+ let data16 = data14.archs;
930
+ const _errs38 = errors;
931
+ if (errors === _errs38) {
932
+ if (Array.isArray(data16)) {
933
+ var valid13 = true;
934
+ const len2 = data16.length;
935
+ for (let i3 = 0; i3 < len2; i3++) {
936
+ const _errs40 = errors;
937
+ if (typeof data16[i3] !== "string") {
938
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2 + "/archs/" + i3, schemaPath: "definitions#/definitions/platforms/items/properties/archs/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
939
+ return false;
940
+ }
941
+ var valid13 = _errs40 === errors;
942
+ if (!valid13) {
943
+ break;
944
+ }
945
+ }
946
+ }
947
+ else {
948
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2 + "/archs", schemaPath: "definitions#/definitions/platforms/items/properties/archs/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
949
+ return false;
950
+ }
768
951
  }
769
- var valid12 = _errs34 === errors;
952
+ var valid12 = _errs38 === errors;
770
953
  }
771
954
  else {
772
955
  var valid12 = true;
773
956
  }
774
957
  if (valid12) {
775
- if (data12.version !== undefined) {
776
- const _errs36 = errors;
777
- if (typeof data12.version !== "string") {
778
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3 + "/version", schemaPath: "definitions#/definitions/protocols/items/properties/version/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
779
- return false;
780
- }
781
- var valid12 = _errs36 === errors;
782
- }
783
- else {
784
- var valid12 = true;
785
- }
786
- if (valid12) {
787
- if (data12.attr !== undefined) {
788
- const _errs38 = errors;
789
- if (typeof data12.attr !== "string") {
790
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3 + "/attr", schemaPath: "definitions#/definitions/protocols/items/properties/attr/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
791
- return false;
792
- }
793
- var valid12 = _errs38 === errors;
794
- }
795
- else {
796
- var valid12 = true;
797
- }
798
- if (valid12) {
799
- if (data12.url !== undefined) {
800
- const _errs40 = errors;
801
- if (typeof data12.url !== "string") {
802
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3 + "/url", schemaPath: "definitions#/definitions/protocols/items/properties/url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
803
- return false;
958
+ if (data14.agents !== undefined) {
959
+ let data18 = data14.agents;
960
+ const _errs42 = errors;
961
+ if (errors === _errs42) {
962
+ if (Array.isArray(data18)) {
963
+ var valid14 = true;
964
+ const len3 = data18.length;
965
+ for (let i4 = 0; i4 < len3; i4++) {
966
+ const _errs44 = errors;
967
+ if (typeof data18[i4] !== "string") {
968
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2 + "/agents/" + i4, schemaPath: "definitions#/definitions/platforms/items/properties/agents/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
969
+ return false;
970
+ }
971
+ var valid14 = _errs44 === errors;
972
+ if (!valid14) {
973
+ break;
974
+ }
804
975
  }
805
- var valid12 = _errs40 === errors;
806
976
  }
807
977
  else {
808
- var valid12 = true;
978
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2 + "/agents", schemaPath: "definitions#/definitions/platforms/items/properties/agents/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
979
+ return false;
809
980
  }
810
981
  }
982
+ var valid12 = _errs42 === errors;
983
+ }
984
+ else {
985
+ var valid12 = true;
811
986
  }
812
987
  }
813
988
  }
814
989
  }
815
990
  }
816
991
  else {
817
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i3, schemaPath: "definitions#/definitions/protocols/items/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
992
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms/" + i2, schemaPath: "definitions#/definitions/platforms/items/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
818
993
  return false;
819
994
  }
820
995
  }
821
- var valid11 = _errs30 === errors;
996
+ var valid11 = _errs34 === errors;
822
997
  if (!valid11) {
823
998
  break;
824
999
  }
825
1000
  }
826
1001
  }
827
1002
  else {
828
- validate20.errors = [{ instancePath: instancePath + "/expanse/protocols", schemaPath: "definitions#/definitions/protocols/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
1003
+ validate20.errors = [{ instancePath: instancePath + "/expanse/platforms", schemaPath: "definitions#/definitions/platforms/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
829
1004
  return false;
830
1005
  }
831
1006
  }
832
- var valid2 = _errs27 === errors;
1007
+ var valid2 = _errs31 === errors;
833
1008
  }
834
1009
  else {
835
1010
  var valid2 = true;
836
1011
  }
1012
+ if (valid2) {
1013
+ if (data0.protocols !== undefined) {
1014
+ let data20 = data0.protocols;
1015
+ const _errs46 = errors;
1016
+ const _errs47 = errors;
1017
+ if (errors === _errs47) {
1018
+ if (Array.isArray(data20)) {
1019
+ var valid16 = true;
1020
+ const len4 = data20.length;
1021
+ for (let i5 = 0; i5 < len4; i5++) {
1022
+ let data21 = data20[i5];
1023
+ const _errs49 = errors;
1024
+ if (errors === _errs49) {
1025
+ if (data21 && typeof data21 == "object" && !Array.isArray(data21)) {
1026
+ let missing4;
1027
+ if (((data21.id === undefined) && (missing4 = "id")) || ((data21.attr === undefined) && (missing4 = "attr"))) {
1028
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5, schemaPath: "definitions#/definitions/protocols/items/required", keyword: "required", params: { missingProperty: missing4 }, message: "must have required property '" + missing4 + "'" }];
1029
+ return false;
1030
+ }
1031
+ else {
1032
+ if (data21.id !== undefined) {
1033
+ const _errs51 = errors;
1034
+ if (typeof data21.id !== "string") {
1035
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5 + "/id", schemaPath: "definitions#/definitions/protocols/items/properties/id/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1036
+ return false;
1037
+ }
1038
+ var valid17 = _errs51 === errors;
1039
+ }
1040
+ else {
1041
+ var valid17 = true;
1042
+ }
1043
+ if (valid17) {
1044
+ if (data21.name !== undefined) {
1045
+ const _errs53 = errors;
1046
+ if (typeof data21.name !== "string") {
1047
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5 + "/name", schemaPath: "definitions#/definitions/protocols/items/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1048
+ return false;
1049
+ }
1050
+ var valid17 = _errs53 === errors;
1051
+ }
1052
+ else {
1053
+ var valid17 = true;
1054
+ }
1055
+ if (valid17) {
1056
+ if (data21.version !== undefined) {
1057
+ const _errs55 = errors;
1058
+ if (typeof data21.version !== "string") {
1059
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5 + "/version", schemaPath: "definitions#/definitions/protocols/items/properties/version/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1060
+ return false;
1061
+ }
1062
+ var valid17 = _errs55 === errors;
1063
+ }
1064
+ else {
1065
+ var valid17 = true;
1066
+ }
1067
+ if (valid17) {
1068
+ if (data21.attr !== undefined) {
1069
+ const _errs57 = errors;
1070
+ if (typeof data21.attr !== "string") {
1071
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5 + "/attr", schemaPath: "definitions#/definitions/protocols/items/properties/attr/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1072
+ return false;
1073
+ }
1074
+ var valid17 = _errs57 === errors;
1075
+ }
1076
+ else {
1077
+ var valid17 = true;
1078
+ }
1079
+ if (valid17) {
1080
+ if (data21.url !== undefined) {
1081
+ const _errs59 = errors;
1082
+ if (typeof data21.url !== "string") {
1083
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5 + "/url", schemaPath: "definitions#/definitions/protocols/items/properties/url/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1084
+ return false;
1085
+ }
1086
+ var valid17 = _errs59 === errors;
1087
+ }
1088
+ else {
1089
+ var valid17 = true;
1090
+ }
1091
+ }
1092
+ }
1093
+ }
1094
+ }
1095
+ }
1096
+ }
1097
+ else {
1098
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols/" + i5, schemaPath: "definitions#/definitions/protocols/items/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
1099
+ return false;
1100
+ }
1101
+ }
1102
+ var valid16 = _errs49 === errors;
1103
+ if (!valid16) {
1104
+ break;
1105
+ }
1106
+ }
1107
+ }
1108
+ else {
1109
+ validate20.errors = [{ instancePath: instancePath + "/expanse/protocols", schemaPath: "definitions#/definitions/protocols/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
1110
+ return false;
1111
+ }
1112
+ }
1113
+ var valid2 = _errs46 === errors;
1114
+ }
1115
+ else {
1116
+ var valid2 = true;
1117
+ }
1118
+ }
837
1119
  }
838
1120
  }
839
1121
  }
@@ -850,12 +1132,12 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
850
1132
  }
851
1133
  if (valid0) {
852
1134
  if (data.subverse_info !== undefined) {
853
- const _errs42 = errors;
854
- if ("5" !== data.subverse_info) {
855
- validate20.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "5" }, message: "must be equal to constant" }];
1135
+ const _errs61 = errors;
1136
+ if ("6" !== data.subverse_info) {
1137
+ validate20.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "6" }, message: "must be equal to constant" }];
856
1138
  return false;
857
1139
  }
858
- var valid0 = _errs42 === errors;
1140
+ var valid0 = _errs61 === errors;
859
1141
  }
860
1142
  else {
861
1143
  var valid0 = true;
@@ -887,10 +1169,165 @@ function validate28(data, { instancePath = "", parentData, parentDataProperty, r
887
1169
  }
888
1170
  if (errors === _errs1) {
889
1171
  if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
890
- for (const key0 in data0) {
891
- if (((((key0 !== "favicon") && (key0 !== "hyperport")) && (key0 !== "info")) && (key0 !== "uri")) && (key0 !== "name")) {
892
- validate28.errors = [{ instancePath: instancePath + "/" + i0, schemaPath: "#/items/unevaluatedProperties", keyword: "unevaluatedProperties", params: { unevaluatedProperty: key0 }, message: "must NOT have unevaluated properties" }];
893
- return false;
1172
+ if (data0.info !== undefined) {
1173
+ let data1 = data0.info;
1174
+ const _errs4 = errors;
1175
+ const _errs5 = errors;
1176
+ if (errors === _errs5) {
1177
+ if (data1 && typeof data1 == "object" && !Array.isArray(data1)) {
1178
+ if (data1["age-restrictions"] !== undefined) {
1179
+ let data2 = data1["age-restrictions"];
1180
+ const _errs7 = errors;
1181
+ if (errors === _errs7) {
1182
+ if (!(data2 && typeof data2 == "object" && !Array.isArray(data2))) {
1183
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/age-restrictions", schemaPath: "definitions#/definitions/info/properties/age-restrictions/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
1184
+ return false;
1185
+ }
1186
+ }
1187
+ var valid4 = _errs7 === errors;
1188
+ }
1189
+ else {
1190
+ var valid4 = true;
1191
+ }
1192
+ if (valid4) {
1193
+ if (data1["users-count"] !== undefined) {
1194
+ let data3 = data1["users-count"];
1195
+ const _errs9 = errors;
1196
+ if (errors === _errs9) {
1197
+ if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
1198
+ if (data3.active !== undefined) {
1199
+ let data4 = data3.active;
1200
+ const _errs11 = errors;
1201
+ if (!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))) {
1202
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/active", schemaPath: "definitions#/definitions/info/properties/users-count/properties/active/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
1203
+ return false;
1204
+ }
1205
+ var valid5 = _errs11 === errors;
1206
+ }
1207
+ else {
1208
+ var valid5 = true;
1209
+ }
1210
+ if (valid5) {
1211
+ if (data3.DAU !== undefined) {
1212
+ let data5 = data3.DAU;
1213
+ const _errs13 = errors;
1214
+ if (!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))) {
1215
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/DAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/DAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
1216
+ return false;
1217
+ }
1218
+ var valid5 = _errs13 === errors;
1219
+ }
1220
+ else {
1221
+ var valid5 = true;
1222
+ }
1223
+ if (valid5) {
1224
+ if (data3.MAU !== undefined) {
1225
+ let data6 = data3.MAU;
1226
+ const _errs15 = errors;
1227
+ if (!(((typeof data6 == "number") && (!(data6 % 1) && !isNaN(data6))) && (isFinite(data6)))) {
1228
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/MAU", schemaPath: "definitions#/definitions/info/properties/users-count/properties/MAU/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
1229
+ return false;
1230
+ }
1231
+ var valid5 = _errs15 === errors;
1232
+ }
1233
+ else {
1234
+ var valid5 = true;
1235
+ }
1236
+ if (valid5) {
1237
+ if (data3["concurrent-max"] !== undefined) {
1238
+ let data7 = data3["concurrent-max"];
1239
+ const _errs17 = errors;
1240
+ if (!(((typeof data7 == "number") && (!(data7 % 1) && !isNaN(data7))) && (isFinite(data7)))) {
1241
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count/concurrent-max", schemaPath: "definitions#/definitions/info/properties/users-count/properties/concurrent-max/type", keyword: "type", params: { type: "integer" }, message: "must be integer" }];
1242
+ return false;
1243
+ }
1244
+ var valid5 = _errs17 === errors;
1245
+ }
1246
+ else {
1247
+ var valid5 = true;
1248
+ }
1249
+ }
1250
+ }
1251
+ }
1252
+ }
1253
+ else {
1254
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/users-count", schemaPath: "definitions#/definitions/info/properties/users-count/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
1255
+ return false;
1256
+ }
1257
+ }
1258
+ var valid4 = _errs9 === errors;
1259
+ }
1260
+ else {
1261
+ var valid4 = true;
1262
+ }
1263
+ if (valid4) {
1264
+ if (data1.attributes !== undefined) {
1265
+ let data8 = data1.attributes;
1266
+ const _errs19 = errors;
1267
+ if (errors === _errs19) {
1268
+ if (Array.isArray(data8)) {
1269
+ var valid6 = true;
1270
+ const len1 = data8.length;
1271
+ for (let i1 = 0; i1 < len1; i1++) {
1272
+ const _errs21 = errors;
1273
+ if (typeof data8[i1] !== "string") {
1274
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes/" + i1, schemaPath: "definitions#/definitions/info/properties/attributes/items/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
1275
+ return false;
1276
+ }
1277
+ var valid6 = _errs21 === errors;
1278
+ if (!valid6) {
1279
+ break;
1280
+ }
1281
+ }
1282
+ if (valid6) {
1283
+ let i2 = data8.length;
1284
+ let j0;
1285
+ if (i2 > 1) {
1286
+ const indices0 = {};
1287
+ for (; i2--;) {
1288
+ let item0 = data8[i2];
1289
+ if (typeof item0 !== "string") {
1290
+ continue;
1291
+ }
1292
+ if (typeof indices0[item0] == "number") {
1293
+ j0 = indices0[item0];
1294
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/uniqueItems", keyword: "uniqueItems", params: { i: i2, j: j0 }, message: "must NOT have duplicate items (items ## " + j0 + " and " + i2 + " are identical)" }];
1295
+ return false;
1296
+ }
1297
+ indices0[item0] = i2;
1298
+ }
1299
+ }
1300
+ }
1301
+ }
1302
+ else {
1303
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info/attributes", schemaPath: "definitions#/definitions/info/properties/attributes/type", keyword: "type", params: { type: "array" }, message: "must be array" }];
1304
+ return false;
1305
+ }
1306
+ }
1307
+ var valid4 = _errs19 === errors;
1308
+ }
1309
+ else {
1310
+ var valid4 = true;
1311
+ }
1312
+ }
1313
+ }
1314
+ }
1315
+ else {
1316
+ validate28.errors = [{ instancePath: instancePath + "/" + i0 + "/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
1317
+ return false;
1318
+ }
1319
+ }
1320
+ var valid2 = _errs4 === errors;
1321
+ }
1322
+ else {
1323
+ var valid2 = true;
1324
+ }
1325
+ if (valid2) {
1326
+ for (const key0 in data0) {
1327
+ if (((((key0 !== "info") && (key0 !== "favicon")) && (key0 !== "hyperport")) && (key0 !== "uri")) && (key0 !== "name")) {
1328
+ validate28.errors = [{ instancePath: instancePath + "/" + i0, schemaPath: "#/items/unevaluatedProperties", keyword: "unevaluatedProperties", params: { unevaluatedProperty: key0 }, message: "must NOT have unevaluated properties" }];
1329
+ return false;
1330
+ }
894
1331
  }
895
1332
  }
896
1333
  }
@@ -1248,8 +1685,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
1248
1685
  if (valid0) {
1249
1686
  if (data.subverse_info !== undefined) {
1250
1687
  const _errs44 = errors;
1251
- if ("5" !== data.subverse_info) {
1252
- validate27.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "5" }, message: "must be equal to constant" }];
1688
+ if ("6" !== data.subverse_info) {
1689
+ validate27.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "6" }, message: "must be equal to constant" }];
1253
1690
  return false;
1254
1691
  }
1255
1692
  var valid0 = _errs44 === errors;
@@ -1921,7 +2358,7 @@ function requireJsonMsg_cjs () {
1921
2358
 
1922
2359
  var jsonMsg_cjsExports = requireJsonMsg_cjs();
1923
2360
 
1924
- const kstr_VERSION = "5";
2361
+ const kstr_VERSION = "6";
1925
2362
  // TODO: use RFC3339 "timestamp"? https://ajv.js.org/json-type-definition.html
1926
2363
  //-------------------------------------------------------------------------------------------------
1927
2364
  LOGR.get_instance();