opencode-effect-enforcer 0.2.6 → 0.3.0

package/skills/effect-socket/SKILL.md

@@ -7,10 +7,12 @@ description: Build pull-based TCP, Unix, TLS, and WebSocket transports with Effe
 
 ## Source reference
 
-Read `packages/effect/src/unstable/socket/{Socket,SocketServer}.ts` at
-`effect@4.0.0-rc.116` in the Effect reference. Platform adapters live in
+Read `packages/effect/src/socket/{Socket,SocketServer}.ts` at
+`effect@4.0.0` in the Effect reference. Platform adapters live in
 `packages/platform/node-shared/src/{NodeSocket,NodeSocketServer}.ts`; Node and
 Bun expose these as `NodeSocket` / `BunSocket` and their server counterparts.
+These APIs remain `@stability unstable` and may break in minor releases despite
+the stable package version. Keep Effect-family packages on the same release.
 Load `effect-scope` and `effect-fiber` for lifecycle ownership,
 `effect-stream` for framing, and `effect-scheduling` for reconnect policy.
 
@@ -38,7 +40,7 @@ There are no callback-driven `run`, `runString`, or `runRaw` methods on a socket
 <!-- typecheck -->
 ```ts
 import { Effect } from 'effect';
-import { Socket } from 'effect/unstable/socket';
+import { Socket } from 'effect/socket';
 
 const echo = Effect.fn('Socket.echo')(function* (socket: Socket.Socket) {
 	const { pull } = yield* socket.reader;
@@ -57,7 +59,7 @@ and streaming `Stream.decodeText` to preserve split UTF-8 characters.
 <!-- typecheck -->
 ```ts
 import { Duration, Effect } from 'effect';
