effect 4.0.0-beta.103 → 4.0.0-beta.104

package/src/SchemaAST.ts

@@ -532,7 +532,7 @@ export const defaultParseOptions: ParseOptions = {}
  *
  * - `isOptional` — the property key may be absent from the input.
  * - `isMutable` — the property is `readonly` when `false`.
- * - `defaultValue` — an {@link Encoding} applied during construction to
+ * - `constructorDefault` — a {@link Link} applied during construction to
  *   supply missing values.
  * - `annotations` — key-level annotations (e.g. description of the key
  *   itself).
@@ -546,19 +546,19 @@ export class Context {
   readonly isOptional: boolean
   readonly isMutable: boolean
   /** Used for constructor default values (e.g. `withConstructorDefault` API) */
-  readonly defaultValue: Encoding | undefined
+  readonly constructorDefault: Link | undefined
   readonly annotations: Schema.Annotations.Key<unknown> | undefined
 
   constructor(
     isOptional: boolean,
     isMutable: boolean,
     /** Used for constructor default values (e.g. `withConstructorDefault` API) */
-    defaultValue: Encoding | undefined = undefined,
+    constructorDefault: Link | undefined = undefined,
     annotations: Schema.Annotations.Key<unknown> | undefined = undefined
   ) {
     this.isOptional = isOptional
     this.isMutable = isMutable
-    this.defaultValue = defaultValue
+    this.constructorDefault = constructorDefault
     this.annotations = annotations
   }
 }
