@typed/template 0.12.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed/template",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "",
   "license": "MIT",
   "repository": {
@@ -9,19 +9,20 @@
   },
   "sideEffects": [],
   "author": "Typed contributors",
+  "homepage": "https://github.com/tylors/typed",
   "dependencies": {
-    "@effect/platform": "^0.55.1",
-    "@effect/schema": "^0.67.14",
-    "effect": "^3.2.5",
-    "fast-check": "^3.19.0",
+    "@effect/platform": "^0.66.2",
+    "@effect/schema": "^0.74.1",
+    "effect": "^3.8.4",
+    "fast-check": "^3.22.0",
     "html5parser": "^2.0.2",
-    "typed-query-selector": "^2.11.2",
+    "typed-query-selector": "^2.12.0",
     "udomdiff": "^1.1.0",
-    "@typed/context": "0.28.0",
-    "@typed/dom": "16.0.0",
-    "@typed/environment": "0.9.0",
-    "@typed/fx": "1.30.0",
-    "@typed/wire": "0.5.0"
+    "@typed/context": "0.30.0",
+    "@typed/dom": "18.0.0",
+    "@typed/environment": "0.11.0",
+    "@typed/fx": "1.32.0",
+    "@typed/wire": "0.6.0"
   },
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -147,6 +148,11 @@
       "types": "./dist/dts/Vitest.d.ts",
       "import": "./dist/esm/Vitest.js",
       "default": "./dist/cjs/Vitest.js"
+    },
+    "./compiler-tools": {
+      "types": "./dist/dts/compiler-tools.d.ts",
+      "import": "./dist/esm/compiler-tools.js",
+      "default": "./dist/cjs/compiler-tools.js"
     }
   },
   "typesVersions": {
@@ -219,6 +225,9 @@
       ],
       "Vitest": [
         "./dist/dts/Vitest.d.ts"
+      ],
+      "compiler-tools": [
+        "./dist/dts/compiler-tools.d.ts"
       ]
     }
   }

package/src/ElementRef.ts

@@ -23,8 +23,17 @@ export type ElementRefTypeId = typeof ElementRefTypeId
  * A reference to a rendered element.
  * @since 1.0.0
  */
