@typed/ui 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/Hovercard.js

@@ -0,0 +1,188 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { RefSubject } from "@typed/fx";
+import { EventHandler, html, } from "@typed/template";
+import * as Dom from "./Dom.js";
+import * as NativePopover from "./NativePopover.js";
+/** Schema for hovercard hydration state.
+ * @remarks
+ * ## Why
+ * Shared identity/open encoding keeps SSR and browser state compatible.
+ * ## Ownership and lifetime
+ * The immutable schema acquires no resources.
+ * @since 1.0.0
+ * @category Open state
+ */
+export const StateSchema = Schema.Struct({ id: Schema.String, open: Schema.Boolean });
+/** Creates hydrated hovercard state.
+ * @remarks
+ * ## Why
+ * Visibility and identity can be tested without mounting UI.
+ * ## Ownership and lifetime
+ * The calling Effect Scope owns the returned RefSubject.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Hovercard from "@typed/ui/Hovercard"
+ *
+ * const program = Effect.gen(function* () {
+ *   return yield* Hovercard.makeState({ id: "author-card" })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category Open state
+ */
+export function makeState(initial) {
+    return RefSubject.hydrate(StateSchema, { id: initial.id, open: initial.open ?? false });
+}
+/** Sets hovercard visibility.
+ * @remarks
+ * ## Why
+ * Delayed focus/hover flows converge on one atomic state update.
+ * ## Ownership and lifetime
+ * The Effect uses the existing RefSubject lifetime and acquires no resource.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Hovercard from "@typed/ui/Hovercard"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Hovercard.makeState({ id: "author-card" })
+ *   yield* Hovercard.setOpen(state, true)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category Open state
+ */
+export function setOpen(state, open) {
+    return RefSubject.update(state, (current) => ({ ...current, open }));
+}
+const scheduleVersions = new WeakMap();
+const scheduleOpen = Effect.fn(function* (state, open, delay) {
+    const version = (scheduleVersions.get(state) ?? 0) + 1;
+    scheduleVersions.set(state, version);
+    if (delay > 0)
+        yield* Effect.sleep(delay);
+    if (scheduleVersions.get(state) === version)
+        yield* setOpen(state, open);
+});
+function anchorInternalProps(options) {
+    const id = RefSubject.map(options.state, (state) => state.id);
+    return () => ({
+        "aria-controls": id,
+        onfocus: scheduleOpen(options.state, true, options.showDelay ?? 0),
+        onblur: EventHandler.make(Effect.fn(function* (event) {
+            const contentId = (yield* options.state).id;
+            const content = Dom.currentTarget(event).ownerDocument.getElementById(contentId);
+            if (event.relatedTarget instanceof Node && content?.contains(event.relatedTarget))
+                return;
+            yield* scheduleOpen(options.state, false, options.hideDelay ?? 0);
+        })),
+        onkeydown: EventHandler.make(Effect.fn(function* (event) {
+            if (event.key === "Escape")
+                yield* scheduleOpen(options.state, false, 0);
+        })),
+        onmouseenter: scheduleOpen(options.state, true, options.showDelay ?? 0),
+        onmouseleave: scheduleOpen(options.state, false, options.hideDelay ?? 0),
+    });
+}
+/** Renders an anchor coordinating pointer and optional host-focus behavior.
+ * @remarks
+ * ## Why
+ * The default host is a non-focusable `<span>`, so it provides pointer behavior
+ * only. Give the span `tabindex`, or supply a natively focusable custom host,
+ * for direct focus, blur, and keydown handling. Unlike a tooltip, hovercard
+ * content may receive focus; host blur checks `relatedTarget` and stays open
+ * while focus moves inside the card. Nested-anchor focus does not bubble.
+ * ## Ownership and lifetime
+ * Running the Fx owns real DOM handlers and dynamic relationships in its Scope.
+ * Custom hosts must preserve `aria-controls` and all supplied handlers.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Hovercard from "@typed/ui/Hovercard"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Hovercard.makeState({ id: "author-card" })
+ *   return Hovercard.Anchor({
+ *     state,
+ *     content: "Ada Lovelace",
+ *     props: { tabindex: 0 }
+ *   })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category Pointer and focus anchors
+ */
+export function Anchor(options, host) {
+    return Dom.renderHost()(options, host, anchorInternalProps(options), options.content, (props, content) => html `<span ...${props}>${content}</span>`);
+}
+function contentInternalProps(options) {
+    const id = RefSubject.map(options.state, (state) => state.id);
+    return ({ property }) => ({
+        id,
+        role: "dialog",
+        "aria-label": property("label", undefined),
+        "aria-labelledby": property("labelledBy", undefined),
+        popover: "manual",
+        onfocusin: scheduleOpen(options.state, true, 0),
+        onfocusout: EventHandler.make(Effect.fn(function* (event) {
+            const content = Dom.currentTarget(event);
+            if (event.relatedTarget instanceof Node && content.contains(event.relatedTarget))
+                return;
+            yield* scheduleOpen(options.state, false, 0);
+        })),
+        onmouseenter: scheduleOpen(options.state, true, 0),
+        onmouseleave: EventHandler.make(Effect.fn(function* (event) {
+            const contentId = (yield* options.state).id;
+            if (event.relatedTarget instanceof Element &&
+                event.relatedTarget.getAttribute("aria-controls") === contentId)
+                return;
+            yield* scheduleOpen(options.state, false, 0);
+        })),
+        onkeydown: EventHandler.make(Effect.fn(function* (event) {
+            if (event.key === "Escape")
+                yield* scheduleOpen(options.state, false, 0);
+        })),
+        ontoggle: EventHandler.make(Effect.fn((event) => setOpen(options.state, Dom.toggleState(event) === "open"))),
+        ref: Dom.composeRefs(options.state, NativePopover.ref(options.state)),
+    });
+}
+/** Renders named, focusable hovercard content in the native top layer.
+ * @remarks
+ * ## Why
+ * `role="dialog"` distinguishes interactive content from a tooltip. Native
+ * popover placement is retained, and focus/pointer transitions prevent closing
+ * while interaction remains inside the card.
+ * ## Ownership and lifetime
+ * Running the Fx owns handlers and NativePopover observation in its Scope. A
+ * custom host must preserve id, role, accessible name, manual popover,
+ * lifecycle handlers, and one hydration ref owner.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Hovercard from "@typed/ui/Hovercard"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Hovercard.makeState({ id: "author-card" })
+ *   return Hovercard.Content({ state, label: "Author", content: "Mathematician" })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category Native content host
+ */
+export function Content(options, host) {
+    return Dom.renderHost()(options, host, contentInternalProps(options), options.content, (i, content) => {
+        return html `<div ...${i}>${content}</div>`;
+    });
+}
+/** Canonical widget alias for `Content`.
+ * @remarks
+ * ## Why
+ * The alias provides the widget name while `Content` names compound use.
+ * ## Ownership and lifetime
+ * It has exactly the same Scope and native popover ownership as `Content`.
+ * @since 1.0.0
+ * @category Native content host
+ */
+export const Hovercard = Content;

