opencode-effect-enforcer 0.2.2 → 0.2.4

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

@@ -22,8 +22,8 @@ Key files:
 - `packages/effect/src/unstable/rpc/RpcWorker.ts` — `InitialMessage` for worker transports
 - `packages/effect/src/unstable/rpc/RpcTest.ts` — in-process test client
 - `packages/effect/src/unstable/rpc/RpcSchema.ts` — `ClientAbort` cause annotation, stream schema markers
-- `packages/platform-node/test/RpcServer.test.ts` + `test/fixtures/rpc-{schemas,e2e}.ts` — the best end-to-end reference for real wiring across http/ws/tcp transports and every serialization
-- `packages/platform-browser/test/fixtures/rpc-worker.ts` — minimal worker-side server entrypoint
+- `packages/platform/node/test/RpcServer.test.ts` + `test/fixtures/rpc-{schemas,e2e}.ts` — the best end-to-end reference for real wiring across http/ws/tcp transports and every serialization
+- `packages/platform/browser/test/fixtures/rpc-worker.ts` — minimal worker-side server entrypoint
 
 ## Core Model
 
@@ -349,7 +349,33 @@ 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 | binary, smallest; msgpackr `useRecords: true` |
+| `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)
+
+`RpcSerialization.RpcSerialization`, `RpcClient.Protocol`, and
+`RpcServer.Protocol` now require `codecFor: RpcSerialization.CodecFor`:
+
+```ts
+type CodecFor = <S extends Schema.Top>(schema: S) =>
+	Schema.Codec<S['Type'], unknown, S['DecodingServices'], S['EncodingServices']>;
+```
+
+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
+still need no serialization layer. Cluster network traffic follows the protocol
+codec; cluster persistence continues to use JSON.
+
+`layerSchemaBinary({ maxFrameSize?, fingerprintPayloads? })` must be selected on
+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.
+See `effect-schema-composition` for binary layout/ownership constraints.
 
 Rules, verified against the protocol implementations and the e2e matrix:
 
@@ -608,7 +634,7 @@ it.effect('GetUser', () =>
 
 ### Transport integration tests
 
-For exercising a real transport in-process, use `NodeHttpServer.layerTest` (provides both `HttpServer` and `HttpClient` on a random port) under your normal server+client layers — `packages/platform-node/test/RpcServer.test.ts` is the template; it runs one shared e2e suite against http/ws/tcp with the serializations each transport supports (plain json only over ws).
+For exercising a real transport in-process, use `NodeHttpServer.layerTest` (provides both `HttpServer` and `HttpClient` on a random port) under your normal server+client layers — `packages/platform/node/test/RpcServer.test.ts` is the template. Framed formats support byte streams; unframed HTTP buffers the response. Verify the selected transport/serialization pair rather than assuming every pairing streams.
 
 ### Unit-testing one handler
 
@@ -628,6 +654,7 @@ const myProtocol = RpcServer.Protocol.make((writeRequest) =>
 		const disconnects = yield* Queue.make<number>();
 		// wire your transport: on inbound data → writeRequest(clientId, message)
 		return {
+			codecFor: Schema.toCodecJson, // or the selected serialization.codecFor
 			disconnects,
 			send: (clientId, response, _transferables) => sendToTransport(clientId, response),
 			end: (clientId) => Effect.void,
@@ -752,7 +779,7 @@ const ServerLayer = RpcServer.layer(StoreRpcs, { concurrency: 1 }).pipe(
 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.)
-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. Use a framed serialization to get a chunked streaming response, and remember HTTP has no acks → no backpressure either way.
+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.
 8. **Treating `Rpc.fork`/`Rpc.uninterruptible` as rpc options.** They wrap the handler's *returned* Effect/Stream: `db.get(id).pipe(Rpc.fork)`. There is no `{ fork: true }` key on `Rpc.make`.

package/skills/effect-scheduling/SKILL.md

@@ -44,7 +44,7 @@ const retryPolicy = Schedule.exponential('100 millis').pipe(
 const result = request.pipe(
 	Effect.retryOrElse(retryPolicy, (error, scheduleOutput) =>
 		Effect.logError('request retries exhausted', error).pipe(
-			Effect.zipRight(fallback(error, scheduleOutput))
+			Effect.andThen(fallback(error, scheduleOutput))
 		)
 	)
 );

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

@@ -24,19 +24,21 @@ Reference this for:
 
 ### The Schema Type
 
-Every schema in Effect has the type signature `Schema<Type, Encoded, Context>` where:
+Use `Schema.Schema<Type>` when only the decoded type matters, or
+`Schema.Codec<Type, Encoded, DecodingServices, EncodingServices>` to retain the
+full codec contract:
 
 - **Type**: The validated, decoded output type (what you get after successful decoding)
 - **Encoded**: The raw input type (what you provide for decoding)
-- **Context**: External dependencies required for encoding/decoding (often `never`)
+- **DecodingServices**: Services needed to decode (default `never`)
+- **EncodingServices**: Services needed to encode (default `never`)
 
 **Example:**
 
 ```typescript
 import { Schema } from 'effect';
 
