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

package/src/internal/graph.ts

@@ -7,7 +7,12 @@ import { pipeArguments } from "../Pipeable.ts"
 import { hasProperty } from "../Predicate.ts"
 
 /** @internal */
-export const TypeId = "~effect/collections/Graph"
+export const TypeId = "~effect/Graph"
+
+/** @internal */
+export const isGraph = <N = unknown, E = unknown, T extends Graph.Kind = Graph.Kind, U = never>(
+  u: U | Graph.Graph<N, E, T> | Graph.MutableGraph<N, E, T>
+): u is Graph.Graph<N, E, T> | Graph.MutableGraph<N, E, T> => hasProperty(u, TypeId)
 
 /** @internal */
 export interface GraphImpl<in out N, in out E, T extends Graph.Kind>

package/src/internal/hashMap.ts

@@ -16,7 +16,7 @@ import * as Result from "../Result.ts"
 import type { NoInfer } from "../Types.ts"
 
 /** @internal */
-export const HashMapTypeId = "~effect/collections/HashMap"
+export const HashMapTypeId = "~effect/HashMap"
 
 /** @internal */
 export type HashMapTypeId = typeof HashMapTypeId
@@ -410,8 +410,10 @@ class CollisionNode<K, V> extends Node<K, V> {
     return new CollisionNode(edit, this.hash, newEntries)
   }
 
