ballerina-core 1.0.0

package/src/async/state.ts

@@ -0,0 +1,144 @@
+import { Updater } from "../fun/domains/updater/state";
+import { BasicFun, Fun } from "../fun/state";
+
+export type LoadedAsyncState<a> = { kind: "loaded"; value: a }
+export type ReloadingAsyncState<a> = { kind: "reloading"; value: a }
+export type FailedReloadAsyncState<a> = { kind: "failed-reload"; value: a; error: any }
+
+export type AsyncState<a> = (
+  | ((
+      | { kind: "unloaded" }
+      | { kind: "loading" }
+      | ReloadingAsyncState<a>
+      | { kind: "error"; error: any }
+    ) & { failedLoadingAttempts: number })
+  | LoadedAsyncState<a>
+  | FailedReloadAsyncState<a>
+) & {
+  map: <b>(f: BasicFun<a, b>) => AsyncState<b>;
+  getLoadingAttempts: <a>(this: AsyncState<a>) => number;
+};
+
+export type HasValueAsyncState<a> = AsyncState<a> & { kind:"loaded" | "reloading" | "failed-reload"}
+export type IsLoadingAsyncState<a> = AsyncState<a> & { kind:"loading" | "reloading" }
+
+function map<a, b>(this: AsyncState<a>, f: BasicFun<a, b>): AsyncState<b> {
+  return this.kind == "loaded"
+    ? AsyncState.Default.loaded(f(this.value))
+    : this.kind == "unloaded"
+      ? AsyncState.Default.unloaded()
+      : this.kind == "error"
+        ? AsyncState.Default.error()
+        : this.kind == "loading"
+          ? AsyncState.Default.loading()
+          : AsyncState.Default.reloading(f(this.value));
+}
+
+function getLoadingAttempts<a>(this: AsyncState<a>): number {
+  return this.kind == "loaded" || this.kind == "failed-reload" ? 0 : this.failedLoadingAttempts;
+}
+
+export const AsyncState = {
+  Default: {
+    unloaded: <a>(): AsyncState<a> => ({
+      kind: "unloaded",
+      map,
+      getLoadingAttempts,
+      failedLoadingAttempts: 0,
+    }),
+    loading: <a>(): AsyncState<a> => ({
+      kind: "loading",
+      map,
+      getLoadingAttempts,
+      failedLoadingAttempts: 0,
+    }),
+    reloading: <a>(value: a): AsyncState<a> => ({
+      kind: "reloading",
+      value,
+      map,
+      getLoadingAttempts,
+      failedLoadingAttempts: 0,
+    }),
+    failedReload: <a>(value: a, error?: any): AsyncState<a> => ({
+      kind: "failed-reload",
+      value,
+      error,
+      map,
+      getLoadingAttempts,
+    }),
+    error: <a>(value?: any): AsyncState<a> => ({
+      kind: "error",
+      map,
+      error: value,
+      getLoadingAttempts,
+      failedLoadingAttempts: 0,
+    }),
+    loaded: <a>(value: a): AsyncState<a> => ({
+      kind: "loaded",
+      value,
+      map,
+      getLoadingAttempts,
+    }),
+  },
+  Updaters: {
+    failedLoadingAttempts: <a>(updateAttempts: Updater<number>): Updater<AsyncState<a>> =>
+      Updater((current) =>
+        current.kind == "loaded" || current.kind == "failed-reload"
+          ? current
+          : {
+              ...current,
+              failedLoadingAttempts: updateAttempts(current.failedLoadingAttempts),
+            }
+      ),
+    toUnloaded: <a>(): Updater<AsyncState<a>> =>
+      Updater((_) => ({
+        kind: "unloaded",
+        map,
+        getLoadingAttempts,
+        failedLoadingAttempts: 0,
+      })),  
+    toLoading: <a>(): Updater<AsyncState<a>> =>
+      Updater((current) => ({
+        kind: "loading",
+        map,
+        getLoadingAttempts,
+        failedLoadingAttempts: current.getLoadingAttempts(),
+      })),
+    toReloading: <a>(): Updater<AsyncState<a>> =>
+      Updater((current) => 
+        current.kind == "loaded" ? 
+          AsyncState.Default.reloading(current.value) 
+        : AsyncState.Updaters.toLoading<a>()(current)),
+    toError: <a>(error?: any): Updater<AsyncState<a>> =>
+      Updater((current) => 
+        AsyncState.Operations.hasValue(current) ? 
+        ({
+        kind: "failed-reload",
+        value:current.value,
+        map,
+        error,
+        getLoadingAttempts,
+        failedLoadingAttempts: current.getLoadingAttempts() + 1,
+      }) : ({
+        kind: "error",
+        map,
+        error,
+        getLoadingAttempts,
+        failedLoadingAttempts: current.getLoadingAttempts() + 1,
+      })),
+    toLoaded: <a>(value: a): Updater<AsyncState<a>> =>
+      Updater((_) => ({ kind: "loaded", value, map, getLoadingAttempts })),
+  },
+  Operations: {
+    map: <a, b>(f: BasicFun<a, b>): Fun<AsyncState<a>, AsyncState<b>> =>
+      Fun((_) => _.map(f)),
+    status:<a>(_:AsyncState<a>) : a | AsyncState<a>["kind"] =>
+        _.kind == "loaded" || _.kind == "reloading" ? _.value : _.kind,
+    hasValue:<a>(_:AsyncState<a>) : _ is HasValueAsyncState<a> =>
+      _.kind == "loaded" || _.kind == "reloading" || _.kind == "failed-reload",
+    isLoading:<a>(_:AsyncState<a>) : _ is IsLoadingAsyncState<a> =>
+      _.kind == "loading" || _.kind == "reloading",
+    errors:<a>(_:AsyncState<a>) : Array<any> =>
+      _.kind == "error" ? [_.error] : [],
+  },
+};

