pareto 0.63.0 → 0.65.0

package/auto.pareto/auto.dependencies/pareto-subatomic-library/glossaries/lines.data.ts

@@ -4,26 +4,21 @@ import {
     aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-    array, data, dictionary, externalTypeReference, glossaryParameter, group, infInit, member, null_, number, parametrizedType, ref, sfunction, streamconsumer, string, taggedUnion, type, typeParameter, typeReference
+    list, data, dictionary, externalTypeReference, glossaryParameter, group, infInit, member,
+     parametrizedType, sfunction, streamconsumer, 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"
 const d = pd.d
 
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
+export const $: g_glossary.D.Data__Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Lines": type(list(text())),
         }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Lines": type(array(string())),
-            }),
-        },
     },
-    'interface types': d({
-    }),
-    'algorithm types': d({
-    }),
 }

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

@@ -1,23 +1,23 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+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"
+import { glossary, group, member, integer, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "enrichWithPositionInformation": algorithm("EnrichWithPositionInformation", null, {}),
-        "getPossibleLastElement": algorithm("GetPossibleLastElement", null, {}),
-        "getPossibleFirstElement": algorithm("GetPossibleFirstElement", null, {}),
-        "getPossibleElementAt": algorithm("GetPossibleElementAt", null, {}),
-        "isEmpty": algorithm("IsEmpty", null, {}),
-        "unsafeGetLastElement": algorithm("UnsafeGetLastElement", null, {}),
-        "unsafeGetFirstElement": algorithm("UnsafeGetFirstElement", null, {}),
-        "unsafeGetElementAt": algorithm("UnsafeGetElementAt", null, {}),
-        "getLength": algorithm("GetLength", null, {}),
+        "enrichWithPositionInformation": algorithm("EnrichWithPositionInformation", {}),
+        "getPossibleLastElement": algorithm("GetPossibleLastElement", {}),
+        "getPossibleFirstElement": algorithm("GetPossibleFirstElement", {}),
+        "getPossibleElementAt": algorithm("GetPossibleElementAt", {}),
+        "isEmpty": algorithm("IsEmpty", {}),
+        "unsafeGetLastElement": algorithm("UnsafeGetLastElement", {}),
+        "unsafeGetFirstElement": algorithm("UnsafeGetFirstElement", {}),
+        "unsafeGetElementAt": algorithm("UnsafeGetElementAt", {}),
+        "getLength": algorithm("GetLength", {}),
     }
 )

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

@@ -1,8 +1,8 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, boolean,
-    data, dictionary, externalTypeReference, group, member, number, optional, parametrizedType, ref, sfunction,
+    list, boolean,
+    data, dictionary, externalTypeReference, group, member, integer, optional, parametrizedType, component, sfunction,
     type, typeParameter, typeReference
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
@@ -18,21 +18,21 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+                "Array": parametrizedType({ "Type": null }, list(component(typeParameter("Type")))),
                 "Boolean": type(boolean()),
