opencode-effect-enforcer 0.2.5 → 0.2.6

package/skills/effect-parallelization/SKILL.md

@@ -81,7 +81,7 @@ yield* Effect.forEach(ids, fetchUser, { concurrency: 8 });
 yield* Effect.forEach(ids, fetchUser, { concurrency: 'unbounded' });
 ```
 
-As of beta.102, `"inherit"`, `References.CurrentConcurrency`, and `Effect.withConcurrency` are removed. Reusable APIs that expose fan-out policy should accept a `Types.Concurrency` value and pass it explicitly to each combinator instead of relying on ambient configuration.
+Reusable APIs that expose fan-out policy should accept a `Types.Concurrency` value and pass it explicitly to each combinator instead of relying on ambient configuration.
 
 ### Failure semantics under concurrency
 
@@ -652,7 +652,7 @@ const checkConfig = (entries: ReadonlyArray<Entry>) =>
 ## Common Mistakes
 
 1. **Assuming `Effect.all` / `Effect.forEach` are parallel by default** — they are sequential. Pass `{ concurrency: n | 'unbounded' }` explicitly; without it you also silently lose request batching (see effect-batching).
-2. **Using removed ambient concurrency APIs** — beta.102 removed `"inherit"`, `References.CurrentConcurrency`, and `Effect.withConcurrency`. Pass a number or `"unbounded"` explicitly at each combinator.
+2. **Relying on ambient concurrency** — pass a number or `"unbounded"` explicitly at each combinator.
 3. **Wrong option key on zips** — `Effect.zip`/`zipWith` take `{ concurrent: true }` (boolean), not `{ concurrency: ... }`.
 4. **v3 `mode: 'either'` / `mode: 'validate'` on `Effect.all`** — gone. v4 has `mode: 'result'` (slots become `Result<A, E>`); for accumulate-all-failures use `Effect.validate`, which fails with `NonEmptyArray<E>`.
 5. **`Effect.makeSemaphore` / `Effect.makeLatch` no longer exist** — they moved to their own modules: `Semaphore.make(n)`, `Latch.make(open?)`, both importable from `'effect'`.

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

@@ -28,7 +28,7 @@ Reference this for:
 - Declarative, not imperative
 - Pipeline-friendly composition
 
-## Schema-First Matching (rc.112)
+## Schema-First Matching
 
 For domain/wire models, prefer class variants combined with
 `Schema.Union([...]).pipe(Schema.toTaggedUnion('kind'))`. Use `.match` for

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

@@ -206,7 +206,7 @@ const fileOperations = Effect.gen(function* () {
 });
 ```
 
-`fs.watch(directory)` reports direct-child changes by default; pass `{ recursive: true }` to include nested subdirectories. For open handles, `file.seek(offset, 'start' | 'current')` returns the new offset as a branded `FileSystem.Size`. The old `FileSystem.File.Descriptor` type and `file.descriptor` property were removed in beta.103; use scoped `File` methods instead.
+`fs.watch(directory)` reports direct-child changes by default; pass `{ recursive: true }` for nested subdirectories. `file.seek(offset, 'start' | 'current')` accepts and returns `bigint`; negative resulting positions fail without moving the cursor. File byte counts use `ByteSize.ByteSize`. Use scoped File methods for handle operations.
 
 **Streaming Files:**
 
@@ -782,10 +782,10 @@ declare const someOperation: Effect.Effect<string>;
 
 // ✅ CORRECT - Type-safe CLI with full Effect integration
 // Define arguments
-const inputArg = Argument.file('input');
+const inputArg = Argument.File('input');
 
 // Define flags
-const verboseFlag = Flag.boolean('verbose').pipe(Flag.withAlias('v'));
+const verboseFlag = Flag.Boolean('verbose').pipe(Flag.withAlias('v'), Flag.withDefault(false));
 
 // Define command
 const command = CliCommand.make(

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

@@ -9,11 +9,11 @@ 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
+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
+`effect-rpc-server`). JSON, NDJSON, and JSON-RPC formats use
 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.