package/dist/HttpRouter.d.ts

@@ -1,13 +1,136 @@
 import * as Effect from "effect/Effect";
-import * as Scope from "effect/Scope";
-import { type HttpRouter } from "effect/unstable/http/HttpRouter";
+import { type HttpRouter, type Provided as HttpRouterProvided, type Request as HttpRouterRequest } from "effect/unstable/http/HttpRouter";
+import * as HttpServerError from "effect/unstable/http/HttpServerError";
 import { type Matcher, type Router } from "@typed/router";
+import { type Navigation } from "@typed/navigation";
 import { type RenderEvent } from "@typed/template";
-type ProvidedForSsr = Scope.Scope | Router;
+type ProvidedForSsr = HttpRouterProvided | Navigation | Router;
+type SsrForHttpRequirement<E, R> = Exclude<R, ProvidedForSsr> | HttpRouterRequest.From<"Error", E | HttpServerError.HttpServerError>;
+type SsrForHttpEffect<E, R> = Effect.Effect<void, never, SsrForHttpRequirement<E, R>>;
+/**
+ * Registers buffered, GET-only HTML routes for a matcher.
+ *
+ * Path captures take precedence over same-named query parameters. Rendering
+ * completes before the response is created; this adapter does not stream.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Typed route matchers already describe decoding, guards, parent prefixes, and
+ * render output. `ssrForHttp` installs that same model in Effect's HttpRouter
+ * and buffers one complete HTML document for runtimes that require a known body.
+ *
+ * ## Ownership and lifetime
+ *
+ * Registration adds GET routes to the supplied Effect HttpRouter. Each request
+ * creates request-local memory navigation and current-route services; the
+ * request Effect owns rendering and all finalizers. Buffered rendering must
+ * complete before the response is returned. Rendering HTML does not mount or
+ * hydrate a browser client.
+ *
+ * ## Routing behavior
+ *
+ * Matcher cases sharing a path are tried in their compiled order. Path params
+ * overwrite same-named query params. Decode/guard failures continue candidate
+ * selection; a matched renderer failure stays in the typed request error channel.
+ *
+ * @example
+ * ```ts
+ * import { ssrForHttp } from "@typed/ui/HttpRouter"
+ * import { Effect } from "effect"
+ * import * as HttpRouter from "effect/unstable/http/HttpRouter"
+ * import { Parse, match } from "@typed/router"
+ * import { html } from "@typed/template"
+ *
+ * const pages = match(Parse("/"), html`<h1>Home</h1>`)
+ * const routes = Effect.gen(function* () {
+ *   const router = yield* HttpRouter.make
+ *   yield* ssrForHttp(router, pages)
+ *   return router
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Buffered server rendering
+ */
 export declare const ssrForHttp: {
-    <E, R>(input: Matcher<RenderEvent, E, R>): (router: HttpRouter) => Effect.Effect<void, never, Exclude<R, ProvidedForSsr>>;
-    <E, R>(router: HttpRouter, input: Matcher<RenderEvent, E, R>): Effect.Effect<void, never, Exclude<R, ProvidedForSsr>>;
+    <E, R>(input: Matcher<RenderEvent, E, R>): (router: HttpRouter) => SsrForHttpEffect<E, R>;
+    <E, R>(router: HttpRouter, input: Matcher<RenderEvent, E, R>): SsrForHttpEffect<E, R>;
 };
