@xemahq/contracts 0.30.0 → 0.31.0
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.
- package/dist/.source-stamp.json +1 -1
- package/dist/biome/lib/biome-generated-index.d.ts +102 -0
- package/dist/biome/lib/biome-generated-index.d.ts.map +1 -1
- package/dist/biome-dependency/lib/biome-dependency-contract.d.ts +83 -0
- package/dist/biome-dependency/lib/biome-dependency-contract.d.ts.map +1 -1
- package/dist/biome-dependency/lib/biome-dependency-contract.js +79 -6
- package/dist/biome-dependency/lib/biome-dependency-contract.js.map +1 -1
- package/dist/biome-dependency/lib/peer-seam-table.d.ts +3 -1
- package/dist/biome-dependency/lib/peer-seam-table.d.ts.map +1 -1
- package/dist/biome-dependency/lib/peer-seam-table.js +19 -2
- package/dist/biome-dependency/lib/peer-seam-table.js.map +1 -1
- package/dist/distribution/lib/biome-closure.d.ts +40 -4
- package/dist/distribution/lib/biome-closure.d.ts.map +1 -1
- package/dist/distribution/lib/biome-closure.js +221 -42
- package/dist/distribution/lib/biome-closure.js.map +1 -1
- package/dist/distribution/lib/distribution-roots.d.ts +10 -3
- package/dist/distribution/lib/distribution-roots.d.ts.map +1 -1
- package/dist/distribution/lib/distribution-roots.js +15 -2
- package/dist/distribution/lib/distribution-roots.js.map +1 -1
- package/package.json +1 -1
package/dist/.source-stamp.json
CHANGED
|
@@ -369,6 +369,9 @@ export declare const GeneratedBiomeFactsSchema: z.ZodObject<{
|
|
|
369
369
|
sha256: z.ZodString;
|
|
370
370
|
}, z.core.$strict>;
|
|
371
371
|
peers: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
372
|
+
invokes: z.ZodOptional<z.ZodObject<{
|
|
373
|
+
clientFunctions: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
374
|
+
}, z.core.$strict>>;
|
|
372
375
|
relationship: z.ZodLiteral<import("../../biome-dependency").PeerRelationship.ServicePeer>;
|
|
373
376
|
consumer: z.ZodObject<{
|
|
374
377
|
componentKey: z.ZodOptional<z.ZodString>;
|
|
@@ -379,6 +382,9 @@ export declare const GeneratedBiomeFactsSchema: z.ZodObject<{
|
|
|
379
382
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
380
383
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
381
384
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
385
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
386
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
387
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
382
388
|
}, z.core.$strict>, z.ZodObject<{
|
|
383
389
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
384
390
|
}, z.core.$strict>], "kind">;
|
|
@@ -399,6 +405,9 @@ export declare const GeneratedBiomeFactsSchema: z.ZodObject<{
|
|
|
399
405
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
400
406
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
401
407
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
408
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
409
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
410
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
402
411
|
}, z.core.$strict>, z.ZodObject<{
|
|
403
412
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
404
413
|
}, z.core.$strict>], "kind">;
|
|
@@ -419,6 +428,9 @@ export declare const GeneratedBiomeFactsSchema: z.ZodObject<{
|
|
|
419
428
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
420
429
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
421
430
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
431
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
432
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
433
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
422
434
|
}, z.core.$strict>, z.ZodObject<{
|
|
423
435
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
424
436
|
}, z.core.$strict>], "kind">;
|
|
@@ -439,6 +451,9 @@ export declare const GeneratedBiomeFactsSchema: z.ZodObject<{
|
|
|
439
451
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
440
452
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
441
453
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
454
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
455
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
456
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
442
457
|
}, z.core.$strict>, z.ZodObject<{
|
|
443
458
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
444
459
|
}, z.core.$strict>], "kind">;
|
|
@@ -459,6 +474,9 @@ export declare const GeneratedBiomeFactsSchema: z.ZodObject<{
|
|
|
459
474
|
lifecycle: z.ZodLiteral<import("../../biome-dependency").PeerLifecycle.Runtime>;
|
|
460
475
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
461
476
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
477
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
478
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
479
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
462
480
|
}, z.core.$strict>, z.ZodObject<{
|
|
463
481
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
464
482
|
}, z.core.$strict>], "kind">;
|
|
@@ -493,6 +511,22 @@ export declare const GeneratedBiomeFactsSchema: z.ZodObject<{
|
|
|
493
511
|
seam: z.ZodString;
|
|
494
512
|
}, z.core.$strict>>>;
|
|
495
513
|
}, z.core.$strict>>>;
|
|
514
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
515
|
+
consumer: z.ZodObject<{
|
|
516
|
+
componentKey: z.ZodString;
|
|
517
|
+
}, z.core.$strict>;
|
|
518
|
+
serviceName: z.ZodString;
|
|
519
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
520
|
+
operationId: z.ZodString;
|
|
521
|
+
clientFunction: z.ZodString;
|
|
522
|
+
}, z.core.$strict>>>;
|
|
523
|
+
evidence: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
524
|
+
path: z.ZodString;
|
|
525
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
526
|
+
jsonPointer: z.ZodOptional<z.ZodString>;
|
|
527
|
+
seam: z.ZodString;
|
|
528
|
+
}, z.core.$strict>>>;
|
|
529
|
+
}, z.core.$strict>>>;
|
|
496
530
|
}, z.core.$strict>>;
|
|
497
531
|
}, z.core.$strict>;
|
|
498
532
|
export type GeneratedBiomeFacts = z.infer<typeof GeneratedBiomeFactsSchema>;
|
|
@@ -683,6 +717,9 @@ export declare const BiomeBundleGeneratedIndexSchema: z.ZodObject<{
|
|
|
683
717
|
sha256: z.ZodString;
|
|
684
718
|
}, z.core.$strict>;
|
|
685
719
|
peers: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
720
|
+
invokes: z.ZodOptional<z.ZodObject<{
|
|
721
|
+
clientFunctions: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
722
|
+
}, z.core.$strict>>;
|
|
686
723
|
relationship: z.ZodLiteral<import("../../biome-dependency").PeerRelationship.ServicePeer>;
|
|
687
724
|
consumer: z.ZodObject<{
|
|
688
725
|
componentKey: z.ZodOptional<z.ZodString>;
|
|
@@ -693,6 +730,9 @@ export declare const BiomeBundleGeneratedIndexSchema: z.ZodObject<{
|
|
|
693
730
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
694
731
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
695
732
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
733
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
734
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
735
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
696
736
|
}, z.core.$strict>, z.ZodObject<{
|
|
697
737
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
698
738
|
}, z.core.$strict>], "kind">;
|
|
@@ -713,6 +753,9 @@ export declare const BiomeBundleGeneratedIndexSchema: z.ZodObject<{
|
|
|
713
753
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
714
754
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
715
755
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
756
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
757
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
758
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
716
759
|
}, z.core.$strict>, z.ZodObject<{
|
|
717
760
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
718
761
|
}, z.core.$strict>], "kind">;
|
|
@@ -733,6 +776,9 @@ export declare const BiomeBundleGeneratedIndexSchema: z.ZodObject<{
|
|
|
733
776
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
734
777
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
735
778
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
779
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
780
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
781
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
736
782
|
}, z.core.$strict>, z.ZodObject<{
|
|
737
783
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
738
784
|
}, z.core.$strict>], "kind">;
|
|
@@ -753,6 +799,9 @@ export declare const BiomeBundleGeneratedIndexSchema: z.ZodObject<{
|
|
|
753
799
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
754
800
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
755
801
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
802
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
803
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
804
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
756
805
|
}, z.core.$strict>, z.ZodObject<{
|
|
757
806
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
758
807
|
}, z.core.$strict>], "kind">;
|
|
@@ -773,6 +822,9 @@ export declare const BiomeBundleGeneratedIndexSchema: z.ZodObject<{
|
|
|
773
822
|
lifecycle: z.ZodLiteral<import("../../biome-dependency").PeerLifecycle.Runtime>;
|
|
774
823
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
775
824
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
825
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
826
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
827
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
776
828
|
}, z.core.$strict>, z.ZodObject<{
|
|
777
829
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
778
830
|
}, z.core.$strict>], "kind">;
|
|
@@ -807,6 +859,22 @@ export declare const BiomeBundleGeneratedIndexSchema: z.ZodObject<{
|
|
|
807
859
|
seam: z.ZodString;
|
|
808
860
|
}, z.core.$strict>>>;
|
|
809
861
|
}, z.core.$strict>>>;
|
|
862
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
863
|
+
consumer: z.ZodObject<{
|
|
864
|
+
componentKey: z.ZodString;
|
|
865
|
+
}, z.core.$strict>;
|
|
866
|
+
serviceName: z.ZodString;
|
|
867
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
868
|
+
operationId: z.ZodString;
|
|
869
|
+
clientFunction: z.ZodString;
|
|
870
|
+
}, z.core.$strict>>>;
|
|
871
|
+
evidence: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
872
|
+
path: z.ZodString;
|
|
873
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
874
|
+
jsonPointer: z.ZodOptional<z.ZodString>;
|
|
875
|
+
seam: z.ZodString;
|
|
876
|
+
}, z.core.$strict>>>;
|
|
877
|
+
}, z.core.$strict>>>;
|
|
810
878
|
}, z.core.$strict>>;
|
|
811
879
|
}, z.core.$strict>;
|
|
812
880
|
}, z.core.$strict>;
|
|
@@ -984,6 +1052,9 @@ export declare const BiomeGeneratedIndexSchema: z.ZodObject<{
|
|
|
984
1052
|
sha256: z.ZodString;
|
|
985
1053
|
}, z.core.$strict>;
|
|
986
1054
|
peers: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1055
|
+
invokes: z.ZodOptional<z.ZodObject<{
|
|
1056
|
+
clientFunctions: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
1057
|
+
}, z.core.$strict>>;
|
|
987
1058
|
relationship: z.ZodLiteral<import("../../biome-dependency").PeerRelationship.ServicePeer>;
|
|
988
1059
|
consumer: z.ZodObject<{
|
|
989
1060
|
componentKey: z.ZodOptional<z.ZodString>;
|
|
@@ -994,6 +1065,9 @@ export declare const BiomeGeneratedIndexSchema: z.ZodObject<{
|
|
|
994
1065
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
995
1066
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
996
1067
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
1068
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1069
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
1070
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
997
1071
|
}, z.core.$strict>, z.ZodObject<{
|
|
998
1072
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
999
1073
|
}, z.core.$strict>], "kind">;
|
|
@@ -1014,6 +1088,9 @@ export declare const BiomeGeneratedIndexSchema: z.ZodObject<{
|
|
|
1014
1088
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
1015
1089
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1016
1090
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
1091
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1092
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
1093
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
1017
1094
|
}, z.core.$strict>, z.ZodObject<{
|
|
1018
1095
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
1019
1096
|
}, z.core.$strict>], "kind">;
|
|
@@ -1034,6 +1111,9 @@ export declare const BiomeGeneratedIndexSchema: z.ZodObject<{
|
|
|
1034
1111
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
1035
1112
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1036
1113
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
1114
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1115
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
1116
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
1037
1117
|
}, z.core.$strict>, z.ZodObject<{
|
|
1038
1118
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
1039
1119
|
}, z.core.$strict>], "kind">;
|
|
@@ -1054,6 +1134,9 @@ export declare const BiomeGeneratedIndexSchema: z.ZodObject<{
|
|
|
1054
1134
|
lifecycle: z.ZodEnum<typeof import("../../biome-dependency").PeerLifecycle>;
|
|
1055
1135
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1056
1136
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
1137
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1138
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
1139
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
1057
1140
|
}, z.core.$strict>, z.ZodObject<{
|
|
1058
1141
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
1059
1142
|
}, z.core.$strict>], "kind">;
|
|
@@ -1074,6 +1157,9 @@ export declare const BiomeGeneratedIndexSchema: z.ZodObject<{
|
|
|
1074
1157
|
lifecycle: z.ZodLiteral<import("../../biome-dependency").PeerLifecycle.Runtime>;
|
|
1075
1158
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1076
1159
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Required>;
|
|
1160
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1161
|
+
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Operation>;
|
|
1162
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
1077
1163
|
}, z.core.$strict>, z.ZodObject<{
|
|
1078
1164
|
kind: z.ZodLiteral<import("../../biome-dependency").PeerInclusionKind.Optional>;
|
|
1079
1165
|
}, z.core.$strict>], "kind">;
|
|
@@ -1108,6 +1194,22 @@ export declare const BiomeGeneratedIndexSchema: z.ZodObject<{
|
|
|
1108
1194
|
seam: z.ZodString;
|
|
1109
1195
|
}, z.core.$strict>>>;
|
|
1110
1196
|
}, z.core.$strict>>>;
|
|
1197
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1198
|
+
consumer: z.ZodObject<{
|
|
1199
|
+
componentKey: z.ZodString;
|
|
1200
|
+
}, z.core.$strict>;
|
|
1201
|
+
serviceName: z.ZodString;
|
|
1202
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1203
|
+
operationId: z.ZodString;
|
|
1204
|
+
clientFunction: z.ZodString;
|
|
1205
|
+
}, z.core.$strict>>>;
|
|
1206
|
+
evidence: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1207
|
+
path: z.ZodString;
|
|
1208
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
1209
|
+
jsonPointer: z.ZodOptional<z.ZodString>;
|
|
1210
|
+
seam: z.ZodString;
|
|
1211
|
+
}, z.core.$strict>>>;
|
|
1212
|
+
}, z.core.$strict>>>;
|
|
1111
1213
|
}, z.core.$strict>>;
|
|
1112
1214
|
}, z.core.$strict>>>;
|
|
1113
1215
|
}, z.core.$strict>;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"biome-generated-index.d.ts","sourceRoot":"","sources":["../../../src/biome/lib/biome-generated-index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,oCAAoC,EAAG,CAAU,CAAC;AAG/D,eAAO,MAAM,8BAA8B,EAAG,uBAAgC,CAAC;AAE/E,oBAAY,sBAAsB;IAChC,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,SAAS,cAAc;IACvB,OAAO,YAAY;IACnB,OAAO,aAAa;CACrB;AAED,eAAO,MAAM,4BAA4B,0CAExC,CAAC;AAEF,oBAAY,gCAAgC;IAC1C,QAAQ,aAAa;IACrB,QAAQ,aAAa;CACtB;AAED,eAAO,MAAM,sCAAsC,oDAElD,CAAC;AAEF,oBAAY,2BAA2B;IACrC,kBAAkB,wBAAwB;IAC1C,mBAAmB,0BAA0B;IAC7C,iBAAiB,uBAAuB;IACxC,gBAAgB,uBAAuB;IACvC,oBAAoB,0BAA0B;IAC9C,gBAAgB,sBAAsB;IACtC,kBAAkB,wBAAwB;IAC1C,gBAAgB,sBAAsB;IACtC,oBAAoB,0BAA0B;CAC/C;AAED,eAAO,MAAM,iCAAiC,+CAE7C,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;kBAOlC,CAAC;AACZ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAeF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAyDnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,oCAAoC;;;;;;;;;;kBAOtC,CAAC;AACZ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;kBAM/B,CAAC;AACZ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,oCAAoC;;;;;;;;;kBAMtC,CAAC;AACZ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;kBAatC,CAAC;AACZ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,eAAO,MAAM,yBAAyB
|
|
1
|
+
{"version":3,"file":"biome-generated-index.d.ts","sourceRoot":"","sources":["../../../src/biome/lib/biome-generated-index.ts"],"names":[],"mappings":"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"}
|
|
@@ -16,6 +16,7 @@ export declare const PeerLifecycleSchema: z.ZodEnum<typeof PeerLifecycle>;
|
|
|
16
16
|
export declare enum DynamicPeerKind {
|
|
17
17
|
ContributionSync = "contribution-sync",
|
|
18
18
|
CapabilityInvoke = "capability-invoke",
|
|
19
|
+
ContributionDeclared = "contribution-declared",
|
|
19
20
|
RouteForward = "route-forward",
|
|
20
21
|
AdapterHost = "adapter-host",
|
|
21
22
|
RunnerDispatch = "runner-dispatch"
|
|
@@ -23,10 +24,15 @@ export declare enum DynamicPeerKind {
|
|
|
23
24
|
export declare const DynamicPeerKindSchema: z.ZodEnum<typeof DynamicPeerKind>;
|
|
24
25
|
export declare enum PeerInclusionKind {
|
|
25
26
|
Required = "required",
|
|
27
|
+
Operation = "operation",
|
|
26
28
|
Optional = "optional"
|
|
27
29
|
}
|
|
30
|
+
export declare const OperationIdSchema: z.ZodString;
|
|
28
31
|
export declare const PeerInclusionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
29
32
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
33
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
34
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
35
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
30
36
|
}, z.core.$strict>, z.ZodObject<{
|
|
31
37
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
32
38
|
}, z.core.$strict>], "kind">;
|
|
@@ -42,7 +48,14 @@ export type DependencyContractEvidence = z.infer<typeof DependencyContractEviden
|
|
|
42
48
|
export declare const DependencyContractConsumerSchema: z.ZodObject<{
|
|
43
49
|
componentKey: z.ZodOptional<z.ZodString>;
|
|
44
50
|
}, z.core.$strict>;
|
|
51
|
+
export declare const PeerInvocationsSchema: z.ZodObject<{
|
|
52
|
+
clientFunctions: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
53
|
+
}, z.core.$strict>;
|
|
54
|
+
export type PeerInvocations = z.infer<typeof PeerInvocationsSchema>;
|
|
45
55
|
export declare const PeerEdgeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
56
|
+
invokes: z.ZodOptional<z.ZodObject<{
|
|
57
|
+
clientFunctions: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
58
|
+
}, z.core.$strict>>;
|
|
46
59
|
relationship: z.ZodLiteral<PeerRelationship.ServicePeer>;
|
|
47
60
|
consumer: z.ZodObject<{
|
|
48
61
|
componentKey: z.ZodOptional<z.ZodString>;
|
|
@@ -53,6 +66,9 @@ export declare const PeerEdgeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
53
66
|
lifecycle: z.ZodEnum<typeof PeerLifecycle>;
|
|
54
67
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
55
68
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
69
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
70
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
71
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
56
72
|
}, z.core.$strict>, z.ZodObject<{
|
|
57
73
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
58
74
|
}, z.core.$strict>], "kind">;
|
|
@@ -73,6 +89,9 @@ export declare const PeerEdgeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
73
89
|
lifecycle: z.ZodEnum<typeof PeerLifecycle>;
|
|
74
90
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
75
91
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
92
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
93
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
94
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
76
95
|
}, z.core.$strict>, z.ZodObject<{
|
|
77
96
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
78
97
|
}, z.core.$strict>], "kind">;
|
|
@@ -93,6 +112,9 @@ export declare const PeerEdgeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
93
112
|
lifecycle: z.ZodEnum<typeof PeerLifecycle>;
|
|
94
113
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
95
114
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
115
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
116
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
117
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
96
118
|
}, z.core.$strict>, z.ZodObject<{
|
|
97
119
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
98
120
|
}, z.core.$strict>], "kind">;
|
|
@@ -113,6 +135,9 @@ export declare const PeerEdgeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
113
135
|
lifecycle: z.ZodEnum<typeof PeerLifecycle>;
|
|
114
136
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
115
137
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
138
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
139
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
140
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
116
141
|
}, z.core.$strict>, z.ZodObject<{
|
|
117
142
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
118
143
|
}, z.core.$strict>], "kind">;
|
|
@@ -133,6 +158,9 @@ export declare const PeerEdgeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
133
158
|
lifecycle: z.ZodLiteral<PeerLifecycle.Runtime>;
|
|
134
159
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
135
160
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
161
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
162
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
163
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
136
164
|
}, z.core.$strict>, z.ZodObject<{
|
|
137
165
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
138
166
|
}, z.core.$strict>], "kind">;
|
|
@@ -170,6 +198,27 @@ export declare const ProvidedContributionKindsSchema: z.ZodObject<{
|
|
|
170
198
|
}, z.core.$strict>>>;
|
|
171
199
|
}, z.core.$strict>;
|
|
172
200
|
export type ProvidedContributionKinds = z.infer<typeof ProvidedContributionKindsSchema>;
|
|
201
|
+
export declare const ComponentOperationSchema: z.ZodObject<{
|
|
202
|
+
operationId: z.ZodString;
|
|
203
|
+
clientFunction: z.ZodString;
|
|
204
|
+
}, z.core.$strict>;
|
|
205
|
+
export declare const ComponentOperationsSchema: z.ZodObject<{
|
|
206
|
+
consumer: z.ZodObject<{
|
|
207
|
+
componentKey: z.ZodString;
|
|
208
|
+
}, z.core.$strict>;
|
|
209
|
+
serviceName: z.ZodString;
|
|
210
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
211
|
+
operationId: z.ZodString;
|
|
212
|
+
clientFunction: z.ZodString;
|
|
213
|
+
}, z.core.$strict>>>;
|
|
214
|
+
evidence: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
215
|
+
path: z.ZodString;
|
|
216
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
217
|
+
jsonPointer: z.ZodOptional<z.ZodString>;
|
|
218
|
+
seam: z.ZodString;
|
|
219
|
+
}, z.core.$strict>>>;
|
|
220
|
+
}, z.core.$strict>;
|
|
221
|
+
export type ComponentOperations = z.infer<typeof ComponentOperationsSchema>;
|
|
173
222
|
export declare const BiomeDependencyContractSchema: z.ZodObject<{
|
|
174
223
|
contractVersion: z.ZodLiteral<1>;
|
|
175
224
|
seamTable: z.ZodObject<{
|
|
@@ -177,6 +226,9 @@ export declare const BiomeDependencyContractSchema: z.ZodObject<{
|
|
|
177
226
|
sha256: z.ZodString;
|
|
178
227
|
}, z.core.$strict>;
|
|
179
228
|
peers: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
229
|
+
invokes: z.ZodOptional<z.ZodObject<{
|
|
230
|
+
clientFunctions: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
231
|
+
}, z.core.$strict>>;
|
|
180
232
|
relationship: z.ZodLiteral<PeerRelationship.ServicePeer>;
|
|
181
233
|
consumer: z.ZodObject<{
|
|
182
234
|
componentKey: z.ZodOptional<z.ZodString>;
|
|
@@ -187,6 +239,9 @@ export declare const BiomeDependencyContractSchema: z.ZodObject<{
|
|
|
187
239
|
lifecycle: z.ZodEnum<typeof PeerLifecycle>;
|
|
188
240
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
189
241
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
242
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
243
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
244
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
190
245
|
}, z.core.$strict>, z.ZodObject<{
|
|
191
246
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
192
247
|
}, z.core.$strict>], "kind">;
|
|
@@ -207,6 +262,9 @@ export declare const BiomeDependencyContractSchema: z.ZodObject<{
|
|
|
207
262
|
lifecycle: z.ZodEnum<typeof PeerLifecycle>;
|
|
208
263
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
209
264
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
265
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
266
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
267
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
210
268
|
}, z.core.$strict>, z.ZodObject<{
|
|
211
269
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
212
270
|
}, z.core.$strict>], "kind">;
|
|
@@ -227,6 +285,9 @@ export declare const BiomeDependencyContractSchema: z.ZodObject<{
|
|
|
227
285
|
lifecycle: z.ZodEnum<typeof PeerLifecycle>;
|
|
228
286
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
229
287
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
288
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
289
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
290
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
230
291
|
}, z.core.$strict>, z.ZodObject<{
|
|
231
292
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
232
293
|
}, z.core.$strict>], "kind">;
|
|
@@ -247,6 +308,9 @@ export declare const BiomeDependencyContractSchema: z.ZodObject<{
|
|
|
247
308
|
lifecycle: z.ZodEnum<typeof PeerLifecycle>;
|
|
248
309
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
249
310
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
311
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
312
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
313
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
250
314
|
}, z.core.$strict>, z.ZodObject<{
|
|
251
315
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
252
316
|
}, z.core.$strict>], "kind">;
|
|
@@ -267,6 +331,9 @@ export declare const BiomeDependencyContractSchema: z.ZodObject<{
|
|
|
267
331
|
lifecycle: z.ZodLiteral<PeerLifecycle.Runtime>;
|
|
268
332
|
inclusion: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
269
333
|
kind: z.ZodLiteral<PeerInclusionKind.Required>;
|
|
334
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
335
|
+
kind: z.ZodLiteral<PeerInclusionKind.Operation>;
|
|
336
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
270
337
|
}, z.core.$strict>, z.ZodObject<{
|
|
271
338
|
kind: z.ZodLiteral<PeerInclusionKind.Optional>;
|
|
272
339
|
}, z.core.$strict>], "kind">;
|
|
@@ -301,6 +368,22 @@ export declare const BiomeDependencyContractSchema: z.ZodObject<{
|
|
|
301
368
|
seam: z.ZodString;
|
|
302
369
|
}, z.core.$strict>>>;
|
|
303
370
|
}, z.core.$strict>>>;
|
|
371
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
372
|
+
consumer: z.ZodObject<{
|
|
373
|
+
componentKey: z.ZodString;
|
|
374
|
+
}, z.core.$strict>;
|
|
375
|
+
serviceName: z.ZodString;
|
|
376
|
+
operations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
377
|
+
operationId: z.ZodString;
|
|
378
|
+
clientFunction: z.ZodString;
|
|
379
|
+
}, z.core.$strict>>>;
|
|
380
|
+
evidence: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
381
|
+
path: z.ZodString;
|
|
382
|
+
line: z.ZodOptional<z.ZodNumber>;
|
|
383
|
+
jsonPointer: z.ZodOptional<z.ZodString>;
|
|
384
|
+
seam: z.ZodString;
|
|
385
|
+
}, z.core.$strict>>>;
|
|
386
|
+
}, z.core.$strict>>>;
|
|
304
387
|
}, z.core.$strict>;
|
|
305
388
|
export type BiomeDependencyContract = z.infer<typeof BiomeDependencyContractSchema>;
|
|
306
389
|
export declare function dependencyContractEvidencePaths(contract: BiomeDependencyContract): readonly string[];
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"biome-dependency-contract.d.ts","sourceRoot":"","sources":["../../../src/biome-dependency/lib/biome-dependency-contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkBxB,eAAO,MAAM,iCAAiC,EAAG,CAAU,CAAC;AAO5D,oBAAY,gBAAgB;IAE1B,WAAW,iBAAiB;IAE5B,iBAAiB,uBAAuB;IAExC,YAAY,kBAAkB;IAE9B,UAAU,gBAAgB;IAE1B,aAAa,mBAAmB;CACjC;AACD,eAAO,MAAM,sBAAsB,oCAAiC,CAAC;AAGrE,oBAAY,aAAa;IAEvB,OAAO,YAAY;IAEnB,OAAO,YAAY;CACpB;AACD,eAAO,MAAM,mBAAmB,iCAA8B,CAAC;
|
|
1
|
+
{"version":3,"file":"biome-dependency-contract.d.ts","sourceRoot":"","sources":["../../../src/biome-dependency/lib/biome-dependency-contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkBxB,eAAO,MAAM,iCAAiC,EAAG,CAAU,CAAC;AAO5D,oBAAY,gBAAgB;IAE1B,WAAW,iBAAiB;IAE5B,iBAAiB,uBAAuB;IAExC,YAAY,kBAAkB;IAE9B,UAAU,gBAAgB;IAE1B,aAAa,mBAAmB;CACjC;AACD,eAAO,MAAM,sBAAsB,oCAAiC,CAAC;AAGrE,oBAAY,aAAa;IAEvB,OAAO,YAAY;IAEnB,OAAO,YAAY;CACpB;AACD,eAAO,MAAM,mBAAmB,iCAA8B,CAAC;AAW/D,oBAAY,eAAe;IAEzB,gBAAgB,sBAAsB;IAOtC,gBAAgB,sBAAsB;IAOtC,oBAAoB,0BAA0B;IAE9C,YAAY,kBAAkB;IAE9B,WAAW,iBAAiB;IAE5B,cAAc,oBAAoB;CACnC;AACD,eAAO,MAAM,qBAAqB,mCAAgC,CAAC;AA6BnE,oBAAY,iBAAiB;IAC3B,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,QAAQ,aAAa;CACtB;AAGD,eAAO,MAAM,iBAAiB,aAAoB,CAAC;AAanD,eAAO,MAAM,mBAAmB;;;;;;;4BAU9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAGhE,eAAO,MAAM,qBAAqB,aAEhC,CAAC;AAQH,eAAO,MAAM,gCAAgC;;;;;kBAe1C,CAAC;AACJ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC;AAOF,eAAO,MAAM,gCAAgC;;kBAElC,CAAC;AAeZ,eAAO,MAAM,qBAAqB;;kBAUvB,CAAC;AACZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAkBpE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAsBzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,iBAAiB;;;;;;;;;;;kBAMnB,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAG5D,eAAO,MAAM,+BAA+B;;;;;;;;;;;kBAMjC,CAAC;AACZ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAQF,eAAO,MAAM,wBAAwB;;;kBAK1B,CAAC;AACZ,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;kBAiBnC,CAAC;AACJ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuCtC,CAAC;AACL,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAGF,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,uBAAuB,GAChC,SAAS,MAAM,EAAE,CASnB"}
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
-
exports.BiomeDependencyContractSchema = exports.ProvidedContributionKindsSchema = exports.DynamicPeerSchema = exports.PeerEdgeSchema = exports.DependencyContractConsumerSchema = exports.DependencyContractEvidenceSchema = exports.PeerServiceNameSchema = exports.PeerInclusionSchema = exports.PeerInclusionKind = exports.DynamicPeerKindSchema = exports.DynamicPeerKind = exports.PeerLifecycleSchema = exports.PeerLifecycle = exports.PeerRelationshipSchema = exports.PeerRelationship = exports.BIOME_DEPENDENCY_CONTRACT_VERSION = void 0;
|
|
3
|
+
exports.BiomeDependencyContractSchema = exports.ComponentOperationsSchema = exports.ComponentOperationSchema = exports.ProvidedContributionKindsSchema = exports.DynamicPeerSchema = exports.PeerEdgeSchema = exports.PeerInvocationsSchema = exports.DependencyContractConsumerSchema = exports.DependencyContractEvidenceSchema = exports.PeerServiceNameSchema = exports.PeerInclusionSchema = exports.OperationIdSchema = exports.PeerInclusionKind = exports.DynamicPeerKindSchema = exports.DynamicPeerKind = exports.PeerLifecycleSchema = exports.PeerLifecycle = exports.PeerRelationshipSchema = exports.PeerRelationship = exports.BIOME_DEPENDENCY_CONTRACT_VERSION = void 0;
|
|
4
4
|
exports.dependencyContractEvidencePaths = dependencyContractEvidencePaths;
|
|
5
5
|
const contribution_1 = require("../../contribution");
|
|
6
6
|
const zod_1 = require("zod");
|
|
@@ -24,6 +24,7 @@ var DynamicPeerKind;
|
|
|
24
24
|
(function (DynamicPeerKind) {
|
|
25
25
|
DynamicPeerKind["ContributionSync"] = "contribution-sync";
|
|
26
26
|
DynamicPeerKind["CapabilityInvoke"] = "capability-invoke";
|
|
27
|
+
DynamicPeerKind["ContributionDeclared"] = "contribution-declared";
|
|
27
28
|
DynamicPeerKind["RouteForward"] = "route-forward";
|
|
28
29
|
DynamicPeerKind["AdapterHost"] = "adapter-host";
|
|
29
30
|
DynamicPeerKind["RunnerDispatch"] = "runner-dispatch";
|
|
@@ -32,10 +33,26 @@ exports.DynamicPeerKindSchema = zod_1.z.nativeEnum(DynamicPeerKind);
|
|
|
32
33
|
var PeerInclusionKind;
|
|
33
34
|
(function (PeerInclusionKind) {
|
|
34
35
|
PeerInclusionKind["Required"] = "required";
|
|
36
|
+
PeerInclusionKind["Operation"] = "operation";
|
|
35
37
|
PeerInclusionKind["Optional"] = "optional";
|
|
36
38
|
})(PeerInclusionKind || (exports.PeerInclusionKind = PeerInclusionKind = {}));
|
|
39
|
+
exports.OperationIdSchema = zod_1.z.string().min(1);
|
|
40
|
+
const sortedUnique = (values) => values.every((value, i) => i === 0 || values[i - 1] < value);
|
|
41
|
+
const OperationIdListSchema = zod_1.z
|
|
42
|
+
.array(exports.OperationIdSchema)
|
|
43
|
+
.min(1)
|
|
44
|
+
.readonly()
|
|
45
|
+
.refine(sortedUnique, {
|
|
46
|
+
message: 'an operation list is sorted by code unit and free of duplicates',
|
|
47
|
+
});
|
|
37
48
|
exports.PeerInclusionSchema = zod_1.z.discriminatedUnion('kind', [
|
|
38
49
|
zod_1.z.object({ kind: zod_1.z.literal(PeerInclusionKind.Required) }).strict(),
|
|
50
|
+
zod_1.z
|
|
51
|
+
.object({
|
|
52
|
+
kind: zod_1.z.literal(PeerInclusionKind.Operation),
|
|
53
|
+
operations: OperationIdListSchema,
|
|
54
|
+
})
|
|
55
|
+
.strict(),
|
|
39
56
|
zod_1.z.object({ kind: zod_1.z.literal(PeerInclusionKind.Optional) }).strict(),
|
|
40
57
|
]);
|
|
41
58
|
const SERVICE_NAME = /^[a-z][a-z0-9-]*$/;
|
|
@@ -60,18 +77,32 @@ const EvidenceListSchema = zod_1.z
|
|
|
60
77
|
exports.DependencyContractConsumerSchema = zod_1.z
|
|
61
78
|
.object({ componentKey: zod_1.z.string().min(1).optional() })
|
|
62
79
|
.strict();
|
|
63
|
-
|
|
80
|
+
exports.PeerInvocationsSchema = zod_1.z
|
|
64
81
|
.object({
|
|
82
|
+
clientFunctions: zod_1.z
|
|
83
|
+
.array(zod_1.z.string().min(1))
|
|
84
|
+
.readonly()
|
|
85
|
+
.refine(sortedUnique, {
|
|
86
|
+
message: 'invoked client functions are sorted by code unit and free of duplicates',
|
|
87
|
+
}),
|
|
88
|
+
})
|
|
89
|
+
.strict();
|
|
90
|
+
const serviceEdgeShape = (relationship) => ({
|
|
65
91
|
relationship: zod_1.z.literal(relationship),
|
|
66
92
|
consumer: exports.DependencyContractConsumerSchema,
|
|
67
93
|
target: zod_1.z.object({ serviceName: exports.PeerServiceNameSchema }).strict(),
|
|
68
94
|
lifecycle: exports.PeerLifecycleSchema,
|
|
69
95
|
inclusion: exports.PeerInclusionSchema,
|
|
70
96
|
evidence: EvidenceListSchema,
|
|
71
|
-
})
|
|
72
|
-
|
|
97
|
+
});
|
|
98
|
+
const serviceEdge = (relationship) => zod_1.z.object(serviceEdgeShape(relationship)).strict();
|
|
73
99
|
exports.PeerEdgeSchema = zod_1.z.discriminatedUnion('relationship', [
|
|
74
|
-
|
|
100
|
+
zod_1.z
|
|
101
|
+
.object({
|
|
102
|
+
...serviceEdgeShape(PeerRelationship.ServicePeer),
|
|
103
|
+
invokes: exports.PeerInvocationsSchema.optional(),
|
|
104
|
+
})
|
|
105
|
+
.strict(),
|
|
75
106
|
serviceEdge(PeerRelationship.DatabasePool),
|
|
76
107
|
serviceEdge(PeerRelationship.EventPlane),
|
|
77
108
|
serviceEdge(PeerRelationship.BiomeDelivery),
|
|
@@ -102,6 +133,25 @@ exports.ProvidedContributionKindsSchema = zod_1.z
|
|
|
102
133
|
evidence: EvidenceListSchema,
|
|
103
134
|
})
|
|
104
135
|
.strict();
|
|
136
|
+
exports.ComponentOperationSchema = zod_1.z
|
|
137
|
+
.object({
|
|
138
|
+
operationId: exports.OperationIdSchema,
|
|
139
|
+
clientFunction: zod_1.z.string().min(1),
|
|
140
|
+
})
|
|
141
|
+
.strict();
|
|
142
|
+
exports.ComponentOperationsSchema = zod_1.z
|
|
143
|
+
.object({
|
|
144
|
+
consumer: zod_1.z.object({ componentKey: zod_1.z.string().min(1) }).strict(),
|
|
145
|
+
serviceName: exports.PeerServiceNameSchema,
|
|
146
|
+
operations: zod_1.z.array(exports.ComponentOperationSchema).readonly(),
|
|
147
|
+
evidence: EvidenceListSchema,
|
|
148
|
+
})
|
|
149
|
+
.strict()
|
|
150
|
+
.refine((entry) => sortedUnique(entry.operations.map((op) => op.operationId)) &&
|
|
151
|
+
new Set(entry.operations.map((op) => op.clientFunction)).size ===
|
|
152
|
+
entry.operations.length, {
|
|
153
|
+
message: 'operations are sorted by operationId, and no two share an operationId or a client function',
|
|
154
|
+
});
|
|
105
155
|
exports.BiomeDependencyContractSchema = zod_1.z
|
|
106
156
|
.object({
|
|
107
157
|
contractVersion: zod_1.z.literal(exports.BIOME_DEPENDENCY_CONTRACT_VERSION),
|
|
@@ -114,14 +164,37 @@ exports.BiomeDependencyContractSchema = zod_1.z
|
|
|
114
164
|
peers: zod_1.z.array(exports.PeerEdgeSchema).readonly(),
|
|
115
165
|
dynamicPeers: zod_1.z.array(exports.DynamicPeerSchema).readonly(),
|
|
116
166
|
provides: zod_1.z.array(exports.ProvidedContributionKindsSchema).readonly(),
|
|
167
|
+
operations: zod_1.z.array(exports.ComponentOperationsSchema).readonly(),
|
|
117
168
|
})
|
|
118
|
-
.strict()
|
|
169
|
+
.strict()
|
|
170
|
+
.superRefine((contract, context) => {
|
|
171
|
+
const exposed = new Map(contract.operations.map((entry) => [
|
|
172
|
+
entry.consumer.componentKey,
|
|
173
|
+
new Set(entry.operations.map((op) => op.operationId)),
|
|
174
|
+
]));
|
|
175
|
+
contract.peers.forEach((edge, index) => {
|
|
176
|
+
if (edge.inclusion.kind !== PeerInclusionKind.Operation)
|
|
177
|
+
return;
|
|
178
|
+
const key = edge.consumer.componentKey;
|
|
179
|
+
const ops = key === undefined ? undefined : exposed.get(key);
|
|
180
|
+
for (const operationId of edge.inclusion.operations) {
|
|
181
|
+
if (ops === undefined || !ops.has(operationId)) {
|
|
182
|
+
context.addIssue({
|
|
183
|
+
code: 'custom',
|
|
184
|
+
path: ['peers', index, 'inclusion', 'operations'],
|
|
185
|
+
message: `operation-scoped edge names operation "${operationId}", which component "${key ?? '<biome>'}" does not expose`,
|
|
186
|
+
});
|
|
187
|
+
}
|
|
188
|
+
}
|
|
189
|
+
});
|
|
190
|
+
});
|
|
119
191
|
function dependencyContractEvidencePaths(contract) {
|
|
120
192
|
const paths = new Set();
|
|
121
193
|
const add = (evidence) => evidence.forEach(({ path }) => paths.add(path));
|
|
122
194
|
contract.peers.forEach((edge) => add(edge.evidence));
|
|
123
195
|
contract.dynamicPeers.forEach((peer) => add(peer.evidence));
|
|
124
196
|
contract.provides.forEach((fact) => add(fact.evidence));
|
|
197
|
+
contract.operations.forEach((entry) => add(entry.evidence));
|
|
125
198
|
return [...paths];
|
|
126
199
|
}
|
|
127
200
|
//# sourceMappingURL=biome-dependency-contract.js.map
|