-  iterator(): Iterator<[K, V]> {
-    return this.entries[Symbol.iterator]()
+  *iterator(): Iterator<[K, V]> {
+    for (const [key, value] of this.entries) {
+      yield [key, value]
+    }
   }
 
   [Symbol.iterator](): Iterator<[K, V]> {

package/src/internal/hashSet.ts

@@ -13,7 +13,7 @@ import { hasProperty } from "../Predicate.ts"
 import * as HashMap from "./hashMap.ts"
 
 /** @internal */
-export const HashSetTypeId = "~effect/collections/HashSet"
+export const HashSetTypeId = "~effect/HashSet"
 
 /** @internal */
 export type HashSetTypeId = typeof HashSetTypeId

package/src/internal/matcher.ts

@@ -17,7 +17,22 @@ import * as Result from "../Result.ts"
 import type { Unify } from "../Unify.ts"
 
 /** @internal */
-export const TypeId = "~effect/match/Match/Matcher"
+export const TypeId = "~effect/Match/Matcher"
+
+/** @internal */
+export type Contextual<P, Fallback> = [P] extends [never] ? Fallback : P
+
+type TagHandlers<D extends string, R, Ret> = {
+  readonly [Tag in Types.Tags<D, R> & string]: (_: Extract<R, Record<D, Tag>>) => Ret
+}
+
+type PartialTagHandlers<D extends string, R, Ret> = {
+  readonly [Tag in Types.Tags<D, R> & string]?: ((_: Extract<R, Record<D, Tag>>) => Ret) | undefined
+}
+
+type ValueTagHandlers<I> = {
+  readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any
+}
 
 const TypeMatcherProto: Omit<TypeMatcher<any, any, any, any, any, any>, "cases" | "select"> = {
   [TypeId]: {
@@ -220,23 +235,31 @@ export const valueTags: {
   <
     const I,
     P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
+      & ValueTagHandlers<I>
       & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(fields: P): (input: I) => Unify<ReturnType<P[keyof P]>>
+  >(
+    fields: Contextual<P, ValueTagHandlers<I>>
+  ): (input: I) => Unify<ReturnType<P[keyof P]>>
   <
     const I,
     P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
+      & ValueTagHandlers<I>
       & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(input: I, fields: P): Unify<ReturnType<P[keyof P]>>
+  >(
+    input: I,
+    fields: Contextual<P, ValueTagHandlers<I>>
+  ): Unify<ReturnType<P[keyof P]>>
 } = dual(
   2,
   <
     const I,
     P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
+      & ValueTagHandlers<I>
       & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(input: I, fields: P): Unify<ReturnType<P[keyof P]>> => {
+  >(
+    input: I,
+    fields: Contextual<P, ValueTagHandlers<I>>
+  ): Unify<ReturnType<P[keyof P]>> => {
     const match: any = tagsExhaustive(fields as any)(makeTypeMatcher(identity, []))
     return match(input)
   }
@@ -413,14 +436,10 @@ export const discriminators = <D extends string>(field: D) =>
   R,
   Ret,
   P extends
-    & {
-      readonly [Tag in Types.Tags<D, R> & string]?:
-        | ((_: Extract<R, Record<D, Tag>>) => Ret)
-        | undefined
-    }
+    & PartialTagHandlers<D, R, Ret>
     & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
 >(
-  fields: P
+  fields: Contextual<P, PartialTagHandlers<D, R, Ret>>
 ) => {
   const predicate = makeWhen(
     (arg: any) => arg != null && Object.hasOwn(fields, arg[field]),
@@ -446,14 +465,10 @@ export const discriminatorsExhaustive: <D extends string>(
   R,
   Ret,
   P extends
-    & {
-      readonly [Tag in Types.Tags<D, R> & string]: (
-        _: Extract<R, Record<D, Tag>>
-      ) => Ret
-    }
+    & TagHandlers<D, R, Ret>
     & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
 >(
-  fields: P
+  fields: Contextual<P, TagHandlers<D, R, Ret>>
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret>
 ) => [Pr] extends [never] ? (u: I) => Unify<A | ReturnType<P[keyof P]>>

package/src/internal/metric.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const FiberRuntimeMetricsKey = "effect/observability/Metric/FiberRuntimeMetricsKey"
+export const FiberRuntimeMetricsKey = "effect/Metric/FiberRuntimeMetrics"

package/src/internal/option.ts

@@ -10,7 +10,7 @@ import { hasProperty } from "../Predicate.ts"
 import { SingleShotGen } from "../Utils.ts"
 import { PipeInspectableProto } from "./core.ts"
 
-const TypeId = "~effect/data/Option"
+const TypeId = "~effect/Option"
 
 const CommonProto = {
   [TypeId]: {
@@ -91,8 +91,10 @@ export const isSome = <A>(fa: Option.Option<A>): fa is Option.Some<A> => fa._tag
 export const none: Option.Option<never> = Object.create(NoneProto)
 
 /** @internal */
-export const some = <A>(value: A): Option.Option<A> => {
-  const a = Object.create(SomeProto)
-  a.value = value
-  return a
-}
+const SomeImpl = function(this: any, value: unknown) {
+  this.value = value
+} as unknown as { new<A>(value: A): Option.Option<A>; prototype: any }
+SomeImpl.prototype = SomeProto
+
+/** @internal */
+export const some = <A>(value: A): Option.Option<A> => new SomeImpl(value)

package/src/internal/random.ts

@@ -1,13 +1,8 @@
 import * as Context from "../Context.ts"
+import type { Random as RandomService } from "../Random.ts"
 
 /** @internal */
-export interface Random {
-  nextIntUnsafe(): number
-  nextDoubleUnsafe(): number
-}
-
-/** @internal */
-export const Random: Context.Reference<Random> = Context.Reference<Random>("effect/Random", {
+export const Random: Context.Reference<RandomService> = Context.Reference<RandomService>("effect/Random", {
   defaultValue: () => ({
     nextIntUnsafe() {
       return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) +
@@ -18,3 +13,21 @@ export const Random: Context.Reference<Random> = Context.Reference<Random>("effe
     }
   })
 })
+
+/** @internal */
+export const nextBetween = (min: number, max: number, draw: number): number => {
+  const value = draw * (max - min) + min
+  if (value !== max || min >= max || !Number.isFinite(max)) {
+    return value
+  }
+  // Rounding can reach the excluded endpoint even for a draw below 1.
+  // Return its immediate predecessor, which is at least min for finite min < max.
+  if (max === 0) {
+    return -Number.MIN_VALUE
+  }
+  const view = new DataView(new ArrayBuffer(8))
+  view.setFloat64(0, max)
+  const bits = view.getBigUint64(0)
+  view.setBigUint64(0, max > 0 ? bits - BigInt(1) : bits + BigInt(1))
+  return view.getFloat64(0)
+}

package/src/internal/rcRef.ts

@@ -116,7 +116,10 @@ const getState = <A, E>(self: RcRefImpl<A, E>) =>
               self.acquire as Effect.Effect<A, E>,
               Context.add(self.context, Scope.Scope, scope)
             )).pipe(
-              Effect.map((value) => {
+              Effect.flatMap((value) => {
+                if (self.state._tag === "Closed") {
+                  return Effect.interrupt
+                }
                 const state: State.Acquired<A> = {
                   _tag: "Acquired",
                   value,
@@ -126,7 +129,7 @@ const getState = <A, E>(self: RcRefImpl<A, E>) =>
                   invalidated: false
                 }
                 self.state = state
-                return state
+                return Effect.succeed(state)
               }),
               Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void)
             )
@@ -149,17 +152,17 @@ export const get = Effect.fnUntraced(function*<A, E>(
     if (state.refCount > 0) {
       return Effect.void
     }
-    if (self.idleTimeToLive === undefined) {
-      self.state = stateEmpty
-      return Scope.close(state.scope, Exit.void)
-    } else if (state.invalidated) {
+    if (self.idleTimeToLive === undefined || state.invalidated) {
+      if (self.state === state) {
+        self.state = stateEmpty
+      }
       return Scope.close(state.scope, Exit.void)
     } else if (!isFinite) {
       return Effect.void
     }
     state.fiber = Effect.sleep(self.idleTimeToLive).pipe(
       Effect.flatMap(() => {
-        if (self.state._tag === "Acquired" && self.state.refCount === 0) {
+        if (self.state === state && state.refCount === 0) {
           self.state = stateEmpty
           return Scope.close(state.scope, Exit.void)
         }

package/src/internal/references.ts

@@ -20,6 +20,7 @@ export const CurrentStackFrame = Context.Reference<StackFrame | undefined>("effe
 
 /** @internal */
 export const TracerEnabled = Context.Reference<boolean>("effect/References/TracerEnabled", {
+  fiberCached: true,
   defaultValue: constTrue
 })
 

package/src/internal/request.ts

@@ -62,7 +62,7 @@ export const requestUnsafe = <A extends Request.Any>(
 ): () => void => {
   const entry = addEntry(options.resolver, self, options.onExit, {
     context: options.context,
-    currentScheduler: Context.get(options.context, Scheduler)
+    cache: { scheduler: Context.get(options.context, Scheduler) }
   })
   return () => removeEntryUnsafe(options.resolver, entry)
 }
@@ -87,7 +87,7 @@ const addEntry = <A extends Request.Any>(
   resume: (exit: Exit<any, any>) => void,
   fiber: {
     readonly context: Context.Context<never>
-    readonly currentScheduler: Scheduler
+    readonly cache: { readonly scheduler: Scheduler }
     readonly id?: number
   }
 ) => {
@@ -105,8 +105,9 @@ const addEntry = <A extends Request.Any>(
     completeUnsafe(effect) {
       if (completed) return
       completed = true
+      // Removed entries still notify resolver hooks, but not their cancelled callers.
+      if (batch && !batch.entrySet.delete(entry)) return
       resume(effect)
-      batch?.entrySet.delete(entry)
     }
   })
   if (resolver.preCheck !== undefined && !resolver.preCheck(entry)) {
@@ -161,7 +162,7 @@ const addEntry = <A extends Request.Any>(
       batch = newBatch
     }
     batchMap.set(key, batch)
-    batch.fiber = effect.runForkWith(fiber.context)(batch.delayEffect, { scheduler: fiber.currentScheduler })
+    batch.fiber = effect.runForkWith(fiber.context)(batch.delayEffect, { scheduler: fiber.cache.scheduler })
   }
 
   batch.entrySet.add(entry)
@@ -169,7 +170,7 @@ const addEntry = <A extends Request.Any>(
   if (batch.resolver.collectWhile(batch.entries)) return entry
 
   batch.fiber!.interruptUnsafe(fiber.id)
-  batch.fiber = effect.runForkWith(fiber.context)(runBatch(batch), { scheduler: fiber.currentScheduler })
+  batch.fiber = effect.runForkWith(fiber.context)(runBatch(batch), { scheduler: fiber.cache.scheduler })
   return entry
 }
 
@@ -184,13 +185,17 @@ const removeEntryUnsafe = <A extends Request.Any>(
   const batch = batchMap.get(key)
   if (!batch) return
 
-  batch.entries.delete(entry)
+  if (!batch.entries.delete(entry)) return
   batch.entrySet.delete(entry)
 
+  let fiber: Fiber<void, unknown> | undefined
   if (batch.entries.size === 0) {
     batchMap.delete(key)
-    batch.fiber?.interruptUnsafe()
+    fiber = batch.fiber
   }
+  // Delay finalizers may enqueue new requests, so complete the removed entry first.
+  entry.completeUnsafe(effect.exitInterrupt())
+  fiber?.interruptUnsafe()
 }
 
 const maybeRemoveEntry = <A extends Request.Any>(

package/src/internal/result.ts

@@ -10,7 +10,7 @@ import { SingleShotGen } from "../Utils.ts"
 import { PipeInspectableProto } from "./core.ts"
 import * as option from "./option.ts"
 
-const TypeId = "~effect/data/Result"
+const TypeId = "~effect/Result"
 
 const CommonProto = {
   [TypeId]: {
@@ -80,18 +80,22 @@ export const isSuccess = <A, E>(result: Result.Result<A, E>): result is Result.S
   result._tag === "Success"
 
 /** @internal */
-export const fail = <E>(failure: E): Result.Result<never, E> => {
-  const a = Object.create(FailureProto)
-  a.failure = failure
-  return a
-}
+const FailureImpl = function(this: any, failure: unknown) {
+  this.failure = failure
+} as unknown as { new<E>(failure: E): Result.Result<never, E>; prototype: any }
+FailureImpl.prototype = FailureProto
 
 /** @internal */
-export const succeed = <A>(success: A): Result.Result<A> => {
-  const a = Object.create(SuccessProto)
-  a.success = success
-  return a
-}
+export const fail = <E>(failure: E): Result.Result<never, E> => new FailureImpl(failure)
+
+/** @internal */
+const SuccessImpl = function(this: any, success: unknown) {
+  this.success = success
+} as unknown as { new<A>(success: A): Result.Result<A>; prototype: any }
+SuccessImpl.prototype = SuccessProto
+
+/** @internal */
+export const succeed = <A>(success: A): Result.Result<A> => new SuccessImpl(success)
 
 /** @internal */
 export const getFailure = <A, E>(self: Result.Result<A, E>): Option<E> =>

package/src/internal/schema/annotations.ts

@@ -70,15 +70,15 @@ export const annotationExcludedKeys = new Set([
   SENTINELS_ANNOTATION_KEY,
   STRUCTURAL_ANNOTATION_KEY,
   "representation",
-  "arbitrary",
+  "arbitraryConstraint",
   "brands",
   "toJsonSchema",
   "toCode",
-  "toArbitrary",
   "toEquivalence",
   "toFormatter",
   "toCodec",
   "toCodecJson",
   "toCodecStringTree",
-  "toCodecIso"
+  "toCodecIso",
+  "toCodecArbitrary"
 ])

package/src/internal/schema/fromJsonSchemaDocument.ts

@@ -1,7 +1,7 @@
 import * as JsonSchema from "../../JsonSchema.ts"
 import { remainder } from "../../Number.ts"
-import * as Schema from "../../Schema.ts"
-import * as SchemaAST from "../../SchemaAST.ts"
+import type * as Schema from "../../Schema.ts"
+import * as InternalAST from "../../SchemaAST.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import { errorWithPath } from "../errors.ts"
 import * as InternalRecord from "../record.ts"
@@ -128,7 +128,7 @@ function jsonSchemaAnnotations(
   if (typeof schema.format === "string") annotations.format = schema.format
   if (typeof schema.contentEncoding === "string") annotations.contentEncoding = schema.contentEncoding
   if (typeof schema.contentMediaType === "string") annotations.contentMediaType = schema.contentMediaType
-  if (SchemaAST.isJson(schema.contentSchema)) annotations.contentSchema = schema.contentSchema
+  if (InternalAST.isJson(schema.contentSchema)) annotations.contentSchema = schema.contentSchema
   return Object.keys(annotations).length === 0 ? undefined : annotations
 }
 
@@ -634,7 +634,9 @@ function translateJsonSchemaMultiDocument(
     right: SchemaRepresentation.Union,
     path: Path
   ): ImportedJsonSchemaRepresentation | undefined {
-    if (left.mode !== "anyOf" || right.mode !== "anyOf") return undefined
+    if ((left.options?.mode ?? "anyOf") !== "anyOf" || (right.options?.mode ?? "anyOf") !== "anyOf") {
+      return undefined
+    }
     const rightByValue = new Map<string | number | boolean | null, ImportedJsonSchemaRepresentation>()
     for (const type of right.types) {
       const representation = type as ImportedJsonSchemaRepresentation
@@ -909,7 +911,7 @@ function translateJsonSchemaMultiDocument(
         representation,
         types.length === 1
           ? types[0]
-          : { _tag: "Union", types, mode: "anyOf", checks: [] },
+          : { _tag: "Union", types, checks: [] },
         [...path, "enum"]
       )
     }
@@ -957,7 +959,7 @@ function translateJsonSchemaMultiDocument(
         const union: ImportedJsonSchemaRepresentation = {
           _tag: "Union",
           types: members.map((member, index) => recur(member, [...path, mode, index])),
-          mode,
+          ...(mode === "oneOf" ? { options: { mode } } : {}),
           checks: []
         }
         representation = combine(union, representation, [...path, mode])
@@ -976,7 +978,6 @@ function translateJsonSchemaMultiDocument(
       return {
         _tag: "Union",
         types: types.map((type) => on({ ...schema, type }, path)),
-        mode: "anyOf",
         checks: []
       }
     }
@@ -1159,28 +1160,11 @@ function translateJsonSchemaMultiDocument(
   return { representations, references }
 }
 
-const jsonSchemaRevivers: ReadonlyArray<SchemaRepresentation.AnyReviver> = [
-  Schema.JsonReviver,
-  Schema.isPatternReviver,
-  Schema.isFiniteReviver,
-  Schema.isGreaterThanReviver,
-  Schema.isGreaterThanOrEqualToReviver,
-  Schema.isLessThanReviver,
-  Schema.isLessThanOrEqualToReviver,
-  Schema.isMultipleOfReviver,
-  Schema.isIntReviver,
-  Schema.isMinLengthReviver,
-  Schema.isMaxLengthReviver,
-  Schema.isMinPropertiesReviver,
-  Schema.isMaxPropertiesReviver,
-  Schema.isPropertyNamesReviver,
-  Schema.isUniqueReviver
-]
-
 /** @internal */
 export function fromJsonSchemaDocument(
   document: JsonSchema.Document<"draft-2020-12">,
-  options?: SchemaRepresentation.FromJsonSchemaOptions
+  options: SchemaRepresentation.FromJsonSchemaOptions | undefined,
+  revivers: ReadonlyArray<SchemaRepresentation.AnyReviver>
 ): Schema.Top {
   const translated = translateJsonSchemaMultiDocument(
     {
@@ -1194,13 +1178,14 @@ export function fromJsonSchemaDocument(
   return fromRepresentation({
     representation: translated.representations[0],
     references: translated.references
-  }, jsonSchemaRevivers)
+  }, revivers)
 }
 
 /** @internal */
 export function fromJsonSchemaMultiDocument(
   document: JsonSchema.MultiDocument<"draft-2020-12">,
-  options?: SchemaRepresentation.FromJsonSchemaOptions
+  options: SchemaRepresentation.FromJsonSchemaOptions | undefined,
+  revivers: ReadonlyArray<SchemaRepresentation.AnyReviver>
 ): readonly [Schema.Top, ...Array<Schema.Top>] {
-  return fromRepresentations(translateJsonSchemaMultiDocument(document, options), jsonSchemaRevivers)
+  return fromRepresentations(translateJsonSchemaMultiDocument(document, options), revivers)
 }

package/src/internal/schema/fromRepresentation.ts

@@ -2,9 +2,11 @@ import * as Arr from "../../Array.ts"
 import * as Result from "../../Result.ts"
 import * as Schema from "../../Schema.ts"
 import type * as SchemaAST from "../../SchemaAST.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import { errorWithPath } from "../errors.ts"
 import * as InternalRecord from "../record.ts"
+import * as InternalToCodec from "./toCodec.ts"
 
 type Path = ReadonlyArray<string | number>
 
@@ -43,7 +45,7 @@ function makeReviverMap(
     }
     out.set(reviver.id, {
       ...reviver,
-      payloadSchema: Schema.toCodecJson(reviver.payloadSchema)
+      payloadSchema: InternalToCodec.toCodecJson(reviver.payloadSchema)
     })
   }
 
@@ -102,7 +104,7 @@ function revivePersisted(
     reviver: SchemaRepresentation.AnyReviver,
     path: Path
   ): any {
-    const decoded = Schema.decodeUnknownResult(reviver.payloadSchema)(representation.payload)
+    const decoded = SchemaParser.decodeUnknownResult(reviver.payloadSchema)(representation.payload)
     if (Result.isFailure(decoded)) {
       throw errorWithPath(`Invalid representation payload for ${representation.id}`, path)
     }
@@ -314,7 +316,7 @@ function revivePersisted(
       }
       case "Union": {
         const members = representation.types.map((member, index) => recur(member, [...path, "types", index]))
-        return finishStructural(Schema.Union(members, { mode: representation.mode }), representation, path)
+        return finishStructural(Schema.Union(members, representation.options), representation, path)
       }
     }
   }

package/src/internal/schema/{schema.ts → make.ts}

@@ -2,50 +2,10 @@ import * as Pipeable from "../../Pipeable.ts"
 import type * as Schema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
 import * as SchemaParser from "../../SchemaParser.ts"
-import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 
 /** @internal */
 export const TypeId = "~effect/Schema/Schema"
 
-/** @internal */
-export function makeDeclarationReviver<P>(
-  id: string,
-  payloadSchema: Schema.Decoder<P>,
-  revive: SchemaRepresentation.DeclarationReviver<P>["revive"]
-): SchemaRepresentation.DeclarationReviver<P> {
-  return {
-    id,
-    payloadSchema,
-    revive
-  }
-}
-
-/** @internal */
-export function makeFilterReviver<P>(
-  id: string,
-  payloadSchema: Schema.Decoder<P>,
-  revive: SchemaRepresentation.FilterReviver<P>["revive"]
-): SchemaRepresentation.FilterReviver<P> {
-  return {
-    id,
-    payloadSchema,
-    revive
-  }
-}
-
-/** @internal */
-export function makeFilterGroupReviver<P>(
-  id: string,
-  payloadSchema: Schema.Decoder<P>,
-  revive: SchemaRepresentation.FilterGroupReviver<P>["revive"]
-): SchemaRepresentation.FilterGroupReviver<P> {
-  return {
-    id,
-    payloadSchema,
-    revive
-  }
-}
-
 const SchemaProto = {
   [TypeId]: TypeId,
   pipe() {

package/src/internal/schema/parser.ts

@@ -2,21 +2,29 @@ import * as Exit from "../../Exit.ts"
 import * as Option from "../../Option.ts"
 import { args } from "../core.ts"
 
+/** @internal */
 export const missing = Symbol()
 
+/** @internal */
 export { args }
 
+/** @internal */
 export type Success<A, E = never> = Exit.Success<A, E> & { readonly [args]: A }
 
+/** @internal */
 export const succeed = Exit.succeed as <A>(value: A) => Success<A>
 
+/** @internal */
 export const missingExit = succeed(missing)
 
 // Shared success for a present input returned unchanged. It must be resolved
 // before crossing an asynchronous or transformation boundary.
+/** @internal */
 export const sameExit: Success<unknown> = succeed(missing)
 
+/** @internal */
 export const toOption = <A>(value: A): Option.Option<A> => value === missing ? Option.none() : Option.some(value as A)
 
+/** @internal */
 export const fromOptionExit = <A>(option: Option.Option<A>): Success<A | typeof missing> =>
   option._tag === "None" ? missingExit : succeed(option.value)