@weftui/core 0.26.2 → 0.27.0

package/docs/tutorial/02-reactivity.md

@@ -11,7 +11,7 @@ description: Add component-local state with SubscriptionRef and weave its stream
 
 ## Local state with `SubscriptionRef`
 
-Use Effect's `SubscriptionRef` for component-local state. Its `.changes` property is a `Stream` that emits the current value and then every update. Pass that stream as a child or prop and the DOM at that spot becomes live:
+Use Effect's `SubscriptionRef` for component-local state. `SubscriptionRef.changes(ref)` returns a `Stream` that emits the current value and then every update. Pass that stream as a child or prop and the DOM at that spot becomes live:
 
 ```typescript
 import { h } from "@weftui/core";
@@ -23,7 +23,7 @@ const Counter = () =>
     const count = yield* SubscriptionRef.make(0);
 
     return yield* h.div([
-      h.span([count.changes]),
+      h.span([SubscriptionRef.changes(count)]),
       h.button({ onclick: () => SubscriptionRef.update(count, (n) => n + 1) }, "+"),
       h.button({ onclick: () => SubscriptionRef.update(count, (n) => n - 1) }, "-"),
     ]);
@@ -36,18 +36,18 @@ void Effect.runPromise(mount(Counter(), document.getElementById("root")!));
 
 ## The key idea: the body runs once
 
-The `Counter` function runs **exactly once**. It creates the ref, builds the tree, and returns. After that, nothing re-invokes it — the only thing that changes the DOM is the `count.changes` stream woven into the `h.span`. When you click `+`, `SubscriptionRef.update` pushes a new value, the stream emits, and the renderer patches _just that span's text_ in place. No diff, no re-render, no sibling touched.
+The `Counter` function runs **exactly once**. It creates the ref, builds the tree, and returns. After that, nothing re-invokes it — the only thing that changes the DOM is the `SubscriptionRef.changes(count)` stream woven into the `h.span`. When you click `+`, `SubscriptionRef.update` pushes a new value, the stream emits, and the renderer patches _just that span's text_ in place. No diff, no re-render, no sibling touched.
 
 This is what "streams are the weft" means in practice: reactivity is local to exactly where you thread a stream. Everything else is static. The full model is [The Rendering Model](https://weftui.dev/docs/explanation/rendering-model); the vocabulary of stream-shaped values is [Reactive Primitives](https://weftui.dev/docs/explanation/reactive-primitives).
 
-> **Note.** `[count.changes]` — the stream is passed as a child array. Static values (`"Hello"`, `5`) work in the same position and simply never change. The rule is uniform: a plain value is static, a stream-shaped value is reactive.
+> **Note.** `[SubscriptionRef.changes(count)]` — the stream is passed as a child array. Static values (`"Hello"`, `5`) work in the same position and simply never change. The rule is uniform: a plain value is static, a stream-shaped value is reactive.
 
 ## Deriving values
 
-Because `.changes` is a `Stream`, you shape reactive text with ordinary stream operators:
+Because `SubscriptionRef.changes(count)` returns a `Stream`, you shape reactive text with ordinary stream operators:
 
 ```typescript
-h.span([Stream.map(count.changes, (n) => `Count: ${n}`)]);
+h.span([Stream.map(SubscriptionRef.changes(count), (n) => `Count: ${n}`)]);
 ```
 
 Anywhere you would compute a derived value, map the stream instead — the derivation stays reactive.

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

@@ -18,10 +18,9 @@ import { h } from "@weftui/core";
 import { mount } from "@weftui/dom/client";
 import { Context, Effect, Layer, pipe } from "effect";
 
-class Logger extends Context.Tag("Logger")<
-  Logger,
-  { log: (message: string) => Effect.Effect<void> }
->() {}
+class Logger extends Context.Service<Logger, { log: (message: string) => Effect.Effect<void> }>()(
+  "Logger",
+) {}
 
 const LoggerLive = Layer.succeed(Logger, {
   log: (message) => Effect.sync(() => console.log(message)),

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

@@ -20,12 +20,12 @@ import { Data, Effect } from "effect";
 class ApiError extends Data.TaggedError("ApiError")<{ status: number }> {}
 
 const SafeWidget = () =>
-  Boundary.catchAll({ fallback: (e) => h.div({ class: "error" }, `Request failed: ${e.status}`) }, [
+  Boundary.catch({ fallback: (e) => h.div({ class: "error" }, `Request failed: ${e.status}`) }, [
     Effect.fail(new ApiError({ status: 503 })),
   ]);
 ```
 
-There are six failure-catch variants — `catchAll`, `catchAllCause`, `catchTag`, `catchTags`, `catchSome`, `catchIf` — mirroring Effect's own error operators. A failure that a boundary does not match re-raises to the **nearest enclosing** boundary; if none catches it, the mount fails. The conceptual model (and why the boundary's type reflects exactly which failures are handled) is [Boundaries and Suspense](https://weftui.dev/docs/explanation/boundaries-and-suspense).
+There are six failure-catch variants — `catch`, `catchCause`, `catchTag`, `catchTags`, `catchFilter`, `catchIf` — mirroring Effect's own error operators. A failure that a boundary does not match re-raises to the **nearest enclosing** boundary; if none catches it, the mount fails. The conceptual model (and why the boundary's type reflects exactly which failures are handled) is [Boundaries and Suspense](https://weftui.dev/docs/explanation/boundaries-and-suspense).
 
 ## Render on the server
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weftui/core",
-  "version": "0.26.2",
+  "version": "0.27.0",
   "description": "Element builders and combinators for Weft — reactive UI, woven from Effect",
   "keywords": [
     "combinators",
@@ -41,17 +41,15 @@
     "access": "public"
   },
   "devDependencies": {
-    "@effect/rpc": "^0.75.1",
     "@types/node": "^25.9.2",
     "csstype": "^3.2.3",
-    "effect": "^3.21.4",
+    "effect": "4.0.0-beta.93",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",
     "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
     "vite-plus": "0.2.2"
   },
   "peerDependencies": {
-    "@effect/rpc": "^0.75",
-    "effect": "^3.21"
+    "effect": "4.0.0-beta.93"
   }
 }