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