package/src/baseEntity/domains/identifiable/state.ts

@@ -0,0 +1,29 @@
+import { Map, OrderedMap } from "immutable" 
+
+export type Guid = string;
+
+export type Identifiable = { Id: Guid };
+export type SmallIdentifiable = { id: string };
+
+export const Identifiable = {
+  Operations:{
+    toMap:<T extends Identifiable>(
+      values: Array<T>
+    ): Map<Guid, T> => Map(values.map((_) => [_.Id, _])),
+    toOrderedMap:<T extends Identifiable>(
+      values: Array<T>
+    ): OrderedMap<Guid, T> => OrderedMap(values.map((_) => [_.Id, _]))
+
+  }    
+}
+
+export const SmallIdentifiable = {
+  Operations:{
+    toMap:<T extends SmallIdentifiable>(
+      values: Array<T>
+    ): Map<Guid, T> => Map(values.map((_) => [_.id, _])),
+    toOrderedMap:<T extends SmallIdentifiable>(
+      values: Array<T>
+    ): OrderedMap<Guid, T> => OrderedMap(values.map((_) => [_.id, _]))
+  }    
+}

package/src/collections/domains/array/state.ts

@@ -0,0 +1,16 @@
+import { BasicFun, Fun } from "../../../fun/state";
+
+export const ArrayRepo = {
+	Operations: {
+		map: <a, b>(f: BasicFun<a, b>): Fun<Array<a>, Array<b>> => Fun(_ => _.map(f))
+	}
+};
+
+declare global {
+  interface Array<T> {
+    random(): T;
+  }
+}
+Array.prototype.random = function <a>(this:Array<a>) : a {
+  return this[Math.floor((Math.random() * this.length))];
+};

package/src/collections/domains/immutable/domains/list/state.ts

