@typed/template 0.6.0 → 0.7.0

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,8 +47,8 @@ export function renderToHtml<R, E>(
 /**
  * @since 1.0.0
  */
-export function renderToHtmlString<R, E>(
-  fx: Fx.Fx<R, E, RenderEvent>
+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)) {
@@ -122,7 +122,7 @@ function renderObject<R, E>(renderable: object | null | undefined, isStatic: boo
   } else if (Effect.isEffect(renderable)) {
     return Fx.switchMap(
       Fx.fromEffect(renderable as Effect.Effect<Renderable, E, R>),
-      (r) => renderNode<R, E>(r, isStatic)
+      (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<ReadonlyArray<A>, E1>>
+  ): <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<ReadonlyArray<A>, E1>>,
+    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<ReadonlyArray<A>, E1>>,
+    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

@@ -80,7 +80,7 @@ export interface EventPart {
   readonly value: null
   readonly index: number
   readonly onCause: (cause: Cause<unknown>) => Effect<unknown>
-  readonly addEventListener: (handler: EventHandler<never, never, Event>) => void
+  readonly addEventListener: (handler: EventHandler<Event>) => void
 }
 
 /**

package/src/Placeholder.ts

@@ -21,7 +21,7 @@ export type PlaceholderTypeId = typeof PlaceholderTypeId
 /**
  * @since 1.0.0
  */
-export interface Placeholder<out R = never, out E = never, out A = unknown> {
+export interface Placeholder<A = unknown, E = never, R = never> {
   readonly [PlaceholderTypeId]: {
     readonly _R: (_: never) => R
     readonly _E: (_: never) => E
@@ -37,32 +37,32 @@ export namespace Placeholder {
    * @since 1.0.0
    */
   export type Any<A = any> =
-    | Placeholder<any, any, A>
-    | Placeholder<any, never, A>
-    | Placeholder<never, never, A>
-    | Placeholder<never, any, A>
+    | Placeholder<A, any, any>
+    | Placeholder<A, never, any>
+    | Placeholder<A>
+    | Placeholder<A, any>
 
   /**
    * @since 1.0.0
    */
-  export type Context<T> = [T] extends [never] ? never : T extends Placeholder<infer R, infer _E, infer _A> ? R : never
+  export type Context<T> = [T] extends [never] ? never : T extends Placeholder<infer _A, infer _E, infer R> ? R : never
   /**
    * @since 1.0.0
    */
-  export type Error<T> = [T] extends [never] ? never : T extends Placeholder<infer _R, infer E, infer _A> ? E : never
+  export type Error<T> = [T] extends [never] ? never : T extends Placeholder<infer _A, infer E, infer _R> ? E : never
   /**
    * @since 1.0.0
    */
-  export type Success<T> = [T] extends [never] ? never : T extends Placeholder<infer _R, infer _E, infer A> ? A : never
+  export type Success<T> = [T] extends [never] ? never : T extends Placeholder<infer A, infer _E, infer _R> ? A : never
 
   /**
    * @since 1.0.0
    */
-  export function asRef<R = never, E = never, A = never>(
-    placeholder: Placeholder<R, E, A> | Fx<R, E, A> | Effect.Effect<A, E, R> | A
-  ): Effect.Effect<RefSubject.RefSubject<never, E, A>, never, R | Scope.Scope> {
-    if (isFx<R, E, A>(placeholder) || Effect.isEffect(placeholder)) {
-      return RefSubject.make(placeholder as Fx<R, E, A>)
+  export function asRef<A = never, E = never, R = never>(
+    placeholder: Placeholder<A, E, R> | Fx<A, E, R> | Effect.Effect<A, E, R> | A
+  ): Effect.Effect<RefSubject.RefSubject<A, E>, never, R | Scope.Scope> {
+    if (isFx<A, E, R>(placeholder) || Effect.isEffect(placeholder)) {
+      return RefSubject.make(placeholder as Fx<A, E, R>)
     } else {
       return RefSubject.of<A, E>(placeholder as A)
     }

package/src/Platform.ts

@@ -20,8 +20,8 @@ const HYPHENATED_CONTENT_TYPE = { "content-type": HTML_CONTENT_TYPE }
 /**
  * @since 1.0.0
  */
-export function htmlResponse<R, E>(
-  fx: Fx.Fx<R, E, RenderEvent>,
+export function htmlResponse<E, R>(
+  fx: Fx.Fx<RenderEvent, E, R>,
   options?: HttpServer.response.Options
 ): Effect.Effect<HttpServer.response.ServerResponse, E, RenderContext.RenderContext | Exclude<R, RenderTemplate>> {
   return Effect.contextWithEffect((ctx) =>

package/src/Render.ts

@@ -23,8 +23,8 @@ export type ToRendered<T extends RenderEvent | null> = T extends null ? Rendered
  * @since 1.0.0
  */
 export function render<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, ctx, { rootElement }] = Context.getMany(context, Document, RenderContext, RootElement)
 
@@ -40,7 +40,7 @@ export function render<R, E, T extends RenderEvent | null>(
  * @since 1.0.0
  */
 export function renderLayer<R, E, T extends RenderEvent | null>(
-  rendered: Fx.Fx<R, E, T>
+  rendered: Fx.Fx<T, E, R>
 ): Layer.Layer<
   never,
   never,

package/src/RenderTemplate.ts

@@ -16,11 +16,7 @@ export interface RenderTemplate {
   <Values extends ReadonlyArray<Renderable<any, any>>>(
     templateStrings: TemplateStringsArray,
     values: Values
-  ): Fx.Fx<
-    Scope | Placeholder.Context<Values[number]>,
-    Placeholder.Error<Values[number]>,
-    RenderEvent
-  >
+  ): Fx.Fx<RenderEvent, Placeholder.Error<Values[number]>, Scope | Placeholder.Context<Values[number]>>
 }
 
 /**
@@ -38,6 +34,6 @@ export const RenderTemplate: Context.Tagged<RenderTemplate, RenderTemplate> = Co
 export function html<const Values extends ReadonlyArray<Renderable<any, any>>>(
   template: TemplateStringsArray,
   ...values: Values
-): Fx.Fx<RenderTemplate | Scope | Placeholder.Context<Values[number]>, Placeholder.Error<Values[number]>, RenderEvent> {
+): Fx.Fx<RenderEvent, Placeholder.Error<Values[number]>, RenderTemplate | Scope | Placeholder.Context<Values[number]>> {
   return Fx.fromFxEffect(RenderTemplate.with((render) => render(template, values)))
 }

package/src/Renderable.ts

@@ -12,12 +12,12 @@ import type { RenderEvent } from "./RenderEvent.js"
  */
 export type Renderable<R = never, E = never> =
   | Renderable.Value
-  | Placeholder<R, E, any>
-  | { readonly [key: string]: Renderable<R, E> | Placeholder<R, E, any> | unknown } // TODO: Should we manage data attributes this way?
-  | Placeholder<R, E, any>
+  | Placeholder<any, E, R>
+  | { readonly [key: string]: Renderable<E, R> | Placeholder<any, E, R> | unknown } // TODO: Should we manage data attributes this way?
+  | Placeholder<any, E, R>
   | Effect<any, E, R>
-  | Fx<R, E, any>
-  | ReadonlyArray<Renderable<R, E>>
+  | Fx<any, E, R>
+  | ReadonlyArray<Renderable<E, R>>
 
 /**
  * @since 1.0.0

package/src/Test.ts

@@ -42,8 +42,8 @@ export interface TestRender<E> {
   readonly window: Window & GlobalThis
   readonly document: Document
   readonly elementRef: ElementRef.ElementRef
-  readonly errors: RefSubject.Computed<never, never, ReadonlyArray<E>>
-  readonly lastError: RefSubject.Filtered<never, never, E>
+  readonly errors: RefSubject.Computed<ReadonlyArray<E>>
+  readonly lastError: RefSubject.Filtered<E>
   readonly interrupt: Effect.Effect<void>
   readonly makeEvent: (type: string, eventInitDict?: EventInit) => Event
   readonly makeCustomEvent: <A>(type: string, eventInitDict?: CustomEventInit<A>) => CustomEvent<A>
@@ -54,8 +54,8 @@ export interface TestRender<E> {
 /**
  * @since 1.0.0
  */
-export function testRender<R, E>(
-  fx: Fx.Fx<R, E, RenderEvent>,
+export function testRender<E, R>(
+  fx: Fx.Fx<RenderEvent, E, R>,
   options?:
     & HappyDOMOptions
     & { readonly [K in keyof DomServicesElementParams]?: (document: Document) => DomServicesElementParams[K] }
@@ -67,7 +67,7 @@ export function testRender<R, E>(
   return Effect.gen(function*(_) {
     const window = yield* _(getOrMakeWindow(options))
     const elementRef = yield* _(ElementRef.make())
-    const errors = yield* _(RefSubject.make<never, never, ReadonlyArray<E>>(Effect.succeed([])))
+    const errors = yield* _(RefSubject.make<ReadonlyArray<E>>(Effect.succeed([])))
     const fiber = yield* _(
       fx,
       render,
@@ -187,7 +187,7 @@ export interface TestHydrate<E, Elements> extends TestRender<E> {
  * @since 1.0.0
  */
 export function testHydrate<R, E, Elements>(
-  fx: Fx.Fx<R, E, RenderEvent>,
+  fx: Fx.Fx<RenderEvent, E, R>,
   f: (rendered: Rendered, window: Window & GlobalThis) => Elements,
   options?:
     & HappyDOMOptions
@@ -218,7 +218,7 @@ export function testHydrate<R, E, Elements>(
     const elements = f(rendered.length === 1 ? rendered[0] : rendered, window)
 
     const elementRef = yield* _(ElementRef.make())
-    const errors = yield* _(RefSubject.make<never, never, ReadonlyArray<E>>(Effect.succeed([])))
+    const errors = yield* _(RefSubject.make<ReadonlyArray<E>>(Effect.succeed([])))
     const fiber = yield* _(
       fx,
       hydrate,

package/src/internal/EventSource.ts

@@ -7,7 +7,7 @@ import type { EventHandler } from "../EventHandler.js"
 
 type EventName = string
 
-type Handler<Ev extends Event> = EventHandler<never, never, Ev>
+type Handler<Ev extends Event> = EventHandler<Ev>
 
 export interface EventSource {
   readonly addEventListener: <Ev extends Event>(

package/src/internal/hydrate.ts

@@ -40,11 +40,7 @@ export const hydrateTemplate: (document: Document, ctx: RenderContext) => Render
   return <Values extends ReadonlyArray<Renderable<any, any>>>(
     templateStrings: TemplateStringsArray,
     values: Values
-  ): Fx.Fx<
-    Scope.Scope | Placeholder.Context<Values[number]>,
-    Placeholder.Error<Values[number]>,
-    RenderEvent
-  > => {
+  ): Fx.Fx<RenderEvent, Placeholder.Error<Values[number]>, Scope.Scope | Placeholder.Context<Values[number]>> => {
     return Fx.make((sink) =>
       Effect.gen(function*(_) {
         const context = yield* _(Effect.context<Scope.Scope>())

package/src/internal/module-augmentation.ts

@@ -1,44 +1,44 @@
 import type { Placeholder } from "../Placeholder.js"
 
 declare global {
-  export interface String extends Placeholder<never, never, string> {}
+  export interface String extends Placeholder<string> {}
 
-  export interface Number extends Placeholder<never, never, number> {}
+  export interface Number extends Placeholder<number> {}
 
-  export interface Boolean extends Placeholder<never, never, boolean> {}
+  export interface Boolean extends Placeholder<boolean> {}
 
-  export interface Symbol extends Placeholder<never, never, symbol> {}
+  export interface Symbol extends Placeholder<symbol> {}
 
-  export interface BigInt extends Placeholder<never, never, bigint> {}
+  export interface BigInt extends Placeholder<bigint> {}
 
   export interface Array<T> extends
     Placeholder<
-      Placeholder.Context<T>,
+      Array<Placeholder.Success<T>>,
       Placeholder.Error<T>,
-      Array<Placeholder.Success<T>>
+      Placeholder.Context<T>
     >
   {}
 
   export interface ReadonlyArray<T> extends
     Placeholder<
-      Placeholder.Context<T>,
+      ReadonlyArray<Placeholder.Success<T>>,
       Placeholder.Error<T>,
-      ReadonlyArray<Placeholder.Success<T>>
+      Placeholder.Context<T>
     >
   {}
 
   // DOM types
-  export interface Node extends Placeholder<never, never, Node> {}
+  export interface Node extends Placeholder<Node> {}
 
-  export interface DocumentFragment extends Placeholder<never, never, DocumentFragment> {}
+  export interface DocumentFragment extends Placeholder<DocumentFragment> {}
 
-  export interface Element extends Placeholder<never, never, Element> {}
+  export interface Element extends Placeholder<Element> {}
 
-  export interface HTMLElement extends Placeholder<never, never, HTMLElement> {}
+  export interface HTMLElement extends Placeholder<HTMLElement> {}
 
-  export interface SVGElement extends Placeholder<never, never, SVGElement> {}
+  export interface SVGElement extends Placeholder<SVGElement> {}
 }
 
 declare module "@typed/fx/Fx" {
-  export interface Fx<R, E, A> extends Placeholder<R, E, A> {}
+  export interface Fx<A, E, R> extends Placeholder<A, E, R> {}
 }

package/src/internal/parts.ts

@@ -295,7 +295,7 @@ export class EventPartImpl implements EventPart {
     readonly index: number,
     readonly source: ElementSource<any>,
     readonly onCause: <E>(cause: Cause<E>) => Effect.Effect<unknown>,
-    readonly addEventListener: <Ev extends Event>(handler: EventHandler<never, never, Ev>) => void
+    readonly addEventListener: <Ev extends Event>(handler: EventHandler<Ev>) => void
   ) {
   }
 }