-import { Socket } from 'effect/unstable/socket';
+import { Socket } from 'effect/socket';
 
 const receive = Effect.gen(function* () {
 	const socket = yield* Socket.makeWebSocket('wss://example.com/feed', {
@@ -84,8 +86,9 @@ casts; opening-handshake headers are available where the platform supports them.
 
 An effectful URL is reevaluated on each connection. `fromWebSocket(acquire, options)`
 wraps a scoped transport acquisition. Pausable transports pause at `highWaterMark`
-(default 64 KiB) and resume when drained. Browser WebSockets cannot pause and
-fail with `SocketReadError` when the configured bound is exceeded. Text-frame
+(default 64 KiB) and resume when drained. Browser WebSockets cannot pause; their
+default buffer is unbounded. Set `highWaterMark` explicitly to fail with
+`SocketReadError` when that byte bound is exceeded. Text-frame
 buffering counts UTF-8 bytes, not string length.
 
 ## TCP, Unix, and TLS
@@ -127,7 +130,7 @@ reconnect. Use a new socket value for an independent concurrent client connectio
 <!-- typecheck -->
 ```ts
 import { Duration, Effect, Schedule } from 'effect';
-import { Socket } from 'effect/unstable/socket';
+import { Socket } from 'effect/socket';
 
 const consume = Effect.fn('Socket.consume')(function* (socket: Socket.Socket) {
 	const pull = yield* Socket.readerString(socket);
@@ -151,6 +154,12 @@ const reconnect = (socket: Socket.Socket) => consume(socket).pipe(
 WebSocket close codes are protocol data; TCP does not transmit them. Prefer
 writer-scope release for a graceful TCP half-close rather than a close event.
 
+Node/Bun HTTP upgrade adapters choose server close codes from the owning scope
+exit: `1000` for success, `1001` for interruption-only exits, and `1011` for other
+failures. An explicit code already sent is preserved. HTTP response conversion
+and observation middleware retain the handler failure for request cleanup. This
+is server-upgrade behavior, not a configurable clean-close predicate on sockets.
+
 ## Streams, channels, and framing
 
 `Socket.toStream(socket)` provides read-only byte consumption.
@@ -183,7 +192,7 @@ rather than becoming accept-loop failures; add application-level supervision
 where they must stop the service. HTTP upgrades yield the same Socket interface;
 see `effect-http-server`.
 
-Server addresses are `NetAddress.SocketAddress` from `effect/unstable/net`.
+Server addresses are `NetAddress.SocketAddress` from `effect/net`.
 Narrow to `InetAddress` before reading `port`; format its IP with `formatIp`,
 or use `formatHost` when passing a host and port separately (preserves IPv6 scopes).
 Unix path addresses expose `path`. Use `inetAddressFromHostString` to parse numeric
@@ -191,10 +200,45 @@ hosts and `scopeIdsFromInterfaces` with supplied interface data for named zones.
 URL helpers bracket IPv6 and reject scoped IPv6; do not assemble URLs by casting
 an address to the removed `TcpAddress` type.
 
+Treat IP values as opaque: IPv4 now stores one unsigned 32-bit number and IPv6
+four words internally, not public `.bytes`. Use `ipv4ToOctets`, `ipv6ToOctets`,
+`ipv6ToSegments`, and formatting/construction helpers. Do not persist internal
+fields or hash values as a wire representation.
+
+`NetAddress.Family<A>` selects the IPv4/IPv6 address family, `Inet<A>` the matching
+port-carrying address, and `MulticastInterface<A>` an IPv4 interface address or
+IPv6 numeric interface index (`ipv4Unspecified`/`0` choose the OS default).
+Classification predicates such as `isMulticast`, `isUnicast`, `isLoopback`, and
+`isLinkLocal` preserve the input family while refining it to the corresponding
+branded type. Use the named schemas in `effect/Schema` for boundary validation
+rather than asserting these refinements.
+
+<!-- typecheck -->
+```ts
+import { Effect } from 'effect';
+import * as Schema from 'effect/Schema';
+import { NetAddress } from 'effect/net';
+
+const parseMulticast = Schema.decodeUnknownEffect(Schema.IpMulticastAddressFromString);
+const displayMulticast = Effect.fn('Socket.displayMulticast')(function* (input: unknown) {
+	const address = yield* parseMulticast(input);
+	return NetAddress.formatIp(address);
+});
+```
+
+For native adapters, `formatNativeHost(address, scopeIds, platform?)` and
+`formatMulticastInterface(selector, scopeIds, platform?)` use an explicitly
+supplied interface-name-to-index map. Non-Windows output prefers a matching
+interface name; Windows uses numeric zones. `toCanonical` accepts both IP and
+internet addresses: mapped IPv6 becomes IPv4 while retaining its port; other
+values retain identity and IPv6 scope metadata.
+
 ## Higher-level transports and tests
 
 - RPC: `RpcClient.layerProtocolSocket` and `RpcServer.layerProtocolSocketServer`;
   provide matching `RpcSerialization` layers and the socket/server layer.
+  Missed pongs are read failures that fail in-flight calls even with transient
+  open-error retries enabled; reconnect does not replay those calls.
 - Cluster: `NodeClusterSocket` / `BunClusterSocket`; SchemaBinary is the default,
   NDJSON is explicitly selectable.
 - In-memory tests: `Socket.fromTransformStream` wraps a readable/writable pair;

package/skills/effect-sql/SKILL.md

@@ -8,37 +8,39 @@ You are an Effect TypeScript expert specializing in type-safe SQL database acces
 ## Effect Source Reference
 
 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.
+Inspect the `effect@4.0.0` tag for this skill; main may be newer. SQL APIs remain
+`@stability unstable` and may break in minor releases. Keep `effect` and all
+`@effect/sql-*` and platform dependencies on the same release.
 
 Reference this for:
 
-- `packages/effect/src/unstable/sql/` — Core SQL modules (SqlClient, SqlSchema, SqlModel, SqlResolver, Migrator, Statement)
-- `packages/effect/src/unstable/schema/Model.ts` — Model class with variant schemas
+- `packages/effect/src/sql/` — Core SQL modules (SqlClient, SqlSchema, SqlModel, SqlResolver, Migrator, Statement)
+- `packages/effect/src/schema/Model.ts` — Model class with variant schemas
 - `packages/sql/pg/src/PgClient.ts` — PostgreSQL driver example
 
 ## Core Imports
 
-All SQL modules live under the `effect/unstable/sql` path:
+All SQL modules live under the `effect/sql` path:
 
 ```ts
-import { SqlClient } from 'effect/unstable/sql/SqlClient';
-import * as SqlSchema from 'effect/unstable/sql/SqlSchema';
-import * as SqlModel from 'effect/unstable/sql/SqlModel';
-import * as SqlResolver from 'effect/unstable/sql/SqlResolver';
-import * as Migrator from 'effect/unstable/sql/Migrator';
+import { SqlClient } from 'effect/sql/SqlClient';
+import * as SqlSchema from 'effect/sql/SqlSchema';
+import * as SqlModel from 'effect/sql/SqlModel';
+import * as SqlResolver from 'effect/sql/SqlResolver';
+import * as Migrator from 'effect/sql/Migrator';
 ```
 
 Alternatively, the barrel exports namespace modules:
 
 ```ts
-import { SqlClient, SqlSchema, SqlModel, SqlResolver, Migrator } from 'effect/unstable/sql';
+import { SqlClient, SqlSchema, SqlModel, SqlResolver, Migrator } from 'effect/sql';
 // With the barrel, the service is SqlClient.SqlClient.
 ```
 
 For Model schemas (used with SqlModel):
 
 ```ts
-import { Model } from 'effect/unstable/schema';
+import { Model } from 'effect/schema';
 ```
 
 ## SqlClient — Tagged Template Queries
@@ -49,7 +51,7 @@ import { Model } from 'effect/unstable/schema';
 
 ```ts
 import { Effect } from 'effect';
-import { SqlClient } from 'effect/unstable/sql/SqlClient';
+import { SqlClient } from 'effect/sql/SqlClient';
 
 const program = Effect.gen(function* () {
 	const sql = yield* SqlClient;
@@ -157,7 +159,28 @@ yield*
 
 Transaction context is attached to the active `SqlClient` service instance. Queries join a transaction only when they run with that same client; avoid mixing clients or manually reserved connections for one atomic unit of work.
 
-A failed top-level `BEGIN` or nested `SAVEPOINT` is propagated as a typed `SqlError`; the wrapped effect does not run, and no rollback is attempted for the transaction or savepoint that never started. If a nested `SAVEPOINT` failure escapes the outer transaction body, the already-started outer transaction rolls back. Because the failure is typed, outer code may catch it and continue the transaction instead. Commit and rollback command failures are treated as defects.
+A failed top-level `BEGIN` or nested `SAVEPOINT` is propagated as a typed `SqlError`; the wrapped effect does not run, and no rollback is attempted for the transaction or savepoint that never started. If a nested `SAVEPOINT` failure escapes the outer transaction body, the already-started outer transaction rolls back. Catching this typed failure does not repair the database transaction state: continue only if the driver/database still permits it. Commit and rollback command failures are treated as defects.
+
+Nested savepoints are released after success or successful rollback by PostgreSQL,
+PGlite, MySQL, libSQL, and Node/Bun/React Native/WASM SQLite drivers. A release
+failure is also a defect. Custom clients opt in with
+`SqlClient.make({ releaseSavepoint: (name) => ... })`; omitting it leaves the
+previous behavior, suitable for dialects such as MSSQL without release support.
+
+`commit` accepts either SQL text or `(connection) => Effect<void, SqlError>` so
+drivers can inspect completion, while `onCommitFailure` performs cleanup on the
+same connection before release. Failed commit/cleanup still surface as defects,
+not a successful transaction result. SQLite drivers roll back transactions left
+open by failed COMMIT (for example deferred foreign-key violations). A failed
+cleanup prevents reuse until a subsequent acquisition successfully retries that
+rollback; the database is not silently reopened.
+
+PostgreSQL can return a `ROLLBACK` command result for `COMMIT` after a caught
+statement error aborted the transaction. `PgClient` detects this and fails the
+transaction with a `SqlError` defect (`UnknownError`, operation `commit`). Catching
+a statement failure in application code does not restore PostgreSQL transaction
+state. Use a nested transaction/savepoint around a recoverable operation when the
+outer transaction must continue.
 
 ### Dialect Branching
 
@@ -188,8 +211,8 @@ sql.onDialect({
 
 ```ts
 import { Schema } from 'effect';
-import { SqlClient } from 'effect/unstable/sql/SqlClient';
-import * as SqlSchema from 'effect/unstable/sql/SqlSchema';
+import { SqlClient } from 'effect/sql/SqlClient';
+import * as SqlSchema from 'effect/sql/SqlSchema';
 
 const sql = yield* SqlClient;
 
@@ -238,7 +261,7 @@ The `Model` module provides a schema class system with built-in variants for dat
 
 ```ts
 import { Schema } from 'effect';
-import { Model } from 'effect/unstable/schema';
+import { Model } from 'effect/schema';
 
 const UserId = Schema.Number.pipe(Schema.brand('UserId'));
 
@@ -294,7 +317,7 @@ Use `GeneratedByDb` only for fields that are truly read-only after selection, su
 `SqlModel.makeRepository` generates a complete CRUD interface from a Model class.
 
 ```ts
-import * as SqlModel from 'effect/unstable/sql/SqlModel';
+import * as SqlModel from 'effect/sql/SqlModel';
 
 const UserRepo =
 	yield*
@@ -330,8 +353,8 @@ yield* UserRepo.delete(userId);
 
 ```ts
 import { RequestResolver } from 'effect';
-import * as SqlModel from 'effect/unstable/sql/SqlModel';
-import * as SqlResolver from 'effect/unstable/sql/SqlResolver';
+import * as SqlModel from 'effect/sql/SqlModel';
+import * as SqlResolver from 'effect/sql/SqlResolver';
 
 const UserResolvers =
 	yield*
@@ -393,7 +416,7 @@ Resolver versions created by `SqlModel.makeResolvers` honor the same soft-delete
 Results map 1:1 to requests by position. Result count must match request count.
 
 ```ts
-import * as SqlResolver from 'effect/unstable/sql/SqlResolver';
+import * as SqlResolver from 'effect/sql/SqlResolver';
 
 const insertResolver = SqlResolver.ordered({
 	Request: User.insert,
@@ -476,7 +499,7 @@ Each migration file exports a default Effect:
 ```ts
 // migrations/0001_create_users.ts
 import { Effect } from 'effect';
-import { SqlClient } from 'effect/unstable/sql/SqlClient';
+import { SqlClient } from 'effect/sql/SqlClient';
 
 export default Effect.gen(function* () {
 	const sql = yield* SqlClient;
@@ -494,7 +517,7 @@ export default Effect.gen(function* () {
 ### Running Migrations
 
 ```ts
-import * as Migrator from 'effect/unstable/sql/Migrator';
+import * as Migrator from 'effect/sql/Migrator';
 
 // Create a migrator (optionally with schema dump support)
 const migrate = Migrator.make({
@@ -542,7 +565,7 @@ Migrator.fromBabelGlob(migrations);
 ### Migration Errors
 
 ```ts
-import * as Migrator from 'effect/unstable/sql/Migrator';
+import * as Migrator from 'effect/sql/Migrator';
 
 // MigrationError has a `kind` discriminator:
 // - "BadState"    — migrations table in unexpected state
@@ -563,7 +586,7 @@ Effect SQL uses driver-specific packages that provide `SqlClient` layers.
 | `@effect/sql-pg`          | PostgreSQL (native Effect protocol client) |
 | `@effect/sql-pglite`      | Embedded PostgreSQL/PGlite           |
 | `@effect/sql-mysql2`      | MySQL (via `mysql2`)                 |
-| `@effect/sql-sqlite-node` | SQLite (via `better-sqlite3`)        |
+| `@effect/sql-sqlite-node` | SQLite (`node:sqlite`; Node 22.16+)  |
 | `@effect/sql-libsql`      | libSQL / Turso                       |
 | `@effect/sql-mssql`       | Microsoft SQL Server                 |
 | `@effect/sql-clickhouse`  | ClickHouse                           |
@@ -573,7 +596,7 @@ Effect SQL uses driver-specific packages that provide `SqlClient` layers.
 ```ts
 import { Effect, Layer } from 'effect';
 import { PgClient } from '@effect/sql-pg';
-import { SqlClient } from 'effect/unstable/sql/SqlClient';
+import { SqlClient } from 'effect/sql/SqlClient';
 
 // Static config
 const DatabaseLayer = PgClient.layer({
@@ -615,13 +638,24 @@ Bind JSON explicitly with `sql.json`, and send one statement per query string.
 Named preparation is enabled by default; set `prepare: false` for incompatible
 poolers, or use statement-level `unprepared` / `valuesUnprepared`.
 
+Prepared names are namespaced per physical connection to avoid collisions when
+backend sessions are shared. This does not replace checking your pooler's support
+for named prepared statements. Pools retire fatal sessions before the next borrow
+and retire sessions with an unconfirmed `CancelRequest`, including cancellation
+while idle, so a delayed cancel cannot hit a later checkout. The current checkout
+and unpooled sessions can still encounter their own late cancellation. Failed
+background pool acquisitions are retried on borrow; callers already waiting on
+their own failed acquisition receive that failure.
+
 Decode rows according to the actual driver boundary: `int8` is `bigint`, `date`
 is a string, timestamps are `Date` (millisecond precision), and `bytea` is
 `Uint8Array`. Infinite/out-of-range timestamps decode to invalid Dates; validate
 before constructing domain instants. Timestamp encoders accept Date or epoch
 milliseconds; invalid Date encoding fails. A Date binds as `timestamptz`, so use
 UTC session time or `PgTypes.timestamp(value)` for UTC fields in a timestamp column.
-`executeRaw` returns `PgConnection.Result`.
+`executeRaw` returns `PgConnection.Result`. Binary `regclass` and `regclass[]`
+decode as unsigned numeric OIDs; cast to `text` in SQL when relation names are
+required.
 
 Unregistered OIDs decode as UTF-8 text, suitable for scalar enum labels but not
 arbitrary binary types. Register custom scalar/array codecs through
@@ -684,8 +718,8 @@ Use `@effect/sql-pglite` for embedded PostgreSQL-compatible databases backed by
 ```ts
 import { Config, Effect } from 'effect';
 import { PgliteClient, PgliteMigrator } from '@effect/sql-pglite';
-import * as Migrator from 'effect/unstable/sql/Migrator';
-import { SqlClient } from 'effect/unstable/sql/SqlClient';
+import * as Migrator from 'effect/sql/Migrator';
+import { SqlClient } from 'effect/sql/SqlClient';
 
 const PgliteLayer = PgliteClient.layer({
 	dataDir: 'idb://myapp'
@@ -750,7 +784,7 @@ yield*
 All SQL operations can fail with `SqlError`:
 
 ```ts
-import { SqlError } from 'effect/unstable/sql/SqlError';
+import { SqlError } from 'effect/sql/SqlError';
 
 yield*
 	sql`SELECT * FROM users`.pipe(
@@ -779,10 +813,10 @@ Keep non-unique integrity failures on their own paths; they remain `ConstraintEr
 
 ```ts
 import { Effect, Layer, Schema } from 'effect';
-import { Model } from 'effect/unstable/schema';
-import { SqlClient } from 'effect/unstable/sql/SqlClient';
-import * as SqlModel from 'effect/unstable/sql/SqlModel';
-import * as Migrator from 'effect/unstable/sql/Migrator';
+import { Model } from 'effect/schema';
+import { SqlClient } from 'effect/sql/SqlClient';
+import * as SqlModel from 'effect/sql/SqlModel';
+import * as Migrator from 'effect/sql/Migrator';
 import { PgClient } from '@effect/sql-pg';
 
 // 1. Define Model

package/skills/effect-stream/SKILL.md

@@ -15,7 +15,7 @@ Reference this for:
 - Stream constructors and combinators (`packages/effect/src/Stream.ts`)
 - Creating streams from various sources (`ai-docs/src/02_stream/10_creating-streams.ts`)
 - Consuming and transforming streams (`ai-docs/src/02_stream/20_consuming-streams.ts`)
-- Encoding/decoding with NDJSON and SchemaBinary (`packages/effect/src/unstable/encoding/`)
+- Encoding/decoding with NDJSON and SchemaBinary (`packages/effect/src/encoding/`)
 
 ## Core Model
 
@@ -25,7 +25,7 @@ Use a stream when values are naturally many-valued and ordered over time. For on
 
 ```ts
 import { Effect, Schedule, Schema, Sink, Stream } from 'effect';
-import { Ndjson, SchemaBinary } from 'effect/unstable/encoding';
+import { Ndjson, SchemaBinary } from 'effect/encoding';
 ```
 
 For Node.js readable streams:
@@ -84,6 +84,11 @@ const samples = Stream.fromEffectSchedule(
 const forever = Stream.fromEffectRepeat(Effect.succeed('tick'));
 ```
 
+`Stream.repeat(source, schedule)` and `Stream.forever(source)` repeat the whole
+source, closing each completed run's scope before starting the next one. Keep
+per-run acquisitions inside the source so they release between iterations;
+resources that must span repetitions belong to an outer owning scope.
+
 ### Paginated APIs
 
 `Stream.paginate` drives cursor-based pagination. Return the current page and `Option.some(nextCursor)` or `Option.none()` to stop.
@@ -152,6 +157,35 @@ const callbackStream = Stream.callback<PointerEvent>(
 
 Options: `{ bufferSize?: number, strategy?: "sliding" | "dropping" | "suspend" }`
 
+### Queue completion and terminal batches
+
+For a queue-backed source, `Queue.end` stops new offers but lets buffered values
+drain before `Cause.Done`; `Queue.fail` likewise drains before its error.
+`Queue.takeN` / `takeBetween` can return a final batch smaller than their requested
+minimum once closing begins. An open queue with a partial batch stays suspended
+until its batching threshold is reached; it does not busy-loop on each offer.
+Do not interpret a short terminal batch as malformed input.
+
+<!-- typecheck -->
+```ts
+import { Cause, Effect, Queue } from 'effect';
+
+const program = Effect.gen(function* () {
+	const queue = yield* Queue.bounded<number, Cause.Done>(8);
+	yield* Queue.offerAll(queue, [1, 2]);
+	yield* Queue.end(queue);
+	const finalBatch = yield* Queue.takeN(queue, 5); // [1, 2]
+	const terminal = yield* Effect.exit(Queue.take(queue)); // Done
+	return { finalBatch, terminal };
+});
+```
+
+Interrupted pending `offer` / `offerAll` producers withdraw their unaccepted
+values even during closing, allowing the queue to finish. `Queue.shutdown`
+discards buffered messages immediately; `shutdownUnsafe` is the synchronous
+callback equivalent. Both return `false` if already completed or shut down.
+They preserve an existing closing cause; an open queue shuts down by interruption.
+
 ### From ReadableStream (DOM/Web)
 
 ```ts
@@ -228,6 +262,10 @@ stream.pipe(
 );
 ```
 
+A synchronous throw from a concurrent mapping callback is reported as a defect
+inside its worker fiber; it does not become a typed mapping error. Lift expected
+throwable operations with `Effect.try` / `tryPromise` at their boundary.
+
 ### FlatMap
 
 Transform each element into a stream and flatten. Supports concurrency.
@@ -357,10 +395,10 @@ stream.pipe(
 
 ## 4. Encoding & Decoding (NDJSON / SchemaBinary)
 
-Use `Stream.pipeThroughChannel` with codec channels from `effect/unstable/encoding`.
+Use `Stream.pipeThroughChannel` with codec channels from `effect/encoding`.
 
 ```ts
-import { Ndjson, SchemaBinary } from 'effect/unstable/encoding';
+import { Ndjson, SchemaBinary } from 'effect/encoding';
 ```
 
 ### Schema-derived binary frames
@@ -369,7 +407,7 @@ import { Ndjson, SchemaBinary } from 'effect/unstable/encoding';
 ```ts
 import { Stream } from 'effect';
 import * as Schema from 'effect/Schema';
-import { SchemaBinary } from 'effect/unstable/encoding';
+import { SchemaBinary } from 'effect/encoding';
 
 class Reading extends Schema.Class<Reading>('Reading')({
 	id: Schema.String,
@@ -618,6 +656,13 @@ Options: `{ capacity: number | "unbounded", strategy?: "sliding" | "dropping" |
 
 Because the producer starts immediately, subscribers that attach after the source has already emitted will miss earlier values unless `replay` is configured (and `replay` only retains the most recent N values — it is not a full log). For a **fixed, known set of consumers**, prefer `broadcastN`: it subscribes all downstream streams before starting the source, so none of them miss values.
 
+Completion and failure are retained separately from ordinary values:
+`broadcast`, `broadcastN`, `share`, and `toPubSubTake` end their underlying PubSub
+with the source's terminal exit. Current and late subscribers observe that exit
+after buffered/replayed values, even if a dropping buffer was full. This does
+not replay earlier data. For `toPubSubTake`, consume with `Stream.fromPubSubTake`
+so the terminal `Take` is interpreted as completion/failure.
+
 ### broadcastN
 
 Fixed-fanout multicast produces a tuple of `n` streams; the source starts only **after all `n` downstream streams have been subscribed**, so every consumer sees the full sequence without needing `replay`. If a downstream stream is interrupted, it unsubscribes and no longer contributes backpressure.

package/skills/effect-testing/SKILL.md

@@ -124,6 +124,41 @@ it.live('test with real time', () =>
 
 Use `it.live` only when real time or live runtime services are behavior under test. It scopes the test without installing `TestClock` or `TestConsole`. Real databases, HTTP clients, and filesystems still require their explicit layers; `it.live` does not provide them.
 
+### Vitest Fixtures
+
+Build helpers with `makeMethods(test.extend(...))` when using Vitest fixtures.
+Destructure the fixtures in the callback: Vitest reads those names to select
+setup and rejects a plain `(ctx) =>` parameter once fixtures are defined.
+
+```typescript
+import { expect, makeMethods, test } from '@effect/vitest';
+import { Effect } from 'effect';
+
+const it = makeMethods(
+	test.extend('config', { scope: 'file' }, () => ({ port: 3000 }))
+);
+
+it.effect('reads the config fixture', ({ config }) =>
+	Effect.sync(() => {
+		expect(config.port).toBe(3000);
+	})
+);
+
+it.effect.each([3000])('uses port %s', (port, { config }) =>
+	Effect.sync(() => {
+		expect(config.port).toBe(port);
+	})
+);
+```
+
+`it.effect.each` passes the test case first and context second. Named and
+anonymous `it.layer` suites preserve fixtures; fixture teardown follows the
+Effect test scope's closure. Property tests cannot request fixtures, though auto
+fixtures still run. Build `makeMethods` from `test` or `test.extend(...)`, not
+the suite-bound test passed to a `describe` callback, which can register nested
+layer tests outside their intended suite. In concurrent tests, destructure and
+use the callback's `expect` for per-test snapshots and assertion counts.
+
 ### Resource Management in Tests
 
 `it.effect` already handles scoping internally — there is no separate `it.scoped` or `it.scopedLive` variant. Use `Effect.acquireRelease` or `Effect.scoped` directly within `it.effect`:
@@ -606,6 +641,11 @@ it.effect('should fail with specific error', () =>
 
 ## Property-Based Testing
 
+Native `Arbitrary` is exported from `effect/Arbitrary` or the `effect` root;
+it does not use fast-check. It remains marked `@stability unstable`, so preserve
+important failing inputs rather than relying on replay compatibility across
+releases.
+
 ### Using it.prop for Pure Properties
 
 ```typescript
@@ -685,7 +725,7 @@ it.effect.prop('user validation works', { user: User }, ({ user }) =>
 with `Arbitrary.all`. For manual sampling use the interruptible native runner:
 
 ```typescript
-import { Arbitrary } from 'effect/unstable/arbitrary';
+import * as Arbitrary from 'effect/Arbitrary';
 
 const userArbitrary = Arbitrary.schema(User);
 const samples = Arbitrary.sampleEffect(userArbitrary, { count: 10, seed: 'users' });
@@ -699,9 +739,22 @@ result; inspect the outcome rather than treating completion as success. Preserve
 seeds, replay tokens, and important failing inputs. Replay paths can change when
 the generator/shrinker changes. In the Vitest adapter, thrown exceptions, typed
 failures, and defects are shrinkable falsifications; interruption stays interruption.
+The direct `Arbitrary.checkEffect` runner instead propagates defects and
+interruption; only `false` and typed Effect failures become falsifications.
+Generated values are not cloned. Keep properties deterministic and immutable,
+and acquire/reset stateful fixtures inside each evaluation: shrinking and replay
+run the property repeatedly without resetting shared services for you.
 
 ### Configuring native property checks
 
+Set suite-wide defaults before concurrent tests start with
+`Arbitrary.configureGlobal({ check: { runs: 1000 }, sample: { count: 10 } })`.
+This replaces the previous configuration; `{}` restores built-in defaults.
+Non-`undefined` per-call options win. Defaults are read when an execution starts,
+including for Effects created earlier, and do not change active runs. Replay
+tokens still control replayed checks. Vitest's `arbitrary` options use these
+same defaults.
+
 ```typescript
 import { it } from '@effect/vitest';
 import { Effect } from 'effect';
@@ -721,6 +774,42 @@ it.effect.prop(
 );
 ```
 
+## Schema Assertions
+
+`TestSchema` from `effect/testing` is marked `@stability unstable`.
+`new TestSchema.Asserts(schema)` provides `make()`, `decoding()`, and `encoding()`
+assertions. Their `succeedEffect` and `failEffect` methods are lazy Effects;
+decoding/encoding assertions use the caller's services, test clock, and
+interruption. Prefer them inside `it.effect` over starting a separate runtime
+through Promise helpers.
+
+<!-- typecheck -->
+```typescript
+import { Effect } from 'effect';
+import * as Schema from 'effect/Schema';
+import { TestSchema } from 'effect/testing';
+
+const asserts = new TestSchema.Asserts(Schema.FiniteFromString);
+const verify = Effect.gen(function* () {
+	yield* asserts.decoding().succeedEffect('42', 42);
+	yield* asserts.encoding().succeedEffect(42, '42');
+	yield* asserts.verifyRoundTripEffect({ seed: 1, runs: 20 });
+});
+```
+
+`verifyRoundTripEffect` generates decoded values and checks encode-then-decode
+with strict deep equality; it requires both encoding and decoding services.
+It does not promise to preserve arbitrary original wire spellings. The Promise
+counterpart is `verifyRoundTrip`, replacing `verifyLosslessTransformation`.
+Promise `succeed` / `fail` remain available for any test runner after satisfying
+their services with the assertion object's `.provide(...)` method.
+
+Success assertions compare against the input when only one argument is supplied;
+pass an explicit expected value for transformations. Failure assertions compare
+the formatted schema issue, not arbitrary failures. Assertion mismatches are
+defects. Schema defects and interruption propagate, even when combined with
+validation failures, rather than satisfying a failure assertion.
+
 ## Test Control
 
 ### Skipping Tests
@@ -973,7 +1062,7 @@ For SSE endpoints, use `HttpServerResponse.stream` with different `Stream` const
 
 ```typescript
 import { Effect, Stream } from 'effect';
-import { HttpServerResponse } from 'effect/unstable/http';
+import { HttpServerResponse } from 'effect/http';
 
 // Normal SSE response — stream JSON lines, then [DONE]
 const sse = (lines: ReadonlyArray<unknown>) =>