opencode-effect-enforcer 0.2.5 → 0.2.8

package/skills/effect-config/SKILL.md

@@ -37,20 +37,20 @@ Never read `process.env` directly in Effect code. `Config` provides:
 Each constructor reads a single value and decodes it. The optional `name` parameter sets the root path segment for lookup. Omit it when the config is part of a larger `Config.schema`.
 
 ```ts
-Config.string('HOST'); // string
-Config.nonEmptyString('HOST'); // string (rejects "")
-Config.number('RATE'); // number (includes NaN, Infinity)
-Config.finite('RATE'); // number (rejects NaN, Infinity)
-Config.int('PORT'); // number (integers only)
-Config.boolean('DEBUG'); // boolean (accepts true/false, yes/no, on/off, 1/0, y/n)
-Config.port('PORT'); // number (integer in 1–65535)
-Config.url('CALLBACK_URL'); // URL
-Config.date('EXPIRES_AT'); // Date (rejects invalid dates)
-Config.duration('TIMEOUT'); // Duration (parses "10 seconds", "500 millis", "Infinity", "-Infinity")
-Config.logLevel('LOG_LEVEL'); // string (All|Fatal|Error|Warn|Info|Debug|Trace|None)
-Config.redacted('API_KEY'); // Redacted<string> (hidden from logs and toString)
-Config.literal('production', 'ENV'); // literal type (accepts only the given literal)
-Config.literals(['development', 'production'], 'ENV'); // accepts one of several literals
+Config.String('HOST'); // string
+Config.NonEmptyString('HOST'); // string (rejects "")
+Config.Number('RATE'); // number (includes NaN, Infinity)
+Config.Finite('RATE'); // number (rejects NaN, Infinity)
+Config.Int('PORT'); // number (integers only)
+Config.Boolean('DEBUG'); // boolean (accepts true/false, yes/no, on/off, 1/0, y/n)
+Config.Port('PORT'); // number (integer in 1–65535)
+Config.URL('CALLBACK_URL'); // URL
+Config.Date('EXPIRES_AT'); // Date (rejects invalid dates)
+Config.Duration('TIMEOUT'); // Duration (parses "10 seconds", "500 millis", "Infinity", "-Infinity")
+Config.LogLevel('LOG_LEVEL'); // string (All|Fatal|Error|Warn|Info|Debug|Trace|None)
+Config.Redacted('API_KEY'); // Redacted<string> (hidden from logs and toString)
+Config.Literal('production', 'ENV'); // literal type (accepts only the given literal)
+Config.Literals(['development', 'production'], 'ENV'); // accepts one of several literals
 ```
 
 ## Config Combinators
@@ -60,7 +60,7 @@ Config.literals(['development', 'production'], 'ENV'); // accepts one of several
 Only triggers when data is **missing**. Validation errors (wrong type, out of range) still propagate.
 
 ```ts
-const port = Config.int('PORT').pipe(Config.withDefault(3000));
+const port = Config.Int('PORT').pipe(Config.withDefault(3000));
 ```
 
 ### `Config.option` — Optional Values
@@ -68,13 +68,13 @@ const port = Config.int('PORT').pipe(Config.withDefault(3000));
 Returns `Option.some(value)` on success, `Option.none()` when data is missing.
 
 ```ts
-const maybePort = Config.option(Config.int('PORT'));
+const maybePort = Config.option(Config.Int('PORT'));
 ```
 
 ### `Config.map` — Transform a Value
 
 ```ts
-const upperHost = Config.string('HOST').pipe(
+const upperHost = Config.String('HOST').pipe(
 	Config.map((s) => s.toUpperCase())
 );
 ```