-export interface ElementRef<T extends Rendered = Rendered>
-  extends Versioned<never, never, T, never, Scope.Scope, T, NoSuchElementException, never>
+export interface ElementRef<T extends Rendered = Rendered> extends
+  Versioned<
+    never,
+    never,
+    T,
+    never,
+    Scope.Scope,
+    T,
+    NoSuchElementException,
+    never
+  >
 {
   readonly [ElementRefTypeId]: RefSubject.RefSubject<Option.Option<T>>
 
@@ -39,7 +48,11 @@ const strictEqual = Option.getEquivalence((a, b) => a === b)
 /**
  * @since 1.0.0
  */
-export function make<T extends Rendered = Rendered>(): Effect.Effect<ElementRef<T>, never, Scope.Scope> {
+export function make<T extends Rendered = Rendered>(): Effect.Effect<
+  ElementRef<T>,
+  never,
+  Scope.Scope
+> {
   return Effect.map(
     RefSubject.of(Option.none<T>(), { eq: strictEqual }),
     (ref) => new ElementRefImpl(ref) as any as ElementRef<T>
@@ -49,23 +62,22 @@ export function make<T extends Rendered = Rendered>(): Effect.Effect<ElementRef<
 /**
  * @since 1.0.0
  */
-export function of<T extends Rendered>(rendered: T): Effect.Effect<ElementRef<T>, never, Scope.Scope> {
+export function of<T extends Rendered>(
+  rendered: T
+): Effect.Effect<ElementRef<T>, never, Scope.Scope> {
   return Effect.map(
     RefSubject.of(Option.some<T>(rendered), { eq: strictEqual }),
     (ref) => new ElementRefImpl(ref) as any as ElementRef<T>
   )
 }
 
-// @ts-expect-error does not implement Placeholder
+// @ts-expect-error Missing PlaceholderTypeId
 class ElementRefImpl<T extends Rendered> extends FxEffectBase<T, never, Scope.Scope, T, NoSuchElementException, never>
   implements ElementRef<T>
 {
   readonly [ElementRefTypeId]: RefSubject.RefSubject<Option.Option<T>>
 
-  private source: ElementSource<
-    T,
-    DefaultEventMap<T>
-  >
+  private source: ElementSource<T, DefaultEventMap<T>>
 
   readonly query: ElementRef<T>["query"]
   readonly events: ElementRef<T>["events"]
@@ -97,16 +109,26 @@ class ElementRefImpl<T extends Rendered> extends FxEffectBase<T, never, Scope.Sc
  * @since 1.0.0
  */
 export const set: {
-  <A extends Rendered>(value: A): (elementRef: ElementRef<A>) => Effect.Effect<A>
+  <A extends Rendered>(
+    value: A
+  ): (elementRef: ElementRef<A>) => Effect.Effect<A>
   <A extends Rendered>(elementRef: ElementRef<A>, value: A): Effect.Effect<A>
-} = dual(2, function set<A extends Rendered>(elementRef: ElementRef<A>, value: A) {
-  return Effect.as(RefSubject.set(elementRef[ElementRefTypeId], Option.some(value)), value)
+} = dual(2, function set<
+  A extends Rendered
+>(elementRef: ElementRef<A>, value: A) {
+  return Effect.as(
+    RefSubject.set(elementRef[ElementRefTypeId], Option.some(value)),
+    value
+  )
 })
 
 /**
  * @since 1.0.0
  */
-export function dispatchEvent<T extends Rendered>(ref: ElementRef<T>, event: Event) {
+export function dispatchEvent<T extends Rendered>(
+  ref: ElementRef<T>,
+  event: Event
+) {
   return ref.pipe(
     Effect.flatMap((rendered) => {
       const elements = getElements(rendered)

package/src/ElementSource.ts

@@ -40,7 +40,10 @@ export interface ElementSource<
   readonly selector: Selector
 
   readonly query: {
-    <S extends string, Ev extends {} = DefaultEventMap<ParseSelector<S, Element>>>(
+    <
+      S extends string,
+      Ev extends {} = DefaultEventMap<ParseSelector<S, Element>>
+    >(
       selector: S
     ): ElementSource<ParseSelector<S, Element>, Ev>
 
@@ -54,33 +57,44 @@ export interface ElementSource<
   readonly events: <Type extends keyof EventMap>(
     type: Type,
     options?: AddEventListenerOptions
-  ) => Fx.Fx<EventWithCurrentTarget<Rendered.Elements<T>[number], EventMap[Type]>, never, Scope.Scope>
+  ) => Fx.Fx<
+    EventWithCurrentTarget<Rendered.Elements<T>[number], EventMap[Type]>,
+    never,
+    Scope.Scope
+  >
 
-  readonly dispatchEvent: (event: Event, wait?: DurationInput) => Effect.Effect<void, NoSuchElementException>
+  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<T>
-): ElementSource<T, EventMap> {
+export function ElementSource<
+  T extends Rendered,
+  EventMap extends {} = DefaultEventMap<T>
+>(rootElement: RefSubject.Filtered<T>): ElementSource<T, EventMap> {
   return new ElementSourceImpl<T, EventMap>(rootElement) as any
 }
 
 /**
  * @since 1.0.0
  */
-export function fromElement<T extends Element, EventMap extends {} = DefaultEventMap<T>>(
-  rootElement: T
-): ElementSource<T, EventMap> {
+export function fromElement<
+  T extends Element,
+  EventMap extends {} = DefaultEventMap<T>
+>(rootElement: T): ElementSource<T, EventMap> {
   return ElementSourceImpl.fromElement(rootElement) as any
 }
 
 /**
  * @since 1.0.0
  */
-export type ParseSelector<T extends string, Fallback> = [T] extends [typeof ROOT_CSS_SELECTOR] ? Fallback
+export type ParseSelector<T extends string, Fallback> = [T] extends [
+  typeof ROOT_CSS_SELECTOR
+] ? Fallback
   : Fallback extends globalThis.Element ? Extract<TQS.ParseSelector<T, Fallback>, globalThis.Element>
   : Fallback
 
@@ -106,7 +120,9 @@ type RenderedWithoutArray = Exclude<Rendered, ReadonlyArray<Rendered>>
 /**
  * @since 1.0.0
  */
-export function getElements<T extends Rendered>(element: T): ReadonlyArray<Element> {
+export function getElements<T extends Rendered>(
+  element: T
+): ReadonlyArray<Element> {
   if (Array.isArray(element)) return element.flatMap(getElements)
   if (isWire(element as RenderedWithoutArray)) {
     return Array.from((element.valueOf() as DocumentFragment).children)
@@ -117,12 +133,16 @@ export function getElements<T extends Rendered>(element: T): ReadonlyArray<Eleme
   }
 
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  if ((element as Node).parentElement) return [(element as Node).parentElement!]
+  if ((element as Node).parentElement) {
+    return [(element as Node).parentElement!]
+  }
 
   return []
 }
 
-function findMostSpecificElement<T extends Element>(cssSelectors: ReadonlyArray<string>) {
+function findMostSpecificElement<T extends Element>(
+  cssSelectors: ReadonlyArray<string>
+) {
   return function(element: Rendered): T {
     const elements = getElements(element)
 
@@ -140,7 +160,9 @@ function findMostSpecificElement<T extends Element>(cssSelectors: ReadonlyArray<
   }
 }
 
-function findMatchingElements<El extends Element = Element>(cssSelectors: ReadonlyArray<string>) {
+function findMatchingElements<El extends Element = Element>(
+  cssSelectors: ReadonlyArray<string>
+) {
   if (cssSelectors.length === 0) return getElements
 
   const cssSelector = cssSelectors.join(" ")
@@ -175,13 +197,15 @@ function makeEventStream<Ev extends Event>(
       elements.map((element) =>
         Fx.filter(
           Fx.make<Ev>((sink) =>
-            Effect.scoped(Effect.zipRight(
-              addEventListener(element, {
-                eventName,
-                handler: (ev) => sink.onSuccess(ev as any as Ev)
-              }),
-              Effect.never
-            ))
+            Effect.scoped(
+              Effect.zipRight(
+                addEventListener(element, {
+                  eventName,
+                  handler: (ev) => sink.onSuccess(ev as any as Ev)
+                }),
+                Effect.never
+              )
+            )
           ),
           (event: Ev) =>
             ensureMatches(cssSelector, element, event, capture) ||
@@ -211,15 +235,20 @@ function makeElementEventStream<Ev extends Event>(
       elements.map((element) =>
         Fx.filter(
           Fx.make<Ev>((sink) =>
-            Effect.scoped(Effect.zipRight(
-              addEventListener(element, {
-                eventName,
-                handler: (ev) => sink.onSuccess(ev as any as Ev)
-              }),
-              Effect.never
-            ))
+            Effect.scoped(
+              Effect.zipRight(
+                addEventListener(element, {
+                  eventName,
+                  handler: (ev) => sink.onSuccess(ev as any as Ev)
+                }),
+                Effect.never
+              )
+            )
           ),
-          (event: Ev) => event.target ? currentTarget.contains(event.target as Element) : false
+          (event: Ev) =>
+            event.target
+              ? currentTarget.contains(event.target as Element)
+              : false
         )
       )
     )
@@ -262,24 +291,39 @@ const EVENT_PROPERTY_TO_REPLACE = "currentTarget"
 function cloneEvent<E extends Event>(event: E, currentTarget: Element): E {
   return new Proxy(event, {
     get(target: E, property: string | symbol) {
-      return property === EVENT_PROPERTY_TO_REPLACE ? currentTarget : target[property as keyof E]
+      return property === EVENT_PROPERTY_TO_REPLACE
+        ? currentTarget
+        : target[property as keyof E]
     }
   })
 }
 
-function ensureMatches(cssSelector: string, element: Element, ev: Event, capture = false): boolean {
+function ensureMatches(
+  cssSelector: string,
+  element: Element,
+  ev: Event,
+  capture = false
+): boolean {
   let target = ev.target as Element
 
-  if (!cssSelector) return (capture && element.contains(target)) || target === element
+  if (!cssSelector) {
+    return (capture && element.contains(target)) || target === element
+  }
 
-  for (; target && target !== element; target = target.parentElement as Element) {
+  for (
+    ;
+    target && target !== element;
+    target = target.parentElement as Element
+  ) {
     if (target.matches(cssSelector)) return true
   }
 
   return element.matches(cssSelector)
 }
 
-function isDocumentFragment(element: RenderedWithoutArray): element is DocumentFragment {
+function isDocumentFragment(
+  element: RenderedWithoutArray
+): element is DocumentFragment {
   return element.nodeType === element.DOCUMENT_FRAGMENT_NODE
 }
 
@@ -291,13 +335,18 @@ function isElement(element: RenderedWithoutArray): element is Element {
  * @internal
  * @since 1.0.0
  */
-// @ts-expect-error Doesn't implement Placeholder
+// @ts-expect-error Missing PlaceholderTypeId
 export class ElementSourceImpl<
   T extends Rendered,
   EventMap extends {} = DefaultEventMap<Rendered.Elements<T>[number]>
-> extends FxEffectBase<Rendered.Elements<T>, never, Scope.Scope, Rendered.Elements<T>, NoSuchElementException, never>
-  implements ElementSource<T, EventMap>
-{
+> extends FxEffectBase<
+  Rendered.Elements<T>,
+  never,
+  Scope.Scope,
+  Rendered.Elements<T>,
+  NoSuchElementException,
+  never
+> implements ElementSource<T, EventMap> {
   private bubbleMap = new Map<any, Fx.Fx<any, never, Scope.Scope>>()
   private captureMap = new Map<any, Fx.Fx<any, never, Scope.Scope>>()
 
@@ -312,18 +361,23 @@ export class ElementSourceImpl<
     this.query = this.query.bind(this)
     this.events = this.events.bind(this)
 
-    this.elements = this.selector._tag === "css" ?
-      RefSubject.map(this.rootElement, findMatchingElements<any>(this.selector.selectors)) :
-      RefSubject.filterMapEffect(
+    this.elements = this.selector._tag === "css"
+      ? RefSubject.map(
+        this.rootElement,
+        findMatchingElements<any>(this.selector.selectors)
+      )
+      : (RefSubject.filterMapEffect(
         Versioned.of(this.selector.element),
         (x) => Effect.succeedSome([x] as any as Rendered.Elements<T>)
-      ) as any
+      ) as any)
 
     this.version = this.elements.version
   }
 
   static fromElement<T extends Rendered>(rootElement: T): ElementSource<T> {
-    return new ElementSourceImpl<T>(RefSubject.filterMapEffect(Versioned.of(rootElement), Effect.succeedSome)) as any
+    return new ElementSourceImpl<T>(
+      RefSubject.filterMapEffect(Versioned.of(rootElement), Effect.succeedSome)
+    ) as any
   }
 
   toEffect(): Effect.Effect<Rendered.Elements<T>, NoSuchElementException> {
@@ -334,26 +388,39 @@ export class ElementSourceImpl<
     return this.elements
   }
 
-  query<S extends string, Ev extends {} = DefaultEventMap<ParseSelector<S, Element>>>(
-    selector: S
-  ): ElementSource<ParseSelector<S, Element>, Ev> {
+  query<
+    S extends string,
+    Ev extends {} = DefaultEventMap<ParseSelector<S, Element>>
+  >(selector: S): ElementSource<ParseSelector<S, Element>, Ev> {
     if (selector === ROOT_CSS_SELECTOR) {
       return this as any
     } else if (typeof selector === "string") {
       if (this.selector._tag === "css") {
-        return new ElementSourceImpl(this.rootElement, CssSelectors([...this.selector.selectors, selector])) as any
+        return new ElementSourceImpl(
+          this.rootElement,
+          CssSelectors([...this.selector.selectors, selector])
+        ) as any
       } else {
-        return ElementSourceImpl.fromElement(this.selector.element).query(selector) as any
+        return ElementSourceImpl.fromElement(this.selector.element).query(
+          selector
+        ) as any
       }
     } else {
-      return new ElementSourceImpl(this.rootElement, ElementSelector(selector)) as any
+      return new ElementSourceImpl(
+        this.rootElement,
+        ElementSelector(selector)
+      ) as any
     }
   }
 
   events<Type extends keyof EventMap>(
     type: Type,
     options?: AddEventListenerOptions
-  ): Fx.Fx<EventWithCurrentTarget<Rendered.Elements<T>[number], EventMap[Type]>, never, Scope.Scope> {
+  ): Fx.Fx<
+    EventWithCurrentTarget<Rendered.Elements<T>[number], EventMap[Type]>,
+    never,
+    Scope.Scope
+  > {
     const capture = options?.capture === true
     const map = capture ? this.captureMap : this.bubbleMap
 
@@ -361,13 +428,24 @@ export class ElementSourceImpl<
 
     if (current === undefined) {
       if (this.selector._tag === "css") {
-        current = RefSubject.map(this.rootElement, findMostSpecificElement(this.selector.selectors)).pipe(
-          Fx.switchMap(makeEventStream(this.selector.selectors, type as any, options)),
+        current = RefSubject.map(
+          this.rootElement,
+          findMostSpecificElement(this.selector.selectors)
+        ).pipe(
+          Fx.switchMap(
+            makeEventStream(this.selector.selectors, type as any, options)
+          ),
           Fx.multicast
         )
       } else {
         current = this.rootElement.pipe(
-          Fx.switchMap(makeElementEventStream(this.selector.element, type as string, options)),
+          Fx.switchMap(
+            makeElementEventStream(
+              this.selector.element,
+              type as string,
+              options
+            )
+          ),
           Fx.multicast
         )
       }

package/src/Html.ts

@@ -5,7 +5,7 @@
 import type { CurrentEnvironment } from "@typed/environment"
 import * as Fx from "@typed/fx/Fx"
 import * as Sink from "@typed/fx/Sink"
-import { TypeId } from "@typed/fx/TypeId"
+import { FxTypeId } from "@typed/fx/TypeId"
 import { join } from "effect/Array"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
@@ -380,7 +380,7 @@ function unwrapRenderable<E, R>(
         return Fx.fromFxEffect(
           Effect.map(renderable as any, unwrapRenderable<any, any>)
         )
-      } else if (TypeId in renderable) {
+      } else if (FxTypeId in renderable) {
         return renderable as any
       } else return Fx.succeed(renderable as any)
     }

package/src/Hydrate.ts

@@ -3,51 +3,17 @@
  */
 
 import * as Context from "@typed/context"
-import { Document } from "@typed/dom/Document"
-import type { DomServices, DomServicesElementParams } from "@typed/dom/DomServices"
-import type { GlobalThis } from "@typed/dom/GlobalThis"
 import { RootElement } from "@typed/dom/RootElement"
-import type { CurrentEnvironment } from "@typed/environment"
 import * as Fx from "@typed/fx/Fx"
 import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
+import type * as Layer from "effect/Layer"
 import { HydrateContext } from "./internal/HydrateContext.js"
-import { hydrateTemplate } from "./internal/v2/hydrate.js"
 import { getHydrationRoot } from "./internal/v2/hydration-template.js"
 import { attachRoot } from "./internal/v2/render.js"
 import type { ToRendered } from "./Render.js"
 import * as RenderContext from "./RenderContext.js"
 import { type RenderEvent } from "./RenderEvent.js"
-import { RenderTemplate } from "./RenderTemplate.js"
-
-/**
- * @since 1.0.0
- */
-export const hydrateLayer = (
-  window: Window & GlobalThis,
-  options?: DomServicesElementParams
-): Layer.Layer<
-  | RenderTemplate
-  | RenderContext.RenderContext
-  | CurrentEnvironment
-  | DomServices
-> =>
-  Layer.provideMerge(
-    RenderTemplate.layer(
-      Effect.contextWith(
-        (context: Context.Context<Document | RenderContext.RenderContext>) => {
-          const [document, ctx] = Context.getMany(
-            context,
-            Document,
-            RenderContext.RenderContext
-          )
-
-          return hydrateTemplate(document, ctx)
-        }
-      )
-    ),
-    RenderContext.dom(window, options)
-  )
+import type { RenderTemplate } from "./RenderTemplate.js"
 
 /**
  * @since 1.0.0
@@ -63,7 +29,6 @@ export function hydrate<R, E, T extends RenderEvent | null>(
     )
     const ctx: HydrateContext = {
       where: getHydrationRoot(rootElement),
-      parentTemplate: null,
       hydrate: true
     }
 

package/src/Platform.ts

@@ -2,9 +2,8 @@
  * @since 1.0.0
  */
 
-import * as Headers from "@effect/platform/Http/Headers"
-import type { ServerRequest } from "@effect/platform/Http/ServerRequest"
-import * as HttpServer from "@effect/platform/HttpServer"
+import type { HttpServerRequest } from "@effect/platform"
+import { Headers, HttpServerResponse } from "@effect/platform"
 import type * as Fx from "@typed/fx/Fx"
 import { toStream } from "@typed/fx/Stream"
 import * as Effect from "effect/Effect"
@@ -22,10 +21,10 @@ const HYPHENATED_CONTENT_TYPE = { "content-type": HTML_CONTENT_TYPE }
  */
 export function htmlResponse<E, R>(
   fx: Fx.Fx<RenderEvent | null, E, R>,
-  options?: HttpServer.response.Options
-): Effect.Effect<HttpServer.response.ServerResponse, E, R> {
+  options?: HttpServerResponse.Options
+): Effect.Effect<HttpServerResponse.HttpServerResponse, E, R> {
   return Effect.contextWithEffect((ctx) =>
-    HttpServer.response.stream(
+    HttpServerResponse.stream(
       Stream.provideContext(Stream.encodeText(toStream(renderToHtml(fx))), ctx),
       {
         ...CAMEL_CASE_CONTENT_TYPE,
@@ -41,9 +40,9 @@ export function htmlResponse<E, R>(
  */
 export function htmlResponseString(
   html: string,
-  options?: HttpServer.response.Options
-): HttpServer.response.ServerResponse {
-  return HttpServer.response.raw(
+  options?: HttpServerResponse.Options
+): HttpServerResponse.HttpServerResponse {
+  return HttpServerResponse.raw(
     html,
     {
       ...CAMEL_CASE_CONTENT_TYPE,
@@ -56,7 +55,7 @@ export function htmlResponseString(
 /**
  * @since 1.0.0
  */
-export function getUrlFromServerRequest(request: ServerRequest): URL {
+export function getUrlFromServerRequest(request: HttpServerRequest.HttpServerRequest): URL {
   const { headers } = request
   const host = Headers.get(headers, "x-forwarded-host").pipe(
     Option.orElse(() => Headers.get(headers, "host")),

package/src/RenderQueue.ts

@@ -366,7 +366,9 @@ class MicroTaskImpl extends BaseImpl implements RenderQueue {
     })
     return Effect.sync(() => {
       this.scheduled = false
-      id && this._clear(id)
+      if (id) {
+        this._clear(id)
+      }
     })
   })
 

package/src/Template.ts

@@ -1,7 +1,7 @@
 /**
  * @since 1.0.0
  */
-import type { Chunk } from "effect/Chunk"
+import type { Chunk, NonEmptyChunk } from "effect/Chunk"
 import { type Inspectable, NodeInspectSymbol } from "effect/Inspectable"
 
 /**
@@ -15,7 +15,9 @@ export class Template implements Inspectable {
     readonly hash: string,
     // Parts are a array of Parts to the respective path from the root node to access it prior to rendering
     /// any nodes/elements into the template.
-    readonly parts: ReadonlyArray<readonly [part: PartNode | SparsePartNode, path: Chunk<number>]>
+    readonly parts: ReadonlyArray<
+      readonly [part: PartNode | SparsePartNode, path: Chunk<number> | NonEmptyChunk<number>]
+    >
   ) {}
 
   toJSON() {

package/src/Test.ts

@@ -21,7 +21,7 @@ import type * as Scope from "effect/Scope"
 import * as ElementRef from "./ElementRef.js"
 import { ROOT_CSS_SELECTOR } from "./ElementSource.js"
 import { renderToHtml, renderToHtmlString, serverLayer, staticLayer } from "./Html.js"
-import { hydrate, hydrateLayer } from "./Hydrate.js"
+import { hydrate } from "./Hydrate.js"
 import { adjustTime } from "./internal/utils.js"
 import { render, renderLayer } from "./Render.js"
 import type * as RenderContext from "./RenderContext.js"
@@ -263,7 +263,7 @@ export function testHydrate<R, E, Elements>(
               fromRendered(rendered)
             )
         )),
-      Effect.provide(hydrateLayer(window)),
+      Effect.provide(renderLayer(window)),
       Effect.forkScoped
     )