@@ -0,0 +1,20 @@
+import { List } from "immutable";
+import { Updater } from "../../../../../fun/domains/updater/state";
+import { BasicFun } from "../../../../../fun/state";
+
+export const ListRepo = {
+  Default: {
+
+  },
+  Updaters: {
+    push<V>(v:V): Updater<List<V>> {
+      return Updater((_) => _.push(v));
+    },
+    filter<V>(predicate: BasicFun<V, boolean>): Updater<List<V>> {
+      return Updater((_) => _.filter(predicate));
+    },
+  },
+  Operations: {
+  },
+};
+

package/src/collections/domains/immutable/domains/map/state.ts

@@ -0,0 +1,33 @@
+import { Map } from "immutable";
+import { Identifiable } from "../../../../../baseEntity/domains/identifiable/state";
+import { Unit } from "../../../../../fun/domains/unit/state";
+import { BasicUpdater, Updater } from "../../../../../fun/domains/updater/state";
+import { BasicFun } from "../../../../../fun/state";
+
+export const MapRepo = {
+  Default: {
+    fromIdentifiables: <T extends Identifiable>(array: T[]): Map<T["Id"], T> =>
+      Map(
+        array.reduce<Record<string, T>>((acc, item) => {
+          acc[item.Id] = item;
+          return acc;
+        }, {})
+      ),
+  },
+  Updaters:{
+    set<K, V>(key: K, value: V): Updater<Map<K, V>> {
+      return Updater((_) => _.set(key, value));
+    },
+    remove<K, V>(key: K): Updater<Map<K, V>> {
+      return Updater((_) => _.remove(key));
+    },
+    update: <k, v>(k: k, _: BasicUpdater<v>): Updater<Map<k, v>> =>
+      Updater((current) =>
+        current.has(k) ? current.set(k, _(current.get(k)!)) : current
+      ),
+    upsert: <k, v>(k: k, defaultValue:BasicFun<Unit,v>, _: BasicUpdater<v>): Updater<Map<k, v>> =>
+      Updater((current) =>
+        current.has(k) ? current.set(k, _(current.get(k)!)) : current.set(k, _(defaultValue({})))
+      ),
+  }
+};

package/src/collections/domains/immutable/domains/orderedMap/state.ts

