pareto 0.58.0 → 0.60.0

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

@@ -0,0 +1,40 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    data,
+    sfunction,
+    type,
+    group,
+    typeReference,
+    member,
+    string,
+    dictionary,
+    null_,
+    array,
+    imp,
+    externalTypeReference,
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import { $ as d_in } from "../../glossaries/auto.graphviz.data"
+import { $ as d_out } from "../../glossaries/string_aware_fountain_pen.data"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+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({
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("out", "Block"), data(externalTypeReference("in", "Graph"))),
+    }),
+
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/pareto_2_typescript/api.data.ts

@@ -0,0 +1,16 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { aInterface, aInterfaceMethod, glossary, group, member, number, sInterface, sInterfaceMethod, streamconsumer, string, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+export const $: g_project.D.API = api(
+    glos,
+
+    {
+        "map": algorithm("Map", null, {})
+    }
+)

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

@@ -0,0 +1,53 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    dictionary,
+    typeReference,
+    data,
+    sfunction,
+    ref,
+    typeParameter,
+    externalTypeReference,
+    parametrizedType,
+    optional,
+    group,
+    member,
+    aInterface,
+    streamconsumer,
+    aInterfaceMethod,
+    type,
+    string,
+    boolean,
+    sInterface,
+    sInterfaceMethod,
+    array,
+    imp,
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as d_in } from "../../glossaries/auto.pareto.data"
+import { $ as d_out } from "../../glossaries/typescript_intermediate.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({
+            "Map Data": type(group({
+                "compilation unit": member(ref(externalTypeReference("in", "Compilation Unit", {}))),
+            })),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("out", "Block"), data(typeReference("Map Data"))),
+    }),
+}

package/auto.pareto/{modules/tendril2alan_light → auto.dependencies/pareto-pure/modules/tendril_2_alan_light}/glossary.data.ts

