effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/unstable/persistence/RateLimiter.ts

@@ -162,7 +162,7 @@ export const make: Effect.Effect<
               delay,
               limit: options.limit,
               remaining: options.limit - count,
-              resetAfter: Duration.times(window, Math.ceil(ttl / windowMillis))
+              resetAfter: Duration.millis(ttl)
             })
           }
         )
@@ -176,40 +176,28 @@ export const make: Effect.Effect<
           refillRate,
           allowOverflow: onExceeded === "delay"
         }),
-        (remaining) => {
-          if (onExceeded === "fail") {
-            if (remaining < 0) {
-              return Effect.fail(
-                new RateLimiterError({
-                  reason: new RateLimitExceeded({
-                    key: options.key,
-                    retryAfter: Duration.times(refillRate, -remaining),
-                    limit: options.limit,
-                    remaining: 0
-                  })
+        ([remaining, elapsedMillis]) => {
+          const delay = Duration.millis(Math.max(0, Math.ceil(-remaining) * refillRateMillis - elapsedMillis))
+          const resetAfter = Duration.millis(
+            Math.max(0, Math.ceil(options.limit - remaining) * refillRateMillis - elapsedMillis)
+          )
+          if (onExceeded === "fail" && remaining < 0) {
+            return Effect.fail(
+              new RateLimiterError({
+                reason: new RateLimitExceeded({
+                  key: options.key,
+                  retryAfter: delay,
+                  limit: options.limit,
+                  remaining: 0
                 })
-              )
-            }
-            return Effect.succeed<ConsumeResult>({
-              delay: Duration.zero,
-              limit: options.limit,
-              remaining,
-              resetAfter: Duration.times(refillRate, options.limit - remaining)
-            })
-          }
-          if (remaining >= 0) {
-            return Effect.succeed<ConsumeResult>({
-              delay: Duration.zero,
-              limit: options.limit,
-              remaining,
-              resetAfter: Duration.times(refillRate, options.limit - remaining)
-            })
+              })
+            )
           }
           return Effect.succeed<ConsumeResult>({
-            delay: Duration.times(refillRate, -remaining),
+            delay,
             limit: options.limit,
             remaining,
-            resetAfter: Duration.times(refillRate, options.limit - remaining)
+            resetAfter
           })
         }
       )
@@ -370,7 +358,7 @@ export function sleep(self: RateLimiter, options?: {
  * @category type IDs
  * @since 4.0.0
  */
-export const ErrorTypeId: ErrorTypeId = "~@effect/experimental/RateLimiter/RateLimiterError"
+export const ErrorTypeId: ErrorTypeId = "~effect/persistence/RateLimiter/RateLimiterError"
 
 /**
  * Type-level identifier used to brand `RateLimiterError` values.
@@ -378,7 +366,7 @@ export const ErrorTypeId: ErrorTypeId = "~@effect/experimental/RateLimiter/RateL
  * @category type IDs
  * @since 4.0.0
  */
-export type ErrorTypeId = "~@effect/experimental/RateLimiter/RateLimiterError"
+export type ErrorTypeId = "~effect/persistence/RateLimiter/RateLimiterError"
 
 /**
  * Error reason for a rate-limit check that exceeded the configured limit.
@@ -505,6 +493,11 @@ export interface ConsumeResult {
 
   /**
    * The time until the rate limit fully resets.
+   *
+   * **Details**
+   *
+   * For token buckets, accounts for elapsed refill time and reserved debt,
+   * assuming no further consumption.
    */
   readonly resetAfter: Duration.Duration
 }
@@ -633,14 +626,18 @@ export class RateLimiterStore extends Context.Service<
     }) => Effect.Effect<readonly [count: number, ttl: number], RateLimiterError>
 
     /**
-     * Returns the current remaining tokens for the `key` after consuming the
-     * specified amount of tokens.
+     * Refills the bucket for `key`, attempts to consume `tokens`, and returns
+     * `[remaining, elapsedMillis]` from that single atomic operation.
      *
-     * If `allowOverflow` is true, the number of tokens can drop below zero.
+     * `remaining` is the token count after subtracting `tokens`. Fractional counts
+     * must retain their numeric precision. A negative count is only persisted
+     * when `allowOverflow` is true.
      *
-     * In the case of no overflow, the returned token count will only be
-     * negative if the requested tokens exceed the available tokens, but the
-     * real token count will not be persisted below zero.
+     * `elapsedMillis` is the time since the current refill interval started, in
+     * milliseconds (fractions preserved), always at least `0` and less than
+     * `Duration.toMillis(refillRate)`. It is `0` when the bucket is at capacity
+     * after refilling and before consuming. Otherwise the boundary advances by
+     * whole refill intervals and the interval never restarts.
      */
     readonly tokenBucket: (options: {
       readonly key: string
@@ -648,7 +645,7 @@ export class RateLimiterStore extends Context.Service<
       readonly limit: number
       readonly refillRate: Duration.Duration
       readonly allowOverflow: boolean
-    }) => Effect.Effect<number, RateLimiterError>
+    }) => Effect.Effect<readonly [remaining: number, elapsedMillis: number], RateLimiterError>
 
     /**
      * Consumes tokens from the adaptive rate-limit state for the `key`.
@@ -745,20 +742,21 @@ export const layerStoreMemory: Layer.Layer<
           if (!bucket) {
             bucket = { tokens: options.limit, lastRefill: now }
             tokenBuckets.set(options.key, bucket)
-          } else {
-            const elapsed = now - bucket.lastRefill
-            const tokensToAdd = Math.floor(elapsed / refillRateMillis)
-            if (tokensToAdd > 0) {
-              bucket.tokens = Math.min(options.limit, bucket.tokens + tokensToAdd)
-              bucket.lastRefill += tokensToAdd * refillRateMillis
-            }
+          }
+          const tokensToAdd = Math.floor((now - bucket.lastRefill) / refillRateMillis)
+          if (tokensToAdd > 0) {
+            bucket.tokens = Math.min(options.limit, bucket.tokens + tokensToAdd)
+            bucket.lastRefill += tokensToAdd * refillRateMillis
+          }
+          if (bucket.tokens >= options.limit) {
+            bucket.lastRefill = now
           }
 
           const newTokenCount = bucket.tokens - options.tokens
           if (options.allowOverflow || newTokenCount >= 0) {
             bucket.tokens = newTokenCount
           }
-          return newTokenCount
+          return [newTokenCount, Math.max(0, now - bucket.lastRefill)] as const
         })
       ),
     adaptiveConsume: (options) =>
@@ -945,14 +943,17 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
       const refillMillis = Duration.toMillis(options.refillRate)
       return Effect.clockWith((clock) =>
         Effect.mapError(
-          tokenBucket(
-            key,
-            lastRefillKey,
-            options.tokens,
-            refillMillis,
-            options.limit,
-            clock.currentTimeMillisUnsafe(),
-            options.allowOverflow ? 1 : 0
+          Effect.map(
+            tokenBucket(
+              key,
+              lastRefillKey,
+              options.tokens,
+              refillMillis,
+              options.limit,
+              clock.currentTimeMillisUnsafe(),
+              options.allowOverflow ? 1 : 0
+            ),
+            ([remaining, elapsedMillis]) => [Number(remaining), Number(elapsedMillis)] as const
           ),
           (cause) =>
             new RateLimiterError({
@@ -1078,6 +1079,9 @@ if refill_amount > 0 then
   current = math.min(current + refill_amount, limit)
   last_refill = last_refill + (refill_amount * refill_ms)
 end
+if current >= limit then
+  last_refill = now
+end
 
 local next = current - tokens
 local stored = current
@@ -1085,14 +1089,16 @@ if next >= 0 or overflow then
   stored = next
 end
 
-local ttl = math.floor((limit - stored) * refill_ms)
+elapsed = math.max(0, now - last_refill)
+local ttl = math.ceil(math.ceil(limit - stored) * refill_ms - elapsed)
 if ttl < 1 then ttl = 1 end
 redis.call("SET", key, stored, "PX", ttl)
 redis.call("SET", last_refill_key, last_refill, "PX", ttl)
-return next
+-- Use 17 significant digits to round-trip both numbers.
+return { string.format("%.17g", next), string.format("%.17g", elapsed) }
 `
   }
-).withReturnType<number>()
+).withReturnType<readonly [remaining: string, elapsedMillis: string]>()
 
 const adaptiveConsumeScript = Redis.script(
   (key: string, tokens: number, fallbackWindowMillis: number, ttlGraceMillis: number) => [

package/src/unstable/process/ChildProcess.ts

@@ -21,7 +21,7 @@ import type * as Sink from "../../Sink.ts"
 import type * as Stream from "../../Stream.ts"
 import { type ChildProcessHandle, ChildProcessSpawner } from "./ChildProcessSpawner.ts"
 
-const TypeId = "~effect/unstable/process/ChildProcess"
+const TypeId = "~effect/process/ChildProcess"
 
 /**
  * A command that can be built using `make`, combined using `pipeTo`, and executed using `exec` or `spawn`.
@@ -247,8 +247,12 @@ export interface KillOptions {
   /**
    * The duration of time to wait after the child process has been terminated
    * before forcefully killing the child process by sending it the `"SIGKILL"`
-   * signal. Defaults to `undefined`, which means that no timeout will be
-   * enforced by default.
+   * signal. Defaults to `undefined`, so `"SIGKILL"` is never sent.
+   *
+   * **Details**
+   *
+   * The spawner decides whether to terminate descendants and how long to wait.
+   * See its platform module documentation, such as `NodeChildProcessSpawner`.
    */
   readonly forceKillAfter?: Duration.Input | undefined
 }