-// Schema<number, string, never>
-//        ^Type  ^Encoded ^Context
+// Schema.Codec<number, string, never, never>
 const NumberFromString = Schema.NumberFromString;
 ```
 
@@ -123,7 +125,7 @@ const PositiveInt = Schema.Number.check(
 	Schema.isGreaterThan(0)
 );
 
-// Type: Schema<number, number, never>
+// Type: Schema.Codec<number, number, never, never>
 // Both Type and Encoded are `number`
 ```
 
@@ -404,8 +406,8 @@ Schema.String.pipe(
 );
 
 // Pre-built transformation schemas
-Schema.Trimmed; // Schema<string, string> — trimmed string
-Schema.NonEmptyString; // Schema<string, string> — non-empty
+Schema.Trimmed; // checks an already-trimmed string; does not trim input
+Schema.NonEmptyString; // checks a non-empty string
 ```
 
 ### Number Transformations
@@ -453,7 +455,7 @@ function split(separator: string) {
 		Schema.decodeTo(
 			Schema.Array(Schema.String),
 			SchemaTransformation.transform({
-				decode: (s) => s.split(separator) as ReadonlyArray<string>,
+				decode: (s): ReadonlyArray<string> => s.split(separator),
 				encode: (as) => as.join(separator)
 			})
 		)
@@ -463,6 +465,58 @@ function split(separator: string) {
 
 ## Custom Transformations
 
+### Schema-derived binary boundaries (rc.112)
+
+Use `SchemaBinary.toCodec(schema)` from `effect/unstable/encoding` for a compact
+`Uint8Array` representation. It derives the wire layout from the schema's
+**encoded side**, preserving transformations, checks, and decoding/encoding
+services. Use public Schema encode/decode adapters; `toCodecDirect` and the
+module's internal fast-path functions are not application APIs.
+
+<!-- typecheck -->
+```ts
+import { Effect } from 'effect';
+import * as Schema from 'effect/Schema';
+import { SchemaBinary } from 'effect/unstable/encoding';
+
+class Reading extends Schema.Class<Reading>('Reading')({
+	id: Schema.String,
+	value: Schema.NumberFromString
+}) {}
+
+const ReadingBinary = SchemaBinary.toCodec(Reading);
+const roundTrip = Effect.gen(function* () {
+	const bytes = yield* Schema.encodeEffect(ReadingBinary)(
+		new Reading({ id: 'sensor-1', value: 12 })
+	);
+	return yield* Schema.decodeUnknownEffect(ReadingBinary)(bytes);
+});
+```
+
+One codec call handles one complete frame. For arbitrary stream chunks, use
+`SchemaBinary.parser`, `encode` / `decode` Channels, or `duplex` (see
+`effect-stream`). Encoded bytes are arena-backed views; copy with `bytes.slice()`
+when independent ownership is required. Default mode supports compatible schema
+evolution; `{ fingerprint: true }` uses positional layouts and an 8-byte layout
+hash, requiring matching schema definitions. A fingerprint is a compatibility
+check, not authentication or encryption.
+
+The connection-scoped `encoder` / `parser` pair accepts `{ dictionary: true }`
+for repeated strings. Both peers must use the same schema/options and process
+frames in order; dictionary frames do not stand alone. This mode throws during
+construction if the binary layer cannot fully validate that schema itself.
+`parser.feed` lifts the synchronous parser into Effect; it does not make schema
+transformations asynchronous or add their services. Use codec adapters or
+`encode` / `decode` channels for async/service-dependent transformations. A parser
+is spent after failure; call `end` at EOF to detect an incomplete trailing frame.
+Use `maxFrameSize` to bound buffered frames. `SchemaBinary.fieldId` can assign
+stable IDs to fields for compatible evolution; changing established IDs is a
+wire-contract change.
+
+Use JSON codecs for JSON contracts and binary codecs only when the transport
+contract permits them. RPC selects a payload codec through `codecFor`; use
+`RpcSerialization.layerSchemaBinary()` instead of manually wrapping RPC envelopes.
+
 ### SchemaTransformation.transform — Simple Transformations
 
 Use `SchemaTransformation.transform` when the transformation always succeeds:
@@ -542,7 +596,7 @@ const OptionFromNonEmptyString = Schema.optionalKey(Schema.String).pipe(
 import { Effect, Schema } from 'effect';
 
 declare const self: Effect.Effect<unknown, unknown, unknown>;
-declare const schema: Schema.Schema<unknown, unknown, never>;
+declare const schema: Schema.Codec<unknown, unknown>;
 declare const toError: (e: unknown) => unknown;
 
 // Streamlined
@@ -748,9 +802,9 @@ const DogWithBreed3 = Schema.Struct({
 ```typescript
 import { Schema, SchemaTransformation } from 'effect';
 
