@weftui/dom 0.27.0 → 0.28.0

package/docs/reference/dom.md

@@ -2,7 +2,7 @@
 title: "@weftui/dom"
 order: 2
 section: reference
-description: Full API surface for @weftui/dom — the client renderer (mount, hydrate) and the server renderer (renderToString and streaming variants).
+description: Full API surface for @weftui/dom — the WeftApp client runtime (make, mount, hydrate, errors, dispose) and the server renderer (renderToString and streaming variants).
 ---
 
 # @weftui/dom API Reference
@@ -14,70 +14,191 @@ for a narrative walkthrough.
 
 ## `@weftui/dom/client`
 
-### `mount`
+`WeftApp` is the client entry point's app namespace (`export * as WeftApp from
+"./weft-app"`). One `WeftApp` value is one lazily-built `ManagedRuntime` (the app
+layer) + one root `Scope` + one unhandled-error hub. Each `WeftApp.mount` /
+`WeftApp.hydrate` call creates a child **root scope** under the app scope;
+layer-built services are shared **by reference** across every root mounted from the
+same app (layer memoization), which is what makes cross-island reactive state work
+(see [examples/shared-state-islands](https://github.com/stefvw93/weft/tree/main/examples/shared-state-islands)). The
+barrel also re-exports `MountError`, `HydrateError`, `RootHandle`, `UnhandledError`,
+and the `WeftApp` interface's type as `WeftAppType` (renamed on export to avoid
+colliding with the `WeftApp` namespace import).
+
+### `WeftApp.make`
+
+```ts
+const make: {
+  (): WeftApp<never, never>;
+  <R, E>(
+    layer: Layer.Layer<R, E, never>,
+    options?: { readonly memoMap?: Layer.MemoMap },
+  ): WeftApp<R, E>;
+};
+```
+
+Creates a `WeftApp` from an app layer. Synchronous and side-effect-free with
+respect to the layer: the layer builds **lazily** on the first `mount` / `hydrate`
+(or the first direct `app.runtime` run) — `ManagedRuntime.make` semantics. A layer
+whose construction has an observable side effect shows that effect only after the
+first mount, never at `make` time. `options.memoMap` shares layer memoization
+across multiple `WeftApp` instances.
+
+There is deliberately no `makeScoped`. To bind an app's lifetime to a scope,
+compose it yourself:
+
+```ts
+const acquireApp = Effect.acquireRelease(
+  Effect.sync(() => WeftApp.make(AppLive)),
+  (app) => WeftApp.dispose(app),
+);
+```
+
+### `WeftApp.mount`
+
+```ts
+const mount: <R, E>(
+  app: WeftApp<R, E>,
+  node: Renderable,
+  root: HTMLElement,
+) => Effect.Effect<RootHandle, E | MountError>;
+```
+
+Mounts `node` into `root` as a new root of `app`. Self-contained — the returned
+effect's requirement channel is `never`, so it runs with a bare `Effect.runPromise`;
+services come exclusively from the app layer, and an `Effect.provide` wrapped around
+this call does not reach components. Clears `root`'s existing children, renders,
+appends the result. Completes after initial render; streams keep running in the
+background, owned by the root's scope (a child of the app scope). The app layer
+builds lazily here on first mount; its error channel `E` surfaces at that point. On
+render failure the root scope is closed before the error propagates; the app
+runtime and other roots are untouched. Mounting on a disposed app fails — it does
+not hang.
+
+### `WeftApp.hydrate`
+
+```ts
+function hydrate<A extends Renderable, R = never, E = never>(
+  app: WeftApp<R, E>,
+  node: A,
+  root: HTMLElement,
+): [AssertNoServerOnly<CoreNode.Context<A>>] extends [CoreNode.Context<A>]
+  ? Effect.Effect<RootHandle, E | HydrateError>
+  : ServerOnlyLeak;
+```
+
+Continues, on the client, the DOM produced on the server by
+`renderToStringHydratable` / `renderToStreamHydratable`, as a new root of `app`.
+Unlike `mount`, does **not** clear `root`: it walks the node tree in lockstep with
+the existing server DOM, adopting nodes in place. Error channel is `E |
+HydrateError` (adds `HydrationMismatchError` on top of everything `mount` can fail
+with). Preserves the compile-time `AssertNoServerOnly` → `ServerOnlyLeak` guard: a
+server-only requirement left in `node`'s context degrades the return type to the
+`ServerOnlyLeak` sentinel (compile error at the call site) instead of a runtime
+failure. Hydration mechanics — the readiness barrier, stream-id seeding — are
+otherwise unchanged from `mount`.
+
+### `WeftApp.errors`
 
 ```ts