@@ -0,0 +1,117 @@
+import { OrderedMap } from "immutable";
+import { Identifiable, SmallIdentifiable } from "../../../../../baseEntity/domains/identifiable/state";
+import { BasicUpdater, Updater } from "../../../../../fun/domains/updater/state";
+import { BasicFun } from "../../../../../fun/state";
+import { Unit } from "../../../../../../main";
+
+export const OrderedMapRepo = {
+  Default: {
+    fromSmallIdentifiables: <T extends SmallIdentifiable>(
+      array: T[]
+    ): OrderedMap<T["id"], T> =>
+      OrderedMap(
+        array.reduce(
+          (acc, item) => {
+            acc[item.id] = item;
+            return acc;
+          },
+          {} as Record<string, T>
+        )
+      ),
+    fromIdentifiables: <T extends Identifiable>(
+      array: T[]
+    ): OrderedMap<T["Id"], T> =>
+      OrderedMap(
+        array.reduce(
+          (acc, item) => {
+            acc[item.Id] = item;
+            return acc;
+          },
+          {} as Record<string, T>
+        )
+      ),
+  },
+  Updaters: {
+    replaceAndMerge<K, V>(
+      key: K,
+      originalMap: OrderedMap<K, V>,
+      mergeMap: OrderedMap<K, V>
+    ) {
+      const index = originalMap.keySeq().findIndex((k) => k === key);
+
+      let newMap = originalMap.remove(key);
+
+      mergeMap.entrySeq().forEach((entry, idx) => {
+        newMap = newMap
+          .slice(0, index + idx)
+          .concat([[entry[0], entry[1]]], newMap.slice(index + idx));
+      });
+
+      return newMap;
+    },
+    filter<K, V>(predicate: BasicFun<[K, V], boolean>): Updater<OrderedMap<K, V>> {
+      return Updater((_) => _.filter((v: V, k: K) => predicate([k, v])))
+    },
+    set<K, V>(key: K, value: V): Updater<OrderedMap<K, V>> {
+      return Updater((_) => _.set(key, value));
+    },
+    insertAtBeginning<K, V>(key: K, value: V): Updater<OrderedMap<K,V>> {
+      return Updater((_) =>   OrderedMap<K, V>(_.toArray().toSpliced(0, 0, [key, value])))
+    },
+    insertAtEnd<K, V>(key: K, value: V): Updater<OrderedMap<K,V>> {
+      return Updater((_) =>   OrderedMap<K, V>(_.toArray().toSpliced(_.size, 0, [key, value])))
+    },
+    insertAt<K, V>([key, value] : [K, V], insertionPosition: K, order: "before" | "after"): Updater<OrderedMap<K,V>> {
+      return Updater((_) =>   { const __ = _.toArray();
+                                const insertionIndex = __.findIndex((value) => value[0] == insertionPosition) + (order == "after" ? 1 : 0)
+                                return OrderedMap(__.toSpliced(insertionIndex, 0, [key, value]))})
+    },
+    remove<K, V>(key: K): Updater<OrderedMap<K, V>> {
+      return Updater((_) => _.remove(key));
+    },
+    clear<K, V>(): Updater<OrderedMap<K, V>> {
+      return Updater((_) => OrderedMap<K,V>());
+    },
+    merge<K, V>(
+      key: K,
+      originalMap: OrderedMap<K, V>,
+      mergeMap: OrderedMap<K, V>
+    ) {
+      const index = originalMap.keySeq().findIndex((k) => k === key);
+
+      mergeMap.entrySeq().forEach((entry, idx) => {
+        originalMap = originalMap
+          .slice(0, index + idx)
+          .concat([[entry[0], entry[1]]], originalMap.slice(index + idx));
+      });
+
+      return originalMap;
+    },
+    update: <k, v>(k: k, _: BasicUpdater<v>): Updater<OrderedMap<k, v>> =>
+      Updater((current) =>
+        current.has(k) ? current.set(k, _(current.get(k)!)) : current
+      ),
+    upsert: <k, v>(k: k, defaultValue: BasicFun<Unit, v>, _: BasicUpdater<v>): Updater<OrderedMap<k, v>> =>
+      Updater((current) =>
+        current.has(k) ? current.set(k, _(current.get(k)!)) : current.set(k, _(defaultValue({})))
+      ),
+    append: <k, v>(
+      newEntries:Array<[k, v]>
+    ) : Updater<OrderedMap<k, v>> =>
+      Updater(current => 
+        OrderedMap([...current.toArray(), ...newEntries])
+      ),
+    prepend: <k, v>(
+      newEntries:Array<[k, v]>
+    ) : Updater<OrderedMap<k, v>> =>
+      Updater(current => 
+        OrderedMap([...newEntries, ...current.toArray()])
+      ),
+  
+  },
+  Operations: {
+    toArray: <T extends Identifiable>(map: OrderedMap<T["Id"], T>) =>
+      map.valueSeq().toArray(),
+  },
+};
+

package/src/collections/domains/immutable/domains/ordereredSet/state.ts

@@ -0,0 +1,19 @@
+import { Set } from "immutable";
+import { Updater } from "../../../../../fun/domains/updater/state";
+
+export const SetRepo = {
+  Updaters: {
+    add: <e>(e: e): Updater<Set<e>> =>
+      Updater(current =>
+        current.add(e)
+      ),
+    remove: <e>(e: e): Updater<Set<e>> =>
+      Updater(current =>
+        current.remove(e)
+      ),
+    subtract: <e>(elements: Iterable<e>): Updater<Set<e>> =>
+      Updater(current =>
+        current.subtract(elements)
+      )
+  }
+}

