pareto 0.55.0 → 0.57.0

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

@@ -0,0 +1,17 @@
+
+
+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"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "library2ParetoComparators": algorithm("Library2ParetoComparators", null, {}),
+
+    }
+)

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

@@ -1,29 +1,21 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
-} from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, imp, member, null_, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
 
-import * as g_glossary from "lib-pareto-typescript-project/dist/modules/cosmos_type_system"
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
 
 import { $ as d_pareto } from "../../glossaries/auto.pareto.data"
 import { $ as d_cosmos } from "../../glossaries/auto.cosmos_type_system.data"
 
 const d = pd.d
 
-export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
-        "pareto": {
-            'glossary': d_pareto,
-            'type arguments': d({
-            }),
-        },
-        "cosmos": {
-            'glossary': d_cosmos,
-            'type arguments': d({
-            }),
-        },
+        "pareto": imp(d_pareto, {}),
+        "cosmos": imp(d_cosmos, {}),
     }),
     'root': {
         'namespaces': d({}),

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

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

@@ -0,0 +1,55 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, 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({
+            "Block": type(array(taggedUnion({
+                "nested line": ref(typeReference("Line")),
+                "line": string(),
+            }))),
+            "Line": type(array(taggedUnion({
+                "snippet": string(),
+                "indent": ref(typeReference("Block"))
+            }))),
+            "Lines": type(array(group({
+                "indentation": member(number()),
+                "text": member(string()),
+            }))),
+            "Indented Lines": type(array(string())),
+            "SerializeData": type(group({
+                "block": member(ref(typeReference("Block"))),
+                "indentation": member(string()),
+            })),
+            "IndentData": type(group({
+                "lines": member(ref(typeReference("Lines"))),
+                "indentation": member(string()),
+            })),
+            "String": type(string()),
+        }),
+    },
+    'interface types': d({
+        "Lines": aInterface(aInterfaceMethod(typeReference("Lines"))),
+        "Indented Lines": aInterface(streamconsumer(aInterfaceMethod(typeReference("String")), null)),
+    }),
+    'algorithm types': d({
+        "Indent": sfunction(typeReference("Indented Lines"), data(typeReference("IndentData"))),
+        "Serialize": sfunction(typeReference("Lines"), data(typeReference("Block"))),
+        "Stream": infInit(aInterfaceReference("Lines"), {
+            "handler": aInterfaceReference("Indented Lines")
+        }),
+    }),
+}

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

@@ -0,0 +1,24 @@
+
+
+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"
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        // "map": algorithm("Map", null, {
+        //     // "resolveDictionary": sfunction("resolve", {}, "SafeResolveDictionary"),
+        //     // // "decorateDictionaryEntriesWithKey": sfunction("foreach", {}, "DecorateDictionaryEntriesWithKey"),
+        //     // // "buildDictionary": sfunction("build", {}, "BuildUnsafeDictionary"),
+        //     // // "filter": sfunction("dictionary", {}, "Filter"),
+        //     // // "isEmpty": sfunction("dictionary", {}, "IsEmpty"),
+        //     // // "merge": sfunction("array", {}, "Merge"),
+        //     // // "push": sfunction("array", {}, "Push"),
+        // }),
+    }
+)

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

@@ -0,0 +1,48 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, number, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as d_liana } from "../../glossaries/auto.liana.data"
+import { $ as d_tendril } from "../../glossaries/auto.tendril.data"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+        "liana": {
+            'glossary': d_liana,
+            'type arguments': d({
+            }),
+        },
+        "tendril": {
+            'glossary': d_tendril,
+            'type arguments': d({
+            }),
+        },
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "TypeScript Location": type(group({
+                "file": member(string()),
+                "line": member(number()),
+                "column": member(number()),
+            }))
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Map": sfunction(
+            //FIXME this function should reference to the libraries that don't have annotations.
+            //this function is designed not to be able to produce runtime errors, so no error info is needed
+            //However, the functionality to produce a resolved, annotationless library need to be written
+            externalTypeReference("tendril", "Type Library", { "Annotation": typeReference("TypeScript Location") }),
+            data(externalTypeReference("liana", "Type Library", { "Annotation": typeReference("TypeScript Location") }))
+        ),
+    }),
+}

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

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