-const ReadonlySetFromArray = <A, I, R>(
-	itemSchema: Schema.Schema<A, I, R>
-): Schema.Schema<ReadonlySet<A>, ReadonlyArray<I>, R> =>
+const ReadonlySetFromArray = <A, I, RD, RE>(
+	itemSchema: Schema.Codec<A, I, RD, RE>
+): Schema.Codec<ReadonlySet<A>, ReadonlyArray<I>, RD, RE> =>
 	Schema.Array(itemSchema).pipe(
 		Schema.decodeTo(
 			Schema.ReadonlySet(Schema.toType(itemSchema)),
@@ -762,7 +816,7 @@ const ReadonlySetFromArray = <A, I, R>(
 	);
 
 const schema = ReadonlySetFromArray(Schema.String);
-// Schema<ReadonlySet<string>, readonly string[], never>
+// Schema.Codec<ReadonlySet<string>, readonly string[], never, never>
 ```
 
 ### Multi-Stage Transformations
@@ -967,9 +1021,9 @@ When creating schemas, ensure:
 - `SchemaGetter` is imported from `effect/SchemaGetter` or `{ SchemaGetter } from "effect"`
 - `SchemaIssue` is imported from `effect/SchemaIssue` or `{ SchemaIssue } from "effect"`
 - `Struct` is imported from `{ Struct } from "effect"` for `mapFields` operations
-- Schema API signature: `Schema<Type, Encoded, Context>`
+- Type-only schema: `Schema.Schema<Type>`; full codec: `Schema.Codec<Type, Encoded, DecodingServices, EncodingServices>`
 - All schemas return `readonly` types by default
-- Use `Schema.revealCodec(schema)` to view any schema as `Schema<Type, Encoded, Context>`
+- Use `Schema.revealCodec(schema)` to expose its full `Schema.Codec` contract
 - Use `Schema.toType(schema)` to get the type-side schema (replaces v3 `Schema.typeSchema`)
 - Access struct fields with `.fields` property
 - Filters preserve schema type — `.check()` on a `Schema.Struct` returns a `Schema.Struct`

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

@@ -20,6 +20,14 @@ Reference this for:
 
 ## 1. Key Renames (find-and-replace safe)
 
+### Current type model (rc.112)
+
+`Schema.Schema<T>` describes only the decoded type. Preserve wire types and
+services with `Schema.Codec<T, E, RD, RE>`: decoded Type, Encoded representation,
+DecodingServices, and EncodingServices. A three-argument `Schema.Schema<A, I, R>`
+is not a v4 type. Prefer inference or `S extends Schema.Constraint` in generic
+schema helpers so concrete schema operations are retained.
+
 | v3                            | v4                                  | Notes                                     |
 | ----------------------------- | ----------------------------------- | ----------------------------------------- |
 | `annotations(ann)`            | `annotate(ann)`                     |                                           |
@@ -374,7 +382,7 @@ const fallback = SchemaGetter.withDefault(Effect.succeed('viewer'));
 
 ### Later v4 Updates
 
-- `Schema.makeEffect(input, options?)` on schemas and schema-backed classes returns an `Effect` that fails directly with `SchemaIssue.Issue`, not `Schema.SchemaError`.
+- `schema.makeEffect(input, options?)` on schemas and schema-backed classes returns an `Effect` that fails directly with `SchemaIssue.Issue`, not `Schema.SchemaError`.
 - `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.
@@ -485,6 +493,40 @@ 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.
+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)
+
+`Schema.TaggedUnion(...)` and `Schema.Union([...]).pipe(Schema.toTaggedUnion(tag))`
+now expose `matchOrElse(value, cases, fallback)` and its curried
+`matchOrElse(cases, fallback)(value)` form. Use exhaustive `.match` for closed
+business decisions. Use `.matchOrElse` when all remaining cases genuinely share
+one behavior. The `toTaggedUnion` helper narrows the fallback to omitted variants;
+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)
+
+- `SchemaRepresentation.fromJsonSchemaDocument` rejects unsupported references,
+  validation keywords, object/array `const` or `enum` values, and intersections
+  it cannot represent faithfully. Do not discard the failing constraint to make
+  an import succeed.
+- A keyword such as `minLength` does not imply `type: 'string'`. Constraints beside
+  `const`, `enum`, and `$ref` are applied. Imported `oneOf` remains `oneOf` on export,
+  and tuple imports preserve `minItems` even when `prefixItems` alone is insufficient.
+- `JsonSchema` dialect conversion preserves custom keywords and representable
+  conditionals, contains, dependencies, identifiers, and tuples; it relocates
+  local references and throws for unsupported conversions. These synchronous
+  schema-tooling failures need an explicit `Effect.try` boundary when actionable.
+- Import vendored V1 interoperability types from `effect/StandardSchema`, for
+  example `StandardSchemaV1` and `StandardJSONSchemaV1`. Continue to adapt Effect
+  schemas with `Schema.toStandardSchemaV1`; the new module is not a schema builder.
+- Binary encoding is available from `effect/unstable/encoding` as `SchemaBinary`.
+  See `effect-schema-composition` for codecs and `effect-stream` for framing.
+
 ## 8. New Modules
 
 ### SchemaTransformation