@@ -84,7 +84,7 @@ const upperHost = Config.string('HOST').pipe(
 Unlike `withDefault`, this catches **all** `ConfigError`s:
 
 ```ts
-const host = Config.string('HOST').pipe(
+const host = Config.String('HOST').pipe(
 	Config.orElse(() => Config.succeed('localhost'))
 );
 ```
@@ -96,13 +96,13 @@ Accepts a record or a tuple:
 ```ts
 // As a record
 const appConfig = Config.all({
-	host: Config.string('host'),
-	port: Config.int('port'),
-	debug: Config.boolean('debug')
+	host: Config.String('host'),
+	port: Config.Int('port'),
+	debug: Config.Boolean('debug')
 });
 
 // As a tuple
-const pair = Config.all([Config.string('a'), Config.int('b')]);
+const pair = Config.all([Config.String('a'), Config.Int('b')]);
 ```
 
 ### `Config.nested` — Scope Under a Prefix
@@ -111,8 +111,8 @@ Prepends a path segment to every key the inner config reads. With environment va
 
 ```ts
 const dbConfig = Config.all({
-	host: Config.string('host'),
-	port: Config.int('port')
+	host: Config.String('host'),
+	port: Config.Int('port')
 }).pipe(Config.nested('database'));
 
 // Reads from env: database_host, database_port
@@ -146,17 +146,40 @@ const ServerConfig = Config.schema(
 );
 ```
 
-### Config Schemas for Use with `Config.schema`
+### Config constructors versus schemas
 
-| Schema                      | Type           | Notes                                      |
-| --------------------------- | -------------- | ------------------------------------------ |
-| `Config.Boolean`            | `boolean`      | Decodes `true/false/yes/no/on/off/1/0/y/n` |
-| `Schema.DurationFromString` | `Duration`     | Decodes duration strings; accepts `"Infinity"` / `"-Infinity"` |
-| `Config.Port`               | `number`       | Integer in 1–65535                         |
-| `Config.LogLevel`           | `string`       | One of the standard log level literals     |
-| `Config.Record(key, value)` | `Record<K, V>` | Also parses flat `"k1=v1,k2=v2"` strings   |
+PascalCase names on `Config` construct configs, not schemas. Combine
+`Config.Boolean`, `Config.Port`, and `Config.LogLevel` with `Config.all`; use
+Schema values inside `Config.schema`. The specialized implementation schemas
+are internal. `Config.mapEffect` is the effectful mapping combinator.
 
-Plain `Schema.Array` and `Schema.Record` load structural provider children. Use `Config.Array` and `Config.Record` when a flat separated scalar should also be accepted. Opaque encodings such as `Schema.Any`, `Schema.Unknown`, and `Schema.Json` are rejected when `Config.schema` is constructed; use a concrete shape or `Schema.fromJsonString(Schema.Json)` to read scalar JSON.
+<!-- typecheck -->
+```ts
+import { Config, ConfigProvider, Schema } from 'effect';
+
+const settings = Config.all({
+	port: Config.Port('PORT'),
+	debug: Config.Boolean('DEBUG'),
+	exporters: Config.Array(Schema.String, 'EXPORTERS'),
+	labels: Config.Record(Schema.String, Schema.String, 'LABELS'),
+	limit: Config.ByteSize('LIMIT')
+});
+const parsed = settings.parse(ConfigProvider.fromUnknown({
+	PORT: '8080', DEBUG: 'yes', EXPORTERS: 'otlp,console',
+	LABELS: 'service.name=api', LIMIT: '64 KiB'
+}));
+```
+
+`Config.Array(value, path?, options?)` and `Config.Record(key, value, path?, options?)`
+also accept an options object without a path. They read structural values or
+separated strings. Plain `Schema.Array` / `Schema.Record` in `Config.schema` load
+structural children. Opaque encodings such as `Schema.Any`, `Schema.Unknown`, and
+`Schema.Json` are rejected; use a concrete shape or
+`Schema.fromJsonString(Schema.Json)` for scalar JSON.
+
+Environment/bracket array indices must be unpadded decimal integers from 0 through
+4294967294. Numeric-looking keys such as `01` remain object keys; use `[1]` for
+array paths.
 
 Missing or unavailable representations are decoded as `undefined` before `Config.withDefault` and `Config.option` decide semantic absence. A successful decoded `undefined` or an explicitly present empty structure remains a real value and is not replaced by a default.
 
@@ -166,8 +189,8 @@ Missing or unavailable representations are decoded as `undefined` before `Config
 
 ```ts
 const program = Effect.gen(function* () {
-	const host = yield* Config.string('HOST');
-	const port = yield* Config.int('PORT');
+	const host = yield* Config.String('HOST');
+	const port = yield* Config.Int('PORT');
 	console.log(`${host}:${port}`);
 });
 ```
@@ -175,7 +198,7 @@ const program = Effect.gen(function* () {
 ### 2. Call `.parse(provider)` directly — useful for testing
 
 ```ts
-const host = Config.string('HOST');
+const host = Config.String('HOST');
 const provider = ConfigProvider.fromUnknown({ HOST: 'localhost' });
 const result = Effect.runSync(host.parse(provider));
 // "localhost"
@@ -368,7 +391,7 @@ const TestLayer = ConfigProvider.layer(
 );
 
 const program = Effect.gen(function* () {
-	const port = yield* Config.int('port');
+	const port = yield* Config.Int('port');
 	return port;
 });
 
@@ -416,7 +439,7 @@ const DefaultsLayer = ConfigProvider.layerAdd(
 const provider = ConfigProvider.fromUnknown({ HOST: 'localhost' });
 
 const program = Effect.gen(function* () {
-	const host = yield* Config.string('HOST');
+	const host = yield* Config.String('HOST');
 	return host;
 }).pipe(Effect.provideService(ConfigProvider.ConfigProvider, provider));
 ```
@@ -430,8 +453,8 @@ import { Config, ConfigProvider, Effect } from 'effect';
 
 // Pattern 1: .parse(provider) for direct testing
 const config = Config.all({
-	host: Config.string('host'),
-	port: Config.int('port')
+	host: Config.String('host'),
+	port: Config.Int('port')
 });
 
 const testProvider = ConfigProvider.fromUnknown({
@@ -451,7 +474,7 @@ const TestConfigLayer = ConfigProvider.layer(
 );
 
 const program = Effect.gen(function* () {
-	const host = yield* Config.string('host').pipe(Config.nested('server'));
+	const host = yield* Config.String('host').pipe(Config.nested('server'));
 	return host;
 });
 
@@ -466,7 +489,7 @@ Config operations fail with `ConfigError`, which wraps either:
 - **`SchemaError`** — data was found but didn't match the schema (wrong type, out of range, missing key)
 
 ```ts
-const program = Config.int('PORT')
+const program = Config.Int('PORT')
 	.parse(ConfigProvider.fromUnknown({ PORT: 'not-a-number' }))
 	.pipe(
 		Effect.tapError((error) =>
@@ -510,7 +533,7 @@ const DbConfig = Config.schema(
 const AppConfig = Config.all({
 	server: ServerConfig,
 	db: DbConfig,
-	debug: Config.boolean('debug').pipe(Config.withDefault(false))
+	debug: Config.Boolean('debug').pipe(Config.withDefault(false))
 });
 
 // In production — just yield it, reads from process.env
@@ -551,7 +574,7 @@ debug=true
 const port = parseInt(process.env.PORT ?? '3000');
 
 // GOOD
-const port = Config.int('PORT').pipe(Config.withDefault(3000));
+const port = Config.Int('PORT').pipe(Config.withDefault(3000));
 ```
 
 ### NEVER validate config manually

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

@@ -13,7 +13,7 @@ and `effect-typeclass-design` for reusable predicate/order APIs.
 
 ## Source Reference
 
-Baseline: **Effect 4.0.0-rc.112**. In the Effect source reference, consult
+Baseline: **Effect 4.0.0-rc.116**. In the Effect source reference, consult
 `packages/effect/SCHEMA.md` and `packages/effect/src/{Schema,Match,DateTime,Order}.ts`.
 Verify the installed version and source tag before applying newer APIs.
 
@@ -159,7 +159,7 @@ message. Never claim the invariant is enforced solely because fields use
   `matchOrElse`. Use it when plain internal object variants are intentional.
 - `Data.TaggedEnum` is useful for trusted, non-schema types. It does not decode
   unknown input; do not duplicate a schema model with a parallel Data union.
-- Use `.match` for exhaustiveness. Use rc.112 `.matchOrElse(cases, fallback)` or
+- Use `.match` for exhaustiveness. Use `.matchOrElse(cases, fallback)` or
   `.matchOrElse(value, cases, fallback)` when one fallback truthfully handles all
   other cases. The fallback from `toTaggedUnion` is narrowed to unmatched
   variants; direct `Schema.TaggedUnion.matchOrElse` types it as the full union.
@@ -228,7 +228,7 @@ see `effect-schema-composition` for transformation and recursion details.
 - Use `Schema.toEquivalence` for model comparisons. `Eq.equals` provides general
   structural equality in v4, but schema equivalence expresses model intent.
 - Compose `Order.mapInput` / `Order.combine` and sort with `Arr.sort`. Finite
-  `Arr.groupBy` / `Iterable.groupBy` keys remain finite in rc.112, with optional
+  `Arr.groupBy` / `Iterable.groupBy` preserve finite keys, with optional
   properties: a particular group may not exist. Handle that absence explicitly.
 - Use `DateTime` for instants, `Duration` for intervals, and `DateTime.now` for
   effectful current time. Deterministic fixtures may use `DateTime.makeUnsafe`

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

@@ -84,7 +84,7 @@ Reference this for:
 | `Schema.TaggedErrorClass`         | `Schema.TaggedError`           |
 | `Schema.ErrorClass`               | `Schema.Error`                 |
 | `Schema.Error` (instance schema)  | `Schema.ErrorInstance`         |
-| `Schema.ErrorReviver`             | `Schema.ErrorInstanceReviver`  |
+| `Schema.ErrorReviver`             | `SchemaRepresentation.ErrorInstanceReviver`  |
 | `ParseError`                      | `Schema.SchemaError`           |
 
 ## Core Error Handling Philosophy
@@ -592,7 +592,7 @@ const program2 = riskyOp().pipe(
 );
 ```
 
-> **Type preservation (beta.71):** When you omit `orElse`, the tags you do not handle stay in the error channel — `catchTag(['NotFound'], ...)` on `Effect<string, NotFound | Forbidden | ServerError>` yields `Effect<string, Forbidden | ServerError>`. Supplying `orElse` handles those remaining variants, so the resulting error channel reflects only what the fallback produces. A beta.71 fix ensures `catchTag` / `catchTags` / `catchIf` no longer silently drop the unhandled error types from the inferred type.
+> **Type preservation:** When you omit `orElse`, unhandled tags stay in the error channel — `catchTag(['NotFound'], ...)` on `Effect<string, NotFound | Forbidden | ServerError>` yields `Effect<string, Forbidden | ServerError>`. Supplying `orElse` handles the remaining variants, so the resulting error channel reflects what the fallback produces.
 
 ### catchTags - Multiple Error Types
 

package/skills/effect-fiber/SKILL.md

@@ -555,7 +555,7 @@ This is exactly what the FiberHandle/Map/Set runtime helpers wrap for you — pr
 
 ### Keep-alive and runMain
 
-In the current v4 runtime there is **no per-fiber keep-alive in the core runtime** (it existed earlier in v4 but was removed in beta.80; the `migration/fiber-keep-alive.md` doc predates the removal). A bare `Effect.runFork`/`Effect.runPromise` whose fiber is suspended on a pure Effect primitive (e.g. `Deferred.await`, `Effect.never`) does not by itself hold the Node.js process open.
+There is **no per-fiber keep-alive in the core runtime**. A bare `Effect.runFork`/`Effect.runPromise` whose fiber is suspended on a pure Effect primitive (e.g. `Deferred.await`, `Effect.never`) does not by itself hold the Node.js process open.
 
 `Runtime.makeRunMain`-based runners — `NodeRuntime.runMain` from `@effect/platform-node`, `BunRuntime.runMain`, etc. — install a long-interval timer that keeps the process alive until the main fiber completes, and additionally provide SIGINT/SIGTERM handling (interrupting the root fiber gracefully), exit-code mapping (interruption-only causes → 130), and error reporting. Always use `runMain` for long-lived program entry points:
 
@@ -724,7 +724,7 @@ const handoff = Effect.gen(function* () {
 10. **Expecting `onlyIfMissing: true` to error when occupied** — it succeeds, returning a shared already-interrupted fiber while keeping the existing one. Check `Exit.hasInterrupts(yield* Fiber.await(fiber))` to detect the rejected start.
 11. **Calling `run` on a closed collection** — `FiberHandle.run`/`FiberMap.run` interrupt the *calling* fiber; `FiberSet.run` and all `runtime()` runners return a pre-interrupted fiber instead. Neither throws.
 12. **Assuming collection fibers are children of the caller** — they are root fibers created via `Effect.runForkWith` with the caller's context: they start immediately and survive the calling fiber; only the collection (scope close, replacement, remove/clear) interrupts them.
-13. **Relying on `Effect.runFork`/`runPromise` to keep Node alive** — beta.80 removed the core fiber keep-alive; a fiber suspended on `Deferred.await`/`Effect.never` won't hold the process open. Use `NodeRuntime.runMain` (built on `Runtime.makeRunMain`).
+13. **Relying on `Effect.runFork`/`runPromise` to keep Node alive** — a fiber suspended on `Deferred.await`/`Effect.never` won't hold the process open. Use `NodeRuntime.runMain` (built on `Runtime.makeRunMain`).
 14. **Letting interruption leak through acquire/release** — wrap the whole sequence in `Effect.uninterruptibleMask` and `restore` only the use phase; pending interruption is delivered as soon as the region ends, so cleanup still runs exactly once.
 15. **Leaving collection type parameters off** — `FiberHandle.make()` defaults to `<unknown, unknown>`, making `join` surface `unknown` errors. Always pass them: `FiberHandle.make<A, E>()`, `FiberMap.make<K, A, E>()`, `FiberSet.make<A, E>()`.
 16. **Using v3 `FiberId` types** — v4 fiber ids are plain `number`s; `Cause.interruptors(cause)` and `Effect.onInterrupt` finalizers give you `ReadonlySet<number>`.

package/skills/effect-filesystem/SKILL.md

@@ -207,16 +207,46 @@ const useFileHandle = Effect.gen(function* () {
 		Effect.gen(function* () {
 			const file = yield* fs.open('data.txt', { flag: 'r' });
 
-			// File methods return branded Size values for byte counts and offsets.
+			// Byte counts use ByteSize; seek positions are signed bigint inputs.
 			const buffer = new Uint8Array(1024);
 			const bytesRead = yield* file.read(buffer);
-			const offset = yield* file.seek(FileSystem.Size(0), 'start');
+			const offset = yield* file.seek(0n, 'start');
 		})
 	);
 });
 ```
 
-`file.seek(offset, from)` accepts a `SizeInput`, supports `from: 'start' | 'current'`, and returns the new offset as `FileSystem.Size` (not `void` or a plain number). Open `File` handles no longer expose a `descriptor` property or `File.Descriptor` type as of beta.103; use the scoped handle operations (`read`, `readAlloc`, `write`, `writeAll`, `seek`, `stat`, `sync`, and `truncate`) instead.
+`file.seek(offset, from)` accepts `bigint`, supports `from: 'start' | 'current'`,
+and returns `Effect<bigint, PlatformError>`. A negative resulting position fails
+without changing the cursor. Byte counts and `File.Info.size` use
+`ByteSize.ByteSize`; size inputs use `ByteSize.Input`. Keep large offsets/counts
+exact, and handle `Option.none()` for optional stat metadata outside the safe
+integer range. Use scoped handle operations (`read`, `readAlloc`, `write`,
+`writeAll`, `seek`, `stat`, `sync`, `truncate`) rather than raw descriptors.
+
+### Byte sizes and exact offsets
+
+<!-- typecheck -->
+```ts
+import { ByteSize, Effect, FileSystem } from 'effect';
+
+const inspect = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const file = yield* fs.open('data.bin');
+	const position = yield* file.seek(0n, 'start');
+	const chunk = yield* file.readAlloc(64 * 1024);
+	return { position, chunk };
+}).pipe(Effect.scoped);
+const bodyLimit = ByteSize.mebibytes(1);
+const parsedLimit = ByteSize.fromString('1.5 MiB');
+```
+
+`ByteSize.Input` string literals are canonical non-negative integers with recognized
+units. Parse external strings or fractional quantities with `ByteSize.fromString`
+(or the explicitly throwing `fromStringUnsafe` at a controlled boundary).
+Do not convert large sizes/offsets to number and silently lose precision.
+Buffer allocation lengths (`readAlloc`) and per-buffer read/write counts are
+numbers. File stat sizes and streaming byte limits use ByteSize; seek uses bigint.
 
 ## Directory Operations
 
@@ -284,7 +314,7 @@ const getFileInfo = Effect.gen(function* () {
 
 	yield* Console.log(`Type: ${info.type}`);
 	// "File" | "Directory" | "SymbolicLink" | "BlockDevice" | "CharacterDevice" | "FIFO" | "Socket" | "Unknown"
-	yield* Console.log(`Size: ${info.size}`); // FileSystem.Size (branded bigint)
+	yield* Console.log(`Size: ${info.size}`); // ByteSize.ByteSize
 	yield* Console.log(`Modified: ${info.mtime}`); // Option<Date>
 	yield* Console.log(`Accessed: ${info.atime}`); // Option<Date>
 	yield* Console.log(`Created: ${info.birthtime}`); // Option<Date>

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

@@ -7,6 +7,21 @@ You are an Effect TypeScript expert specializing in the HttpApi module for build
 
 ## Effect Source Reference
 
+Use `HttpApi.ParseOptions` annotations at API, group, or endpoint scope to
+configure client and server codecs. `HttpApiBuilder.handler` defines a reusable
+endpoint callback with inferred request, success, error, and service types.
+Generated clients and AtomHttpApi calls accept per-call `sseOptions`.
+SSE IDs may be absent: model them with `Schema.optional(Schema.String)`.
+With excess-property errors, include the `event` field (default `message`) and
+any `id`, including inherited IDs. `Sse.decodeSchema` / `ChannelSchema.decode`
+accept parse options directly.
+
+HTTP `QUERY` endpoints are supported. OpenAPI 3.1 represents them through
+`x-oai-additionalOperations`, requiring consumer support for that extension;
+the generator also accepts OpenAPI 3.2's native `query` operation.
+Generated multipart binary fields use `File | Blob` and dedicated `*Multipart`
+component exports. Keep generated imports aligned with the chosen transport.
+
 The Effect v4 source is available at `~/.local/share/opencode/repos/github.com/Effect-TS/effect@main/`. Browse and read files there directly to look up APIs, types, and implementations.
 
 Key reference files:
@@ -1128,7 +1143,7 @@ The `layerClient` second argument can also be an `Effect` returning the middlewa
 const AuthorizationClient = HttpApiMiddleware.layerClient(
 	Authorization,
 	Effect.gen(function* () {
-		const token = yield* Config.redacted('API_TOKEN');
+		const token = yield* Config.Redacted('API_TOKEN');
 		return ({ next, request }) =>
 			next(
 				HttpClientRequest.bearerToken(request, Redacted.value(token))
@@ -1170,7 +1185,7 @@ 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
+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;

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

@@ -9,6 +9,15 @@ In v4 there is no `@effect/platform` package — the HTTP client lives in the `e
 
 ## Effect Source Reference
 
+Client recovery through `HttpClient.catch` must return an `HttpClientResponse`.
+For a different success type, recover on the Effect returned by `execute`.
+`response.url` includes query parameters, excludes the hash, and reflects the
+final URL after redirects. Response schema decoders honor supplied parse options.
+Use `Schema.Cookie`, `Schema.Cookies`, `Schema.Headers`, and `Schema.UrlParams`
+for HTTP value schemas. Import Undici-specific APIs from
+`@effect/platform-node/Undici`; the transport layer owns their initialization.
+HTTP `QUERY` is supported; configure CORS `allowedMethods` explicitly if needed.
+
 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 `unstable` and change between betas.
 
 Key files:
@@ -42,7 +51,7 @@ An `HttpClient.With<E, R>` is a pair of functions — `preprocess` (request →
 - Runtime application and provider integrations use `HttpClient`; do not call raw `fetch` from business or provider code.
 - A raw `fetch` call is permitted only in an explicitly named low-level platform adapter that owns transport interop and documents why an Effect transport cannot be used. Lift it with `Effect.tryPromise`, pass the supplied `AbortSignal` to fetch, and do not let `Request`, `Response`, rejected promises, or untyped payloads escape that adapter.
 - Give each upstream adapter a named service and named effects that own request construction, authentication, execution, status classification, schema decoding, and error mapping.
-- Read credentials with `Config.redacted` and attach them in a configured client transform; never pass raw secret strings through business workflows.
+- Read credentials with `Config.Redacted` and attach them in a configured client transform; never pass raw secret strings through business workflows.
 - Classify status before decoding a success schema. Non-2xx error bodies often have a different shape and must not be decoded as successful payloads.
 - Decode external response data with `HttpClientResponse.schemaBodyJson`, `schemaJson`, or another `Schema` decoder. A successful JSON parse is not validation.
 - Preserve bounded diagnostic evidence such as provider request IDs, status, error codes, and retry metadata. Redact credentials, authorization headers, query secrets, private payload fields, and full bodies before logging or storing evidence.
@@ -233,7 +242,7 @@ request.pipe(
 
 `UrlParams.Input` accepts records, iterables of `[key, value]` tuples, or `URLSearchParams`. Values may be `string | number | bigint | boolean | null | undefined`; `undefined` entries are **skipped** (great for optional params), arrays produce repeated keys, and nested records render with bracket notation (`filter[name]=x`).
 
-For standalone `UrlParams` values (e.g. `response.urlParamsBody`) the module mirrors these combinators: `UrlParams.getFirst`/`getAll`, `set`/`append`/`setAll`/`appendAll`, `toRecord`. In schema pipelines, `UrlParams.schemaRecord` decodes params into a record (`schemaBodyUrlParams` wraps it) and `UrlParams.schemaJsonField(name, { reviver })` parses one field's value as JSON with an optional `JSON.parse` reviver.
+For standalone `UrlParams` values (e.g. `response.urlParamsBody`) the module mirrors these combinators: `UrlParams.getFirst`/`getAll`, `set`/`append`/`setAll`/`appendAll`, `toRecord`. Schema values and record/JSON-field codecs live in `effect/Schema`; use `Schema.RecordFromUrlParams` and `Schema.JsonFromUrlParamsField(name, options?)`.
 
 ### Headers and auth
 

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

@@ -197,14 +197,14 @@ 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
+On Node, `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';
 
-someEffect.pipe(Effect.provideService(HttpServerRequest.MaxBodySize, FileSystem.Size(1024 * 1024)));
+someEffect.pipe(Effect.provideService(HttpServerRequest.MaxBodySize, ByteSize.mebibytes(1)));
 ```
 
 ### Schema-validated decoding
@@ -624,7 +624,7 @@ Layer.launch(Main).pipe(BunRuntime.runMain);
 
 ```ts
 const server = yield* HttpServer.HttpServer;
-server.address; // { _tag: 'TcpAddress', hostname, port } | { _tag: 'UnixAddress', path }
+server.address; // NetAddress.SocketAddress; narrow to InetAddress before reading port
 HttpServer.formatAddress(server.address); // 'http://0.0.0.0:3000'
 yield* HttpServer.logAddress; // log it
 someServerLayer.pipe(HttpServer.withLogAddress); // log on startup
@@ -654,7 +654,7 @@ yield* HttpServer.serveEffect(httpEffect);
 
 ## 8. WebSocket Upgrades
 
-In `@effect/platform-bun` rc.112, outgoing WebSocket messages are compressed when
+In `@effect/platform-bun`, 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
@@ -667,16 +667,18 @@ application payloads. See `packages/platform/bun/src/BunHttpServer.ts`.
 const WsRoute = HttpRouter.add('GET', '/ws', Effect.gen(function* () {
 	const request = yield* HttpServerRequest.HttpServerRequest;
 	const socket = yield* request.upgrade; // Effect<Socket.Socket, HttpServerError>
-	const write = yield* socket.writer; // scoped — the request Scope keeps it alive
-
-	// runs until the client disconnects; the handler receives each message
-	yield* socket.runString((message) => write(`echo: ${message}`));
-
-	return HttpServerResponse.empty(); // sent when the socket session ends
+	const writer = yield* socket.writer;
+	const pull = yield* Socket.readerString(socket);
+	yield* pull.pipe(
+		Effect.flatMap((batch) => Effect.forEach(batch, (message) => writer.write(`echo: ${message}`))),
+		Effect.forever,
+		Effect.catchReason('SocketError', 'SocketCloseError', () => Effect.void)
+	);
+	return HttpServerResponse.empty(); // the adapter does not write HTTP bytes after upgrade
 }));
 ```
 
-- `socket.run(handler)` for binary (`Uint8Array`) messages, `runString` for text, `runRaw` for both.
+- Acquire `socket.reader` for raw batches or `Socket.readerBytes` / `readerString` for converted pulls. Every close is a typed failure; handle closure at the protocol boundary.
 - `HttpServerRequest.upgradeChannel()` exposes the socket as a `Channel` for pipeline-style use.
 - `request.upgrade` fails with `HttpServerError` (`RequestParseError` reason) when the request is not upgradeable — e.g. in plain web-handler adapters that lack upgrade support.
 - For socket combinators, close events, and client sockets see the `effect-socket` skill.
@@ -685,6 +687,21 @@ const WsRoute = HttpRouter.add('GET', '/ws', Effect.gen(function* () {
 
 ## 9. Static Files (`HttpStaticServer`)
 
+`HttpServerResponse.file` calculates length from the file and requested range;
+it has no `contentLength` override. Explicit content types/headers take priority;
+web files then use nonempty `File.type`, then extension inference. Ranges clamp
+to EOF and retain exact bigint offsets. HEAD and statuses 204/205/304 omit the
+body and finalize request resources without starting omitted Effect streams.
+
+`HttpRouter.toWebHandler` and the layer-based `HttpEffect` web handlers start
+building their layers when created. Construction failures reject requests with
+the build error. Own and dispose that handler lifetime explicitly.
+
+Bound server addresses use `NetAddress.SocketAddress`. Use `NetAddress.formatIp`
+for numeric IP display, `formatHost` for host/port socket APIs, and the server URL
+helpers for IPv6-safe URLs. Bun/Deno listener layers can fail with `ServeError`
+when address conversion fails.
+
 ```ts
 const StaticFiles = HttpStaticServer.layer({
 	root: './public',

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

@@ -424,7 +424,7 @@ export const DatabaseTest = Layer.succeed(
 
 // Use in application
 const program = Effect.gen(function* () {
-	const nodeEnv = yield* Config.string('NODE_ENV').pipe(
+	const nodeEnv = yield* Config.String('NODE_ENV').pipe(
 		Config.withDefault('production')
 	);
 	yield* myProgram.pipe(
@@ -463,6 +463,10 @@ const program = Effect.all([
 
 ## Error Handling in Layers
 
+`Layer.tapError` and `Layer.tapCause` observers must accept the complete source
+error type. Preloading a LayerMap does not make future resource acquisition
+infallible; its accessors retain the resource error channel.
+
 Handle construction errors:
 
 ```typescript
@@ -577,7 +581,7 @@ const layer = Layer.effect(Settings, Effect.gen(function* () {
 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
+`effect-cache`). `LayerMap.contextEffectOption` atomically retains an
 already-cached layer context without allocating a missing key.
 
 When the requirement is a restartable worker, latest-wins scheduling, or queued

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

@@ -53,14 +53,15 @@ Layer.mergeAll(
 )
 ```
 
-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.
+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. `initialize` negotiates from its body even when the client sends an unsupported default protocol header. Subsequent requests validate `MCP-Protocol-Version`; unsupported explicit versions return `400`. Let initialization reach body negotiation.
 
 ## Protocol Revisions
 
-Effect ships four dated adapters:
+Declare the protocol adapters the server supports:
 
 ```typescript
 const protocols = [
+	McpProtocol.v2026_07_28,
 	McpProtocol.v2025_11_25,
 	McpProtocol.v2025_06_18,
 	McpProtocol.v2025_03_26,
@@ -71,6 +72,7 @@ const protocols = [
 - `2024-11-05` and `2025-03-26` are compatibility revisions.
 - `2025-06-18` supports form elicitation.
 - `2025-11-25` adds sampling with tools, independently advertised form/URL elicitation modes, descriptor icons, and elicitation-complete notifications.
+- `2026-07-28` is available as `McpProtocol.v2026_07_28`.
 - Duplicate versions or an empty protocol declaration fail layer construction with `Cause.IllegalArgumentError`.
 - `v2024_11_05` over `layerHttp` uses Effect's single-endpoint Streamable HTTP compatibility transport. It does not recreate the historical two-endpoint HTTP+SSE transport, GET SSE, event resumption, session expiry, or client session termination.
 
@@ -78,6 +80,18 @@ Each part layer has type `Layer.Layer<never, never, ...>` — they register them
 
 ## Tools and Toolkit
 
+Server options accept `instructions` for initialization/discovery. Prompt
+registration accepts `title`; callbacks receive decoded prompt parameters.
+
+`Tool.Strict` controls MCP input schema generation and argument validation.
+Strict dynamic tools require Effect schemas; raw JSON Schema is rejected at
+registration. Non-strict tools may use identified input schemas. Invalid arguments
+produce `InvalidParams` before protocol 2025-11-25 and `isError: true` on newer
+protocols. Declared handler failures return `isError: true` without
+`structuredContent`; only JSON objects are valid structured content.
+Declared failures are distinct from internal diagnostics. Defects and encoding
+failures are logged/reported while client-facing messages stay generic.
+
 ### Defining Tools
 
 Tools are defined with `Tool.make` specifying a name, description, parameter schemas, and success schema:
@@ -362,7 +376,9 @@ Layer.mergeAll(/* parts */).pipe(
 );
 ```
 
-**Critical**: When using stdio transport, logs MUST go to stderr. Any stdout output interferes with protocol communication. Use `Logger.consolePretty({ stderr: true })` or `Logger.LogToStderr`.
+For stdio transport, route logs to stderr with `Logger.LogToStderr`. Stdout is
+reserved for protocol messages. `Logger.consolePretty` controls formatting;
+the context reference controls its destination.
 
 ### HTTP Transport
 
@@ -525,7 +541,8 @@ const ServerLayer = Layer.mergeAll(
 		})
 	),
 	Layer.provide(NodeStdio.layer),
-	Layer.provide(Logger.layer([Logger.consolePretty({ stderr: true })]))
+	Layer.provide(Logger.layer([Logger.consolePretty()])),
+	Layer.provide(Layer.succeed(Logger.LogToStderr)(true))
 );
 
 Layer.launch(ServerLayer).pipe(NodeRuntime.runMain);

package/skills/effect-observability/SKILL.md

@@ -207,7 +207,7 @@ import { Config, Effect, Layer, Logger } from 'effect';
 
 const LoggerLayer = Layer.unwrap(
 	Effect.gen(function* () {
-		const env = yield* Config.string('NODE_ENV').pipe(
+		const env = yield* Config.String('NODE_ENV').pipe(
 			Config.withDefault('development')
 		);
 		if (env === 'production') {
@@ -652,7 +652,7 @@ const ProdObservability = Layer.mergeAll(
 
 const ObservabilityLayer = Layer.unwrap(
 	Effect.gen(function* () {
-		const env = yield* Config.string('NODE_ENV').pipe(
+		const env = yield* Config.String('NODE_ENV').pipe(
 			Config.withDefault('development')
 		);
 		return env === 'production' ? ProdObservability : DevObservability;

package/skills/effect-optics/SKILL.md

@@ -328,7 +328,7 @@ const atKey = (key: string) =>
 	);
 ```
 
-Since beta.105, all fallible optic operations use `SchemaIssue.Issue`, not `string`. Custom `makePrism` and `makeOptional` implementations must return structured issues. Issues do not format themselves through `toString`; use `SchemaIssue.makeFormatterDefault()` when a human-readable message is needed:
+Fallible optic operations use `SchemaIssue.Issue`. Custom `makePrism` and `makeOptional` implementations return structured issues. Use `SchemaIssue.makeFormatterDefault()` for human-readable messages:
 
 ```ts
 const formatIssue = SchemaIssue.makeFormatterDefault();