-mount(node: Renderable, target: Element): Effect<MountHandle, RenderError, R>
+const errors: <R, E>(app: WeftApp<R, E>) => Stream.Stream<UnhandledError>;
 ```
 
-Renders a Weft `node` into `target` for a fresh (non-SSR) page, building real DOM
-and starting every reactive stream. Returns a `MountHandle` whose scope owns the
-mounted tree; closing it tears the tree down. Use `mount` for purely client-rendered
-apps; use `hydrate` when the markup already exists from SSR.
+The app's unhandled-error stream. While at least one subscriber exists, the default
+`Effect.logError` fallback is suppressed and every `UnhandledError` is delivered to
+all subscribers. With zero subscribers, each unhandled error runs the default log
+(annotated with `weft.region`) instead. No replay — a subscriber sees only errors
+published after it subscribed; multiple concurrent subscribers each receive every
+subsequent error. When the last subscriber unsubscribes, the default log resumes.
 
-### `hydrate`
+### `WeftApp.dispose`
 
 ```ts
-hydrate(node: Renderable, target: Element): Effect<MountHandle, HydrationMismatchError | RenderError, R>
+const dispose: <R, E>(app: WeftApp<R, E>) => Effect.Effect<void>;
 ```
 
-Adopts server-rendered DOM **in place** inside `target` and resumes reactivity
-without re-creating elements. The `node` must produce a tree structurally identical
-to what the server rendered; a divergence fails with `HydrationMismatchError`. This
-is the flash-free path: no second render, the existing nodes simply become live.
+Disposes the app: closes every root scope (in mount order), then releases the
+runtime's layers (`runtime.disposeEffect`), then shuts the error hub down.
+Idempotent — teardown effects run once. Subsequent `mount` / `hydrate` calls fail.
 
-### `mountScoped`
+### `WeftApp<R, E>` (`WeftAppType`)
 
 ```ts
-mountScoped(app: Renderable, root: HTMLElement): Effect<MountHandle, UnsupportedNodeTypeError | StreamSubscriptionError | RenderError, Scope.Scope>
+interface WeftApp<in R = never, out E = never> {
+  readonly [TypeId]: typeof TypeId;
+  readonly runtime: ManagedRuntime.ManagedRuntime<R, E>;
+}
 ```
 
-Scope-aware `mount`: identical behavior, but requires an ambient `Scope.Scope` in
-`R` and registers `unmount` as a finalizer on it, so the mount lives until that
-scope closes rather than only until the mount effect resolves. Provide any scoped
-layer **outside** a long-lived scoped region so it outlives initial render — see
-[Provide Services](https://weftui.dev/docs/how-to/provide-services) for the composition and
-[Layer lifetime at the mount](https://weftui.dev/docs/explanation/services-and-context#layer-lifetime-at-the-mount)
-for why.
+Re-exported from the barrel as `WeftAppType`. `runtime` is the app's
+`ManagedRuntime`, for running app-level effects against the shared layer outside any
+root — e.g. `app.runtime.runFork(trackPageviews)` (see
+`website/src/entry-client.ts`) or `app.runtime.runPromise(Router.push("/about"))`.
 
-### `hydrateScoped`
+### `RootHandle`
 
 ```ts
