opencode-effect-enforcer 0.2.2 → 0.2.4

package/skills/effect-domain-predicates/SKILL.md

@@ -55,8 +55,7 @@ When you need an `Equivalence` instance (for use with combinators), derive it fr
 import { Schema, Array } from 'effect';
 import * as Equivalence from 'effect/Equivalence';
 
-declare const Task: Schema.Schema<any, any, never>;
-type Task = Schema.Schema.Type<typeof Task>;
+class Task extends Schema.Class<Task>('Task')({ id: Schema.String }) {}
 
 // Derive from schema (structural equality)
 export const TaskEquivalence = Schema.toEquivalence(Task);
@@ -603,7 +602,7 @@ declare const appointments: Array<Appointment.Appointment>;
  * import { pipe } from "effect/Function"
  *
  * const tomorrow = DateTime.addDuration(
- *   DateTime.unsafeNow(),
+ *   DateTime.makeUnsafe('2026-09-06T00:00:00Z'),
  *   Duration.days(1)
  * )
  *
@@ -612,7 +611,8 @@ declare const appointments: Array<Appointment.Appointment>;
  *   Array.filter(Appointment.isScheduledBefore(tomorrow))
  * )
  */
-const tomorrow = DateTime.addDuration(DateTime.unsafeNow(), Duration.days(1));
+// Deterministic fixture; in runtime code obtain the instant with yield* DateTime.now.
+const tomorrow = DateTime.addDuration(DateTime.makeUnsafe('2026-09-06T00:00:00Z'), Duration.days(1));
 
 const beforeTomorrow = pipe(
 	appointments,
@@ -791,8 +791,7 @@ const areSame = Equal.equals(t1, t2);
 ```typescript
 import { Schema, Array } from 'effect';
 
-declare const Task: Schema.Schema<any, any, never>;
-type Task = Schema.Schema.Type<typeof Task>;
+class Task extends Schema.Class<Task>('Task')({ id: Schema.String }) {}
 
 export const Equivalence = Schema.toEquivalence(Task);
 

package/skills/effect-error-handling/SKILL.md

@@ -1083,7 +1083,7 @@ const secondaryService: Effect.Effect<Data, SecondaryServiceError> =
 
 // Try primary, fallback to secondary
 //          Effect<Data, SecondaryServiceError, Dependencies>
-const program = primaryService.pipe(Effect.orElse(() => secondaryService));
+const program = primaryService.pipe(Effect.catch(() => secondaryService));
 ```
 
 ### Retry with Schedule
@@ -1205,10 +1205,11 @@ const program = loadConfig.pipe(
 
 // With custom defect message
 const program2 = loadConfig.pipe(
-	Effect.orDieWith(
+	Effect.mapError(
 		(error) =>
 			new Error(`Fatal: Configuration failed to load: ${error._tag}`)
-	)
+	),
+	Effect.orDie
 );
 ```
 
@@ -1387,7 +1388,7 @@ Model ambiguous HTTP responses (where the body structure differs for success vs
 
 ```typescript
 import { Effect, Schema } from 'effect';
-import { HttpClientResponse } from 'effect/unstable/HttpClient';
+import { HttpClientResponse } from 'effect/unstable/http';
 
 class TokenSuccess extends Schema.Class<TokenSuccess>('TokenSuccess')({
 	access_token: AccessToken,

package/skills/effect-http-api/SKILL.md

@@ -14,7 +14,7 @@ Key reference files:
 - `packages/effect/HTTPAPI.md` — canonical HttpApi documentation
 - `packages/effect/src/unstable/httpapi/*.ts` — module sources
 - `packages/effect/typetest/unstable/httpapi/*.tst.ts` — type-level contracts
-- `packages/platform-node/test/HttpApi.test.ts` — comprehensive runtime tests
+- `packages/platform/node/test/HttpApi.test.ts` — comprehensive runtime tests
 - `ai-docs/src/51_http-server/` — server walkthrough with fixtures
 - `ai-docs/src/50_http-client/` — HttpClient walkthrough
 
@@ -1170,6 +1170,17 @@ Top-level group endpoints are at the root: `buildUrl.health()`. With `disableCod
 
 ## OpenAPI Documentation
 
+As of rc.112 built-in OpenAPI documentation responses are generated lazily on
+the first request, rather than while the route layer is built. A generation
+defect is not permanently cached: a later request retries generation. Include a
+documentation-route request in integration checks if generation must be verified;
+successful server startup alone no longer proves it. Explicit `OpenApi.fromApi`
+remains a direct synchronous generation call.
+
+JSON Schema import/conversion now rejects unsupported references, validation
+keywords, and unrepresentable dialect conversions instead of weakening them.
+See `effect-schema-v4` before importing third-party schemas into an API contract.
+
 ### Scalar UI
 
 ```ts

package/skills/effect-http-client/SKILL.md

@@ -24,7 +24,7 @@ Key files:
 - `packages/effect/src/unstable/http/Url.ts` — immutable helpers over the native `URL`
 - `packages/effect/src/unstable/http/Cookies.ts` — cookie model, `fromSetCookie`, `toCookieHeader`, `getValue`
 - `packages/effect/src/unstable/http/Headers.ts` — header model, `Input` forms, `CurrentRedactedNames`
-- `packages/platform-node/src/NodeHttpClient.ts` — Node transports: undici, node:http, fetch re-export
+- `packages/platform/node/src/NodeHttpClient.ts` — Node transports: undici, node:http, fetch re-export
 - `packages/effect/test/unstable/http/HttpClient.test.ts` — retryTransient, withRateLimiter, abort semantics
 - `ai-docs/src/50_http-client/10_basics.ts` — canonical "wrap a configured client in a service" lesson
 

package/skills/effect-http-server/SKILL.md

@@ -24,9 +24,9 @@ Key files:
 - `packages/effect/src/unstable/http/HttpBody.ts` — body variants (`Empty`/`Raw`/`Uint8Array`/`FormData`/`Stream`) and constructors
 - `packages/effect/src/unstable/http/Headers.ts`, `Cookies.ts`, `Multipart.ts` — header/cookie/multipart models and limits
 - `packages/effect/src/unstable/http/HttpStaticServer.ts` — static file serving
-- `packages/platform-node/src/NodeHttpServer.ts` — Node server adapter, `layer`, `layerTest`, graceful shutdown
-- `packages/platform-bun/src/BunHttpServer.ts` — Bun equivalent
-- `packages/platform-node/test/NodeHttpServer.test.ts` — the best end-to-end reference for real route/middleware/multipart wiring
+- `packages/platform/node/src/NodeHttpServer.ts` — Node server adapter, `layer`, `layerTest`, graceful shutdown
+- `packages/platform/bun/src/BunHttpServer.ts` — Bun equivalent
+- `packages/platform/node/test/NodeHttpServer.test.ts` — the best end-to-end reference for real route/middleware/multipart wiring
 
 ## Core Model
 
@@ -197,6 +197,10 @@ const byteStream = request.stream; // Stream<Uint8Array, HttpServerError> (singl
 
 Cap accepted body sizes with the `MaxBodySize` reference (re-exported from `HttpIncomingMessage`, default `undefined` = unlimited):
 
+On Node in rc.112, `remoteAddress` returns `Option.none()` after Node has cleared
+the incoming message's socket. Preserve absence; do not dereference the native
+socket after request cleanup. The same behavior applies to Node client responses.
+
 ```ts
 import { FileSystem } from 'effect';
 
@@ -650,6 +654,13 @@ yield* HttpServer.serveEffect(httpEffect);
 
 ## 8. WebSocket Upgrades
 
+In `@effect/platform-bun` rc.112, outgoing WebSocket messages are compressed when
+per-message deflate is configured **and negotiated**. The server option
+`websocket.compressionThreshold` sets the minimum byte size (default `1024`);
+smaller messages stay uncompressed. Configure it alongside
+`websocket.perMessageDeflate` on `BunHttpServer.layer` rather than pre-compressing
+application payloads. See `packages/platform/bun/src/BunHttpServer.ts`.
+
 `request.upgrade` yields a `Socket` (from `effect/unstable/socket`) once the connection is upgraded. Both `NodeHttpServer` and `BunHttpServer` handle the platform `upgrade` events for you — just write a normal route:
 
 ```ts

package/skills/effect-layer-design/SKILL.md

@@ -554,69 +554,35 @@ const services = Layer.mergeAll(UserServiceLayer, OrderServiceLayer).pipe(
 
 If downstream code does not need the dependency, use `Layer.provide` and keep it hidden. Do not preserve every intermediate service by default.
 
-## Pattern: SynchronizedRef + Deferred State Machine
+## Pattern: Share Work With a Cache
 
-For services that need atomic state transitions with concurrent callers, use `SynchronizedRef.modifyEffect` combined with `Deferred` for result sharing:
+For lazy one-shot result sharing, allocate `Effect.cached(work)` once inside the
+service's layer. It shares in-flight work and the completed result (including
+failure). Do not reallocate the cache on each method call.
 
+<!-- typecheck -->
 ```typescript
-import { Deferred, Effect, Fiber, Scope, SynchronizedRef } from 'effect';
-
-type State<A, E> =
-	| { readonly _tag: 'Idle' }
-	| {
-			readonly _tag: 'Running';
-			readonly done: Deferred.Deferred<A, E>;
-			readonly fiber: Fiber.Fiber<A, E>;
-	  }
-	| { readonly _tag: 'Pending'; readonly done: Deferred.Deferred<A, E> };
-
-const make = <A, E>(scope: Scope.Scope) => {
-	const ref = SynchronizedRef.makeUnsafe<State<A, E>>({ _tag: 'Idle' });
-
-	const run = (work: Effect.Effect<A, E>) =>
-		SynchronizedRef.modifyEffect(
-			ref,
-			Effect.fnUntraced(function* (state) {
-				switch (state._tag) {
-					case 'Running':
-						// Already running — share the existing result
-						return [Deferred.await(state.done), state];
-					case 'Idle': {
-						// Start new work
-						const done = yield* Deferred.make<A, E>();
-						const fiber = yield* Effect.forkIn(
-							work.pipe(Effect.intoDeferred(done)),
-							scope
-						);
-						return [
-							Deferred.await(done),
-							{ _tag: 'Running' as const, done, fiber }
-						];
-					}
-					case 'Pending': {
-						// Queued — share the pending result
-						return [Deferred.await(state.done), state];
-					}
-				}
-			})
-		).pipe(Effect.flatten);
-
-	return { run };
-};
-```
+import { Context, Effect, Layer } from 'effect';
 
-Key properties:
+class Settings extends Context.Service<Settings, {
+	readonly load: Effect.Effect<string>;
+}>()('app/Settings') {}
 
-- **`SynchronizedRef.modifyEffect`** — atomically reads state, runs an effect, and updates state in one operation. No other caller can interleave.
-- **`Deferred`** — shares the result of in-flight work with concurrent callers who arrive while it's running.
-- **`Effect.forkIn(work, scope)`** — ties the worker fiber to the service scope, not the calling fiber.
-- The state machine pattern ensures at most one concurrent execution of `work`, with all callers sharing the same result.
+const layer = Layer.effect(Settings, Effect.gen(function* () {
+	const load = yield* Effect.cached(Effect.succeed('settings'));
+	return Settings.of({ load });
+}));
+```
 
-Use this pattern when:
+For refresh use `Effect.cachedInvalidateWithTTL(work, Duration.infinity)` and
+expose the returned invalidation effect. For keyed retention use `Cache`,
+`ScopedCache`, `RcMap`, or `LayerMap` according to resource lifetime (see
+`effect-cache`). `LayerMap.contextEffectOption` in rc.112 atomically retains an
+already-cached layer context without allocating a missing key.
 
-- Multiple concurrent callers may trigger the same expensive operation
-- Only one execution should run at a time
-- All callers should receive the same result
+When the requirement is a restartable worker, latest-wins scheduling, or queued
+state transitions, use a dedicated coordinator with explicit states and a
+supervised fiber lifetime (see `effect-fiber`). A cache is not a job scheduler.
 
 ## Naming Convention
 

package/skills/effect-mcp-server/SKILL.md

@@ -53,7 +53,7 @@ Layer.mergeAll(
 )
 ```
 
-Every server runner now requires a non-empty `protocols` option. Put the preferred fallback revision first; an exact initialization offer is selected when present, otherwise the first adapter is used where the transport permits fallback. Streamable HTTP rejects an explicit unsupported `MCP-Protocol-Version` header with `400`.
+Every server runner requires a non-empty `protocols` option. Put the preferred fallback revision first; an exact initialization offer is selected when present, otherwise the first adapter is used where the transport permits fallback. In rc.112, `initialize` negotiates from its body even if the client sends an unsupported default `MCP-Protocol-Version` header. The header is checked only on subsequent requests; unsupported explicit versions there still return `400`. Do not reject the initialization request in custom middleware before body negotiation.
 
 ## Protocol Revisions
 

package/skills/effect-pattern-matching/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: effect-pattern-matching
-description: Master Effect pattern matching using Data.TaggedEnum, $match, $is, Match.typeTags, and Effect.match. Avoid manual _tag checks and Effect.result patterns. Use this skill when working with discriminated unions, ADTs, or conditional logic based on tagged types.
+description: Match schema tagged unions with match/matchOrElse and guards, trusted Data.TaggedEnum values with $match/$is, and Effect outcomes with Effect.match. Use for discriminated unions, ADTs, or conditional logic based on tagged types.
 ---
 
 # Effect Pattern Matching Skill
@@ -28,9 +28,44 @@ Reference this for:
 - Declarative, not imperative
 - Pipeline-friendly composition
 
-## Pattern 1: Data.TaggedEnum for ADTs
+## Schema-First Matching (rc.112)
 
-Use `Data.TaggedEnum` instead of manual tagged unions.
+For domain/wire models, prefer class variants combined with
+`Schema.Union([...]).pipe(Schema.toTaggedUnion('kind'))`. Use `.match` for
+exhaustiveness, `.guards` for narrowing decoded values, and `.matchOrElse` for
+intentional partial matching. Direct `Schema.TaggedUnion` creates canonical
+`_tag` object variants. Both expose data-first and data-last `matchOrElse` forms;
+the `toTaggedUnion` fallback excludes handled variants, while direct
+`Schema.TaggedUnion.matchOrElse` types its fallback as the full union.
+
+<!-- typecheck -->
+```typescript
+import * as Schema from 'effect/Schema';
+
+const State = Schema.TaggedUnion({
+	Loading: {},
+	Ready: { data: Schema.Array(Schema.String) },
+	Failed: { message: Schema.String }
+});
+type State = typeof State.Type;
+
+const getData = State.matchOrElse({ Ready: (state) => state.data }, () => []);
+const label = State.match({
+	Loading: () => 'Loading',
+	Ready: ({ data }) => `${data.length} items`,
+	Failed: ({ message }) => message
+});
+```
+
+TypeScript correctly narrows literal discriminator checks. Prefer these helpers
+for exhaustive, reusable branching, not because manual checks cannot narrow.
+For the full class-based lifecycle example see `effect-domain-modeling`.
+
+## Pattern 1: Data.TaggedEnum for Trusted ADTs
+
+Use `Data.TaggedEnum` for trusted, non-schema ADTs. It supplies constructors and
+tag checks but does not parse unknown input; avoid a parallel Data model for an
+existing schema union.
 
 ### The Problem: Manual Tagged Unions
 
@@ -415,14 +450,12 @@ type LoadState = Data.TaggedEnum<{
 }>;
 const LoadState = Data.taggedEnum<LoadState>();
 
-const getData = (state: LoadState): string[] =>
-	pipe(
-		state,
-		// Type guard refines to Ready
-		LoadState.$is('Ready'),
-		// Now can access .data safely
-		(ready) => (ready ? ready.data : [])
-	);
+const getData = LoadState.$match({
+	Loading: () => [],
+	Ready: ({ data }) => data,
+	Error: () => []
+});
+// A guard returns boolean; piping through $is would lose the original value.
 ```
 
 ## Pattern 5: Use Option.match Instead of \_tag Checks

package/skills/effect-platform-abstraction/SKILL.md

@@ -16,7 +16,7 @@ Reference this for:
 - Path source: `packages/effect/src/Path.ts`
 - Crypto source: `packages/effect/src/Crypto.ts`
 - Socket source: `packages/effect/src/unstable/socket/`
-- Platform layers: `packages/platform-node/`, `packages/platform-bun/`, and `packages/platform-browser/`
+- Platform layers: `packages/platform/node/`, `packages/platform/bun/`, and `packages/platform/browser/`
 - Migration guide: `MIGRATION.md`
 - Effect source: `packages/effect/src/`
 

package/skills/effect-platform-layers/SKILL.md

@@ -292,7 +292,7 @@ const TestContext = Layer.mergeAll(
 		Terminal.make({
 			columns: Effect.succeed(80),
 			rows: Effect.succeed(24),
-			readInput: Effect.dieMessage('readInput not used in this test'),
+		readInput: Effect.die('readInput not used in this test'),
 			readLine: Effect.succeed('test input'),
 			display: () => Effect.void
 		})

package/skills/effect-rpc-api/SKILL.md

@@ -9,6 +9,13 @@ This skill covers the **contract layer**: the definitions that client and server
 
 ## Effect Source Reference
 
+In rc.112 schema encoding is selected by the transport's `codecFor`, rather
+than being fixed to canonical JSON for every protocol. Preserve the schemas and
+their decoding/encoding requirements in shared contracts; custom protocol
+implementations must supply `codecFor` (see `effect-rpc-client` /
+`effect-rpc-server`). Existing JSON, NDJSON, JSON-RPC, and MsgPack formats keep
+their wire representation; the new SchemaBinary transport has its own codecs.
+
 The Effect v4 source is at `~/.local/share/opencode/repos/github.com/Effect-TS/effect@main/`. Read it directly when in doubt — these modules are under `unstable` and move between betas.
 
 Key files:
@@ -20,7 +27,7 @@ Key files:
 - `packages/effect/src/unstable/rpc/RpcMessage.ts` — wire envelopes: `Request`, `Ack`, `Interrupt`, `Eof`, `Ping`, `ResponseChunk`, `ResponseExit`, `ExitEncoded`, `RequestId`
 - `packages/effect/src/unstable/rpc/RpcClientError.ts` — the transport error type referenced when typing shared client aliases
 - `packages/effect/src/unstable/rpc/index.ts` — public exports of the rpc namespace
-- `packages/platform-node/test/fixtures/rpc-schemas.ts` — the best real-world contract fixture: rpcs, streaming, middleware, deferred responses
+- `packages/platform/node/test/fixtures/rpc-schemas.ts` — the best real-world contract fixture: rpcs, streaming, middleware, deferred responses
 - `packages/effect/test/rpc/Rpc.test.ts` — `exitSchema`, custom defect schemas, `getStreamSchemas` semantics
 
 ## Core Model

package/skills/effect-rpc-client/SKILL.md

@@ -20,8 +20,8 @@ Key files:
 - `packages/effect/src/unstable/rpc/RpcWorker.ts` — `InitialMessage`, `layerInitialMessage`, `initialMessage`
 - `packages/effect/src/unstable/rpc/RpcMessage.ts` — wire vocabulary: `Request`, `Ack`, `Interrupt`, `Chunk`, `Exit`, `Defect`, `Ping`/`Pong`, `ClientProtocolError`, `RequestId`
 - `packages/effect/src/unstable/socket/Socket.ts` — `Socket` service, `layerWebSocket`, `WebSocketConstructor`
-- `packages/platform-node/test/RpcServer.test.ts` + `test/fixtures/rpc-e2e.ts` + `test/fixtures/rpc-schemas.ts` — the best end-to-end reference: every transport × serialization combination, headers, streams, interrupts, defects
-- `packages/platform-browser/test/RpcWorker.test.ts` + `test/fixtures/rpc-worker.ts` — worker transport end to end
+- `packages/platform/node/test/RpcServer.test.ts` + `test/fixtures/rpc-e2e.ts` + `test/fixtures/rpc-schemas.ts` — the best end-to-end reference: every transport × serialization combination, headers, streams, interrupts, defects
+- `packages/platform/browser/test/RpcWorker.test.ts` + `test/fixtures/rpc-worker.ts` — worker transport end to end
 
 ## Core Model
 
@@ -293,6 +293,13 @@ const TcpProtocolLive = RpcClient.layerProtocolSocket().pipe(
 
 Build your own with `RpcClient.Protocol.make((writeResponse, clientIds) => Effect<Omit<Service, 'run'>>)` — it buffers server responses per client until that client's `run` loop is installed. You rarely need this; prefer `RpcTest` for in-memory wiring (section 11).
 
+As of rc.112 the returned service must include `codecFor`, normally forwarded
+from the selected `RpcSerialization` service. It chooses the schema codec for
+RPC payloads/results while the protocol handles envelopes. JSON-compatible
+custom transports can use `codecFor: Schema.toCodecJson`. Preserve the schema's
+decoding and encoding service requirements; see `effect-rpc-server` for the
+full `RpcSerialization.CodecFor` contract.
+
 ---
 
 ## 5. Serialization — Pairing Codecs with Transports
@@ -303,7 +310,14 @@ Build your own with `RpcClient.Protocol.make((writeResponse, clientIds) => Effec
 |---|---|---|---|
 | `RpcSerialization.layerJson` | `application/json` | no | HTTP (response decoded once, as an array); WebSocket (each ws message is one frame already) |
 | `RpcSerialization.layerNdjson` | `application/ndjson` | yes (newline) | anything — the safe default; enables streaming over HTTP |
-| `RpcSerialization.layerMsgPack` | `application/msgpack` | yes (msgpack frames) | binary transports; smallest payloads; uses msgpackr `useRecords: true` |
+| `RpcSerialization.layerMsgPack` | `application/msgpack` | yes (msgpack frames) | binary framing with JSON-compatible schema codecs; msgpackr `useRecords: true` |
+| `RpcSerialization.layerSchemaBinary(options?)` | `application/vnd.effect.rpc+schema-binary` | yes | schema-derived binary framing and payload codecs; pair on both peers |
+
+`layerSchemaBinary({ maxFrameSize?, fingerprintPayloads? })` defaults to a
+16 MiB frame limit and no payload fingerprint. Envelopes are fingerprinted and
+dictionary-enabled; payload fingerprints opt into strict layout agreement.
+Existing built-in formats retain their wire encoding in rc.112. Workers use
+`Schema.toCodecJson` with structured clone without a serialization layer.
 | `RpcSerialization.layerJsonRpc({ contentType? })` | `application/json` | no | JSON-RPC 2.0 interop over HTTP/WebSocket; maps rpc tag ↔ `method`, supports batch arrays |
 | `RpcSerialization.layerNdJsonRpc({ contentType? })` | `application/json-rpc` | yes (newline) | JSON-RPC 2.0 over sockets |
 
@@ -413,7 +427,7 @@ const getUser = (id: string) =>
 Semantics to remember:
 
 - **`ClientProtocolError` fails everything in flight.** When a socket dies or a worker crashes, every pending request on that connection fails with the same `RpcClientError`. Requests are *not* replayed after reconnect — retry at the call site.
-- **Server defects are `Cause.Die`, not typed failures.** `Effect.catchTag` will not see them; use `Effect.sandbox`/`Effect.catchAllCause`. What survives the wire depends on the rpc's `defect` schema (see the effect-rpc-api skill).
+- **Server defects are `Cause.Die`, not typed failures.** `Effect.catchTag` will not see them; use `Effect.sandbox`/`Effect.catchCause`. What survives the wire depends on the rpc's `defect` schema (see the effect-rpc-api skill).
 - **Whole-connection defects** (server-side fatal defects when the server runs without `disableFatalDefects`) arrive as a `Defect` message and kill every in-flight request on the connection as `Cause.Die`.
 - `RpcTest.makeClient` clients have `E = never` — no transport error channel, only your rpc errors and middleware errors.
 
@@ -548,7 +562,7 @@ it.effect('GetUser', () =>
 
 Signature: `RpcTest.makeClient(group, options?: { flatten? })` with required context `Scope | Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs> | Rpc.MiddlewareClient<Rpcs>` — i.e. the handler layers, any *server* middleware layers, **and** any client middleware layers. Forgetting the client middleware layer is the classic confusing type error.
 
-The test client's `E` is `never`: transport errors cannot occur, so tests exercise only your declared errors, middleware errors, and defects. To also test serialization and transport semantics, build a real client+server pair against `NodeHttpServer.layerTest` exactly as `packages/platform-node/test/RpcServer.test.ts` does.
+The test client's `E` is `never`: transport errors cannot occur, so tests exercise only your declared errors, middleware errors, and defects. To also test serialization and transport semantics, build a real client+server pair against `NodeHttpServer.layerTest` exactly as `packages/platform/node/test/RpcServer.test.ts` does.
 
 ### `RpcClient.makeNoSerialization` (advanced)
 
@@ -656,7 +670,7 @@ const WorkerClientLive = UsersClient.layer.pipe(
 5. **Mismatched client/server serialization.** Both sides share one `RpcSerialization` choice; there is no negotiation. Garbled `RpcClientDefect: Error decoding ...` errors usually mean the codecs differ.
 6. **Reading mixed-case header names server-side.** `Headers.fromInput` lowercases keys: send `{ userId: '123' }`, read `headers.userid`. Same for `withHeaders` and middleware `Headers.set`.
 7. **Expecting `discard: true` to be error-free.** It only removes the rpc's *declared* error; `RpcClientError` and middleware errors remain, and over HTTP the POST round-trip is still awaited.
-8. **Catching server defects with `catchTag`.** Handler `Effect.die`s arrive as `Cause.Die`, not typed failures. Use `Effect.sandbox`/`Effect.catchAllCause`, and remember one server fatal defect can fail *all* in-flight requests on the connection.
+8. **Catching server defects with `catchTag`.** Handler `Effect.die`s arrive as `Cause.Die`, not typed failures. Use `Effect.sandbox`/`Effect.catchCause`, and remember one server fatal defect can fail *all* in-flight requests on the connection.
 9. **Assuming requests survive a reconnect.** A socket/worker failure fails every in-flight call with `RpcClientError`; after reconnect nothing is replayed. Add `Effect.retry` at call sites; `retryTransientErrors: true` only keeps requests pending across *connection-establishment* failures.
 10. **Passing `retryPolicy` to `layerProtocolSocket`.** The layer accepts `retryTransientErrors` and `onTransientError`, but not `retryPolicy`. For a custom reconnect schedule use `Layer.effect(RpcClient.Protocol)(RpcClient.makeProtocolSocket({ retryPolicy, retryTransientErrors, onTransientError }))`.
 11. **Treating a flattened client like an object client.** With `flatten: true` you call `client('GetUser', payload)`; `client.GetUser(payload)` is not a function. Pick one shape per client.

package/skills/effect-rpc-cluster/SKILL.md

@@ -36,9 +36,9 @@ Key files:
 - `packages/effect/src/unstable/workflow/WorkflowProxy.ts` + `WorkflowProxyServer.ts` — workflow ↔ RPC/HTTP bridge
 - `packages/effect/src/unstable/cluster/ClusterWorkflowEngine.ts` — production workflow engine backed by sharding + storage
 - `packages/effect/src/unstable/reactivity/AtomRpc.ts` — reactive RPC client for Atom UIs (see also `effect-atom-rpc` skill)
-- `packages/platform-node/src/NodeClusterHttp.ts` / `NodeClusterSocket.ts` — Node "all-in-one" cluster layers
-- `packages/platform-bun/src/BunClusterHttp.ts` / `BunClusterSocket.ts` — Bun equivalents
-- `packages/platform-node/test/RpcServer.test.ts` + `test/fixtures/rpc-{schemas,e2e}.ts` — best end-to-end reference for real RPC wiring
+- `packages/platform/node/src/NodeClusterHttp.ts` / `NodeClusterSocket.ts` — Node "all-in-one" cluster layers
+- `packages/platform/bun/src/BunClusterHttp.ts` / `BunClusterSocket.ts` — Bun equivalents
+- `packages/platform/node/test/RpcServer.test.ts` + `test/fixtures/rpc-{schemas,e2e}.ts` — best end-to-end reference for real RPC wiring
 - `packages/effect/test/cluster/TestEntity.ts` + `test/cluster/Entity.test.ts` — best reference for Entity + makeTestClient
 
 ## Imports
@@ -606,7 +606,10 @@ client.Subscribe({ topic: 't' }, {
 });
 ```
 
-`discard: true` removes the error channel — the request is sent and acknowledged; the result and any failure are discarded. Use for fire-and-forget commands (especially against persistent entities).
+`discard: true` skips response decoding and removes response-side failures;
+transport and required client-middleware failures can still occur. A successful
+send is not proof that the server completed the operation. Cluster persistent
+messages additionally have their documented storage/delivery outcomes.
 
 `asQueue: true` is useful when you need finer control than a `Stream` gives you — e.g., you want to take only one chunk, then drop it. The end-of-stream signal is `Cause.Done` in the queue's error channel.
 
@@ -685,15 +688,21 @@ const ConnectionHooksLayer = Layer.succeed(RpcClient.ConnectionHooks, {
 
 ### `RpcSchema.ClientAbort`
 
-When a client interrupts a streaming subscription, the server-side handler's `onInterrupt` finalizer sees a `Cause` carrying the `ClientAbort` annotation. Use it to distinguish client cancel from server shutdown:
+When a client interrupts a subscription, inspect interrupt reasons in the exit
+cause for the `ClientAbort` annotation. `onInterrupt` receives interruptor IDs,
+not a Cause; use `onExit` to distinguish client cancel from server shutdown:
 
+<!-- typecheck -->
 ```ts
 import { RpcSchema } from 'effect/unstable/rpc';
-import { Cause, Context } from 'effect';
-
-const subscribeHandler = stream.pipe(
-	Effect.onInterrupt((cause) => {
-		const isClientAbort = Context.has(cause, RpcSchema.ClientAbort);
+import { Cause, Effect, Exit, Stream } from 'effect';
+import * as Arr from 'effect/Array';
+
+declare const stream: Stream.Stream<string>;
+const subscribeHandler = stream.pipe(Stream.runDrain,
+	Effect.onExit((exit) => {
+		const isClientAbort = Exit.isFailure(exit) && Arr.some(exit.cause.reasons, (reason) =>
+			Cause.isInterruptReason(reason) && reason.annotations.has(RpcSchema.ClientAbort.key));
 		return Effect.logInfo('subscribe ended', { isClientAbort });
 	})
 );
@@ -782,10 +791,17 @@ The choice of serialization is load-bearing because of *framing*. Some transport
 | Layer | Content-Type | Framed? | Use for | Notes |
 |---|---|---|---|---|
 | `RpcSerialization.layerJson` | `application/json` | no | `layerProtocolHttp` | Default JSON over request/response |
-| `RpcSerialization.layerNdjson` | `application/ndjson` | yes (newline) | `layerProtocolWebsocket`, sockets, http+stream | Newline-delimited JSON; required for streaming |
+| `RpcSerialization.layerNdjson` | `application/ndjson` | yes (newline) | `layerProtocolWebsocket`, sockets, http+stream | Newline-delimited JSON; one of several streaming formats |
 | `RpcSerialization.layerJsonRpc()` | `application/json` (configurable) | no | JSON-RPC 2.0 interop | Maps `_tag` to `method`; preserves batched arrays |
 | `RpcSerialization.layerNdJsonRpc()` | `application/json-rpc` (configurable) | yes (newline) | JSON-RPC 2.0 over sockets | |
-| `RpcSerialization.layerMsgPack` | `application/msgpack` | yes (msgpack frames) | binary transports | Smallest wire size; native binary; uses `useRecords: true` |
+| `RpcSerialization.layerMsgPack` | `application/msgpack` | yes (msgpack frames) | binary transports | JSON-compatible schema codecs; uses `useRecords: true` |
+| `RpcSerialization.layerSchemaBinary(options?)` | `application/vnd.effect.rpc+schema-binary` | yes | binary transports, framed HTTP | schema-aware binary payloads and envelopes |
+
+In rc.112 serializations and both protocol services require `codecFor`.
+Custom protocols forward it from the serialization; custom JSON-compatible
+protocols can use `Schema.toCodecJson`. Cluster network codecs now follow the
+transport while persistent message storage remains JSON. See `effect-rpc-server`
+for the complete contract, binary options, and compatibility constraints.
 
 `RpcSerialization.makeMsgPack(options?)` lets you customize msgpackr (`useRecords`, `useFloat32`, etc.).
 
@@ -793,7 +809,7 @@ Picking the wrong one is a real bug:
 
 - `layerJson` over a websocket → no framing → the first chunk past the first message is misinterpreted
 - `layerMsgPack` against a JSON-only HTTP client → garbled responses
-- `layerNdjson` against `layerProtocolHttp` → works, but framing is wasted; clients have to wait for the response to end
+- `layerNdjson` against `layerProtocolHttp` → streams incrementally through a bounded response queue (default 16), without RPC acks
 
 ## Testing — `RpcTest.makeClient`
 
@@ -1347,6 +1363,15 @@ The generated **RPC** payload wraps the original payload as `{ entityId: string,
 
 As of beta.106, `EventLogEncryption.encrypt` returns `{ iv, encryptedEntry }` for every input entry, and `EventLogMessage.WriteEntries.encryptedEntries` carries `{ entryId, iv, encryptedEntry }` values. A fresh AES-GCM IV is generated per entry. This changes the encrypted replication wire format: upgrade encrypted event-log clients and servers together rather than performing a mixed-version rolling deployment.
 
+In rc.112, `EventJournal.withRemoteUncommited` (spelling intentional) receives a
+non-empty readonly entry array in its callback and returns `Effect<Option<A>, ...>`.
+No pending entries means `None` and the callback is not invoked; `Some(result)`
+means it ran. Update adapters/tests that assumed every flush calls the writer.
+EventLog retries transient remote write failures with exponential backoff from
+200 ms (factor 1.5), capped at 10 seconds, so pending local entries synchronize
+after recovery. Preserve journal acknowledgment/idempotency semantics in custom
+remotes rather than adding an independent retry loop.
+
 ### `WorkflowProxy` — workflow → RPC / HTTP
 
 ```ts
@@ -1372,6 +1397,11 @@ To namespace the generated rpcs, pass `prefix` as the **second** argument: `Work
 
 These proxies are how you give a frontend or an external system a typed RPC/HTTP surface that drives durable workflows, without leaking workflow-engine internals.
 
+In rc.112 workflow discard endpoints return a `Schema.String` execution ID
+instead of `void`, for both RPC and HTTP. Call the generated `<Name>Discard` RPC
+normally to receive it; passing the RPC client's `{ discard: true }` option
+discards even that ID. Entity discard endpoints keep their separate contract.
+
 ## Cluster + workflow integration — `ClusterWorkflowEngine`
 
 The in-memory `WorkflowEngine.layerMemory` is for testing only. For production, use `ClusterWorkflowEngine.layer`, which wires the workflow engine into the cluster's `Sharding` + `MessageStorage`:
@@ -1620,4 +1650,4 @@ const usersByName = Effect.gen(function*() {
 - For production cluster, use `NodeClusterSocket.layer` / `NodeClusterHttp.layer` (or the Bun equivalents) unless you specifically need to assemble layers manually.
 - Size `maxResidentEntities` and `unprocessedMessageBatchSize` deliberately for the runner's memory and storage throughput.
 - Match transport ↔ serialization: HTTP → `layerJson`; sockets/websocket/streaming → `layerNdjson` or `layerMsgPack`.
-- Pattern-match on `client.GetUser(...).pipe(Effect.catchTag('UserNotFound', ...), Effect.catchFilter(...))` for typed recovery; reserve broad `Effect.catchAll` for the runtime boundary.
+- Pattern-match on `client.GetUser(...).pipe(Effect.catchTag('UserNotFound', ...), Effect.catchFilter(...))` for typed recovery; reserve broad `Effect.catch` for an explicit boundary recovery policy.