opencode-effect-enforcer 0.2.8 → 0.4.0

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

@@ -8,13 +8,15 @@ You are an Effect TypeScript expert specializing in building MCP (Model Context
 ## 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 `git show effect@4.0.0:<path>` in that checkout for this baseline; main
+may be ahead. Keep Effect-family package versions aligned. The MCP/AI APIs remain
+`@stability unstable` and can change incompatibly in minor releases.
 
 Reference these files:
 
 - `packages/effect/MCP.md` — primary MCP guide with full examples
-- `packages/effect/src/unstable/ai/McpServer.ts` — server implementation and API
-- `packages/effect/src/unstable/ai/McpSchema.ts` — schema types, param helper, error classes
+- `packages/effect/src/ai/McpServer.ts` — server implementation and API
+- `packages/effect/src/ai/McpSchema.ts` — schema types, param helper, error classes
 
 ## What is MCP
 
@@ -25,7 +27,7 @@ Model Context Protocol (MCP) is a standard protocol for LLM tool integration. It
 ```typescript
 import { Cause, Context, Effect, Layer, Logger } from 'effect';
 import { Schema } from 'effect';
-import { McpProtocol, McpServer, McpSchema, Tool, Toolkit } from 'effect/unstable/ai';
+import { McpProtocol, McpServer, McpSchema, Tool, Toolkit } from 'effect/ai';
 ```
 
 For platform-specific transports:
@@ -72,7 +74,8 @@ 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`.
+- `2026-07-28` is available as `McpProtocol.v2026_07_28`; it uses stateless
+  request-scoped execution rather than the older initialized-session lifecycle.
 - 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.
 
@@ -84,34 +87,60 @@ 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.
+Strict tools reject unknown keys; non-strict tools ignore them during decoding.
+Both report all missing/invalid fields together (`errors: 'all'`), including
+unknown keys for strict tools. Strict dynamic tools require Effect schemas;
+raw JSON Schema cannot supply runtime strict validation and is rejected at registration.
+
+Parameters must encode to a JSON Schema with `type: 'object'` at the root. Use
+`Schema.Class` or `Schema.Struct`, or omit parameters/use `Tool.EmptyParams` for
+parameterless tools. Identified object schemas are supported: the adapter inlines
+top-level references for input/output schemas and form elicitation, retaining
+referenced definitions. It does not turn primitive result types into objects.
+
+Tool failure projection depends on the negotiated protocol:
+
+| Failure | 2024-11-05 through 2025-06-18 | 2025-11-25 and 2026-07-28 |
+| --- | --- | --- |
+| Invalid arguments | `-32602 Invalid params` | `isError: true` tool result |
+| Internal handler/encoding failure | `-32603 Internal error` | `isError: true` tool result |
+| Declared tool failure | `isError: true` tool result | `isError: true` tool result |
+
+Declared failures omit `structuredContent`; an error with an empty `message`
+uses its encoded failure value rather than returning empty text. Internal defects
+and encoding failures are reported internally with generic client-facing messages.
+
+Success projection is also version-specific. The 2024-11-05/2025-03-26 adapters
+omit structured output. The 2025-06-18/2025-11-25 adapters expose object-root
+output schemas and object-valued `structuredContent`, omitting primitive/array
+structured values. The 2026-07-28 adapter supports JSON-valued structured output.
+When a protocol omits string structured content, a single text block that exactly
+mirrors its JSON encoding is unquoted to plain text; other text blocks are preserved.
 
 ### Defining Tools
 
 Tools are defined with `Tool.make` specifying a name, description, parameter schemas, and success schema:
 
+<!-- typecheck -->
 ```typescript
+import * as Schema from 'effect/Schema';
+import { Tool } from 'effect/ai';
+
 const GreetTool = Tool.make('GreetTool', {
 	description: 'Generate a greeting message',
-	parameters: {
+	parameters: Schema.Struct({
 		name: Schema.String,
 		style: Schema.Union([
 			Schema.Literal('formal'),
 			Schema.Literal('casual')
 		])
-	},
+	}),
 	success: Schema.String
 });
 
 const CalculatorTool = Tool.make('CalculatorTool', {
 	description: 'Perform basic arithmetic',
-	parameters: {
+	parameters: Schema.Struct({
 		operation: Schema.Union([
 			Schema.Literal('add'),
 			Schema.Literal('subtract'),
@@ -120,16 +149,16 @@ const CalculatorTool = Tool.make('CalculatorTool', {
 		]),
 		a: Schema.Number,
 		b: Schema.Number
-	},
+	}),
 	success: Schema.Number
 });
 
 const NotifyTool = Tool.make('NotifyTool', {
 	description: 'Send an optional notification',
-	parameters: {
+	parameters: Schema.Struct({
 		message: Schema.String,
 		channel: Schema.optionalKey(Schema.String)
-	},
+	}),
 	success: Schema.Void
 });
 ```
@@ -184,6 +213,8 @@ Effect tool annotations are emitted as MCP tool hints:
 - `Tool.Destructive` → `destructiveHint`, default `true`
 - `Tool.Idempotent` → `idempotentHint`, default `false`
 - `Tool.OpenWorld` → `openWorldHint`, default `true`
+- `Tool.Title` → annotation title; 2025-06-18 and 2025-11-25 preserve it in
+  `tools/list` alongside the descriptor's top-level title and behavioral hints
 
 These hints help clients decide how to present tools, but they are not authorization decisions. Always enforce access control in your server handlers.
 
@@ -282,6 +313,8 @@ const result = McpServer.elicit({
 - Returns `Effect<S["Type"], ElicitationDeclined, McpServerClient>`
 - Handle `ElicitationDeclined` with `catchTag` for fallback behavior
 - If the user cancels, the effect is interrupted
+- Identified object schemas (including named `Schema.Class` values) are accepted;
+  the requested form still has to fit the negotiated revision's supported field shapes.
 - The negotiated client must advertise form elicitation. In `2025-11-25`, an empty `elicitation` capability is treated as form support; explicit `elicitation.form` and `elicitation.url` capabilities are otherwise gated independently.
 
 URL elicitation is a `2025-11-25` reverse-client operation. Use the scoped client facade, then notify that specific client when the external flow completes:
@@ -380,6 +413,9 @@ 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.
 
+With a stateful protocol configured, pre-initialization stdio `ping` returns an
+empty result without creating a session, even when a stateless adapter is listed first.
+
 ### HTTP Transport
 
 For web-based MCP servers using Streamable HTTP:
@@ -396,7 +432,9 @@ McpServer.layerHttp({
 - Requires `HttpRouter.HttpRouter` in the context
 - Implements single-endpoint Streamable HTTP with JSON-RPC
 - The `path` parameter sets the HTTP endpoint path
-- Non-`initialize` HTTP requests with no session id return `400`; an unknown `Mcp-Session-Id` returns `404`. Clients must keep and resend the session id from initialization.
+- For stateful revisions, non-`initialize` HTTP requests with no session id return
+  `400`; an unknown `Mcp-Session-Id` returns `404`. Keep and resend the session id
+  from initialization. The 2026-07-28 stateless adapter uses request metadata instead.
 
 ### Type signatures
 
@@ -442,7 +480,7 @@ Use `McpSchema.EnabledWhen` to conditionally list prompts, resources, resource t
 ```typescript
 import { Context, Effect, Layer } from 'effect';
 import { Schema } from 'effect';
-import { McpSchema, McpServer, Tool } from 'effect/unstable/ai';
+import { McpSchema, McpServer, Tool } from 'effect/ai';
 
 const requiresRoots = Context.make(
 	McpSchema.EnabledWhen,
@@ -481,12 +519,12 @@ const WorkspaceResource = Layer.effectDiscard(
 import { NodeRuntime, NodeStdio } from '@effect/platform-node';
 import { Effect, Layer, Logger } from 'effect';
 import { Schema } from 'effect';
-import { McpProtocol, McpSchema, McpServer, Tool, Toolkit } from 'effect/unstable/ai';
+import { McpProtocol, McpSchema, McpServer, Tool, Toolkit } from 'effect/ai';
 
 // --- Tools ---
 const GreetTool = Tool.make('GreetTool', {
 	description: 'Generate a greeting',
-	parameters: { name: Schema.String },
+	parameters: Schema.Struct({ name: Schema.String }),
 	success: Schema.String
 });
 
@@ -555,7 +593,7 @@ Layer.launch(ServerLayer).pipe(NodeRuntime.runMain);
 ```typescript
 const FetchTool = Tool.make('FetchData', {
 	description: 'Fetch data from database',
-	parameters: { id: Schema.String },
+	parameters: Schema.Struct({ id: Schema.String }),
 	success: Schema.String
 });
 
@@ -617,7 +655,9 @@ const ConfigResource = McpServer.resource({
 2. **Provide transport last** — `Layer.provide(McpServer.layerStdio(...))` or `Layer.provide(McpServer.layerHttp(...))`
 3. **stderr for stdio** — Never log to stdout when using stdio transport
 4. **Toolkit pattern** — `McpServer.toolkit(tk).pipe(Layer.provideMerge(tk.toLayer({...})))` is the canonical pattern
-5. **Schema for parameters** — All tool parameters and resource template params use Effect Schema
+5. **Schema for parameters** — `Tool.make` takes a schema with an encoded object
+   root, not a raw field record. `McpServer.prompt` still takes a field record;
+   resource template parameters take individual codecs.
 6. **`McpSchema.param`** — Use for resource URI template parameters with automatic string codec
 7. **`Effect.fn`** — Use for resource template content handlers that receive multiple arguments
 8. **Launch with `Layer.launch`** — The server runs as a long-lived layer: `Layer.launch(ServerLayer).pipe(NodeRuntime.runMain)`

package/skills/effect-observability/SKILL.md

@@ -8,14 +8,17 @@ You are an Effect TypeScript expert specializing in observability — structured
 ## 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 `git show effect@4.0.0:<path>` there for this baseline; main may be ahead.
+Keep `effect` and `@effect/*` packages on the same version. The OTLP modules and
+`@effect/opentelemetry` APIs are tagged `@stability unstable` and may break in
+minor releases; the shorter `effect/observability` import path is not a stability guarantee.
 
 Reference this for:
 
 - `Logger` module: `packages/effect/src/Logger.ts`
 - `Tracer` module: `packages/effect/src/Tracer.ts`
 - `Metric` module: `packages/effect/src/Metric.ts`
-- OTLP export: `packages/effect/src/unstable/observability/`
+- OTLP export: `packages/effect/src/observability/`
 - Observability examples: `ai-docs/src/08_observability/`
 
 ---
@@ -178,7 +181,7 @@ const BatchedLoggerLayer = Logger.layer([batchedLogger]);
 
 ### File Logging
 
-Write logs directly to a file (requires `FileSystem` from `@effect/platform`):
+Write logs directly to a file (requires the `FileSystem` service from `effect`):
 
 ```ts
 import { NodeFileSystem } from '@effect/platform-node';
@@ -395,7 +398,7 @@ for (const metric of snapshots) {
 
 ## 5. OTLP Export
 
-Effect v4 includes built-in OTLP exporters in `effect/unstable/observability`. No external OpenTelemetry SDK needed.
+Effect v4 includes built-in OTLP exporters in `effect/observability`. No external OpenTelemetry SDK needed.
 
 ### All-in-One: `Otlp.layerJson`
 
@@ -403,8 +406,8 @@ The simplest setup — exports traces, logs, and metrics to a single OTLP endpoi
 
 ```ts
 import { Layer } from 'effect';
-import { FetchHttpClient } from 'effect/unstable/http';
-import { Otlp } from 'effect/unstable/observability';
+import { FetchHttpClient } from 'effect/http';
+import { Otlp } from 'effect/observability';
 
 const ObservabilityLayer = Otlp.layerJson({
 	baseUrl: 'http://localhost:4318',
@@ -426,19 +429,26 @@ Variants:
 - `Otlp.layerProtobuf` — Protobuf serialization (more efficient)
 - `Otlp.layer` — requires you to provide `OtlpSerialization` separately
 
+Use `Otlp.layerFromConfig()` for standard OpenTelemetry environment
+configuration (`OTEL_EXPORTER_OTLP_ENDPOINT`, signal-specific endpoints,
+headers, exporter selection, and `OTEL_SDK_DISABLED`). Provide both
+`OtlpSerialization.layerJson` (or protobuf) and an `HttpClient` layer. Explicit
+`layerJson({ baseUrl })` is the programmatic endpoint path; it is not the
+environment-selected exporter setup.
+
 ### Individual OTLP Exporters
 
 For fine-grained control, configure each exporter independently:
 
 ```ts
 import { Layer } from 'effect';
-import { FetchHttpClient } from 'effect/unstable/http';
+import { FetchHttpClient } from 'effect/http';
 import {
 	OtlpLogger,
 	OtlpMetrics,
 	OtlpSerialization,
 	OtlpTracer
-} from 'effect/unstable/observability';
+} from 'effect/observability';
 
 const OtlpTracingLayer = OtlpTracer.layer({
 	url: 'http://localhost:4318/v1/traces',
@@ -482,7 +492,7 @@ Each OTLP signal layer now outputs the shared `OtlpExporter.Flusher` service. Us
 
 ```ts
 import { Effect } from 'effect';
-import { OtlpExporter } from 'effect/unstable/observability';
+import { OtlpExporter } from 'effect/observability';
 
 const flushTelemetry = Effect.gen(function* () {
 	const flusher = yield* OtlpExporter.Flusher;
@@ -490,7 +500,42 @@ const flushTelemetry = Effect.gen(function* () {
 });
 ```
 
-All signal layers in the same memoized layer graph share one flusher registry, so one call drains logs, traces, and metrics concurrently. `flush` cannot fail and has no built-in timeout; it waits only for exports it starts, not an export already in flight.
+All signal layers in the same memoized layer graph share one flusher registry, so
+one call requests exports concurrently. `flush` cannot fail and has no built-in
+timeout; it waits only for exports it starts, not exports already in flight.
+Exporters in their temporary-disable window are skipped, so completion is not a
+delivery acknowledgement. Successful delta-metric flushes advance their aggregation window.
+
+The combined `Otlp.layer*` signatures expose `never` as their output service.
+To access `Flusher` with the combined layer, merge `OtlpExporter.layerFlusher`
+explicitly; memoization shares that registry with the signal layers:
+
+<!-- typecheck -->
+```ts
+import { Effect, Layer } from 'effect';
+import { FetchHttpClient } from 'effect/http';
+import { Otlp, OtlpExporter } from 'effect/observability';
+
+const telemetry = Layer.mergeAll(
+	Otlp.layerJson({ baseUrl: 'http://localhost:4318' }),
+	OtlpExporter.layerFlusher
+).pipe(Layer.provide(FetchHttpClient.layer));
+
+const flush = Effect.gen(function* () {
+	const flusher = yield* OtlpExporter.Flusher;
+	return yield* flusher.flush.pipe(Effect.timeoutOption('5 seconds'));
+}).pipe(Effect.provide(telemetry));
+```
+
+### Exporter lifecycle
+
+Keep the exporter layer alive for the application's lifetime. Scope finalization
+starts a final export and waits for tracked in-flight exports, bounded by
+`shutdownTimeout`; a manual flush has the narrower semantics described above.
+The HTTP exporter drains response bodies before completing or retrying requests,
+including error responses that carry a body. Custom/mock HTTP clients must
+supply a consumable response body rather than only a status code. This releases
+connections between export attempts; callers need no separate drain step.
 
 ### OTLP Layer Options
 
@@ -547,7 +592,7 @@ Export Effect metrics in Prometheus exposition format:
 
 ```ts
 import { Effect, Metric } from 'effect';
-import * as PrometheusMetrics from 'effect/unstable/observability/PrometheusMetrics';
+import * as PrometheusMetrics from 'effect/observability/PrometheusMetrics';
 
 const program = Effect.gen(function* () {
 	const counter = Metric.counter('http_requests_total', {
@@ -572,7 +617,7 @@ const program = Effect.gen(function* () {
 Automatically register a `/metrics` endpoint on your HTTP router:
 
 ```ts
-import * as PrometheusMetrics from 'effect/unstable/observability/PrometheusMetrics';
+import * as PrometheusMetrics from 'effect/observability/PrometheusMetrics';
 
 // Default: GET /metrics
 const PrometheusLayer = PrometheusMetrics.layerHttp();
@@ -633,8 +678,8 @@ Use a test tracer or assert on span attributes captured via `Effect.withSpan`.
 
 ```ts
 import { Config, Effect, Layer, Logger, References } from 'effect';
-import { FetchHttpClient } from 'effect/unstable/http';
-import { Otlp } from 'effect/unstable/observability';
+import { FetchHttpClient } from 'effect/http';
+import { Otlp } from 'effect/observability';
 
 const DevObservability = Logger.layer([Logger.consolePretty()]);
 
@@ -715,5 +760,6 @@ class Checkout extends Context.Service<
 7. **Metric names should follow conventions** — snake_case with units suffix (e.g., `http_request_duration_ms`).
 8. **`Metric.withAttributes` creates a tagged variant** — it does not mutate the original metric.
 9. **`OtlpMetrics` temporality** — use `"delta"` for backends like Datadog/Dynatrace, `"cumulative"` (default) for Prometheus-style backends.
-10. **All OTLP modules are under `effect/unstable/observability`** — the API may evolve but the patterns are stable.
+10. **OTLP modules are under `effect/observability`** — they remain tagged
+    `@stability unstable`; inspect the matching release when upgrading.
 11. **Use `OtlpExporter.Flusher` for manual drains** — bound `flusher.flush` with `Effect.timeoutOption` when shutdown latency must be capped.

package/skills/effect-parallelization/SKILL.md

@@ -120,9 +120,9 @@ yield* Effect.all([logA, logB, logC], { concurrency: 'unbounded', discard: true
 // Effect<void, E, R>
 ```
 
-### `mode: 'result'` — run everything, never fail
+### `mode: 'result'` — collect typed outcomes
 
-Each slot becomes a `Result<A, E>` and the error channel becomes `never`. Every effect runs to completion (no fail-fast interruption):
+Each slot becomes a `Result<A, E>` and the error channel becomes `never`. Typed failures do not short-circuit the batch; defects and interruption still terminate it:
 
 ```ts
 const results = yield* Effect.all(
@@ -233,6 +233,7 @@ const settled = yield* Effect.raceFirst(primary, secondary);
 Semantics (verified in `internal/effect.ts`):
 
 - **Loser interruption is awaited**: when a winner settles, the remaining fibers are interrupted uninterruptibly and the race only resumes with the winning exit after those interruptions (including finalizers) complete.
+- Cleanup also covers losers still starting when the race settles or the caller is interrupted. Use the race combinators directly rather than custom start/cancel bookkeeping.
 - `race`/`raceAll`: early failures do not finish the race — the race keeps waiting until one effect succeeds or all have failed. If all fail, the failure reasons are collected into one combined `Cause`.
 - `raceFirst`/`raceAllFirst`: the first fiber to settle (success *or* failure) decides the outcome.
 - Effects are forked in iteration order; if an early effect completes synchronously, later effects may never start at all.
@@ -300,17 +301,33 @@ const strong = yield* Effect.filterMapEffect(
 // Array of kept, transformed values
 ```
 
-### `Effect.partition` — split failures from successes, never fail
+### `Effect.partition` — collect successes and typed failures
 
-Runs every element (no short-circuit). Returns `[excluded, satisfying]` — failures first. Both arrays preserve input order:
+Typed failures do not short-circuit. Returns `[passes, fails]` — **successes first**. Both arrays preserve input order; defects and interruption still propagate:
 
 ```ts
-const [failures, users] = yield* Effect.partition(
+const [users, failures] = yield* Effect.partition(
 	userIds,
 	(id) => fetchUser(id),
 	{ concurrency: 8 }
 );
-// Effect<[excluded: Array<E>, satisfying: Array<User>], never, R>
+// Effect<[passes: Array<User>, fails: Array<E>], never, R>
+```
+
+`Arr.partition`, `Arr.separate`, the corresponding `Chunk` / `Record` helpers,
+and `Option.partitionMap` also put successes first, matching `Stream.partition`.
+Name destructured tuple elements by meaning rather than assuming the older order.
+
+<!-- typecheck -->
+```ts
+import { Effect } from 'effect';
+
+const partitioned = Effect.partition(
+	[1, 2, 3],
+	(n) => n === 2 ? Effect.fail('rejected') : Effect.succeed(n),
+	{ concurrency: 2 }
+);
+// Success value: [[1, 3], ['rejected']]
 ```
 
 ### `Effect.validate` — accumulate all failures
@@ -518,7 +535,7 @@ import { Effect } from 'effect';
 
 const syncAllUsers = (userIds: ReadonlyArray<string>) =>
 	Effect.gen(function* () {
-		const [failures, synced] = yield* Effect.partition(
+		const [synced, failures] = yield* Effect.partition(
 			userIds,
 			(id) => syncUser(id),
 			{ concurrency: 8 }

package/skills/effect-path/SKILL.md

@@ -7,6 +7,8 @@ description: Use effect Path for platform-abstract file path operations includin
 
 Use effect Path abstraction for platform-abstract file path operations. Apply this skill when working with file paths, joining segments, resolving absolute paths, or converting between file URLs and paths. `Path.layer` supplies POSIX semantics from `effect`; Node.js and Bun platform layers provide host-specific path semantics. `@effect/platform-browser` does not provide a `BrowserPath` layer, so browser code should provide `Path.layer` or a custom layer explicitly.
 
+Targets **Effect 4.0.0** (`effect@4.0.0` source tag). In browsers without `process.cwd()`, supply an absolute POSIX base to `resolve`/`toFileUrl` when using `Path.layer`; it does not invent a browser working directory.
+
 ## Import Pattern
 
 ```typescript
@@ -195,6 +197,7 @@ Both operations can fail with `BadArgument` error.
 
 ### fromFileUrl - Convert file URL to path
 
+<!-- typecheck -->
 ```typescript
 import { Path } from 'effect';
 import { Effect } from 'effect';
@@ -205,12 +208,13 @@ const program = Effect.gen(function* () {
 		new URL('file:///home/user/file.txt')
 	);
 	// "/home/user/file.txt" on Unix
-	// "C:\home\user\file.txt" on Windows
+	// On Windows, use a drive-qualified URL such as file:///C:/home/user/file.txt.
 });
 ```
 
 ### toFileUrl - Convert path to file URL
 
+<!-- typecheck -->
 ```typescript
 import { Path } from 'effect';
 import { Effect } from 'effect';
@@ -224,6 +228,7 @@ const program = Effect.gen(function* () {
 
 ## Complete Example
 
+<!-- typecheck -->
 ```typescript
 import { Path } from 'effect';
 import { Effect } from 'effect';
@@ -253,9 +258,10 @@ const buildOutputPath = Effect.gen(function* () {
 
 In Effect v4, `Migrator.fromFileSystem(directory)` requires both `FileSystem.FileSystem` and `Path.Path`. Migration modules are imported through `path.toFileUrl(path.join(directory, file))` so absolute Windows paths are valid ESM specifiers.
 
+<!-- typecheck -->
 ```typescript
 import { FileSystem, Path } from 'effect';
-import * as Migrator from 'effect/unstable/sql/Migrator';
+import * as Migrator from 'effect/sql/Migrator';
 
 const loader: Migrator.Loader<FileSystem.FileSystem | Path.Path> =
 	Migrator.fromFileSystem('./migrations');