@typed/template 0.5.4 → 0.7.0

package/src/ElementSource.ts

@@ -29,12 +29,12 @@ export interface ElementSource<
   Versioned.Versioned<
     never,
     never,
-    Scope.Scope,
-    never,
     Rendered.Elements<T>,
     never,
+    Scope.Scope,
+    Rendered.Elements<T>,
     NoSuchElementException,
-    Rendered.Elements<T>
+    never
   >
 {
   readonly selector: Selector
@@ -49,21 +49,21 @@ export interface ElementSource<
     ): ElementSource<Target, EventMap>
   }
 
-  readonly elements: RefSubject.Filtered<never, never, Rendered.Elements<T>>
+  readonly elements: RefSubject.Filtered<Rendered.Elements<T>>
 
   readonly events: <Type extends keyof EventMap>(
     type: Type,
     options?: AddEventListenerOptions
-  ) => Fx.Fx<Scope.Scope, never, EventWithCurrentTarget<Rendered.Elements<T>[number], EventMap[Type]>>
+  ) => Fx.Fx<EventWithCurrentTarget<Rendered.Elements<T>[number], EventMap[Type]>, never, Scope.Scope>
 
-  readonly dispatchEvent: (event: Event, wait?: DurationInput) => Effect.Effect<never, NoSuchElementException, void>
+  readonly dispatchEvent: (event: Event, wait?: DurationInput) => Effect.Effect<void, NoSuchElementException>
 }
 
 /**
  * @since 1.0.0
  */
 export function ElementSource<T extends Rendered, EventMap extends {} = DefaultEventMap<T>>(
-  rootElement: RefSubject.Filtered<never, never, T>
+  rootElement: RefSubject.Filtered<T>
 ): ElementSource<T, EventMap> {
   return new ElementSourceImpl<T, EventMap>(rootElement) as any
 }
