ballerina-core 1.0.33 → 1.0.34

package/main.ts

@@ -91,6 +91,10 @@ export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream
 export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream-multiselect/template"
 export * from "./src/forms/domains/primitives/domains/list/state"
 export * from "./src/forms/domains/primitives/domains/list/template"
+export * from "./src/forms/domains/primitives/domains/base-64-file/state"
+export * from "./src/forms/domains/primitives/domains/base-64-file/template"
+export * from "./src/forms/domains/primitives/domains/secret/state"
+export * from "./src/forms/domains/primitives/domains/secret/template"
 export * from "./src/forms/domains/primitives/domains/map/state"
 export * from "./src/forms/domains/primitives/domains/map/template"
 export * from "./src/forms/domains/singleton/domains/mapping/state"
@@ -111,6 +115,7 @@ export * from "./src/forms/domains/launcher/domains/merger/state"
 export * from "./src/forms/domains/launcher/coroutines/runner"
 export * from "./src/forms/domains/launcher/state"
 export * from "./src/forms/domains/launcher/template"
+export * from "./src/forms/domains/parser/domains/injectables/state"
 
 // import { simpleUpdater, simpleUpdaterWithChildren } from "./src/fun/domains/updater/domains/simpleUpdater/state"
 // import { Updater } from "./src/fun/domains/updater/state"

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.33",
+  "version": "1.0.34",
   "main": "main.ts",
   "dependencies": {
     "immutable": "^5.0.0-beta.5",

package/src/forms/domains/launcher/domains/create/coroutines/runner.ts

@@ -19,7 +19,7 @@ export const createFormRunner = <E, FS>() => {
       Co.Seq([
       Co.GetState().then(current =>
         Debounce<Synchronized<Unit, Synchronized<E, ApiErrors>>, CreateFormContext<E, FS>>(
-          Synchronize<E, ApiErrors>(e => current.api.create(e), _ => "transient failure", 5, 50)
+          Synchronize<E, ApiErrors>(e => current.api.create([e, current.formState]), _ => "transient failure", 5, 50)
             .embed(
               _ => AsyncState.Operations.hasValue(_.sync) ? _.sync.value : undefined,
               _ => Synchronized.Updaters.sync<Unit, Synchronized<E, ApiErrors>>(AsyncState.Operations.map(_))

package/src/forms/domains/launcher/domains/create/state.ts

@@ -5,7 +5,7 @@ export type CreateFormContext<E,FS> = {
   entityId:string,
   api:{
     default:() => Promise<E>,
-    create:BasicFun<E, Promise<ApiErrors>>
+    create:BasicFun<[E, FS], Promise<ApiErrors>>
   },
   actualForm:Template<Value<E> & FS, FS, { onChange:SimpleCallback<BasicUpdater<E>> }>
 }

package/src/forms/domains/launcher/domains/edit/coroutines/runner.ts

@@ -40,7 +40,7 @@ export const editFormRunner = <E, FS>() => {
           Synchronize<Unit, ApiErrors, EditFormWritableState<E, FS>>(
             (_) =>
               current.entity.sync.kind == "loaded"
-                ? current.api.update(current.entityId, current.entity.sync.value)
+                ? current.api.update(current.entityId, current.entity.sync.value,  current.formState)
                 : Promise.resolve([]),
             (_) => "transient failure",
             5,

package/src/forms/domains/launcher/domains/edit/state.ts

@@ -7,7 +7,7 @@ export type EditFormContext<E,FS> = {
   entityId:string,
   api:{
     get:(id: Guid) => Promise<E>,
-    update:(id: Guid, entity:E) => Promise<ApiErrors>
+    update:(id: Guid, entity:E, formstate: FS) => Promise<ApiErrors>
   },
   actualForm:Template<Value<E> & FS, FS, { onChange:SimpleCallback<BasicUpdater<E>>}>
 }

package/src/forms/domains/parser/coroutines/runner.ts

@@ -1,21 +1,23 @@
-import { AsyncState, builtInsFromFieldViews, FormsConfig, Sum, Synchronize, Unit } from "../../../../../main"
+import { AsyncState, builtInsFromFieldViews, FormsConfig, injectablesFromFieldViews, Sum, Synchronize, Unit } from "../../../../../main"
 import { CoTypedFactory } from "../../../../coroutines/builder"
 import { FormParsingResult, FormsParserContext, FormsParserState, parseForms, replaceKeywords } from "../state"
 
-export const LoadValidateAndParseFormsConfig = () => {
-  const Co = CoTypedFactory<FormsParserContext, FormsParserState>()
+export const LoadValidateAndParseFormsConfig = <T extends {[key in keyof T] : {type: any, state: any}}>() => {
+  const Co = CoTypedFactory<FormsParserContext<T>, FormsParserState>()
 
  return Co.Template<Unit>(
   Co.GetState().then(current => 
   Synchronize<Unit, FormParsingResult>(async() => {
     const rawFormsConfig = await current.getFormsConfig();
     const formsConfig = replaceKeywords(rawFormsConfig, "from api")
-    const builtIns = builtInsFromFieldViews(current.fieldViews, current.fieldTypeConverters)
-    const validationResult = FormsConfig.Default.validateAndParseAPIResponse(builtIns)(formsConfig)
+    const builtIns = builtInsFromFieldViews(current.fieldViews)
+    const injectedPrimitives = current.injectedPrimitives ? injectablesFromFieldViews(current.fieldViews, current.injectedPrimitives) : undefined
+    const validationResult = FormsConfig.Default.validateAndParseAPIResponse(builtIns, current.fieldTypeConverters, injectedPrimitives)(formsConfig)
     if (validationResult.kind == "r")
       return Sum.Default.right(validationResult.value)
     return parseForms(
       builtIns,
+      injectedPrimitives,
       current.fieldTypeConverters,
       current.containerFormView,
       current.nestedContainerFormView,
@@ -23,7 +25,7 @@ export const LoadValidateAndParseFormsConfig = () => {
       current.infiniteStreamSources,
       current.enumOptionsSources,
       current.entityApis,
-      current.leafPredicates)(validationResult.value)
+      current.leafPredicates,)(validationResult.value)
   }, _ => "transient failure", 5, 50)
     .embed(
       _ => _.formsConfig,

package/src/forms/domains/parser/domains/built-ins/state.ts

@@ -2,7 +2,7 @@ import { Map, List, Set, OrderedMap } from "immutable"
 import { CollectionReference } from "../../../collection/domains/reference/state";
 import { CollectionSelection } from "../../../collection/domains/selection/state";
 import { BasicFun } from "../../../../../fun/state";
-import { replaceKeyword, replaceKeywords, revertKeyword, Type, TypeDefinition, TypeName } from "../../../../../../main";
+import { InjectedPrimitives, replaceKeyword, replaceKeywords, revertKeyword, Type, TypeDefinition, TypeName } from "../../../../../../main";
 
 export const PrimitiveTypes =
   ["string",
@@ -10,7 +10,10 @@ export const PrimitiveTypes =
     "boolean",
     "maybeBoolean",
     "Date",
-    "CollectionReference"] as const
+    "CollectionReference",
+    "base64File",
+    "secret",
+  ] as const
 export type PrimitiveType = (typeof PrimitiveTypes)[number]
 
 export const GenericTypes = [
@@ -20,22 +23,25 @@ export const GenericTypes = [
   "Map"] as const
 export type GenericType = (typeof GenericTypes)[number]
 
-export type ApiConverter<T> = { fromAPIRawValue: BasicFun<any, T>, toAPIRawValue: BasicFun<T, any> }
-export type ApiConverters = {
+export type ApiConverter<T> =  { fromAPIRawValue: BasicFun<any, T>, toAPIRawValue: BasicFun<[T, boolean], any> }
+export type ApiConverters<U> = {[key in keyof U]: ApiConverter<U[key]> } & BuiltInApiConverters
+export type BuiltInApiConverters = {
   "string": ApiConverter<string>
   "number": ApiConverter<number>
   "boolean": ApiConverter<boolean>
   "maybeBoolean": ApiConverter<boolean | undefined>
+  "base64File": ApiConverter<string>
+  "secret": ApiConverter<string>,
   "Date": ApiConverter<Date>
   "CollectionReference": ApiConverter<CollectionReference>
   "SingleSelection": ApiConverter<CollectionSelection<any>>
   "MultiSelection": ApiConverter<OrderedMap<string, any>>
-  "List": ApiConverter<List<any>>
+  "List": ApiConverter<List<any>>,
   "Map": ApiConverter<List<[any, any]>>
 }
 
-export type PrimitiveBuiltIn = { renderers: Set<keyof BuiltIns["renderers"]>, apiConverters: ApiConverter<any>, defaultValue: any }
-export type GenericBuiltIn = { defaultValue: any, apiConverters: ApiConverter<any> }
+export type PrimitiveBuiltIn = { renderers: Set<keyof BuiltIns["renderers"]>, defaultValue: any }
+export type GenericBuiltIn = { defaultValue: any }
 export type BuiltIns = {
   primitives: Map<string, PrimitiveBuiltIn>;
   generics: Map<string, GenericBuiltIn>;
@@ -44,6 +50,8 @@ export type BuiltIns = {
     maybeBoolean: Set<string>;
     number: Set<string>;
     string: Set<string>;
+    base64File: Set<string>;
+    secret: Set<string>;
     date: Set<string>;
     enumSingleSelection: Set<string>;
     enumMultiSelection: Set<string>;
@@ -54,22 +62,24 @@ export type BuiltIns = {
   };
 };
 
-export const builtInsFromFieldViews = (fieldViews: any, fieldTypeConverters: ApiConverters): BuiltIns => {
+export const builtInsFromFieldViews = (fieldViews: any): BuiltIns => {
   let builtins: BuiltIns = {
     "primitives": Map<string, PrimitiveBuiltIn>([
-      ["string", { renderers: Set(["string"]), apiConverters: fieldTypeConverters["string"], defaultValue: "" }] as [string, PrimitiveBuiltIn],
-      ["number", { renderers: Set(["number"]), apiConverters: fieldTypeConverters["number"], defaultValue: 0 }] as [string, PrimitiveBuiltIn],
-      ["boolean", { renderers: Set(["boolean"]), apiConverters: fieldTypeConverters["boolean"], defaultValue: false }],
-      ["maybeBoolean", { renderers: Set(["maybeBoolean"]), apiConverters: fieldTypeConverters["maybeBoolean"], defaultValue: undefined }] as [string, PrimitiveBuiltIn],
-      ["date", { renderers: Set(["date"]), apiConverters: fieldTypeConverters["Date"], defaultValue: new Date(Date.now()) }] as [string, PrimitiveBuiltIn],
-      ["Date", { renderers: Set(["date"]), apiConverters: fieldTypeConverters["Date"], defaultValue: new Date(Date.now()) }] as [string, PrimitiveBuiltIn],
-      ["CollectionReference", { renderers: Set(["enumSingleSelection", "enumMultiSelection", "streamSingleSelection", "streamMultiSelection"]), apiConverters: fieldTypeConverters["CollectionReference"], defaultValue: CollectionReference.Default("", "") }] as [string, PrimitiveBuiltIn]
+      ["string", { renderers: Set(["string"]), defaultValue: "" }] as [string, PrimitiveBuiltIn],
+      ["number", { renderers: Set(["number"]),  defaultValue: 0 }] as [string, PrimitiveBuiltIn],
+      ["boolean", { renderers: Set(["boolean"]), defaultValue: false }],
+      ["maybeBoolean", { renderers: Set(["maybeBoolean"]), defaultValue: undefined }] as [string, PrimitiveBuiltIn],
+      ["date", { renderers: Set(["date"]), defaultValue: new Date(Date.now()) }] as [string, PrimitiveBuiltIn],
+      ["Date", { renderers: Set(["date"]), defaultValue: new Date(Date.now()) }] as [string, PrimitiveBuiltIn],
+      ["CollectionReference", { renderers: Set(["enumSingleSelection", "enumMultiSelection", "streamSingleSelection", "streamMultiSelection"]), defaultValue: CollectionReference.Default("", "") }] as [string, PrimitiveBuiltIn],
+      ["base64File", { renderers: Set(["base64File"]), defaultValue: "" }] as [string, PrimitiveBuiltIn],
+      ["secret", { renderers: Set(["secret"]), defaultValue: "" }] as [string, PrimitiveBuiltIn],
     ]),
     "generics": Map([
-      ["SingleSelection", { apiConverters: fieldTypeConverters["SingleSelection"], defaultValue: CollectionSelection().Default.right("no selection") }] as [string, GenericBuiltIn],
-      ["Multiselection", { apiConverters: fieldTypeConverters["SingleSelection"], defaultValue: Map() }] as [string, GenericBuiltIn],
-      ["List", { apiConverters: fieldTypeConverters["SingleSelection"], defaultValue: List() }] as [string, GenericBuiltIn],
-      ["Map", { apiConverters: fieldTypeConverters["SingleSelection"], defaultValue: List() }] as [string, GenericBuiltIn]
+      ["SingleSelection", { defaultValue: CollectionSelection().Default.right("no selection") }] as [string, GenericBuiltIn],
+      ["Multiselection", { defaultValue: Map() }] as [string, GenericBuiltIn],
+      ["List", { defaultValue: List() }] as [string, GenericBuiltIn],
+      ["Map", { defaultValue: List() }] as [string, GenericBuiltIn]
     ]),
     "renderers": {
       "boolean": Set(),
@@ -82,6 +92,8 @@ export const builtInsFromFieldViews = (fieldViews: any, fieldTypeConverters: Api
       "number": Set(),
       "string": Set(),
       "list": Set(),
+      "base64File": Set(),
+      "secret": Set(),
       "map": Set(),
     }
   }
@@ -96,12 +108,17 @@ export const builtInsFromFieldViews = (fieldViews: any, fieldTypeConverters: Api
   return builtins
 }
 
-
-export const defaultValue = (types: Map<TypeName, TypeDefinition>, builtIns: BuiltIns) => (t: TypeName | Type): any => {
+export const defaultValue = <T>(types: Map<TypeName, TypeDefinition>, builtIns: BuiltIns, injectedPrimitives?: InjectedPrimitives<T>) => (t: TypeName | Type): any => {
   if (typeof t == "string") {
     let primitive = builtIns.primitives.get(t)
+    let injectedPrimitive = injectedPrimitives?.injectedPrimitives.get(t as keyof T)
+    if(primitive && injectedPrimitive) {
+      throw `both primitive and injected primitive are defined for ${t}`
+    }
     if (primitive != undefined) {
       return primitive.defaultValue
+    } else if (injectedPrimitive != undefined) {
+      return injectedPrimitive.defaultValue
     } else {
       let generic = builtIns.generics.get(t)
       if (generic != undefined) {
@@ -143,11 +160,11 @@ const parseTypeIShouldBePartOfFormValidation = (t:any) : TypeName | Type => {
   return null!
 }
 
-export const fromAPIRawValue = (t: Type, types: Map<TypeName, TypeDefinition>, builtIns: BuiltIns, converters: ApiConverters, isKeywordsReplaced: boolean = false) => (raw: any): any => {
+export const fromAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>, builtIns: BuiltIns, converters: BuiltInApiConverters, isKeywordsReplaced: boolean = false, injectedPrimitives?: InjectedPrimitives<T>) => (raw: any): any => {
   // alert(JSON.stringify(t))
   if (raw == undefined) {
     console.warn(`instantiating default value for type ${JSON.stringify(t)}: the value was undefined so something is missing from the API response`)
-    return defaultValue(types, builtIns)(t.kind == "primitive" ? t.value : t.kind == "lookup" ? t.name : t.value)
+    return defaultValue(types, builtIns, injectedPrimitives)(t.kind == "primitive" ? t.value : t.kind == "lookup" ? t.name : t.value)
   }
 
   const obj = !isKeywordsReplaced ? replaceKeywords(raw, "from api") : raw
@@ -158,43 +175,46 @@ export const fromAPIRawValue = (t: Type, types: Map<TypeName, TypeDefinition>, b
     if (t.value == "SingleSelection" && t.args.length == 1) {
       let result = converters[t.value].fromAPIRawValue(obj)
       result = CollectionSelection().Updaters.left(
-        fromAPIRawValue({ kind: "lookup", name: t.args[0] }, types, builtIns, converters, true))(result)
+        fromAPIRawValue({ kind: "lookup", name: t.args[0] }, types, builtIns, converters, true, injectedPrimitives))(result)
       return result
     }
     if ((t.value == "Multiselection" || t.value == "MultiSelection") && t.args.length == 1) {
       let result = converters["MultiSelection"].fromAPIRawValue(obj)
-      result = result.map(fromAPIRawValue({ kind: "lookup", name: t.args[0] }, types, builtIns, converters, true))
+      result = result.map(fromAPIRawValue({ kind: "lookup", name: t.args[0] }, types, builtIns, converters, true, injectedPrimitives))
       return result
     }
     if (t.value == "List" && t.args.length == 1) {
       let result = converters[t.value].fromAPIRawValue(obj)
+      const isPrimitive = PrimitiveTypes.some(_ => _ == t.args[0]) || injectedPrimitives?.injectedPrimitives.has(t.args[0] as keyof T) 
       result = result.map(fromAPIRawValue(
-        PrimitiveTypes.some(_ => _ == t.args[0]) ?
+        isPrimitive ?
           { kind: "primitive", value: t.args[0] as PrimitiveType }
           : { kind: "lookup", name: t.args[0] }
-        , types, builtIns, converters, true))
+        , types, builtIns, converters, true, injectedPrimitives))
       return result
     }
     if (t.value == "Map" && t.args.length == 2) {
       let result = converters[t.value].fromAPIRawValue(obj)
       let t_args = t.args.map(parseTypeIShouldBePartOfFormValidation)
+      const isKeyPrimitive = PrimitiveTypes.some(_ => _ == t.args[0]) || injectedPrimitives?.injectedPrimitives.has(t.args[0] as keyof T) 
+      const isValuePrimitive = PrimitiveTypes.some(_ => _ == t.args[1]) || injectedPrimitives?.injectedPrimitives.has(t.args[1] as keyof T) 
       result = result.map(keyValue => ([
         fromAPIRawValue(
           typeof t_args[0] == "string" ? 
-            PrimitiveTypes.some(_ => _ == t_args[0]) ?
+            isKeyPrimitive ?
               { kind: "primitive", value: t_args[0] as PrimitiveType }
             : { kind: "lookup", name: t_args[0] }
           :
             t_args[0], 
-            types, builtIns, converters, true)(keyValue[0]),
+            types, builtIns, converters, true, injectedPrimitives)(keyValue[0]),
         fromAPIRawValue(
           typeof t_args[1] == "string" ? 
-            PrimitiveTypes.some(_ => _ == t_args[1]) ?
+            isValuePrimitive ?
               { kind: "primitive", value: t_args[1] as PrimitiveType }
             : { kind: "lookup", name: t_args[1] }
           :
             t_args[1], 
-            types, builtIns, converters, true)(keyValue[1]),
+            types, builtIns, converters, true, injectedPrimitives)(keyValue[1]),
       ])
       )
       return result
@@ -205,7 +225,7 @@ export const fromAPIRawValue = (t: Type, types: Map<TypeName, TypeDefinition>, b
     tDef.fields.forEach((fieldType, fieldName) => {
       const replacedFieldName = replaceKeyword(fieldName)
       const fieldValue = obj[replacedFieldName]
-      result[replacedFieldName] = fromAPIRawValue(fieldType, types, builtIns, converters, true)(fieldValue)
+      result[replacedFieldName] = fromAPIRawValue(fieldType, types, builtIns, converters, true, injectedPrimitives)(fieldValue)
     })
     return result
   }
@@ -214,64 +234,67 @@ export const fromAPIRawValue = (t: Type, types: Map<TypeName, TypeDefinition>, b
 }
 
 
-export const toAPIRawValue = (t: Type, types: Map<TypeName, TypeDefinition>, builtIns: BuiltIns, converters: ApiConverters, isKeywordsReverted: boolean = false) => (raw: any): any => {
-
+export const toAPIRawValue = <T>(t: Type, types: Map<TypeName, TypeDefinition>, builtIns: BuiltIns, converters: BuiltInApiConverters, isKeywordsReverted: boolean = false, injectedPrimitives?: InjectedPrimitives<T>) => (raw: any, formState: any) : any => {
   const obj = !isKeywordsReverted ? replaceKeywords(raw, "to api") : raw
 
   if (t.kind == "primitive") {
-    return converters[t.value].toAPIRawValue(obj as never)
+    return converters[t.value].toAPIRawValue([obj, formState.modifiedByUser] as never)
   } else if (t.kind == "application") { // application here means "generic type application"
     if (t.value == "SingleSelection" && t.args.length == 1) {
-      let result = converters[t.value].toAPIRawValue(obj)
-      if (result != undefined && typeof result == "object")
-        result = toAPIRawValue({ kind: "lookup", name: t.args[0] }, types, builtIns, converters, true)(result)
+      let result = converters[t.value].toAPIRawValue([obj, formState.modifiedByUser])
+      if (result != undefined && typeof result == "object"){
+        result = toAPIRawValue({ kind:"lookup", name:t.args[0] }, types, builtIns, converters, true, injectedPrimitives)(result, formState)
+      }
       return result
     }
     if ((t.value == "Multiselection" || t.value == "MultiSelection") && t.args.length == 1) {
       // alert(`MultiSelect ${JSON.stringify(t)} ${JSON.stringify(obj)}`)
-      let result = converters["MultiSelection"].toAPIRawValue(obj)
+      let result = converters["MultiSelection"].toAPIRawValue([obj, formState.modifiedByUser])
       // alert(`MultiSelect result1 = ${JSON.stringify(result)}`)
       // alert(`${JSON.stringify(t.args[0])}`)
-      result = result.map((_: any) =>
-        typeof _ == "object" ? toAPIRawValue({ kind: "lookup", name: t.args[0] }, types, builtIns, converters, true)(_) : _)
+      result = result.map((_:any) => 
+        typeof _ == "object" ? toAPIRawValue({ kind:"lookup", name: t.args[0] }, types, builtIns, converters, true, injectedPrimitives)(_, formState) : _)
       // alert(`MultiSelect result2 = ${JSON.stringify(result)}`)
       return result
     }
     if (t.value == "List" && t.args.length == 1) {
-      let result = converters[t.value].toAPIRawValue(obj)
-      result = result.map(toAPIRawValue(
-        PrimitiveTypes.some(_ => _ == t.args[0]) ?
-          { kind: "primitive", value: t.args[0] as PrimitiveType }
-          : { kind: "lookup", name: t.args[0] },
-        // { kind:"lookup", name:t.args[0] }, 
-        types, builtIns, converters, true))
-      return result
+      const converterResult = converters[t.value].toAPIRawValue([obj, formState.modifiedByUser])
+      const isPrimitive = PrimitiveTypes.some(_ => _ == t.args[0]) || injectedPrimitives?.injectedPrimitives.has(t.args[0] as keyof T) 
+      return converterResult.map((item: any, index: number) =>
+        toAPIRawValue(
+          isPrimitive ?
+            { kind:"primitive", value:t.args[0] as PrimitiveType }
+          : { kind:"lookup", name:t.args[0] },
+          types, builtIns, converters, true, injectedPrimitives)(item,
+            formState.elementFormStates.get(index)
+      ))
     }
     if (t.value == "Map" && t.args.length == 2) {
-      let result = converters[t.value].toAPIRawValue(obj)
-
+      const converterResult = converters[t.value].toAPIRawValue([obj, formState.modifiedByUser])
+      const isKeyPrimitive = PrimitiveTypes.some(_ => _ == t.args[0]) || injectedPrimitives?.injectedPrimitives.has(t.args[0] as keyof T)
+      const isValuePrimitive = PrimitiveTypes.some(_ => _ == t.args[1]) || injectedPrimitives?.injectedPrimitives.has(t.args[1] as keyof T)
       let t_args = t.args.map(parseTypeIShouldBePartOfFormValidation)
-      result = result.map((keyValue: any) => ([
+      return converterResult.map((keyValue: any, index: number) => ([
         toAPIRawValue(
           typeof t_args[0] == "string" ? 
-            PrimitiveTypes.some(_ => _ == t_args[0]) ?
+            isKeyPrimitive ?
               { kind: "primitive", value: t_args[0] as PrimitiveType }
             : { kind: "lookup", name: t_args[0] }
           :
             t_args[0], 
-            types, builtIns, converters, true)(keyValue[0]),
+            types, builtIns, converters, true, injectedPrimitives)(keyValue[0], formState.elementFormStates.get(index).KeyFormState
+          ),
         toAPIRawValue(
           typeof t_args[1] == "string" ? 
-            PrimitiveTypes.some(_ => _ == t_args[1]) ?
+            isValuePrimitive ?
               { kind: "primitive", value: t_args[1] as PrimitiveType }
             : { kind: "lookup", name: t_args[1] }
           :
             t_args[1], 
-          types, builtIns, converters, true)(keyValue[1]),
+          types, builtIns, converters, true, injectedPrimitives)(keyValue[1], formState.elementFormStates.get(index).ValueFormState
+          ),
       ])
       )
-
-      return result
     }
 
   } else { // t.kind == lookup: we are dealing with a record/object
@@ -280,7 +303,7 @@ export const toAPIRawValue = (t: Type, types: Map<TypeName, TypeDefinition>, bui
     tDef.fields.forEach((fieldType, fieldName) => {
       const revertedFieldName = revertKeyword(fieldName)
       const fieldValue = obj[revertedFieldName]
-      result[revertedFieldName] = toAPIRawValue(fieldType, types, builtIns, converters, true)(fieldValue)
+      result[revertedFieldName] = toAPIRawValue(fieldType, types, builtIns, converters, true, injectedPrimitives)(fieldValue, formState[fieldName])
     })
     return result
   }

package/src/forms/domains/parser/domains/injectables/state.ts

@@ -0,0 +1,42 @@
+import { Map, Set } from 'immutable';
+import { Unit } from '../../../../../../main';
+
+export type InjectablePrimitive<T, U = Unit> = {
+    defaultValue: T;
+    fieldView: any;
+    defaultState?: U;
+}
+  
+export type InjectedPrimitive<T> = {
+    renderers: Set<keyof T>;
+    defaultValue: any;
+    fieldView: any;
+    defaultState: any;
+}
+
+export type Injectables<T extends {[key in keyof T] : {type: any, state: any}}> = Map<keyof T, InjectablePrimitive<T[keyof T]["type"], T[keyof T]["state"]>>;
+
+export type InjectedPrimitives<T> =
+{
+  injectedPrimitives: Map<keyof T, InjectedPrimitive<T>>;
+  renderers: {
+    [key in keyof T]: Set<string>;
+  }
+}
+  
+export const injectablesFromFieldViews = <T extends {[key in keyof T] : {type: any, state: any}}>(fieldViews: any, injectables: Injectables<T>): InjectedPrimitives<T> => {
+  let result = {injectedPrimitives: Map<string, InjectedPrimitive<T>>(), renderers: {}} as InjectedPrimitives<T>;
+  result.injectedPrimitives = injectables.map(((injectable, key) =>
+    ({ renderers: Set([key]), defaultValue: injectable.defaultValue, fieldView: injectable.fieldView, defaultState: injectable.defaultState }) as InjectedPrimitive<T>
+  ))
+  result.renderers = { ...injectables.map((_, key) => ({[key]: Set<string>()})).valueSeq().toArray().reduce((acc, x) => ({...acc, ...x}), {}) } as InjectedPrimitives<T>['renderers'] 
+  Object.keys(result.renderers).forEach((_categoryName) => {
+    const categoryName = _categoryName
+    if (categoryName in fieldViews) {
+      Object.keys(fieldViews[categoryName]).forEach(viewName => {
+        result.renderers[categoryName as keyof T] = result.renderers[categoryName as keyof T].add(viewName)
+      })
+    }
+  })
+  return result
+}

package/src/forms/domains/parser/domains/types/state.ts

@@ -1,5 +1,6 @@
 import { Map, OrderedMap } from "immutable";
 import { BuiltIns } from "../built-ins/state";
+import { InjectedPrimitives } from "../injectables/state";
 
 export type FieldName = string;
 export type TypeName = string;
@@ -8,7 +9,7 @@ export type TypeDefinition = {
   name: TypeName;
   fields: OrderedMap<FieldName, Type>;
 };
-export type PrimitiveTypeName = "string" | "number" | "maybeBoolean" | "boolean" | "Date" | "CollectionReference"
+export type PrimitiveTypeName = "string" | "number" | "maybeBoolean" | "boolean" | "Date" | "CollectionReference" | "base64File" | "secret";
 export type Type = {
   kind: "lookup"; name: TypeName;
 } | {
@@ -31,10 +32,10 @@ export const Type = {
             fst.args.length == snd.args.length &&
             fst.args.every((v, i) => v == snd.args[i]) :
             false,
-    FromName: (types: Map<string, TypeDefinition>, builtIns: BuiltIns) => (typeName: string): Type | undefined => {
+    FromName: <T>(types: Map<string, TypeDefinition>, builtIns: BuiltIns, injectedPrimitives?: InjectedPrimitives<T>) => (typeName: string): Type | undefined => {
       const recordTypeName = types.get(typeName)?.name
       if (recordTypeName) return Type.Default.lookup(recordTypeName)
-      const primitiveTypeName = builtIns.primitives.get(typeName) && typeName
+      const primitiveTypeName = (builtIns.primitives.get(typeName) && typeName)  ?? (injectedPrimitives?.injectedPrimitives.get(typeName as keyof T) && typeName)
       if (primitiveTypeName) return Type.Default.primitive(primitiveTypeName as any)
       return undefined
     }

package/src/forms/domains/parser/domains/validator/state.ts

@@ -1,11 +1,12 @@
 import { Set, Map, OrderedMap } from "immutable";
-import { BoolExpr, BuiltIns, FieldName, FormsConfigMerger, MappingPaths, Sum, Type, TypeDefinition, TypeName } from "../../../../../../main";
+import { ApiConverters, BoolExpr, BuiltIns, FieldName, FormsConfigMerger, InjectedPrimitives, MappingPaths, revertKeyword, Sum, Type, TypeDefinition, TypeName } from "../../../../../../main";
 
 export type FieldConfig = {
   renderer: string;
   label: string
   api: { stream?: string, enumOptions?: string },
   elementRenderer?: string,
+  elementLabel?: string,
   mapRenderer?: { keyRenderer: FieldConfig, valueRenderer: FieldConfig },
   visible: BoolExpr<any>;
   disabled: BoolExpr<any>;
@@ -16,6 +17,7 @@ export type FormDef = {
   typeDef: TypeDefinition;
   fields: Map<FieldName, FieldConfig>;
   tabs: FormLayout;
+  header?: string;
 };
 export type FormLayout = OrderedMap<string, TabLayout>
 export type GroupLayout = Array<FieldName>;
@@ -66,7 +68,7 @@ export type FormValidationError = string;
 export type FormValidationResult = Sum<FormsConfig, Array<FormValidationError>>
 export const FormsConfig = {
   Default: {
-    validateAndParseAPIResponse: (builtIns: BuiltIns) => (fc: any): FormValidationResult => {
+    validateAndParseAPIResponse: <T>(builtIns: BuiltIns, apiConverters: ApiConverters<T>, injectedPrimitives?: InjectedPrimitives<T>) => (fc: any): FormValidationResult => {
       let errors: Array<FormValidationError> = [];
       const formsConfig = Array.isArray(fc) ? FormsConfigMerger.Default.merge(fc) : fc;
       let types: Map<TypeName, TypeDefinition> = Map();
@@ -74,6 +76,12 @@ export const FormsConfig = {
         errors.push("the formsConfig does not contain a 'types' field");
         return Sum.Default.right(errors);
       }
+      if(injectedPrimitives){
+        injectedPrimitives?.injectedPrimitives.keySeq().toArray().some((injectedPrimitiveName) => {
+          if(!Object.keys(apiConverters).includes(injectedPrimitiveName as string)){
+          errors.push(`the formsConfig does not contain an Api Converter for injected primitive: ${injectedPrimitiveName as string}`);
+        }})
+      }
       Object.keys(formsConfig["types"]).forEach((typeName: any) => {
         let typeDef: TypeDefinition = { name: typeName, extends: [], fields: OrderedMap() };
         types = types.set(typeName, typeDef);
@@ -91,9 +99,12 @@ export const FormsConfig = {
         Object.keys(configTypeDef["fields"]).forEach((fieldName: any) => {
           let configFieldType = configTypeDef["fields"][fieldName];
           if (typeof configFieldType == "string") {
-            if (builtIns.primitives.has(configFieldType))
+            if (injectedPrimitives?.injectedPrimitives.has(configFieldType as keyof T) && 
+            (builtIns.primitives.has(configFieldType) || builtIns.generics.has(configFieldType))) {
+              errors.push(`field ${fieldName} in type ${typeName}: injectedPrimitive cannot have same name as builtIn primitive`);
+            }
+            if (builtIns.primitives.has(configFieldType) || injectedPrimitives?.injectedPrimitives.has(configFieldType as keyof T))
               typeDef.fields = typeDef.fields.set(fieldName, { kind: "primitive", value: configFieldType as any });
-
             else
               typeDef.fields = typeDef.fields.set(fieldName, { kind: "lookup", name: configFieldType as any });
           } else if (typeof configFieldType == "object") {
@@ -117,11 +128,11 @@ export const FormsConfig = {
       });
       types.forEach((typeDef, typeName) => {
         typeDef.extends.forEach(extendedTypeName => {
-          if (!builtIns.primitives.has(extendedTypeName) && !types.has(extendedTypeName))
+          if ((!builtIns.primitives.has(extendedTypeName) && !injectedPrimitives?.injectedPrimitives.has(extendedTypeName as keyof T)) && !types.has(extendedTypeName))
             errors.push(`type ${typeName} extends non-existent type ${extendedTypeName}`);
         });
         typeDef.fields.forEach((fieldDef, fieldName) => {
-          if (fieldDef.kind == "primitive" && !builtIns.primitives.has(fieldDef.value))
+          if (fieldDef.kind == "primitive" && (!builtIns.primitives.has(fieldDef.value) && !injectedPrimitives?.injectedPrimitives.has(fieldDef.value as keyof T) ))
             errors.push(`field ${fieldName} of type ${typeName} is non-existent primitive type ${fieldDef.value}`);
           if (fieldDef.kind == "lookup" && !types.has(fieldDef.name))
             errors.push(`field ${fieldName} of type ${typeName} is non-existent type ${fieldDef.name}`);
@@ -300,7 +311,11 @@ export const FormsConfig = {
 
       const rendererMatchesType = (formName:string, fieldName:string) => (fieldTypeDef:Type, fieldConfig:any) => {
         if (fieldTypeDef?.kind == "primitive") {
-          if (fieldTypeDef.value == "maybeBoolean") {
+          if(injectedPrimitives?.injectedPrimitives.has(fieldTypeDef.value as keyof T)){
+            if (!injectedPrimitives.renderers[fieldTypeDef.value as keyof T].has(fieldConfig["renderer"]))
+              errors.push(`field ${fieldName} of form ${formName} references non-existing injected primitive 'renderer' ${fieldConfig["renderer"]}`);
+          }
+          else if (fieldTypeDef.value == "maybeBoolean") {
             // alert(JSON.stringify(fieldConfig["renderer"]))
             // alert(JSON.stringify(builtIns.renderers.MaybeBooleanViews))
             if (!builtIns.renderers.maybeBoolean.has(fieldConfig["renderer"]))
@@ -322,6 +337,10 @@ export const FormsConfig = {
           } else {
             errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
           }
+          if(injectedPrimitives?.injectedPrimitives.has(fieldTypeDef.value as keyof T)){
+            if (!injectedPrimitives.renderers[fieldTypeDef.value as keyof T].has(fieldConfig["renderer"]))
+              errors.push(`field ${fieldName} of form ${formName} references non-existing injected primitive 'renderer' ${fieldConfig["renderer"]}`);
+          }
         } else if (fieldTypeDef?.kind == "application") {
           if (fieldTypeDef?.value == "SingleSelection") {
             if (!builtIns.renderers.enumSingleSelection.has(fieldConfig["renderer"]) &&
@@ -332,8 +351,9 @@ export const FormsConfig = {
               !builtIns.renderers.streamMultiSelection.has(fieldConfig["renderer"]))
               errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
           } else if (fieldTypeDef?.value == "List") {
-            if (!builtIns.renderers.list.has(fieldConfig["renderer"]))
-              errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
+            if (!builtIns.renderers.list.has(fieldConfig["renderer"]) ){
+              errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`)
+            }
           } else if (fieldTypeDef?.value == "Map") {
             if (!builtIns.renderers.map.has(fieldConfig["renderer"]))
               errors.push(`field ${fieldName} of form ${formName} references non-existing ${fieldTypeDef.value} 'renderer' ${fieldConfig["renderer"]}`);
@@ -347,8 +367,8 @@ export const FormsConfig = {
               : "args" in typeDef == false ? undefined
               : Array.isArray(typeDef.args) == false ? undefined
               :  Type.Default.application(typeDef.fun, typeDef.args)
-              const keyType:Type | undefined = typeof fieldTypeDef.args[0] == "string" ? Type.Operations.FromName(types, builtIns)(fieldTypeDef.args[0]) : typeDefToType(fieldTypeDef.args[0] as any)
-              const valueType:Type | undefined = typeof fieldTypeDef.args[1] == "string" ? Type.Operations.FromName(types, builtIns)(fieldTypeDef.args[1]) : typeDefToType(fieldTypeDef.args[1] as any)
+              const keyType:Type | undefined = typeof fieldTypeDef.args[0] == "string" ? Type.Operations.FromName(types, builtIns, injectedPrimitives)(fieldTypeDef.args[0]) : typeDefToType(fieldTypeDef.args[0] as any)
+              const valueType:Type | undefined = typeof fieldTypeDef.args[1] == "string" ? Type.Operations.FromName(types, builtIns, injectedPrimitives)(fieldTypeDef.args[1]) : typeDefToType(fieldTypeDef.args[1] as any)
               if (!keyType) {
                 errors.push(`field ${fieldName} of form ${formName} references non-existing key type ${JSON.stringify(fieldTypeDef.args[0])}`);
               } else if (!valueType) {
@@ -405,6 +425,9 @@ export const FormsConfig = {
         let formDef: FormDef = forms.get(formName)!
         const formTypeDef = types.get(formDef.type)
         const configFormDef = formsConfig["forms"][formName];
+        if (formsConfig["forms"][formName].header){
+          formDef.header = formsConfig["forms"][formName].header
+        }
         Object.keys(configFormDef["fields"]).forEach(fieldName => {
           const fieldConfig = configFormDef["fields"][fieldName]
           const fieldTypeDef = formTypeDef?.fields.get(fieldName);
@@ -415,9 +438,12 @@ export const FormsConfig = {
             let elementType = fieldTypeDef.args[0]
             const rendererHasType = (elementRenderer: string, elementType: string): Array<string> => {
               const primitiveRendererNames = builtIns.primitives.get(elementType)
-              if (primitiveRendererNames != undefined) {
+              const injectedPrimitiveRendererNames = injectedPrimitives?.injectedPrimitives.get(elementType as keyof T)
+              if (primitiveRendererNames != undefined || injectedPrimitiveRendererNames != undefined) {
                 const primitiveRenderers =
-                  Set(primitiveRendererNames.renderers.flatMap(_ => builtIns.renderers[_]).toArray())
+                  Set(primitiveRendererNames ? primitiveRendererNames.renderers.flatMap(_ => builtIns.renderers[_]).toArray() : []).concat(
+                    injectedPrimitives ? Set(injectedPrimitiveRendererNames?.renderers.flatMap(_ => injectedPrimitives.renderers[_])).toArray() : []
+                  )
                 if (!primitiveRenderers.has(elementRenderer)) {
                   return [`${elementType} cannot be rendered by primitive renderer ${elementRenderer}`]
                 }
@@ -439,18 +465,19 @@ export const FormsConfig = {
           }
           if (fieldTypeDef?.kind == "lookup") {
             if (!forms.has(fieldConfig.renderer))
-              errors.push(`field ${fieldName} of form ${formName} references non-existing form ${fieldConfig["renderer"]}`);
+              errors.push(`field ${revertKeyword(fieldName)} of form ${formName} references non-existing form ${fieldConfig["renderer"]}`);
             else {
               const otherForm = forms.get(fieldConfig.renderer)!
               if (otherForm.type != fieldTypeDef.name)
-                errors.push(`field ${fieldName} of form ${formName} references form ${fieldConfig["renderer"]}, which has type ${otherForm.type} whereas ${fieldTypeDef.name} was expected`);
+                errors.push(`field ${revertKeyword(fieldName)} of form ${formName} references form ${fieldConfig["renderer"]}, which has type ${otherForm.type} whereas ${fieldTypeDef.name} was expected`);
             }
           }
           formDef.fields = formDef.fields.set(
             fieldName, {
             renderer: fieldConfig.renderer,
-            label: fieldConfig.label ?? fieldName,
+            label: fieldConfig.label ?? revertKeyword(fieldName),
             elementRenderer: fieldConfig.elementRenderer,
+            elementLabel: fieldConfig.elementLabel,
             mapRenderer: 
               fieldConfig.keyRenderer && fieldConfig.valueRenderer ? 
                 { keyRenderer:fieldConfig.keyRenderer, valueRenderer:fieldConfig.valueRenderer } 

package/src/forms/domains/parser/state.tsx

@@ -1,5 +1,5 @@
 import { List, Map, OrderedMap, OrderedSet, Set } from "immutable";
-import { BoolExpr, Unit, PromiseRepo, Guid, LeafPredicatesEvaluators, Predicate, FormsConfig, BuiltIns, FormDef, Sum, BasicFun, Template, unit, EditFormState, EditFormTemplate, ApiErrors, CreateFormTemplate, EntityFormTemplate, SharedFormState, CreateFormState, Entity, EditFormContext, CreateFormContext, MappedEntityFormTemplate, Mapping, FormValidationResult, Synchronized, simpleUpdater, PrimitiveType, GenericType, ApiConverter, TypeName, ListFieldState, ListForm, TypeDefinition, ApiConverters, defaultValue, fromAPIRawValue, toAPIRawValue, EditFormForeignMutationsExpected, MapFieldState, MapForm, Type, FieldConfig } from "../../../../main";
+import { BoolExpr, Unit, PromiseRepo, Guid, LeafPredicatesEvaluators, Predicate, FormsConfig, BuiltIns, FormDef, Sum, BasicFun, Template, unit, EditFormState, EditFormTemplate, ApiErrors, CreateFormTemplate, EntityFormTemplate, SharedFormState, CreateFormState, Entity, EditFormContext, CreateFormContext, MappedEntityFormTemplate, Mapping, FormValidationResult, Synchronized, simpleUpdater, PrimitiveType, GenericType, ApiConverter, TypeName, ListFieldState, ListForm, TypeDefinition, BuiltInApiConverters, defaultValue, fromAPIRawValue, toAPIRawValue, EditFormForeignMutationsExpected, MapFieldState, MapForm, Type, FieldConfig, Base64FileForm, SecretForm, InjectedPrimitives, Injectables, ApiConverters } from "../../../../main";
 import { Value } from "../../../value/state";
 import { CollectionReference } from "../collection/domains/reference/state";
 import { CollectionSelection } from "../collection/domains/selection/state";
@@ -24,7 +24,7 @@ const parseOptions = (leafPredicates: any, options: any) => {
 };
 
 export const FieldView = //<Context, FieldViews extends DefaultFieldViews, EnumFieldConfigs extends {}, EnumSources extends {}>() => <ViewType extends keyof FieldViews, ViewName extends keyof FieldViews[ViewType]>
-  (fieldConfig:FieldConfig, fieldViews: any, viewType: any, viewName: any, fieldName: string, label: string, enumFieldConfigs: EnumOptionsSources, enumSources: any, leafPredicates: any): any => // FieldView<Context, FieldViews, ViewType, ViewName> =>
+  <T,>(fieldConfig:FieldConfig, fieldViews: any, viewType: any, viewName: any, fieldName: string, label: string, enumFieldConfigs: EnumOptionsSources, enumSources: any, leafPredicates: any, injectedPrimitives?: InjectedPrimitives<T>): any =>
   {
     if (viewType == "maybeBoolean")
       return MaybeBooleanForm<any & FormLabel, Unit>()
@@ -69,13 +69,35 @@ export const FieldView = //<Context, FieldViews extends DefaultFieldViews, EnumF
       return InfiniteMultiselectDropdownForm<CollectionReference, any & FormLabel, Unit>()
         .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
         .mapContext<any & FormLabel & SharedFormState & SearchableInfiniteStreamState<CollectionReference> & Value<OrderedMap<Guid, CollectionReference>>>(_ => ({ ..._, label: label })) as any
+    if (viewType == "base64File")
+      return Base64FileForm<any & FormLabel, Unit>()
+      .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
+        .mapContext<any & FormLabel & SharedFormState & Value<string>>(_ => ({ ..._, label: label })) as any
+    if (viewType == "secret")
+      return SecretForm<any & FormLabel, Unit>()
+        .withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
+        .mapContext<any & FormLabel & SharedFormState & Value<string>>(_ => ({ ..._, label: label })) as any
+    // check injectedViews
+    if (injectedPrimitives?.injectedPrimitives.has(viewType)) {
+      const injectedPrimitive = injectedPrimitives.injectedPrimitives.get(viewType)
+      return injectedPrimitive?.fieldView(fieldViews, viewType, viewName, label) as any
+    }
     return `error: the view for ${viewType as string}::${viewName as string} cannot be found`;
   }
 
 export const FieldFormState = //<Context, FieldViews extends DefaultFieldViews, InfiniteStreamSources extends {}, InfiniteStreamConfigs extends {}>() => <ViewType extends keyof FieldViews, ViewName extends keyof FieldViews[ViewType]>
-  (fieldConfig:FieldConfig, fieldViews: any, viewType: any, viewName: any, fieldName: string, InfiniteStreamSources: any, infiniteStreamConfigs: any): any => {
-    if (viewType == "maybeBoolean" || viewType == "boolean" || viewType == "number" || viewType == "string")
+  <T,>(fieldConfig:FieldConfig, fieldViews: any, viewType: any, viewName: any, fieldName: string, InfiniteStreamSources: any, infiniteStreamConfigs: any, injectedPrimitives?: InjectedPrimitives<T>): any => {
+    if (viewType == "maybeBoolean" || viewType == "boolean" || viewType == "number" || viewType == "string" || viewType == "base64File" || viewType == "secret")
       return SharedFormState.Default();
+    if( injectedPrimitives?.injectedPrimitives.has(viewType)){
+      const injectedPrimitiveDefaultState = injectedPrimitives.injectedPrimitives.get(viewType)?.defaultState;
+      return injectedPrimitiveDefaultState != undefined ?
+      ({
+        ...injectedPrimitiveDefaultState,
+        ...SharedFormState.Default()
+      }) : SharedFormState.Default();
+      return SharedFormState.Default()
+    }
     if (viewType == "date")
       return DateFormState.Default("");
     if (viewType == "enumSingleSelection" || viewType == "enumMultiSelection")
@@ -101,7 +123,7 @@ export type ParsedForm = {
   visibleFields: any,
   disabledFields: any,
 }
-export const ParseForm = (
+export const ParseForm = <T,>(
   formName: string,
   formDef: FormDef,
   containerFormView: any,
@@ -120,7 +142,8 @@ export const ParseForm = (
   visibleFieldsBoolExprs: any,
   disabledFieldsBoolExprs: any,
   defaultValue: BasicFun<TypeName | Type, any>,
-  type: TypeDefinition
+  type: TypeDefinition,
+  injectedPrimitives?: InjectedPrimitives<T>
 ): ParsedForm => {
   const fieldNameToViewCategory = (fieldName: string) => {
     const fieldViewCategories = Object.keys(fieldViews)
@@ -152,7 +175,7 @@ export const ParseForm = (
     const fieldConfig = formDef.fields.get(fieldName)!
     initialFormState[fieldName] =
       otherForms.get(viewName)?.initialFormState ??
-      FieldFormState(fieldConfig, fieldViews, fieldNameToViewCategory(fieldName) as any, (fieldsViewsConfig as any)[fieldName], fieldName, InfiniteStreamSources, fieldsInfiniteStreamsConfig);
+      FieldFormState(fieldConfig, fieldViews, fieldNameToViewCategory(fieldName) as any, (fieldsViewsConfig as any)[fieldName], fieldName, InfiniteStreamSources, fieldsInfiniteStreamsConfig, injectedPrimitives);
     if (typeof initialFormState[fieldName] == "string") {
       throw `cannot resolve initial state ${viewName} of field ${fieldName}`
     }
@@ -171,6 +194,7 @@ export const ParseForm = (
       if (viewType == "list") {
         const elementRendererName = formFieldElementRenderers[fieldName]
         const field = type.fields.get(fieldName)!
+        const elementLabel = formDef.fields.get(fieldName)!.elementLabel
         const initialElementValue = defaultValue(field.kind == "primitive" ? field.value : field.kind == "lookup" ? field.name : field.args[0])
         const elementForm = otherForms.get(elementRendererName)
         if (elementForm != undefined) { // the list argument is a nested form
@@ -178,18 +202,18 @@ export const ParseForm = (
           formConfig[fieldName] = ListForm<any, any, any & FormLabel, Unit>(
             { Default: () => ({ ...initialFormState }) },
             { Default: () => ({ ...initialElementValue }) },
-            elementForm.form.withView(nestedContainerFormView),
+            elementForm.form.withView(nestedContainerFormView).mapContext<any>(_ => ({ ..._, label: elementLabel }))
           ).withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
-            .mapContext<any>(_ => ({ ..._, label: label }))
+            .mapContext<any>(_ => ({ ..._, label }))
         } else { // the list argument is a primitive
-          const elementForm = FieldView(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, fieldName, label, EnumOptionsSources, fieldsOptionsConfig, leafPredicates)
-          const initialFormState = FieldFormState(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, fieldName, InfiniteStreamSources, fieldsInfiniteStreamsConfig);
+          const elementForm = FieldView(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, fieldName, elementLabel ?? label, EnumOptionsSources, fieldsOptionsConfig, leafPredicates, injectedPrimitives)
+          const initialFormState = FieldFormState(fieldConfig, fieldViews, fieldNameToElementViewCategory(formFieldElementRenderers)(fieldName) as any, elementRendererName, fieldName, InfiniteStreamSources, fieldsInfiniteStreamsConfig, injectedPrimitives);
           formConfig[fieldName] = ListForm<any, any, any & FormLabel, Unit>(
             { Default: () => initialFormState },
             { Default: () => initialElementValue },
             elementForm,
           ).withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
-            .mapContext<any>(_ => ({ ..._, label: label }))
+            .mapContext<any>(_ => ({ ..._, label }))
         }
       } else {
         if (viewType == "map") {
@@ -213,15 +237,16 @@ export const ParseForm = (
           const initialValueValue = defaultValue(valueType)
           const getFormAndInitialState = (elementRenderers:any, rendererName:any, fieldConfig:FieldConfig) => {
             const formDef = otherForms.get(rendererName)
+            const elementLabel = elementRenderers[fieldName].label ?? label
             if (formDef != undefined) {
               return [
-                formDef.form.withView(nestedContainerFormView),
+                formDef.form.withView(nestedContainerFormView).mapContext<any>(_ => ({ ..._, label: elementLabel })),
                 formDef.initialFormState
               ]
             } else {
               const categoryName = fieldNameToElementViewCategory(elementRenderers)(fieldName) as any
-              const form = FieldView(fieldConfig, fieldViews, categoryName, rendererName, fieldName, label, EnumOptionsSources, fieldsOptionsConfig, leafPredicates)
-              const initialFormState = FieldFormState(fieldConfig, fieldViews, categoryName, rendererName, fieldName, InfiniteStreamSources, fieldsInfiniteStreamsConfig);
+              const form = FieldView(fieldConfig, fieldViews, categoryName, rendererName, fieldName, elementLabel, EnumOptionsSources, fieldsOptionsConfig, leafPredicates, injectedPrimitives)
+              const initialFormState = FieldFormState(fieldConfig, fieldViews, categoryName, rendererName, fieldName, InfiniteStreamSources, fieldsInfiniteStreamsConfig, injectedPrimitives);
               return [
                 form,
                 initialFormState
@@ -244,7 +269,7 @@ export const ParseForm = (
           ).withView(((fieldViews as any)[viewType] as any)[viewName]() as any)
             .mapContext<any>(_ => ({ ..._, label: label }))
         } else {
-          formConfig[fieldName] = FieldView(fieldConfig, fieldViews, viewType, viewName, fieldName, label, EnumOptionsSources, fieldsOptionsConfig, leafPredicates);
+          formConfig[fieldName] = FieldView(fieldConfig, fieldViews, viewType, viewName, fieldName, label, EnumOptionsSources, fieldsOptionsConfig, leafPredicates, injectedPrimitives);
         }
       }
     }
@@ -338,9 +363,10 @@ export type EnumName = string
 
 export type EnumOptionsSources = BasicFun<EnumName, BasicFun<Unit, Promise<Array<[CollectionReference, BoolExpr<Unit>]>>>>
 export const parseForms =
-  <LeafPredicates,>(
+  <LeafPredicates, T,>(
     builtIns: BuiltIns,
-    apiConverters: ApiConverters,
+    injectedPrimitives: InjectedPrimitives<T> | undefined,
+    apiConverters: BuiltInApiConverters,
     containerFormView: any,
     nestedContainerFormView: any,
     fieldViews: any,
@@ -422,8 +448,9 @@ export const parseForms =
             leafPredicates,
             formFieldVisibilities,
             formFieldDisabled,
-            defaultValue(formsConfig.types, builtIns),
+            defaultValue(formsConfig.types, builtIns, injectedPrimitives),
             formConfig.typeDef,
+            injectedPrimitives
           )
           const formBuilder = Form<any, any, any, any>().Default<any>()
           const form = formBuilder.template({
@@ -447,11 +474,11 @@ export const parseForms =
           get: (id: string) => entityApis.get(launcher.api)(id).then((raw: any) => {
             // alert(JSON.stringify(raw))
             // alert(JSON.stringify(parsedForm.formDef.type))
-            const parsed = fromAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters)(raw)
+            const parsed = fromAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(raw)
             return parsed
           }),
-          update: (id: Guid, value: any) =>
-            entityApis.update(launcher.api)(id, toAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters)(value))
+          update: (id: Guid, value: any, formState: any) =>
+            entityApis.update(launcher.api)(id, toAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(value, formState))
         }
         parsedLaunchers.edit = parsedLaunchers.edit.set(
           launcherName,
@@ -474,16 +501,16 @@ export const parseForms =
         const form = parsedForm.form
         const initialState = parsedForm.initialFormState
         const api = {
-          create: (value: any) => {
+          create: ([value, formState]: [any, any]) => {
             // alert(`type = ${JSON.stringify(parsedForm.formDef.type)}`)
             // alert(`value = ${JSON.stringify(value)}`)
-            const raw = toAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters)(value)
+            const raw = toAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(value, formState)
             // alert(`raw = ${JSON.stringify(raw.interests)}`)
             return entityApis.create(launcher.api)(raw)
           },
           default: (_: Unit) => entityApis.default(launcher.api)(unit)
             .then((raw: any) => {
-              const parsed = fromAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters)(raw)
+              const parsed = fromAPIRawValue({ kind: "lookup", name: parsedForm.formDef.type }, formsConfig.types, builtIns, apiConverters, false, injectedPrimitives)(raw)
               return parsed
             })
         }
@@ -591,16 +618,17 @@ export const replaceKeywords = (obj: any, kind: "from api" | "to api"): any => {
   return obj;
 };
 
-export type FormsParserContext = {
+export type FormsParserContext<T extends {[key in keyof T] : {type: any, state: any}}> = {
   containerFormView: any,
   nestedContainerFormView: any,
   fieldViews: any,
-  fieldTypeConverters: ApiConverters,
+  fieldTypeConverters: ApiConverters<T>,
   infiniteStreamSources: InfiniteStreamSources,
   enumOptionsSources: EnumOptionsSources,
   entityApis: EntityApis,
   leafPredicates: any,
   getFormsConfig: BasicFun<void, Promise<any>>
+  injectedPrimitives?: Injectables<T>,
 }
 export type FormsParserState = {
   formsConfig: Synchronized<Unit, FormParsingResult>

package/src/forms/domains/parser/template.tsx

@@ -1,4 +1,5 @@
+import { Unit } from "../../../../main";
 import { LoadValidateAndParseFormsConfig } from "./coroutines/runner";
 
-export const FormsParserTemplate = LoadValidateAndParseFormsConfig()
+export const FormsParserTemplate = <T extends {[key in keyof T] : {type: any, state: any}} = Unit>() => LoadValidateAndParseFormsConfig<T>()
 

package/src/forms/domains/primitives/domains/base-64-file/state.ts

@@ -0,0 +1,12 @@
+import { SimpleCallback } from "../../../../../../main";
+import { View } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { FormLabel } from "../../../singleton/domains/form-label/state";
+import { OnChange, SharedFormState } from "../../../singleton/state";
+
+export type Base64FileView<Context extends FormLabel, ForeignMutationsExpected> =
+  View<
+    Context & Value<string> & SharedFormState & { disabled:boolean },
+    SharedFormState,
+    ForeignMutationsExpected & { onChange: OnChange<string>; setNewValue: SimpleCallback<string> }
+  >;

package/src/forms/domains/primitives/domains/base-64-file/template.tsx

@@ -0,0 +1,24 @@
+import { List } from "immutable";
+import { BasicFun, replaceWith, ValidateRunner } from "../../../../../../main";
+import { Template } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { FormLabel } from "../../../singleton/domains/form-label/state";
+import { FieldValidation, FieldValidationWithPath, OnChange, SharedFormState } from "../../../singleton/state";
+import { Base64FileView } from "./state";
+
+
+export const Base64FileForm = <Context extends FormLabel, ForeignMutationsExpected>(
+  validation?:BasicFun<string, Promise<FieldValidation>>) => {
+  return Template.Default<Context & Value<string> & { disabled:boolean }, SharedFormState, ForeignMutationsExpected & { onChange: OnChange<string>; }, Base64FileView<Context, ForeignMutationsExpected>>(props => <>
+    <props.view {...props}
+      foreignMutations={{
+        ...props.foreignMutations,
+        setNewValue: (_) => props.foreignMutations.onChange(replaceWith(_), List())
+      }} />
+  </>
+  ).any([
+    ValidateRunner<Context & { disabled:boolean }, SharedFormState, ForeignMutationsExpected, string>(
+      validation ? _ => validation(_).then(FieldValidationWithPath.Default.fromFieldValidation) : undefined
+    ),
+  ])
+}

package/src/forms/domains/primitives/domains/list/template.tsx

@@ -1,9 +1,9 @@
 import { List } from "immutable";
-import { SimpleCallback, BasicFun, Unit, ValidateRunner, Updater, BasicUpdater, MapRepo, ListRepo } from "../../../../../../main";
+import { SimpleCallback, BasicFun, Unit, ValidateRunner, Updater, BasicUpdater, MapRepo, ListRepo, CoTypedFactory, Debounce, Synchronize} from "../../../../../../main";
 import { Template } from "../../../../../template/state";
 import { Value } from "../../../../../value/state";
 import { FormLabel } from "../../../singleton/domains/form-label/state";
-import { FieldValidation, FieldValidationWithPath, OnChange } from "../../../singleton/state";
+import { FieldValidation, FieldValidationWithPath, FormValidatorSynchronized, OnChange, SharedFormState } from "../../../singleton/state";
 import { ListFieldState, ListFieldView } from "./state";
 
 export const ListForm = <Element, ElementFormState, Context extends FormLabel, ForeignMutationsExpected>(
@@ -19,20 +19,20 @@ export const ListForm = <Element, ElementFormState, Context extends FormLabel, F
 ) => {
   const embeddedElementTemplate = (elementIndex:number) =>
       elementTemplate
-        .mapForeignMutations((_ : ForeignMutationsExpected & {
-            onChange: OnChange<List<Element>>;
-            add: SimpleCallback<Unit>;
-            remove: SimpleCallback<number>;
-          }) : ForeignMutationsExpected & {
-            onChange: OnChange<Element>;
-          } => ({
-          ..._,
-          onChange: (elementUpdater, path) => {
-            _.onChange(Updater((elements:List<Element>) => elements.update(elementIndex, (_:Element | undefined) => _ == undefined ? _ : elementUpdater(_))), path)
-          },
-          add: (newElement: Element) => { },
-          remove: (elementIndex: number) => { }
-        }))
+        .mapForeignMutationsFromProps<ForeignMutationsExpected & {
+          onChange: OnChange<List<Element>>;
+          add: SimpleCallback<Unit>;
+          remove: SimpleCallback<number>;}>((props): ForeignMutationsExpected & {onChange: OnChange<Element>} => ({
+        ...props.foreignMutations,
+        onChange: (elementUpdater, path) => {
+          props.foreignMutations.onChange(Updater((elements:List<Element>) =>
+            elements.update(elementIndex, (_:Element | undefined) => _ == undefined ? _ : elementUpdater(_))), path)
+          props.setState(_ => ({..._,
+             modifiedByUser:true,
+            })) },
+        add: (newElement: Element) => { },
+        remove: (elementIndex: number) => { }
+      }))
         .mapContext((_: Context & Value<List<Element>> & ListFieldState<Element, ElementFormState>) : (Context & Value<Element> & ElementFormState) | undefined => {
           const element = _.value.get(elementIndex)
           if (element == undefined) return undefined

package/src/forms/domains/primitives/domains/map/template.tsx

@@ -27,17 +27,17 @@ export const MapForm = <K, V, KeyFormState, ValueFormState, Context extends Form
 ) => {
   const embeddedKeyTemplate = (elementIndex: number) =>
     keyTemplate
-      .mapForeignMutations((_: ForeignMutationsExpected & {
+      .mapForeignMutationsFromProps<ForeignMutationsExpected & {
         onChange: OnChange<List<[K, V]>>;
         add: SimpleCallback<Unit>;
         remove: SimpleCallback<number>;
-      }): ForeignMutationsExpected & {
-        onChange: OnChange<K>;
-      } =>
+      }>((props): ForeignMutationsExpected & {
+        onChange: OnChange<K>; } =>
       ({
-        ..._,
+        ...props.foreignMutations,
         onChange: (elementUpdater, path) => {
-          _.onChange(Updater((elements: List<[K, V]>) => elements.update(elementIndex, (_: [K, V] | undefined) => _ == undefined ? _ : [elementUpdater(_[0]), _[1]])), path)
+          props.foreignMutations.onChange(Updater((elements: List<[K, V]>) => elements.update(elementIndex, (_: [K, V] | undefined) => _ == undefined ? _ : [elementUpdater(_[0]), _[1]])), path)
+          props.setState(_ => ({ ..._, modifiedByUser: true }))
         },
         add: (newElement: [K, V]) => { },
         remove: (elementIndex: number) => { }
@@ -56,17 +56,18 @@ export const MapForm = <K, V, KeyFormState, ValueFormState, Context extends Form
         ))
   const embeddedValueTemplate = (elementIndex: number) =>
     valueTemplate
-      .mapForeignMutations((_: ForeignMutationsExpected & {
+      .mapForeignMutationsFromProps<ForeignMutationsExpected & {
         onChange: OnChange<List<[K, V]>>;
         add: SimpleCallback<Unit>;
         remove: SimpleCallback<number>;
-      }): ForeignMutationsExpected & {
+      }>((props): ForeignMutationsExpected & {
         onChange: OnChange<V>;
       } =>
       ({
-        ..._,
+        ...props.foreignMutations,
         onChange: (elementUpdater, path) => {
-          _.onChange(Updater((elements: List<[K, V]>) => elements.update(elementIndex, (_: [K, V] | undefined) => _ == undefined ? _ : [_[0], elementUpdater(_[1])])), path)
+          props.foreignMutations.onChange(Updater((elements: List<[K, V]>) => elements.update(elementIndex, (_: [K, V] | undefined) => _ == undefined ? _ : [_[0], elementUpdater(_[1])])), path)
+          props.setState(_ => ({ ..._, modifiedByUser: true }))
         },
         add: (newElement: [K, V]) => { },
         remove: (elementIndex: number) => { }

package/src/forms/domains/primitives/domains/secret/state.ts

@@ -0,0 +1,12 @@
+import { SimpleCallback } from "../../../../../../main";
+import { View } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { FormLabel } from "../../../singleton/domains/form-label/state";
+import { OnChange, SharedFormState } from "../../../singleton/state";
+
+export type SecretView<Context extends FormLabel, ForeignMutationsExpected> =
+  View<
+    Context & Value<string> & SharedFormState & { disabled:boolean },
+    SharedFormState,
+    ForeignMutationsExpected & { onChange: OnChange<string>; setNewValue: SimpleCallback<string> }
+  >;

package/src/forms/domains/primitives/domains/secret/template.tsx

@@ -0,0 +1,24 @@
+import { List } from "immutable";
+import { BasicFun, replaceWith, ValidateRunner } from "../../../../../../main";
+import { Template } from "../../../../../template/state";
+import { Value } from "../../../../../value/state";
+import { FormLabel } from "../../../singleton/domains/form-label/state";
+import { FieldValidation, FieldValidationWithPath, OnChange, SharedFormState } from "../../../singleton/state";
+import { SecretView } from "./state";
+
+
+export const SecretForm = <Context extends FormLabel, ForeignMutationsExpected>(
+  validation?:BasicFun<string, Promise<FieldValidation>>) => {
+  return Template.Default<Context & Value<string> & { disabled:boolean }, SharedFormState, ForeignMutationsExpected & { onChange: OnChange<string>; }, SecretView<Context, ForeignMutationsExpected>>(props => <>
+    <props.view {...props}
+      foreignMutations={{
+        ...props.foreignMutations,
+        setNewValue: (_) => props.foreignMutations.onChange(replaceWith(_), List())
+      }} />
+  </>
+  ).any([
+    ValidateRunner<Context & { disabled:boolean }, SharedFormState, ForeignMutationsExpected, string>(
+      validation ? _ => validation(_).then(FieldValidationWithPath.Default.fromFieldValidation) : undefined
+    ),
+  ])
+}

package/src/forms/domains/singleton/state.ts

@@ -54,7 +54,7 @@ export const SharedFormState = {
 export type EntityFormState<Entity, Fields extends (keyof Entity) & (keyof FieldStates), FieldStates, Context, ForeignMutationsExpected> =
   { [f in Fields]: FieldStates[f] & SharedFormState } & SharedFormState
 export type EntityFormContext<Entity, Fields extends (keyof Entity) & (keyof FieldStates), FieldStates, Context, ForeignMutationsExpected> =
-  Context & EntityFormState<Entity, Fields, FieldStates, Context, ForeignMutationsExpected> & { visibleFields: OrderedMap<Fields, BasicPredicate<Context>>, disabledFields: OrderedMap<Fields, BasicPredicate<Context>> } & Value<Entity>
+  Context & EntityFormState<Entity, Fields, FieldStates, Context, ForeignMutationsExpected> & { visibleFields: OrderedMap<Fields, BasicPredicate<Context>>, disabledFields: OrderedMap<Fields, BasicPredicate<Context>>, header?: string } & Value<Entity>
 export type OnChange<Entity> = (updater: BasicUpdater<Entity>, path: List<string>) => void
 export type EntityFormForeignMutationsExpected<Entity, Fields extends (keyof Entity) & (keyof FieldStates), FieldStates, Context, ForeignMutationsExpected> =
   ForeignMutationsExpected & { onChange: OnChange<Entity> }

package/src/forms/domains/singleton/template.tsx

@@ -1,5 +1,5 @@
 import { List, OrderedMap, OrderedSet } from "immutable"
-import { BasicUpdater, id, BasicPredicate, SimpleCallback, Unit, Debounced, Synchronized, unit, replaceWith, CoTypedFactory, Debounce, Synchronize, BasicFun, EntityFormState, EntityFormContext, EntityFormForeignMutationsExpected, EntityFormTemplate, EntityFormView, FieldTemplates, FieldValidationWithPath, FormValidatorSynchronized, OnChange, SharedFormState } from "../../../../main"
+import { BasicUpdater, id, BasicPredicate, SimpleCallback, Unit, Debounced, Synchronized, unit, replaceWith, CoTypedFactory, Debounce, Synchronize, BasicFun, EntityFormState, EntityFormContext, EntityFormForeignMutationsExpected, EntityFormTemplate, EntityFormView, FieldTemplates, FieldValidationWithPath, FormValidatorSynchronized, OnChange, SharedFormState, DirtyStatus } from "../../../../main"
 import { Template, View } from "../../../template/state"
 import { Value } from "../../../value/state"
 
@@ -34,6 +34,13 @@ export const Form = <Entity, FieldStates, Context, ForeignMutationsExpected>() =
                       modifiedByUser:true,
                       validation:Debounced.Updaters.Template.value<FormValidatorSynchronized>(Synchronized.Updaters.value(replaceWith(unit)))(_[field].validation),
                     }) }))
+                  } else {
+                    props.setState(_ => ({ ..._,
+                      modifiedByUser: true,
+                      [field]:({
+                        ..._[field],
+                        modifiedByUser:true,
+                      }) }))
                   }
                   setTimeout(() =>
                     props.foreignMutations.onChange((current: Entity): Entity => ({
@@ -81,22 +88,25 @@ export const Form = <Entity, FieldStates, Context, ForeignMutationsExpected>() =
   }
 })
 
+// TODO: Validate runner and dirty status are also used to ensure to element is initialised, but this should be further debugged with a more correct solution
 export const ValidateRunner = <Context, FormState extends SharedFormState, ForeignMutationsExpected, Entity,>(
   validation?:BasicFun<Entity, Promise<FieldValidationWithPath>>,
 ) => {
   const Co = CoTypedFactory<Context & Value<Entity> & FormState, FormState>()
   return Co.Template<ForeignMutationsExpected & { onChange: OnChange<Entity>; }>(
-    Co.Repeat(
+    validation ? Co.Repeat(
       Debounce<FormValidatorSynchronized, Value<Entity>>(
         Synchronize<Unit, FieldValidationWithPath, Value<Entity>>(
           _ => validation ? validation(_.value) : Promise.resolve([]),
           () => "transient failure", 3, 50
         ), 50
       ).embed(_ => ({..._.validation, value:_.value}), (_) => curr => ({...curr, validation:_(curr.validation)}))
-    ),
+    ) :
+    Co.SetState((curr) => ({...curr, validation: Debounced.Updaters.Core.dirty(replaceWith<DirtyStatus>("not dirty"))}))
+    ,
     {
       interval:15,
-      runFilter:props => Boolean(validation) && Debounced.Operations.shouldCoroutineRun(props.context.validation)
+      runFilter: props => Debounced.Operations.shouldCoroutineRun(props.context.validation)
     }
   )
 }