package/skills/effect-scope/SKILL.md

@@ -305,6 +305,11 @@ Close semantics (from `internal/effect.ts` `scopeCloseFinalizers`):
 - The scope transitions to `Closed` *before* finalizers run, so finalizers registered from inside finalizers execute immediately.
 - You can inspect `scope.state._tag` (`'Empty' | 'Open' | 'Closed'`) and `scope.strategy` directly.
 
+In rc.112, `Scope.State.Open` stores `finalizerKey` / `finalizer` inline and
+allocates its optional `finalizers` map only for additional entries. Avoid
+constructing or mutating that representation; use `Scope.addFinalizer*` and
+`Scope.close`. LIFO order and failure-preserving cleanup still apply.
+
 Manual scopes are warranted when a resource's lifetime does not align with any effect's lexical extent — for example a connection cached between requests, a resource handed off to another fiber, or interop with non-Effect lifecycle callbacks (`Scope.makeUnsafe` + `Scope.closeUnsafe` from a `dispose()` method).
 
 ---
@@ -494,6 +499,31 @@ Semantics (verified in `ScopedRef.ts` and its tests):
 
 For keyed collections of scoped resources, see `LayerMap` (`ai-docs/src/01_effect/04_resources/30_layer-map.ts`); for capacity-managed pools, see `Pool` (`packages/effect/src/Pool.ts` — `Pool.make` returns a scoped pool whose `Pool.get(pool)` is itself scoped per item). `ScopedCache` is covered by the `effect-cache` skill.
 