@@ -627,5 +627,5 @@ it('GetUser exits round-trip', () => {
 11. **Mutating in place.** `annotate`, `prefix`, `middleware`, `setSuccess`, etc. all return new `Rpc`/`RpcGroup` values; discarding the return value is a no-op.
 12. **Renaming or re-prefixing rpcs after deployment.** `_tag` is the wire identity; old clients will send tags the server no longer knows. Treat tag changes like breaking schema changes.
 13. **Passing a union to `Schema.Union` variadically.** v4 takes an array: `Schema.Union([OrderError, RateLimited])`, not `Schema.Union(OrderError, RateLimited)`.
-14. **Declaring errors as plain `Schema.Struct`s.** Use `Schema.TaggedError` (or `Schema.Error` with a `Schema.tag` field) so errors are yieldable, `catchTag`-able, and carry a stable `_tag` on the wire. The former `Schema.TaggedErrorClass` / `Schema.ErrorClass` names were removed in beta.104.
+14. **Declaring errors as plain `Schema.Struct`s.** Use `Schema.TaggedError` (or `Schema.Error` with a `Schema.tag` field) so errors are yieldable, `catchTag`-able, and carry a stable `_tag` on the wire.
 15. **Expecting stack traces in remote defects.** The default `Schema.Defect()` strips stacks; opt in per rpc with `defect: Schema.Defect({ includeStack: true })`.

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

@@ -15,7 +15,7 @@ Key files:
 
 - `packages/effect/src/unstable/rpc/RpcClient.ts` — `make`, `makeNoSerialization`, the `Protocol` service, `layerProtocolHttp`/`layerProtocolSocket`/`layerProtocolWorker` (+ `makeProtocol*`), `CurrentHeaders`, `withHeaders`, `ConnectionHooks`
 - `packages/effect/src/unstable/rpc/RpcClientError.ts` — `RpcClientError` and `RpcClientDefect`
-- `packages/effect/src/unstable/rpc/RpcSerialization.ts` — `json`, `ndjson`, `jsonRpc`, `ndJsonRpc`, `msgPack` codecs, their layers, the `Parser` interface and `includesFraming`
+- `packages/effect/src/unstable/rpc/RpcSerialization.ts` — JSON, NDJSON, JSON-RPC, SchemaBinary codecs, their layers, the `Parser` interface and `includesFraming`
 - `packages/effect/src/unstable/rpc/RpcTest.ts` — `makeClient` in-process test client
 - `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`
@@ -30,7 +30,7 @@ A client is assembled from three replaceable layers plus your shared `RpcGroup`
 ```
 RpcClient.make(group)                      typed methods, spans, request ids
 	requires: Protocol                        ← RpcClient.layerProtocolHttp / Socket / Worker
-		requires: RpcSerialization              ← RpcSerialization.layerJson / Ndjson / MsgPack / JsonRpc
+		requires: RpcSerialization              ← JSON / NDJSON / SchemaBinary / JSON-RPC layer
 		requires: transport service             ← HttpClient | Socket.Socket | WorkerPlatform + Spawner
 ```
 
@@ -263,14 +263,14 @@ const BrowserProtocolLive = RpcClient.layerProtocolSocket().pipe(
 );
 ```
 
-`Socket.layerWebSocket(url, { closeCodeIsError?, openTimeout?, protocols? })` requires a `WebSocketConstructor`; `layerWebSocketConstructorGlobal` uses `globalThis.WebSocket`. `NodeSocket.layerWebSocket` bundles the constructor.
+`Socket.layerWebSocket(url, { openTimeout?, protocols?, highWaterMark? })` requires a `WebSocketConstructor`; `layerWebSocketConstructorGlobal` uses `globalThis.WebSocket`. `NodeSocket.layerWebSocket` bundles the constructor. Close is a typed failure; reconnect policies reacquire the scoped reader.
 
 ### Raw TCP
 
 ```ts
 const TcpProtocolLive = RpcClient.layerProtocolSocket().pipe(
 	Layer.provide(NodeSocket.layerNet({ port: 9000 })),
-	Layer.provide(RpcSerialization.layerMsgPack)
+	Layer.provide(RpcSerialization.layerSchemaBinary())
 );
 ```
 
@@ -293,7 +293,7 @@ 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
+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
@@ -310,26 +310,27 @@ full `RpcSerialization.CodecFor` contract.
 |---|---|---|---|
 | `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 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
+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 |
 
-Rules of thumb, verified by the upstream e2e matrix (http: ndjson/msgpack/ndJsonRpc; ws: ndjson/json/msgpack/jsonRpc; tcp: ndjson/msgpack/ndJsonRpc):
+Choose serialization according to transport framing:
 
-- **Raw TCP needs a framed codec** (`ndjson` / `msgPack` / `ndJsonRpc`) — plain `json` cannot find message boundaries in a byte stream.
+- **Raw TCP needs a framed codec** (NDJSON, SchemaBinary, or newline JSON-RPC) — plain JSON cannot find message boundaries in a byte stream.
 - **WebSocket works with any codec** including plain `json`, because the ws transport frames messages itself.
 - **HTTP + unframed (`json`/`jsonRpc`)**: the client buffers the whole response and expects a JSON array of response messages — streaming rpcs only flush when the response ends.
-- **HTTP + framed (`ndjson`/`msgPack`/`ndJsonRpc`)**: the client incrementally parses the response body — streaming rpc chunks arrive as the server emits them, over a single POST.
-- **Client and server must use the same codec.** A msgpack client against a json server garbles both directions.
+- **HTTP + framed serialization**: the client incrementally parses the response body — streaming rpc chunks arrive as the server emits them, over a single POST.
+- **Client and server must use the same codec.** SchemaBinary and JSON are distinct wire contracts.
 
-`RpcSerialization.makeMsgPack(options)` customizes msgpackr (`useRecords`, `useFloat32`, ...); wrap with `Layer.succeed(RpcSerialization.RpcSerialization)(RpcSerialization.makeMsgPack({ useRecords: false }))` if the peer cannot handle msgpackr record extensions.
+Use `layerSchemaBinary()` for schema-derived binary transport, and coordinate
+both peers when changing formats. Do not treat a serialization change as a
+transparent migration of persisted data.
 
 ---
 
@@ -666,7 +667,7 @@ const WorkerClientLive = UsersClient.layer.pipe(
 1. **Importing from `@effect/rpc`.** Gone in v4 — everything is `effect/unstable/rpc`. And `import { RpcClientError } from 'effect/unstable/rpc'` gives you a *namespace*; import the class from `effect/unstable/rpc/RpcClientError`.
 2. **Missing `Scope` for `RpcClient.make`.** The constructor is scoped. Build clients inside `Layer.effect(Tag)(RpcClient.make(group))` or under `Effect.scoped` — providing protocol layers alone will not discharge `Scope`.
 3. **Forgetting the client middleware layer.** A group with a `requiredForClient: true` middleware needs `Layer.provide(RpcMiddleware.layerClient(M, ...))` on the client (and in `RpcTest.makeClient`'s context). The compile error points at an unsatisfied `ForClient<M>` requirement — provide the layer, don't cast.
-4. **Wrong codec/transport pairing.** Raw TCP + `layerJson` corrupts framing — use `layerNdjson`/`layerMsgPack`/`layerNdJsonRpc`. Over HTTP, unframed `layerJson` buffers the whole response, so streaming rpcs stall until the request ends — use a framed codec. WebSocket alone is fine with any codec (the transport frames messages).
+4. **Wrong codec/transport pairing.** Raw TCP requires `layerNdjson`, `layerSchemaBinary()`, or `layerNdJsonRpc()`. HTTP with unframed JSON buffers the response; use a framed codec for streaming. WebSocket supplies its own framing.
 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.

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

@@ -18,7 +18,7 @@ Key files:
 - `packages/effect/src/unstable/rpc/RpcServer.ts` — `make`, `layer`, `layerHttp`, every `layerProtocol*` and `toHttpEffect*`
 - `packages/effect/src/unstable/rpc/RpcClient.ts` — `make`, `Protocol`, every `layerProtocol*`, `withHeaders`, `CurrentHeaders`, `ConnectionHooks`
 - `packages/effect/src/unstable/rpc/RpcMiddleware.ts` — `Service` constructor, `layerClient`
-- `packages/effect/src/unstable/rpc/RpcSerialization.ts` — json/ndjson/jsonRpc/ndJsonRpc/msgPack codecs and their layers
+- `packages/effect/src/unstable/rpc/RpcSerialization.ts` — JSON/NDJSON/JSON-RPC/SchemaBinary codecs and layers
 - `packages/effect/src/unstable/rpc/RpcTest.ts` — in-process test client
 - `packages/effect/src/unstable/rpc/RpcWorker.ts` — `InitialMessage` for worker transports
 - `packages/effect/src/unstable/rpc/RpcSchema.ts` — `Stream` schema marker, `ClientAbort` cause annotation
@@ -99,7 +99,7 @@ import { BunClusterHttp, BunClusterSocket } from '@effect/platform-bun';
 ## Architecture at a Glance
 
 ```
-                   wire format (json | ndjson | msgpack | jsonRpc | ndJsonRpc)
+                   wire format (json | ndjson | schema-binary | jsonRpc | ndJsonRpc)
                                           │
        ┌──────────────┐        Protocol   │   Protocol         ┌──────────────┐
        │  RpcClient   │  ───────────────► │ ◄───────────────── │  RpcServer   │
@@ -794,21 +794,24 @@ The choice of serialization is load-bearing because of *framing*. Some transport
 | `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 | 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`.
+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.).
+SchemaBinary is the default cluster network serialization. Select NDJSON explicitly
+for JSON transport. Event-log persistence and remote messages also use SchemaBinary;
+coordinate persisted-data and peer format changes. Cluster message storage uses
+its own JSON codecs: when a reply cannot be stored, waiting callers receive the
+same defect fallback that storage records.
 
 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
+- SchemaBinary against a JSON-only HTTP client → incompatible responses
 - `layerNdjson` against `layerProtocolHttp` → streams incrementally through a bounded response queue (default 16), without RPC acks
 
 ## Testing — `RpcTest.makeClient`
@@ -1232,7 +1235,7 @@ The Node and Bun platform packages ship opinionated all-in-one layers that wire
 import { NodeClusterSocket } from '@effect/platform-node';
 
 const ClusterLayer = NodeClusterSocket.layer({
-	serialization: 'msgpack', // or 'ndjson'; default 'msgpack'
+	serialization: 'binary', // or 'ndjson'; default 'binary'
 	clientOnly: false, // true → don't bind a server port
 	storage: 'sql', // 'sql' | 'memory' | 'byo'; default 'sql'
 	runnerHealth: 'ping', // 'ping' | 'k8s'; default 'ping'
@@ -1361,9 +1364,9 @@ The generated **RPC** payload wraps the original payload as `{ entityId: string,
 
 ### Encrypted Event-Log Compatibility
 
-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.
+`EventLogEncryption.encrypt` returns `{ iv, encryptedEntry }` for every input entry, and `EventLogMessage.WriteEntries.encryptedEntries` carries `{ entryId, iv, encryptedEntry }` values. Each entry uses a fresh AES-GCM IV. Encrypted replication peers must agree on the wire format.
 
-In rc.112, `EventJournal.withRemoteUncommited` (spelling intentional) receives a
+`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.
@@ -1397,7 +1400,7 @@ 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
+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.
@@ -1622,7 +1625,7 @@ const usersByName = Effect.gen(function*() {
 3. **Treating `Rpc.fork` and `Rpc.uninterruptible` like options.** They are wrappers — apply with `.pipe(Rpc.fork)` on the handler's return value.
 4. **Forgetting `primaryKey` on entity rpcs that need dedup.** Without it, retried sends are *not* deduplicated; this is critical for clustered handlers that should be idempotent.
 5. **Using `JSON.parse`/`JSON.stringify` on rpc payloads.** Schemas already round-trip; if you need a JSON string boundary, use `Schema.fromJsonString(...)`.
-6. **Picking `layerJson` for a streaming or socket transport.** No framing → message corruption. Use `layerNdjson` or `layerMsgPack`.
+6. **Picking unframed JSON for raw TCP or incremental HTTP streaming.** Use `layerNdjson` or `layerSchemaBinary()`.
 7. **Forgetting `Layer.provide(AuthClient)` on a `requiredForClient: true` middleware.** Compile error, but a confusing one if you don't know to look.
 8. **Using `WorkflowEngine.layerMemory` in production.** It is testing-only; use `ClusterWorkflowEngine.layer` plus a real cluster bundle.
 9. **Forgetting `ShardingConfig` when using `Entity.makeTestClient`.** `TestRunner.layer` provides one; `makeTestClient` does not.
@@ -1649,5 +1652,5 @@ const usersByName = Effect.gen(function*() {
 - Use `RpcTest.makeClient` for handler tests and `Entity.makeTestClient` for entity tests; reach for `TestRunner.layer` for full-cluster integration tests.
 - 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`.
+- Match serialization to framing: unframed JSON for whole messages; NDJSON or SchemaBinary for byte streams and incremental responses.
 - Pattern-match on `client.GetUser(...).pipe(Effect.catchTag('UserNotFound', ...), Effect.catchFilter(...))` for typed recovery; reserve broad `Effect.catch` for an explicit boundary recovery policy.

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

@@ -17,7 +17,7 @@ Key files:
 - `packages/effect/src/unstable/rpc/RpcGroup.ts` — `toLayer`, `toLayerHandler`, `toHandlers`, `accessHandler`, `of`, handler type derivation
 - `packages/effect/src/unstable/rpc/Rpc.ts` — `ServerClient`, `Handler`, `ToHandlerFn`, `ResultFrom`, `fork`, `uninterruptible`, `ServicesServer`
 - `packages/effect/src/unstable/rpc/RpcMiddleware.ts` — `Service` constructor, server middleware function shape, `layerClient`
-- `packages/effect/src/unstable/rpc/RpcSerialization.ts` — `json`, `ndjson`, `jsonRpc`, `ndJsonRpc`, `msgPack` parsers and their layers
+- `packages/effect/src/unstable/rpc/RpcSerialization.ts` — JSON, NDJSON, JSON-RPC, and SchemaBinary parsers and layers
 - `packages/effect/src/unstable/rpc/RpcMessage.ts` — the wire vocabulary (`Request`, `Ack`, `Interrupt`, `Eof`, `Chunk`, `Exit`, `Defect`, `ClientEnd`)
 - `packages/effect/src/unstable/rpc/RpcWorker.ts` — `InitialMessage` for worker transports
 - `packages/effect/src/unstable/rpc/RpcTest.ts` — in-process test client
@@ -293,7 +293,7 @@ const TcpServer = RpcServer.layer(UserRpcs).pipe(
 	Layer.provide(UsersLive),
 	Layer.provide(RpcServer.layerProtocolSocketServer),
 	Layer.provide(NodeSocketServer.layer({ port: 9000 })),
-	Layer.provide(RpcSerialization.layerMsgPack) // must be a framed format (§4)
+	Layer.provide(RpcSerialization.layerSchemaBinary()) // must be a framed format (§4)
 );
 ```
 
@@ -349,10 +349,9 @@ Provide exactly one `RpcSerialization` layer. The load-bearing property is `incl
 | `RpcSerialization.layerNdjson` | `application/ndjson` | yes | newline-delimited JSON |
 | `RpcSerialization.layerJsonRpc({ contentType? })` | `application/json` | no | JSON-RPC 2.0 interop |
 | `RpcSerialization.layerNdJsonRpc({ contentType? })` | `application/json-rpc` | yes | JSON-RPC 2.0, newline-framed |
-| `RpcSerialization.layerMsgPack` | `application/msgpack` | yes | msgpackr `useRecords: true`; schema payloads still use JSON codecs |
 | `RpcSerialization.layerSchemaBinary(options?)` | `application/vnd.effect.rpc+schema-binary` | yes | schema-derived binary payloads and envelopes |
 
-### Schema-aware serialization (rc.112)
+### Schema-aware serialization
 
 `RpcSerialization.RpcSerialization`, `RpcClient.Protocol`, and
 `RpcServer.Protocol` now require `codecFor: RpcSerialization.CodecFor`:
@@ -364,9 +363,9 @@ type CodecFor = <S extends Schema.Top>(schema: S) =>
 
 Forward the selected serialization's `codecFor` when implementing a protocol.
 This selects codecs for payloads, successes, errors, defects, and stream elements;
-envelope framing remains the serialization's responsibility. Existing JSON,
-NDJSON, JSON-RPC, and MsgPack wire formats keep their JSON-compatible schema
-codecs. Workers supply `Schema.toCodecJson` themselves over structured clone and
+envelope framing remains the serialization's responsibility. JSON,
+NDJSON, and JSON-RPC use JSON-compatible schema codecs.
+Workers supply `Schema.toCodecJson` themselves over structured clone and
 still need no serialization layer. Cluster network traffic follows the protocol
 codec; cluster persistence continues to use JSON.
 
@@ -374,17 +373,16 @@ codec; cluster persistence continues to use JSON.
 both peers. The default maximum frame size is 16 MiB. Envelopes use fingerprints
 and a connection-local string dictionary. Payload fingerprints default to `false`
 to allow compatible schema evolution; enable them for strict layout agreement.
-This is an Effect RPC format, not generic MsgPack or JSON-RPC interoperability.
+This is an Effect RPC format; use JSON-RPC layers for JSON-RPC interoperability.
 See `effect-schema-composition` for binary layout/ownership constraints.
 
 Rules, verified against the protocol implementations and the e2e matrix:
 
-- **Raw TCP sockets need a framed format** (`ndjson`, `ndJsonRpc`, `msgPack`). Plain `json` cannot split the byte stream — decoding breaks as soon as two messages share a chunk.
-- **WebSocket frames messages itself**, so *any* format works there — the e2e suite runs ws with json, ndjson, msgpack, and jsonRpc.
-- **HTTP POST works with both**, with different response behavior: with an **unframed** format the server buffers all responses and returns one JSON array when every request finishes (a streaming rpc arrives as one big batch at the end); with a **framed** format the server returns a chunked streaming response and chunks arrive incrementally. Use `layerNdjson` (or msgpack) over HTTP if you serve streaming rpcs.
+- **Raw TCP sockets need a framed format** (NDJSON, newline JSON-RPC, or SchemaBinary). Plain JSON cannot split the byte stream.
+- **WebSocket frames messages itself**, so it also supports unframed serialization.
+- **HTTP POST works with both**, with different response behavior: an **unframed** format buffers responses until all requests finish; a **framed** format emits chunks incrementally. Use `layerNdjson` or `layerSchemaBinary()` for streaming RPCs.
 - The response `content-type` is the serialization's `contentType`.
 - `RpcSerialization.layerJsonRpc()` / `layerNdJsonRpc()` speak JSON-RPC 2.0: rpc tags map to `method`, batched arrays are preserved, and internal signals travel as `@effect/rpc/Ack`-style methods. Use for interop with non-Effect JSON-RPC clients.
-- `RpcSerialization.makeMsgPack(options)` customizes msgpackr (`useRecords`, `useFloat32`, ...); wrap with `Layer.succeed(RpcSerialization.RpcSerialization)(RpcSerialization.makeMsgPack({ ... }))`.
 
 Client and server must use the **same** serialization.
 
@@ -778,7 +776,7 @@ const ServerLayer = RpcServer.layer(StoreRpcs, { concurrency: 1 }).pipe(
 1. **Importing from `@effect/rpc`.** v3 habit; the package does not exist in v4. Everything is `effect/unstable/rpc` (and platform layers come from `@effect/platform-node` / `-bun` / `-browser`).
 2. **Forgetting `protocol: 'http'` on `layerHttp`.** The default is `'websocket'` — your `POST /rpc` curl returns 404 and only a `GET` upgrade route exists. Also note `layerHttp` takes `{ group, path, ... }` as one options bag, while `layer(group, options)` takes the group positionally.
 3. **Providing handlers/middleware but no `Protocol` or `RpcSerialization`.** `RpcServer.layer` requires all of: handler layer(s), middleware implementation layers, a `layerProtocol*`, and (for non-worker protocols) a `RpcSerialization.layer*`. Missing ones surface as unresolved layer requirements.
-4. **`layerJson` on a raw TCP socket server.** No framing — decode breaks when messages span chunks. Sockets need `layerNdjson`, `layerNdJsonRpc()`, or `layerMsgPack`. (WebSocket is fine with `layerJson` — ws frames messages itself.)
+4. **`layerJson` on a raw TCP socket server.** Sockets need `layerNdjson`, `layerNdJsonRpc()`, or `layerSchemaBinary()` for framing. WebSocket supplies its own framing and supports `layerJson`.
 5. **Streaming rpcs over `layerProtocolHttp` + `layerJson` and wondering why chunks arrive all at once.** Unframed HTTP buffers the whole response until every request in the call finishes. Framed HTTP streams incrementally with a bounded response queue (`streamBufferSize`, default 16). HTTP has no RPC acknowledgment protocol, but the bounded queue still backpressures producers; full-duplex transports additionally support RPC acks.
 6. **Leaving `disableFatalDefects: false` in production.** One handler `die` then nukes every in-flight request on that connection with a connection-level defect. Set `true` to confine defects to the failing request.
 7. **Assuming `concurrency` is per-client.** It is one semaphore per server instance shared by all clients. Use `Rpc.fork` to exempt cheap read handlers instead of raising the global limit.

package/skills/effect-scheduling/SKILL.md

@@ -11,6 +11,13 @@ Verify APIs against `~/.local/share/opencode/repos/github.com/Effect-TS/effect@m
 
 ## Semantics
 
+`Effect.timeoutOrElse` finishes interrupting the source before evaluating the
+fallback. The fallback runs in the caller fiber with its interruptibility and
+supervision. `Effect.repeatOrElse` receives the previous step's `Schedule.Metadata`
+in its fallback. Custom `RateLimiterStore.tokenBucket` implementations return
+`[remaining, elapsedMillis]` atomically; fabricating zero elapsed time produces
+incorrect delay, retryAfter, and resetAfter values.
+
 - `Effect.retry` reruns typed failures. It does not retry defects or interruption.
 - `Effect.repeat` reruns successes. A typed failure stops repetition unless the pass handles it first.
 - The source effect runs once before the schedule is stepped.

package/skills/effect-schema-composition/SKILL.md

@@ -465,7 +465,7 @@ function split(separator: string) {
 
 ## Custom Transformations
 
-### Schema-derived binary boundaries (rc.112)
+### Schema-derived binary boundaries
 
 Use `SchemaBinary.toCodec(schema)` from `effect/unstable/encoding` for a compact
 `Uint8Array` representation. It derives the wire layout from the schema's
@@ -535,9 +535,9 @@ const BooleanFromString = Schema.Literals(['on', 'off']).pipe(
 );
 ```
 
-### SchemaTransformation.transformOrFail — Transformations That Can Fail
+### SchemaTransformation.transformEffect — Transformations That Can Fail
 
-Use `SchemaTransformation.transformOrFail` when transformation might fail:
+Use `SchemaTransformation.transformEffect` when transformation might fail:
 
 ```typescript
 import {
@@ -551,7 +551,7 @@ import {
 
 const NumberFromString = Schema.String.pipe(
 	Schema.decodeTo(Schema.Number, {
-		decode: SchemaGetter.transformOrFail((s) =>
+		decode: SchemaGetter.transformEffect((s) =>
 			Option.match(Number.parse(s), {
 				onNone: () =>
 					Effect.fail(
@@ -633,6 +633,14 @@ export const beGreaterThan =
 
 ### Constructor vs Boundary Decoder
 
+`make`, `makeOption`, and `makeEffect` return an existing class
+instance unchanged. Use `new` when a distinct instance is required. Pass parsing
+options at the adapter call, not in annotations; options apply operation-wide.
+Products support parsing concurrency but union alternatives stay sequential.
+Retain extra object fields with Record/StructWithRest; excess-property modes are
+`ignore` or `error`. See `effect-schema-v4` for inherited-field, template-literal,
+JSON Schema, Getter composition, and optional JIT/AOT contracts.
+
 Keep decoded shapes schema-first with `Schema.Class`. Choose construction and decoding APIs by input trust and failure semantics:
 
 | API | Use Case | Failure |

package/skills/effect-schema-v4/SKILL.md

@@ -20,7 +20,7 @@ Reference this for:
 
 ## 1. Key Renames (find-and-replace safe)
 
-### Current type model (rc.112)
+### Type model
 
 `Schema.Schema<T>` describes only the decoded type. Preserve wire types and
 services with `Schema.Codec<T, E, RD, RE>`: decoded Type, Encoded representation,
@@ -35,13 +35,13 @@ schema helpers so concrete schema operations are retained.
 | `typeSchema(schema)`          | `toType(schema)`                    |                                           |
 | `asSchema(schema)`            | `revealCodec(schema)`               |                                           |
 | `equivalence()`               | `toEquivalence()`                   |                                           |
-| `arbitrary()`                 | `toArbitrary()`                     | Returns a factory that accepts the `fast-check` module |
+| `arbitrary()`                 | `Arbitrary.schema(schema)`          | Native `effect/unstable/arbitrary`; fast-check bridge removed |
 | `pretty()`                    | `toFormatter()`                     |                                           |
-| `parseJson()`                 | `fromJsonString(Schema.Unknown)`    | `UnknownFromJsonString` is internal as of beta.103 |
+| `parseJson()`                 | `fromJsonString(Schema.Unknown)`    | Public unknown-JSON codec |
 | `parseJson(schema)`           | `fromJsonString(schema)`            | With-schema version                       |
-| `TaggedErrorClass`            | `TaggedError`                       | Renamed in beta.104                       |
-| `ErrorClass`                  | `Error`                             | Renamed in beta.104                       |
-| `Error` (instance schema)     | `ErrorInstance`                     | Renamed in beta.104                       |
+| `TaggedErrorClass`            | `TaggedError`                       | Tagged error constructor |
+| `ErrorClass`                  | `Error`                             | Error constructor |
+| `Error` (instance schema)     | `ErrorInstance`                     | Error instance schema |
 | `BigIntFromSelf`              | `BigInt`                            |                                           |
 | `SymbolFromSelf`              | `Symbol`                            |                                           |
 | `URLFromSelf`                 | `URL`                               |                                           |
@@ -66,7 +66,7 @@ schema helpers so concrete schema operations are retained.
 | `standardSchemaV1`            | `toStandardSchemaV1`                |                                           |
 | `nonEmptyString`              | `isNonEmpty()`                      | Now used with `.check()`                  |
 | `disableValidation`           | `disableChecks`                     | In `MakeOptions` for Class constructors   |
-| standalone `SchemaError` module | `Schema.SchemaError`              | The root `SchemaError` namespace export was removed in rc.108; use `Schema.isSchemaError` to narrow |
+| standalone `SchemaError` module | `Schema.SchemaError`              | Use `Schema.isSchemaError` to narrow |
 
 ### Parser/Codec Function Renames
 
@@ -161,7 +161,7 @@ const isNegative = Schema.isLessThan(0);
 const isNonPositive = Schema.isLessThanOrEqualTo(0);
 ```
 
-For the common non-negative safe-integer domain, use the canonical `Schema.Natural` added in beta.102 instead of composing checks manually.
+For the non-negative safe-integer domain, use `Schema.Natural`.
 
 ### Custom Filters
 
@@ -252,7 +252,7 @@ import {
 
 const NumberFromString = Schema.String.pipe(
 	Schema.decodeTo(Schema.Number, {
-		decode: SchemaGetter.transformOrFail((s) =>
+		decode: SchemaGetter.transformEffect((s) =>
 			Option.match(Number.parse(s), {
 				onNone: () =>
 					Effect.fail(
@@ -386,8 +386,8 @@ const fallback = SchemaGetter.withDefault(Effect.succeed('viewer'));
 - `Schema.resolveInto` was renamed to `Schema.resolveAnnotations`.
 - `Schema.resolveAnnotationsKey(schema)` returns key-level annotations.
 - `Schema.annotateEncoded({...})` annotates the encoded side of a transformed schema; use `Schema.annotate({...})` for the decoded Type side.
-- Schemas are directly extendable as classes; `Schema.asClass` was removed in beta.102.
-- `Schema.toArbitrary(schema)` returns a factory that must be called with the `fast-check` module; `Schema.toArbitraryLazy` and arbitrary derivation reports were removed in beta.106.
+- Schemas are directly extendable as classes.
+- Derive native generators with `Arbitrary.schema(schema)` from `effect/unstable/arbitrary`. See `effect-testing` for sampling, bounded generation, shrinking, and replay.
 - New built-in schemas:
     - `Schema.DateFromString`
     - `Schema.BigIntFromString`
@@ -404,7 +404,7 @@ const fallback = SchemaGetter.withDefault(Effect.succeed('viewer'));
 
 ```ts
 import { Effect, Schema } from 'effect';
-import * as FastCheck from 'fast-check';
+import { Arbitrary } from 'effect/unstable/arbitrary';
 
 class UserName extends Schema.NonEmptyString {
 	static readonly decodeUnknownSync = Schema.decodeUnknownSync(this);
@@ -428,8 +428,7 @@ const duration = Schema.DurationFromString;
 
 const parsed = Schema.String.makeEffect('alice');
 
-const makeNameArbitrary = Schema.toArbitrary(Schema.NonEmptyString);
-const nameArbitrary = makeNameArbitrary(FastCheck);
+const nameArbitrary = Arbitrary.schema(Schema.NonEmptyString);
 ```
 
 ### Graph Schemas
@@ -493,12 +492,12 @@ The input is `{ ast, occurrences, identifier }`; return a name to extract that c
 
 The standalone `SchemaError` root module was removed. Parser adapters such as `Schema.decodeUnknownEffect` fail with `Schema.SchemaError`, which contains the structured `issue`; narrow unknown failures with `Schema.isSchemaError`. By contrast, schema/class `makeEffect` and constructor defaults fail directly with `SchemaIssue.Issue`.
 
-In rc.112, `SchemaError` skips stack-frame capture for lower construction cost.
+`SchemaError` skips stack-frame capture for lower construction cost.
 Use its `issue` and formatter/message for validation diagnostics; a captured
 parser-error stack is not a diagnostic contract. Synchronous parser optimizations
 do not change the choice between constructors, sync decoders, and Effect decoders.
 
-### Partial tagged-union matching (rc.112)
+### Partial tagged-union matching
 
 `Schema.TaggedUnion(...)` and `Schema.Union([...]).pipe(Schema.toTaggedUnion(tag))`
 now expose `matchOrElse(value, cases, fallback)` and its curried
@@ -508,7 +507,7 @@ one behavior. The `toTaggedUnion` helper narrows the fallback to omitted variant
 the direct `TaggedUnion` overload types its fallback as the full union.
 Neither matcher decodes unknown input. See `effect-pattern-matching` for a checked example.
 
-### JSON Schema import, conversion, and Standard Schema (rc.112)
+### JSON Schema import, conversion, and Standard Schema
 
 - `SchemaRepresentation.fromJsonSchemaDocument` rejects unsupported references,
   validation keywords, object/array `const` or `enum` values, and intersections
@@ -527,6 +526,50 @@ Neither matcher decodes unknown input. See `effect-pattern-matching` for a check
 - Binary encoding is available from `effect/unstable/encoding` as `SchemaBinary`.
   See `effect-schema-composition` for codecs and `effect-stream` for framing.
 
+## Parsing and compilation contracts
+
+- Pass parse options to decoder, encoder, or constructor adapters. `parseOptions`
+  annotations no longer affect parsing, and operation options apply throughout
+  the complete parse. `propertyOrder` is removed; order presentation explicitly.
+- `onExcessProperty` supports `"ignore"` and `"error"`. Model retained extra fields
+  with `Schema.Record` or `Schema.StructWithRest`, rather than unvalidated preserve.
+- Parsing concurrency applies to product children (arrays, tuples, fields, record
+  entries), defaults to sequential, and applies independently at each nesting.
+  Union candidates remain sequential. Concurrent transformed record-key collisions
+  retain the value that finishes last.
+- Declared fields may be inherited and are copied to own output properties;
+  dynamic record keys remain own-only and `__proto__` remains own-only. Enforce
+  ownership at the boundary when the protocol requires own declared fields.
+- Class `make`, `makeOption`, and `makeEffect` preserve existing instances. Use
+  `new MyClass(fields)` for a distinct instance. Class equivalence now compares
+  declared fields, excluding unrelated runtime properties.
+- `TemplateLiteral` rejects encoded/transformed parts, even in nested templates
+  or unions. Use `TemplateLiteralParser` for transformed tuple parts and provide
+  their decoding/encoding services. Its encoded projection validates the template.
+- JSON Schema generation uses `onExcessProperty`, replacing its former
+  `additionalProperties` option; generated objects are open by default. Schema-valued
+  extra properties belong in Record/StructWithRest. `Enum` rejects non-finite
+  members; `isMultipleOf` rejects zero/non-finite divisors and normalizes negatives.
+- Built-in revivers live in `SchemaRepresentation`; constructors are
+  `makeReviverDeclaration`, `makeReviverFilter`, and `makeReviverFilterGroup`.
+  `toEncoderXml` fails directly with `SchemaIssue.Issue`.
+- For tooling, use `SchemaAST.AST` and named instance interfaces rather than
+  `SchemaAST.Base` or constructor prototype types. Union mode is
+  `ast.options?.mode` (default `anyOf`); migrate persisted representation documents.
+  `SchemaAST.Context.constructorDefault` holds an Effect directly, not a Link.
+- JSON Schema imports support `{ not: {} }` and closed single-pattern records
+  with `patterns: "apply"`. Open patterned objects and references beneath a nested
+  `$id` are rejected; flatten references or explicitly choose to ignore constraints.
+
+Experimental JIT/AOT compilation uses the existing `SchemaParser` APIs. Opt in
+globally with `effect/unstable/schema/SchemaJITCompiler/enable` or selectively with
+`SchemaJITCompiler.enable(ast)`. AOT's `SchemaAOTCompiler/Build` discovers direct
+schema exports from explicit loaders and writes a self-installing module via
+FileSystem/Path. Choose prepared operations explicitly: omitted operations use
+the interpreter, and detailed effectful parsing remains the fallback. Keep the
+interpreter as the default unless measured performance warrants compilation;
+use AOT where dynamic function construction is unavailable.
+
 ## 8. New Modules
 
 ### SchemaTransformation
@@ -563,10 +606,15 @@ const DurationFromString = Schema.String.pipe(
 
 ### SchemaGetter
 
-Single-direction transform primitives. A `Getter<T, E, R>` is `Option<E> → Effect<Option<T>, Issue, R>`. Key exports:
+Single-direction transform primitives. `Getter<T, E, R>` is a tagged
+union of synchronous, optional, and effectful transformations. Interpret one with
+`SchemaGetter.run(getter, option)` to obtain `Effect<Option<T>, Issue, R>`.
+Getter values expose only `pipe`; use standalone dual `map`, `compose`, and `run`.
+Key exports:
 
 - `transform(fn)` — pure map over present values
-- `transformOrFail(fn)` — fallible map returning `Effect`
+- `transformEffect(fn)` — fallible map of a present value returning `Effect`
+- `transformOptionalEffect(fn)` — effectful map that handles missing values too
 - `transformOptional(fn)` — full `Option<E> → Option<T>` control (for optional field transforms)
 - `passthrough()` — identity getter
 - `withDefault(effect)` — provide a default `Effect` for missing values
@@ -574,6 +622,13 @@ Single-direction transform primitives. A `Getter<T, E, R>` is `Option<E> → Eff
 - `checkEffect(fn)` — effectful validation
 - `String()`, `Number()`, `Boolean()`, `BigInt()`, `Date()` — coercion getters
 
+Use `transformOptionalEffect` instead of constructing a Getter directly.
+Use `transformEffect` / `transformOptionalEffect` instead of `onSome` / `onNone`.
+`SchemaGetter.forbiddenEncoding` is the encode getter for a decode-only codec.
+For transformation pairs, use `SchemaTransformation.makeTransformation` and
+the standalone dual `composeTransformation(first, second)`; transformations and
+middleware support `.pipe`.
+
 ```ts
 import { Schema, SchemaGetter } from 'effect';
 
@@ -680,7 +735,7 @@ class Cat extends Schema.TaggedClass<Cat>()('Cat', {
 
 ## 10. TaggedError
 
-`Schema.TaggedErrorClass` was renamed to `Schema.TaggedError` in beta.104. The constructor pattern is unchanged:
+Define yieldable tagged errors with `Schema.TaggedError`:
 
 ```ts
 import { Effect, Schema } from 'effect';