-export declare function handleHttpServerError(router: HttpRouter): Effect.Effect<void, never, import("effect/unstable/http/HttpRouter").Request<"GlobalError", unknown>>;
+/**
+ * Registers streaming, GET-only HTML routes for a matcher.
+ *
+ * Path captures take precedence over same-named query parameters. HTML chunks
+ * are emitted as they are rendered via `renderToHtml` and `HttpServerResponse.stream`.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Streaming lets the server send ordered renderer-owned HTML chunks before the
+ * whole page completes while preserving the same Typed matcher and Effect HTTP model.
+ *
+ * ## Ownership and lifetime
+ *
+ * Registration adds GET routes to the supplied router. Each request owns its
+ * navigation/router services and stream Scope. Client cancellation interrupts
+ * rendering and runs finalizers. The stream carries typed renderer failures;
+ * producing HTML alone does not attach client hydration behavior.
+ *
+ * @example
+ * ```ts
+ * import { streamingSsrForHttp } from "@typed/ui/HttpRouter"
+ * import { Effect } from "effect"
+ * import * as HttpRouter from "effect/unstable/http/HttpRouter"
+ * import { Parse, match } from "@typed/router"
+ * import { html } from "@typed/template"
+ *
+ * const pages = match(Parse("/"), html`<h1>Streamed home</h1>`)
+ * const routes = Effect.gen(function* () {
+ *   const router = yield* HttpRouter.make
+ *   yield* streamingSsrForHttp(router, pages)
+ *   return router
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Streaming server rendering
+ */
+export declare const streamingSsrForHttp: {
+    <E, R>(input: Matcher<RenderEvent, E, R>): (router: HttpRouter) => SsrForHttpEffect<E, R>;
+    <E, R>(router: HttpRouter, input: Matcher<RenderEvent, E, R>): SsrForHttpEffect<E, R>;
+};
+/**
+ * Converts Effect HTTP server errors into empty 400, 404, or 500 responses.
+ * Other failures remain in the global error channel.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Effect's structured server failures have a safe transport status, whereas
+ * application/domain errors must remain visible for deliberate handling.
+ *
+ * ## Ownership and lifetime
+ *
+ * The middleware is installed on the supplied router and runs in each request
+ * lifetime. It allocates no long-lived resource and does not log, swallow, or
+ * reclassify non-HttpServerError failures.
+ *
+ * @example
+ * ```ts
+ * import { handleHttpServerError } from "@typed/ui/HttpRouter"
+ * import { Effect } from "effect"
+ * import * as HttpRouter from "effect/unstable/http/HttpRouter"
+ *
+ * const router = Effect.gen(function* () {
+ *   const router = yield* HttpRouter.make
+ *   yield* handleHttpServerError(router)
+ *   return router
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category HTTP error responses
+ */
+export declare function handleHttpServerError(router: HttpRouter): Effect.Effect<void, never, HttpRouterRequest<"GlobalError", unknown>>;
 export {};
 //# sourceMappingURL=HttpRouter.d.ts.map