+### Callback-scoped pool checkout (rc.112)
+
+Prefer `Pool.use(pool, use)` when one callback owns the entire borrow. It returns
+the item on success, failure, or interruption without adding `Scope` to the
+caller's requirements. Pool construction still needs an owning scope. Use
+`Pool.get` when the caller deliberately owns a longer checkout scope.
+
+<!-- typecheck -->
+```ts
+import { Effect, Pool } from 'effect';
+
+const program = Effect.gen(function* () {
+	const pool = yield* Pool.make({
+		acquire: Effect.succeed('connection'),
+		size: 2
+	});
+	return yield* Pool.use(pool, (connection) => Effect.succeed(connection.length));
+}).pipe(Effect.scoped);
+```
+
+`Effect.scoped(Pool.get(pool))` releases the checkout before the returned item is
+used outside that effect. Put the use inside the scope or use `Pool.use`.
+`Pool.State` / `Pool.PoolItem` changed in rc.112 (incremental usage and intrusive
+FIFO tracking); use the public checkout/invalidation APIs rather than their fields.
+
 ---
 
 ## 9. Scope-Aware Utilities

package/skills/effect-service-implementation/SKILL.md

@@ -344,7 +344,10 @@ This reduces cognitive load in the parent service and makes race-sensitive behav
 
 ## Pattern: No Requirement Leakage
 
-Service methods should **never** have requirements in their return type:
+Capture stable implementation dependencies at construction. Preserve intentional
+call-time requirements such as `Scope`, transactions, request context, and
+schema decoding/encoding services in method return types; capturing those in an
+application-lifetime layer would give them the wrong lifetime or authority.
 
 ```typescript
 // database.ts
@@ -389,7 +392,8 @@ Dependencies are handled by:
 1. **`Layer.effect` closure** — services captured at construction time via `yield*`
 2. **`Layer.provide`** — wires dependency layers into `defaultLayer`
 
-Both keep the method signatures clean (`R = never`).
+Both remove stable infrastructure dependencies from method signatures. `R = never`
+is appropriate only when the operation has no intentional caller-supplied context.
 
 ## Pattern: Whole-Function Transforms
 
@@ -556,7 +560,9 @@ const TestWebhook = Layer.mock(PaymentWebhookGateway.Service)({
 });
 ```
 
-`Layer.mock(Service)({...})` is shorthand for `Layer.succeed(Service, Service.of({...}))` — use whichever reads more clearly in context.
+`Layer.mock(Service)({...})` accepts a partial implementation and supplies defecting
+stubs for unimplemented members. Use a complete `Layer.succeed(Service,
+Service.of({...}))` fake when every method must be implemented at compile time.
 
 For a reusable stateful fake, expose a separate test-control service and provide the same implementation under both tags with `Layer.effectContext`. Production code sees only the production interface; tests can inspect state and trigger transitions deterministically.
 
@@ -643,7 +649,7 @@ Tag identifiers should include the domain name according to project convention:
 - [ ] When using class-style `Context.Service`, the shape is its type parameter and the class body is empty
 - [ ] Service methods use `Effect.fn("Domain.methodName")` with the projected domain prefix
 - [ ] Service represents single capability
-- [ ] All operations have Requirements = never (no R parameter)
+- [ ] Stable dependencies are captured; intentional caller-scoped requirements remain explicit in R
 - [ ] Dependencies captured in `Layer.effect` closure via `yield*`; wired via `Layer.provide` on `defaultLayer`
 - [ ] The project tag's implementation constructor is used; for `Context.Service`, use `Service.of({...})`
 - [ ] Tagged with a descriptive, unique identifier under project convention

package/skills/effect-socket/SKILL.md

@@ -15,11 +15,11 @@ Key files:
 
 - `packages/effect/src/unstable/socket/Socket.ts` — `Socket` interface and service tag, `make`, `CloseEvent`, the `SocketError` taxonomy, channel adapters (`toChannel`, `toChannelString`, `toChannelMap`, `makeChannel`), WebSocket constructors (`makeWebSocket`, `fromWebSocket`, `layerWebSocket`, `WebSocketConstructor`), `fromTransformStream`
 - `packages/effect/src/unstable/socket/SocketServer.ts` — `SocketServer` service contract, `Address` (`TcpAddress` / `UnixAddress`), `SocketServerError`
