pareto 0.56.0 → 0.57.0

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-library/modules/dictionary/api.data.ts

@@ -0,0 +1,60 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { aInterface, aInterfaceMethod, glossary, group, member, number, sInterface, sInterfaceMethod, streamconsumer, string, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        /**
+         * does the dictionary contain the specified key
+         */
+        "contains": algorithm("Contains", null, {}),
+        /**
+         * is the dictionary empty (no entries)
+         */
+        "isEmpty": algorithm("IsEmpty", null, {}),
+        /**
+         * a dictionary where every entry contains optional data is transformed
+         * into a dictionary with only the entries that contained data
+         */
+        "filter": algorithm("Filter", null, {}),
+        /**
+         * a dictionary with containing entries with values and a key candidate is transformed
+         * into a dictionary where the new key of the entry is the candidate. If candidates are not unique
+         * the function panics
+         */
+        "unsafeRekey": algorithm("UnsafeRekey", null, {}),
+        /**
+         * 2 dictionaries are combined into 1 dictionary. If keys are not unique this function panics.
+         */
+        "unsafeMerge": algorithm("UnsafeMerge", null, {}),
+        /**
+         * a key/value pair is added to a dictionary resulting in a new dictionary.
+         * if the key is not unique the function panics
+         */
+        "unsafeAddEntry": algorithm("UnsafeAddEntry", null, {}),
+        /**
+         * a focus dictionary is matched to a benchmark dictionary resulting in a result dictionary
+         * this last dictionary contains all entries found in the benchmark dictionary.
+         * each entry value is optionally supplemented with the value of the focus entry, if found.
+         */
+        "matchDictionaries": algorithm("MatchDictionaries", null, {}),
+        /**
+         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the last dictionary will be used.
+         */
+        "mergeAndOverwrite": algorithm("MergeAndOverwrite", null, {}),
+        /**
+         * the keys of the outermost dictionary is combined with the key of the innermost dictionary
+         */
+        "flattenDictionaryOfDictionaries": algorithm("FlattenDictionaryOfDictionaries", null, {}),
+        /**
+         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the first dictionary will be used.
+         */
+        "mergeAndIgnore": algorithm("MergeAndIgnore", null, {}),
+    }
+)

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