package/src/collections/domains/immutable/domains/set/state.ts

@@ -0,0 +1,15 @@
+import { OrderedSet } from "immutable";
+import { Updater } from "../../../../../fun/domains/updater/state";
+
+export const OrderedSetRepo = {
+  Updaters:{
+    add:<e>(e:e) : Updater<OrderedSet<e>> =>
+      Updater(current =>
+        current.add(e)
+      ),
+    subtract:<e>(elements:Iterable<e>) : Updater<OrderedSet<e>> =>
+      Updater(current =>
+        current.subtract(elements)
+      )
+  }
+}

package/src/collections/domains/maybe/state.ts

@@ -0,0 +1,20 @@
+import { unit, Unit } from "../../../fun/domains/unit/state";
+import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
+import { BasicFun, Fun } from "../../../fun/state";
+
+export type Maybe<e> = e | undefined;
+export const Maybe = {
+  Default: <e>(_: e | undefined) => _,
+  Updaters: {
+    value: <e>(_: BasicUpdater<e>): Updater<Maybe<e>> =>
+      Updater(Maybe.Operations.map(_)),
+    ensureValue: <e>(_: BasicFun<Unit, e>): Updater<Maybe<e>> =>
+      Updater((__) => (__ != undefined ? __ : _(unit))),
+  },
+  Operations: {
+    map: <a, b>(f: BasicFun<a, b>): Fun<Maybe<a>, Maybe<b>> =>
+      Fun<Maybe<a>, Maybe<b>>((_) =>
+        _ != undefined ? Maybe.Default(f(_)) : Maybe.Default(undefined)
+      ),
+  },
+};

package/src/collections/domains/product/state.ts

@@ -0,0 +1,47 @@
+import { id } from "../../../fun/domains/id/state";
+import { Unit } from "../../../fun/domains/unit/state";
+import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
+import { BasicFun, Fun } from "../../../fun/state";
+
+export type Product<a, b> = { left:a, right:b };
+export type Pair<a, b> = Product<a, b>;
+export const Product = Object.assign(
+  <a, b>() => ({
+    Default: (left:a, right:b) : Product<a,b> => ({ left, right }),
+    Updaters: {
+      left: Fun(
+        (_: BasicUpdater<a>): Updater<Product<a, b>> =>
+          Updater(Product<a, b>().Operations.map2(_, id))
+      ),
+      right: Fun(
+        (_: BasicUpdater<b>): Updater<Product<a, b>> =>
+          Updater(Product<a, b>().Operations.map2(id, _))
+      ),
+    },
+    Operations: {
+      map2: <a1, b1>(
+        l: BasicFun<a, a1>,
+        r: BasicFun<b, b1>
+      ): Fun<Product<a, b>, Product<a1, b1>> =>
+        Fun(_ => Product.Default(l(_.left), r(_.right))),
+    },
+  }),
+  {
+    Default: <a,b>(left:a, right:b) : Product<a,b> => ({ left, right }),
+    Updaters: {
+      left: 
+        <a,b>(_: BasicUpdater<a>): Updater<Product<a, b>> =>
+          Updater(Product<a, b>().Operations.map2(_, id)),
+      right: 
+      <a,b>(_: BasicUpdater<b>): Updater<Product<a, b>> =>
+          Updater(Product<a, b>().Operations.map2(id, _)),
+    },
+    Operations: {
+      map2: <a, b, a1, b1>(
+        l: BasicFun<a, a1>,
+        r: BasicFun<b, b1>
+      ): Fun<Product<a, b>, Product<a1, b1>> =>
+        Fun(_ => Product.Default(l(_.left), r(_.right))),
+    },
+  }
+);

package/src/collections/domains/sum/state.ts

