pareto 0.57.0 → 0.59.0

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/testresult.data.ts

@@ -0,0 +1,137 @@
+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
+} 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({
+            // "intermediate": {
+            //     'namespaces': d({
+
+            //     }),
+            //     '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()),
+            })),
+
+            "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"))),
+                })),
+            })),
+            "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({
+
+    }),
+    'algorithm types': d({
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/typescript_intermediate.data.ts

@@ -0,0 +1,68 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, 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"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Block": type(array(taggedUnion({
+                "nested line": ref(typeReference("Line")),
+                "line": string(),
+
+                //specials
+
+                /**
+                 * this one can be used to transform a dictionary into an array of blocks. The order is not controllable.
+                 */
+                "block dictionary": dictionary(ref(typeReference("Block"))),
+            }))),
+            "Line": type(array(taggedUnion({
+                "snippet": string(),
+                "indent": ref(typeReference("Block")),
+
+                //specials
+                "apostrophed string": string(),
+                "quoted string": string(),
+                "backticked string": string(),
+                "identifier": string(),
+                // /**
+                //  * this one is necessary because TypeScript does not allow trailing commas in certain places.
+                //  * for example in type arguments.
+                //  */
+                // "array without trailing commas": array(ref(typeReference("Line"))),
+                /**
+                 * this one can be used to transform a dictionary into an array of line parts. The order is not controllable.
+                 * typescript sometimes handles empty dictoinaries in impure ways and sometimes doesn't accept a trailing comma.
+                 */
+                "line dictionary": group({
+                    "dictionary": member(dictionary(ref(typeReference("Line")))),
+                    "if empty": member(ref(typeReference("Line"))),
+                    "if not empty": member(group({
+                        "prefix": member(ref(typeReference("Line"))),
+                        "suffix": member(ref(typeReference("Line"))),
+                        "add commas in between": member(boolean()),
+                    })),
+                }),
+            }))),
+            "Lines": type(array(group({
+                "indentation": member(number()),
+                "text": member(string()),
+            }))),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+    }),
+}

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

@@ -0,0 +1,20 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, 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 { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        /**
+         * use this function to serialize to an intermediate format.
+         * Serialization to this format can be done in a pure way.
+         * serialization from this format to an array of strings is not pure, specifically for 1 reason so far: apostrophed strings.
+         */
+        "map": algorithm("Map", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/modules/alan_light_2_alan_light_intermediate/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_alan_light } from "../../glossaries/auto.alan_light.data"
+import { $ as d_alan_light_intermediate } from "../../glossaries/alan_light_intermediate.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({
+        "alan light": imp(d_alan_light, {}),
+        "alan light intermediate": imp(d_alan_light_intermediate, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("alan light intermediate", "Block"), data(externalTypeReference("alan light", "Root"))),
+    }),
+
+}

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

@@ -0,0 +1,15 @@
+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 { glossary, group, member, number, sInterface, sInterfaceMethod, string, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "serialize": algorithm("Serialize", null, {}),
+    }
+)

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

@@ -0,0 +1,39 @@
+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,
+    imp,
+    externalTypeReference
+} 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_astn } from "../../glossaries/astn.data"
+import { $ as d_fp } from "../../glossaries/fountain_pen.data"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({
+    }),
+    'imports': d({
+        "astn": imp(d_astn, {}),
+        "fountain pen": imp(d_fp, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+        }),
+    },
+    'interface types': d({
+
+    }),
+    'algorithm types': d({
+        "Serialize": sfunction(externalTypeReference("fountain pen", "Block"), data(externalTypeReference("astn", "Value"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos2pareto → cosmos_type_system_2_pareto}/api.data.ts

@@ -2,9 +2,9 @@
 
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as glos } from "./glossary.data"
 

package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos2pareto → cosmos_type_system_2_pareto}/glossary.data.ts

@@ -2,9 +2,9 @@ import * as pd from 'pareto-core-data'
 
 import {
     array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, member, null_, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
-} from "pareto/auto.dist/public/shorthands/cosmos"
+} from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as d_pareto } from "../../glossaries/auto.pareto.data"
 import { $ as d_cosmos } from "../../glossaries/auto.cosmos_type_system.data"

package/auto.pareto/auto.dependencies/pareto-pure/modules/fountain_pen_2_fountain_pen/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"
+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,
+    {
+        "serialize": algorithm("Serialize", null, {}),
+    }
+)

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

@@ -0,0 +1,34 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, 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"
+const d = pd.d
+
+import { $ as d_fountain_pen } from "../../glossaries/fountain_pen.data"
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+        "fp": imp(d_fountain_pen, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "SerializeData": type(group({
+                "block": member(ref(externalTypeReference("fp", "Block"))),
+            })),
+            "String": type(string()),
+        }),
+    },
+    'interface types': d({    }),
+    'algorithm types': d({
+        "Serialize": sfunction(externalTypeReference("fp", "Lines"), data(externalTypeReference("fp", "Block"))),
+
+    }),
+}

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

@@ -0,0 +1,18 @@
+
+
+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 { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "indent": algorithm("Indent", null, {}),
+        "stream": algorithm("Stream", null, {}),
+    }
+)

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

@@ -0,0 +1,42 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, 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"
+const d = pd.d
+
+import { $ as d_fountain_pen } from "../../glossaries/fountain_pen.data"
+import { $ as d_lines } from "../../glossaries/lines.data"
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+        "fp": imp(d_fountain_pen, {}),
+        "lines": imp(d_lines, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "IndentData": type(group({
+                "lines": member(ref(externalTypeReference("fp", "Lines"))),
+                "indentation": member(string()),
+            })),
+            "String": type(string()),
+        }),
+    },
+    'interface types': d({
+        "Lines": aInterface(aInterfaceMethod(externalTypeReference("fp", "Lines"))),
+        "Indented Lines": aInterface(streamconsumer(aInterfaceMethod(typeReference("String")), null)),
+    }),
+    'algorithm types': d({
+        "Indent": sfunction(externalTypeReference("lines", "Lines"), data(typeReference("IndentData"))),
+        "Stream": infInit(aInterfaceReference("Lines"), {
+            "handler": aInterfaceReference("Indented Lines")
+        }),
+    }),
+}

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_pareto } from "../../glossaries/auto.pareto.data"
+import { $ as d_typescript_intermediate } from "../../glossaries/typescript_intermediate.data"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'imports': d({
+        "pareto": imp(d_pareto, {}),
+        "typescript intermediate": imp(d_typescript_intermediate, {}),
+    }),
+
+    'glossary parameters': d({}),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Map Data": type(group({
+                "compilation unit": member(ref(externalTypeReference("pareto", "Compilation Unit", {}))),
+            })),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("typescript intermediate", "Block"), data(typeReference("Map Data"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril_2_alan_light/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"
+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/tendril_2_alan_light/glossary.data.ts

@@ -0,0 +1,49 @@
+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_tendril } from "../../glossaries/auto.tendril_resolved.data"
+import { $ as d_alan_light } 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, {}),
+    }),
+    'glossary parameters': d({}),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("alan light", "Root"), data(externalTypeReference("tendril", "Model"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril_2_cosmos_type_system/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"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "map": algorithm("Map", null, {})
+    }
+)

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

@@ -5,12 +5,12 @@ import {
     aInterfaceMethod,
     aInterfaceReference,
     array, boolean, data, dictionary, externalTypeReference, glossaryParameter, group, imp, infInit, member, null_, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
-} from "pareto/auto.dist/public/shorthands/cosmos"
+} 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 g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+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 = {

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, {}),
+    }
+)