@@ -0,0 +1,73 @@
+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
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+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"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+        "cosmos": imp(d_cosmos, {}),
+        "tendril": imp(d_tendril, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "MapData": type(group({
+                "mapped library": member(ref(typeReference("Mapped Library"))),
+                "settings": member(ref(typeReference("Mapping Settings"))),
+            })),
+            "Mapped Library": type(group({
+                "library": member(ref(externalTypeReference("tendril", "Type Library", {}))),
+                "terminal mapping": member(ref(typeReference("Terminal Mapping"))),
+            })),
+
+            "Terminal Mapping": type(dictionary(taggedUnion({
+                "boolean": null_(),
+                "number": null_(),
+                "string": null_(),
+            }))),
+            "Mapping Settings": type(group({
+                "annotations": member(boolean()),
+                "datamodel": member(optional(group({
+                    "constraints mapping": member(group({
+                        "terminal values": member(boolean()),
+                        "constraints": member(optional(taggedUnion({
+                            "optional": group({}),
+                            "required": group({}),
+                        }))),
+                    })),
+                }))),
+                // "visitor interface": member(optional(group({
+                //     "datamodel": member(taggedUnion({
+                //         "internal": group({}),
+                //         "exernal": group({
+                //             "location": member(string()),
+                //         }),
+                //     })),
+                // }))),
+                // "algorithms": member(group({
+                //     "serialize": member(optional(group({
+                //         //data location,
+                //     }))),
+                //     //resolve
+                // })),
+            })),
+        }),
+    },
+    'interface types': d({
+    }),
+    'algorithm types': d({
+        "Map": sfunction(externalTypeReference("cosmos", "Glossary", {}), data(typeReference("MapData"))),
+
+    }),
+}

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

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

@@ -0,0 +1,33 @@
+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
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import { $ as d_pareto } from "../../glossaries/auto.pareto.data"
+import { $ as d_tendril } from "../../glossaries/auto.tendril_resolved.data"
+
+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({
+        "pareto": imp(d_pareto, {}),
+        "tendril": imp(d_tendril, {}),
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+
+        }),
+    },
+    'interface types': d({
+    }),
+    'algorithm types': d({
+        "CreateResolver": sfunction(externalTypeReference("pareto", "Compilation Unit", {}), data(externalTypeReference("tendril", "Type Library", {}))),
+    }),
+}

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

@@ -0,0 +1,26 @@
+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 d_glos } from "./glossary.data"
+
+
+export const $: g_project.D.API = api(
+    d_glos,
+    {
+        "annotateTestResult": algorithm("Annotate TestResult", null, {}),
+        "serializeSummary": algorithm("Serialize Summary", null, {
+            // "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, {
+            // "dictionaryForEach": libDep("pareto-standard-impure-library", "foreach", "DictionaryForEach", {}),
+        }),
+        "summarize": algorithm("Summarize", null, {}),
+
+    }
+)

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

