effect 4.0.6 → 4.0.7

package/src/SchemaParser.ts

@@ -1136,29 +1136,62 @@ function runSync<T>(effect: Effect.Effect<T, SchemaIssue.Issue>, message: string
   throw new Error("Schema validation failed", { cause: issue })
 }
 
+const constructorDefectMessage = "Constructor adapter can only throw schema issues"
+
+function throwConstructorDefect(error: unknown): never {
+  throw new Error(constructorDefectMessage, { cause: Cause.die(error) })
+}
+
 function makeConstructorSync<T, E>(
   ast: SchemaAST.AST
 ): (input: E, options?: Schema.MakeOptions) => T {
   let entry: CompilerRegistry.Entry | undefined
-  let parser: Parser | undefined
-  return (input, options) => {
-    entry ??= CompilerRegistry.resolve(ast)
-    const parseOptions = options?.disableChecks
-      ? options.parseOptions ? { ...options.parseOptions, disableChecks: true } : { disableChecks: true }
-      : options?.parseOptions ?? SchemaAST.defaultParseOptions
-    const make = entry.make
-    if (make !== undefined && input !== InternalParser.missing) {
-      let output: unknown
-      try {
-        output = make(input, parseOptions)
-      } catch (error) {
-        InternalSchemaCause.getSchemaIssueOrThrow(Cause.die(error), "Constructor adapter can only throw schema issues")
-        throw error
-      }
-      if (output !== CompilerRegistry.invalid && output !== InternalParser.missing) return output as T
+  return (input, options) => constructSync(entry ??= CompilerRegistry.resolve(ast), input, options)
+}
+
+function constructSync<T>(entry: CompilerRegistry.Entry, input: unknown, options: Schema.MakeOptions | undefined): T {
+  const parseOptions = options?.disableChecks
+    ? options.parseOptions ? { ...options.parseOptions, disableChecks: true } : { disableChecks: true }
+    : options?.parseOptions ?? SchemaAST.defaultParseOptions
+  const make = entry.make
+  if (make !== undefined && input !== InternalParser.missing) {
+    let output: unknown
+    try {
+      output = make(input, parseOptions)
+    } catch (error) {
+      throwConstructorDefect(error)
     }
-    const result = (parser ??= entry.makeEffect)(input, parseOptions)
-    return runSync(parserResult<T, never>(result, input), "Constructor adapter can only throw schema issues")
+    if (output !== CompilerRegistry.invalid && output !== InternalParser.missing) return output as T
+  }
+  return runSync(parserResult<T, never>(entry.makeEffect(input, parseOptions), input), constructorDefectMessage)
+}
+
+/**
+ * Constructs a class instance from its type-side declaration.
+ *
+ * When the declaration has no compiled constructor, the fields are validated first
+ * and the instance is built outside the parser, so stacks captured by the
+ * class constructor keep the caller's frames.
+ *
+ * @internal
+ */
+export function makeClassSync<T>(
+  ast: SchemaAST.AST,
+  input: unknown,
+  options: Schema.MakeOptions | undefined,
+  construct: (fields: object) => T
+): T {
+  const entry = CompilerRegistry.resolve(ast)
+  const descriptor = SchemaAST.getConstructorDescriptor(ast)
+  if (descriptor === undefined || entry.make !== undefined || entry.compiledMakeEffect !== undefined) {
+    return constructSync(entry, input, options)
+  }
+  if (descriptor.isConstructed(input)) return input as T
+  const fields = constructSync<object>((entry.resolve ?? CompilerRegistry.resolve)(descriptor.link.to), input, options)
+  try {
+    return construct(fields)
+  } catch (error) {
+    throwConstructorDefect(error)
   }
 }
 

package/src/SchemaRepresentation.ts

@@ -288,13 +288,19 @@ export interface Unknown extends Keyword<"Unknown"> {}
 export interface Any extends Keyword<"Any"> {}
 
 /**
- * A string representation.
+ * A string representation, optionally describing its content through a media
+ * type and a schema for the value encoded in the string.
  *
  * @stability stable
  * @category models
  * @since 4.0.0
  */
-export interface String extends Keyword<"String"> {}
+export interface String extends Keyword<"String"> {
+  readonly content?: {
+    readonly mediaType: string
+    readonly schema?: Representation | undefined
+  } | undefined
+}
 
 /**
  * A number representation.
@@ -2388,26 +2394,6 @@ export const MutableJsonReviver: DeclarationReviver<null> = makeFixedDeclaration
   Schema.MutableJson
 )
 
-const jsonSchemaRevivers: ReadonlyArray<AnyReviver> = [
-  JsonReviver,
-  isPatternReviver,
-  isFiniteReviver,
-  isGreaterThanReviver,
-  isGreaterThanOrEqualToReviver,
-  isLessThanReviver,
-  isLessThanOrEqualToReviver,
-  isMultipleOfReviver,
-  isIntReviver,
-  isMinLengthReviver,
-  isMaxLengthReviver,
-  isMinCodePointsReviver,
-  isMaxCodePointsReviver,
-  isMinPropertiesReviver,
-  isMaxPropertiesReviver,
-  isPropertyNamesReviver,
-  isUniqueReviver
-]
-
 /**
  * Options for importing JSON Schema Draft 2020-12 documents.
  *
@@ -2965,7 +2951,14 @@ const RepresentationUnion = Schema.Union([
   makeKeywordSchema("Never"),
   makeKeywordSchema("Unknown"),
   makeKeywordSchema("Any"),
-  makeKeywordSchema("String"),
+  Schema.Struct({
+    _tag: Schema.tag("String"),
+    ...KeywordFields,
+    content: Schema.optional(Schema.Struct({
+      mediaType: Schema.String,
+      schema: Schema.optional(RepresentationSchema)
+    }))
+  }),
   makeKeywordSchema("Number"),
   makeKeywordSchema("Boolean"),
   makeKeywordSchema("BigInt"),
@@ -3192,11 +3185,13 @@ export function fromRepresentations(
  * - Intersections of overlapping unions are limited to disjoint root-type partitions and finite primitive `anyOf`
  *   literal sets. Other union intersections, including cases that would duplicate a nested choice, are rejected.
  * - Unknown extension keywords are ignored and their semantics are not enforced.
- * - Only direct local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported. Root
- *   references, external references, and pointers below a definition are rejected with the supported reference format.
- *   Missing definitions are reported by name. References reached inside nested schema
- *   resources introduced by `$id` are rejected instead of resolved against the top-level definitions.
- * - Built-in declarations and checks are reconstructed with importer-owned revivers.
+ * - Only local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported, optionally
+ *   followed by a pointer below the definition. A pointer target becomes a definition keyed by its escaped tokens, such
+ *   as `Name/properties/field`, and is rejected if a top-level definition already uses that key. Root references and
+ *   external references are rejected with the supported reference format. Missing definitions are reported by name.
+ *   References reached inside nested schema resources introduced by `$id` are rejected instead of resolved against the
+ *   top-level definitions.
+ * - Imported constraints use built-in schemas and checks.
  * - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
  *   documents, or `patterns: "ignore"` to skip them. Ignoring patterns can both admit invalid values and reject valid
  *   values when `oneOf` branches start overlapping.
@@ -3214,7 +3209,7 @@ export function fromJsonSchemaDocument(
   document: JsonSchema.Document<"draft-2020-12">,
   options?: FromJsonSchemaOptions
 ): Schema.Top {
-  return InternalFromJsonSchemaDocument.fromJsonSchemaDocument(document, options, jsonSchemaRevivers)
+  return InternalFromJsonSchemaDocument.fromJsonSchemaDocument(document, options)
 }
 
 /**
@@ -3238,10 +3233,12 @@ export function fromJsonSchemaDocument(
  *   are supported.
  * - Intersections of overlapping unions are limited to disjoint root-type partitions and finite primitive `anyOf`
  *   literal sets. Other union intersections, including cases that would duplicate a nested choice, are rejected.
- * - Only direct local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported. Root
- *   references, external references, and pointers below a definition are rejected with the supported reference format.
- *   Missing definitions are reported by name. References reached inside nested schema
- *   resources introduced by `$id` are rejected instead of resolved against the top-level definitions.
+ * - Only local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported, optionally
+ *   followed by a pointer below the definition. A pointer target becomes a definition keyed by its escaped tokens, such
+ *   as `Name/properties/field`, and is rejected if a top-level definition already uses that key. Root references and
+ *   external references are rejected with the supported reference format. Missing definitions are reported by name.
+ *   References reached inside nested schema resources introduced by `$id` are rejected instead of resolved against the
+ *   top-level definitions.
  * - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
  *   documents, or `patterns: "ignore"` to skip them. Ignoring patterns can both admit invalid values and reject valid
  *   values when `oneOf` branches start overlapping.
@@ -3258,5 +3255,5 @@ export function fromJsonSchemaMultiDocument(
   document: JsonSchema.MultiDocument<"draft-2020-12">,
   options?: FromJsonSchemaOptions
 ): readonly [Schema.Top, ...Array<Schema.Top>] {
-  return InternalFromJsonSchemaDocument.fromJsonSchemaMultiDocument(document, options, jsonSchemaRevivers)
+  return InternalFromJsonSchemaDocument.fromJsonSchemaMultiDocument(document, options)
 }

package/src/SchemaTransformation.ts

@@ -20,6 +20,7 @@ import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import { format, formatDate, formatJson } from "./Formatter.ts"
 import { dual } from "./Function.ts"
+import * as InternalContent from "./internal/schema/content.ts"
 import * as Option from "./Option.ts"
 import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
@@ -613,7 +614,10 @@ export function trim(): Transformation<string, string> {
  *
  * Decoding converts values such as `"my_field_name"` to `"myFieldName"`.
  * Encoding converts values such as `"myFieldName"` back to `"my_field_name"`.
- * The transformation is round-trippable for standard snake_case and camelCase.
+ * Lowercase snake_case values round-trip when single underscores separate the
+ * segments and every segment after the first starts with a letter. A segment
+ * that starts with a digit does not: `"foo_2_bar"` decodes to `"foo2Bar"`,
+ * which encodes to `"foo2_bar"`.
  *
  * **Example** (Converting snake case to camel case)
  *
@@ -1950,7 +1954,10 @@ export function fromJsonString(options?: {
 }): Transformation<unknown, string> {
   return new Transformation(
     SchemaGetter.parseJson(options ?? {}),
-    SchemaGetter.stringifyJson(options)
+    InternalContent.setContent(SchemaGetter.stringifyJson(options), {
+      mediaType: "application/json",
+      preserveSchema: options?.reviver === undefined && options?.replacer === undefined
+    })
   )
 }
 

package/src/Semaphore.ts

@@ -13,7 +13,7 @@
  */
 import type * as Effect from "./Effect.ts"
 import type { Fiber } from "./Fiber.ts"
-import { dual } from "./Function.ts"
+import { dual, identity } from "./Function.ts"
 import * as core from "./internal/core.ts"
 import * as internal from "./internal/effect.ts"
 import type * as Option from "./Option.ts"
@@ -214,26 +214,58 @@ export interface Semaphore {
  */
 export const makeUnsafe = (permits: number): Semaphore => new SemaphoreImpl(permits)
 
-const waitForPermits = <A, E, R>(
+interface Waiter {
+  readonly permits: number
+  resume: ((effect: Effect.Effect<void>) => void) | undefined
+}
+
+// The first queued request that fits in the free permits. Larger requests
+// ahead of it keep their place but are overtaken, as documented on `take`.
+const firstAvailableWaiter = (self: SemaphoreImpl): Waiter | undefined => {
+  for (const waiter of self.waiters) {
+    if (waiter.permits <= self.free) return waiter
+  }
+}
+
+const takePermits = <A, E, R>(
   self: SemaphoreImpl,
   n: number,
-  effect: Effect.Effect<A, E, R>
+  onAcquire: () => Effect.Effect<A, E, R>,
+  restore: <AX, EX, RX>(effect: Effect.Effect<AX, EX, RX>) => Effect.Effect<AX, EX, RX> = identity
 ): Effect.Effect<A, E, R> =>
-  internal.callback((resume) => {
-    if (self.free >= n) return resume(effect)
-    const observer = () => {
-      if (self.free < n) return
-      self.waiters.delete(observer)
-      resume(effect)
+  core.withFiber((fiber) => {
+    if (self.free >= n && firstAvailableWaiter(self) === undefined) {
+      self.taken += n
+      return onAcquire()
+    }
+    // A wake does not reserve permits: the waiter keeps its queue entry until
+    // it acquires or is interrupted, and re-checks eligibility when it runs.
+    const waiter: Waiter = { permits: n, resume: undefined }
+    const remove = () => {
+      if (self.waiters.delete(waiter)) self.releaseUnsafe(fiber, 0)
+      return undefined
     }
-    self.waiters.add(observer)
-    return internal.sync(() => {
-      self.waiters.delete(observer)
+    self.waiters.add(waiter)
+    internal.onExitUnsafe(fiber, remove)
+    const wait = restore(internal.callback<void>((resume) => {
+      // The fiber may have yielded since the last check, missing a wake.
+      if (firstAvailableWaiter(self) === waiter) {
+        resume(internal.void)
+      } else {
+        waiter.resume = resume
+      }
+    }))
+    const loop: Effect.Effect<A, E, R> = internal.flatMap(wait, () => {
+      if (firstAvailableWaiter(self) !== waiter) return loop
+      self.taken += n
+      remove()
+      return onAcquire()
     })
+    return loop
   })
 
 class SemaphoreImpl implements Semaphore {
-  public waiters = new Set<() => void>()
+  public waiters = new Set<Waiter>()
   public taken = 0
   public permits: number
 
@@ -246,14 +278,7 @@ class SemaphoreImpl implements Semaphore {
   }
 
   take(n: number): Effect.Effect<number> {
-    const take: Effect.Effect<number> = internal.suspend(() => {
-      if (this.free < n) {
-        return waitForPermits(this, n, take)
-      }
-      this.taken += n
-      return internal.succeed(n)
-    })
-    return take
+    return takePermits(this, n, () => internal.succeed(n))
   }
 
   takeIfAvailable(n: number): Effect.Effect<boolean> {
@@ -268,9 +293,17 @@ class SemaphoreImpl implements Semaphore {
     this.taken -= n
     if (this.waiters.size > 0) {
       fiber.currentDispatcher.scheduleTask(() => {
-        for (const observer of this.waiters) {
-          if (this.free <= 0) break
-          observer()
+        // Wake every queued request that fits in the free permits. Waiters
+        // that were already woken still count against the budget, since they
+        // keep their place until they acquire. Resumed fibers run inline and
+        // can add or remove waiters, so iterate over a snapshot.
+        let remaining = this.free
+        for (const waiter of Array.from(this.waiters)) {
+          if (!this.waiters.has(waiter) || waiter.permits > remaining) continue
+          remaining -= waiter.permits
+          const resume = waiter.resume
+          waiter.resume = undefined
+          resume?.(internal.void)
         }
       }, 0)
     }
@@ -296,24 +329,18 @@ class SemaphoreImpl implements Semaphore {
 
   withPermits(n: number) {
     return <A, E, R>(self: Effect.Effect<A, E, R>) =>
-      internal.uninterruptibleMask((restore) => {
-        const acquire: Effect.Effect<A, E, R> = internal.suspend(() => {
-          if (this.free < n) {
-            const wait = waitForPermits(this, n, internal.void)
-            return internal.flatMap(restore(wait), () => acquire)
-          }
-          this.taken += n
-          return internal.onExitPrimitive(
-            restore(self),
-            () => {
+      internal.uninterruptibleMask((restore) =>
+        takePermits(
+          this,
+          n,
+          () =>
+            internal.onExitPrimitive(restore(self), () => {
               this.releaseUnsafe(internal.getCurrentFiber()!, n)
               return undefined
-            },
-            true
-          )
-        })
-        return acquire
-      })
+            }, true),
+          restore
+        )
+      )
   }
 
   readonly withPermit = this.withPermits(1)

package/src/Sink.ts

@@ -2687,7 +2687,12 @@ export const catchCause: {
 ): Sink<A | A2, In, L, E2, R | R2> =>
   transformEffect(
     self,
-    Effect.catchCause((cause) => Effect.map(f(cause), (a2) => [a2 as A | A2] as const))
+    Effect.catchCause((cause) =>
+      // Upstream failures are not sink errors, so they bypass the handler.
+      Channel.hasUpstreamFailure(cause)
+        ? Effect.failCause(cause as Cause.Cause<never>)
+        : Effect.map(f(cause), (a2) => [a2 as A | A2] as const)
+    )
   ))
 
 const catch_: {
@@ -2774,7 +2779,15 @@ export const onExit: {
 ): Sink<A, In, L, E | E2, R | R2> =>
   transformEffect(
     self,
-    Effect.onExit((exit) => f(Exit.map(exit, ([a]) => a)))
+    Effect.onExit((exit) =>
+      // Upstream failures stop the sink like an interruption; they are not
+      // sink errors.
+      f(
+        Exit.isFailure(exit) && Channel.hasUpstreamFailure(exit.cause)
+          ? Exit.interrupt()
+          : Exit.map(exit, ([a]) => a)
+      )
+    )
   ))
 
 /**

package/src/Stream.ts

@@ -7295,17 +7295,12 @@ export const peel: {
   ): Effect.fn.Return<[A2, Stream<A, E, never>], E | E2, Scope.Scope | R | R2> {
     let cause: Cause.Cause<E | Cause.Done<void>> | undefined = undefined
     const originalPull = yield* Channel.toPull(self.channel)
-    const pull: Pull.Pull<
-      Arr.NonEmptyReadonlyArray<A>,
-      E
-    > = Effect.catchCause(originalPull, (cause_) => {
+    const pull = Effect.catchCause(originalPull, (cause_) => {
       cause = cause_
       return Effect.failCause(cause_)
     })
 
-    const [result, leftover] = yield* Effect.scopedWith((scope) =>
-      sink.transform(pull as Pull.Pull<Arr.NonEmptyReadonlyArray<A>>, scope)
-    )
+    const [result, leftover] = yield* Effect.scopedWith((scope) => runSink(sink, pull, scope))
     let stream: Stream<A, E> = cause ? empty : fromPull(Effect.succeed(originalPull))
     if (leftover) {
       stream = concat(fromArray(leftover), stream)
@@ -11098,7 +11093,7 @@ export const takeRight: {
     const count = Count.normalize(n)
     if (count === 0) return empty
     return mapAccumArray(self, MutableList.make<A>, (list, arr) => {
-      MutableList.appendAll(list, arr)
+      MutableList.appendAllUnsafe(list, arr)
       if (list.length > count) {
         MutableList.takeNVoid(list, list.length - count)
       }
@@ -12528,10 +12523,10 @@ export const rechunk: {
       let chunk = Arr.empty<A>() as Arr.NonEmptyArray<A>
       let index = 0
       let current: Arr.NonEmptyReadonlyArray<A> | undefined
-      let done = false
+      let cause: Cause.Cause<E | Cause.Done> | undefined
 
       return Effect.suspend(function loop(): Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E, void, R> {
-        if (done) return Cause.done()
+        if (cause) return Effect.failCause(cause)
         else if (current === undefined) {
           return Effect.flatMap(pull, (arr) => {
             if (chunk.length === 0 && arr.length === target) {
@@ -12558,10 +12553,10 @@ export const rechunk: {
         current = undefined
         return loop()
       }).pipe(
-        Pull.catchDone(() => {
-          if (chunk.length === 0) return Cause.done()
+        Effect.catchCause((cause_) => {
+          if (chunk.length === 0) return Effect.failCause(cause_)
           const result = chunk
-          done = true
+          cause = cause_
           chunk = [] as any
           return Effect.succeed(result)
         })
@@ -15122,7 +15117,12 @@ const groupByImpl = <A, E, R, K, V, E2, R2>(
         body: constant(Effect.flatMap(pull, (arr) => f(arr, queues, queueMap))),
         step: constVoid
       }).pipe(
-        Effect.catchCause((cause) => Queue.failCause(out, cause)),
+        Effect.catchCause((cause) => {
+          for (const [, queue] of queueMap) {
+            Queue.endUnsafe(queue)
+          }
+          return Queue.failCause(out, cause)
+        }),
         Effect.forkIn(scope)
       )
 
@@ -15659,7 +15659,7 @@ export const aggregateWithin: {
         return buffer.state.exit as Exit.Exit<never, Cause.Done<void> | E>
       }
       hasInput.closeUnsafe()
-      const pull = emit(Effect.suspend(() => sink.transform(sinkUpstream as any, scope)))
+      const pull = emit(Effect.suspend(() => runSink(sink, sinkUpstream, scope)))
       return buffer.state._tag === "Open" ? Effect.raceFirst(pull, stepToBuffer) : pull
     })
   }))))
@@ -19327,11 +19327,28 @@ export const run: {
 ): Effect.Effect<A2, E | E2, R | R2> =>
   Effect.scopedWith((scope) =>
     Channel.toPullScoped(self.channel, scope).pipe(
-      Effect.flatMap((upstream) => sink.transform(upstream as any, scope)),
+      Effect.flatMap((upstream) => runSink(sink, upstream, scope)),
       Effect.map(([a]) => a)
     )
   ))
 
+/**
+ * Runs `sink` against `upstream`. Upstream failures bypass the sink's error
+ * handlers and are restored once the sink has exited.
+ */
+const runSink = <A, E, R, A2, L, E2, R2>(
+  sink: Sink.Sink<A2, A, L, E2, R2>,
+  upstream: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E, void, R>,
+  scope: Scope.Scope
+): Effect.Effect<Sink.End<A2, L>, E | E2, R | R2> =>
+  Channel.restoreUpstreamFailure<Sink.End<A2, L>, E | E2, R2>(
+    // The upstream pull runs in this fiber, which already provides `R`.
+    sink.transform(
+      Channel.upstreamFailureToDefect(upstream) as Pull.Pull<Arr.NonEmptyReadonlyArray<A>, never, void>,
+      scope
+    )
+  )
+
 /**
  * Runs the stream and collects all elements into an array.
  *

package/src/String.ts

@@ -1860,6 +1860,9 @@ export const constantCase: (self: string) => string = noCase({
  * Unlike {@link constantCase}, digit-letter boundaries are not split. For
  * example, `"api-v2 xml"` becomes `"API_V2_XML"`.
  *
+ * `configCase` is not idempotent: `"field2value"` becomes `"FIELD2VALUE"`, and
+ * applying it again gives `"FIELD2_VALUE"`.
+ *
  * @see {@link constantCase} for standard uppercase underscore-separated output
  * @stability stable
  * @category transforming

package/src/Tracer.ts

@@ -326,6 +326,15 @@ export type SpanKind = "internal" | "server" | "client" | "producer" | "consumer
  * annotations, attributes, links, sampling and kind information, lifecycle
  * status, and methods to end the span or add attributes, events, and links.
  *
+ * **Details**
+ *
+ * Once a span has `Ended` status, implementations should ignore further calls
+ * to `end`, `attribute`, `event`, and `addLinks`, following the OpenTelemetry
+ * tracing specification. An ended span can still be read and used as a parent.
+ * The built-in span implementations follow this rule, and Effect does not
+ * record logs or `annotateCurrentSpan` attributes on an ended span, such as
+ * when a fiber outlives the span it was forked in.
+ *
  * **Example** (Working with spans)
  *
  * ```ts import.meta.vitest
@@ -684,7 +693,8 @@ export const nativeTracer: Tracer = make({
  * identifiers, the attribute map, and the event list are created lazily on
  * first access, so spans that are never inspected allocate as little as
  * possible. Attributes, events, links, and status are mutated through `Span`
- * methods.
+ * methods. Once the span has ended, those methods do nothing, so a second `end`
+ * keeps the original end time and exit.
  *
  * @see {@link Span} for the interface implemented by native spans
  *
@@ -748,6 +758,7 @@ export class NativeSpan implements Span {
   }
 
   end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void {
+    if (this.status._tag === "Ended") return
     this.status = {
       _tag: "Ended",
       endTime,
@@ -757,14 +768,17 @@ export class NativeSpan implements Span {
   }
 
   attribute(key: string, value: unknown): void {
+    if (this.status._tag === "Ended") return
     this.attributes.set(key, value)
   }
 
   event(name: string, startTime: bigint, attributes?: Record<string, unknown>): void {
+    if (this.status._tag === "Ended") return
     this.events.push([name, startTime, attributes ?? {}])
   }
 
   addLinks(links: ReadonlyArray<SpanLink>): void {
+    if (this.status._tag === "Ended") return
     // oxlint-disable-next-line no-restricted-syntax
     this.links.push(...links)
   }

package/src/ai/LanguageModel.ts

@@ -1553,6 +1553,7 @@ export const make: (params: {
             preliminary: false,
             result: r.encodedResult,
             encodedResult: r.encodedResult,
+            ...modelOutputField(r.modelOutput),
             isFailure: r.isFailure
           }) as Response.StreamPart<Tools>
         )
@@ -1680,6 +1681,7 @@ export const make: (params: {
             providerExecuted: false,
             result: result.result,
             encodedResult: result.encodedResult,
+            ...modelOutputField(result.modelOutput),
             isFailure: result.isFailure,
             preliminary: result.preliminary
           }) as Response.StreamPart<Tools>
@@ -2268,6 +2270,7 @@ const executeApprovedToolCalls = <Tools extends Record<string, Tool.Any>>(
       name: toolCall.name,
       result: terminalResult.result,
       encodedResult: terminalResult.encodedResult,
+      ...modelOutputField(terminalResult.modelOutput),
       isFailure: terminalResult.isFailure,
       preliminary: terminalResult.preliminary,
       providerExecuted: false
@@ -2347,6 +2350,10 @@ const makeInterruptedToolResult = (
   })
 }
 
+// Omits the key entirely so unmapped tool result parts keep their shape.
+const modelOutputField = (modelOutput: ReadonlyArray<Prompt.ToolModelOutputPart> | undefined) =>
+  modelOutput === undefined ? undefined : { modelOutput }
+
 type ToolResolutionResult<Tools extends Record<string, Tool.Any>> =
   | Response.ToolResultPart<
     Tool.Name<Tools[keyof Tools]>,
@@ -2417,6 +2424,7 @@ const resolveToolCalls = <Tools extends Record<string, Tool.Any>>(
                 providerExecuted: false,
                 result: result.result,
                 encodedResult: result.encodedResult,
+                ...modelOutputField(result.modelOutput),
                 isFailure: result.isFailure,
                 preliminary: result.preliminary
               }) as ToolResolutionResult<Tools>
@@ -2446,6 +2454,7 @@ const resolveToolCalls = <Tools extends Record<string, Tool.Any>>(
               providerExecuted: false,
               result: result.result,
               encodedResult: result.encodedResult,
+              ...modelOutputField(result.modelOutput),
               isFailure: result.isFailure,
               preliminary: result.preliminary
             }) as ToolResolutionResult<Tools>