@@ -1141,8 +1141,8 @@ export class TemplateLiteral extends Base {
     this.suffixLengths = suffixLengths
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
-    const parser = recur(this.asTemplateLiteralParser())
+  getParser(compile: SchemaParser.Compiler): SchemaParser.Parser {
+    const parser = compile(this.asTemplateLiteralParser())
     return (input, options) => {
       if (input === InternalParser.missing) return InternalParser.missingExit
       const result = parser(input, options)
@@ -1684,7 +1684,10 @@ export class Arrays extends Base {
     }
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
+  getParser(
+    compile: SchemaParser.Compiler,
+    compileConstructorDefault: SchemaParser.Compiler = compile
+  ): SchemaParser.Parser {
     // oxlint-disable-next-line @typescript-eslint/no-this-alias
     const ast = this
     type ElementParser = { readonly ast: AST; readonly parser: SchemaParser.Parser }
@@ -1715,8 +1718,8 @@ export class Arrays extends Base {
         return yield* Effect.fail(new SchemaIssue.InvalidType(ast))
       }
       if (!elements) {
-        elements = ast.elements.map((ast) => ({ ast, parser: recur(ast) }))
-        rest = ast.rest.map((ast) => ({ ast, parser: recur(ast) }))
+        elements = ast.elements.map((ast) => ({ ast, parser: compileConstructorDefault(ast) }))
+        rest = ast.rest.map((ast) => ({ ast, parser: compileConstructorDefault(ast) }))
       }
 
       const len = input.length
@@ -2076,7 +2079,10 @@ export class Objects extends Base {
     }
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
+  getParser(
+    compile: SchemaParser.Compiler,
+    compileConstructorDefault: SchemaParser.Compiler = compile
+  ): SchemaParser.Parser {
     // oxlint-disable-next-line @typescript-eslint/no-this-alias
     const ast = this
     const expectedKeys: Array<PropertyKey> = []
@@ -2175,15 +2181,15 @@ export class Objects extends Base {
       }
       if (!properties) {
         properties = ast.propertySignatures.map((ps) => ({
-          parser: recur(ps.type),
+          parser: compileConstructorDefault(ps.type),
           name: ps.name,
           type: ps.type
         }))
         indexes = indexCount
           ? ast.indexSignatures.map((is) => ({
             is,
-            parserKey: recur(parameterFromPropertyKey(is.parameter)),
-            parserValue: recur(is.type)
+            parserKey: compile(parameterFromPropertyKey(is.parameter)),
+            parserValue: compileConstructorDefault(is.type)
           }))
           : undefined
       }
@@ -2577,7 +2583,7 @@ export function collectSentinels(ast: AST): Array<Sentinel> {
 }
 
 type CandidateIndex =
-  | ((input: any) => ReadonlyArray<AST>)
+  | ((input: any, isConstructor: boolean) => ReadonlyArray<AST>)
   | {
     bySentinel?: Map<PropertyKey, Map<LiteralValue | symbol, Array<number>>>
     otherwise?: { [K in Type]?: Array<number> }
@@ -2636,10 +2642,14 @@ function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
       for (const [literal, indexes] of byValue) {
         candidates.set(literal, Object.freeze(indexes.map((index) => types[index])))
       }
-      idx = (input) =>
-        Predicate.isObjectKeyword(input) && Object.hasOwn(input, key)
-          ? candidates.get((input as any)[key]) ?? emptyCandidates
-          : emptyCandidates
+      idx = (input, isConstructor) => {
+        if (Predicate.isObjectKeyword(input)) {
+          const value = Object.hasOwn(input, key) ? (input as any)[key] : undefined
+          if (value !== undefined) return candidates.get(value) ?? emptyCandidates
+          if (isConstructor) return types
+        }
+        return emptyCandidates
+      }
     }
   }
 
@@ -2664,9 +2674,13 @@ function filterLiterals(input: any) {
  *
  * @internal
  */
-export function getCandidates(input: any, types: ReadonlyArray<AST>): ReadonlyArray<AST> {
+export function getCandidates(
+  input: any,
+  types: ReadonlyArray<AST>,
+  isConstructor = false
+): ReadonlyArray<AST> {
   const idx = getIndex(types)
-  if (typeof idx === "function") return idx(input)
+  if (typeof idx === "function") return idx(input, isConstructor)
 
   const runtimeType: Type = input === null ? "null" : Array.isArray(input) ? "array" : typeof input
 
@@ -2676,11 +2690,16 @@ export function getCandidates(input: any, types: ReadonlyArray<AST>): ReadonlyAr
     if (Predicate.isObjectKeyword(input)) {
       const selected = new Set(base)
       for (const [k, m] of idx.bySentinel) {
-        if (Object.hasOwn(input, k)) {
-          const match = m.get((input as any)[k])
+        const value = Object.hasOwn(input, k) ? (input as any)[k] : undefined
+        if (value !== undefined) {
+          const match = m.get(value)
           if (match) {
             for (const candidate of match) selected.add(candidate)
           }
+        } else if (isConstructor) {
+          for (const indexes of m.values()) {
+            for (const candidate of indexes) selected.add(candidate)
+          }
         }
       }
       return Array.from(selected).sort((a, b) => a - b).map((i) => types[i])
@@ -2743,7 +2762,10 @@ export class Union<A extends AST = AST> extends Base {
     this.encodingChecks = encodingChecks
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
+  getParser(
+    compile: SchemaParser.Compiler,
+    compileConstructorDefault?: SchemaParser.Compiler
+  ): SchemaParser.Parser {
     // oxlint-disable-next-line @typescript-eslint/no-this-alias
     const ast = this
 
@@ -2751,10 +2773,10 @@ export class Union<A extends AST = AST> extends Base {
       if (input === InternalParser.missing) {
         return InternalParser.missingExit
       }
-      const candidates = getCandidates(input, ast.types)
+      const candidates = getCandidates(input, ast.types, compileConstructorDefault !== undefined)
 
       if (candidates.length === 1) {
-        const result = recur(candidates[0])(input, options)
+        const result = compile(candidates[0])(input, options)
         if ((result as Exit.Exit<unknown, SchemaIssue.Issue>)._tag === "Success") return result
         return effectIsExit(result)
           ? failSingleUnionCandidate(ast, (result as Exit.Failure<unknown, SchemaIssue.Issue>).cause)
@@ -2763,7 +2785,7 @@ export class Union<A extends AST = AST> extends Base {
 
       const state = {
         ast,
-        recur,
+        compile,
         input,
         out: undefined,
         successes: ast.mode === "oneOf" ? [] : undefined,
@@ -2854,7 +2876,7 @@ function failSingleUnionCandidate(
 }
 
 const parseUnion = iterateEager<{
-  readonly recur: (ast: AST) => SchemaParser.Parser
+  readonly compile: (ast: AST) => SchemaParser.Parser
   readonly ast: Union
   readonly input: unknown
   readonly options: ParseOptions
@@ -2863,7 +2885,7 @@ const parseUnion = iterateEager<{
   issues: Array<SchemaIssue.Issue> | undefined
 }, AST>()({
   onItem(s, ast) {
-    const parser = s.recur(ast)
+    const parser = s.compile(ast)
     return parser(s.input, s.options)
   },
   step(s, candidate, exit) {
@@ -2966,9 +2988,9 @@ export class Suspend extends Base {
     this.thunk = memoizeThunk(thunk)
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
+  getParser(compile: SchemaParser.Compiler): SchemaParser.Parser {
     let parser: SchemaParser.Parser
-    return (input, options) => (parser ??= recur(this.thunk()))(input, options)
+    return (input, options) => (parser ??= compile(this.thunk()))(input, options)
   }
   /** @internal */
   recur(recur: (ast: AST) => AST) {
@@ -3364,7 +3386,7 @@ export function annotateKey<A extends AST>(ast: A, annotations: Schema.Annotatio
     new Context(
       ast.context.isOptional,
       ast.context.isMutable,
-      ast.context.defaultValue,
+      ast.context.constructorDefault,
       { ...ast.context.annotations, ...annotations }
     ) :
     new Context(false, false, undefined, annotations)
@@ -3390,7 +3412,7 @@ const optionalKeyLastLink = applyToLastLink(optionalKey)
 export function optionalKey<A extends AST>(ast: A): A {
   const context = ast.context ?
     ast.context.isOptional === false ?
-      new Context(true, ast.context.isMutable, ast.context.defaultValue, ast.context.annotations) :
+      new Context(true, ast.context.isMutable, ast.context.constructorDefault, ast.context.annotations) :
       ast.context :
     new Context(true, false)
   return optionalKeyLastLink(replaceContext(ast, context))
@@ -3402,7 +3424,7 @@ const mutableKeyLastLink = applyToLastLink(mutableKey)
 export function mutableKey<A extends AST>(ast: A): A {
   const context = ast.context ?
     ast.context.isMutable === false ?
-      new Context(ast.context.isOptional, true, ast.context.defaultValue, ast.context.annotations) :
+      new Context(ast.context.isOptional, true, ast.context.constructorDefault, ast.context.annotations) :
       ast.context :
     new Context(false, true)
   return mutableKeyLastLink(replaceContext(ast, context))
@@ -3417,10 +3439,10 @@ export function withConstructorDefault<A extends AST>(
     SchemaGetter.withDefault(defaultValue),
     SchemaGetter.passthrough()
   )
-  const encoding: Encoding = [new Link(unknown, transformation)]
+  const constructorDefault = new Link(unknown, transformation)
   const context = ast.context ?
-    new Context(ast.context.isOptional, ast.context.isMutable, encoding, ast.context.annotations) :
-    new Context(false, false, encoding)
+    new Context(ast.context.isOptional, ast.context.isMutable, constructorDefault, ast.context.annotations) :
+    new Context(false, false, constructorDefault)
   return replaceContext(ast, context)
 }
 
@@ -3949,7 +3971,17 @@ export function runChecks<T>(
 }
 
 /** @internal */
-export const ClassTypeId = "~effect/Schema/Class"
+export interface ConstructorDescriptor {
+  readonly isConstructed: Predicate.Predicate<unknown>
+  readonly link: Link
+}
+
+/** @internal */
+export function getConstructorDescriptor(ast: AST): ConstructorDescriptor | undefined {
+  if (!isDeclaration(ast)) return undefined
+  const getDescriptor = ast.annotations?.[InternalAnnotations.CONSTRUCTOR_ANNOTATION_KEY]
+  return Predicate.isFunction(getDescriptor) ? getDescriptor(ast.typeParameters) : undefined
+}
 
 /**
  * Returns all annotations from the AST node.

package/src/SchemaParser.ts

@@ -18,41 +18,11 @@ import { effectIsExit } from "./internal/effect.ts"
 import * as InternalSchemaCause from "./internal/schema/cause.ts"
 import * as InternalParser from "./internal/schema/parser.ts"
 import * as Option from "./Option.ts"
-import * as Predicate from "./Predicate.ts"
 import * as Result from "./Result.ts"
 import type * as Schema from "./Schema.ts"
 import * as SchemaAST from "./SchemaAST.ts"
 import * as SchemaIssue from "./SchemaIssue.ts"
 
-// Converts a type-side AST into its constructor form by recursively restoring
-// constructor encodings for nested classes and fields with constructor defaults.
-const toConstructorAST = memoize((ast: SchemaAST.AST): SchemaAST.AST => {
-  switch (ast._tag) {
-    case "Declaration": {
-      const getLink = ast.annotations?.[SchemaAST.ClassTypeId]
-      if (Predicate.isFunction(getLink)) {
-        const link = getLink(ast.typeParameters)
-        return SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, toConstructorAST)])
-      }
-      return ast
-    }
-    case "Objects":
-    case "Arrays":
-      return ast.recur((ast) => {
-        const defaultValue = ast.context?.defaultValue
-        if (defaultValue) {
-          const out = toConstructorAST(ast)
-          return SchemaAST.replaceEncoding(out, out.encoding ? [...out.encoding, ...defaultValue] : defaultValue)
-        }
-        return toConstructorAST(ast)
-      })
-    case "Suspend":
-      return ast.recur(toConstructorAST)
-    default:
-      return ast
-  }
-})
-
 /**
  * Creates an effectful maker for the schema's decoded type side.
  *
@@ -71,8 +41,7 @@ const toConstructorAST = memoize((ast: SchemaAST.AST): SchemaAST.AST => {
  * @since 4.0.0
  */
 export function makeEffect<S extends Schema.Constraint>(schema: S) {
-  const ast = toConstructorAST(SchemaAST.toType(schema.ast))
-  const parser = run<S["Type"], never>(ast)
+  const parser = runWithCompiler<S["Type"], never>(constructorCompiler, SchemaAST.toType(schema.ast))
   return (input: S["~type.make.in"], options?: Schema.MakeOptions): Effect.Effect<S["Type"], SchemaIssue.Issue> => {
     return parser(
       input,
@@ -923,9 +892,13 @@ const getValue = (value: unknown): Effect.Effect<any, SchemaIssue.Issue> => {
 
 /** @internal */
 export function run<T, R>(ast: SchemaAST.AST) {
+  return runWithCompiler<T, R>(normalCompiler, ast)
+}
+
+function runWithCompiler<T, R>(compiler: Compiler, ast: SchemaAST.AST) {
   let parser: Parser
   return (input: unknown, options?: SchemaAST.ParseOptions): Effect.Effect<T, SchemaIssue.Issue, R> => {
-    const result = (parser ??= compile(ast))(
+    const result = (parser ??= compiler(ast))(
       input,
       options ?? SchemaAST.defaultParseOptions
     )
@@ -1016,20 +989,79 @@ export interface Parser {
   ): Effect.Effect<unknown, SchemaIssue.Issue, any>
 }
 
-const parserCache = new WeakMap<SchemaAST.AST, Parser>()
+/** @internal */
+export interface Compiler {
+  (ast: SchemaAST.AST): Parser
+}
+
+const normalCompiler: Compiler = memoize((ast) => makeParser(ast, normalCompiler))
+const constructorCompiler: Compiler = memoize((ast) => makeParser(ast, constructorCompiler, compileConstructorDefault))
+const compileDefaulted = memoize((ast: SchemaAST.AST) =>
+  makeParser(ast, constructorCompiler, compileConstructorDefault, ast.context?.constructorDefault)
+)
+
+function compileConstructorDefault(ast: SchemaAST.AST): Parser {
+  return ast.context?.constructorDefault ? compileDefaulted(ast) : constructorCompiler(ast)
+}
 
-function compile(ast: SchemaAST.AST): Parser {
-  let parser = parserCache.get(ast)
-  if (!parser) {
-    parserCache.set(ast, parser = makeParser(ast))
+function applyTransformation(
+  result: Effect.Effect<unknown, SchemaIssue.Issue, unknown>,
+  current: unknown,
+  transformation: SchemaAST.Link["transformation"],
+  options: SchemaAST.ParseOptions
+): Effect.Effect<unknown, SchemaIssue.Issue, unknown> {
+  let transformed: Effect.Effect<Option.Option<unknown>, SchemaIssue.Issue, unknown>
+  if (effectIsExit(result) && result._tag === "Success") {
+    const optional = InternalParser.toOption(
+      result === InternalParser.sameExit
+        ? current
+        : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+    )
+    transformed = transformation._tag === "Transformation"
+      ? transformation.decode.run(optional, options)
+      : transformation.decode(InternalParser.succeed(optional), options)
+  } else if (transformation._tag === "Transformation") {
+    transformed = Effect.flatMapEager(
+      result,
+      (value) => transformation.decode.run(InternalParser.toOption(value), options)
+    )
+  } else {
+    transformed = transformation.decode(
+      Effect.mapEager(result, InternalParser.toOption),
+      options
+    )
   }
-  return parser
+  return effectIsExit(transformed) && transformed._tag === "Success"
+    ? InternalParser.fromOptionExit(
+      (transformed as InternalParser.Success<Option.Option<unknown>, SchemaIssue.Issue>)[InternalParser.args]
+    )
+    : Effect.flatMapEager(transformed, InternalParser.fromOptionExit)
 }
 
-function makeParser(ast: SchemaAST.AST): Parser {
-  const parser = ast.getParser(compile)
+function makeConstructorParser(descriptor: SchemaAST.ConstructorDescriptor, compile: Compiler): Parser {
+  let sourceParser: Parser
+  return (input, options) => {
+    if (input === InternalParser.missing) return InternalParser.missingExit
+    if (descriptor.isConstructed(input)) return InternalParser.sameExit
+    const result = (sourceParser ??= compile(descriptor.link.to))(input, options)
+    return applyTransformation(result, input, descriptor.link.transformation, options)
+  }
+}
+
+function makeParser(
+  ast: SchemaAST.AST,
+  compile: Compiler,
+  compileConstructorDefault?: Compiler,
+  constructorDefault?: SchemaAST.Link
+): Parser {
+  const descriptor = compileConstructorDefault ? SchemaAST.getConstructorDescriptor(ast) : undefined
+  const parser = descriptor
+    ? makeConstructorParser(descriptor, compile)
+    : ast.getParser(compile, compileConstructorDefault)
   const checks = ast.checks
-  const links = ast.encoding
+  const links = constructorDefault
+    ? ast.encoding ? [...ast.encoding, constructorDefault] : [constructorDefault]
+    : ast.encoding
   const encodingChecks = (ast as any).encodingChecks
   const astOptions = (checks ? checks[checks.length - 1].annotations : ast.annotations)
     ?.["parseOptions"]
@@ -1122,33 +1154,7 @@ function makeParser(ast: SchemaAST.AST): Parser {
     let current = input
     let result = parsers[parsers.length - 1](input, options)
     for (let i = links.length - 1; i >= 0; i--) {
-      const transformation = links[i].transformation
-      let transformed: Effect.Effect<Option.Option<unknown>, SchemaIssue.Issue, unknown>
-      if (effectIsExit(result) && result._tag === "Success") {
-        const optional = InternalParser.toOption(
-          result === InternalParser.sameExit
-            ? current
-            : (result as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
-        )
-        transformed = transformation._tag === "Transformation"
-          ? transformation.decode.run(optional, options)
-          : transformation.decode(InternalParser.succeed(optional), options)
-      } else if (transformation._tag === "Transformation") {
-        transformed = Effect.flatMapEager(
-          result,
-          (value) => transformation.decode.run(InternalParser.toOption(value), options)
-        )
-      } else {
-        transformed = transformation.decode(
-          Effect.mapEager(result, InternalParser.toOption),
-          options
-        )
-      }
-      result = effectIsExit(transformed) && transformed._tag === "Success"
-        ? InternalParser.fromOptionExit(
-          (transformed as InternalParser.Success<Option.Option<unknown>, SchemaIssue.Issue>)[InternalParser.args]
-        )
-        : Effect.flatMapEager(transformed, InternalParser.fromOptionExit)
+      result = applyTransformation(result, current, links[i].transformation, options)
       if (i !== 0) {
         const next = parsers[i - 1]
         if ((result as Exit.Exit<unknown, unknown>)._tag === "Success") {

package/src/ScopedCache.ts

@@ -211,7 +211,7 @@ export const make = <
 > =>
   makeWith<Key, A, E, R, ServiceMode>({
     ...options,
-    timeToLive: options.timeToLive ? () => options.timeToLive! : defaultTimeToLive
+    timeToLive: options.timeToLive !== undefined ? () => options.timeToLive! : defaultTimeToLive
   })
 
 const Proto = {

package/src/Sink.ts

@@ -2529,7 +2529,7 @@ export const catchCause: {
 const catch_: {
   <E, A2, E2, R2>(
     f: (error: Types.NoInfer<E>) => Effect.Effect<A2, E2, R2>
-  ): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A2 | A, In, L, E, R2 | R>
+  ): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A2 | A, In, L, E2, R2 | R>
   <A, In, L, E, R, A2, E2, R2>(
     self: Sink<A, In, L, E, R>,
     f: (error: E) => Effect.Effect<A2, E2, R2>

package/src/Stream.ts

@@ -9657,6 +9657,13 @@ const retryWithoutReset = <A, E, R, X, E2, R2>(
  * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
  * a later fallback.
  *
+ * Attempts can be observed from outside the stream by passing
+ * `options.onEvent`, which receives an `ExecutionPlan.Event` before each
+ * attempt and after it settles; see `Effect.withExecutionPlan` for the handler
+ * semantics. When a downstream consumer stops pulling early (for example
+ * `Stream.take` outside the plan), the truncated attempt reports
+ * `AttemptSuccess`: the consumer stopped, not the source.
+ *
  * **Example** (Applying an execution plan)
  *
  * ```ts import.meta.vitest
@@ -9700,6 +9707,13 @@ export const withExecutionPlan: {
    * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
    * a later fallback.
    *
+   * Attempts can be observed from outside the stream by passing
+   * `options.onEvent`, which receives an `ExecutionPlan.Event` before each
+   * attempt and after it settles; see `Effect.withExecutionPlan` for the handler
+   * semantics. When a downstream consumer stops pulling early (for example
+   * `Stream.take` outside the plan), the truncated attempt reports
+   * `AttemptSuccess`: the consumer stopped, not the source.
+   *
    * **Example** (Applying an execution plan)
    *
    * ```ts import.meta.vitest
@@ -9732,10 +9746,13 @@ export const withExecutionPlan: {
    * @category error handling
    * @since 3.16.0
    */
-  <Input, R2, Provides, PolicyE>(
+  <Input, R2, Provides, PolicyE, RX = never>(
     policy: ExecutionPlan.ExecutionPlan<{ provides: Provides; input: Input; error: PolicyE; requirements: R2 }>,
-    options?: { readonly preventFallbackOnPartialStream?: boolean | undefined }
-  ): <A, E extends Input, R>(self: Stream<A, E, R>) => Stream<A, E | PolicyE, R2 | Exclude<R, Provides>>
+    options?: {
+      readonly preventFallbackOnPartialStream?: boolean | undefined
+      readonly onEvent?: ((event: ExecutionPlan.Event<Input | PolicyE>) => Effect.Effect<void, never, RX>) | undefined
+    }
+  ): <A, E extends Input, R>(self: Stream<A, E, R>) => Stream<A, E | PolicyE, R2 | Exclude<R, Provides> | RX>
   /**
    * Applies an `ExecutionPlan` to a stream, retrying with step-provided resources
    * until it succeeds or the plan is exhausted.
@@ -9746,6 +9763,13 @@ export const withExecutionPlan: {
    * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
    * a later fallback.
    *
+   * Attempts can be observed from outside the stream by passing
+   * `options.onEvent`, which receives an `ExecutionPlan.Event` before each
+   * attempt and after it settles; see `Effect.withExecutionPlan` for the handler
+   * semantics. When a downstream consumer stops pulling early (for example
+   * `Stream.take` outside the plan), the truncated attempt reports
+   * `AttemptSuccess`: the consumer stopped, not the source.
+   *
    * **Example** (Applying an execution plan)
    *
    * ```ts import.meta.vitest
@@ -9778,12 +9802,15 @@ export const withExecutionPlan: {
    * @category error handling
    * @since 3.16.0
    */
-  <A, E extends Input, R, R2, Input, Provides, PolicyE>(
+  <A, E extends Input, R, R2, Input, Provides, PolicyE, RX = never>(
     self: Stream<A, E, R>,
     policy: ExecutionPlan.ExecutionPlan<{ provides: Provides; input: Input; error: PolicyE; requirements: R2 }>,
-    options?: { readonly preventFallbackOnPartialStream?: boolean | undefined }
-  ): Stream<A, E | PolicyE, R2 | Exclude<R, Provides>>
-} = dual((args) => isStream(args[0]), <A, E extends Input, R, R2, Input, Provides, PolicyE>(
+    options?: {
+      readonly preventFallbackOnPartialStream?: boolean | undefined
+      readonly onEvent?: ((event: ExecutionPlan.Event<E | PolicyE>) => Effect.Effect<void, never, RX>) | undefined
+    }
+  ): Stream<A, E | PolicyE, R2 | Exclude<R, Provides> | RX>
+} = dual((args) => isStream(args[0]), <A, E extends Input, R, R2, Input, Provides, PolicyE, RX>(
   self: Stream<A, E, R>,
   policy: ExecutionPlan.ExecutionPlan<{
     provides: Provides
@@ -9793,8 +9820,9 @@ export const withExecutionPlan: {
   }>,
   options?: {
     readonly preventFallbackOnPartialStream?: boolean | undefined
+    readonly onEvent?: ((event: ExecutionPlan.Event<E | PolicyE>) => Effect.Effect<void, never, RX>) | undefined
   }
-): Stream<A, E | PolicyE, R2 | Exclude<R, Provides>> =>
+): Stream<A, E | PolicyE, R2 | Exclude<R, Provides> | RX> =>
   suspend(() => {
     const preventFallbackOnPartialStream = options?.preventFallbackOnPartialStream ?? false
     let i = 0
@@ -9812,6 +9840,28 @@ export const withExecutionPlan: {
         return meta
       })
     )
+    const emitter = options?.onEvent === undefined
+      ? undefined
+      : internalExecutionPlan.makeEventEmitter(options.onEvent, () => meta)
+    let attemptState: internalExecutionPlan.AttemptState | undefined
+    const instrument: (attempt: Stream<A, E | PolicyE, any>) => Stream<A, E | PolicyE, any> = emitter === undefined
+      ? identity
+      : (attempt) =>
+        onExit(
+          onStart(
+            attempt,
+            Effect.map(emitter.begin, (state) => {
+              attemptState = state
+            })
+          ),
+          (exit) =>
+            Effect.suspend(() => {
+              if (attemptState === undefined) return Effect.void
+              const state = attemptState
+              attemptState = undefined
+              return emitter.end(state, exit)
+            })
+        )
     let lastError = Option.none</**
      * Applies an `ExecutionPlan` to a stream, retrying with step-provided resources
      * until it succeeds or the plan is exhausted.
@@ -9822,6 +9872,13 @@ export const withExecutionPlan: {
      * `preventFallbackOnPartialStream` to fail instead of mixing partial output with
      * a later fallback.
      *
+     * Attempts can be observed from outside the stream by passing
+     * `options.onEvent`, which receives an `ExecutionPlan.Event` before each
+     * attempt and after it settles; see `Effect.withExecutionPlan` for the handler
+     * semantics. When a downstream consumer stops pulling early (for example
+     * `Stream.take` outside the plan), the truncated attempt reports
+     * `AttemptSuccess`: the consumer stopped, not the source.
+     *
      * **Example** (Applying an execution plan)
      *
      * ```ts import.meta.vitest
@@ -9865,7 +9922,9 @@ export const withExecutionPlan: {
         return fail(Option.getOrThrow(lastError))
       }
 
-      let nextStream: Stream<A, E | PolicyE, R2 | Exclude<R, Provides>> = provideMeta(provide(self, step.provide))
+      let nextStream: Stream<A, E | PolicyE, R2 | Exclude<R, Provides>> = provideMeta(
+        instrument(provide(self, step.provide))
+      )
       let receivedElements = false
 
       if (Option.isSome(lastError)) {
@@ -11776,12 +11835,18 @@ export const slidingSize: {
          */
         A>()
         let emitted = false
+        let skip = 0
         const pull: Pull.Pull<
           Arr.NonEmptyReadonlyArray<Arr.NonEmptyReadonlyArray<A>>,
           E | Cause.Done
         > = Effect.matchCauseEffect(upstream, {
           onSuccess(arr) {
             MutableList.appendAllUnsafe(list, arr)
+            if (skip > 0) {
+              const length = list.length
+              MutableList.takeNVoid(list, skip)
+              skip = Math.max(0, skip - length)
+            }
             if (list.length < chunkSize) return pull
             emitted = true
             const chunks = [] as any as Arr.NonEmptyArray<Arr.NonEmptyReadonlyArray<A>>
@@ -11790,10 +11855,12 @@ export const slidingSize: {
                 chunks.push(MutableList.takeN(list, chunkSize) as any)
               } else {
                 chunks.push(MutableList.toArrayN(list, chunkSize) as any)
-                if (chunkSize === 1) {
+                if (chunkSize === 1 && stepSize <= 0) {
                   MutableList.take(list)
                 } else {
+                  const length = list.length
                   MutableList.takeNVoid(list, stepSize)
+                  skip = Math.max(0, stepSize - length)
                 }
               }
             }

package/src/SynchronizedRef.ts

@@ -358,7 +358,7 @@ export const getAndUpdateSome: {
 } = dual(
   2,
   <A>(self: SynchronizedRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A> =>
-    self.semaphore.withPermit(Ref.getAndUpdateSome(self, pf))
+    self.semaphore.withPermit(Ref.getAndUpdateSome(self.backing, pf))
 )
 
 /**