pareto 0.61.0 → 0.62.0

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril_2_alan_light/glossary.data.ts

@@ -32,15 +32,17 @@ import { $ as d_out } from "../../glossaries/auto.alan_light.data"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'imports': d({
-        "in": imp(d_in, {}),
-        "out": imp(d_out, {}),
-    }),
-    'glossary parameters': d({}),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
+    'data glossary': {
+        'imports': d({
+            "in": imp(d_in, {}),
+            "out": imp(d_out, {}),
         }),
+        'glossary parameters': d({}),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril_2_cosmos_type_system/glossary.data.ts

@@ -14,55 +14,57 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-        "in": imp(d_in, {}),
-        "out": imp(d_out, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "MapData": type(group({
-                "mapped library": member(ref(typeReference("Mapped Library"))),
-                "settings": member(ref(typeReference("Mapping Settings"))),
-            })),
-            "Mapped Library": type(group({
-                "library": member(ref(externalTypeReference("in", "Type Library", {}))),
-                "terminal mapping": member(ref(typeReference("Terminal Mapping"))),
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "in": imp(d_in, {}),
+            "out": imp(d_out, {}),
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "MapData": type(group({
+                    "mapped library": member(ref(typeReference("Mapped Library"))),
+                    "settings": member(ref(typeReference("Mapping Settings"))),
+                })),
+                "Mapped Library": type(group({
+                    "library": member(ref(externalTypeReference("in", "Type Library", {}))),
+                    "terminal mapping": member(ref(typeReference("Terminal Mapping"))),
+                })),
 
-            "Terminal Mapping": type(dictionary(taggedUnion({
-                "boolean": null_(),
-                "number": null_(),
-                "string": null_(),
-            }))),
-            "Mapping Settings": type(group({
-                "annotations": member(boolean()),
-                "datamodel": member(optional(group({
-                    "constraints mapping": member(group({
-                        "terminal values": member(boolean()),
-                        "constraints": member(optional(taggedUnion({
-                            "optional": group({}),
-                            "required": group({}),
-                        }))),
-                    })),
+                "Terminal Mapping": type(dictionary(taggedUnion({
+                    "boolean": null_(),
+                    "number": null_(),
+                    "string": null_(),
                 }))),
-                // "visitor interface": member(optional(group({
-                //     "datamodel": member(taggedUnion({
-                //         "internal": group({}),
-                //         "exernal": group({
-                //             "location": member(string()),
-                //         }),
-                //     })),
-                // }))),
-                // "algorithms": member(group({
-                //     "serialize": member(optional(group({
-                //         //data location,
-                //     }))),
-                //     //resolve
-                // })),
-            })),
-        }),
+                "Mapping Settings": type(group({
+                    "annotations": member(boolean()),
+                    "datamodel": member(optional(group({
+                        "constraints mapping": member(group({
+                            "terminal values": member(boolean()),
+                            "constraints": member(optional(taggedUnion({
+                                "optional": group({}),
+                                "required": group({}),
+                            }))),
+                        })),
+                    }))),
+                    // "visitor interface": member(optional(group({
+                    //     "datamodel": member(taggedUnion({
+                    //         "internal": group({}),
+                    //         "exernal": group({
+                    //             "location": member(string()),
+                    //         }),
+                    //     })),
+                    // }))),
+                    // "algorithms": member(group({
+                    //     "serialize": member(optional(group({
+                    //         //data location,
+                    //     }))),
+                    //     //resolve
+                    // })),
+                })),
+            }),
+        },
     },
     'interface types': d({
     }),

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril_2_pareto/glossary.data.ts

@@ -14,16 +14,18 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-        "in": imp(d_in, {}),
-        "out": imp(d_out, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "in": imp(d_in, {}),
+            "out": imp(d_out, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+
+            }),
+        },
     },
     'interface types': d({
     }),

package/auto.pareto/auto.dependencies/pareto-pure/modules/testresult_2_testresult/glossary.data.ts

@@ -9,127 +9,129 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({
-            "intermediate": {
-                'namespaces': d({
-
-                }),
-                'data types': d({}),
-            },
-            "summary": {
-                'namespaces': d({
-
-                }),
-                'data types': d({}),
-            },
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
-        'data types': d({
-            "Library": type(group({
-                "public": member(ref(typeReference("Module Set"))),
-                "private": member(ref(typeReference("Module Set"))),
-            })),
-            "Module Set": type(dictionary(ref(typeReference("Module")))),
-            "Module": type(dictionary(ref(typeReference("Algorithm")))),
-            "Algorithm": type(group({
-                "location": member(ref(typeReference("Source Location"))),
-                "tests": member(optional(dictionary(ref(typeReference("Test"))))),
-            })),
-            "Source Location": type(group({
-                "file": member(string()),
-                "line": member(number()),
-                "column": member(number()),
-            })),
-            "Test": type(array(ref(typeReference("Error")))),
-            "Error": type(taggedUnion({
-                "content": ref(typeReference("Compare Error"))
-            })),
-            "Compare Error": type(group({
-                "location": member(ref(typeReference("Source Location"))),
-                "path": member(string()),
-                "type": member(taggedUnion({
-                    "wrong number": group({
-                        "found": member(number()),
-                    }),
-                    "wrong text": group({
-                        "found": member(string()),
-                    }),
-                    "wrong boolean": group({
-                        "found": member(boolean())
-                    }),
-                    "optional value expected not to be set": null_(),
-                    "optional value expected to be set": null_(),
-                    "not the right state": group({
-                        "found": member(string())
-                    }),
-                    "not enough elements": null_(),
-                    "too many elements": null_(),
-                    "superfluous entries": group({
-                        "keys": member(dictionary(null_()))
+        'root': {
+            'namespaces': d({
+                "intermediate": {
+                    'namespaces': d({
+
                     }),
-                    "missing dictionary entry": group({
-                        "key": member(string()),
+                    'data types': d({}),
+                },
+                "summary": {
+                    'namespaces': d({
+
                     }),
+                    'data types': d({}),
+                },
+            }),
+            'data types': d({
+                "Library": type(group({
+                    "public": member(ref(typeReference("Module Set"))),
+                    "private": member(ref(typeReference("Module Set"))),
+                })),
+                "Module Set": type(dictionary(ref(typeReference("Module")))),
+                "Module": type(dictionary(ref(typeReference("Algorithm")))),
+                "Algorithm": type(group({
+                    "location": member(ref(typeReference("Source Location"))),
+                    "tests": member(optional(dictionary(ref(typeReference("Test"))))),
+                })),
+                "Source Location": type(group({
+                    "file": member(string()),
+                    "line": member(number()),
+                    "column": member(number()),
+                })),
+                "Test": type(array(ref(typeReference("Error")))),
+                "Error": type(taggedUnion({
+                    "content": ref(typeReference("Compare Error"))
                 })),
+                "Compare Error": type(group({
+                    "location": member(ref(typeReference("Source Location"))),
+                    "path": member(string()),
+                    "type": member(taggedUnion({
+                        "wrong number": group({
+                            "found": member(number()),
+                        }),
+                        "wrong text": group({
+                            "found": member(string()),
+                        }),
+                        "wrong boolean": group({
+                            "found": member(boolean())
+                        }),
+                        "optional value expected not to be set": null_(),
+                        "optional value expected to be set": null_(),
+                        "not the right state": group({
+                            "found": member(string())
+                        }),
+                        "not enough elements": null_(),
+                        "too many elements": null_(),
+                        "superfluous entries": group({
+                            "keys": member(dictionary(null_()))
+                        }),
+                        "missing dictionary entry": group({
+                            "key": member(string()),
+                        }),
+                    })),
 
-            })),
-            "Summary": type(group({
-                "number of tests": member(number()),
-                "number of missing tests": member(number()),
-                "number of errors": member(number()),
-            })),
+                })),
+                "Summary": type(group({
+                    "number of tests": member(number()),
+                    "number of missing tests": member(number()),
+                    "number of errors": member(number()),
+                })),
 
-            "String": type(string()),
+                "String": type(string()),
 
-            "intLibrary": type(group({
-                "public": member(ref(typeReference("intModule Set"))),
-                "private": member(ref(typeReference("intModule Set"))),
-            })),
-            "intModule Set": type(dictionary(ref(typeReference("intModule")))),
-            "intModule": type(dictionary(ref(typeReference("intAlgorithm")))),
-            "intAlgorithm": type(group({
-                "location": member(ref(typeReference("Source Location"))),
-                "status": member(taggedUnion({
-                    "no tests": null_(),
-                    "skipped": null_(),
-                    "has tests": dictionary(ref(typeReference("intTest"))),
+                "intLibrary": type(group({
+                    "public": member(ref(typeReference("intModule Set"))),
+                    "private": member(ref(typeReference("intModule Set"))),
                 })),
-            })),
-            "intTest": type(taggedUnion({
-                "has errors": array(ref(typeReference("Error"))),
-                "has no errors": null_(),
-            })),
-            "annotatedStatus": type(taggedUnion({
-                "has errors": null_(),  // red
-                "missing tests": null_(), // yellow
-                "no tests": null_(), // grey
-                "success": null_(), // green
-            })),
-            "annotatedLibrary": type(group({
-                "public": member(ref(typeReference("annotatedModule Set"))),
-                "private": member(ref(typeReference("annotatedModule Set"))),
-            })),
-            "annotatedModule Set": type(group({
-                "status": member(ref(typeReference("annotatedStatus"))),
-                "modules": member(dictionary(ref(typeReference("annotatedModule")))),
-            })),
-            "annotatedModule": type(group({
-                "status": member(ref(typeReference("annotatedStatus"))),
-                "algorithms": member(dictionary(ref(typeReference("annotatedAlgorithm")))),
-            })),
-            "annotatedAlgorithm": type(group({
-                "location": member(ref(typeReference("Source Location"))),
-                "status": member(ref(typeReference("annotatedStatus"))),
-                "tests": member(dictionary(ref(typeReference("annotatedTest")))),
-            })),
-            "annotatedTest": type(group({
-                "status": member(ref(typeReference("annotatedStatus"))),
-                "errors": member(array(ref(typeReference("Error")))),
-            })),
-        }),
+                "intModule Set": type(dictionary(ref(typeReference("intModule")))),
+                "intModule": type(dictionary(ref(typeReference("intAlgorithm")))),
+                "intAlgorithm": type(group({
+                    "location": member(ref(typeReference("Source Location"))),
+                    "status": member(taggedUnion({
+                        "no tests": null_(),
+                        "skipped": null_(),
+                        "has tests": dictionary(ref(typeReference("intTest"))),
+                    })),
+                })),
+                "intTest": type(taggedUnion({
+                    "has errors": array(ref(typeReference("Error"))),
+                    "has no errors": null_(),
+                })),
+                "annotatedStatus": type(taggedUnion({
+                    "has errors": null_(),  // red
+                    "missing tests": null_(), // yellow
+                    "no tests": null_(), // grey
+                    "success": null_(), // green
+                })),
+                "annotatedLibrary": type(group({
+                    "public": member(ref(typeReference("annotatedModule Set"))),
+                    "private": member(ref(typeReference("annotatedModule Set"))),
+                })),
+                "annotatedModule Set": type(group({
+                    "status": member(ref(typeReference("annotatedStatus"))),
+                    "modules": member(dictionary(ref(typeReference("annotatedModule")))),
+                })),
+                "annotatedModule": type(group({
+                    "status": member(ref(typeReference("annotatedStatus"))),
+                    "algorithms": member(dictionary(ref(typeReference("annotatedAlgorithm")))),
+                })),
+                "annotatedAlgorithm": type(group({
+                    "location": member(ref(typeReference("Source Location"))),
+                    "status": member(ref(typeReference("annotatedStatus"))),
+                    "tests": member(dictionary(ref(typeReference("annotatedTest")))),
+                })),
+                "annotatedTest": type(group({
+                    "status": member(ref(typeReference("annotatedStatus"))),
+                    "errors": member(array(ref(typeReference("Error")))),
+                })),
+            }),
+        },
     },
     'interface types': d({
         "Stringstream": sInterface(sInterfaceMethod(typeReference("String"))),

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/array/glossary.data.ts

@@ -12,76 +12,78 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            //out
-            "Array": parametrizedType(
-                { "Type": null },
-                array(ref(typeParameter("Type")))
-            ),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                //out
+                "Array": parametrizedType(
+                    { "Type": null },
+                    array(ref(typeParameter("Type")))
+                ),
 
-            "ZippedArray": parametrizedType(
-                { "Benchmark": null, "Focus": null },
-                array(group({
-                    "benchmark": member(ref(typeParameter("Benchmark"))),
-                    "focus": member(ref(typeParameter("Focus"))),
-                }))
-            ),
+                "ZippedArray": parametrizedType(
+                    { "Benchmark": null, "Focus": null },
+                    array(group({
+                        "benchmark": member(ref(typeParameter("Benchmark"))),
+                        "focus": member(ref(typeParameter("Focus"))),
+                    }))
+                ),
 
-            //in
-            "ArrayOfArrays": parametrizedType(
-                { "Type": null },
-                array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+                //in
+                "ArrayOfArrays": parametrizedType(
+                    { "Type": null },
+                    array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
 
-            "AppendParameters": parametrizedType(
-                { "Type": null },
-                group({
-                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                    "element": member(ref(typeParameter("Type"))),
-                })
-            ),
-            "PrependParameters": parametrizedType(
-                { "Type": null },
-                group({
-                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                    "element": member(ref(typeParameter("Type"))),
-                })
-            ),
-            "ArrayTuple": parametrizedType(
-                { "Benchmark": null, "Focus": null },
-                group({
-                    "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
-                    "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
-                })
-            ),
-            "Nested": parametrizedType({ "Type": null }, taggedUnion({
-                "single": ref(typeParameter("Type")),
-                "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type") }))),
-                "none": null_(),
-            })),
-            // "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            // "KeyValuePair": parametrizedType({ "Type": null }, group({
-            //     "key": member(string()),
-            //     "value": member(ref(typeParameter("Type"))),
-            // })),
+                "AppendParameters": parametrizedType(
+                    { "Type": null },
+                    group({
+                        "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": member(ref(typeParameter("Type"))),
+                    })
+                ),
+                "PrependParameters": parametrizedType(
+                    { "Type": null },
+                    group({
+                        "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": member(ref(typeParameter("Type"))),
+                    })
+                ),
+                "ArrayTuple": parametrizedType(
+                    { "Benchmark": null, "Focus": null },
+                    group({
+                        "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
+                        "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
+                    })
+                ),
+                "Nested": parametrizedType({ "Type": null }, taggedUnion({
+                    "single": ref(typeParameter("Type")),
+                    "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type") }))),
+                    "none": null_(),
+                })),
+                // "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                // "KeyValuePair": parametrizedType({ "Type": null }, group({
+                //     "key": member(string()),
+                //     "value": member(ref(typeParameter("Type"))),
+                // })),
 
-            "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
-                "value": member(ref(typeParameter("Type"))),
-                "dependencies": member(dictionary(null_())),
-            }))),
+                "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
+                    "value": member(ref(typeParameter("Type"))),
+                    "dependencies": member(dictionary(null_())),
+                }))),
 
 
-            "KeyValuePairArray": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
+                "KeyValuePairArray": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "KeyValuePair": parametrizedType({ "Type": null }, group({
+                    "key": member(string()),
+                    "value": member(ref(typeParameter("Type"))),
+                })),
 
-        }),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/boolean/glossary.data.ts

@@ -17,19 +17,21 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Boolean": type(boolean()),
-            "Pair Of Booleans": type(group({
-                "yin": member(boolean()),
-                "yang": member(boolean()),
-            })),
-            "Array Of Booleans": type(array(boolean())),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Boolean": type(boolean()),
+                "Pair Of Booleans": type(group({
+                    "yin": member(boolean()),
+                    "yang": member(boolean()),
+                })),
+                "Array Of Booleans": type(array(boolean())),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({