package/dist/HttpRouter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HttpRouter.d.ts","sourceRoot":"","sources":["../src/HttpRouter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,KAAK,UAAU,EAA4B,MAAM,iCAAiC,CAAC;AAK5F,OAAO,EAQL,KAAK,OAAO,EAGZ,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEvE,KAAK,cAAc,GAAG,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC;AAE3C,eAAO,MAAM,UAAU,EAAE;IACvB,CAAC,CAAC,EAAE,CAAC,EACH,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC,GAChC,CAAC,MAAM,EAAE,UAAU,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;IAClF,CAAC,CAAC,EAAE,CAAC,EACH,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC,GAChC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;CAY1D,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,yGAQvD"}
+{"version":3,"file":"HttpRouter.d.ts","sourceRoot":"","sources":["../src/HttpRouter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAOxC,OAAO,EACL,KAAK,UAAU,EACf,KAAK,QAAQ,IAAI,kBAAkB,EACnC,KAAK,OAAO,IAAI,iBAAiB,EAGlC,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,eAAe,MAAM,sCAAsC,CAAC;AAGxE,OAAO,EAML,KAAK,OAAO,EAKZ,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAoC,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAErF,KAAK,cAAc,GAAG,kBAAkB,GAAG,UAAU,GAAG,MAAM,CAAC;AAE/D,KAAK,qBAAqB,CAAC,CAAC,EAAE,CAAC,IAC3B,OAAO,CAAC,CAAC,EAAE,cAAc,CAAC,GAC1B,iBAAiB,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,eAAe,CAAC,eAAe,CAAC,CAAC;AAEzE,KAAK,gBAAgB,CAAC,CAAC,EAAE,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AA+EtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,KAAK,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1F,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAClD,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,mBAAmB,EAAE;IAChC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,KAAK,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1F,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACjD,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,yEAQvD"}

package/dist/HttpRouter.js

@@ -1,36 +1,182 @@
+import { Fx } from "@typed/fx";
 import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
 import { dual } from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
-import { RouteContext } from "effect/unstable/http/HttpRouter";
+import * as Context from "effect/Context";
+import { hasProperty } from "effect/Predicate";
+import * as Stream from "effect/Stream";
+import { RouteContext, } from "effect/unstable/http/HttpRouter";
 import * as HttpServerError from "effect/unstable/http/HttpServerError";
 import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
-import { RefSubject } from "@typed/fx";
-import { compile, CurrentRoute, makeCatchManager, makeLayerManager, makeLayoutManager, Join, Parse, } from "@typed/router";
+import { compile, CurrentRoute, makeRouteExecutor, Join, Parse, } from "@typed/router";
+import { Uuid7State } from "@typed/id/Uuid7";
 import { initialMemory } from "@typed/navigation";
-import { renderToHtmlString } from "@typed/template";
-export const ssrForHttp = dual(2, (router, input) => {
-    return Effect.gen(function* () {
-        const matcher = Option.match(yield* Effect.serviceOption(CurrentRoute), {
-            onNone: () => input,
-            onSome: (parent) => input.prefix(parent.route),
+import { renderToHtml, renderToHtmlString } from "@typed/template";
+const htmlResponseHeaders = { "content-type": "text/html; charset=utf-8" };
+const bufferedResponse = () => Effect.fn((rendered, requestServices) => Effect.gen(function* () {
+    const html = yield* renderToHtmlString(rendered).pipe(Effect.provideContext(requestServices));
+    return HttpServerResponse.text(html, { headers: htmlResponseHeaders });
+}));
+const streamingResponse = () => Effect.fn((rendered, requestServices) => Effect.gen(function* () {
+    const context = Context.merge(requestServices, yield* Effect.context());
+    return HttpServerResponse.stream(Stream.provideContext(renderToHtml(rendered).pipe(Fx.provideContext(requestServices), Fx.toStream, Stream.encodeText), context), { headers: htmlResponseHeaders });
+}));
+function makeSsrForHttp(createResponse) {
+    return dual(2, (router, input) => {
+        return Effect.gen(function* () {
+            const matcher = Option.match(yield* Effect.serviceOption(CurrentRoute), {
+                onNone: () => input,
+                onSome: (parent) => input.prefix(parent.route),
+            });
+            const entries = compile(matcher.cases);
+            const currentServices = yield* Effect.context();
+            const candidatesByPath = new Map();
+            for (const entry of entries) {
+                const path = getMatcherPath(entry.route.path);
+                const candidates = candidatesByPath.get(path);
+                if (candidates === undefined) {
+                    candidatesByPath.set(path, [entry]);
+                }
+                else {
+                    candidates.push(entry);
+                }
+            }
+            yield* router.addAll(Array.from(candidatesByPath, ([path, candidates]) => toRoute(path, candidates, currentServices, createResponse)));
         });
-        const entries = compile(matcher.cases);
-        const currentServices = yield* Effect.services();
-        yield* router.addAll(entries.map((e) => toRoute(e, currentServices)));
     });
-});
+}
+function getMatcherPath(path) {
+    const queryStart = path.search(/\?[^/?]+=/);
+    return (queryStart < 0 ? path : path.slice(0, queryStart));
+}
+/**
+ * Registers buffered, GET-only HTML routes for a matcher.
+ *
+ * Path captures take precedence over same-named query parameters. Rendering
+ * completes before the response is created; this adapter does not stream.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Typed route matchers already describe decoding, guards, parent prefixes, and
+ * render output. `ssrForHttp` installs that same model in Effect's HttpRouter
+ * and buffers one complete HTML document for runtimes that require a known body.
+ *
+ * ## Ownership and lifetime
+ *
+ * Registration adds GET routes to the supplied Effect HttpRouter. Each request
+ * creates request-local memory navigation and current-route services; the
+ * request Effect owns rendering and all finalizers. Buffered rendering must
+ * complete before the response is returned. Rendering HTML does not mount or
+ * hydrate a browser client.
+ *
+ * ## Routing behavior
+ *
+ * Matcher cases sharing a path are tried in their compiled order. Path params
+ * overwrite same-named query params. Decode/guard failures continue candidate
+ * selection; a matched renderer failure stays in the typed request error channel.
+ *
+ * @example
+ * ```ts
+ * import { ssrForHttp } from "@typed/ui/HttpRouter"
+ * import { Effect } from "effect"
+ * import * as HttpRouter from "effect/unstable/http/HttpRouter"
+ * import { Parse, match } from "@typed/router"
+ * import { html } from "@typed/template"
+ *
+ * const pages = match(Parse("/"), html`<h1>Home</h1>`)
+ * const routes = Effect.gen(function* () {
+ *   const router = yield* HttpRouter.make
+ *   yield* ssrForHttp(router, pages)
+ *   return router
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Buffered server rendering
+ */
+export const ssrForHttp = makeSsrForHttp(bufferedResponse());
+/**
+ * Registers streaming, GET-only HTML routes for a matcher.
+ *
+ * Path captures take precedence over same-named query parameters. HTML chunks
+ * are emitted as they are rendered via `renderToHtml` and `HttpServerResponse.stream`.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Streaming lets the server send ordered renderer-owned HTML chunks before the
+ * whole page completes while preserving the same Typed matcher and Effect HTTP model.
+ *
+ * ## Ownership and lifetime
+ *
+ * Registration adds GET routes to the supplied router. Each request owns its
+ * navigation/router services and stream Scope. Client cancellation interrupts
+ * rendering and runs finalizers. The stream carries typed renderer failures;
+ * producing HTML alone does not attach client hydration behavior.
+ *
+ * @example
+ * ```ts
+ * import { streamingSsrForHttp } from "@typed/ui/HttpRouter"
+ * import { Effect } from "effect"
+ * import * as HttpRouter from "effect/unstable/http/HttpRouter"
+ * import { Parse, match } from "@typed/router"
+ * import { html } from "@typed/template"
+ *
+ * const pages = match(Parse("/"), html`<h1>Streamed home</h1>`)
+ * const routes = Effect.gen(function* () {
+ *   const router = yield* HttpRouter.make
+ *   yield* streamingSsrForHttp(router, pages)
+ *   return router
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Streaming server rendering
+ */
+export const streamingSsrForHttp = makeSsrForHttp(streamingResponse());
+/**
+ * Converts Effect HTTP server errors into empty 400, 404, or 500 responses.
+ * Other failures remain in the global error channel.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Effect's structured server failures have a safe transport status, whereas
+ * application/domain errors must remain visible for deliberate handling.
+ *
+ * ## Ownership and lifetime
+ *
+ * The middleware is installed on the supplied router and runs in each request
+ * lifetime. It allocates no long-lived resource and does not log, swallow, or
+ * reclassify non-HttpServerError failures.
+ *
+ * @example
+ * ```ts
+ * import { handleHttpServerError } from "@typed/ui/HttpRouter"
+ * import { Effect } from "effect"
+ * import * as HttpRouter from "effect/unstable/http/HttpRouter"
+ *
+ * const router = Effect.gen(function* () {
+ *   const router = yield* HttpRouter.make
+ *   yield* handleHttpServerError(router)
+ *   return router
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category HTTP error responses
+ */
 export function handleHttpServerError(router) {
     return router.addGlobalMiddleware(Effect.catch((error) => HttpServerError.isHttpServerError(error)
-        ? Effect.succeed(HttpServerResponse.text(error.message, { status: getStatus(error) }))
+        ? Effect.succeed(HttpServerResponse.empty({ status: getStatus(error) }))
         : Effect.fail(error)));
 }
 function getStatus(error) {
-    switch (error.reason._tag) {
+    const reason = error.reason;
+    switch (reason._tag) {
         case "RouteNotFound":
             return 404;
         case "RequestParseError":
@@ -38,20 +184,23 @@ function getStatus(error) {
         case "InternalError":
         case "ResponseError":
             return 500;
+        default: {
+            const _exhaustive = reason;
+            return 500;
+        }
     }
 }
-function toRoute(entry, currentServices) {
+function toRoute(path, candidates, currentServices, createResponse) {
     return {
-        "~effect/http/HttpRouter/Route": "~effect/http/HttpRouter/Route",
+        ["~effect/http/HttpRouter/Route"]: "~effect/http/HttpRouter/Route",
         method: "GET",
-        path: entry.route.path,
+        path,
         handler: Effect.gen(function* () {
-            const fiberId = yield* Effect.fiberId;
-            const rootScope = yield* Effect.scope;
             const routeContext = yield* RouteContext;
             const request = yield* HttpServerRequest.HttpServerRequest;
             const searchParams = yield* HttpServerRequest.ParsedSearchParams;
-            const provided = Layer.mergeAll(initialMemory({ url: request.url }), Layer.succeed(CurrentRoute, yield* Effect.serviceOption(CurrentRoute).pipe(Effect.map(Option.match({
+            const requestUrl = Option.getOrElse(HttpServerRequest.toURL(request), () => new URL(request.url, "http://localhost"));
+            const provided = Layer.mergeAll(initialMemory({ url: requestUrl, origin: requestUrl.origin }).pipe(Layer.provide(Uuid7State.Default)), Layer.succeed(CurrentRoute, yield* Effect.serviceOption(CurrentRoute).pipe(Effect.map(Option.match({
                 onNone: () => ({
                     route: Parse(request.url),
                     parent: undefined,
@@ -61,39 +210,33 @@ function toRoute(entry, currentServices) {
                     parent,
                 }),
             })))));
-            const input = { ...routeContext.params, ...searchParams };
-            const params = yield* Effect.mapError(entry.decode(input), (cause) => new HttpServerError.HttpServerError({
-                reason: new HttpServerError.RequestParseError({ request, cause }),
-            }));
-            const memoMap = yield* Layer.makeMemoMap;
-            const layerManager = makeLayerManager(memoMap, rootScope, fiberId);
-            const layoutManager = makeLayoutManager(rootScope, fiberId);
-            const catchManager = makeCatchManager(rootScope, fiberId);
-            const prepared = yield* layerManager.prepare(entry.layers.concat(provided));
-            const guardExit = yield* entry
-                .guard(params)
-                .pipe(Effect.provideServices(prepared.services), Effect.exit);
-            if (Exit.isFailure(guardExit) || Option.isNone(guardExit.value)) {
-                yield* prepared.rollback;
-                return yield* new HttpServerError.HttpServerError({
-                    reason: new HttpServerError.RouteNotFound({ request }),
-                });
-            }
-            const matchedParams = guardExit.value.value;
-            yield* prepared.commit;
-            const scope = yield* Scope.fork(rootScope);
-            const paramsRef = yield* RefSubject.make(matchedParams).pipe(Scope.provide(scope));
-            const preparedServices = prepared.services;
-            const handlerServices = ServiceMap.merge(ServiceMap.merge(currentServices, preparedServices), ServiceMap.make(Scope.Scope, scope));
-            const handlerFx = entry.handler(paramsRef);
-            const withLayouts = yield* layoutManager.apply(entry.layouts, matchedParams, handlerFx, preparedServices);
-            const withCatches = yield* catchManager.apply(entry.catches, withLayouts, preparedServices);
-            const html = yield* renderToHtmlString(withCatches).pipe(Effect.provideServices(handlerServices));
-            return HttpServerResponse.text(html, {
-                headers: { "content-type": "text/html; charset=utf-8" },
-            });
+            const input = { ...searchParams, ...routeContext.params };
+            const requestServices = Context.merge(currentServices, yield* Effect.context());
+            const executor = yield* makeRouteExecutor().pipe(Effect.provideContext(requestServices));
+            const rendered = yield* executor
+                .transition({
+                path: request.url,
+                input,
+                candidates,
+                layers: [provided],
+            })
+                .pipe(Effect.catchIf(isRouteDecodeError, (error) => new HttpServerError.HttpServerError({
+                reason: new HttpServerError.RequestParseError({ request, cause: error }),
+            })), Effect.catchIf(isRouteGuardError, () => new HttpServerError.HttpServerError({
+                reason: new HttpServerError.RouteNotFound({ request }),
+            })));
+            return yield* createResponse(rendered, requestServices);
         }),
         uninterruptible: false,
-        prefix: undefined,
+        prefix: Option.none(),
     };
 }
+function hasTag(value, tag) {
+    return hasProperty(value, "_tag") && value._tag === tag;
+}
+function isRouteDecodeError(value) {
+    return hasTag(value, "RouteDecodeError");
+}
+function isRouteGuardError(value) {
+    return hasTag(value, "RouteGuardError");
+}