@@ -0,0 +1,144 @@
+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/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({
+            "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()),
+            })),
+
+            "String": type(string()),
+
+            "intLibrary": type(group({
+                "public": member(ref(typeReference("intModule Set"))),
+                "private": member(ref(typeReference("intModule Set"))),
+            })),
+            "intModule Set": type(dictionary(ref(typeReference("intModule")))),
+            "intModule": type(dictionary(ref(typeReference("intAlgorithm")))),
+            "intAlgorithm": type(group({
+                "location": member(ref(typeReference("Source Location"))),
+                "status": member(taggedUnion({
+                    "no tests": null_(),
+                    "skipped": null_(),
+                    "has tests": dictionary(ref(typeReference("intTest"))),
+                })),
+            })),
+            "intTest": type(taggedUnion({
+                "has errors": array(ref(typeReference("Error"))),
+                "has no errors": null_(),
+            })),
+            "annotatedStatus": type(taggedUnion({
+                "has errors": null_(),  // red
+                "missing tests": null_(), // yellow
+                "no tests": null_(), // grey
+                "success": null_(), // green
+            })),
+            "annotatedLibrary": type(group({
+                "public": member(ref(typeReference("annotatedModule Set"))),
+                "private": member(ref(typeReference("annotatedModule Set"))),
+            })),
+            "annotatedModule Set": type(group({
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "modules": member(dictionary(ref(typeReference("annotatedModule")))),
+            })),
+            "annotatedModule": type(group({
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "algorithms": member(dictionary(ref(typeReference("annotatedAlgorithm")))),
+            })),
+            "annotatedAlgorithm": type(group({
+                "location": member(ref(typeReference("Source Location"))),
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "tests": member(dictionary(ref(typeReference("annotatedTest")))),
+            })),
+            "annotatedTest": type(group({
+                "status": member(ref(typeReference("annotatedStatus"))),
+                "errors": member(array(ref(typeReference("Error")))),
+            })),
+        }),
+    },
+    'interface types': d({
+        "Stringstream": sInterface(sInterfaceMethod(typeReference("String"))),
+
+    }),
+    'algorithm types': d({
+        "Annotate TestResult": sfunction(typeReference("annotatedLibrary"), data(typeReference("intLibrary"))),
+        "Summarize": sfunction(typeReference("Summary"), data(typeReference("intLibrary"))),
+        "Serialize Summary": procedure(data(typeReference("Summary")), sInterfaceReference("Stringstream")),
+        "Serialize TestResult": procedure(data(typeReference("annotatedLibrary")), sInterfaceReference("Stringstream")),
+    }),
+}

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

@@ -3,7 +3,7 @@ import * as pd from 'pareto-core-data'
 import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
 
 const d = pd.d
-import { } from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+import { } from "pareto/auto.dist/public/shorthands/cosmos"
 
 import { $ as d_arithmetic } from "./modules/arithmetic/api.data"
 import { $ as d_array } from "./modules/array/api.data"

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

@@ -1,11 +1,11 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+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 'lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands'
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
 
 export const $: g_project.D.API = api(
     glos,

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

@@ -3,7 +3,7 @@ import * as pd from 'pareto-core-data'
 import {
     array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
     type, typeReference
-} from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+} from "pareto/auto.dist/public/shorthands/cosmos"
 
 import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
 

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

@@ -1,11 +1,11 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+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 'lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands'
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
 
 export const $: g_project.D.API = api(
     glos,

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

@@ -3,7 +3,7 @@ import * as pd from 'pareto-core-data'
 import {
     array, data, dictionary, externalTypeReference, group, member, number, optional, parametrizedType, ref, sfunction,
     type, typeParameter, typeReference
-} from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+} from "pareto/auto.dist/public/shorthands/cosmos"
 
 import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
 

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

@@ -1,11 +1,11 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+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 'lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands'
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
 
 export const $: g_project.D.API = api(
     glos,

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

@@ -11,7 +11,7 @@ import {
     sfunction,
     type,
     typeReference,
-} from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+} from "pareto/auto.dist/public/shorthands/cosmos"
 
 import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
 const d = pd.d

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

@@ -1,11 +1,11 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+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, taggedUnion, type, typeReference } from 'lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands'
+import { glossary, group, member, number, sInterface, sInterfaceMethod, string, taggedUnion, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
 
 export const $: g_project.D.API = api(
     glos,

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

@@ -7,7 +7,7 @@ import {
     sfunction,
     sInterfaceMethod, sInterfaceReference, streamconsumer, string, taggedUnion, type, typeReference, aInterface, sInterface, parametrizedType,
     infInit
-} from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+} from "pareto/auto.dist/public/shorthands/cosmos"
 
 import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
 const d = pd.d

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

@@ -1,11 +1,11 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+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 'lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands'
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
 
 export const $: g_project.D.API = api(
     glos,