-- `packages/platform-node-shared/src/NodeSocket.ts` — `makeNet`, `fromDuplex`, `makeNetChannel`, `layerNet`, `NetSocket` service, `NodeWS` (`ws` re-export)
-- `packages/platform-node-shared/src/NodeSocketServer.ts` — TCP/Unix server `make`/`layer`, WebSocket server `makeWebSocket`/`layerWebSocket`, `IncomingMessage` service
-- `packages/platform-node/src/NodeSocket.ts` — re-exports shared module; adds `layerWebSocketConstructor`, `layerWebSocketConstructorWS`, `layerWebSocket`
-- `packages/platform-bun/src/BunSocket.ts` — same shared re-export; Bun-global WebSocket constructor layers
-- `packages/platform-node/test/NodeSocket.test.ts` — loopback echo server, WebSocket client semantics, transform-stream sockets
+- `packages/platform/node-shared/src/NodeSocket.ts` — `makeNet`, `fromDuplex`, `makeNetChannel`, `layerNet`, `NetSocket` service, `NodeWS` (`ws` re-export)
+- `packages/platform/node-shared/src/NodeSocketServer.ts` — TCP/Unix server `make`/`layer`, WebSocket server `makeWebSocket`/`layerWebSocket`, `IncomingMessage` service
+- `packages/platform/node/src/NodeSocket.ts` — re-exports shared module; adds `layerWebSocketConstructor`, `layerWebSocketConstructorWS`, `layerWebSocket`
+- `packages/platform/bun/src/BunSocket.ts` — same shared re-export; Bun-global WebSocket constructor layers
+- `packages/platform/node/test/NodeSocket.test.ts` — loopback echo server, WebSocket client semantics, transform-stream sockets
 - `packages/effect/src/unstable/devtools/DevToolsClient.ts` — production example of NDJSON-framed request/response over a `Socket`
 - `packages/effect/src/unstable/rpc/RpcClient.ts` (`makeProtocolSocket`) — production example of socket reconnect with retry schedules
 

package/skills/effect-sql/SKILL.md

@@ -606,6 +606,28 @@ const main = program.pipe(Effect.provide(DatabaseLayer));
 
 ### PgClient-Specific Features
 