@@ -26,18 +26,16 @@ import {
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
-
-import { $ as d_tendril } from "../../auto.dependencies/pareto-pure/glossaries/auto.tendril_resolved.data"
-import { $ as d_alan_light } from "../../auto.dependencies/pareto-pure/glossaries/auto.alan.data"
+import { $ as d_in } from "../../glossaries/auto.tendril_resolved.data"
+import { $ as d_out } from "../../glossaries/auto.alan_light.data"
 
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
     'imports': d({
-        "tendril": imp(d_tendril, {}),
-        "alan light": imp(d_alan_light, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
-
     'glossary parameters': d({}),
     'root': {
         'namespaces': d({}),
@@ -46,6 +44,6 @@ export const $: g_glossary.D.Glossary = {
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Map": sfunction(externalTypeReference("alan light", "Root"), data(externalTypeReference("tendril", "Model"))),
+        "Map": sfunction(externalTypeReference("out", "Root"), data(externalTypeReference("in", "Model"))),
     }),
 }

package/auto.pareto/auto.dependencies/pareto-pure/modules/{tendril2cosmos_type_system → tendril_2_cosmos_type_system}/glossary.data.ts

@@ -7,8 +7,8 @@ import {
     array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import { $ as d_cosmos } from "../../glossaries/auto.cosmos_type_system.data"
-import { $ as d_tendril } from "../../glossaries/auto.tendril_resolved.data"
+import { $ as d_out } from "../../glossaries/auto.cosmos_type_system.data"
+import { $ as d_in } from "../../glossaries/auto.tendril_resolved.data"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
@@ -16,8 +16,8 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "cosmos": imp(d_cosmos, {}),
-        "tendril": imp(d_tendril, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
@@ -27,7 +27,7 @@ export const $: g_glossary.D.Glossary = {
                 "settings": member(ref(typeReference("Mapping Settings"))),
             })),
             "Mapped Library": type(group({
-                "library": member(ref(externalTypeReference("tendril", "Type Library", {}))),
+                "library": member(ref(externalTypeReference("in", "Type Library", {}))),
                 "terminal mapping": member(ref(typeReference("Terminal Mapping"))),
             })),
 
@@ -67,7 +67,7 @@ export const $: g_glossary.D.Glossary = {
     'interface types': d({
     }),
     'algorithm types': d({
-        "Map": sfunction(externalTypeReference("cosmos", "Glossary", {}), data(typeReference("MapData"))),
+        "Map": sfunction(externalTypeReference("out", "Glossary", {}), data(typeReference("MapData"))),
 
     }),
 }

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

@@ -0,0 +1,17 @@
+
+
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "createResolver": algorithm("CreateResolver", null, {}),
+        "createSerializer": algorithm("CreateSerializer", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/modules/{tendril2pareto → tendril_2_pareto}/glossary.data.ts

@@ -7,8 +7,8 @@ import {
     array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import { $ as d_pareto } from "../../glossaries/auto.pareto.data"
-import { $ as d_tendril } from "../../glossaries/auto.tendril_resolved.data"
+import { $ as d_out } from "../../glossaries/auto.pareto.data"
+import { $ as d_in } from "../../glossaries/auto.tendril_resolved.data"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 const d = pd.d
@@ -16,8 +16,8 @@ const d = pd.d
 export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "pareto": imp(d_pareto, {}),
-        "tendril": imp(d_tendril, {}),
+        "in": imp(d_in, {}),
+        "out": imp(d_out, {}),
     }),
     'root': {
         'namespaces': d({}),
@@ -28,6 +28,7 @@ export const $: g_glossary.D.Glossary = {
     'interface types': d({
     }),
     'algorithm types': d({
-        "CreateResolver": sfunction(externalTypeReference("pareto", "Compilation Unit", {}), data(externalTypeReference("tendril", "Type Library", {}))),
+        "CreateResolver": sfunction(externalTypeReference("out", "Compilation Unit", {}), data(externalTypeReference("in", "Type Library", {}))),
+        "CreateSerializer": sfunction(externalTypeReference("out", "Compilation Unit", {}), data(externalTypeReference("in", "Type Library", {}))),
     }),
 }

package/auto.pareto/auto.dependencies/pareto-pure/modules/{testresult → testresult_2_testresult}/api.data.ts

@@ -4,10 +4,8 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 
 import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
-
 import { $ as d_glos } from "./glossary.data"
 
-
 export const $: g_project.D.API = api(
     d_glos,
     {

package/auto.pareto/auto.dependencies/pareto-standard-library/$.data.ts

@@ -5,13 +5,12 @@ import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.co
 const d = pd.d
 import { } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import { $ as d_arithmetic } from "./modules/arithmetic/api.data"
 import { $ as d_array } from "./modules/array/api.data"
 import { $ as d_boolean } from "./modules/boolean/api.data"
-import { $ as d_build } from "./modules/build/api.data"
+import { $ as d_buildInterfaceInitializers } from "./modules/buildInterfaceInitializers/api.data"
 import { $ as d_dictionary } from "./modules/dictionary/api.data"
-import { $ as d_json } from "./modules/json/api.data"
-import { $ as d_nested } from "./modules/nested/api.data"
+import { $ as d_number } from "./modules/number/api.data"
+import { $ as d_optional } from "./modules/optional/api.data"
 import { $ as d_resolve } from "./modules/resolve/api.data"
 import { $ as d_string } from "./modules/string/api.data"
 import { $ as d_tostring } from "./modules/tostring/api.data"
@@ -26,16 +25,13 @@ export const $: g_project.D.Library = {
         'public': {
             'glossaries': d({}),
             'modules': d({
-                "arithmetic": d_arithmetic,
                 "array": d_array,
                 "boolean": d_boolean,
-                "build": d_build,
+                "build interface initializers": d_buildInterfaceInitializers,
                 "dictionary": d_dictionary,
-                "json": d_json,
-                "nested": d_nested,
-                "resolve": d_resolve,
+                "number": d_number,
+                "optional": d_optional,
                 "string": d_string,
-                "tostring": d_tostring,
             })
         },
         'private': {

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

@@ -14,6 +14,8 @@ export const $: g_project.D.API = api(
         "append": algorithm("Append", null, {}),
         "prepend": algorithm("Prepend", null, {}),
         "zip": algorithm("Zip", null, {}),
+        "flattenTree": algorithm("FlattenTree", null, {}),
+        "unsafeSortTopologically": algorithm("SortTopologically", null, {}),
 
     }
 )

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

@@ -1,7 +1,9 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, data, dictionary, externalTypeReference, group, member, number, optional, parametrizedType, ref, sfunction,
+    array, data, dictionary, externalTypeReference, group, member, null_, number, optional, parametrizedType, ref, sfunction,
+    string,
+    taggedUnion,
     type, typeParameter, typeReference
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
@@ -16,37 +18,104 @@ export const $: g_glossary.D.Glossary = {
     'root': {
         'namespaces': d({}),
         'data types': d({
-            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
-            "ArrayOfArrays": parametrizedType({ "Type": null }, array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+            //out
+            "Array": parametrizedType(
+                { "Type": null },
+                array(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") }))),
+            "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") })))),
+
+            "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_(),
             })),
-            "ZippedArray": parametrizedType({ "Benchmark": null, "Focus": null }, array(group({
-                "benchmark": member(ref(typeParameter("Benchmark"))),
-                "focus": member(ref(typeParameter("Focus"))),
+            // "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_())),
             }))),
 
+
+            "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({
-        "Append": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("AppendParameters", { "Type": typeParameter("Type") })), { "Type": null }),
-        "Prepend": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("PrependParameters", { "Type": typeParameter("Type") })), { "Type": null }),
-        "FlattenArrayOfArrays": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("ArrayOfArrays", { "Type": typeParameter("Type") })), { "Type": null }),
+        "Append": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("AppendParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "Prepend": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("PrependParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "FlattenArrayOfArrays": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("ArrayOfArrays", { "Type": typeParameter("Type") })),
+            { "Type": null },
+        ),
+        "FlattenTree": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("Nested", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
         "Zip": sfunction(
             typeReference("ZippedArray", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") }),
             data(typeReference("ArrayTuple", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") })),
             { "Benchmark": null, "Focus": null }
         ),
+
+
+        "SortTopologically": sfunction(
+            typeReference("KeyValuePairArray", { "Type": typeParameter("Type") }),
+            data(typeReference("DependencyDictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
     }),
 }

package/auto.pareto/auto.dependencies/{pareto-pure/auto.dependencies/pareto-standard-library/modules/build → pareto-standard-library/modules/buildInterfaceInitializers}/api.data.ts

@@ -18,7 +18,6 @@ export const $: g_project.D.API = api(
         "createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", "DictionaryBuildStrategy", {}),
         "createArrayBuilder": algorithm("CreateArrayBuilder", null, {}),
 
-
         "createStringBuilder": algorithm("CreateStringBuilder", "Startstring", {
         }),
     }

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

@@ -0,0 +1,167 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, dictionary, ref, typeParameter, group, sInf, member,
+    sfunction,
+    sInterfaceMethod, sInterfaceReference, streamconsumer, string, taggedUnion, type, typeReference, aInterface, sInterface, parametrizedType,
+    infInit
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Simple Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+
+            "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+            "Simple String": type(string()),
+
+            "Array": parametrizedType({ "Type": null, "EndType": null }, group({
+                "array": member(array(ref(typeParameter("Type")))),
+                "end": member(ref(typeParameter("EndType"))),
+            })),
+            "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
+                "dictionary": member(dictionary(ref(typeParameter("Type")))),
+                "end": member(ref(typeParameter("EndType"))),
+            })),
+            "String": parametrizedType({ "EndType": null }, group({
+                "string": member(string()),
+                "end": member(ref(typeParameter("EndType"))),
+            })),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+
+            "DictionaryBuildStrategy": type(taggedUnion({
+                "ignore": group({}),
+                "overwrite": group({}),
+            })),
+            "Startstring": type(string()),
+        }),
+    },
+    'interface types': d({
+        "Array": aInterface(
+            aInterfaceMethod(typeReference("Array", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType")
+            })),
+            { "Type": null, "EndType": null }
+        ),
+        "Dictionary": aInterface(
+            aInterfaceMethod(typeReference("Dictionary", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType")
+            })),
+            { "Type": null, "EndType": null }
+        ),
+        "Elements": aInterface(
+            streamconsumer(
+                aInterfaceMethod(typeParameter("Type")),
+                aInterfaceMethod(typeParameter("EndType")),
+            ),
+            { "Type": null, "EndType": null }
+        ),
+        "Entries": aInterface(
+            streamconsumer(
+                aInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })),
+                aInterfaceMethod(typeParameter("EndType")),
+            ),
+            { "Type": null, "EndType": null }
+        ),
+        "DuplicatesHandler": aInterface(
+            streamconsumer(
+                aInterfaceMethod(typeReference("Simple String")),
+                aInterfaceMethod(null),
+            )
+        ),
+        "StringConsumer": aInterface(
+            aInterfaceMethod(typeReference("String", { "EndType": typeParameter("EndType") })),
+            { "EndType": null }
+        ),
+        "StringStreamConsumer": aInterface(
+            streamconsumer(
+                aInterfaceMethod(typeReference("Simple String")),
+                aInterfaceMethod(typeParameter("EndType")),
+            ),
+            { "EndType": null }
+        ),
+        "Add": sInterface(
+            sInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "Push": sInterface(
+            sInterfaceMethod(typeParameter("Type")),
+            { "Type": null }
+        ),
+    }),
+    'algorithm types': d({
+        "CreateArrayBuilder": infInit(
+            aInterfaceReference("Elements", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType"),
+            }),
+            {
+                "handler": aInterfaceReference("Array", {
+                    "Type": typeParameter("Type"),
+                    "EndType": typeParameter("EndType"),
+                }),
+            },
+            { "Type": null, "EndType": null }
+        ),
+        "CreateUnsafeDictionaryBuilder": infInit(
+            aInterfaceReference("Entries", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType"),
+            }),
+            {
+                "handler": aInterfaceReference("Dictionary", {
+                    "Type": typeParameter("Type"),
+                    "EndType": typeParameter("EndType")
+                }),
+            },
+            { "Type": null, "EndType": null }
+        ),
+        "CreateSafeDictionaryBuilder": infInit(
+            aInterfaceReference("Entries", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType"),
+            }),
+            {
+                "handler": aInterfaceReference("Dictionary", {
+                    "Type": typeParameter("Type"),
+                    "EndType": typeParameter("EndType")
+                }),
+                "duplicatesHandler": aInterfaceReference("DuplicatesHandler"),
+
+            },
+            { "Type": null, "EndType": null }
+        ),
+        "CreateStringBuilder": infInit(
+            aInterfaceReference("StringStreamConsumer", { "EndType": typeParameter("EndType") }),
+            {
+                "handler": aInterfaceReference("StringConsumer", { "EndType": typeParameter("EndType") }),
+            },
+            { "EndType": null }
+        ),
+        // "BuildArray": sfunction(typeReference("Simple Array", {
+        //     "Type": typeParameter("Type"),
+        // }), sInf(sInterfaceReference("Push", { "Type": typeParameter("Type") })), { "Type": null }),
+        // "BuildUnsafeDictionary": sfunction(typeReference("Simple Dictionary", {
+        //     "Type": typeParameter("Type"),
+        // }), sInf(sInterfaceReference("Add", { "Type": typeParameter("Type") })), { "Type": null }),
+        // "BuildSafeDictionary": sfunction(typeReference("Simple Dictionary", {
+        //     "Type": typeParameter("Type"),
+        // }), sInf(sInterfaceReference("Add", { "Type": typeParameter("Type") })), { "Type": null }),
+
+    }),
+
+}

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

@@ -64,7 +64,6 @@ export const $: g_glossary.D.Glossary = {
             })),
             "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
-
             "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
         }),
@@ -111,8 +110,11 @@ export const $: g_glossary.D.Glossary = {
             typeReference("Dictionary", { "Type": typeParameter("Type") }),
             data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
             { "Type": null }
-        ),       
-         "DecorateDictionaryEntriesWithKey": sfunction(typeReference("KeyValueDictionary", { "Type": typeParameter("Type") }), data(typeReference("Dictionary", { "Type": typeParameter("Type") })), { "Type": null }),
+        ),
+        "DecorateDictionaryEntriesWithKey": sfunction(
+            typeReference("KeyValueDictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("Dictionary", { "Type": typeParameter("Type") })), { "Type": null }
+        ),
 
     }),
 

package/auto.pareto/auto.dependencies/pareto-standard-library/modules/nested/api.data.ts

@@ -10,6 +10,5 @@ import { glossary, group, member, number, type } from "pareto-pure/auto.dist/pub
 export const $: g_project.D.API = api(
     glos,
     {
-        "flatten": algorithm("Flatten", null, {})
     }
 )