effect-cf 0.0.3 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dan van der Merwe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,70 +1,56 @@
 # effect-cf
 
-Effect-native primitives for Cloudflare Workers and bindings.
+Effect-native Cloudflare primitives for Workers, Durable Objects, bindings, KV, and Durable Object storage.
 
-## Design Goal
+## Install
 
-Cloudflare services should be described as `Context`, `Layer`, and `Effect` values and executed through package-owned Cloudflare entrypoint/runtime boundaries. Consumer code should stay in `Effect`; bindings and storage helpers wrap Promise-returning Cloudflare APIs so applications do not call `Effect.runPromise` or manually bridge Promises.
+`effect-cf` currently targets Effect 4 beta.
 
-The low-level Worker entrypoint factory is exported as `Worker.make`. It returns a `WorkerEntrypoint` class with a `fetch` handler and optional typed RPC methods. Durable Object support starts with `DurableObject.make`, which routes Durable Object lifecycle methods and RPC handlers through one managed runtime for each Durable Object instance.
-
-Worker fetch handlers can return either web `Response` values or Effect `HttpServerResponse` values. `Worker.make` renders `HttpServerResponse` back to a web `Response` at the Cloudflare boundary, so application handlers can stay in Effect HTTP primitives.
-
-Use `requestLayer` on `Worker.make` for per-request services such as auth/session context, tenant metadata, request IDs, or request-local clients. The request layer scope is the handler evaluation scope: it closes when the handler produces a `Response`, not when a streaming response body is later consumed by the platform.
+```bash
+bun add effect-cf "effect@^4.0.0-beta.65"
+```
 
-For modules that need an `ExportedHandler` object instead of a `WorkerEntrypoint` class, use `Worker.makeFetchHandler`. This helper is fetch-only and intentionally does not accept Worker RPC methods.
+```bash
+pnpm add effect-cf "effect@^4.0.0-beta.65"
+```
 
-RPC contracts can be described as classes with `Worker.Tag` and `DurableObject.Tag`. Contract classes expose `.make(...)` for runtime entrypoint creation and `.Binding(...)` / `.Namespace(...)` for typed bindings. Bindings infer call types from the same code-owned contract classes. Definition-backed calls encode/decode arguments and success values with their Effect schemas at Worker and Durable Object boundaries.
+```bash
+npm install effect-cf "effect@^4.0.0-beta.65"
+```
 
-Binding helpers expose two RPC paths:
+## Goal
 
-- `call(...)` awaits one RPC result inside `Effect`. Use it for ordinary structured-cloneable values.
-- `rpc(...)` returns Cloudflare's native RPC thenable/stub without awaiting it, preserving promise pipelining.
-- `scopedCall(...)` awaits the result and registers any `Symbol.dispose` disposer with the current Effect `Scope`.
+Cloudflare APIs return promises and expose platform-specific bindings. `effect-cf` wraps those boundaries as `Context`, `Layer`, and `Effect` values so application code stays inside one managed Effect runtime.
 
-Client APIs use Cloudflare-style provider types, so object results expose pipelined property and method access. `ServerApi` remains available when a plain implementation-shaped `(...args) => Promise<A>` contract is needed.
+Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 
-## Current Exports
+## Exports
 
-- `Worker` - WorkerEntrypoint class factory, schema-backed RPC contract tags, and service binding helpers
-- `DurableObject` - Durable Object class factory, schema-backed RPC contract tags, and namespace helpers
-- `WorkerDefinition`, `DurableObjectDefinition` - compatibility exports for the lower-level definition modules
-- `DurableObjectNamespace` - typed Durable Object namespace binding helper
-- `DurableObjectState`, `DurableObjectStorage` - small Effect wrappers for Durable Object state, alarms, SQL, and embedded KV storage
-- `DurableObjectWebSocket` - Durable Object WebSocket upgrade helpers built on `WebSocketPair` and `acceptWebSocket`
-- `Binding` - low-level binding service helper
+- `Worker` - Worker entrypoint factory, request services, and typed Worker bindings
+- `DurableObject` - Durable Object entrypoint factory and typed namespace helpers
+- `DurableObjectState` / `DurableObjectStorage` - Effect wrappers for state, alarms, SQL, and embedded KV
+- `DurableObjectWebSocket` - WebSocket upgrade helpers for Durable Objects
 - `Kv` - typed KV namespace helper
-- `Rpc` - Cloudflare RPC type helpers, `RpcTarget` / `RpcStub` re-exports, and scoped disposal utilities
-- `ServiceBinding` - typed Worker-to-Worker service binding helper
-- `WorkerEnvironment` - request environment service
-- `WorkerConfig` - Effect `Config` helpers backed by Cloudflare worker `env`, including `layerWith` for custom env-to-config mapping
-
-## RPC Values
-
-Definition-backed RPC methods are intended for schema-backed structured values. If a Cloudflare RPC method returns a lifecycle-managed RPC object or stub, expose that through a lower-level binding API instead of a `WorkerDefinition` / `DurableObjectDefinition` method so disposal remains explicit.
+- `Rpc` - Cloudflare RPC type helpers and scoped disposal utilities
+- `WorkerConfig` - Effect `Config` helpers backed by Cloudflare `env`
 
-## Durable Object WebSocket Example
+## Worker Example
 
 ```ts
-const request = yield * Worker.NativeRequest;
+import { HttpServerResponse } from "effect";
+import { Worker } from "effect-cf";
 
-if (!Worker.isWebSocketUpgrade(request)) {
-  return new Response("Expected WebSocket upgrade", { status: 426 });
-}
-
-const upgrade =
-  yield *
-  DurableObjectWebSocket.acceptUpgrade({
-    tags: ["room:general"],
-    attachment: { roomId: "general" },
-  });
-
-return upgrade.response;
+export default Worker.make({
+  fetch: () => HttpServerResponse.text("ok"),
+});
 ```
 
 ## Durable Object Example
 
 ```ts
+import { Effect, Layer, Schema as S } from "effect";
+import { DurableObject, DurableObjectState } from "effect-cf";
+
 export class Counter extends DurableObject.Tag<Counter>()("Counter", {
   get: DurableObject.method({ success: S.Number }),
 }) {}
@@ -83,4 +69,8 @@ export const CounterDurableObject = Counter.make(Layer.empty, {
 });
 ```
 
-Define the Wrangler binding and SQLite migration in the application. This package intentionally does not replace `wrangler.jsonc`.
+Define Wrangler bindings and migrations in the consuming application.
+
+## License
+
+MIT