+### Low-level PostgreSQL codecs (rc.112)
+
+`@effect/sql-pg` adds public `PgProtocol`, `PgTypes`, and `PgAuth` modules.
+These are building blocks for protocol adapters; `PgClient` still uses `pg`.
+
+- `PgProtocol`: PostgreSQL 3.0 frontend encoding and incremental backend-frame
+  parsing. Stateful parser failures are terminal and synchronous; lift a parser
+  boundary with `Effect.try` and preserve the protocol error.
+- `PgTypes`: binary scalar and one-dimensional array OID codecs returning typed
+  `Result` failures. Internal field-reader throwing fast paths are not the public
+  application API.
+- `PgAuth`: MD5 and SCRAM-SHA-256 authentication codecs with typed `Result`
+  failures. Treat authentication material as secrets.
+- Encoded frames/decoded byte fields are buffer views. Copy bytes that must
+  outlive the owning message. Read `packages/sql/pg/src/{PgProtocol,PgTypes,PgAuth}.ts`
+  for exact signatures before implementing an adapter.
+
+Driver releases also update production dependencies for D1, mysql2, and PGlite;
+keep the Effect-family package versions aligned when upgrading those adapters.
+
+### PgClient JSON and Notifications
+
 ```ts
 const pg = yield* PgClient;
 

package/skills/effect-stream/SKILL.md

@@ -355,7 +355,7 @@ stream.pipe(
 
 ---
 
-## 4. Encoding & Decoding (NDJSON / Msgpack)
+## 4. Encoding & Decoding (NDJSON / Msgpack / SchemaBinary)
 
 Use `Stream.pipeThroughChannel` with codec channels from `effect/unstable/encoding`.
 
@@ -363,6 +363,37 @@ Use `Stream.pipeThroughChannel` with codec channels from `effect/unstable/encodi
 import { Ndjson, Msgpack } from 'effect/unstable/encoding';
 ```
 
+### Schema-derived binary frames (rc.112)
+
+<!-- typecheck -->
+```ts
+import { Stream } from 'effect';
+import * as Schema from 'effect/Schema';
+import { SchemaBinary } from 'effect/unstable/encoding';
+
+class Reading extends Schema.Class<Reading>('Reading')({
+	id: Schema.String,
+	value: Schema.Number
+}) {}
+
+const roundTrip = Stream.make(new Reading({ id: 'sensor-1', value: 21 })).pipe(
+	Stream.pipeThroughChannel(SchemaBinary.encode(Reading)()),
+	Stream.pipeThroughChannel(SchemaBinary.decode(Reading, { maxFrameSize: 1024 })()),
+	Stream.runCollect
+);
+```
+
+`encode(schema)()` and `decode(schema)()` are channel factories; use them with
+`Stream.pipeThroughChannel`. Input chunks can split or concatenate frames.
+The decoder retains completed values before a later failure and fails with
+`Schema.SchemaError` on an incomplete final frame. Decoding/encoding services
+from schema transformations remain in the channel requirements. `maxFrameSize`
+limits decoding only. Keep paired schemas/options compatible, and copy any
+arena-backed encoded bytes that must survive later writes. For synchronous
+framing/dictionaries use `SchemaBinary.encoder` and `parser`; `duplex` adapts a
+bidirectional channel. See `effect-schema-composition` for codec layout,
+fingerprints, and ownership. Use `RpcSerialization.layerSchemaBinary` for RPC.
+
 ### Text decoding (split multi-byte characters)
 
 To turn a byte stream into text, use `Stream.decodeText` (or `Channel.decodeText`) rather than hand-rolling `new TextDecoder().decode(chunk)` per chunk. These helpers decode with streaming enabled, so multi-byte UTF-8 characters split across `Uint8Array` chunk boundaries are reassembled correctly; per-chunk `TextDecoder` calls would corrupt characters that straddle a boundary.

package/skills/effect-testing/SKILL.md

@@ -14,13 +14,18 @@ Browse and read files there directly to look up APIs, types, and implementations
 
 Reference this for:
 
-- Testing utilities: `packages/effect/src/Testing.ts`
+- Testing utilities: `packages/effect/src/testing/`
 - @effect/vitest source: `packages/vitest/`
 - Migration guide: `MIGRATION.md`
 - Effect source: `packages/effect/src/`
 
 ## Framework Selection
 
+Keep `@effect/vitest` aligned with the Effect release. The rc.112 adapter's
+Vitest peer range is `>=4.1.0 <5.0.0`; do not install it into a Vitest 3 project
+without migrating that project's test framework. Plain compiler/inventory tests
+can keep using their existing Vitest runner without the adapter.
+
 **CRITICAL**: Choose the correct testing framework based on the code being tested.
 
 ### Use @effect/vitest for Effect Code
@@ -168,13 +173,13 @@ import {
 	assertFalse,
 	assertSome, // For Option.Some
 	assertNone, // For Option.None
-	assertSuccess, // For Either.Right / Exit.Success
-	assertFailure // For Either.Left / Exit.Failure
+	assertSuccess, // For Result.Success / Exit.Success
+	assertFailure // For Result.Failure / Exit.Failure
 } from '@effect/vitest/utils';
-import { Effect, Option, Either } from 'effect';
+import { Effect, Option, Result } from 'effect';
 
 declare const someOptionalEffect: Effect.Effect<Option.Option<number>>;
-declare const someEitherEffect: Effect.Effect<Either.Either<number, Error>>;
+declare const someResultEffect: Effect.Effect<Result.Result<number, Error>>;
 declare const expectedValue: number;
 
 it.effect('with effect assertions', () =>
@@ -182,8 +187,8 @@ it.effect('with effect assertions', () =>
 		const option = yield* someOptionalEffect;
 		assertSome(option, expectedValue);
 
-		const either = yield* someEitherEffect;
-		assertSuccess(either, expectedValue);
+		const result = yield* someResultEffect;
+		assertSuccess(result, expectedValue);
 	})
 );
 ```
@@ -223,7 +228,10 @@ const TestUserService = Layer.mock(UserService)({
 });
 ```
 
-`Layer.mock(Service)({...})` is shorthand for `Layer.succeed(Service, Service.of({...}))` — use whichever reads more clearly in context.
+`Layer.mock` accepts a partial implementation and supplies defecting stubs for
+omitted methods. It is not equivalent to a complete, compiler-checked
+`Layer.succeed(Service, Service.of({...}))`. Prefer complete fakes for reusable
+test services; use partial mocks only when omitted operations should defect.
 
 ### First-Class Controllable Test Services
 
@@ -809,7 +817,7 @@ import { Effect, Logger } from 'effect';
 it.effect('logs visible', () =>
 	Effect.gen(function* () {
 		yield* Effect.log('This will appear');
-	}).pipe(Effect.provide(Logger.pretty))
+	}).pipe(Effect.provide(Logger.layer([Logger.consolePretty()])))
 );
 
 // Use it.live only when the live console itself is under test.
@@ -857,23 +865,23 @@ describe('UserService', () => {
 });
 ```
 