@@ -0,0 +1,82 @@
+import { id } from "../../../fun/domains/id/state";
+import { Unit } from "../../../fun/domains/unit/state";
+import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
+import { BasicFun, Fun } from "../../../fun/state";
+export type LeftValue<a> = { value: a; kind: "l" };
+export const LeftValue = {
+  Updaters: {
+    value: <a>(_: BasicUpdater<a>): Updater<LeftValue<a>> =>
+      Updater((v) => ({ ...v, value: _(v.value) })),
+  },
+};
+export type RightValue<b> = { value: b; kind: "r" };
+export const RightValue = {
+  Updaters: {
+    value: <b>(_: BasicUpdater<b>): Updater<RightValue<b>> =>
+      Updater((v) => ({ ...v, value: _(v.value) })),
+  },
+};
+export type Sum<a, b> = { value: a; kind: "l" } | { value: b; kind: "r" };
+export type Either<a, b> = Sum<a, b>;
+export const Sum = Object.assign(
+  <a, b>() => ({
+    Default: {
+      left: Fun((_: a): Sum<a, b> => ({ value: _, kind: "l" })),
+      right: Fun((_: b): Sum<a, b> => ({ value: _, kind: "r" })),
+    },
+    Updaters: {
+      left: Fun(
+        (_: BasicUpdater<a>): Updater<Sum<a, b>> =>
+          Updater(Sum<a, b>().Updaters.map2(_, id))
+      ),
+      right: Fun(
+        (_: BasicUpdater<b>): Updater<Sum<a, b>> =>
+          Updater(Sum<a, b>().Updaters.map2(id, _))
+      ),
+      map2: <a, b, a1, b1>(
+        l: BasicFun<a, a1>,
+        r: BasicFun<b, b1>
+      ): Fun<Sum<a, b>, Sum<a1, b1>> =>
+        Sum<a, b>().Operations.fold<a, b, Sum<a1, b1>>(
+          Fun(l).then(Sum<a1, b1>().Default.left),
+          Fun(r).then(Sum<a1, b1>().Default.right)
+        ),
+    },
+    Operations: {
+      fold: <a, b, c>(
+        l: BasicFun<a, c>,
+        r: BasicFun<b, c>
+      ): Fun<Sum<a, b>, c> =>
+        Fun((_) => (_.kind == "l" ? l(_.value) : r(_.value))),
+    },
+  }),
+  {
+    Default: {
+      left: <a, b>(_: a): Sum<a, b> => ({ value: _, kind: "l" }),
+      right: <a, b>(_: b): Sum<a, b> => ({ value: _, kind: "r" }),
+    },
+    Updaters: {
+      left: <a, b>(_: BasicUpdater<a>): Updater<Sum<a, b>> =>
+        Updater(Sum.Updaters.map2(_, id)),
+      right: <a, b>(_: BasicUpdater<b>): Updater<Sum<a, b>> =>
+        Updater(Sum.Updaters.map2(id, _)),
+      map2: <a, b, a1, b1>(
+        l: BasicFun<a, a1>,
+        r: BasicFun<b, b1>
+      ): Fun<Sum<a, b>, Sum<a1, b1>> =>
+        Sum.Operations.fold<a, b, Sum<a1, b1>>(
+          Fun(l).then(Sum.Default.left<a1, b1>),
+          Fun(r).then(Sum.Default.right<a1, b1>)
+        ),
+    },
+    Operations: {
+      fold: <a, b, c>(
+        l: BasicFun<a, c>,
+        r: BasicFun<b, c>
+      ): Fun<Sum<a, b>, c> =>
+        Fun((_) => (_.kind == "l" ? l(_.value) : r(_.value))),
+    },
+  }
+);
+export const Either = Sum;
+export type Option<a> = Sum<Unit, a>;

package/src/coroutines/builder.tsx