-                "EnrichedArray": parametrizedType({ "Type": null }, array(group({
-                    "value": member(ref(typeParameter("Type"))),
+                "EnrichedArray": parametrizedType({ "Type": null }, list(group({
+                    "value": member(component(typeParameter("Type"))),
                     "isFirst": member(boolean()),
                     "isLast": member(boolean()),
-                    "position": member(number()),
+                    "position": member(integer()),
                 }))),
                 "GetElementAtData": parametrizedType({ "Type": null }, group({
-                    "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
-                    "index": member(number()),
+                    "array": member(component(typeReference("Array", { "Type": typeParameter("Type") }))),
+                    "index": member(integer()),
                 })),
-                "Length": type(number()),
-                "OptionalValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
-                "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
+                "Length": type(integer()),
+                "OptionalValue": parametrizedType({ "Type": null }, optional(component(typeParameter("Type")))),
+                "Value": parametrizedType({ "Type": null }, component(typeParameter("Type"))),
 
 
             }),

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/dictionary/api.data.ts

@@ -1,11 +1,11 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+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 { aInterface, aInterfaceMethod, glossary, group, member, number, sInterface, sInterfaceMethod, streamconsumer, string, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { aInterface, aInterfaceMethod, glossary, group, member, integer, sInterface, sInterfaceMethod, streamconsumer, text, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
@@ -13,15 +13,15 @@ export const $: g_project.D.API = api(
         /**
          * does the dictionary contain the specified key
          */
-        "contains": algorithm("Contains", null, {}),
-        "getPossibleEntry": algorithm("GetPossibleEntry", null, {}),
+        "contains": algorithm("Contains", {}),
+        "getPossibleEntry": algorithm("GetPossibleEntry", {}),
         /**
          * is the dictionary empty (no entries)
          */
-        "isEmpty": algorithm("IsEmpty", null, {}),
+        "isEmpty": algorithm("IsEmpty", {}),
 
-        "size": algorithm("Size", null, {}),
+        "size": algorithm("Size", {}),
 
-        "unsafeGetEntry": algorithm("UnsafeGetEntry", null, {}),
+        "unsafeGetEntry": algorithm("UnsafeGetEntry", {}),
     }
 )

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

@@ -5,22 +5,22 @@ import {
     typeReference,
     data,
     sfunction,
-    ref,
     typeParameter,
     externalTypeReference,
     parametrizedType,
     optional,
     group,
+    component,
     member,
     aInterface,
     streamconsumer,
     aInterfaceMethod,
     type,
-    string,
     boolean,
     sInterface,
     sInterfaceMethod,
-    number,
+    integer,
+    text,
 } 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"
@@ -35,15 +35,15 @@ export const $: g_glossary.D.Glossary = {
             'namespaces': d({}),
             'data types': d({
                 "Boolean": type(boolean()),
-                "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+                "Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
                 "DictionaryAndKey": parametrizedType({ "Type": null }, group({
-                    "dictionary": member(dictionary(ref(typeParameter("Type")))),
-                    "key": member(string()),
+                    "dictionary": member(dictionary(component(typeParameter("Type")))),
+                    "key": member(text()),
                 })),
 
-                "Number": type(number()),
-                "PossibleValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
-                "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
+                "Number": type(integer()),
+                "PossibleValue": parametrizedType({ "Type": null }, optional(component(typeParameter("Type")))),
+                "Value": parametrizedType({ "Type": null }, component(typeParameter("Type"))),
 
             }),
         },

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/filesystem/api.data.ts

@@ -5,11 +5,11 @@ import { algorithm, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_t
 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"
+import { glossary, group, member, integer, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "createFileWriter": algorithm("CreateFileWriter", null, {}),
+        "createFileWriter": algorithm("CreateFileWriter", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/filesystem/glossary.data.ts

@@ -7,17 +7,17 @@ import {
     group,
     typeReference,
     member,
-    string,
+    text,
     dictionary,
-    null_,
-    array,
+    nothing,
+    list,
     imp,
     externalTypeReference,
     infInit,
     aInterfaceReference,
     aInterface,
     aInterfaceMethod,
-    ref,
+    component,
     infref,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
@@ -35,14 +35,14 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "File Path": type(array(string())),
+                "File Path": type(list(text())),
                 "File Write Data": type(group({
-                    "directory path": member(ref(typeReference("File Path"))),
-                    "file name": member(string()),
-                    "data": member(ref(externalTypeReference("lines", "Lines"))),
+                    "directory path": member(component(typeReference("File Path"))),
+                    "file name": member(text()),
+                    "data": member(component(externalTypeReference("lines", "Lines"))),
                 })),
                 "Root Data": type(group({
-                    "context directory": member(string()),
+                    "context directory": member(text()),
                 })),
             }),
         },

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/json/api.data.ts

@@ -1,22 +1,22 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+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, sInterface, sInterfaceMethod, string, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+import { glossary, group, member, integer, sInterface, sInterfaceMethod, text, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "parse": algorithm("Parse", null, {}),
+        "parse": algorithm("Parse", {}),
 
         /**
          * this one is impure because it uses needs to inspect strings to escape them properly
          */
-        "serialize": algorithm("Serialize", null, {}),
+        "serialize": algorithm("Serialize", {}),
 
-        "unsafeParse": algorithm("UnsafeParse", null, {}),
+        "unsafeParse": algorithm("UnsafeParse", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/json/glossary.data.ts

@@ -1,10 +1,10 @@
 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_,
+    list, afunction, boolean, data, dictionary,
+    glossaryParameter, group, member, integer, optional, component, sfunction, text, type, typeReference,
+    stateGroup,
+    nothing,
     sInterface,
     sInterfaceMethod
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
@@ -22,19 +22,19 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "String": type(string()),
-                "Result": type(taggedUnion({
-                    "success": ref(typeReference("Value")),
-                    "error": string(),
+                "String": type(text()),
+                "Result": type(stateGroup({
+                    "success": component(typeReference("Value")),
+                    "error": text(),
                 })),
-                //"Result": type(ref(glossaryParameter("Type"))),
-                "Value": type(taggedUnion({
-                    "object": dictionary(ref(typeReference("Value"))),
-                    "array": array(ref(typeReference("Value"))),
-                    "string": string(),
-                    "number": number(),
+                //"Result": type(component(glossaryParameter("Type"))),
+                "Value": type(stateGroup({
+                    "object": dictionary(component(typeReference("Value"))),
+                    "array": list(component(typeReference("Value"))),
+                    "string": text(),
+                    "number": integer(),
                     "boolean": boolean(),
-                    "null": null_(),
+                    "null": nothing(),
                 })),
 
             }),

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/numerical_predicates/api.data.ts

@@ -1,18 +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 { 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"
+import { glossary, group, member, integer, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "smallerThan": algorithm("SmallerThan", null, {}),
-        "greaterThan": algorithm("GreaterThan", null, {}),
-        "isZero": algorithm("IsZero", null, {}),
-        "equal": algorithm("Equal", null, {}),
+        "smallerThan": algorithm("SmallerThan", {}),
+        "greaterThan": algorithm("GreaterThan", {}),
+        "isZero": algorithm("IsZero", {}),
+        "equal": algorithm("Equal", {}),
     }
 )

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/numerical_predicates/glossary.data.ts

@@ -1,7 +1,7 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
+    list, boolean, data, dictionary, externalTypeReference, group, member, integer, optional, sfunction,
     type, typeReference
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
@@ -18,14 +18,14 @@ export const $: g_glossary.D.Glossary = {
             'namespaces': d({}),
             'data types': d({
                 "Boolean": type(boolean()),
-                "Number": type(number()),
+                "Number": type(integer()),
                 "NumberPair": type(group({
-                    "yin": member(number()),
-                    "yang": member(number()),
+                    "yin": member(integer()),
+                    "yang": member(integer()),
                 })),
                 "CompareData": type(group({
-                    "benchmark": member(number()),
-                    "focus": member(number()),
+                    "benchmark": member(integer()),
+                    "focus": member(integer()),
                 })),
 
             }),

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/string/api.data.ts

@@ -1,37 +1,37 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+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"
+import { glossary, group, member, integer, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "charCodeAt": algorithm("CharCodeAt", null, {}),
-        "endsWith": algorithm("EndsWith", null, {}),
-        "escape": algorithm("Escape", null, {}),
-        "fromCharacterArray": algorithm("FromCharacterArray", null, {}),
-        "fromCharacter": algorithm("FromCharacter", null, {}),
-        "includes": algorithm("Includes", null, {}),
-        "indexOf": algorithm("IndexOf", null, {}),
-        "length": algorithm("Length", null, {}),
-        "padEnd": algorithm("PadEnd", null, {}),
-        "padStart": algorithm("PadStart", null, {}),
-        "replaceAll": algorithm("ReplaceAll", null, {}),
-        "replaceFirst": algorithm("ReplaceFirst", null, {}),
-        "split": algorithm("Split", null, {}),
-        "splitIn2": algorithm("SplitIn2", null, {}),
-        "startsWith": algorithm("StartsWith", null, {}),
-        "substring": algorithm("Substring", null, {}),
-        "toCharacterArray": algorithm("ToCharacterArray", null, {}),
-        //"unsafeCharCodeAt": algorithm("UnsafeCharCodeAt", null, {}),
+        "charCodeAt": algorithm("CharCodeAt", {}),
+        "endsWith": algorithm("EndsWith", {}),
+        "escape": algorithm("Escape", {}),
+        "fromCharacterArray": algorithm("FromCharacterArray", {}),
+        "fromCharacter": algorithm("FromCharacter", {}),
+        "includes": algorithm("Includes", {}),
+        "indexOf": algorithm("IndexOf", {}),
+        "length": algorithm("Length", {}),
+        "padEnd": algorithm("PadEnd", {}),
+        "padStart": algorithm("PadStart", {}),
+        "replaceAll": algorithm("ReplaceAll", {}),
+        "replaceFirst": algorithm("ReplaceFirst", {}),
+        "split": algorithm("Split", {}),
+        "splitIn2": algorithm("SplitIn2", {}),
+        "startsWith": algorithm("StartsWith", {}),
+        "substring": algorithm("Substring", {}),
+        "toCharacterArray": algorithm("ToCharacterArray", {}),
+        //"unsafeCharCodeAt": algorithm("UnsafeCharCodeAt", {}),
 
         //candidates:
 
-        //"trimEnd": algorithm("TrimEnd", null, {}),
+        //"trimEnd": algorithm("TrimEnd", {}),
         // lastIndexOf(searchValue[, fromIndex])
         // Returns the last index of the specified value.
 

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/string/glossary.data.ts

@@ -4,7 +4,7 @@ import {
     aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-    array, boolean, data, group, member, number, optional, sfunction, streamconsumer, string, type, typeReference
+     list, boolean, data, group, member, integer, optional, sfunction, streamconsumer, text, type, 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"
@@ -20,67 +20,67 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "String": type(string()),
-                "Length": type(number()),
+                "String": type(text()),
+                "Length": type(integer()),
                 "Boolean": type(boolean()),
-                "Character Code": type(number()),
-                "Possible Character Code": type(optional(number())),
-                "Possible Position": type(optional(number())),
+                "Character Code": type(integer()),
+                "Possible Character Code": type(optional(integer())),
+                "Possible Position": type(optional(integer())),
 
                 "CharacterCode At Data": type(group({
-                    "contextString": member(string()),
-                    "index": member(number()),
+                    "contextString": member(text()),
+                    "index": member(integer()),
                 })),
-                "CharacterArray": type(array(number())),
+                "CharacterArray": type(list(integer())),
                 "SplitData": type(group({
-                    "contextString": member(string()),
-                    "splitter": member(string()),
+                    "contextString": member(text()),
+                    "splitter": member(text()),
                 })),
                 "IncludesData": type(group({
-                    "contextString": member(string()),
-                    "searchString": member(string()),
+                    "contextString": member(text()),
+                    "searchString": member(text()),
                 })),
                 "SplitIn2Result": type(group({
-                    "head": member(string()),
-                    "tail": member(optional(string())),
+                    "head": member(text()),
+                    "tail": member(optional(text())),
                 })),
-                "SplitResult": type(array(string())),
+                "SplitResult": type(list(text())),
                 "StartsWithData": type(group({
-                    "contextString": member(string()),
-                    "searchString": member(string()),
+                    "contextString": member(text()),
+                    "searchString": member(text()),
                 })),
                 "EndsWithData": type(group({
-                    "contextString": member(string()),
-                    "searchString": member(string()),
+                    "contextString": member(text()),
+                    "searchString": member(text()),
                 })),
                 "SubstringData": type(group({
-                    "contextString": member(string()),
-                    "begin": member(number()),
+                    "contextString": member(text()),
+                    "begin": member(integer()),
                     /**
                      * I'm deliberately choosing length over end here, because length will become a 'natural' in the future
                      * and then this function is guaranteed to not have a negative length.
                      * going with 'end' would require a check for negative values.
                      */
-                    "length": member(number()),
+                    "length": member(integer()),
                 })),
                 "ReplaceData": type(group({
-                    "contextString": member(string()),
-                    "pattern": member(string()),
-                    "replacement": member(string()),
+                    "contextString": member(text()),
+                    "pattern": member(text()),
+                    "replacement": member(text()),
                 })),
                 "EscapeParameters": type(group({
-                    "contextString": member(string()),
-                    "escape": member(string()),
-                    "patterns to escape": member(array(string())),
+                    "contextString": member(text()),
+                    "escape": member(text()),
+                    "patterns to escape": member(list(text())),
                 })),
                 "PadData": type(group({
-                    "contextString": member(string()),
-                    "targetLength": member(number()),
-                    "padString": member(string()),
+                    "contextString": member(text()),
+                    "targetLength": member(integer()),
+                    "padString": member(text()),
                 })),
                 "IndexOfData": type(group({
-                    "contextString": member(string()),
-                    "searchString": member(string()),
+                    "contextString": member(text()),
+                    "searchString": member(text()),
                 })),
             }),
         },

package/auto.pareto/modules/{string_aware_fountain_pen_2 fountain_pen/api.data.ts → fountain_pen_indented_file_2_fountain_pen_indented_file_with_escaped_texts/api.data.ts}

@@ -5,11 +5,10 @@ import * as sh from "pareto-pure/auto.dist/public/shorthands/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"
-import { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = sh.api(
     glos,
     {
-        "map Block 2 Block": sh.algorithm("Map Block 2 Block", null, {}),
+        "map Block 2 Block": sh.algorithm("Map Block 2 Block", {}),
     }
 )

package/auto.pareto/modules/{string_aware_fountain_pen_2 fountain_pen/glossary.data.ts → fountain_pen_indented_file_2_fountain_pen_indented_file_with_escaped_texts/glossary.data.ts}

@@ -12,8 +12,8 @@ export const $: g_glossary.D.Glossary = {
     'data glossary': {
         'glossary parameters': d({}),
         'imports': d({
-            "in": sh.imp(d_in, {}),
-            "out": sh.imp(d_out, {}),
+            "in": sh.imp(d_in['data glossary'], {}),
+            "out": sh.imp(d_out['data glossary'], {}),
         }),
         'root': {
             'namespaces': d({}),

package/auto.pareto/modules/main/api.data.ts

@@ -9,6 +9,6 @@ import { $ as glos } from "./glossary.data"
 export const $: g_project.D.API = api(
     glos,
     {
-        "temp_compile_boekhouding": algorithm("Main", null, {}),
+        "temp_compile_boekhouding": algorithm("Main", {}),
     }
 )

package/auto.pareto/modules/main/glossary.data.ts

@@ -4,10 +4,15 @@ import {
     aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-    array, data, dictionary, externalTypeReference, group, infInit, infref, member, number, optional, parametrizedType, ref, sfunction,
+    group,
+    infInit,
+    integer,
+    list,
+    member,
     streamconsumer,
-    string,
-    type, typeParameter, typeReference
+    text,
+    type,
+    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,10 +27,10 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "Message": type(string()),
-                "Exit code": type(number()),
+                "Message": type(text()),
+                "Exit code": type(integer()),
                 "Command Line Arguments": type(group({
-                    "arguments": member(array(string()))
+                    "arguments": member(list(text()))
                 })),
             }),
         },