-### Testing STM Operations
+### Testing Transactions
+
+In v4, transactional collections use `TxRef` and `Effect.tx`; there is no
+separate `STM` effect type or `STM.commit`. Test rollback as well as success:
 
 ```typescript
 import { it, expect } from '@effect/vitest';
-import { Effect, STM, TRef } from 'effect';
+import { Effect, TxRef } from 'effect';
 
-it.effect('should handle concurrent updates', () =>
+it.effect('rolls back a failed transaction', () =>
 	Effect.gen(function* () {
-		const counter = yield* TRef.make(0);
-
-		const increment = STM.updateAndGet(counter, (n) => n + 1);
-
-		yield* STM.commit(increment);
-		yield* STM.commit(increment);
-
-		const final = yield* STM.commit(TRef.get(counter));
-		expect(final).toBe(2);
+		const counter = yield* TxRef.make(0);
+		yield* Effect.gen(function* () {
+			yield* TxRef.set(counter, 1);
+			return yield* Effect.fail('cancel');
+		}).pipe(Effect.tx, Effect.flip);
+		expect(yield* TxRef.get(counter)).toBe(0);
 	})
 );
 ```
@@ -882,14 +890,14 @@ it.effect('should handle concurrent updates', () =>
 
 ```typescript
 import { it, expect } from '@effect/vitest';
-import { Effect, STM } from 'effect';
+import { Effect } from 'effect';
 
 declare const GCounter: {
 	make: (id: string) => Effect.Effect<unknown>;
-	increment: (counter: unknown, value: number) => STM.STM<void>;
-	query: (counter: unknown) => STM.STM<unknown>;
-	merge: (counter: unknown, state: unknown) => STM.STM<void>;
-	value: (counter: unknown) => STM.STM<number>;
+	increment: (counter: unknown, value: number) => Effect.Effect<void>;
+	query: (counter: unknown) => Effect.Effect<unknown>;
+	merge: (counter: unknown, state: unknown) => Effect.Effect<void>;
+	value: (counter: unknown) => Effect.Effect<number>;
 };
 
 declare const ReplicaId: (id: string) => string;
@@ -899,13 +907,13 @@ it.effect('should merge states correctly', () =>
 		const counter1 = yield* GCounter.make(ReplicaId('replica-1'));
 		const counter2 = yield* GCounter.make(ReplicaId('replica-2'));
 
-		yield* STM.commit(GCounter.increment(counter1, 10));
-		yield* STM.commit(GCounter.increment(counter2, 20));
+		yield* Effect.tx(GCounter.increment(counter1, 10));
+		yield* Effect.tx(GCounter.increment(counter2, 20));
 
-		const state2 = yield* STM.commit(GCounter.query(counter2));
-		yield* STM.commit(GCounter.merge(counter1, state2));
+		const state2 = yield* Effect.tx(GCounter.query(counter2));
+		yield* Effect.tx(GCounter.merge(counter1, state2));
 
-		const result = yield* STM.commit(GCounter.value(counter1));
+		const result = yield* Effect.tx(GCounter.value(counter1));
 		expect(result).toBe(30);
 	})
 );

package/skills/effect-workflow/SKILL.md

@@ -125,6 +125,12 @@ yield* SendEmail.resume(executionId);
 
 ### Deterministic Execution ID
 
+As of rc.112, generated `WorkflowProxy.toRpcGroup` `<Name>Discard` RPCs and
+`WorkflowProxy.toHttpApiGroup` discard HTTP endpoints also return the execution
+ID (`Schema.String`). Consumers can persist that ID to poll/resume the workflow.
+Update generated client response types and tests that expected `void`; ordinary
+RPC `discard: true` call options still discard the response and cannot return it.
+
 The execution ID is computed as a hash of `"${name}-${idempotencyKey(payload)}"`. This means executing the same workflow with the same payload is idempotent — it returns the existing execution rather than starting a new one.
 
 ```ts