@@ -0,0 +1,130 @@
+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,
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Boolean": type(boolean()),
+            "String": type(string()),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+            "DictionaryAndKey": parametrizedType({ "Type": null }, group({
+                "dictionary": member(dictionary(ref(typeParameter("Type")))),
+                "key": member(string()),
+            })),
+            "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(ref(typeParameter("Type"))))),
+            "MergeParameters": parametrizedType({ "Type": null }, group({
+                "primary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                "secondary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+            })),
+            "MatchedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
+                "benchmark": member(ref(typeParameter("Benchmark"))),
+                "focus": member(optional(ref(typeParameter("Focus")))),
+            }))),
+
+            "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
+                "benchmark": member(ref(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
+                "focus": member(ref(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
+            })),
+            "FlattenDictionaryOfDictionariesParameters": parametrizedType({ "Type": null }, group({
+                "dictionaries": member(dictionary(ref(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
+                "separator": member(string()),
+                "escape": member(string()),// to escape if the separator appears in the key of the top level dictionary
+            })),
+            "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
+                "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                "keyValuePair": member(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
+            })),
+
+
+            "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+
+        }),
+    },
+    'interface types': d({
+    }),
+    'algorithm types': d({
+        "Contains": sfunction(
+            typeReference("Boolean"),
+            data(typeReference("DictionaryAndKey", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "IsEmpty": sfunction(
+            typeReference("Boolean"),
+            data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "Filter": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("FilterableDictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "UnsafeRekey": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("RekeyDictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "UnsafeMerge": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "UnsafeAddEntry": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("UnsafeAddEntryParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "MergeAndIgnore": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "MatchDictionaries": sfunction(
+            typeReference("MatchedDictionary", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") }),
+            data(typeReference("DictionaryTuple", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") })),
+            { "Benchmark": null, "Focus": null }
+        ),
+        "FlattenDictionaryOfDictionaries": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("FlattenDictionaryOfDictionariesParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "MergeAndOverwrite": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+    }),
+
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-library/modules/filesystem/api.data.ts

@@ -0,0 +1,19 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "createFileWriter": algorithm("CreateFileWriter", null, {}),
+        //"openFileStream": algorithm(functionReference("this", {}, "GetFile"), null, {}),
+        "makeDirectory": algorithm("MakeDirectory", null, {}),
+        "readDirectory": algorithm("ReadDirectory", null, {}),
+        "unlink": algorithm("Unlink", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-library/modules/filesystem/glossary.data.ts

@@ -0,0 +1,189 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    infInit,
+    afunction, aInterfaceMethod, aInterfaceReference, boolean, data, dictionary, externalTypeReference, group,
+    member, null_, parametrizedType, ref, streamconsumer, string, taggedUnion, type, typeParameter, typeReference, aInterface,
+    array
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Null": type(null_()),
+            "String": type(string()),
+            "Path": type(array(string())),
+            "AnnotatedError": parametrizedType({ "Error": null }, group({
+                "path": member(ref(typeReference("String"))),
+                "error": member(ref(typeParameter("Error"))),
+            })),
+            "Result": parametrizedType({
+                "Error": null,
+                "Success": null,
+            }, taggedUnion({
+                "error": ref(typeParameter("Error")),
+                "success": ref(typeParameter("Success")),
+            })),
+            "AnnotatedReadDirError": type(ref(typeReference("AnnotatedError", {
+                "Error": typeReference("ReadDirError"),
+            }))),
+            "AnnotatedReadFileError": type(ref(typeReference("AnnotatedError", {
+                "Error": typeReference("ReadFileError"),
+            }))),
+            "AnnotatedRmdirError": type(ref(typeReference("AnnotatedError", {
+                "Error": typeReference("RmdirError"),
+            }))),
+            "AnnotatedMkdirError": type(ref(typeReference("AnnotatedError", {
+                "Error": typeReference("MkdirError"),
+            }))),
+            "AnnotatedUnlinkError": type(ref(typeReference("AnnotatedError", {
+                "Error": typeReference("UnlinkError"),
+            }))),
+            "AnnotatedWriteFileError": type(ref(typeReference("AnnotatedError", {
+                "Error": typeReference("WriteFileError"),
+            }))),
+            "WriteFileParameters": type(group({
+                "path": member(ref(typeReference("Path"))),
+                "overwrite if exists": member(boolean()),
+                "create containing directories": member(boolean()),
+            })),
+            // "AnnotatedReadFileError": group({
+            //     "path": member(str()),
+            //     "error": member(taggedUnion({
+            //         "no entity": null_(),
+            //         "is directory": null_(),
+            //         "unknown": type(group({
+            //             "message": member(str()),
+            //         })),
+            //     })),
+            // }),
+            "DirNodeData": type(group({
+                "path": member(string()),
+                "type": member(taggedUnion({
+                    "directory": null_(),
+                    "file": null_(),
+                    "unknown": null_(),
+                })),
+            })),
+            "MkdirError": type(taggedUnion({
+                "no entity": null_(),
+                "exists": null_(),
+                "unknown": group({
+                    "message": member(string()),
+                }),
+            })),
+            "Mkdir_Data": type(group({
+                "path": member(ref(typeReference("Path"))),
+                "createContainingDirectories": member(boolean()),
+            })),
+            "Mkdir_Result": type(ref(typeReference("Result", {
+                "Error": typeReference("AnnotatedMkdirError"),
+                "Success": typeReference("Null"),
+            }))),
+            "ReadDirectory_Data": type(group({
+                "path": member(ref(typeReference("Path"))),
+            })),
+            "ReadDirectory_Success": type(dictionary(ref(typeReference("DirNodeData")))),
+            "ReadDirectory_Result": type(ref(typeReference("Result", {
+                "Error": typeReference("AnnotatedReadDirError"),
+                "Success": typeReference("ReadDirectory_Success"),
+            }))),
+            "ReadDirError": type(taggedUnion({
+                "no entity": null_(),
+                "is not directory": null_(),
+                "unknown": group({
+                    "message": member(string()),
+                }),
+            })),
+            "ReadFile_Result": type(ref(typeReference("Result", {
+                "Error": typeReference("AnnotatedReadFileError"),
+                "Success": typeReference("String"),
+            }))),
+
+            "ReadFile_Data": type(group({
+                "path": member(ref(typeReference("Path"))),
+            })),
+            "ReadFileError": type(taggedUnion({
+                "no entity": null_(),
+                "is directory": null_(),
+                "unknown": group({
+                    "message": member(string()),
+                }),
+            })),
+            "RmdirError": type(taggedUnion({
+                "no entity": null_(),
+                "not empty": null_(),
+                "unknown": group({
+                    "message": member(string()),
+                }),
+            })),
+            "UnlinkError": type(taggedUnion({
+                "no entity": null_(),
+                "is directory": null_(),
+                "unknown": group({
+                    "message": member(string()),
+                }),
+            })),
+            "Unlink_Data": type(group({
+                "path": member(ref(typeReference("Path"))),
+            })),
+            "Unlink_Result": type(ref(typeReference("Result", {
+                "Error": typeReference("AnnotatedUnlinkError"),
+                "Success": typeReference("Null"),
+            }))),
+
+            // "WriteFile_Result": type(ref(typeReference("Result", {
+            //     "Error": typeReference("AnnotatedWriteFileError"),
+            //     "Success": typeReference("common", "Null"),
+            // })),
+
+            "WriteFileError": type(taggedUnion({
+                "no entity": null_(),
+                "is directory": null_(),
+                "unknown": group({
+                    "message": member(string()),
+                }),
+            })),
+        }),
+    },
+    'interface types': d({
+        //these should be defined somewhere but is this the place
+        // "HandleReadDirError": interfaceMethod(typeReference("AnnotatedReadDirFileError"), null, null, null),
+        // "HandleReadFileError": interfaceMethod(typeReference("AnnotatedReadFileError"), null, null, null),
+        // "HandleMkdirError": interfaceMethod(typeReference("AnnotatedMkdirError"), null, null, null),
+        // "HandleUnlinkError": interfaceMethod(typeReference("AnnotatedUnlinkError"), null, null, null),
+
+
+        "OnFileWriteError": aInterface(aInterfaceMethod(typeReference("AnnotatedWriteFileError"))),
+
+
+        // "Reader": ['group', {
+        //     'members': d({
+        //         "init": builderMethod(null, ['reference', builderReference("StreamConsumer")]),
+        //         "onError": builderMethod(typeReference("AnnotatedReadFileError")),
+        //     }),
+        // }]
+        "StringStreamConsumer": aInterface(streamconsumer(
+            aInterfaceMethod(typeReference("String")),
+            aInterfaceMethod(null),
+        )),
+        "WriteFile": aInterface(aInterfaceMethod(typeReference("WriteFileParameters"), ['reference', aInterfaceReference("StringStreamConsumer")])),
+    }),
+    'algorithm types': d({
+        "CreateFileWriter": infInit(aInterfaceReference("WriteFile"), {
+            "onWriteFileError": aInterfaceReference("OnFileWriteError"),
+        }),
+        "MakeDirectory": afunction(typeReference("Mkdir_Result"), typeReference("Mkdir_Data")),
+        "ReadDirectory": afunction(typeReference("ReadDirectory_Result"), typeReference("ReadDirectory_Data")),
+        "Unlink": afunction(typeReference("Unlink_Result"), typeReference("Unlink_Data")),
+        //"OpenFIleStream": afunc(typeReference("common", "Path"), null, null, inf(interfaceReference("Reader"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-library/modules/foreach/api.data.ts

@@ -0,0 +1,25 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, sibling, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+// import { $ as g_collation } from "../collation/glossary.data"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "arrayForEach": algorithm("ArrayForEach", null, {}),
+        "dictionaryForEach": algorithm("DictionaryForEach", null, {
+            //FIXME "compare": sibling("collation", "IsABeforeB"),
+        }),
+        "enrichedArrayForEach": algorithm("EnrichedArrayForEach", null, {}),
+        "enrichedDictionaryForEach": algorithm("EnrichedDictionaryForEach", null, {
+            //FIXME "compare": sibling("collation", "IsABeforeB"),
+        }),
+        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-library/modules/foreach/glossary.data.ts

@@ -0,0 +1,78 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    string,
+    dictionary, member, group,
+    array,
+    typeReference,
+    boolean,
+    ref,
+    sInterfaceMethod,
+    sfunction,
+    data,
+    procedure,
+    sInterfaceReference,
+    parametrizedType,
+    typeParameter,
+    sInterface,
+    optional,
+
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({}),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+            "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+            "AnnotatedEntry": parametrizedType({ "Type": null }, group({
+                "isFirst": member(boolean()),
+                "isLast": member(boolean()),
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+            "AnnotatedElement": parametrizedType({ "Type": null }, group({
+                "isFirst": member(boolean()),
+                "isLast": member(boolean()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+
+
+        }),
+    },
+    'interface types': d({
+        "OnElement": sInterface(sInterfaceMethod(typeParameter("Type")), { "Type": null }),
+        "OnEntry": sInterface(sInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })), { "Type": null }),
+        "OnEnrichedDictionary": sInterface(['group', {
+            'members': d({
+                "onEmpty": sInterfaceMethod(null),
+                "onNotEmpty": sInterfaceMethod(null, sInterfaceMethod(typeReference("AnnotatedEntry", { "Type": typeParameter("Type") }))),
+            }),
+        }], { "Type": null }),
+        "OnEnrichedArray": sInterface(['group', {
+            'members': d({
+                "onEmpty": sInterfaceMethod(null),
+                "onNotEmpty": sInterfaceMethod(null, sInterfaceMethod(typeReference("AnnotatedElement", { "Type": typeParameter("Type") }))),
+            }),
+        }], { "Type": null }),
+    }),
+    'algorithm types': d({
+        "ArrayForEach": procedure(data(typeReference("Array", { "Type": typeParameter("Type") })), sInterfaceReference("OnElement", { "Type": typeParameter("Type") }), { "Type": null }),
+        "DictionaryForEach": procedure(data(typeReference("Dictionary", { "Type": typeParameter("Type") })), sInterfaceReference("OnEntry", { "Type": typeParameter("Type") }), { "Type": null }),
+        "EnrichedDictionaryForEach": procedure(data(typeReference("Dictionary", { "Type": typeParameter("Type") })), sInterfaceReference("OnEnrichedDictionary", { "Type": typeParameter("Type") }), { "Type": null }),
+        "EnrichedArrayForEach": procedure(data(typeReference("Array", { "Type": typeParameter("Type") })), sInterfaceReference("OnEnrichedArray", { "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-pure/auto.dependencies/pareto-standard-impure-library/modules/http/api.data.ts

@@ -0,0 +1,16 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { array, glossary, group, member, number, ref, string, taggedUnion, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "initializeHTTPServerProxy": algorithm("Initialize HTTP Server Proxy", "Configuration", {}),
+        "initializeHTTPSServerProxy": algorithm("Initialize HTTP Server Proxy", "Configuration", {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-library/modules/http/glossary.data.ts

@@ -0,0 +1,69 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface, aInterfaceMethod, aInterfaceReference, array, boolean,
+    group, member, ref, resource, streamconsumer, string, taggedUnion, type, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Path": type(array(string())),
+            "EncounteredErrors": type(boolean()),
+            "Data": type(taggedUnion({
+                "error": ref(typeReference("HTTPError")),
+                "data": string()
+            })),
+            "HTTPError": type(taggedUnion({
+                "unknown": string(),
+            })),
+
+
+            "Configuration": type(group({
+                "hostName": member(string()),
+                "contextPath": member(ref(typeReference("Path"))),
+            })),
+        }),
+    },
+    'interface types': d({
+
+        //"HandleError": interfaceMethod(typeReference("HTTPError")),
+        // "ProcessHTTPResource": func(typeReference("common", "Path"), null, builderReference("Init"), null),
+        //"Init": aInterface(aInterfaceMethod(null, ['reference', aInterfaceReference("StreamConsumer")])),
+        // "Init": ['choice', {
+        //     'options': d({
+        //         "success": ['reference', aInterfaceReference("StreamConsumer")],
+        //         "error": ['reference', aInterfaceReference("ErrorStreamConsumer")],
+        //     })
+        // }],
+        // "Init": builderMethod(null, ['reference', {
+        //     'context': ['local', null],
+        //     'interface': "StreamConsumer"
+        // }], false),
+        // "StreamConsumer": aInterface(streamconsumer(
+        //     aInterfaceMethod(externalTypeReference("common", "String")),
+        //     aInterfaceMethod(typeReference("EncounteredErrors")),
+        // )),
+        "Consumer": aInterface(streamconsumer(
+            aInterfaceMethod(typeReference("Data")),
+            aInterfaceMethod(null),
+        )),
+    }),
+    'algorithm types': d({
+        "Initialize HTTP Server Proxy": resource(typeReference("Path"), aInterfaceReference("Consumer")),
+        // "HTTPRequest": a(, {
+        //     "init": aInterfaceReference("Init"),
+        //     "errorConsumer": aInterfaceReference("ErrorStreamConsumer")
+        // })
+
+    }),
+
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-library/modules/json/api.data.ts

@@ -0,0 +1,16 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, sInterface, sInterfaceMethod, string, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "convertJSON": algorithm("ConvertJSON", null, {}),
+        "unsafeConvertJSON": algorithm("UnsafeConvertJSON", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-library/modules/json/glossary.data.ts

@@ -0,0 +1,51 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, afunction, boolean, computed, data, dictionary,
+    glossaryParameter, group, member, number, optional, ref, sfunction, string, type, typeReference,
+    taggedUnion,
+    null_,
+    sInterface,
+    sInterfaceMethod
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({
+    }),
+    'imports': d({}),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "String": type(string()),
+            "Result": type(taggedUnion({
+                "success": ref(typeReference("JSONValue")),
+                "error": string(),
+            })),
+            //"Result": type(ref(glossaryParameter("Type"))),
+            "JSONValue": type(taggedUnion({
+                "object": dictionary(ref(typeReference("JSONValue"))),
+                "array": array(ref(typeReference("JSONValue"))),
+                "string": string(),
+                "number": number(),
+                "boolean": boolean(),
+                "null": null_(),
+            })),
+
+
+        }),
+    },
+    'interface types': d({
+
+    }),
+    'algorithm types': d({
+        "ConvertJSON": sfunction(typeReference("Result"), data(typeReference("String"))),
+
+        /*use this one if the application may crash if the JSON is invalid*/
+        "UnsafeConvertJSON": sfunction(typeReference("JSONValue"), data(typeReference("String"))),
+        //"Convert": sfunction(typeReference("Result"), data(typeReference("JSONValue"))),
+    }),
+}