@@ -436,6 +440,8 @@ export interface CommandOptions extends KillOptions {
    * If set to `true`, prevents the child process's console or GUI window from
    * becoming visible on Windows.
    *
+   * **Details**
+   *
    * Defaults to `true` unless `detached` is set to `true`. This option has no
    * effect on non-Windows platforms.
    */
@@ -1376,8 +1382,13 @@ const splitByWhitespaces = (template: string, rawTemplate: string): {
         rawIndex += 1
       } else if (nextRawCharacter === "u" && rawTemplate[rawIndex + 2] === "{") {
         // Handle variable-length unicode escape sequences (i.e. `\u{1F600}`) by:
+        // - Advancing the template index an extra code unit for astral code points
         // - Advancing the raw template index past the unicode escape sequence
-        rawIndex = rawTemplate.indexOf("}", rawIndex + 3)
+        const end = rawTemplate.indexOf("}", rawIndex + 3)
+        if (parseInt(rawTemplate.slice(rawIndex + 3, end), 16) > 0xffff) {
+          templateIndex += 1
+        }
+        rawIndex = end
       } else {
         // Advance raw template index past fixed-length escape sequences:
         // - \n    → 2 chars (backslash + n)

package/src/unstable/process/ChildProcessSpawner.ts

@@ -68,7 +68,7 @@ export const ProcessId: Brand.Constructor<ProcessId> = Brand.nominal<ProcessId>(
  */
 export type Reref = Effect.Effect<void, PlatformError.PlatformError>
 
-const HandleTypeId = "~effect/ChildProcessSpawner/ChildProcessHandle"
+const HandleTypeId = "~effect/process/ChildProcessSpawner/ChildProcessHandle"
 
 /**
  * A handle to a running child process.

package/src/unstable/reactivity/Atom.ts

@@ -22,6 +22,7 @@ import type { LazyArg } from "../../Function.ts"
 import { constant, constTrue, constVoid, dual, pipe } from "../../Function.ts"
 import type * as Inspectable from "../../Inspectable.ts"
 import { PipeInspectableProto } from "../../internal/core.ts"
+import { getStackTraceLimit } from "../../internal/stackTraceLimit.ts"
 import * as Layer from "../../Layer.ts"
 import * as MutableHashMap from "../../MutableHashMap.ts"
 import * as Option from "../../Option.ts"
@@ -1640,7 +1641,9 @@ export const withFallback: {
   return isWritable(self)
     ? writable(
       withFallback,
-      self.write,
+      function(ctx, value) {
+        ctx.set(self, value)
+      },
       self.refresh ?? function(refresh) {
         refresh(self)
       }
@@ -1880,7 +1883,7 @@ export const withLabel: {
 >(2, (self, name) =>
   Object.assign(Object.create(Object.getPrototypeOf(self)), {
     ...self,
-    label: [name, new Error().stack?.split("\n")[5] ?? ""]
+    label: [name, getStackTraceLimit() === 0 ? "" : new Error().stack?.split("\n")[5] ?? ""]
   }))
 
 /**
@@ -3134,7 +3137,7 @@ export const serializable: {
   const codecJson = Schema.toCodecJson(options.schema)
   return Object.assign(Object.create(Object.getPrototypeOf(self)), {
     ...self,
-    label: self.label ?? [options.key, new Error().stack?.split("\n")[5] ?? ""],
+    label: self.label ?? [options.key, getStackTraceLimit() === 0 ? "" : new Error().stack?.split("\n")[5] ?? ""],
     [SerializableTypeId]: {
       key: options.key,
       encode: Schema.encodeSync(codecJson),

package/src/unstable/reactivity/AtomHttpApi.ts

@@ -17,9 +17,9 @@ import type { ReadonlyRecord } from "../../Record.ts"
 import * as Schema from "../../Schema.ts"
 import type { SchemaError } from "../../Schema.ts"
 import type { Mutable, Simplify } from "../../Types.ts"
+import type * as Sse from "../encoding/Sse.ts"
 import type * as HttpClient from "../http/HttpClient.ts"
 import * as HttpClientError from "../http/HttpClientError.ts"
-import type { HttpClientResponse } from "../http/HttpClientResponse.ts"
 import type * as HttpApi from "../httpapi/HttpApi.ts"
 import * as HttpApiClient from "../httpapi/HttpApiClient.ts"
 import * as HttpApiEndpoint from "../httpapi/HttpApiEndpoint.ts"
@@ -82,7 +82,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
           readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
         }
       >,
-      ResponseByMode<Extract<_Success, Schema.Top>["Type"], ResponseMode>,
+      ResponseByMode<Endpoint, ResponseMode>,
       ErrorByMode<_Error, _Middleware, ResponseMode>
     >
     : never
@@ -140,7 +140,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
     >
   ] ? Atom.Atom<
       AsyncResult.AsyncResult<
-        ResponseByMode<Extract<_Success, Schema.Top>["Type"], ResponseMode>,
+        ResponseByMode<Endpoint, ResponseMode>,
         ErrorByMode<_Error, _Middleware, ResponseMode>
       >
     >
@@ -223,11 +223,13 @@ export const Service =
         query: any
         headers: any
         payload: any
+        sseOptions?: Sse.DecodeOptions | undefined
         reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
       }>()(
         Effect.fnUntraced(function*(opts) {
           const client = (yield* self) as any
-          const effect = catchErrors(client[group][endpoint]({
+          const groupClient = groups[group].topLevel ? client : client[group]
+          const effect = catchErrors(groupClient[endpoint]({
             ...opts,
             responseMode
           }) as Effect.Effect<any>)
@@ -261,7 +263,8 @@ export const Service =
     const queryFamily = Atom.family((opts: QueryKey) => {
       let atom = self.runtime.atom(self.use((client_) => {
         const client = client_ as any
-        return catchErrors(client[opts.group][opts.endpoint](opts) as Effect.Effect<
+        const groupClient = groups[opts.group].topLevel ? client : client[opts.group]
+        return catchErrors(groupClient[opts.endpoint](opts) as Effect.Effect<
           any,
           HttpClientError.HttpClientError | SchemaError
         >)
@@ -296,6 +299,7 @@ export const Service =
         readonly payload?: any
         readonly headers?: any
         readonly responseMode?: HttpApiEndpoint.ClientResponseMode
+        readonly sseOptions?: Sse.DecodeOptions | undefined
         readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
         readonly timeToLive?: Duration.Input | undefined
         readonly serializationKey?: string | undefined
@@ -309,8 +313,9 @@ export const Service =
         payload: request.payload,
         headers: request.headers,
         responseMode: request.responseMode ?? "decoded-only",
+        sseOptions: request.sseOptions,
         reactivityKeys: request.reactivityKeys,
-        timeToLive: request.timeToLive
+        timeToLive: request.timeToLive !== undefined
           ? Duration.fromInputUnsafe(request.timeToLive)
           : undefined,
         serializationKey: request.serializationKey
@@ -336,14 +341,20 @@ interface QueryKey {
   payload: any
   responseMode: HttpApiEndpoint.ClientResponseMode
   reactivityKeys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
+  sseOptions: Sse.DecodeOptions | undefined
   timeToLive: Duration.Duration | undefined
   serializationKey: string | undefined
 }
 
-type ResponseByMode<Success, ResponseMode extends HttpApiEndpoint.ClientResponseMode> = [ResponseMode] extends
-  ["decoded-and-response"] ? [Success, HttpClientResponse]
-  : [ResponseMode] extends ["response-only"] ? HttpClientResponse
-  : Success
+type ResponseByMode<
+  Endpoint extends HttpApiEndpoint.Constraint,
+  ResponseMode extends HttpApiEndpoint.ClientResponseMode
+> = HttpApiClient.Client.Response<
+  Effect.Success<
+    ReturnType<HttpApiClient.Client.Method<Extract<Endpoint, HttpApiEndpoint.ConstraintRequest>, never, never>>
+  >,
+  ResponseMode
+>
 
 type ErrorByMode<
   Error extends Schema.Constraint,

package/src/unstable/reactivity/AtomRegistry.ts

@@ -913,12 +913,10 @@ class NodeImpl<A> {
     this.state = NodeState.removed
     this.listeners.clear()
 
-    if (this.lifetime === undefined) {
-      return
+    if (this.lifetime !== undefined) {
+      this.disposeLifetime()
     }
 
-    this.disposeLifetime()
-
     if (this.previousParents === undefined) {
       return
     }

package/src/unstable/reactivity/AtomRpc.ts

@@ -73,7 +73,7 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any> ex
         readonly headers?: Headers.Input | undefined
       },
       _Success["Type"],
-      _Error["Type"] | RpcClientError | _Middleware["error"]["Type"]
+      _Error["Type"] | RpcClientError | _Middleware["error"]["Type"] | _Middleware["~ClientError"]
     >
     : never
 
@@ -94,18 +94,19 @@ export interface AtomRpcClient<Self, Id extends string, Rpcs extends Rpc.Any> ex
     infer _Payload,
     infer _Success,
     infer _Error,
-    infer _Middleware
+    infer _Middleware,
+    infer _Requires
   > ? [_Success] extends [RpcSchema.Stream<infer _A, infer _E>] ? Atom.Writable<
         Atom.PullResult<
           _A["Type"],
-          _E["Type"] | _Error["Type"] | RpcClientError | _Middleware["error"]["Type"]
+          _E["Type"] | _Error["Type"] | RpcClientError | _Middleware["error"]["Type"] | _Middleware["~ClientError"]
         >,
         void
       >
     : Atom.Atom<
       AsyncResult.AsyncResult<
         _Success["Type"],
-        _Error["Type"] | RpcClientError | _Middleware["error"]["Type"]
+        _Error["Type"] | RpcClientError | _Middleware["error"]["Type"] | _Middleware["~ClientError"]
       >
     >
     : never
@@ -275,7 +276,7 @@ export const Service = <Self>() =>
         ? Headers.fromInput(options.headers)
         : undefined,
       reactivityKeys: options?.reactivityKeys,
-      timeToLive: options?.timeToLive
+      timeToLive: options?.timeToLive !== undefined
         ? Duration.fromInputUnsafe(options.timeToLive)
         : undefined,
       serializationKey: options?.serializationKey

package/src/unstable/reactivity/Hydration.ts

@@ -10,6 +10,7 @@
  *
  * @since 4.0.0
  */
+import * as Schema from "../../Schema.ts"
 import * as AsyncResult from "./AsyncResult.ts"
 import * as Atom from "./Atom.ts"
 import type * as AtomRegistry from "./AtomRegistry.ts"
@@ -21,7 +22,7 @@ import type * as AtomRegistry from "./AtomRegistry.ts"
  * @since 4.0.0
  */
 export interface DehydratedAtom {
-  readonly "~effect/reactivity/DehydratedAtom": true
+  readonly "~effect/reactivity/Hydration/DehydratedAtom": true
 }
 
 /**
@@ -43,15 +44,31 @@ export interface DehydratedAtomValue extends DehydratedAtom {
   readonly resultPromise?: Promise<unknown> | undefined
 }
 
+const Skipped = Symbol.for("effect/reactivity/Hydration/Skipped")
+
+const encodeOrSkip = (
+  atom: Atom.Atom<any> & Atom.Serializable<any>,
+  value: unknown
+): unknown => {
+  try {
+    return atom[Atom.SerializableTypeId].encode(value)
+  } catch (error) {
+    if (Schema.isSchemaError(error)) return Skipped
+    throw error
+  }
+}
+
 /**
  * Encodes the serializable atoms currently stored in a registry into dehydrated
  * state.
  *
  * **Details**
  *
- * Only atoms marked with `Atom.serializable` are included. `encodeInitialAs`
- * controls whether `AsyncResult.Initial` values are ignored, encoded as values, or
- * represented by promises that resolve when the atom leaves the initial state.
+ * Only atoms marked with `Atom.serializable` whose current values can be encoded
+ * are included. Atoms that fail schema encoding are skipped without throwing.
+ * `encodeInitialAs` controls whether `AsyncResult.Initial` values are ignored,
+ * encoded as values, or represented by promises that resolve when the atom
+ * leaves the initial state.
  *
  * @category dehydration
  * @since 4.0.0
@@ -74,7 +91,8 @@ export const dehydrate = (
     const value = node.value()
     const isInitial = AsyncResult.isAsyncResult(value) && AsyncResult.isInitial(value)
     if (encodeInitialResultMode === "ignore" && isInitial) return
-    const encodedValue = atom[Atom.SerializableTypeId].encode(value)
+    const encodedValue = encodeOrSkip(atom, value)
+    if (encodedValue === Skipped) return
 
     // Create a promise that resolves when the atom moves out of Initial state
     let resultPromise: Promise<unknown> | undefined
@@ -82,15 +100,15 @@ export const dehydrate = (
       resultPromise = new Promise((resolve) => {
         const unsubscribe = registry.subscribe(atom, (newValue) => {
           if (AsyncResult.isAsyncResult(newValue) && !AsyncResult.isInitial(newValue)) {
-            resolve(atom[Atom.SerializableTypeId].encode(newValue))
             unsubscribe()
+            resolve(encodeOrSkip(atom, newValue))
           }
         })
       })
     }
 
     arr.push({
-      "~effect/reactivity/DehydratedAtom": true,
+      "~effect/reactivity/Hydration/DehydratedAtom": true,
       key: key as string,
       value: encodedValue,
       dehydratedAt: now,
@@ -136,6 +154,7 @@ export const hydrate = (
     // and we should wait for it to resolve to a non-Initial state, then update the registry
     if (!datom.resultPromise) continue
     datom.resultPromise.then((resolvedValue) => {
+      if (resolvedValue === Skipped) return
       // Try to update the existing node directly instead of using setSerializable
       const nodes = registry.getNodes()
       const node = nodes.get(datom.key)

package/src/unstable/reactivity/Reactivity.ts

@@ -22,48 +22,59 @@ import * as Scope from "../../Scope.ts"
 import * as Stream from "../../Stream.ts"
 
 /**
- * Service for key-based reactive invalidation.
+ * Brand type for `Reactivity`.
  *
- * **When to use**
- *
- * Use to provide the invalidation service that refreshes queries, streams, and
- * atoms when application keys change.
+ * @category type IDs
+ * @since 4.0.0
+ */
+export type TypeId = "~effect/reactivity/Reactivity"
+
+/**
+ * Brand for `Reactivity` implementations.
  *
- * **Details**
+ * @category type IDs
+ * @since 4.0.0
+ */
+export const TypeId: TypeId = "~effect/reactivity/Reactivity"
+
+/**
+ * Registers handlers and reruns queries when their keys are invalidated.
  *
- * The service can register handlers for keys, invalidate those keys, wrap
- * mutations so successful effects invalidate keys, and turn query effects into
- * queues or streams that rerun when keys are invalidated.
+ * @category models
+ * @since 4.0.0
+ */
+export interface Reactivity {
+  readonly [TypeId]: TypeId
+  readonly invalidateUnsafe: (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) => void
+  readonly registerUnsafe: (
+    keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>,
+    handler: () => void
+  ) => () => void
+  readonly invalidate: (
+    keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>
+  ) => Effect.Effect<void>
+  readonly mutation: <A, E, R>(
+    keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>,
+    effect: Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E, R>
+  readonly query: <A, E, R>(
+    keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>,
+    effect: Effect.Effect<A, E, R>
+  ) => Effect.Effect<Queue.Dequeue<A, E>, never, R | Scope.Scope>
+  readonly stream: <A, E, R>(
+    keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>,
+    effect: Effect.Effect<A, E, R>
+  ) => Stream.Stream<A, E, Exclude<R, Scope.Scope>>
+  readonly withBatch: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+}
+
+/**
+ * Service key for reactive invalidation.
  *
  * @category services
  * @since 4.0.0
  */
-export class Reactivity extends Context.Service<
-  Reactivity,
-  {
-    readonly invalidateUnsafe: (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) => void
-    readonly registerUnsafe: (
-      keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>,
-      handler: () => void
-    ) => () => void
-    readonly invalidate: (
-      keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>
-    ) => Effect.Effect<void>
-    readonly mutation: <A, E, R>(
-      keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>,
-      effect: Effect.Effect<A, E, R>
-    ) => Effect.Effect<A, E, R>
-    readonly query: <A, E, R>(
-      keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>,
-      effect: Effect.Effect<A, E, R>
-    ) => Effect.Effect<Queue.Dequeue<A, E>, never, R | Scope.Scope>
-    readonly stream: <A, E, R>(
-      keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>,
-      effect: Effect.Effect<A, E, R>
-    ) => Stream.Stream<A, E, Exclude<R, Scope.Scope>>
-    readonly withBatch: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  }
->()("effect/reactivity/Reactivity") {}
+export const Reactivity: Context.Service<Reactivity, Reactivity> = Context.Service("effect/reactivity/Reactivity")
 
 /**
  * Creates an in-memory `Reactivity` service.
@@ -123,7 +134,8 @@ export const make = Effect.sync(() => {
     })
     return () => {
       for (let i = 0; i < resolvedKeys.length; i++) {
-        const set = handlers.get(resolvedKeys[i])!
+        const set = handlers.get(resolvedKeys[i])
+        if (set === undefined) continue
         set.delete(handler)
         if (set.size === 0) {
           handlers.delete(resolvedKeys[i])
@@ -201,6 +213,7 @@ export const make = Effect.sync(() => {
     })
 
   return Reactivity.of({
+    [TypeId]: TypeId,
     mutation,
     query,
     stream,