@@ -0,0 +1,66 @@
+import { Map, Collection, OrderedMap } from "immutable";
+import { Unit } from "../fun/domains/unit/state";
+import { BasicUpdater } from "../fun/domains/updater/state";
+import { BasicFun } from "../fun/state";
+import { Template, createTemplate } from "../template/state";
+import { Coroutine, InboundEventFromContext, InboundKindFromContext } from "./state";
+import { CoroutineComponentOptions, CoroutineTemplate } from "./template";
+import { Guid } from "../baseEntity/domains/identifiable/state";
+import { SimpleCallback } from "../fun/domains/simpleCallback/state";
+
+export const CoTypedFactory = Object.assign(<c, s>() => ({
+  Seq: Coroutine.Seq<c & s, s>,
+  GetState: Coroutine.GetState<c & s, s>,
+  SetState: Coroutine.SetState<c & s, s>,
+  UpdateState: Coroutine.UpdateState<c & s, s>,
+  Any: Coroutine.Any<c & s, s, Unit>,
+  All:<result,>(ps: Array<Coroutine<c & s, s, result>>) => Coroutine.All<c & s, s, result>(ps),
+  Yield: Coroutine.Yield<c & s, s, Unit>,
+  Wait: Coroutine.Wait<c & s, s>,
+  Await: <r, err>(
+    p: BasicFun<Unit, Promise<r>>,
+    onErr: BasicFun<any, err>,
+    debugName?: string
+  ) => Coroutine.Await<c & s, s, r, err>(p, onErr, debugName),
+  Repeat: Coroutine.Repeat<c & s, s>,
+  Return: <r,>(res: r) => Coroutine.Return<c & s, s, r>(res),
+  While: Coroutine.While<c & s, s>,
+  For: <element,>(collection:Collection<number, element>) => (p:BasicFun<element, Coroutine<c & s, s, Unit>>) => 
+    Coroutine.For<c & s, s, element>(collection, p),
+  Embed: <parentContext, parentState, result>(
+    p: Coroutine<c &s, s, result>,
+    narrow:BasicFun<parentContext & parentState, c &s>,
+    widen:BasicFun<BasicUpdater<s>,BasicUpdater<parentState>>
+  ): Coroutine<parentContext & parentState, parentState, result> =>
+    Coroutine.Embed(p, narrow, widen),
+  Template:<fm,>(
+    initialCoroutine: Coroutine<c & s, s, Unit>,
+    options?: CoroutineComponentOptions<c & s, s>
+  ) : Template<c & s , s, fm> => createTemplate(
+      props => (options?.runFilter || (_ => true))({...props, foreignMutations:{}}) ? CoroutineTemplate<c & s, s, fm>()({
+      ...props,
+      context:{
+        ...props.context, 
+        initialCoroutine,
+        options,
+      },
+    }) : <></>
+  ),
+  Trigger:<event extends { id:Guid, kind:kind }, kind extends string>(event:event)
+    : Coroutine<c & s & { outboundEvents:Map<kind, OrderedMap<Guid, event>> }, s & { outboundEvents:Map<kind, OrderedMap<Guid, event>> }, Unit> => 
+    Coroutine.Trigger<c & s & { outboundEvents:Map<kind, OrderedMap<Guid, event>> }, s & { outboundEvents:Map<kind, OrderedMap<Guid, event>> }, event, kind>(event),
+  Do:(action:SimpleCallback<void>)
+    : Coroutine<c & s, s, Unit> => 
+    Coroutine.Do(action),
+}), 
+{
+  withOn:<eventKind, event, c, s extends { inboundEvents: Map<eventKind, OrderedMap<Guid, event>> }>() => ({
+    ...CoTypedFactory<c,s>(),
+    On:<matchedEvent extends InboundKindFromContext<c & s>>(
+      kind:matchedEvent, 
+      filter?:BasicFun<[InboundEventFromContext<c & s> & { kind:matchedEvent }, c & s], boolean>)
+      : Coroutine<c & s, s, InboundEventFromContext<c & s> & { kind:matchedEvent }> => {
+        return Coroutine.On<eventKind, event, c & s, s, matchedEvent>(kind, filter)
+      },
+  })
+});