-hydrateScoped(app: Renderable, root: HTMLElement): Effect<MountHandle, UnsupportedNodeTypeError | StreamSubscriptionError | RenderError | HydrationMismatchError, Scope.Scope>
+interface RootHandle {
+  readonly element: HTMLElement;
+  unmount(): Effect.Effect<void>;
+}
 ```
 
-Scope-aware `hydrate` — same relationship as `mountScoped` to `mount`, with
-`hydrate`'s error union (`HydrationMismatchError` added) and the same client-only
-compile-time guard: a server-only requirement left in `app`'s `R` degrades the
-return type to `ServerOnlyLeak` via `AssertNoServerOnly`.
+Returned by `mount` / `hydrate`. `element` is the DOM element the root was mounted
+into. `unmount()` closes **this root's scope only**: it interrupts its stream
+subscriptions and any scoped work forked from its event handlers. It does **not**
+dispose the app runtime, touch other roots, or remove the rendered DOM nodes from
+`element`. Idempotent — teardown side effects fire once.
 
-### `MountHandle`
+### `UnhandledError`
 
-The handle returned by `mount`, `hydrate`, `mountScoped`, and `hydrateScoped`. Its
-`unmount()` interrupts every subscription and event handler and disposes the
-mount's `ManagedRuntime`; it does **not** remove the mounted DOM nodes from `root`.
-`unmount` is idempotent — safe to call more than once, including once
-automatically and once explicitly.
+```ts
+interface UnhandledError {
+  readonly cause: Cause.Cause<unknown>;
+  readonly region: string;
+  readonly root: RootHandle;
+}
+```
+
+An error that escaped every user-level handler and reached the app's
+unhandled-error hub, published on `WeftApp.errors(app)`. `region` identifies where
+in the render tree the error escaped. Sources (one entry per failing occurrence):
+
+- a rendered stream subscription failing or dying with **no enclosing `Boundary`**
+  (region e.g. `"attribute:class"`, `"child:stream-3"`),
+- an error escaping the **outermost** `Boundary` recovery (region
+  `"boundary:outermost"`),
+- an event-handler effect **failing or dying** (region `"event:onClick"`) — reported
+  in development and production alike; there is no `NODE_ENV`-gated swallow.
+
+Interrupt-only causes are never published. Errors handled by a nested `Boundary`
+never reach the hub.
+
+### `MountError`
+
+```ts
+type MountError = UnsupportedNodeTypeError | StreamSubscriptionError | RenderError;
+```
+
+Errors `mount` can fail with, beyond the app layer's own error channel `E`.
+
+### `HydrateError`
+
+```ts
+type HydrateError = MountError | HydrationMismatchError;
+```
+
+Everything `MountError` covers, plus `HydrationMismatchError` when the server DOM
+and the node tree diverge.
+
+### `TypeId`
+
+```ts
+const TypeId: unique symbol; // Symbol.for("@weftui/dom/WeftApp")
+```
 
-The runtime backing the handle lives until `unmount` runs, not until the
-`mount`/`hydrate` effect resolves — that effect completes right after initial
-render, while streams and handlers keep running in the background. If `mount` or
-`hydrate` runs inside a region that supplies an ambient `Scope.Scope` (e.g. under
-`Effect.scoped`), `unmount` is auto-registered on that scope as a finalizer, so the
-mount tears down when the scope closes; with no ambient scope, behavior is
-unchanged and `unmount` must be called explicitly. `mountScoped`/`hydrateScoped`
-register the same finalizer explicitly, so the typed variant does not silently
-depend on this auto-registration.
+The unique brand for `WeftApp` values. Internal identity marker; rarely referenced
+directly.
 
 ## `@weftui/dom/server`
 
@@ -136,7 +257,7 @@ Re-exports the renderer error types:
 ## See also
 
 - [Render on the Server](https://weftui.dev/docs/how-to/render-on-the-server) — a narrative walkthrough of the server/client split
-- [Provide Services](https://weftui.dev/docs/how-to/provide-services) — recipes for value layers, `mountScoped`, and `ManagedRuntime`
+- [Provide Services](https://weftui.dev/docs/how-to/provide-services) — recipes for app layers, scoped layers, and binding an app's lifetime to an external scope
 - [The Rendering Model](https://weftui.dev/docs/explanation/rendering-model) — hydrate-in-place and why there is no virtual DOM
-- [Services and Context](https://weftui.dev/docs/explanation/services-and-context#layer-lifetime-at-the-mount) — why scoped layers need the mount to outlive initial render
+- [Services and Context](https://weftui.dev/docs/explanation/services-and-context) — how services flow from the app layer to every root
 - [`@weftui/core` reference](https://weftui.dev/docs/reference/core) · [`@weftui/router` reference](https://weftui.dev/docs/reference/router)

package/docs/reference/router.md

@@ -203,7 +203,7 @@ RouterApp<E, R>(def: RouterDef<E, R>): Node<Exclude<E, RouterNotFound>, R | Rout
 
 The universal router root node — render this on both server and client. Wraps the nested outlet in the router's internal not-found boundary, so a `RouterNotFound` raised by a page renders the configured `notFound` page in place. Server dispatch runs through `HttpApiBuilder`: a page-raised `RouterNotFound` and a no-match surface their 404 through the platform request pipeline.
 
-`RouterApp` requires `Router` in its environment — provide it via `RouterLive` (client) or `RouterServer` (server), not `Effect.provide` at the node level (that would release the scoped layer immediately).
+`RouterApp` requires `Router` in its environment — provide it via `RouterLive` (client) or `RouterServer` (server), not `Effect.provide` at the node level — services under `WeftApp` come exclusively from the app's layer, not ambient `Effect.provide`.
 
 ### `outletNode` (a.k.a. `RouterOutlet`)
 
@@ -224,11 +224,11 @@ RouterLive(
 ): Layer.Layer<Router | AppRpcClientTag>;
 ```
 
