pareto 0.63.0 → 0.65.0

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

@@ -1,10 +1,25 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    aInterface,
-    aInterfaceMethod,
-    aInterfaceReference,
-    array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    type,
+    typeParameter,
+    typeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import { $ as d_out } from "../../glossaries/auto.cosmos_type_system.data"
@@ -17,42 +32,42 @@ export const $: g_glossary.D.Glossary = {
     'data glossary': {
         'glossary parameters': d({}),
         'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
+            "in": imp(d_in['data glossary'], {}),
+            "out": imp(d_out['data glossary'], {}),
         }),
         'root': {
             'namespaces': d({}),
             'data types': d({
                 "MapData": type(group({
-                    "mapped library": member(ref(typeReference("Mapped Library"))),
-                    "settings": member(ref(typeReference("Mapping Settings"))),
+                    "mapped library": member(component(typeReference("Mapped Library"))),
+                    "settings": member(component(typeReference("Mapping Settings"))),
                 })),
                 "Mapped Library": type(group({
-                    "library": member(ref(externalTypeReference("in", "Type Library", {}))),
-                    "terminal mapping": member(ref(typeReference("Terminal Mapping"))),
+                    "library": member(component(externalTypeReference("in", "Type Library", {}))),
+                    "terminal mapping": member(component(typeReference("Terminal Mapping"))),
                 })),
 
-                "Terminal Mapping": type(dictionary(taggedUnion({
-                    "boolean": null_(),
-                    "number": null_(),
-                    "string": null_(),
+                "Terminal Mapping": type(dictionary(stateGroup({
+                    "boolean": nothing(),
+                    "integer": nothing(),
+                    "text": nothing(),
                 }))),
                 "Mapping Settings": type(group({
                     "annotations": member(boolean()),
                     "datamodel": member(optional(group({
                         "constraints mapping": member(group({
                             "terminal values": member(boolean()),
-                            "constraints": member(optional(taggedUnion({
+                            "constraints": member(optional(stateGroup({
                                 "optional": group({}),
                                 "required": group({}),
                             }))),
                         })),
                     }))),
                     // "visitor interface": member(optional(group({
-                    //     "datamodel": member(taggedUnion({
+                    //     "datamodel": member(stateGroup({
                     //         "internal": group({}),
                     //         "exernal": group({
-                    //             "location": member(string()),
+                    //             "location": member(text()),
                     //         }),
                     //     })),
                     // }))),

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

@@ -11,7 +11,7 @@ import { $ as glos } from "./glossary.data"
 export const $: g_project.D.API = api(
     glos,
     {
-        "createResolver": algorithm("CreateResolver", null, {}),
-        "createSerializer": algorithm("CreateSerializer", null, {}),
+        "createResolver": algorithm("CreateResolver", {}),
+        "createSerializer": algorithm("CreateSerializer", {}),
     }
 )

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

@@ -1,10 +1,25 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    aInterface,
-    aInterfaceMethod,
-    aInterfaceReference,
-    array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    type,
+    typeParameter,
+    typeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import { $ as d_out } from "../../glossaries/auto.pareto.data"
@@ -17,8 +32,8 @@ export const $: g_glossary.D.Glossary = {
     'data glossary': {
         'glossary parameters': d({}),
         'imports': d({
-            "in": imp(d_in, {}),
-            "out": imp(d_out, {}),
+            "in": imp(d_in['data glossary'], {}),
+            "out": imp(d_out['data glossary'], {}),
         }),
         'root': {
             'namespaces': d({}),

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

@@ -9,16 +9,16 @@ import { $ as d_glos } from "./glossary.data"
 export const $: g_project.D.API = api(
     d_glos,
     {
-        "annotateTestResult": algorithm("Annotate TestResult", null, {}),
-        "serializeSummary": algorithm("Serialize Summary", null, {
+        "annotateTestResult": algorithm("Annotate TestResult", {}),
+        "serializeSummary": algorithm("Serialize Summary", {
             // "add": libDep("pareto-standard-impure-library", "arithmetic", "Add", {}),
             // "isZero": libDep("pareto-standard-impure-library", "numerical__predicates", "IsZero", {}),
             // "negate": libDep("pareto-standard-impure-library", "arithmetic", "Negate", {}),
         }),
-        "serializeTestResult": algorithm("Serialize TestResult", null, {
+        "serializeTestResult": algorithm("Serialize TestResult", {
             // "dictionaryForEach": libDep("pareto-standard-impure-library", "foreach", "DictionaryForEach", {}),
         }),
-        "summarize": algorithm("Summarize", null, {}),
+        "summarize": algorithm("Summarize", {}),
 
     }
 )

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

@@ -1,7 +1,30 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, number, optional, parametrizedType, procedure, ref, sfunction, sInterface, sInterfaceMethod, sInterfaceReference, string, taggedUnion, type, typeParameter, typeReference
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    imp,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    type,
+    typeParameter,
+    typeReference,
+
+    procedure,
+    sInterface,
+    sInterfaceMethod,
+    sInterfaceReference,
 } 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"
@@ -30,105 +53,105 @@ export const $: g_glossary.D.Glossary = {
             }),
             'data types': d({
                 "Library": type(group({
-                    "public": member(ref(typeReference("Module Set"))),
-                    "private": member(ref(typeReference("Module Set"))),
+                    "public": member(component(typeReference("Module Set"))),
+                    "private": member(component(typeReference("Module Set"))),
                 })),
-                "Module Set": type(dictionary(ref(typeReference("Module")))),
-                "Module": type(dictionary(ref(typeReference("Algorithm")))),
+                "Module Set": type(dictionary(component(typeReference("Module")))),
+                "Module": type(dictionary(component(typeReference("Algorithm")))),
                 "Algorithm": type(group({
-                    "location": member(ref(typeReference("Source Location"))),
-                    "tests": member(optional(dictionary(ref(typeReference("Test"))))),
+                    "location": member(component(typeReference("Source Location"))),
+                    "tests": member(optional(dictionary(component(typeReference("Test"))))),
                 })),
                 "Source Location": type(group({
-                    "file": member(string()),
-                    "line": member(number()),
-                    "column": member(number()),
+                    "file": member(text()),
+                    "line": member(integer()),
+                    "column": member(integer()),
                 })),
-                "Test": type(array(ref(typeReference("Error")))),
-                "Error": type(taggedUnion({
-                    "content": ref(typeReference("Compare Error"))
+                "Test": type(list(component(typeReference("Error")))),
+                "Error": type(stateGroup({
+                    "content": component(typeReference("Compare Error"))
                 })),
                 "Compare Error": type(group({
-                    "location": member(ref(typeReference("Source Location"))),
-                    "path": member(string()),
-                    "type": member(taggedUnion({
+                    "location": member(component(typeReference("Source Location"))),
+                    "path": member(text()),
+                    "type": member(stateGroup({
                         "wrong number": group({
-                            "found": member(number()),
+                            "found": member(integer()),
                         }),
                         "wrong text": group({
-                            "found": member(string()),
+                            "found": member(text()),
                         }),
                         "wrong boolean": group({
                             "found": member(boolean())
                         }),
-                        "optional value expected not to be set": null_(),
-                        "optional value expected to be set": null_(),
+                        "optional value expected not to be set": nothing(),
+                        "optional value expected to be set": nothing(),
                         "not the right state": group({
-                            "found": member(string())
+                            "found": member(text())
                         }),
-                        "not enough elements": null_(),
-                        "too many elements": null_(),
+                        "not enough elements": nothing(),
+                        "too many elements": nothing(),
                         "superfluous entries": group({
-                            "keys": member(dictionary(null_()))
+                            "keys": member(dictionary(nothing()))
                         }),
                         "missing dictionary entry": group({
-                            "key": member(string()),
+                            "key": member(text()),
                         }),
                     })),
 
                 })),
                 "Summary": type(group({
-                    "number of tests": member(number()),
-                    "number of missing tests": member(number()),
-                    "number of errors": member(number()),
+                    "number of tests": member(integer()),
+                    "number of missing tests": member(integer()),
+                    "number of errors": member(integer()),
                 })),
 
-                "String": type(string()),
+                "String": type(text()),
 
                 "intLibrary": type(group({
-                    "public": member(ref(typeReference("intModule Set"))),
-                    "private": member(ref(typeReference("intModule Set"))),
+                    "public": member(component(typeReference("intModule Set"))),
+                    "private": member(component(typeReference("intModule Set"))),
                 })),
-                "intModule Set": type(dictionary(ref(typeReference("intModule")))),
-                "intModule": type(dictionary(ref(typeReference("intAlgorithm")))),
+                "intModule Set": type(dictionary(component(typeReference("intModule")))),
+                "intModule": type(dictionary(component(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"))),
+                    "location": member(component(typeReference("Source Location"))),
+                    "status": member(stateGroup({
+                        "no tests": nothing(),
+                        "skipped": nothing(),
+                        "has tests": dictionary(component(typeReference("intTest"))),
                     })),
                 })),
-                "intTest": type(taggedUnion({
-                    "has errors": array(ref(typeReference("Error"))),
-                    "has no errors": null_(),
+                "intTest": type(stateGroup({
+                    "has errors": list(component(typeReference("Error"))),
+                    "has no errors": nothing(),
                 })),
-                "annotatedStatus": type(taggedUnion({
-                    "has errors": null_(),  // red
-                    "missing tests": null_(), // yellow
-                    "no tests": null_(), // grey
-                    "success": null_(), // green
+                "annotatedStatus": type(stateGroup({
+                    "has errors": nothing(),  // red
+                    "missing tests": nothing(), // yellow
+                    "no tests": nothing(), // grey
+                    "success": nothing(), // green
                 })),
                 "annotatedLibrary": type(group({
-                    "public": member(ref(typeReference("annotatedModule Set"))),
-                    "private": member(ref(typeReference("annotatedModule Set"))),
+                    "public": member(component(typeReference("annotatedModule Set"))),
+                    "private": member(component(typeReference("annotatedModule Set"))),
                 })),
                 "annotatedModule Set": type(group({
-                    "status": member(ref(typeReference("annotatedStatus"))),
-                    "modules": member(dictionary(ref(typeReference("annotatedModule")))),
+                    "status": member(component(typeReference("annotatedStatus"))),
+                    "modules": member(dictionary(component(typeReference("annotatedModule")))),
                 })),
                 "annotatedModule": type(group({
-                    "status": member(ref(typeReference("annotatedStatus"))),
-                    "algorithms": member(dictionary(ref(typeReference("annotatedAlgorithm")))),
+                    "status": member(component(typeReference("annotatedStatus"))),
+                    "algorithms": member(dictionary(component(typeReference("annotatedAlgorithm")))),
                 })),
                 "annotatedAlgorithm": type(group({
-                    "location": member(ref(typeReference("Source Location"))),
-                    "status": member(ref(typeReference("annotatedStatus"))),
-                    "tests": member(dictionary(ref(typeReference("annotatedTest")))),
+                    "location": member(component(typeReference("Source Location"))),
+                    "status": member(component(typeReference("annotatedStatus"))),
+                    "tests": member(dictionary(component(typeReference("annotatedTest")))),
                 })),
                 "annotatedTest": type(group({
-                    "status": member(ref(typeReference("annotatedStatus"))),
-                    "errors": member(array(ref(typeReference("Error")))),
+                    "status": member(component(typeReference("annotatedStatus"))),
+                    "errors": member(list(component(typeReference("Error")))),
                 })),
             }),
         },

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

@@ -24,6 +24,10 @@ export const $: g_project.D.Library = {
     'module sets': {
         'public': {
             'glossaries': d({}),
+            'transformations': {
+                'enrich': d({}),
+                'yield': d({}),
+            },
             'modules': d({
                 "array": d_array,
                 "boolean": d_boolean,
@@ -36,6 +40,10 @@ export const $: g_project.D.Library = {
         },
         'private': {
             'glossaries': d({}),
+            'transformations': {
+                'enrich': d({}),
+                'yield': d({}),
+            },
             'modules': d({}),
         }
     }

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

@@ -5,17 +5,16 @@ 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 glos } from "./glossary.data"
-import { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "flattenArrayOfArrays": algorithm("FlattenArrayOfArrays", null, {}),
-        "append": algorithm("Append", null, {}),
-        "prepend": algorithm("Prepend", null, {}),
-        "zip": algorithm("Zip", null, {}),
-        "flattenTree": algorithm("FlattenTree", null, {}),
-        "unsafeSortTopologically": algorithm("SortTopologically", null, {}),
+        "flattenArrayOfArrays": algorithm("FlattenArrayOfArrays", {}),
+        "append": algorithm("Append", {}),
+        "prepend": algorithm("Prepend", {}),
+        "zip": algorithm("Zip", {}),
+        "flattenTree": algorithm("FlattenTree", {}),
+        "unsafeSortTopologically": algorithm("SortTopologically", {}),
 
     }
 )

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

@@ -1,10 +1,24 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, data, dictionary, externalTypeReference, group, member, null_, number, optional, parametrizedType, ref, sfunction,
-    string,
-    taggedUnion,
-    type, typeParameter, typeReference
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    type,
+    typeParameter,
+    typeReference,
 } 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"
@@ -22,64 +36,64 @@ export const $: g_glossary.D.Glossary = {
                 //out
                 "Array": parametrizedType(
                     { "Type": null },
-                    array(ref(typeParameter("Type")))
+                    list(component(typeParameter("Type")))
                 ),
 
                 "ZippedArray": parametrizedType(
                     { "Benchmark": null, "Focus": null },
-                    array(group({
-                        "benchmark": member(ref(typeParameter("Benchmark"))),
-                        "focus": member(ref(typeParameter("Focus"))),
+                    list(group({
+                        "benchmark": member(component(typeParameter("Benchmark"))),
+                        "focus": member(component(typeParameter("Focus"))),
                     }))
                 ),
 
                 //in
                 "ArrayOfArrays": parametrizedType(
                     { "Type": null },
-                    array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+                    list(component(typeReference("Array", { "Type": typeParameter("Type") })))),
 
                 "AppendParameters": parametrizedType(
                     { "Type": null },
                     group({
-                        "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                        "element": member(ref(typeParameter("Type"))),
+                        "array": member(component(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": member(component(typeParameter("Type"))),
                     })
                 ),
                 "PrependParameters": parametrizedType(
                     { "Type": null },
                     group({
-                        "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                        "element": member(ref(typeParameter("Type"))),
+                        "array": member(component(typeReference("Array", { "Type": typeParameter("Type") }))),
+                        "element": member(component(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") }))),
+                        "benchmark": member(component(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
+                        "focus": member(component(typeReference("Array", { "Type": typeParameter("Focus") }))),
                     })
                 ),
-                "Nested": parametrizedType({ "Type": null }, taggedUnion({
-                    "single": ref(typeParameter("Type")),
-                    "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type") }))),
-                    "none": null_(),
+                "Nested": parametrizedType({ "Type": null }, stateGroup({
+                    "single": component(typeParameter("Type")),
+                    "multiple": list(component(typeReference("Nested", { "Type": typeParameter("Type") }))),
+                    "none": nothing(),
                 })),
-                // "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                // "Array": parametrizedType({ "Type": null }, list(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
                 // "KeyValuePair": parametrizedType({ "Type": null }, group({
-                //     "key": member(string()),
-                //     "value": member(ref(typeParameter("Type"))),
+                //     "key": member(text()),
+                //     "value": member(component(typeParameter("Type"))),
                 // })),
 
                 "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
-                    "value": member(ref(typeParameter("Type"))),
-                    "dependencies": member(dictionary(null_())),
+                    "value": member(component(typeParameter("Type"))),
+                    "dependencies": member(dictionary(nothing())),
                 }))),
 
 
-                "KeyValuePairArray": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "KeyValuePairArray": parametrizedType({ "Type": null }, list(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
                 "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": member(string()),
-                    "value": member(ref(typeParameter("Type"))),
+                    "key": member(text()),
+                    "value": member(component(typeParameter("Type"))),
                 })),
 
             }),

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

@@ -5,17 +5,16 @@ 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 glos } from "./glossary.data"
-import { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "array_and": algorithm("Array And", null, {}),
-        "array_or": algorithm("Array Or", null, {}),
-        "array_xor": algorithm("Array Xor", null, {}),
-        "and": algorithm("And", null, {}),
-        "or": algorithm("Or", null, {}),
-        "xor": algorithm("Xor", null, {}),
-        "not": algorithm("Not", null, {}),
+        "array_and": algorithm("Array And", {}),
+        "array_or": algorithm("Array Or", {}),
+        "array_xor": algorithm("Array Xor", {}),
+        "and": algorithm("And", {}),
+        "or": algorithm("Or", {}),
+        "xor": algorithm("Xor", {}),
+        "not": algorithm("Not", {}),
     }
 )

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

@@ -1,15 +1,23 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array,
     boolean,
+    component,
     data,
+    dictionary,
     externalTypeReference,
     group,
+    integer,
+    list,
     member,
-    number,
+    nothing,
+    optional,
+    parametrizedType,
     sfunction,
+    stateGroup,
+    text,
     type,
+    typeParameter,
     typeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
@@ -29,7 +37,7 @@ export const $: g_glossary.D.Glossary = {
                     "yin": member(boolean()),
                     "yang": member(boolean()),
                 })),
-                "Array Of Booleans": type(array(boolean())),
+                "Array Of Booleans": type(list(boolean())),
             }),
         },
     },

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

@@ -5,20 +5,18 @@ 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 glos } from "./glossary.data"
-import { glossary, group, member, number, sInterface, sInterfaceMethod, string, taggedUnion, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        // "buildArray": algorithm("BuildArray", null, {}),
-        // "buildUnsafeDictionary": algorithm("BuildUnsafeDictionary", null, {}),
+        // "buildArray": algorithm("BuildArray", {}),
+        // "buildUnsafeDictionary": algorithm("BuildUnsafeDictionary", {}),
         // "buildSafeDictionary": algorithm("BuildSafeDictionary", "DictionaryBuildStrategy", {}, {
         // }),
-        "createUnsafeDictionaryBuilder": algorithm("CreateUnsafeDictionaryBuilder", null, {}),
-        "createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", "DictionaryBuildStrategy", {}),
-        "createArrayBuilder": algorithm("CreateArrayBuilder", null, {}),
+        "createUnsafeDictionaryBuilder": algorithm("CreateUnsafeDictionaryBuilder", {}),
+        //"createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", {}),
+        "createArrayBuilder": algorithm("CreateArrayBuilder", {}),
 
-        "createStringBuilder": algorithm("CreateStringBuilder", "Startstring", {
-        }),
+        "createStringBuilder": algorithm("CreateStringBuilder", {}),
     }
 )