@@ -165,7 +165,7 @@ function makeEventStream<Ev extends Event>(
   eventName: string,
   options: EventListenerOptions = {}
 ) {
-  return function(element: Rendered): Fx.Fx<never, never, Ev> {
+  return function(element: Rendered): Fx.Fx<Ev> {
     const { capture } = options
     const cssSelector = cssSelectors.join(" ")
     const lastTwoCssSelectors = cssSelectors.slice(-2).join("")
@@ -174,7 +174,7 @@ function makeEventStream<Ev extends Event>(
     const event$ = Fx.mergeAll(
       elements.map((element) =>
         Fx.filter(
-          Fx.make<never, never, Ev>((sink) =>
+          Fx.make<Ev>((sink) =>
             Effect.scoped(Effect.zipRight(
               addEventListener(element, {
                 eventName,
@@ -203,14 +203,14 @@ function makeElementEventStream<Ev extends Event>(
   eventName: string,
   options: EventListenerOptions = {}
 ) {
-  return function(rendered: Rendered): Fx.Fx<never, never, Ev> {
+  return function(rendered: Rendered): Fx.Fx<Ev> {
     const { capture } = options
     const elements = getElements(rendered)
 
     const event$ = Fx.mergeAll(
       elements.map((element) =>
         Fx.filter(
-          Fx.make<never, never, Ev>((sink) =>
+          Fx.make<Ev>((sink) =>
             Effect.scoped(Effect.zipRight(
               addEventListener(element, {
                 eventName,
@@ -295,17 +295,17 @@ function isElement(element: RenderedWithoutArray): element is Element {
 export class ElementSourceImpl<
   T extends Rendered,
   EventMap extends {} = DefaultEventMap<Rendered.Elements<T>[number]>
-> extends FxEffectBase<Scope.Scope, never, Rendered.Elements<T>, never, NoSuchElementException, Rendered.Elements<T>>
+> extends FxEffectBase<Rendered.Elements<T>, never, Scope.Scope, Rendered.Elements<T>, NoSuchElementException, never>
   implements ElementSource<T, EventMap>
 {
-  private bubbleMap = new Map<any, Fx.Fx<Scope.Scope, never, any>>()
-  private captureMap = new Map<any, Fx.Fx<Scope.Scope, never, any>>()
+  private bubbleMap = new Map<any, Fx.Fx<any, never, Scope.Scope>>()
+  private captureMap = new Map<any, Fx.Fx<any, never, Scope.Scope>>()
 
   readonly elements: ElementSource<T, EventMap>["elements"]
   readonly version: ElementSource<T, EventMap>["version"]
 
   constructor(
-    readonly rootElement: RefSubject.Filtered<never, never, T>,
+    readonly rootElement: RefSubject.Filtered<T>,
     readonly selector: Selector = CssSelectors([])
   ) {
     super()
@@ -326,11 +326,11 @@ export class ElementSourceImpl<
     return new ElementSourceImpl<T>(RefSubject.filterMapEffect(Versioned.of(rootElement), Effect.succeedSome)) as any
   }
 
-  toEffect(): Effect.Effect<never, NoSuchElementException, Rendered.Elements<T>> {
+  toEffect(): Effect.Effect<Rendered.Elements<T>, NoSuchElementException> {
     return this.elements
   }
 
-  toFx(): Fx.Fx<Scope.Scope, never, Rendered.Elements<T>> {
+  toFx(): Fx.Fx<Rendered.Elements<T>, never, Scope.Scope> {
     return this.elements
   }
 
@@ -353,7 +353,7 @@ export class ElementSourceImpl<
   events<Type extends keyof EventMap>(
     type: Type,
     options?: AddEventListenerOptions
-  ): Fx.Fx<Scope.Scope, never, EventWithCurrentTarget<Rendered.Elements<T>[number], EventMap[Type]>> {
+  ): Fx.Fx<EventWithCurrentTarget<Rendered.Elements<T>[number], EventMap[Type]>, never, Scope.Scope> {
     const capture = options?.capture === true
     const map = capture ? this.captureMap : this.bubbleMap
 

package/src/EventHandler.ts

@@ -17,32 +17,32 @@ export type EventHandlerTypeId = typeof EventHandlerTypeId
 /**
  * @since 1.0.0
  */
-export interface EventHandler<R, E, Ev extends Event = Event> extends Placeholder<R, E, null> {
+export interface EventHandler<Ev extends Event = Event, E = never, R = never> extends Placeholder<never, E, R> {
   readonly [EventHandlerTypeId]: EventHandlerTypeId
-  readonly handler: (event: Ev) => Effect<R, E, unknown>
+  readonly handler: (event: Ev) => Effect<unknown, E, R>
   readonly options: AddEventListenerOptions | undefined
 }
 
 /**
  * @since 1.0.0
  */
-export type Context<T> = T extends EventHandler<infer R, infer _E, infer _Ev> ? R : never
+export type Context<T> = T extends EventHandler<infer _Ev, infer _E, infer R> ? R : never
 /**
  * @since 1.0.0
  */
-export type Error<T> = T extends EventHandler<infer _R, infer E, infer _Ev> ? E : never
+export type Error<T> = T extends EventHandler<infer _Ev, infer E, infer _R> ? E : never
 /**
  * @since 1.0.0
  */
-export type EventOf<T> = T extends EventHandler<infer _R, infer _E, infer Ev> ? Ev : never
+export type EventOf<T> = T extends EventHandler<infer Ev, infer _E, infer _R> ? Ev : never
 
 /**
  * @since 1.0.0
  */
 export function make<R, E, Ev extends Event>(
-  handler: (event: Ev) => Effect<R, E, unknown>,
+  handler: (event: Ev) => Effect<unknown, E, R>,
   options?: AddEventListenerOptions
-): EventHandler<R, E, Ev> {
+): EventHandler<Ev, E, R> {
   return {
     [EventHandlerTypeId]: EventHandlerTypeId,
     handler,
@@ -54,9 +54,9 @@ export function make<R, E, Ev extends Event>(
  * @since 1.0.0
  */
 export function preventDefault<R, E, Ev extends Event>(
-  handler: (event: Ev) => Effect<R, E, unknown>,
+  handler: (event: Ev) => Effect<unknown, E, R>,
   options?: AddEventListenerOptions
-): EventHandler<R, E, Ev> {
+): EventHandler<Ev, E, R> {
   return make((ev) => (ev.preventDefault(), handler(ev)), options)
 }
 
@@ -64,9 +64,9 @@ export function preventDefault<R, E, Ev extends Event>(
  * @since 1.0.0
  */
 export function stopPropagation<R, E, Ev extends Event>(
-  handler: (event: Ev) => Effect<R, E, unknown>,
+  handler: (event: Ev) => Effect<unknown, E, R>,
   options?: AddEventListenerOptions
-): EventHandler<R, E, Ev> {
+): EventHandler<Ev, E, R> {
   return make((ev) => (ev.stopPropagation(), handler(ev)), options)
 }
 
@@ -74,9 +74,9 @@ export function stopPropagation<R, E, Ev extends Event>(
  * @since 1.0.0
  */
 export function stopImmediatePropagation<R, E, Ev extends Event>(
-  handler: (event: Ev) => Effect<R, E, unknown>,
+  handler: (event: Ev) => Effect<unknown, E, R>,
   options?: AddEventListenerOptions
-): EventHandler<R, E, Ev> {
+): EventHandler<Ev, E, R> {
   return make((ev) => (ev.stopImmediatePropagation(), handler(ev)), options)
 }
 
@@ -85,9 +85,9 @@ export function stopImmediatePropagation<R, E, Ev extends Event>(
  */
 export function target<T extends HTMLElement>() {
   return <R, E, Ev extends Event>(
-    handler: (event: EventWithTarget<T, Ev>) => Effect<R, E, unknown>,
+    handler: (event: EventWithTarget<T, Ev>) => Effect<unknown, E, R>,
     options?: AddEventListenerOptions
-  ): EventHandler<R, E, EventWithTarget<T, Ev>> => {
+  ): EventHandler<EventWithTarget<T, Ev>, E, R> => {
     return make(handler, options)
   }
 }
@@ -96,9 +96,9 @@ export function target<T extends HTMLElement>() {
  * @since 1.0.0
  */
 export function keys<Keys extends ReadonlyArray<string>>(...keys: Keys) {
-  return <R, E>(
-    handler: (event: KeyboardEvent & { key: Keys[number] }) => Effect<R, E, unknown>,
+  return <E, R>(
+    handler: (event: KeyboardEvent & { key: Keys[number] }) => Effect<unknown, E, R>,
     options?: AddEventListenerOptions
-  ): EventHandler<R, E, KeyboardEvent> =>
+  ): EventHandler<KeyboardEvent, E, R> =>
     make((ev: KeyboardEvent) => !isUsingKeyModifier(ev) && keys.includes(ev.key) ? handler(ev as any) : unit, options)
 }

package/src/Html.ts

@@ -30,9 +30,9 @@ const [padStart, padEnd] = [[TYPED_START], [TYPED_END]] as const
 /**
  * @since 1.0.0
  */
-export function renderToHtml<R, E>(
-  fx: Fx.Fx<R, E, RenderEvent>
-): Fx.Fx<Exclude<R, RenderTemplate> | RenderContext, E, string> {
+export function renderToHtml<E, R>(
+  fx: Fx.Fx<RenderEvent, E, R>
+): Fx.Fx<string, E, Exclude<R, RenderTemplate> | RenderContext> {
   return Fx.fromFxEffect(
     RenderContext.with((ctx) =>
       fx.pipe(
@@ -47,9 +47,9 @@ export function renderToHtml<R, E>(
 /**
  * @since 1.0.0
  */
-export function renderToHtmlString<R, E>(
-  fx: Fx.Fx<R, E, RenderEvent>
-): Effect.Effect<Exclude<R, RenderTemplate> | RenderContext, E, string> {
+export function renderToHtmlString<E, R>(
+  fx: Fx.Fx<RenderEvent, E, R>
+): Effect.Effect<string, E, Exclude<R, RenderTemplate> | RenderContext> {
   return Effect.map(Fx.toReadonlyArray(renderToHtml(fx)), join(""))
 }
 
@@ -58,9 +58,9 @@ function renderHtml(ctx: RenderContext) {
     templateStrings: TemplateStringsArray,
     values: Values
   ): Fx.Fx<
-    Scope.Scope | Placeholder.Context<readonly [] extends Values ? never : Values[number]>,
+    RenderEvent,
     Placeholder.Error<Values[number]>,
-    RenderEvent
+    Scope.Scope | Placeholder.Context<readonly [] extends Values ? never : Values[number]>
   > => {
     const isStatic = ctx.environment === "static"
     const entry = getServerEntry(templateStrings, ctx.templateCache, isStatic)
@@ -71,8 +71,8 @@ function renderHtml(ctx: RenderContext) {
         Fx.mergeOrdered(
           entry.chunks.map((chunk) =>
             renderChunk<
-              Placeholder.Context<readonly [] extends Values ? never : Values[number]>,
-              Placeholder.Error<Values[number]>
+              Placeholder.Error<Values[number]>,
+              Placeholder.Context<readonly [] extends Values ? never : Values[number]>
             >(chunk, values, isStatic)
           )
         ),
@@ -82,21 +82,21 @@ function renderHtml(ctx: RenderContext) {
   }
 }
 
-function renderChunk<R, E>(
+function renderChunk<E, R>(
   chunk: HtmlChunk,
   values: ReadonlyArray<Renderable<any, any>>,
   isStatic: boolean
-): Fx.Fx<R, E, RenderEvent> {
+): Fx.Fx<RenderEvent, E, R> {
   if (chunk._tag === "text") {
     return Fx.succeed(HtmlRenderEvent(chunk.value))
   } else if (chunk._tag === "part") {
-    return renderPart<R, E>(chunk, values, isStatic)
+    return renderPart<E, R>(chunk, values, isStatic)
   } else {
-    return renderSparsePart<R, E>(chunk, values) as Fx.Fx<R, E, RenderEvent>
+    return renderSparsePart<E, R>(chunk, values) as Fx.Fx<RenderEvent, E, R>
   }
 }
 
-function renderNode<R, E>(renderable: Renderable<any, any>, isStatic: boolean): Fx.Fx<R, E, RenderEvent> {
+function renderNode<E, R>(renderable: Renderable<any, any>, isStatic: boolean): Fx.Fx<RenderEvent, E, R> {
   switch (typeof renderable) {
     case "string":
     case "number":
@@ -111,7 +111,7 @@ function renderNode<R, E>(renderable: Renderable<any, any>, isStatic: boolean):
   }
 }
 
-function renderObject<R, E>(renderable: object | null | undefined, isStatic: boolean) {
+function renderObject<E, R>(renderable: object | null | undefined, isStatic: boolean) {
   if (renderable === null || renderable === undefined) {
     return isStatic ? Fx.empty : Fx.succeed(HtmlRenderEvent(TEXT_START))
   } else if (Array.isArray(renderable)) {
@@ -121,8 +121,8 @@ function renderObject<R, E>(renderable: object | null | undefined, isStatic: boo
     return Fx.concatMap(takeOneIfNotRenderEvent(renderable), (r) => renderNode(r, isStatic) as any)
   } else if (Effect.isEffect(renderable)) {
     return Fx.switchMap(
-      Fx.fromEffect(renderable as Effect.Effect<R, E, Renderable>),
-      (r) => renderNode<R, E>(r, isStatic)
+      Fx.fromEffect(renderable as Effect.Effect<Renderable, E, R>),
+      (r) => renderNode<E, R>(r, isStatic)
     )
   } else if (isRenderEvent(renderable)) {
     return Fx.succeed(renderable)
@@ -131,17 +131,17 @@ function renderObject<R, E>(renderable: object | null | undefined, isStatic: boo
   }
 }
 
-function renderPart<R, E>(
+function renderPart<E, R>(
   chunk: PartChunk,
   values: ReadonlyArray<Renderable<any, any>>,
   isStatic: boolean
-): Fx.Fx<R, E, RenderEvent> {
+): Fx.Fx<RenderEvent, E, R> {
   const { node, render } = chunk
   const renderable: Renderable<any, any> = values[node.index]
 
   // Refs and events are not rendered into HTML
-  if (isDirective<R, E>(renderable)) {
-    return Fx.make((sink: Sink.Sink<never, E, RenderEvent>) => {
+  if (isDirective<E, R>(renderable)) {
+    return Fx.make<RenderEvent, E, R>((sink: Sink.Sink<RenderEvent, E>) => {
       const part = partNodeToPart(
         node,
         (value) => sink.onSuccess(HtmlRenderEvent(render(value)))
@@ -150,8 +150,8 @@ function renderPart<R, E>(
       return Effect.catchAllCause(renderable(part), sink.onFailure)
     })
   } else if (node._tag === "node") {
-    if (isStatic) return renderNode<R, E>(renderable, isStatic)
-    return Fx.append(renderNode<R, E>(renderable, isStatic), HtmlRenderEvent(TYPED_HOLE(node.index)))
+    if (isStatic) return renderNode<E, R>(renderable, isStatic)
+    return Fx.append(renderNode<E, R>(renderable, isStatic), HtmlRenderEvent(TYPED_HOLE(node.index)))
   } else if (node._tag === "properties") {
     if (renderable == null) return Fx.empty
     return Fx.map(
@@ -166,7 +166,7 @@ function renderPart<R, E>(
   } else {
     if (renderable === null) return Fx.succeed(HtmlRenderEvent(render(renderable)))
 
-    const html = Fx.filterMap(Fx.take(unwrapRenderable<R, E>(renderable), 1), (value) => {
+    const html = Fx.filterMap(Fx.take(unwrapRenderable<E, R>(renderable), 1), (value) => {
       const s = render(value)
 
       return s ? Option.some(HtmlRenderEvent(s)) : Option.none()
@@ -180,10 +180,10 @@ function renderPart<R, E>(
   }
 }
 
-function renderSparsePart<R, E>(
+function renderSparsePart<E, R>(
   chunk: SparsePartChunk,
   values: ReadonlyArray<Renderable<any, any>>
-): Fx.Fx<R, E, RenderEvent> {
+): Fx.Fx<RenderEvent, E, R> {
   const { node, render } = chunk
 
   return Fx.map(
@@ -194,8 +194,8 @@ function renderSparsePart<R, E>(
 
           const renderable: Renderable<any, any> = (values as any)[node.index]
 
-          if (isDirective<R, E>(renderable)) {
-            return Fx.make<R, E, unknown>((sink: Sink.Sink<never, E, unknown>) =>
+          if (isDirective<E, R>(renderable)) {
+            return Fx.make<unknown, E, R>((sink: Sink.Sink<unknown, E>) =>
               Effect.catchAllCause(
                 renderable(partNodeToPart(node, (value) => sink.onSuccess(value))),
                 sink.onFailure
@@ -203,7 +203,7 @@ function renderSparsePart<R, E>(
             )
           }
 
-          return unwrapRenderable<R, E>(renderable)
+          return unwrapRenderable<E, R>(renderable)
         })
       ),
       1
@@ -212,8 +212,8 @@ function renderSparsePart<R, E>(
   )
 }
 
-function takeOneIfNotRenderEvent<R, E, A>(fx: Fx.Fx<R, E, A>): Fx.Fx<R, E, A> {
-  return Fx.make<R, E, A>((sink) =>
+function takeOneIfNotRenderEvent<A, E, R>(fx: Fx.Fx<A, E, R>): Fx.Fx<A, E, R> {
+  return Fx.make<A, E, R>((sink) =>
     Sink.withEarlyExit(sink, (sink) =>
       fx.run(
         Sink.make(
@@ -249,7 +249,7 @@ function getServerEntry(
   }
 }
 
-function unwrapRenderable<R, E>(renderable: Renderable<any, any>): Fx.Fx<R, E, any> {
+function unwrapRenderable<E, R>(renderable: Renderable<any, any>): Fx.Fx<any, E, R> {
   switch (typeof renderable) {
     case "undefined":
     case "object": {

package/src/Hydrate.ts

@@ -20,8 +20,8 @@ import { RenderTemplate } from "./RenderTemplate.js"
  * @since 1.0.0
  */
 export function hydrate<R, E, T extends RenderEvent | null>(
-  rendered: Fx.Fx<R, E, T>
-): Fx.Fx<Exclude<R, RenderTemplate> | Document | RenderContext | RootElement, E, ToRendered<T>> {
+  rendered: Fx.Fx<T, E, R>
+): Fx.Fx<ToRendered<T>, E, Exclude<R, RenderTemplate> | Document | RenderContext | RootElement> {
   return Fx.fromFxEffect(Effect.contextWith((context) => {
     const [document, renderContext, { rootElement }] = Context.getMany(context, Document, RenderContext, RootElement)
     const ctx: HydrateContext = {
@@ -40,14 +40,14 @@ export function hydrate<R, E, T extends RenderEvent | null>(
       Fx.mapEffect(rendered, (what) => attachRoot(renderContext.renderCache, rootElement, what)),
       layer
     )
-  })) as Fx.Fx<Exclude<R, RenderTemplate> | Document | RenderContext | RootElement, E, ToRendered<T>>
+  })) as Fx.Fx<ToRendered<T>, E, Exclude<R, RenderTemplate> | Document | RenderContext | RootElement>
 }
 
 /**
  * @since 1.0.0
  */
 export function hydrateLayer<R, E, T extends RenderEvent | null>(
-  rendered: Fx.Fx<R, E, T>
+  rendered: Fx.Fx<T, E, R>
 ) {
   return Fx.drainLayer(Fx.switchMapCause(hydrate(rendered), (cause) => Fx.fromEffect(Effect.logError(cause))))
 }

package/src/Many.ts

@@ -20,14 +20,14 @@ import { HtmlRenderEvent, type RenderEvent } from "./RenderEvent.js"
 /**
  * @since 1.0.0
  */
-export function many<R, E, A, B extends PropertyKey, R2, E2>(
-  values: Fx.Fx<R, E, ReadonlyArray<A>>,
+export function many<A, E, R, B extends PropertyKey, R2, E2>(
+  values: Fx.Fx<ReadonlyArray<A>, E, R>,
   getKey: (a: NoInfer<A>) => B,
-  f: (a: RefSubject.RefSubject<never, never, NoInfer<A>>, key: B) => Fx.Fx<R2, E2, RenderEvent>
-): Fx.Fx<R | R2 | Scope.Scope | RenderContext, E | E2, RenderEvent | ReadonlyArray<RenderEvent>> {
+  f: (a: RefSubject.RefSubject<NoInfer<A>>, key: B) => Fx.Fx<RenderEvent, E2, R2>
+): Fx.Fx<RenderEvent | ReadonlyArray<RenderEvent>, E | E2, R | R2 | Scope.Scope | RenderContext> {
   return Fx.fromFxEffect(
     Effect.contextWith(
-      (context): Fx.Fx<R | R2 | RenderContext | Scope.Scope, E | E2, RenderEvent | ReadonlyArray<RenderEvent>> => {
+      (context): Fx.Fx<RenderEvent | ReadonlyArray<RenderEvent>, E | E2, R | R2 | RenderContext | Scope.Scope> => {
         const ctx = get(context, RenderContext)
         const hydrateContext = getOption(context, HydrateContext)
 
@@ -87,15 +87,15 @@ export const manyAsyncData: {
     matchers: {
       NoData: () => NoData
       Loading: (todo: TODO) => Loading
-      Failure: (data: RefSubject.Computed<never, never, E1>, computed: TODO) => Failure
-      Success: (value: RefSubject.Computed<never, never, A>, computed: TODO) => Success
+      Failure: (data: RefSubject.Computed<E1>, computed: TODO) => Failure
+      Success: (value: RefSubject.Computed<A>, computed: TODO) => Success
     }
-  ): <R, E>(
-    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, ReadonlyArray<A>>>
+  ): <E, R>(
+    fx: Fx.Fx<AsyncData.AsyncData<ReadonlyArray<A>, E1>, E, R>
   ) => Fx.Fx<
-    R | Fx.Fx.Context<NoData | Loading | Failure | Success>,
+    Fx.Fx.Success<NoData | Loading | Failure | Success>,
     E | Fx.Fx.Error<NoData | Loading | Failure | Success>,
-    Fx.Fx.Success<NoData | Loading | Failure | Success>
+    R | Fx.Fx.Context<NoData | Loading | Failure | Success>
   >
 
   <
@@ -109,18 +109,18 @@ export const manyAsyncData: {
     Failure extends Fx.Fx<any, any, any>,
     Success extends Fx.Fx<any, any, any>
   >(
-    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, ReadonlyArray<A>>>,
+    fx: Fx.Fx<AsyncData.AsyncData<ReadonlyArray<A>, E1>, E, R>,
     getKey: (a: A) => B,
     matchers: {
       NoData: () => NoData
       Loading: (data: TODO) => Loading
-      Failure: (data: RefSubject.Computed<never, never, E1>, computed: TODO) => Failure
-      Success: (value: RefSubject.Computed<never, never, A>, computed: TODO) => Success
+      Failure: (data: RefSubject.Computed<E1>, computed: TODO) => Failure
+      Success: (value: RefSubject.Computed<A>, computed: TODO) => Success
     }
   ): Fx.Fx<
-    R | Fx.Fx.Context<NoData | Loading | Failure | Success>,
+    Fx.Fx.Success<NoData | Loading | Failure | Success>,
     E | Fx.Fx.Error<NoData | Loading | Failure | Success>,
-    Fx.Fx.Success<NoData | Loading | Failure | Success>
+    R | Fx.Fx.Context<NoData | Loading | Failure | Success>
   >
 } = dual(
   3,
@@ -130,23 +130,23 @@ export const manyAsyncData: {
     E1,
     A,
     B extends PropertyKey,
-    NoData extends Fx.Fx<any, any, RenderEvent>,
-    Loading extends Fx.Fx<any, any, RenderEvent>,
-    Failure extends Fx.Fx<any, any, RenderEvent>,
-    Success extends Fx.Fx<any, any, RenderEvent>
+    NoData extends Fx.Fx<RenderEvent, any, any>,
+    Loading extends Fx.Fx<RenderEvent, any, any>,
+    Failure extends Fx.Fx<RenderEvent, any, any>,
+    Success extends Fx.Fx<RenderEvent, any, any>
   >(
-    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, ReadonlyArray<A>>>,
+    fx: Fx.Fx<AsyncData.AsyncData<ReadonlyArray<A>, E1>, E, R>,
     getKey: (a: A) => B,
     matchers: {
       NoData: NoData
-      Loading: (data: RefSubject.Filtered<never, never, Progress>) => Loading
-      Failure: (data: RefSubject.Computed<never, never, E1>) => Failure
-      Success: (value: RefSubject.Computed<never, never, A>, key: B) => Success
+      Loading: (data: RefSubject.Filtered<Progress>) => Loading
+      Failure: (data: RefSubject.Computed<E1>) => Failure
+      Success: (value: RefSubject.Computed<A>, key: B) => Success
     }
   ): Fx.Fx<
-    R | Fx.Fx.Context<NoData | Loading | Failure | Success>,
+    RenderEvent | ReadonlyArray<RenderEvent>,
     E | Fx.Fx.Error<NoData | Loading | Failure | Success>,
-    RenderEvent | ReadonlyArray<RenderEvent>
+    R | Fx.Fx.Context<NoData | Loading | Failure | Success>
   > => {
     return RefAsyncData.matchAsyncData(fx, {
       NoData: matchers.NoData,

package/src/Part.ts

@@ -33,7 +33,7 @@ export interface AttributePart {
   readonly value: string | null | undefined
   readonly index: number
 
-  readonly update: (value: this["value"]) => Effect<Scope, never, void>
+  readonly update: (value: this["value"]) => Effect<void, never, Scope>
 }
 
 /**
@@ -45,7 +45,7 @@ export interface BooleanPart {
   readonly value: boolean | null | undefined
   readonly index: number
 
-  readonly update: (value: this["value"]) => Effect<Scope, never, void>
+  readonly update: (value: this["value"]) => Effect<void, never, Scope>
 }
 
 /**
@@ -56,7 +56,7 @@ export interface ClassNamePart {
   readonly value: ReadonlyArray<string> | null | undefined
   readonly index: number
 
-  readonly update: (value: this["value"]) => Effect<Scope, never, void>
+  readonly update: (value: this["value"]) => Effect<void, never, Scope>
 }
 
 /**
@@ -67,7 +67,7 @@ export interface DataPart {
   readonly value: Readonly<Record<string, string | undefined>> | null | undefined
   readonly index: number
 
-  readonly update: (value: this["value"]) => Effect<Scope, never, void>
+  readonly update: (value: this["value"]) => Effect<void, never, Scope>
 }
 
 /**
@@ -79,8 +79,8 @@ export interface EventPart {
   readonly source: ElementSource<any>
   readonly value: null
   readonly index: number
-  readonly onCause: (cause: Cause<unknown>) => Effect<never, never, unknown>
-  readonly addEventListener: (handler: EventHandler<never, never, Event>) => void
+  readonly onCause: (cause: Cause<unknown>) => Effect<unknown>
+  readonly addEventListener: (handler: EventHandler<Event>) => void
 }
 
 /**
@@ -92,7 +92,7 @@ export interface PropertyPart {
   readonly value: unknown
   readonly index: number
 
-  readonly update: (value: this["value"]) => Effect<Scope, never, void>
+  readonly update: (value: this["value"]) => Effect<void, never, Scope>
 }
 
 /**
@@ -112,7 +112,7 @@ export interface CommentPart {
   readonly value: string | null | undefined
   readonly index: number
 
-  readonly update: (value: this["value"]) => Effect<Scope, never, void>
+  readonly update: (value: this["value"]) => Effect<void, never, Scope>
 }
 
 /**
@@ -123,7 +123,7 @@ export interface TextPart {
   readonly value: string | null | undefined
   readonly index: number
 
-  readonly update: (value: this["value"]) => Effect<Scope, never, void>
+  readonly update: (value: this["value"]) => Effect<void, never, Scope>
 }
 
 /**
@@ -134,7 +134,7 @@ export interface NodePart {
   readonly value: unknown
   readonly index: number
 
-  readonly update: (value: this["value"]) => Effect<Scope, never, void>
+  readonly update: (value: this["value"]) => Effect<void, never, Scope>
 }
 
 /**
@@ -145,7 +145,7 @@ export interface PropertiesPart {
   readonly value: Readonly<Record<string, any>> | null | undefined
   readonly index: number
 
-  readonly update: (value: this["value"]) => Effect<Scope, never, void>
+  readonly update: (value: this["value"]) => Effect<void, never, Scope>
 }
 
 /**
@@ -161,7 +161,7 @@ export interface SparseAttributePart {
   readonly name: string
   readonly parts: ReadonlyArray<AttributePart | StaticText>
 
-  readonly update: (value: ReadonlyArray<string>) => Effect<Scope, never, void>
+  readonly update: (value: ReadonlyArray<string>) => Effect<void, never, Scope>
 }
 
 /**
@@ -171,7 +171,7 @@ export interface SparseClassNamePart {
   readonly _tag: "sparse/className"
   readonly parts: ReadonlyArray<ClassNamePart | StaticText>
 
-  readonly update: (value: ReadonlyArray<string>) => Effect<Scope, never, void>
+  readonly update: (value: ReadonlyArray<string>) => Effect<void, never, Scope>
 }
 
 /**
@@ -181,7 +181,7 @@ export interface SparseCommentPart {
   readonly _tag: "sparse/comment"
   readonly parts: ReadonlyArray<CommentPart | StaticText>
 
-  readonly update: (value: ReadonlyArray<string>) => Effect<Scope, never, void>
+  readonly update: (value: ReadonlyArray<string>) => Effect<void, never, Scope>
 }
 
 /**