-The client `Router` layer, backed by the History API. Seeds a `SubscriptionRef` from `window.location`, listens for `popstate`, installs the same-origin link-click interceptor, and derives the `HttpApiClient` exposed as `Router.httpApiClient` (over `FetchHttpClient`; `baseUrl` defaults to same-origin). Alongside `Router` it also provides the core [`AppRpcClientTag`](https://weftui.dev/docs/reference/core#apprpcclienttag) seam — a **network** flat rpc client over the app's merged `RpcGroup` (`RpcClient.make` → `POST /_eui/rpc`) — so `@weftui/dom` can resolve a [`Boundary.rpc`](https://weftui.dev/docs/reference/core#boundaryrpc) (hydrated refetch and client-first SPA mount) without depending on this package or `effect/unstable/rpc`. Pass the same merged `group` the server wires into [`RouterServer`](#routerserver). **Scoped** — it must outlive the mount, so provide it through a `ManagedRuntime`:
+The client `Router` layer, backed by the History API. Seeds a `SubscriptionRef` from `window.location`, listens for `popstate`, installs the same-origin link-click interceptor, and derives the `HttpApiClient` exposed as `Router.httpApiClient` (over `FetchHttpClient`; `baseUrl` defaults to same-origin). Alongside `Router` it also provides the core [`AppRpcClientTag`](https://weftui.dev/docs/reference/core#apprpcclienttag) seam — a **network** flat rpc client over the app's merged `RpcGroup` (`RpcClient.make` → `POST /_eui/rpc`) — so `@weftui/dom` can resolve a [`Boundary.rpc`](https://weftui.dev/docs/reference/core#boundaryrpc) (hydrated refetch and client-first SPA mount) without depending on this package or `effect/unstable/rpc`. Pass the same merged `group` the server wires into [`RouterServer`](#routerserver). **Scoped** — it must outlive the mount; give it to `WeftApp.make` and the app runtime owns its lifetime (built lazily on first mount, released at `WeftApp.dispose`):
 
 ```typescript
-const runtime = ManagedRuntime.make(RouterLive(App, { rpc: { group: StockRpcs } }));
-void runtime.runPromise(hydrate(RouterApp(App), root));
+const app = WeftApp.make(RouterLive(App, { rpc: { group: StockRpcs } }));
+void Effect.runPromise(WeftApp.hydrate(app, RouterApp(App), root));
 ```
 
 ### Programmatic navigation
@@ -323,7 +323,7 @@ These power the runtime and are exported for tooling/tests; most apps never touc
 | Export                      | Description                                                                                                                                                                    |
 | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `compile(def)`              | Walks a tree into flat `CompiledLeaf`s with merged path/query schemas and layout chains.                                                                                       |
-| `buildHttpApi(leaves)`      | Builds the authoritative `HttpApi` (one `"pages"` group, a GET endpoint per leaf with `setPath`/`setUrlParams` + 404). Called by `Router.router`; the result is `def.httpApi`. |
+| `buildHttpApi(leaves)`      | Builds the authoritative `HttpApi` (one `"pages"` group, a GET endpoint per leaf with `params`/`query` schemas + 404). Called by `Router.router`; the result is `def.httpApi`. |
 | `leafRegistry`              | `WeakMap<RouteNode, CompiledLeaf>` read by `href` to resolve a leaf's pattern/schemas.                                                                                         |
 | `match(compiled, url)`      | Resolves a URL to a `RouteMatch` (`Matched` with decoded `path`/`query`, or `NotFound`).                                                                                       |
 | `compileMatchers(compiled)` | Precompiles per-leaf regex matchers.                                                                                                                                           |

package/docs/tutorial/01-your-first-app.md

@@ -14,9 +14,11 @@ We assume you know [Effect](https://effect.website/docs/getting-started/introduc
 ## Install
 
 ```bash
-npm install @weftui/core @weftui/dom effect
+npm install @weftui/core @weftui/dom effect@beta
 ```
 
+Weft tracks Effect 4's beta line. This release is built and tested against `effect@4.0.0-beta.98`; the peer range accepts newer 4.0 betas, which may contain upstream breaking changes.
+
 `@weftui/core` gives you the element builders and combinators; `@weftui/dom` renders them (its `./client` entry mounts in the browser). `effect` is the peer everything is built on.
 
 ## Build a component
@@ -25,14 +27,15 @@ A **component is a plain function you call** — there is no JSX and no `<Compon
 
 ```typescript
 import { h } from "@weftui/core";
-import { mount } from "@weftui/dom/client";
+import { WeftApp } from "@weftui/dom/client";
 import { Effect } from "effect";
 
 function App() {
   return h.div({ class: "app" }, [h.h1("Hello, Weft"), h.p("A minimal app.")]);
 }
 
-void Effect.runPromise(mount(App(), document.getElementById("root")!));
+const app = WeftApp.make();
+void Effect.runPromise(WeftApp.mount(app, App(), document.getElementById("root")!));
 ```
 
 The `h` namespace is the entry point: every property (`h.div`, `h.h1`, `h.button`, …) is a builder for that HTML tag. A builder takes optional props and children, and returns a `Node`.
@@ -40,7 +43,7 @@ The `h` namespace is the entry point: every property (`h.div`, `h.h1`, `h.button
 ## What just happened
 
 - `App()` returns a **`Node<never, never>`** — the two type parameters are the error channel (`E`) and the requirement channel (`R`), both `never` here because this component neither fails nor needs a service. As your app grows, those channels accumulate what it can fail with and what it depends on. That is the whole point of Weft's types — see [The Rendering Model](https://weftui.dev/docs/explanation/rendering-model).
-- `mount(node, target)` renders the node into `target`, building real DOM and starting any reactive streams. It returns an `Effect<MountHandle>`; run it with your Effect runtime (`Effect.runPromise` is fine for a script).
+- `WeftApp.make()` creates a Weft app — synchronously, with no layer to build yet. `WeftApp.mount(app, node, target)` renders the node into `target`, building real DOM and starting any reactive streams. It returns `Effect<RootHandle, …>` with `R = never`, so a bare `Effect.runPromise` runs it — no `Effect.provide` needed. You will give `WeftApp.make` a `Layer` once components need services — see [Services and Async](https://weftui.dev/docs/tutorial/03-services-and-async).
 - The component function runs **once**. Nothing here re-runs on a timer or a state change — because there is no state yet. That comes next.
 
 ## Next

package/docs/tutorial/02-reactivity.md

@@ -15,7 +15,7 @@ Use Effect's `SubscriptionRef` for component-local state. `SubscriptionRef.chang
 
 ```typescript
 import { h } from "@weftui/core";
-import { mount } from "@weftui/dom/client";
+import { WeftApp } from "@weftui/dom/client";
 import { Effect, SubscriptionRef } from "effect";
 
 const Counter = () =>
@@ -29,7 +29,8 @@ const Counter = () =>
     ]);
   });
 
-void Effect.runPromise(mount(Counter(), document.getElementById("root")!));
+const app = WeftApp.make();
+void Effect.runPromise(WeftApp.mount(app, Counter(), document.getElementById("root")!));
 ```
 
 `Effect.gen` lets you `yield*` the `SubscriptionRef` to set up state **before** building the tree. Because a `Node` is an `Effect`, the component body is an ordinary generator — no hooks, no dependency arrays.

package/docs/tutorial/03-services-and-async.md

@@ -11,12 +11,12 @@ description: Give handlers access to services from the environment, and render a
 
 ## Handlers that use services
 
-An event handler can **return an Effect**, and that Effect runs in the component's environment — so it can read any service you provide at the mount boundary:
+An event handler can **return an Effect**, and that Effect runs in the app's environment — so it can read any service the app's layer provides:
 
 ```typescript
 import { h } from "@weftui/core";
-import { mount } from "@weftui/dom/client";
-import { Context, Effect, Layer, pipe } from "effect";
+import { WeftApp } from "@weftui/dom/client";
+import { Context, Effect, Layer } from "effect";
 
 class Logger extends Context.Service<Logger, { log: (message: string) => Effect.Effect<void> }>()(
   "Logger",
@@ -38,13 +38,12 @@ const LogButton = () =>
     "Log",
   );
 
-// Provide the layer at mount — every handler in the tree can now read Logger.
-void Effect.runPromise(
-  pipe(mount(LogButton(), document.getElementById("root")!), Effect.provide(LoggerLive)),
-);
+// Give the app the layer — every handler in every root can now read Logger.
+const app = WeftApp.make(LoggerLive);
+void Effect.runPromise(WeftApp.mount(app, LogButton(), document.getElementById("root")!));
 ```
 
-`Logger` entered the tree's requirement channel the moment `LogButton` read it, and you discharged it **once**, at `mount`, with `Effect.provide`. Provide too little and it is a compile error at the mount call. This is Weft's entire dependency-injection story — it is just Effect's. The deeper treatment is [Services and Context](https://weftui.dev/docs/explanation/services-and-context).
+`Logger` entered the tree's requirement channel the moment `LogButton` read it, and you discharged it **once**, by passing `LoggerLive` to `WeftApp.make`. Provide too little and it is a compile error — the type of `app` (and so of `WeftApp.mount(app, LogButton(), …)`) names exactly which service is missing. Services come exclusively from the app's layer: an `Effect.provide` wrapped around the `mount` call does **not** reach components or handlers. This is Weft's entire dependency-injection story — it is just Effect's. The deeper treatment is [Services and Context](https://weftui.dev/docs/explanation/services-and-context).
 
 ## Async loading states
 
@@ -52,7 +51,7 @@ A component can return a **`Stream<Node>`** to show different content over time.
 
 ```typescript
 import { h } from "@weftui/core";
-import { mount } from "@weftui/dom/client";
+import { WeftApp } from "@weftui/dom/client";
 import { Effect, Stream } from "effect";
 
 const AsyncGreeting = ({ name }: { name: string }) =>
@@ -66,7 +65,10 @@ const AsyncGreeting = ({ name }: { name: string }) =>
     ),
   );
 
-void Effect.runPromise(mount(AsyncGreeting({ name: "World" }), document.getElementById("root")!));
+const app = WeftApp.make();
+void Effect.runPromise(
+  WeftApp.mount(app, AsyncGreeting({ name: "World" }), document.getElementById("root")!),
+);
 ```
 
 The stream emits the loading node first, then the resolved node — the renderer swaps the DOM in place on the second emission. This is the raw mechanism; for coordinating _several_ async regions with a single fallback, reach for [`Boundary.suspend`](https://weftui.dev/docs/explanation/boundaries-and-suspense), which you will meet in the next step.

package/docs/tutorial/04-errors-and-server.md

@@ -42,11 +42,12 @@ export const render = () => Effect.runPromise(renderToStringHydratable(App()));
 
 ```typescript
 // client entry
-import { hydrate } from "@weftui/dom/client";
+import { WeftApp } from "@weftui/dom/client";
 import { Effect } from "effect";
 import { App } from "./app";
 
-void Effect.runPromise(hydrate(App(), document.getElementById("root")!));
+const app = WeftApp.make();
+void Effect.runPromise(WeftApp.hydrate(app, App(), document.getElementById("root")!));
 ```
 
 The same side-effect-free `App` is imported by both entries. For server-resolved data that replays into the client without a second request, `Boundary.rpc` extends this model — resolve an rpc on the server, serialize its result into the HTML, replay it on hydrate, then keep the region live for refetch.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weftui/dom",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "DOM renderer for Weft — mount and hydrate in the browser, render to string or stream on the server",
   "keywords": [
     "dom",
@@ -44,19 +44,20 @@
     "access": "public"
   },
   "dependencies": {
-    "@weftui/core": "0.27.0"
+    "@weftui/core": "0.28.0"
   },
   "devDependencies": {
     "@types/jsdom": "^28.0.3",
-    "@types/node": "^25.9.2",
-    "effect": "4.0.0-beta.93",
+    "@types/node": "^26.1.1",
+    "effect": "4.0.0-beta.98",
     "jsdom": "^29.1.1",
-    "tsx": "^4.22.4",
-    "typescript": "^6.0.3",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
-    "vite-plus": "0.2.2"
+    "tstyche": "^7.2.2",
+    "tsx": "^4.23.1",
+    "typescript": "^7.0.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.5",
+    "vite-plus": "0.2.5"
   },
   "peerDependencies": {
-    "effect": "4.0.0-beta.93"
+    "effect": ">=4.0.0-beta.98 <4.0.0"
   }
 }