{"version":3,"file":"index.mjs","names":["Prototype","Class","symbol","number","string","withVisitedTracking","combine","symbol","equals","Hash.hash","redact","emptyContext","format","Predicate.hasProperty","redact","redact","Predicate.hasProperty","Predicate.isFunction","format","Class","format","Hash.symbol","Hash.structureKeys","Equal.symbol","Equal.equals","isEffect","isCause","Hash.array","isFailReason","Hash.combine","Hash.string","Hash.hash","isDieReason","InterruptorStackTrace","withFiber","Error","TaggedError","isDone","Done","done","make","Tuple","TypeId","CommonProto","Equal.symbol","isSome","Equal.equals","Hash.symbol","Hash.combine","Hash.hash","format","isNone","none","some","TypeId","Equal.symbol","isResult","isSuccess","Equal.equals","Hash.symbol","Hash.combine","Hash.hash","format","isFailure","fail","succeed","make","String","Number","BigInt","Date","isLessThan","isGreaterThan","isLessThanOrEqualTo","isGreaterThanOrEqualTo","option.none","option.some","option.isNone","option.isSome","match","getOrUndefined","map","flatMap","filter","get","make","withFiber","TypeId","Proto","makeUnsafe","Equal.symbol","Equal.equals","Hash.symbol","Hash.number","empty","getUnsafe","Option.some","Option.none","merge","mergeAll","isArrayNonEmpty","normalize","succeed","result.succeed","fail","result.fail","try_","result.isResult","isFailure","result.isFailure","isSuccess","result.isSuccess","map","match","make","makeEquivalence","Equivalence.Tuple","map","makeEquivalence","Array","fromIterable","append","appendAll","internalArray.isArrayNonEmpty","get","Option.none","Option.some","Count.normalize","take","Order.combineAll","Tuple.make","empty","map","Equivalence.Array","TypeId","bigint0","bigint1","bigint10","fromInputUnsafe","invalid","zero","make","Hash.symbol","Hash.hash","Hash.number","Hash.structure","Equal.symbol","equals","isFinite","isZero","isNegative","abs","match","Equivalence","format","Pipeable.Class","Predicate.isTagged","Error","core.Error","TaggedError","core.TaggedError","Data.TaggedError","encodeBase64","encoder","decodeBase64","Result.fail","Result.succeed","Result.map","Context.Service","make","Option.getOrUndefined","Encoding.randomHex","Equal.symbol","Hash.symbol","Hash.combine","Hash.string","Hash.random","makeInterruptReason","isFailReason","Result.succeed","Result.fail","findError","hasDies","isDieReason","hasInterrupts","hasInterruptsOnly","hash","Hash.hash","Equal.equals","CauseStackTrace","InterruptorStackTrace","Context.get","Context.make","failCause","flatMap","Context.empty","Context.hasSameCache","Context.getOrUndefinedUnsafe","Tracer.TracerKey","Scheduler.Scheduler","Tracer.ParentSpanKey","InternalMetric.FiberRuntimeMetricsKey","Scheduler.MaxOpsBeforeYield","Scheduler.PreventSchedulerYield","Context.makeUnsafe","succeed","callback","sync","withFiber","Context.merge","asVoid","Arr.empty","fail","suspend","fromResult","succeedNone","failCauseSync","die","void_","try_","UnknownError","promise","tryPromise","gen","fnUntraced","fn","isEffect","useSpan","fnUntracedEager","as","map","Option.some","andThen","tap","uninterruptible","forkUnsafe","raceFirst","flatMapEager","mapEager","mapErrorEager","mapError","mapBothEager","exitInterrupt","Result.isFailure","serviceOption","Context.getOption","updateContext","Context.getUnsafe","Context.add","context","contextWith","provideContext","forever","whileLoop","catchCause","catchCauseFilter","catch_","catchIf","catchTag","matchEffect","orDie","orElseSucceed","ignore","matchCauseEffect","result","exit","Option.isNone","Duration.format","timeout","Duration.fromInputUnsafe","sleep","Option.none","scope","scoped","scopedWith","onExit","acquireRelease","uninterruptibleMask","addFinalizer","ensuring","onError","onInterrupt","cached","interrupt","all","forEach","Arr.fromIterable","forkIn","forkScoped","runForkWith","runFork","runPromiseExit","runPromise","Scheduler.MixedScheduler","runSyncExit","runSync","bigint0","Tracer.DisablePropagation","Option.getOrUndefined","Tracer.Tracer","Tracer.CurrentTraceLevel","Option.isSome","Tracer.MinimumTraceLevel","Tracer.ParentSpan","withParentSpan","Duration.toMillis","clockWith","isTimeoutError","TaggedError","IllegalArgumentError","Order.Number","isCause","TypeId","makeUnsafe","internalEffect.callback","internalEffect.sync","done","isDone","effect.scopeTag","makeUnsafe","effect.scopeMakeUnsafe","provide","effect.provideScope","effect.scopeAddFinalizerExit","addFinalizer","effect.scopeAddFinalizer","effect.scopeForkUnsafe","effect.scopeClose","TypeId","internalEffect.andThen","internalEffect.scopeAddFinalizerExit","Scope.forkUnsafe","internalEffect.onExit","Scope.close","internalEffect.void","Scope.makeUnsafe","Deferred.makeUnsafe","Deferred.await","internalEffect.suspend","internalEffect.flatMap","Deferred.done","Context.Service","Context.getOrUndefined","internalEffect.provideService","internalEffect.map","Context.add","core.withFiber","succeed","Context.make","internalEffect.succeed","Scope.provide","internalEffect.as","Context.empty","internalEffect.forEach","Context.mergeAll","internalEffect.provideContext","provide","Context.merge","succeed","core.exitSucceed","failCause","core.exitFailCause","fail","core.exitFail","void_","effect.exitVoid","effect.exitIsSuccess","effect.exitIsFailure","core.isCause","core.isCauseReason","core.isFailReason","core.isDieReason","core.causeFromReasons","fail","core.causeFail","core.Fail","core.Die","effect.makeInterruptReason","effect.hasInterruptsOnly","map","effect.causeMap","effect.causeCombine","effect.causeSquash","effect.findError","effect.hasDies","effect.hasInterrupts","effect.causePretty","core.isDone","core.Done","core.done","effect.isTimeoutError","effect.IllegalArgumentError","effect.UnknownError","Context.Service","TypeId","Proto","Inspectable.NodeInspectSymbol","toDateUtc","Hash.symbol","Hash.number","Equal.symbol","isDateTime","Hash.combine","Hash.hash","Equal.equals","Hash.string","Predicate.hasProperty","isUtc","makeUnsafe","make","toUtc","toEpochMillis","formatIso","String","readonlyArray.isArrayNonEmpty","internalEffect.catchCauseFilter","Cause.isDone","Result.fail","Cause.fromReasons","Result.succeed","Result.isFailure","Exit.succeed","Exit.failCause","matchEffect","internalEffect.matchCauseEffect","TypeId","Duration.zero","effect.map","effect.catchCause","effect.succeed","effect.failCause","effect.clockWith","effect.suspend","effect.flatMap","effect.as","effect.sleep","Duration.toMillis","Duration.fromInputUnsafe","Duration.millis","millis","passthrough","Pull.matchEffect","Cause.done","isEffect","forever","effect.scopedWith","effect.flatMap","Layer.buildWithMemoMap","Layer.makeMemoMapUnsafe","Layer.buildWithScope","effect.provideContext","provide","isEffect","Context.isContext","Layer.mergeAll","effect.flatMap","Schedule.toStepWithMetadata","effect.catch_","effect.forever","effect.tap","effect.suspend","effect.provideService","Schedule.CurrentMetadata","effect.sync","core.isDone","effect.succeed","Option.none","Option.some","Pull.catchDone","repeat","Schedule.isSchedule","effect.fail","retry","Schedule.forever","Schedule.passthrough","Schedule.while","core.isEffect","effect.map","core.isEffect","internal.all","forEach","internal.forEach","internal.whileLoop","internal.promise","internal.tryPromise","succeed","internal.succeed","internal.succeedNone","suspend","internal.suspend","internal.sync","void_","internal.void","callback","internal.callback","internal.gen","fail","internal.fail","failCause","internal.failCause","internal.failCauseSync","internal.die","internal.try","core.withFiber","internal.fromResult","internal.flatMap","internal.andThen","internal.tap","internal.exit","map","internal.map","internal.as","internal.asVoid","catch_","internal.catch_","internal.catchTag","catchCause","internal.catchCause","internal.catchIf","mapError","internal.mapError","internal.orDie","internalSchedule.retry","ignore","internal.ignore","internal.orElseSucceed","internal.timeout","internal.sleep","internal.raceFirst","internal.matchCauseEffect","internal.matchEffect","internal.context","internal.contextWith","internalLayer.provide","provideContext","internal.provideContext","internal.serviceOption","internal.updateContext","internal.scope","internal.scoped","internal.scopedWith","internal.acquireRelease","internal.addFinalizer","ensuring","internal.ensuring","internal.onError","onExit","internal.onExit","internal.cached","interrupt","internal.interrupt","internal.onInterrupt","internal.uninterruptible","internal.uninterruptibleMask","internal.forever","internalSchedule.repeat","internal.useSpan","internal.withParentSpan","internal.forkIn","internal.forkScoped","internal.runFork","internal.runForkWith","internal.runPromise","internal.runPromiseExit","internal.runSync","internal.runSyncExit","internal.fnUntraced","internal.fn","internal.clockWith","Context.Service","internal.mapEager","internal.mapErrorEager","internal.mapBothEager","internal.flatMapEager","internal.fnUntracedEager","BigInt","Option.none","Option.some","bigint0","bigint1","make","parse","TypeId","Data.TaggedError","Data.Error","effect.fiberInterrupt","effect.fiberRunIn","makeUnsafe","internal.makeLatchUnsafe","TypeId","make","Empty","make","Count.normalize","take","TypeId","variance","make","core.withFiber","MutableList.make","internalEffect.succeed","internalEffect.suspend","failCause","internalEffect.sync","core.exitFailCause","internalEffect.exitZipRight","core.causeFail","core.Done","core.exitSucceed","Count.normalize","internalEffect.andThen","Option.none","Option.some","MutableList.take","internalEffect.exitVoid","MutableList.takeN","internalEffect.callback","Pull.isDoneCause","makeUnsafe","internal.callback","internal.sync","internal.suspend","internal.succeed","core.withFiber","internal.void","internal.uninterruptibleMask","internal.flatMap","internal.onExitPrimitive","internal.getCurrentFiber","internal.succeedNone","internal.asSome","TypeId","identity_","fromTransform","Effect.catchCause","Effect.succeed","Effect.failCause","transformPull","Effect.flatMap","fromPull","Effect.fnUntraced","Scope.forkUnsafe","Scope.close","Pull.doneExitFromCause","Effect.onError","Queue.make","Effect.tap","Scope.addFinalizer","Queue.shutdown","Effect.forkIn","Scope.provide","Effect.map","Queue.takeAll","suspend","Effect.suspend","Count.normalizeNonEmpty","Effect.sync","done","Option.none","Cause.done","Option.some","succeed","empty","fail","Effect.fail","fromReadableStream","MutableRef.make","Effect.matchCauseEffect","Effect.tryPromise","Arr.of","Effect.as","Effect.promise","map","Pull.catchDone","Pull.isDoneCause","Exit.failCause","Effect.andThen","Result.isFailure","Cause.findError","mapError","merge","Queue.bounded","Queue.failCause","Effect.void","Queue.offer","Effect.forever","Queue.take","splitLines","Arr.isReadonlyArrayNonEmpty","Pull.matchEffect","unwrap","Scope.addFinalizerExit","ensuring","Scope.makeUnsafe","Effect.onExit","provideContext","Effect.provideContext","runForEach","mkUint8Array","Effect.whileLoop","TypeId","fromChannel","TypeId","fromChannel","Channel.toTransform","Effect.flatMap","Effect.forever","Pull.catchDone","Effect.succeed","toChannel","Channel.fromTransform","Cause.done","Effect.forEach","unwrap","Channel.unwrap","Effect.map","TypeId","make","Effect.withFiber","Context.get","Scope.Scope","Duration.fromInputUnsafe","Effect.as","Scope.addFinalizerExit","close","Scope.close","Exit.void","Effect.void","Effect.uninterruptibleMask","Effect.interrupt","Fiber.interrupt","Effect.succeed","Scope.makeUnsafe","Effect.suspend","Effect.provideContext","Context.add","Effect.flatMap","Effect.onExit","Exit.isFailure","get","scope","Effect.scope","Duration.isFinite","Effect.sleep","Effect.ensuring","Effect.sync","Effect.runForkWith","Fiber.runIn","make","internal.make","get","internal.get","TypeId","internal.fromChannel","Channel.fromPull","Channel.fromTransform","Effect.flatMap","Channel.toPullScoped","Channel.callbackArray","empty","Channel.empty","succeed","Channel.succeed","Arr.of","Channel.suspend","fail","Channel.fail","fromIterable","Channel.fromIterableArray","Arr.isReadonlyArrayNonEmpty","Channel.fromReadableStream","Channel.unwrap","Effect.map","map","Channel.map","Arr.map","merge","Channel.merge","Channel.mapError","Effect.sync","done","Effect.suspend","Effect.succeed","Effect.catch","Exit.fail","Cause.done","Channel.pipeTo","Channel.splitLines","Channel.ensuring","Channel.provideContext","run","Effect.scopedWith","Channel.runFold","Channel.runForEach","Effect.whileLoop","Channel.mkUint8Array","Latch.makeUnsafe","Effect.runFork","Effect.provideContext","Cause.squash","Effect.runPromise","Effect.asVoid","Fiber.interrupt","Effect.context","TypeId","make","Effect.as","Effect.catchTag","Effect.succeed","Effect.fail","Effect.flatMap","Effect.try","Effect.fnUntraced","ByteSize.fromInputUnsafe","Stream.fromPull","Effect.suspend","Cause.done","Option.match","Arr.of","Stream.unwrap","Effect.map","Sink.forEach","Sink.unwrap","Context.Service","TypeId","Path","resolveAt","Exit.succeed","Option.none","Option.some","TypeId","InternalParser.missing","Filter","Arr.isReadonlyArrayNonEmpty","Arr.map","InternalAnnotations.getExpected","format","Cause.isFailReason","SchemaIssue.isIssue","Internal.isDateTime","Internal.isUtc","Internal.makeUnsafe","make","Internal.make","Internal.toUtc","Internal.toDateUtc","Internal.toEpochMillis","Context.Service","Internal.formatIso","Pipeable.Class","Effect.mapEager","Option.map","Effect.flatMapEager","Effect.fail","Option.isSome","SchemaIssue.Forbidden","passthrough_","Effect.succeed","passthrough","Option.isNone","Effect.succeedNone","transform","transformEffect","Option.some","Option.filter","Predicate.isNotUndefined","String","Number","BigInt","Date","Effect.try","SchemaIssue.InvalidValue","Encoding.encodeBase64","Effect.mapErrorEager","Effect.fromResult","Encoding.decodeBase64","TypeId","Hash.symbol","normalize","Hash.combine","Hash.hash","Hash.number","Equal.symbol","make","Equivalence","TypeId","Predicate.hasProperty","make","SchemaGetter.transformEffect","transform","SchemaGetter.transform","Predicate.isObject","format","Predicate.isError","Effect.succeed","Effect.fail","SchemaIssue.InvalidValue","fromJsonString","SchemaGetter.parseJson","SchemaGetter.stringifyJson","TypeId","InternalParser.missing","InternalParser.missingExit","Null","Undefined","SchemaTransformation.Transformation","Void","succeed","InternalParser.succeed","Unknown","Predicate.isUnknown","Literal","format","SchemaGetter.transform","String","Predicate.isString","Number","Predicate.isNumber","Boolean","Predicate.isBoolean","Effect.fnUntracedEager","Effect.fail","SchemaIssue.InvalidType","SchemaIssue.UnexpectedKey","SchemaIssue.Pointer","SchemaIssue.Composite","InternalParser.sameExit","InternalParser.args","SchemaIssue.MissingKey","Exit.fail","InternalSchemaCause.getSchemaIssue","Exit.failCause","Cause.map","toEncoded","Predicate.isNotNullish","Exit.void","Effect.flatMap","Effect.exit","Arr.empty","Effect.flatMapEager","Effect.die","Union","InternalAnnotations.SENTINELS_ANNOTATION_KEY","Predicate.isObjectKeyword","SchemaIssue.AnyOf","Effect.catchCause","Effect.succeed","SchemaIssue.OneOf","Pipeable.Class","makeFilter","SchemaIssue.normalizeFilterOutput","isPattern","Arr.append","optional","withConstructorDefault","SchemaGetter.withDefault","SchemaGetter.passthrough","decodeTo","Predicate.isPropertyKey","Arr.isArrayNonEmpty","toType","SchemaTransformation.numberFromString","SchemaTransformation.bigintFromString","SchemaIssue.Filter","InternalAnnotations.CONSTRUCTOR_ANNOTATION_KEY","Predicate.isFunction","InternalAnnotations.resolveAt","Json","Option.some","Result.succeed","Inspectable.BaseProto","make","Effect.map","Stream.decodeText","Stream.unwrap","Stream.splitLines","Effect.scoped","Effect.flatMap","Stream.runCollect","Stream.mkString","Context.Service","TypeId","Proto","Context.getUnsafe","make","PlatformError.systemError","Sink.fromChannel","Channel.mapDone","Channel.fromTransform","Effect.succeed","Effect.flatMap","Effect.callback","Effect.void","Effect.sync","Effect.forever","Pull.catchDone","Cause.done","Effect.raceFirst","Effect.fail","Stream.fromChannel","Channel.fromTransform","MutableRef.make","Latch.makeUnsafe","Exit.fail","Cause.Done","Effect.suspend","Effect.fail","Effect.flatMap","Arr.of","Effect.succeed","Effect.as","Scope.addFinalizer","Effect.sync","Cause.UnknownError","Deferred.isDoneUnsafe","make","FileSystem.FileSystem","Path.Path","Effect.fnUntraced","Predicate.isUndefined","Stream.isStream","Sink.isSink","ChildProcess.parseFdName","Predicate.isNotUndefined","Sink.drain","Stream.empty","NodeSink.fromWritable","Effect.forkScoped","Stream.run","NodeStream.fromReadable","Stream.transduce","Effect.suspend","Predicate.isNotNull","Effect.as","Effect.succeed","Stream.merge","Effect.callback","Deferred.makeUnsafe","Effect.fail","Exit.succeed","Effect.sync","Effect.void","Effect.try","Effect.catch","Duration.toMillis","Deferred.await","Effect.acquireRelease","Deferred.isDone","Effect.ignore","Effect.map","Effect.flatMap","Stream.unwrap","ChildProcess.make","fdName","ChildProcess.fdName","Effect.forEach","Effect.gen","makeSpawner","layer","TypeId","make","Effect.map","Effect.sync","random.nextBetween","Uuid.v4String","Effect.clockWith","Effect.succeed","Uuid.v7String","Effect.fail","PlatformError.badArgument","Effect.try","PlatformError.systemError","make","layer","EffectCrypto.Crypto","layer","NodeCrypto.layer","Error.badArgument","Option.flatMap","Option.fromNullishOr","BI.toNumber","Effect.try","link","Effect.suspend","remove","Effect.acquireRelease","Effect.orDie","Effect.map","FileSystem.FileTypeId","Effect.flatMap","Effect.fail","Effect.succeed","Option.none","Option.some","Error.systemError","Effect.void","Effect.fnUntraced","Crypto","Effect.tryPromise","Effect.callback","ByteSize.bytes","Stream.callback","Effect.sync","Effect.matchEffect","Queue.offer","Cause.fail","Option.getOrElse","Stream.unwrap","FileSystem.WatchBackend","FileSystem.make","layer","FileSystem.FileSystem","layer","NodeFileSystem.layer","Effect.try","Path","TypeId","NodePath","layer","layer","NodePath.layer","TypeId","make","Effect.succeed","layer","Stdio.Stdio","layer","NodeStdio.layer","SchemaAST.toType","Effect.runSyncExit","Exit.isSuccess","Option.some","Option.none","make","InternalSchemaCause.getSchemaIssueOrThrow","decodeUnknownEffect","encodeUnknownEffect","SchemaAST.flip","InternalParser.missing","Effect.fail","SchemaIssue.InvalidValue","Effect.succeed","SchemaAST.defaultParseOptions","InternalParser.sameExit","Effect.flatMapEager","InternalParser.args","makeParser","InternalParser.toOption","InternalParser.succeed","Effect.mapEager","InternalParser.fromOptionExit","InternalParser.missingExit","SchemaAST.getConstructorDescriptor","SchemaAST.collectIssues","SchemaIssue.Composite","Effect.flatMap","Effect.catchCause","Effect.failCauseSync","Cause.map","SchemaIssue.Encoding","TypeId","Pipeable.pipeArguments","SchemaAST.annotate","SchemaAST.annotateKey","SchemaAST.appendChecks","make","SchemaParser.makeEffect","SchemaParser.make","SchemaParser.makeOption","toCodecJson","InternalMake.make","SchemaAST.replaceContextLastLink","SchemaAST.Context","SchemaAST.toEncoded","Predicate.isFunction","SchemaAST.replaceEncoding","SchemaAST.unknownToJson","SchemaAST.mapLink","SchemaAST.objectKeywordToJson","SchemaAST.parameterFromString","SchemaAST.Union","toCodecStringTree","SchemaAST.unknownToStringTree","SchemaAST.Link","SchemaAST.Literal","InternalTransformation.Transformation","isSchemaError","Predicate.hasProperty","value","TypeId","make","Proto","Hash.symbol","Hash.hash","Equal.symbol","Equal.equals","TypeId","Predicate.hasProperty","Data.Error","Data.TaggedError","Proto","Inspectable.BaseProto","Record.map","Duration.seconds","empty","Result.fail","Result.succeed","Duration.isFinite","Duration.fromInputUnsafe","Result.getOrThrow","Duration.toSeconds","toRecord","TypeId","Proto","Redactable.symbolRedactable","Context.get","Redactable.redact","Equal.symbol","Equivalence","Hash.symbol","Hash.structure","Inspectable.NodeInspectSymbol","Inspectable.BaseProto","make","empty","fromInput","setAll","Redacted.make","TypeId","Proto","Equal.symbol","Hash.symbol","Hash.array","make","Arr.fromIterable","empty","Arr.appendAll","TypeId","InternalMake.TypeId","make","SchemaAST.Declaration","SchemaAST.getAST","Effect.succeed","Effect.fail","SchemaIssue.InvalidType","Data.TaggedError","SchemaIssue.defaultFormatter","isSchemaErrorInternal","Effect.catchCause","Effect.failCauseSync","Cause_.map","Exit_.isSuccess","Exit_.failCause","Cause_.isFailReason","Effect.runSyncExit","SchemaParser.decodeUnknownEffect","SchemaParser.encodeUnknownEffect","InternalMake.make","Predicate.hasProperty","SchemaAST.optional","SchemaAST.toType","SchemaAST.toEncoded","SchemaAST.Literal","SchemaGetter.transform","SchemaAST.unknown","SchemaAST.null","SchemaAST.undefined","String","SchemaAST.string","Number","SchemaAST.number","Boolean","SchemaAST.boolean","SchemaAST.void","SchemaAST.struct","SchemaAST.record","SchemaAST.tuple","SchemaAST.Arrays","SchemaAST.union","SchemaAST.decodeTo","SchemaTransformation.make","SchemaTransformation.passthrough","SchemaGetter.forbiddenEncoding","SchemaAST.withConstructorDefault","SchemaGetter.omit","SchemaGetter.passthrough","SchemaGetter.withDefault","SchemaAST.Link","SchemaAST.makeFilter","format","SchemaAST.isPattern","SchemaAST.finite","Order.isGreaterThan","Order.isGreaterThanOrEqualTo","Order.isLessThan","Order.isLessThanOrEqualTo","Order.Number","Order.Date","Order.BigInt","SchemaTransformation.defectFromJson","RegExp","SchemaTransformation.transformEffect","Effect.try","SchemaIssue.InvalidValue","URL","SchemaTransformation.urlFromString","Date","SchemaTransformation.dateFromString","SchemaTransformation.dateFromMillis","SchemaTransformation.fromJsonString","Result_.match","Encoding.decodeBase64","Effect.tryPromise","Encoding.encodeBase64","FormData","URLSearchParams","SchemaTransformation.transform","Uint8Array","SchemaTransformation.uint8ArrayFromBase64String","BigDecimal_.Order","BigDecimal_.format","Cause_.isReason","Effect.mapBothEager","Cause_.makeFailReason","SchemaIssue.makeCompositeAtKey","Cause_.makeDieReason","Cause_.makeInterruptReason","Cause_.isCause","Cause_.fromReasons","SchemaGetter.transformEffect","Option_.match","DateTime.make","DateTime.toUtc","DateTime.formatIso","DateTime.isDateTime","DateTime.isUtc","DateTime.makeUnsafe","DateTime.toDateUtc","DateTime.toEpochMillis","Cookies_.isCookie","Cookies_.isCookies","Cookies_.fromSetCookie","Cookies_.toSetCookieHeaders","Cookies_.fromReadonlyRecord","Cookies_.toRecord","Cookies_.fromIterable","Cookies_.makeCookieUnsafe","UrlParams_.isUrlParams","UrlParams_.Equivalence","UrlParams_.make","UrlParams_.toReadonlyRecord","UrlParams_.fromInput","struct","internalOptions","Pipeable.pipeArguments","SchemaParser.make","SchemaParser.makeOption","SchemaAST.annotate","SchemaAST.annotateKey","SchemaAST.appendChecks","SchemaTransformation.Transformation","InternalAnnotations.CONSTRUCTOR_ANNOTATION_KEY","InternalAnnotations.SENTINELS_ANNOTATION_KEY","SchemaAST.collectSentinels","Error","core.Error","InternalToCodec.toCodecJson","InternalToCodec.toCodecStringTree","SchemaAST.Json","TypeId","Schema.Error","make","make","Queue.make","Effect.addFinalizer","Effect.sync","RcRef.make","Effect.acquireRelease","Queue.offerUnsafe","Effect.gen","Option.fromUndefinedOr","RcRef.get","Effect.suspend","Queue.poll","Effect.flatMap","Option.match","Effect.scoped","Effect.andThen","Queue.take","Effect.succeed","Effect.mapError","Terminal.QuitError","Effect.uninterruptible","Effect.callback","Predicate.isNullish","Effect.void","Effect.fail","Terminal.make","layer","Terminal.Terminal","layer","NodeTerminal.layer","layer","NodeChildProcessSpawner.layer","NodeFileSystem.layer","NodeCrypto.layer","NodePath.layer","NodeStdio.layer","NodeTerminal.layer","decode","Schema.decodeEffect","Schema.NonEmptyArray","Channel.fromTransform","Effect.succeed","Effect.flatMap","TypeId","Result.isSuccess","Result.succeed","value","Result.fail","when","orElse","Result.isResult","internal.value","internal.when","internal.orElse","Cause.hasInterruptsOnly","Cause.hasDies","Cause.pretty","Cause.isFailReason","Inspectable.toStringUnknown","Effect.runPromiseExit","Exit.isSuccess","Cause.isDieReason","Effect.fnUntraced","FileSystem.FileSystem","Path.Path","Schema.decodeEffect","Schema.fromJsonString","Effect.catchIf","Effect.succeed","Effect.provide","NodeServices.layer","Array.fromIterable","Array.filter","Array.sortBy","Order.mapInput","Order.String","Array.map","Array.join","String.isNonEmpty","Array.take","TypeId","Predicate.hasProperty","Data.TaggedError","Proto","Inspectable.NodeInspectSymbol","format","Empty","empty","Uint8Array","UrlParams.toString","UrlParams.fromInput","FormData","TypeId","Data.TaggedError","Schema.Error","Headers.remove","Headers.set","Data.TaggedError","make","Result.try","TypeId","Proto","Inspectable.BaseProto","redact","makeWith","empty","UrlParams.empty","Headers.empty","HttpBody.empty","make","Headers.set","Headers.setAll","UrlParams.fromInput","Option.fromNullishOr","UrlParams.setAll","UrlParams.appendAll","Option.some","bodyInternal.updateHeaders","HttpBody.formData","Url.make","Option.getOrUndefined","Result.isSuccess","Option.none","TypeId","Effect.runSync","redact","TypeId","filterStatusOk","Effect.succeed","Effect.fail","Error.HttpClientError","Error.StatusCodeError","Inspectable.Class","HttpIncomingMessage.TypeId","HttpIncomingMessage.inspect","HttpClientRequest.toUrl","Option.isNone","Headers.fromInput","Cookies.fromSetCookie","Option.none","Stream.fromReadableStream","Error.DecodeError","Stream.fail","Error.EmptyBodyError","Effect.flatMap","Effect.try","Effect.map","UrlParams.fromInput","Effect.tryPromise","Effect.cached","Effect.runSync","Proto","Headers.empty","TypeId","Headers.fromInput","Inspectable.Class","HttpIncomingMessage.TypeId","HttpClientResponse.TypeId","HttpIncomingMessage.inspect","HttpClientRequest.empty","HttpClientRequest.toUrl","Option.isNone","Headers.merge","Option.none","Stream.empty","Stream.mapError","Stream.succeed","Stream.fromReadableStream","isReadableStream","Stream.unwrap","Effect.map","Effect.flatMap","Effect.try","HttpClientError.HttpClientError","HttpClientError.DecodeError","Effect.succeed","Stream.mkUint8Array","Effect.tryPromise","textDecoder","UrlParams.fromInput","Effect.contextWith","Stream.toReadableStreamWith","Proto","ErrorReporter.ignore","redact","Cookies.empty","Body.empty","Headers.empty","headersInternal.emptyMutableUnsafe","Headers.fromRecordUnsafe","TypeId","Data.TaggedError","Respondable.symbol","ErrorReporter.ignore","Effect.succeed","Response.empty","Context.Service","Cause.StackTrace","defaultContentType","State","make","make","defaultIsFile","CT.parse","ByteSize.fromInputUnsafe","make","HP.make","Search.make","decodeField","make","internal.make","internal.defaultIsFile","internal.decodeField","TypeId","Data.Error","Data.TaggedError","ErrorReporter.ignore","HttpServerRespondable.symbol","Effect.succeed","HttpServerResponse.empty","Schema.String","Effect.withFiber","Context.get","IncomingMessage.MaxBodySize","MP.defaultIsFile","Channel.fromTransform","Effect.map","Option.none","MP.make","MP.decodeField","Channel.fromPull","Effect.suspend","Arr.isReadonlyArrayNonEmpty","Cause.done","Effect.flatMap","Option.some","Exit.fail","Option.isNone","Cause.Done","Effect.void","Effect.catchCause","Pull.isDoneCause","Exit.failCause","Option.isSome","Inspectable.Class","Stream.fromChannel","Channel.mkUint8Array","Effect.mapError","FileSystem.FileSystem","Stream.run","Effect.gen","Path.Path","Stream.runForEach","Effect.catchTag","Effect.fail","TypeId","Context.Service","Inspectable.Class","HttpIncomingMessage.TypeId","HttpIncomingMessage.inspect","Option.none","Headers.fromInput","Cookies.parseHeader","Stream.fromReadableStream","Stream.fail","Effect.runSync","Effect.cached","Effect.tryPromise","Effect.flatMap","Effect.try","UrlParams.fromInput","Multipart.toPersisted","Stream.pipeThroughChannel","Stream.mapError","Multipart.makeChannel","Effect.fail","Stream.empty","Stream.succeed","Effect.succeed","Stream.mkUint8Array","Effect.map","Stream.fromIterable","Multipart.TypeId","Headers.fromRecordUnsafe","Option.match","Effect.withFiber","Context.getUnsafe","TypeId","transformResponse","makeWith","HttpClientResponse.filterStatusOk","Proto","Inspectable.BaseProto","HttpClientRequest.make","make","Effect.flatMap","Effect.withFiber","Url.make","Option.getOrUndefined","Result.isFailure","Effect.fail","Error.HttpClientError","Error.InvalidUrlError","Tracer.DisablePropagation","Effect.uninterruptibleMask","Effect.matchCauseEffect","Effect.succeed","Cause.hasInterrupts","Effect.failCause","Effect.useSpan","Headers.CurrentRedactedNames","Headers.isRedactedName","HttpClientRequest.setHeaders","TraceContext.toHeaders","Effect.withParentSpan","Effect.map","Schedule.isSchedule","Schedule.passthrough","Effect.repeat","Effect.retry","Predicate.or","Layer.effect","Effect.contextWith","effect","Effect.updateContext","Context.merge","HttpClientResponse.TypeId","HttpIncomingMessage.TypeId","Effect.suspend","Effect.onInterrupt","Effect.sync","Stream.suspend","Stream.ensuring","Inspectable.NodeInspectSymbol","Cause.isTimeoutError","Error.isHttpClientError","Context.Service","Layer.effectDiscard","Effect.gen","Effect.isEffect","Layer.effectContext","Effect.map","Context.makeUnsafe","Layer.succeedContext","context","Effect.context","Context.getOrUndefinedUnsafe","Layer.CurrentMemoMap","Context.get","Scope.Scope","Layer.buildWithMemoMap","Layer.provide","Layer.provideMerge","Arr.empty","Arr.fromIterable","HttpMiddleware.withLoggerDisabled","HttpStatus.fromLiteral","Schema.isSchema","Predicate.hasProperty","Schema.make","SchemaAST.isVoid","SchemaAST.toEncoded","TypeId","Arr.isArrayNonEmpty","HttpApiSchema.NoContent","Proto","makeProto","HttpRouter.prefixPath","Context.add","Context.merge","make","Schema.toCodecStringTree","Context.empty","Schema.isSchema","Schema.Struct","HttpApiSchema.asFormUrlEncoded","HttpApiSchema.getPayloadEncoding","MediaType.normalize","reservedStreamFailureEvent","Arr.ensure","HttpApiSchema.isStreamSchema","HttpApiSchema.isWithHeaders","HttpApiSchema.getResponseEncodingSchema","HttpApiSchema.rebuildWithHeaders","HttpApiSchema.getStatusErrorSchema","HttpApiSchema.getStatusSuccessSchema","HttpApiSchema.isNoContent","HttpApiSchema.getWithHeadersAnnotation","HttpApiSchema.isStreamSse","AST.toEncoded","AST.isUnion","AST.isSuspend","AST.isObjects","AST.isLiteral","HttpApiSchema.getResponseEncoding","Schema.toEncoded","Schema.decodeTo","Schema.toCodecJson","TypeId","Proto","makeProto","Context.merge","Record.map","Context.add","make","Context.empty","HttpApiEndpoint.getSuccessSchemas","HttpApiSchema.getStatusSuccessSchema","HttpApiEndpoint.getErrorSchemas","HttpApiSchema.getStatusErrorSchema","HttpApiSchema.isWithHeaders","HttpApiSchema.isStreamSchema","Context.Service","Data.TaggedError","Channel.fromTransform","Effect.sync","Effect.flatMap","Effect.fail","Effect.void","Effect.suspend","Arr.isArrayNonEmpty","Effect.succeed","Channel.pipeTo","ChannelSchema.decode","Schema.decodeTo","Duration.millis","Schema.String","Data.TaggedClass","Result.succeed","Result.fail","Effect.gen","Effect.context","HttpClient.mapRequest","HttpClientRequest.prependUrl","Effect.flatMap","Effect.catchCause","Effect.failCause","Cause.combine","Cause.fail","HttpClientError.HttpClientError","HttpClientError.StatusCodeError","Effect.fail","HttpApiSchema.getStatusSuccessSchema","UndefinedOr.map","Schema.encodeUnknownEffect","HttpApiEndpoint.getPayloadSchemas","Arr.isArrayNonEmpty","HttpMethod.hasBody","Schema.Union","Effect.fnUntraced","HttpClientRequest.make","HttpClientRequest.setUrl","HttpClientRequest.bodyFormData","HttpClientRequest.setBody","HttpClientRequest.appendUrlParams","HttpClientRequest.setHeaders","Effect.as","HttpApiSchema.isWithHeaders","HttpApiSchema.getWithHeadersAnnotation","Schema.decodeEffect","isWithHeaders","Schema.Struct","Schema.decodeTo","Schema.Unknown","Schema.toType","SchemaTransformation.transform","HttpApiSchema.withHeaders","MediaType.normalize","HttpApiSchema.isNoContent","HttpApiSchema.getResponseEncodingSchema","HttpClientError.DecodeError","HttpApiSchema.isStreamSchema","HttpApiSchema.isStreamUint8Array","Effect.map","Stream.provideContext","Schema.decodeUnknownEffect","Schema.Literal","Schema.fromJsonString","Schema.toCodecJson","Schema.Cause","Schema.Defect","Sse.decodeSchema","Stream.transformPull","Stream.decodeText","Stream.pipeThroughChannel","Effect.sync","Effect.suspend","Cause.isCause","Effect.succeed","Stream.map","ArrayBuffer","Schema.Uint8Array","Schema.String","Schema.Undefined","Schema.UnknownFromJsonString","HttpApiSchema.getResponseEncoding","SchemaAST.isNull","SchemaAST.toEncoded","Schema.RecordFromUrlParams","UrlParams.fromInput","UrlParams.toString","HttpBody.isHttpBody","HttpApiSchema.getPayloadEncoding","SchemaTransformation.transformEffect","SchemaIssue.Forbidden","HttpBody.text","SchemaIssue.InvalidValue","Predicate.isObject","HttpBody.urlParams","HttpBody.uint8Array","Record.map","Context.merge","Context.add","Context.empty","S.Struct","S.optional","S.NullOr","S.String","S.Number","S.DateFromMillis","S.Array","S.Union","S.Literal","HttpApi.make","HttpApiGroup.make","HttpApiEndpoint.get","Array.filter","Array.sortWith","Order.Number","BAR_WIDTH","Match.value","Match.when","Match.orElse","Array.zipWith","Context.Service","Context.getOrUndefined","Headers.merge","Headers.fromInput","Headers.remove","Effect.map","Effect.tryPromise","HttpClientError.HttpClientError","HttpClientError.TransportError","HttpClientResponse.fromWeb","Effect.flatMap","Stream.toReadableStreamEffect","S.Struct","S.optional","S.NullOr","S.Number","S.String","S.Boolean","S.Union","S.Array","HttpApi.make","HttpApiGroup.make","HttpApiEndpoint.get","S.Struct","S.Number","S.optional","S.NullOr","S.Boolean","S.String","S.Array","HttpApi.make","HttpApiGroup.make","HttpApiEndpoint.get","Schema.TaggedError","Schema.Literals","Schema.String","Schema.optional","Schema.Defect","Cause.isTimeoutError","Data.taggedEnum","Effect.fnUntraced","Effect.fromResult","Encoding.decodeBase64UrlString","String.split","Array.get","Option.getOrElse","Schema.decodeEffect","Schema.fromJsonString","Schema.Struct","Context.Service","HttpClient.HttpClient","HttpClient.mapRequest","HttpClientRequest.acceptJson","HttpClient.filterStatusOk","HttpClient.retryTransient","Schedule.jittered","Schedule.exponential","Effect.tryPromise","Effect.succeed","Effect.orElseSucceed","Effect.fn","HttpApiClient.makeWith","HttpClientRequest.setHeaders","Effect.all","Effect.timeout","Effect.mapError","HttpClientRequest.bearerToken","Layer.effect","Layer.provide","FetchHttpClient.layer","Array.zip","Schema.Struct","Schema.withDecodingDefault","Effect.succeed","Effect.map","Effect.catch","Schema.decodeUnknownSync","Effect.gen","Effect.provide","Record.keys","Effect.all","Effect.tap","Effect.sync"],"sources":["../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Pipeable.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Function.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/equal.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Predicate.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Hash.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Equal.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Redactable.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Formatter.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Inspectable.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/stackTraceLimit.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Utils.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/record.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/core.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Effectable.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Equivalence.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/option.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/result.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Order.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Option.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Context.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/array.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/count.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Result.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Tuple.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Record.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Array.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Duration.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Scheduler.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Data.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Encoding.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Tracer.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/metric.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/references.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/tracer.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/effect.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Deferred.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Scope.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Layer.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Exit.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Cause.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/dateTime.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/String.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/random.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Pull.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Schedule.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/layer.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schedule.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Effect.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/BigInt.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/ByteSize.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/PlatformError.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Fiber.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Latch.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/MutableRef.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/MutableList.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Queue.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Semaphore.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Channel.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/stream.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Sink.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/rcRef.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/RcRef.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Stream.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/FileSystem.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Path.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schema/annotations.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schema/parser.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/SchemaIssue.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schema/cause.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/DateTime.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/SchemaGetter.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/BigDecimal.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/SchemaTransformation.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/SchemaAST.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Brand.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/process/ChildProcessSpawner.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/process/ChildProcess.js","../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/internal/nodeChildProcessSpawner.js","../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/internal/utils.js","../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeSink.js","../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeStream.js","../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeChildProcessSpawner.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/uuid.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Crypto.js","../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeCrypto.js","../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.0_/node_modules/@effect/platform-node/dist/NodeCrypto.js","../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeFileSystem.js","../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.0_/node_modules/@effect/platform-node/dist/NodeFileSystem.js","../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodePath.js","../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.0_/node_modules/@effect/platform-node/dist/NodePath.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Stdio.js","../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeStdio.js","../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.0_/node_modules/@effect/platform-node/dist/NodeStdio.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/SchemaParser.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schema/make.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schema/toCodec.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Struct.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/schemaError.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/redacted.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Redacted.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/Cookies.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/Headers.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/UrlParams.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Schema.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Terminal.js","../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeTerminal.js","../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.0_/node_modules/@effect/platform-node/dist/NodeTerminal.js","../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.0_/node_modules/@effect/platform-node/dist/NodeServices.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/ChannelSchema.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/ErrorReporter.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/matcher.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Match.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/UndefinedOr.js","../../../tooling/shared/src/run.ts","../../../tooling/shared/src/config.ts","../../../tooling/shared/src/statusline.ts","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpBody.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpClientError.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpMethod.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/internal/httpBody.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/Url.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpClientRequest.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpIncomingMessage.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpClientResponse.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/internal/headers.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpServerResponse.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpServerRespondable.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpServerError.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/MultipartParser/internal/contentType.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/MultipartParser/internal/headers.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/MultipartParser/internal/search.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/MultipartParser/internal/multipart.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/MultipartParser.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/Multipart.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpServerRequest.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpTraceContext.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpMiddleware.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpClient.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpRouter.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/HttpStatus.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/httpapi/HttpApiSchema.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/httpapi/internal/mediaType.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/httpapi/HttpApiEndpoint.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/httpapi/HttpApi.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/encoding/Sse.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/httpapi/HttpApiClient.js","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/httpapi/HttpApiGroup.js","../src/provider/zai.ts","../src/reset.ts","../src/render.ts","../../../node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/unstable/http/FetchHttpClient.js","../src/provider/anthropic.ts","../src/provider/openai.ts","../src/service.ts","../src/widget.ts","../src/index.ts"],"sourcesContent":["/**\n * The `Pipeable` module defines the shared interface and implementation helpers\n * for values that support Effect-style method chaining with `.pipe(...)`.\n *\n * A `Pipeable` value can pass itself through a sequence of unary functions from\n * left to right, so code can be written as `value.pipe(f, g, h)` instead of\n * deeply nesting calls. This is the method form used by many Effect data types\n * to compose transformations, validations, and effectful operations while\n * keeping the original value as the starting point of the pipeline.\n *\n * @since 2.0.0\n */\n/**\n * Applies a `pipe` method's variadic arguments to an initial value from left\n * to right.\n *\n * **When to use**\n *\n * Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`\n * object.\n *\n * **Details**\n *\n * This helper is intended for implementing `Pipeable.pipe` methods that\n * receive JavaScript's `arguments` object. With no functions it returns the\n * original value; otherwise it feeds each result into the next function.\n *\n * **Example** (Implementing a pipe method)\n *\n * ```ts import.meta.vitest\n * import { Pipeable } from \"effect\"\n *\n * class NumberBox {\n * constructor(readonly value: number) {}\n *\n * pipe(..._fns: ReadonlyArray<(value: number) => number>): number {\n * return Pipeable.pipeArguments(this.value, arguments) as number\n * }\n * }\n *\n * const result = new NumberBox(5).pipe(\n * (n) => n + 2,\n * (n) => n * 3\n * )\n * result // => 21\n * ```\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const pipeArguments = (self, args) => {\n switch (args.length) {\n case 0:\n return self;\n case 1:\n return args[0](self);\n case 2:\n return args[1](args[0](self));\n case 3:\n return args[2](args[1](args[0](self)));\n case 4:\n return args[3](args[2](args[1](args[0](self))));\n case 5:\n return args[4](args[3](args[2](args[1](args[0](self)))));\n case 6:\n return args[5](args[4](args[3](args[2](args[1](args[0](self))))));\n case 7:\n return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));\n case 8:\n return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));\n case 9:\n return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));\n default:\n {\n let ret = self;\n for (let i = 0, len = args.length; i < len; i++) {\n ret = args[i](ret);\n }\n return ret;\n }\n }\n};\n/**\n * Reusable prototype that implements `Pipeable.pipe`.\n *\n * **When to use**\n *\n * Use when classes or object prototypes can reuse this value when they need the\n * standard pipe implementation backed by `pipeArguments`.\n *\n * @category prototypes\n * @since 3.15.0\n */\nexport const Prototype = {\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n/**\n * Provides a base constructor whose instances implement the standard `Pipeable.pipe`\n * method.\n *\n * **When to use**\n *\n * Use when you need to define a class that supports Effect-style method\n * chaining through `.pipe(...)`.\n *\n * @category constructors\n * @since 3.15.0\n */\nexport const Class = /*#__PURE__*/function () {\n function PipeableBase() {}\n PipeableBase.prototype = Prototype;\n return PipeableBase;\n}();\n/**\n * Returns a subclass of the provided class that adds the standard `pipe`\n * method.\n *\n * **When to use**\n *\n * Use to add pipe support to an existing class without extending a base class\n * or modifying its prototype.\n *\n * **Details**\n *\n * The original constructor and instance members are preserved, and the added\n * method delegates to `pipeArguments`.\n *\n * @see {@link Prototype} for a reusable prototype object\n * @see {@link Class} for a base constructor to extend\n * @category constructors\n * @since 4.0.0\n */\nexport const Mixin = klass => class extends klass {\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n//# sourceMappingURL=Pipeable.js.map","import { pipeArguments } from \"./Pipeable.js\";\n/**\n * Creates a function that can be called in data-first style or data-last\n * (`pipe`-friendly) style.\n *\n * **When to use**\n *\n * Use to expose one implementation through both direct and `pipe`-friendly\n * call styles.\n *\n * **Details**\n *\n * Pass either the arity of the uncurried function or a predicate that decides\n * whether the current call is data-first. Arity is the common case. Use a\n * predicate when optional arguments make arity ambiguous.\n *\n * **Example** (Selecting data-first or data-last style by arity)\n *\n * ```ts import.meta.vitest\n * import { Function, pipe } from \"effect\"\n *\n * const sum = Function.dual<\n * (that: number) => (self: number) => number,\n * (self: number, that: number) => number\n * >(2, (self, that) => self + that)\n *\n * sum(2, 3) // => 5\n * pipe(2, sum(3)) // => 5\n * ```\n *\n * **Example** (Defining overloads with call signatures)\n *\n * ```ts import.meta.vitest\n * import { Function, pipe } from \"effect\"\n *\n * const sum: {\n * (that: number): (self: number) => number\n * (self: number, that: number): number\n * } = Function.dual(2, (self: number, that: number): number => self + that)\n *\n * sum(2, 3) // => 5\n * pipe(2, sum(3)) // => 5\n * ```\n *\n * **Example** (Selecting data-first or data-last style with a predicate)\n *\n * ```ts import.meta.vitest\n * import { Function, pipe } from \"effect\"\n *\n * const sum = Function.dual<\n * (that: number) => (self: number) => number,\n * (self: number, that: number) => number\n * >(\n * (args) => args.length === 2,\n * (self, that) => self + that\n * )\n *\n * sum(2, 3) // => 5\n * pipe(2, sum(3)) // => 5\n * ```\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const dual = function (arity, body) {\n if (typeof arity === \"function\") {\n return function () {\n return arity(arguments) ? body.apply(this, arguments) : self => body(self, ...arguments);\n };\n }\n switch (arity) {\n case 0:\n case 1:\n throw new RangeError(`Invalid arity ${arity}`);\n case 2:\n return function (a, b) {\n if (arguments.length >= 2) {\n return body(a, b);\n }\n return function (self) {\n return body(self, a);\n };\n };\n case 3:\n return function (a, b, c) {\n if (arguments.length >= 3) {\n return body(a, b, c);\n }\n return function (self) {\n return body(self, a, b);\n };\n };\n default:\n return function () {\n if (arguments.length >= arity) {\n // @ts-expect-error\n return body.apply(this, arguments);\n }\n const args = arguments;\n return function (self) {\n return body(self, ...args);\n };\n };\n }\n};\n/**\n * Applies a function to a given value.\n *\n * **When to use**\n *\n * Use to pass a fixed value into a unary function, especially when the function\n * is the value flowing through `pipe`.\n *\n * **Details**\n *\n * `apply(a)(f)` is equivalent to `f(a)`.\n *\n * **Example** (Applying an argument to a function)\n *\n * ```ts import.meta.vitest\n * import { Function, pipe, String } from \"effect\"\n *\n * pipe(String.length, Function.apply(\"hello\")) // => 5\n * ```\n *\n * @see {@link pipe} for building left-to-right pipelines\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const apply = a => self => self(a);\n/**\n * Returns its input argument unchanged.\n *\n * **When to use**\n *\n * Use to return a value unchanged where a function is required.\n *\n * **Example** (Returning the same value)\n *\n * ```ts import.meta.vitest\n * import { identity } from \"effect\"\n *\n * identity(5) // => 5\n * ```\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const identity = a => a;\n/**\n * Ensures that the type of an expression matches some type,\n * without changing the resulting type of that expression.\n *\n * **When to use**\n *\n * Use to check assignability while preserving the expression's precise inferred\n * type.\n *\n * **Example** (Checking an expression against a type)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * const test1 = Function.satisfies()(5 as const) // => 5\n * // ^? const test: 5\n * // @ts-expect-error\n * const test2 = Function.satisfies()(5)\n * // ^? Argument of type 'number' is not assignable to parameter of type 'string'\n * ```\n *\n * @see {@link cast} for changing only the static TypeScript type\n *\n * @category utility types\n * @since 2.0.0\n */\nexport const satisfies = () => b => b;\n/**\n * Returns the input value with a different static type.\n *\n * **When to use**\n *\n * Use when you need an explicit type-level cast and accept that the value is\n * returned unchanged at runtime.\n *\n * **Gotchas**\n *\n * This is a type-level cast only; it performs no runtime validation or\n * conversion.\n *\n * @see {@link satisfies} for checking assignability without changing the resulting type\n *\n * @category utility types\n * @since 4.0.0\n */\nexport const cast = identity;\n/**\n * Creates a zero-argument function that always returns the provided value.\n *\n * **When to use**\n *\n * Use when you need a thunk or callback that returns the same value on every\n * invocation.\n *\n * **Example** (Creating a constant thunk)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * const constNull = Function.constant(null)\n *\n * constNull() // => null\n * constNull() // => null\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const constant = value => () => value;\n/**\n * Returns `true` when called.\n *\n * **When to use**\n *\n * Use when you need a thunk that returns `true` on every invocation.\n *\n * **Example** (Returning true from a thunk)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * Function.constTrue() // => true\n * ```\n *\n * @category constants\n * @since 2.0.0\n */\nexport const constTrue = /*#__PURE__*/constant(true);\n/**\n * Returns `false` when called.\n *\n * **When to use**\n *\n * Use when you need a thunk that returns `false` on every invocation.\n *\n * **Example** (Returning false from a thunk)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * Function.constFalse() // => false\n * ```\n *\n * @category constants\n * @since 2.0.0\n */\nexport const constFalse = /*#__PURE__*/constant(false);\n/**\n * Returns `null` when called.\n *\n * **When to use**\n *\n * Use when you need a thunk that returns `null` on every invocation.\n *\n * **Example** (Returning null from a thunk)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * Function.constNull() // => null\n * ```\n *\n * @category constants\n * @since 2.0.0\n */\nexport const constNull = /*#__PURE__*/constant(null);\n/**\n * Returns `undefined` when called.\n *\n * **When to use**\n *\n * Use when you need a thunk that returns `undefined` on every invocation.\n *\n * **Example** (Returning undefined from a thunk)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * Function.constUndefined() // => undefined\n * ```\n *\n * @category constants\n * @since 2.0.0\n */\nexport const constUndefined = /*#__PURE__*/constant(undefined);\n/**\n * Returns no meaningful value when called.\n *\n * **When to use**\n *\n * Use when you need a thunk that is called only for its effect and has no\n * meaningful return value.\n *\n * **Example** (Returning void from a thunk)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * Function.constVoid() // => undefined\n * ```\n *\n * @category constants\n * @since 2.0.0\n */\nexport const constVoid = constUndefined;\n/**\n * Reverses the order of arguments for a curried function.\n *\n * **When to use**\n *\n * Use to adapt a curried function when its argument groups need to be supplied\n * in the opposite order.\n *\n * **Example** (Flipping curried arguments)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * const f = (a: number) => (b: string) => a - b.length\n *\n * Function.flip(f)(\"aaa\")(2) // => -1\n * ```\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const flip = f => (...b) => (...a) => f(...a)(...b);\n/**\n * Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.\n * The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.\n *\n * **When to use**\n *\n * Use to compose exactly two unary functions into a reusable unary function.\n *\n * **Example** (Composing two functions)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * const increment = (n: number) => n + 1\n * const square = (n: number) => n * n\n *\n * Function.compose(increment, square)(2) // => 9\n * ```\n *\n * @see {@link flow} for composing a left-to-right sequence of functions\n * @see {@link pipe} for applying a value through a left-to-right sequence immediately\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const compose = /*#__PURE__*/dual(2, (ab, bc) => a => bc(ab(a)));\n/**\n * Marks an impossible branch by accepting a `never` value and returning any\n * type.\n *\n * **When to use**\n *\n * Use when you need a return value in a branch that exhaustive checks prove\n * cannot be reached.\n *\n * **Gotchas**\n *\n * Calling `absurd` throws, because a value of type `never` should be\n * impossible at runtime.\n *\n * **Example** (Handling impossible values)\n *\n * ```ts import.meta.vitest\n * import { absurd } from \"effect\"\n *\n * const handleNever = (value: never) => {\n * return absurd(value) // This will throw an error if called\n * }\n * ```\n *\n * @category utility types\n * @since 2.0.0\n */\nexport const absurd = _ => {\n throw new Error(\"Called `absurd` function which should be uncallable\");\n};\n/**\n * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.\n *\n * **When to use**\n *\n * Use to adapt a multi-argument function so it accepts one tuple argument.\n *\n * **Example** (Converting arguments to a tuple)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * const sumTupled = Function.tupled((x: number, y: number): number => x + y)\n *\n * sumTupled([1, 2]) // => 3\n * ```\n *\n * @see {@link untupled} for adapting a tuple-argument function back to multiple arguments\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const tupled = f => a => f(...a);\n/**\n * Converts a tupled function back to an uncurried function.\n *\n * **When to use**\n *\n * Use to adapt a tuple-argument function so it accepts multiple arguments.\n *\n * **Example** (Converting a tuple to arguments)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * const getFirst = Function.untupled((tuple: [A, B]): A => tuple[0])\n *\n * getFirst(1, 2) // => 1\n * ```\n *\n * @see {@link tupled} for adapting a multi-argument function to one tuple argument\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const untupled = f => (...a) => f(a);\nexport function pipe(a, ...args) {\n return pipeArguments(a, args);\n}\nexport function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {\n switch (arguments.length) {\n case 1:\n return ab;\n case 2:\n return function () {\n return bc(ab.apply(this, arguments));\n };\n case 3:\n return function () {\n return cd(bc(ab.apply(this, arguments)));\n };\n case 4:\n return function () {\n return de(cd(bc(ab.apply(this, arguments))));\n };\n case 5:\n return function () {\n return ef(de(cd(bc(ab.apply(this, arguments)))));\n };\n case 6:\n return function () {\n return fg(ef(de(cd(bc(ab.apply(this, arguments))))));\n };\n case 7:\n return function () {\n return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));\n };\n case 8:\n return function () {\n return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));\n };\n case 9:\n return function () {\n return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));\n };\n }\n return;\n}\n/**\n * Creates a compile-time placeholder for a value of any type.\n *\n * **When to use**\n *\n * Use as a temporary typed placeholder while developing incomplete code.\n *\n * **Gotchas**\n *\n * `hole` is intended for temporary development use. If the placeholder is\n * evaluated at runtime, it throws.\n *\n * **Example** (Creating a development placeholder)\n *\n * ```ts import.meta.vitest\n * import { hole } from \"effect\"\n *\n * // Intentionally not called: `hole` throws if the placeholder is evaluated.\n * const buildUser = (id: number): { readonly id: number; readonly name: string } => ({\n * id,\n * name: hole()\n * })\n *\n * ```\n *\n * @category utility types\n * @since 2.0.0\n */\nexport const hole = /*#__PURE__*/cast(absurd);\n/**\n * Returns the second argument and discards the first. The SK combinator is\n * a fundamental combinator in the lambda calculus and the SKI combinator\n * calculus.\n *\n * **When to use**\n *\n * Use to discard the first argument and return the second argument.\n *\n * **Example** (Discarding the first argument)\n *\n * ```ts import.meta.vitest\n * import { Function } from \"effect\"\n *\n * Function.SK(0, \"hello\") // => \"hello\"\n * ```\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const SK = (_, b) => b;\n/**\n * Creates a memoized function whose input is an object, caching results by\n * object identity.\n *\n * **When to use**\n *\n * Use to reuse the result of a synchronous computation whose output is stable\n * for a given object reference.\n *\n * **Details**\n *\n * Each memoized wrapper owns a private `WeakMap` keyed by object identity.\n *\n * **Gotchas**\n *\n * `undefined` is reserved to represent a cache miss and is therefore not\n * supported as a return value.\n *\n * Structurally equal objects do not share cache entries. If the same object is\n * mutated after its first call, later calls still return the cached result for\n * that reference.\n *\n * @category caching\n * @since 4.0.0\n */\nexport function memoize(f) {\n const cache = new WeakMap();\n return a => {\n const cached = cache.get(a);\n if (cached !== undefined) return cached;\n const result = f(a);\n cache.set(a, result);\n return result;\n };\n}\n/**\n * Creates a memoized idempotent object transformation that caches both inputs\n * and their outputs by object identity.\n *\n * **When to use**\n *\n * Use when an object transformation is idempotent and its output can be safely\n * reused as a fixed point.\n *\n * **Details**\n *\n * After computing an input, the returned function caches both the input and\n * the output. Calling it with either reference returns the output without\n * invoking the supplied function again.\n *\n * **Gotchas**\n *\n * The returned function treats each computed output as a fixed point. If\n * applying the supplied function to an output would produce an observably\n * different value, this memoization changes that behavior.\n *\n * @see {@link memoize} for memoizing functions without an idempotence requirement\n * @category caching\n * @since 4.0.0\n */\nexport function memoizeIdempotent(f) {\n const cache = new WeakMap();\n return a => {\n const cached = cache.get(a);\n if (cached !== undefined) return cached;\n const result = f(a);\n cache.set(a, result);\n cache.set(result, result);\n return result;\n };\n}\n//# sourceMappingURL=Function.js.map","/** @internal */\nexport const getAllObjectKeys = obj => {\n const keys = new Set(Reflect.ownKeys(obj));\n if (obj.constructor === Object) return keys;\n if (obj instanceof Error) {\n keys.delete(\"stack\");\n }\n const proto = Object.getPrototypeOf(obj);\n let current = proto;\n while (current !== null && current !== Object.prototype) {\n const ownKeys = Reflect.ownKeys(current);\n for (let i = 0; i < ownKeys.length; i++) {\n keys.add(ownKeys[i]);\n }\n current = Object.getPrototypeOf(current);\n }\n if (keys.has(\"constructor\") && typeof obj.constructor === \"function\" && proto === obj.constructor.prototype) {\n keys.delete(\"constructor\");\n }\n return keys;\n};\n/** @internal */\nexport const byReferenceInstances = /*#__PURE__*/new WeakSet();\n//# sourceMappingURL=equal.js.map","/**\n * Defines runtime checks for values.\n *\n * A `Predicate` returns `true` or `false` for an `A`. A\n * `Refinement` is a predicate that also narrows the TypeScript type when\n * it succeeds. This module includes guards for common JavaScript values,\n * property and tag checks, tuple and struct checks, boolean combinators, and\n * helpers for composing predicates and refinements.\n *\n * @since 2.0.0\n */\nimport { dual } from \"./Function.js\";\n/**\n * Transforms the input of a predicate using a mapping function.\n *\n * **When to use**\n *\n * Use when you have a predicate on `A` and want to check `B` values by mapping\n * each `B` to an `A`, such as checking lengths or projections.\n *\n * **Details**\n *\n * Returns a new predicate that applies `f` before `self`. There is no\n * additional short-circuiting beyond what `self` does.\n *\n * **Example** (Checking string length)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const isLongerThan2 = Predicate.mapInput((s: string) => s.length)(\n * (n: number) => n > 2\n * )\n *\n * isLongerThan2(\"hello\") // => true\n * ```\n *\n * @see {@link Predicate}\n * @see {@link and}\n * @see {@link not}\n * @category combinators\n * @since 2.0.0\n */\nexport const mapInput = /*#__PURE__*/dual(2, (self, f) => b => self(f(b)));\n/**\n * Checks whether a readonly array has exactly `n` elements.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard for exact tuple length that narrows\n * `ReadonlyArray` to `TupleOf`.\n *\n * **Details**\n *\n * This only checks length, not element types, and returns a refinement on the\n * array type.\n *\n * **Example** (Checking exact length)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const isPair = Predicate.isTupleOf(2)\n *\n * isPair([1, 2]) // => true\n * ```\n *\n * @see {@link isTupleOfAtLeast}\n * @see {@link Tuple}\n * @category guards\n * @since 3.3.0\n */\nexport const isTupleOf = /*#__PURE__*/dual(2, (self, n) => self.length === n);\n/**\n * Checks whether a readonly array has at least `n` elements.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard for tuple-like minimum length that\n * narrows `ReadonlyArray` to `TupleOfAtLeast`.\n *\n * **Details**\n *\n * This only checks length, not element types, and returns a refinement on the\n * array type.\n *\n * **Example** (Checking minimum length)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const hasAtLeast2 = Predicate.isTupleOfAtLeast(2)\n *\n * hasAtLeast2([1, 2, 3]) // => true\n * ```\n *\n * @see {@link isTupleOf}\n * @see {@link Tuple}\n * @category guards\n * @since 3.3.0\n */\nexport const isTupleOfAtLeast = /*#__PURE__*/dual(2, (self, n) => self.length >= n);\n/**\n * Checks whether a value is truthy.\n *\n * **When to use**\n *\n * Use when you want a predicate that mirrors JavaScript truthiness and filters\n * out falsy values like `0`, `\"\"`, and `false`.\n *\n * **Details**\n *\n * This uses `!!input` and treats `0`, `\"\"`, `false`, `null`, and `undefined`\n * as false.\n *\n * **Example** (Filtering truthy values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const values = [0, 1, \"\", \"ok\", false]\n * const truthy = values.filter(Predicate.isTruthy) // => [1, \"ok\"]\n * ```\n *\n * @see {@link isNullish}\n * @see {@link isNotNullish}\n * @category predicates\n * @since 2.0.0\n */\nexport function isTruthy(input) {\n return !!input;\n}\n/**\n * Checks whether a value is a `Set`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` runtime guard for `Set` values.\n *\n * **Details**\n *\n * Uses `instanceof Set`.\n *\n * **Example** (Guarding a Set)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = new Set([1, 2])\n *\n * if (Predicate.isSet(data)) {\n * data.size // => 2\n * }\n * ```\n *\n * @see {@link isMap}\n * @see {@link isIterable}\n * @category guards\n * @since 2.0.0\n */\nexport function isSet(input) {\n return input instanceof Set;\n}\n/**\n * Checks whether a value is a `Map`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` runtime guard for `Map` values.\n *\n * **Details**\n *\n * Uses `instanceof Map`.\n *\n * **Example** (Guarding a Map)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = new Map([[\"a\", 1]])\n *\n * if (Predicate.isMap(data)) {\n * data.size // => 1\n * }\n * ```\n *\n * @see {@link isSet}\n * @see {@link isIterable}\n * @category guards\n * @since 2.0.0\n */\nexport function isMap(input) {\n return input instanceof Map;\n}\n/**\n * Checks whether a value is a `string`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard to narrow an `unknown` value to a\n * string.\n *\n * **Details**\n *\n * Uses `typeof input === \"string\"`.\n *\n * **Example** (Guarding strings)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = \"hi\"\n *\n * if (Predicate.isString(data)) {\n * data.toUpperCase() // => \"HI\"\n * }\n * ```\n *\n * @see {@link isNumber}\n * @see {@link isBoolean}\n * @see {@link Refinement}\n * @category guards\n * @since 2.0.0\n */\nexport function isString(input) {\n return typeof input === \"string\";\n}\n/**\n * Checks whether a value is a `number`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard to narrow an `unknown` value to a\n * number.\n *\n * **Details**\n *\n * Uses `typeof input === \"number\"` and does not exclude `NaN` or `Infinity`.\n *\n * **Example** (Guarding numbers)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = 42\n *\n * if (Predicate.isNumber(data)) {\n * data + 1 // => 43\n * }\n * ```\n *\n * @see {@link isBigInt}\n * @see {@link isString}\n * @category guards\n * @since 2.0.0\n */\nexport function isNumber(input) {\n return typeof input === \"number\";\n}\n/**\n * Checks whether a value is a `boolean`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard to narrow an `unknown` value to a\n * boolean.\n *\n * **Details**\n *\n * Uses `typeof input === \"boolean\"`.\n *\n * **Example** (Guarding booleans)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = true\n *\n * if (Predicate.isBoolean(data)) {\n * data ? \"yes\" : \"no\" // => \"yes\"\n * }\n * ```\n *\n * @see {@link isString}\n * @see {@link isNumber}\n * @category guards\n * @since 2.0.0\n */\nexport function isBoolean(input) {\n return typeof input === \"boolean\";\n}\n/**\n * Checks whether a value is a `bigint`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard to narrow an `unknown` value to a\n * bigint.\n *\n * **Details**\n *\n * Uses `typeof input === \"bigint\"`.\n *\n * **Example** (Guarding bigints)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = 1n\n *\n * if (Predicate.isBigInt(data)) {\n * data + 2n // => 3n\n * }\n * ```\n *\n * @see {@link isNumber}\n * @category guards\n * @since 2.0.0\n */\nexport function isBigInt(input) {\n return typeof input === \"bigint\";\n}\n/**\n * Checks whether a value is a `symbol`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard to narrow an `unknown` value to a\n * symbol.\n *\n * **Details**\n *\n * Uses `typeof input === \"symbol\"`.\n *\n * **Example** (Guarding symbols)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = Symbol.for(\"id\")\n *\n * if (Predicate.isSymbol(data)) {\n * data.description // => \"id\"\n * }\n * ```\n *\n * @see {@link isPropertyKey}\n * @category guards\n * @since 2.0.0\n */\nexport function isSymbol(input) {\n return typeof input === \"symbol\";\n}\n/**\n * Checks whether a value is a valid `PropertyKey` (string, number, or symbol).\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard for unknown property keys before\n * indexing.\n *\n * **Details**\n *\n * Uses `isString`, `isNumber`, and `isSymbol`.\n *\n * **Example** (Guarding property keys)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const key: unknown = \"name\"\n * const obj: Record = { name: \"Ada\" }\n *\n * if (Predicate.isPropertyKey(key) && key in obj) {\n * obj[key] // => \"Ada\"\n * }\n * ```\n *\n * @see {@link isString}\n * @see {@link isNumber}\n * @see {@link isSymbol}\n * @category guards\n * @since 4.0.0\n */\nexport function isPropertyKey(u) {\n return isString(u) || isNumber(u) || isSymbol(u);\n}\n/**\n * Checks whether a value is a `function`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard to narrow an `unknown` value to a\n * callable function.\n *\n * **Details**\n *\n * Uses `typeof input === \"function\"`.\n *\n * **Example** (Guarding functions)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = () => 1\n *\n * if (Predicate.isFunction(data)) {\n * data() // => 1\n * }\n * ```\n *\n * @see {@link isObjectKeyword}\n * @category guards\n * @since 2.0.0\n */\nexport function isFunction(input) {\n return typeof input === \"function\";\n}\n/**\n * Checks whether a value is `undefined`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard for values that are exactly\n * `undefined`.\n *\n * **Details**\n *\n * Uses `input === undefined`.\n *\n * **Example** (Guarding undefined values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = undefined\n *\n * Predicate.isUndefined(data) // => true\n * ```\n *\n * @see {@link isNotUndefined}\n * @see {@link isNullish}\n * @category guards\n * @since 2.0.0\n */\nexport function isUndefined(input) {\n return input === undefined;\n}\n/**\n * Checks whether a value is not `undefined`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` refinement that filters out `undefined`\n * while preserving other falsy values.\n *\n * **Details**\n *\n * Returns a refinement that excludes `undefined`.\n *\n * **Example** (Filtering undefined values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const values = [1, undefined, 2]\n * const defined = values.filter(Predicate.isNotUndefined) // => [1, 2]\n * ```\n *\n * @see {@link isUndefined}\n * @see {@link isNotNullish}\n * @category guards\n * @since 2.0.0\n */\nexport function isNotUndefined(input) {\n return input !== undefined;\n}\n/**\n * Checks whether a value is `null`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard for nullable values.\n *\n * **Details**\n *\n * Uses `input === null`.\n *\n * **Example** (Guarding null values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = null\n *\n * Predicate.isNull(data) // => true\n * ```\n *\n * @see {@link isNotNull}\n * @see {@link isNullish}\n * @category guards\n * @since 2.0.0\n */\nexport function isNull(input) {\n return input === null;\n}\n/**\n * Checks whether a value is not `null`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` refinement that filters out `null` while\n * preserving other falsy values.\n *\n * **Details**\n *\n * Returns a refinement that excludes `null`.\n *\n * **Example** (Filtering null values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const values = [1, null, 2]\n * const nonNull = values.filter(Predicate.isNotNull) // => [1, 2]\n * ```\n *\n * @see {@link isNull}\n * @see {@link isNotNullish}\n * @category guards\n * @since 2.0.0\n */\nexport function isNotNull(input) {\n return input !== null;\n}\n/**\n * Checks whether a value is `null` or `undefined`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard for nullish values.\n *\n * **Details**\n *\n * Uses `input === null || input === undefined`.\n *\n * **Example** (Guarding nullish values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const values = [0, null, \"\", undefined]\n * const nullish = values.filter(Predicate.isNullish) // => [null, undefined]\n * ```\n *\n * @see {@link isNotNullish}\n * @see {@link isUndefined}\n * @see {@link isNull}\n * @category guards\n * @since 4.0.0\n */\nexport function isNullish(input) {\n return input === null || input === undefined;\n}\n/**\n * Checks whether a value is not `null` and not `undefined`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` refinement that filters out nullish values\n * but keeps other falsy ones.\n *\n * **Details**\n *\n * Uses `input != null`.\n *\n * **Example** (Filtering non-nullish values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const values = [0, null, \"\", undefined]\n * const present = values.filter(Predicate.isNotNullish) // => [0, \"\"]\n * ```\n *\n * @see {@link isNullish}\n * @see {@link isNotNull}\n * @see {@link isNotUndefined}\n * @category guards\n * @since 4.0.0\n */\nexport function isNotNullish(input) {\n return input != null;\n}\n/**\n * Type guard that always returns `false`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` that never accepts, e.g. in default branches.\n *\n * **Example** (Matching no values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * Predicate.isNever(\"anything\") // => false\n * ```\n *\n * @see {@link isUnknown}\n * @category guards\n * @since 2.0.0\n */\nexport function isNever(_) {\n return false;\n}\n/**\n * Type guard that always returns `true`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` that always accepts, e.g. as a placeholder.\n *\n * **Example** (Matching every value)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * Predicate.isUnknown(123) // => true\n * ```\n *\n * @see {@link isNever}\n * @category guards\n * @since 2.0.0\n */\nexport function isUnknown(_) {\n return true;\n}\n/**\n * Checks whether a value is an object or an array (non-null object).\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard that accepts plain objects and arrays,\n * but not `null`.\n *\n * **Details**\n *\n * Uses `typeof input === \"object\" && input !== null` and includes arrays.\n *\n * **Example** (Checking objects or arrays)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * Predicate.isObjectOrArray([]) // => true\n * ```\n *\n * @see {@link isObject}\n * @see {@link isObjectKeyword}\n * @category guards\n * @since 4.0.0\n */\nexport function isObjectOrArray(input) {\n return typeof input === \"object\" && input !== null;\n}\n/**\n * Checks whether a value is a non-null object value that is not an array.\n *\n * **When to use**\n *\n * Use to narrow unknown input to a non-null, non-array object with a\n * `Predicate` guard.\n *\n * **Details**\n *\n * This is a structural runtime check using `typeof input === \"object\"`, so it\n * also accepts object instances such as `Date`, `Map`, class instances, and\n * typed arrays. It excludes `null` and arrays.\n *\n * **Example** (Guarding objects)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * Predicate.isObject({ a: 1 }) // => true\n * Predicate.isObject([1, 2]) // => false\n * ```\n *\n * @see {@link isObjectOrArray}\n * @see {@link isReadonlyObject}\n * @category guards\n * @since 2.0.0\n */\nexport function isObject(input) {\n return typeof input === \"object\" && input !== null && !Array.isArray(input);\n}\n/**\n * Checks whether a value is a non-null, non-array object and narrows it to a\n * readonly indexable object type.\n *\n * **When to use**\n *\n * Use to narrow unknown input to a readonly view of a non-null, non-array\n * object with a `Predicate` guard.\n *\n * **Details**\n *\n * Readonly-ness is a TypeScript type-level view; it is not observable at\n * runtime. This delegates to `isObject`, so class instances and built-in object\n * instances are accepted.\n *\n * **Example** (Checking readonly objects)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = { a: 1 }\n *\n * Predicate.isReadonlyObject(data) // => true\n * ```\n *\n * @see {@link isObject}\n * @category guards\n * @since 4.0.0\n */\nexport function isReadonlyObject(input) {\n return isObject(input);\n}\n/**\n * Checks whether a value is an `object` in the JavaScript sense (objects, arrays, functions).\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard that accepts arrays and functions as\n * well as objects.\n *\n * **Details**\n *\n * Returns `true` for arrays and functions, and `false` for `null`.\n *\n * **Example** (Checking object keywords)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * Predicate.isObjectKeyword(() => 1) // => true\n * Predicate.isObjectKeyword(null) // => false\n * ```\n *\n * @see {@link isObject}\n * @see {@link isObjectOrArray}\n * @category guards\n * @since 4.0.0\n */\nexport function isObjectKeyword(input) {\n return typeof input === \"object\" && input !== null || isFunction(input);\n}\n/**\n * Checks whether a value has a given property key.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard for property access on `unknown`\n * values with a simple structural object check.\n *\n * **Details**\n *\n * Uses the `in` operator and `isObjectKeyword`. This does not check property\n * value types.\n *\n * **Example** (Guarding object properties)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const hasName = Predicate.hasProperty(\"name\")\n * const data: unknown = { name: \"Ada\" }\n *\n * if (hasName(data)) {\n * data.name // => \"Ada\"\n * }\n * ```\n *\n * @see {@link isTagged}\n * @see {@link isObjectKeyword}\n * @category guards\n * @since 2.0.0\n */\nexport const hasProperty = /*#__PURE__*/dual(2, (self, property) => isObjectKeyword(self) && property in self);\n/**\n * Checks whether a value has a `_tag` property equal to the given tag.\n *\n * **When to use**\n *\n * Use when you model tagged unions with a `_tag` field and want a quick\n * `Predicate` guard for tagged values.\n *\n * **Details**\n *\n * Uses `hasProperty` and strict equality on `_tag`.\n *\n * **Example** (Guarding tagged values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const isOk = Predicate.isTagged(\"Ok\")\n *\n * isOk({ _tag: \"Ok\", value: 1 }) // => true\n * ```\n *\n * @see {@link hasProperty}\n * @category guards\n * @since 2.0.0\n */\nexport const isTagged = /*#__PURE__*/dual(2, (self, tag) => hasProperty(self, \"_tag\") && self[\"_tag\"] === tag);\n/**\n * Checks whether a value is an `Error`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard for errors caught from unknown sources.\n *\n * **Details**\n *\n * Uses `instanceof Error`.\n *\n * **Example** (Guarding errors)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = new Error(\"boom\")\n *\n * Predicate.isError(data) // => true\n * ```\n *\n * @see {@link isUnknown}\n * @category guards\n * @since 2.0.0\n */\nexport function isError(input) {\n return input instanceof Error;\n}\n/**\n * Checks whether a value is a `Uint8Array`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` runtime guard for binary data.\n *\n * **Details**\n *\n * Uses `instanceof Uint8Array`.\n *\n * **Example** (Guarding Uint8Array values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = new Uint8Array([1, 2])\n *\n * Predicate.isUint8Array(data) // => true\n * ```\n *\n * @see {@link isIterable}\n * @see {@link isSet}\n * @category guards\n * @since 2.0.0\n */\nexport function isUint8Array(input) {\n return input instanceof Uint8Array;\n}\n/**\n * Checks whether a value is a `Date`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` runtime guard for dates.\n *\n * **Details**\n *\n * Uses `instanceof Date`.\n *\n * **Example** (Guarding Date values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = new Date()\n *\n * Predicate.isDate(data) // => true\n * ```\n *\n * @see {@link isRegExp}\n * @category guards\n * @since 2.0.0\n */\nexport function isDate(input) {\n return input instanceof Date;\n}\n/**\n * Checks whether a value is iterable.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard before iterating an unknown value.\n *\n * **Details**\n *\n * Accepts strings as iterable and uses `hasProperty` for `Symbol.iterator`.\n *\n * **Example** (Guarding iterables)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = [1, 2, 3]\n *\n * Predicate.isIterable(data) // => true\n * ```\n *\n * @see {@link isSet}\n * @see {@link isMap}\n * @category guards\n * @since 2.0.0\n */\nexport function isIterable(input) {\n return hasProperty(input, Symbol.iterator) || isString(input);\n}\n/**\n * Checks whether a value is a `Promise`-like object with `then` and `catch`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard for promise instances across realms.\n *\n * **Details**\n *\n * Performs a structural check for `then` and `catch` functions.\n *\n * **Example** (Guarding promises)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = Promise.resolve(1)\n *\n * Predicate.isPromise(data) // => true\n * ```\n *\n * @see {@link isPromiseLike}\n * @category guards\n * @since 2.0.0\n */\nexport function isPromise(input) {\n return hasProperty(input, \"then\") && \"catch\" in input && isFunction(input.then) && isFunction(input.catch);\n}\n/**\n * Checks whether a value is `PromiseLike` (has a `then` method).\n *\n * **When to use**\n *\n * Use when you need a `Predicate` guard for promise-like values with a\n * callable `then` method.\n *\n * **Details**\n *\n * Performs a structural check for a callable `then`.\n *\n * **Example** (Guarding promise-like values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = { then: () => {} }\n *\n * Predicate.isPromiseLike(data) // => true\n * ```\n *\n * @see {@link isPromise}\n * @category guards\n * @since 2.0.0\n */\nexport function isPromiseLike(input) {\n return hasProperty(input, \"then\") && isFunction(input.then);\n}\n/**\n * Checks whether a value is a `RegExp`.\n *\n * **When to use**\n *\n * Use when you need a `Predicate` runtime guard for regular expressions.\n *\n * **Details**\n *\n * Uses `instanceof RegExp`.\n *\n * **Example** (Guarding RegExp values)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const data: unknown = /abc/\n *\n * Predicate.isRegExp(data) // => true\n * ```\n *\n * @see {@link isDate}\n * @category guards\n * @since 3.9.0\n */\nexport function isRegExp(input) {\n return input instanceof RegExp;\n}\n/**\n * Composes two predicates or refinements into one.\n *\n * **When to use**\n *\n * Use when you want to compose two `Predicate` checks in sequence, especially\n * when chaining refinements for progressive narrowing.\n *\n * **Details**\n *\n * For refinements, the output type is narrowed by both checks. Evaluation\n * short-circuits on the first `false`.\n *\n * **Example** (Composing refinements)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const isNumber: Predicate.Refinement = (u): u is number => typeof u === \"number\"\n * const isInteger: Predicate.Refinement = (n): n is number => Number.isInteger(n)\n *\n * const isIntegerNumber = Predicate.compose(isNumber, isInteger)\n *\n * isIntegerNumber(1) // => true\n * ```\n *\n * @see {@link and}\n * @see {@link Refinement}\n * @category combinators\n * @since 2.0.0\n */\nexport const compose = /*#__PURE__*/dual(2, (ab, bc) => a => ab(a) && bc(a));\n/**\n * Creates a predicate for tuples by applying predicates to each element.\n *\n * **When to use**\n *\n * Use when you want to validate tuple positions independently by lifting\n * element predicates into a tuple predicate.\n *\n * **Details**\n *\n * Returns a refinement if any element predicate is a refinement. Evaluation\n * stops at the first failing element.\n *\n * **Example** (Checking tuples)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const tupleCheck = Predicate.Tuple([(n: number) => n > 0, Predicate.isString])\n *\n * tupleCheck([1, \"ok\"]) // => true\n * ```\n *\n * @see {@link Struct}\n * @see {@link isTupleOf}\n * @category combinators\n * @since 4.0.0\n */\nexport function Tuple(elements) {\n return as => {\n for (let i = 0; i < elements.length; i++) {\n if (elements[i](as[i]) === false) {\n return false;\n }\n }\n return true;\n };\n}\n/**\n * Creates a predicate for objects by applying predicates to named properties.\n *\n * **When to use**\n *\n * Use when you want to validate a record shape at runtime by lifting property\n * predicates into an object predicate.\n *\n * **Details**\n *\n * Returns a refinement if any field predicate is a refinement. Only the\n * specified keys are checked, and extra keys are ignored.\n *\n * **Example** (Checking structs)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const userCheck = Predicate.Struct({\n * id: Predicate.isNumber,\n * name: Predicate.isString\n * })\n *\n * userCheck({ id: 1, name: \"Ada\" }) // => true\n * ```\n *\n * @see {@link Tuple}\n * @see {@link hasProperty}\n * @category combinators\n * @since 4.0.0\n */\nexport function Struct(fields) {\n const keys = Object.keys(fields);\n return a => {\n for (const key of keys) {\n if (!fields[key](a[key])) {\n return false;\n }\n }\n return true;\n };\n}\n/**\n * Negates a predicate.\n *\n * **When to use**\n *\n * Use when you want the inverse of an existing predicate.\n *\n * **Details**\n *\n * Returns a new predicate that flips the boolean result.\n *\n * **Example** (Negating a predicate)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const isNotString = Predicate.not(Predicate.isString)\n *\n * isNotString(1) // => true\n * ```\n *\n * @see {@link and}\n * @see {@link or}\n * @see {@link xor}\n * @category combinators\n * @since 2.0.0\n */\nexport function not(self) {\n return a => !self(a);\n}\n/**\n * Creates a predicate that returns `true` if either predicate is `true`.\n *\n * **When to use**\n *\n * Use when you want to combine `Predicate`s with OR, accepting values that\n * satisfy at least one condition, including refinements that narrow to a union.\n *\n * **Details**\n *\n * Evaluation short-circuits on the first `true`. For refinements, the output\n * type is a union.\n *\n * **Example** (Checking either condition)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)\n *\n * isStringOrNumber(\"a\") // => true\n * ```\n *\n * @see {@link and}\n * @see {@link xor}\n * @category combinators\n * @since 2.0.0\n */\nexport const or = /*#__PURE__*/dual(2, (self, that) => a => self(a) || that(a));\n/**\n * Creates a predicate that returns `true` only if both predicates are `true`.\n *\n * **When to use**\n *\n * Use when you want to combine `Predicate`s with AND, accepting values that\n * satisfy multiple conditions, including refinements that narrow to an\n * intersection.\n *\n * **Details**\n *\n * Evaluation short-circuits on the first `false`. For refinements, the output\n * type is an intersection.\n *\n * **Example** (Checking both conditions)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const hasAAndB = Predicate.and(\n * Predicate.hasProperty(\"a\"),\n * Predicate.hasProperty(\"b\")\n * )\n *\n * const input: unknown = JSON.parse(`{\"a\":1,\"b\":\"ok\"}`)\n * if (hasAAndB(input)) {\n * // input has both properties at this point\n * const a = input.a\n * const b = input.b\n *\n * const values = [a, b] // => [1, \"ok\"]\n * }\n * ```\n *\n * @see {@link or}\n * @see {@link not}\n * @category combinators\n * @since 2.0.0\n */\nexport const and = /*#__PURE__*/dual(2, (self, that) => a => self(a) && that(a));\n/**\n * Creates a predicate that returns `true` if exactly one predicate is `true`.\n *\n * **When to use**\n *\n * Use when you want to combine two `Predicate`s with exclusive-or semantics.\n *\n * **Details**\n *\n * Returns `true` when results differ.\n *\n * **Example** (Checking exclusive-or conditions)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const isEven = (n: number) => n % 2 === 0\n * const isPositive = (n: number) => n > 0\n * const either = Predicate.xor(isEven, isPositive)\n *\n * either(-2) // => true\n * ```\n *\n * @see {@link or}\n * @see {@link and}\n * @category combinators\n * @since 2.0.0\n */\nexport const xor = /*#__PURE__*/dual(2, (self, that) => a => self(a) !== that(a));\n/**\n * Creates a predicate that returns `true` when both predicates agree.\n *\n * **When to use**\n *\n * Use when you want to check equivalence of two `Predicate`s.\n *\n * **Details**\n *\n * Returns `true` when both results are equal.\n *\n * **Example** (Defining equivalence)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const isEven = (n: number) => n % 2 === 0\n * const same = Predicate.eqv(isEven, isEven)\n *\n * same(3) // => true\n * ```\n *\n * @see {@link xor}\n * @category combinators\n * @since 2.0.0\n */\nexport const eqv = /*#__PURE__*/dual(2, (self, that) => a => self(a) === that(a));\n/**\n * Creates a predicate representing logical implication: if `antecedent`, then `consequent`.\n *\n * **When to use**\n *\n * Use when you need to encode logical implication between `Predicate` rules,\n * where one rule only applies when a precondition holds.\n *\n * **Details**\n *\n * Models constraints like \"if A then B\" and returns `true` when the antecedent\n * is `false`.\n *\n * **Example** (Checking implication)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const isAdult = (age: number) => age >= 18\n * const canVote = (age: number) => age >= 18\n * const implies = Predicate.implies(isAdult, canVote)\n *\n * implies(16) // => true\n * ```\n *\n * @see {@link and}\n * @see {@link or}\n * @category combinators\n * @since 2.0.0\n */\nexport const implies = /*#__PURE__*/dual(2, (antecedent, consequent) => a => antecedent(a) ? consequent(a) : true);\n/**\n * Creates a predicate that returns `true` when neither predicate is `true`.\n *\n * **When to use**\n *\n * Use when you want to combine two `Predicate`s with logical NOR semantics.\n *\n * **Details**\n *\n * Returns the negation of `or`.\n *\n * **Example** (Checking NOR conditions)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const neither = Predicate.nor(Predicate.isString, Predicate.isNumber)\n *\n * neither(true) // => true\n * ```\n *\n * @see {@link or}\n * @see {@link not}\n * @category combinators\n * @since 2.0.0\n */\nexport const nor = /*#__PURE__*/dual(2, (self, that) => a => !(self(a) || that(a)));\n/**\n * Creates a predicate that returns `true` unless both predicates are `true`.\n *\n * **When to use**\n *\n * Use when you want to combine two `Predicate`s with logical NAND semantics.\n *\n * **Details**\n *\n * Returns the negation of `and`.\n *\n * **Example** (Checking NAND conditions)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const notBoth = Predicate.nand(Predicate.isString, Predicate.isNumber)\n *\n * notBoth(\"a\") // => true\n * ```\n *\n * @see {@link and}\n * @see {@link not}\n * @category combinators\n * @since 2.0.0\n */\nexport const nand = /*#__PURE__*/dual(2, (self, that) => a => !(self(a) && that(a)));\n/**\n * Creates a predicate that returns `true` if all predicates in the collection return `true`.\n *\n * **When to use**\n *\n * Use when you have a dynamic list of predicates to apply.\n *\n * **Details**\n *\n * Evaluation short-circuits on the first `false`. The collection is iterated\n * each time the predicate is called.\n *\n * **Example** (Checking all predicates)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const allChecks = Predicate.every([Predicate.isNumber, (n: number) => n > 0])\n *\n * allChecks(2) // => true\n * ```\n *\n * @see {@link some}\n * @see {@link and}\n * @category combining\n * @since 2.0.0\n */\nexport function every(collection) {\n return a => {\n for (const p of collection) {\n if (!p(a)) {\n return false;\n }\n }\n return true;\n };\n}\n/**\n * Creates a predicate that returns `true` if any predicate in the collection returns `true`.\n *\n * **When to use**\n *\n * Use when you have a dynamic list of predicates and only need one to pass.\n *\n * **Details**\n *\n * Evaluation short-circuits on the first `true`. The collection is iterated\n * each time the predicate is called.\n *\n * **Example** (Checking any predicate)\n *\n * ```ts import.meta.vitest\n * import { Predicate } from \"effect\"\n *\n * const anyCheck = Predicate.some([Predicate.isString, Predicate.isNumber])\n *\n * anyCheck(\"ok\") // => true\n * ```\n *\n * @see {@link every}\n * @see {@link or}\n * @category combining\n * @since 2.0.0\n */\nexport function some(collection) {\n return a => {\n for (const p of collection) {\n if (p(a)) {\n return true;\n }\n }\n return false;\n };\n}\n//# sourceMappingURL=Predicate.js.map","/**\n * Computes Effect hash values and defines the interface for objects that want\n * to provide their own hash implementation. Hashes are small numeric\n * fingerprints used by Effect data structures to bucket values quickly; they\n * are not cryptographic digests and they are not proof that two values are\n * equal. The module also includes helpers for primitive, structure, array, and\n * reference-based hashes, plus functions for combining and optimizing numeric\n * hash values.\n *\n * @since 2.0.0\n */\nimport { dual } from \"./Function.js\";\nimport { byReferenceInstances, getAllObjectKeys } from \"./internal/equal.js\";\nimport { hasProperty } from \"./Predicate.js\";\n/**\n * Defines the unique identifier used to identify objects that implement the Hash interface.\n *\n * **When to use**\n *\n * Use as the computed property key for the method that supplies a custom hash\n * value on a `Hash` implementor.\n *\n * @see {@link Hash} for the interface implemented with this symbol\n * @see {@link isHash} for checking whether a value implements `Hash`\n * @see {@link hash} for computing hash values\n *\n * @category symbols\n * @since 2.0.0\n */\nexport const symbol = \"~effect/Hash\";\n/**\n * Computes a hash value for any given value.\n *\n * **When to use**\n *\n * Use to compute an Effect hash for primitives, collections, and hashable\n * objects.\n *\n * **Details**\n *\n * This function can hash primitives (numbers, strings, booleans, etc.) as well as\n * objects, arrays, and other complex data structures. It automatically handles\n * different types and provides a consistent hash value for equivalent inputs.\n *\n * **Gotchas**\n *\n * Objects being hashed must be treated as immutable after their first hash\n * computation. Hash results are cached, so mutating an object after hashing will\n * lead to stale cached values and broken hash-based operations. For mutable\n * objects, implement a custom `Hash` interface that hashes the object reference\n * rather than its content.\n *\n * **Example** (Hashing different values)\n *\n * ```ts import.meta.vitest\n * import { Hash } from \"effect\"\n *\n * Hash.hash(42) === Hash.hash(42) // => true\n * Hash.hash(\"hello\") === Hash.hash(\"hello\") // => true\n * Hash.hash([1, 2, 3]) === Hash.hash([1, 2, 3]) // => true\n * ```\n *\n * @category hashing\n * @since 2.0.0\n */\nexport const hash = self => {\n switch (typeof self) {\n case \"number\":\n return number(self);\n case \"bigint\":\n return string(self.toString(10));\n case \"string\":\n return string(self);\n case \"undefined\":\n return string(\"undefined\");\n case \"function\":\n case \"object\":\n {\n if (self === null) {\n return string(\"null\");\n } else if (self instanceof Date) {\n if (Number.isNaN(self.getTime())) {\n return string(\"Invalid Date\");\n }\n return string(self.toISOString());\n } else if (self instanceof RegExp) {\n return string(self.toString());\n } else {\n if (byReferenceInstances.has(self)) {\n return random(self);\n }\n if (hashCache.has(self)) {\n return hashCache.get(self);\n }\n const h = withVisitedTracking(self, () => {\n if (isHash(self)) {\n return self[symbol]();\n } else if (typeof self === \"function\") {\n return random(self);\n } else if (self instanceof DataView) {\n return array(new Uint8Array(self.buffer, self.byteOffset, self.byteLength));\n } else if (Array.isArray(self) || ArrayBuffer.isView(self)) {\n return array(self);\n } else if (self instanceof Map) {\n return hashMap(self);\n } else if (self instanceof Set) {\n return hashSet(self);\n }\n return structure(self);\n });\n hashCache.set(self, h);\n return h;\n }\n }\n default:\n // The remaining primitive types are boolean and symbol.\n return string(String(self));\n }\n};\n/**\n * Generates a random hash value for an object and caches it.\n *\n * **When to use**\n *\n * Use to hash an object by reference identity instead of structural content.\n *\n * **Details**\n *\n * This function creates a random hash value for objects that don't have their own\n * hash implementation. The hash value is cached using a WeakMap, so the same object\n * will always return the same hash value during its lifetime.\n *\n * **Example** (Hashing objects by reference)\n *\n * ```ts import.meta.vitest\n * import { Hash } from \"effect\"\n *\n * const obj1 = { a: 1 }\n * const obj2 = { a: 1 }\n *\n * Hash.random(obj1) === Hash.random(obj1) // => true\n *\n * typeof Hash.random(obj2) // => \"number\"\n * ```\n *\n * @category hashing\n * @since 2.0.0\n */\nexport const random = self => {\n if (!randomHashCache.has(self)) {\n randomHashCache.set(self, number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)));\n }\n return randomHashCache.get(self);\n};\n/**\n * Combines two hash values into a single hash value.\n *\n * **When to use**\n *\n * Use to build a hash for a composite value by folding together hash values for\n * its parts.\n *\n * **Details**\n *\n * Supports both direct and pipeable usage. The implementation combines two\n * hash values with `(self * 53) ^ b`.\n *\n * **Example** (Combining hash values)\n *\n * ```ts import.meta.vitest\n * import { Hash, pipe } from \"effect\"\n *\n * const hash1 = Hash.hash(\"hello\")\n * const hash2 = Hash.hash(\"world\")\n *\n * const combined = Hash.combine(hash2)(hash1)\n * combined === pipe(hash1, Hash.combine(hash2)) // => true\n * ```\n *\n * @see {@link hash} for computing hash values from arbitrary inputs\n * @see {@link structureKeys} for hashing selected object fields without manual combination\n *\n * @category hashing\n * @since 2.0.0\n */\nexport const combine = /*#__PURE__*/dual(2, (self, b) => self * 53 ^ b);\n/**\n * Applies bit manipulation techniques to optimize a hash value.\n *\n * **When to use**\n *\n * Use to improve the bit distribution of a raw numeric hash value.\n *\n * **Details**\n *\n * This function takes a hash value and applies bitwise operations to improve\n * the distribution of hash values, reducing the likelihood of collisions.\n *\n * **Example** (Optimizing a hash value)\n *\n * ```ts import.meta.vitest\n * import { Hash } from \"effect\"\n *\n * Hash.optimize(1234567890) // => 160826066\n * ```\n *\n * @category hashing\n * @since 2.0.0\n */\nexport const optimize = n => n & 0xbfffffff | n >>> 1 & 0x40000000;\n/**\n * Checks whether a value implements the Hash interface.\n *\n * **When to use**\n *\n * Use to detect whether an unknown value provides a custom hash implementation.\n *\n * **Details**\n *\n * This function determines whether a given value has the Hash symbol property,\n * indicating that it can provide its own hash value implementation.\n *\n * **Example** (Checking for Hash support)\n *\n * ```ts import.meta.vitest\n * import { Hash } from \"effect\"\n *\n * class MyHashable implements Hash.Hash {\n * [Hash.symbol]() {\n * return 42\n * }\n * }\n *\n * Hash.isHash(new MyHashable()) // => true\n * Hash.isHash({}) // => false\n * Hash.isHash(\"string\") // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isHash = u => hasProperty(u, symbol);\n/**\n * Computes a hash value for a number.\n *\n * **When to use**\n *\n * Use to hash a JavaScript number with Effect's numeric hash semantics.\n *\n * **Details**\n *\n * This function creates a hash value for numeric inputs, handling special cases\n * like NaN, Infinity, and -Infinity with distinct hash values. It uses bitwise operations to ensure good distribution\n * of hash values across different numeric inputs.\n *\n * **Example** (Hashing numbers)\n *\n * ```ts import.meta.vitest\n * import { Hash } from \"effect\"\n *\n * Number.isInteger(Hash.number(42)) // => true\n * Number.isInteger(Hash.number(3.14)) // => true\n * Hash.number(NaN) === Hash.number(NaN) // => true\n * Hash.number(Infinity) === Hash.number(Infinity) // => true\n * Hash.number(100) === Hash.number(100) // => true\n * ```\n *\n * @category hashing\n * @since 2.0.0\n */\nexport const number = n => {\n if (n !== n || n === Infinity || n === -Infinity) {\n return string(String(n));\n }\n let h = n | 0;\n if (h !== n) {\n h ^= n * 0xffffffff;\n }\n while (n > 0xffffffff) {\n h ^= n /= 0xffffffff;\n }\n return optimize(h);\n};\n/**\n * Computes a hash value for a string using the djb2 algorithm.\n *\n * **When to use**\n *\n * Use when you need a string field to contribute to a custom structural hash\n * implementation.\n *\n * **Details**\n *\n * This function implements a variation of the djb2 hash algorithm, which is\n * known for its good distribution properties and speed. It processes each\n * character of the string to produce a consistent hash value.\n *\n * **Example** (Hashing strings)\n *\n * ```ts import.meta.vitest\n * import { Hash } from \"effect\"\n *\n * Hash.string(\"hello\") // => 181380007\n * Hash.string(\"world\") // => 164394279\n * Hash.string(\"\") // => 5381\n * Hash.string(\"test\") === Hash.string(\"test\") // => true\n * ```\n *\n * @category hashing\n * @since 2.0.0\n */\nexport const string = str => {\n let h = 5381,\n i = str.length;\n while (i) {\n h = h * 33 ^ str.charCodeAt(--i);\n }\n return optimize(h);\n};\n/**\n * Computes a hash value for an object using only the specified keys.\n *\n * **When to use**\n *\n * Use to hash an object by a selected set of property keys.\n *\n * **Details**\n *\n * This function allows you to hash an object by considering only specific keys,\n * which is useful when you want to create a hash based on a subset of an object's\n * properties.\n *\n * **Example** (Hashing selected object keys)\n *\n * ```ts import.meta.vitest\n * import { Hash } from \"effect\"\n *\n * const person = { name: \"John\", age: 30, city: \"New York\" }\n *\n * const hash1 = Hash.structureKeys(person, [\"name\", \"age\"])\n * const hash2 = Hash.structureKeys(person, [\"name\", \"city\"])\n *\n * hash1 // => -590673747\n * hash2 // => 284850673\n *\n * const person2 = { name: \"John\", age: 30, city: \"Boston\" }\n * const hash3 = Hash.structureKeys(person2, [\"name\", \"age\"])\n * hash1 === hash3 // => true\n * ```\n *\n * @category hashing\n * @since 2.0.0\n */\nexport const structureKeys = (o, keys) => {\n let h = 12289;\n for (const key of keys) {\n h ^= combine(hash(key), hash(o[key]));\n }\n return optimize(h);\n};\n/**\n * Computes a structural hash for an object using Effect's object key collection.\n *\n * **When to use**\n *\n * Use to hash an object from all structural keys collected by Effect.\n *\n * **Details**\n *\n * The hash is based on the object's structural keys and their values, including\n * symbol keys and relevant prototype keys for non-plain objects.\n *\n * **Example** (Hashing object structures)\n *\n * ```ts import.meta.vitest\n * import { Hash } from \"effect\"\n *\n * const obj1 = { name: \"John\", age: 30 }\n * const obj2 = { name: \"Jane\", age: 25 }\n * const obj3 = { name: \"John\", age: 30 }\n *\n * Hash.structure(obj1) // => -590673747\n * Hash.structure(obj2) // => -590160631\n * Hash.structure(obj3) // => -590673747\n * Hash.structure(obj1) === Hash.structure(obj3) // => true\n * ```\n *\n * @category hashing\n * @since 2.0.0\n */\nexport const structure = o => structureKeys(o, getAllObjectKeys(o));\nconst iterableWith = (seed, f) => iter => {\n let h = seed;\n for (const element of iter) {\n h ^= f(element);\n }\n return optimize(h);\n};\n/**\n * Computes a hash value for an iterable by hashing all of its elements.\n *\n * **When to use**\n *\n * Use to hash the values yielded by an iterable with Effect hash semantics.\n *\n * **Details**\n *\n * The implementation folds element hashes from the seed `6151` with XOR and\n * then optimizes the final hash.\n *\n * **Gotchas**\n *\n * A hash is not an equality proof. Because this implementation uses XOR,\n * reordered inputs can produce the same hash.\n *\n * **Example** (Hashing arrays)\n *\n * ```ts import.meta.vitest\n * import { Hash } from \"effect\"\n *\n * const arr1 = [1, 2, 3]\n * const arr2 = [1, 2, 3]\n * const arr3 = [3, 2, 1]\n *\n * Hash.array(arr1) // => 6151\n * Hash.array(arr2) // => 6151\n * Hash.array(arr3) // => 6151\n * Hash.array(arr1) === Hash.array(arr2) // => true\n * Hash.array(arr1) === Hash.array(arr3) // => true\n * ```\n *\n * @see {@link hash} for the general-purpose hash dispatcher\n *\n * @category hashing\n * @since 2.0.0\n */\nexport const array = /*#__PURE__*/iterableWith(6151, hash);\nconst hashMap = /*#__PURE__*/iterableWith(/*#__PURE__*/string(\"Map\"), ([k, v]) => combine(hash(k), hash(v)));\nconst hashSet = /*#__PURE__*/iterableWith(/*#__PURE__*/string(\"Set\"), hash);\nconst randomHashCache = /*#__PURE__*/new WeakMap();\nconst hashCache = /*#__PURE__*/new WeakMap();\nconst visitedObjects = /*#__PURE__*/new WeakSet();\nfunction withVisitedTracking(obj, fn) {\n if (visitedObjects.has(obj)) {\n return string(\"[Circular]\");\n }\n visitedObjects.add(obj);\n const result = fn();\n visitedObjects.delete(obj);\n return result;\n}\n//# sourceMappingURL=Hash.js.map","import * as Hash from \"./Hash.js\";\nimport { byReferenceInstances, getAllObjectKeys } from \"./internal/equal.js\";\nimport { hasProperty } from \"./Predicate.js\";\n/**\n * Defines the unique string identifier for the `Equal` interface.\n *\n * **When to use**\n *\n * Use when you implement custom equality and need the computed property key for\n * the equality method.\n *\n * **Details**\n *\n * This is a pure constant with no allocation or side effects.\n *\n * **Example** (Implementing Equal on a class)\n *\n * ```ts import.meta.vitest\n * import { Equal, Hash } from \"effect\"\n *\n * class UserId implements Equal.Equal {\n * constructor(readonly id: string) {}\n *\n * [Equal.symbol](that: Equal.Equal): boolean {\n * return that instanceof UserId && this.id === that.id\n * }\n *\n * [Hash.symbol](): number {\n * return Hash.string(this.id)\n * }\n * }\n *\n * Equal.equals(new UserId(\"1\"), new UserId(\"1\")) // => true\n * Equal.equals(new UserId(\"1\"), new UserId(\"2\")) // => false\n * ```\n *\n * @see {@link Equal} — the interface that uses this symbol\n * @see {@link isEqual} — type guard for `Equal` implementors\n * @category symbols\n * @since 2.0.0\n */\nexport const symbol = \"~effect/Equal\";\nexport function equals() {\n if (arguments.length === 1) {\n return self => compareBoth(self, arguments[0]);\n }\n return compareBoth(arguments[0], arguments[1]);\n}\nfunction compareBoth(self, that) {\n if (self === that) return true;\n if (self == null || that == null) return false;\n const selfType = typeof self;\n if (selfType !== typeof that) {\n return false;\n }\n // Special case for NaN: NaN should be considered equal to NaN\n if (selfType === \"number\" && self !== self && that !== that) {\n return true;\n }\n if (selfType !== \"object\" && selfType !== \"function\") {\n return false;\n }\n if (byReferenceInstances.has(self) || byReferenceInstances.has(that)) {\n return false;\n }\n // For objects and functions, use cached comparison\n return withCache(self, that, compareObjects);\n}\n/** Helper to run comparison with proper visited tracking */\nfunction withVisitedTracking(self, that, fn) {\n const hasLeft = visitedLeft.has(self);\n const hasRight = visitedRight.has(that);\n // Check for circular references before adding\n if (hasLeft && hasRight) {\n return true; // Both are circular at the same level\n }\n if (hasLeft || hasRight) {\n return false; // Only one is circular\n }\n visitedLeft.add(self);\n visitedRight.add(that);\n const result = fn();\n visitedLeft.delete(self);\n visitedRight.delete(that);\n return result;\n}\nconst visitedLeft = /*#__PURE__*/new WeakSet();\nconst visitedRight = /*#__PURE__*/new WeakSet();\n/** Helper to perform cached object comparison */\nfunction compareObjects(self, that) {\n if (Hash.hash(self) !== Hash.hash(that)) {\n return false;\n } else if (self instanceof Date) {\n if (!(that instanceof Date)) return false;\n const selfTime = self.getTime();\n const thatTime = that.getTime();\n return selfTime === thatTime || Number.isNaN(selfTime) && Number.isNaN(thatTime);\n } else if (self instanceof RegExp) {\n if (!(that instanceof RegExp)) return false;\n return self.toString() === that.toString();\n }\n const selfIsEqual = isEqual(self);\n const thatIsEqual = isEqual(that);\n if (selfIsEqual !== thatIsEqual) return false;\n const bothEquals = selfIsEqual && thatIsEqual;\n if (typeof self === \"function\" && !bothEquals) {\n return false;\n }\n return withVisitedTracking(self, that, () => {\n if (bothEquals) {\n return self[symbol](that);\n } else if (Array.isArray(self)) {\n if (!Array.isArray(that) || self.length !== that.length) {\n return false;\n }\n return compareArrays(self, that);\n } else if (ArrayBuffer.isView(self)) {\n const selfIsDataView = self instanceof DataView;\n if (!ArrayBuffer.isView(that) || self.byteLength !== that.byteLength || selfIsDataView !== that instanceof DataView) {\n return false;\n }\n if (selfIsDataView) {\n const thatDataView = that;\n return compareTypedArrays(new Uint8Array(self.buffer, self.byteOffset, self.byteLength), new Uint8Array(thatDataView.buffer, thatDataView.byteOffset, thatDataView.byteLength));\n }\n return compareTypedArrays(self, that);\n } else if (self instanceof Map) {\n if (!(that instanceof Map) || self.size !== that.size) {\n return false;\n }\n return compareMaps(self, that);\n } else if (self instanceof Set) {\n if (!(that instanceof Set) || self.size !== that.size) {\n return false;\n }\n return compareSets(self, that);\n }\n return compareRecords(self, that);\n });\n}\nfunction withCache(self, that, f) {\n // Check cache first\n let selfMap = equalityCache.get(self);\n if (!selfMap) {\n selfMap = new WeakMap();\n equalityCache.set(self, selfMap);\n } else if (selfMap.has(that)) {\n return selfMap.get(that);\n }\n // Perform the comparison\n const result = f(self, that);\n // Cache the result bidirectionally\n selfMap.set(that, result);\n let thatMap = equalityCache.get(that);\n if (!thatMap) {\n thatMap = new WeakMap();\n equalityCache.set(that, thatMap);\n }\n thatMap.set(self, result);\n return result;\n}\nconst equalityCache = /*#__PURE__*/new WeakMap();\nfunction compareArrays(self, that) {\n for (let i = 0; i < self.length; i++) {\n if (!compareBoth(self[i], that[i])) {\n return false;\n }\n }\n return true;\n}\nfunction compareTypedArrays(self, that) {\n if (self.length !== that.length) {\n return false;\n }\n for (let i = 0; i < self.length; i++) {\n if (self[i] !== that[i]) {\n return false;\n }\n }\n return true;\n}\nfunction compareRecords(self, that) {\n const selfKeys = getAllObjectKeys(self);\n const thatKeys = getAllObjectKeys(that);\n if (selfKeys.size !== thatKeys.size) {\n return false;\n }\n for (const key of selfKeys) {\n if (!thatKeys.has(key) || !compareBoth(self[key], that[key])) {\n return false;\n }\n }\n return true;\n}\n/** @internal */\nexport function makeCompareMap(keyEquivalence, valueEquivalence) {\n return function compareMaps(self, that) {\n const thatEntries = Array.from(that);\n for (const [selfKey, selfValue] of self) {\n let found = false;\n for (let i = 0; i < thatEntries.length; i++) {\n const [thatKey, thatValue] = thatEntries[i];\n if (keyEquivalence(selfKey, thatKey) && valueEquivalence(selfValue, thatValue)) {\n thatEntries[i] = thatEntries[thatEntries.length - 1];\n thatEntries.pop();\n found = true;\n break;\n }\n }\n if (!found) {\n return false;\n }\n }\n return true;\n };\n}\nconst compareMaps = /*#__PURE__*/makeCompareMap(compareBoth, compareBoth);\n/** @internal */\nexport function makeCompareSet(equivalence) {\n return function compareSets(self, that) {\n const thatValues = Array.from(that);\n for (const selfValue of self) {\n let found = false;\n for (let i = 0; i < thatValues.length; i++) {\n const thatValue = thatValues[i];\n if (equivalence(selfValue, thatValue)) {\n thatValues[i] = thatValues[thatValues.length - 1];\n thatValues.pop();\n found = true;\n break;\n }\n }\n if (!found) {\n return false;\n }\n }\n return true;\n };\n}\nconst compareSets = /*#__PURE__*/makeCompareSet(compareBoth);\n/**\n * Checks whether a value implements the {@link Equal} interface.\n *\n * **When to use**\n *\n * Use when you need generic utility code to distinguish `Equal` implementors\n * from plain values before calling `[Equal.symbol]` directly.\n *\n * **Details**\n *\n * - Pure function, no side effects.\n * - Returns `true` if and only if `u` has a property keyed by\n * {@link symbol}.\n * - Acts as a TypeScript type guard, narrowing the input to {@link Equal}.\n *\n * **Example** (Checking Equal values)\n *\n * ```ts import.meta.vitest\n * import { Equal, Hash } from \"effect\"\n *\n * class Token implements Equal.Equal {\n * constructor(readonly value: string) {}\n * [Equal.symbol](that: Equal.Equal): boolean {\n * return that instanceof Token && this.value === that.value\n * }\n * [Hash.symbol](): number {\n * return Hash.string(this.value)\n * }\n * }\n *\n * Equal.isEqual(new Token(\"abc\")) // => true\n * Equal.isEqual({ x: 1 }) // => false\n * Equal.isEqual(42) // => false\n * ```\n *\n * @see {@link Equal} — the interface being checked\n * @see {@link symbol} — the property key that signals `Equal` support\n * @category guards\n * @since 2.0.0\n */\nexport const isEqual = u => hasProperty(u, symbol);\n/**\n * Wraps {@link equals} as an `Equivalence`.\n *\n * **When to use**\n *\n * Use when you want to pass `Equal.equals` to APIs that require an\n * `Equivalence`.\n *\n * **Details**\n *\n * - Returns a function `(a: A, b: A) => boolean` that delegates to\n * {@link equals}.\n * - Pure; allocates a thin wrapper on each call.\n *\n * **Example** (Deduplicating with Equal semantics)\n *\n * ```ts import.meta.vitest\n * import { Array, Equal } from \"effect\"\n *\n * Array.dedupeWith([1, 2, 2, 3, 1], Equal.asEquivalence()) // => [1, 2, 3]\n * ```\n *\n * @see {@link equals} — the underlying comparison function\n * @category instances\n * @since 4.0.0\n */\nexport const asEquivalence = () => equals;\n/**\n * Creates a proxy that uses reference equality instead of structural equality.\n *\n * **When to use**\n *\n * Use when you need to compare a plain object or array by identity without\n * mutating the original value.\n *\n * **Details**\n *\n * - Returns a `Proxy` wrapping `obj`. The proxy reads through to the\n * original, so property access is unchanged.\n * - The proxy is registered in an internal WeakSet; {@link equals} returns\n * `false` for any pair where at least one operand is in that set (unless\n * they are the same reference).\n * - Each call creates a **new** proxy, so `byReference(x) !== byReference(x)`.\n * - Does **not** mutate the original object (unlike {@link byReferenceUnsafe}).\n *\n * **Example** (Opting out of structural equality)\n *\n * ```ts import.meta.vitest\n * import { Equal } from \"effect\"\n *\n * const a = { x: 1 }\n * const b = { x: 1 }\n *\n * Equal.equals(a, b) // => true\n *\n * const aRef = Equal.byReference(a)\n * Equal.equals(aRef, b) // => false\n * Equal.equals(aRef, aRef) // => true\n * aRef.x // => 1\n * ```\n *\n * @see {@link byReferenceUnsafe} — same effect without a proxy (mutates the\n * original)\n * @see {@link equals} — the comparison function affected by this opt-out\n * @category equality\n * @since 4.0.0\n */\nexport const byReference = obj => byReferenceUnsafe(new Proxy(obj, {}));\n/**\n * Marks an object permanently to use reference equality, without creating a proxy.\n *\n * **When to use**\n *\n * Use when you need reference equality without proxy allocation and accept\n * permanently marking the original object for reference-only equality.\n *\n * **Details**\n *\n * - Adds `obj` to an internal WeakSet. From that point on, {@link equals}\n * treats it as reference-only.\n * - Returns the **same** object (not a copy or proxy), so\n * `byReferenceUnsafe(x) === x`.\n * - Does **not** affect the object's prototype, properties, or behavior\n * beyond equality checks.\n *\n * **Gotchas**\n *\n * The marking is irreversible for the lifetime of the object.\n *\n * **Example** (Marking an object for reference equality)\n *\n * ```ts import.meta.vitest\n * import { Equal } from \"effect\"\n *\n * const obj1 = { a: 1, b: 2 }\n * const obj2 = { a: 1, b: 2 }\n *\n * const marked = Equal.byReferenceUnsafe(obj1)\n *\n * Equal.equals(obj1, obj2) // => false\n * Equal.equals(obj1, obj1) // => true\n * marked === obj1 // => true\n * ```\n *\n * @see {@link byReference} — safer alternative that creates a proxy\n * @see {@link equals} — the comparison function affected by this opt-out\n * @category unsafe\n * @since 4.0.0\n */\nexport const byReferenceUnsafe = obj => {\n byReferenceInstances.add(obj);\n return obj;\n};\n//# sourceMappingURL=Equal.js.map","import { pipeArguments } from \"./Pipeable.js\";\nimport { hasProperty } from \"./Predicate.js\";\n/**\n * Defines the symbol used to identify objects that implement the {@link Redactable}\n * protocol.\n *\n * **When to use**\n *\n * Use as the property key when implementing the `Redactable` protocol.\n *\n * **Details**\n *\n * Add a method under this key to make an object redactable. The method receives\n * the current `Context` and must return the replacement value. The symbol is\n * registered globally via `Symbol.for(\"~effect/Redactable\")`, so it is\n * identical across multiple copies of the library at runtime.\n *\n * **Example** (Masking an API key)\n *\n * ```ts import.meta.vitest\n * import { Context, Redactable } from \"effect\"\n *\n * class ApiKey {\n * constructor(readonly raw: string) {}\n *\n * [Redactable.symbolRedactable](_ctx: Context.Context) {\n * return this.raw.slice(0, 4) + \"...\"\n * }\n * }\n *\n * Redactable.redact(new ApiKey(\"secret-key\")) // => \"secr...\"\n * ```\n *\n * @see {@link Redactable} for the interface this symbol belongs to\n * @see {@link isRedactable} to check whether a value has this symbol\n * @category symbols\n * @since 3.10.0\n */\nexport const symbolRedactable = /*#__PURE__*/Symbol.for(\"~effect/Redactable\");\n/**\n * Type guard that checks whether a value implements the {@link Redactable}\n * interface.\n *\n * **When to use**\n *\n * Use to narrow an unknown value before calling redaction-specific helpers.\n *\n * @see {@link Redactable} for the interface being checked\n * @see {@link redact} to apply redaction if the value is redactable\n * @category guards\n * @since 3.10.0\n */\nexport const isRedactable = u => hasProperty(u, symbolRedactable);\n/**\n * Returns a redacted value if it implements {@link Redactable}, otherwise returns it\n * unchanged.\n *\n * **When to use**\n *\n * Use as the general-purpose entry point for redaction when the input may\n * or may not implement the redaction protocol.\n *\n * **Details**\n *\n * This function calls {@link isRedactable} and, when it returns `true`,\n * delegates to {@link getRedacted}.\n *\n * **Gotchas**\n *\n * Redaction is not recursive. Nested redactable values inside the returned\n * object are not automatically redacted.\n *\n * @see {@link isRedactable} to check before redacting\n * @see {@link getRedacted} for the lower-level variant for known redactables\n * @category destructors\n * @since 3.10.0\n */\nexport function redact(u) {\n if (isRedactable(u)) return getRedacted(u);\n return u;\n}\n/**\n * Returns the result of calling `[symbolRedactable]` on a value that is\n * already known to be {@link Redactable}.\n *\n * **When to use**\n *\n * Use when you need to read the redacted representation from a value already\n * verified as `Redactable`.\n *\n * **Details**\n *\n * This function reads the current fiber's `Context` from the global fiber\n * reference and passes it to the redaction method.\n *\n * **Gotchas**\n *\n * If no fiber is active, an empty `Context` is passed to the redaction method.\n *\n * @see {@link redact} for the higher-level variant that handles non-redactable values\n * @see {@link isRedactable} for the type guard to verify before calling this\n * @category destructors\n * @since 4.0.0\n */\nexport function getRedacted(redactable) {\n return redactable[symbolRedactable](globalThis[currentFiberTypeId]?.context ?? emptyContext);\n}\n/** @internal */\nexport const currentFiberTypeId = \"~effect/Fiber/currentFiber\";\nconst emptyMap = /*#__PURE__*/new Map();\nconst emptyContext = {\n \"~effect/Context\": {},\n base: emptyMap,\n depth: 0,\n mapUnsafe: emptyMap,\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n//# sourceMappingURL=Redactable.js.map","/**\n * Formats JavaScript values into readable strings.\n *\n * `format` is intended for logs, diagnostics, and error messages. It handles\n * primitives, objects, arrays, dates, regular expressions, maps, sets, class\n * instances, errors, circular references, and redactable values. `formatJson`\n * wraps JSON formatting with redaction and circular-reference handling, and the\n * module also includes helpers for property keys, paths, and dates.\n *\n * @since 4.0.0\n */\nimport * as Predicate from \"./Predicate.js\";\nimport { getRedacted, redact, symbolRedactable } from \"./Redactable.js\";\n/**\n * Converts any JavaScript value into a human-readable string.\n *\n * **When to use**\n *\n * Use when you need to format arbitrary JavaScript values for debugging,\n * logging, or error messages.\n *\n * **Details**\n *\n * - Output is **not** valid JSON; use {@link formatJson} when you need\n * parseable JSON.\n * - Handles `BigInt`, `Symbol`, `Set`, `Map`, `Date`, `RegExp`, and class\n * instances that `JSON.stringify` cannot represent.\n * - Circular references are shown as `\"[Circular]\"` instead of throwing.\n * - Failures while inspecting a value are rendered as diagnostic placeholders instead of throwing.\n * - Primitives: stringified naturally (`null`, `undefined`, `123`, `true`).\n * Strings are JSON-quoted.\n * - Objects with a custom `toString` (not `Object.prototype.toString`):\n * `toString()` is called unless `ignoreToString` is `true`.\n * - Errors with a `cause`: formatted as `\" (cause: )\"`.\n * - Iterables (`Set`, `Map`, etc.): formatted as\n * `ClassName([...elements])`.\n * - Class instances: wrapped as `ClassName({...})`.\n * - `Redactable` values are automatically redacted.\n * - Arrays/objects with 0–1 entries are inline; larger ones are\n * pretty-printed when `space` is set.\n * - `space` — indentation unit (number of spaces, or a string like\n * `\"\\t\"`). Defaults to `0` (compact).\n * - `ignoreToString` — skip calling `toString()`. Defaults to `false`.\n *\n * **Example** (Formatting compact output)\n *\n * ```ts import.meta.vitest\n * import { Formatter } from \"effect\"\n *\n * Formatter.format({ a: 1, b: [2, 3] }) // => \"{\\\"a\\\":1,\\\"b\\\":[2,3]}\"\n * ```\n *\n * **Example** (Pretty-printed output)\n *\n * ```ts import.meta.vitest\n * import { Formatter } from \"effect\"\n *\n * const output = Formatter.format({ a: 1, b: [2, 3] }, { space: 2 })\n * output // => \"{\\n \\\"a\\\": 1,\\n \\\"b\\\": [\\n 2,\\n 3\\n ]\\n}\"\n * ```\n *\n * **Example** (Handling circular references)\n *\n * ```ts import.meta.vitest\n * import { Formatter } from \"effect\"\n *\n * const obj: any = { name: \"loop\" }\n * obj.self = obj\n * Formatter.format(obj) // => \"{\\\"name\\\":\\\"loop\\\",\\\"self\\\":[Circular]}\"\n * ```\n *\n * @see {@link formatJson}\n * @see {@link Formatter}\n * @category formatting\n * @since 2.0.0\n */\nexport function format(input, options) {\n const space = options?.space ?? 0;\n const ancestors = new WeakSet();\n const gap = !space ? \"\" : typeof space === \"number\" ? \" \".repeat(space) : space;\n const ind = d => gap.repeat(d);\n const wrap = (v, body) => {\n const ctor = v?.constructor;\n return ctor && ctor !== Object.prototype.constructor && ctor.name ? `${ctor.name}(${body})` : body;\n };\n const ownKeys = o => {\n try {\n return Reflect.ownKeys(o);\n } catch {\n return [\"[ownKeys threw]\"];\n }\n };\n function recur(v, d = 0) {\n try {\n return recurUnsafe(v, d);\n } catch {\n if (typeof v === \"object\" && v !== null || typeof v === \"function\") ancestors.delete(v);\n return \"[inspection threw]\";\n }\n }\n function recurUnsafe(v, d = 0) {\n if (typeof v === \"string\") return JSON.stringify(v);\n if (typeof v === \"number\" || v == null || typeof v === \"boolean\" || typeof v === \"symbol\") return String(v);\n if (typeof v === \"bigint\") return String(v) + \"n\";\n if (typeof v === \"object\" || typeof v === \"function\") {\n if (ancestors.has(v)) return CIRCULAR;\n ancestors.add(v);\n let output;\n if (symbolRedactable in v) {\n output = recur(getRedacted(v), d);\n } else if (Array.isArray(v)) {\n output = !gap || v.length <= 1 ? `[${v.map(x => recur(x, d)).join(\",\")}]` : `[\\n${ind(d + 1)}${v.map(x => recur(x, d + 1)).join(\",\\n\" + ind(d + 1))}\\n${ind(d)}]`;\n } else if (v instanceof Date) {\n output = formatDate(v);\n } else if (!options?.ignoreToString && Predicate.hasProperty(v, \"toString\") && typeof v[\"toString\"] === \"function\" && v[\"toString\"] !== Object.prototype.toString && v[\"toString\"] !== Array.prototype.toString) {\n const s = safeToString(v);\n output = v instanceof Error && v.cause !== undefined ? `${s} (cause: ${recur(v.cause, d)})` : s;\n } else if (Symbol.iterator in v) {\n output = `${v.constructor.name}(${recur(Array.from(v), d)})`;\n } else {\n const keys = ownKeys(v);\n if (!gap || keys.length <= 1) {\n const body = `{${keys.map(k => `${formatPropertyKey(k)}:${recur(safeGet(v, k), d)}`).join(\",\")}}`;\n output = wrap(v, body);\n } else {\n const body = `{\\n${keys.map(k => `${ind(d + 1)}${formatPropertyKey(k)}: ${recur(safeGet(v, k), d + 1)}`).join(\",\\n\")}\\n${ind(d)}}`;\n output = wrap(v, body);\n }\n }\n ancestors.delete(v);\n return output;\n }\n return String(v);\n }\n return recur(input, 0);\n}\nconst CIRCULAR = \"[Circular]\";\n/**\n * @internal\n */\nexport function formatPropertyKey(name) {\n return typeof name === \"string\" ? JSON.stringify(name) : String(name);\n}\n/**\n * Formats an array of property keys as a bracket-notation path string.\n *\n * @internal\n */\nexport function formatPath(path) {\n return path.map(key => `[${formatPropertyKey(key)}]`).join(\"\");\n}\n/**\n * Formats a `Date` as an ISO 8601 string, returning `\"Invalid Date\"` for\n * invalid dates instead of throwing.\n *\n * @internal\n */\nexport function formatDate(date) {\n try {\n return date.toISOString();\n } catch {\n return \"Invalid Date\";\n }\n}\nfunction safeToString(input) {\n try {\n const s = input.toString();\n return typeof s === \"string\" ? s : String(s);\n } catch {\n return \"[toString threw]\";\n }\n}\nfunction safeGet(input, key) {\n try {\n return input[key];\n } catch {\n return \"[property access threw]\";\n }\n}\n/**\n * Stringifies a value to JSON safely, silently dropping circular references.\n *\n * **When to use**\n *\n * Use when you need valid JSON output, unlike `format`, and the input may\n * contain circular references that should be silently omitted rather than\n * throwing a `TypeError`.\n *\n * **Details**\n *\n * Uses `JSON.stringify` internally with a replacer that tracks the current\n * object ancestry. Circular references are replaced with `undefined`, which\n * omits them from object output. `Redactable` values are automatically redacted\n * before serialization. `BigInt` values are stringified with an `n` suffix.\n * Values not supported by JSON otherwise follow standard `JSON.stringify`\n * behavior. The `space` parameter controls indentation and defaults to `0`.\n *\n * **Gotchas**\n *\n * When the root input is `undefined`, a symbol, or a function, `formatJson`\n * returns `\"null\"` instead of the `undefined` returned by `JSON.stringify`.\n * Nested values retain standard `JSON.stringify` behavior.\n *\n * **Example** (Formatting compact JSON)\n *\n * ```ts import.meta.vitest\n * import { Formatter } from \"effect\"\n *\n * Formatter.formatJson({ name: \"Alice\", age: 30 }) // => \"{\\\"name\\\":\\\"Alice\\\",\\\"age\\\":30}\"\n * ```\n *\n * **Example** (Handling circular references)\n *\n * ```ts import.meta.vitest\n * import { Formatter } from \"effect\"\n *\n * const obj: any = { name: \"test\" }\n * obj.self = obj\n * Formatter.formatJson(obj) // => \"{\\\"name\\\":\\\"test\\\"}\"\n * ```\n *\n * **Example** (Pretty-printed JSON)\n *\n * ```ts import.meta.vitest\n * import { Formatter } from \"effect\"\n *\n * const output = Formatter.formatJson({ name: \"Alice\", age: 30 }, { space: 2 })\n * output // => \"{\\n \\\"name\\\": \\\"Alice\\\",\\n \\\"age\\\": 30\\n}\"\n * ```\n *\n * @see {@link format}\n * @see {@link Formatter}\n * @category serialization\n * @since 4.0.0\n */\nexport function formatJson(input, options) {\n const ancestors = [];\n return JSON.stringify(input, function (key, value) {\n const original = Object.getOwnPropertyDescriptor(this, key)?.value;\n const redacted = Predicate.hasProperty(original, symbolRedactable) ? redact(original) : redact(value);\n if (typeof redacted === \"bigint\") {\n return format(redacted);\n }\n if (typeof redacted !== \"object\" || redacted === null) {\n return redacted;\n }\n while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {\n ancestors.pop();\n }\n if (ancestors.includes(redacted)) {\n return undefined; // circular reference\n }\n ancestors.push(redacted);\n return redacted;\n }, options?.space) ?? \"null\";\n}\n//# sourceMappingURL=Formatter.js.map","/**\n * Controls how values appear in logs and debugging output.\n *\n * Effect data types use `Inspectable` to provide stable string, JSON, and\n * Node.js inspection output. This keeps custom values readable in logs, REPLs,\n * test failures, and diagnostics. This module defines the Node inspect symbol,\n * the `Inspectable` interface, safe conversion helpers, and shared prototype or\n * class implementations for custom values.\n *\n * @since 2.0.0\n */\nimport { format, formatJson } from \"./Formatter.js\";\nimport * as Predicate from \"./Predicate.js\";\nimport { redact } from \"./Redactable.js\";\n/**\n * Defines the symbol used by Node.js for custom object inspection.\n *\n * **When to use**\n *\n * Use to implement Node.js custom inspection for a value.\n *\n * **Details**\n *\n * This symbol is recognized by Node.js's `util.inspect()` function and the REPL\n * for custom object representation. When an object has a method with this symbol,\n * it will be called to determine how the object should be displayed.\n *\n * **Example** (Defining custom Node inspection)\n *\n * ```ts import.meta.vitest\n * import { Inspectable } from \"effect\"\n *\n * class CustomObject {\n * constructor(private value: string) {}\n *\n * [Inspectable.NodeInspectSymbol]() {\n * return `CustomObject(${this.value})`\n * }\n * }\n *\n * const obj = new CustomObject(\"hello\")\n * obj[Inspectable.NodeInspectSymbol]() // => \"CustomObject(hello)\"\n * ```\n *\n * @category symbols\n * @since 2.0.0\n */\nexport const NodeInspectSymbol = /*#__PURE__*/Symbol.for(\"nodejs.util.inspect.custom\");\n/**\n * Converts a value to its structured inspection representation.\n *\n * **When to use**\n *\n * Use when you need the structured representation of an inspectable value\n * without risking unhandled errors.\n *\n * **Details**\n *\n * This function applies redaction before extracting data from objects that\n * implement `toJSON`, recursively processes arrays, and handles errors\n * gracefully. Plain objects are returned unchanged, so the result is not\n * guaranteed to be accepted by `JSON.stringify`; it may still contain values\n * such as `BigInt`, functions, or circular references.\n *\n * @see {@link toStringUnknown} for converting unknown values to strings\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toJson = input => {\n try {\n input = redact(input);\n if (Predicate.hasProperty(input, \"toJSON\") && Predicate.isFunction(input[\"toJSON\"]) && input[\"toJSON\"].length === 0) {\n return input.toJSON();\n } else if (Array.isArray(input)) {\n return input.map(toJson);\n }\n return input;\n } catch {\n return \"[toJSON threw]\";\n }\n};\n/**\n * Converts an unknown value to a string for diagnostics.\n *\n * **When to use**\n *\n * Use to produce a diagnostic string from a value whose runtime type is unknown.\n *\n * **Details**\n *\n * Strings are returned unchanged. Objects are formatted as JSON using the\n * provided whitespace setting when possible, and values that cannot be\n * formatted are converted with `String`.\n *\n * @category converting\n * @since 2.0.0\n */\nexport const toStringUnknown = (u, whitespace = 2) => {\n if (typeof u === \"string\") {\n return u;\n }\n try {\n return typeof u === \"object\" ? formatJson(u, {\n space: whitespace\n }) : format(u, {\n space: whitespace\n });\n } catch {\n return String(u);\n }\n};\n/**\n * A base prototype object that implements the {@link Inspectable} interface.\n *\n * **When to use**\n *\n * Use as a prototype for plain objects that should share standard inspectable behavior.\n *\n * **Details**\n *\n * This object provides default implementations for the {@link Inspectable} methods.\n * It can be used as a prototype for objects that want to be inspectable,\n * or as a mixin to add inspection capabilities to existing objects.\n *\n * **Example** (Using the base inspectable prototype)\n *\n * ```ts import.meta.vitest\n * import { Inspectable } from \"effect\"\n *\n * // Use as prototype\n * const myObject = Object.create(Inspectable.BaseProto)\n * myObject.name = \"example\"\n * myObject.value = 42\n *\n * myObject.toString() // => \"\\\"[toJSON threw]\\\"\"\n *\n * // Or extend in a constructor\n * function MyClass(this: any, name: string) {\n * this.name = name\n * }\n * MyClass.prototype = Object.create(Inspectable.BaseProto)\n * MyClass.prototype.constructor = MyClass\n * ```\n *\n * @category prototypes\n * @since 2.0.0\n */\nexport const BaseProto = {\n toJSON() {\n return toJson(this);\n },\n [NodeInspectSymbol]() {\n return this.toJSON();\n },\n toString() {\n return format(this.toJSON());\n }\n};\n/**\n * Provides an abstract base class that implements the Inspectable interface.\n *\n * **When to use**\n *\n * Use as a base class for inspectable objects that define their own JSON representation.\n *\n * **Details**\n *\n * This class provides a convenient way to create inspectable objects by extending it.\n * Subclasses only need to implement the `toJSON()` method, and they automatically\n * get proper `toString()` and Node.js inspection support.\n *\n * **Example** (Extending the inspectable base class)\n *\n * ```ts import.meta.vitest\n * import { Inspectable } from \"effect\"\n *\n * class User extends Inspectable.Class {\n * constructor(\n * public readonly id: number,\n * public readonly name: string,\n * public readonly email: string\n * ) {\n * super()\n * }\n *\n * toJSON() {\n * return {\n * _tag: \"User\",\n * id: this.id,\n * name: this.name,\n * email: this.email\n * }\n * }\n * }\n *\n * const user = new User(1, \"Alice\", \"alice@example.com\")\n * user.toString() // => \"{\\\"_tag\\\":\\\"User\\\",\\\"id\\\":1,\\\"name\\\":\\\"Alice\\\",\\\"email\\\":\\\"alice@example.com\\\"}\"\n * user[Inspectable.NodeInspectSymbol]() // => { _tag: \"User\", id: 1, name: \"Alice\", email: \"alice@example.com\" }\n * ```\n *\n * @category models\n * @since 2.0.0\n */\nexport class Class {\n /**\n * Node.js custom inspection method.\n *\n * **When to use**\n *\n * Use to expose the class JSON representation to Node.js inspection.\n *\n * @since 2.0.0\n */\n [NodeInspectSymbol]() {\n return this.toJSON();\n }\n /**\n * Returns a formatted string representation of this object.\n *\n * **When to use**\n *\n * Use to format the class JSON representation as a string.\n *\n * @since 2.0.0\n */\n toString() {\n return format(this.toJSON());\n }\n}\n//# sourceMappingURL=Inspectable.js.map","/**\n * Check if `Error.stackTraceLimit` is writable.\n * Returns `false` if the property is frozen, non-writable, or `Error` is non-extensible.\n *\n * @internal\n */\nexport const isStackTraceLimitWritable = () => {\n const desc = Object.getOwnPropertyDescriptor(Error, \"stackTraceLimit\");\n if (desc === undefined) {\n return Object.isExtensible(Error);\n }\n return Object.hasOwn(desc, \"writable\") ? desc.writable === true : desc.set !== undefined;\n};\n// Cache the check result since it won't change during runtime\nconst canWriteStackTraceLimit = /*#__PURE__*/isStackTraceLimitWritable();\n/**\n * Get the current `Error.stackTraceLimit` value.\n * Returns `undefined` if the property doesn't exist.\n *\n * @internal\n */\nexport const getStackTraceLimit = () => Error.stackTraceLimit;\n/**\n * Safely set `Error.stackTraceLimit` if possible, otherwise no-op.\n *\n * Accepts `undefined` so a value read via {@link getStackTraceLimit} can be\n * restored faithfully.\n *\n * @internal\n */\nexport const setStackTraceLimit = value => {\n if (canWriteStackTraceLimit) {\n ;\n Error.stackTraceLimit = value;\n }\n};\n//# sourceMappingURL=stackTraceLimit.js.map","import { getStackTraceLimit } from \"./internal/stackTraceLimit.js\";\n/**\n * Yields its wrapped value exactly once through an `IterableIterator`.\n *\n * **When to use**\n *\n * Use to implement `[Symbol.iterator]()` on Effect-like types so they can be\n * `yield*`-ed inside generator functions, such as `Effect.gen` and\n * `Option.gen`.\n *\n * **Details**\n *\n * The first call to `next()` returns `{ value: self, done: false }`. Every\n * subsequent call returns `{ value: a, done: true }` where `a` is the argument\n * passed to `next()`. `[Symbol.iterator]()` returns a **new** `SingleShotGen`\n * wrapping the same value, so the outer type can be iterated multiple times.\n *\n * **Example** (Yielding a wrapped value in a generator)\n *\n * ```ts import.meta.vitest\n * import { Utils } from \"effect\"\n *\n * const gen = new Utils.SingleShotGen(\"hello\")\n *\n * gen.next(0) // => { value: \"hello\", done: false }\n *\n * gen.next(42) // => { value: 42, done: true }\n * ```\n *\n * @see {@link Gen} for the type-level signature that relies on `SingleShotGen`\n * @category constructors\n * @since 2.0.0\n */\nexport class SingleShotGen {\n called = false;\n self;\n constructor(self) {\n this.self = self;\n }\n /**\n * Yields the stored value once, then completes with the value sent back in.\n *\n * **When to use**\n *\n * Use to advance a `SingleShotGen` through its single yield and completion\n * step.\n *\n * @since 2.0.0\n */\n next(a) {\n return this.called ? {\n value: a,\n done: true\n } : (this.called = true, {\n value: this.self,\n done: false\n });\n }\n /**\n * Creates a fresh single-shot iterator over the stored value.\n *\n * **When to use**\n *\n * Use to iterate the wrapped value again without reusing the consumed\n * iterator state.\n *\n * @since 2.0.0\n */\n [Symbol.iterator]() {\n return new SingleShotGen(this.self);\n }\n}\n// the probe is wrapped in a single function call (rather than module-level\n// statements) so the whole selection is pure-annotated by the build and\n// tree-shakable when `internalCall` is unused.\nconst pickInternalCall = () => {\n const InternalTypeId = \"~effect/Utils/internal\";\n const standard = {\n [InternalTypeId]: body => {\n return body();\n }\n };\n const forced = {\n [InternalTypeId]: body => {\n try {\n return body();\n } finally {\n //\n }\n }\n };\n const isNotOptimizedAway = getStackTraceLimit() !== 0 && standard[InternalTypeId](() => new Error().stack)?.includes(InternalTypeId) === true;\n return isNotOptimizedAway ? standard[InternalTypeId] : forced[InternalTypeId];\n};\n/** @internal */\nexport const internalCall = /*#__PURE__*/pickInternalCall();\n//# sourceMappingURL=Utils.js.map","/** @internal */\nexport function assignProperty(self, key, value) {\n if (key === \"__proto__\") {\n Object.defineProperty(self, key, {\n value,\n writable: true,\n enumerable: true,\n configurable: true\n });\n } else {\n ;\n self[key] = value;\n }\n}\n/** @internal */\nexport function assignProperties(self, source) {\n for (const key of Reflect.ownKeys(source)) {\n if (Object.prototype.propertyIsEnumerable.call(source, key)) {\n assignProperty(self, key, source[key]);\n }\n }\n}\n//# sourceMappingURL=record.js.map","import * as Equal from \"../Equal.js\";\nimport { format } from \"../Formatter.js\";\nimport { dual, identity } from \"../Function.js\";\nimport * as Hash from \"../Hash.js\";\nimport { NodeInspectSymbol } from \"../Inspectable.js\";\nimport { pipeArguments } from \"../Pipeable.js\";\nimport { hasProperty } from \"../Predicate.js\";\nimport { SingleShotGen } from \"../Utils.js\";\nimport * as InternalRecord from \"./record.js\";\n/** @internal */\nexport const EffectTypeId = `~effect/Effect`;\n/** @internal */\nexport const ExitTypeId = `~effect/Exit`;\nconst effectVariance = {\n _A: identity,\n _E: identity,\n _R: identity\n};\n/** @internal */\nexport const identifier = `${EffectTypeId}/identifier`;\n/** @internal */\nexport const args = `${EffectTypeId}/args`;\n/** @internal */\nexport const evaluate = `${EffectTypeId}/evaluate`;\n/** @internal */\nexport const contA = `${EffectTypeId}/successCont`;\n/** @internal */\nexport const contE = `${EffectTypeId}/failureCont`;\n/** @internal */\nexport const contAll = `${EffectTypeId}/ensureCont`;\n/** @internal */\nexport const Yield = /*#__PURE__*/Symbol.for(\"effect/Effect/Yield\");\n/** @internal */\nexport const PipeInspectableProto = {\n pipe() {\n return pipeArguments(this, arguments);\n },\n toJSON() {\n return {\n ...this\n };\n },\n toString() {\n return format(this.toJSON(), {\n ignoreToString: true,\n space: 2\n });\n },\n [NodeInspectSymbol]() {\n return this.toJSON();\n }\n};\n/** @internal */\nexport const StructuralProto = {\n [Hash.symbol]() {\n return Hash.structureKeys(this, Object.keys(this));\n },\n [Equal.symbol](that) {\n const selfKeys = Object.keys(this);\n const thatKeys = Object.keys(that);\n if (selfKeys.length !== thatKeys.length) return false;\n for (let i = 0; i < selfKeys.length; i++) {\n if (selfKeys[i] !== thatKeys[i] || !Equal.equals(this[selfKeys[i]], that[selfKeys[i]])) {\n return false;\n }\n }\n return true;\n }\n};\n/** @internal */\nexport const EffectProto = {\n [EffectTypeId]: effectVariance,\n ...PipeInspectableProto,\n [Symbol.iterator]() {\n return new SingleShotGen(this);\n },\n toJSON() {\n return {\n _id: \"Effect\",\n op: this[identifier],\n ...(args in this ? {\n args: this[args]\n } : undefined)\n };\n }\n};\n/** @internal */\nexport const isEffect = u => hasProperty(u, EffectTypeId);\n/** @internal */\nexport const isExit = u => hasProperty(u, ExitTypeId);\n// ----------------------------------------------------------------------------\n// Cause\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const CauseTypeId = \"~effect/Cause\";\n/** @internal */\nexport const CauseReasonTypeId = \"~effect/Cause/Reason\";\n/** @internal */\nexport const isCause = self => hasProperty(self, CauseTypeId);\n/** @internal */\nexport const isCauseReason = self => hasProperty(self, CauseReasonTypeId);\n/** @internal */\nexport class CauseImpl {\n constructor(failures) {\n this[CauseTypeId] = CauseTypeId;\n this.reasons = failures;\n }\n pipe() {\n return pipeArguments(this, arguments);\n }\n toJSON() {\n return {\n _id: \"Cause\",\n failures: this.reasons.map(f => f.toJSON())\n };\n }\n toString() {\n return `Cause(${format(this.reasons)})`;\n }\n [NodeInspectSymbol]() {\n return this.toJSON();\n }\n [Equal.symbol](that) {\n return isCause(that) && this.reasons.length === that.reasons.length && this.reasons.every((e, i) => Equal.equals(e, that.reasons[i]));\n }\n [Hash.symbol]() {\n return Hash.array(this.reasons);\n }\n}\nconst annotationsMap = /*#__PURE__*/new WeakMap();\n/** @internal */\nexport class ReasonBase {\n [CauseReasonTypeId];\n annotations;\n _tag;\n constructor(_tag, annotations, originalError) {\n this[CauseReasonTypeId] = CauseReasonTypeId;\n this._tag = _tag;\n if (annotations !== constEmptyAnnotations && typeof originalError === \"object\" && originalError !== null && annotations.size > 0) {\n const prevAnnotations = annotationsMap.get(originalError);\n if (prevAnnotations) {\n annotations = new Map([...prevAnnotations, ...annotations]);\n }\n annotationsMap.set(originalError, annotations);\n }\n this.annotations = annotations;\n }\n annotate(annotations, options) {\n if (annotations.mapUnsafe.size === 0) return this;\n const newAnnotations = new Map(this.annotations);\n annotations.mapUnsafe.forEach((value, key) => {\n if (options?.overwrite !== true && newAnnotations.has(key)) return;\n newAnnotations.set(key, value);\n });\n const self = Object.assign(Object.create(Object.getPrototypeOf(this)), this);\n self.annotations = newAnnotations;\n return self;\n }\n pipe() {\n return pipeArguments(this, arguments);\n }\n toString() {\n return format(this);\n }\n [NodeInspectSymbol]() {\n return this.toString();\n }\n}\n/** @internal */\nexport const constEmptyAnnotations = /*#__PURE__*/new Map();\n/** @internal */\nexport class Fail extends ReasonBase {\n constructor(error, annotations = constEmptyAnnotations) {\n super(\"Fail\", annotations, error);\n this.error = error;\n }\n toString() {\n return `Fail(${format(this.error)})`;\n }\n toJSON() {\n return {\n _tag: \"Fail\",\n error: this.error\n };\n }\n [Equal.symbol](that) {\n return isFailReason(that) && Equal.equals(this.error, that.error) && Equal.equals(this.annotations, that.annotations);\n }\n [Hash.symbol]() {\n return Hash.combine(Hash.string(this._tag))(Hash.combine(Hash.hash(this.error))(Hash.hash(this.annotations)));\n }\n}\n/** @internal */\nexport const causeFromReasons = reasons => new CauseImpl(reasons);\n/** @internal */\nexport const causeEmpty = /*#__PURE__*/new CauseImpl([]);\n/** @internal */\nexport const causeFail = error => new CauseImpl([new Fail(error)]);\n/** @internal */\nexport class Die extends ReasonBase {\n constructor(defect, annotations = constEmptyAnnotations) {\n super(\"Die\", annotations, defect);\n this.defect = defect;\n }\n toString() {\n return `Die(${format(this.defect)})`;\n }\n toJSON() {\n return {\n _tag: \"Die\",\n defect: this.defect\n };\n }\n [Equal.symbol](that) {\n return isDieReason(that) && Equal.equals(this.defect, that.defect) && Equal.equals(this.annotations, that.annotations);\n }\n [Hash.symbol]() {\n return Hash.combine(Hash.string(this._tag))(Hash.combine(Hash.hash(this.defect))(Hash.hash(this.annotations)));\n }\n}\n/** @internal */\nexport const causeDie = defect => new CauseImpl([new Die(defect)]);\n/** @internal */\nexport const causeAnnotate = /*#__PURE__*/dual(args => isCause(args[0]), (self, annotations, options) => {\n if (annotations.mapUnsafe.size === 0) return self;\n return new CauseImpl(self.reasons.map(f => f.annotate(annotations, options)));\n});\n/** @internal */\nexport const isFailReason = self => self._tag === \"Fail\";\n/** @internal */\nexport const isDieReason = self => self._tag === \"Die\";\n/** @internal */\nexport const isInterruptReason = self => self._tag === \"Interrupt\";\nfunction defaultEvaluate(_fiber) {\n return exitDie(`Effect.evaluate: Not implemented`);\n}\n/** @internal */\nexport const makePrimitiveProto = options => ({\n ...EffectProto,\n [identifier]: options.op,\n [evaluate]: options[evaluate] ?? defaultEvaluate,\n [contA]: options[contA],\n [contE]: options[contE],\n [contAll]: options[contAll]\n});\n/** @internal */\nexport const makePrimitive = options => {\n const Proto = makePrimitiveProto(options);\n const PrimitiveImpl = function (value) {\n this[args] = value;\n };\n PrimitiveImpl.prototype = Proto;\n return function (value) {\n return new PrimitiveImpl(value);\n };\n};\n/** @internal */\nexport const makeExit = options => {\n const Proto = {\n [ExitTypeId]: ExitTypeId,\n _tag: options.op,\n get [options.prop]() {\n return this[args];\n },\n ...makePrimitiveProto(options),\n toString() {\n return `${options.op}(${format(this[args])})`;\n },\n toJSON() {\n return {\n _id: \"Exit\",\n _tag: options.op,\n [options.prop]: this[args]\n };\n },\n [Equal.symbol](that) {\n return isExit(that) && that._tag === this._tag && Equal.equals(this[args], that[args]);\n },\n [Hash.symbol]() {\n return Hash.combine(Hash.string(options.op), Hash.hash(this[args]));\n }\n };\n const ExitPrimitive = function (value) {\n this[args] = value;\n };\n ExitPrimitive.prototype = Proto;\n return function (value) {\n return new ExitPrimitive(value);\n };\n};\n/** @internal */\nexport const exitSucceed = /*#__PURE__*/makeExit({\n op: \"Success\",\n prop: \"value\",\n [evaluate](fiber) {\n const cont = fiber.getCont(contA);\n return cont ? cont[contA](this[args], fiber, this) : fiber.yieldWith(this);\n }\n});\n/** @internal */\nexport const StackTraceKey = {\n key: \"effect/Cause/StackTrace\"\n};\n/** @internal */\nexport const InterruptorStackTrace = {\n key: \"effect/Cause/InterruptorStackTrace\"\n};\n/** @internal */\nexport const exitFailCause = /*#__PURE__*/makeExit({\n op: \"Failure\",\n prop: \"cause\",\n [evaluate](fiber) {\n let cause = this[args];\n let annotated = false;\n if (fiber.cache.stackFrame) {\n cause = causeAnnotate(cause, {\n mapUnsafe: new Map([[StackTraceKey.key, fiber.cache.stackFrame]])\n });\n annotated = true;\n }\n let cont = fiber.getCont(contE);\n while (fiber.interruptible && fiber._interruptedCause && cont) {\n cont = fiber.getCont(contE);\n }\n return cont ? cont[contE](cause, fiber, annotated ? undefined : this) : fiber.yieldWith(annotated ? exitFailCause(cause) : this);\n }\n});\n/** @internal */\nexport const exitFail = e => exitFailCause(causeFail(e));\n/** @internal */\nexport const exitDie = defect => exitFailCause(causeDie(defect));\n/** @internal */\nexport const withFiber = /*#__PURE__*/makePrimitive({\n op: \"WithFiber\",\n [evaluate](fiber) {\n return this[args](fiber);\n }\n});\n/**\n * Accesses the current fiber to compute a value without a separate `succeed`\n * operation.\n *\n * @internal\n */\nexport const withFiberSucceed = /*#__PURE__*/makePrimitive({\n op: \"WithFiberSucceed\",\n [evaluate](fiber) {\n const value = this[args](fiber);\n const cont = fiber.getCont(contA);\n return cont ? cont[contA](value, fiber) : fiber.yieldWith(exitSucceed(value));\n }\n});\n/** @internal */\nexport const YieldableError = /*#__PURE__*/function () {\n class YieldableError extends globalThis.Error {}\n const proto = /*#__PURE__*/makePrimitiveProto({\n op: \"YieldableError\",\n [evaluate]() {\n return exitFail(this);\n }\n });\n delete proto.toString;\n Object.assign(YieldableError.prototype, proto);\n return YieldableError;\n}();\n/** @internal */\nexport const Error = /*#__PURE__*/function () {\n const plainArgsSymbol = /*#__PURE__*/Symbol.for(\"effect/Data/Error/plainArgs\");\n return class Base extends YieldableError {\n constructor(args) {\n super(args?.message, args?.cause ? {\n cause: args.cause\n } : undefined);\n if (args) {\n InternalRecord.assignProperties(this, args);\n // @effect-diagnostics-next-line floatingEffect:off\n Object.defineProperty(this, plainArgsSymbol, {\n value: args,\n enumerable: false\n });\n }\n }\n toJSON() {\n return {\n ...this[plainArgsSymbol],\n ...this\n };\n }\n };\n}();\n/** @internal */\nexport const TaggedError = tag => {\n class Base extends Error {\n _tag = tag;\n }\n ;\n Base.prototype.name = tag;\n return Base;\n};\n/** @internal */\nexport const NoSuchElementErrorTypeId = \"~effect/Cause/NoSuchElementError\";\n/** @internal */\nexport const isNoSuchElementError = u => hasProperty(u, NoSuchElementErrorTypeId);\n/** @internal */\nexport class NoSuchElementError extends /*#__PURE__*/TaggedError(\"NoSuchElementError\") {\n [NoSuchElementErrorTypeId] = NoSuchElementErrorTypeId;\n constructor(message) {\n super({\n message\n });\n }\n}\n/** @internal */\nexport const DoneTypeId = \"~effect/Cause/Done\";\n/** @internal */\nexport const isDone = u => hasProperty(u, DoneTypeId);\nconst DoneVoid = {\n [DoneTypeId]: DoneTypeId,\n _tag: \"Done\",\n value: undefined\n};\n/** @internal */\nexport const Done = value => {\n if (value === undefined) return DoneVoid;\n return {\n [DoneTypeId]: DoneTypeId,\n _tag: \"Done\",\n value\n };\n};\nconst doneVoid = /*#__PURE__*/exitFail(DoneVoid);\n/** @internal */\nexport const done = value => {\n if (value === undefined) return doneVoid;\n return exitFail(Done(value));\n};\n//# sourceMappingURL=core.js.map","import { evaluate, makePrimitiveProto } from \"./internal/core.js\";\n/**\n * Create a low-level `Effect` prototype.\n *\n * **When to use**\n *\n * Use when you need to create a custom Effect-like value without extending a\n * class, by providing a label and an evaluate function that receives the\n * current fiber.\n *\n * **Details**\n *\n * When the effect is evaluated, it calls `evaluate` with the current fiber.\n *\n * @see {@link Class} for a class-based approach to defining custom Effect values\n * @see {@link Mixin} for wrapping an existing class constructor\n *\n * @category prototypes\n * @since 4.0.0\n */\nexport const Prototype = options => makePrimitiveProto({\n op: options.label,\n [evaluate]: options.evaluate\n});\nconst proto = /*#__PURE__*/Prototype({\n label: \"Effectable\",\n evaluate(_) {\n return this.asEffect();\n }\n});\nconst Base = /*#__PURE__*/(() => {\n const Base = function () {};\n Base.prototype = proto;\n return Base;\n})();\n/**\n * Provides an abstract class that can be extended to create an `Effect`.\n *\n * **When to use**\n *\n * Use as an abstract base class to define custom classes whose instances behave\n * as `Effect` values.\n *\n * @see {@link Prototype} for a lower-level primitive approach to creating custom Effect-like values without a class\n * @see {@link Mixin} for wrapping an existing class constructor\n * @category constructors\n * @since 2.0.0\n */\nexport class Class extends Base {}\n/**\n * Returns a subclass of the provided class that inserts the Effect prototype\n * into the inheritance chain.\n *\n * **When to use**\n *\n * Use to make instances of an existing class behave as `Effect` values without\n * extending {@link Class} or modifying the original prototype.\n *\n * **Details**\n *\n * Pass the class to wrap, then implement `asEffect` on the final class. The\n * returned class is abstract, and the success, error, and service types are\n * inferred from the concrete `asEffect` return type. Concrete and abstract base\n * classes are supported. Constructor parameters and instance members are\n * preserved, except that Effect's prototype members shadow base prototype\n * members with the same name: `pipe`, `toString`, `toJSON`, `[Symbol.iterator]`,\n * and `[Symbol.for(\"nodejs.util.inspect.custom\")]`.\n *\n * **Example** (Evaluating a mixed-in class)\n *\n * ```ts import.meta.vitest\n * import { Effect, Effectable } from \"effect\"\n *\n * class Box {\n * constructor(readonly value: number) {}\n * }\n *\n * class EffectBox extends Effectable.Mixin(Box) {\n * asEffect() {\n * return Effect.succeed(this.value)\n * }\n * }\n *\n * const box = new EffectBox(2)\n * Effect.isEffect(box) // => true\n * await Effect.runPromise(box) // => 2\n * ```\n *\n * @see {@link Prototype} for a lower-level primitive approach to creating custom Effect-like values without a class\n * @see {@link Class} for a base constructor to extend\n * @category constructors\n * @since 4.0.0\n */\nexport const Mixin = klass => {\n class Mixed extends klass {}\n Object.defineProperties(Mixed.prototype, Object.getOwnPropertyDescriptors(proto));\n return Mixed;\n};\n//# sourceMappingURL=Effectable.js.map","/**\n * Defines reusable equality functions for values of the same type.\n *\n * An `Equivalence` returns `true` when two `A` values should be treated as\n * the same for a particular purpose. This module includes strict equality\n * instances for primitive types, constructors for custom comparisons, and\n * helpers for tuples, arrays, structs, records, dates, and values compared\n * through a derived field.\n *\n * @since 2.0.0\n */\nimport { dual } from \"./Function.js\";\nimport * as Reducer from \"./Reducer.js\";\n/**\n * Creates a custom equivalence relation with an optimized reference equality check.\n *\n * **When to use**\n *\n * Use when you need an equality rule that the built-in instances and input\n * mapping helpers cannot express, and you can provide a law-abiding comparison.\n *\n * **Details**\n *\n * The returned equivalence first checks reference equality (`===`) for\n * performance. If the values are not the same reference, it falls back to the\n * provided equivalence function, which must satisfy reflexive, symmetric, and\n * transitive properties.\n *\n * **Example** (Case-insensitive string equivalence)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const caseInsensitive = Equivalence.make((a, b) =>\n * a.toLowerCase() === b.toLowerCase()\n * )\n *\n * caseInsensitive(\"Hello\", \"HELLO\") // => true\n * caseInsensitive(\"foo\", \"bar\") // => false\n *\n * // Same reference optimization\n * const str = \"test\"\n * caseInsensitive(str, str) // => true\n * ```\n *\n * **Example** (Comparing numbers with tolerance)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const tolerance = Equivalence.make((a, b) => Math.abs(a - b) < 0.0001)\n *\n * tolerance(1.0, 1.001) // => false\n * tolerance(1.0, 1.00001) // => true\n * ```\n *\n * @see {@link strictEqual}\n * @see {@link mapInput}\n * @category constructors\n * @since 2.0.0\n */\nexport const make = isEquivalent => (self, that) => self === that || isEquivalent(self, that);\nconst isStrictEquivalent = (x, y) => x === y;\n/**\n * Creates an equivalence relation that uses strict equality (`===`) to compare values.\n *\n * **When to use**\n *\n * Use when you need strict equality (`===`) as the comparison.\n *\n * **Details**\n *\n * Uses JavaScript's strict equality operator (`===`). Primitives compare by\n * value. Objects compare by reference, so only the same object instance is\n * equivalent. Use this as a building block for more complex equivalences via\n * `mapInput` or `combine`.\n *\n * **Gotchas**\n *\n * `NaN !== NaN`, so `NaN` values are never considered equivalent.\n *\n * **Example** (Comparing primitive types)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const strictEq = Equivalence.strictEqual()\n *\n * strictEq(1, 1) // => true\n * strictEq(1, 2) // => false\n * strictEq(NaN, NaN) // => false\n * ```\n *\n * **Example** (Comparing objects by reference)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const obj = { value: 42 }\n * const strictObjEq = Equivalence.strictEqual()\n *\n * strictObjEq(obj, obj) // => true\n * strictObjEq(obj, { value: 42 }) // => false\n * ```\n *\n * @see {@link make}\n * @see `Equal` for structural equality\n * @category constructors\n * @since 4.0.0\n */\nexport const strictEqual = () => isStrictEquivalent;\n/**\n * Equivalence instance for strings using strict equality (`===`).\n *\n * **When to use**\n *\n * Use when you need to supply case-sensitive string equality.\n *\n * **Example** (Comparing strings)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * Equivalence.String(\"hello\", \"hello\") // => true\n * Equivalence.String(\"hello\", \"world\") // => false\n * ```\n *\n * @category instances\n * @since 4.0.0\n */\nexport const String = isStrictEquivalent;\n/**\n * Equivalence instance for numbers.\n *\n * **When to use**\n *\n * Use when you need numeric equality that treats NaN as equal to itself.\n *\n * **Example** (Comparing numbers)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * Equivalence.Number(1, 1) // => true\n * Equivalence.Number(1, 2) // => false\n * Equivalence.Number(NaN, NaN) // => true\n * ```\n *\n * @category instances\n * @since 4.0.0\n */\nexport const Number = /*#__PURE__*/make((self, that) => globalThis.Number.isNaN(self) && globalThis.Number.isNaN(that));\n/**\n * Equivalence instance for booleans using strict equality (`===`).\n *\n * **When to use**\n *\n * Use when you need to supply boolean equality.\n *\n * **Example** (Comparing booleans)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * Equivalence.Boolean(true, true) // => true\n * Equivalence.Boolean(true, false) // => false\n * ```\n *\n * @category instances\n * @since 4.0.0\n */\nexport const Boolean = isStrictEquivalent;\n/**\n * Equivalence instance for bigints using strict equality (`===`).\n *\n * **When to use**\n *\n * Use when you need to supply bigint equality.\n *\n * **Example** (Comparing bigints)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * Equivalence.BigInt(1n, 1n) // => true\n * Equivalence.BigInt(1n, 2n) // => false\n * ```\n *\n * @category instances\n * @since 4.0.0\n */\nexport const BigInt = isStrictEquivalent;\n/**\n * Combines two equivalence relations using logical AND.\n *\n * **When to use**\n *\n * Use when you need to combine exactly two equivalences with AND semantics.\n *\n * **Details**\n *\n * Returns `true` only if both equivalences return `true`. The comparison\n * short-circuits when the first equivalence returns `false`. The result is also\n * an equivalence that satisfies reflexive, symmetric, and transitive\n * properties.\n *\n * **Example** (Combining name and age equivalences)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * interface Person {\n * name: string\n * age: number\n * }\n *\n * const nameEquivalence = Equivalence.mapInput(\n * Equivalence.strictEqual(),\n * (p: Person) => p.name\n * )\n *\n * const ageEquivalence = Equivalence.mapInput(\n * Equivalence.strictEqual(),\n * (p: Person) => p.age\n * )\n *\n * const personEquivalence = Equivalence.combine(nameEquivalence, ageEquivalence)\n *\n * const person1 = { name: \"Alice\", age: 30 }\n * const person2 = { name: \"Alice\", age: 30 }\n * const person3 = { name: \"Alice\", age: 31 }\n *\n * personEquivalence(person1, person2) // => true\n * personEquivalence(person1, person3) // => false\n * ```\n *\n * @see {@link combineAll}\n * @see {@link mapInput}\n * @category combining\n * @since 2.0.0\n */\nexport const combine = /*#__PURE__*/dual(2, (self, that) => make((x, y) => self(x, y) && that(x, y)));\n/**\n * Combines multiple equivalence relations into a single equivalence using logical AND.\n *\n * **When to use**\n *\n * Use when you need to combine many `Equivalence` instances from an iterable.\n *\n * **Details**\n *\n * Returns `true` only if all equivalences in the collection return `true`. The\n * comparison stops at the first equivalence that returns `false`. Empty\n * collections return an equivalence that always returns `true`. The result is\n * also an equivalence that satisfies reflexive, symmetric, and transitive\n * properties.\n *\n * **Example** (Combining multiple field equivalences)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * interface Point3D {\n * x: number\n * y: number\n * z: number\n * }\n *\n * const xEq = Equivalence.mapInput(\n * Equivalence.strictEqual(),\n * (p: Point3D) => p.x\n * )\n * const yEq = Equivalence.mapInput(\n * Equivalence.strictEqual(),\n * (p: Point3D) => p.y\n * )\n * const zEq = Equivalence.mapInput(\n * Equivalence.strictEqual(),\n * (p: Point3D) => p.z\n * )\n *\n * const point3DEq = Equivalence.combineAll([xEq, yEq, zEq])\n *\n * const point1 = { x: 1, y: 2, z: 3 }\n * const point2 = { x: 1, y: 2, z: 3 }\n * const point3 = { x: 1, y: 2, z: 4 }\n *\n * point3DEq(point1, point2) // => true\n * point3DEq(point1, point3) // => false\n * ```\n *\n * **Example** (Handling empty collections)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * // Empty collection always returns true\n * const alwaysEq = Equivalence.combineAll([])\n * alwaysEq(\"anything\", \"else\") // => true\n * ```\n *\n * @see {@link combine}\n * @see {@link mapInput}\n * @category combining\n * @since 2.0.0\n */\nexport const combineAll = collection => make((x, y) => {\n for (const equivalence of collection) {\n if (!equivalence(x, y)) {\n return false;\n }\n }\n return true;\n});\n/**\n * Transforms an equivalence relation by mapping the input values before comparison.\n *\n * **When to use**\n *\n * Use when you need an equivalence for one type by comparing a derived value.\n *\n * **Details**\n *\n * - Applies the transformation function to both values before comparing\n * - The transformation function should be pure and have no side effects\n * - The resulting equivalence compares the transformed values using the provided equivalence\n * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties\n * - Useful for comparing by one property or normalizing values before\n * comparison, such as case-insensitive strings\n *\n * **Example** (Deriving equivalence from an object property)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * interface User {\n * id: number\n * name: string\n * email: string\n * }\n *\n * // Create equivalence based on user ID only\n * const userByIdEq = Equivalence.mapInput(\n * Equivalence.strictEqual(),\n * (user: User) => user.id\n * )\n *\n * const user1 = { id: 1, name: \"Alice\", email: \"alice@example.com\" }\n * const user2 = { id: 1, name: \"Alice Smith\", email: \"alice.smith@example.com\" }\n * const user3 = { id: 2, name: \"Bob\", email: \"bob@example.com\" }\n *\n * userByIdEq(user1, user2) // => true\n * userByIdEq(user1, user3) // => false\n * ```\n *\n * **Example** (Case-insensitive string equivalence)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const caseInsensitiveEq = Equivalence.mapInput(\n * Equivalence.strictEqual(),\n * (s: string) => s.toLowerCase()\n * )\n *\n * caseInsensitiveEq(\"Hello\", \"HELLO\") // => true\n * caseInsensitiveEq(\"Hello\", \"World\") // => false\n * ```\n *\n * @see {@link combine}\n * @see {@link Struct}\n * @category mapping\n * @since 2.0.0\n */\nexport const mapInput = /*#__PURE__*/dual(2, (self, f) => make((x, y) => self(f(x), f(y))));\n/**\n * Creates an equivalence for tuples with heterogeneous element types.\n *\n * **When to use**\n *\n * Use when you need an `Equivalence` for fixed-length tuples with per-position\n * equivalences.\n *\n * **Details**\n *\n * Tuples must have the same length; different lengths are never equivalent.\n * Each equivalence is applied to the corresponding element position. The result\n * returns `true` only if all elements are equivalent according to their\n * respective equivalences, and it also satisfies reflexive, symmetric, and\n * transitive properties.\n *\n * **Example** (Comparing homogeneous tuples)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const stringTupleEq = Equivalence.Tuple([\n * Equivalence.strictEqual(),\n * Equivalence.strictEqual(),\n * Equivalence.strictEqual()\n * ])\n *\n * const tuple1 = [\"hello\", \"world\", \"test\"] as const\n * const tuple2 = [\"hello\", \"world\", \"test\"] as const\n * const tuple3 = [\"hello\", \"world\", \"different\"] as const\n *\n * stringTupleEq(tuple1, tuple2) // => true\n * stringTupleEq(tuple1, tuple3) // => false\n * ```\n *\n * **Example** (Comparing tuples with custom equivalences)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const caseInsensitive = Equivalence.mapInput(\n * Equivalence.strictEqual(),\n * (s: string) => s.toLowerCase()\n * )\n *\n * const customTupleEq = Equivalence.Tuple([\n * caseInsensitive,\n * caseInsensitive,\n * caseInsensitive\n * ])\n *\n * customTupleEq([\"Hello\", \"World\", \"Test\"], [\"HELLO\", \"WORLD\", \"TEST\"]) // => true\n * ```\n *\n * @category combinators\n * @since 4.0.0\n */\nexport function Tuple(elements) {\n return make((self, that) => {\n if (self.length !== that.length) {\n return false;\n }\n for (let i = 0; i < self.length; i++) {\n if (!elements[i](self[i], that[i])) {\n return false;\n }\n }\n return true;\n });\n}\n/**\n * @since 4.0.0\n */\nfunction Array_(item) {\n return make((self, that) => {\n if (self.length !== that.length) return false;\n for (let i = 0; i < self.length; i++) {\n if (!item(self[i], that[i])) return false;\n }\n return true;\n });\n}\nexport {\n/**\n * Creates an equivalence for arrays where all elements are compared using the same equivalence.\n *\n * **When to use**\n *\n * Use when you need to compare arrays with one equivalence for every element.\n *\n * **Details**\n *\n * - Requires arrays to have the same length; different lengths are never equivalent\n * - Compares elements positionally, such as index `0` with index `0`\n * - Returns `true` only if all corresponding elements are equivalent\n * - Empty arrays are considered equivalent\n * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties\n *\n * **Example** (Comparing number arrays)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const numberArrayEq = Equivalence.Array(Equivalence.strictEqual())\n *\n * numberArrayEq([1, 2, 3], [1, 2, 3]) // => true\n * numberArrayEq([1, 2, 3], [1, 2, 4]) // => false\n * numberArrayEq([1, 2], [1, 2, 3]) // => false\n * ```\n *\n * **Example** (Case-insensitive string array)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const caseInsensitive = Equivalence.mapInput(\n * Equivalence.strictEqual(),\n * (s: string) => s.toLowerCase()\n * )\n * const stringArrayEq = Equivalence.Array(caseInsensitive)\n *\n * stringArrayEq([\"Hello\", \"World\"], [\"HELLO\", \"WORLD\"]) // => true\n * stringArrayEq([\"Hello\"], [\"Hi\"]) // => false\n * stringArrayEq([], []) // => true\n * ```\n *\n * @see {@link Tuple}\n * @see {@link Record}\n * @category combinators\n * @since 4.0.0\n */\nArray_ as Array };\n/**\n * Creates an equivalence for objects by comparing their properties using provided equivalences.\n *\n * **When to use**\n *\n * Use when you need an `Equivalence` for objects with known, fixed property\n * names.\n *\n * **Details**\n *\n * Compares only the properties specified in the struct definition; other\n * properties are ignored. String and symbol keys are supported via\n * `Reflect.ownKeys`. The result returns `true` only if all specified properties\n * are equivalent according to their equivalences, and it also satisfies\n * reflexive, symmetric, and transitive properties.\n *\n * **Example** (Comparing structs with different equivalences per field)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * interface Person {\n * name: string\n * age: number\n * email: string\n * }\n *\n * const caseInsensitive = Equivalence.mapInput(\n * Equivalence.strictEqual(),\n * (s: string) => s.toLowerCase()\n * )\n *\n * const personEq = Equivalence.Struct({\n * name: caseInsensitive,\n * age: Equivalence.strictEqual(),\n * email: caseInsensitive\n * })\n *\n * const person1 = { name: \"Alice\", age: 30, email: \"alice@example.com\" }\n * const person2 = { name: \"ALICE\", age: 30, email: \"ALICE@EXAMPLE.COM\" }\n * const person3 = { name: \"Alice\", age: 31, email: \"alice@example.com\" }\n *\n * personEq(person1, person2) // => true\n * personEq(person1, person3) // => false\n * ```\n *\n * **Example** (Comparing specific fields)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const nameAgeEq = Equivalence.Struct({\n * name: Equivalence.strictEqual(),\n * age: Equivalence.strictEqual()\n * })\n *\n * // Only compares name and age, ignores other properties\n * const obj1 = { name: \"Alice\", age: 30, extra: \"ignored\" }\n * const obj2 = { name: \"Alice\", age: 30, extra: \"different\" }\n * nameAgeEq(obj1, obj2) // => true\n * ```\n *\n * @see {@link Record}\n * @see {@link mapInput}\n * @see {@link combine}\n * @category combinators\n * @since 4.0.0\n */\nexport function Struct(fields) {\n const keys = Reflect.ownKeys(fields);\n return make((self, that) => {\n for (const key of keys) {\n if (!fields[key](self[key], that[key])) return false;\n }\n return true;\n });\n}\n/**\n * Creates an equivalence for objects by comparing all properties using the same equivalence.\n *\n * **When to use**\n *\n * Use when you need to compare records with the same equivalence for every\n * property value.\n *\n * **Details**\n *\n * - Compares all properties present in both objects\n * - Requires both objects to have the same set of keys; different keys result in `false`\n * - All property values must be equivalent according to the provided equivalence\n * - Supports both string and symbol keys via `Reflect.ownKeys`\n * - Empty objects are considered equivalent\n * - The result is also an equivalence that satisfies reflexive, symmetric, and transitive properties\n *\n * **Example** (Defining records with string values)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const stringRecordEq = Equivalence.Record(Equivalence.strictEqual())\n *\n * const record1 = { a: \"hello\", b: \"world\" }\n * const record2 = { a: \"hello\", b: \"world\" }\n * const record3 = { a: \"hello\", b: \"different\" }\n * const record4 = { a: \"hello\" } // missing key 'b'\n *\n * stringRecordEq(record1, record2) // => true\n * stringRecordEq(record1, record3) // => false\n * stringRecordEq(record1, record4) // => false\n * ```\n *\n * **Example** (Defining records with number values)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const numberRecordEq = Equivalence.Record(Equivalence.strictEqual())\n *\n * const scores1 = { alice: 100, bob: 85 }\n * const scores2 = { alice: 100, bob: 85 }\n * const scores3 = { alice: 100, bob: 90 }\n *\n * numberRecordEq(scores1, scores2) // => true\n * numberRecordEq(scores1, scores3) // => false\n * ```\n *\n * @category combinators\n * @since 4.0.0\n */\nexport function Record(value) {\n return make((self, that) => {\n const selfKeys = Reflect.ownKeys(self);\n const thatKeys = Reflect.ownKeys(that);\n if (selfKeys.length !== thatKeys.length) return false;\n for (const key of selfKeys) {\n if (!Object.hasOwn(that, key) || !value(self[key], that[key])) {\n return false;\n }\n }\n return true;\n });\n}\n/**\n * Creates a `Reducer` for combining `Equivalence` instances, useful for aggregating equivalences in collections.\n *\n * **When to use**\n *\n * Use when you need a reducer that combines equivalences.\n *\n * **Details**\n *\n * Returns a reducer that combines equivalences using `combine`. The identity\n * element for empty collections is an equivalence that always returns `true`.\n * The reducer uses `combineAll` for collections of equivalences and can be used\n * with fold operations.\n *\n * **Example** (Creating a Reducer)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const reducer = Equivalence.makeReducer()\n * const equivalences = [\n * Equivalence.strictEqual(),\n * Equivalence.make((a, b) => Math.abs(a - b) < 1)\n * ]\n *\n * const combined = reducer.combineAll(equivalences)\n * // Combined equivalence requires both conditions to be true\n * combined(1, 1) // => true\n * combined(1, 1.5) // => false\n * ```\n *\n * @see {@link combine} Combine two equivalences\n * @see {@link combineAll} Combine multiple equivalences\n * @see {@link Reducer} Reducer type for collection operations\n * @category constructors\n * @since 4.0.0\n */\nexport function makeReducer() {\n return Reducer.make(combine, () => true, combineAll);\n}\n/**\n * Equivalence instance for `Date` objects that compares their `getTime()` values using `Equivalence.Number`.\n *\n * **When to use**\n *\n * Use when you need an `Equivalence` for JavaScript date objects by their\n * millisecond timestamp.\n *\n * **Details**\n *\n * Different `Date` instances that represent the same millisecond timestamp are equivalent. Because `Equivalence.Number`\n * treats `NaN` as equal to `NaN`, two invalid `Date` values are also considered equivalent.\n *\n * **Example** (Comparing Date values)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const d1 = new Date(\"2020-01-01T00:00:00.000Z\")\n * const d2 = new Date(\"2020-01-01T00:00:00.000Z\")\n * const d3 = new Date(\"2021-01-01T00:00:00.000Z\")\n * const invalidDate1 = new Date(\"foo\")\n * const invalidDate2 = new Date(\"bar\")\n *\n * Equivalence.Date(d1, d2) // => true\n * Equivalence.Date(d1, d3) // => false\n * Equivalence.Date(invalidDate1, invalidDate2) // => true\n * Equivalence.Date(invalidDate1, d1) // => false\n * ```\n *\n * **Example** (Comparing reference and value equality)\n *\n * ```ts import.meta.vitest\n * import { Equivalence } from \"effect\"\n *\n * const d1 = new Date(0)\n * const d2 = new Date(0)\n *\n * d1 === d2 // => false\n * Equivalence.Date(d1, d2) // => true\n * ```\n *\n * @see {@link Number} for the numeric equivalence applied to each `Date#getTime()` result\n * @see {@link mapInput} for deriving an equivalence by mapping inputs before comparison\n * @see {@link strictEqual} for reference equality when two values must be the same object\n * @category instances\n * @since 2.0.0\n */\nexport const Date = /*#__PURE__*/mapInput(Number, d => d.getTime());\n//# sourceMappingURL=Equivalence.js.map","/**\n * @since 2.0.0\n */\nimport * as Equal from \"../Equal.js\";\nimport { format } from \"../Formatter.js\";\nimport * as Hash from \"../Hash.js\";\nimport { toJson } from \"../Inspectable.js\";\nimport { hasProperty } from \"../Predicate.js\";\nimport { SingleShotGen } from \"../Utils.js\";\nimport { PipeInspectableProto } from \"./core.js\";\nconst TypeId = \"~effect/Option\";\nconst CommonProto = {\n [TypeId]: {\n _A: _ => _\n },\n ...PipeInspectableProto,\n [Symbol.iterator]() {\n return new SingleShotGen(this);\n }\n};\n// `valueOrUndefined` is folded into the initializer (rather than a separate\n// `Object.defineProperty(SomeProto, ...)` statement) so the whole definition\n// is pure-annotated by the build and tree-shakable.\nconst SomeProto = /*#__PURE__*/Object.defineProperty(/*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonProto), {\n _tag: \"Some\",\n _op: \"Some\",\n [Equal.symbol](that) {\n return isOption(that) && isSome(that) && Equal.equals(this.value, that.value);\n },\n [Hash.symbol]() {\n return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.value));\n },\n toString() {\n return `some(${format(this.value)})`;\n },\n toJSON() {\n return {\n _id: \"Option\",\n _tag: this._tag,\n value: toJson(this.value)\n };\n }\n}), \"valueOrUndefined\", {\n get() {\n return this.value;\n }\n});\nconst NoneHash = /*#__PURE__*/Hash.hash(\"None\");\nconst NoneProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonProto), {\n _tag: \"None\",\n _op: \"None\",\n valueOrUndefined: undefined,\n [Equal.symbol](that) {\n return isOption(that) && isNone(that);\n },\n [Hash.symbol]() {\n return NoneHash;\n },\n toString() {\n return `none()`;\n },\n toJSON() {\n return {\n _id: \"Option\",\n _tag: this._tag\n };\n }\n});\n/** @internal */\nexport const isOption = input => hasProperty(input, TypeId);\n/** @internal */\nexport const isNone = fa => fa._tag === \"None\";\n/** @internal */\nexport const isSome = fa => fa._tag === \"Some\";\n/** @internal */\nexport const none = /*#__PURE__*/Object.create(NoneProto);\n/** @internal */\nconst SomeImpl = function (value) {\n this.value = value;\n};\nSomeImpl.prototype = SomeProto;\n/** @internal */\nexport const some = value => new SomeImpl(value);\n//# sourceMappingURL=option.js.map","import * as Equal from \"../Equal.js\";\nimport { format } from \"../Formatter.js\";\nimport { dual } from \"../Function.js\";\nimport * as Hash from \"../Hash.js\";\nimport { toJson } from \"../Inspectable.js\";\nimport { hasProperty } from \"../Predicate.js\";\nimport { SingleShotGen } from \"../Utils.js\";\nimport { PipeInspectableProto } from \"./core.js\";\nimport * as option from \"./option.js\";\nconst TypeId = \"~effect/Result\";\nconst CommonProto = {\n [TypeId]: {\n /* v8 ignore next 2 */\n _A: _ => _,\n _E: _ => _\n },\n ...PipeInspectableProto,\n [Symbol.iterator]() {\n return new SingleShotGen(this);\n }\n};\nconst SuccessProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonProto), {\n _tag: \"Success\",\n _op: \"Success\",\n [Equal.symbol](that) {\n return isResult(that) && isSuccess(that) && Equal.equals(this.success, that.success);\n },\n [Hash.symbol]() {\n return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.success));\n },\n toString() {\n return `success(${format(this.success)})`;\n },\n toJSON() {\n return {\n _id: \"Result\",\n _tag: this._tag,\n value: toJson(this.success)\n };\n }\n});\nconst FailureProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonProto), {\n _tag: \"Failure\",\n _op: \"Failure\",\n [Equal.symbol](that) {\n return isResult(that) && isFailure(that) && Equal.equals(this.failure, that.failure);\n },\n [Hash.symbol]() {\n return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.failure));\n },\n toString() {\n return `failure(${format(this.failure)})`;\n },\n toJSON() {\n return {\n _id: \"Result\",\n _tag: this._tag,\n failure: toJson(this.failure)\n };\n }\n});\n/** @internal */\nexport const isResult = input => hasProperty(input, TypeId);\n/** @internal */\nexport const isFailure = result => result._tag === \"Failure\";\n/** @internal */\nexport const isSuccess = result => result._tag === \"Success\";\n/** @internal */\nconst FailureImpl = function (failure) {\n this.failure = failure;\n};\nFailureImpl.prototype = FailureProto;\n/** @internal */\nexport const fail = failure => new FailureImpl(failure);\n/** @internal */\nconst SuccessImpl = function (success) {\n this.success = success;\n};\nSuccessImpl.prototype = SuccessProto;\n/** @internal */\nexport const succeed = success => new SuccessImpl(success);\n/** @internal */\nexport const getFailure = self => isSuccess(self) ? option.none : option.some(self.failure);\n/** @internal */\nexport const getSuccess = self => isFailure(self) ? option.none : option.some(self.success);\n/** @internal */\nexport const fromOption = /*#__PURE__*/dual(2, (self, onNone) => option.isNone(self) ? fail(onNone()) : succeed(self.value));\n//# sourceMappingURL=result.js.map","/**\n * Defines comparison functions for ordered values.\n *\n * An `Order` compares two `A` values and returns whether the first is less\n * than, equal to, or greater than the second. Orders are used for sorting,\n * choosing minimum or maximum values, checking ranges, and building ordered data\n * structures. This module includes built-in orders, constructors for custom\n * orders, tools for reversing and combining comparisons, tuple and struct\n * helpers, comparison predicates, clamping, and reducer support.\n *\n * @since 2.0.0\n */\nimport { dual } from \"./Function.js\";\nimport * as Reducer from \"./Reducer.js\";\n/**\n * Creates a new `Order` instance from a comparison function.\n *\n * **When to use**\n *\n * Use when you need a sorting rule not covered by the built-in orders or input\n * mapping helpers, and you can provide a total comparison.\n *\n * **Details**\n *\n * Uses reference equality (`===`) as a shortcut: if `self === that`, it returns\n * `0` without calling the comparison function. The comparison function should\n * return `-1`, `0`, or `1`, and the returned order satisfies total ordering\n * laws when the comparison function does.\n *\n * **Example** (Creating an Order)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const byAge = Order.make<{ name: string; age: number }>((self, that) => {\n * if (self.age < that.age) return -1\n * if (self.age > that.age) return 1\n * return 0\n * })\n *\n * byAge({ name: \"Alice\", age: 30 }, { name: \"Bob\", age: 25 }) // => 1\n * byAge({ name: \"Alice\", age: 25 }, { name: \"Bob\", age: 30 }) // => -1\n * ```\n *\n * @see {@link mapInput} to transform an order by mapping the input type\n * @see {@link combine} to combine multiple orders\n * @category constructors\n * @since 2.0.0\n */\nexport function make(compare) {\n return (self, that) => self === that ? 0 : compare(self, that);\n}\n/**\n * Order instance for strings that compares them lexicographically using JavaScript's `<` operator.\n *\n * **When to use**\n *\n * Use when you need lexicographic string ordering.\n *\n * **Details**\n *\n * Uses lexicographic dictionary ordering. The empty string is less than any\n * non-empty string, and comparisons are case-sensitive.\n *\n * **Example** (Ordering strings)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * Order.String(\"apple\", \"banana\") // => -1\n * Order.String(\"banana\", \"apple\") // => 1\n * Order.String(\"apple\", \"apple\") // => 0\n * ```\n *\n * @see {@link mapInput} to compare objects by a string property\n * @see {@link Struct} to combine with other orders for struct comparison\n * @category instances\n * @since 4.0.0\n */\nexport const String = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);\n/**\n * Order instance for numbers that compares them numerically.\n *\n * **When to use**\n *\n * Use when you need numeric ordering for numbers.\n *\n * **Details**\n *\n * `0` is considered equal to `-0`. All `NaN` values are considered equal to\n * each other, and any `NaN` is considered less than any non-`NaN` number. All\n * other values use standard numeric comparison.\n *\n * **Example** (Ordering numbers)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * Order.Number(1, 1) // => 0\n * Order.Number(1, 2) // => -1\n * Order.Number(2, 1) // => 1\n *\n * Order.Number(0, -0) // => 0\n * Order.Number(NaN, 1) // => -1\n * ```\n *\n * @see {@link mapInput} to compare objects by a number property\n * @see {@link BigInt} for bigint comparisons\n * @category instances\n * @since 4.0.0\n */\nexport const Number = /*#__PURE__*/make((self, that) => {\n if (globalThis.Number.isNaN(self) && globalThis.Number.isNaN(that)) return 0;\n if (globalThis.Number.isNaN(self)) return -1; // NaN < any number\n if (globalThis.Number.isNaN(that)) return 1; // any number > NaN\n return self < that ? -1 : 1;\n});\n/**\n * Order instance for booleans where `false` is considered less than `true`.\n *\n * **When to use**\n *\n * Use when you need boolean ordering where `false` comes before `true`.\n *\n * **Details**\n *\n * `false` is less than `true`, and equal values return `0`.\n *\n * **Example** (Ordering booleans)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * Order.Boolean(false, true) // => -1\n * Order.Boolean(true, false) // => 1\n * Order.Boolean(true, true) // => 0\n * ```\n *\n * @see {@link mapInput} to compare objects by a boolean property\n * @category instances\n * @since 4.0.0\n */\nexport const Boolean = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);\n/**\n * Order instance for bigints that compares them numerically.\n *\n * **When to use**\n *\n * Use when you need numeric ordering for `bigint` values.\n *\n * **Details**\n *\n * Uses standard numeric comparison for bigint values and handles arbitrarily\n * large integers.\n *\n * **Example** (Ordering BigInts)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * Order.BigInt(1n, 2n) // => -1\n * Order.BigInt(2n, 1n) // => 1\n * Order.BigInt(1n, 1n) // => 0\n * ```\n *\n * @see {@link Number} for regular number comparisons\n * @see {@link mapInput} to compare objects by a bigint property\n * @category instances\n * @since 4.0.0\n */\nexport const BigInt = /*#__PURE__*/make((self, that) => self < that ? -1 : 1);\n/**\n * Creates a new `Order` that reverses the comparison order of the input `Order`.\n *\n * **When to use**\n *\n * Use when you need the reverse of an existing order.\n *\n * **Details**\n *\n * Returns a new order that swaps the arguments before comparison. If the\n * original order returns `-1`, the flipped order returns `1`, and vice versa.\n * Equal comparisons remain `0`.\n *\n * **Example** (Reversing an Order)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const flip = Order.flip(Order.Number)\n *\n * flip(1, 2) // => 1\n * flip(2, 1) // => -1\n * flip(1, 1) // => 0\n * ```\n *\n * @see {@link combine} to combine orders for multi-criteria comparison\n * @category combinators\n * @since 4.0.0\n */\nexport function flip(O) {\n return make((self, that) => O(that, self));\n}\n/**\n * Combines two `Order` instances to create a new `Order` that first compares using the first `Order`,\n * and if the values are equal, then compares using the second `Order`.\n *\n * **When to use**\n *\n * Use when you need tie-breaking with exactly two orders.\n *\n * **Details**\n *\n * First applies the first order. If the result is non-zero, that result is\n * returned; otherwise, the second order is applied. The result is the first\n * non-zero comparison result, or `0` if both orders return `0`.\n *\n * **Example** (Combining two Orders)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const byAge = Order.mapInput(\n * Order.Number,\n * (person: { name: string; age: number }) => person.age\n * )\n * const byName = Order.mapInput(\n * Order.String,\n * (person: { name: string; age: number }) => person.name\n * )\n * const byAgeAndName = Order.combine(byAge, byName)\n *\n * const person1 = { name: \"Alice\", age: 30 }\n * const person2 = { name: \"Bob\", age: 30 }\n * const person3 = { name: \"Charlie\", age: 25 }\n *\n * byAgeAndName(person1, person2) // => -1\n * byAgeAndName(person1, person3) // => 1\n * ```\n *\n * @see {@link combineAll} to combine multiple orders from a collection\n * @see {@link mapInput} to transform orders to work with different types\n * @category combining\n * @since 2.0.0\n */\nexport const combine = /*#__PURE__*/dual(2, (self, that) => make((a1, a2) => {\n const out = self(a1, a2);\n if (out !== 0) {\n return out;\n }\n return that(a1, a2);\n}));\n/**\n * Creates an `Order` that considers all values as equal.\n *\n * **When to use**\n *\n * Use when you need an order that treats all values as equal.\n *\n * **Details**\n *\n * Always returns `0` regardless of input values, making it useful as a neutral\n * element in order composition.\n *\n * **Example** (Ordering with an always-equal Order)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const alwaysEqualOrder = Order.alwaysEqual()\n *\n * alwaysEqualOrder(1, 2) // => 0\n * alwaysEqualOrder(2, 1) // => 0\n * alwaysEqualOrder(1, 1) // => 0\n * ```\n *\n * @see {@link combine} to combine with other orders\n * @category constructors\n * @since 4.0.0\n */\nexport function alwaysEqual() {\n return make(() => 0);\n}\n/**\n * Combines all `Order` instances in the provided collection into a single `Order`.\n * The resulting `Order` compares using each `Order` in sequence until a non-zero result is found.\n *\n * **When to use**\n *\n * Use when you need tie-breaking across a variable number of orders.\n *\n * **Details**\n *\n * Applies orders in iteration order and short-circuits on the first non-zero\n * result. It returns `0` only if all orders return `0`.\n * The collection is materialized when the order is created, so it must be finite.\n *\n * **Example** (Combining multiple Orders)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const byAge = Order.mapInput(\n * Order.Number,\n * (person: { name: string; age: number }) => person.age\n * )\n * const byName = Order.mapInput(\n * Order.String,\n * (person: { name: string; age: number }) => person.name\n * )\n *\n * const combinedOrder = Order.combineAll([byAge, byName])\n *\n * const person1 = { name: \"Alice\", age: 30 }\n * const person2 = { name: \"Bob\", age: 30 }\n *\n * combinedOrder(person1, person2) // => -1\n * ```\n *\n * @see {@link combine} to combine two orders\n * @see {@link makeReducer} to create a reducer for combining orders\n * @category combining\n * @since 2.0.0\n */\nexport function combineAll(collection) {\n const orders = Array.from(collection);\n return make((a1, a2) => {\n let out = 0;\n for (const O of orders) {\n out = O(a1, a2);\n if (out !== 0) {\n return out;\n }\n }\n return out;\n });\n}\n/**\n * Transforms an `Order` on type `A` into an `Order` on type `B` by providing a function that\n * maps values of type `B` to values of type `A`.\n *\n * **When to use**\n *\n * Use when you need to adapt an `Order` to compare a larger value by one\n * derived property.\n *\n * **Details**\n *\n * Applies the mapping function to both values before comparison. The mapping\n * function should be pure and not have side effects so the ordering properties\n * of the original order are preserved.\n *\n * **Example** (Mapping Input)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const byLength = Order.mapInput(Order.Number, (s: string) => s.length)\n *\n * byLength(\"a\", \"bb\") // => -1\n * byLength(\"bb\", \"a\") // => 1\n * byLength(\"aa\", \"bb\") // => 0\n * ```\n *\n * @see {@link combine} to combine mapped orders for multi-criteria comparison\n * @see {@link Struct} to create orders for structs with multiple fields\n * @category mapping\n * @since 2.0.0\n */\nexport const mapInput = /*#__PURE__*/dual(2, (self, f) => make((b1, b2) => self(f(b1), f(b2))));\n/**\n * Order instance for `Date` objects that compares them chronologically by their timestamp.\n *\n * **When to use**\n *\n * Use when you need chronological ordering for JavaScript date values.\n *\n * **Details**\n *\n * Compares dates by their underlying timestamp in milliseconds since the epoch.\n * Earlier dates are less than later dates. Invalid dates are compared through\n * their `getTime()` result.\n *\n * **Example** (Ordering Dates)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const date1 = new Date(\"2023-01-01\")\n * const date2 = new Date(\"2023-01-02\")\n *\n * Order.Date(date1, date2) // => -1\n * Order.Date(date2, date1) // => 1\n * Order.Date(date1, date1) // => 0\n * ```\n *\n * @see {@link mapInput} to compare objects by a date property\n * @category instances\n * @since 2.0.0\n */\nexport const Date = /*#__PURE__*/mapInput(Number, date => date.getTime());\n/**\n * Creates an `Order` for a tuple type based on orders for each element.\n *\n * **When to use**\n *\n * Use when you need fixed-length tuple ordering with per-position orders.\n *\n * **Details**\n *\n * Compares tuples element-by-element using the corresponding order and stops at\n * the first non-zero comparison result. Tuples must have the same length as the\n * order collection, and the result is `0` only if all elements are equal.\n *\n * **Example** (Ordering tuples)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const tupleOrder = Order.Tuple([Order.Number, Order.String])\n *\n * tupleOrder([1, \"a\"], [2, \"b\"]) // => -1\n * tupleOrder([1, \"b\"], [1, \"a\"]) // => 1\n * tupleOrder([1, \"a\"], [1, \"a\"]) // => 0\n * ```\n *\n * @see {@link Array} to compare arrays with length consideration\n * @category combinators\n * @since 4.0.0\n */\nexport function Tuple(elements) {\n return make((self, that) => {\n const len = elements.length;\n for (let i = 0; i < len; i++) {\n const o = elements[i](self[i], that[i]);\n if (o !== 0) {\n return o;\n }\n }\n return 0;\n });\n}\n/**\n * @since 4.0.0\n */\nfunction Array_(O) {\n return make((self, that) => {\n const aLen = self.length;\n const bLen = that.length;\n const len = Math.min(aLen, bLen);\n for (let i = 0; i < len; i++) {\n const o = O(self[i], that[i]);\n if (o !== 0) {\n return o;\n }\n }\n return Number(aLen, bLen);\n });\n}\nexport {\n/**\n * Creates an `Order` for arrays by applying the given `Order` to each element, then comparing by length if all elements are equal.\n *\n * **When to use**\n *\n * Use when you need lexicographic ordering for arrays of one element type.\n *\n * **Details**\n *\n * Compares arrays element-by-element using the provided order and stops at the\n * first non-zero comparison result. If all elements are equal, shorter arrays\n * are less than longer arrays. The result is `0` only if arrays have the same\n * length and all elements are equal.\n *\n * **Example** (Ordering array elements)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const arrayOrder = Order.Array(Order.Number)\n *\n * arrayOrder([1, 2], [1, 3]) // => -1\n * arrayOrder([1, 2], [1, 2, 3]) // => -1\n * arrayOrder([1, 2, 3], [1, 2]) // => 1\n * arrayOrder([1, 2], [1, 2]) // => 0\n * ```\n *\n * @see {@link Tuple} for type-safe tuple ordering\n * @category combinators\n * @since 4.0.0\n */\nArray_ as Array };\n/**\n * Creates an `Order` for structs by applying the given `Order`s to each property in sequence.\n *\n * **When to use**\n *\n * Use when you need multi-field ordering for objects with known properties.\n *\n * **Details**\n *\n * Compares structs field-by-field in the key order of the fields object and\n * stops at the first non-zero comparison result. Field order matters: earlier\n * fields take precedence. The result is `0` only if all fields are equal.\n *\n * **Example** (Ordering structs)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const personOrder = Order.Struct({\n * name: Order.String,\n * age: Order.Number\n * })\n *\n * const person1 = { name: \"Alice\", age: 30 }\n * const person2 = { name: \"Bob\", age: 25 }\n * const person3 = { name: \"Alice\", age: 25 }\n *\n * personOrder(person1, person2) // => -1\n * personOrder(person1, person3) // => 1\n * personOrder(person1, person1) // => 0\n * ```\n *\n * @see {@link combine} to combine orders manually\n * @see {@link mapInput} to extract and compare by a single property\n * @category combinators\n * @since 4.0.0\n */\nexport function Struct(fields) {\n const keys = Object.keys(fields);\n return make((self, that) => {\n for (const key of keys) {\n const o = fields[key](self[key], that[key]);\n if (o !== 0) {\n return o;\n }\n }\n return 0;\n });\n}\n/**\n * Checks whether one value is strictly less than another according to the given order.\n *\n * **When to use**\n *\n * Use when you need a boolean less-than predicate using an `Order`.\n *\n * **Details**\n *\n * Returns `true` if the order returns `-1`, meaning the first value is less\n * than the second. Equal or greater values return `false`.\n *\n * **Example** (Checking less-than comparisons)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const isLessThanNumber = Order.isLessThan(Order.Number)\n *\n * isLessThanNumber(1, 2) // => true\n * isLessThanNumber(2, 1) // => false\n * isLessThanNumber(1, 1) // => false\n * ```\n *\n * @see {@link isLessThanOrEqualTo} for non-strict less than or equal\n * @see {@link isGreaterThan} for strict greater than\n * @category predicates\n * @since 4.0.0\n */\nexport const isLessThan = O => dual(2, (self, that) => O(self, that) === -1);\n/**\n * Checks whether one value is strictly greater than another according to the given order.\n *\n * **When to use**\n *\n * Use when you need a boolean greater-than predicate using an `Order`.\n *\n * **Details**\n *\n * Returns `true` if the order returns `1`, meaning the first value is greater\n * than the second. Equal or lesser values return `false`.\n *\n * **Example** (Checking greater-than comparisons)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const isGreaterThanNumber = Order.isGreaterThan(Order.Number)\n *\n * isGreaterThanNumber(2, 1) // => true\n * isGreaterThanNumber(1, 2) // => false\n * isGreaterThanNumber(1, 1) // => false\n * ```\n *\n * @see {@link isGreaterThanOrEqualTo} for non-strict greater than or equal\n * @see {@link isLessThan} for strict less than\n * @category predicates\n * @since 4.0.0\n */\nexport const isGreaterThan = O => dual(2, (self, that) => O(self, that) === 1);\n/**\n * Checks whether one value is less than or equal to another according to the given order.\n *\n * **When to use**\n *\n * Use when you need a boolean less-than-or-equal predicate using an `Order`.\n *\n * **Details**\n *\n * Returns `true` if the order returns `-1` or `0`, and returns `false` only if\n * the order returns `1`.\n *\n * **Example** (Checking less-than-or-equal comparisons)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const isLessThanOrEqualToNumber = Order.isLessThanOrEqualTo(Order.Number)\n *\n * isLessThanOrEqualToNumber(1, 2) // => true\n * isLessThanOrEqualToNumber(1, 1) // => true\n * isLessThanOrEqualToNumber(2, 1) // => false\n * ```\n *\n * @see {@link isLessThan} for strict less than\n * @see {@link isGreaterThan} for strict greater than\n * @category predicates\n * @since 4.0.0\n */\nexport const isLessThanOrEqualTo = O => dual(2, (self, that) => O(self, that) !== 1);\n/**\n * Checks whether one value is greater than or equal to another according to the given order.\n *\n * **When to use**\n *\n * Use when you need a boolean greater-than-or-equal predicate using an\n * `Order`.\n *\n * **Details**\n *\n * Returns `true` if the order returns `1` or `0`, and returns `false` only if\n * the order returns `-1`.\n *\n * **Example** (Checking greater-than-or-equal comparisons)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const isGreaterThanOrEqualToNumber = Order.isGreaterThanOrEqualTo(Order.Number)\n *\n * isGreaterThanOrEqualToNumber(2, 1) // => true\n * isGreaterThanOrEqualToNumber(1, 1) // => true\n * isGreaterThanOrEqualToNumber(1, 2) // => false\n * ```\n *\n * @see {@link isGreaterThan} for strict greater than\n * @see {@link isLessThanOrEqualTo} for less than or equal\n * @category predicates\n * @since 4.0.0\n */\nexport const isGreaterThanOrEqualTo = O => dual(2, (self, that) => O(self, that) !== -1);\n/**\n * Returns the minimum of two values according to the given order. If they are equal, returns the first argument.\n *\n * **When to use**\n *\n * Use when you need to select the smaller of two values according to an\n * `Order`.\n *\n * **Details**\n *\n * Returns the value that compares as less than or equal to the other value. If\n * values are equal, the first argument is returned.\n *\n * **Example** (Selecting the minimum value)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const minNumber = Order.min(Order.Number)\n *\n * minNumber(1, 2) // => 1\n * minNumber(2, 1) // => 1\n * minNumber(1, 1) // => 1\n * ```\n *\n * @see {@link max} for the maximum of two values\n * @see {@link clamp} to clamp a value between min and max\n * @category comparisons\n * @since 2.0.0\n */\nexport const min = O => dual(2, (self, that) => self === that || O(self, that) < 1 ? self : that);\n/**\n * Returns the maximum of two values according to the given order. If they are equal, returns the first argument.\n *\n * **When to use**\n *\n * Use when you need to select the larger of two values according to an\n * `Order`.\n *\n * **Details**\n *\n * Returns the value that compares as greater than or equal to the other value.\n * If values are equal, the first argument is returned.\n *\n * **Example** (Selecting the maximum value)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const maxNumber = Order.max(Order.Number)\n *\n * maxNumber(1, 2) // => 2\n * maxNumber(2, 1) // => 2\n * maxNumber(1, 1) // => 1\n * ```\n *\n * @see {@link min} for the minimum of two values\n * @see {@link clamp} to clamp a value between min and max\n * @category comparisons\n * @since 2.0.0\n */\nexport const max = O => dual(2, (self, that) => self === that || O(self, that) > -1 ? self : that);\n/**\n * Restricts a value between a minimum and a maximum according to the given order.\n *\n * **When to use**\n *\n * Use when you need to clamp a value to an inclusive range according to an\n * `Order`.\n *\n * **Details**\n *\n * Returns the value itself when it is between minimum and maximum, inclusive.\n * Values below the range return minimum, and values above the range return\n * maximum. The minimum must be less than or equal to the maximum according to\n * the order.\n *\n * **Example** (Clamping values)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const clamp = Order.clamp(Order.Number)({ minimum: 1, maximum: 5 })\n *\n * clamp(3) // => 3\n * clamp(0) // => 1\n * clamp(6) // => 5\n * ```\n *\n * @see {@link min} for the minimum of two values\n * @see {@link max} for the maximum of two values\n * @see {@link isBetween} to check if a value is within a range\n * @category comparisons\n * @since 2.0.0\n */\nexport const clamp = O => dual(2, (self, options) => min(O)(options.maximum, max(O)(options.minimum, self)));\n/**\n * Checks whether a value is between a minimum and a maximum (inclusive) according to the given order.\n *\n * **When to use**\n *\n * Use when you need range checks that respect domain-specific ordering, such as\n * dates, versions, or custom priorities, instead of JavaScript numeric\n * comparison.\n *\n * **Details**\n *\n * Returns `true` when the value is greater than or equal to minimum and less\n * than or equal to maximum. Values outside the range return `false`. Both\n * bounds are inclusive.\n *\n * **Example** (Checking ranges)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const betweenNumber = Order.isBetween(Order.Number)\n *\n * betweenNumber(5, { minimum: 1, maximum: 10 }) // => true\n * betweenNumber(1, { minimum: 1, maximum: 10 }) // => true\n * betweenNumber(10, { minimum: 1, maximum: 10 }) // => true\n * betweenNumber(0, { minimum: 1, maximum: 10 }) // => false\n * betweenNumber(11, { minimum: 1, maximum: 10 }) // => false\n * ```\n *\n * @see {@link clamp} to clamp a value to a range\n * @see {@link isLessThanOrEqualTo} for less than or equal check\n * @see {@link isGreaterThanOrEqualTo} for greater than or equal check\n * @category predicates\n * @since 4.0.0\n */\nexport const isBetween = O => dual(2, (self, options) => !isLessThan(O)(self, options.minimum) && !isGreaterThan(O)(self, options.maximum));\n/**\n * Creates a `Reducer` for combining `Order` instances, useful for aggregating orders in collections.\n *\n * **When to use**\n *\n * Use when you need a reducer that combines orders.\n *\n * **Details**\n *\n * Returns a reducer that combines orders using `combine`, uses `alwaysEqual` as\n * the identity element for empty collections, and uses `combineAll` for\n * combining collections of orders. The reducer can be used with fold operations\n * on collections.\n *\n * **Example** (Creating a Reducer)\n *\n * ```ts import.meta.vitest\n * import { Order } from \"effect\"\n *\n * const reducer = Order.makeReducer()\n * const orders = [Order.Number, Order.flip(Order.Number)]\n *\n * const combined = reducer.combineAll(orders)\n * combined(1, 2) // => -1\n * ```\n *\n * @see {@link combine} to combine two orders\n * @see {@link combineAll} to combine multiple orders\n * @see {@link Reducer} for reducing orders as a collection operation\n * @category constructors\n * @since 4.0.0\n */\nexport function makeReducer() {\n return Reducer.make(combine, () => 0, combineAll);\n}\n//# sourceMappingURL=Order.js.map","/**\n * Models a value that may be present or absent.\n *\n * An `Option` is `Some` when a value is available and `None` when it is\n * not. This lets code handle missing values explicitly instead of relying on\n * `null` or `undefined`. The module includes helpers for creating, checking,\n * transforming, combining, and extracting optional values, plus conversions to\n * and from common nullable or result-like shapes. It also includes `Option.gen`\n * for writing small generator-based computations that stop at the first `None`.\n *\n * @since 2.0.0\n */\nimport * as Combiner from \"./Combiner.js\";\nimport * as Equal from \"./Equal.js\";\nimport * as Equivalence from \"./Equivalence.js\";\nimport { constNull, constUndefined, dual, identity } from \"./Function.js\";\nimport * as doNotation from \"./internal/doNotation.js\";\nimport * as option from \"./internal/option.js\";\nimport * as InternalRecord from \"./internal/record.js\";\nimport * as result from \"./internal/result.js\";\nimport * as order from \"./Order.js\";\nimport { isFunction } from \"./Predicate.js\";\nimport * as Reducer from \"./Reducer.js\";\nconst TypeId = \"~effect/Option\";\n/**\n * Creates an `Option` representing the absence of a value.\n *\n * **When to use**\n *\n * Use to represent a missing or uninitialized value, such as returning \"no\n * result\" from a function.\n *\n * **Details**\n *\n * - Returns `Option`, which is a subtype of `Option` for any `A`\n * - Always returns the same singleton instance\n *\n * **Example** (Creating an empty Option)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * // ┌─── Option\n * // ▼\n * const noValue = Option.none() // => Option.none()\n * ```\n *\n * @see {@link some} for the opposite operation.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const none = () => option.none;\n/**\n * Wraps the given value into an `Option` to represent its presence.\n *\n * **When to use**\n *\n * Use to wrap a known present value as `Option`\n * - Returning a successful result from a partial function\n *\n * **Details**\n *\n * - Always returns `Some`\n * - Does not filter `null` or `undefined`; use {@link fromNullishOr} for that\n *\n * **Example** (Wrapping a value)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * // ┌─── Option\n * // ▼\n * const value = Option.some(1) // => Option.some(1)\n * ```\n *\n * @see {@link none} for the opposite operation.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const some = option.some;\n/**\n * Determines whether the given value is an `Option`.\n *\n * **When to use**\n *\n * Use to validate unknown values at runtime boundaries, such as type-narrowing\n * in union types.\n *\n * **Details**\n *\n * - Returns `true` for both `Some` and `None` instances\n * - Acts as a type guard, narrowing the input to `Option`\n *\n * **Example** (Checking if a value is an Option)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.isOption(Option.some(1)) // => true\n * Option.isOption(Option.none()) // => true\n * Option.isOption({}) // => false\n * ```\n *\n * @see {@link isNone} to check for `None` specifically\n * @see {@link isSome} to check for `Some` specifically\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isOption = option.isOption;\n/**\n * Checks whether an `Option` is `None` (absent).\n *\n * **When to use**\n *\n * Use when you need to branch on an absent `Option` before accessing `.value`.\n *\n * **Details**\n *\n * - Acts as a type guard, narrowing to `None`\n *\n * **Example** (Checking for None)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.isNone(Option.some(1)) // => false\n * Option.isNone(Option.none()) // => true\n * ```\n *\n * @see {@link isSome} for the opposite check.\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isNone = option.isNone;\n/**\n * Checks whether an `Option` contains a value (`Some`).\n *\n * **When to use**\n *\n * Use when you need to branch on a present `Option` before accessing `.value`.\n *\n * **Details**\n *\n * - Acts as a type guard, narrowing to `Some`\n *\n * **Example** (Checking for Some)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.isSome(Option.some(1)) // => true\n * Option.isSome(Option.none()) // => false\n * ```\n *\n * @see {@link isNone} for the opposite check.\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isSome = option.isSome;\n/**\n * Pattern-matches on an `Option`, handling both `None` and `Some` cases.\n *\n * **When to use**\n *\n * Use when you need to handle both `Some` and `None` in one expression and\n * transform an `Option` into a plain value.\n *\n * **Details**\n *\n * - If `None`, calls `onNone` and returns its result\n * - If `Some`, calls `onSome` with the value and returns its result\n * - Supports the `dual` API (data-last and data-first)\n *\n * **Example** (Matching on an Option)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.match(Option.some(1), {\n * onNone: () => \"Option is empty\",\n * onSome: (value) => `Option has a value: ${value}`\n * }) // => \"Option has a value: 1\"\n * ```\n *\n * @see {@link getOrElse} for unwrapping with a default\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport const match = /*#__PURE__*/dual(2, (self, {\n onNone,\n onSome\n}) => isNone(self) ? onNone() : onSome(self.value));\n/**\n * Converts an `Option`-returning function into a type guard (refinement).\n *\n * **When to use**\n *\n * Use when you need to turn an `Option`-returning parser into a type-narrowing\n * predicate, such as for `Array.prototype.filter`.\n *\n * **Details**\n *\n * - Returns `true` when the original function returns `Some`\n * - Returns `false` when the original function returns `None`\n * - Narrows the input type to `B` on success\n *\n * **Example** (Converting a parser to a type guard)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * type MyData = string | number\n *\n * const parseString = (data: MyData): Option.Option =>\n * typeof data === \"string\" ? Option.some(data) : Option.none()\n *\n * // ┌─── (a: MyData) => a is string\n * // ▼\n * const isString = Option.toRefinement(parseString)\n *\n * isString(\"a\") // => true\n * isString(1) // => false\n * ```\n *\n * @see {@link liftPredicate} for the reverse direction\n *\n * @category converting\n * @since 2.0.0\n */\nexport const toRefinement = f => a => isSome(f(a));\n/**\n * Wraps the first element of an `Iterable` in a `Some`, or returns `None` if\n * the iterable is empty.\n *\n * **When to use**\n *\n * Use when you need to safely extract the head of a collection, including\n * generators or lazy iterables.\n *\n * **Details**\n *\n * - Only consumes the first element; does not iterate the rest\n * - Returns `None` for empty iterables\n *\n * **Example** (Getting the first element)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.fromIterable([1, 2, 3]) // => Option.some(1)\n * Option.fromIterable([]) // => Option.none()\n * ```\n *\n * @see {@link toArray} for the inverse direction\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromIterable = collection => {\n for (const a of collection) {\n return some(a);\n }\n return none();\n};\n/**\n * Converts a `Result` into an `Option`, keeping only the success value.\n *\n * **When to use**\n *\n * Use when you need to discard a `Result` failure and keep only the success\n * value as an `Option`.\n *\n * **Details**\n *\n * - `Success` becomes `Some` with the success value\n * - `Failure` becomes `None` and the failure value is discarded\n *\n * **Example** (Extracting the success side)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Option.getSuccess(Result.succeed(\"ok\")) // => Option.some(\"ok\")\n * Option.getSuccess(Result.fail(\"err\")) // => Option.none()\n * ```\n *\n * @see {@link getFailure} for the opposite operation.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const getSuccess = result.getSuccess;\n/**\n * Converts a `Result` into an `Option`, keeping only the failure value.\n *\n * **When to use**\n *\n * Use when you need to discard a `Result` success and keep only the failure\n * value as an `Option`.\n *\n * **Details**\n *\n * - `Failure` becomes `Some` with the failure value\n * - `Success` becomes `None` and the success value is discarded\n *\n * **Example** (Extracting the failure side)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Option.getFailure(Result.succeed(\"ok\")) // => Option.none()\n * Option.getFailure(Result.fail(\"err\")) // => Option.some(\"err\")\n * ```\n *\n * @see {@link getSuccess} for the opposite operation.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const getFailure = result.getFailure;\n/**\n * Extracts the value from a `Some`, or evaluates a fallback thunk on `None`.\n *\n * **When to use**\n *\n * Use when providing a default value for an absent `Option`\n * - Unwrapping with lazy evaluation of the fallback\n *\n * **Details**\n *\n * - `Some` → returns the inner value\n * - `None` → calls `onNone()` and returns its result\n * - `onNone` is only called when needed (lazy)\n *\n * **Example** (Unwrapping with a fallback)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.some(1).pipe(Option.getOrElse(() => 0)) // => 1\n * Option.none().pipe(Option.getOrElse(() => 0)) // => 0\n * ```\n *\n * @see {@link getOrNull} to fall back to `null`\n * @see {@link getOrUndefined} to fall back to `undefined`\n * @see {@link getOrThrow} to throw on `None`\n *\n * @category getters\n * @since 2.0.0\n */\nexport const getOrElse = /*#__PURE__*/dual(2, (self, onNone) => isNone(self) ? onNone() : self.value);\n/**\n * Returns the fallback `Option` if `self` is `None`; otherwise returns `self`.\n *\n * **When to use**\n *\n * Use when you need a lazy fallback `Option`, such as when building priority\n * chains of optional values.\n *\n * **Details**\n *\n * - `Some` → returns `self` unchanged\n * - `None` → evaluates and returns `that()`\n * - `that` is lazily evaluated\n *\n * **Example** (Providing a fallback Option)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.none().pipe(Option.orElse(() => Option.some(\"b\"))) // => Option.some(\"b\")\n * Option.some(\"a\").pipe(Option.orElse(() => Option.some(\"b\"))) // => Option.some(\"a\")\n * ```\n *\n * @see {@link orElseSome} to wrap the fallback value in `Some` automatically\n * @see {@link firstSomeOf} to pick the first `Some` from a collection\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const orElse = /*#__PURE__*/dual(2, (self, that) => isNone(self) ? that() : self);\n/**\n * Returns `Some` of the fallback value if `self` is `None`; otherwise returns\n * `self`.\n *\n * **When to use**\n *\n * Use when providing a default plain value (not an `Option`) as fallback\n *\n * **Details**\n *\n * - `Some` → returns `self` unchanged\n * - `None` → calls `onNone()`, wraps result in `Some`, and returns it\n *\n * **Example** (Providing a fallback value)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.none().pipe(Option.orElseSome(() => \"b\")) // => Option.some(\"b\")\n * Option.some(\"a\").pipe(Option.orElseSome(() => \"b\")) // => Option.some(\"a\")\n * ```\n *\n * @see {@link orElse} when the fallback is itself an `Option`\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const orElseSome = /*#__PURE__*/dual(2, (self, onNone) => isNone(self) ? some(onNone()) : self);\n/**\n * Returns the first available value and marks whether it came from the fallback.\n *\n * **When to use**\n *\n * Use when you need to know whether a present value came from the primary or\n * fallback `Option`.\n *\n * **Details**\n *\n * - `self` is `Some` → `Some(Result.fail(value))` (value from primary)\n * - `self` is `None`, `that()` is `Some` → `Some(Result.succeed(value))` (value from fallback)\n * - Both `None` → `None`\n *\n * **Example** (Tracking value source)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * const fallback = () => Option.some(\"fallback\")\n *\n * Option.orElseResult(Option.some(\"primary\"), fallback) // => Option.some(Result.fail(\"primary\"))\n * Option.orElseResult(Option.none(), fallback) // => Option.some(Result.succeed(\"fallback\"))\n * ```\n *\n * @see {@link orElse} for the simpler variant without source tracking\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const orElseResult = /*#__PURE__*/dual(2, (self, that) => isNone(self) ? map(that(), result.succeed) : map(self, result.fail));\n/**\n * Returns the first `Some` found in an iterable of `Option`s, or `None` if\n * all are `None`.\n *\n * **When to use**\n *\n * Use when you need the first available `Some` value from a priority list.\n *\n * **Details**\n *\n * - Short-circuits on the first `Some`\n * - Returns `None` only when every element is `None`\n *\n * **Example** (Finding the first Some)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.firstSomeOf([\n * Option.none(),\n * Option.some(1),\n * Option.some(2)\n * ]) // => Option.some(1)\n * ```\n *\n * @see {@link orElse} for a two-option fallback\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const firstSomeOf = collection => {\n let out = none();\n for (out of collection) {\n if (isSome(out)) {\n return out;\n }\n }\n return out;\n};\n/**\n * Converts a nullable value (`null` or `undefined`) into an `Option`.\n *\n * **When to use**\n *\n * Use when you need JavaScript nullish values to become absence at an API\n * boundary while all other values, including falsy ones, remain present.\n *\n * **Details**\n *\n * - `null` or `undefined` → `None`\n * - Any other value → `Some` (typed as `NonNullable`)\n *\n * **Example** (Converting nullable values to an Option)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.fromNullishOr(undefined) // => Option.none()\n * Option.fromNullishOr(null) // => Option.none()\n * Option.fromNullishOr(1) // => Option.some(1)\n * ```\n *\n * @see {@link fromNullOr} to only treat `null` as absent\n * @see {@link fromUndefinedOr} to only treat `undefined` as absent\n * @see {@link liftNullishOr} to lift a nullable-returning function\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromNullishOr = a => a == null ? none() : some(a);\n/**\n * Converts a possibly `undefined` value into an `Option`, leaving `null`\n * as a valid `Some`.\n *\n * **When to use**\n *\n * Use when you want to treat only `undefined` as absent while preserving `null`\n * as a meaningful value.\n *\n * **Details**\n *\n * - `undefined` → `None`\n * - Any other value (including `null`) → `Some`\n *\n * **Example** (Converting possibly undefined values to an Option)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.fromUndefinedOr(undefined) // => Option.none()\n * Option.fromUndefinedOr(null) // => Option.some(null)\n * Option.fromUndefinedOr(42) // => Option.some(42)\n * ```\n *\n * @see {@link fromNullishOr} to treat both `null` and `undefined` as absent\n * @see {@link fromNullOr} to only treat `null` as absent\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromUndefinedOr = a => a === undefined ? none() : some(a);\n/**\n * Converts a possibly `null` value into an `Option`, leaving `undefined`\n * as a valid `Some`.\n *\n * **When to use**\n *\n * Use when you want to treat only `null` as absent while preserving\n * `undefined` as a meaningful value.\n *\n * **Details**\n *\n * - `null` → `None`\n * - Any other value (including `undefined`) → `Some`\n *\n * **Example** (Converting possibly null values to an Option)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.fromNullOr(null) // => Option.none()\n * Option.fromNullOr(undefined) // => Option.some(undefined)\n * Option.fromNullOr(42) // => Option.some(42)\n * ```\n *\n * @see {@link fromNullishOr} to treat both `null` and `undefined` as absent\n * @see {@link fromUndefinedOr} to only treat `undefined` as absent\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromNullOr = a => a === null ? none() : some(a);\n/**\n * Lifts a function that may return `null` or `undefined` into one that returns\n * an `Option`.\n *\n * **When to use**\n *\n * Use to wrap existing nullable-returning functions for use in `Option` pipelines\n *\n * **Details**\n *\n * - Calls the original function with the given arguments\n * - Wraps the result via {@link fromNullishOr}\n *\n * **Example** (Lifting a parser)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const parse = (s: string): number | undefined => {\n * const n = parseFloat(s)\n * return isNaN(n) ? undefined : n\n * }\n *\n * const parseOption = Option.liftNullishOr(parse)\n *\n * parseOption(\"1\") // => Option.some(1)\n * parseOption(\"not a number\") // => Option.none()\n * ```\n *\n * @see {@link fromNullishOr} for converting a single value\n * @see {@link liftThrowable} for functions that throw instead\n *\n * @category converting\n * @since 4.0.0\n */\nexport const liftNullishOr = f => (...a) => fromNullishOr(f(...a));\n/**\n * Extracts the value from a `Some`, or returns `null` for `None`.\n *\n * **When to use**\n *\n * Use when you need to pass absent `Option` values to APIs that expect `null`.\n *\n * **Details**\n *\n * - `Some` → the inner value\n * - `None` → `null`\n *\n * **Example** (Unwrapping to null)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.getOrNull(Option.some(1)) // => 1\n * Option.getOrNull(Option.none()) // => null\n * ```\n *\n * @see {@link getOrUndefined} to return `undefined` instead\n * @see {@link getOrElse} for a custom fallback\n *\n * @category getters\n * @since 2.0.0\n */\nexport const getOrNull = /*#__PURE__*/getOrElse(constNull);\n/**\n * Extracts the value from a `Some`, or returns `undefined` for `None`.\n *\n * **When to use**\n *\n * Use when you need to pass absent `Option` values to APIs that expect\n * `undefined`.\n *\n * **Details**\n *\n * - `Some` → the inner value\n * - `None` → `undefined`\n *\n * **Example** (Unwrapping to undefined)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.getOrUndefined(Option.some(1)) // => 1\n * Option.getOrUndefined(Option.none()) // => undefined\n * ```\n *\n * @see {@link getOrNull} to return `null` instead\n * @see {@link getOrElse} for a custom fallback\n *\n * @category getters\n * @since 2.0.0\n */\nexport const getOrUndefined = /*#__PURE__*/getOrElse(constUndefined);\n/**\n * Lifts a function that may throw into one that returns an `Option`.\n *\n * **When to use**\n *\n * Use to wrap exception-throwing APIs (e.g. `JSON.parse`) for safe usage\n *\n * **Details**\n *\n * - If the function returns normally → `Some` with the result\n * - If the function throws → `None` (exception is swallowed)\n *\n * **Example** (Lifting JSON.parse)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const parse = Option.liftThrowable(JSON.parse)\n *\n * parse(\"1\") // => Option.some(1)\n * parse(\"\") // => Option.none()\n * ```\n *\n * @see {@link liftNullishOr} for nullable-returning functions\n *\n * @category converting\n * @since 2.0.0\n */\nexport const liftThrowable = f => (...a) => {\n try {\n return some(f(...a));\n } catch {\n return none();\n }\n};\n/**\n * Extracts the value from a `Some`, or throws a custom error for `None`.\n *\n * **When to use**\n *\n * Use when you need fail-fast unwrapping of an `Option` for unexpected absence\n * and want to provide a descriptive debugging error.\n *\n * **Details**\n *\n * - `Some` → returns the inner value\n * - `None` → throws the value returned by `onNone()`\n *\n * **Example** (Throwing a custom error)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Option.getOrThrowWith(Option.some(1), () => new Error(\"missing\")) // => 1\n *\n * const failure = Result.try({\n * try: () => Option.getOrThrowWith(Option.none(), () => new Error(\"missing\")),\n * catch: (error) => (error as Error).message\n * })\n * Result.getFailure(failure).pipe(Option.getOrElse(() => \"no error\")) // => \"missing\"\n * ```\n *\n * @see {@link getOrThrow} for a version with a default error\n * @see {@link getOrElse} for a non-throwing alternative\n *\n * @category converting\n * @since 2.0.0\n */\nexport const getOrThrowWith = /*#__PURE__*/dual(2, (self, onNone) => {\n if (isSome(self)) {\n return self.value;\n }\n throw onNone();\n});\n/**\n * Extracts the value from a `Some`, or throws a default `Error` for `None`.\n *\n * **When to use**\n *\n * Use when you need quick fail-fast unwrapping of an `Option` and a generic\n * error is acceptable.\n *\n * **Details**\n *\n * - `Some` → returns the inner value\n * - `None` → throws `new Error(\"getOrThrow called on a None\")`\n *\n * **Example** (Throwing a default error)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Option.getOrThrow(Option.some(1)) // => 1\n *\n * const failure = Result.try({\n * try: () => Option.getOrThrow(Option.none()),\n * catch: (error) => (error as Error).message\n * })\n * Result.getFailure(failure).pipe(Option.getOrElse(() => \"no error\")) // => \"getOrThrow called on a None\"\n * ```\n *\n * @see {@link getOrThrowWith} for a custom error\n * @see {@link getOrElse} for a non-throwing alternative\n *\n * @category converting\n * @since 2.0.0\n */\nexport const getOrThrow = /*#__PURE__*/getOrThrowWith(() => new Error(\"getOrThrow called on a None\"));\n/**\n * Transforms the value inside a `Some` using the provided function, leaving\n * `None` unchanged.\n *\n * **When to use**\n *\n * Use to apply a pure transformation to an `Option`'s present value, especially\n * when chaining transformations in a pipeline.\n *\n * **Details**\n *\n * - `Some` → applies `f` and wraps the result in a new `Some`\n * - `None` → returns `None` unchanged\n *\n * **Example** (Mapping over an Option)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.map(Option.some(2), (n) => n * 2) // => Option.some(4)\n * Option.map(Option.none(), (n: number) => n * 2) // => Option.none()\n * ```\n *\n * @see {@link flatMap} when `f` returns an `Option`\n * @see {@link as} to replace the value with a constant\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : some(f(self.value)));\n/**\n * Replaces the value inside a `Some` with a constant, leaving `None` unchanged.\n *\n * **When to use**\n *\n * Use when you need to replace a present `Option` value while preserving\n * whether it was `Some` or `None`.\n *\n * **Example** (Replacing a value)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.as(Option.some(42), \"new value\") // => Option.some(\"new value\")\n * Option.as(Option.none(), \"new value\") // => Option.none()\n * ```\n *\n * @see {@link asVoid} to replace with `undefined`\n * @see {@link map} for a general transformation\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const as = /*#__PURE__*/dual(2, (self, b) => map(self, () => b));\n/**\n * Replaces the value inside a `Some` with `void` (`undefined`), leaving `None`\n * unchanged.\n *\n * **When to use**\n *\n * Use when you need to discard a present `Option` value while preserving\n * whether it was `Some` or `None`.\n *\n * **Example** (Voiding the value)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.asVoid(Option.some(42)) // => Option.some(undefined)\n * Option.asVoid(Option.none()) // => Option.none()\n * ```\n *\n * @see {@link as} to replace with a specific constant\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const asVoid = /*#__PURE__*/as(undefined);\nconst void_ = /*#__PURE__*/some(undefined);\nexport {\n/**\n * Provides a pre-built `Some(undefined)` constant.\n *\n * **When to use**\n *\n * Use to return a \"success with no meaningful value\" from an `Option`-returning function\n *\n * **Example** (Referencing Option.void)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.void // => Option.some(undefined)\n * ```\n *\n * @see {@link asVoid} to convert an existing `Option` to `Option`\n *\n * @category constructors\n * @since 2.0.0\n */\nvoid_ as void };\n/**\n * Applies a function that returns an `Option` to the value of a `Some`,\n * flattening the result. Returns `None` if the input is `None`.\n *\n * **When to use**\n *\n * Use when you need to chain dependent `Option` computations where each step\n * may return `None`.\n *\n * **Details**\n *\n * - `Some` → applies `f` to the value and returns its `Option` result\n * - `None` → returns `None` without calling `f`\n * - Equivalent to `map` followed by {@link flatten}\n *\n * **Example** (Chaining optional lookups)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * interface User {\n * readonly name: string\n * readonly address: Option.Option<{ readonly street: Option.Option }>\n * }\n *\n * const user: User = {\n * name: \"John\",\n * address: Option.some({ street: Option.some(\"123 Main St\") })\n * }\n *\n * user.address.pipe(\n * Option.flatMap((addr) => addr.street)\n * ) // => Option.some(\"123 Main St\")\n * ```\n *\n * @see {@link map} when `f` returns a plain value\n * @see {@link andThen} for a more flexible variant\n * @see {@link flatten} to unwrap a nested `Option>`\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const flatMap = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : f(self.value));\n/**\n * Chains a second computation onto an `Option`. The second value can be a\n * plain value, an `Option`, or a function returning either.\n *\n * **When to use**\n *\n * Use when you need to chain an `Option` with a next step that may be another\n * `Option`, a plain value, or a function.\n *\n * **Details**\n *\n * - If `self` is `None`, returns `None` immediately\n * - If `f` is a function, calls it with the `Some` value\n * - If `f` returns an `Option`, returns it as-is; if a plain value, wraps in `Some`\n * - If `f` is not a function, uses it directly (same wrapping rules)\n *\n * **Example** (Chaining with andThen)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * // Chain with a function returning Option\n * Option.andThen(Option.some(5), (x) => Option.some(x * 2)) // => Option.some(10)\n *\n * // Chain with a static value\n * Option.andThen(Option.some(5), \"hello\") // => Option.some(\"hello\")\n *\n * // Chain with None - skips\n * Option.andThen(Option.none(), (x) => Option.some(x * 2)) // => Option.none()\n * ```\n *\n * @see {@link flatMap} for the standard monadic bind\n * @see {@link map} when you always return a plain value\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const andThen = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => {\n const b = isFunction(f) ? f(a) : f;\n return isOption(b) ? b : some(b);\n}));\n/**\n * Combines {@link flatMap} with {@link fromNullishOr}: applies a function that\n * may return `null`/`undefined` to the value of a `Some`.\n *\n * **When to use**\n *\n * Use when you need to chain optional computations that use `null` or\n * `undefined` instead of `Option`, such as nested property access.\n *\n * **Details**\n *\n * - `None` → `None`\n * - `Some` → applies `f`, then wraps via {@link fromNullishOr}\n *\n * **Example** (Navigating optional properties)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * interface Employee {\n * company?: { address?: { street?: { name?: string } } }\n * }\n *\n * const emp: Employee = {\n * company: { address: { street: { name: \"high street\" } } }\n * }\n *\n * Option.some(emp).pipe(\n * Option.flatMapNullishOr((e) => e.company?.address?.street?.name)\n * ) // => Option.some(\"high street\")\n * ```\n *\n * @see {@link flatMap} when the function already returns `Option`\n * @see {@link fromNullishOr} for single-value conversion\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const flatMapNullishOr = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none() : fromNullishOr(f(self.value)));\n/**\n * Flattens a nested `Option>` into `Option`.\n *\n * **When to use**\n *\n * Use when you need to remove one layer of nested `Option`.\n *\n * **Details**\n *\n * - `Some(Some(value))` → `Some(value)`\n * - `Some(None)` → `None`\n * - `None` → `None`\n *\n * **Example** (Flattening nested Options)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.flatten(Option.some(Option.some(\"value\"))) // => Option.some(\"value\")\n * Option.flatten(Option.some(Option.none())) // => Option.none()\n * ```\n *\n * @see {@link flatMap} which is `map` + `flatten`\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const flatten = /*#__PURE__*/flatMap(identity);\n/**\n * Sequences two `Option`s, keeping the value from the second if both are `Some`.\n *\n * **When to use**\n *\n * Use when you need two `Option` values to both be `Some`, then keep only the\n * second value.\n *\n * **Details**\n *\n * - Both `Some` → returns `that`\n * - Either `None` → returns `None`\n *\n * **Example** (Keeping the second value)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.zipRight(Option.some(1), Option.some(\"hello\")) // => Option.some(\"hello\")\n * Option.zipRight(Option.none(), Option.some(\"hello\")) // => Option.none()\n * ```\n *\n * @see {@link zipLeft} to keep the first value instead\n * @see {@link zipWith} to combine both values\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipRight = /*#__PURE__*/dual(2, (self, that) => flatMap(self, () => that));\n/**\n * Sequences two `Option`s, keeping the value from the first if both are `Some`.\n *\n * **When to use**\n *\n * Use when you need two `Option` values to both be `Some`, then keep only the\n * first value.\n *\n * **Details**\n *\n * - Both `Some` → returns `self`\n * - Either `None` → returns `None`\n *\n * **Example** (Keeping the first value)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.zipLeft(Option.some(\"hello\"), Option.some(1)) // => Option.some(\"hello\")\n * Option.zipLeft(Option.some(\"hello\"), Option.none()) // => Option.none()\n * ```\n *\n * @see {@link zipRight} to keep the second value instead\n * @see {@link zipWith} to combine both values\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipLeft = /*#__PURE__*/dual(2, (self, that) => tap(self, () => that));\n/**\n * Composes two `Option`-returning functions into a single function that chains\n * them together.\n *\n * **When to use**\n *\n * Use when you need to compose two functions that each return an `Option`, so\n * `None` short-circuits without calling the next function.\n *\n * **Details**\n *\n * - Calls `afb(a)`, then if `Some`, calls `bfc` with its value\n * - Short-circuits to `None` if either function returns `None`\n *\n * **Example** (Composing parsers)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const parse = (s: string): Option.Option =>\n * isNaN(Number(s)) ? Option.none() : Option.some(Number(s))\n *\n * const double = (n: number): Option.Option =>\n * n > 0 ? Option.some(n * 2) : Option.none()\n *\n * const parseAndDouble = Option.composeK(parse, double)\n *\n * parseAndDouble(\"42\") // => Option.some(84)\n * parseAndDouble(\"not a number\") // => Option.none()\n * ```\n *\n * @see {@link flatMap} for single-step chaining\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const composeK = /*#__PURE__*/dual(2, (afb, bfc) => a => flatMap(afb(a), bfc));\n/**\n * Runs a side-effecting `Option`-returning function on the value of a `Some`,\n * returning the original `Option` if the function returns `Some`, or `None`\n * if it returns `None`.\n *\n * **When to use**\n *\n * Use to validate an `Option`'s present value without transforming it, such as\n * adding a side-condition check in a pipeline.\n *\n * **Details**\n *\n * - `None` → `None`\n * - `Some` → calls `f(value)`; if result is `Some`, returns original `self`; if `None`, returns `None`\n *\n * **Example** (Validating without transforming)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const getInteger = (n: number) =>\n * Number.isInteger(n) ? Option.some(n) : Option.none()\n *\n * Option.tap(Option.some(1), getInteger) // => Option.some(1)\n * Option.tap(Option.some(1.14), getInteger) // => Option.none()\n * ```\n *\n * @see {@link flatMap} when you want to transform the value\n * @see {@link filter} for predicate-based filtering\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const tap = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => map(f(a), () => a)));\n/**\n * Combines two `Option`s into a `Some` containing a tuple `[A, B]` if both\n * are `Some`.\n *\n * **When to use**\n *\n * Use when you need to require two `Option` values to both be `Some` and keep\n * both values as a tuple.\n *\n * **Details**\n *\n * - Both `Some` → `Some([a, b])`\n * - Either `None` → `None`\n *\n * **Example** (Pairing two Options)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.product(Option.some(\"hello\"), Option.some(42)) // => Option.some([\"hello\", 42])\n * Option.product(Option.none(), Option.some(42)) // => Option.none()\n * ```\n *\n * @see {@link zipWith} to combine with a function instead of a tuple\n * @see {@link all} to combine many `Option`s\n *\n * @category combining\n * @since 2.0.0\n */\nexport const product = (self, that) => isSome(self) && isSome(that) ? some([self.value, that.value]) : none();\n/**\n * Combines a primary `Option` with an iterable of `Option`s into a tuple if\n * all are `Some`.\n *\n * **When to use**\n *\n * Use when you need several `Option` values of the same type to all be `Some`\n * and return them as a non-empty tuple.\n *\n * **Details**\n *\n * - All `Some` → `Some([self.value, ...rest])`\n * - Any `None` → `None`\n *\n * **Example** (Combining many Options)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const first = Option.some(1)\n * const rest = [Option.some(2), Option.some(3)]\n *\n * Option.productMany(first, rest) // => Option.some([1, 2, 3])\n * Option.productMany(first, [Option.some(2), Option.none()]) // => Option.none()\n * ```\n *\n * @see {@link product} for combining exactly two\n * @see {@link all} for tuples, structs, and iterables\n *\n * @category combining\n * @since 2.0.0\n */\nexport const productMany = (self, collection) => {\n if (isNone(self)) {\n return none();\n }\n const out = [self.value];\n for (const o of collection) {\n if (isNone(o)) {\n return none();\n }\n out.push(o.value);\n }\n return some(out);\n};\n/**\n * Combines a structure of `Option`s (tuple, struct, or iterable) into a single\n * `Option` containing the unwrapped structure.\n *\n * **When to use**\n *\n * Use when you need to combine multiple `Option` values into one while\n * preserving the input shape, with any `None` making the result `None`.\n *\n * **Details**\n *\n * - Tuple input → `Option` of a tuple with the same length\n * - Struct input → `Option` of a struct with the same keys\n * - Iterable input → `Option` of an `Array`\n * - Any `None` in the input → entire result is `None`\n *\n * **Example** (Combining a tuple and a struct)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const maybeName: Option.Option = Option.some(\"John\")\n * const maybeAge: Option.Option = Option.some(25)\n *\n * // ┌─── Option<[string, number]>\n * // ▼\n * const tuple = Option.all([maybeName, maybeAge]) // => Option.some([\"John\", 25])\n *\n * // ┌─── Option<{ name: string; age: number; }>\n * // ▼\n * const struct = Option.all({ name: maybeName, age: maybeAge }) // => Option.some({ name: \"John\", age: 25 })\n * ```\n *\n * @see {@link product} for combining exactly two\n * @see {@link productMany} for a homogeneous collection\n *\n * @category combining\n * @since 2.0.0\n */\n// @ts-expect-error\nexport const all = input => {\n if (Symbol.iterator in input) {\n const out = [];\n for (const o of input) {\n if (isNone(o)) {\n return none();\n }\n out.push(o.value);\n }\n return some(out);\n }\n const out = {};\n for (const key of Object.keys(input)) {\n const o = input[key];\n if (isNone(o)) {\n return none();\n }\n InternalRecord.assignProperty(out, key, o.value);\n }\n return some(out);\n};\n/**\n * Combines two `Option`s using a provided function.\n *\n * **When to use**\n *\n * Use when you need to combine two present `Option` values into a computed\n * result.\n *\n * **Details**\n *\n * - Both `Some` → applies `f(a, b)` and wraps in `Some`\n * - Either `None` → `None`\n *\n * **Example** (Combining with a function)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.zipWith(\n * Option.some(\"John\"),\n * Option.some(25),\n * (name, age) => ({ name: name.toUpperCase(), age })\n * ) // => Option.some({ name: \"JOHN\", age: 25 })\n * ```\n *\n * @see {@link product} to combine into a tuple instead\n * @see {@link lift2} to lift a binary function\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipWith = /*#__PURE__*/dual(3, (self, that, f) => map(product(self, that), ([a, b]) => f(a, b)));\n/**\n * Reduces an iterable of `Option`s to a single value, skipping `None` entries.\n *\n * **When to use**\n *\n * Use when you need to aggregate values from a collection where some may be\n * absent.\n *\n * **Details**\n *\n * - Iterates through the collection, applying `f` only to `Some` values\n * - `None` values are skipped entirely\n * - Returns the accumulated result\n *\n * **Example** (Summing present values)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe } from \"effect\"\n *\n * const items = [Option.some(1), Option.none(), Option.some(2), Option.none()]\n *\n * pipe(items, Option.reduceCompact(0, (b, a) => b + a)) // => 3\n * ```\n *\n * @category folding\n * @since 2.0.0\n */\nexport const reduceCompact = /*#__PURE__*/dual(3, (self, b, f) => {\n let out = b;\n for (const oa of self) {\n if (isSome(oa)) {\n out = f(out, oa.value);\n }\n }\n return out;\n});\n/**\n * Converts an `Option` into an `Array`.\n *\n * **When to use**\n *\n * Use when you need to pass an `Option` to array-based APIs or spread optional\n * values into collections.\n *\n * **Details**\n *\n * - `Some` → single-element array `[value]`\n * - `None` → empty array `[]`\n *\n * **Example** (Converting to an array)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.toArray(Option.some(1)) // => [1]\n * Option.toArray(Option.none()) // => []\n * ```\n *\n * @see {@link fromIterable} for the inverse direction\n *\n * @category converting\n * @since 2.0.0\n */\nexport const toArray = self => isNone(self) ? [] : [self.value];\n/**\n * Splits an `Option` into two `Option`s using a function that returns a `Result`.\n *\n * **When to use**\n *\n * Use when you need to split an optional value into \"left\" and \"right\"\n * channels using a `Result`-returning function.\n *\n * **Details**\n *\n * - `None` → `[None, None]`\n * - `Some` where `f` returns `Err` → `[Some(error), None]`\n * - `Some` where `f` returns `Ok` → `[None, Some(value)]`\n *\n * **Example** (Partitioning by Result)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * const parseNumber = (s: string): Result.Result => {\n * const n = Number(s)\n * return isNaN(n) ? Result.fail(\"Not a number\") : Result.succeed(n)\n * }\n *\n * Option.partitionMap(Option.some(\"42\"), parseNumber) // => [Option.none(), Option.some(42)]\n * Option.partitionMap(Option.some(\"abc\"), parseNumber) // => [Option.some(\"Not a number\"), Option.none()]\n * Option.partitionMap(Option.none(), parseNumber) // => [Option.none(), Option.none()]\n * ```\n *\n * @see {@link filter} for simple predicate-based filtering\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const partitionMap = /*#__PURE__*/dual(2, (self, f) => {\n if (isNone(self)) {\n return [none(), none()];\n }\n const e = f(self.value);\n return result.isFailure(e) ? [some(e.failure), none()] : [none(), some(e.success)];\n});\n/**\n * Transforms and filters an `Option` using a `Filter` callback.\n *\n * **When to use**\n *\n * Use to transform an `Option`'s present value and discard it when the `Filter`\n * fails.\n *\n * **Details**\n *\n * The callback returns a `Result`: `Result.succeed` keeps and transforms the\n * value, while `Result.fail` discards it.\n *\n * **Example** (Filtering and transforming)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Option.filterMap(\n * Option.some(2),\n * (n) => (n % 2 === 0 ? Result.succeed(`Even: ${n}`) : Result.failVoid)\n * ) // => Option.some(\"Even: 2\")\n * ```\n *\n * @see {@link filter} for predicate-based filtering\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filterMap = /*#__PURE__*/dual(2, (self, f) => {\n if (isNone(self)) {\n return none();\n }\n const next = f(self.value);\n return result.isSuccess(next) ? some(next.success) : none();\n});\n/**\n * Filters an `Option` using a predicate. Returns `None` if the predicate is\n * not satisfied or the input is `None`.\n *\n * **When to use**\n *\n * Use when you need to discard an `Option`'s present value when it does not\n * meet a condition, while narrowing the type via a refinement predicate.\n *\n * **Details**\n *\n * - `None` → `None`\n * - `Some` where `predicate(value)` is `true` → `Some(value)`\n * - `Some` where `predicate(value)` is `false` → `None`\n * - Supports refinements for type narrowing\n *\n * **Example** (Filtering with a predicate)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const removeEmpty = (input: Option.Option) =>\n * Option.filter(input, (value) => value !== \"\")\n *\n * removeEmpty(Option.some(\"hello\")) // => Option.some(\"hello\")\n * removeEmpty(Option.some(\"\")) // => Option.none()\n * removeEmpty(Option.none()) // => Option.none()\n * ```\n *\n * @see {@link filterMap} to transform and filter simultaneously\n * @see {@link exists} to test without filtering\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filter = /*#__PURE__*/dual(2, (self, predicate) => isNone(self) ? none() : predicate(self.value) ? some(self.value) : none());\n/**\n * Creates an `Equivalence` for `Option` from an `Equivalence` for `A`.\n *\n * **When to use**\n *\n * Use when you need equality to treat two `None` values as equal and compare\n * two `Some` values with a supplied equality rule.\n *\n * **Details**\n *\n * - `None` vs `None` → `true`\n * - `Some` vs `None` (or vice versa) → `false`\n * - `Some(a)` vs `Some(b)` → delegates to the provided `Equivalence`\n *\n * **Example** (Comparing Options)\n *\n * ```ts import.meta.vitest\n * import { Equivalence, Option } from \"effect\"\n *\n * const eq = Option.makeEquivalence(Equivalence.strictEqual())\n *\n * eq(Option.some(1), Option.some(1)) // => true\n * eq(Option.some(1), Option.some(2)) // => false\n * eq(Option.none(), Option.none()) // => true\n * ```\n *\n * @category instances\n * @since 4.0.0\n */\nexport const makeEquivalence = isEquivalent => Equivalence.make((x, y) => isNone(x) ? isNone(y) : isNone(y) ? false : isEquivalent(x.value, y.value));\n/**\n * Creates an `Order` for `Option` from an `Order` for `A`.\n *\n * **When to use**\n *\n * Use when you need to sort `Some` and `None` values, with `None` ordered\n * before present values and present values compared by a supplied ordering\n * rule.\n *\n * **Details**\n *\n * - `None` is considered less than any `Some`\n * - Two `Some` values are compared using the provided `Order`\n * - Two `None` values are equal (returns `0`)\n *\n * **Example** (Ordering Options)\n *\n * ```ts import.meta.vitest\n * import { Number as N, Option } from \"effect\"\n *\n * const ord = Option.makeOrder(N.Order)\n *\n * ord(Option.none(), Option.some(1)) // => -1\n * ord(Option.some(1), Option.none()) // => 1\n * ord(Option.some(1), Option.some(2)) // => -1\n * ```\n *\n * @category sorting\n * @since 4.0.0\n */\nexport const makeOrder = O => order.make((self, that) => isSome(self) ? isSome(that) ? O(self.value, that.value) : 1 : -1);\n/**\n * Lifts a binary function to operate on two `Option` values.\n *\n * **When to use**\n *\n * Use when you need to reuse an existing binary function with two `Option`\n * values.\n *\n * **Details**\n *\n * - Both `Some` → applies `f` and wraps in `Some`\n * - Either `None` → `None`\n *\n * **Example** (Lifting addition)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const addOptions = Option.lift2((a: number, b: number) => a + b)\n *\n * addOptions(Option.some(2), Option.some(3)) // => Option.some(5)\n * addOptions(Option.some(2), Option.none()) // => Option.none()\n * ```\n *\n * @see {@link zipWith} for a non-lifted variant\n *\n * @category lifting\n * @since 2.0.0\n */\nexport const lift2 = f => dual(2, (self, that) => zipWith(self, that, f));\n/**\n * Lifts a `Predicate` or `Refinement` into the `Option` context: returns\n * `Some(value)` when the predicate holds, `None` otherwise.\n *\n * **When to use**\n *\n * Use to convert a boolean check into an `Option`-returning function\n * - Validating input and wrapping it in `Option`\n *\n * **Details**\n *\n * - `predicate(value)` is `true` → `Some(value)`\n * - `predicate(value)` is `false` → `None`\n * - Supports refinements for type narrowing\n *\n * **Example** (Validating positive numbers)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const parsePositive = Option.liftPredicate((n: number) => n > 0)\n *\n * parsePositive(1) // => Option.some(1)\n * parsePositive(-1) // => Option.none()\n * ```\n *\n * @see {@link filter} to apply a predicate to an existing `Option`\n * @see {@link toRefinement} for the inverse direction\n *\n * @category lifting\n * @since 2.0.0\n */\nexport const liftPredicate = /*#__PURE__*/dual(2, (b, predicate) => predicate(b) ? some(b) : none());\n/**\n * Checks whether an `Option` contains a value equivalent to the given one, using a\n * custom `Equivalence`.\n *\n * **When to use**\n *\n * Use when you need to test whether an `Option` contains a value using a\n * custom equality check.\n *\n * **Details**\n *\n * - `Some` where `isEquivalent(value, a)` is `true` → `true`\n * - `Some` where not equivalent, or `None` → `false`\n *\n * **Example** (Checking with custom equivalence)\n *\n * ```ts import.meta.vitest\n * import { Equivalence, Option } from \"effect\"\n *\n * const check = Option.containsWith(Equivalence.strictEqual())\n *\n * Option.some(2).pipe(check(2)) // => true\n * Option.some(1).pipe(check(2)) // => false\n * Option.none().pipe(check(2)) // => false\n * ```\n *\n * @see {@link contains} for a version using default equality\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const containsWith = isEquivalent => dual(2, (self, a) => isNone(self) ? false : isEquivalent(self.value, a));\n/**\n * Checks whether an `Option` contains a value equal to the given one, using default\n * structural equality.\n *\n * **When to use**\n *\n * Use when you need a quick membership test for an `Option` value using\n * standard equality.\n *\n * **Details**\n *\n * - `Some` where `Equal.equals(value, a)` is `true` → `true`\n * - `Some` where not equal, or `None` → `false`\n *\n * **Example** (Checking containment)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * Option.some(2).pipe(Option.contains(2)) // => true\n * Option.some(1).pipe(Option.contains(2)) // => false\n * Option.none().pipe(Option.contains(2)) // => false\n * ```\n *\n * @see {@link containsWith} for custom equality\n * @see {@link exists} to test with a predicate\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const contains = /*#__PURE__*/containsWith(/*#__PURE__*/Equal.asEquivalence());\n/**\n * Checks whether the value in a `Some` satisfies a predicate or refinement.\n *\n * **When to use**\n *\n * Use to check a condition on an optional value without unwrapping\n *\n * **Details**\n *\n * - `None` → `false`\n * - `Some` where `predicate(value)` is `true` → `true`\n * - `Some` where `predicate(value)` is `false` → `false`\n * - With a refinement, narrows the `Option` type on `true`\n *\n * **Example** (Testing a condition)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const isEven = (n: number) => n % 2 === 0\n *\n * Option.some(2).pipe(Option.exists(isEven)) // => true\n * Option.some(1).pipe(Option.exists(isEven)) // => false\n * Option.none().pipe(Option.exists(isEven)) // => false\n * ```\n *\n * @see {@link filter} to keep or discard based on a predicate\n * @see {@link contains} to test for a specific value\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const exists = /*#__PURE__*/dual(2, (self, refinement) => isNone(self) ? false : refinement(self.value));\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * Gives a name to the value of an `Option`, creating a single-key record\n * inside `Some`. Starting point for the do notation pipeline.\n *\n * **When to use**\n *\n * Use when you need to start an `Option` do notation chain by naming the first\n * value.\n *\n * **Example** (Starting do notation)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe } from \"effect\"\n *\n * pipe(\n * Option.some(2),\n * Option.bindTo(\"x\"),\n * Option.bind(\"y\", () => Option.some(3)),\n * Option.let(\"sum\", ({ x, y }) => x + y)\n * ) // => Option.some({ x: 2, y: 3, sum: 5 })\n * ```\n *\n * @see {@link Do} for starting with an empty record\n * @see {@link bind} to add `Option` values\n * @see {@link let_ let} to add plain values\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const bindTo = /*#__PURE__*/doNotation.bindTo(map);\nconst let_ = /*#__PURE__*/doNotation.let_(map);\nexport {\n/**\n * Adds a computed plain value to the do notation record.\n *\n * **When to use**\n *\n * Use when you need to bind a derived non-`Option` value in an `Option` do\n * notation pipeline.\n *\n * **Example** (Adding a computed value)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe } from \"effect\"\n *\n * pipe(\n * Option.Do,\n * Option.bind(\"x\", () => Option.some(2)),\n * Option.bind(\"y\", () => Option.some(3)),\n * Option.let(\"sum\", ({ x, y }) => x + y)\n * ) // => Option.some({ x: 2, y: 3, sum: 5 })\n * ```\n *\n * @see {@link Do} for starting the chain\n * @see {@link bind} to add `Option` values\n * @see {@link bindTo} to start by naming an existing `Option`\n *\n * @category mapping\n * @since 2.0.0\n */\nlet_ as let };\n/**\n * Adds an `Option` value to the do notation record under a given name. If the\n * `Option` is `None`, the whole pipeline short-circuits to `None`.\n *\n * **When to use**\n *\n * Use when you need to sequence `Option` computations in do notation.\n *\n * **Example** (Binding Option values)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe } from \"effect\"\n *\n * pipe(\n * Option.Do,\n * Option.bind(\"x\", () => Option.some(2)),\n * Option.bind(\"y\", () => Option.some(3)),\n * Option.let(\"sum\", ({ x, y }) => x + y),\n * Option.filter(({ x, y }) => x * y > 5)\n * ) // => Option.some({ x: 2, y: 3, sum: 5 })\n * ```\n *\n * @see {@link Do} for starting the chain\n * @see {@link let_ let} to add plain values\n * @see {@link bindTo} to start by naming an existing `Option`\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const bind = /*#__PURE__*/doNotation.bind(map, flatMap);\n/**\n * Provides an `Option` containing an empty record `{}`, used as the starting point for\n * do notation chains.\n *\n * **When to use**\n *\n * Use when you need to start an `Option` do notation pipeline before adding\n * bindings.\n *\n * **Example** (Building Option pipelines with do notation)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe } from \"effect\"\n *\n * pipe(\n * Option.Do,\n * Option.bind(\"x\", () => Option.some(2)),\n * Option.bind(\"y\", () => Option.some(3)),\n * Option.let(\"sum\", ({ x, y }) => x + y),\n * Option.filter(({ x, y }) => x * y > 5)\n * ) // => Option.some({ x: 2, y: 3, sum: 5 })\n * ```\n *\n * @see {@link bind} to add `Option` values\n * @see {@link let_ let} to add plain values\n * @see {@link bindTo} to start by naming an existing `Option`\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const Do = /*#__PURE__*/some({});\n/**\n * Provides generator-based syntax for `Option`, similar to `async`/`await` but for\n * optional values. Yielding a `None` short-circuits the generator to `None`.\n *\n * **When to use**\n *\n * Use when you need generator syntax for a sequence of `Option` steps that\n * should short-circuit on `None`.\n *\n * **Details**\n *\n * - Each `yield*` unwraps a `Some` value or short-circuits to `None`\n * - The return value is wrapped in `Some`\n * - No `Effect` runtime is needed\n *\n * **Example** (Sequencing Option computations with generator syntax)\n *\n * ```ts import.meta.vitest\n * import { Option } from \"effect\"\n *\n * const maybeName: Option.Option = Option.some(\"John\")\n * const maybeAge: Option.Option = Option.some(25)\n *\n * Option.gen(function*() {\n * const name = (yield* maybeName).toUpperCase()\n * const age = yield* maybeAge\n * return { name, age }\n * }) // => Option.some({ name: \"JOHN\", age: 25 })\n * ```\n *\n * @see {@link Do} / {@link bind} for the do notation alternative\n *\n * @category generators\n * @since 2.0.0\n */\nexport const gen = (...args) => {\n const f = args.length === 1 ? args[0] : args[1].bind(args[0]);\n const iterator = f();\n let state = iterator.next();\n while (!state.done) {\n const current = state.value;\n if (isNone(current)) {\n return current;\n }\n state = iterator.next(current.value);\n }\n return some(state.value);\n};\n/**\n * Creates a `Reducer` for `Option` that prioritizes the first non-`None`\n * value and combines values when both are `Some`.\n *\n * **When to use**\n *\n * Use to build an `Option` reducer that falls back to the first available value\n * when either side may be absent.\n *\n * **Details**\n *\n * - `None` + `None` → `None`\n * - `Some(a)` + `None` → `Some(a)`\n * - `None` + `Some(b)` → `Some(b)`\n * - `Some(a)` + `Some(b)` → `Some(combine(a, b))`\n * - Initial value is `None`\n *\n * **Example** (Reducing with first-wins semantics)\n *\n * ```ts import.meta.vitest\n * import { Number, Option } from \"effect\"\n *\n * const reducer = Option.makeReducer(Number.ReducerSum)\n * reducer.combineAll([Option.some(1), Option.none(), Option.some(2)]) // => Option.some(3)\n * ```\n *\n * @see {@link makeReducerFailFast} for fail-fast semantics\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeReducer(combiner) {\n return Reducer.make((self, that) => {\n if (isNone(self)) return that;\n if (isNone(that)) return self;\n return some(combiner.combine(self.value, that.value));\n }, none());\n}\n/**\n * Creates a `Combiner` for `Option` with fail-fast semantics: returns `None`\n * if either operand is `None`.\n *\n * **When to use**\n *\n * Use when you need an `Option` combiner that returns `None` unless both\n * operands are `Some`.\n *\n * **Details**\n *\n * - `None` + anything → `None`\n * - anything + `None` → `None`\n * - `Some(a)` + `Some(b)` → `Some(combine(a, b))`\n *\n * **Example** (Fail-fast combining)\n *\n * ```ts import.meta.vitest\n * import { Number, Option } from \"effect\"\n *\n * const combiner = Option.makeCombinerFailFast(Number.ReducerSum)\n * combiner.combine(Option.some(1), Option.some(2)) // => Option.some(3)\n * combiner.combine(Option.some(1), Option.none()) // => Option.none()\n * ```\n *\n * @see {@link makeReducerFailFast} to get a full `Reducer`\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeCombinerFailFast(combiner) {\n return Combiner.make((self, that) => {\n if (isNone(self) || isNone(that)) return none();\n return some(combiner.combine(self.value, that.value));\n });\n}\n/**\n * Creates a `Reducer` for `Option` by lifting an existing `Reducer` with\n * fail-fast semantics.\n *\n * **When to use**\n *\n * Use when you need to reduce `Option` values with fail-fast semantics, where\n * any `None` aborts the entire result instead of being skipped.\n *\n * **Details**\n *\n * - Initial value is `Some(reducer.initialValue)`\n * - Combines only when both operands are `Some`\n * - Any `None` causes the result to become `None` immediately\n *\n * **Example** (Fail-fast reducing)\n *\n * ```ts import.meta.vitest\n * import { Number, Option } from \"effect\"\n *\n * const reducer = Option.makeReducerFailFast(Number.ReducerSum)\n * reducer.combineAll([Option.some(1), Option.some(2)]) // => Option.some(3)\n * reducer.combineAll([Option.some(1), Option.none()]) // => Option.none()\n * ```\n *\n * @see {@link makeCombinerFailFast} for just the combiner\n * @see {@link makeReducer} for non-fail-fast semantics\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeReducerFailFast(reducer) {\n const combine = makeCombinerFailFast(reducer).combine;\n const initialValue = some(reducer.initialValue);\n return Reducer.make(combine, initialValue, collection => {\n let out = initialValue;\n for (const value of collection) {\n out = combine(out, value);\n if (isNone(out)) return out;\n }\n return out;\n });\n}\n//# sourceMappingURL=Option.js.map","import * as Effectable from \"./Effectable.js\";\nimport * as Equal from \"./Equal.js\";\nimport { dual } from \"./Function.js\";\nimport * as Hash from \"./Hash.js\";\nimport { exitSucceed, PipeInspectableProto, withFiber } from \"./internal/core.js\";\nimport * as Option from \"./Option.js\";\nimport { hasProperty } from \"./Predicate.js\";\n/**\n * Runtime type identifier attached to `Context` service keys and used by\n * `isKey` to recognize them.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const ServiceTypeId = \"~effect/Context/Service\";\n/**\n * Creates a `Context` service key.\n *\n * **When to use**\n *\n * Use when you need to define a context service key for a dependency that must\n * be provided by the surrounding context.\n *\n * **Details**\n *\n * Call `Context.Service(\"Key\")` for a function-style key, or use the two-stage\n * form `Context.Service()(\"Key\")` for class-style service\n * declarations. The returned key can be yielded as an Effect and passed to\n * `Context.make`, `Context.add`, and the Context getter functions.\n *\n * **Gotchas**\n *\n * The string key is the runtime identity of the service. Reusing the same key\n * string for unrelated services makes them occupy the same slot in a\n * `Context`.\n *\n * **Example** (Creating service keys)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n *\n * // Create a simple service\n * const Database = Context.Service<{\n * query: (sql: string) => string\n * }>(\"Database\")\n *\n * // Create a service class\n * class Config extends Context.Service()(\"Config\") {}\n *\n * // Use the services to create contexts\n * const db = Context.make(Database, {\n * query: (sql) => `Result: ${sql}`\n * })\n * const config = Context.make(Config, { port: 8080 })\n * Context.get(db, Database).query(\"SELECT 1\") // => \"Result: SELECT 1\"\n * Context.get(config, Config).port // => 8080\n * ```\n *\n * @see {@link Reference} for service keys with default values\n *\n * @category services\n * @since 4.0.0\n */\nexport const Service = function () {\n function KeyClass() {}\n const self = KeyClass;\n Object.setPrototypeOf(self, ServiceProto);\n const init = (key, options) => {\n self.key = key;\n if (options?.defaultValue) {\n self[ReferenceTypeId] = ReferenceTypeId;\n self.defaultValue = options.defaultValue;\n }\n if (options?.make) {\n ;\n self.make = options.make;\n }\n if (options?.fiberCached) {\n cacheKeys.add(key);\n }\n return self;\n };\n return arguments.length > 0 ? init(arguments[0], arguments[1]) : init;\n};\nconst ServiceProto = {\n [ServiceTypeId]: ServiceTypeId,\n ... /*#__PURE__*/Effectable.Prototype({\n label: \"Service\",\n evaluate(fiber) {\n return exitSucceed(get(fiber.context, this));\n }\n }),\n toJSON() {\n return {\n _id: \"Service\",\n key: this.key\n };\n },\n of(self) {\n return self;\n },\n context(self) {\n return make(this, self);\n },\n use(f) {\n return withFiber(fiber => f(get(fiber.context, this)));\n },\n useSync(f) {\n return withFiber(fiber => exitSucceed(f(get(fiber.context, this))));\n }\n};\nconst cacheKeys = /*#__PURE__*/new Set();\nconst ReferenceTypeId = \"~effect/Context/Reference\";\nconst TypeId = \"~effect/Context\";\nconst MaxDepth = 8;\nconst FlattenAfterBaseHits = 8;\nconst makeImpl = (cacheRoot, base, overlay, depth) => {\n const self = Object.create(Proto);\n self.cacheRoot = cacheRoot ?? self;\n self.base = base;\n self.overlay = overlay;\n self.depth = depth;\n self._flat = undefined;\n self.baseHits = 0;\n return self;\n};\nconst applyOverlays = (map, overlay) => {\n if (!overlay) return;\n applyOverlays(map, overlay.parent);\n map.set(overlay.key, overlay.value);\n};\nconst flatten = self => {\n if (self._flat) return self._flat;\n if (!self.overlay) return self._flat = self.base;\n const map = new Map(self.base);\n applyOverlays(map, self.overlay);\n return self._flat = map;\n};\nconst withFlat = (self, f) => {\n const map = new Map(self.mapUnsafe);\n f(map);\n return makeUnsafe(map);\n};\n// A private symbol so user code cannot forge a value that reads as absent\nconst notFound = /*#__PURE__*/Symbol();\nconst lookup = (self, key) => {\n const impl = self;\n for (let overlay = impl.overlay; overlay; overlay = overlay.parent) {\n if (overlay.key === key) return overlay.value;\n }\n const value = impl.base.get(key);\n // Misses must not advance the counter: reference-default lookups miss the\n // base on every fiber cache refresh, which would flatten every short-lived\n // request context and reintroduce the O(services) per-request cost\n if (value === undefined && !impl.base.has(key)) return notFound;\n if (impl.overlay && ++impl.baseHits >= FlattenAfterBaseHits) {\n impl.base = flatten(impl);\n impl.overlay = undefined;\n impl.depth = 0;\n }\n return value;\n};\n/**\n * Creates a `Context` from an existing service map.\n *\n * **When to use**\n *\n * Use when constructing a low-level `Context` from a trusted map whose lifecycle\n * you control.\n *\n * **Gotchas**\n *\n * The provided map is retained without copying and must not be mutated after\n * construction. Prefer `empty`, `make`, `add`, or `merge` for normal Context\n * construction.\n *\n * **Example** (Creating a context from a map)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n *\n * // Create a context from a Map (unsafe)\n * const map = new Map([\n * [\"Logger\", { log: (_msg: string) => {} }]\n * ])\n *\n * const context = Context.makeUnsafe(map)\n * context.mapUnsafe.size // => 1\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeUnsafe = mapUnsafe => makeImpl(undefined, mapUnsafe, undefined, 0);\nconst Proto = {\n get mapUnsafe() {\n return flatten(this);\n },\n ...PipeInspectableProto,\n [TypeId]: {\n _Services: _ => _\n },\n toJSON() {\n return {\n _id: \"Context\",\n services: Array.from(this.mapUnsafe).map(([key, value]) => ({\n key,\n value\n }))\n };\n },\n [Equal.symbol](that) {\n if (!isContext(that)) return false;\n const self = this.mapUnsafe;\n const other = that.mapUnsafe;\n if (self.size !== other.size) return false;\n for (const [key, value] of self) {\n if (!other.has(key) || !Equal.equals(value, other.get(key))) return false;\n }\n return true;\n },\n [Hash.symbol]() {\n return Hash.number(this.mapUnsafe.size);\n }\n};\n/** @internal */\nexport const hasSameCache = (self, that) => self.cacheRoot === that.cacheRoot;\n/**\n * Checks whether the provided argument is a `Context`.\n *\n * **When to use**\n *\n * Use to narrow an unknown value before passing it to APIs that require a\n * `Context`.\n *\n * **Details**\n *\n * This checks the runtime `Context` marker and does not inspect which services\n * the context contains.\n *\n * **Gotchas**\n *\n * This guard only proves that the value is a `Context`; it does not prove that\n * any specific service is present.\n *\n * **Example** (Checking for contexts)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n * Context.isContext(Context.empty()) // => true\n * ```\n *\n * @see {@link isKey} for checking service keys\n * @see {@link isReference} for checking references with defaults\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isContext = u => hasProperty(u, TypeId);\n/**\n * Checks whether the provided argument is a `Key`.\n *\n * **Example** (Checking for keys)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n * Context.isKey(Context.Service(\"Service\")) // => true\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isKey = u => hasProperty(u, ServiceTypeId);\n/**\n * Checks whether the provided argument is a `Reference`.\n *\n * **Example** (Checking for references)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n *\n * const LoggerRef = Context.Reference(\"Logger\", {\n * defaultValue: () => ({ log: (_msg: string) => {} })\n * })\n *\n * Context.isReference(LoggerRef) // => true\n * Context.isReference(Context.Service(\"Key\")) // => false\n * ```\n *\n * @category guards\n * @since 3.11.0\n */\nexport const isReference = u => !!u[ReferenceTypeId];\n/**\n * Returns an empty `Context`.\n *\n * **Example** (Creating an empty context)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n * Context.empty().mapUnsafe.size // => 0\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const empty = () => emptyContext;\nconst emptyContext = /*#__PURE__*/makeUnsafe(/*#__PURE__*/new Map());\n/**\n * Creates a new `Context` with a single service associated to the key.\n *\n * **Example** (Creating a context with one service)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n *\n * const Port = Context.Service<{ PORT: number }>(\"Port\")\n *\n * const context = Context.make(Port, { PORT: 8080 })\n *\n * Context.get(context, Port).PORT // => 8080\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const make = (key, service) => makeUnsafe(new Map([[key.key, service]]));\n/**\n * Adds a service to a given `Context`.\n *\n * **When to use**\n *\n * Use when you need to store a known service value in a `Context`.\n *\n * **Details**\n *\n * If the context already contains the same service key, the new service\n * replaces the previous one.\n *\n * **Example** (Adding a service to a context)\n *\n * ```ts import.meta.vitest\n * import { Context, pipe } from \"effect\"\n *\n * const Port = Context.Service<{ PORT: number }>(\"Port\")\n * const Timeout = Context.Service<{ TIMEOUT: number }>(\"Timeout\")\n *\n * const someContext = Context.make(Port, { PORT: 8080 })\n *\n * const context = pipe(\n * someContext,\n * Context.add(Timeout, { TIMEOUT: 5000 })\n * )\n *\n * const values = [Context.get(context, Port).PORT, Context.get(context, Timeout).TIMEOUT]\n * values // => [8080, 5000]\n * ```\n *\n * @see {@link addOrOmit} for adding or removing a service from an `Option`\n *\n * @category combining\n * @since 2.0.0\n */\nexport const add = /*#__PURE__*/dual(3, (self, key, service) => addUnsafe(self, key.key, service));\n/**\n * Adds a service by key to a given `Context` using a string key.\n *\n * @category combining\n * @since 4.0.0\n */\nexport const addUnsafe = (self, key, service) => {\n const impl = self;\n const cacheRoot = cacheKeys.has(key) ? undefined : impl.cacheRoot;\n if (impl.depth >= MaxDepth) {\n // Rebase the overlay chain into a flat map, keeping the cacheRoot so a\n // rebase on an ordinary key does not invalidate fiber caches\n const map = new Map(impl.mapUnsafe);\n map.set(key, service);\n return makeImpl(cacheRoot, map, undefined, 0);\n }\n return makeImpl(cacheRoot, impl.base, {\n key,\n value: service,\n parent: impl.overlay\n }, impl.depth + 1);\n};\n/**\n * Adds or removes a service depending on an `Option`.\n *\n * **When to use**\n *\n * Use when you need to add or omit a `Context` service based on an `Option`.\n *\n * **Details**\n *\n * When `service` is `Option.some`, the value is stored for the key. When it is\n * `Option.none`, the key is removed from the returned `Context`.\n *\n * **Example** (Adding optional services)\n *\n * ```ts import.meta.vitest\n * import { Context, Option } from \"effect\"\n *\n * const Port = Context.Service<{ PORT: number }>(\"Port\")\n *\n * const withPort = Context.empty().pipe(\n * Context.addOrOmit(Port, Option.some({ PORT: 8080 }))\n * )\n *\n * const withoutPort = withPort.pipe(\n * Context.addOrOmit(Port, Option.none())\n * )\n * Context.getOption(withPort, Port) // => Option.some({ PORT: 8080 })\n * Context.getOption(withoutPort, Port) // => Option.none()\n * ```\n *\n * @see {@link add} for always storing a service value\n *\n * @category combining\n * @since 4.0.0\n */\nexport const addOrOmit = /*#__PURE__*/dual(3, (self, key, service) => service._tag === \"None\" ? omit(key)(self) : add(self, key, service.value));\n/**\n * Gets the service for a key, or evaluates the fallback when a non-reference\n * key is absent.\n *\n * **When to use**\n *\n * Use when you need a fallback for a missing `Context.Service` key while still\n * resolving `Context.Reference` defaults.\n *\n * **Details**\n *\n * If the key is a `Context.Reference` and no override is stored in the\n * context, its cached default value is returned instead of the fallback.\n *\n * **Gotchas**\n *\n * The fallback is not evaluated for missing `Context.Reference` keys because\n * references resolve to their default value.\n *\n * **Example** (Falling back for missing services)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n *\n * const Logger = Context.Service<{ log: (msg: string) => void }>(\"Logger\")\n * const Database = Context.Service<{ query: (sql: string) => string }>(\n * \"Database\"\n * )\n *\n * const context = Context.make(Logger, { log: (_msg: string) => {} })\n *\n * const logger = Context.getOrElse(context, Logger, () => ({ log: () => {} }))\n * const database = Context.getOrElse(\n * context,\n * Database,\n * () => ({ query: () => \"fallback\" })\n * )\n *\n * logger === Context.get(context, Logger) // => true\n * database.query(\"SELECT 1\") // => \"fallback\"\n * ```\n *\n * @see {@link getOption} for returning `Option.none` when a non-reference key is missing\n *\n * @category getters\n * @since 3.7.0\n */\nexport const getOrElse = /*#__PURE__*/dual(3, (self, key, orElse) => {\n const value = lookup(self, key.key);\n if (value !== notFound) return value;\n return isReference(key) ? getDefaultValue(key) : orElse();\n});\n/**\n * Returns the service currently stored for a key, or `undefined` when the key\n * is absent.\n *\n * **When to use**\n *\n * Use when you need to read the service stored for a key without resolving\n * `Context.Reference` defaults.\n *\n * **Gotchas**\n *\n * This is a raw lookup and does not resolve default values for\n * `Context.Reference` keys.\n *\n * @see {@link getOption} for a reference-aware optional lookup\n *\n * @category getters\n * @since 4.0.0\n */\nexport const getOrUndefined = /*#__PURE__*/dual(2, (self, key) => getOrUndefinedUnsafe(self, key.key));\n/** @internal */\nexport const getOrUndefinedUnsafe = (self, key) => {\n const value = lookup(self, key);\n return value === notFound ? undefined : value;\n};\n/**\n * Gets the service for a key, throwing if an absent non-reference key cannot be\n * resolved.\n *\n * **When to use**\n *\n * Use when you need to read a service from a context whose type does not prove\n * the service is present.\n *\n * **Details**\n *\n * If the key is a `Context.Reference` and no override is stored in the\n * context, its cached default value is returned. For absent non-reference keys,\n * this function throws a runtime error.\n *\n * **Example** (Getting services unsafely)\n *\n * ```ts import.meta.vitest\n * import { Context, Option } from \"effect\"\n *\n * const Port = Context.Service<{ PORT: number }>(\"Port\")\n * const Timeout = Context.Service<{ TIMEOUT: number }>(\"Timeout\")\n *\n * const context = Context.make(Port, { PORT: 8080 })\n *\n * Context.getUnsafe(context, Port).PORT // => 8080\n * Context.getOption(context, Timeout) // => Option.none()\n * ```\n *\n * @see {@link get} for type-checked service access\n * @see {@link getOption} for optional service access\n *\n * @category unsafe\n * @since 4.0.0\n */\nexport const getUnsafe = /*#__PURE__*/dual(2, (self, service) => {\n const value = lookup(self, service.key);\n if (value === notFound) {\n if (isReference(service)) return getDefaultValue(service);\n throw serviceNotFoundError(service);\n }\n return value;\n});\n/**\n * Gets a service from the context that corresponds to the given key.\n *\n * **When to use**\n *\n * Use when you need type-checked access to a service already included in the\n * context type.\n *\n * **Example** (Getting a service from a context)\n *\n * ```ts import.meta.vitest\n * import { Context, pipe } from \"effect\"\n *\n * const Port = Context.Service<{ PORT: number }>(\"Port\")\n * const Timeout = Context.Service<{ TIMEOUT: number }>(\"Timeout\")\n *\n * const context = pipe(\n * Context.make(Port, { PORT: 8080 }),\n * Context.add(Timeout, { TIMEOUT: 5000 })\n * )\n *\n * Context.get(context, Timeout).TIMEOUT // => 5000\n * ```\n *\n * @see {@link getOption} for optional service access\n * @see {@link getOrElse} for fallback values\n *\n * @category getters\n * @since 2.0.0\n */\nexport const get = getUnsafe;\nconst defaultValueCacheKey = \"~effect/Context/defaultValue\";\nconst getDefaultValue = ref => {\n if (defaultValueCacheKey in ref) {\n return ref[defaultValueCacheKey];\n }\n return ref[defaultValueCacheKey] = ref.defaultValue();\n};\nconst serviceNotFoundError = service => {\n const error = new Error(`Service not found${service.key ? `: ${String(service.key)}` : \"\"}`);\n if (error.stack) {\n const lines = error.stack.split(\"\\n\");\n lines.splice(1, 3);\n error.stack = lines.join(\"\\n\");\n }\n return error;\n};\n/**\n * Gets the service for a key safely wrapped in an `Option`.\n *\n * **When to use**\n *\n * Use when you need to read a `Context` service as an `Option` so absence is\n * represented as data.\n *\n * **Details**\n *\n * Returns `Option.some` when the service is stored in the context. If the key\n * is a `Context.Reference` and no override is stored, returns `Option.some` of\n * the cached default value. Missing non-reference keys return `Option.none`.\n *\n * **Example** (Getting optional services)\n *\n * ```ts import.meta.vitest\n * import { Context, Option } from \"effect\"\n *\n * const Port = Context.Service<{ PORT: number }>(\"Port\")\n * const Timeout = Context.Service<{ TIMEOUT: number }>(\"Timeout\")\n *\n * const context = Context.make(Port, { PORT: 8080 })\n *\n * Context.getOption(context, Port) // => Option.some({ PORT: 8080 })\n * Context.getOption(context, Timeout) // => Option.none()\n * ```\n *\n * @see {@link getOrElse} for returning a fallback value directly\n *\n * @category getters\n * @since 2.0.0\n */\nexport const getOption = /*#__PURE__*/dual(2, (self, service) => {\n const value = lookup(self, service.key);\n if (value !== notFound) return Option.some(value);\n return isReference(service) ? Option.some(getDefaultValue(service)) : Option.none();\n});\n/**\n * Merges two `Context`s into one.\n *\n * **When to use**\n *\n * Use when you need to combine two contexts.\n *\n * **Details**\n *\n * When both contexts contain the same service key, the service from `that`\n * overrides the service from `self`.\n *\n * **Example** (Merging two contexts)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n *\n * const Port = Context.Service<{ PORT: number }>(\"Port\")\n * const Timeout = Context.Service<{ TIMEOUT: number }>(\"Timeout\")\n *\n * const firstContext = Context.make(Port, { PORT: 8080 })\n * const secondContext = Context.make(Timeout, { TIMEOUT: 5000 })\n *\n * const context = Context.merge(firstContext, secondContext)\n *\n * const values = [Context.get(context, Port).PORT, Context.get(context, Timeout).TIMEOUT]\n * values // => [8080, 5000]\n * ```\n *\n * @see {@link mergeAll} for merging more than two contexts at once\n *\n * @category combining\n * @since 2.0.0\n */\nexport const merge = /*#__PURE__*/dual(2, (self, that) => {\n if (self.mapUnsafe.size === 0) return that;\n if (that.mapUnsafe.size === 0) return self;\n return withFlat(self, map => that.mapUnsafe.forEach((value, key) => map.set(key, value)));\n});\n/**\n * Merges any number of `Context`s into one.\n *\n * **When to use**\n *\n * Use when you need to combine a variadic list of contexts.\n *\n * **Details**\n *\n * When multiple contexts contain the same service key, the service from the\n * last context with that key is kept.\n *\n * **Example** (Merging multiple contexts)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n *\n * const Port = Context.Service<{ PORT: number }>(\"Port\")\n * const Timeout = Context.Service<{ TIMEOUT: number }>(\"Timeout\")\n * const Host = Context.Service<{ HOST: string }>(\"Host\")\n *\n * const firstContext = Context.make(Port, { PORT: 8080 })\n * const secondContext = Context.make(Timeout, { TIMEOUT: 5000 })\n * const thirdContext = Context.make(Host, { HOST: \"localhost\" })\n *\n * const context = Context.mergeAll(\n * firstContext,\n * secondContext,\n * thirdContext\n * )\n *\n * context.mapUnsafe.size // => 3\n * ```\n *\n * @see {@link merge} for merging two contexts\n *\n * @category combining\n * @since 3.12.0\n */\nexport const mergeAll = (...ctxs) => {\n const map = new Map();\n for (let i = 0; i < ctxs.length; i++) {\n ctxs[i].mapUnsafe.forEach((value, key) => {\n map.set(key, value);\n });\n }\n return makeUnsafe(map);\n};\n/**\n * Returns a new `Context` that contains only the specified services.\n *\n * **When to use**\n *\n * Use when you want to keep an allowlist of services in a `Context`.\n *\n * **Example** (Picking services from a context)\n *\n * ```ts import.meta.vitest\n * import { Context, Option, pipe } from \"effect\"\n *\n * const Port = Context.Service<{ PORT: number }>(\"Port\")\n * const Timeout = Context.Service<{ TIMEOUT: number }>(\"Timeout\")\n *\n * const someContext = pipe(\n * Context.make(Port, { PORT: 8080 }),\n * Context.add(Timeout, { TIMEOUT: 5000 })\n * )\n *\n * const context = pipe(someContext, Context.pick(Port))\n *\n * Context.getOption(context, Port) // => Option.some({ PORT: 8080 })\n * Context.getOption(context, Timeout) // => Option.none()\n * ```\n *\n * @see {@link omit} for removing selected services\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const pick = (...services) => self => {\n const keep = new Set(services.map(key => key.key));\n return withFlat(self, map => map.forEach((_, key) => {\n if (!keep.has(key)) map.delete(key);\n }));\n};\n/**\n * Returns a new `Context` with the specified service keys removed.\n *\n * **When to use**\n *\n * Use when you want to remove a denylist of services from a `Context`.\n *\n * **Example** (Omitting services from a context)\n *\n * ```ts import.meta.vitest\n * import { Context, Option, pipe } from \"effect\"\n *\n * const Port = Context.Service<{ PORT: number }>(\"Port\")\n * const Timeout = Context.Service<{ TIMEOUT: number }>(\"Timeout\")\n *\n * const someContext = pipe(\n * Context.make(Port, { PORT: 8080 }),\n * Context.add(Timeout, { TIMEOUT: 5000 })\n * )\n *\n * const context = pipe(someContext, Context.omit(Timeout))\n *\n * Context.getOption(context, Port) // => Option.some({ PORT: 8080 })\n * Context.getOption(context, Timeout) // => Option.none()\n * ```\n *\n * @see {@link pick} for keeping selected services\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const omit = (...keys) => self => withFlat(self, map => {\n for (let i = 0; i < keys.length; i++) {\n map.delete(keys[i].key);\n }\n});\n/**\n * Creates a context key with a default value.\n *\n * **When to use**\n *\n * Use when you need to define a context key with a lazily computed default\n * value.\n *\n * **Details**\n *\n * `Context.Reference` allows you to create a key that can hold a value. You\n * can provide a default value for the service, which will automatically be used\n * when the context is accessed, or override it with a custom implementation\n * when needed. The default value is computed lazily and cached on the\n * reference.\n *\n * **Example** (Creating references with default values)\n *\n * ```ts import.meta.vitest\n * import { Context } from \"effect\"\n *\n * // Create a reference with a default value\n * const messages: Array = []\n * const LoggerRef = Context.Reference(\"Logger\", {\n * defaultValue: () => ({ log: (msg: string) => messages.push(`Default: ${msg}`) })\n * })\n *\n * // The reference provides the default value when accessed from an empty context\n * const context = Context.empty()\n * const logger = Context.get(context, LoggerRef)\n *\n * // You can also override the default value\n * const customContext = Context.make(LoggerRef, {\n * log: (msg: string) => messages.push(`Custom: ${msg}`)\n * })\n * const customLogger = Context.get(customContext, LoggerRef)\n * logger.log(\"default\")\n * customLogger.log(\"message\")\n * messages // => [\"Default: default\", \"Custom: message\"]\n * ```\n *\n * @see {@link Service} for required services without default values\n *\n * @category services\n * @since 3.11.0\n */\nexport const Reference = Service;\n//# sourceMappingURL=Context.js.map","/**\n * @since 2.0.0\n */\n/** @internal */\nexport const isArrayNonEmpty = self => self.length > 0;\n//# sourceMappingURL=array.js.map","/**\n * Normalizes a collection count to a non-negative integer. `NaN` and\n * non-positive values become `0`; positive infinity is preserved.\n *\n * @internal\n */\nexport const normalize = n => n > 0 ? Math.floor(n) : 0;\n/**\n * Normalizes a collection count to an integer greater than or equal to `1`.\n *\n * @internal\n */\nexport const normalizeNonEmpty = n => Math.max(1, normalize(n));\n//# sourceMappingURL=count.js.map","/**\n * Models a value that has already succeeded or failed.\n *\n * A `Result` is `Success` when a value is available and\n * `Failure` when an error is available. It is plain data, so inspecting\n * or transforming it does not run side effects. This module includes helpers\n * for creating, checking, mapping, combining, and extracting results, plus\n * conversions to and from `Option` and nullable values.\n *\n * @since 4.0.0\n */\nimport * as Equivalence from \"./Equivalence.js\";\nimport { constNull, constUndefined, dual, identity } from \"./Function.js\";\nimport * as doNotation from \"./internal/doNotation.js\";\nimport * as option_ from \"./internal/option.js\";\nimport * as InternalRecord from \"./internal/record.js\";\nimport * as result from \"./internal/result.js\";\nimport { isFunction } from \"./Predicate.js\";\nconst TypeId = \"~effect/Result\";\n/**\n * Creates a `Result` holding a `Success` value.\n *\n * **Details**\n *\n * - Use when you have a value and want to lift it into the `Result` type\n * - The error type `E` defaults to `never`\n *\n * **Example** (Wrapping a value)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.succeed(42) // => Result.succeed(42)\n * ```\n *\n * @see {@link fail} to create a Failure\n * @see {@link void_ void} for a pre-built `Success`\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const succeed = result.succeed;\n/**\n * Creates a `Result` holding a `Failure` value.\n *\n * **When to use**\n *\n * Use to represent a failed `Result` with a typed failure value.\n *\n * **Details**\n *\n * - The success type `A` defaults to `never`\n *\n * **Example** (Creating a failure)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.fail(\"Something went wrong\") // => Result.fail(\"Something went wrong\")\n * ```\n *\n * @see {@link succeed} to create a Success\n * @see {@link mapError} to transform the error\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fail = result.fail;\nconst void_ = /*#__PURE__*/succeed(void 0);\nexport {\n/**\n * Provides a pre-built successful `Result` that carries `undefined`.\n *\n * **When to use**\n *\n * Use when you need a successful `Result` value that signals completion\n * without carrying meaningful data.\n *\n * **Details**\n *\n * This is equivalent to `Result.succeed(undefined)`, but reuses a shared\n * `Success` wrapper instead of allocating one each time.\n *\n * **Example** (Referencing void results)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * const result: Result.Result = Result.void // => Result.succeed(undefined)\n * ```\n *\n * @see {@link succeed} to create a Success with a specific value\n *\n * @category constructors\n * @since 3.13.0\n */\nvoid_ as void };\n/**\n * Provides a pre-built failed `Result` whose failure value is `undefined`.\n *\n * **When to use**\n *\n * Use when you need a failed `Result` value that acts only as a control signal\n * without failure data.\n *\n * **Details**\n *\n * This is equivalent to `Result.fail(undefined)` with type\n * `Result`, but reuses a shared `Failure` wrapper instead of\n * allocating one each time.\n *\n * **Example** (Failing without a payload)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.failVoid // => Result.fail(undefined)\n * ```\n *\n * @see {@link fail} to create a Failure with a specific value\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const failVoid = /*#__PURE__*/fail(void 0);\n/**\n * Converts a possibly `null` or `undefined` value into a `Result`.\n *\n * **When to use**\n *\n * Use when you need `null` or `undefined` input to become a `Failure` while\n * present values remain available as `Success`.\n *\n * **Details**\n *\n * - Non-nullish values become `Success>`\n * - `null` or `undefined` becomes `Failure` using the provided function\n * - Supports both data-first and data-last (piped) usage\n * - The `onNullish` callback receives the original value\n *\n * **Example** (Handling nullable values)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.fromNullishOr(1, () => \"fallback\") // => Result.succeed(1)\n *\n * Result.fromNullishOr(null, () => \"fallback\") // => Result.fail(\"fallback\")\n * ```\n *\n * @see {@link fromOption} to convert from an Option\n * @see {@link succeed} / {@link fail} for direct construction\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromNullishOr = /*#__PURE__*/dual(2, (self, onNullish) => self == null ? fail(onNullish(self)) : succeed(self));\n/**\n * Converts an `Option` into a `Result`.\n *\n * **When to use**\n *\n * Use when an existing `Option` should become a `Result`, preserving `Some` as\n * success and turning `None` into a caller-provided failure.\n *\n * **Details**\n *\n * - `Some` becomes `Success`\n * - `None` becomes `Failure` using the provided function\n * - Supports both data-first and data-last (piped) usage\n *\n * **Example** (Converting an Option to a Result)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Result.fromOption(Option.some(1), () => \"missing\") // => Result.succeed(1)\n *\n * Result.fromOption(Option.none(), () => \"missing\") // => Result.fail(\"missing\")\n * ```\n *\n * @see {@link getSuccess} to extract the success value as an Option\n * @see {@link getFailure} to extract the failure value as an Option\n * @see {@link fromNullishOr} to build a Result from nullable values\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromOption = result.fromOption;\nconst try_ = evaluate => {\n if (isFunction(evaluate)) {\n try {\n return succeed(evaluate());\n } catch (e) {\n return fail(e);\n }\n } else {\n try {\n return succeed(evaluate.try());\n } catch (e) {\n return fail(evaluate.catch(e));\n }\n }\n};\nexport {\n/**\n * Wraps a synchronous computation that may throw into a `Result` safely.\n *\n * **Details**\n *\n * - If the function returns normally, the result is `Success`\n * - If the function throws, the exception is caught and becomes `Failure`\n * - With a single function argument, the error type is `unknown`\n * - With `{ try, catch }` options, the `catch` function maps the thrown value to `E`\n *\n * **Example** (Catching JSON parse errors)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.try(() => JSON.parse('{\"name\": \"Alice\"}')) // => Result.succeed({ name: \"Alice\" })\n *\n * const err = Result.try({\n * try: () => JSON.parse(\"not json\"),\n * catch: (e) => `Parse failed: ${e}`\n * })\n * Result.isFailure(err) // => true\n * ```\n *\n * @see {@link succeed} / {@link fail} for direct construction\n * @see {@link fromNullishOr} for nullable values\n *\n * @category constructors\n * @since 2.0.0\n */\ntry_ as try };\n/**\n * Checks whether a value is a `Result` (either `Success` or `Failure`).\n *\n * **When to use**\n *\n * Use to validate unknown input before operating on it as a `Result`.\n *\n * **Details**\n *\n * - Returns `true` for both `Success` and `Failure` variants\n * - Acts as a TypeScript type guard, narrowing to `Result`\n *\n * **Example** (Checking if a value is a Result)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.isResult(Result.succeed(1)) // => true\n *\n * Result.isResult({ value: 1 }) // => false\n * ```\n *\n * @see {@link isSuccess} / {@link isFailure} to narrow to a specific variant\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isResult = result.isResult;\n/**\n * Checks whether a `Result` is a `Failure`.\n *\n * **When to use**\n *\n * Use to narrow a known `Result` to the `Failure` variant.\n *\n * **Details**\n *\n * - Acts as a TypeScript type guard, narrowing to `Failure`\n * - After narrowing, you can access `.failure` to read the error value\n *\n * **Example** (Narrowing to failure)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * const result = Result.fail(\"oops\")\n *\n * if (Result.isFailure(result)) {\n * result.failure // => \"oops\"\n * }\n * ```\n *\n * @see {@link isSuccess} for the opposite check\n * @see {@link isResult} to check if a value is any Result\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isFailure = result.isFailure;\n/**\n * Checks whether a `Result` is a `Success`.\n *\n * **When to use**\n *\n * Use to narrow a known `Result` to the `Success` variant.\n *\n * **Details**\n *\n * - Acts as a TypeScript type guard, narrowing to `Success`\n * - After narrowing, you can access `.success` to read the value\n *\n * **Example** (Narrowing to success)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * const result = Result.succeed(42)\n *\n * if (Result.isSuccess(result)) {\n * result.success // => 42\n * }\n * ```\n *\n * @see {@link isFailure} for the opposite check\n * @see {@link isResult} to check if a value is any Result\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isSuccess = result.isSuccess;\n/**\n * Extracts the success value as an `Option`, discarding the failure.\n *\n * **When to use**\n *\n * Use when you need to extract the success value from a `Result` as an\n * `Option` and discard failure information.\n *\n * **Details**\n *\n * - `Success` becomes `Some`\n * - `Failure` becomes `None`\n *\n * **Example** (Extracting the success as an Option)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Result.getSuccess(Result.succeed(\"ok\")) // => Option.some(\"ok\")\n *\n * Result.getSuccess(Result.fail(\"err\")) // => Option.none()\n * ```\n *\n * @see {@link getFailure} to extract the error instead\n * @see {@link fromOption} for the reverse conversion\n *\n * @category getters\n * @since 4.0.0\n */\nexport const getSuccess = result.getSuccess;\n/**\n * Extracts the failure value as an `Option`, discarding the success.\n *\n * **When to use**\n *\n * Use when you need to extract the failure value from a `Result` as an\n * `Option` and discard successful values.\n *\n * **Details**\n *\n * - `Failure` becomes `Some`\n * - `Success` becomes `None`\n *\n * **Example** (Extracting the failure as an Option)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Result.getFailure(Result.succeed(\"ok\")) // => Option.none()\n *\n * Result.getFailure(Result.fail(\"err\")) // => Option.some(\"err\")\n * ```\n *\n * @see {@link getSuccess} to extract the success instead\n * @see {@link fromOption} for the reverse conversion\n *\n * @category getters\n * @since 4.0.0\n */\nexport const getFailure = result.getFailure;\n/**\n * Creates an `Equivalence` for comparing two `Result` values.\n *\n * **Details**\n *\n * - Two `Success` values are equal when the `success` equivalence says so\n * - Two `Failure` values are equal when the `failure` equivalence says so\n * - A `Success` and a `Failure` are never equal\n *\n * **Example** (Comparing Results for equality)\n *\n * ```ts import.meta.vitest\n * import { Equivalence, Result } from \"effect\"\n *\n * const eq = Result.makeEquivalence(\n * Equivalence.strictEqual(),\n * Equivalence.strictEqual()\n * )\n *\n * eq(Result.succeed(1), Result.succeed(1)) // => true\n *\n * eq(Result.succeed(1), Result.fail(\"x\")) // => false\n * ```\n *\n * @category instances\n * @since 4.0.0\n */\nexport const makeEquivalence = (success, failure) => Equivalence.make((x, y) => isFailure(x) ? isFailure(y) && failure(x.failure, y.failure) : isSuccess(y) && success(x.success, y.success));\n/**\n * Transforms both the success and failure channels of a `Result`.\n *\n * **When to use**\n *\n * Use to transform both success and failure values without changing whether the\n * result succeeds or fails.\n *\n * **Details**\n *\n * - Applies `onSuccess` if the result is a `Success`\n * - Applies `onFailure` if the result is a `Failure`\n *\n * **Example** (Mapping both channels)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * Result.succeed(1),\n * Result.mapBoth({\n * onSuccess: (n) => n + 1,\n * onFailure: (e) => `Error: ${e}`\n * })\n * ) // => Result.succeed(2)\n * ```\n *\n * @see {@link map} to transform only the success value\n * @see {@link mapError} to transform only the error value\n * @see {@link match} to fold into a single value\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapBoth = /*#__PURE__*/dual(2, (self, {\n onFailure,\n onSuccess\n}) => isFailure(self) ? fail(onFailure(self.failure)) : succeed(onSuccess(self.success)));\n/**\n * Transforms the failure channel of a `Result`, leaving the success channel unchanged.\n *\n * **When to use**\n *\n * Use to transform only the failure channel while preserving success values.\n *\n * **Details**\n *\n * - If the result is a `Failure`, applies `f` to the error and returns a new `Failure`\n * - If the result is a `Success`, returns it as-is\n *\n * **Example** (Adding context to an error)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * Result.fail(\"not found\"),\n * Result.mapError((e) => `Error: ${e}`)\n * ) // => Result.fail(\"Error: not found\")\n * ```\n *\n * @see {@link map} to transform only the success value\n * @see {@link mapBoth} to transform both channels\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapError = /*#__PURE__*/dual(2, (self, f) => isFailure(self) ? fail(f(self.failure)) : self);\n/**\n * Transforms the success channel of a `Result`, leaving the failure channel unchanged.\n *\n * **When to use**\n *\n * Use to apply a transformation to the success value of a `Result` while\n * preserving any existing failure.\n *\n * **Details**\n *\n * - If the result is a `Success`, applies `f` to the value and returns a new `Success`\n * - If the result is a `Failure`, returns it as-is\n * - Use {@link flatMap} if `f` returns a `Result` (to avoid nested Results)\n *\n * **Example** (Doubling the success value)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * Result.succeed(3),\n * Result.map((n) => n * 2)\n * ) // => Result.succeed(6)\n * ```\n *\n * @see {@link mapError} to transform only the error value\n * @see {@link mapBoth} to transform both channels\n * @see {@link flatMap} when `f` returns a `Result`\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, f) => isSuccess(self) ? succeed(f(self.success)) : self);\n/**\n * Folds a `Result` into a single value by applying one of two functions.\n *\n * **When to use**\n *\n * Use when a `Result`'s success and failure branches should be collapsed into\n * one plain output type.\n *\n * **Details**\n *\n * - Applies `onSuccess` if the result is a `Success`\n * - Applies `onFailure` if the result is a `Failure`\n * - Both branches must return the same type (or a common supertype)\n *\n * **Example** (Folding to a string)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * const format = Result.match({\n * onSuccess: (n: number) => `Got ${n}`,\n * onFailure: (e: string) => `Err: ${e}`\n * })\n *\n * format(Result.succeed(42)) // => \"Got 42\"\n *\n * format(Result.fail(\"timeout\")) // => \"Err: timeout\"\n * ```\n *\n * @see {@link merge} to extract `A | E` without mapping\n * @see {@link getOrElse} to unwrap only the success with a fallback\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport const match = /*#__PURE__*/dual(2, (self, {\n onFailure,\n onSuccess\n}) => isFailure(self) ? onFailure(self.failure) : onSuccess(self.success));\n/**\n * Lifts a value into a `Result` based on a predicate or refinement.\n *\n * **When to use**\n *\n * Use to construct a `Result` from a raw value guarded by a predicate or\n * refinement.\n *\n * **Details**\n *\n * - If the predicate returns `true`, the value becomes `Success`\n * - If the predicate returns `false`, `orFailWith` produces the error for `Failure`\n * - Also accepts a `Refinement` to narrow the success type\n * - Supports both data-first and data-last (piped) usage\n *\n * **Example** (Validating a number)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * 5,\n * Result.liftPredicate(\n * (n: number) => n > 0,\n * (n) => `${n} is not positive`\n * )\n * ) // => Result.succeed(5)\n * ```\n *\n * @see {@link filterOrFail} to validate a value that is already in a `Result`\n * @see {@link fromNullishOr} for nullable-based construction\n *\n * @category constructors\n * @since 3.4.0\n */\nexport const liftPredicate = /*#__PURE__*/dual(3, (a, predicate, orFailWith) => predicate(a) ? succeed(a) : fail(orFailWith(a)));\n/**\n * Validates the success value of a `Result` using a predicate, failing with a\n * custom error if the predicate returns `false`.\n *\n * **When to use**\n *\n * Use to validate an already-successful `Result` value with a predicate or\n * refinement.\n *\n * **Details**\n *\n * - If the result is already a `Failure`, it is returned as-is\n * - If the predicate passes, the `Success` is returned unchanged\n * - If the predicate fails, `orFailWith` produces the error for a new `Failure`\n * - Also accepts a `Refinement` to narrow the success type\n * - The error type of the output is the union of both error types\n *\n * **Example** (Filtering a success value)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * Result.succeed(0),\n * Result.filterOrFail(\n * (n) => n > 0,\n * (n) => `${n} is not positive`\n * )\n * ) // => Result.fail(\"0 is not positive\")\n * ```\n *\n * @see {@link liftPredicate} to create a `Result` from a raw value with a predicate\n * @see {@link flatMap} for general conditional chaining\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterOrFail = /*#__PURE__*/dual(3, (self, predicate, orFailWith) => flatMap(self, a => predicate(a) ? succeed(a) : fail(orFailWith(a))));\n/**\n * Unwraps a `Result` into `A | E` by returning the inner value regardless\n * of whether it is a success or failure.\n *\n * **Details**\n *\n * - `Success` returns `A`\n * - `Failure` returns `E`\n * - Useful when both channels share a compatible type\n *\n * **Example** (Extracting the inner value)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.merge(Result.succeed(42)) // => 42\n *\n * Result.merge(Result.fail(\"error\")) // => \"error\"\n * ```\n *\n * @see {@link match} to map each branch to a common type\n * @see {@link getOrElse} to provide a fallback for failures\n *\n * @category getters\n * @since 2.0.0\n */\nexport const merge = /*#__PURE__*/match({\n onFailure: identity,\n onSuccess: identity\n});\n/**\n * Extracts the success value, or computes a fallback from the error.\n *\n * **When to use**\n *\n * Use when you need the success value from a `Result`, with a fallback computed\n * from the failure value.\n *\n * **Details**\n *\n * - `Success` returns the inner value\n * - `Failure` applies `onFailure` to the error and returns the result\n * - The return type is `A | A2` (union of both branches)\n *\n * **Example** (Providing a fallback)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.getOrElse(Result.succeed(1), () => 0) // => 1\n *\n * Result.getOrElse(Result.fail(\"err\"), () => 0) // => 0\n * ```\n *\n * @see {@link getOrNull} / {@link getOrUndefined} for simpler fallbacks\n * @see {@link getOrThrow} to throw on failure\n * @see {@link match} to map both branches\n * @see {@link orElse} to recover with another Result instead of unwrapping\n *\n * @category getters\n * @since 2.0.0\n */\nexport const getOrElse = /*#__PURE__*/dual(2, (self, onFailure) => isFailure(self) ? onFailure(self.failure) : self.success);\n/**\n * Extracts the success value, or returns `null` on failure.\n *\n * **When to use**\n *\n * Use when you need to pass failed `Result` values to APIs that represent\n * absence as `null`.\n *\n * **Details**\n *\n * - `Success` returns `A`\n * - `Failure` returns `null`\n *\n * **Example** (Unwrapping to nullable)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.getOrNull(Result.succeed(1)) // => 1\n *\n * Result.getOrNull(Result.fail(\"err\")) // => null\n * ```\n *\n * @see {@link getOrUndefined} to return `undefined` instead\n * @see {@link getOrElse} for a custom fallback\n *\n * @category getters\n * @since 2.0.0\n */\nexport const getOrNull = /*#__PURE__*/getOrElse(constNull);\n/**\n * Extracts the success value, or returns `undefined` on failure.\n *\n * **When to use**\n *\n * Use when you need to pass failed `Result` values to APIs that represent\n * absence as `undefined`.\n *\n * **Details**\n *\n * - `Success` returns `A`\n * - `Failure` returns `undefined`\n *\n * **Example** (Unwrapping to optional)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.getOrUndefined(Result.succeed(1)) // => 1\n *\n * Result.getOrUndefined(Result.fail(\"err\")) // => undefined\n * ```\n *\n * @see {@link getOrNull} to return `null` instead\n * @see {@link getOrElse} for a custom fallback\n *\n * @category getters\n * @since 2.0.0\n */\nexport const getOrUndefined = /*#__PURE__*/getOrElse(constUndefined);\n/**\n * Extracts the success value or throws a custom error derived from the failure.\n *\n * **When to use**\n *\n * Use when converting a `Result` into a thrown exception with a custom error\n * message or error type.\n *\n * **Details**\n *\n * - `Success` returns `A`\n * - `Failure` throws the value returned by `onFailure(e)`\n *\n * **Example** (Throwing a custom error)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.getOrThrowWith(Result.succeed(1), () => new Error(\"fail\")) // => 1\n *\n * const failure = Result.try({\n * try: () => Result.getOrThrowWith(\n * Result.fail(\"oops\"),\n * (error) => new Error(`Unexpected: ${error}`)\n * ),\n * catch: (error) => (error as Error).message\n * })\n * Result.merge(failure) // => \"Unexpected: oops\"\n * ```\n *\n * @see {@link getOrThrow} to throw the raw failure value\n * @see {@link getOrElse} for a non-throwing alternative\n *\n * @category getters\n * @since 2.0.0\n */\nexport const getOrThrowWith = /*#__PURE__*/dual(2, (self, onFailure) => {\n if (isSuccess(self)) {\n return self.success;\n }\n throw onFailure(self.failure);\n});\n/**\n * Extracts the success value or throws the raw failure value `E`.\n *\n * **When to use**\n *\n * Use when unchecked boundaries should turn failures into thrown exceptions.\n *\n * **Details**\n *\n * - `Success` returns `A`\n * - `Failure` throws `E` directly\n * - Use {@link getOrThrowWith} for a custom error object\n *\n * **Example** (Unwrapping or throwing)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.getOrThrow(Result.succeed(1)) // => 1\n *\n * const failure = Result.try(() => Result.getOrThrow(Result.fail(\"error\")))\n * Result.merge(failure) // => \"error\"\n * ```\n *\n * @see {@link getOrThrowWith} for custom error mapping\n * @see {@link getOrElse} for a non-throwing alternative\n *\n * @category getters\n * @since 2.0.0\n */\nexport const getOrThrow = /*#__PURE__*/getOrThrowWith(identity);\n/**\n * Returns the original `Result` if it is a `Success`, otherwise applies\n * `that` to the error and returns the resulting `Result`.\n *\n * **When to use**\n *\n * Use when a failure should recover into another `Result` while keeping\n * successes unchanged.\n *\n * **Details**\n *\n * - `Success` is returned unchanged\n * - `Failure` calls `that(e)` to produce a new `Result`\n *\n * **Example** (Recovering from a failure)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * Result.fail(\"primary failed\"),\n * Result.orElse(() => Result.succeed(99))\n * ) // => Result.succeed(99)\n * ```\n *\n * @see {@link getOrElse} to unwrap with a fallback value (not a Result)\n * @see {@link mapError} to transform the error without recovering\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const orElse = /*#__PURE__*/dual(2, (self, that) => isFailure(self) ? that(self.failure) : succeed(self.success));\n/**\n * Chains a function that returns a `Result` onto a successful value.\n *\n * **When to use**\n *\n * Use to sequence `Result`-returning computations that should short-circuit on\n * failure.\n *\n * **Details**\n *\n * - If `self` is a `Success`, applies `f` to the value and returns the resulting `Result`\n * - If `self` is a `Failure`, short-circuits and returns it unchanged\n * - The error types are merged into a union (`E | E2`)\n * - This is the monadic `bind` / `>>=` for `Result`\n *\n * **Example** (Validating sequentially)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * Result.succeed(5),\n * Result.flatMap((n) =>\n * n > 0 ? Result.succeed(n * 2) : Result.fail(\"not positive\")\n * )\n * ) // => Result.succeed(10)\n * ```\n *\n * @see {@link andThen} for a more flexible variant that also accepts plain values\n * @see {@link map} when `f` does not return a `Result`\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const flatMap = /*#__PURE__*/dual(2, (self, f) => isFailure(self) ? fail(self.failure) : f(self.success));\n/**\n * Provides a flexible variant of {@link flatMap} that accepts multiple input shapes.\n *\n * **When to use**\n *\n * Use to sequence a next step that may be a `Result`, a function, or a plain\n * value.\n *\n * **Details**\n *\n * The second argument can be:\n * - A function `(a: A) => Result` (same as `flatMap`)\n * - A function `(a: A) => A2` (auto-wrapped in `succeed`)\n * - A `Result` value (ignores the success of `self`)\n * - A plain value `A2` (auto-wrapped in `succeed`, ignores `self`)\n *\n * If `self` is a `Failure`, the second argument is never evaluated.\n *\n * **Example** (Chaining Result values with different argument types)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * // With a function returning a Result\n * const a = pipe(\n * Result.succeed(1),\n * Result.andThen((n) => Result.succeed(n + 1))\n * ) // => Result.succeed(2)\n *\n * // With a plain mapping function\n * const b = pipe(\n * Result.succeed(1),\n * Result.andThen((n) => n + 1)\n * ) // => Result.succeed(2)\n *\n * // With a constant value\n * const c = pipe(Result.succeed(1), Result.andThen(\"done\")) // => Result.succeed(\"done\")\n * ```\n *\n * @see {@link flatMap} for the stricter variant (function returning Result only)\n * @see {@link map} when you always return a plain value\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const andThen = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => {\n const out = isFunction(f) ? f(a) : f;\n return isResult(out) ? out : succeed(out);\n}));\n/**\n * Collects a structure of `Result`s into a single `Result` of collected values.\n *\n * **When to use**\n *\n * Use to collect independent `Result` values into one `Result` while preserving\n * the original structure.\n *\n * **Details**\n *\n * Accepts:\n * - A tuple/array: returns `Result` with a tuple/array of success values\n * - A struct (record): returns `Result` with a struct of success values\n * - An iterable: returns `Result` with an array of success values\n *\n * Short-circuits on the first `Failure` encountered; later elements are not inspected.\n *\n * **Example** (Collecting a tuple and a struct)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * // Tuple\n * Result.all([Result.succeed(1), Result.succeed(\"two\")]) // => Result.succeed([1, \"two\"])\n *\n * // Struct\n * Result.all({ x: Result.succeed(1), y: Result.fail(\"err\") }) // => Result.fail(\"err\")\n * ```\n *\n * @see {@link flatMap} for chaining two Results sequentially\n * @see {@link gen} for generator-based composition of multiple Results\n *\n * @category sequencing\n * @since 2.0.0\n */\n// @ts-expect-error\nexport const all = input => {\n if (Symbol.iterator in input) {\n const out = [];\n for (const e of input) {\n if (isFailure(e)) {\n return e;\n }\n out.push(e.success);\n }\n return succeed(out);\n }\n const out = {};\n for (const key of Object.keys(input)) {\n const e = input[key];\n if (isFailure(e)) {\n return e;\n }\n InternalRecord.assignProperty(out, key, e.success);\n }\n return succeed(out);\n};\n/**\n * Swaps the success and failure channels of a `Result`.\n *\n * **When to use**\n *\n * Use to swap channels when failure-focused operations are easier through\n * success-oriented combinators.\n *\n * **Details**\n *\n * - `Success` becomes `Failure` (i.e., `Result`)\n * - `Failure` becomes `Success` (i.e., `Result`)\n * - Useful when you want to apply success-oriented operations (like `map`)\n * to the error channel, then flip back\n *\n * **Example** (Swapping channels)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.flip(Result.succeed(42)) // => Result.fail(42)\n *\n * Result.flip(Result.fail(\"error\")) // => Result.succeed(\"error\")\n * ```\n *\n * @see {@link mapError} to transform the error without swapping\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const flip = self => isFailure(self) ? succeed(self.failure) : fail(self.success);\n/**\n * Provides generator-based syntax for composing `Result` values sequentially.\n *\n * **When to use**\n *\n * Use when you need generator syntax to compose sequential `Result`\n * computations instead of nested `flatMap` calls.\n *\n * **Details**\n *\n * - Use `yield*` to unwrap a `Result` inside the generator; if any yielded\n * `Result` is a `Failure`, the generator short-circuits and returns that failure\n * - The return value of the generator is wrapped in `Success`\n * - Evaluated eagerly and synchronously (unlike `Effect.gen`)\n *\n * **Example** (Composing multiple Results)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n *\n * Result.gen(function*() {\n * const a = yield* Result.succeed(1)\n * const b = yield* Result.succeed(2)\n * return a + b\n * }) // => Result.succeed(3)\n * ```\n *\n * @see {@link flatMap} for point-free sequential composition\n * @see {@link all} to collect multiple independent Results\n *\n * @category generators\n * @since 2.0.0\n */\nexport const gen = (...args) => {\n const f = args.length === 1 ? args[0] : args[1].bind(args[0]);\n const iterator = f();\n let state = iterator.next();\n while (!state.done) {\n const current = state.value;\n if (isFailure(current)) {\n return current;\n }\n state = iterator.next(current.success);\n }\n return succeed(state.value);\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * Provides the starting point for the \"do notation\" simulation with `Result`.\n *\n * **When to use**\n *\n * Use to start a `Result` do-notation pipeline from an empty successful record\n * before adding named fields from `Result`-producing computations and pure\n * computed values.\n *\n * **Details**\n *\n * Creates a `Result<{}>` (success with an empty object). Use with\n * {@link bind} to add `Result`-producing fields and {@link let_ let}\n * to add pure computed fields.\n *\n * **Example** (Building an object step by step)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * Result.Do,\n * Result.bind(\"x\", () => Result.succeed(2)),\n * Result.bind(\"y\", () => Result.succeed(3)),\n * Result.let(\"sum\", ({ x, y }) => x + y)\n * ) // => Result.succeed({ x: 2, y: 3, sum: 5 })\n * ```\n *\n * @see {@link bind} to add Result-producing fields\n * @see {@link let_ let} to add pure computed fields\n * @see {@link gen} for an alternative generator-based syntax\n * @see {@link bindTo} for starting a do-notation chain from an existing Result\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const Do = /*#__PURE__*/succeed({});\n/**\n * Adds a named field to the do-notation accumulator by running a `Result`-producing\n * function that receives the current accumulated object.\n *\n * **When to use**\n *\n * Use when you need to add a `Result`-producing step to a `Result`\n * do-notation pipeline and store its successful value under a named field in\n * the accumulated object.\n *\n * **Details**\n *\n * - Short-circuits on the first `Failure`\n * - The field name must not collide with existing keys\n * - Use {@link let_ let} for pure (non-Result) computed fields\n *\n * **Example** (Binding Result values)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * Result.Do,\n * Result.bind(\"x\", () => Result.succeed(2)),\n * Result.bind(\"y\", ({ x }) => Result.succeed(x + 3))\n * ) // => Result.succeed({ x: 2, y: 5 })\n * ```\n *\n * @see {@link Do} to start the do-notation chain\n * @see {@link let_ let} for pure computed fields\n * @see {@link bindTo} to wrap an initial Result into a named field\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const bind = /*#__PURE__*/doNotation.bind(map, flatMap);\n/**\n * Wraps the success value of a `Result` into a named field, producing a\n * `Result>`.\n *\n * **When to use**\n *\n * Use to name the success value of an existing `Result` before continuing a\n * do-notation pipeline.\n *\n * **Details**\n *\n * This is typically used to start a do-notation chain from an existing\n * `Result`.\n *\n * **Example** (Wrapping a value into a named field)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * Result.succeed(42),\n * Result.bindTo(\"answer\")\n * ) // => Result.succeed({ answer: 42 })\n * ```\n *\n * @see {@link Do} to start from an empty object\n * @see {@link bind} to add more fields\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const bindTo = /*#__PURE__*/doNotation.bindTo(map);\nconst let_ = /*#__PURE__*/doNotation.let_(map);\nexport {\n/**\n * Adds a named field to the do-notation accumulator by computing a pure\n * (non-Result) value from the current accumulated object.\n *\n * **When to use**\n *\n * Use when you need to add a derived field that cannot fail inside a\n * do-notation pipeline.\n *\n * **Details**\n *\n * - Use {@link bind} when the computation returns a `Result`\n * - The field name must not collide with existing keys\n *\n * **Example** (Adding a computed field)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * pipe(\n * Result.Do,\n * Result.bind(\"x\", () => Result.succeed(2)),\n * Result.bind(\"y\", () => Result.succeed(3)),\n * Result.let(\"sum\", ({ x, y }) => x + y)\n * ) // => Result.succeed({ x: 2, y: 3, sum: 5 })\n * ```\n *\n * @see {@link Do} to start the do-notation chain\n * @see {@link bind} for Result-producing fields\n *\n * @category mapping\n * @since 2.0.0\n */\nlet_ as let };\n/**\n * Transforms `Option>` into `Result, E>`.\n *\n * **When to use**\n *\n * Use when optional absence should be treated as a successful `None`, while an\n * inner `Result` failure should still fail the whole result.\n *\n * **Details**\n *\n * - `None` becomes `Success(None)`\n * - `Some(Success(a))` becomes `Success(Some(a))`\n * - `Some(Failure(e))` becomes `Failure(e)`\n *\n * **Example** (Transposing an Option of a Result)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Result.transposeOption(Option.some(Result.succeed(42))) // => Result.succeed(Option.some(42))\n *\n * Result.transposeOption(Option.none>()) // => Result.succeed(Option.none())\n * ```\n *\n * @see {@link transposeMapOption} to map and transpose in one step\n *\n * @category transposing\n * @since 3.14.0\n */\nexport const transposeOption = self => {\n return option_.isNone(self) ? succeedNone : map(self.value, option_.some);\n};\n/**\n * Maps an `Option` value with a `Result`-producing function, then transposes\n * the structure from `Option>` to `Result, E>`.\n *\n * **When to use**\n *\n * Use when an optional value should be validated only when present, preserving\n * absence as a successful `None`.\n *\n * **Details**\n *\n * - `None` becomes `Success(None)` (the function is never called)\n * - `Some(a)` where `f(a)` is `Success(b)` becomes `Success(Some(b))`\n * - `Some(a)` where `f(a)` is `Failure(e)` becomes `Failure(e)`\n *\n * **Example** (Mapping and transposing in one step)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * const parse = (s: string) =>\n * isNaN(Number(s))\n * ? Result.fail(\"not a number\" as const)\n * : Result.succeed(Number(s))\n *\n * Result.transposeMapOption(Option.some(\"42\"), parse) // => Result.succeed(Option.some(42))\n *\n * Result.transposeMapOption(Option.none(), parse) // => Result.succeed(Option.none())\n * ```\n *\n * @see {@link transposeOption} when the Option already contains a Result\n *\n * @category transposing\n * @since 3.15.0\n */\nexport const transposeMapOption = /*#__PURE__*/dual(2, (self, f) => option_.isNone(self) ? succeedNone : map(f(self.value), option_.some));\n/**\n * Provides a pre-built `Result>` that succeeds with `None`.\n *\n * **When to use**\n *\n * Use when an optional success should be absent, such as the `None` branch of\n * `transposeOption` or `transposeMapOption`.\n *\n * **Details**\n *\n * This is equivalent to `Result.succeed(Option.none())`, but reuses a shared\n * `Success` wrapper instead of allocating one each time.\n *\n * **Example** (Succeeding with None)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Result.succeedNone // => Result.succeed(Option.none())\n * ```\n *\n * @see {@link succeedSome} for the `Some` counterpart\n * @see {@link transposeOption} to transpose an Option that already contains a Result\n * @see {@link transposeMapOption} to map and transpose an Option in one step\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const succeedNone = /*#__PURE__*/succeed(option_.none);\n/**\n * Creates a `Result>` that succeeds with `Some(a)`.\n *\n * **Details**\n *\n * - Equivalent to `Result.succeed(Option.some(a))`\n * - Useful with {@link transposeOption} patterns\n *\n * **Example** (Wrapping a value in Some inside a Result)\n *\n * ```ts import.meta.vitest\n * import { Option, Result } from \"effect\"\n *\n * Result.succeedSome(42) // => Result.succeed(Option.some(42))\n * ```\n *\n * @see {@link succeedNone} for the `None` counterpart\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const succeedSome = a => succeed(option_.some(a));\n/**\n * Runs a side-effect on the success value without altering the `Result`.\n *\n * **Details**\n *\n * - If the result is a `Success`, calls `f` with the value (return value is ignored)\n * - If the result is a `Failure`, `f` is not called\n * - Returns the original `Result` unchanged (same reference)\n * - Useful for logging, debugging, or performing mutations outside the Result chain\n *\n * **Example** (Logging a success value)\n *\n * ```ts import.meta.vitest\n * import { pipe, Result } from \"effect\"\n *\n * const values: Array = []\n * const result = pipe(\n * Result.succeed(42),\n * Result.tap((n) => values.push(n))\n * )\n *\n * values // => [42]\n * result // => Result.succeed(42)\n * ```\n *\n * @see {@link map} to transform the success value\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const tap = /*#__PURE__*/dual(2, (self, f) => {\n if (isSuccess(self)) {\n f(self.success);\n }\n return self;\n});\n//# sourceMappingURL=Result.js.map","/**\n * Works with fixed-length arrays, also called tuples.\n *\n * The runtime helpers in this module create new tuples instead of mutating\n * their inputs, and the types preserve element positions where possible. The\n * helpers cover tuple construction, indexed access, selecting or removing\n * positions, appending values, transforming elements, renaming indices, mapping\n * typed positions, and deriving comparison or combination helpers for tuple\n * shapes.\n *\n * @since 2.0.0\n */\nimport * as Combiner from \"./Combiner.js\";\nimport * as Equivalence from \"./Equivalence.js\";\nimport { dual } from \"./Function.js\";\nimport * as order from \"./Order.js\";\nimport * as Reducer from \"./Reducer.js\";\n/**\n * Creates a tuple from the provided arguments.\n *\n * **When to use**\n *\n * Use when you need a properly typed tuple without writing `[a, b, c] as const`\n * or another manual cast.\n *\n * **Details**\n *\n * The returned value has the exact tuple type, with each element's literal type\n * preserved.\n *\n * **Example** (Creating a tuple)\n *\n * ```ts import.meta.vitest\n * import { Tuple } from \"effect\"\n *\n * Tuple.make(10, 20, \"red\") // => [10, 20, \"red\"]\n * ```\n *\n * @see {@link get} – access a single element by index\n * @see {@link appendElement} – append an element to a tuple\n * @category constructors\n * @since 2.0.0\n */\nexport const make = (...elements) => elements;\n/**\n * Retrieves the element at the specified index from a tuple.\n *\n * **When to use**\n *\n * Use when a single tuple element should be extracted in a pipeline.\n *\n * **Details**\n *\n * The index is constrained to valid tuple positions at the type level.\n *\n * **Example** (Extracting an element by index)\n *\n * ```ts import.meta.vitest\n * import { pipe, Tuple } from \"effect\"\n *\n * pipe(Tuple.make(1, true, \"hello\"), Tuple.get(2)) // => \"hello\"\n * ```\n *\n * @see {@link make} – create a tuple\n * @see {@link pick} – extract multiple elements into a new tuple\n * @category getters\n * @since 4.0.0\n */\nexport const get = /*#__PURE__*/dual(2, (self, index) => self[index]);\n/**\n * Creates a new tuple containing only the elements at the specified indices.\n *\n * **When to use**\n *\n * Use to select a subset of elements from a tuple by position.\n *\n * **Details**\n *\n * The result order matches the order of the provided indices.\n *\n * **Example** (Selecting elements by index)\n *\n * ```ts import.meta.vitest\n * import { Tuple } from \"effect\"\n *\n * Tuple.pick([\"a\", \"b\", \"c\", \"d\"], [0, 2, 3]) // => [\"a\", \"c\", \"d\"]\n * ```\n *\n * @see {@link omit} – the inverse (exclude indices instead)\n * @see {@link get} – extract a single element\n * @category filtering\n * @since 4.0.0\n */\nexport const pick = /*#__PURE__*/dual(2, (self, indices) => {\n return indices.map(i => self[i]);\n});\n/**\n * Creates a new tuple with the elements at the specified indices removed.\n *\n * **When to use**\n *\n * Use to drop elements from a tuple by position.\n *\n * **Details**\n *\n * Elements not at the specified indices are kept in their original order.\n *\n * **Example** (Removing elements by index)\n *\n * ```ts import.meta.vitest\n * import { Tuple } from \"effect\"\n *\n * Tuple.omit([\"a\", \"b\", \"c\", \"d\"], [1, 3]) // => [\"a\", \"c\"]\n * ```\n *\n * @see {@link pick} – the inverse (keep only specified indices)\n * @category filtering\n * @since 4.0.0\n */\nexport const omit = /*#__PURE__*/dual(2, (self, indices) => {\n const toDrop = new Set(indices);\n return self.filter((_, i) => !toDrop.has(i));\n});\n/**\n * Appends a single element to the end of a tuple.\n *\n * **When to use**\n *\n * Use when you need the appended value to remain part of the tuple's type-level\n * shape and preserve literal element positions.\n *\n * **Details**\n *\n * The result type is `[...T, E]`, preserving all existing element types.\n *\n * **Example** (Appending an element)\n *\n * ```ts import.meta.vitest\n * import { pipe, Tuple } from \"effect\"\n *\n * pipe(Tuple.make(1, 2), Tuple.appendElement(\"end\")) // => [1, 2, \"end\"]\n * ```\n *\n * @see {@link appendElements} – append multiple elements (another tuple)\n * @category combining\n * @since 2.0.0\n */\nexport const appendElement = /*#__PURE__*/dual(2, (self, element) => [...self, element]);\n/**\n * Concatenates two tuples into a single tuple.\n *\n * **When to use**\n *\n * Use to append all elements from one tuple to another tuple.\n *\n * **Details**\n *\n * The result type is `[...T1, ...T2]`, preserving all element types from both\n * tuples. Neither input tuple is mutated; a fresh tuple is returned.\n *\n * **Example** (Concatenating tuples)\n *\n * ```ts import.meta.vitest\n * import { pipe, Tuple } from \"effect\"\n *\n * pipe(Tuple.make(1, 2), Tuple.appendElements([\"a\", \"b\"] as const)) // => [1, 2, \"a\", \"b\"]\n * ```\n *\n * @see {@link appendElement} – append a single element\n * @category combining\n * @since 4.0.0\n */\nexport const appendElements = /*#__PURE__*/dual(2, (self, that) => [...self, ...that]);\n/**\n * Transforms elements of a tuple by providing an array of transform functions.\n * Each function applies to the element at the same position. Positions beyond\n * the array's length are copied unchanged.\n *\n * **When to use**\n *\n * Use when you want to update the first N elements while keeping the rest.\n *\n * **Details**\n *\n * Each transform function receives the current value and can return a different\n * type.\n *\n * **Example** (Transforming selected elements)\n *\n * ```ts import.meta.vitest\n * import { pipe, Tuple } from \"effect\"\n *\n * pipe(\n * Tuple.make(\"hello\", 42, true),\n * Tuple.evolve([\n * (s) => s.toUpperCase(),\n * (n) => n * 2\n * ])\n * ) // => [\"HELLO\", 84, true]\n * ```\n *\n * @see {@link map} – apply the same transformation to all elements\n * @see {@link renameIndices} – swap element positions\n * @category mapping\n * @since 4.0.0\n */\nexport const evolve = /*#__PURE__*/dual(2, (self, evolver) => {\n return self.map((e, i) => evolver[i] !== undefined ? evolver[i](e) : e);\n});\n/**\n * Renames tuple indices by providing an array of stringified source\n * indices. Each position in the array specifies which index to read from\n * (e.g., `[\"2\", \"1\", \"0\"]` reverses a 3-element tuple).\n *\n * **When to use**\n *\n * Use to reorder tuple elements while preserving index-specific types.\n *\n * **Details**\n *\n * The mapping returns a tuple in the requested index order.\n *\n * **Gotchas**\n *\n * The mapping uses stringified source indices, not arbitrary names.\n *\n * **Example** (Swapping elements)\n *\n * ```ts import.meta.vitest\n * import { pipe, Tuple } from \"effect\"\n *\n * pipe(\n * Tuple.make(\"a\", \"b\", \"c\"),\n * Tuple.renameIndices([\"2\", \"1\", \"0\"])\n * ) // => [\"c\", \"b\", \"a\"]\n * ```\n *\n * @see {@link evolve} – transform element values instead of positions\n * @category transforming\n * @since 4.0.0\n */\nexport const renameIndices = /*#__PURE__*/dual(2, (self, mapping) => {\n return self.map((e, i) => mapping[i] !== undefined ? self[mapping[i]] : e);\n});\n/**\n * Applies a `Struct.Lambda` transformation to every element in a tuple.\n *\n * **When to use**\n *\n * Use when you want to apply the same transformation to every tuple element.\n *\n * **Details**\n *\n * The lambda lets the compiler track the output type for each element.\n *\n * **Gotchas**\n *\n * The lambda must be created with `Struct.lambda`; a plain function will not\n * type-check.\n *\n * **Example** (Wrapping every element in an array)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct, Tuple } from \"effect\"\n *\n * interface AsArray extends Struct.Lambda {\n * (self: A): Array\n * readonly \"~lambda.out\": Array\n * }\n *\n * const asArray = Struct.lambda((a) => [a])\n * pipe(Tuple.make(1, \"hello\", true), Tuple.map(asArray)) // => [[1], [\"hello\"], [true]]\n * ```\n *\n * @see {@link mapPick} – apply a lambda only to selected indices\n * @see {@link mapOmit} – apply a lambda to all indices except selected ones\n * @see {@link evolve} – apply different functions to different indices\n * @category mapping\n * @since 3.9.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, lambda) => {\n return self.map(e => lambda(e));\n});\n/**\n * Applies a `Struct.Lambda` transformation only to the elements at the\n * specified indices; all other elements are copied unchanged.\n *\n * **When to use**\n *\n * Use when you want to apply the same transformation to a subset of\n * positions.\n *\n * **Example** (Wrapping only selected elements in arrays)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct, Tuple } from \"effect\"\n *\n * interface AsArray extends Struct.Lambda {\n * (self: A): Array\n * readonly \"~lambda.out\": Array\n * }\n *\n * const asArray = Struct.lambda((a) => [a])\n * pipe(\n * Tuple.make(1, \"hello\", true),\n * Tuple.mapPick([0, 2], asArray)\n * ) // => [[1], \"hello\", [true]]\n * ```\n *\n * @see {@link map} – apply a lambda to all elements\n * @see {@link mapOmit} – apply a lambda to all elements except selected ones\n * @category mapping\n * @since 4.0.0\n */\nexport const mapPick = /*#__PURE__*/dual(3, (self, indices, lambda) => {\n const toPick = new Set(indices);\n return self.map((e, i) => toPick.has(i) ? lambda(e) : e);\n});\n/**\n * Applies a `Struct.Lambda` transformation to all elements except those at the\n * specified indices; the excluded elements are copied unchanged.\n *\n * **When to use**\n *\n * Use when most elements should be transformed but a few should be\n * preserved.\n *\n * **Example** (Wrapping all elements except one in arrays)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct, Tuple } from \"effect\"\n *\n * interface AsArray extends Struct.Lambda {\n * (self: A): Array\n * readonly \"~lambda.out\": Array\n * }\n *\n * const asArray = Struct.lambda((a) => [a])\n * pipe(\n * Tuple.make(1, \"hello\", true),\n * Tuple.mapOmit([1], asArray)\n * ) // => [[1], \"hello\", [true]]\n * ```\n *\n * @see {@link map} – apply a lambda to all elements\n * @see {@link mapPick} – apply a lambda only to selected indices\n * @category mapping\n * @since 4.0.0\n */\nexport const mapOmit = /*#__PURE__*/dual(3, (self, indices, lambda) => {\n const toOmit = new Set(indices);\n return self.map((e, i) => toOmit.has(i) ? e : lambda(e));\n});\n/**\n * Creates an `Equivalence` for tuples by comparing corresponding elements\n * using the provided per-position `Equivalence`s. Two tuples are equivalent\n * when all their corresponding elements are equivalent.\n *\n * **When to use**\n *\n * Use when you need an `Equivalence` to compare tuples element-by-element.\n *\n * **Details**\n *\n * This is an alias of `Equivalence.Tuple`.\n *\n * **Example** (Comparing tuples for equivalence)\n *\n * ```ts import.meta.vitest\n * import { Equivalence, Tuple } from \"effect\"\n *\n * const eq = Tuple.makeEquivalence([\n * Equivalence.strictEqual(),\n * Equivalence.strictEqual()\n * ])\n *\n * eq([\"Alice\", 30], [\"Alice\", 30]) // => true\n * eq([\"Alice\", 30], [\"Bob\", 30]) // => false\n * ```\n *\n * @see {@link makeOrder} – create an `Order` for tuples\n * @category instances\n * @since 4.0.0\n */\nexport const makeEquivalence = Equivalence.Tuple;\n/**\n * Creates an `Order` for tuples by comparing corresponding elements using the\n * provided per-position `Order`s. Elements are compared left-to-right; the\n * first non-zero comparison determines the result.\n *\n * **When to use**\n *\n * Use when you need to sort fixed-position arrays lexicographically, with each\n * position using its own ordering rule.\n *\n * **Details**\n *\n * This is an alias of `Order.Tuple`.\n *\n * **Example** (Ordering tuples)\n *\n * ```ts import.meta.vitest\n * import { Number, String, Tuple } from \"effect\"\n *\n * const ord = Tuple.makeOrder([String.Order, Number.Order])\n *\n * ord([\"Alice\", 30], [\"Bob\", 25]) // => -1\n * ord([\"Alice\", 30], [\"Alice\", 30]) // => 0\n * ```\n *\n * @see {@link makeEquivalence} – create an `Equivalence` for tuples\n * @category ordering\n * @since 4.0.0\n */\nexport const makeOrder = order.Tuple;\nexport {\n/**\n * Checks whether an array has exactly `N` elements, narrowing the type to a\n * fixed-length tuple.\n *\n * **When to use**\n *\n * Use to guard that an array has exactly the tuple length expected at\n * runtime.\n *\n * **Details**\n *\n * This is a re-export of `Predicate.isTupleOf`. It narrows the type to\n * `TupleOf` in the truthy branch.\n *\n * **Gotchas**\n *\n * This only checks `.length`; it does not validate element types.\n *\n * **Example** (Checking exact length)\n *\n * ```ts import.meta.vitest\n * import { Tuple } from \"effect\"\n *\n * const arr: Array = [1, 2, 3]\n * if (Tuple.isTupleOf(arr, 3)) {\n * arr // => [1, 2, 3]\n * }\n * ```\n *\n * @see `isTupleOfAtLeast` – check for a minimum length\n * @category guards\n * @since 3.3.0\n */\nisTupleOf,\n/**\n * Checks whether an array has at least `N` elements, narrowing the type to a\n * tuple with a minimum length.\n *\n * **When to use**\n *\n * Use to guard that an array has at least the tuple length expected at\n * runtime.\n *\n * **Details**\n *\n * This is a re-export of `Predicate.isTupleOfAtLeast`. It narrows the type to\n * `TupleOfAtLeast` in the truthy branch.\n *\n * **Gotchas**\n *\n * This only checks `.length`; it does not validate element types.\n *\n * **Example** (Checking minimum length)\n *\n * ```ts import.meta.vitest\n * import { Tuple } from \"effect\"\n *\n * const arr: Array = [1, 2, 3, 4]\n * if (Tuple.isTupleOfAtLeast(arr, 3)) {\n * arr // => [1, 2, 3, 4]\n * }\n * ```\n *\n * @see `isTupleOf` – check for an exact length\n * @category guards\n * @since 3.3.0\n */\nisTupleOfAtLeast } from \"./Predicate.js\";\n/**\n * Creates a `Combiner` for a tuple shape by providing a `Combiner` for each\n * position. When two tuples are combined, each element is merged using its\n * corresponding combiner.\n *\n * **When to use**\n *\n * Use when you need to merge two same-shape tuples by combining each position\n * independently, such as summing counters or concatenating strings.\n *\n * **Example** (Combining tuple elements)\n *\n * ```ts import.meta.vitest\n * import { Number, String, Tuple } from \"effect\"\n *\n * const C = Tuple.makeCombiner([\n * Number.ReducerSum,\n * String.ReducerConcat\n * ])\n *\n * C.combine([1, \"hello\"], [2, \" world\"]) // => [3, \"hello world\"]\n * ```\n *\n * @see {@link makeReducer} – like `makeCombiner` but with an initial value\n * @category combining\n * @since 4.0.0\n */\nexport function makeCombiner(combiners) {\n return Combiner.make((self, that) => {\n const out = [];\n for (let i = 0; i < self.length; i++) {\n out.push(combiners[i].combine(self[i], that[i]));\n }\n return out;\n });\n}\n/**\n * Creates a `Reducer` for a tuple shape by providing a `Reducer` for each\n * position. The initial value is derived from each position's\n * `Reducer.initialValue`. When reducing a collection of tuples, each element\n * is combined independently.\n *\n * **When to use**\n *\n * Use when you need to fold same-shape tuples by accumulating each position\n * independently into one summary tuple.\n *\n * **Example** (Reducing a collection of tuples)\n *\n * ```ts import.meta.vitest\n * import { Number, String, Tuple } from \"effect\"\n *\n * const R = Tuple.makeReducer([\n * Number.ReducerSum,\n * String.ReducerConcat\n * ])\n *\n * R.combineAll([\n * [1, \"a\"],\n * [2, \"b\"],\n * [3, \"c\"]\n * ]) // => [6, \"abc\"]\n * ```\n *\n * @see {@link makeCombiner} – like `makeReducer` but without an initial value\n * @category folding\n * @since 4.0.0\n */\nexport function makeReducer(reducers) {\n const combine = makeCombiner(reducers).combine;\n const initialValue = [];\n for (let i = 0; i < reducers.length; i++) {\n initialValue.push(reducers[i].initialValue);\n }\n return Reducer.make(combine, initialValue);\n}\n//# sourceMappingURL=Tuple.js.map","/**\n * Works with plain JavaScript records as immutable key/value dictionaries.\n *\n * A record is an object whose keys are strings or symbols. This module includes\n * helpers for construction, lookup, updates, mapping, filtering, folding,\n * set-like combination, and typed conversions between records and iterable\n * entries. Helpers that change values return new records instead of mutating the\n * input.\n *\n * @since 2.0.0\n */\nimport * as Equal from \"./Equal.js\";\nimport { dual, identity } from \"./Function.js\";\nimport * as InternalRecord from \"./internal/record.js\";\nimport * as Option from \"./Option.js\";\nimport * as Reducer from \"./Reducer.js\";\nimport * as R from \"./Result.js\";\n/**\n * Creates a new, empty record.\n *\n * **Example** (Creating an empty record)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * // Create an empty record\n * const emptyRecord = Record.empty()\n * emptyRecord // => {}\n *\n * // The type ensures type safety for future operations\n * Record.set(emptyRecord, \"count\", 42) // => { count: 42 }\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const empty = () => ({});\n/**\n * Determines if a mutable record is empty.\n *\n * **Example** (Checking for an empty record)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.isEmptyRecord({}) // => true\n * Record.isEmptyRecord({ a: 3 }) // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isEmptyRecord = self => Object.keys(self).length === 0;\n/**\n * Determines if a readonly record is empty.\n *\n * **Example** (Checking for an empty readonly record)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.isEmptyReadonlyRecord({}) // => true\n * Record.isEmptyReadonlyRecord({ a: 3 }) // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isEmptyReadonlyRecord = isEmptyRecord;\n/**\n * Takes an iterable and a projection function and returns a record.\n * The projection function maps each value of the iterable to a tuple of a key and a value, which is then added to the resulting record.\n *\n * **Example** (Building a record from mapped iterable values)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.fromIterableWith([1, 2, 3, 4], (a) => [String(a), a * 2]) // => { \"1\": 2, \"2\": 4, \"3\": 6, \"4\": 8 }\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromIterableWith = /*#__PURE__*/dual(2, (self, f) => {\n const out = empty();\n for (const a of self) {\n const [k, b] = f(a);\n InternalRecord.assignProperty(out, k, b);\n }\n return out;\n});\n/**\n * Creates a new record from an iterable, utilizing the provided function to determine the key for each element.\n *\n * **Example** (Building a record keyed by iterable values)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * const users = [\n * { id: \"2\", name: \"name2\" },\n * { id: \"1\", name: \"name1\" }\n * ]\n *\n * Record.fromIterableBy(\n * users,\n * (user) => user.id\n * ) // => { \"1\": { id: \"1\", name: \"name1\" }, \"2\": { id: \"2\", name: \"name2\" } }\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromIterableBy = /*#__PURE__*/dual(2, (items, f) => fromIterableWith(items, a => [f(a), a]));\n/**\n * Builds a record from an iterable of key-value pairs.\n *\n * **Details**\n *\n * If there are conflicting keys when using `fromEntries`, the last occurrence of the key/value pair will overwrite the\n * previous ones. So the resulting record will only have the value of the last occurrence of each key.\n *\n * **Example** (Building a record from entries)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.fromEntries([[\"a\", 1], [\"b\", 2]]) // => { a: 1, b: 2 }\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromEntries = Object.fromEntries;\n/**\n * Transforms the values of a record into an `Array` with a custom mapping function.\n *\n * **Example** (Collecting mapped record values)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * const x = { a: 1, b: 2, c: 3 }\n * Record.collect(x, (key, n) => [key, n]) // => [[\"a\", 1], [\"b\", 2], [\"c\", 3]]\n * ```\n *\n * @category converting\n * @since 2.0.0\n */\nexport const collect = /*#__PURE__*/dual(2, (self, f) => {\n const out = [];\n for (const key of keys(self)) {\n out.push(f(key, self[key]));\n }\n return out;\n});\n/**\n * Takes a record and returns an array of tuples containing its keys and values.\n *\n * **Example** (Converting a record to entries)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * const x = { a: 1, b: 2, c: 3 }\n * Record.toEntries(x) // => [[\"a\", 1], [\"b\", 2], [\"c\", 3]]\n * ```\n *\n * @category converting\n * @since 2.0.0\n */\nexport const toEntries = /*#__PURE__*/collect((key, value) => [key, value]);\n/**\n * Returns the number of key/value pairs in a record.\n *\n * **Example** (Getting the record size)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.size({ a: \"a\", b: 1, c: true }) // => 3\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const size = self => keys(self).length;\n/**\n * Checks whether a given `key` exists in a record.\n *\n * **Example** (Checking key membership)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.has({ a: 1, b: 2 }, \"a\") // => true\n * Record.has(Record.empty(), \"c\") // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const has = /*#__PURE__*/dual(2, (self, key) => Object.hasOwn(self, key));\n/**\n * Retrieves a value at a particular key from a record safely, returning it wrapped in an `Option`.\n *\n * **Example** (Getting a value as an Option)\n *\n * ```ts import.meta.vitest\n * import { Option, Record as R } from \"effect\"\n *\n * const person: Record = { name: \"John Doe\", age: 35 }\n *\n * R.get(person, \"name\") // => Option.some(\"John Doe\")\n * R.get(person, \"email\") // => Option.none()\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const get = /*#__PURE__*/dual(2, (self, key) => Object.hasOwn(self, key) ? Option.some(self[key]) : Option.none());\n/**\n * Applies a function to the element at the specified key safely, creating a new record,\n * or return `Option.none()` if the key doesn't exist.\n *\n * **Example** (Modifying a value at a key)\n *\n * ```ts import.meta.vitest\n * import { Option, Record } from \"effect\"\n *\n * const f = (x: number) => x * 2\n *\n * const input: Record = { a: 3 }\n *\n * Record.modify(input, \"a\", f) // => Option.some({ a: 6 })\n * Record.modify(input, \"b\", f) // => Option.none()\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const modify = /*#__PURE__*/dual(3, (self, key, f) => {\n if (!has(self, key)) return Option.none();\n return Option.some({\n ...self,\n [key]: f(self[key])\n });\n});\n/**\n * Replaces the value at an existing key safely and returns the updated record in\n * `Option.some`.\n *\n * **Details**\n *\n * If the key is not present, returns `Option.none()` and leaves the record\n * unchanged.\n *\n * **Example** (Replacing a value at a key)\n *\n * ```ts import.meta.vitest\n * import { Option, Record } from \"effect\"\n *\n * Record.replace({ a: 1, b: 2, c: 3 }, \"a\", 10) // => Option.some({ a: 10, b: 2, c: 3 })\n * Record.replace(Record.empty(), \"a\", 10) // => Option.none()\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const replace = /*#__PURE__*/dual(3, (self, key, b) => modify(self, key, () => b));\n/**\n * Removes a key from a record.\n *\n * **When to use**\n *\n * Use to create a shallow copy of a record without one property.\n *\n * **Details**\n *\n * If the key is not present, the result is still a shallow copy of the original\n * record.\n *\n * **Example** (Removing a key)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.remove({ a: 1, b: 2 }, \"a\") // => { b: 2 }\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const remove = /*#__PURE__*/dual(2, (self, key) => {\n if (!has(self, key)) {\n return {\n ...self\n };\n }\n const out = {\n ...self\n };\n delete out[key];\n return out;\n});\n/**\n * Retrieves the value of the property with the given `key` from a record safely and returns an `Option`\n * of a tuple with the value and the record with the removed property.\n * If the key is not present, returns `Option.none()`.\n *\n * **Example** (Popping a value and removing its key)\n *\n * ```ts import.meta.vitest\n * import { Option, Record } from \"effect\"\n *\n * const input: Record = { a: 1, b: 2 }\n *\n * Record.pop(input, \"a\") // => Option.some([1, { b: 2 }])\n * Record.pop(input, \"c\") // => Option.none()\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const pop = /*#__PURE__*/dual(2, (self, key) => has(self, key) ? Option.some([self[key], remove(self, key)]) : Option.none());\n/**\n * Maps a record into another record by applying a transformation function to each of its values.\n *\n * **Example** (Mapping record values)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * const f = (n: number) => `-${n}`\n *\n * Record.map({ a: 3, b: 5 }, f) // => { a: \"-3\", b: \"-5\" }\n *\n * const g = (n: number, key: string) => `${key.toUpperCase()}-${n}`\n *\n * Record.map({ a: 3, b: 5 }, g) // => { a: \"A-3\", b: \"B-5\" }\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, f) => {\n const out = {\n ...self\n };\n for (const key of keys(self)) {\n InternalRecord.assignProperty(out, key, f(self[key], key));\n }\n return out;\n});\n/**\n * Maps the keys of a `ReadonlyRecord` while preserving the corresponding values.\n *\n * **Example** (Mapping record keys)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()) // => { A: 3, B: 5 }\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapKeys = /*#__PURE__*/dual(2, (self, f) => {\n const out = {};\n for (const key of keys(self)) {\n const a = self[key];\n InternalRecord.assignProperty(out, f(key, a), a);\n }\n return out;\n});\n/**\n * Maps entries of a `ReadonlyRecord` using the provided function, allowing modification of both keys and corresponding values.\n *\n * **Example** (Mapping record entries)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]) // => { A: 4, B: 6 }\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapEntries = /*#__PURE__*/dual(2, (self, f) => {\n const out = {};\n for (const key of keys(self)) {\n const [k, b] = f(self[key], key);\n InternalRecord.assignProperty(out, k, b);\n }\n return out;\n});\n/**\n * Transforms a record by applying the function `f` to each key and value in the original record.\n * If the function succeeds, the key-value pair is included in the output record.\n *\n * **Example** (Filtering and mapping with Result)\n *\n * ```ts import.meta.vitest\n * import { Record, Result } from \"effect\"\n *\n * const x = { a: 1, b: 2, c: 3 }\n * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid\n * Record.filterMap(x, f) // => { c: 6 }\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filterMap = /*#__PURE__*/dual(2, (self, f) => {\n const out = empty();\n for (const key of keys(self)) {\n const result = f(self[key], key);\n if (R.isSuccess(result)) {\n InternalRecord.assignProperty(out, key, result.success);\n }\n }\n return out;\n});\n/**\n * Selects properties from a record whose values match the given predicate.\n *\n * **Example** (Filtering record values)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * const x = { a: 1, b: 2, c: 3, d: 4 }\n * Record.filter(x, (n) => n > 2) // => { c: 3, d: 4 }\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filter = /*#__PURE__*/dual(2, (self, predicate) => {\n const out = empty();\n for (const key of keys(self)) {\n if (predicate(self[key], key)) {\n InternalRecord.assignProperty(out, key, self[key]);\n }\n }\n return out;\n});\n/**\n * Returns a new record containing only the `Some` values from a record of\n * `Option` values, preserving the original keys.\n *\n * **Example** (Extracting Some values)\n *\n * ```ts import.meta.vitest\n * import { Option, Record } from \"effect\"\n *\n * Record.getSomes({ a: Option.some(1), b: Option.none(), c: Option.some(2) }) // => { a: 1, c: 2 }\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const getSomes = self => {\n const out = empty();\n for (const key of keys(self)) {\n const option = self[key];\n if (Option.isSome(option)) {\n InternalRecord.assignProperty(out, key, option.value);\n }\n }\n return out;\n};\n/**\n * Returns a new record containing only the `Err` values from a record of\n * `Result` values, preserving the original keys.\n *\n * **Example** (Extracting Result failures)\n *\n * ```ts import.meta.vitest\n * import { Record, Result } from \"effect\"\n *\n * Record.getFailures({\n * a: Result.succeed(1),\n * b: Result.fail(\"err\"),\n * c: Result.succeed(2)\n * }) // => { b: \"err\" }\n * ```\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const getFailures = self => {\n const out = empty();\n for (const key of keys(self)) {\n const value = self[key];\n if (R.isFailure(value)) {\n InternalRecord.assignProperty(out, key, value.failure);\n }\n }\n return out;\n};\n/**\n * Returns a new record containing only the `Ok` values from a record of\n * `Result` values, preserving the original keys.\n *\n * **Example** (Extracting Result successes)\n *\n * ```ts import.meta.vitest\n * import { Record, Result } from \"effect\"\n *\n * Record.getSuccesses({\n * a: Result.succeed(1),\n * b: Result.fail(\"err\"),\n * c: Result.succeed(2)\n * }) // => { a: 1, c: 2 }\n * ```\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const getSuccesses = self => {\n const out = empty();\n for (const key of keys(self)) {\n const value = self[key];\n if (R.isSuccess(value)) {\n InternalRecord.assignProperty(out, key, value.success);\n }\n }\n return out;\n};\n/**\n * Applies a function to each record entry and partitions the returned `Result`\n * values into two records.\n *\n * **Details**\n *\n * Failure values are collected in the left record, and success values are\n * collected in the right record, preserving the original keys.\n *\n * **Example** (Partitioning with Result)\n *\n * ```ts import.meta.vitest\n * import { Record, Result } from \"effect\"\n *\n * const x = { a: 1, b: 2, c: 3 }\n * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))\n * Record.partition(x, f) // => [{ a: 1, c: 3 }, { b: 2 }]\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const partition = /*#__PURE__*/dual(2, (self, f) => {\n const left = empty();\n const right = empty();\n for (const key of keys(self)) {\n const e = f(self[key], key);\n if (R.isFailure(e)) {\n InternalRecord.assignProperty(left, key, e.failure);\n } else {\n InternalRecord.assignProperty(right, key, e.success);\n }\n }\n return [left, right];\n});\n/**\n * Partitions a record of `Result` values into two separate records,\n * one with the `Err` values and one with the `Ok` values.\n *\n * **Example** (Separating Result values)\n *\n * ```ts import.meta.vitest\n * import { Record, Result } from \"effect\"\n *\n * Record.separate({ a: Result.fail(\"e\"), b: Result.succeed(1) }) // => [{ a: \"e\" }, { b: 1 }]\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const separate = /*#__PURE__*/partition(identity);\n/**\n * Retrieves the keys of a given record as an array.\n *\n * **Example** (Getting record keys)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.keys({ a: 1, b: 2, c: 3 }) // => [\"a\", \"b\", \"c\"]\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const keys = self => Object.keys(self);\n/**\n * Retrieves the values of a given record as an array.\n *\n * **Example** (Getting record values)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.values({ a: 1, b: 2, c: 3 }) // => [1, 2, 3]\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const values = self => collect(self, (_, a) => a);\n/**\n * Adds a new key-value pair or update an existing key's value in a record.\n *\n * **Example** (Setting a record value)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.set(\"a\", 5)({ a: 1, b: 2 }) // => { a: 5, b: 2 }\n * Record.set(\"c\", 5)({ a: 1, b: 2 }) // => { a: 1, b: 2, c: 5 }\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const set = /*#__PURE__*/dual(3, (self, key, value) => {\n return {\n ...self,\n [key]: value\n };\n});\n/**\n * Mutates a record by assigning a value to a property.\n *\n * **When to use**\n *\n * Use when incrementally constructing a new record and copying it for every\n * property would be unnecessary.\n *\n * **Gotchas**\n *\n * This function mutates `self`. When `key` is `\"__proto__\"`, it creates an\n * own data property instead of changing the object's prototype.\n *\n * **Example** (Assigning an external key safely)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * const key: string = \"__proto__\" // Assume this comes from external input\n * const value = { polluted: true }\n *\n * const unsafe: Record = {}\n * unsafe[key] = value\n * Object.getPrototypeOf(unsafe) === value // => true\n *\n * const safe: Record = {}\n * Record.assignProperty(safe, key, value)\n * Object.getPrototypeOf(safe) === Object.prototype // => true\n * safe[key] === value // => true\n * ```\n *\n * @see {@link set} for an immutable update\n * @category mutations\n * @since 4.0.0\n */\nexport const assignProperty = InternalRecord.assignProperty;\n/**\n * Checks whether all the keys and values in one record are also found in another record.\n * Uses the provided equivalence function to compare values.\n *\n * **Example** (Checking subrecords with a custom equivalence)\n *\n * ```ts import.meta.vitest\n * import { Equivalence, Record } from \"effect\"\n *\n * const isSubrecord = Record.isSubrecordBy(\n * Equivalence.make((self, that) => self.toLowerCase() === that.toLowerCase())\n * )\n *\n * const required: Record.ReadonlyRecord = { role: \"Admin\" }\n * const available: Record.ReadonlyRecord = {\n * role: \"admin\",\n * status: \"active\"\n * }\n *\n * isSubrecord(required, available) // => true\n * isSubrecord({ role: \"Admin\", status: \"inactive\" }, available) // => false\n * isSubrecord(required, { role: \"editor\", status: \"active\" }) // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isSubrecordBy = equivalence => dual(2, (self, that) => {\n for (const key of keys(self)) {\n if (!has(that, key) || !equivalence(self[key], that[key])) {\n return false;\n }\n }\n return true;\n});\n/**\n * Checks whether the first record is a subrecord of the second record.\n *\n * **Details**\n *\n * Returns `true` when every key and value in `self` is also present in `that`.\n * Values are compared with Effect equality via `Equal.asEquivalence()`.\n *\n * **Example** (Checking subrecords)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.isSubrecord({ a: 1 } as Record, { a: 1, b: 2 }) // => true\n * Record.isSubrecord({ a: 1, b: 2 }, { a: 1 } as Record) // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isSubrecord = /*#__PURE__*/isSubrecordBy(/*#__PURE__*/Equal.asEquivalence());\n/**\n * Reduces a record to a single value by combining its entries with a specified function.\n *\n * **Example** (Reducing record values)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.reduce({ a: 1, b: 2, c: 3 }, 0, (acc, value) => acc + value) // => 6\n * ```\n *\n * @category folding\n * @since 2.0.0\n */\nexport const reduce = /*#__PURE__*/dual(3, (self, zero, f) => {\n let out = zero;\n for (const key of keys(self)) {\n out = f(out, self[key], key);\n }\n return out;\n});\n/**\n * Checks whether all entries in a record meet a specific condition.\n *\n * **Example** (Checking every record value)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.every({ a: 1, b: 2 }, (n) => n > 0) // => true\n * Record.every({ a: 1, b: -1 }, (n) => n > 0) // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const every = /*#__PURE__*/dual(2, (self, refinement) => {\n for (const key of keys(self)) {\n if (!refinement(self[key], key)) {\n return false;\n }\n }\n return true;\n});\n/**\n * Checks whether any entry in a record meets a specific condition.\n *\n * **Example** (Checking for any matching value)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.some({ a: 1, b: 2 }, (n) => n > 1) // => true\n * Record.some({ a: 1, b: 2 }, (n) => n > 2) // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const some = /*#__PURE__*/dual(2, (self, predicate) => {\n for (const key of keys(self)) {\n if (predicate(self[key], key)) {\n return true;\n }\n }\n return false;\n});\n/**\n * Merges two records, preserving entries that exist in either of the records.\n * For keys that exist in both records, the provided combine function is used to merge the values.\n *\n * **Example** (Merging records with union)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.union({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b) // => { a: 1, b: 5, c: 4 }\n * ```\n *\n * @category combining\n * @since 2.0.0\n */\nexport const union = /*#__PURE__*/dual(3, (self, that, combine) => {\n if (isEmptyRecord(self)) {\n return {\n ...that\n };\n }\n if (isEmptyRecord(that)) {\n return {\n ...self\n };\n }\n const out = empty();\n for (const key of keys(self)) {\n if (has(that, key)) {\n InternalRecord.assignProperty(out, key, combine(self[key], that[key]));\n } else {\n InternalRecord.assignProperty(out, key, self[key]);\n }\n }\n for (const key of keys(that)) {\n if (!has(out, key)) {\n InternalRecord.assignProperty(out, key, that[key]);\n }\n }\n return out;\n});\n/**\n * Merges two records, retaining only the entries that exist in both records.\n * For intersecting keys, the provided combine function is used to merge the values.\n *\n * **Example** (Merging intersecting keys)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.intersection({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b) // => { b: 5 }\n * ```\n *\n * @category combining\n * @since 2.0.0\n */\nexport const intersection = /*#__PURE__*/dual(3, (self, that, combine) => {\n const out = empty();\n if (isEmptyRecord(self) || isEmptyRecord(that)) {\n return out;\n }\n for (const key of keys(self)) {\n if (has(that, key)) {\n InternalRecord.assignProperty(out, key, combine(self[key], that[key]));\n }\n }\n return out;\n});\n/**\n * Merges two records, preserving only the entries that are unique to each record.\n * Keys that exist in both records are excluded from the result.\n *\n * **Example** (Keeping keys unique to each record)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.difference({ a: 1, b: 2 }, { b: 3, c: 4 }) // => { a: 1, c: 4 }\n * ```\n *\n * @category combining\n * @since 2.0.0\n */\nexport const difference = /*#__PURE__*/dual(2, (self, that) => {\n if (isEmptyRecord(self)) {\n return {\n ...that\n };\n }\n if (isEmptyRecord(that)) {\n return {\n ...self\n };\n }\n const out = {};\n for (const key of keys(self)) {\n if (!has(that, key)) {\n InternalRecord.assignProperty(out, key, self[key]);\n }\n }\n for (const key of keys(that)) {\n if (!has(self, key)) {\n InternalRecord.assignProperty(out, key, that[key]);\n }\n }\n return out;\n});\n/**\n * Create an `Equivalence` for records using the provided `Equivalence` for values.\n * Two records are considered equivalent if they have the same keys and their corresponding values are equivalent.\n *\n * **Example** (Comparing records with a value equivalence)\n *\n * ```ts import.meta.vitest\n * import { Equal, Record } from \"effect\"\n *\n * const recordEquivalence = Record.makeEquivalence(Equal.asEquivalence())\n *\n * recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 2 }) // => true\n * recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 3 }) // => false\n * ```\n *\n * @category instances\n * @since 4.0.0\n */\nexport const makeEquivalence = equivalence => {\n const is = isSubrecordBy(equivalence);\n return (self, that) => is(self, that) && is(that, self);\n};\n/**\n * Create a non-empty record from a single element.\n *\n * **Example** (Creating a singleton record)\n *\n * ```ts import.meta.vitest\n * import { Record } from \"effect\"\n *\n * Record.singleton(\"a\", 1) // => { a: 1 }\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const singleton = (key, value) => ({\n [key]: value\n});\n/**\n * Creates a `Reducer` for combining `Record`s using union, with values for keys that exist in both records combined\n * using the provided `Combiner`.\n *\n * **When to use**\n *\n * Use to build a reusable reducer for accumulating many records into one\n * union-shaped record, preserving keys from every input and combining\n * overlapping values with the supplied combiner.\n *\n * **Details**\n *\n * The returned reducer uses `Record.union` for combine and an empty record as\n * `initialValue`, so the default `combineAll` folds from `{}` and accumulates\n * keys from each input record.\n *\n * @see {@link union} for one-off record merging with the same union semantics\n * @see {@link makeReducerIntersection} for a reducer that keeps only keys present on both sides\n *\n * @category combining\n * @since 4.0.0\n */\nexport function makeReducerUnion(combiner) {\n return Reducer.make((self, that) => union(self, that, combiner.combine), {});\n}\n/**\n * Creates a `Reducer` whose `combine` operation intersects two records and\n * combines values for keys present in both records.\n *\n * **When to use**\n *\n * Use to build a `Reducer` that combines records by retaining only keys shared\n * by both inputs and combining matching values with a `Combiner`.\n *\n * **Gotchas**\n *\n * The reducer's `initialValue` is an empty record. Because intersection with\n * an empty record is empty, the default `combineAll` folds from `{}` and\n * therefore produces `{}` for ordinary non-empty inputs.\n *\n * @see {@link makeReducerUnion} for a reducer that preserves keys from either input record\n * @see {@link intersection} for applying the shared-key merge to one pair of records\n *\n * @category combining\n * @since 4.0.0\n */\nexport function makeReducerIntersection(combiner) {\n return Reducer.make((self, that) => intersection(self, that, combiner.combine), {});\n}\n/**\n * Returns the first entry that satisfies the specified\n * predicate, or `None` if no such entry exists.\n *\n * **Example** (Finding the first matching entry)\n *\n * ```ts import.meta.vitest\n * import { Option, Record } from \"effect\"\n *\n * const record = { a: 1, b: 2, c: 3 }\n * Record.findFirst(\n * record,\n * (value, key) => value > 1 && key !== \"b\"\n * ) // => Option.some([\"c\", 3])\n * ```\n *\n * @category searching\n * @since 3.14.0\n */\nexport const findFirst = /*#__PURE__*/dual(2, (self, f) => {\n const k = keys(self);\n for (let i = 0; i < k.length; i++) {\n const key = k[i];\n if (f(self[key], key)) {\n return Option.some([key, self[key]]);\n }\n }\n return Option.none();\n});\n//# sourceMappingURL=Record.js.map","/**\n * Works with JavaScript arrays, readonly arrays, and non-empty arrays.\n *\n * The helpers cover common collection work such as creating arrays, reading\n * elements, transforming values, sorting, grouping, splitting, combining, and\n * reducing many values to one result. Helpers that change contents return new\n * arrays and preserve non-empty array types when the result is guaranteed to\n * contain values.\n *\n * @since 2.0.0\n */\nimport * as Equal from \"./Equal.js\";\nimport * as Equivalence from \"./Equivalence.js\";\nimport { dual, identity } from \"./Function.js\";\nimport * as Hash from \"./Hash.js\";\nimport * as internalArray from \"./internal/array.js\";\nimport * as Count from \"./internal/count.js\";\nimport * as internalDoNotation from \"./internal/doNotation.js\";\nimport * as InternalRecord from \"./internal/record.js\";\nimport * as moduleIterable from \"./Iterable.js\";\nimport * as Option from \"./Option.js\";\nimport * as Order from \"./Order.js\";\nimport * as Record from \"./Record.js\";\nimport * as Reducer from \"./Reducer.js\";\nimport * as Result from \"./Result.js\";\nimport * as Tuple from \"./Tuple.js\";\n/**\n * Exposes the global array constructor.\n *\n * **When to use**\n *\n * Use to access native JavaScript array constructor methods such as `isArray`\n * or `from` from the Effect module namespace.\n *\n * **Example** (Accessing the Array constructor)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.Array === globalThis.Array // => true\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Array = globalThis.Array;\n/**\n * Creates a `NonEmptyArray` from one or more elements.\n *\n * **When to use**\n *\n * Use when you need to create a typed non-empty array from literal values.\n *\n * **Details**\n *\n * The element type is inferred as the union of all arguments. Because at least\n * one argument is required, this always returns a `NonEmptyArray`.\n *\n * **Example** (Creating an array from values)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.make(1, 2, 3) // => [1, 2, 3]\n * ```\n *\n * @see {@link of} — create a single-element array\n * @see {@link fromIterable} — create from any iterable\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const make = (...elements) => elements;\n/**\n * Creates a new `Array` of the specified length with all slots uninitialized.\n *\n * **When to use**\n *\n * Use when you need a pre-sized array that will be filled imperatively.\n *\n * **Details**\n *\n * `n` is rounded down. `NaN` and non-positive values are treated as `0`.\n * Elements are typed as `A | undefined` because the slots are empty.\n *\n * **Example** (Allocating a fixed-size array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.allocate(3).length // => 3\n * ```\n *\n * @see {@link makeBy} — create an array by computing each element\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const allocate = n => new Array(Count.normalize(n));\n/**\n * Creates a `NonEmptyArray` of length `n` where element `i` is computed by `f(i)`.\n *\n * **When to use**\n *\n * Use when you need to compute each array element from its index.\n *\n * **Details**\n *\n * `n` is rounded down and normalized to an integer greater than or equal to 1.\n * `NaN` is treated as `1`, so this function always returns at least one\n * element. Supports both data-first and data-last usage.\n *\n * **Example** (Generating values from indices)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.makeBy(5, (n) => n * 2) // => [0, 2, 4, 6, 8]\n * ```\n *\n * @see {@link range} — create a range of integers\n * @see {@link replicate} — repeat a single value\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const makeBy = /*#__PURE__*/dual(2, (n, f) => {\n const max = Count.normalizeNonEmpty(n);\n const out = new Array(max);\n for (let i = 0; i < max; i++) {\n out[i] = f(i);\n }\n return out;\n});\n/**\n * Creates a `NonEmptyArray` containing a range of integers, inclusive on both\n * ends.\n *\n * **When to use**\n *\n * Use when you need a non-empty sequence of consecutive integers.\n *\n * **Details**\n *\n * If `start > end`, returns `[start]`.\n *\n * **Example** (Creating a range)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.range(1, 3) // => [1, 2, 3]\n * ```\n *\n * @see {@link makeBy} — generate values from a function\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const range = (start, end) => start <= end ? makeBy(end - start + 1, i => start + i) : [start];\n/**\n * Creates a `NonEmptyArray` containing a value repeated `n` times.\n *\n * **When to use**\n *\n * Use when you need a non-empty array containing repeated copies of one value.\n *\n * **Details**\n *\n * `n` is normalized to an integer greater than or equal to 1, so this function\n * always returns at least one element. Supports both data-first and data-last\n * usage.\n *\n * **Example** (Repeating a value)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.replicate(\"a\", 3) // => [\"a\", \"a\", \"a\"]\n * ```\n *\n * @see {@link makeBy} — vary values based on index\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const replicate = /*#__PURE__*/dual(2, (a, n) => makeBy(n, () => a));\n/**\n * Converts an `Iterable` to an `Array`.\n *\n * **When to use**\n *\n * Use to convert any `Iterable` (Set, Generator, etc.) into an array.\n *\n * **Details**\n *\n * If the input is already an array, this returns it by reference without\n * copying. Otherwise, it creates a new array from the iterable. Use `copy` if\n * you need a fresh array even when the input is already an array.\n *\n * **Example** (Converting a Set to an array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.fromIterable(new Set([1, 2, 3])) // => [1, 2, 3]\n * ```\n *\n * @see {@link ensure} — wrap a single value or return an existing array\n * @see {@link copy} — create a shallow copy of an array\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromIterable = collection => Array.isArray(collection) ? collection : Array.from(collection);\n/**\n * Normalizes a value that is either a single element or an array into an array.\n *\n * **When to use**\n *\n * Use to normalize input that may be a single value or an array into a consistent\n * array.\n *\n * **Details**\n *\n * If the input is already an array, this returns it by reference. If the input\n * is a single value, this wraps it in a one-element array. This is useful for\n * APIs that accept `A | Array`.\n *\n * **Example** (Normalizing input)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.ensure(\"a\") // => [\"a\"]\n * Array.ensure([\"a\", \"b\", \"c\"]) // => [\"a\", \"b\", \"c\"]\n * ```\n *\n * @see {@link of} — always wrap in a single-element array\n * @see {@link fromIterable} — convert any iterable\n *\n * @category constructors\n * @since 3.3.0\n */\nexport const ensure = self => Array.isArray(self) ? self : [self];\n/**\n * Converts a record into an array of `[key, value]` tuples.\n *\n * **When to use**\n *\n * Use to convert a record into an array of key-value tuples for iteration or\n * transformation.\n *\n * **Details**\n *\n * Key order follows `Object.entries` semantics. Empty records produce an empty\n * array.\n *\n * **Example** (Converting a record to entries)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.fromRecord({ a: 1, b: 2, c: 3 }) // => [[\"a\", 1], [\"b\", 2], [\"c\", 3]]\n * ```\n *\n * @see {@link Record.toEntries} the equivalent function from the Record module\n * @see {@link Record.fromEntries} to build a record from an array of tuples\n *\n * @category converting\n * @since 2.0.0\n */\nexport const fromRecord = Record.toEntries;\n/**\n * Converts an `Option` to an array: `Some(a)` becomes `[a]`, `None` becomes `[]`.\n *\n * **When to use**\n *\n * Use to convert a single `Option` into an array for downstream array operations.\n *\n * **Example** (Converting an Option to an array)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.fromOption(Option.some(1)) // => [1]\n * Array.fromOption(Option.none()) // => []\n * ```\n *\n * @see {@link getSomes} — extract `Some` values from an array of Options\n *\n * @category converting\n * @since 2.0.0\n */\nexport const fromOption = Option.toArray;\n/**\n * Pattern-matches on an array, handling empty and non-empty cases separately.\n *\n * **When to use**\n *\n * Use when you need to branch on whether an array is empty.\n *\n * **Details**\n *\n * `onNonEmpty` receives a `NonEmptyReadonlyArray`. Supports both data-first and\n * data-last usage.\n *\n * **Example** (Branching on emptiness)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const describe = Array.match({\n * onEmpty: () => \"empty\",\n * onNonEmpty: ([head, ...tail]) => `head: ${head}, tail: ${tail.length}`\n * })\n *\n * describe([]) // => \"empty\"\n * describe([1, 2, 3]) // => \"head: 1, tail: 2\"\n * ```\n *\n * @see {@link matchLeft} — destructures into head + tail\n * @see {@link matchRight} — destructures into init + last\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport const match = /*#__PURE__*/dual(2, (self, {\n onEmpty,\n onNonEmpty\n}) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(self) : onEmpty());\n/**\n * Pattern-matches on an array from the left, providing the first element and\n * the remaining elements separately.\n *\n * **When to use**\n *\n * Use when you need to branch on an array and handle the non-empty case as the\n * first element plus the remaining elements.\n *\n * **Details**\n *\n * `onNonEmpty` receives `(head, tail)` where `tail` is the rest of the array.\n *\n * **Example** (Destructuring head and tail)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const matchLeft = Array.matchLeft({\n * onEmpty: () => \"empty\",\n * onNonEmpty: (head, tail) => `head: ${head}, tail: ${tail.length}`\n * })\n *\n * matchLeft([]) // => \"empty\"\n * matchLeft([1, 2, 3]) // => \"head: 1, tail: 2\"\n * ```\n *\n * @see {@link match} — receives the full non-empty array\n * @see {@link matchRight} — destructures into init + last\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport const matchLeft = /*#__PURE__*/dual(2, (self, {\n onEmpty,\n onNonEmpty\n}) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(headNonEmpty(self), tailNonEmpty(self)) : onEmpty());\n/**\n * Pattern-matches on an array from the right, providing all elements except the\n * last and the last element separately.\n *\n * **When to use**\n *\n * Use when you need to branch on an array and handle the non-empty case as the\n * elements before the last plus the last element.\n *\n * **Details**\n *\n * `onNonEmpty` receives `(init, last)` where `init` is everything but the last element.\n *\n * **Example** (Destructuring init and last)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const matchRight = Array.matchRight({\n * onEmpty: () => \"empty\",\n * onNonEmpty: (init, last) => `init: ${init.length}, last: ${last}`\n * })\n *\n * matchRight([]) // => \"empty\"\n * matchRight([1, 2, 3]) // => \"init: 2, last: 3\"\n * ```\n *\n * @see {@link match} — receives the full non-empty array\n * @see {@link matchLeft} — destructures into head + tail\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport const matchRight = /*#__PURE__*/dual(2, (self, {\n onEmpty,\n onNonEmpty\n}) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(initNonEmpty(self), lastNonEmpty(self)) : onEmpty());\n/**\n * Adds a single element to the front of an iterable, returning a `NonEmptyArray`.\n *\n * **When to use**\n *\n * Use when you need to guarantee a non-empty result after adding a required\n * leading value.\n *\n * **Example** (Prepending an element)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.prepend([2, 3, 4], 1) // => [1, 2, 3, 4]\n * ```\n *\n * @see {@link append} — add to the end\n * @see {@link prependAll} — prepend multiple elements\n *\n * @category combining\n * @since 2.0.0\n */\nexport const prepend = /*#__PURE__*/dual(2, (self, head) => [head, ...self]);\n/**\n * Prepends all elements from a prefix iterable to the front of an array.\n *\n * **When to use**\n *\n * Use to prepend multiple elements from an iterable to the front of an array.\n *\n * **Details**\n *\n * If either input is non-empty, the result is a `NonEmptyArray`.\n *\n * **Example** (Prepending multiple elements)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.prependAll([2, 3], [0, 1]) // => [0, 1, 2, 3]\n * ```\n *\n * @see {@link prepend} — add a single element to the front\n * @see {@link appendAll} — add elements to the end\n *\n * @category combining\n * @since 2.0.0\n */\nexport const prependAll = /*#__PURE__*/dual(2, (self, that) => fromIterable(that).concat(fromIterable(self)));\n/**\n * Adds a single element to the end of an iterable, returning a `NonEmptyArray`.\n *\n * **When to use**\n *\n * Use when you need to guarantee a non-empty result after adding a required\n * trailing value.\n *\n * **Example** (Appending an element)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.append([1, 2, 3], 4) // => [1, 2, 3, 4]\n * ```\n *\n * @see {@link prepend} — add to the front\n * @see {@link appendAll} — append multiple elements\n *\n * @category combining\n * @since 2.0.0\n */\nexport const append = /*#__PURE__*/dual(2, (self, last) => [...self, last]);\n/**\n * Concatenates two iterables into a single array.\n *\n * **When to use**\n *\n * Use to combine two iterable inputs into a new array with the second input's\n * elements after the first.\n *\n * **Details**\n *\n * If either input is non-empty, the result is a `NonEmptyArray`.\n *\n * **Example** (Concatenating arrays)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.appendAll([1, 2], [3, 4]) // => [1, 2, 3, 4]\n * ```\n *\n * @see {@link append} — add a single element to the end\n * @see {@link prependAll} — add elements to the front\n *\n * @category combining\n * @since 2.0.0\n */\nexport const appendAll = /*#__PURE__*/dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));\n/**\n * Folds left-to-right while keeping every intermediate accumulator value.\n *\n * **When to use**\n *\n * Use to compute a running accumulator where each intermediate value is needed.\n *\n * **Details**\n *\n * The output length is `input.length + 1` because it starts with the initial\n * value. The result is always a `NonEmptyArray`. Use `reduce` if you only need\n * the final accumulated value.\n *\n * **Example** (Running totals)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.scan([1, 2, 3, 4], 0, (acc, value) => acc + value) // => [0, 1, 3, 6, 10]\n * ```\n *\n * @see {@link scanRight} — right-to-left scan\n * @see {@link reduce} — fold without intermediate values\n *\n * @category folding\n * @since 2.0.0\n */\nexport const scan = /*#__PURE__*/dual(3, (self, b, f) => {\n const out = [b];\n let i = 0;\n for (const a of self) {\n out[i + 1] = f(out[i], a);\n i++;\n }\n return out;\n});\n/**\n * Folds right-to-left while keeping every intermediate accumulator value.\n *\n * **When to use**\n *\n * Use to compute a running accumulator from right to left where each intermediate\n * value is needed.\n *\n * **Details**\n *\n * The output length is `input.length + 1` because it ends with the initial\n * value. The result is always a `NonEmptyArray`.\n *\n * **Example** (Scanning running totals in reverse)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.scanRight([1, 2, 3, 4], 0, (acc, value) => acc + value) // => [10, 9, 7, 4, 0]\n * ```\n *\n * @see {@link scan} — left-to-right scan\n * @see {@link reduceRight} — fold without intermediate values\n *\n * @category folding\n * @since 2.0.0\n */\nexport const scanRight = /*#__PURE__*/dual(3, (self, b, f) => {\n const input = fromIterable(self);\n const out = new Array(input.length + 1);\n out[input.length] = b;\n for (let i = input.length - 1; i >= 0; i--) {\n out[i] = f(out[i + 1], input[i]);\n }\n return out;\n});\n/**\n * Checks whether a value is an `Array`.\n *\n * **When to use**\n *\n * Use to verify a value is a mutable array, narrowing its type to `Array`.\n *\n * **Details**\n *\n * Acts as a type guard narrowing the input to `Array` and delegates to\n * `globalThis.Array.isArray`.\n *\n * **Example** (Type-guarding an unknown value)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.isArray(null) // => false\n * Array.isArray([1, 2, 3]) // => true\n * ```\n *\n * @see {@link isArrayEmpty} — check for an empty array\n * @see {@link isArrayNonEmpty} — check for a non-empty array\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isArray = Array.isArray;\n/**\n * Checks whether a mutable `Array` is empty, narrowing the type to `[]`.\n *\n * **Example** (Checking for an empty array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.isArrayEmpty([]) // => true\n * Array.isArrayEmpty([1, 2, 3]) // => false\n * ```\n *\n * @see {@link isReadonlyArrayEmpty} — readonly variant\n * @see {@link isArrayNonEmpty} — opposite check\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isArrayEmpty = self => self.length === 0;\n/**\n * Checks whether a `ReadonlyArray` is empty, narrowing the type to `readonly []`.\n *\n * **Example** (Checking for an empty readonly array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.isReadonlyArrayEmpty([]) // => true\n * Array.isReadonlyArrayEmpty([1, 2, 3]) // => false\n * ```\n *\n * @see {@link isArrayEmpty} — mutable variant\n * @see {@link isReadonlyArrayNonEmpty} — opposite check\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isReadonlyArrayEmpty = isArrayEmpty;\n/**\n * Checks whether a mutable `Array` is non-empty, narrowing the type to\n * `NonEmptyArray`.\n *\n * **When to use**\n *\n * Use when you need the narrowed value to remain a mutable `Array` after proving\n * it has at least one element.\n *\n * **Example** (Checking for a non-empty array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.isArrayNonEmpty([]) // => false\n * Array.isArrayNonEmpty([1, 2, 3]) // => true\n * ```\n *\n * @see {@link isReadonlyArrayNonEmpty} — readonly variant\n * @see {@link isArrayEmpty} — opposite check\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isArrayNonEmpty = internalArray.isArrayNonEmpty;\n/**\n * Checks whether a `ReadonlyArray` is non-empty, narrowing the type to\n * `NonEmptyReadonlyArray`.\n *\n * **When to use**\n *\n * Use when you need to prove a readonly array has at least one element without\n * requiring mutable array methods afterward.\n *\n * **Example** (Checking for a non-empty readonly array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.isReadonlyArrayNonEmpty([]) // => false\n * Array.isReadonlyArrayNonEmpty([1, 2, 3]) // => true\n * ```\n *\n * @see {@link isArrayNonEmpty} — mutable variant\n * @see {@link isReadonlyArrayEmpty} — opposite check\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isReadonlyArrayNonEmpty = internalArray.isArrayNonEmpty;\n/**\n * Returns the number of elements in a `ReadonlyArray`.\n *\n * **When to use**\n *\n * Use when you need length as a composable function rather than a property access.\n *\n * **Example** (Getting the length)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.length([1, 2, 3]) // => 3\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const length = self => self.length;\n/**\n * Checks whether a string represents a JavaScript array index: a non-negative\n * integer below `2 ** 32 - 1`, written without leading zeroes, a sign, or\n * exponent notation.\n *\n * @internal\n */\nexport function isCanonicalArrayIndex(key) {\n const index = Number(key);\n return String(index) === key && Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1;\n}\n/** @internal */\nexport function isOutOfBounds(i, as) {\n return !Number.isFinite(i) || i < 0 || i >= as.length;\n}\n/**\n * Reads an element at the given index safely, returning `Option.some` or\n * `Option.none` if the index is out of bounds.\n *\n * **When to use**\n *\n * Use when you need to read an array element by index and handle an\n * out-of-bounds index as `Option.none`.\n *\n * **Details**\n *\n * The index is floored to an integer. This never throws.\n *\n * **Example** (Accessing indexes safely)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.get([1, 2, 3], 1) // => Option.some(2)\n * Array.get([1, 2, 3], 10) // => Option.none()\n * ```\n *\n * @see {@link getUnsafe} for indexed access that throws when the index is out of bounds\n * @see {@link head} for reading the first element as an `Option`\n * @see {@link last} for reading the last element as an `Option`\n *\n * @category getters\n * @since 2.0.0\n */\nexport const get = /*#__PURE__*/dual(2, (self, index) => {\n const i = Math.floor(index);\n return isOutOfBounds(i, self) ? Option.none() : Option.some(self[i]);\n});\n/**\n * Reads an element at the given index, throwing if the index is out of bounds.\n *\n * **When to use**\n *\n * Use to read an array element at a known valid index when out-of-bounds would\n * be a programming error.\n *\n * **Details**\n *\n * Throws an `Error` with the message `\"Index out of bounds: \"`. Prefer\n * `get` for safe access.\n *\n * **Example** (Accessing indexes unsafely)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.getUnsafe([1, 2, 3], 1) // => 2\n * // Array.getUnsafe([1, 2, 3], 10) // throws Error\n * ```\n *\n * @see {@link get} — safe version returning `Option`\n *\n * @category unsafe\n * @since 4.0.0\n */\nexport const getUnsafe = /*#__PURE__*/dual(2, (self, index) => {\n const i = Math.floor(index);\n if (isOutOfBounds(i, self)) {\n throw new Error(`Index out of bounds: ${i}`);\n }\n return self[i];\n});\n/**\n * Splits a non-empty array into its first element and the remaining elements.\n *\n * **When to use**\n *\n * Use when you have a `NonEmptyReadonlyArray` and need both its first element\n * and the remaining elements as separate values.\n *\n * **Details**\n *\n * Returns a tuple `[head, tail]` and requires a `NonEmptyReadonlyArray`.\n *\n * **Example** (Destructuring head and tail)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.unprepend([1, 2, 3, 4]) // => [1, [2, 3, 4]]\n * ```\n *\n * @see {@link unappend} for splitting a non-empty array into init and last\n * @see {@link headNonEmpty} for getting only the first element\n * @see {@link tailNonEmpty} for getting only the elements after the first\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const unprepend = self => [headNonEmpty(self), tailNonEmpty(self)];\n/**\n * Splits a non-empty array into all elements except the last, and the last\n * element.\n *\n * **When to use**\n *\n * Use when you need to split a non-empty array into the elements before the\n * last element and the last element.\n *\n * **Details**\n *\n * Returns a tuple `[init, last]` and requires a `NonEmptyReadonlyArray`.\n *\n * **Example** (Destructuring init and last)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.unappend([1, 2, 3, 4]) // => [[1, 2, 3], 4]\n * ```\n *\n * @see {@link unprepend} for splitting a non-empty array into head and tail\n * @see {@link initNonEmpty} for getting only the elements before the last\n * @see {@link lastNonEmpty} for getting only the last element\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const unappend = self => [initNonEmpty(self), lastNonEmpty(self)];\n/**\n * Returns the first element of an array safely wrapped in `Option.some`, or\n * `Option.none` if the array is empty.\n *\n * **When to use**\n *\n * Use to safely get the first element of an array that may be empty.\n *\n * **Example** (Getting the first element)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.head([1, 2, 3]) // => Option.some(1)\n * Array.head([]) // => Option.none()\n * ```\n *\n * @see {@link headNonEmpty} — direct access when array is known non-empty\n * @see {@link last} — get the last element\n *\n * @category getters\n * @since 2.0.0\n */\nexport const head = /*#__PURE__*/get(0);\n/**\n * Returns the first element of a `NonEmptyReadonlyArray` directly (no `Option`\n * wrapper).\n *\n * **When to use**\n *\n * Use to get the first element without `Option` wrapping when the array is known\n * to be non-empty.\n *\n * **Example** (Getting the head of a non-empty array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.headNonEmpty([1, 2, 3, 4]) // => 1\n * ```\n *\n * @see {@link head} — safe version for possibly-empty arrays\n *\n * @category getters\n * @since 2.0.0\n */\nexport const headNonEmpty = /*#__PURE__*/getUnsafe(0);\n/**\n * Returns the last element of an array safely wrapped in `Option.some`, or\n * `Option.none` if the array is empty.\n *\n * **When to use**\n *\n * Use to safely get the last element of an array that may be empty.\n *\n * **Example** (Getting the last element)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.last([1, 2, 3]) // => Option.some(3)\n * Array.last([]) // => Option.none()\n * ```\n *\n * @see {@link lastNonEmpty} — direct access when array is known non-empty\n * @see {@link head} — get the first element\n *\n * @category getters\n * @since 2.0.0\n */\nexport const last = self => isReadonlyArrayNonEmpty(self) ? Option.some(lastNonEmpty(self)) : Option.none();\n/**\n * Returns the last element of a `NonEmptyReadonlyArray` directly (no `Option`\n * wrapper).\n *\n * **When to use**\n *\n * Use to get the last element without `Option` wrapping when the array is known\n * to be non-empty.\n *\n * **Example** (Getting the last of a non-empty array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.lastNonEmpty([1, 2, 3, 4]) // => 4\n * ```\n *\n * @see {@link last} — safe version for possibly-empty arrays\n *\n * @category getters\n * @since 2.0.0\n */\nexport const lastNonEmpty = self => self[self.length - 1];\n/**\n * Returns all elements except the first safely, wrapped in an `Option`.\n *\n * **When to use**\n *\n * Use to safely get all elements after the first when the iterable may be empty.\n *\n * **Details**\n *\n * Allocates a new array via `slice(1)`. Empty inputs return `Option.none()`.\n *\n * **Example** (Getting the tail)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.tail([1, 2, 3, 4]) // => Option.some([2, 3, 4])\n * Array.tail([]) // => Option.none()\n * ```\n *\n * @see {@link tailNonEmpty} — when the array is known non-empty\n * @see {@link init} — all elements except the last\n *\n * @category getters\n * @since 2.0.0\n */\nexport function tail(self) {\n const as = fromIterable(self);\n return isReadonlyArrayNonEmpty(as) ? Option.some(tailNonEmpty(as)) : Option.none();\n}\n/**\n * Returns all elements except the first of a `NonEmptyReadonlyArray`.\n *\n * **When to use**\n *\n * Use to get all elements after the first when the array is known to be non-empty.\n *\n * **Example** (Getting the tail of a non-empty array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.tailNonEmpty([1, 2, 3, 4]) // => [2, 3, 4]\n * ```\n *\n * @see {@link tail} — safe version for possibly-empty arrays\n * @see {@link initNonEmpty} — all elements except the last\n *\n * @category getters\n * @since 2.0.0\n */\nexport const tailNonEmpty = self => self.slice(1);\n/**\n * Returns all elements except the last safely, wrapped in an `Option`.\n *\n * **When to use**\n *\n * Use to safely get all elements before the last when the iterable may be empty.\n *\n * **Details**\n *\n * Allocates a new array via `slice(0, -1)`. Empty inputs return\n * `Option.none()`.\n *\n * **Example** (Getting init)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.init([1, 2, 3, 4]) // => Option.some([1, 2, 3])\n * Array.init([]) // => Option.none()\n * ```\n *\n * @see {@link initNonEmpty} — when the array is known non-empty\n * @see {@link tail} — all elements except the first\n *\n * @category getters\n * @since 2.0.0\n */\nexport function init(self) {\n const as = fromIterable(self);\n return isReadonlyArrayNonEmpty(as) ? Option.some(initNonEmpty(as)) : Option.none();\n}\n/**\n * Returns all elements except the last of a `NonEmptyReadonlyArray`.\n *\n * **When to use**\n *\n * Use to get all elements before the last when the array is known to be non-empty.\n *\n * **Example** (Getting init of a non-empty array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.initNonEmpty([1, 2, 3, 4]) // => [1, 2, 3]\n * ```\n *\n * @see {@link init} — safe version for possibly-empty arrays\n * @see {@link tailNonEmpty} — all elements except the first\n *\n * @category getters\n * @since 2.0.0\n */\nexport const initNonEmpty = self => self.slice(0, -1);\nconst clampCount = (n, length) => Math.min(Count.normalize(n), length);\n/**\n * Keeps the first `n` elements, creating a new array.\n *\n * **When to use**\n *\n * Use to keep up to the first `n` elements from an iterable as a new array.\n *\n * **Details**\n *\n * `n` is rounded down and clamped to `[0, length]`. `NaN` is treated as `0`.\n * Returns an empty array when `n <= 0`.\n *\n * **Example** (Taking from the start)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.take([1, 2, 3, 4, 5], 3) // => [1, 2, 3]\n * ```\n *\n * @see {@link takeRight} for keeping elements from the end\n * @see {@link takeWhile} for keeping an initial prefix while a predicate holds\n * @see {@link drop} for removing elements from the start\n *\n * @category getters\n * @since 2.0.0\n */\nexport const take = /*#__PURE__*/dual(2, (self, n) => {\n const input = fromIterable(self);\n return input.slice(0, clampCount(n, input.length));\n});\n/**\n * Keeps the last `n` elements, creating a new array.\n *\n * **When to use**\n *\n * Use to keep the last `n` elements of an iterable.\n *\n * **Details**\n *\n * `n` is rounded down and clamped to `[0, length]`. `NaN` is treated as `0`.\n * Returns an empty array when `n <= 0`.\n *\n * **Example** (Taking from the end)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.takeRight([1, 2, 3, 4, 5], 3) // => [3, 4, 5]\n * ```\n *\n * @see {@link take} — keep from the start\n * @see {@link dropRight} — remove from the end\n *\n * @category getters\n * @since 2.0.0\n */\nexport const takeRight = /*#__PURE__*/dual(2, (self, n) => {\n const input = fromIterable(self);\n const i = clampCount(n, input.length);\n return i === 0 ? [] : input.slice(-i);\n});\n/**\n * Takes elements from the start while the predicate holds, stopping at the\n * first element that fails.\n *\n * **When to use**\n *\n * Use to keep the leading elements of an iterable while each element satisfies\n * a predicate, returning the retained prefix as an array.\n *\n * **Details**\n *\n * Supports refinements for type narrowing. The predicate receives\n * `(element, index)`.\n *\n * **Example** (Taking while condition holds)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4) // => [1, 3, 2]\n * ```\n *\n * @see {@link take} for keeping a fixed number of leading elements\n * @see {@link dropWhile} for removing the matching prefix and keeping the rest\n * @see {@link span} for splitting the matching prefix from the remaining elements\n *\n * @category getters\n * @since 2.0.0\n */\nexport const takeWhile = /*#__PURE__*/dual(2, (self, predicate) => {\n let i = 0;\n const out = [];\n for (const a of self) {\n if (!predicate(a, i)) {\n break;\n }\n out.push(a);\n i++;\n }\n return out;\n});\n/**\n * Takes elements from the start while a `Filter` succeeds, collecting transformed values.\n *\n * **When to use**\n *\n * Use when you need to take a prefix from an iterable while a function can\n * successfully extract or transform elements, stopping at the first element\n * that produces a failure result.\n *\n * **Details**\n *\n * The filter receives `(element, index)` and processing stops at the first\n * filter failure.\n *\n * @see {@link takeWhile} for taking a prefix based on a boolean predicate\n *\n * @category getters\n * @since 4.0.0\n */\nexport const takeWhileFilter = /*#__PURE__*/dual(2, (self, f) => {\n let i = 0;\n const out = [];\n for (const a of self) {\n const result = f(a, i);\n if (Result.isFailure(result)) {\n break;\n }\n out.push(result.success);\n i++;\n }\n return out;\n});\nconst spanIndex = (self, predicate) => {\n let i = 0;\n for (const a of self) {\n if (!predicate(a, i)) {\n break;\n }\n i++;\n }\n return i;\n};\n/**\n * Splits an iterable into two arrays: the longest prefix where the predicate\n * holds, and the remaining elements.\n *\n * **When to use**\n *\n * Use when you need both the longest predicate-matching prefix and the\n * remaining elements.\n *\n * **Details**\n *\n * Equivalent to `[takeWhile(pred), dropWhile(pred)]`, but more efficient\n * because it runs in a single pass. Supports refinements for type narrowing of\n * the prefix.\n *\n * **Example** (Splitting at predicate boundary)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.span([1, 3, 2, 4, 5], (x) => x % 2 === 1) // => [[1, 3], [2, 4, 5]]\n * ```\n *\n * @see {@link takeWhile} for keeping only the matching prefix\n * @see {@link dropWhile} for keeping only the elements after the matching prefix\n * @see {@link splitWhere} for splitting at the first element that satisfies a predicate\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const span = /*#__PURE__*/dual(2, (self, predicate) => {\n const input = fromIterable(self);\n return splitAt(input, spanIndex(input, predicate));\n});\n/**\n * Removes the first `n` elements, creating a new array.\n *\n * **When to use**\n *\n * Use to keep the suffix of an iterable after skipping a fixed number of\n * leading elements.\n *\n * **Details**\n *\n * `n` is rounded down and clamped to `[0, length]`. `NaN` is treated as `0`.\n * When `n <= 0`, this returns a copy of the full array.\n *\n * **Example** (Dropping from the start)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.drop([1, 2, 3, 4, 5], 2) // => [3, 4, 5]\n * ```\n *\n * @see {@link dropRight} for removing a fixed number of elements from the end\n * @see {@link dropWhile} for removing a prefix based on a predicate instead of a fixed count\n * @see {@link take} for keeping a fixed number of elements from the start\n *\n * @category getters\n * @since 2.0.0\n */\nexport const drop = /*#__PURE__*/dual(2, (self, n) => {\n const input = fromIterable(self);\n return input.slice(clampCount(n, input.length), input.length);\n});\n/**\n * Removes the last `n` elements, creating a new array.\n *\n * **When to use**\n *\n * Use to remove the last `n` elements from an iterable.\n *\n * **Details**\n *\n * `n` is rounded down and clamped to `[0, length]`. `NaN` is treated as `0`.\n *\n * **Example** (Dropping from the end)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.dropRight([1, 2, 3, 4, 5], 2) // => [1, 2, 3]\n * ```\n *\n * @see {@link drop} — remove from the start\n * @see {@link takeRight} — keep from the end\n *\n * @category getters\n * @since 2.0.0\n */\nexport const dropRight = /*#__PURE__*/dual(2, (self, n) => {\n const input = fromIterable(self);\n return input.slice(0, input.length - clampCount(n, input.length));\n});\n/**\n * Drops elements from the start while the predicate holds, returning the rest.\n *\n * **When to use**\n *\n * Use to remove a leading prefix of elements that satisfy a predicate.\n *\n * **Details**\n *\n * The predicate receives `(element, index)`.\n *\n * **Example** (Dropping while condition holds)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.dropWhile([1, 2, 3, 4, 5], (x) => x < 4) // => [4, 5]\n * ```\n *\n * @see {@link takeWhile} — keep the matching prefix instead\n * @see {@link drop} — drop a fixed count\n *\n * @category getters\n * @since 2.0.0\n */\nexport const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => {\n const input = fromIterable(self);\n let i = 0;\n while (i < input.length) {\n if (!predicate(input[i], i)) {\n break;\n }\n i++;\n }\n return input.slice(i);\n});\n/**\n * Drops elements from the start while a `Filter` succeeds.\n *\n * **When to use**\n *\n * Use when you need to drop a prefix from an iterable by computing a `Result`\n * per element instead of using a simple boolean predicate.\n *\n * **Details**\n *\n * The filter receives `(element, index)`. The result contains the remaining\n * original elements after the first filter failure.\n *\n * @see {@link dropWhile} for dropping a prefix with a simple boolean predicate\n * @see {@link takeWhileFilter} for keeping only the matching prefix\n *\n * @category getters\n * @since 4.0.0\n */\nexport const dropWhileFilter = /*#__PURE__*/dual(2, (self, f) => {\n const input = fromIterable(self);\n let i = 0;\n while (i < input.length) {\n if (Result.isFailure(f(input[i], i))) {\n break;\n }\n i++;\n }\n return input.slice(i);\n});\n/**\n * Returns the index of the first element matching the predicate, wrapped in an\n * `Option`.\n *\n * **When to use**\n *\n * Use to find the index of the first matching element from the start of an\n * iterable.\n *\n * **Example** (Finding an index)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.findFirstIndex([5, 3, 8, 9], (x) => x > 5) // => Option.some(2)\n * ```\n *\n * @see {@link findLastIndex} — search from the end\n * @see {@link findFirst} — get the element itself\n *\n * @category searching\n * @since 2.0.0\n */\nexport const findFirstIndex = /*#__PURE__*/dual(2, (self, predicate) => {\n let i = 0;\n for (const a of self) {\n if (predicate(a, i)) {\n return Option.some(i);\n }\n i++;\n }\n return Option.none();\n});\n/**\n * Returns the index of the last element matching the predicate, wrapped in an\n * `Option`.\n *\n * **When to use**\n *\n * Use to find the index of the last matching element from the end of an array.\n *\n * **Example** (Finding the last matching index)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.findLastIndex([1, 3, 8, 9], (x) => x < 5) // => Option.some(1)\n * ```\n *\n * @see {@link findFirstIndex} — search from the start\n * @see {@link findLast} — get the element itself\n *\n * @category searching\n * @since 2.0.0\n */\nexport const findLastIndex = /*#__PURE__*/dual(2, (self, predicate) => {\n const input = fromIterable(self);\n for (let i = input.length - 1; i >= 0; i--) {\n if (predicate(input[i], i)) {\n return Option.some(i);\n }\n }\n return Option.none();\n});\n/**\n * Returns the first element matching a predicate, refinement, or mapping\n * function, wrapped in `Option`.\n *\n * **When to use**\n *\n * Use to scan an iterable in iteration order and return the first selected\n * element or mapped value as an `Option`.\n *\n * **Details**\n *\n * Accepts a predicate `(a, i) => boolean`, a refinement, or a function\n * `(a, i) => Option` for simultaneous find-and-transform. If no element\n * matches, this returns `Option.none()`.\n *\n * **Example** (Finding the first match)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.findFirst([1, 2, 3, 4, 5], (x) => x > 3) // => Option.some(4)\n * ```\n *\n * @see {@link findLast} — search from the end\n * @see {@link findFirstIndex} — get the index instead\n * @see {@link findFirstWithIndex} — get both element and index\n *\n * @category searching\n * @since 2.0.0\n */\nexport const findFirst = moduleIterable.findFirst;\n/**\n * Returns the first selected value together with its index, wrapped in an\n * `Option`.\n *\n * **When to use**\n *\n * Use to find both the first matching element and its index in one pass.\n *\n * **Details**\n *\n * Accepts a predicate, a refinement, or a function returning `Option`. For an\n * `Option`-returning function, returns `[mappedValue, index]` for the first\n * `Some`, or `Option.none()` if no element is selected.\n *\n * **Example** (Finding element with its index)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3) // => Option.some([4, 3])\n * ```\n *\n * @see {@link findFirst} — get only the element\n * @see {@link findFirstIndex} — get only the index\n *\n * @category searching\n * @since 3.17.0\n */\nexport const findFirstWithIndex = /*#__PURE__*/dual(2, (self, f) => {\n let i = 0;\n for (const a of self) {\n const o = f(a, i);\n if (typeof o === \"boolean\") {\n if (o) {\n return Option.some([a, i]);\n }\n } else {\n if (Option.isSome(o)) {\n return Option.some([o.value, i]);\n }\n }\n i++;\n }\n return Option.none();\n});\n/**\n * Returns the last element matching a predicate, refinement, or mapping\n * function, wrapped in `Option`.\n *\n * **When to use**\n *\n * Use to find the last matching element from the end of an array.\n *\n * **Details**\n *\n * Searches from the end of the array. If no element matches, this returns\n * `Option.none()`.\n *\n * **Example** (Finding the last match)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.findLast([1, 2, 3, 4, 5], (n) => n % 2 === 0) // => Option.some(4)\n * ```\n *\n * @see {@link findFirst} — search from the start\n * @see {@link findLastIndex} — get the index instead\n *\n * @category searching\n * @since 2.0.0\n */\nexport const findLast = /*#__PURE__*/dual(2, (self, f) => {\n const input = fromIterable(self);\n for (let i = input.length - 1; i >= 0; i--) {\n const a = input[i];\n const o = f(a, i);\n if (typeof o === \"boolean\") {\n if (o) {\n return Option.some(a);\n }\n } else {\n if (Option.isSome(o)) {\n return o;\n }\n }\n }\n return Option.none();\n});\n/**\n * Inserts an element at the specified index safely, returning a new `NonEmptyArray`\n * wrapped in an `Option`.\n *\n * **When to use**\n *\n * Use to insert a single element at a specific position in an array.\n *\n * **Details**\n *\n * Valid indices are `0` to `length`, inclusive. Inserting at `length` appends.\n *\n * **Example** (Inserting at an index)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.insertAt([\"a\", \"b\", \"c\", \"e\"], 3, \"d\") // => Option.some([\"a\", \"b\", \"c\", \"d\", \"e\"])\n * ```\n *\n * @see {@link replace} — replace an existing element\n * @see {@link modify} — transform an element at an index\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const insertAt = /*#__PURE__*/dual(3, (self, i, b) => {\n const out = Array.from(self); // copy because `splice` mutates the array\n const index = Math.floor(i);\n if (index !== out.length && isOutOfBounds(index, out)) {\n return Option.none();\n }\n out.splice(index, 0, b);\n return Option.some(out);\n});\n/**\n * Replaces the element at the specified index safely with a new value, returning the\n * updated array in `Option.some`.\n *\n * **When to use**\n *\n * Use to set a fixed replacement value at a specific index.\n *\n * **Details**\n *\n * Returns `Option.none()` when the index is out of bounds.\n *\n * **Example** (Replacing an element)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.replace([1, 2, 3], 1, 4) // => Option.some([1, 4, 3])\n * ```\n *\n * @see {@link modify} — transform an element with a function\n * @see {@link insertAt} — insert without removing\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const replace = /*#__PURE__*/dual(3, (self, i, b) => modify(self, i, () => b));\n/**\n * Applies a function to the element at the specified index safely, returning the\n * updated array in `Option.some`.\n *\n * **When to use**\n *\n * Use to derive a replacement value from an array element at a specific index\n * while leaving the other elements unchanged.\n *\n * **Details**\n *\n * Returns `Option.none()` when the index is out of bounds.\n *\n * **Example** (Modifying an element)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * const values = [1, 2, 3, 4]\n * const double = (n: number) => n * 2\n *\n * Array.modify(values, 2, double) // => Option.some([1, 2, 6, 4])\n * Array.modify(values, 5, double) // => Option.none()\n * ```\n *\n * @see {@link replace} — set a fixed value at an index\n * @see {@link modifyHeadNonEmpty} — modify the first element\n * @see {@link modifyLastNonEmpty} — modify the last element\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const modify = /*#__PURE__*/dual(3, (self, i, f) => {\n const arr = Array.from(self);\n const index = Math.floor(i);\n if (isOutOfBounds(index, arr)) {\n return Option.none();\n }\n const out = arr;\n const b = f(arr[index]);\n out[index] = b;\n return Option.some(out);\n});\n/**\n * Removes the element at the specified index, returning a new array. If the\n * index is out of bounds, returns a copy of the original.\n *\n * **When to use**\n *\n * Use when you want a missing index to be a no-op and need a fresh array result\n * instead of an optional failure.\n *\n * **Example** (Removing an element)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.remove([1, 2, 3, 4], 2) // => [1, 2, 4]\n * Array.remove([1, 2, 3, 4], 5) // => [1, 2, 3, 4]\n * ```\n *\n * @see {@link insertAt} — insert an element\n * @see {@link filter} — remove elements by predicate\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const remove = /*#__PURE__*/dual(2, (self, i) => {\n const out = Array.from(self);\n const index = Math.floor(i);\n if (isOutOfBounds(index, out)) {\n return out;\n }\n out.splice(index, 1);\n return out;\n});\n/**\n * Reverses an iterable into a new array.\n *\n * **When to use**\n *\n * Use to reverse an iterable into a new array without mutating the original\n * input.\n *\n * **Details**\n *\n * Preserves `NonEmptyArray` in the return type.\n *\n * **Example** (Reversing an array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.reverse([1, 2, 3, 4]) // => [4, 3, 2, 1]\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const reverse = self => Array.from(self).reverse();\n/**\n * Sorts an array by the given `Order`, returning a new array.\n *\n * **When to use**\n *\n * Use to sort an array using a single `Order` comparator.\n *\n * **Details**\n *\n * Preserves `NonEmptyArray` in the return type. Use `sortWith` to sort by a\n * derived key, or `sortBy` for multi-key sorting.\n *\n * **Example** (Sorting numbers)\n *\n * ```ts import.meta.vitest\n * import { Array, Order } from \"effect\"\n *\n * Array.sort([3, 1, 4, 1, 5], Order.Number) // => [1, 1, 3, 4, 5]\n * ```\n *\n * @see {@link sortWith} — sort by a mapping function\n * @see {@link sortBy} — sort by multiple orders\n *\n * @category sorting\n * @since 2.0.0\n */\nexport const sort = /*#__PURE__*/dual(2, (self, O) => {\n const out = Array.from(self);\n out.sort(O);\n return out;\n});\n/**\n * Sorts an array by a derived key using a mapping function and an `Order` for\n * that key.\n *\n * **When to use**\n *\n * Use when you need to sort values by a derived key, such as a string length or\n * object field, while keeping the original values.\n *\n * **Details**\n *\n * Equivalent to `sort(Order.mapInput(order, f))`, but more convenient.\n *\n * **Example** (Sorting strings by length)\n *\n * ```ts import.meta.vitest\n * import { Array, Order } from \"effect\"\n *\n * Array.sortWith([\"aaa\", \"b\", \"cc\"], (s) => s.length, Order.Number) // => [\"b\", \"cc\", \"aaa\"]\n * ```\n *\n * @see {@link sort} for sorting with an `Order` that compares the elements directly\n * @see {@link sortBy} for sorting with multiple `Order`s applied in sequence\n *\n * @category sorting\n * @since 2.0.0\n */\nexport const sortWith = /*#__PURE__*/dual(3, (self, f, order) => Array.from(self).map(a => [a, f(a)]).sort(([, a], [, b]) => order(a, b)).map(([_]) => _));\n/**\n * Sorts an array by multiple `Order`s applied in sequence: the first order is\n * used first; ties are broken by the second order, and so on.\n *\n * **When to use**\n *\n * Use to sort by multiple criteria where later orders break ties from earlier\n * ones.\n *\n * **Details**\n *\n * This is data-last only and returns a function. The return type preserves\n * `NonEmptyArray`.\n *\n * **Example** (Sorting by multiple keys)\n *\n * ```ts import.meta.vitest\n * import { Array, Order, pipe } from \"effect\"\n *\n * const users = [\n * { name: \"Alice\", age: 30 },\n * { name: \"Bob\", age: 25 },\n * { name: \"Charlie\", age: 30 }\n * ]\n *\n * const sortedUsers = pipe(\n * users,\n * Array.sortBy(\n * Order.mapInput(Order.Number, (user: (typeof users)[number]) => user.age),\n * Order.mapInput(Order.String, (user: (typeof users)[number]) => user.name)\n * )\n * )\n *\n * sortedUsers.map((user) => user.name).join(\",\") // => \"Bob,Alice,Charlie\"\n * ```\n *\n * @see {@link sort} — sort by a single `Order`\n * @see {@link sortWith} — sort by a derived key\n *\n * @category sorting\n * @since 2.0.0\n */\nexport const sortBy = (...orders) => {\n const sortByAll = sort(Order.combineAll(orders));\n return self => {\n const input = fromIterable(self);\n if (isReadonlyArrayNonEmpty(input)) {\n return sortByAll(input);\n }\n return [];\n };\n};\n/**\n * Pairs elements from two iterables by position. If the iterables differ in\n * length, the extra elements from the longer one are discarded.\n *\n * **When to use**\n *\n * Use when you need simple pairs of corresponding elements from two iterables.\n *\n * **Details**\n *\n * Returns `NonEmptyArray` when both inputs are non-empty.\n *\n * **Example** (Zipping two arrays)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.zip([1, 2, 3], [\"a\", \"b\"]) // => [[1, \"a\"], [2, \"b\"]]\n * ```\n *\n * @see {@link zipWith} — zip with a combiner function\n * @see {@link unzip} — inverse operation\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zip = /*#__PURE__*/dual(2, (self, that) => zipWith(self, that, Tuple.make));\n/**\n * Combines elements from two iterables pairwise using a function. If the\n * iterables differ in length, extra elements are discarded.\n *\n * **When to use**\n *\n * Use when zipping two iterables in an array pipeline and each pair should\n * become a computed array element instead of a tuple.\n *\n * **Example** (Zipping with addition)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b) // => [5, 7, 9]\n * ```\n *\n * @see {@link zip} — zip into tuples\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipWith = /*#__PURE__*/dual(3, (self, that, f) => {\n const as = fromIterable(self);\n const bs = fromIterable(that);\n if (isReadonlyArrayNonEmpty(as) && isReadonlyArrayNonEmpty(bs)) {\n const out = [f(headNonEmpty(as), headNonEmpty(bs))];\n const len = Math.min(as.length, bs.length);\n for (let i = 1; i < len; i++) {\n out[i] = f(as[i], bs[i]);\n }\n return out;\n }\n return [];\n});\n/**\n * Splits an array of pairs into two arrays. Inverse of {@link zip}.\n *\n * **Example** (Unzipping pairs)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.unzip([[1, \"a\"], [2, \"b\"], [3, \"c\"]]) // => [[1, 2, 3], [\"a\", \"b\", \"c\"]]\n * ```\n *\n * @see {@link zip} — combine two arrays into pairs\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const unzip = self => {\n const input = fromIterable(self);\n if (isReadonlyArrayNonEmpty(input)) {\n const fa = [input[0][0]];\n const fb = [input[0][1]];\n for (let i = 1; i < input.length; i++) {\n fa[i] = input[i][0];\n fb[i] = input[i][1];\n }\n return [fa, fb];\n }\n return [[], []];\n};\n/**\n * Places a separator element between every pair of elements.\n *\n * **When to use**\n *\n * Use to insert a separator between elements, for example when preparing data for display or concatenation.\n *\n * **Details**\n *\n * The return type preserves `NonEmptyArray`. Empty inputs produce an empty\n * result.\n *\n * **Example** (Interspersing a separator)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.intersperse([1, 2, 3], 0) // => [1, 0, 2, 0, 3]\n * ```\n *\n * @see {@link join} — intersperse and join into a string\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const intersperse = /*#__PURE__*/dual(2, (self, middle) => {\n const input = fromIterable(self);\n if (isReadonlyArrayNonEmpty(input)) {\n const out = [headNonEmpty(input)];\n const tail = tailNonEmpty(input);\n for (let i = 0; i < tail.length; i++) {\n if (i < tail.length) {\n out.push(middle);\n }\n out.push(tail[i]);\n }\n return out;\n }\n return [];\n});\n/**\n * Applies a function to the first element of a non-empty array, returning a\n * new array.\n *\n * **When to use**\n *\n * Use to transform the first element of a non-empty array while preserving the rest.\n *\n * **Example** (Modifying the head)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.modifyHeadNonEmpty([1, 2, 3], (n) => n * 10) // => [10, 2, 3]\n * ```\n *\n * @see {@link setHeadNonEmpty} — replace with a fixed value\n * @see {@link modifyLastNonEmpty} — modify the last element\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const modifyHeadNonEmpty = /*#__PURE__*/dual(2, (self, f) => [f(headNonEmpty(self)), ...tailNonEmpty(self)]);\n/**\n * Replaces the first element of a non-empty array with a new value.\n *\n * **When to use**\n *\n * Use when you already know the array is non-empty and the replacement value\n * does not depend on the current first element.\n *\n * **Example** (Setting the head)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.setHeadNonEmpty([1, 2, 3], 10) // => [10, 2, 3]\n * ```\n *\n * @see {@link modifyHeadNonEmpty} — transform the head with a function\n * @see {@link setLastNonEmpty} — replace the last element\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const setHeadNonEmpty = /*#__PURE__*/dual(2, (self, b) => modifyHeadNonEmpty(self, () => b));\n/**\n * Applies a function to the last element of a non-empty array, returning a\n * new array.\n *\n * **When to use**\n *\n * Use when you already know the array is non-empty and the new last element\n * depends on the current last element.\n *\n * **Example** (Modifying the last element)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.modifyLastNonEmpty([1, 2, 3], (n) => n * 2) // => [1, 2, 6]\n * ```\n *\n * @see {@link setLastNonEmpty} — replace with a fixed value\n * @see {@link modifyHeadNonEmpty} — modify the first element\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const modifyLastNonEmpty = /*#__PURE__*/dual(2, (self, f) => append(initNonEmpty(self), f(lastNonEmpty(self))));\n/**\n * Replaces the last element of a non-empty array with a new value.\n *\n * **When to use**\n *\n * Use when you already know the array is non-empty and the replacement value\n * does not depend on the current last element.\n *\n * **Example** (Setting the last element)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.setLastNonEmpty([1, 2, 3], 4) // => [1, 2, 4]\n * ```\n *\n * @see {@link modifyLastNonEmpty} — transform the last element with a function\n * @see {@link setHeadNonEmpty} — replace the first element\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const setLastNonEmpty = /*#__PURE__*/dual(2, (self, b) => modifyLastNonEmpty(self, () => b));\n/**\n * Transforms an array by rotating it `n` steps. Positive `n` rotates right; negative `n`\n * rotates left.\n *\n * **When to use**\n *\n * Use when elements should wrap around the end of the array rather than being\n * dropped.\n *\n * **Details**\n *\n * `n` is rounded to the nearest integer before rotating. The return type\n * preserves `NonEmptyArray`. Empty arrays, or rotations normalized to `0`,\n * return a copy.\n *\n * **Example** (Rotating elements)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.rotate([\"a\", \"b\", \"c\", \"d\"], 2) // => [\"c\", \"d\", \"a\", \"b\"]\n * ```\n *\n * @see {@link take} for taking a fixed number of elements from the start\n * @see {@link drop} for dropping a fixed number of elements from the start\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const rotate = /*#__PURE__*/dual(2, (self, n) => {\n const input = fromIterable(self);\n if (isReadonlyArrayNonEmpty(input)) {\n const len = input.length;\n const m = Math.round(n) % len;\n if (isOutOfBounds(Math.abs(m), input) || m === 0) {\n return copy(input);\n }\n if (m < 0) {\n const [f, s] = splitAtNonEmpty(input, -m);\n return appendAll(s, f);\n } else {\n return rotate(input, m - len);\n }\n }\n return [];\n});\n/**\n * Returns a membership-test function using a custom equivalence.\n *\n * **When to use**\n *\n * Use when checking membership with caller-provided equality instead of\n * `Equal.equivalence()`.\n *\n * **Example** (Checking with custom equality)\n *\n * ```ts import.meta.vitest\n * import { Array, pipe } from \"effect\"\n *\n * const containsNumber = Array.containsWith((a: number, b: number) => a === b)\n *\n * pipe([1, 2, 3, 4], containsNumber(3)) // => true\n * ```\n *\n * @see {@link contains} for the `Equal.equivalence()` variant\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const containsWith = isEquivalent => dual(2, (self, a) => {\n for (const i of self) {\n if (isEquivalent(a, i)) {\n return true;\n }\n }\n return false;\n});\n/**\n * Checks whether an array contains a value, using `Equal.equivalence()` for\n * comparison.\n *\n * **When to use**\n *\n * Use to check whether an iterable contains a value using Effect's default\n * equality instead of providing a comparison function.\n *\n * **Example** (Checking membership)\n *\n * ```ts import.meta.vitest\n * import { Array, pipe } from \"effect\"\n *\n * pipe([\"a\", \"b\", \"c\", \"d\"], Array.contains(\"c\")) // => true\n * ```\n *\n * @see {@link containsWith} — use custom equality\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const contains = /*#__PURE__*/containsWith(/*#__PURE__*/Equal.asEquivalence());\n/**\n * Applies a function repeatedly to consume prefixes of the array and collect\n * the values it produces.\n *\n * **When to use**\n *\n * Use when you need custom grouping logic where each step returns both a value\n * and the remaining input.\n *\n * **Details**\n *\n * The function receives a `NonEmptyReadonlyArray` and returns `[value, rest]`.\n * Processing continues until the remaining array is empty.\n *\n * **Example** (Chopping an array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.chop([1, 2, 3, 4, 5], (as): [number, Array] => [as[0] * 2, as.slice(1)]) // => [2, 4, 6, 8, 10]\n * ```\n *\n * @see {@link chunksOf} — split into fixed-size chunks\n * @see {@link splitAt} — split at an index\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const chop = /*#__PURE__*/dual(2, (self, f) => {\n const input = fromIterable(self);\n if (isReadonlyArrayNonEmpty(input)) {\n const [b, rest] = f(input);\n const out = [b];\n let next = rest;\n while (internalArray.isArrayNonEmpty(next)) {\n const [b, rest] = f(next);\n out.push(b);\n next = rest;\n }\n return out;\n }\n return [];\n});\n/**\n * Splits an iterable into two arrays at the given index.\n *\n * **When to use**\n *\n * Use to divide an array into a prefix and suffix at a specific position.\n *\n * **Details**\n *\n * `n` is rounded down and clamped to `[0, length]`. `NaN` is treated as `0`,\n * which places all elements in the second array.\n *\n * **Example** (Splitting at an index)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.splitAt([1, 2, 3, 4, 5], 3) // => [[1, 2, 3], [4, 5]]\n * ```\n *\n * @see {@link splitAtNonEmpty} — for non-empty arrays\n * @see {@link splitWhere} — split at a predicate boundary\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const splitAt = /*#__PURE__*/dual(2, (self, n) => {\n const input = Array.from(self);\n const _n = Count.normalize(n);\n if (isReadonlyArrayNonEmpty(input)) {\n if (_n >= 1) {\n return splitAtNonEmpty(input, _n);\n }\n return [[], input];\n }\n return [input, []];\n});\n/**\n * Splits a non-empty array into two parts at the given index. The first part\n * is guaranteed to be non-empty (`n` is clamped to >= 1).\n *\n * **When to use**\n *\n * Use when downstream code requires the left side of the split to contain at\n * least one element.\n *\n * **Details**\n *\n * `n` is rounded down and clamped to `[1, length]`. `NaN` is treated as `1`.\n *\n * **Example** (Splitting a non-empty array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.splitAtNonEmpty([\"a\", \"b\", \"c\", \"d\", \"e\"], 3) // => [[\"a\", \"b\", \"c\"], [\"d\", \"e\"]]\n * ```\n *\n * @see {@link splitAt} — for possibly-empty arrays\n *\n * @category splitting\n * @since 4.0.0\n */\nexport const splitAtNonEmpty = /*#__PURE__*/dual(2, (self, n) => {\n const _n = Count.normalizeNonEmpty(n);\n return _n >= self.length ? [copy(self), []] : [prepend(self.slice(1, _n), headNonEmpty(self)), self.slice(_n)];\n});\n/**\n * Splits an iterable into `n` roughly equal-sized chunks.\n *\n * **When to use**\n *\n * Use to distribute elements across a fixed number of groups, such as when splitting work across threads.\n *\n * **Details**\n *\n * `n` is rounded down and normalized to at least `1`, with `NaN` treated as\n * `1`. The last chunk may be shorter.\n *\n * **Example** (Splitting into groups)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.split([1, 2, 3, 4, 5, 6, 7, 8], 3) // => [[1, 2, 3], [4, 5, 6], [7, 8]]\n * ```\n *\n * @see {@link chunksOf} — split into fixed-size chunks\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const split = /*#__PURE__*/dual(2, (self, n) => {\n const input = fromIterable(self);\n return chunksOf(input, Math.ceil(input.length / Count.normalizeNonEmpty(n)));\n});\n/**\n * Splits an iterable at the first element matching the predicate. The matching\n * element is included in the second array.\n *\n * **When to use**\n *\n * Use when you need to split an array at the first element that marks a\n * condition boundary.\n *\n * **Example** (Splitting at a condition)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.splitWhere([1, 2, 3, 4, 5], (n) => n > 3) // => [[1, 2, 3], [4, 5]]\n * ```\n *\n * @see {@link span} — splits at the first element that fails the predicate\n * @see {@link splitAt} — split at a fixed index\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const splitWhere = /*#__PURE__*/dual(2, (self, predicate) => span(self, (a, i) => !predicate(a, i)));\n/**\n * Creates a shallow copy of an array.\n *\n * **When to use**\n *\n * Use to create a distinct array reference for an existing array, for example\n * before mutating the returned array.\n *\n * **Details**\n *\n * The return type preserves `NonEmptyArray`. Use this when you need a distinct\n * reference, for example before mutating the returned array.\n *\n * **Example** (Copying an array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const original = [1, 2, 3]\n * const copied = Array.copy(original)\n *\n * copied // => [1, 2, 3]\n * original === copied // => false\n * ```\n *\n * @see {@link fromIterable} — returns the same reference for arrays\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const copy = self => self.slice();\n/**\n * Pads or truncates an array to exactly `n` elements, filling with `fill`\n * if the array is shorter, or slicing if longer.\n *\n * **When to use**\n *\n * Use to ensure an array has a specific length, padding with a fill value or truncating as needed.\n *\n * **Details**\n *\n * `n` is rounded down. `NaN` and non-positive values are treated as `0`, which\n * returns an empty array.\n *\n * **Example** (Padding an array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.pad([1, 2, 3], 6, 0) // => [1, 2, 3, 0, 0, 0]\n * ```\n *\n * @see {@link take} — truncate without padding\n * @see {@link replicate} — create an array of a single repeated value\n *\n * @category transforming\n * @since 3.8.4\n */\nexport const pad = /*#__PURE__*/dual(3, (self, n, fill) => {\n const length = Count.normalize(n);\n if (self.length >= length) {\n return take(self, length);\n }\n return appendAll(self, makeBy(length - self.length, () => fill));\n});\n/**\n * Splits an iterable into chunks of length `n`. The last chunk may be shorter\n * if `n` does not evenly divide the length.\n *\n * **When to use**\n *\n * Use to divide an iterable into a new array of non-overlapping chunks with a\n * maximum chunk size.\n *\n * **Details**\n *\n * `n` is rounded down and normalized to at least `1`; `NaN` and non-positive\n * values therefore produce singleton chunks. `chunksOf(n)([])` is `[]`, not\n * `[[]]`. Each chunk is a `NonEmptyArray`, and the outer return type preserves\n * `NonEmptyArray`.\n *\n * **Example** (Chunking an array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.chunksOf([1, 2, 3, 4, 5], 2) // => [[1, 2], [3, 4], [5]]\n * ```\n *\n * @see {@link split} — split into a given number of groups\n * @see {@link window} — sliding windows\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const chunksOf = /*#__PURE__*/dual(2, (self, n) => {\n const input = fromIterable(self);\n if (isReadonlyArrayNonEmpty(input)) {\n return chop(input, splitAtNonEmpty(n));\n }\n return [];\n});\n/**\n * Creates overlapping sliding windows of size `n`.\n *\n * **When to use**\n *\n * Use to process sequences with a moving window, such as for computing running averages or detecting patterns.\n *\n * **Details**\n *\n * `n` is rounded down, with `NaN` and non-positive values treated as `0`.\n * Returns an empty array if the normalized size is `0` or exceeds the array\n * length. Each window is a tuple of exactly the normalized size.\n *\n * **Example** (Creating sliding windows)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const values = [1, 2, 3, 4, 5]\n *\n * Array.window(values, 3) // => [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n * Array.window(values, 6) // => []\n * ```\n *\n * @see {@link chunksOf} — non-overlapping chunks\n *\n * @category splitting\n * @since 3.13.2\n */\nexport const window = /*#__PURE__*/dual(2, (self, n) => {\n const input = fromIterable(self);\n const size = Count.normalize(n);\n if (size > 0 && size <= input.length && isReadonlyArrayNonEmpty(input)) {\n return Array.from({\n length: input.length - (size - 1)\n }, (_, index) => input.slice(index, index + size));\n }\n return [];\n});\n/**\n * Groups consecutive equal elements using a custom equivalence function.\n *\n * **When to use**\n *\n * Use when you already have a non-empty array arranged so matching elements are\n * adjacent and need a custom equivalence function.\n *\n * **Details**\n *\n * Only adjacent elements are grouped. Non-adjacent duplicates stay separate.\n * Requires a `NonEmptyReadonlyArray`.\n *\n * **Example** (Grouping consecutive equal elements)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.groupWith(\n * [\"a\", \"a\", \"b\", \"b\", \"b\", \"c\", \"a\"],\n * (x, y) => x === y\n * ) // => [[\"a\", \"a\"], [\"b\", \"b\", \"b\"], [\"c\"], [\"a\"]]\n * ```\n *\n * @see {@link group} for grouping adjacent elements with `Equal.equivalence()`\n * @see {@link groupBy} for grouping all elements into a record by key, regardless of adjacency\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const groupWith = /*#__PURE__*/dual(2, (self, isEquivalent) => chop(self, as => {\n const h = headNonEmpty(as);\n const out = [h];\n let i = 1;\n for (; i < as.length; i++) {\n const a = as[i];\n if (isEquivalent(a, h)) {\n out.push(a);\n } else {\n break;\n }\n }\n return [out, as.slice(i)];\n}));\n/**\n * Groups consecutive equal elements using `Equal.equivalence()`.\n *\n * **When to use**\n *\n * Use when you already have adjacent equal values and Effect's default equality\n * is the right comparison.\n *\n * **Details**\n *\n * Only adjacent elements are grouped.\n *\n * **Example** (Grouping adjacent equal elements)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.group([1, 1, 2, 2, 2, 3, 1]) // => [[1, 1], [2, 2, 2], [3], [1]]\n * ```\n *\n * @see {@link groupWith} — use custom equality\n * @see {@link groupBy} — group by a key function into a record\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const group = /*#__PURE__*/groupWith(/*#__PURE__*/Equal.asEquivalence());\n/**\n * Groups elements into a record by a key-returning function. Each key maps\n * to a `NonEmptyArray` of elements that produced that key.\n *\n * **When to use**\n *\n * Use to build buckets of elements indexed by a computed string or symbol key.\n *\n * **Details**\n *\n * Unlike `group` and `groupWith`, elements do not need to be adjacent to be\n * grouped together. The key function must return a `string` or `symbol`.\n *\n * **Gotchas**\n *\n * When the key function returns a finite union of string literals or unique\n * symbols, the result preserves those keys as optional properties because the\n * input may not produce every key. Open `string` and `symbol` key types retain\n * their record index signatures.\n *\n * **Example** (Grouping by a property)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const people = [\n * { name: \"Alice\", group: \"A\" },\n * { name: \"Bob\", group: \"B\" },\n * { name: \"Charlie\", group: \"A\" }\n * ]\n *\n * Object.keys(Array.groupBy(people, (person) => person.group)).join(\",\") // => \"A,B\"\n * ```\n *\n * @see {@link group} — group adjacent equal elements\n * @see {@link groupWith} — group adjacent elements by custom equality\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const groupBy = /*#__PURE__*/dual(2, (self, f) => {\n const out = {};\n for (const a of self) {\n const k = f(a);\n if (Object.hasOwn(out, k)) {\n out[k].push(a);\n } else {\n InternalRecord.assignProperty(out, k, [a]);\n }\n }\n return out;\n});\nconst hashBucketsAdd = (buckets, value) => {\n const hash = Hash.hash(value);\n const bucket = buckets.get(hash);\n if (bucket === undefined) {\n buckets.set(hash, [value]);\n return true;\n }\n // Hash collisions still require an Effect equality check.\n for (const previous of bucket) {\n if (Equal.equals(previous, value)) {\n return false;\n }\n }\n bucket.push(value);\n return true;\n};\nconst makeHashBuckets = values => {\n const buckets = new Map();\n for (const value of values) {\n hashBucketsAdd(buckets, value);\n }\n return buckets;\n};\nconst hashBucketsHas = (buckets, value) => {\n const bucket = buckets.get(Hash.hash(value));\n if (bucket === undefined) {\n return false;\n }\n for (const candidate of bucket) {\n if (Equal.equals(candidate, value)) {\n return true;\n }\n }\n return false;\n};\n/**\n * Computes the union of two arrays using a custom equivalence, removing\n * duplicates.\n *\n * **When to use**\n *\n * Use when you need the union of two arrays but duplicate detection must use a\n * custom equivalence instead of the default `Equal.equivalence()`.\n *\n * **Example** (Computing unions with custom equality)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.unionWith([1, 2], [2, 3], (a, b) => a === b) // => [1, 2, 3]\n * ```\n *\n * @see {@link union} for the `Equal.equivalence()` variant\n * @see {@link intersectionWith} for keeping elements present in both arrays\n * @see {@link differenceWith} for keeping elements present only in the first array\n *\n * @category set operations\n * @since 2.0.0\n */\nexport const unionWith = /*#__PURE__*/dual(3, (self, that, isEquivalent) => {\n const a = fromIterable(self);\n const b = fromIterable(that);\n if (isReadonlyArrayNonEmpty(a)) {\n if (isReadonlyArrayNonEmpty(b)) {\n const dedupe = dedupeWith(isEquivalent);\n return dedupe(appendAll(a, b));\n }\n return a;\n }\n return b;\n});\n/**\n * Computes the union of two arrays, removing duplicates using\n * `Equal.equivalence()`.\n *\n * **Example** (Computing array unions)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.union([1, 2], [2, 3]) // => [1, 2, 3]\n * ```\n *\n * @see {@link unionWith} — use custom equality\n * @see {@link intersection} — elements in both arrays\n * @see {@link difference} — elements only in the first array\n *\n * @category set operations\n * @since 2.0.0\n */\nexport const union = /*#__PURE__*/dual(2, (self, that) => {\n const a = fromIterable(self);\n const b = fromIterable(that);\n if (isReadonlyArrayNonEmpty(a)) {\n return isReadonlyArrayNonEmpty(b) ? dedupe(appendAll(a, b)) : a;\n }\n return b;\n});\n/**\n * Computes the intersection of two arrays using a custom equivalence. Order is\n * determined by the first array.\n *\n * **When to use**\n *\n * Use when you need to keep only values present in both arrays and equality\n * must be defined by a custom comparator, such as matching objects by id.\n *\n * **Example** (Computing intersections with custom equality)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }]\n * const array2 = [{ id: 3 }, { id: 4 }, { id: 1 }]\n * const isEquivalent = (a: { id: number }, b: { id: number }) => a.id === b.id\n *\n * Array.intersectionWith(isEquivalent)(array2)(array1) // => [{ id: 1 }, { id: 3 }]\n * ```\n *\n * @see {@link intersection} for the `Equal.equivalence()` variant\n * @see {@link unionWith} for keeping values from either array with custom equality\n * @see {@link differenceWith} for keeping values only from the first array with custom equality\n *\n * @category set operations\n * @since 2.0.0\n */\nexport const intersectionWith = isEquivalent => {\n const has = containsWith(isEquivalent);\n return dual(2, (self, that) => {\n const thatArray = fromIterable(that);\n return fromIterable(self).filter(a => has(thatArray, a));\n });\n};\n/**\n * Computes the intersection of two arrays using `Equal.equivalence()`. Order is\n * determined by the first array.\n *\n * **When to use**\n *\n * Use when Effect equality is the right membership test and you want to keep\n * values present in both inputs while preserving the first input's order.\n *\n * **Example** (Computing array intersections)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.intersection([1, 2, 3], [3, 4, 1]) // => [1, 3]\n * ```\n *\n * @see {@link intersectionWith} — use custom equality\n * @see {@link union} — elements in either array\n * @see {@link difference} — elements only in the first array\n *\n * @category set operations\n * @since 2.0.0\n */\nexport const intersection = /*#__PURE__*/dual(2, (self, that) => {\n const thatArray = fromIterable(that);\n const selfArray = fromIterable(self);\n if (selfArray.length === 0 || thatArray.length === 0) {\n return [];\n }\n const buckets = makeHashBuckets(thatArray);\n return selfArray.filter(value => hashBucketsHas(buckets, value));\n});\n/**\n * Computes elements in the first array that are not in the second, using a\n * custom equivalence.\n *\n * **When to use**\n *\n * Use when you need to keep only values from the first array and equality must\n * be defined by a custom comparator, such as matching objects by id.\n *\n * **Example** (Computing differences with custom equality)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.differenceWith((a, b) => a === b)([1, 2, 3], [2, 3, 4]) // => [1]\n * ```\n *\n * @see {@link difference} for the `Equal.equivalence()` variant\n * @see {@link unionWith} for keeping values from either array with custom equality\n * @see {@link intersectionWith} for keeping values present in both arrays with custom equality\n *\n * @category set operations\n * @since 2.0.0\n */\nexport const differenceWith = isEquivalent => {\n const has = containsWith(isEquivalent);\n return dual(2, (self, that) => {\n const thatArray = fromIterable(that);\n return fromIterable(self).filter(a => !has(thatArray, a));\n });\n};\n/**\n * Computes elements in the first array that are not in the second, using\n * `Equal.equivalence()`.\n *\n * **When to use**\n *\n * Use when you need to keep values from the first array that are absent from\n * the second and the default `Equal.equivalence()` comparison is appropriate.\n *\n * **Example** (Computing array differences)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.difference([1, 2, 3], [2, 3, 4]) // => [1]\n * ```\n *\n * @see {@link differenceWith} — use custom equality\n * @see {@link union} — elements in either array\n * @see {@link intersection} — elements in both arrays\n *\n * @category set operations\n * @since 2.0.0\n */\nexport const difference = /*#__PURE__*/dual(2, (self, that) => {\n const thatArray = fromIterable(that);\n const selfArray = fromIterable(self);\n if (selfArray.length === 0) {\n return [];\n }\n if (thatArray.length === 0) {\n return selfArray.filter(() => true);\n }\n const buckets = makeHashBuckets(thatArray);\n return selfArray.filter(value => !hashBucketsHas(buckets, value));\n});\n/**\n * Creates an empty array.\n *\n * **When to use**\n *\n * Use to create a typed empty array without allocating placeholder elements.\n *\n * **Example** (Creating an empty array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.empty() // => []\n * ```\n *\n * @see {@link of} — create a single-element array\n * @see {@link make} — create from multiple values\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const empty = () => [];\n/**\n * Wraps a single value in a `NonEmptyArray`.\n *\n * **Example** (Creating a single-element array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.of(1) // => [1]\n * ```\n *\n * @see {@link make} — create from multiple values\n * @see {@link empty} — create an empty array\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const of = a => [a];\n/**\n * Transforms each element using a function, returning a new array.\n *\n * **When to use**\n *\n * Use to transform each element independently while preserving the array shape.\n *\n * **Details**\n *\n * The function receives `(element, index)`. The return type preserves\n * `NonEmptyArray`.\n *\n * **Example** (Doubling values)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.map([1, 2, 3], (x) => x * 2) // => [2, 4, 6]\n * ```\n *\n * @see {@link flatMap} — map and flatten\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, f) => self.map(f));\n/**\n * Maps each element to an array and flattens the results into a single array.\n *\n * **When to use**\n *\n * Use to map each array element to zero or more values and concatenate the\n * results in one pass.\n *\n * **Details**\n *\n * The function receives `(element, index)`. This returns `NonEmptyArray` when\n * both the input and mapped arrays are non-empty.\n *\n * **Example** (Flat mapping an array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.flatMap([1, 2, 3], (x) => [x, x * 2]) // => [1, 2, 2, 4, 3, 6]\n * ```\n *\n * @see {@link map} — transform without flattening\n * @see {@link flatten} — flatten without mapping\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const flatMap = /*#__PURE__*/dual(2, (self, f) => {\n if (isReadonlyArrayEmpty(self)) {\n return [];\n }\n const out = [];\n for (let i = 0; i < self.length; i++) {\n const inner = f(self[i], i);\n for (let j = 0; j < inner.length; j++) {\n out.push(inner[j]);\n }\n }\n return out;\n});\n/**\n * Flattens a nested array of arrays into a single array.\n *\n * **When to use**\n *\n * Use to collapse one level of nested arrays when no per-element mapping is\n * needed.\n *\n * **Example** (Flattening nested arrays)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.flatten([[1, 2], [], [3, 4], [], [5, 6]]) // => [1, 2, 3, 4, 5, 6]\n * ```\n *\n * @see {@link flatMap} — map then flatten in one step\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const flatten = /*#__PURE__*/flatMap(identity);\n/**\n * Extracts all `Some` values from an iterable of `Option`s, discarding `None`s.\n *\n * **When to use**\n *\n * Use to collect only present values from an iterable of `Option` values while\n * discarding `None` values.\n *\n * **Example** (Extracting Some values)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.getSomes([Option.some(1), Option.none(), Option.some(2)]) // => [1, 2]\n * ```\n *\n * @see {@link fromOption} — convert a single Option\n * @see {@link getSuccesses} — extract successes from Results\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const getSomes = self => {\n const out = [];\n for (const a of self) {\n if (Option.isSome(a)) {\n out.push(a.value);\n }\n }\n return out;\n};\n/**\n * Extracts all failure values from an iterable of `Result`s, discarding\n * successes.\n *\n * **When to use**\n *\n * Use when you can drop the success channel and only need the failure\n * payloads, not the original result wrappers.\n *\n * **Example** (Extracting failures)\n *\n * ```ts import.meta.vitest\n * import { Array, Result } from \"effect\"\n *\n * Array.getFailures([Result.succeed(1), Result.fail(\"err\"), Result.succeed(2)]) // => [\"err\"]\n * ```\n *\n * @see {@link getSuccesses} — extract success values\n * @see {@link separate} — split into failures and successes\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const getFailures = self => {\n const out = [];\n for (const a of self) {\n if (Result.isFailure(a)) {\n out.push(a.failure);\n }\n }\n return out;\n};\n/**\n * Extracts all success values from an iterable of `Result`s, discarding\n * failures.\n *\n * **When to use**\n *\n * Use when you can drop the failure channel and only need the success\n * payloads, not the original result wrappers.\n *\n * **Example** (Extracting successes)\n *\n * ```ts import.meta.vitest\n * import { Array, Result } from \"effect\"\n *\n * Array.getSuccesses([Result.succeed(1), Result.fail(\"err\"), Result.succeed(2)]) // => [1, 2]\n * ```\n *\n * @see {@link getFailures} — extract failure values\n * @see {@link separate} — split into failures and successes\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const getSuccesses = self => {\n const out = [];\n for (const a of self) {\n if (Result.isSuccess(a)) {\n out.push(a.success);\n }\n }\n return out;\n};\n/**\n * Keeps transformed values for elements where a `Filter` succeeds.\n *\n * **When to use**\n *\n * Use to filter an iterable with a `Result`-returning transformation while\n * discarding failures.\n *\n * **Details**\n *\n * The filter receives `(element, index)`. Failures are discarded.\n *\n * **Example** (Filtering and transforming)\n *\n * ```ts import.meta.vitest\n * import { Array, Result } from \"effect\"\n *\n * Array.filterMap([1, 2, 3, 4], (n) => n % 2 === 0 ? Result.succeed(n * 10) : Result.failVoid) // => [20, 40]\n * ```\n *\n * @see {@link filter} — keep original elements matching a predicate\n * @see {@link partition} for keeping both failures and successes\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filterMap = /*#__PURE__*/dual(2, (self, f) => {\n const as = fromIterable(self);\n const out = [];\n for (let i = 0; i < as.length; i++) {\n const result = f(as[i], i);\n if (Result.isSuccess(result)) {\n out.push(result.success);\n }\n }\n return out;\n});\n/**\n * Keeps only elements satisfying a predicate (or refinement).\n *\n * **When to use**\n *\n * Use to filter an iterable into a new array of original elements that satisfy\n * a boolean predicate or refinement.\n *\n * **Details**\n *\n * The predicate receives `(element, index)`. Refinements are supported for type\n * narrowing.\n *\n * **Example** (Filtering even numbers)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.filter([1, 2, 3, 4], (x) => x % 2 === 0) // => [2, 4]\n * ```\n *\n * @see {@link partition} — split into matching and non-matching\n * @see {@link filterMap} for transforming while filtering\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filter = /*#__PURE__*/dual(2, (self, predicate) => {\n const as = fromIterable(self);\n const out = [];\n for (let i = 0; i < as.length; i++) {\n if (predicate(as[i], i)) {\n out.push(as[i]);\n }\n }\n return out;\n});\n/**\n * Splits an iterable using a `Filter` into failures and successes.\n *\n * **When to use**\n *\n * Use to partition an iterable by evaluating each element with a\n * `Result`-returning filter and keeping both failure and success values.\n *\n * **Details**\n *\n * Returns `[excluded, satisfying]`. The filter receives `(element, index)`.\n *\n * **Example** (Partitioning with a filter)\n *\n * ```ts import.meta.vitest\n * import { Array, Result } from \"effect\"\n *\n * Array.partition([1, -2, 3], (n, i) =>\n * n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)\n * ) // => [[\"negative:-2\"], [1, 5]]\n * ```\n *\n * @see {@link filter} — keep only matching elements\n * @see {@link filterMap} for discarding failures\n * @see {@link separate} — split an iterable of `Result` values\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const partition = /*#__PURE__*/dual(2, (self, f) => {\n const excluded = [];\n const satisfying = [];\n let i = 0;\n for (const a of self) {\n const result = f(a, i++);\n if (Result.isSuccess(result)) {\n satisfying.push(result.success);\n } else {\n excluded.push(result.failure);\n }\n }\n return [excluded, satisfying];\n});\n/**\n * Separates an iterable of `Result`s into failure values and success values.\n *\n * **When to use**\n *\n * Use to split an iterable of `Result` values into failure and success arrays.\n *\n * **Details**\n *\n * Returns `[failures, successes]`. This is equivalent to\n * `partition(identity)`.\n *\n * **Example** (Separating Results)\n *\n * ```ts import.meta.vitest\n * import { Array, Result } from \"effect\"\n *\n * Array.separate([Result.succeed(1), Result.fail(\"error\"), Result.succeed(2)]) // => [[\"error\"], [1, 2]]\n * ```\n *\n * @see {@link getFailures} — extract only failures\n * @see {@link getSuccesses} — extract only successes\n * @see {@link partition} for computing `Result` values while splitting\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const separate = /*#__PURE__*/partition(identity);\n/**\n * Folds an iterable from left to right into a single value.\n *\n * **When to use**\n *\n * Use to combine all elements into one accumulated value from left to right.\n *\n * **Details**\n *\n * The function receives `(accumulator, element, index)`.\n *\n * **Example** (Summing an array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.reduce([1, 2, 3], 0, (acc, n) => acc + n) // => 6\n * ```\n *\n * @see {@link reduceRight} — fold from right to left\n * @see {@link scan} — fold keeping intermediate values\n *\n * @category folding\n * @since 2.0.0\n */\nexport const reduce = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(self).reduce((b, a, i) => f(b, a, i), b));\n/**\n * Folds an iterable from right to left into a single value.\n *\n * **When to use**\n *\n * Use when you need to fold values from right to left.\n *\n * **Details**\n *\n * The function receives `(accumulator, element, index)`.\n *\n * **Example** (Folding from right to left)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.reduceRight([1, 2, 3], 0, (acc, n) => acc + n) // => 6\n * ```\n *\n * @see {@link reduce} — fold from left to right\n * @see {@link scanRight} — fold keeping intermediate values\n *\n * @category folding\n * @since 2.0.0\n */\nexport const reduceRight = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(self).reduceRight((b, a, i) => f(b, a, i), b));\n/**\n * Lifts a predicate into an array: returns `[value]` if the predicate holds,\n * `[]` otherwise.\n *\n * **Example** (Wrapping values conditionally)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const fromEven = Array.liftPredicate((n: number) => n % 2 === 0)\n *\n * fromEven(1) // => []\n * fromEven(2) // => [2]\n * ```\n *\n * @see {@link liftOption} — lift an Option-returning function\n *\n * @category lifting\n * @since 2.0.0\n */\nexport const liftPredicate = predicate => b => predicate(b) ? [b] : [];\n/**\n * Lifts an `Option`-returning function into one that returns an array:\n * `Some(a)` becomes `[a]`, `None` becomes `[]`.\n *\n * **When to use**\n *\n * Use when an optional parser or lookup should participate in array pipelines\n * as zero-or-one results.\n *\n * **Example** (Lifting an Option function)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * const parseNumber = Array.liftOption((s: string) => {\n * const n = Number(s)\n * return isNaN(n) ? Option.none() : Option.some(n)\n * })\n *\n * parseNumber(\"123\") // => [123]\n * parseNumber(\"abc\") // => []\n * ```\n *\n * @see {@link liftPredicate} — lift a boolean predicate\n * @see {@link liftResult} — lift a Result-returning function\n *\n * @category lifting\n * @since 2.0.0\n */\nexport const liftOption = f => (...a) => fromOption(f(...a));\n/**\n * Converts a nullable value to an array: `null`/`undefined` becomes `[]`,\n * anything else becomes `[value]`.\n *\n * **When to use**\n *\n * Use to treat a nullable single value as zero or one array element.\n *\n * **Example** (Converting nullable values to an array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.fromNullishOr(1) // => [1]\n * Array.fromNullishOr(null) // => []\n * Array.fromNullishOr(undefined) // => []\n * ```\n *\n * @see {@link liftNullishOr} — lift a nullable-returning function\n * @see {@link fromOption} — convert from Option\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromNullishOr = a => a == null ? empty() : [a];\n/**\n * Lifts a nullable-returning function into one that returns an array:\n * `null`/`undefined` becomes `[]`, anything else becomes `[value]`.\n *\n * **Example** (Lifting a nullable function)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const parseNumber = Array.liftNullishOr((s: string) => {\n * const n = Number(s)\n * return isNaN(n) ? null : n\n * })\n *\n * parseNumber(\"123\") // => [123]\n * parseNumber(\"abc\") // => []\n * ```\n *\n * @see {@link fromNullishOr} — convert a single nullable value\n * @see {@link liftOption} — lift an Option-returning function\n *\n * @category lifting\n * @since 4.0.0\n */\nexport const liftNullishOr = f => (...a) => fromNullishOr(f(...a));\n/**\n * Maps each element with a nullable-returning function, keeping only non-null /\n * non-undefined results.\n *\n * **When to use**\n *\n * Use when you need to map and filter in one step, where the mapper can return\n * `null` or `undefined` to skip elements.\n *\n * **Example** (Flat mapping with nullable values)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.flatMapNullishOr([1, 2, 3], (n) => (n % 2 === 0 ? null : n)) // => [1, 3]\n * ```\n *\n * @see {@link flatMap} for mapping each element to an array and flattening\n * @see {@link fromNullishOr} for converting a single nullable value to an array\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const flatMapNullishOr = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => fromNullishOr(f(a))));\n/**\n * Lifts a `Result`-returning function into one that returns an array: failures\n * produce `[]`, successes produce `[value]`.\n *\n * **When to use**\n *\n * Use when a fallible parser or lookup should participate in array pipelines as\n * zero-or-one results and the failure value should be discarded.\n *\n * **Example** (Lifting a Result function)\n *\n * ```ts import.meta.vitest\n * import { Array, Result } from \"effect\"\n *\n * const parseNumber = (s: string): Result.Result =>\n * isNaN(Number(s))\n * ? Result.fail(new Error(\"Not a number\"))\n * : Result.succeed(Number(s))\n *\n * const liftedParseNumber = Array.liftResult(parseNumber)\n *\n * liftedParseNumber(\"42\") // => [42]\n * liftedParseNumber(\"not a number\") // => []\n * ```\n *\n * @see {@link liftOption} — lift an Option-returning function\n * @see {@link liftPredicate} — lift a boolean predicate\n *\n * @category lifting\n * @since 4.0.0\n */\nexport const liftResult = f => (...a) => {\n const e = f(...a);\n return Result.isFailure(e) ? [] : [e.success];\n};\n/**\n * Checks whether all elements satisfy the predicate. Supports refinements for\n * type narrowing.\n *\n * **When to use**\n *\n * Use to check whether every array element satisfies a predicate, including\n * refinement-based type narrowing.\n *\n * **Example** (Testing all elements)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.every([2, 4, 6], (x) => x % 2 === 0) // => true\n * Array.every([2, 3, 6], (x) => x % 2 === 0) // => false\n * ```\n *\n * @see {@link some} — test if any element matches\n *\n * @category guards\n * @since 2.0.0\n */\nexport const every = /*#__PURE__*/dual(2, (self, refinement) => self.every(refinement));\n/**\n * Checks whether at least one element satisfies the predicate. Narrows the type\n * to `NonEmptyReadonlyArray` on success.\n *\n * **Example** (Testing for any match)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.some([1, 3, 4], (x) => x % 2 === 0) // => true\n * Array.some([1, 3, 5], (x) => x % 2 === 0) // => false\n * ```\n *\n * @see {@link every} — test if all elements match\n * @see {@link contains} — test for a specific value\n *\n * @category guards\n * @since 2.0.0\n */\nexport const some = /*#__PURE__*/dual(2, (self, predicate) => self.some(predicate));\n/**\n * Applies a function to each suffix of the array (starting from each index),\n * collecting the results.\n *\n * **When to use**\n *\n * Use when you need to compute a result from every suffix of an array, such as\n * cumulative aggregations from each position.\n *\n * **Details**\n *\n * For index `i`, the function receives `self.slice(i)`.\n *\n * **Example** (Computing suffix lengths)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.extend([1, 2, 3], (as) => as.length) // => [3, 2, 1]\n * ```\n *\n * @see {@link scan} for keeping intermediate accumulator values during a fold\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const extend = /*#__PURE__*/dual(2, (self, f) => self.map((_, i, as) => f(as.slice(i))));\n/**\n * Returns the minimum element of a non-empty array according to the given\n * `Order`.\n *\n * **Example** (Finding the minimum)\n *\n * ```ts import.meta.vitest\n * import { Array, Order } from \"effect\"\n *\n * Array.min([3, 1, 2], Order.Number) // => 1\n * ```\n *\n * @see {@link max} — find the maximum\n * @see {@link sort} — sort the entire array\n *\n * @category getters\n * @since 2.0.0\n */\nexport const min = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.min(O)));\n/**\n * Returns the maximum element of a non-empty array according to the given\n * `Order`.\n *\n * **Example** (Finding the maximum)\n *\n * ```ts import.meta.vitest\n * import { Array, Order } from \"effect\"\n *\n * Array.max([3, 1, 2], Order.Number) // => 3\n * ```\n *\n * @see {@link min} — find the minimum\n * @see {@link sort} — sort the entire array\n *\n * @category getters\n * @since 2.0.0\n */\nexport const max = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.max(O)));\n/**\n * Builds an array by repeatedly applying a function to a seed value. The\n * function returns `Option.some([element, nextSeed])` to continue, or\n * `Option.none()` to stop.\n *\n * **Example** (Generating a sequence)\n *\n * ```ts import.meta.vitest\n * import { Array, Option } from \"effect\"\n *\n * Array.unfold(1, (n) => n <= 5 ? Option.some([n, n + 1]) : Option.none()) // => [1, 2, 3, 4, 5]\n * ```\n *\n * @see {@link makeBy} — generate from index\n * @see {@link range} — generate a numeric range\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const unfold = (b, f) => {\n const out = [];\n let next = b;\n while (true) {\n const o = f(next);\n if (Option.isNone(o)) {\n break;\n }\n const [a, b] = o.value;\n out.push(a);\n next = b;\n }\n return out;\n};\n/**\n * Creates an `Order` for arrays based on an element `Order`. Arrays are\n * compared element-wise; if all compared elements are equal, shorter arrays\n * come first.\n *\n * **Example** (Comparing arrays)\n *\n * ```ts import.meta.vitest\n * import { Array, Order } from \"effect\"\n *\n * const arrayOrder = Array.makeOrder(Order.Number)\n *\n * arrayOrder([1, 2], [1, 3]) // => -1\n * ```\n *\n * @see {@link makeEquivalence} — create an equivalence for arrays\n *\n * @category instances\n * @since 4.0.0\n */\nexport const makeOrder = Order.Array;\n/**\n * Creates an `Equivalence` for arrays based on an element `Equivalence`. Two\n * arrays are equivalent when they have the same length and all elements are\n * pairwise equivalent.\n *\n * **Example** (Comparing arrays for equality)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const eq = Array.makeEquivalence((a, b) => a === b)\n *\n * eq([1, 2, 3], [1, 2, 3]) // => true\n * ```\n *\n * @see {@link makeOrder} — create an ordering for arrays\n *\n * @category instances\n * @since 4.0.0\n */\nexport const makeEquivalence = Equivalence.Array;\n/**\n * Runs a side-effect for each element. The callback receives `(element, index)`.\n *\n * **When to use**\n *\n * Use to iterate over an array for side-effects only, when no transformed\n * result is needed.\n *\n * **Example** (Iterating with side-effects)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * const visited: Array = []\n * Array.forEach([1, 2, 3], (n) => visited.push(n))\n *\n * visited // => [1, 2, 3]\n * ```\n *\n * @see {@link map} for transforming each element into a new array\n *\n * @category traversing\n * @since 2.0.0\n */\nexport const forEach = /*#__PURE__*/dual(2, (self, f) => fromIterable(self).forEach((a, i) => f(a, i)));\n/**\n * Removes duplicates using a custom equivalence, preserving the order of the\n * first occurrence.\n *\n * **When to use**\n *\n * Use to remove all duplicate elements with a custom equivalence when default\n * equality is not appropriate.\n *\n * **Example** (Deduplicating with custom equality)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.dedupeWith([1, 2, 2, 3, 3, 3], (a, b) => a === b) // => [1, 2, 3]\n * ```\n *\n * @see {@link dedupe} — uses default equality\n * @see {@link dedupeAdjacentWith} — only dedupes consecutive elements\n *\n * @category deduplication\n * @since 2.0.0\n */\nexport const dedupeWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {\n const input = fromIterable(self);\n if (isReadonlyArrayNonEmpty(input)) {\n const out = [headNonEmpty(input)];\n const rest = tailNonEmpty(input);\n for (const r of rest) {\n if (out.every(a => !isEquivalent(r, a))) {\n out.push(r);\n }\n }\n return out;\n }\n return [];\n});\n/**\n * Removes duplicates using `Equal.equivalence()`, preserving the order of the\n * first occurrence.\n *\n * **When to use**\n *\n * Use to remove repeated values from an iterable when Effect's default equality\n * is the right comparison, preserving the first occurrence.\n *\n * **Example** (Removing duplicates)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.dedupe([1, 2, 1, 3, 2, 4]) // => [1, 2, 3, 4]\n * ```\n *\n * @see {@link dedupeWith} — use custom equality\n * @see {@link dedupeAdjacent} — only dedupes consecutive elements\n *\n * @category deduplication\n * @since 2.0.0\n */\nexport const dedupe = self => {\n const input = fromIterable(self);\n if (input.length < 2) {\n return [...input];\n }\n const buckets = new Map();\n const out = [];\n for (const value of input) {\n if (hashBucketsAdd(buckets, value)) {\n out.push(value);\n }\n }\n return out;\n};\n/**\n * Removes consecutive duplicate elements using a custom equivalence.\n *\n * **When to use**\n *\n * Use when consecutive duplicates should be collapsed using a custom\n * equivalence, while equivalent values that appear later should remain in the\n * result.\n *\n * **Details**\n *\n * Non-adjacent duplicates are preserved.\n *\n * **Example** (Deduplicating adjacent elements)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.dedupeAdjacentWith([1, 1, 2, 2, 3, 3], (a, b) => a === b) // => [1, 2, 3]\n * ```\n *\n * @see {@link dedupeAdjacent} — uses default equality\n * @see {@link dedupeWith} — dedupes all duplicates, not just adjacent\n *\n * @category deduplication\n * @since 2.0.0\n */\nexport const dedupeAdjacentWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {\n const out = [];\n let lastA = Option.none();\n for (const a of self) {\n if (Option.isNone(lastA) || !isEquivalent(a, lastA.value)) {\n out.push(a);\n lastA = Option.some(a);\n }\n }\n return out;\n});\n/**\n * Removes consecutive duplicate elements using `Equal.equivalence()`.\n *\n * **When to use**\n *\n * Use when you need to collapse consecutive duplicates while preserving later\n * non-consecutive repeats, and the default equality is sufficient.\n *\n * **Example** (Removing adjacent duplicates)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.dedupeAdjacent([1, 1, 2, 2, 3, 3]) // => [1, 2, 3]\n * ```\n *\n * @see {@link dedupeAdjacentWith} — use custom equality\n * @see {@link dedupe} — remove all duplicates\n *\n * @category deduplication\n * @since 2.0.0\n */\nexport const dedupeAdjacent = /*#__PURE__*/dedupeAdjacentWith(/*#__PURE__*/Equal.asEquivalence());\n/**\n * Joins string elements with a separator.\n *\n * **Example** (Joining strings)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.join([\"a\", \"b\", \"c\"], \"-\") // => \"a-b-c\"\n * ```\n *\n * @see {@link intersperse} — insert separator elements without joining\n *\n * @category folding\n * @since 2.0.0\n */\nexport const join = /*#__PURE__*/dual(2, (self, sep) => fromIterable(self).join(sep));\n/**\n * Maps over an array while threading an accumulator through each step, returning both the final state and the mapped array.\n *\n * **When to use**\n *\n * Use when you need to map while threading state through each element and keep\n * the final state.\n *\n * **Details**\n *\n * Combines `map` and `reduce` in a single pass. The callback receives the\n * current state, element, and index, and returns `[nextState, mappedValue]`.\n * The result is `[finalState, mappedArray]`. This can be used in both\n * data-first and data-last style.\n *\n * **Example** (Running sum alongside mapped values)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.mapAccum([1, 2, 3], 0, (acc, n) => [acc + n, acc + n]) // => [6, [1, 3, 6]]\n * ```\n *\n * @see {@link scan} — when you only need the accumulated results (not the final state)\n * @see {@link reduce} — when you only need the final accumulated value\n *\n * @category folding\n * @since 2.0.0\n */\nexport const mapAccum = /*#__PURE__*/dual(3, (self, s, f) => {\n let i = 0;\n let s1 = s;\n const out = [];\n for (const a of self) {\n const r = f(s1, a, i);\n s1 = r[0];\n out.push(r[1]);\n i++;\n }\n return [s1, out];\n});\n/**\n * Computes the cartesian product of two arrays, applying a combiner to each pair.\n *\n * **When to use**\n *\n * Use to compute every combination from two arrays and immediately transform\n * each pair into a custom result.\n *\n * **Details**\n *\n * Produces every combination of an element from `self` with an element from\n * `that`, so the result length is `self.length * that.length`. Iteration visits\n * every element of `that` for each element of `self`.\n *\n * **Example** (Combining numbers and letters)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.cartesianWith([1, 2], [\"a\", \"b\"], (a, b) => `${a}-${b}`) // => [\"1-a\", \"1-b\", \"2-a\", \"2-b\"]\n * ```\n *\n * @see {@link cartesian} for returning tuples instead of applying a combiner\n *\n * @category combining\n * @since 2.0.0\n */\nexport const cartesianWith = /*#__PURE__*/dual(3, (self, that, f) => flatMap(self, a => map(that, b => f(a, b))));\n/**\n * Computes the cartesian product of two arrays, returning all pairs as tuples.\n *\n * **When to use**\n *\n * Use when you need every `[a, b]` pair from two arrays as tuples.\n *\n * **Details**\n *\n * Produces every `[a, b]` combination of an element from `self` with an element\n * from `that`, so the result length is `self.length * that.length`.\n *\n * **Example** (Generating all pairs from two arrays)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.cartesian([1, 2], [\"a\", \"b\"]) // => [[1, \"a\"], [1, \"b\"], [2, \"a\"], [2, \"b\"]]\n * ```\n *\n * @see {@link cartesianWith} — apply a combiner to each pair\n *\n * @category combining\n * @since 2.0.0\n */\nexport const cartesian = /*#__PURE__*/dual(2, (self, that) => cartesianWith(self, that, (a, b) => [a, b]));\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * Provides the starting point for the \"do simulation\" — an array comprehension pattern.\n *\n * **When to use**\n *\n * Use when you want array-comprehension style code with do notation.\n *\n * **Details**\n *\n * Use {@link bind} to introduce array variables and {@link let_ let} for plain\n * values. Each `bind` produces the cartesian product of all bound variables,\n * like nested loops. Use `filter` and `map` in the pipeline to add conditions\n * and transformations.\n *\n * **Example** (Building array comprehensions with do notation)\n *\n * ```ts import.meta.vitest\n * import { Array, pipe } from \"effect\"\n *\n * pipe(\n * Array.Do,\n * Array.bind(\"x\", () => [1, 3, 5]),\n * Array.bind(\"y\", () => [2, 4, 6]),\n * Array.filter(({ x, y }) => x < y),\n * Array.map(({ x, y }) => [x, y] as const)\n * ) // => [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]]\n * ```\n *\n * @see {@link bind} — introduce an array variable into the scope\n * @see {@link bindTo} — start a pipeline by naming the first array\n * @see {@link let_ let} — introduce a plain computed value\n *\n * @category constructors\n * @since 3.2.0\n */\nexport const Do = /*#__PURE__*/of({});\n/**\n * Adds a new array variable to a do-notation scope, producing the cartesian product with all previous bindings.\n *\n * **When to use**\n *\n * Use to add another array-producing binding to an `Array.Do` pipeline, pairing\n * each existing scope with every value returned by the callback.\n *\n * **Details**\n *\n * Each `bind` call adds a named property to the accumulated object. The\n * callback receives the current scope and must return an array. This is\n * equivalent to `flatMap` plus merging the new value into the scope object.\n *\n * **Example** (Binding two arrays)\n *\n * ```ts import.meta.vitest\n * import { Array, pipe } from \"effect\"\n *\n * pipe(\n * Array.Do,\n * Array.bind(\"x\", () => [1, 2]),\n * Array.bind(\"y\", () => [\"a\", \"b\"])\n * ) // => [{ x: 1, y: \"a\" }, { x: 1, y: \"b\" }, { x: 2, y: \"a\" }, { x: 2, y: \"b\" }]\n * ```\n *\n * @see {@link Do} — start a do-notation pipeline\n * @see {@link bindTo} — name the first array in a pipeline\n * @see {@link let_ let} — add a plain computed value\n *\n * @category sequencing\n * @since 3.2.0\n */\nexport const bind = /*#__PURE__*/internalDoNotation.bind(map, flatMap);\n/**\n * Wraps each array element in an object with the given key, starting a do-notation scope.\n *\n * **When to use**\n *\n * Use when you already have an array and want to start a do-notation pipeline\n * by naming each element.\n *\n * **Details**\n *\n * Equivalent to `Array.map(self, (a) => ({ [tag]: a }))`. This is an\n * alternative to starting with `Do` plus `bind` when you already have an array.\n *\n * **Example** (Naming an existing array)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.bindTo([1, 2, 3], \"x\") // => [{ x: 1 }, { x: 2 }, { x: 3 }]\n * ```\n *\n * @see {@link Do} — start with an empty scope\n * @see {@link bind} — add another array variable to the scope\n *\n * @category mapping\n * @since 3.2.0\n */\nexport const bindTo = /*#__PURE__*/internalDoNotation.bindTo(map);\nconst let_ = /*#__PURE__*/internalDoNotation.let_(map);\nexport {\n/**\n * Adds a computed plain value to the do-notation scope without introducing a new array dimension.\n *\n * **When to use**\n *\n * Use when each do-notation branch needs a derived field from the current\n * bindings without multiplying the number of branches.\n *\n * **Details**\n *\n * Unlike `bind`, the callback returns a single value instead of an array, so\n * no cartesian product occurs. Use this for derived or intermediate values\n * that depend on previously bound variables.\n *\n * **Example** (Adding a computed value)\n *\n * ```ts import.meta.vitest\n * import { Array, pipe } from \"effect\"\n *\n * pipe(\n * Array.Do,\n * Array.bind(\"x\", () => [1, 2, 3]),\n * Array.let(\"doubled\", ({ x }) => x * 2)\n * ) // => [{ x: 1, doubled: 2 }, { x: 2, doubled: 4 }, { x: 3, doubled: 6 }]\n * ```\n *\n * @see {@link Do} — start a do-notation pipeline\n * @see {@link bind} — introduce an array variable (produces cartesian product)\n *\n * @category mapping\n * @since 3.2.0\n */\nlet_ as let };\nconst reducer = /*#__PURE__*/Reducer.make((a, b) => a.concat(b), []);\n/**\n * Returns a `Reducer` that combines `ReadonlyArray` values by concatenation.\n *\n * @see {@link makeReducerConcat} — mutable `Array` variant\n *\n * @category folding\n * @since 4.0.0\n */\nexport function getReadonlyReducerConcat() {\n return reducer;\n}\n/**\n * Returns a `Reducer` that combines `Array` values by concatenation.\n *\n * @see {@link getReadonlyReducerConcat} — readonly variant\n *\n * @category folding\n * @since 4.0.0\n */\nexport function makeReducerConcat() {\n return reducer;\n}\n/**\n * Computes the number of elements in an iterable that satisfy a predicate.\n *\n * **When to use**\n *\n * Use when you need to count how many elements of an iterable satisfy a\n * predicate.\n *\n * **Details**\n *\n * The predicate receives both the element and its index. Empty iterables return\n * `0`.\n *\n * **Example** (Counting even numbers)\n *\n * ```ts import.meta.vitest\n * import { Array } from \"effect\"\n *\n * Array.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0) // => 2\n * ```\n *\n * @see {@link filter} — when you need the matching elements, not just the count\n *\n * @category folding\n * @since 3.16.0\n */\nexport const countBy = /*#__PURE__*/dual(2, (self, f) => {\n let count = 0;\n const as = fromIterable(self);\n for (let i = 0; i < as.length; i++) {\n const a = as[i];\n if (f(a, i)) {\n count++;\n }\n }\n return count;\n});\n//# sourceMappingURL=Array.js.map","/**\n * Represents immutable spans of time.\n *\n * A `Duration` can be finite, positive infinity, or negative infinity. It is\n * the standard representation for delays, timeouts, intervals, and\n * time-to-live values across Effect APIs. This module includes constructors\n * from common input shapes, unit conversions, comparisons, arithmetic,\n * formatting, and reusable reducer or combiner helpers.\n *\n * @since 2.0.0\n */\nimport * as Combiner from \"./Combiner.js\";\nimport * as Equal from \"./Equal.js\";\nimport { dual, identity } from \"./Function.js\";\nimport * as Hash from \"./Hash.js\";\nimport { NodeInspectSymbol } from \"./Inspectable.js\";\nimport * as Option from \"./Option.js\";\nimport * as order from \"./Order.js\";\nimport { pipeArguments } from \"./Pipeable.js\";\nimport { hasProperty, isNumber } from \"./Predicate.js\";\nimport * as Reducer from \"./Reducer.js\";\nconst TypeId = \"~effect/Duration\";\nconst bigint0 = /*#__PURE__*/BigInt(0);\nconst bigint1 = /*#__PURE__*/BigInt(1);\nconst bigint2 = /*#__PURE__*/BigInt(2);\nconst bigint10 = /*#__PURE__*/BigInt(10);\nconst bigint24 = /*#__PURE__*/BigInt(24);\nconst bigint60 = /*#__PURE__*/BigInt(60);\nconst bigint1e3 = /*#__PURE__*/BigInt(1_000);\nconst bigint1e6 = /*#__PURE__*/BigInt(1_000_000);\nconst bigint1e9 = /*#__PURE__*/BigInt(1_000_000_000);\nconst roundTiesAwayFromZero = input => BigInt(input < 0 ? Math.ceil(input - 0.5) : Math.floor(input + 0.5));\nconst roundMillisToNanos = millis => roundTiesAwayFromZero(millis * 1_000_000);\nconst parseNanos = (input, scale) => {\n const decimalIndex = input.indexOf(\".\");\n if (decimalIndex === -1) return BigInt(input) * scale;\n const isNegative = input[0] === \"-\";\n const fractional = input.slice(decimalIndex + 1);\n const fractionalScale = bigint10 ** BigInt(fractional.length);\n const scaled = (BigInt(input.slice(isNegative ? 1 : 0, decimalIndex)) * fractionalScale + BigInt(fractional)) * scale;\n const rounded = scaled / fractionalScale + (scaled % fractionalScale * bigint2 >= fractionalScale ? bigint1 : bigint0);\n return isNegative ? -rounded : rounded;\n};\nconst nanosToHrTime = nanos => {\n const sign = nanos < bigint0 ? -bigint1 : bigint1;\n const absolute = nanos < bigint0 ? -nanos : nanos;\n return [Number(sign * (absolute / bigint1e9)), Number(sign * (absolute % bigint1e9))];\n};\nconst DURATION_REGEXP = /^(-?\\d+(?:\\.\\d+)?)\\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/;\n/**\n * Decodes a `Duration.Input` into a `Duration`.\n *\n * **When to use**\n *\n * Use when the input has already been validated or comes from a trusted source\n * and throwing is acceptable for invalid duration syntax.\n *\n * **Gotchas**\n *\n * If the input is not a valid `Duration.Input`, it throws an error.\n *\n * **Example** (Decoding duration inputs)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.fromInputUnsafe(1000) // => Duration.millis(1000)\n * Duration.fromInputUnsafe(\"5 seconds\") // => Duration.seconds(5)\n * Duration.fromInputUnsafe(\"Infinity\") // => Duration.infinity\n * Duration.fromInputUnsafe([2, 500_000_000]) // => Duration.nanos(2_500_000_000n)\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromInputUnsafe = input => {\n switch (typeof input) {\n case \"number\":\n return millis(input);\n case \"bigint\":\n return nanos(input);\n case \"string\":\n {\n if (input === \"Infinity\") {\n return infinity;\n }\n if (input === \"-Infinity\") {\n return negativeInfinity;\n }\n const match = DURATION_REGEXP.exec(input);\n if (!match) break;\n const [_, valueStr, unit] = match;\n if (unit === \"nano\" || unit === \"nanos\") {\n return nanos(parseNanos(valueStr, bigint1));\n }\n if (unit === \"micro\" || unit === \"micros\") {\n return nanos(parseNanos(valueStr, bigint1e3));\n }\n const value = Number(valueStr);\n switch (unit) {\n case \"milli\":\n case \"millis\":\n return millis(value);\n case \"second\":\n case \"seconds\":\n return seconds(value);\n case \"minute\":\n case \"minutes\":\n return minutes(value);\n case \"hour\":\n case \"hours\":\n return hours(value);\n case \"day\":\n case \"days\":\n return days(value);\n case \"week\":\n case \"weeks\":\n return weeks(value);\n }\n break;\n }\n case \"object\":\n {\n if (input === null) break;\n if (TypeId in input) return input;\n if (Array.isArray(input)) {\n if (input.length !== 2 || !input.every(isNumber)) {\n return invalid(input);\n }\n if (Number.isNaN(input[0]) || Number.isNaN(input[1])) {\n return zero;\n }\n if (input[0] === -Infinity || input[1] === -Infinity) {\n return negativeInfinity;\n }\n if (input[0] === Infinity || input[1] === Infinity) {\n return infinity;\n }\n return make(roundTiesAwayFromZero(input[0] * 1_000_000_000 + input[1]));\n }\n const obj = input;\n let millis = 0;\n // we can use truthy checks here, because 0 can be ignored\n if (obj.weeks) millis += obj.weeks * 604_800_000;\n if (obj.days) millis += obj.days * 86_400_000;\n if (obj.hours) millis += obj.hours * 3_600_000;\n if (obj.minutes) millis += obj.minutes * 60_000;\n if (obj.seconds) millis += obj.seconds * 1_000;\n if (obj.milliseconds) millis += obj.milliseconds;\n if (!obj.microseconds && !obj.nanoseconds) return make(millis);\n return make(roundTiesAwayFromZero(millis * 1_000_000 + (obj.microseconds ?? 0) * 1_000 + (obj.nanoseconds ?? 0)));\n }\n }\n return invalid(input);\n};\nconst invalid = input => {\n throw new Error(`Invalid Input: ${input}`);\n};\n/**\n * Decodes a `Input` value into a `Duration` safely, returning\n * `Option.none()` if decoding fails.\n *\n * **Example** (Safely decoding duration inputs)\n *\n * ```ts import.meta.vitest\n * import { Duration, Option } from \"effect\"\n *\n * Duration.fromInput(1000) // => Option.some(Duration.seconds(1))\n * Duration.fromInput(\"invalid\" as any) // => Option.none()\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromInput = /*#__PURE__*/Option.liftThrowable(fromInputUnsafe);\nconst zeroDurationValue = {\n _tag: \"Millis\",\n millis: 0\n};\nconst infinityDurationValue = {\n _tag: \"Infinity\"\n};\nconst negativeInfinityDurationValue = {\n _tag: \"NegativeInfinity\"\n};\nconst DurationProto = {\n [TypeId]: TypeId,\n [Hash.symbol]() {\n // Hash equal finite durations using the same canonical nanoseconds\n // representation used by `equals`.\n switch (this.value._tag) {\n case \"Millis\":\n {\n const nanos = this.value.millis * 1_000_000;\n return Number.isFinite(nanos) ? Hash.hash(roundTiesAwayFromZero(nanos)) : Hash.number(this.value.millis);\n }\n case \"Nanos\":\n return Hash.hash(this.value.nanos);\n default:\n return Hash.structure(this.value);\n }\n },\n [Equal.symbol](that) {\n return isDuration(that) && equals(this, that);\n },\n toString() {\n switch (this.value._tag) {\n case \"Infinity\":\n return \"Infinity\";\n case \"NegativeInfinity\":\n return \"-Infinity\";\n case \"Nanos\":\n return `${this.value.nanos} nanos`;\n case \"Millis\":\n return `${this.value.millis} millis`;\n }\n },\n toJSON() {\n switch (this.value._tag) {\n case \"Millis\":\n return {\n _id: \"Duration\",\n _tag: \"Millis\",\n millis: this.value.millis\n };\n case \"Nanos\":\n return {\n _id: \"Duration\",\n _tag: \"Nanos\",\n nanos: String(this.value.nanos)\n };\n case \"Infinity\":\n return {\n _id: \"Duration\",\n _tag: \"Infinity\"\n };\n case \"NegativeInfinity\":\n return {\n _id: \"Duration\",\n _tag: \"NegativeInfinity\"\n };\n }\n },\n [NodeInspectSymbol]() {\n return this.toJSON();\n },\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\nconst make = input => {\n const duration = Object.create(DurationProto);\n if (typeof input === \"number\") {\n if (isNaN(input) || input === 0 || Object.is(input, -0)) {\n duration.value = zeroDurationValue;\n } else if (!Number.isFinite(input)) {\n duration.value = input > 0 ? infinityDurationValue : negativeInfinityDurationValue;\n } else if (!Number.isInteger(input)) {\n duration.value = {\n _tag: \"Nanos\",\n nanos: roundMillisToNanos(input)\n };\n } else {\n duration.value = {\n _tag: \"Millis\",\n millis: input\n };\n }\n } else if (input === bigint0) {\n duration.value = zeroDurationValue;\n } else {\n duration.value = {\n _tag: \"Nanos\",\n nanos: input\n };\n }\n return duration;\n};\n/**\n * Checks whether a value is a Duration.\n *\n * **Example** (Checking for durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.isDuration(Duration.seconds(1)) // => true\n * Duration.isDuration(1000) // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isDuration = u => hasProperty(u, TypeId);\n/**\n * Checks whether a Duration is finite (not infinite).\n *\n * **Example** (Checking finite durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.isFinite(Duration.seconds(5)) // => true\n * Duration.isFinite(Duration.infinity) // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isFinite = self => self.value._tag !== \"Infinity\" && self.value._tag !== \"NegativeInfinity\";\n/**\n * Checks whether a Duration is zero.\n *\n * **Example** (Checking for zero durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.isZero(Duration.zero) // => true\n * Duration.isZero(Duration.seconds(1)) // => false\n * ```\n *\n * @category predicates\n * @since 3.5.0\n */\nexport const isZero = self => {\n switch (self.value._tag) {\n case \"Millis\":\n return self.value.millis === 0;\n case \"Nanos\":\n return self.value.nanos === bigint0;\n case \"Infinity\":\n case \"NegativeInfinity\":\n return false;\n }\n};\n/**\n * Returns `true` if the duration is negative (strictly less than zero).\n *\n * **Example** (Checking for negative durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.isNegative(Duration.seconds(-5)) // => true\n * Duration.isNegative(Duration.zero) // => false\n * Duration.isNegative(Duration.negativeInfinity) // => true\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isNegative = self => {\n switch (self.value._tag) {\n case \"Millis\":\n return self.value.millis < 0;\n case \"Nanos\":\n return self.value.nanos < bigint0;\n case \"NegativeInfinity\":\n return true;\n case \"Infinity\":\n return false;\n }\n};\n/**\n * Returns `true` if the duration is positive (strictly greater than zero).\n *\n * **Example** (Checking for positive durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.isPositive(Duration.seconds(5)) // => true\n * Duration.isPositive(Duration.zero) // => false\n * Duration.isPositive(Duration.infinity) // => true\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isPositive = self => {\n switch (self.value._tag) {\n case \"Millis\":\n return self.value.millis > 0;\n case \"Nanos\":\n return self.value.nanos > bigint0;\n case \"Infinity\":\n return true;\n case \"NegativeInfinity\":\n return false;\n }\n};\n/**\n * Returns the absolute value of the duration.\n *\n * **Example** (Taking absolute duration values)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.abs(Duration.seconds(-5)) // => Duration.seconds(5)\n * Duration.abs(Duration.negativeInfinity) // => Duration.infinity\n * ```\n *\n * @category math\n * @since 4.0.0\n */\nexport const abs = self => {\n switch (self.value._tag) {\n case \"Infinity\":\n case \"NegativeInfinity\":\n return infinity;\n case \"Millis\":\n return self.value.millis < 0 ? make(-self.value.millis) : self;\n case \"Nanos\":\n return self.value.nanos < bigint0 ? make(-self.value.nanos) : self;\n }\n};\n/**\n * Returns the negated duration.\n *\n * **Example** (Negating durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.negate(Duration.seconds(5)) // => Duration.seconds(-5)\n * Duration.negate(Duration.infinity) // => Duration.negativeInfinity\n * ```\n *\n * @category math\n * @since 4.0.0\n */\nexport const negate = self => {\n switch (self.value._tag) {\n case \"Infinity\":\n return negativeInfinity;\n case \"NegativeInfinity\":\n return infinity;\n case \"Millis\":\n return self.value.millis === 0 ? self : make(-self.value.millis);\n case \"Nanos\":\n return self.value.nanos === bigint0 ? self : make(-self.value.nanos);\n }\n};\n/**\n * A Duration representing zero time.\n *\n * **Example** (Referencing the zero duration)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMillis(Duration.zero) // => 0\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const zero = /*#__PURE__*/make(0);\n/**\n * A Duration representing infinite time.\n *\n * **Example** (Referencing infinite duration)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMillis(Duration.infinity) // => Infinity\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const infinity = /*#__PURE__*/make(Infinity);\n/**\n * A Duration representing negative infinite time.\n *\n * **Example** (Referencing negative infinite duration)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMillis(Duration.negativeInfinity) // => -Infinity\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const negativeInfinity = /*#__PURE__*/make(-Infinity);\n/**\n * Creates a Duration from nanoseconds.\n *\n * **Example** (Creating durations from nanoseconds)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.nanos(500_000_000n) // => Duration.nanos(500_000_000n)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const nanos = nanos => make(nanos);\n/**\n * Creates a Duration from microseconds.\n *\n * **Example** (Creating durations from microseconds)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.micros(500_000n) // => Duration.nanos(500_000_000n)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const micros = micros => make(micros * bigint1e3);\n/**\n * Creates a Duration from milliseconds.\n *\n * **Example** (Creating durations from milliseconds)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMillis(Duration.millis(1000)) // => 1000\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const millis = millis => make(millis);\n/**\n * Creates a Duration from seconds.\n *\n * **Example** (Creating durations from seconds)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMillis(Duration.seconds(30)) // => 30_000\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const seconds = seconds => make(seconds * 1000);\n/**\n * Creates a Duration from minutes.\n *\n * **Example** (Creating durations from minutes)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMillis(Duration.minutes(5)) // => 300_000\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const minutes = minutes => make(minutes * 60_000);\n/**\n * Creates a Duration from hours.\n *\n * **Example** (Creating durations from hours)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMillis(Duration.hours(2)) // => 7_200_000\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const hours = hours => make(hours * 3_600_000);\n/**\n * Creates a Duration from days.\n *\n * **Example** (Creating durations from days)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMillis(Duration.days(1)) // => 86_400_000\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const days = days => make(days * 86_400_000);\n/**\n * Creates a Duration from weeks.\n *\n * **Example** (Creating durations from weeks)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMillis(Duration.weeks(1)) // => 604_800_000\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const weeks = weeks => make(weeks * 604_800_000);\n/**\n * Converts a Duration to milliseconds.\n *\n * **Example** (Converting durations to milliseconds)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMillis(Duration.seconds(5)) // => 5000\n * Duration.toMillis(Duration.minutes(2)) // => 120_000\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const toMillis = self => match(fromInputUnsafe(self), {\n onMillis: identity,\n onNanos: nanos => Number(nanos) / 1_000_000,\n onInfinity: () => Infinity,\n onNegativeInfinity: () => -Infinity\n});\n/**\n * Converts a Duration to seconds.\n *\n * **Example** (Converting durations to seconds)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toSeconds(Duration.millis(5000)) // => 5\n * Duration.toSeconds(Duration.minutes(2)) // => 120\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const toSeconds = self => match(fromInputUnsafe(self), {\n onMillis: millis => millis / 1_000,\n onNanos: nanos => Number(nanos) / 1_000_000_000,\n onInfinity: () => Infinity,\n onNegativeInfinity: () => -Infinity\n});\n/**\n * Converts a Duration to minutes.\n *\n * **Example** (Converting durations to minutes)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toMinutes(Duration.seconds(120)) // => 2\n * Duration.toMinutes(Duration.hours(1)) // => 60\n * ```\n *\n * @category getters\n * @since 3.8.0\n */\nexport const toMinutes = self => match(fromInputUnsafe(self), {\n onMillis: millis => millis / 60_000,\n onNanos: nanos => Number(nanos) / 60_000_000_000,\n onInfinity: () => Infinity,\n onNegativeInfinity: () => -Infinity\n});\n/**\n * Converts a Duration to hours.\n *\n * **Example** (Converting durations to hours)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toHours(Duration.minutes(120)) // => 2\n * Duration.toHours(Duration.days(1)) // => 24\n * ```\n *\n * @category getters\n * @since 3.8.0\n */\nexport const toHours = self => match(fromInputUnsafe(self), {\n onMillis: millis => millis / 3_600_000,\n onNanos: nanos => Number(nanos) / 3_600_000_000_000,\n onInfinity: () => Infinity,\n onNegativeInfinity: () => -Infinity\n});\n/**\n * Converts a Duration to days.\n *\n * **Example** (Converting durations to days)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toDays(Duration.hours(48)) // => 2\n * Duration.toDays(Duration.weeks(1)) // => 7\n * ```\n *\n * @category getters\n * @since 3.8.0\n */\nexport const toDays = self => match(fromInputUnsafe(self), {\n onMillis: millis => millis / 86_400_000,\n onNanos: nanos => Number(nanos) / 86_400_000_000_000,\n onInfinity: () => Infinity,\n onNegativeInfinity: () => -Infinity\n});\n/**\n * Converts a Duration to weeks.\n *\n * **Example** (Converting durations to weeks)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toWeeks(Duration.days(14)) // => 2\n * Duration.toWeeks(Duration.days(7)) // => 1\n * ```\n *\n * @category getters\n * @since 3.8.0\n */\nexport const toWeeks = self => match(fromInputUnsafe(self), {\n onMillis: millis => millis / 604_800_000,\n onNanos: nanos => Number(nanos) / 604_800_000_000_000,\n onInfinity: () => Infinity,\n onNegativeInfinity: () => -Infinity\n});\n/**\n * Gets the duration in nanoseconds as a bigint.\n *\n * **When to use**\n *\n * Use when the duration is known to be finite and you need the nanosecond value\n * as a `bigint`.\n *\n * **Details**\n *\n * Millisecond-backed fractional durations are rounded to the nearest\n * nanosecond, with ties away from zero.\n *\n * **Gotchas**\n *\n * If the duration is infinite, it throws an error.\n *\n * **Example** (Reading nanoseconds unsafely)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toNanosUnsafe(Duration.seconds(2)) // => 2_000_000_000n\n *\n * // Duration.toNanosUnsafe(Duration.infinity)\n * // throws Error: \"Cannot convert infinite duration to nanos\"\n * ```\n *\n * @category getters\n * @since 4.0.0\n */\nexport const toNanosUnsafe = input => {\n const self = fromInputUnsafe(input);\n switch (self.value._tag) {\n case \"Infinity\":\n case \"NegativeInfinity\":\n throw new Error(\"Cannot convert infinite duration to nanos\");\n case \"Nanos\":\n return self.value.nanos;\n case \"Millis\":\n return roundMillisToNanos(self.value.millis);\n }\n};\n/**\n * Gets the duration in nanoseconds safely as an `Option`.\n *\n * **Details**\n *\n * If the duration is infinite, returns `Option.none()`.\n *\n * **Example** (Safely reading nanoseconds)\n *\n * ```ts import.meta.vitest\n * import { Duration, Option } from \"effect\"\n *\n * Duration.toNanos(Duration.seconds(1)) // => Option.some(1_000_000_000n)\n * Duration.toNanos(Duration.infinity) // => Option.none()\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const toNanos = /*#__PURE__*/Option.liftThrowable(toNanosUnsafe);\n/**\n * Converts a Duration to high-resolution time format [seconds, nanoseconds].\n *\n * **Example** (Converting durations to high-resolution time)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.toHrTime(Duration.millis(1500)) // => [1, 500_000_000]\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const toHrTime = input => {\n const self = fromInputUnsafe(input);\n switch (self.value._tag) {\n case \"Infinity\":\n return [Infinity, 0];\n case \"NegativeInfinity\":\n return [-Infinity, 0];\n case \"Nanos\":\n return nanosToHrTime(self.value.nanos);\n case \"Millis\":\n return nanosToHrTime(roundMillisToNanos(self.value.millis));\n }\n};\n/**\n * Pattern matches on the representation of a `Duration`.\n *\n * **Details**\n *\n * Provide handlers for millisecond-backed values, nanosecond-backed values,\n * and positive infinity. Use `onNegativeInfinity` to handle negative infinity\n * separately; otherwise negative infinity is handled by `onInfinity`.\n *\n * **Example** (Pattern matching on duration representations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.match(Duration.seconds(5), {\n * onMillis: (millis) => `${millis} milliseconds`,\n * onNanos: (nanos) => `${nanos} nanoseconds`,\n * onInfinity: () => \"infinite\"\n * }) // => \"5000 milliseconds\"\n * ```\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport const match = /*#__PURE__*/dual(2, (self, options) => {\n switch (self.value._tag) {\n case \"Millis\":\n return options.onMillis(self.value.millis);\n case \"Nanos\":\n return options.onNanos(self.value.nanos);\n case \"Infinity\":\n return options.onInfinity();\n case \"NegativeInfinity\":\n return (options.onNegativeInfinity ?? options.onInfinity)();\n }\n});\n/**\n * Pattern matches on two `Duration`s, providing handlers that receive both values.\n *\n * **Example** (Pattern matching on duration pairs)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.matchPair(Duration.seconds(3), Duration.seconds(2), {\n * onMillis: (a, b) => a + b,\n * onNanos: (a, b) => Number(a + b),\n * onInfinity: () => Infinity\n * }) // => 5000\n * ```\n *\n * @category pattern matching\n * @since 4.0.0\n */\nexport const matchPair = /*#__PURE__*/dual(3, (self, that, options) => {\n if (self.value._tag === \"Infinity\" || self.value._tag === \"NegativeInfinity\" || that.value._tag === \"Infinity\" || that.value._tag === \"NegativeInfinity\") return options.onInfinity(self, that);\n if (self.value._tag === \"Millis\") {\n return that.value._tag === \"Millis\" ? options.onMillis(self.value.millis, that.value.millis) : options.onNanos(toNanosUnsafe(self), that.value.nanos);\n } else {\n return options.onNanos(self.value.nanos, toNanosUnsafe(that));\n }\n});\n/**\n * Provides an `Order` instance for comparing `Duration` values.\n *\n * **Details**\n *\n * `NegativeInfinity` < any finite value < `Infinity`.\n *\n * **Example** (Sorting durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * const durations = [\n * Duration.seconds(3),\n * Duration.seconds(1),\n * Duration.seconds(2)\n * ]\n * durations.sort((a, b) => Duration.Order(a, b)).map(Duration.toSeconds) // => [1, 2, 3]\n * ```\n *\n * @category instances\n * @since 2.0.0\n */\nexport const Order = /*#__PURE__*/order.make((self, that) => matchPair(self, that, {\n onMillis: (self, that) => self < that ? -1 : self > that ? 1 : 0,\n onNanos: (self, that) => self < that ? -1 : self > that ? 1 : 0,\n onInfinity: (self, that) => {\n if (self.value._tag === that.value._tag) return 0;\n if (self.value._tag === \"Infinity\") return 1;\n if (self.value._tag === \"NegativeInfinity\") return -1;\n // self is finite\n if (that.value._tag === \"Infinity\") return -1;\n // that is NegativeInfinity\n return 1;\n }\n}));\n/**\n * Returns `true` if a `Duration` is greater than or equal to `minimum` and\n * less than or equal to `maximum`, according to `Duration.Order`.\n *\n * **When to use**\n *\n * Use to test whether a duration is inside an inclusive range.\n *\n * **Details**\n *\n * Both bounds are inclusive and compared with `Duration.Order`.\n *\n * **Gotchas**\n *\n * The bounds are not normalized. If `minimum` is greater than `maximum`, the\n * predicate returns `false` for every duration.\n *\n * **Example** (Checking duration ranges)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.between(Duration.seconds(3), {\n * minimum: Duration.seconds(2),\n * maximum: Duration.seconds(5)\n * }) // => true\n * ```\n *\n * @see {@link clamp} for constraining a duration to a range\n * @see {@link isGreaterThanOrEqualTo} for checking only the lower bound\n * @see {@link isLessThanOrEqualTo} for checking only the upper bound\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const between = /*#__PURE__*/order.isBetween(Order);\n/**\n * Provides an `Equivalence` instance for comparing `Duration` values.\n *\n * **Example** (Comparing durations for equivalence)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.Equivalence(Duration.seconds(5), Duration.millis(5000)) // => true\n * ```\n *\n * @category instances\n * @since 2.0.0\n */\nexport const Equivalence = (self, that) => matchPair(self, that, {\n onMillis: (self, that) => self === that,\n onNanos: (self, that) => self === that,\n onInfinity: (self, that) => self.value._tag === that.value._tag\n});\n/**\n * Returns the smaller of two Durations.\n *\n * **Example** (Selecting the shorter duration)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.min(Duration.seconds(5), Duration.seconds(3)) // => Duration.seconds(3)\n * ```\n *\n * @category ordering\n * @since 2.0.0\n */\nexport const min = /*#__PURE__*/order.min(Order);\n/**\n * Returns the larger of two Durations.\n *\n * **Example** (Selecting the longer duration)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.max(Duration.seconds(5), Duration.seconds(3)) // => Duration.seconds(5)\n * ```\n *\n * @category ordering\n * @since 2.0.0\n */\nexport const max = /*#__PURE__*/order.max(Order);\n/**\n * Returns a `Duration` constrained between a minimum and maximum value.\n *\n * **Example** (Clamping durations to a range)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.clamp(Duration.seconds(10), {\n * minimum: Duration.seconds(2),\n * maximum: Duration.seconds(5)\n * }) // => Duration.seconds(5)\n * ```\n *\n * @category ordering\n * @since 2.0.0\n */\nexport const clamp = /*#__PURE__*/order.clamp(Order);\n/**\n * Divides a `Duration` by a finite, non-zero number safely.\n *\n * **Details**\n *\n * Returns `Option.none()` for zero, negative zero, or non-finite divisors. For\n * nanosecond-backed durations, also returns `Option.none()` when the divisor\n * cannot be converted to a `bigint`, such as a fractional divisor.\n *\n * **Example** (Safely dividing durations)\n *\n * ```ts import.meta.vitest\n * import { Duration, Option } from \"effect\"\n *\n * Duration.divide(Duration.seconds(10), 2) // => Option.some(Duration.seconds(5))\n * Duration.divide(Duration.seconds(10), 0) // => Option.none()\n * ```\n *\n * @category math\n * @since 2.4.19\n */\nexport const divide = /*#__PURE__*/dual(2, (self, by) => {\n if (!Number.isFinite(by)) return Option.none();\n if (by === 0 || Object.is(by, -0)) return Option.none();\n return match(self, {\n onMillis: millis => Option.some(make(millis / by)),\n onNanos: nanos => {\n try {\n return Option.some(make(nanos / BigInt(by)));\n } catch {\n return Option.none();\n }\n },\n onInfinity: () => Option.some(by > 0 ? infinity : negativeInfinity),\n onNegativeInfinity: () => Option.some(by > 0 ? negativeInfinity : infinity)\n });\n});\n/**\n * Divides a `Duration` by a number using fallback rules instead of returning\n * an `Option`.\n *\n * **When to use**\n *\n * Use when dividing a `Duration` should return `Duration.zero` or signed\n * infinity for invalid cases instead of forcing callers to handle `Option.none`.\n *\n * **Details**\n *\n * Non-finite divisors return `Duration.zero`. Division by positive or negative\n * zero can produce signed infinity for non-zero finite durations, while zero\n * or infinite durations divided by zero produce `Duration.zero`.\n * Nanosecond-backed durations return `Duration.zero` when the divisor cannot\n * be converted to a `bigint`.\n *\n * **Example** (Dividing durations unsafely)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.divideUnsafe(Duration.seconds(10), 2) // => Duration.seconds(5)\n * Duration.divideUnsafe(Duration.seconds(10), 0) // => Duration.infinity\n * ```\n *\n * @category math\n * @since 4.0.0\n */\nexport const divideUnsafe = /*#__PURE__*/dual(2, (self, by) => {\n if (!Number.isFinite(by)) return zero;\n return match(self, {\n onMillis: millis => make(millis / by),\n onNanos: nanos => {\n if (Object.is(by, 0) || Object.is(by, -0)) {\n if (nanos === bigint0) return zero;\n // match IEEE 754: same sign → +infinity, different sign → -infinity\n const positiveNanos = nanos > bigint0;\n const positiveZero = Object.is(by, 0);\n return positiveNanos === positiveZero ? infinity : negativeInfinity;\n }\n try {\n return make(nanos / BigInt(by));\n } catch {\n return zero;\n }\n },\n onInfinity: () => by > 0 ? infinity : by < 0 ? negativeInfinity : zero,\n onNegativeInfinity: () => by > 0 ? negativeInfinity : by < 0 ? infinity : zero\n });\n});\n/**\n * Returns a `Duration` multiplied by a number.\n *\n * **Details**\n *\n * For nanosecond-backed durations, the multiplier must be convertible to a\n * `bigint`; fractional or non-finite multipliers can throw. Infinite\n * durations return positive infinity, negative infinity, or zero depending on\n * the multiplier sign.\n *\n * **Example** (Multiplying durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.times(Duration.seconds(5), 2) // => Duration.seconds(10)\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const times = /*#__PURE__*/dual(2, (self, times) => match(self, {\n onMillis: millis => make(millis * times),\n onNanos: nanos => make(nanos * BigInt(times)),\n onInfinity: () => times > 0 ? infinity : times < 0 ? negativeInfinity : zero,\n onNegativeInfinity: () => times > 0 ? negativeInfinity : times < 0 ? infinity : zero\n}));\n/**\n * Subtracts one Duration from another. The result can be negative.\n *\n * **Details**\n *\n * Infinity subtraction follows signed-infinity arithmetic. Subtracting the\n * same infinity from itself returns zero. Positive infinity minus negative\n * infinity or any finite duration remains positive infinity. Negative infinity\n * minus positive infinity or any finite duration remains negative infinity.\n * Finite durations minus positive infinity produce negative infinity, and\n * finite durations minus negative infinity produce positive infinity.\n *\n * **Example** (Subtracting durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.subtract(Duration.seconds(10), Duration.seconds(3)) // => Duration.seconds(7)\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const subtract = /*#__PURE__*/dual(2, (self, that) => matchPair(self, that, {\n onMillis: (self, that) => make(self - that),\n onNanos: (self, that) => make(self - that),\n onInfinity: (self, that) => {\n const s = self.value._tag;\n const t = that.value._tag;\n if (s === \"Infinity\") return t === \"Infinity\" ? zero : infinity;\n if (s === \"NegativeInfinity\") return t === \"NegativeInfinity\" ? zero : negativeInfinity;\n return t === \"Infinity\" ? negativeInfinity : infinity;\n }\n}));\n/**\n * Adds two Durations together.\n *\n * **Details**\n *\n * Infinity addition follows these rules:\n *\n * - infinity + infinity = infinity\n * - infinity + negativeInfinity = zero\n * - infinity + finite = infinity\n * - negativeInfinity + negativeInfinity = negativeInfinity\n * - negativeInfinity + finite = negativeInfinity\n *\n * **Example** (Adding durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.sum(Duration.seconds(5), Duration.seconds(3)) // => Duration.seconds(8)\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const sum = /*#__PURE__*/dual(2, (self, that) => matchPair(self, that, {\n onMillis: (self, that) => make(self + that),\n onNanos: (self, that) => make(self + that),\n onInfinity: (self, that) => {\n const s = self.value._tag;\n const t = that.value._tag;\n if (s === \"Infinity\" && t === \"NegativeInfinity\") return zero;\n if (s === \"NegativeInfinity\" && t === \"Infinity\") return zero;\n if (s === \"Infinity\" || t === \"Infinity\") return infinity;\n if (s === \"NegativeInfinity\" || t === \"NegativeInfinity\") return negativeInfinity;\n // unreachable, but satisfy TS\n return zero;\n }\n}));\n/**\n * Checks whether the first Duration is less than the second.\n *\n * **Example** (Comparing durations with less than)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.isLessThan(Duration.seconds(3), Duration.seconds(5)) // => true\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isLessThan = /*#__PURE__*/order.isLessThan(Order);\n/**\n * Checks whether the first Duration is less than or equal to the second.\n *\n * **Example** (Comparing durations with less than or equal)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.isLessThanOrEqualTo(\n * Duration.seconds(5),\n * Duration.seconds(5)\n * ) // => true\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isLessThanOrEqualTo = /*#__PURE__*/order.isLessThanOrEqualTo(Order);\n/**\n * Checks whether the first Duration is greater than the second.\n *\n * **Example** (Comparing durations with greater than)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.isGreaterThan(Duration.seconds(5), Duration.seconds(3)) // => true\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isGreaterThan = /*#__PURE__*/order.isGreaterThan(Order);\n/**\n * Checks whether the first Duration is greater than or equal to the second.\n *\n * **Example** (Comparing durations with greater than or equal)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.isGreaterThanOrEqualTo(\n * Duration.seconds(5),\n * Duration.seconds(5)\n * ) // => true\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isGreaterThanOrEqualTo = /*#__PURE__*/order.isGreaterThanOrEqualTo(Order);\n/**\n * Checks whether two Durations are equal.\n *\n * **Example** (Checking duration equality)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.equals(Duration.seconds(5), Duration.millis(5000)) // => true\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const equals = /*#__PURE__*/dual(2, (self, that) => Equivalence(self, that));\n/**\n * Decomposes a `Duration` into normalized signed components.\n *\n * **Details**\n *\n * Finite durations are returned as `{ days, hours, minutes, seconds, millis,\n * nanos }`. Infinite durations return every component as `Infinity` or\n * `-Infinity`.\n *\n * **Example** (Decomposing durations into parts)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * // Create a complex duration by adding multiple parts\n * const duration = Duration.sum(\n * Duration.sum(\n * Duration.sum(Duration.days(1), Duration.hours(2)),\n * Duration.sum(Duration.minutes(30), Duration.seconds(45))\n * ),\n * Duration.millis(123)\n * )\n * Duration.parts(duration) // => ({ days: 1, hours: 2, minutes: 30, seconds: 45, millis: 123, nanos: 0 })\n *\n * const complex = Duration.sum(Duration.hours(25), Duration.minutes(90))\n * Duration.parts(complex) // => ({ days: 1, hours: 2, minutes: 30, seconds: 0, millis: 0, nanos: 0 })\n * ```\n *\n * @category converting\n * @since 3.8.0\n */\nexport const parts = self => {\n if (self.value._tag === \"Infinity\") {\n return {\n days: Infinity,\n hours: Infinity,\n minutes: Infinity,\n seconds: Infinity,\n millis: Infinity,\n nanos: Infinity\n };\n }\n if (self.value._tag === \"NegativeInfinity\") {\n return {\n days: -Infinity,\n hours: -Infinity,\n minutes: -Infinity,\n seconds: -Infinity,\n millis: -Infinity,\n nanos: -Infinity\n };\n }\n const n = toNanosUnsafe(self);\n const neg = n < bigint0;\n const a = neg ? -n : n;\n const ms = a / bigint1e6;\n const sec = ms / bigint1e3;\n const min = sec / bigint60;\n const hr = min / bigint60;\n const d = hr / bigint24;\n const sign = neg ? -1 : 1;\n return {\n days: sign * Number(d),\n hours: sign * Number(hr % bigint24),\n minutes: sign * Number(min % bigint60),\n seconds: sign * Number(sec % bigint60),\n millis: sign * Number(ms % bigint1e3),\n nanos: sign * Number(a % bigint1e6)\n };\n};\n/**\n * Converts a `Duration` to a human readable string.\n *\n * **Example** (Formatting durations)\n *\n * ```ts import.meta.vitest\n * import { Duration } from \"effect\"\n *\n * Duration.format(Duration.millis(1000)) // => \"1s\"\n * Duration.format(Duration.millis(1001)) // => \"1s 1ms\"\n * ```\n *\n * @category converting\n * @since 2.0.0\n */\nexport const format = self => {\n if (self.value._tag === \"Infinity\") {\n return \"Infinity\";\n }\n if (self.value._tag === \"NegativeInfinity\") {\n return \"-Infinity\";\n }\n if (isZero(self)) {\n return \"0\";\n }\n if (isNegative(self)) {\n return \"-\" + format(abs(self));\n }\n const fragments = parts(self);\n const pieces = [];\n if (fragments.days !== 0) {\n pieces.push(`${fragments.days}d`);\n }\n if (fragments.hours !== 0) {\n pieces.push(`${fragments.hours}h`);\n }\n if (fragments.minutes !== 0) {\n pieces.push(`${fragments.minutes}m`);\n }\n if (fragments.seconds !== 0) {\n pieces.push(`${fragments.seconds}s`);\n }\n if (fragments.millis !== 0) {\n pieces.push(`${fragments.millis}ms`);\n }\n if (fragments.nanos !== 0) {\n pieces.push(`${fragments.nanos}ns`);\n }\n return pieces.join(\" \");\n};\n/**\n * Reducer for summing `Duration`s.\n *\n * **When to use**\n *\n * Use to sum many `Duration` values through APIs that consume a `Reducer`.\n *\n * **Details**\n *\n * `ReducerSum` uses `sum` and starts from `zero`, so `combineAll([])` returns\n * `zero`.\n *\n * @see {@link sum} for adding two duration values directly\n * @see {@link CombinerMax} for keeping the longest duration instead of summing\n * @see {@link CombinerMin} for keeping the shortest duration instead of summing\n *\n * @category math\n * @since 4.0.0\n */\nexport const ReducerSum = /*#__PURE__*/Reducer.make(sum, zero);\n/**\n * Combiner that returns the maximum `Duration`.\n *\n * **When to use**\n *\n * Use to keep the longest `Duration` when an API consumes a `Combiner`.\n *\n * @see {@link CombinerMin} for keeping the shortest `Duration`\n * @see {@link max} for comparing two `Duration` values directly\n *\n * @category math\n * @since 4.0.0\n */\nexport const CombinerMax = /*#__PURE__*/Combiner.max(Order);\n/**\n * Combiner that returns the minimum `Duration`.\n *\n * **When to use**\n *\n * Use to keep the shortest `Duration` through APIs that consume a `Combiner`.\n *\n * @see {@link CombinerMax} for keeping the longest `Duration`\n * @see {@link min} for comparing two `Duration` values directly\n *\n * @category math\n * @since 4.0.0\n */\nexport const CombinerMin = /*#__PURE__*/Combiner.min(Order);\n//# sourceMappingURL=Duration.js.map","/**\n * Controls how runnable Effect fiber tasks are dispatched.\n *\n * A scheduler decides how tasks are queued, when queued tasks run, and when a\n * fiber should pause so other work can continue. This module includes the\n * scheduler service reference, the default `MixedScheduler`, dispatcher types\n * for queued tasks, and references for tuning or disabling automatic scheduler\n * yields.\n *\n * @since 2.0.0\n */\nimport * as Context from \"./Context.js\";\n/**\n * Context reference for the scheduler used by the Effect runtime.\n *\n * **When to use**\n *\n * Use when you need to replace scheduling behavior globally in tests or runtime\n * setup, such as forcing deterministic task dispatch.\n *\n * **Details**\n *\n * The default value creates a `MixedScheduler`. Provide this service to\n * customize execution mode, task dispatching, or yield behavior.\n *\n * @category services\n * @since 2.0.0\n */\nexport const Scheduler = /*#__PURE__*/Context.Reference(\"effect/Scheduler\", {\n fiberCached: true,\n defaultValue: () => new MixedScheduler()\n});\nconst setMicrotask = f => {\n let cancelled = false;\n Promise.resolve().then(() => {\n if (!cancelled) f();\n });\n return () => {\n cancelled = true;\n };\n};\nconst setTimer = \"setImmediate\" in globalThis ? f => {\n // @ts-ignore\n const timer = globalThis.setImmediate(f);\n // @ts-ignore\n return () => globalThis.clearImmediate(timer);\n} : f => {\n const timer = setTimeout(f, 0);\n return () => clearTimeout(timer);\n};\n// Some runtimes (e.g. Cloudflare Workers) throw when a timer is set in global\n// scope. Fall back to a microtask so effects can still yield at module load.\nconst setImmediate = f => {\n try {\n return setTimer(f);\n } catch {\n return setMicrotask(f);\n }\n};\nclass PriorityBuckets {\n buckets = [];\n scheduleTask(task, priority) {\n const buckets = this.buckets;\n const len = buckets.length;\n let bucket;\n let index = 0;\n for (; index < len; index++) {\n if (buckets[index][0] > priority) break;\n bucket = buckets[index];\n }\n if (bucket && bucket[0] === priority) {\n bucket[1].push(task);\n } else if (index === len) {\n buckets.push([priority, [task]]);\n } else {\n buckets.splice(index, 0, [priority, [task]]);\n }\n }\n drain() {\n const buckets = this.buckets;\n this.buckets = [];\n return buckets;\n }\n}\n/**\n * Provides a scheduler implementation that batches queued tasks and dispatches them by\n * priority.\n *\n * **When to use**\n *\n * Use when you need the default runtime scheduler directly, including a\n * scheduler that batches queued work by priority and preserves FIFO order within\n * each priority.\n *\n * **Details**\n *\n * `MixedScheduler` supports synchronous and asynchronous execution modes, uses\n * operation counts to decide when fibers should yield, and is the default\n * scheduler implementation.\n *\n * @category models\n * @since 2.0.0\n */\nexport class MixedScheduler {\n executionMode;\n setImmediate;\n constructor(executionMode = \"async\", setImmediateFn) {\n this.executionMode = executionMode;\n this.setImmediate = setImmediateFn ?? (executionMode === \"sync\" ? setMicrotask : setImmediate);\n }\n /**\n * Returns whether the fiber has reached its operation budget and should yield.\n *\n * **When to use**\n *\n * Use to decide whether a fiber should yield after consuming its current\n * operation budget.\n *\n * @since 2.0.0\n */\n shouldYield(fiber) {\n return fiber.currentOpCount >= fiber.cache.maxOpsBeforeYield;\n }\n /**\n * Creates a dispatcher that schedules work through this scheduler.\n *\n * **When to use**\n *\n * Use when you need a standalone dispatcher from a scheduler instance, for\n * example in tests that enqueue tasks and then flush them deterministically.\n *\n * @since 4.0.0\n */\n makeDispatcher() {\n return new MixedSchedulerDispatcher(this.setImmediate);\n }\n}\nclass MixedSchedulerDispatcher {\n tasks = /*#__PURE__*/new PriorityBuckets();\n running = undefined;\n setImmediate;\n constructor(setImmediateFn = setImmediate) {\n this.setImmediate = setImmediateFn;\n }\n /**\n * @since 2.0.0\n */\n scheduleTask(task, priority) {\n this.tasks.scheduleTask(task, priority);\n if (this.running === undefined) {\n this.running = this.setImmediate(this.afterScheduled);\n }\n }\n /**\n * @since 2.0.0\n */\n afterScheduled = () => {\n this.running = undefined;\n this.runTasks();\n };\n /**\n * @since 2.0.0\n */\n runTasks() {\n const buckets = this.tasks.drain();\n for (let i = 0; i < buckets.length; i++) {\n const toRun = buckets[i][1];\n for (let j = 0; j < toRun.length; j++) {\n toRun[j]();\n }\n }\n }\n /**\n * @since 2.0.0\n */\n flush() {\n while (this.tasks.buckets.length > 0) {\n if (this.running !== undefined) {\n this.running();\n this.running = undefined;\n }\n this.runTasks();\n }\n }\n}\n/**\n * Context reference that controls the maximum number of operations a fiber\n * can perform before yielding control back to the scheduler.\n *\n * **When to use**\n *\n * Use to tune scheduler fairness for CPU-bound fibers by changing the scheduler\n * operation budget that triggers a yield.\n *\n * **Details**\n *\n * The default value is `2048` operations, which balances performance and\n * fairness by helping prevent long-running fibers from monopolizing the\n * execution thread.\n *\n * @see {@link PreventSchedulerYield} for bypassing scheduler yield checks entirely rather than tuning the operation budget\n *\n * @category services\n * @since 4.0.0\n */\nexport const MaxOpsBeforeYield = /*#__PURE__*/Context.Reference(\"effect/Scheduler/MaxOpsBeforeYield\", {\n fiberCached: true,\n defaultValue: () => 2048\n});\n/**\n * Context reference that controls whether the runtime should bypass scheduler\n * yield checks. When set to `true`, the fiber run loop won't call\n * `Scheduler.shouldYield`.\n *\n * **When to use**\n *\n * Use to bypass scheduler yield checks for controlled runtime workloads where\n * cooperative yielding should be disabled.\n *\n * **Gotchas**\n *\n * Setting this reference to `true` can let long-running fibers monopolize the\n * JavaScript thread.\n *\n * @see {@link MaxOpsBeforeYield} for tuning yield frequency without disabling yield checks\n * @see {@link Scheduler} for providing custom scheduler yield behavior\n *\n * @category services\n * @since 4.0.0\n */\nexport const PreventSchedulerYield = /*#__PURE__*/Context.Reference(\"effect/Scheduler/PreventSchedulerYield\", {\n fiberCached: true,\n defaultValue: () => false\n});\n//# sourceMappingURL=Scheduler.js.map","import * as core from \"./internal/core.js\";\nimport * as InternalRecord from \"./internal/record.js\";\nimport * as Pipeable from \"./Pipeable.js\";\nimport * as Predicate from \"./Predicate.js\";\n/**\n * Provides a base class for immutable data types.\n *\n * **When to use**\n *\n * Use when you need a lightweight immutable value type with `.pipe()` support.\n *\n * **Details**\n *\n * Extend `Class` with a type parameter to declare fields. The constructor\n * accepts those fields as a single object argument. When there are no fields\n * the argument is optional. Instances are `Readonly` and `Pipeable`.\n *\n * **Example** (Defining a value class)\n *\n * ```ts import.meta.vitest\n * import { Data, Equal } from \"effect\"\n *\n * class Person extends Data.Class<{ readonly name: string }> {}\n *\n * Equal.equals(new Person({ name: \"Mike\" }), new Person({ name: \"Mike\" })) // => true\n * ```\n *\n * @see {@link TaggedClass} — adds a `_tag` field\n * @see {@link Error} — yieldable error variant\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const Class = class extends Pipeable.Class {\n constructor(props) {\n super();\n if (props) {\n InternalRecord.assignProperties(this, props);\n }\n }\n};\n/**\n * Provides a base class for immutable data types with a `_tag` discriminator.\n *\n * **When to use**\n *\n * Use when you need a single-variant tagged type or an ad-hoc discriminator.\n *\n * **Details**\n *\n * Like {@link Class}, but the resulting instances also carry a\n * `readonly _tag: Tag` property. The `_tag` is excluded from the constructor\n * argument.\n *\n * **Example** (Defining a tagged class)\n *\n * ```ts import.meta.vitest\n * import { Data } from \"effect\"\n *\n * class Person extends Data.TaggedClass(\"Person\")<{\n * readonly name: string\n * }> {}\n *\n * new Person({ name: \"Mike\" })._tag // => \"Person\"\n * ```\n *\n * @see {@link Class} — without a `_tag`\n * @see {@link TaggedError} — tagged error variant\n * @see {@link TaggedEnum} — multi-variant unions\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const TaggedClass = tag => class extends Class {\n _tag = tag;\n};\n/**\n * Creates constructors and matchers for a `TaggedEnum` type.\n *\n * **When to use**\n *\n * Use when you model a closed union with plain data objects and want\n * construction, tag checks, and exhaustive matching from the same definition.\n *\n * **Details**\n *\n * Returns an object with:\n * - One constructor per variant (keyed by tag name)\n * - `$is(tag)` — returns a type-guard function that checks only the `_tag` field\n * - `$match` — exhaustive pattern matching (data-first or data-last)\n *\n * **Gotchas**\n *\n * - Constructors produce **plain objects**, not class instances.\n * - `$is(tag)` only checks the `_tag` field, not the full structure. It relies\n * on the tag being globally unique and the value being produced by your\n * constructors. For untrusted input, validate with the `Schema` module first.\n *\n * **Example** (Creating and matching tagged enum values)\n *\n * ```ts import.meta.vitest\n * import { Data } from \"effect\"\n *\n * type HttpError = Data.TaggedEnum<{\n * BadRequest: { readonly message: string }\n * NotFound: { readonly url: string }\n * }>\n *\n * const { BadRequest, NotFound, $is, $match } = Data.taggedEnum()\n *\n * const err = NotFound({ url: \"/missing\" })\n *\n * $is(\"NotFound\")(err) // => true\n *\n * $match(err, {\n * BadRequest: (e) => e.message,\n * NotFound: (e) => `${e.url} not found`\n * }) // => \"/missing not found\"\n * ```\n *\n * **Example** (Defining a generic tagged enum)\n *\n * ```ts import.meta.vitest\n * import { Data } from \"effect\"\n *\n * type MyResult = Data.TaggedEnum<{\n * Failure: { readonly error: E }\n * Success: { readonly value: A }\n * }>\n * interface MyResultDef extends Data.TaggedEnum.WithGenerics<2> {\n * readonly taggedEnum: MyResult\n * }\n * const { Failure, Success } = Data.taggedEnum()\n *\n * const ok = Success({ value: 42 })\n * // ok: { readonly _tag: \"Success\"; readonly value: number }\n * ok // => { value: 42, _tag: \"Success\" }\n * ```\n *\n * @see {@link TaggedEnum} — the type-level companion\n * @see {@link TaggedEnum.Constructor} — the returned object type\n * @see {@link TaggedEnum.WithGenerics} — generic enum support\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const taggedEnum = () => new Proxy({}, {\n get(_target, tag, _receiver) {\n if (tag === \"$is\") {\n return Predicate.isTagged;\n } else if (tag === \"$match\") {\n return taggedMatch;\n }\n return props => ({\n ...props,\n _tag: tag\n });\n }\n});\nfunction taggedMatch() {\n if (arguments.length === 1) {\n const cases = arguments[0];\n return function (value) {\n return cases[value._tag](value);\n };\n }\n const value = arguments[0];\n const cases = arguments[1];\n return cases[value._tag](value);\n}\n/**\n * Provides a base class for yieldable errors.\n *\n * **When to use**\n *\n * Use when you need yieldable errors that do **not** need tag-based\n * discrimination.\n *\n * **Details**\n *\n * Extends `Cause.YieldableError`, so instances can be yielded inside\n * `Effect.gen` to fail the enclosing effect. Fields are passed as a single\n * object; when there are no fields the argument is optional. If a `message`\n * field is provided, it becomes the error's `.message`.\n *\n * **Example** (Defining a yieldable error)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Exit } from \"effect\"\n *\n * class NetworkError extends Data.Error<{\n * readonly code: number\n * readonly message: string\n * }> {}\n *\n * const program = Effect.gen(function*() {\n * return yield* new NetworkError({ code: 500, message: \"timeout\" })\n * })\n *\n * Effect.runSync(Effect.exit(program)) // => Exit.fail(new NetworkError({ code: 500, message: \"timeout\" }))\n * ```\n *\n * @see {@link TaggedError} — adds a `_tag` for `Effect.catchTag`\n * @see {@link Class} — non-error data class\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const Error = core.Error;\n/**\n * Creates a tagged error class with a `_tag` discriminator.\n *\n * **When to use**\n *\n * Use when you need domain errors with discriminated-union handling.\n *\n * **Details**\n *\n * Like {@link Error}, but instances also carry a `readonly _tag` property,\n * enabling `Effect.catchTag` and `Effect.catchTags` for tag-based recovery.\n * The `_tag` is excluded from the constructor argument. Yielding an instance\n * inside `Effect.gen` fails the effect with this error.\n *\n * **Example** (Recovering by tag)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class NotFound extends Data.TaggedError(\"NotFound\")<{\n * readonly resource: string\n * }> {}\n *\n * class Forbidden extends Data.TaggedError(\"Forbidden\")<{\n * readonly reason: string\n * }> {}\n *\n * const program = Effect.gen(function*() {\n * return yield* new NotFound({ resource: \"/users/42\" })\n * })\n *\n * const recovered = program.pipe(\n * Effect.catchTag(\"NotFound\", (e) =>\n * Effect.succeed(`missing: ${e.resource}`))\n * )\n *\n * await Effect.runPromise(recovered) // => \"missing: /users/42\"\n * ```\n *\n * @see {@link Error} — without a `_tag`\n * @see {@link TaggedClass} — tagged class that is not an error\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const TaggedError = core.TaggedError;\n//# sourceMappingURL=Data.js.map","/**\n * Encoding and decoding helpers for Base64, Base64Url, and hexadecimal text.\n * The functions convert between strings, UTF-8 text, and `Uint8Array` bytes.\n * Encode functions return strings directly, while decode functions return\n * `Result.Result` so invalid input is reported as an `EncodingError` instead of\n * being thrown.\n *\n * @since 4.0.0\n */\nimport * as Data from \"./Data.js\";\nimport { hasProperty } from \"./Predicate.js\";\nimport * as Result from \"./Result.js\";\n// -------------------------------------------------------------------------------------\n// EncodingError\n// -------------------------------------------------------------------------------------\n/**\n * Type identifier stored on `EncodingError` values and used by\n * `isEncodingError`.\n *\n * **When to use**\n *\n * Use when implementing low-level `EncodingError`-compatible values that need\n * to carry the runtime marker.\n *\n * **Details**\n *\n * This marker is part of the runtime representation of `EncodingError`. Prefer\n * `isEncodingError` when narrowing unknown values.\n *\n * @see {@link isEncodingError} for the public guard that checks this marker\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const EncodingErrorTypeId = \"~effect/Encoding/EncodingError\";\n/**\n * Error returned when an encoding or decoding operation cannot process its\n * input.\n *\n * **When to use**\n *\n * Use when you need to handle or inspect failures from encoding or decoding\n * operations.\n *\n * **Details**\n *\n * The error records whether the failure happened during encoding or decoding,\n * which encoding module reported it, the original input, and a human-readable\n * message.\n *\n * @see {@link isEncodingError} for checking whether a value is an EncodingError\n * @category errors\n * @since 4.0.0\n */\nexport class EncodingError extends /*#__PURE__*/Data.TaggedError(\"EncodingError\") {\n /**\n * Marks this value as an encoding or decoding error for runtime guards.\n *\n * **When to use**\n *\n * Use to identify `EncodingError` instances through `isEncodingError`.\n *\n * @since 4.0.0\n */\n [EncodingErrorTypeId] = EncodingErrorTypeId;\n}\n/**\n * Checks whether a value is an `EncodingError`.\n *\n * **When to use**\n *\n * Use to narrow an unknown value before handling it as an `EncodingError` from\n * encoding or decoding code.\n *\n * **Details**\n *\n * Returns `true` when the value carries the `EncodingErrorTypeId` marker and\n * narrows the value to `EncodingError`.\n *\n * @see {@link EncodingError} for the structured error produced by failed\n * encoding and decoding operations\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isEncodingError = u => hasProperty(u, EncodingErrorTypeId);\n// -------------------------------------------------------------------------------------\n// Base64\n// -------------------------------------------------------------------------------------\n/**\n * Encodes the given value into a base64 (RFC4648) `string`.\n *\n * **When to use**\n *\n * Use to encode text or bytes as a standard padded Base64 string for storage or\n * transport.\n *\n * **Details**\n *\n * String inputs are encoded as UTF-8 bytes before Base64 encoding.\n * `Uint8Array` inputs are encoded directly. The output uses the standard\n * RFC4648 alphabet with `=` padding.\n *\n * **Example** (Encoding Base64 strings and bytes)\n *\n * ```ts import.meta.vitest\n * import { Encoding } from \"effect\"\n *\n * // Encode a string\n * Encoding.encodeBase64(\"hello\") // => \"aGVsbG8=\"\n *\n * // Encode binary data\n * const bytes = new Uint8Array([72, 101, 108, 108, 111])\n * Encoding.encodeBase64(bytes) // => \"SGVsbG8=\"\n * ```\n *\n * @see {@link decodeBase64} for decoding standard Base64 to bytes\n * @see {@link decodeBase64String} for decoding standard Base64 to UTF-8 text\n * @see {@link encodeBase64Url} for URL-safe unpadded Base64 output\n *\n * @category encoding\n * @since 2.0.0\n */\nexport const encodeBase64 = input => typeof input === \"string\" ? base64EncodeUint8Array(encoder.encode(input)) : base64EncodeUint8Array(input);\n/**\n * Decodes a base64 (RFC4648) string into bytes safely.\n *\n * **When to use**\n *\n * Use to decode a standard padded Base64 string into bytes without throwing on\n * invalid input.\n *\n * **Details**\n *\n * Returns `Result.succeed` with a `Uint8Array` when decoding succeeds, or\n * `Result.fail` with an `EncodingError` when the input is not valid base64.\n *\n * **Example** (Decoding Base64 bytes)\n *\n * ```ts import.meta.vitest\n * import { Encoding, Result } from \"effect\"\n *\n * Encoding.decodeBase64(\"SGVsbG8=\") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111]))\n * ```\n *\n * @category decoding\n * @since 2.0.0\n */\nexport const decodeBase64 = str => {\n const stripped = stripCrlf(str);\n const length = stripped.length;\n if (length % 4 !== 0) {\n return Result.fail(new EncodingError({\n kind: \"Decode\",\n module: \"Base64\",\n input: stripped,\n message: `Length must be a multiple of 4, but is ${length}`\n }));\n }\n const index = stripped.indexOf(\"=\");\n if (index !== -1 && (index < length - 2 || index === length - 2 && stripped[length - 1] !== \"=\")) {\n return Result.fail(new EncodingError({\n kind: \"Decode\",\n module: \"Base64\",\n input: stripped,\n message: `Found a '=' character, but it is not at the end`\n }));\n }\n try {\n const missingOctets = stripped.endsWith(\"==\") ? 2 : stripped.endsWith(\"=\") ? 1 : 0;\n const result = new Uint8Array(3 * (length / 4) - missingOctets);\n for (let i = 0, j = 0; i < length; i += 4, j += 3) {\n const buffer = getBase64Code(stripped.charCodeAt(i)) << 18 | getBase64Code(stripped.charCodeAt(i + 1)) << 12 | getBase64Code(stripped.charCodeAt(i + 2)) << 6 | getBase64Code(stripped.charCodeAt(i + 3));\n result[j] = buffer >> 16;\n result[j + 1] = buffer >> 8 & 0xff;\n result[j + 2] = buffer & 0xff;\n }\n return Result.succeed(result);\n } catch (e) {\n return Result.fail(new EncodingError({\n kind: \"Decode\",\n module: \"Base64\",\n input: stripped,\n message: e instanceof Error ? e.message : \"Invalid input\"\n }));\n }\n};\n/**\n * Decodes a base64 (RFC4648) string into a UTF-8 string safely.\n *\n * **When to use**\n *\n * Use to decode a standard padded Base64 string into UTF-8 text without\n * throwing on invalid input.\n *\n * **Details**\n *\n * Returns `Result.succeed` with the decoded text when decoding succeeds, or\n * `Result.fail` with an `EncodingError` when the input is not valid base64.\n *\n * **Example** (Decoding Base64 strings)\n *\n * ```ts import.meta.vitest\n * import { Encoding, Result } from \"effect\"\n *\n * Encoding.decodeBase64String(\"aGVsbG8=\") // => Result.succeed(\"hello\")\n * ```\n *\n * @category decoding\n * @since 2.0.0\n */\nexport const decodeBase64String = str => Result.map(decodeBase64(str), _ => decoder.decode(_));\n// -------------------------------------------------------------------------------------\n// Base64Url\n// -------------------------------------------------------------------------------------\n/**\n * Encodes the given value into a base64 (URL) `string`.\n *\n * **When to use**\n *\n * Use to encode text or bytes as an unpadded Base64Url string for contexts that\n * require the URL-safe alphabet.\n *\n * **Details**\n *\n * String inputs are encoded as UTF-8 bytes before Base64Url encoding.\n * `Uint8Array` inputs are encoded directly. The output removes `=` padding and\n * replaces `+` with `-` and `/` with `_`.\n *\n * **Example** (Encoding URL-safe Base64)\n *\n * ```ts import.meta.vitest\n * import { Encoding } from \"effect\"\n *\n * // URL-safe base64 encoding (uses - and _ instead of + and /)\n * Encoding.encodeBase64Url(\"hello?\") // => \"aGVsbG8_\"\n *\n * const bytes = new Uint8Array([72, 101, 108, 108, 111, 63])\n * Encoding.encodeBase64Url(bytes) // => \"SGVsbG8_\"\n * ```\n *\n * @see {@link decodeBase64Url} for decoding URL-safe Base64 to bytes\n * @see {@link decodeBase64UrlString} for decoding URL-safe Base64 to UTF-8 text\n * @see {@link encodeBase64} for standard padded Base64 output\n *\n * @category encoding\n * @since 2.0.0\n */\nexport const encodeBase64Url = input => typeof input === \"string\" ? base64UrlEncodeUint8Array(encoder.encode(input)) : base64UrlEncodeUint8Array(input);\n/**\n * Decodes a URL-safe base64 string into bytes safely.\n *\n * **When to use**\n *\n * Use to decode padded or unpadded Base64Url text into bytes without throwing\n * on invalid input.\n *\n * **Details**\n *\n * Returns `Result.succeed` with a `Uint8Array` when decoding succeeds, or\n * `Result.fail` with an `EncodingError` when the input is not valid URL-safe\n * base64. Both padded and unpadded URL-safe base64 forms are accepted when\n * otherwise valid.\n *\n * **Example** (Decoding URL-safe Base64 bytes)\n *\n * ```ts import.meta.vitest\n * import { Encoding, Result } from \"effect\"\n *\n * Encoding.decodeBase64Url(\"SGVsbG8_\") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111, 63]))\n * ```\n *\n * @category decoding\n * @since 2.0.0\n */\nexport const decodeBase64Url = str => {\n const stripped = stripCrlf(str);\n const length = stripped.length;\n if (length % 4 === 1) {\n return Result.fail(new EncodingError({\n module: \"Base64Url\",\n kind: \"Decode\",\n input: stripped,\n message: `Length should be a multiple of 4, but is ${length}`\n }));\n }\n if (!/^[-_A-Z0-9]*?={0,2}$/i.test(stripped)) {\n return Result.fail(new EncodingError({\n module: \"Base64Url\",\n kind: \"Decode\",\n input: stripped,\n message: \"Invalid input\"\n }));\n }\n // Some variants allow or require omitting the padding '=' signs\n let sanitized = length % 4 === 2 ? `${stripped}==` : length % 4 === 3 ? `${stripped}=` : stripped;\n sanitized = sanitized.replace(/-/g, \"+\").replace(/_/g, \"/\");\n return decodeBase64(sanitized);\n};\n/**\n * Decodes a URL-safe base64 string into a UTF-8 string safely.\n *\n * **When to use**\n *\n * Use to decode padded or unpadded Base64Url text into UTF-8 text without\n * throwing on invalid input.\n *\n * **Details**\n *\n * Returns `Result.succeed` with the decoded text when decoding succeeds, or\n * `Result.fail` with an `EncodingError` when the input is not valid URL-safe\n * base64.\n *\n * **Example** (Decoding URL-safe Base64 strings)\n *\n * ```ts import.meta.vitest\n * import { Encoding, Result } from \"effect\"\n *\n * Encoding.decodeBase64UrlString(\"aGVsbG8_\") // => Result.succeed(\"hello?\")\n * ```\n *\n * @category decoding\n * @since 2.0.0\n */\nexport const decodeBase64UrlString = str => Result.map(decodeBase64Url(str), _ => decoder.decode(_));\n// -------------------------------------------------------------------------------------\n// Hex\n// -------------------------------------------------------------------------------------\n/**\n * Encodes the given value into a hex `string`.\n *\n * **When to use**\n *\n * Use to encode text or bytes as lowercase hexadecimal text.\n *\n * **Example** (Encoding hex strings and bytes)\n *\n * ```ts import.meta.vitest\n * import { Encoding } from \"effect\"\n *\n * // Encode a string to hex\n * Encoding.encodeHex(\"hello\") // => \"68656c6c6f\"\n *\n * // Encode binary data to hex\n * const bytes = new Uint8Array([72, 101, 108, 108, 111])\n * Encoding.encodeHex(bytes) // => \"48656c6c6f\"\n * ```\n *\n * @category encoding\n * @since 2.0.0\n */\nexport const encodeHex = input => typeof input === \"string\" ? hexEncodeUint8Array(encoder.encode(input)) : hexEncodeUint8Array(input);\n/**\n * Generates a random lowercase hexadecimal string, optimized for lengths that\n * are multiples of 8.\n *\n * **Details**\n *\n * `length` is not validated. The function generates `length >>> 3` random\n * 8-character words, so non-negative lengths below `2 ** 32` are rounded down\n * to a multiple of 8 and other values follow JavaScript's unsigned 32-bit\n * coercion rules.\n *\n * This function uses `Math.random()` and is not cryptographically secure. For\n * security-sensitive values, use the `Crypto.Crypto` service's `randomBytes`\n * method and encode the result with {@link encodeHex}.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const randomHex = length => {\n switch (length) {\n case 16:\n return randomHex16();\n case 32:\n return randomHex32();\n default:\n {\n let result = \"\";\n for (let i = length >>> 3; i > 0; i--) {\n result += randomHex8();\n }\n return result;\n }\n }\n};\nconst hexCharCodes = /*#__PURE__*/Uint8Array.from(\"0123456789abcdef\", c => c.charCodeAt(0));\nconst randomWord = () => Math.random() * 0x100000000 >>> 0;\n// Trace and span identifiers are the common lengths. A single\n// String.fromCharCode call produces a flat string, which avoids rope\n// flattening when the identifier is later serialized.\nconst randomHex8 = () => {\n const a = randomWord();\n return String.fromCharCode(hexCharCodes[a >>> 28], hexCharCodes[a >>> 24 & 15], hexCharCodes[a >>> 20 & 15], hexCharCodes[a >>> 16 & 15], hexCharCodes[a >>> 12 & 15], hexCharCodes[a >>> 8 & 15], hexCharCodes[a >>> 4 & 15], hexCharCodes[a & 15]);\n};\nconst randomHex16 = () => {\n const a = randomWord();\n const b = randomWord();\n return String.fromCharCode(hexCharCodes[a >>> 28], hexCharCodes[a >>> 24 & 15], hexCharCodes[a >>> 20 & 15], hexCharCodes[a >>> 16 & 15], hexCharCodes[a >>> 12 & 15], hexCharCodes[a >>> 8 & 15], hexCharCodes[a >>> 4 & 15], hexCharCodes[a & 15], hexCharCodes[b >>> 28], hexCharCodes[b >>> 24 & 15], hexCharCodes[b >>> 20 & 15], hexCharCodes[b >>> 16 & 15], hexCharCodes[b >>> 12 & 15], hexCharCodes[b >>> 8 & 15], hexCharCodes[b >>> 4 & 15], hexCharCodes[b & 15]);\n};\nconst randomHex32 = () => {\n const a = randomWord();\n const b = randomWord();\n const c = randomWord();\n const d = randomWord();\n return String.fromCharCode(hexCharCodes[a >>> 28], hexCharCodes[a >>> 24 & 15], hexCharCodes[a >>> 20 & 15], hexCharCodes[a >>> 16 & 15], hexCharCodes[a >>> 12 & 15], hexCharCodes[a >>> 8 & 15], hexCharCodes[a >>> 4 & 15], hexCharCodes[a & 15], hexCharCodes[b >>> 28], hexCharCodes[b >>> 24 & 15], hexCharCodes[b >>> 20 & 15], hexCharCodes[b >>> 16 & 15], hexCharCodes[b >>> 12 & 15], hexCharCodes[b >>> 8 & 15], hexCharCodes[b >>> 4 & 15], hexCharCodes[b & 15], hexCharCodes[c >>> 28], hexCharCodes[c >>> 24 & 15], hexCharCodes[c >>> 20 & 15], hexCharCodes[c >>> 16 & 15], hexCharCodes[c >>> 12 & 15], hexCharCodes[c >>> 8 & 15], hexCharCodes[c >>> 4 & 15], hexCharCodes[c & 15], hexCharCodes[d >>> 28], hexCharCodes[d >>> 24 & 15], hexCharCodes[d >>> 20 & 15], hexCharCodes[d >>> 16 & 15], hexCharCodes[d >>> 12 & 15], hexCharCodes[d >>> 8 & 15], hexCharCodes[d >>> 4 & 15], hexCharCodes[d & 15]);\n};\n/**\n * Decodes a hexadecimal string into bytes safely.\n *\n * **When to use**\n *\n * Use to decode hexadecimal text into bytes without throwing on invalid input.\n *\n * **Details**\n *\n * Returns `Result.succeed` with a `Uint8Array` when decoding succeeds, or\n * `Result.fail` with an `EncodingError` when the input has an odd length or\n * contains invalid hex characters.\n *\n * **Example** (Decoding hex bytes)\n *\n * ```ts import.meta.vitest\n * import { Encoding, Result } from \"effect\"\n *\n * Encoding.decodeHex(\"48656c6c6f\") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111]))\n * ```\n *\n * @category decoding\n * @since 2.0.0\n */\nexport const decodeHex = str => {\n const bytes = new TextEncoder().encode(str);\n if (bytes.length % 2 !== 0) {\n return Result.fail(new EncodingError({\n module: \"Hex\",\n kind: \"Decode\",\n input: str,\n message: `Length must be a multiple of 2, but is ${bytes.length}`\n }));\n }\n try {\n const length = bytes.length / 2;\n const result = new Uint8Array(length);\n for (let i = 0; i < length; i++) {\n const a = fromHexChar(bytes[i * 2]);\n const b = fromHexChar(bytes[i * 2 + 1]);\n result[i] = a << 4 | b;\n }\n return Result.succeed(result);\n } catch (e) {\n return Result.fail(new EncodingError({\n module: \"Hex\",\n kind: \"Decode\",\n input: str,\n message: e instanceof Error ? e.message : \"Invalid input\"\n }));\n }\n};\n/**\n * Decodes a hexadecimal string into a UTF-8 string safely.\n *\n * **When to use**\n *\n * Use to decode hexadecimal text into UTF-8 text without throwing on invalid\n * input.\n *\n * **Details**\n *\n * Returns `Result.succeed` with the decoded text when decoding succeeds, or\n * `Result.fail` with an `EncodingError` when the input is not valid hex.\n *\n * **Example** (Decoding hex strings)\n *\n * ```ts import.meta.vitest\n * import { Encoding, Result } from \"effect\"\n *\n * Encoding.decodeHexString(\"68656c6c6f\") // => Result.succeed(\"hello\")\n * ```\n *\n * @category decoding\n * @since 2.0.0\n */\nexport const decodeHexString = str => Result.map(decodeHex(str), _ => decoder.decode(_));\n// -------------------------------------------------------------------------------------\n// internals\n// -------------------------------------------------------------------------------------\nconst encoder = /*#__PURE__*/new TextEncoder();\nconst decoder = /*#__PURE__*/new TextDecoder();\nconst stripCrlf = str => str.replace(/[\\n\\r]/g, \"\");\n// Base64 internals\nconst base64EncodeUint8Array = bytes => {\n const length = bytes.length;\n let result = \"\";\n let i;\n for (i = 2; i < length; i += 3) {\n result += base64abc[bytes[i - 2] >> 2];\n result += base64abc[(bytes[i - 2] & 0x03) << 4 | bytes[i - 1] >> 4];\n result += base64abc[(bytes[i - 1] & 0x0f) << 2 | bytes[i] >> 6];\n result += base64abc[bytes[i] & 0x3f];\n }\n if (i === length + 1) {\n result += base64abc[bytes[i - 2] >> 2];\n result += base64abc[(bytes[i - 2] & 0x03) << 4];\n result += \"==\";\n }\n if (i === length) {\n result += base64abc[bytes[i - 2] >> 2];\n result += base64abc[(bytes[i - 2] & 0x03) << 4 | bytes[i - 1] >> 4];\n result += base64abc[(bytes[i - 1] & 0x0f) << 2];\n result += \"=\";\n }\n return result;\n};\nfunction getBase64Code(charCode) {\n if (charCode >= base64codes.length) {\n throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`);\n }\n const code = base64codes[charCode];\n if (code === 255) {\n throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`);\n }\n return code;\n}\nconst base64abc = [\"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\", \"Y\", \"Z\", \"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\", \"k\", \"l\", \"m\", \"n\", \"o\", \"p\", \"q\", \"r\", \"s\", \"t\", \"u\", \"v\", \"w\", \"x\", \"y\", \"z\", \"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"+\", \"/\"];\nconst base64codes = [255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 0, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255, 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51];\n// Base64Url internals\nconst base64UrlEncodeUint8Array = data => base64EncodeUint8Array(data).replace(/=/g, \"\").replace(/\\+/g, \"-\").replace(/\\//g, \"_\");\n// Hex internals\nconst byteToHex = /*#__PURE__*/Array.from({\n length: 256\n}, (_, i) => i.toString(16).padStart(2, \"0\"));\nconst hexEncodeUint8Array = bytes => {\n let result = \"\";\n for (let i = 0; i < bytes.length; i++) {\n result += byteToHex[bytes[i]];\n }\n return result;\n};\nconst fromHexChar = byte => {\n if (48 <= byte && byte <= 57) {\n return byte - 48;\n }\n if (97 <= byte && byte <= 102) {\n return byte - 97 + 10;\n }\n if (65 <= byte && byte <= 70) {\n return byte - 65 + 10;\n }\n throw new TypeError(\"Invalid input\");\n};\n//# sourceMappingURL=Encoding.js.map","/**\n * Defines the low-level tracing model used by Effect.\n *\n * A span records the lifetime of an operation, including its name, parent,\n * attributes, links, annotations, sampling decision, kind, and completion\n * status. The module also defines the tracer service, parent-span context,\n * external span support, trace propagation settings, and the default in-memory\n * span implementation.\n *\n * @since 2.0.0\n */\nimport * as Context from \"./Context.js\";\nimport * as Encoding from \"./Encoding.js\";\nimport { constFalse } from \"./Function.js\";\nimport * as Option from \"./Option.js\";\nconst evaluate = \"~effect/Effect/evaluate\";\n/**\n * Defines the string key for the parent-span context service.\n *\n * **When to use**\n *\n * Use when you need the raw context key for parent span lookup in lower-level\n * tracing code.\n *\n * **Example** (Reading the parent span key)\n *\n * ```ts import.meta.vitest\n * import { Tracer } from \"effect\"\n *\n * // The key used to identify parent spans in the context\n * Tracer.ParentSpanKey // => \"effect/Tracer/ParentSpan\"\n * ```\n *\n * @category constants\n * @since 4.0.0\n */\nexport const ParentSpanKey = \"effect/Tracer/ParentSpan\";\n/**\n * Context service containing the `Span` or `ExternalSpan` to use as the parent\n * of newly-created child spans.\n *\n * **Example** (Accessing the parent span)\n *\n * ```ts import.meta.vitest\n * import { Effect, Tracer } from \"effect\"\n *\n * // Access the parent span from the context\n * const program = Effect.gen(function*() {\n * const parentSpan = yield* Effect.service(Tracer.ParentSpan)\n * return parentSpan.spanId\n * })\n *\n * const parent = Tracer.externalSpan({ spanId: \"span-123\", traceId: \"trace-456\" })\n * await Effect.runPromise(Effect.provideService(program, Tracer.ParentSpan, parent)) // => \"span-123\"\n * ```\n *\n * @category services\n * @since 2.0.0\n */\nexport class ParentSpan extends /*#__PURE__*/Context.Service()(ParentSpanKey, {\n fiberCached: true\n}) {}\n/**\n * Creates a `Tracer` value from a tracer implementation object.\n *\n * **When to use**\n *\n * Use to create a custom tracing backend value that Effect can use when\n * creating spans.\n *\n * **Details**\n *\n * `make` returns the supplied implementation object unchanged. The object must\n * satisfy the `Tracer` contract, including a `span` method that returns a\n * `Span`.\n *\n * @see {@link Span} for the span values returned by tracer implementations\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const make = options => options;\n/**\n * Creates an `ExternalSpan` from trace and span identifiers, defaulting\n * `sampled` to `true` and annotations to an empty context when they are not\n * provided.\n *\n * **Example** (Creating an external span)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Tracer } from \"effect\"\n *\n * // Create an external span from another tracing system\n * const span = Tracer.externalSpan({\n * spanId: \"span-abc-123\",\n * traceId: \"trace-xyz-789\",\n * sampled: true\n * })\n *\n * // Use the external span as a parent\n * const program = Effect.succeed(\"Hello\").pipe(\n * Effect.withSpan(\"child-operation\", { parent: span })\n * )\n *\n * const spans: Array = []\n * const tracer = Tracer.make({\n * span(options) {\n * const span = new Tracer.NativeSpan(options)\n * spans.push(span)\n * return span\n * }\n * })\n * const value = await Effect.runPromise(Effect.provideService(program, Tracer.Tracer, tracer))\n *\n * value // => \"Hello\"\n * spans.map((span) => Option.getOrUndefined(span.parent)?.spanId) // => [\"span-abc-123\"]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const externalSpan = options => ({\n _tag: \"ExternalSpan\",\n spanId: options.spanId,\n traceId: options.traceId,\n sampled: options.sampled ?? true,\n annotations: options.annotations ?? Context.empty()\n});\n/**\n * Context reference for disabling trace propagation.\n *\n * **When to use**\n *\n * Use to prevent spans in a scope from propagating tracing context.\n *\n * **Details**\n *\n * When enabled on fiber or span annotations, new spans are created as\n * non-propagating no-op spans and disabled spans are skipped when deriving a\n * parent span.\n *\n * **Example** (Disabling span propagation)\n *\n * ```ts import.meta.vitest\n * import { Effect, Tracer } from \"effect\"\n *\n * // Disable span propagation for a specific effect\n * const program = Tracer.DisablePropagation.pipe(\n * Effect.provideService(Tracer.DisablePropagation, true)\n * )\n *\n * await Effect.runPromise(program) // => true\n * ```\n *\n * @category services\n * @since 3.12.0\n */\nexport const DisablePropagation = /*#__PURE__*/Context.Reference(\"effect/Tracer/DisablePropagation\", {\n defaultValue: constFalse\n});\n/**\n * Context reference for controlling the current trace level for dynamic filtering.\n *\n * **When to use**\n *\n * Use to set the default trace level for spans in a scope when span options do\n * not provide `level`.\n *\n * **Details**\n *\n * The default value is `\"Info\"`. Span creation uses `options.level ??\n * CurrentTraceLevel` before applying `MinimumTraceLevel`.\n *\n * @see {@link MinimumTraceLevel} for the threshold that decides whether spans at that level are sampled\n *\n * @category services\n * @since 4.0.0\n */\nexport const CurrentTraceLevel = /*#__PURE__*/Context.Reference(\"effect/Tracer/CurrentTraceLevel\", {\n defaultValue: () => \"Info\"\n});\n/**\n * Context reference for setting the minimum trace level threshold. Spans and their\n * descendants below this level will have their sampling decision forced to\n * false, preventing them from being exported.\n *\n * **When to use**\n *\n * Use to set the trace-level threshold that controls whether spans are sampled\n * by default.\n *\n * **Details**\n *\n * The default value is `\"All\"`. Span creation compares the span level from\n * `options.level ?? CurrentTraceLevel` against this threshold.\n *\n * **Gotchas**\n *\n * Explicit `options.sampled` bypasses threshold computation.\n *\n * @see {@link CurrentTraceLevel} for the default span level used when options do not specify one\n *\n * @category services\n * @since 4.0.0\n */\nexport const MinimumTraceLevel = /*#__PURE__*/Context.Reference(\"effect/Tracer/MinimumTraceLevel\", {\n defaultValue: () => \"All\"\n});\n/**\n * Defines the string key for the active tracer context reference.\n *\n * **When to use**\n *\n * Use when you need the raw context key for active tracer lookup in lower-level\n * tracing code.\n *\n * @category constants\n * @since 4.0.0\n */\nexport const TracerKey = \"effect/Tracer\";\n/**\n * Context reference for the active tracer service. By default it uses the\n * native tracer, which creates `NativeSpan` instances.\n *\n * **Example** (Accessing the current tracer)\n *\n * ```ts import.meta.vitest\n * import { Effect, Tracer } from \"effect\"\n *\n * // Access the current tracer from the context\n * const program = Effect.gen(function*() {\n * const tracer = yield* Effect.service(Tracer.Tracer)\n * // Or use the built-in tracer effect\n * const tracerFromAccessor = yield* Effect.tracer\n * return tracer === tracerFromAccessor\n * })\n *\n * await Effect.runPromise(program) // => true\n * ```\n *\n * @category services\n * @since 2.0.0\n */\nexport const Tracer = /*#__PURE__*/Context.Reference(TracerKey, {\n fiberCached: true,\n defaultValue: () => nativeTracer\n});\n/**\n * The default `Tracer` implementation backing the `Tracer` reference. It\n * creates in-memory `NativeSpan` instances and does not export them anywhere.\n *\n * **Details**\n *\n * Runtime code can compare the active tracer against `nativeTracer` to detect\n * that no tracing backend is installed and skip work that only a backend could\n * observe, such as recording span attributes.\n *\n * @category references\n * @since 4.0.0\n */\nexport const nativeTracer = /*#__PURE__*/make({\n span: options => new NativeSpan(options)\n});\n/**\n * Default in-memory `Span` implementation used by the native tracer. It\n * generates span and trace identifiers, stores attributes, events, and links,\n * and records `Started` or `Ended` status.\n *\n * **Details**\n *\n * The constructor initializes the span with `Started` status. Trace and span\n * identifiers, the attribute map, and the event list are created lazily on\n * first access, so spans that are never inspected allocate as little as\n * possible. Attributes, events, links, and status are mutated through `Span`\n * methods.\n *\n * @see {@link Span} for the interface implemented by native spans\n *\n * @category models\n * @since 4.0.0\n */\nexport class NativeSpan {\n _tag = \"Span\";\n sampled;\n name;\n parent;\n annotations;\n links;\n startTime;\n kind;\n status;\n _traceId = undefined;\n _spanId = undefined;\n _attributes = undefined;\n _events = undefined;\n constructor(options) {\n this.name = options.name;\n this.parent = options.parent;\n this.annotations = options.annotations;\n this.links = options.links;\n this.startTime = options.startTime;\n this.kind = options.kind;\n this.sampled = options.sampled;\n this.status = {\n _tag: \"Started\",\n startTime: options.startTime\n };\n }\n get traceId() {\n return this._traceId ??= Option.getOrUndefined(this.parent)?.traceId ?? Encoding.randomHex(32);\n }\n get spanId() {\n return this._spanId ??= Encoding.randomHex(16);\n }\n get attributes() {\n return this._attributes ??= new Map();\n }\n get events() {\n return this._events ??= [];\n }\n end(endTime, exit) {\n this.status = {\n _tag: \"Ended\",\n endTime,\n exit,\n startTime: this.status.startTime\n };\n }\n attribute(key, value) {\n this.attributes.set(key, value);\n }\n event(name, startTime, attributes) {\n this.events.push([name, startTime, attributes ?? {}]);\n }\n addLinks(links) {\n // oxlint-disable-next-line no-restricted-syntax\n this.links.push(...links);\n }\n}\n//# sourceMappingURL=Tracer.js.map","/** @internal */\nexport const FiberRuntimeMetricsKey = \"effect/Metric/FiberRuntimeMetrics\";\n//# sourceMappingURL=metric.js.map","import * as Context from \"../Context.js\";\nimport { constTrue, constUndefined } from \"../Function.js\";\n/** @internal */\nexport const CurrentErrorReporters = /*#__PURE__*/Context.Reference(\"effect/ErrorReporter/CurrentErrorReporters\", {\n defaultValue: () => new Set()\n});\n/** @internal */\nexport const CurrentStackFrame = /*#__PURE__*/Context.Reference(\"effect/References/CurrentStackFrame\", {\n fiberCached: true,\n defaultValue: constUndefined\n});\n/** @internal */\nexport const TracerEnabled = /*#__PURE__*/Context.Reference(\"effect/References/TracerEnabled\", {\n fiberCached: true,\n defaultValue: constTrue\n});\n/** @internal */\nexport const TracerTimingEnabled = /*#__PURE__*/Context.Reference(\"effect/References/TracerTimingEnabled\", {\n defaultValue: constTrue\n});\n/** @internal */\nexport const TracerSpanAnnotations = /*#__PURE__*/Context.Reference(\"effect/References/TracerSpanAnnotations\", {\n defaultValue: () => ({})\n});\n/** @internal */\nexport const TracerSpanLinks = /*#__PURE__*/Context.Reference(\"effect/References/TracerSpanLinks\", {\n defaultValue: () => []\n});\n/** @internal */\nexport const CurrentLogAnnotations = /*#__PURE__*/Context.Reference(\"effect/References/CurrentLogAnnotations\", {\n defaultValue: () => ({})\n});\n/** @internal */\nexport const CurrentLogLevel = /*#__PURE__*/Context.Reference(\"effect/References/CurrentLogLevel\", {\n fiberCached: true,\n defaultValue: () => \"Info\"\n});\n/** @internal */\nexport const MinimumLogLevel = /*#__PURE__*/Context.Reference(\"effect/References/MinimumLogLevel\", {\n fiberCached: true,\n defaultValue: () => \"Info\"\n});\n/** @internal */\nexport const UnhandledLogLevel = /*#__PURE__*/Context.Reference(\"effect/References/UnhandledLogLevel\", {\n defaultValue: () => \"Error\"\n});\n/** @internal */\nexport const CurrentLogSpans = /*#__PURE__*/Context.Reference(\"effect/References/CurrentLogSpans\", {\n defaultValue: () => []\n});\n//# sourceMappingURL=references.js.map","import { getStackTraceLimit, setStackTraceLimit } from \"./stackTraceLimit.js\";\n/** @internal */\nexport const addSpanStackTrace = options => {\n if (options?.captureStackTrace === false) {\n return options;\n } else if (options?.captureStackTrace !== undefined && typeof options.captureStackTrace !== \"boolean\") {\n return options;\n }\n const limit = getStackTraceLimit();\n if (limit === 0 && options?.captureStackTrace !== true) {\n return {\n ...options,\n captureStackTrace: false\n };\n }\n setStackTraceLimit(3);\n const traceError = new Error();\n setStackTraceLimit(limit);\n return {\n ...options,\n captureStackTrace: spanCleaner(() => traceError.stack)\n };\n};\n/** @internal */\nexport const makeStackCleaner = line => stack => {\n let cache;\n return () => {\n if (cache !== undefined) return cache;\n const trace = stack();\n if (!trace) return undefined;\n const lines = trace.split(\"\\n\");\n if (lines[line] !== undefined) {\n cache = lines[line].trim();\n return cache;\n }\n };\n};\nconst spanCleaner = /*#__PURE__*/makeStackCleaner(3);\n//# sourceMappingURL=tracer.js.map","import * as Arr from \"../Array.js\";\nimport * as Context from \"../Context.js\";\nimport * as Duration from \"../Duration.js\";\nimport * as Equal from \"../Equal.js\";\nimport * as Filter from \"../Filter.js\";\nimport { formatJson } from \"../Formatter.js\";\nimport { constant, constFalse, constTrue, constUndefined, constVoid, dual, identity } from \"../Function.js\";\nimport * as Hash from \"../Hash.js\";\nimport { toJson, toStringUnknown } from \"../Inspectable.js\";\nimport * as Iterable from \"../Iterable.js\";\nimport * as Option from \"../Option.js\";\nimport * as Order from \"../Order.js\";\nimport { pipeArguments } from \"../Pipeable.js\";\nimport { hasProperty, isIterable, isString, isTagged } from \"../Predicate.js\";\nimport { currentFiberTypeId, redact } from \"../Redactable.js\";\nimport * as Result from \"../Result.js\";\nimport * as Scheduler from \"../Scheduler.js\";\nimport * as Tracer from \"../Tracer.js\";\nimport { internalCall } from \"../Utils.js\";\nimport { args, causeAnnotate, causeDie, causeEmpty, causeFromReasons, CauseImpl, constEmptyAnnotations, contA, contAll, contE, evaluate, exitDie, exitFail, exitFailCause, exitSucceed, ExitTypeId, Fail, InterruptorStackTrace, isCause, isDieReason, isEffect, isFailReason, isInterruptReason, isNoSuchElementError, makePrimitive, makePrimitiveProto, NoSuchElementError, ReasonBase, StackTraceKey as CauseStackTrace, TaggedError, withFiber, Yield } from \"./core.js\";\nimport * as doNotation from \"./doNotation.js\";\nimport * as InternalMetric from \"./metric.js\";\nimport * as InternalRecord from \"./record.js\";\nimport { CurrentErrorReporters, CurrentLogAnnotations, CurrentLogLevel, CurrentLogSpans, CurrentStackFrame, MinimumLogLevel, TracerEnabled, TracerSpanAnnotations, TracerSpanLinks, TracerTimingEnabled } from \"./references.js\";\nimport { getStackTraceLimit, setStackTraceLimit } from \"./stackTraceLimit.js\";\nimport { addSpanStackTrace, makeStackCleaner } from \"./tracer.js\";\n// ----------------------------------------------------------------------------\n// Cause\n// ----------------------------------------------------------------------------\n/** @internal */\nexport class Interrupt extends ReasonBase {\n constructor(fiberId, annotations = constEmptyAnnotations) {\n super(\"Interrupt\", annotations, \"Interrupted\");\n this.fiberId = fiberId;\n }\n toString() {\n return `Interrupt(${this.fiberId})`;\n }\n toJSON() {\n return {\n _tag: \"Interrupt\",\n fiberId: this.fiberId\n };\n }\n [Equal.symbol](that) {\n return isInterruptReason(that) && this.fiberId === that.fiberId && this.annotations === that.annotations;\n }\n [Hash.symbol]() {\n return Hash.combine(Hash.string(`${this._tag}:${this.fiberId}`))(Hash.random(this.annotations));\n }\n}\n/** @internal */\nexport const makeInterruptReason = fiberId => new Interrupt(fiberId);\n/** @internal */\nexport const causeInterrupt = fiberId => new CauseImpl([new Interrupt(fiberId)]);\n/** @internal */\nexport const hasFails = self => self.reasons.some(isFailReason);\n/** @internal */\nexport const findFail = self => {\n const reason = self.reasons.find(isFailReason);\n return reason ? Result.succeed(reason) : Result.fail(self);\n};\n/** @internal */\nexport const findError = self => {\n for (let i = 0; i < self.reasons.length; i++) {\n const reason = self.reasons[i];\n if (reason._tag === \"Fail\") {\n return Result.succeed(reason.error);\n }\n }\n return Result.fail(self);\n};\n/** @internal */\nexport const findErrorOption = /*#__PURE__*/Filter.toOption(findError);\n/** @internal */\nexport const hasDies = self => self.reasons.some(isDieReason);\n/** @internal */\nexport const findDie = self => {\n const reason = self.reasons.find(isDieReason);\n return reason ? Result.succeed(reason) : Result.fail(self);\n};\n/** @internal */\nexport const findDefect = self => {\n const reason = self.reasons.find(isDieReason);\n return reason ? Result.succeed(reason.defect) : Result.fail(self);\n};\n/** @internal */\nexport const hasInterrupts = self => self.reasons.some(isInterruptReason);\n/** @internal */\nexport const findInterrupt = self => {\n const reason = self.reasons.find(isInterruptReason);\n return reason ? Result.succeed(reason) : Result.fail(self);\n};\n/** @internal */\nexport const causeFilterInterruptors = self => {\n let interruptors;\n for (let i = 0; i < self.reasons.length; i++) {\n const f = self.reasons[i];\n if (f._tag !== \"Interrupt\") continue;\n interruptors ??= new Set();\n if (f.fiberId !== undefined) {\n interruptors.add(f.fiberId);\n }\n }\n return interruptors ? Result.succeed(interruptors) : Result.fail(self);\n};\n/** @internal */\nexport const causeInterruptors = self => {\n const result = causeFilterInterruptors(self);\n return Result.isFailure(result) ? emptySet : result.success;\n};\nconst emptySet = /*#__PURE__*/new Set();\n/** @internal */\nexport const hasInterruptsOnly = self => self.reasons.length > 0 && self.reasons.every(isInterruptReason);\n/** @internal */\nexport const reasonAnnotations = self => Context.makeUnsafe(self.annotations);\n/** @internal */\nexport const causeAnnotations = self => {\n const map = new Map();\n for (const f of self.reasons) {\n if (f.annotations.size > 0) {\n for (const [key, value] of f.annotations) {\n map.set(key, value);\n }\n }\n }\n return Context.makeUnsafe(map);\n};\nconst dedupeReasons = (self, that) => {\n // Keep deduplication local so causeCombine does not retain Array.ts in the core bundle.\n // Snapshot both arrays before invoking user-defined hash or equality methods.\n const buckets = new Map();\n const out = [];\n for (const reason of self.concat(that)) {\n const hash = Hash.hash(reason);\n const bucket = buckets.get(hash);\n if (bucket === undefined) {\n buckets.set(hash, [reason]);\n } else if (bucket.some(previous => Equal.equals(previous, reason))) {\n continue;\n } else {\n bucket.push(reason);\n }\n out.push(reason);\n }\n return out;\n};\n/** @internal */\nexport const causeCombine = /*#__PURE__*/dual(2, (self, that) => {\n if (self.reasons.length === 0) {\n return that;\n } else if (that.reasons.length === 0) {\n return self;\n }\n const newCause = new CauseImpl(dedupeReasons(self.reasons, that.reasons));\n return Equal.equals(self, newCause) ? self : newCause;\n});\n/** @internal */\nexport const causeMap = /*#__PURE__*/dual(2, (self, f) => {\n let hasFail = false;\n const failures = self.reasons.map(failure => {\n if (isFailReason(failure)) {\n hasFail = true;\n return new Fail(f(failure.error), failure.annotations);\n }\n return failure;\n });\n return hasFail ? causeFromReasons(failures) : self;\n});\n/** @internal */\nexport const causePartition = self => {\n const obj = {\n Fail: [],\n Die: [],\n Interrupt: []\n };\n for (let i = 0; i < self.reasons.length; i++) {\n obj[self.reasons[i]._tag].push(self.reasons[i]);\n }\n return obj;\n};\n/** @internal */\nexport const causeSquash = self => {\n const partitioned = causePartition(self);\n if (partitioned.Fail.length > 0) {\n return partitioned.Fail[0].error;\n } else if (partitioned.Die.length > 0) {\n return partitioned.Die[0].defect;\n } else if (partitioned.Interrupt.length > 0) {\n return new globalThis.Error(\"All fibers interrupted without error\");\n }\n return new globalThis.Error(\"Empty cause\");\n};\n/** @internal */\nexport const causePrettyErrors = (self, options) => {\n const errors = [];\n const interrupts = [];\n if (self.reasons.length === 0) return errors;\n const prevStackLimit = getStackTraceLimit();\n if (prevStackLimit !== 0) setStackTraceLimit(1);\n for (const failure of self.reasons) {\n if (failure._tag === \"Interrupt\") {\n interrupts.push(failure);\n continue;\n }\n errors.push(causePrettyError(failure._tag === \"Die\" ? failure.defect : failure.error, failure.annotations, options));\n }\n if (errors.length === 0) {\n const cause = new Error(\"The fiber was interrupted by:\");\n cause.name = \"InterruptCause\";\n cause.stack = interruptCauseStack(cause, interrupts);\n const error = new globalThis.Error(\"All fibers interrupted without error\", {\n cause\n });\n error.name = \"InterruptError\";\n error.stack = `${error.name}: ${error.message}`;\n errors.push(causePrettyError(error, interrupts[0].annotations, options));\n }\n if (prevStackLimit !== 0) setStackTraceLimit(prevStackLimit);\n return errors;\n};\n/** @internal */\nexport const causePrettyError = (original, annotations, options) => {\n const kind = typeof original;\n let error;\n if (original && kind === \"object\") {\n error = new globalThis.Error(causePrettyMessage(original), {\n cause: original.cause ? causePrettyError(original.cause) : undefined\n });\n if (typeof original.name === \"string\") {\n error.name = original.name;\n }\n if (typeof original.stack === \"string\") {\n error.stack = cleanErrorStack(original.stack, error, annotations);\n } else {\n const stack = `${error.name}: ${error.message}`;\n error.stack = annotations ? addStackAnnotations(stack, annotations) : stack;\n }\n if (options?.includeCauseInStack) {\n error.stack = renderPrettyError(error);\n }\n for (const key of Object.keys(original)) {\n if (!(key in error)) {\n ;\n error[key] = original[key];\n }\n }\n } else {\n error = new globalThis.Error(!original ? `Unknown error: ${original}` : kind === \"string\" ? original : formatJson(original));\n }\n return error;\n};\nconst causePrettyMessage = u => {\n if (typeof u.message === \"string\") {\n return u.message;\n } else if (typeof u.toString === \"function\" && u.toString !== Object.prototype.toString && u.toString !== Array.prototype.toString) {\n try {\n return u.toString();\n } catch {\n // something's off, rollback to json\n }\n }\n return formatJson(u);\n};\nconst locationRegExp = /\\((.*)\\)/g;\nconst cleanErrorStack = (stack, error, annotations) => {\n const message = `${error.name}: ${error.message}`;\n const lines = (stack.startsWith(message) ? stack.slice(message.length) : stack).split(\"\\n\");\n const out = [message];\n for (let i = 1; i < lines.length; i++) {\n if (/(?:Generator\\.next|~effect\\/Effect)/.test(lines[i])) {\n break;\n }\n out.push(lines[i]);\n }\n return annotations ? addStackAnnotations(out.join(\"\\n\"), annotations) : out.join(\"\\n\");\n};\nconst addStackAnnotations = (stack, annotations) => {\n const frame = annotations?.get(CauseStackTrace.key);\n if (frame) {\n stack = `${stack}\\n${currentStackTrace(frame)}`;\n }\n return stack;\n};\nconst interruptCauseStack = (error, interrupts) => {\n const out = [`${error.name}: ${error.message}`];\n for (const current of interrupts) {\n const fiberId = current.fiberId !== undefined ? `#${current.fiberId}` : \"unknown\";\n const frame = current.annotations.get(InterruptorStackTrace.key);\n out.push(` at fiber (${fiberId})`);\n if (frame) out.push(currentStackTrace(frame));\n }\n return out.join(\"\\n\");\n};\nconst currentStackTrace = frame => {\n const out = [];\n let current = frame;\n let i = 0;\n while (current && i < 10) {\n const stack = current.stack();\n if (stack) {\n const locationMatchAll = stack.matchAll(locationRegExp);\n let match = false;\n for (const [, location] of locationMatchAll) {\n match = true;\n out.push(` at ${current.name} (${location})`);\n }\n if (!match) {\n out.push(` at ${current.name} (${stack.replace(/^at /, \"\")})`);\n }\n } else {\n out.push(` at ${current.name}`);\n }\n current = current.parent;\n i++;\n }\n return out.join(\"\\n\");\n};\n/** @internal */\nexport const causePretty = cause => causePrettyErrors(cause).map(renderPrettyError).join(\"\\n\");\nconst renderPrettyError = e => e.cause ? `${e.stack} {\\n${renderErrorCause(e.cause, \" \")}\\n}` : e.stack;\nconst renderErrorCause = (cause, prefix) => {\n const lines = cause.stack.split(\"\\n\");\n let stack = `${prefix}[cause]: ${lines[0]}`;\n for (let i = 1, len = lines.length; i < len; i++) {\n stack += `\\n${prefix}${lines[i]}`;\n }\n if (cause.cause) {\n stack += ` {\\n${renderErrorCause(cause.cause, `${prefix} `)}\\n${prefix}}`;\n }\n return stack;\n};\n// ----------------------------------------------------------------------------\n// Fiber\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const FiberTypeId = \"~effect/Fiber\";\nconst fiberVariance = {\n _A: identity,\n _E: identity\n};\nconst fiberIdStore = {\n id: 0\n};\n/** @internal */\nexport const getCurrentFiber = () => globalThis[currentFiberTypeId];\n/** @internal */\nexport class FiberImpl {\n constructor(context, interruptible = true) {\n this[FiberTypeId] = fiberVariance;\n this.setContext(context);\n this.id = ++fiberIdStore.id;\n this.currentOpCount = 0;\n this.interruptible = interruptible;\n this._stack = [];\n this._observers = undefined;\n this._exit = undefined;\n this._children = undefined;\n this._interruptedCause = undefined;\n this._yielded = undefined;\n this._running = false;\n this._deferredInterrupt = false;\n this._parent = undefined;\n this.cache.runtimeMetrics?.recordFiberStart(this.context);\n }\n [FiberTypeId];\n id;\n interruptible;\n currentOpCount;\n _stack;\n _observers;\n _exit;\n _children;\n _interruptedCause;\n _yielded;\n _running;\n _deferredInterrupt;\n _parent;\n // set in setContext\n context;\n cache;\n _dispatcher = undefined;\n get currentDispatcher() {\n return this._dispatcher ??= this.cache.scheduler.makeDispatcher();\n }\n getRef(ref) {\n return Context.get(this.context, ref);\n }\n addObserver(cb) {\n if (this._exit) {\n cb(this._exit);\n return constVoid;\n }\n if (this._observers === undefined) {\n this._observers = [cb];\n } else {\n this._observers.push(cb);\n }\n return () => {\n if (this._exit || this._observers === undefined) return;\n const index = this._observers.indexOf(cb);\n if (index >= 0) {\n this._observers.splice(index, 1);\n }\n };\n }\n interruptUnsafe(fiberId, annotations) {\n if (this._exit) {\n return;\n }\n let cause = causeInterrupt(fiberId);\n if (this.cache.stackFrame) {\n cause = causeAnnotate(cause, Context.make(CauseStackTrace, this.cache.stackFrame));\n }\n if (annotations) {\n cause = causeAnnotate(cause, annotations);\n }\n this._interruptedCause = this._interruptedCause ? causeCombine(this._interruptedCause, cause) : cause;\n if (this.interruptible) {\n if (this._running) {\n this._deferredInterrupt = true;\n } else {\n this.evaluate(failCause(this._interruptedCause));\n }\n }\n }\n pollUnsafe() {\n return this._exit;\n }\n evaluate(effect) {\n if (this._exit) {\n return;\n } else if (this._yielded !== undefined) {\n const yielded = this._yielded;\n this._yielded = undefined;\n yielded();\n }\n const exit = this.runLoop(effect);\n if (exit === Yield) {\n return;\n }\n // the interruptChildren middleware is added in Effect.forkChild, so it can be\n // tree-shaken if not used\n const interruptChildren = fiberMiddleware.interruptChildren && fiberMiddleware.interruptChildren(this);\n if (interruptChildren !== undefined) {\n return this.evaluate(flatMap(interruptChildren, () => exit));\n }\n this._exit = exit;\n this.cache.runtimeMetrics?.recordFiberEnd(this.context, this._exit);\n if (this._parent) {\n this._parent._children?.delete(this);\n this._parent = undefined;\n }\n if (this._observers !== undefined) {\n const observers = this._observers;\n this._observers = undefined;\n for (let i = 0; i < observers.length; i++) {\n observers[i](exit);\n }\n }\n this._stack.length = 0;\n this._children = undefined;\n this.context = Context.empty();\n }\n runLoop(effect) {\n const prevFiber = globalThis[currentFiberTypeId];\n globalThis[currentFiberTypeId] = this;\n const prevRunning = this._running;\n this._running = true;\n let yielding = false;\n let current = effect;\n this.currentOpCount = 0;\n try {\n while (true) {\n if (this._deferredInterrupt) {\n this._deferredInterrupt = false;\n current = failCause(this._interruptedCause);\n }\n this.currentOpCount++;\n // Refresh the cache because a primitive can replace the fiber context.\n const cache = this.cache;\n if (!yielding && !cache.preventYield && cache.scheduler.shouldYield(this)) {\n yielding = true;\n const prev = current;\n current = flatMap(yieldNow, () => prev);\n }\n current = cache.tracerContext ? cache.tracerContext(current, this) : current[evaluate](this);\n if (current === Yield) {\n const yielded = this._yielded;\n if (ExitTypeId in yielded) {\n this._deferredInterrupt = false;\n this._yielded = undefined;\n return yielded;\n } else if (this._deferredInterrupt) {\n this._yielded = undefined;\n yielded();\n continue;\n }\n return Yield;\n }\n }\n } catch (error) {\n if (!hasProperty(current, evaluate)) {\n return exitDie(`Fiber.runLoop: Not a valid effect: ${String(current)}`);\n }\n return this.runLoop(exitDie(error));\n } finally {\n this._running = prevRunning;\n globalThis[currentFiberTypeId] = prevFiber;\n }\n }\n getCont(symbol) {\n if (this._deferredInterrupt) {\n this._deferredInterrupt = false;\n return deferredInterruptCont;\n }\n while (true) {\n const op = this._stack.pop();\n if (!op) return undefined;\n const all = op[contAll];\n if (all !== undefined) {\n const cont = all.call(op, this);\n if (cont) {\n ;\n cont[symbol] = cont;\n return cont;\n }\n }\n if (op[symbol]) return op;\n }\n }\n yieldWith(value) {\n this._yielded = value;\n return Yield;\n }\n children() {\n return this._children ??= new Set();\n }\n pipe() {\n return pipeArguments(this, arguments);\n }\n setContext(context) {\n const previous = this.context;\n this.context = context;\n // Every key cached below opts in to Context caching, so contexts related\n // only by non-caching adds cannot have changed any of them\n if (previous !== undefined && Context.hasSameCache(previous, context)) return;\n // Contexts sharing a cacheRoot resolve every cached key identically, so\n // the derived cache object is computed once per root and shared by all\n // fibers running with that root (forked fibers reuse the parent's).\n const root = context.cacheRoot;\n const cache = root._fiberCache ??= makeFiberContextCache(context);\n if (this.cache !== undefined && this.cache.scheduler !== cache.scheduler) {\n this._dispatcher = undefined;\n }\n this.cache = cache;\n }\n get currentSpanLocal() {\n const span = this.cache.span;\n return span?._tag === \"Span\" ? span : undefined;\n }\n}\nconst makeFiberContextCache = context => {\n // The string-keyed lookups keep the Tracer key values (and the native\n // tracer behind Tracer.Tracer's default) out of every bundle\n const currentTracer = Context.getOrUndefinedUnsafe(context, Tracer.TracerKey);\n return {\n scheduler: Context.get(context, Scheduler.Scheduler),\n tracer: currentTracer,\n tracerContext: currentTracer ? currentTracer[\"context\"] : undefined,\n tracerEnabled: Context.get(context, TracerEnabled),\n span: Context.getOrUndefinedUnsafe(context, Tracer.ParentSpanKey),\n logLevel: Context.get(context, CurrentLogLevel),\n minimumLogLevel: Context.get(context, MinimumLogLevel),\n stackFrame: Context.get(context, CurrentStackFrame),\n runtimeMetrics: Context.getOrUndefinedUnsafe(context, InternalMetric.FiberRuntimeMetricsKey),\n maxOpsBeforeYield: Context.get(context, Scheduler.MaxOpsBeforeYield),\n preventYield: Context.get(context, Scheduler.PreventSchedulerYield)\n };\n};\nconst deferredInterruptCont = {\n [contA](_value, fiber) {\n return failCause(fiber._interruptedCause);\n },\n [contE](_cause, fiber) {\n return failCause(fiber._interruptedCause);\n }\n};\nconst fiberMiddleware = {\n interruptChildren: undefined\n};\nconst fiberStackAnnotations = fiber => {\n if (!fiber.cache.stackFrame) return undefined;\n const annotations = new Map();\n annotations.set(InterruptorStackTrace.key, fiber.cache.stackFrame);\n return Context.makeUnsafe(annotations);\n};\nconst fiberInterruptChildren = fiber => {\n if (fiber._children === undefined || fiber._children.size === 0) {\n return undefined;\n }\n return fiberInterruptAll(fiber._children);\n};\n/** @internal */\nexport const fiberAwait = self => {\n const impl = self;\n if (impl._exit) return succeed(impl._exit);\n return callback(resume => {\n if (impl._exit) return resume(succeed(impl._exit));\n return sync(self.addObserver(exit => resume(succeed(exit))));\n });\n};\n/** @internal */\nexport const fiberAwaitAll = self => callback(resume => {\n const iter = self[Symbol.iterator]();\n const exits = [];\n let cancel = undefined;\n function loop() {\n let result = iter.next();\n while (!result.done) {\n if (result.value._exit) {\n exits.push(result.value._exit);\n result = iter.next();\n continue;\n }\n cancel = result.value.addObserver(exit => {\n exits.push(exit);\n loop();\n });\n return;\n }\n resume(succeed(exits));\n }\n loop();\n return sync(() => cancel?.());\n});\n/** @internal */\nexport const fiberJoin = self => {\n const impl = self;\n if (impl._exit) return impl._exit;\n return callback(resume => {\n if (impl._exit) return resume(impl._exit);\n return sync(self.addObserver(resume));\n });\n};\n/** @internal */\nexport const fiberJoinAll = self => callback(resume => {\n const fibers = Array.from(self);\n if (fibers.length === 0) return resume(succeed(Arr.empty()));\n const out = new Array(fibers.length);\n const cancels = Arr.empty();\n let done = 0;\n let failed = false;\n for (let i = 0; i < fibers.length; i++) {\n if (failed) break;\n cancels.push(fibers[i].addObserver(exit => {\n done++;\n if (exit._tag === \"Failure\") {\n failed = true;\n cancels.forEach(cancel => cancel());\n return resume(exit);\n }\n out[i] = exit.value;\n if (done === fibers.length) {\n resume(succeed(out));\n }\n }));\n }\n return sync(() => {\n failed = true;\n cancels.forEach(cancel => cancel());\n });\n});\n/** @internal */\nexport const fiberInterrupt = self => withFiber(fiber => fiberInterruptAs(self, fiber.id));\n/** @internal */\nexport const fiberInterruptAs = /*#__PURE__*/dual(args => hasProperty(args[0], FiberTypeId), (self, fiberId, annotations) => withFiber(parent => {\n let ann = fiberStackAnnotations(parent);\n ann = ann && annotations ? Context.merge(ann, annotations) : ann ?? annotations;\n self.interruptUnsafe(fiberId, ann);\n return asVoid(fiberAwait(self));\n}));\n/** @internal */\nexport const fiberInterruptAll = fibers => withFiber(parent => {\n const annotations = fiberStackAnnotations(parent);\n let fiberArr = Arr.empty();\n for (const fiber of fibers) {\n fiber.interruptUnsafe(parent.id, annotations);\n fiberArr.push(fiber);\n }\n return asVoid(fiberAwaitAll(fiberArr));\n});\n/** @internal */\nexport const fiberInterruptAllAs = /*#__PURE__*/dual(2, (fibers, fiberId) => withFiber(parent => {\n const annotations = fiberStackAnnotations(parent);\n const fiberArr = Arr.empty();\n for (const fiber of fibers) {\n fiber.interruptUnsafe(fiberId, annotations);\n fiberArr.push(fiber);\n }\n return asVoid(fiberAwaitAll(fiberArr));\n}));\n/** @internal */\nexport const succeed = exitSucceed;\n/** @internal */\nexport const failCause = exitFailCause;\n/** @internal */\nexport const fail = exitFail;\n/** @internal */\nexport const sync = /*#__PURE__*/makePrimitive({\n op: \"Sync\",\n [evaluate](fiber) {\n const value = this[args]();\n const cont = fiber.getCont(contA);\n return cont ? cont[contA](value, fiber) : fiber.yieldWith(exitSucceed(value));\n }\n});\n/** @internal */\nexport const suspend = /*#__PURE__*/makePrimitive({\n op: \"Suspend\",\n [evaluate](_fiber) {\n return this[args]();\n }\n});\n/** @internal */\nexport const fromOption = /*#__PURE__*/dual(args => args.length >= 2 || Option.isOption(args[0]), (option, onNone) => Option.isNone(option) ? fail(onNone ? onNone() : new NoSuchElementError(\"Effect.fromOption: Option.none\")) : succeed(option.value));\n/** @internal */\nexport const fromResult = /*#__PURE__*/Result.match({\n onFailure: fail,\n onSuccess: succeed\n});\n/** @internal */\nexport const fromNullishOr = value => value == null ? fail(new NoSuchElementError()) : succeed(value);\n/** @internal */\nexport const yieldNowWith = /*#__PURE__*/makePrimitive({\n op: \"Yield\",\n [evaluate](fiber) {\n let resumed = false;\n fiber.currentDispatcher.scheduleTask(() => {\n if (resumed) return;\n fiber.evaluate(exitVoid);\n }, this[args] ?? 0);\n return fiber.yieldWith(() => {\n resumed = true;\n });\n }\n});\n/** @internal */\nexport const yieldNow = /*#__PURE__*/yieldNowWith(0);\n/** @internal */\nexport const succeedSome = a => succeed(Option.some(a));\n/** @internal */\nexport const succeedNone = /*#__PURE__*/succeed(/*#__PURE__*/Option.none());\n/** @internal */\nexport const transposeOption = self => Option.isNone(self) ? succeedNone : map(self.value, Option.some);\n/** @internal */\nexport const failCauseSync = evaluate => suspend(() => failCause(internalCall(evaluate)));\n/** @internal */\nexport const die = defect => exitDie(defect);\n/** @internal */\nexport const failSync = error => suspend(() => fail(internalCall(error)));\n/** @internal */\nconst void_ = /*#__PURE__*/succeed(void 0);\n/** @internal */\nexport { void_ as void };\n/** @internal */\nconst try_ = options => {\n const evaluate = typeof options === \"function\" ? options : options.try;\n const catcher = typeof options === \"function\" ? cause => new UnknownError(cause, \"An error occurred in Effect.try\") : options.catch;\n return suspend(() => {\n try {\n return succeed(internalCall(evaluate));\n } catch (err) {\n return fail(internalCall(() => catcher(err)));\n }\n });\n};\n/** @internal */\nexport { try_ as try };\n/** @internal */\nexport const promise = evaluate => callbackOptions(function (resume, signal) {\n internalCall(() => evaluate(signal)).then(a => resume(succeed(a)), e => resume(die(e)));\n}, evaluate.length !== 0);\n/** @internal */\nexport const tryPromise = options => {\n const f = typeof options === \"function\" ? options : options.try;\n const catcher = typeof options === \"function\" ? cause => new UnknownError(cause, \"An error occurred in Effect.tryPromise\") : options.catch;\n return callbackOptions(function (resume, signal) {\n const failWithCatch = cause => {\n try {\n resume(fail(internalCall(() => catcher(cause))));\n } catch (err) {\n resume(die(err));\n }\n };\n try {\n internalCall(() => f(signal)).then(a => resume(succeed(a)), failWithCatch);\n } catch (err) {\n failWithCatch(err);\n }\n }, f.length !== 0);\n};\n/** @internal */\nexport const withFiberId = f => withFiber(fiber => f(fiber.id));\n/** @internal */\nexport const fiber = /*#__PURE__*/withFiber(succeed);\n/** @internal */\nexport const fiberId = /*#__PURE__*/withFiberId(succeed);\nconst callbackOptions = /*#__PURE__*/function () {\n const Proto = /*#__PURE__*/makePrimitiveProto({\n op: \"Async\",\n [evaluate](fiber) {\n const register = internalCall(() => this.register.bind(fiber.cache.scheduler));\n let resumed = false;\n let yielded = false;\n const controller = this.withSignal ? new AbortController() : undefined;\n const onCancel = register(effect => {\n if (resumed) return;\n resumed = true;\n if (yielded) {\n fiber.evaluate(effect);\n } else {\n yielded = effect;\n }\n }, controller?.signal);\n if (yielded !== false) return yielded;\n yielded = true;\n fiber._yielded = () => {\n resumed = true;\n };\n if (controller === undefined && onCancel === undefined) {\n return Yield;\n }\n fiber._stack.push(asyncFinalizer(() => {\n resumed = true;\n controller?.abort();\n return onCancel ?? exitVoid;\n }));\n return Yield;\n }\n });\n const AsyncImpl = function (register, withSignal) {\n this.register = register;\n this.withSignal = withSignal;\n };\n AsyncImpl.prototype = Proto;\n return function (register, withSignal) {\n return new AsyncImpl(register, withSignal);\n };\n}();\nconst asyncFinalizer = /*#__PURE__*/makePrimitive({\n op: \"AsyncFinalizer\",\n [contAll](fiber) {\n if (fiber.interruptible) {\n fiber.interruptible = false;\n fiber._stack.push(setInterruptibleTrue);\n }\n },\n [contE](cause, _fiber) {\n return hasInterrupts(cause) ? flatMap(this[args](), () => failCause(cause)) : failCause(cause);\n }\n});\n/** @internal */\nexport const callback = register => callbackOptions(register, register.length >= 2);\n/** @internal */\nexport const never = /*#__PURE__*/callback(constVoid);\n/** @internal */\nexport const gen = (...args) => {\n if (args.length === 1) {\n const body = args[0];\n return suspend(() => fromIteratorUnsafe(body()));\n }\n const [options, body] = args;\n return suspend(() => fromIteratorUnsafe(body.call(options.self)));\n};\n/** @internal */\nexport const fnUntraced = (body, ...pipeables) => {\n const fn = pipeables.length === 0 ? function () {\n return suspend(() => fromIteratorUnsafe(body.apply(this, arguments)));\n } : function () {\n let effect = suspend(() => fromIteratorUnsafe(body.apply(this, arguments)));\n for (let i = 0; i < pipeables.length; i++) {\n effect = pipeables[i](effect, ...arguments);\n }\n return effect;\n };\n return defineFunctionLength(body.length, fn);\n};\nconst defineFunctionLength = (length, fn) => Object.defineProperty(fn, \"length\", {\n value: length,\n configurable: true\n});\nconst fnStackCleaner = /*#__PURE__*/makeStackCleaner(2);\n/** @internal */\nexport const fn = function () {\n const nameFirst = typeof arguments[0] === \"string\";\n const name = nameFirst ? arguments[0] : \"Effect.fn\";\n const spanOptions = nameFirst ? arguments[1] : undefined;\n const prevLimit = getStackTraceLimit();\n let defError;\n if (prevLimit !== 0) {\n setStackTraceLimit(2);\n defError = new globalThis.Error();\n setStackTraceLimit(prevLimit);\n }\n if (nameFirst) {\n return (body, ...pipeables) => makeFn(name, body, defError, pipeables, nameFirst, spanOptions);\n }\n return makeFn(name, arguments[0], defError, Array.prototype.slice.call(arguments, 1), nameFirst, spanOptions);\n};\nconst makeFn = (name, bodyOrOptions, defError, pipeables, addSpan, spanOptions) => {\n const body = typeof bodyOrOptions === \"function\" ? bodyOrOptions : pipeables.shift().bind(bodyOrOptions.self);\n return defineFunctionLength(body.length, function (...args) {\n let result = suspend(() => {\n const iter = body.apply(this, arguments);\n return isEffect(iter) ? iter : fromIteratorUnsafe(iter);\n });\n for (let i = 0; i < pipeables.length; i++) {\n result = pipeables[i](result, ...args);\n }\n if (!isEffect(result)) {\n return result;\n }\n const prevLimit = getStackTraceLimit();\n let callError;\n if (prevLimit !== 0) {\n setStackTraceLimit(2);\n callError = new globalThis.Error();\n setStackTraceLimit(prevLimit);\n }\n return updateService(addSpan ? useSpan(name, spanOptions, span => provideParentSpan(result, span)) : result, CurrentStackFrame, prev => ({\n name,\n stack: callError ? fnStackCleaner(() => callError.stack) : constUndefined,\n parent: {\n name: `${name} (definition)`,\n stack: defError ? fnStackCleaner(() => defError.stack) : constUndefined,\n parent: prev\n }\n }));\n });\n};\n/** @internal */\nexport const fnUntracedEager = (body, ...pipeables) => defineFunctionLength(body.length, pipeables.length === 0 ? function () {\n return fromIteratorEagerUnsafe(() => body.apply(this, arguments));\n} : function () {\n let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments));\n for (const pipeable of pipeables) {\n effect = pipeable(effect, ...arguments);\n }\n return effect;\n});\nconst fromIteratorEagerUnsafe = evaluate => {\n try {\n const iterator = evaluate();\n let value = undefined;\n // Try to resolve synchronously in a loop\n while (true) {\n const state = iterator.next(value);\n if (state.done) {\n return succeed(state.value);\n }\n const primitive = state.value;\n if (primitive && primitive._tag === \"Success\") {\n value = primitive.value;\n continue;\n } else if (primitive && primitive._tag === \"Failure\") {\n return state.value;\n } else {\n let isFirstExecution = true;\n return suspend(() => {\n if (isFirstExecution) {\n isFirstExecution = false;\n return flatMap(state.value, value => fromIteratorUnsafe(iterator, value));\n } else {\n return suspend(() => fromIteratorUnsafe(evaluate()));\n }\n });\n }\n }\n } catch (error) {\n return die(error);\n }\n};\nconst fromIteratorUnsafe = /*#__PURE__*/function () {\n const Proto = /*#__PURE__*/makePrimitiveProto({\n op: \"Iterator\",\n [contA](value, fiber) {\n const iter = this.iterator;\n while (true) {\n const state = iter.next(value);\n if (state.done) return succeed(state.value);\n if (!effectIsExit(state.value)) {\n fiber._stack.push(this);\n return state.value;\n } else if (state.value._tag === \"Failure\") {\n return state.value;\n }\n value = state.value.value;\n }\n },\n [evaluate](fiber) {\n return this[contA](this.initial, fiber);\n }\n });\n const IteratorImpl = function (iterator, initial) {\n this.iterator = iterator;\n this.initial = initial;\n };\n IteratorImpl.prototype = Proto;\n return function (iterator, initial) {\n return new IteratorImpl(iterator, initial);\n };\n}();\n// ----------------------------------------------------------------------------\n// mapping & sequencing\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const as = /*#__PURE__*/dual(2, (self, value) => new ContImpl(self, returnPayload, succeed(value)));\nconst evaluateCont = function (fiber) {\n fiber._stack.push(this);\n return this[args];\n};\nconst OnSuccessProto = /*#__PURE__*/makePrimitiveProto({\n op: \"OnSuccess\",\n [evaluate]: evaluateCont\n});\nconst OnSuccessImpl = function (self, f) {\n this[args] = self;\n this[contA] = f;\n};\nOnSuccessImpl.prototype = OnSuccessProto;\n// A success continuation with an extra payload slot. The stored continuation\n// receives the primitive as `this` and reads `this.payload`, so combinators\n// like map / as / tap / andThen can share module-level continuation functions\n// instead of allocating a closure per call.\nconst ContImpl = function (self, cont, payload) {\n this[args] = self;\n this[contA] = cont;\n this.payload = payload;\n};\nContImpl.prototype = OnSuccessProto;\nconst returnPayload = function () {\n return this.payload;\n};\nconst mapCont = function (value) {\n const f = this.payload;\n return succeed(internalCall(() => f(value)));\n};\nconst andThenCont = function (value) {\n const f = this.payload;\n return internalCall(() => f(value));\n};\nconst tapCont = function (value) {\n const f = this.payload;\n return new ContImpl(internalCall(() => f(value)), returnPayload, exitSucceed(value));\n};\nconst tapEffectCont = function (value) {\n return new ContImpl(this.payload, returnPayload, exitSucceed(value));\n};\n/** @internal */\nexport const asSome = self => map(self, Option.some);\n/** @internal */\nexport const flip = self => matchEffect(self, {\n onFailure: succeed,\n onSuccess: fail\n});\n/** @internal */\nexport const andThen = /*#__PURE__*/dual(2, (self, f) => new ContImpl(self, isEffect(f) ? returnPayload : andThenCont, f));\n/** @internal */\nexport const tap = /*#__PURE__*/dual(2, (self, f) => new ContImpl(self, isEffect(f) ? tapEffectCont : tapCont, f));\n/** @internal */\nexport const asVoid = self => new ContImpl(self, returnPayload, exitVoid);\n/** @internal */\nexport const sandbox = self => catchCause(self, fail);\n/** @internal */\nexport const raceAll = (all, options) => withFiber(parent => callback(resume => {\n const effects = Arr.fromIterable(all);\n const len = effects.length;\n let doneCount = 0;\n let done = false;\n const fibers = new Set();\n const failures = [];\n const onExit = (exit, fiber, i) => {\n doneCount++;\n if (exit._tag === \"Failure\") {\n failures.push(...exit.cause.reasons);\n if (doneCount >= len) {\n resume(failCause(causeFromReasons(failures)));\n }\n return;\n }\n const isWinner = !done;\n done = true;\n resume(fibers.size === 0 ? exit : flatMap(uninterruptible(fiberInterruptAll(fibers)), () => exit));\n if (isWinner && options?.onWinner) {\n options.onWinner({\n fiber,\n index: i,\n parentFiber: parent\n });\n }\n };\n for (let i = 0; i < len; i++) {\n const fiber = forkUnsafe(parent, effects[i], true, true, false);\n fibers.add(fiber);\n fiber.addObserver(exit => {\n fibers.delete(fiber);\n onExit(exit, fiber, i);\n });\n if (done) break;\n }\n return fiberInterruptAll(fibers);\n}));\n/** @internal */\nexport const raceAllFirst = (all, options) => withFiber(parent => callback(resume => {\n let done = false;\n const fibers = new Set();\n const onExit = exit => {\n done = true;\n resume(fibers.size === 0 ? exit : flatMap(uninterruptible(fiberInterruptAll(fibers)), () => exit));\n };\n let i = 0;\n for (const effect of all) {\n if (done) break;\n const index = i++;\n const fiber = forkUnsafe(parent, effect, true, true, false);\n fibers.add(fiber);\n fiber.addObserver(exit => {\n fibers.delete(fiber);\n const isWinner = !done;\n onExit(exit);\n if (isWinner && options?.onWinner) {\n options.onWinner({\n fiber,\n index,\n parentFiber: parent\n });\n }\n });\n }\n return fiberInterruptAll(fibers);\n}));\n/** @internal */\nexport const race = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => raceAll([self, that], options));\n/** @internal */\nexport const raceFirst = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => raceAllFirst([self, that], options));\n/** @internal */\nexport const flatMap = /*#__PURE__*/dual(2, (self, f) => new OnSuccessImpl(self, f.length !== 1 ? a => f(a) : f));\n/** @internal */\nexport const matchCauseEffectEager = /*#__PURE__*/dual(2, (self, options) => {\n if (effectIsExit(self)) {\n return self._tag === \"Success\" ? options.onSuccess(self.value) : options.onFailure(self.cause);\n }\n return matchCauseEffect(self, options);\n});\n/** @internal */\nexport const effectIsExit = effect => effect[ExitTypeId] !== undefined;\n/** @internal */\nexport const flatMapEager = /*#__PURE__*/dual(2, (self, f) => {\n if (effectIsExit(self)) {\n return self._tag === \"Success\" ? f(self.value) : self;\n }\n return flatMap(self, f);\n});\n// ----------------------------------------------------------------------------\n// mapping & sequencing\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const flatten = self => flatMap(self, identity);\n/** @internal */\nexport const map = /*#__PURE__*/dual(2, (self, f) => new ContImpl(self, mapCont, f));\n/** @internal */\nexport const mapEager = /*#__PURE__*/dual(2, (self, f) => effectIsExit(self) ? exitMap(self, f) : map(self, f));\n/** @internal */\nexport const mapErrorEager = /*#__PURE__*/dual(2, (self, f) => effectIsExit(self) ? exitMapError(self, f) : mapError(self, f));\n/** @internal */\nexport const mapBothEager = /*#__PURE__*/dual(2, (self, options) => effectIsExit(self) ? exitMapBoth(self, options) : mapBoth(self, options));\n/** @internal */\nexport const catchEager = /*#__PURE__*/dual(2, (self, f) => {\n if (effectIsExit(self)) {\n if (self._tag === \"Success\") return self;\n const error = findError(self.cause);\n if (Result.isFailure(error)) return self;\n return f(error.success);\n }\n return catch_(self, f);\n});\n// ----------------------------------------------------------------------------\n// Exit\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const exitInterrupt = fiberId => exitFailCause(causeInterrupt(fiberId));\n/** @internal */\nexport const exitIsSuccess = self => self._tag === \"Success\";\n/** @internal */\nexport const exitFilterSuccess = self => self._tag === \"Success\" ? Result.succeed(self) : Result.fail(self);\n/** @internal */\nexport const exitFilterValue = self => self._tag === \"Success\" ? Result.succeed(self.value) : Result.fail(self);\n/** @internal */\nexport const exitIsFailure = self => self._tag === \"Failure\";\n/** @internal */\nexport const exitFilterFailure = self => self._tag === \"Failure\" ? Result.succeed(self) : Result.fail(self);\n/** @internal */\nexport const exitFilterCause = self => self._tag === \"Failure\" ? Result.succeed(self.cause) : Result.fail(self);\n/** @internal */\nexport const exitFindError = /*#__PURE__*/Filter.composePassthrough(exitFilterCause, findError);\n/** @internal */\nexport const exitFindDefect = /*#__PURE__*/Filter.composePassthrough(exitFilterCause, findDefect);\n/** @internal */\nexport const exitHasInterrupts = self => self._tag === \"Failure\" && hasInterrupts(self.cause);\n/** @internal */\nexport const exitHasDies = self => self._tag === \"Failure\" && hasDies(self.cause);\n/** @internal */\nexport const exitHasFails = self => self._tag === \"Failure\" && hasFails(self.cause);\n/** @internal */\nexport const exitVoid = /*#__PURE__*/exitSucceed(void 0);\n/** @internal */\nexport const exitMap = /*#__PURE__*/dual(2, (self, f) => self._tag === \"Success\" ? exitSucceed(f(self.value)) : self);\n/** @internal */\nexport const exitMapError = /*#__PURE__*/dual(2, (self, f) => {\n if (self._tag === \"Success\") return self;\n const error = findError(self.cause);\n if (Result.isFailure(error)) return self;\n return exitFail(f(error.success));\n});\n/** @internal */\nexport const exitMapBoth = /*#__PURE__*/dual(2, (self, options) => {\n if (self._tag === \"Success\") return exitSucceed(options.onSuccess(self.value));\n const error = findError(self.cause);\n if (Result.isFailure(error)) return self;\n return exitFail(options.onFailure(error.success));\n});\n/** @internal */\nexport const exitAs = /*#__PURE__*/dual(2, (self, b) => exitIsSuccess(self) ? exitSucceed(b) : self);\n/** @internal */\nexport const exitZipRight = /*#__PURE__*/dual(2, (self, that) => exitIsSuccess(self) ? that : self);\n/** @internal */\nexport const exitMatch = /*#__PURE__*/dual(2, (self, options) => exitIsSuccess(self) ? options.onSuccess(self.value) : options.onFailure(self.cause));\n/** @internal */\nexport const exitAsVoid = /*#__PURE__*/exitAs(void 0);\n/** @internal */\nexport const exitAsVoidAll = exits => {\n const failures = [];\n for (const exit of exits) {\n if (exit._tag === \"Failure\") {\n failures.push(...exit.cause.reasons);\n }\n }\n return failures.length === 0 ? exitVoid : exitFailCause(causeFromReasons(failures));\n};\n/** @internal */\nexport const exitGetSuccess = self => exitIsSuccess(self) ? Option.some(self.value) : Option.none();\n/** @internal */\nexport const exitGetCause = self => exitIsFailure(self) ? Option.some(self.cause) : Option.none();\n/** @internal */\nexport const exitFindErrorOption = self => {\n const error = exitFindError(self);\n return Result.isFailure(error) ? Option.none() : Option.some(error.success);\n};\n// ----------------------------------------------------------------------------\n// environment\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const service = service => service;\n/** @internal */\nexport const serviceOption = service => withFiber(fiber => succeed(Context.getOption(fiber.context, service)));\n/** @internal */\nexport const serviceOptional = service => withFiber(fiber => fromOption(Context.getOption(fiber.context, service)));\n/** @internal */\nexport const updateContext = /*#__PURE__*/dual(2, (self, f) => withFiber(fiber => {\n const prevContext = fiber.context;\n const nextContext = f(prevContext);\n if (prevContext === nextContext) return self;\n fiber.setContext(nextContext);\n return onExitPrimitive(self, () => {\n fiber.setContext(prevContext);\n return undefined;\n });\n}));\n/** @internal */\nexport const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateContext(self, s => {\n const prev = Context.getUnsafe(s, service);\n const next = f(prev);\n if (prev === next) return s;\n return Context.add(s, service, next);\n}));\n/** @internal */\nexport const updateServiceScoped = (service, update, options) => uninterruptible(withFiber(fiber => {\n const original = Context.getUnsafe(fiber.context, service);\n const updated = update(original);\n fiber.setContext(Context.add(fiber.context, service, updated));\n return scopeAddFinalizerExit(Context.getUnsafe(fiber.context, scopeTag), _ => {\n const currentOption = Context.getOption(fiber.context, service);\n if (Option.isNone(currentOption)) return void_;\n const current = currentOption.value;\n let next;\n if (options?.reset === undefined) {\n if (current !== updated) return void_;\n next = original;\n } else {\n next = options.reset(original, updated, current);\n }\n fiber.setContext(Context.add(fiber.context, service, next));\n return void_;\n });\n}));\n/** @internal */\nexport const context = () => getContext;\nconst getContext = /*#__PURE__*/withFiber(fiber => succeed(fiber.context));\n/** @internal */\nexport const contextWith = f => withFiber(fiber => f(fiber.context));\n/** @internal */\nexport const setContext = /*#__PURE__*/dual(2, (self, context) => updateContext(self, constant(context)));\n/** @internal */\nexport const provideContext = /*#__PURE__*/dual(2, (self, context) => {\n if (effectIsExit(self)) return self;\n return updateContext(self, Context.merge(context));\n});\n/** @internal */\nexport const provideService = function () {\n if (arguments.length === 1) {\n return dual(2, (self, impl) => provideServiceImpl(self, arguments[0], impl));\n }\n return dual(3, (self, service, impl) => provideServiceImpl(self, service, impl)).apply(this, arguments);\n};\nconst provideServiceImpl = (self, service, implementation) => updateContext(self, Context.add(service, implementation));\n/** @internal */\nexport const provideServiceEffect = /*#__PURE__*/dual(3, (self, service, acquire) => flatMap(acquire, implementation => provideService(self, service, implementation)));\n// ----------------------------------------------------------------------------\n// zipping\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const zip = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => zipWith(self, that, (a, a2) => [a, a2], options));\n/** @internal */\nexport const zipWith = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, f, options) => options?.concurrent\n// Use `all` exclusively for concurrent cases, as it introduces additional overhead due to the management of concurrency\n? map(all([self, that], {\n concurrency: 2\n}), ([a, a2]) => internalCall(() => f(a, a2))) : flatMap(self, a => map(that, a2 => internalCall(() => f(a, a2)))));\n// ----------------------------------------------------------------------------\n// filtering & conditionals\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const filterOrFail = /*#__PURE__*/dual(args => isEffect(args[0]), (self, predicate, orFailWith) => filterOrElse(self, predicate, orFailWith ? a => fail(orFailWith(a)) : () => fail(new NoSuchElementError())));\n/** @internal */\nexport const when = /*#__PURE__*/dual(2, (self, condition) => flatMap(condition, pass => pass ? asSome(self) : succeedNone));\n// ----------------------------------------------------------------------------\n// repetition\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const replicate = /*#__PURE__*/dual(2, (self, n) => Array.from({\n length: n\n}, () => self));\n/** @internal */\nexport const replicateEffect = /*#__PURE__*/dual(args => isEffect(args[0]), (self, n, options) => all(replicate(self, n), options));\n/** @internal */\nexport const forever = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => whileLoop({\n while: constTrue,\n body: constant(options?.disableYield ? self : flatMap(self, _ => yieldNow)),\n step: constVoid\n}));\n// ----------------------------------------------------------------------------\n// error handling\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const catchCause = /*#__PURE__*/dual(2, (self, f) => new OnFailureImpl(self, f.length !== 1 ? cause => f(cause) : f));\nconst OnFailureProto = /*#__PURE__*/makePrimitiveProto({\n op: \"OnFailure\",\n [evaluate]: evaluateCont\n});\nconst OnFailureImpl = function (self, f) {\n this[args] = self;\n this[contE] = f;\n};\nOnFailureImpl.prototype = OnFailureProto;\n/** @internal */\nexport const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchCause(self, cause => {\n if (!predicate(cause)) {\n return failCause(cause);\n }\n return internalCall(() => f(cause));\n}));\n/** @internal */\nexport const catchCauseFilter = /*#__PURE__*/dual(3, (self, filter, f) => catchCause(self, cause => {\n const eb = filter(cause);\n return Result.isFailure(eb) ? failCause(eb.failure) : internalCall(() => f(eb.success, cause));\n}));\n/** @internal */\nexport const catch_ = /*#__PURE__*/dual(2, (self, f) => catchCauseFilter(self, findError, e => f(e)));\n/** @internal */\nexport const catchNoSuchElement = self => matchEffect(self, {\n onFailure: error => isNoSuchElementError(error) ? succeedNone : fail(error),\n onSuccess: succeedSome\n});\n/** @internal */\nexport const catchDefect = /*#__PURE__*/dual(2, (self, f) => catchCauseFilter(self, findDefect, f));\n/** @internal */\nexport const tapCause = /*#__PURE__*/dual(2, (self, f) => catchCause(self, cause => andThen(internalCall(() => f(cause)), failCause(cause))));\n/** @internal */\nexport const tapCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchCauseIf(self, predicate, cause => andThen(internalCall(() => f(cause)), failCause(cause))));\n/** @internal */\nexport const tapCauseFilter = /*#__PURE__*/dual(3, (self, filter, f) => catchCause(self, cause => {\n const result = filter(cause);\n if (Result.isFailure(result)) {\n return failCause(cause);\n }\n return andThen(internalCall(() => f(result.success, cause)), failCause(cause));\n}));\n/** @internal */\nexport const tapError = /*#__PURE__*/dual(2, (self, f) => tapCauseFilter(self, findError, e => f(e)));\n/** @internal */\nexport const tapErrorTag = /*#__PURE__*/dual(3, (self, k, f) => {\n const predicate = Array.isArray(k) ? e => hasProperty(e, \"_tag\") && k.includes(e._tag) : isTagged(k);\n return tapError(self, error => predicate(error) ? f(error) : void_);\n});\n/** @internal */\nexport const tapDefect = /*#__PURE__*/dual(2, (self, f) => tapCauseFilter(self, findDefect, _ => f(_)));\n/** @internal */\nexport const catchIf = /*#__PURE__*/dual(args => isEffect(args[0]), (self, predicate, f, orElse) => catchCause(self, cause => {\n const error = findError(cause);\n if (Result.isFailure(error)) return failCause(error.failure);\n if (!predicate(error.success)) {\n return orElse ? internalCall(() => orElse(error.success)) : failCause(cause);\n }\n return internalCall(() => f(error.success));\n}));\n/** @internal */\nexport const catchFilter = /*#__PURE__*/dual(args => isEffect(args[0]), (self, filter, f, orElse) => catchCause(self, cause => {\n const error = findError(cause);\n if (Result.isFailure(error)) return failCause(error.failure);\n const result = filter(error.success);\n if (Result.isFailure(result)) {\n return orElse ? internalCall(() => orElse(result.failure)) : failCause(cause);\n }\n return internalCall(() => f(result.success));\n}));\n/** @internal */\nexport const catchTag = /*#__PURE__*/dual(args => isEffect(args[0]), (self, k, f, orElse) => {\n const pred = Array.isArray(k) ? e => hasProperty(e, \"_tag\") && k.includes(e._tag) : isTagged(k);\n return catchIf(self, pred, f, orElse);\n});\n/** @internal */\nexport const catchTags = /*#__PURE__*/dual(args => isEffect(args[0]), (self, cases, orElse) => {\n let keys;\n return catchFilter(self, e => {\n keys ??= Object.keys(cases);\n return hasProperty(e, \"_tag\") && isString(e[\"_tag\"]) && keys.includes(e[\"_tag\"]) ? Result.succeed(e) : Result.fail(e);\n }, e => internalCall(() => cases[e[\"_tag\"]](e)), orElse);\n});\n/** @internal */\nexport const catchReason = /*#__PURE__*/dual(args => isEffect(args[0]), (self, errorTag, reasonTag, f, orElse) => catchIf(self, e => isTagged(e, errorTag) && hasProperty(e, \"reason\") && (orElse !== undefined || isTagged(e.reason, reasonTag)), e => {\n const reason = e.reason;\n if (isTagged(reason, reasonTag)) return f(reason, e);\n return orElse ? internalCall(() => orElse(reason, e)) : fail(e);\n}));\n/** @internal */\nexport const catchReasons = /*#__PURE__*/dual(args => isEffect(args[0]), (self, errorTag, cases, orElse) => {\n let keys;\n return catchIf(self, e => isTagged(e, errorTag) && hasProperty(e, \"reason\") && hasProperty(e.reason, \"_tag\") && isString(e.reason._tag) && (orElse !== undefined || (keys ??= Object.keys(cases)).includes(e.reason._tag)), e => {\n const reason = e.reason;\n keys ??= Object.keys(cases);\n if (keys.includes(reason._tag)) {\n return internalCall(() => cases[reason._tag](reason, e));\n }\n return orElse ? internalCall(() => orElse(reason, e)) : fail(e);\n });\n});\n/** @internal */\nexport const unwrapReason = /*#__PURE__*/dual(2, (self, errorTag) => catchFilter(self, e => {\n if (isTagged(e, errorTag) && hasProperty(e, \"reason\")) {\n return Result.succeed(e.reason);\n }\n return Result.fail(e);\n}, fail));\n/** @internal */\nexport const mapError = /*#__PURE__*/dual(2, (self, f) => catch_(self, error => failSync(() => f(error))));\n/** @internal */\nexport const mapBoth = /*#__PURE__*/dual(2, (self, options) => matchEffect(self, {\n onFailure: e => failSync(() => options.onFailure(e)),\n onSuccess: a => sync(() => options.onSuccess(a))\n}));\n/** @internal */\nexport const orDie = self => catch_(self, die);\n/** @internal */\nexport const orElseSucceed = /*#__PURE__*/dual(2, (self, f) => catch_(self, _ => sync(f)));\n/** @internal */\nexport const firstSuccessOf = effects => suspend(() => {\n const iterator = effects[Symbol.iterator]();\n let state = iterator.next();\n if (state.done) {\n return die(new Error(\"Received an empty collection of effects\"));\n }\n function loop(current) {\n const next = iterator.next();\n if (next.done) return current.value;\n return catch_(current.value, _ => loop(next));\n }\n return loop(state);\n});\n/** @internal */\nexport const eventually = self => catch_(self, _ => flatMap(yieldNow, () => eventually(self)));\n/** @internal */\nexport const ignore = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => {\n if (!options?.log) {\n return matchEffect(self, {\n onFailure: _ => void_,\n onSuccess: _ => void_\n });\n }\n const logEffect = logWithLevel(options.log === true ? undefined : options.log);\n return matchCauseEffect(self, {\n onFailure(cause) {\n const failure = findFail(cause);\n return Result.isFailure(failure) ? failCause(failure.failure) : options.message === undefined ? logEffect(cause) : logEffect(options.message, cause);\n },\n onSuccess: _ => void_\n });\n});\n/** @internal */\nexport const ignoreCause = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => {\n if (!options?.log) {\n return matchCauseEffect(self, {\n onFailure: _ => void_,\n onSuccess: _ => void_\n });\n }\n const logEffect = logWithLevel(options.log === true ? undefined : options.log);\n return matchCauseEffect(self, {\n onFailure: cause => options.message === undefined ? logEffect(cause) : logEffect(options.message, cause),\n onSuccess: _ => void_\n });\n});\n/** @internal */\nexport const option = self => match(self, {\n onFailure: Option.none,\n onSuccess: Option.some\n});\n/** @internal */\nexport const result = self => matchEager(self, {\n onFailure: Result.fail,\n onSuccess: Result.succeed\n});\n// ----------------------------------------------------------------------------\n// pattern matching\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const matchCauseEffect = /*#__PURE__*/dual(2, (self, options) => new OnSuccessAndFailureImpl(self, options.onSuccess.length !== 1 ? a => options.onSuccess(a) : options.onSuccess, options.onFailure.length !== 1 ? cause => options.onFailure(cause) : options.onFailure));\nconst OnSuccessAndFailureProto = /*#__PURE__*/makePrimitiveProto({\n op: \"OnSuccessAndFailure\",\n [evaluate]: evaluateCont\n});\nconst OnSuccessAndFailureImpl = function (self, onSuccess, onFailure) {\n this[args] = self;\n this[contA] = onSuccess;\n this[contE] = onFailure;\n};\nOnSuccessAndFailureImpl.prototype = OnSuccessAndFailureProto;\n/** @internal */\nexport const matchCause = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect(self, {\n onFailure: cause => sync(() => options.onFailure(cause)),\n onSuccess: value => sync(() => options.onSuccess(value))\n}));\n/** @internal */\nexport const matchEffect = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect(self, {\n onFailure: cause => {\n const fail = cause.reasons.find(isFailReason);\n return fail ? internalCall(() => options.onFailure(fail.error)) : failCause(cause);\n },\n onSuccess: options.onSuccess\n}));\n/** @internal */\nexport const match = /*#__PURE__*/dual(2, (self, options) => matchEffect(self, {\n onFailure: error => sync(() => options.onFailure(error)),\n onSuccess: value => sync(() => options.onSuccess(value))\n}));\n/** @internal */\nexport const matchEager = /*#__PURE__*/dual(2, (self, options) => {\n if (effectIsExit(self)) {\n if (self._tag === \"Success\") return exitSucceed(options.onSuccess(self.value));\n const error = findError(self.cause);\n if (Result.isFailure(error)) return self;\n return exitSucceed(options.onFailure(error.success));\n }\n return match(self, options);\n});\n/** @internal */\nexport const matchCauseEager = /*#__PURE__*/dual(2, (self, options) => {\n if (effectIsExit(self)) {\n if (self._tag === \"Success\") return exitSucceed(options.onSuccess(self.value));\n return exitSucceed(options.onFailure(self.cause));\n }\n return matchCause(self, options);\n});\n/** @internal */\nexport const exit = self => effectIsExit(self) ? exitSucceed(self) : exitPrimitive(self);\nconst exitPrimitive = /*#__PURE__*/makePrimitive({\n op: \"Exit\",\n [evaluate](fiber) {\n fiber._stack.push(this);\n return this[args];\n },\n [contA](value, _, exit) {\n return succeed(exit ?? exitSucceed(value));\n },\n [contE](cause, _, exit) {\n return succeed(exit ?? exitFailCause(cause));\n }\n});\n// ----------------------------------------------------------------------------\n// Condition checking\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const isFailure = /*#__PURE__*/matchEager({\n onFailure: () => true,\n onSuccess: () => false\n});\n/** @internal */\nexport const isSuccess = /*#__PURE__*/matchEager({\n onFailure: () => false,\n onSuccess: () => true\n});\n// ----------------------------------------------------------------------------\n// delays & timeouts\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const delay = /*#__PURE__*/dual(2, (self, duration) => andThen(sleep(duration), self));\n/** @internal */\nexport const timeoutOrElse = /*#__PURE__*/dual(2, (self, options) => flatMap(timeoutOption(self, options.duration), option => Option.isNone(option) ? options.orElse() : succeed(option.value)));\n/** @internal */\nconst timeoutErrorFromDuration = duration => new TimeoutError(`Operation timed out after '${Duration.format(duration)}'`);\n/** @internal */\nexport const timeout = /*#__PURE__*/dual(2, (self, duration) => {\n const decoded = Duration.fromInputUnsafe(duration);\n return timeoutOrElse(self, {\n duration: decoded,\n orElse: () => fail(timeoutErrorFromDuration(decoded))\n });\n});\n/** @internal */\nexport const timeoutOption = /*#__PURE__*/dual(2, (self, duration) => raceFirst(asSome(self), as(sleep(duration), Option.none())));\n/** @internal */\nexport const timed = self => clockWith(clock => {\n const start = clock.monotonicTimeNanosUnsafe();\n return map(self, a => [Duration.nanos(clock.monotonicTimeNanosUnsafe() - start), a]);\n});\n// ----------------------------------------------------------------------------\n// resources & finalization\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const ScopeTypeId = \"~effect/Scope\";\n/** @internal */\nexport const ScopeCloseableTypeId = \"~effect/Scope/Closeable\";\n/** @internal */\nexport const scopeTag = /*#__PURE__*/Context.Service(\"effect/Scope\");\n/** @internal */\nexport const scopeClose = (self, exit_) => suspend(() => scopeCloseUnsafe(self, exit_) ?? void_);\n/** @internal */\nexport const scopeCloseUnsafe = (self, exit_) => {\n if (self.state._tag === \"Closed\") return;\n const closed = {\n _tag: \"Closed\",\n exit: exit_\n };\n if (self.state._tag === \"Empty\") {\n self.state = closed;\n return;\n }\n const state = self.state;\n self.state = closed;\n if (state.finalizer !== undefined) {\n return state.finalizer(exit_);\n }\n const finalizers = state.finalizers;\n if (finalizers === undefined || finalizers.size === 0) {\n return;\n } else if (finalizers.size === 1) {\n return finalizers.values().next().value(exit_);\n }\n return scopeCloseFinalizers(self, finalizers, exit_);\n};\nconst combineFinalizerCause = (exit_, finalizer) => exitIsSuccess(exit_) ? finalizer : catchCause(finalizer, cause => failCause(causeCombine(exit_.cause, cause)));\nconst scopeCloseFinalizers = /*#__PURE__*/fnUntraced(function* (self, finalizers, exit_) {\n let exits = [];\n const fibers = [];\n const arr = Array.from(finalizers.values());\n const parent = getCurrentFiber();\n for (let i = arr.length - 1; i >= 0; i--) {\n const finalizer = arr[i];\n if (self.strategy === \"sequential\") {\n exits.push(yield* exit(finalizer(exit_)));\n } else {\n fibers.push(forkUnsafe(parent, finalizer(exit_), true, true, \"inherit\"));\n }\n }\n if (fibers.length > 0) {\n exits = yield* fiberAwaitAll(fibers);\n }\n return yield* exitAsVoidAll(exits);\n});\n/** @internal */\nexport const scopeFork = (scope, finalizerStrategy) => sync(() => scopeForkUnsafe(scope, finalizerStrategy));\n/** @internal */\nexport const scopeForkUnsafe = (scope, finalizerStrategy) => {\n const newScope = scopeMakeUnsafe(finalizerStrategy);\n if (scope.state._tag === \"Closed\") {\n newScope.state = scope.state;\n return newScope;\n }\n const key = {};\n scopeAddFinalizerUnsafe(scope, key, exit => scopeClose(newScope, exit));\n scopeAddFinalizerUnsafe(newScope, key, _ => sync(() => scopeRemoveFinalizerUnsafe(scope, key)));\n return newScope;\n};\n/** @internal */\nexport const scopeAddFinalizerExit = (scope, finalizer) => {\n return suspend(() => {\n if (scope.state._tag === \"Closed\") {\n return finalizer(scope.state.exit);\n }\n scopeAddFinalizerUnsafe(scope, {}, finalizer);\n return void_;\n });\n};\n/** @internal */\nexport const scopeAddFinalizer = (scope, finalizer) => scopeAddFinalizerExit(scope, constant(finalizer));\n/** @internal */\nexport const scopeAddFinalizerUnsafe = (scope, key, finalizer) => {\n if (scope.state._tag === \"Empty\") {\n scope.state = {\n _tag: \"Open\",\n finalizerKey: key,\n finalizer,\n finalizers: undefined\n };\n } else if (scope.state._tag === \"Open\") {\n const state = scope.state;\n if (state.finalizer !== undefined) {\n state.finalizers = new Map([[state.finalizerKey, state.finalizer]]);\n state.finalizerKey = undefined;\n state.finalizer = undefined;\n state.finalizers.set(key, finalizer);\n } else if (state.finalizers === undefined) {\n state.finalizerKey = key;\n state.finalizer = finalizer;\n } else {\n state.finalizers.set(key, finalizer);\n }\n }\n};\n/** @internal */\nexport const scopeRemoveFinalizerUnsafe = (scope, key) => {\n if (scope.state._tag === \"Open\") {\n const state = scope.state;\n if (state.finalizerKey === key) {\n state.finalizerKey = undefined;\n state.finalizer = undefined;\n } else if (state.finalizers !== undefined) {\n state.finalizers.delete(key);\n }\n }\n};\n/** @internal */\nexport const scopeFinalizerCountUnsafe = scope => scope.state._tag !== \"Open\" ? 0 : scope.state.finalizer !== undefined ? 1 : scope.state.finalizers?.size ?? 0;\n/** @internal */\nexport const scopeMakeUnsafe = (finalizerStrategy = \"sequential\") => ({\n [ScopeCloseableTypeId]: ScopeCloseableTypeId,\n [ScopeTypeId]: ScopeTypeId,\n strategy: finalizerStrategy,\n state: constScopeEmpty\n});\nconst constScopeEmpty = {\n _tag: \"Empty\"\n};\n/** @internal */\nexport const scopeMake = finalizerStrategy => sync(() => scopeMakeUnsafe(finalizerStrategy));\n/** @internal */\nexport const scope = scopeTag;\n/** @internal */\nexport const provideScope = /*#__PURE__*/provideService(scopeTag);\n/** @internal */\nexport const scoped = self => withFiber(fiber => {\n const prev = fiber.context;\n const scope = scopeMakeUnsafe();\n fiber.setContext(Context.add(fiber.context, scopeTag, scope));\n return onExitPrimitive(self, exit => {\n fiber.setContext(prev);\n return scopeCloseUnsafe(scope, exit);\n });\n});\n/** @internal */\nexport const scopeUse = /*#__PURE__*/dual(2, (self, scope) => onExit(provideScope(self, scope), exit => suspend(() => scopeCloseUnsafe(scope, exit) ?? void_)));\n/** @internal */\nexport const scopedWith = f => suspend(() => {\n const scope = scopeMakeUnsafe();\n return onExit(f(scope), exit => suspend(() => scopeCloseUnsafe(scope, exit) ?? void_));\n});\n/** @internal */\nexport const acquireRelease = (acquire, release, options) => contextWith(context => uninterruptibleMask(restore => flatMap(scope, scope => tap(options?.interruptible ? restore(acquire) : acquire, a => scopeAddFinalizerExit(scope, exit => provideContext(release(a, exit), context))))));\n/** @internal */\nexport const addFinalizer = finalizer => flatMap(scope, scope => contextWith(context => scopeAddFinalizerExit(scope, exit => provideContext(finalizer(exit), context))));\n/** @internal */\nexport const onExitPrimitive = /*#__PURE__*/function () {\n const Proto = /*#__PURE__*/makePrimitiveProto({\n op: \"OnExit\",\n [evaluate](fiber) {\n fiber._stack.push(this);\n return this.effect;\n },\n [contAll](fiber) {\n if (fiber.interruptible && this.interruptible !== true) {\n fiber._stack.push(setInterruptibleTrue);\n fiber.interruptible = false;\n }\n },\n [contA](value, _, exit) {\n exit ??= exitSucceed(value);\n const eff = this.onExit(exit);\n return eff ? flatMap(eff, _ => exit) : exit;\n },\n [contE](cause, _, exit) {\n exit ??= exitFailCause(cause);\n const eff = this.onExit(exit);\n return eff ? flatMap(combineFinalizerCause(exit, eff), _ => exit) : exit;\n }\n });\n const OnExitImpl = function (effect, onExit, interruptible) {\n this.effect = effect;\n this.onExit = onExit;\n this.interruptible = interruptible;\n };\n OnExitImpl.prototype = Proto;\n return function (effect, onExit, interruptible) {\n return new OnExitImpl(effect, onExit, interruptible);\n };\n}();\n/** @internal */\nexport const onExit = /*#__PURE__*/dual(2, onExitPrimitive);\n/** @internal */\nexport const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => onExit(self, _ => finalizer));\n/** @internal */\nexport const onExitIf = /*#__PURE__*/dual(3, (self, predicate, f) => onExit(self, exit => {\n if (!predicate(exit)) {\n return void_;\n }\n return f(exit);\n}));\n/** @internal */\nexport const onExitFilter = /*#__PURE__*/dual(3, (self, filter, f) => onExit(self, exit => {\n const b = filter(exit);\n return Result.isFailure(b) ? void_ : f(b.success, exit);\n}));\n/** @internal */\nexport const onError = /*#__PURE__*/dual(2, (self, f) => onExitFilter(self, exitFilterCause, f));\n/** @internal */\nexport const onErrorIf = /*#__PURE__*/dual(3, (self, predicate, f) => onExitIf(self, exit => {\n if (exit._tag !== \"Failure\") {\n return false;\n }\n return predicate(exit.cause);\n}, exit => f(exit.cause)));\n/** @internal */\nexport const onErrorFilter = /*#__PURE__*/dual(3, (self, filter, f) => onExit(self, exit => {\n if (exit._tag !== \"Failure\") {\n return void_;\n }\n const result = filter(exit.cause);\n return Result.isFailure(result) ? void_ : f(result.success, exit.cause);\n}));\n/** @internal */\nexport const onInterrupt = /*#__PURE__*/dual(2, (self, finalizer) => onErrorFilter(causeFilterInterruptors, finalizer)(self));\n/** @internal */\nexport const acquireUseRelease = (acquire, use, release) => uninterruptibleMask(restore => flatMap(acquire, a => onExitPrimitive(suspend(() => restore(use(a))), exit => release(a, exit), true)));\n/** @internal */\nexport const acquireDisposable = acquire => acquireRelease(acquire, resource => hasProperty(resource, Symbol.asyncDispose) ? promise(() => resource[Symbol.asyncDispose]()) : sync(() => resource[Symbol.dispose]()));\n// ----------------------------------------------------------------------------\n// Caching\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const cachedInvalidateWithTTL = /*#__PURE__*/dual(2, (self, ttl) => sync(() => {\n const ttlMillis = typeof ttl === \"function\" ? exit => Duration.toMillis(Duration.fromInputUnsafe(ttl(exit))) : constant(Duration.toMillis(Duration.fromInputUnsafe(ttl)));\n const latch = makeLatchUnsafe(false);\n let expiresAt = 0;\n let running = false;\n let exit;\n const wait = flatMap(latch.await, () => exit);\n return [withFiber(fiber => {\n const clock = fiber.getRef(ClockRef);\n const now = expiresAt === Infinity ? 0 : clock.currentTimeMillisUnsafe();\n if (running || now < expiresAt) return exit ?? wait;\n running = true;\n latch.closeUnsafe();\n exit = undefined;\n return onExit(self, exit_ => sync(() => {\n try {\n const duration = ttlMillis(exit_);\n expiresAt = clock.currentTimeMillisUnsafe() + duration;\n exit = exit_;\n } catch (error) {\n const cause = causeDie(error);\n // Publish the same combined cause that onExit returns to the owner.\n exit = exitFailCause(exitIsFailure(exit_) ? causeCombine(exit_.cause, cause) : cause);\n throw error;\n } finally {\n running = false;\n latch.openUnsafe();\n }\n }));\n }), sync(() => {\n expiresAt = 0;\n latch.closeUnsafe();\n exit = undefined;\n })];\n}));\n/** @internal */\nexport const cachedWithTTL = /*#__PURE__*/dual(2, (self, timeToLive) => map(cachedInvalidateWithTTL(self, timeToLive), tuple => tuple[0]));\n/** @internal */\nexport const cached = self => sync(() => {\n const latch = makeLatchUnsafe(false);\n let started = false;\n let exit;\n const wait = flatMap(latch.await, () => exit);\n return suspend(() => {\n if (exit !== undefined) return exit;\n if (started) return wait;\n started = true;\n return onExit(self, result => sync(() => {\n exit = result;\n latch.openUnsafe();\n }));\n });\n});\n// ----------------------------------------------------------------------------\n// interruption\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const interrupt = /*#__PURE__*/withFiber(fiber => failCause(causeInterrupt(fiber.id)));\n/** @internal */\nexport const uninterruptible = self => withFiber(fiber => {\n if (!fiber.interruptible) return self;\n fiber.interruptible = false;\n fiber._stack.push(setInterruptibleTrue);\n return self;\n});\nconst setInterruptible = /*#__PURE__*/makePrimitive({\n op: \"SetInterruptible\",\n [contAll](fiber) {\n fiber.interruptible = this[args];\n if (fiber._interruptedCause && fiber.interruptible) {\n return () => failCause(fiber._interruptedCause);\n }\n }\n});\nconst setInterruptibleTrue = /*#__PURE__*/setInterruptible(true);\nconst setInterruptibleFalse = /*#__PURE__*/setInterruptible(false);\nconst setFiberInterruptible = fiber => {\n fiber.interruptible = true;\n fiber._stack.push(setInterruptibleFalse);\n if (fiber._interruptedCause) return failCause(fiber._interruptedCause);\n};\n/**\n * Makes the current fiber uninterruptible for the returned effect without an\n * extra primitive. Call only within `withFiber`.\n *\n * @internal\n */\nexport const fiberEnterUninterruptibleUnsafe = fiber => {\n const impl = fiber;\n if (!impl.interruptible) return;\n impl.interruptible = false;\n impl._stack.push(setInterruptibleTrue);\n};\n/**\n * Makes the current fiber interruptible for the returned effect without an\n * extra primitive. Call only within `withFiber` and return any pending\n * interruption it produces.\n *\n * @internal\n */\nexport const fiberEnterInterruptibleUnsafe = fiber => {\n const impl = fiber;\n if (impl.interruptible) return undefined;\n return setFiberInterruptible(impl);\n};\n/** @internal */\nexport const interruptible = self => withFiber(fiber => {\n if (fiber.interruptible) return self;\n return setFiberInterruptible(fiber) ?? self;\n});\n/** @internal */\nexport const uninterruptibleMask = f => withFiber(fiber => {\n if (!fiber.interruptible) return f(identity);\n fiber.interruptible = false;\n fiber._stack.push(setInterruptibleTrue);\n return f(interruptible);\n});\n/** @internal */\nexport const interruptibleMask = f => withFiber(fiber => {\n if (fiber.interruptible) return f(identity);\n const interrupted = setFiberInterruptible(fiber);\n const effect = f(uninterruptible);\n return interrupted ?? effect;\n});\n/** @internal */\nexport const abortSignal = /*#__PURE__*/map(/*#__PURE__*/acquireRelease(/*#__PURE__*/sync(() => new AbortController()), controller => sync(() => controller.abort())), _ => _.signal);\n// ========================================================================\n// collecting & elements\n// ========================================================================\n/** @internal */\nexport const all = (arg, options) => {\n if (isIterable(arg)) {\n return options?.mode === \"result\" ? forEach(arg, result, options) : forEach(arg, identity, options);\n } else if (options?.discard) {\n return options.mode === \"result\" ? forEach(Object.values(arg), result, options) : forEach(Object.values(arg), identity, options);\n }\n return suspend(() => {\n const out = {};\n return as(forEach(Object.entries(arg), ([key, effect]) => map(options?.mode === \"result\" ? result(effect) : effect, value => {\n InternalRecord.assignProperty(out, key, value);\n }), {\n discard: true,\n concurrency: options?.concurrency\n }), out);\n });\n};\n/** @internal */\nexport const partition = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, f, options) => map(forEach(elements, (a, i) => result(f(a, i)), options), results => Arr.partition(results, identity)));\n/** @internal */\nexport const reduce = /*#__PURE__*/dual(3, (elements, zero, f) => {\n const arr = Arr.fromIterable(elements);\n if (arr.length === 0) return sync(zero);\n return suspend(() => {\n let index = 0;\n let state = zero();\n return map(whileLoop({\n while: () => index < arr.length,\n body: () => f(state, arr[index], index),\n step(next) {\n state = next;\n index++;\n }\n }), () => state);\n });\n});\n/** @internal */\nexport const validate = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, f, options) => flatMap(partition(elements, f, {\n concurrency: options?.concurrency\n}), ([excluded, satisfying]) => {\n if (Arr.isArrayNonEmpty(excluded)) {\n return fail(excluded);\n }\n return options?.discard ? void_ : succeed(satisfying);\n}));\n/** @internal */\nexport const findFirst = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, predicate) => suspend(() => {\n const iterator = elements[Symbol.iterator]();\n const next = iterator.next();\n if (!next.done) {\n return findFirstLoop(iterator, 0, predicate, next.value);\n }\n return succeed(Option.none());\n}));\nconst findFirstLoop = (iterator, index, predicate, value) => flatMap(predicate(value, index), keep => {\n if (keep) {\n return succeed(Option.some(value));\n }\n const next = iterator.next();\n if (!next.done) {\n return findFirstLoop(iterator, index + 1, predicate, next.value);\n }\n return succeed(Option.none());\n});\n/** @internal */\nexport const findFirstFilter = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, filter) => suspend(() => {\n const iterator = elements[Symbol.iterator]();\n const next = iterator.next();\n if (!next.done) {\n return findFirstFilterLoop(iterator, 0, filter, next.value);\n }\n return succeed(Option.none());\n}));\nconst findFirstFilterLoop = (iterator, index, filter, value) => flatMap(filter(value, index), result => {\n if (Result.isSuccess(result)) {\n return succeed(Option.some(result.success));\n }\n const next = iterator.next();\n if (!next.done) {\n return findFirstFilterLoop(iterator, index + 1, filter, next.value);\n }\n return succeed(Option.none());\n});\n/** @internal */\nexport const whileLoop = /*#__PURE__*/makePrimitive({\n op: \"While\",\n [contA](value, fiber) {\n this[args].step(value);\n if (this[args].while()) {\n fiber._stack.push(this);\n return this[args].body();\n }\n return exitVoid;\n },\n [evaluate](fiber) {\n if (this[args].while()) {\n fiber._stack.push(this);\n return this[args].body();\n }\n return exitVoid;\n }\n});\n/** @internal */\nexport const forEach = /*#__PURE__*/dual(args => typeof args[1] === \"function\", (iterable, f, options) => suspend(() => {\n const concurrency = resolveConcurrency(options?.concurrency);\n if (concurrency === 1) {\n return forEachSequential(iterable, f, options);\n }\n const items = Arr.fromIterable(iterable);\n let length = items.length;\n if (length === 0) {\n return options?.discard ? void_ : succeed([]);\n }\n const out = options?.discard ? undefined : new Array(length);\n const eff = forEachConcurrent({\n f,\n out\n }, items, {\n concurrency\n });\n return eff ? as(eff, out) : succeed(out);\n}));\n/** @internal */\nexport const head = self => flatMap(self, elements => {\n const result = elements[Symbol.iterator]().next();\n return result.done ? fail(new NoSuchElementError()) : succeed(result.value);\n});\nconst forEachSequential = (iterable, f, options) => suspend(() => {\n const out = options?.discard ? undefined : [];\n const iterator = iterable[Symbol.iterator]();\n let state = iterator.next();\n let index = 0;\n return as(whileLoop({\n while: () => !state.done,\n body: () => f(state.value, index++),\n step: b => {\n if (out) out.push(b);\n state = iterator.next();\n }\n }), out);\n});\n/** @internal */\nexport const resolveConcurrency = concurrency => concurrency === \"unbounded\" ? Number.POSITIVE_INFINITY : Math.max(1, concurrency ?? 1);\n/** @internal */\nexport const iterateEager = () => options => {\n const onItem = options.onItem;\n const step = options.step;\n const runSequential = (state, items, index = 0, end = items.length) => {\n for (; index < end; index++) {\n const item = items[index];\n const effect = onItem(state, item, index);\n if (!effectIsExit(effect)) {\n return flatMap(exit(effect), itemExit => step(state, item, itemExit, index) ?? runSequential(state, items, index + 1, end) ?? void_);\n }\n const terminal = step(state, item, effect, index);\n if (terminal) return terminal._tag === \"Failure\" ? terminal : undefined;\n }\n };\n return runSequential;\n};\nconst iterateConcurrentImpl = options => {\n const onItem = options.onItem;\n const step = options.step;\n return (state, items, opts) => {\n let index = 0;\n const end = opts.end ?? items.length;\n const concurrency = opts.concurrency;\n let done = false;\n let parentFiber;\n let fibers;\n let resume;\n let interrupted = false;\n let terminal;\n let effect;\n const failDefect = error => {\n const defect = exitDie(error);\n terminal = defect;\n done = true;\n interrupted = true;\n return fibers && fibers.size > 0 ? flatMap(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => defect) : defect;\n };\n const go = () => {\n let paused = false;\n for (; !terminal && index < end; index++) {\n const item = items[index];\n const eff = effect ?? onItem(state, item, index);\n // fast case (already an exit)\n if (effectIsExit(eff)) {\n terminal = step(state, item, eff, index);\n if (terminal) break;\n // We have an effect, so enter \"async\" mode\n } else if (!parentFiber) {\n return callback(cb => {\n parentFiber = getCurrentFiber();\n fibers = new Set();\n effect = eff;\n resume = cb;\n let result;\n try {\n result = go();\n } catch (error) {\n return cb(failDefect(error));\n }\n if (result) return cb(result);\n return suspend(() => {\n terminal = exitVoid;\n interrupted = true;\n return fibers ? fiberInterruptAll(fibers) : void_;\n });\n });\n // Fork the effect with concurrency > 1\n } else {\n // Clear the temporary effect from capturing the parentFiber\n effect = undefined;\n const fiber = forkUnsafe(parentFiber, eff, true, true, \"inherit\");\n if (fiber._exit) {\n terminal = step(state, item, fiber._exit, index);\n if (terminal) break;\n continue;\n }\n // Add the fiber to the Set\n fibers.add(fiber);\n const currentIndex = index;\n fiber.addObserver(exit => {\n fibers.delete(fiber);\n try {\n if (terminal) {\n if (!interrupted && exit._tag === \"Failure\") {\n for (const reason of exit.cause.reasons) {\n if (reason._tag === \"Interrupt\") continue;else if (terminal._tag === \"Failure\") {\n ;\n terminal.cause.reasons.push(reason);\n } else {\n terminal = exitFailCause(causeFromReasons([reason]));\n }\n }\n }\n } else {\n const result = step(state, item, exit, currentIndex);\n if (result) {\n terminal = result._tag === \"Failure\" ? exitFailCause(causeFromReasons(result.cause.reasons.slice())) : result;\n go();\n }\n }\n if (paused) {\n const eff = go();\n if (eff) resume(eff);\n } else if (done && fibers.size === 0) {\n resume(terminal ?? void_);\n }\n } catch (error) {\n resume(failDefect(error));\n }\n });\n // Check if we have reached the concurrency limit\n if (fibers.size < concurrency) continue;\n paused = true;\n index++;\n return;\n }\n }\n done = true;\n if (terminal) {\n if (fibers && fibers.size > 0) {\n const annotations = fiberStackAnnotations(parentFiber);\n fibers.forEach(f => f.interruptUnsafe(parentFiber.id, annotations));\n return;\n }\n if (resume || terminal._tag === \"Failure\") {\n return terminal;\n }\n } else if (resume) {\n if (!fibers) {\n return exitVoid;\n } else if (fibers.size === 0) {\n resume(void_);\n }\n }\n };\n return go();\n };\n};\n/** @internal */\nexport const iterateConcurrent = () => options => iterateConcurrentImpl(options);\nconst forEachConcurrent = /*#__PURE__*/iterateConcurrentImpl({\n onItem(state, item, index) {\n return state.f(item, index);\n },\n step(state, _, exit, index) {\n if (exit._tag === \"Failure\") return exit;else if (state.out) {\n state.out[index] = exit.value;\n }\n }\n});\n/** @internal */\nexport const filterOrElse = /*#__PURE__*/dual(3, (self, predicate, orElse) => flatMap(self, a => predicate(a) ? succeed(a) : orElse(a)));\n/** @internal */\nexport const filterMapOrElse = /*#__PURE__*/dual(3, (self, filter, orElse) => flatMap(self, a => {\n const result = filter(a);\n return Result.isFailure(result) ? orElse(result.failure) : succeed(result.success);\n}));\n/** @internal */\nexport const filterMapOrFail = /*#__PURE__*/dual(args => isEffect(args[0]), (self, filter, orFailWith) => filterMapOrElse(self, filter, orFailWith ? x => fail(orFailWith(x)) : () => fail(new NoSuchElementError())));\n/** @internal */\nexport const filter = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, predicate, options) => suspend(() => {\n const out = [];\n return as(forEach(elements, (a, i) => {\n const result = predicate(a, i);\n if (typeof result === \"boolean\") {\n if (result) out.push(a);\n return void_;\n }\n return map(result, keep => {\n if (keep) {\n out.push(a);\n }\n });\n }, {\n discard: true,\n concurrency: options?.concurrency\n }), out);\n}));\n/** @internal */\nexport const filterMap = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, filter) => suspend(() => {\n const out = [];\n for (const a of elements) {\n const result = filter(a);\n if (Result.isSuccess(result)) {\n out.push(result.success);\n }\n }\n return succeed(out);\n}));\n/** @internal */\nexport const filterMapEffect = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, filter, options) => suspend(() => {\n const out = [];\n return as(forEach(elements, a => map(filter(a), result => {\n if (Result.isSuccess(result)) {\n out.push(result.success);\n }\n }), {\n discard: true,\n concurrency: options?.concurrency\n }), out);\n}));\n// ----------------------------------------------------------------------------\n// do notation\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const Do = /*#__PURE__*/succeed({});\n/** @internal */\nexport const bindTo = /*#__PURE__*/doNotation.bindTo(map);\n/** @internal */\nexport const bind = /*#__PURE__*/doNotation.bind(map, flatMap);\n/** @internal */\nconst let_ = /*#__PURE__*/doNotation.let_(map);\n/** @internal */\nexport { let_ as let };\n// ----------------------------------------------------------------------------\n// fibers & forking\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const forkChild = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => withFiber(fiber => {\n interruptChildrenPatch();\n return succeed(forkUnsafe(fiber, self, options?.startImmediately, false, options?.uninterruptible ?? false));\n}));\n/** @internal */\nexport const forkUnsafe = (parent, effect, immediate = false, daemon = false, uninterruptible = false) => {\n const parentRuntime = parent;\n const interruptible = uninterruptible === \"inherit\" ? parentRuntime.interruptible : !uninterruptible;\n const child = new FiberImpl(parentRuntime.context, interruptible);\n if (immediate) {\n child.evaluate(effect);\n } else {\n parentRuntime.currentDispatcher.scheduleTask(() => child.evaluate(effect), 0);\n }\n if (!daemon && !child._exit) {\n parentRuntime.children().add(child);\n child._parent = parentRuntime;\n }\n return child;\n};\n/** @internal */\nexport const forkDetach = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => withFiber(fiber => succeed(forkUnsafe(fiber, self, options?.startImmediately, true, options?.uninterruptible))));\n/** @internal */\nexport const awaitAllChildren = self => withFiber(fiber => {\n const initialChildren = fiber._children && new Set(fiber._children);\n return onExit(self, _ => {\n let children = fiber._children;\n if (children === undefined || children.size === 0) {\n return void_;\n } else if (initialChildren) {\n children = Iterable.filter(children, child => !initialChildren.has(child));\n }\n return asVoid(fiberAwaitAll(children));\n });\n});\n/** @internal */\nexport const forkIn = /*#__PURE__*/dual(args => isEffect(args[0]), (self, scope, options) => withFiber(parent => {\n const fiber = forkUnsafe(parent, self, options?.startImmediately, true, options?.uninterruptible);\n if (!fiber._exit) {\n if (scope.state._tag !== \"Closed\") {\n const key = {};\n const finalizer = () => withFiberId(interruptor => interruptor === fiber.id ? void_ : fiberInterrupt(fiber));\n scopeAddFinalizerUnsafe(scope, key, finalizer);\n fiber.addObserver(() => scopeRemoveFinalizerUnsafe(scope, key));\n } else {\n fiber.interruptUnsafe(parent.id, fiberStackAnnotations(parent));\n }\n }\n return succeed(fiber);\n}));\n/** @internal */\nexport const forkScoped = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => flatMap(scope, scope => forkIn(self, scope, options)));\n// ----------------------------------------------------------------------------\n// execution\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const runForkWith = context => (effect, options) => {\n const fiber = new FiberImpl(options?.scheduler ? Context.add(context, Scheduler.Scheduler, options.scheduler) : context, options?.uninterruptible !== true);\n fiber.evaluate(effect);\n if (fiber._exit) return fiber;\n if (options?.signal) {\n if (options.signal.aborted) {\n fiber.interruptUnsafe();\n } else {\n const abort = () => fiber.interruptUnsafe();\n options.signal.addEventListener(\"abort\", abort, {\n once: true\n });\n fiber.addObserver(() => options.signal.removeEventListener(\"abort\", abort));\n }\n }\n if (options?.onFiberStart) {\n options.onFiberStart(fiber);\n }\n return fiber;\n};\n/** @internal */\nexport const fiberRunIn = /*#__PURE__*/dual(2, (self, scope) => {\n if (self._exit) {\n return self;\n } else if (scope.state._tag === \"Closed\") {\n self.interruptUnsafe(self.id);\n return self;\n }\n const key = {};\n scopeAddFinalizerUnsafe(scope, key, () => fiberInterrupt(self));\n self.addObserver(() => scopeRemoveFinalizerUnsafe(scope, key));\n return self;\n});\n/** @internal */\nexport const runFork = /*#__PURE__*/runForkWith(/*#__PURE__*/Context.empty());\n/** @internal */\nexport const runCallbackWith = context => {\n const runFork = runForkWith(context);\n return (effect, options) => {\n const fiber = runFork(effect, options);\n if (options?.onExit) {\n fiber.addObserver(options.onExit);\n }\n return interruptor => {\n return fiber.interruptUnsafe(interruptor);\n };\n };\n};\n/** @internal */\nexport const runCallback = /*#__PURE__*/runCallbackWith(/*#__PURE__*/Context.empty());\n/** @internal */\nexport const runPromiseExitWith = context => {\n const runFork = runForkWith(context);\n return (effect, options) => {\n const fiber = runFork(effect, options);\n return new Promise(resolve => {\n fiber.addObserver(exit => resolve(exit));\n });\n };\n};\n/** @internal */\nexport const runPromiseExit = /*#__PURE__*/runPromiseExitWith(/*#__PURE__*/Context.empty());\n/** @internal */\nexport const runPromiseWith = context => {\n const runPromiseExit = runPromiseExitWith(context);\n return (effect, options) => runPromiseExit(effect, options).then(exit => {\n if (exit._tag === \"Failure\") {\n throw causeSquash(exit.cause);\n }\n return exit.value;\n });\n};\n/** @internal */\nexport const runPromise = /*#__PURE__*/runPromiseWith(/*#__PURE__*/Context.empty());\n/** @internal */\nexport const runSyncExitWith = context => {\n const runFork = runForkWith(context);\n return effect => {\n if (effectIsExit(effect)) return effect;\n const scheduler = new Scheduler.MixedScheduler(\"sync\");\n const fiber = runFork(effect, {\n scheduler\n });\n fiber._dispatcher?.flush();\n return fiber._exit ?? exitDie(new AsyncFiberError(fiber));\n };\n};\n/** @internal */\nexport const runSyncExit = /*#__PURE__*/runSyncExitWith(/*#__PURE__*/Context.empty());\n/** @internal */\nexport const runSyncWith = context => {\n const runSyncExit = runSyncExitWith(context);\n return effect => {\n const exit = runSyncExit(effect);\n if (exit._tag === \"Failure\") throw causeSquash(exit.cause);\n return exit.value;\n };\n};\n/** @internal */\nexport const runSync = /*#__PURE__*/runSyncWith(/*#__PURE__*/Context.empty());\nconst succeedTrue = /*#__PURE__*/succeed(true);\nconst succeedFalse = /*#__PURE__*/succeed(false);\nclass Latch {\n waiters = [];\n scheduled = undefined;\n _isOpen;\n constructor(isOpen) {\n this._isOpen = isOpen;\n }\n scheduleUnsafe(fiber) {\n if (this.waiters.length === 0) {\n return succeedTrue;\n }\n if (this.scheduled === undefined) {\n this.scheduled = this.waiters;\n fiber.currentDispatcher.scheduleTask(this.flushScheduled, 0);\n } else {\n for (let i = 0; i < this.waiters.length; i++) {\n this.scheduled.push(this.waiters[i]);\n }\n }\n this.waiters = [];\n return succeedTrue;\n }\n flushScheduled = () => {\n if (this.scheduled === undefined) return;\n const waiters = this.scheduled;\n this.scheduled = undefined;\n for (let i = 0; i < waiters.length; i++) {\n waiters[i](exitVoid);\n }\n };\n flushWaiters() {\n // swap both arrays out before any resume runs: a resumed waiter can\n // reentrantly close the latch and register new waiters, which must not\n // be drained by this flush\n const waiters = this.waiters;\n this.waiters = [];\n this.flushScheduled();\n for (let i = 0; i < waiters.length; i++) {\n waiters[i](exitVoid);\n }\n }\n open = /*#__PURE__*/withFiber(fiber => {\n if (this._isOpen) return succeedFalse;\n this._isOpen = true;\n return this.scheduleUnsafe(fiber);\n });\n release = /*#__PURE__*/withFiber(fiber => this._isOpen ? succeedFalse : this.scheduleUnsafe(fiber));\n openUnsafe() {\n if (this._isOpen) return false;\n this._isOpen = true;\n this.flushWaiters();\n return true;\n }\n await = /*#__PURE__*/callback(resume => {\n if (this._isOpen) {\n return resume(void_);\n }\n this.waiters.push(resume);\n return sync(() => {\n let index = this.waiters.indexOf(resume);\n if (index !== -1) {\n this.waiters.splice(index, 1);\n } else if (this.scheduled !== undefined) {\n index = this.scheduled.indexOf(resume);\n if (index !== -1) {\n this.scheduled.splice(index, 1);\n }\n }\n });\n });\n closeUnsafe() {\n if (!this._isOpen) return false;\n this._isOpen = false;\n return true;\n }\n close = /*#__PURE__*/sync(() => this.closeUnsafe());\n whenOpen = self => flatMap(this.await, () => self);\n isOpen() {\n return this._isOpen;\n }\n}\n/** @internal */\nexport const makeLatchUnsafe = open => new Latch(open ?? false);\n/** @internal */\nexport const makeLatch = open => sync(() => makeLatchUnsafe(open));\n// ----------------------------------------------------------------------------\n// Tracer\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const tracer = /*#__PURE__*/withFiber(fiber => succeed(fiber.getRef(Tracer.Tracer)));\n/** @internal */\nexport const withTracer = /*#__PURE__*/dual(2, (effect, tracer) => provideService(effect, Tracer.Tracer, tracer));\n/** @internal */\nexport const withTracerEnabled = /*#__PURE__*/provideService(TracerEnabled);\n/** @internal */\nexport const withTracerTiming = /*#__PURE__*/provideService(TracerTimingEnabled);\nconst bigint0 = /*#__PURE__*/BigInt(0);\nconst NoopSpanProto = {\n _tag: \"Span\",\n spanId: \"noop\",\n traceId: \"noop\",\n sampled: false,\n status: {\n _tag: \"Ended\",\n startTime: bigint0,\n endTime: bigint0,\n exit: exitVoid\n },\n attributes: /*#__PURE__*/new Map(),\n links: [],\n kind: \"internal\",\n attribute() {},\n event() {},\n end() {},\n addLinks() {}\n};\n/** @internal */\nexport const noopSpan = options => Object.assign(Object.create(NoopSpanProto), options);\nconst filterDisablePropagation = span => {\n if (!span) return Option.none();\n return Context.get(span.annotations, Tracer.DisablePropagation) ? span._tag === \"Span\" ? filterDisablePropagation(Option.getOrUndefined(span.parent)) : Option.none() : Option.some(span);\n};\n/** @internal */\nexport const makeSpanUnsafe = (fiber, name, options) => {\n const disablePropagation = !fiber.getRef(TracerEnabled) || options?.annotations && Context.get(options.annotations, Tracer.DisablePropagation);\n const parent = options?.parent !== undefined ? Option.some(options.parent) : options?.root ? Option.none() : filterDisablePropagation(fiber.cache.span);\n let span;\n if (disablePropagation) {\n span = noopSpan({\n name,\n parent,\n annotations: Context.add(options?.annotations ?? Context.empty(), Tracer.DisablePropagation, true)\n });\n } else {\n const tracer = fiber.getRef(Tracer.Tracer);\n const clock = fiber.getRef(ClockRef);\n const timingEnabled = fiber.getRef(TracerTimingEnabled);\n const annotationsFromEnv = fiber.getRef(TracerSpanAnnotations);\n const linksFromEnv = fiber.getRef(TracerSpanLinks);\n const level = options?.level ?? fiber.getRef(Tracer.CurrentTraceLevel);\n const links = options?.links !== undefined ? [...linksFromEnv, ...options.links] : linksFromEnv.length === 0 ? [] : linksFromEnv.slice();\n span = tracer.span({\n name,\n parent,\n annotations: options?.annotations ?? Context.empty(),\n links,\n startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : bigint0,\n kind: options?.kind ?? \"internal\",\n root: options?.root ?? Option.isNone(parent),\n sampled: options?.sampled ?? (Option.isSome(parent) && parent.value.sampled === false ? false : !isLogLevelGreaterThan(fiber.getRef(Tracer.MinimumTraceLevel), level))\n });\n for (const key in annotationsFromEnv) {\n span.attribute(key, annotationsFromEnv[key]);\n }\n if (options?.attributes !== undefined) {\n for (const key in options.attributes) {\n span.attribute(key, options.attributes[key]);\n }\n }\n }\n return span;\n};\n/** @internal */\nexport const makeSpan = (name, options) => withFiber(fiber => succeed(makeSpanUnsafe(fiber, name, options)));\n/** @internal */\nexport const makeSpanScoped = (name, options) => uninterruptible(withFiber(fiber => {\n const scope = Context.getUnsafe(fiber.context, scopeTag);\n const span = makeSpanUnsafe(fiber, name, options ?? {});\n const clock = fiber.getRef(ClockRef);\n const timingEnabled = fiber.getRef(TracerTimingEnabled);\n return as(scopeAddFinalizerExit(scope, exit => endSpan(span, exit, clock, timingEnabled)), span);\n}));\n/** @internal */\nexport const withSpanScoped = function () {\n const dataFirst = typeof arguments[0] !== \"string\";\n const name = dataFirst ? arguments[1] : arguments[0];\n const options = addSpanStackTrace(dataFirst ? arguments[2] : arguments[1]);\n if (dataFirst) {\n const self = arguments[0];\n return flatMap(makeSpanScoped(name, options), span => withParentSpan(self, span, options));\n }\n return self => flatMap(makeSpanScoped(name, options), span => withParentSpan(self, span, options));\n};\nconst provideSpanStackFrame = (name, stack) => {\n stack = typeof stack === \"function\" ? stack : constUndefined;\n return updateService(CurrentStackFrame, parent => ({\n name,\n stack,\n parent\n }));\n};\n/** @internal */\nexport const spanAnnotations = TracerSpanAnnotations;\n/** @internal */\nexport const spanLinks = TracerSpanLinks;\n/** @internal */\nexport const linkSpans = /*#__PURE__*/dual(args => isEffect(args[0]), (self, span, attributes = {}) => {\n const spans = Array.isArray(span) ? span : [span];\n const links = spans.map(span => ({\n span,\n attributes\n }));\n return updateService(self, TracerSpanLinks, current => [...current, ...links]);\n});\n/** @internal */\nexport const endSpan = (span, exit, clock, timingEnabled) => sync(() => {\n if (span.status._tag === \"Ended\") return;\n span.end(timingEnabled ? clock.currentTimeNanosUnsafe() : bigint0, exit);\n});\n/** @internal */\nexport const useSpan = (name, ...args) => {\n const options = args.length === 1 ? undefined : args[0];\n const evaluate = args[args.length - 1];\n return withFiber(fiber => {\n const span = makeSpanUnsafe(fiber, name, options);\n const clock = fiber.getRef(ClockRef);\n const timingEnabled = fiber.getRef(TracerTimingEnabled);\n return onExit(suspend(() => internalCall(() => evaluate(span))), exit => endSpan(span, exit, clock, timingEnabled));\n });\n};\nconst provideParentSpan = /*#__PURE__*/provideService(Tracer.ParentSpan);\n/** @internal */\nexport const withParentSpan = function () {\n const dataFirst = isEffect(arguments[0]);\n const span = dataFirst ? arguments[1] : arguments[0];\n let options = dataFirst ? arguments[2] : arguments[1];\n let provideStackFrame = identity;\n if (span._tag === \"Span\") {\n options = addSpanStackTrace(options);\n provideStackFrame = provideSpanStackFrame(span.name, options?.captureStackTrace);\n }\n if (dataFirst) {\n return provideParentSpan(provideStackFrame(arguments[0]), span);\n }\n return self => provideParentSpan(provideStackFrame(self), span);\n};\n/** @internal */\nexport const withSpan = function () {\n const dataFirst = typeof arguments[0] !== \"string\";\n const name = dataFirst ? arguments[1] : arguments[0];\n const traceOptions = addSpanStackTrace(arguments[2]);\n if (dataFirst) {\n const self = arguments[0];\n return useSpan(name, arguments[2], span => withParentSpan(self, span, traceOptions));\n }\n const fnArg = typeof arguments[1] === \"function\" ? arguments[1] : undefined;\n const options = fnArg ? undefined : arguments[1];\n return (self, ...args) => useSpan(name, fnArg ? fnArg(...args) : options, span => withParentSpan(self, span, traceOptions));\n};\n/** @internal */\nexport const annotateSpans = /*#__PURE__*/dual(args => isEffect(args[0]), (effect, ...args) => updateService(effect, TracerSpanAnnotations, annotations => {\n const newAnnotations = args.length === 1 ? {\n ...annotations,\n ...args[0]\n } : {\n ...annotations\n };\n if (args.length === 1) {\n return newAnnotations;\n } else {\n InternalRecord.assignProperty(newAnnotations, args[0], args[1]);\n }\n return newAnnotations;\n}));\n/** @internal */\nexport const annotateCurrentSpan = (...args) => withFiber(fiber => {\n const span = fiber.currentSpanLocal;\n if (span) {\n if (args.length === 1) {\n for (const [key, value] of Object.entries(args[0])) {\n span.attribute(key, value);\n }\n } else {\n span.attribute(args[0], args[1]);\n }\n }\n return void_;\n});\n/** @internal */\nexport const currentSpan = /*#__PURE__*/withFiber(fiber => {\n const span = fiber.currentSpanLocal;\n return span ? succeed(span) : fail(new NoSuchElementError());\n});\n/** @internal */\nexport const currentParentSpan = /*#__PURE__*/serviceOptional(Tracer.ParentSpan);\n// ----------------------------------------------------------------------------\n// Clock\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const ClockRef = /*#__PURE__*/Context.Reference(\"effect/Clock\", {\n defaultValue: () => new ClockImpl()\n});\nconst MAX_TIMER_MILLIS = 2 ** 31 - 1;\nclass ClockImpl {\n currentTimeMillisUnsafe() {\n return Date.now();\n }\n currentTimeMillis = /*#__PURE__*/sync(() => this.currentTimeMillisUnsafe());\n currentTimeNanosUnsafe() {\n return wallTimeNanos();\n }\n currentTimeNanos = /*#__PURE__*/sync(() => this.currentTimeNanosUnsafe());\n monotonicTimeNanosUnsafe() {\n return monotonicNowNanos();\n }\n monotonicTimeNanos = /*#__PURE__*/sync(() => this.monotonicTimeNanosUnsafe());\n sleep(duration) {\n return this.sleepMillis(Duration.toMillis(duration));\n }\n sleepMillis(millis) {\n if (millis <= 0) return yieldNow;else if (!Number.isFinite(millis)) return never;\n return callback(resume => {\n const continuation = millis > MAX_TIMER_MILLIS ? this.sleepMillis(millis - MAX_TIMER_MILLIS) : void_;\n const handle = setTimeout(() => resume(continuation), Math.min(millis, MAX_TIMER_MILLIS));\n return sync(() => clearTimeout(handle));\n });\n }\n}\nconst nanosPerMilli = /*#__PURE__*/BigInt(1_000_000);\nconst monotonicNowNanos = /*#__PURE__*/function () {\n const processHrtime = globalThis.process?.hrtime;\n if (typeof processHrtime?.bigint === \"function\") {\n return () => processHrtime.bigint();\n }\n if (typeof performance !== \"undefined\" && typeof performance.now === \"function\") {\n return () => BigInt(Math.round(performance.now() * 1_000_000));\n }\n let previous = /*#__PURE__*/BigInt(0);\n return () => {\n const current = BigInt(Date.now()) * nanosPerMilli;\n if (current > previous) {\n previous = current;\n }\n return previous;\n };\n}();\nconst wallTimeNanos = /*#__PURE__*/function () {\n const reanchorThresholdNanos = /*#__PURE__*/BigInt(1_000_000_000);\n let origin;\n return () => {\n const monotonic = monotonicNowNanos();\n const wall = BigInt(Date.now()) * nanosPerMilli;\n if (origin === undefined) {\n origin = wall - monotonic;\n } else {\n const projected = origin + monotonic;\n const skew = wall > projected ? wall - projected : projected - wall;\n if (skew > reanchorThresholdNanos) {\n origin = wall - monotonic;\n }\n }\n return origin + monotonic;\n };\n}();\n/** @internal */\nexport const clockWith = f => withFiber(fiber => f(fiber.getRef(ClockRef)));\n/** @internal */\nexport const sleep = duration => clockWith(clock => clock.sleep(Duration.fromInputUnsafe(duration)));\n/** @internal */\nexport const currentTimeMillis = /*#__PURE__*/clockWith(clock => clock.currentTimeMillis);\n/** @internal */\nexport const currentTimeNanos = /*#__PURE__*/clockWith(clock => clock.currentTimeNanos);\n/** @internal */\nexport const monotonicTimeNanos = /*#__PURE__*/clockWith(clock => clock.monotonicTimeNanos);\n// ----------------------------------------------------------------------------\n// Errors\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const TimeoutErrorTypeId = \"~effect/Cause/TimeoutError\";\n/** @internal */\nexport const isTimeoutError = u => hasProperty(u, TimeoutErrorTypeId);\n/** @internal */\nexport class TimeoutError extends /*#__PURE__*/TaggedError(\"TimeoutError\") {\n [TimeoutErrorTypeId] = TimeoutErrorTypeId;\n constructor(message) {\n super({\n message\n });\n }\n}\n/** @internal */\nexport const IllegalArgumentErrorTypeId = \"~effect/Cause/IllegalArgumentError\";\n/** @internal */\nexport const isIllegalArgumentError = u => hasProperty(u, IllegalArgumentErrorTypeId);\n/** @internal */\nexport class IllegalArgumentError extends /*#__PURE__*/TaggedError(\"IllegalArgumentError\") {\n [IllegalArgumentErrorTypeId] = IllegalArgumentErrorTypeId;\n constructor(message) {\n super({\n message\n });\n }\n}\n/** @internal */\nexport const ExceededCapacityErrorTypeId = \"~effect/Cause/ExceededCapacityError\";\n/** @internal */\nexport const isExceededCapacityError = u => hasProperty(u, ExceededCapacityErrorTypeId);\n/** @internal */\nexport class ExceededCapacityError extends /*#__PURE__*/TaggedError(\"ExceededCapacityError\") {\n [ExceededCapacityErrorTypeId] = ExceededCapacityErrorTypeId;\n constructor(message) {\n super({\n message\n });\n }\n}\n/** @internal */\nexport const AsyncFiberErrorTypeId = \"~effect/Cause/AsyncFiberError\";\n/** @internal */\nexport const isAsyncFiberError = u => hasProperty(u, AsyncFiberErrorTypeId);\n/** @internal */\nexport class AsyncFiberError extends /*#__PURE__*/TaggedError(\"AsyncFiberError\") {\n [AsyncFiberErrorTypeId] = AsyncFiberErrorTypeId;\n constructor(fiber) {\n super({\n message: \"An asynchronous Effect was executed with Effect.runSync\",\n fiber\n });\n }\n}\n/** @internal */\nexport const UnknownErrorTypeId = \"~effect/Cause/UnknownError\";\n/** @internal */\nexport const isUnknownError = u => hasProperty(u, UnknownErrorTypeId);\n/** @internal */\nexport class UnknownError extends /*#__PURE__*/TaggedError(\"UnknownError\") {\n [UnknownErrorTypeId] = UnknownErrorTypeId;\n constructor(cause, message) {\n super({\n message,\n cause\n });\n }\n}\n// ----------------------------------------------------------------------------\n// Console\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const ConsoleRef = /*#__PURE__*/Context.Reference(\"effect/Console\", {\n defaultValue: () => globalThis.console\n});\n// ----------------------------------------------------------------------------\n// LogLevel\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const logLevelToOrder = level => {\n switch (level) {\n case \"All\":\n return Number.MIN_SAFE_INTEGER;\n case \"Fatal\":\n return 50_000;\n case \"Error\":\n return 40_000;\n case \"Warn\":\n return 30_000;\n case \"Info\":\n return 20_000;\n case \"Debug\":\n return 10_000;\n case \"Trace\":\n return 0;\n case \"None\":\n return Number.MAX_SAFE_INTEGER;\n }\n};\n/** @internal */\nexport const LogLevelOrder = /*#__PURE__*/Order.mapInput(Order.Number, logLevelToOrder);\n/** @internal */\nexport const isLogLevelGreaterThan = /*#__PURE__*/Order.isGreaterThan(LogLevelOrder);\n// ----------------------------------------------------------------------------\n// Logger\n// ----------------------------------------------------------------------------\n/** @internal */\nexport const CurrentLoggers = /*#__PURE__*/Context.Reference(\"effect/Logger/CurrentLoggers\", {\n defaultValue: () => new Set([defaultLogger, tracerLogger])\n});\n/** @internal */\nexport const LogToStderr = /*#__PURE__*/Context.Reference(\"effect/Logger/LogToStderr\", {\n defaultValue: constFalse\n});\n/** @internal */\nexport const annotateLogsScoped = function () {\n const entries = typeof arguments[0] === \"string\" ? [[arguments[0], arguments[1]]] : Object.entries(arguments[0]);\n return uninterruptible(withFiber(fiber => {\n const prev = fiber.getRef(CurrentLogAnnotations);\n const next = {\n ...prev\n };\n for (let i = 0; i < entries.length; i++) {\n const [key, value] = entries[i];\n InternalRecord.assignProperty(next, key, value);\n }\n fiber.setContext(Context.add(fiber.context, CurrentLogAnnotations, next));\n return scopeAddFinalizerExit(Context.getUnsafe(fiber.context, scopeTag), _ => {\n const current = fiber.getRef(CurrentLogAnnotations);\n const next = {\n ...current\n };\n for (let i = 0; i < entries.length; i++) {\n const [key, value] = entries[i];\n if (current[key] !== value && !Object.is(current[key], value)) continue;\n if (Object.hasOwn(prev, key)) {\n InternalRecord.assignProperty(next, key, prev[key]);\n } else {\n delete next[key];\n }\n }\n fiber.setContext(Context.add(fiber.context, CurrentLogAnnotations, next));\n return void_;\n });\n }));\n};\n/** @internal */\nexport const LoggerTypeId = \"~effect/Logger\";\nconst LoggerProto = {\n [LoggerTypeId]: {\n _Message: identity,\n _Output: identity\n },\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n/** @internal */\nexport const loggerMake = log => {\n const self = Object.create(LoggerProto);\n self.log = log;\n return self;\n};\n/**\n * Sanitize a given string by replacing spaces, equal signs, and double quotes\n * with underscores.\n *\n * @internal\n */\nexport const formatLabel = key => key.replace(/[\\s=\"]/g, \"_\");\n/**\n * Formats a log span into a `` with the provided value. Does not perform any\n * computation.\n *\n * **Example** (Creating a successful Exit)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.succeed(42) // => Exit.succeed(42)\n * ```\n *\n * @see {@link fail} to create a failed Exit\n * @see {@link void_ void} for a pre-allocated success with no value\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const succeed = core.exitSucceed;\n/**\n * Creates a failed Exit from a Cause.\n *\n * **When to use**\n *\n * Use when you already have a `Cause` and want to wrap it in an Exit\n * for advanced error handling where you need full control over the Cause\n * structure.\n *\n * **Details**\n *\n * Returns a `Failure`. If you only have an error value, use\n * {@link fail} instead.\n *\n * **Example** (Creating a failed Exit from a Cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Exit } from \"effect\"\n *\n * Exit.failCause(Cause.fail(\"Something went wrong\")) // => Exit.fail(\"Something went wrong\")\n * ```\n *\n * @see {@link fail} to create a Failure from a plain error value\n * @see {@link die} to create a Failure from a defect\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failCause = core.exitFailCause;\n/**\n * Creates a failed Exit from a typed error value.\n *\n * **When to use**\n *\n * Use when you need to represent an expected typed failure as an `Exit`.\n *\n * **Details**\n *\n * The error is wrapped in a `Cause.Fail` internally.\n *\n * Returns a `Failure`.\n *\n * **Example** (Creating a failed Exit)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.fail(\"Something went wrong\") // => Exit.fail(\"Something went wrong\")\n * ```\n *\n * @see {@link succeed} to create a successful Exit\n * @see {@link die} to create a Failure from an unexpected defect\n * @see {@link failCause} to create a Failure from a full Cause\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fail = core.exitFail;\n/**\n * Creates a failed Exit from a defect (unexpected error).\n *\n * **When to use**\n *\n * Use when you need unexpected, unrecoverable errors that should not appear in\n * the typed error channel.\n *\n * **Details**\n *\n * The defect is wrapped in a `Cause.Die` internally.\n *\n * Returns a `Failure` with `E = never`, since defects do not appear in\n * the typed error channel.\n *\n * **Example** (Creating a defect Exit)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.die(\"Unexpected error\") // => Exit.die(\"Unexpected error\")\n * ```\n *\n * @see {@link fail} to create a Failure from a typed error\n * @see {@link hasDies} to check whether an Exit contains defects\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const die = core.exitDie;\n/**\n * Creates a failed Exit representing fiber interruption.\n *\n * **When to use**\n *\n * Use to signal that a fiber was interrupted.\n *\n * **Details**\n *\n * Optionally pass a fiber ID to identify which fiber was interrupted. Returns\n * a `Failure` with an `Interrupt` cause.\n *\n * **Example** (Creating an interruption Exit)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.interrupt(123) // => Exit.interrupt(123)\n * ```\n *\n * @see {@link hasInterrupts} to check whether an Exit contains interruptions\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const interrupt = effect.exitInterrupt;\nconst void_ = effect.exitVoid;\nexport {\n/**\n * Provides a pre-allocated successful Exit with a `void` value.\n *\n * **When to use**\n *\n * Use when you need a shared successful `Exit` with no meaningful value.\n *\n * **Details**\n *\n * Equivalent to `Exit.succeed(undefined)` but shared as a single instance,\n * avoiding allocation for a common case.\n *\n * **Example** (Referencing the void Exit)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.void // => Exit.succeed(undefined)\n * ```\n *\n * @see {@link succeed} to create a success with a specific value\n * @see {@link asVoid} to discard the value of an existing Exit\n *\n * @category constructors\n * @since 2.0.0\n */\nvoid_ as void };\n/**\n * Checks whether an Exit is a Success.\n *\n * **When to use**\n *\n * Use as a type guard to narrow `Exit` to `Success` and access the\n * `value` property.\n *\n * **Example** (Narrowing to success)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * const exit = Exit.succeed(42)\n *\n * if (Exit.isSuccess(exit)) {\n * exit.value // => 42\n * }\n * ```\n *\n * @see {@link isFailure} for the opposite check\n * @see {@link match} for exhaustive pattern matching\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isSuccess = effect.exitIsSuccess;\n/**\n * Checks whether an Exit is a Failure.\n *\n * **When to use**\n *\n * Use as a type guard to narrow `Exit` to `Failure` and access the\n * `cause` property.\n *\n * **Example** (Narrowing to failure)\n *\n * ```ts import.meta.vitest\n * import { Cause, Exit } from \"effect\"\n *\n * const exit = Exit.fail(\"error\")\n *\n * if (Exit.isFailure(exit)) {\n * exit.cause // => Cause.fail(\"error\")\n * }\n * ```\n *\n * @see {@link isSuccess} for the opposite check\n * @see {@link match} for exhaustive pattern matching\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isFailure = effect.exitIsFailure;\n/**\n * Checks whether a failed Exit contains typed errors (Fail reasons).\n *\n * **When to use**\n *\n * Use to distinguish typed failures from defects or interruptions.\n *\n * **Details**\n *\n * Returns `false` for successful exits. Only checks for `Fail` reasons in the\n * Cause. A Cause with only `Die` or `Interrupt` reasons returns `false`.\n *\n * **Example** (Checking for typed errors)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.hasFails(Exit.fail(\"err\")) // => true\n * Exit.hasFails(Exit.die(\"bug\")) // => false\n * Exit.hasFails(Exit.succeed(42)) // => false\n * ```\n *\n * @see {@link hasDies} to check for defects\n * @see {@link hasInterrupts} to check for interruptions\n *\n * @category guards\n * @since 4.0.0\n */\nexport const hasFails = effect.exitHasFails;\n/**\n * Checks whether a failed Exit contains defects (Die reasons).\n *\n * **When to use**\n *\n * Use to check whether an `Exit` failure cause contains unexpected errors.\n *\n * **Details**\n *\n * Returns `false` for successful exits. Only checks for `Die` reasons in the\n * Cause. A Cause with only `Fail` or `Interrupt` reasons returns `false`.\n *\n * **Example** (Checking for defects)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.hasDies(Exit.die(\"bug\")) // => true\n * Exit.hasDies(Exit.fail(\"err\")) // => false\n * Exit.hasDies(Exit.succeed(42)) // => false\n * ```\n *\n * @see {@link hasFails} to check for typed errors\n * @see {@link hasInterrupts} to check for interruptions\n *\n * @category guards\n * @since 4.0.0\n */\nexport const hasDies = effect.exitHasDies;\n/**\n * Checks whether a failed Exit contains interruptions (Interrupt reasons).\n *\n * **When to use**\n *\n * Use to check whether an `Exit` contains fiber interruption.\n *\n * **Details**\n *\n * Returns `false` for successful exits. Only checks for `Interrupt` reasons in\n * the Cause. A Cause with only `Fail` or `Die` reasons returns `false`.\n *\n * **Example** (Checking for interruptions)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.hasInterrupts(Exit.interrupt(1)) // => true\n * Exit.hasInterrupts(Exit.fail(\"err\")) // => false\n * Exit.hasInterrupts(Exit.succeed(42)) // => false\n * ```\n *\n * @see {@link hasFails} to check for typed errors\n * @see {@link hasDies} to check for defects\n *\n * @category guards\n * @since 4.0.0\n */\nexport const hasInterrupts = effect.exitHasInterrupts;\n/**\n * Extracts the Success variant from an Exit as a Result.\n *\n * **When to use**\n *\n * Use when composing Exit checks with `Filter` or other `Result`-based\n * filtering APIs and you want the full Success wrapper.\n *\n * **Details**\n *\n * Returns `Result.succeed(success)` when the Exit is a Success, or\n * `Result.fail(failure)` with the original Failure otherwise.\n *\n * **Gotchas**\n *\n * This is not an `Option` accessor or an Effect failure. A failed extraction is\n * represented as data in the `Result` failure channel.\n *\n * **Example** (Filtering for success)\n *\n * ```ts import.meta.vitest\n * import { Exit, Result } from \"effect\"\n *\n * Exit.filterSuccess(Exit.succeed(42)) // => Result.succeed(Exit.succeed(42))\n * ```\n *\n * @see {@link filterFailure} for the inverse\n * @see {@link filterValue} to extract the raw value instead of the Success object\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterSuccess = effect.exitFilterSuccess;\n/**\n * Extracts the success value from an Exit as a Result.\n *\n * **When to use**\n *\n * Use when composing Exit checks with `Filter` or other `Result`-based\n * filtering APIs and you want the raw success value rather than the Success\n * wrapper.\n *\n * **Details**\n *\n * Returns `Result.succeed(value)` when the Exit is a Success, or\n * `Result.fail(failure)` with the original Failure otherwise.\n *\n * **Gotchas**\n *\n * This is not an `Option` accessor or an Effect failure. A failed extraction is\n * represented as data in the `Result` failure channel.\n *\n * **Example** (Filtering for the value)\n *\n * ```ts import.meta.vitest\n * import { Exit, Result } from \"effect\"\n *\n * Exit.filterValue(Exit.succeed(42)) // => Result.succeed(42)\n * ```\n *\n * @see {@link filterSuccess} to get the full Success object\n * @see {@link getSuccess} to get the value as an Option instead\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterValue = effect.exitFilterValue;\n/**\n * Extracts the Failure variant from an Exit as a Result.\n *\n * **When to use**\n *\n * Use when composing Exit checks with `Filter` or other `Result`-based\n * filtering APIs and you want the full Failure wrapper.\n *\n * **Details**\n *\n * Returns `Result.succeed(failure)` when the Exit is a Failure, or\n * `Result.fail(success)` with the original Success otherwise.\n *\n * **Gotchas**\n *\n * This is not an `Option` accessor or an Effect failure. A failed extraction is\n * represented as data in the `Result` failure channel.\n *\n * **Example** (Filtering for failure)\n *\n * ```ts import.meta.vitest\n * import { Exit, Result } from \"effect\"\n *\n * Exit.filterFailure(Exit.fail(\"err\")) // => Result.succeed(Exit.fail(\"err\"))\n * ```\n *\n * @see {@link filterSuccess} for the inverse\n * @see {@link filterCause} to extract the Cause directly\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterFailure = effect.exitFilterFailure;\n/**\n * Extracts the Cause from a failed Exit as a Result.\n *\n * **When to use**\n *\n * Use when composing Exit checks with `Filter` or other `Result`-based\n * filtering APIs and you want the raw Cause rather than the Failure wrapper.\n *\n * **Details**\n *\n * Returns `Result.succeed(cause)` when the Exit is a Failure, or\n * `Result.fail(success)` with the original Success otherwise.\n *\n * **Gotchas**\n *\n * This is not an `Option` accessor or an Effect failure. A failed extraction is\n * represented as data in the `Result` failure channel.\n *\n * **Example** (Filtering for the cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Exit, Result } from \"effect\"\n *\n * Exit.filterCause(Exit.fail(\"err\")) // => Result.succeed(Cause.fail(\"err\"))\n * ```\n *\n * @see {@link filterFailure} to get the full Failure object\n * @see {@link getCause} to get the Cause as an Option instead\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterCause = effect.exitFilterCause;\n/**\n * Extracts the first typed error value from a failed Exit as a Result.\n *\n * **When to use**\n *\n * Use when you need the first typed error from an `Exit` as a `Result` for\n * `Filter` or other `Result`-based filtering APIs.\n *\n * **Details**\n *\n * Returns `Result.succeed(error)` when the Cause contains a Fail reason, or\n * `Result.fail(exit)` with the original Exit otherwise.\n *\n * **Gotchas**\n *\n * Only finds the first Fail reason. If the Cause has multiple errors, the rest\n * are ignored.\n *\n * **Example** (Finding the first typed error)\n *\n * ```ts import.meta.vitest\n * import { Exit, Result } from \"effect\"\n *\n * Exit.findError(Exit.fail(\"not found\")) // => Result.succeed(\"not found\")\n * Exit.findError(Exit.die(\"bug\")) // => Result.fail(Exit.die(\"bug\"))\n * ```\n *\n * @see {@link findErrorOption} to get the error as an Option instead\n * @see {@link findDefect} to find defects instead\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const findError = effect.exitFindError;\n/**\n * Extracts the first defect from a failed Exit as a Result.\n *\n * **When to use**\n *\n * Use when you need the first defect from an `Exit` as a `Result` for\n * `Filter` or other `Result`-based filtering APIs.\n *\n * **Details**\n *\n * Returns `Result.succeed(defect)` when the Cause contains a Die reason, or\n * `Result.fail(exit)` with the original Exit otherwise.\n *\n * **Gotchas**\n *\n * Only finds the first Die reason. If the Cause has multiple defects, the rest\n * are ignored.\n *\n * **Example** (Finding the first defect)\n *\n * ```ts import.meta.vitest\n * import { Exit, Result } from \"effect\"\n *\n * Exit.findDefect(Exit.die(\"boom\")) // => Result.succeed(\"boom\")\n * Exit.findDefect(Exit.fail(\"err\")) // => Result.fail(Exit.fail(\"err\"))\n * ```\n *\n * @see {@link findError} to find typed errors instead\n * @see {@link hasDies} to check for defects without extracting them\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const findDefect = effect.exitFindDefect;\n/**\n * Pattern matches on an Exit, handling both success and failure cases.\n *\n * **When to use**\n *\n * Use when you need exhaustive handling of both `Exit` success and failure\n * outcomes.\n *\n * **Details**\n *\n * Calls `onSuccess` with the value if the Exit is a Success, and calls\n * `onFailure` with the Cause if the Exit is a Failure.\n *\n * **Example** (Matching on an Exit)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.match(Exit.succeed(42), {\n * onSuccess: (value) => `Got: ${value}`,\n * onFailure: () => \"Failed\"\n * }) // => \"Got: 42\"\n * ```\n *\n * @see {@link isSuccess} and {@link isFailure} for simple boolean checks\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport const match = effect.exitMatch;\n/**\n * Transforms the success value of an Exit using the given function.\n *\n * **When to use**\n *\n * Use to apply a transformation to the value inside a successful Exit\n *\n * **Details**\n *\n * Failures pass through unchanged.\n *\n * Allocates a new Exit if successful.\n *\n * **Example** (Mapping over a success)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.map(Exit.succeed(21), (x) => x * 2) // => Exit.succeed(42)\n * ```\n *\n * @see {@link mapError} to transform the error\n * @see {@link mapBoth} to transform both success and error\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const map = effect.exitMap;\n/**\n * Transforms the typed error of a failed Exit using the given function.\n *\n * **When to use**\n *\n * Use to remap typed errors while preserving the Exit structure\n *\n * **Details**\n *\n * Successes pass through unchanged.\n *\n * Allocates a new Exit if the error is transformed.\n *\n * **Gotchas**\n *\n * Only transforms typed errors (Fail reasons). If the Cause contains only\n * defects or interruptions, the failure passes through unchanged.\n *\n * **Example** (Mapping over an error)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.mapError(Exit.fail(\"bad input\"), (error) => error.toUpperCase()) // => Exit.fail(\"BAD INPUT\")\n * ```\n *\n * @see {@link map} to transform the success value\n * @see {@link mapBoth} to transform both success and error\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const mapError = effect.exitMapError;\n/**\n * Transforms both the success value and typed error of an Exit.\n *\n * **When to use**\n *\n * Use when you need to remap both channels in one step.\n *\n * **Details**\n *\n * `onSuccess` transforms the value if the Exit is a Success. `onFailure`\n * transforms the typed error if the Exit is a Failure with a Fail reason.\n * Allocates a new Exit.\n *\n * **Gotchas**\n *\n * If the Cause contains only defects or interruptions, the failure passes\n * through unchanged.\n *\n * **Example** (Mapping both channels)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.mapBoth(Exit.succeed(42), {\n * onSuccess: (x) => String(x),\n * onFailure: (error: string) => error.toUpperCase()\n * }) // => Exit.succeed(\"42\")\n * ```\n *\n * @see {@link map} to transform only the success value\n * @see {@link mapError} to transform only the error\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const mapBoth = effect.exitMapBoth;\n/**\n * Discards the success value of an Exit, replacing it with `void`.\n *\n * **When to use**\n *\n * Use when you need to discard a successful `Exit` value while preserving\n * whether the `Exit` succeeded or failed.\n *\n * **Details**\n *\n * Failures pass through unchanged.\n *\n * Allocates a new Exit if successful.\n *\n * **Example** (Discarding the success value)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.asVoid(Exit.succeed(42)) // => Exit.succeed(undefined)\n * ```\n *\n * @see {@link void_ void} for a pre-allocated void success\n * @see {@link asVoidAll} to combine multiple exits into a single void Exit\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const asVoid = effect.exitAsVoid;\n/**\n * Combines multiple Exit values into a single `Exit`.\n *\n * **When to use**\n *\n * Use to validate that all exits in a collection succeeded\n *\n * **Details**\n *\n * If all exits are successful, this returns a void success. If any exit is a\n * failure, this returns a single failure with all error causes combined.\n *\n * Iterates over the entire collection. Collects all failure causes, not just\n * the first.\n *\n * **Example** (Combining exits)\n *\n * ```ts import.meta.vitest\n * import { Exit } from \"effect\"\n *\n * Exit.asVoidAll([Exit.succeed(1), Exit.succeed(2), Exit.succeed(3)]) // => Exit.succeed(undefined)\n * Exit.asVoidAll([Exit.succeed(1), Exit.fail(\"err\"), Exit.succeed(3)]) // => Exit.fail(\"err\")\n * ```\n *\n * @see {@link asVoid} to discard the value of a single Exit\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const asVoidAll = effect.exitAsVoidAll;\n/**\n * Returns the success value of an Exit as an Option.\n *\n * **When to use**\n *\n * Use when you need the success value from an `Exit` as an `Option` instead of\n * pattern matching.\n *\n * **Details**\n *\n * Returns `Option.some(value)` for a Success and `Option.none()` for a Failure.\n *\n * **Example** (Getting the success value)\n *\n * ```ts import.meta.vitest\n * import { Exit, Option } from \"effect\"\n *\n * Exit.getSuccess(Exit.succeed(42)) // => Option.some(42)\n * Exit.getSuccess(Exit.fail(\"err\")) // => Option.none()\n * ```\n *\n * @see {@link getCause} to extract the Cause of a failure\n * @see {@link filterValue} for filter-pipeline usage\n *\n * @category getters\n * @since 4.0.0\n */\nexport const getSuccess = effect.exitGetSuccess;\n/**\n * Returns the Cause of a failed Exit as an Option.\n *\n * **When to use**\n *\n * Use when you need the failure `Cause` from an `Exit` as an `Option` instead\n * of pattern matching.\n *\n * **Details**\n *\n * Returns `Option.some(cause)` for a Failure and `Option.none()` for a Success.\n *\n * **Example** (Getting the failure cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Exit, Option } from \"effect\"\n *\n * Exit.getCause(Exit.fail(\"err\")) // => Option.some(Cause.fail(\"err\"))\n * Exit.getCause(Exit.succeed(42)) // => Option.none()\n * ```\n *\n * @see {@link getSuccess} to extract the success value\n * @see {@link filterCause} for filter-pipeline usage\n *\n * @category getters\n * @since 4.0.0\n */\nexport const getCause = effect.exitGetCause;\n/**\n * Returns the first typed error from a failed Exit as an Option.\n *\n * **When to use**\n *\n * Use when you need the first typed error from an `Exit` as an `Option`,\n * ignoring successes and non-typed failures.\n *\n * **Details**\n *\n * Returns `Option.some(error)` if the Cause contains a Fail reason. Successes,\n * defect-only failures, and interrupt-only failures return `Option.none()`.\n *\n * **Gotchas**\n *\n * Only finds the first Fail reason. If the Cause has multiple typed errors,\n * the rest are ignored.\n *\n * **Example** (Getting the first error)\n *\n * ```ts import.meta.vitest\n * import { Exit, Option } from \"effect\"\n *\n * Exit.findErrorOption(Exit.fail(\"err\")) // => Option.some(\"err\")\n * Exit.findErrorOption(Exit.die(\"bug\")) // => Option.none()\n * Exit.findErrorOption(Exit.succeed(42)) // => Option.none()\n * ```\n *\n * @see {@link findError} for filter-pipeline usage\n * @see {@link getCause} to get the full Cause as an Option\n *\n * @category getters\n * @since 4.0.0\n */\nexport const findErrorOption = effect.exitFindErrorOption;\n//# sourceMappingURL=Exit.js.map","/**\n * Records the full reason an `Effect` failed.\n *\n * A `Cause` can contain typed failures, unexpected defects, interruptions,\n * and annotations. Keeping those details together lets code inspect or format\n * failures without first collapsing them to a single error value. This module\n * includes the `Cause` and `Reason` data types, helpers for building and\n * checking causes, and small error types used by several Effect APIs.\n *\n * @since 2.0.0\n */\nimport * as Context from \"./Context.js\";\nimport * as core from \"./internal/core.js\";\nimport * as effect from \"./internal/effect.js\";\n/**\n * Unique brand for `Cause` values, used for runtime type checks via {@link isCause}.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = core.CauseTypeId;\n/**\n * Unique brand for `Reason` values, used for runtime type checks via {@link isReason}.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const ReasonTypeId = core.CauseReasonTypeId;\n/**\n * Checks whether an arbitrary value is a `Cause`.\n *\n * **Example** (Checking the runtime type)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.isCause(Cause.fail(\"error\")) // => true\n * Cause.isCause(\"not a cause\") // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isCause = core.isCause;\n/**\n * Checks whether an arbitrary value is a `Reason` (`Fail`, `Die`, or `Interrupt`).\n *\n * **Example** (Checking the runtime type)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * const reason = Cause.fail(\"error\").reasons[0]\n * Cause.isReason(reason) // => true\n * Cause.isReason(\"not a reason\") // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isReason = core.isCauseReason;\n/**\n * Narrows a `Reason` to `Fail`.\n *\n * **When to use**\n *\n * Use as a predicate for `Array.filter` to pick out typed `Fail` reasons when\n * iterating over `cause.reasons`.\n *\n * **Example** (Filtering fail reasons)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * const cause = Cause.fail(\"error\")\n * const fails = cause.reasons.filter(Cause.isFailReason)\n * fails[0].error // => \"error\"\n * ```\n *\n * @see {@link isDieReason} — narrow to `Die`\n * @see {@link isInterruptReason} — narrow to `Interrupt`\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isFailReason = core.isFailReason;\n/**\n * Narrows a `Reason` to `Die`.\n *\n * **When to use**\n *\n * Use as a predicate for `Array.filter` to pick out `Die` (defect) reasons when\n * iterating over `cause.reasons`.\n *\n * **Example** (Filtering die reasons)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * const cause = Cause.die(\"defect\")\n * const dies = cause.reasons.filter(Cause.isDieReason)\n * dies[0].defect // => \"defect\"\n * ```\n *\n * @see {@link isFailReason} — narrow to `Fail`\n * @see {@link isInterruptReason} — narrow to `Interrupt`\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isDieReason = core.isDieReason;\n/**\n * Narrows a `Reason` to `Interrupt`.\n *\n * **When to use**\n *\n * Use as a predicate for `Array.filter` to pick out `Interrupt` reasons when\n * iterating over `cause.reasons`.\n *\n * **Example** (Filtering interrupt reasons)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * const cause = Cause.interrupt(123)\n * const interrupts = cause.reasons.filter(Cause.isInterruptReason)\n * interrupts[0].fiberId // => 123\n * ```\n *\n * @see {@link isFailReason} — narrow to `Fail`\n * @see {@link isDieReason} — narrow to `Die`\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isInterruptReason = core.isInterruptReason;\n/**\n * Creates a `Cause` from an array of `Reason` values.\n *\n * **When to use**\n *\n * Use when you already have individual reasons (e.g. from filtering or\n * transforming another cause's `reasons` array) and need to wrap them back\n * into a `Cause`.\n *\n * **Details**\n *\n * - Returns a new `Cause`.\n * - An empty array produces a cause equivalent to `empty`.\n *\n * **Gotchas**\n *\n * The `reasons` array is stored as provided. Treat the array as immutable\n * after passing it to this function.\n *\n * **Example** (Building a cause from reasons)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * const reasons = [\n * Cause.makeFailReason(\"err1\"),\n * Cause.makeFailReason(\"err2\")\n * ]\n * Cause.fromReasons(reasons) // => Cause.combine(Cause.fail(\"err1\"), Cause.fail(\"err2\"))\n * ```\n *\n * @see {@link combine} — merge two existing causes\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromReasons = core.causeFromReasons;\n/**\n * Represents a `Cause` with an empty `reasons` array.\n *\n * **When to use**\n *\n * Use to represent the absence of failure when constructing or combining\n * causes.\n *\n * **Details**\n *\n * Represents the absence of failure. Combining any cause with `empty` via\n * {@link combine} returns the original cause unchanged.\n *\n * **Example** (Combining with the empty cause)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.combine(Cause.empty, Cause.fail(\"boom\")) // => Cause.fail(\"boom\")\n * ```\n *\n * @see {@link combine} for merging causes where `empty` acts as the identity\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const empty = core.causeEmpty;\n/**\n * Creates a `Cause` containing a single `Fail` reason with the\n * given typed error.\n *\n * **When to use**\n *\n * Use to construct a cause from an expected typed error.\n *\n * **Example** (Creating a fail cause)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.fail(\"Something went wrong\") // => Cause.fromReasons([Cause.makeFailReason(\"Something went wrong\")])\n * ```\n *\n * @see {@link die} — for untyped defects\n * @see {@link interrupt} — for fiber interruptions\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fail = core.causeFail;\n/**\n * Creates a `Cause` containing a single `Die` reason with the\n * given defect.\n *\n * **When to use**\n *\n * Use to construct a cause from an untyped defect or unexpected thrown value.\n *\n * **Example** (Creating a die cause)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.die(\"Unexpected\") // => Cause.fromReasons([Cause.makeDieReason(\"Unexpected\")])\n * ```\n *\n * @see {@link fail} — for typed errors\n * @see {@link interrupt} — for fiber interruptions\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const die = core.causeDie;\n/**\n * Creates a `Cause` containing a single `Interrupt` reason,\n * optionally carrying the interrupting fiber's ID.\n *\n * **Example** (Creating an interrupt cause)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.interrupt(123) // => Cause.fromReasons([Cause.makeInterruptReason(123)])\n * ```\n *\n * @see {@link fail} — for typed errors\n * @see {@link die} — for untyped defects\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const interrupt = effect.causeInterrupt;\n/**\n * Creates a standalone `Fail` reason (not wrapped in a `Cause`).\n *\n * **When to use**\n *\n * Use when constructing a standalone typed failure reason for\n * {@link fromReasons} or direct comparison.\n *\n * **Example** (Creating a Fail reason)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.makeFailReason(\"error\") // => Cause.fail(\"error\").reasons[0]\n * ```\n *\n * @see {@link makeDieReason} — create a `Die` reason\n * @see {@link makeInterruptReason} — create an `Interrupt` reason\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeFailReason = error => new core.Fail(error);\n/**\n * Creates a standalone `Die` reason (not wrapped in a `Cause`).\n *\n * **When to use**\n *\n * Use when constructing a standalone defect reason for {@link fromReasons} or\n * direct comparison.\n *\n * **Example** (Creating a Die reason)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.makeDieReason(\"bug\") // => Cause.die(\"bug\").reasons[0]\n * ```\n *\n * @see {@link makeFailReason} — create a `Fail` reason\n * @see {@link makeInterruptReason} — create an `Interrupt` reason\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeDieReason = defect => new core.Die(defect);\n/**\n * Creates a standalone `Interrupt` reason (not wrapped in a `Cause`),\n * optionally carrying the interrupting fiber's ID.\n *\n * **When to use**\n *\n * Use when constructing a standalone interrupt reason for {@link fromReasons}\n * or direct comparison.\n *\n * **Example** (Creating an Interrupt reason)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.makeInterruptReason(42) // => Cause.interrupt(42).reasons[0]\n * ```\n *\n * @see {@link makeFailReason} — create a `Fail` reason\n * @see {@link makeDieReason} — create a `Die` reason\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeInterruptReason = effect.makeInterruptReason;\n/**\n * Returns `true` if every reason in the cause is an `Interrupt` (and\n * there is at least one reason).\n *\n * **When to use**\n *\n * Use when you need to detect failures caused only by interruption.\n *\n * **Example** (Checking interrupt-only causes)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.hasInterruptsOnly(Cause.interrupt(123)) // => true\n * Cause.hasInterruptsOnly(Cause.fail(\"error\")) // => false\n * Cause.hasInterruptsOnly(Cause.empty) // => false\n * ```\n *\n * @see {@link hasInterrupts} — `true` if the cause contains *any* interrupts\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const hasInterruptsOnly = effect.hasInterruptsOnly;\n/**\n * Transforms the typed error values inside a `Cause` using the\n * provided function. Only `Fail` reasons are affected; `Die` and `Interrupt`\n * reasons pass through unchanged.\n *\n * **When to use**\n *\n * Use to transform expected typed failures while preserving defects and\n * interruptions unchanged.\n *\n * **Details**\n *\n * If at least one `Fail` reason exists, this returns a new `Cause`\n * containing the mapped failures. If the cause has no `Fail` reasons, the\n * original cause is returned unchanged.\n *\n * **Example** (Mapping errors to uppercase)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * const cause = Cause.fail(\"error\")\n * const mapped = Cause.map(cause, (e) => e.toUpperCase())\n * const reason = mapped.reasons[0]\n * if (Cause.isFailReason(reason)) {\n * reason.error // => \"ERROR\"\n * }\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const map = effect.causeMap;\n/**\n * Merges two causes into a single cause whose `reasons` array is the union\n * of both inputs (de-duplicated by value equality).\n *\n * **When to use**\n *\n * Use to merge independent causes into one structured failure value.\n *\n * **Details**\n *\n * - Combining with `empty` returns the other cause unchanged.\n * - If the result is structurally equal to `self`, `self` is returned\n * (referential shortcut).\n *\n * **Example** (Combining two causes)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * const combined = Cause.combine(Cause.fail(\"error1\"), Cause.fail(\"error2\"))\n * combined // => Cause.fromReasons([Cause.makeFailReason(\"error1\"), Cause.makeFailReason(\"error2\")])\n * ```\n *\n * @see {@link fromReasons} — build a cause from an array of reasons\n * @see {@link empty} for the identity cause used when combining\n *\n * @category combining\n * @since 4.0.0\n */\nexport const combine = effect.causeCombine;\n/**\n * Collapses a `Cause` into a single `unknown` value, picking the \"most\n * important\" failure in this order:\n *\n * **When to use**\n *\n * Use to collapse a structured cause to the single value that synchronous and\n * promise runners would throw.\n *\n * **Details**\n *\n * 1. First `Fail` error (the `E` value)\n * 2. First `Die` defect\n * 3. A generic `Error(\"All fibers interrupted without error\")` for interrupt-only causes\n * 4. A generic `Error(\"Empty cause\")` for `empty`\n *\n * This is the function used by `Effect.runPromise` and `Effect.runSync` to\n * decide what to throw.\n *\n * **Gotchas**\n *\n * This function is lossy. Use {@link prettyErrors} or iterate `cause.reasons`\n * when you need all failures.\n *\n * **Example** (Squashing a cause)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.squash(Cause.fail(\"error\")) // => \"error\"\n * Cause.squash(Cause.die(\"defect\")) // => \"defect\"\n * ```\n *\n * @see {@link prettyErrors} — non-lossy conversion to `Array`\n * @see {@link pretty} — human-readable string rendering\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const squash = effect.causeSquash;\n/**\n * Returns `true` if the cause contains at least one `Fail` reason.\n *\n * **When to use**\n *\n * Use to check whether a cause includes typed failures before extracting,\n * mapping, or rendering them.\n *\n * **Example** (Checking for typed errors)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.hasFails(Cause.fail(\"error\")) // => true\n * Cause.hasFails(Cause.die(\"defect\")) // => false\n * ```\n *\n * @see {@link hasDies} — check for defects\n * @see {@link hasInterrupts} — check for interruptions\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const hasFails = effect.hasFails;\n/**\n * Returns a `Result` whose success value is the first `Fail` reason in\n * the cause, including its annotations. If the cause has no `Fail` reason, the\n * failure value is the original cause narrowed to `Cause`, because it\n * contains no typed error reasons.\n *\n * **When to use**\n *\n * Use when you need the full `Fail` reason from a `Cause`, including\n * annotations.\n *\n * **Example** (Extracting the first Fail reason)\n *\n * ```ts import.meta.vitest\n * import { Cause, Result } from \"effect\"\n *\n * Cause.findFail(Cause.fail(\"error\")) // => Result.succeed(Cause.makeFailReason(\"error\"))\n * ```\n *\n * @see {@link findError} — extract the unwrapped `E` value\n * @see {@link findDie} — extract the first `Die` reason\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const findFail = effect.findFail;\n/**\n * Returns a `Result` whose success value is the first typed error value `E`\n * from a `Fail` reason in the cause. If the cause has no `Fail` reason,\n * the failure value is the original cause narrowed to `Cause`, because\n * it contains no typed error reasons.\n *\n * **When to use**\n *\n * Use when you need the first typed error value from a `Cause` as a `Result`\n * that preserves the original cause when no match is found.\n *\n * **Example** (Extracting the first error value)\n *\n * ```ts import.meta.vitest\n * import { Cause, Result } from \"effect\"\n *\n * Cause.findError(Cause.fail(\"error\")) // => Result.succeed(\"error\")\n * ```\n *\n * @see {@link findFail} — extract the full `Fail` reason\n * @see {@link findErrorOption} — `Option`-based variant\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const findError = effect.findError;\n/**\n * Returns the first typed error value `E` from a cause wrapped in\n * `Option.some`, or `Option.none` if no `Fail` reason exists.\n *\n * **When to use**\n *\n * Use when you need the first typed error value from a `Cause` as an `Option`,\n * discarding the original cause.\n *\n * **Example** (Extracting an error as Option)\n *\n * ```ts import.meta.vitest\n * import { Cause, Option } from \"effect\"\n *\n * Cause.findErrorOption(Cause.fail(\"error\")) // => Option.some(\"error\")\n * Cause.findErrorOption(Cause.die(\"defect\")) // => Option.none()\n * ```\n *\n * @see {@link findError} — `Result`-based variant\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const findErrorOption = effect.findErrorOption;\n/**\n * Returns `true` if the cause contains at least one `Die` reason.\n *\n * **When to use**\n *\n * Use to check whether a cause includes defects before extracting or rendering\n * them.\n *\n * **Example** (Checking for defects)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.hasDies(Cause.die(\"defect\")) // => true\n * Cause.hasDies(Cause.fail(\"error\")) // => false\n * ```\n *\n * @see {@link hasFails} — check for typed errors\n * @see {@link hasInterrupts} — check for interruptions\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const hasDies = effect.hasDies;\n/**\n * Returns a `Result` whose success value is the first `Die` reason in\n * the cause, including its annotations. If the cause has no `Die` reason, the\n * failure value is the original cause.\n *\n * **When to use**\n *\n * Use when you need the full `Die` reason from a `Cause`, including\n * annotations.\n *\n * **Example** (Extracting the first Die reason)\n *\n * ```ts import.meta.vitest\n * import { Cause, Result } from \"effect\"\n *\n * Cause.findDie(Cause.die(\"defect\")) // => Result.succeed(Cause.makeDieReason(\"defect\"))\n * ```\n *\n * @see {@link findDefect} — extract the unwrapped defect value\n * @see {@link findFail} — extract the first `Fail` reason\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const findDie = effect.findDie;\n/**\n * Returns a `Result` whose success value is the first defect value from a\n * `Die` reason in the cause. If the cause has no `Die` reason, the\n * failure value is the original cause.\n *\n * **When to use**\n *\n * Use when you need the first defect value from a `Cause` as a `Result`,\n * without the full `Die` reason.\n *\n * **Example** (Extracting the first defect)\n *\n * ```ts import.meta.vitest\n * import { Cause, Result } from \"effect\"\n *\n * Cause.findDefect(Cause.die(\"defect\")) // => Result.succeed(\"defect\")\n * ```\n *\n * @see {@link findDie} — extract the full `Die` reason\n * @see {@link findError} — extract the first typed error\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const findDefect = effect.findDefect;\n/**\n * Returns `true` if the cause contains at least one `Interrupt` reason.\n *\n * **Example** (Checking for interruptions)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.hasInterrupts(Cause.interrupt(123)) // => true\n * Cause.hasInterrupts(Cause.fail(\"error\")) // => false\n * ```\n *\n * @see {@link hasInterruptsOnly} — `true` only when *all* reasons are interrupts\n * @see {@link hasFails} — check for typed errors\n * @see {@link hasDies} — check for defects\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const hasInterrupts = effect.hasInterrupts;\n/**\n * Returns a `Result` whose success value is the first `Interrupt` reason\n * in the cause, including its annotations. If the cause has no `Interrupt`\n * reason, the failure value is the original cause.\n *\n * **When to use**\n *\n * Use when you need the first `Interrupt` reason from a `Cause`, including the\n * fiber ID and annotations.\n *\n * **Example** (Extracting the first interrupt)\n *\n * ```ts import.meta.vitest\n * import { Cause, Result } from \"effect\"\n *\n * Cause.findInterrupt(Cause.interrupt(42)) // => Result.succeed(Cause.makeInterruptReason(42))\n * ```\n *\n * @see {@link interruptors} — collect all interrupting fiber IDs as a `Set`\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const findInterrupt = effect.findInterrupt;\n/**\n * Collects the defined fiber IDs from all `Interrupt` reasons in the\n * cause into a `ReadonlySet`. Interrupt reasons without a `fiberId` are\n * ignored. Returns an empty set when the cause has no interrupting fiber IDs.\n *\n * **When to use**\n *\n * Use when you need interrupting fiber IDs as a set, with absence represented\n * as an empty set.\n *\n * **Example** (Collecting interruptors)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * const cause = Cause.combine(\n * Cause.interrupt(1),\n * Cause.interrupt(2)\n * )\n *\n * Cause.interruptors(cause) // => new Set([1, 2])\n * ```\n *\n * @see {@link filterInterruptors} — `Result`-based variant\n *\n * @category getters\n * @since 2.0.0\n */\nexport const interruptors = effect.causeInterruptors;\n/**\n * Returns a `Result` whose success value is the set of defined fiber IDs from\n * the cause's `Interrupt` reasons. If the cause has no `Interrupt`\n * reason, the failure value is the original cause.\n *\n * **When to use**\n *\n * Use when you need absence of interrupt reasons to fail with the original\n * cause.\n *\n * **Gotchas**\n *\n * Interrupt reasons without a `fiberId` still count as interrupts, so the\n * function succeeds with an empty `Set` when every interrupt reason has an\n * undefined fiber ID.\n *\n * **Example** (Extracting interruptors with Result)\n *\n * ```ts import.meta.vitest\n * import { Cause, Result } from \"effect\"\n *\n * Cause.filterInterruptors(Cause.interrupt(1)) // => Result.succeed(new Set([1]))\n * ```\n *\n * @see {@link interruptors} — always-succeeding variant\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterInterruptors = effect.causeFilterInterruptors;\n/**\n * Converts a `Cause` into an `Array` suitable for logging or\n * rethrowing.\n *\n * **When to use**\n *\n * Use to convert every renderable failure in a cause into individual `Error`\n * values before logging or rethrowing.\n *\n * **Details**\n *\n * Each `Fail` and `Die` reason is converted into a standard\n * `Error`:\n *\n * - **Objects / Error instances** — `message`, `name`, `stack`, and `cause`\n * are preserved. Extra enumerable properties are copied. Stack traces are\n * cleaned up and enriched with span annotations when available.\n * - **Strings** — used directly as the `Error` message.\n * - **Other primitives** (`null`, `undefined`, numbers, …) — wrapped in an\n * `Error` with message `\"Unknown error: \"`.\n *\n * `Interrupt` reasons are collected separately. If the cause contains\n * **only** interrupts (no `Fail` or `Die`), a single `InterruptError` is\n * returned whose `cause` lists the interrupting fiber IDs.\n *\n * An empty cause returns an empty array.\n *\n * **Example** (Converting a cause to errors)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.prettyErrors(Cause.fail(new Error(\"boom\")))[0].message // => \"boom\"\n * ```\n *\n * @see {@link pretty} — renders the cause as a single string\n * @see {@link squash} — lossy collapse to a single thrown value\n *\n * @category formatting\n * @since 3.2.0\n */\nexport const prettyErrors = effect.causePrettyErrors;\n/**\n * Formats a `Cause` as a human-readable string for logging or debugging.\n *\n * **When to use**\n *\n * Use to render a whole cause as one human-readable string for logs or\n * diagnostics.\n *\n * **Details**\n *\n * Delegates to {@link prettyErrors} to convert each reason to an `Error`,\n * then joins their stack traces with newlines. Nested `Error.cause` chains\n * are rendered inline with indentation:\n *\n * ```text\n * ErrorName: message\n * at ...\n * at ... {\n * [cause]: NestedError: message\n * at ...\n * }\n * ```\n *\n * Span annotations are appended to the relevant stack frames when available.\n *\n * **Gotchas**\n *\n * Rendering an empty cause produces an empty string because there are no\n * errors to render.\n *\n * **Example** (Rendering a cause)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.pretty(Cause.fail(\"something went wrong\")).includes(\"something went wrong\") // => true\n * ```\n *\n * @see {@link prettyErrors} — get the individual `Error` instances\n *\n * @category formatting\n * @since 2.0.0\n */\nexport const pretty = effect.causePretty;\n/**\n * Checks whether an arbitrary value is a `NoSuchElementError`.\n *\n * **Example** (Checking the runtime type)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.isNoSuchElementError(new Cause.NoSuchElementError()) // => true\n * Cause.isNoSuchElementError(\"nope\") // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isNoSuchElementError = core.isNoSuchElementError;\n/**\n * Unique brand for `NoSuchElementError`.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const NoSuchElementErrorTypeId = core.NoSuchElementErrorTypeId;\n/**\n * Constructs a `NoSuchElementError` with an optional message.\n *\n * **When to use**\n *\n * Use to create the error value for APIs that intentionally fail when an\n * expected element is absent.\n *\n * **Example** (Creating a NoSuchElementError)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * new Cause.NoSuchElementError(\"Element not found\").message // => \"Element not found\"\n * ```\n *\n * @see {@link isNoSuchElementError} for checking unknown values\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const NoSuchElementError = core.NoSuchElementError;\n/**\n * Checks whether an arbitrary value is a `Done` signal.\n *\n * **Example** (Checking the runtime type)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.isDone(Cause.Done()) // => true\n * Cause.isDone(\"not done\") // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isDone = core.isDone;\n/**\n * Unique brand for `Done` values.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const DoneTypeId = core.DoneTypeId;\n/**\n * Creates a `Done` signal with an optional value.\n *\n * **When to use**\n *\n * Use when you need to construct a low-level pull completion signal directly.\n *\n * @see {@link done} — create a failing `Effect` with `Done`\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Done = core.Done;\n/**\n * Creates an Effect that fails with a `Done` error. Shorthand for\n * `Effect.fail(Cause.Done(value))`.\n *\n * **When to use**\n *\n * Use when you model stream or queue completion through the error channel.\n *\n * **Example** (Failing with Done)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit } from \"effect\"\n *\n * const program = Cause.done(\"finished\")\n *\n * await Effect.runPromiseExit(program) // => Exit.fail(Cause.Done(\"finished\"))\n * ```\n *\n * @see {@link Done} — create the signal value without an Effect\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const done = core.done;\n/**\n * Unique brand for `TimeoutError`.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TimeoutErrorTypeId = effect.TimeoutErrorTypeId;\n/**\n * Checks whether an arbitrary value is a `TimeoutError`.\n *\n * **Example** (Checking the runtime type)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.isTimeoutError(new Cause.TimeoutError()) // => true\n * Cause.isTimeoutError(\"nope\") // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isTimeoutError = effect.isTimeoutError;\n/**\n * Constructs a `TimeoutError` with an optional message.\n *\n * **Example** (Creating a TimeoutError)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * new Cause.TimeoutError(\"Operation timed out\").message // => \"Operation timed out\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const TimeoutError = effect.TimeoutError;\n/**\n * Unique brand for `IllegalArgumentError`.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const IllegalArgumentErrorTypeId = effect.IllegalArgumentErrorTypeId;\n/**\n * Checks whether an arbitrary value is an `IllegalArgumentError`.\n *\n * **Example** (Checking the runtime type)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.isIllegalArgumentError(new Cause.IllegalArgumentError()) // => true\n * Cause.isIllegalArgumentError(\"nope\") // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isIllegalArgumentError = effect.isIllegalArgumentError;\n/**\n * Constructs an `IllegalArgumentError` with an optional message.\n *\n * **Example** (Creating an IllegalArgumentError)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * new Cause.IllegalArgumentError(\"Invalid argument\").message // => \"Invalid argument\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const IllegalArgumentError = effect.IllegalArgumentError;\n/**\n * Checks whether an arbitrary value is an `ExceededCapacityError`.\n *\n * **Example** (Checking the runtime type)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.isExceededCapacityError(new Cause.ExceededCapacityError()) // => true\n * Cause.isExceededCapacityError(\"nope\") // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isExceededCapacityError = effect.isExceededCapacityError;\n/**\n * Unique brand for `ExceededCapacityError`.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const ExceededCapacityErrorTypeId = effect.ExceededCapacityErrorTypeId;\n/**\n * Constructs an `ExceededCapacityError` with an optional message.\n *\n * **When to use**\n *\n * Use to create the error value for bounded-resource capacity failures.\n *\n * **Example** (Creating an ExceededCapacityError)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * new Cause.ExceededCapacityError(\"Queue full\").message // => \"Queue full\"\n * ```\n *\n * @see {@link isExceededCapacityError} for checking unknown values\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const ExceededCapacityError = effect.ExceededCapacityError;\n/**\n * Unique brand present on `AsyncFiberError` values and used by\n * `isAsyncFiberError` for runtime checks.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const AsyncFiberErrorTypeId = effect.AsyncFiberErrorTypeId;\n/**\n * Checks whether an arbitrary value is an `AsyncFiberError`.\n *\n * **Example** (Checking the runtime type)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect } from \"effect\"\n *\n * const fiber = Effect.runFork(Effect.void)\n *\n * const error = new Cause.AsyncFiberError(fiber)\n * Cause.isAsyncFiberError(error) // => true\n * Cause.isAsyncFiberError(\"nope\") // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isAsyncFiberError = effect.isAsyncFiberError;\n/**\n * Constructs an `AsyncFiberError` for a fiber that could not be resolved\n * synchronously.\n *\n * **When to use**\n *\n * Use to create the error value for a fiber that could not be completed by a\n * synchronous runner.\n *\n * **Example** (Creating an AsyncFiberError)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect } from \"effect\"\n *\n * const fiber = Effect.runFork(Effect.void)\n *\n * new Cause.AsyncFiberError(fiber).message // => \"An asynchronous Effect was executed with Effect.runSync\"\n * ```\n *\n * @see {@link isAsyncFiberError} for checking unknown values\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const AsyncFiberError = effect.AsyncFiberError;\n/**\n * Unique brand for `UnknownError`.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const UnknownErrorTypeId = effect.UnknownErrorTypeId;\n/**\n * Checks whether an arbitrary value is an `UnknownError`.\n *\n * **Example** (Checking the runtime type)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * Cause.isUnknownError(new Cause.UnknownError(\"x\")) // => true\n * Cause.isUnknownError(\"nope\") // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isUnknownError = effect.isUnknownError;\n/**\n * Constructs an `UnknownError`. The first argument is the original\n * cause (stored in `Error.cause`); the second is an optional human-readable\n * message.\n *\n * **Example** (Creating an UnknownError)\n *\n * ```ts import.meta.vitest\n * import { Cause } from \"effect\"\n *\n * new Cause.UnknownError({ raw: true }, \"Unexpected value\").message // => \"Unexpected value\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const UnknownError = effect.UnknownError;\n/**\n * Attaches metadata to every reason in a `Cause`.\n *\n * **When to use**\n *\n * Use to attach diagnostic metadata to every reason in a cause.\n *\n * **Details**\n *\n * Annotations are stored as a `Context` on each reason and can be\n * retrieved later via {@link reasonAnnotations} or {@link annotations}.\n * The runtime uses this to attach stack traces and spans.\n *\n * - Returns a new `Cause`.\n * - By default, existing keys are preserved. Pass `{ overwrite: true }` to\n * replace them.\n *\n * **Example** (Annotating a cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Context } from \"effect\"\n *\n * class RequestId extends Context.Service()(\"RequestId\") {}\n *\n * const annotated = Cause.annotate(Cause.fail(\"error\"), Context.make(RequestId, \"req-1\"))\n * Context.getOrUndefined(Cause.annotations(annotated), RequestId) // => \"req-1\"\n * ```\n *\n * @see {@link annotations} for reading merged annotations from a cause\n * @see {@link reasonAnnotations} for reading annotations from a single reason\n *\n * @category annotations\n * @since 4.0.0\n */\nexport const annotate = core.causeAnnotate;\n/**\n * Reads the annotations from a single `Reason` as a `Context`.\n *\n * **When to use**\n *\n * Use when you need tracing metadata (e.g. `StackTrace`) from\n * a specific reason rather than the whole cause.\n *\n * **Example** (Reading reason annotations)\n *\n * ```ts import.meta.vitest\n * import { Cause, Context } from \"effect\"\n *\n * class RequestId extends Context.Service()(\"RequestId\") {}\n *\n * const reason = Cause.makeFailReason(\"error\")\n * const annotated = reason.annotate(Context.make(RequestId, \"req-1\"))\n *\n * Context.getOrUndefined(Cause.reasonAnnotations(annotated), RequestId) // => \"req-1\"\n * ```\n *\n * @see {@link annotations} — merged annotations from all reasons in a cause\n *\n * @category annotations\n * @since 4.0.0\n */\nexport const reasonAnnotations = effect.reasonAnnotations;\n/**\n * Reads the merged annotations from all reasons in a `Cause`.\n *\n * **When to use**\n *\n * Use to read diagnostic metadata merged from the whole cause.\n *\n * **Gotchas**\n *\n * When multiple reasons contain the same annotation key, the value from the\n * later reason wins.\n *\n * **Example** (Reading merged annotations)\n *\n * ```ts import.meta.vitest\n * import { Cause, Context } from \"effect\"\n *\n * class RequestId extends Context.Service()(\"RequestId\") {}\n *\n * const cause = Cause.annotate(\n * Cause.fail(\"error\"),\n * Context.make(RequestId, \"req-1\")\n * )\n *\n * Context.getOrUndefined(Cause.annotations(cause), RequestId) // => \"req-1\"\n * ```\n *\n * @see {@link reasonAnnotations} — annotations from a single reason\n *\n * @category annotations\n * @since 4.0.0\n */\nexport const annotations = effect.causeAnnotations;\n/**\n * Context annotation used to store the stack frame captured at the point of failure.\n *\n * **When to use**\n *\n * Use to read the failure stack-frame annotation from a `Reason` when building\n * diagnostics, logging, or custom cause renderers.\n *\n * **Details**\n *\n * The runtime annotates every reason with this when a stack frame is\n * available. Retrieve it via\n * `Context.get(Cause.reasonAnnotations(reason), Cause.StackTrace)`.\n *\n * @see {@link reasonAnnotations} for reading annotations from a single reason\n * @see {@link annotations} for reading merged annotations from a cause\n * @see {@link InterruptorStackTrace} for the interrupt-specific stack-frame annotation\n *\n * @category services\n * @since 4.0.0\n */\nexport class StackTrace extends /*#__PURE__*/Context.Service()(\"effect/Cause/StackTrace\") {}\n/**\n * Context annotation used to store the stack frame captured at the point of\n * interruption.\n *\n * **When to use**\n *\n * Use when you need the stack-frame annotation used by interrupt-only cause\n * rendering.\n *\n * **Details**\n *\n * Similar to `StackTrace` but specific to `Interrupt` reasons.\n *\n * @see {@link StackTrace} for stack frames attached to failures\n * @see {@link reasonAnnotations} for reading annotations from a single reason\n * @see {@link annotate} for attaching annotations to a cause\n *\n * @category services\n * @since 4.0.0\n */\nexport class InterruptorStackTrace extends /*#__PURE__*/Context.Service()(\"effect/Cause/InterruptorStackTrace\") {}\n//# sourceMappingURL=Cause.js.map","import { IllegalArgumentError } from \"../Cause.js\";\nimport * as Clock from \"../Clock.js\";\nimport * as Duration from \"../Duration.js\";\nimport * as Equal from \"../Equal.js\";\nimport * as Equ from \"../Equivalence.js\";\nimport { dual } from \"../Function.js\";\nimport * as Hash from \"../Hash.js\";\nimport * as Inspectable from \"../Inspectable.js\";\nimport * as Option from \"../Option.js\";\nimport * as order from \"../Order.js\";\nimport { pipeArguments } from \"../Pipeable.js\";\nimport * as Predicate from \"../Predicate.js\";\nimport * as effect from \"./effect.js\";\n/** @internal */\nexport const TypeId = \"~effect/DateTime\";\n/** @internal */\nexport const TimeZoneTypeId = \"~effect/DateTime/TimeZone\";\nconst Proto = {\n [TypeId]: TypeId,\n pipe() {\n return pipeArguments(this, arguments);\n },\n [Inspectable.NodeInspectSymbol]() {\n return this.toString();\n },\n toJSON() {\n return toDateUtc(this).toJSON();\n }\n};\nconst ProtoUtc = {\n ...Proto,\n _tag: \"Utc\",\n [Hash.symbol]() {\n return Hash.number(this.epochMilliseconds);\n },\n [Equal.symbol](that) {\n return isDateTime(that) && that._tag === \"Utc\" && this.epochMilliseconds === that.epochMilliseconds;\n },\n toString() {\n return `DateTime.Utc(${toDateUtc(this).toJSON()})`;\n }\n};\nconst ProtoZoned = {\n ...Proto,\n _tag: \"Zoned\",\n [Hash.symbol]() {\n return Hash.combine(Hash.number(this.epochMilliseconds))(Hash.hash(this.zone));\n },\n [Equal.symbol](that) {\n return isDateTime(that) && that._tag === \"Zoned\" && this.epochMilliseconds === that.epochMilliseconds && Equal.equals(this.zone, that.zone);\n },\n toString() {\n return `DateTime.Zoned(${formatIsoZoned(this)})`;\n }\n};\nconst ProtoTimeZone = {\n [TimeZoneTypeId]: TimeZoneTypeId,\n [Inspectable.NodeInspectSymbol]() {\n return this.toString();\n }\n};\nconst ProtoTimeZoneNamed = {\n ...ProtoTimeZone,\n _tag: \"Named\",\n [Hash.symbol]() {\n return Hash.string(`Named:${this.id}`);\n },\n [Equal.symbol](that) {\n return isTimeZone(that) && that._tag === \"Named\" && this.id === that.id;\n },\n toString() {\n return `TimeZone.Named(${this.id})`;\n },\n toJSON() {\n return {\n _id: \"TimeZone\",\n _tag: \"Named\",\n id: this.id\n };\n }\n};\nconst ProtoTimeZoneOffset = {\n ...ProtoTimeZone,\n _tag: \"Offset\",\n [Hash.symbol]() {\n return Hash.string(`Offset:${this.offset}`);\n },\n [Equal.symbol](that) {\n return isTimeZone(that) && that._tag === \"Offset\" && this.offset === that.offset;\n },\n toString() {\n return `TimeZone.Offset(${offsetToString(this.offset)})`;\n },\n toJSON() {\n return {\n _id: \"TimeZone\",\n _tag: \"Offset\",\n offset: this.offset\n };\n }\n};\n/** @internal */\nexport const makeZonedProto = (epochMillis, zone, partsUtc) => {\n const self = Object.create(ProtoZoned);\n self.epochMilliseconds = epochMillis;\n self.zone = zone;\n Object.defineProperty(self, \"partsUtc\", {\n value: partsUtc,\n enumerable: false,\n writable: true\n });\n Object.defineProperty(self, \"adjustedEpochMillis\", {\n value: undefined,\n enumerable: false,\n writable: true\n });\n Object.defineProperty(self, \"partsAdjusted\", {\n value: undefined,\n enumerable: false,\n writable: true\n });\n return self;\n};\n// =============================================================================\n// guards\n// =============================================================================\n/** @internal */\nexport const isDateTime = u => Predicate.hasProperty(u, TypeId);\nconst isDateTimeArgs = args => isDateTime(args[0]);\n/** @internal */\nexport const isTimeZone = u => Predicate.hasProperty(u, TimeZoneTypeId);\n/** @internal */\nexport const isTimeZoneOffset = u => isTimeZone(u) && u._tag === \"Offset\";\n/** @internal */\nexport const isTimeZoneNamed = u => isTimeZone(u) && u._tag === \"Named\";\n/** @internal */\nexport const isUtc = self => self._tag === \"Utc\";\n/** @internal */\nexport const isZoned = self => self._tag === \"Zoned\";\n// =============================================================================\n// instances\n// =============================================================================\n/** @internal */\nexport const Equivalence = /*#__PURE__*/Equ.make((a, b) => a.epochMilliseconds === b.epochMilliseconds);\n/** @internal */\nexport const Order = /*#__PURE__*/order.make((self, that) => self.epochMilliseconds < that.epochMilliseconds ? -1 : self.epochMilliseconds > that.epochMilliseconds ? 1 : 0);\n/** @internal */\nexport const clamp = /*#__PURE__*/order.clamp(Order);\n// =============================================================================\n// constructors\n// =============================================================================\nconst makeUtc = epochMillis => {\n const self = Object.create(ProtoUtc);\n self.epochMilliseconds = epochMillis;\n Object.defineProperty(self, \"partsUtc\", {\n value: undefined,\n enumerable: false,\n writable: true\n });\n return self;\n};\n/** @internal */\nexport const fromDateUnsafe = date => {\n const epochMillis = date.getTime();\n if (Number.isNaN(epochMillis)) {\n throw new IllegalArgumentError(\"Invalid date\");\n }\n return makeUtc(epochMillis);\n};\n/** @internal */\nexport const makeUnsafe = input => {\n if (isDateTime(input)) {\n return input;\n } else if (input instanceof Date) {\n return fromDateUnsafe(input);\n } else if (typeof input === \"object\") {\n if (\"epochMilliseconds\" in input) {\n return fromDateUnsafe(new Date(input.epochMilliseconds));\n }\n const date = new Date(0);\n setPartsDate(date, input);\n return fromDateUnsafe(date);\n } else if (typeof input === \"string\" && !hasZone(input)) {\n return fromDateUnsafe(new Date(input + \"Z\"));\n }\n return fromDateUnsafe(new Date(input));\n};\n/**\n * Detects whether a date string already contains timezone info.\n * Without a zone, `new Date(\"2024-01-01T12:00:00\")` is parsed as local time,\n * so `makeUnsafe` appends \"Z\" to force UTC interpretation.\n * This check prevents appending \"Z\" to strings that already have a zone\n * (e.g. \"2024-01-01T12:00:00Z\", \"...+05:30\", \"...GMT\"), which would produce invalid dates.\n */\nconst hasZone = input => /Z|GMT|[+-]\\d{2}$|[+-]\\d{2}:?\\d{2}$|\\]$/.test(input);\nconst minEpochMillis = -8640000000000000 + 12 * 60 * 60 * 1000;\nconst maxEpochMillis = 8640000000000000 - 14 * 60 * 60 * 1000;\n/** @internal */\nexport const makeZonedUnsafe = (input, options) => {\n let timeZoneOption = options?.timeZone;\n if (timeZoneOption === undefined && isDateTime(input) && isZoned(input)) {\n return input;\n }\n const self = makeUnsafe(input);\n if (self.epochMilliseconds < minEpochMillis || self.epochMilliseconds > maxEpochMillis) {\n throw new RangeError(`Epoch millis out of range: ${self.epochMilliseconds}`);\n }\n if (timeZoneOption === undefined && typeof input === \"object\" && \"timeZoneId\" in input) {\n timeZoneOption = input.timeZoneId;\n }\n let zone;\n if (timeZoneOption === undefined) {\n const offset = new Date(self.epochMilliseconds).getTimezoneOffset() * -60 * 1000;\n zone = zoneMakeOffset(offset);\n } else if (isTimeZone(timeZoneOption)) {\n zone = timeZoneOption;\n } else if (typeof timeZoneOption === \"number\") {\n zone = zoneMakeOffset(timeZoneOption);\n } else {\n const parsedZone = zoneFromString(timeZoneOption);\n if (Option.isNone(parsedZone)) {\n throw new IllegalArgumentError(`Invalid time zone: ${timeZoneOption}`);\n }\n zone = parsedZone.value;\n }\n if (options?.adjustForTimeZone !== true) {\n return makeZonedProto(self.epochMilliseconds, zone, self.partsUtc);\n }\n return makeZonedFromAdjusted(self.epochMilliseconds, zone, options?.disambiguation ?? \"compatible\");\n};\n/** @internal */\nexport const makeZoned = /*#__PURE__*/Option.liftThrowable(makeZonedUnsafe);\n/** @internal */\nexport const make = /*#__PURE__*/Option.liftThrowable(makeUnsafe);\nconst zonedStringRegExp = /^(.{17,35})\\[(.+)\\]$/;\n/** @internal */\nexport const makeZonedFromString = input => {\n const match = zonedStringRegExp.exec(input);\n if (match === null) {\n const offset = parseOffset(input);\n return offset !== null ? makeZoned(input, {\n timeZone: offset\n }) : Option.none();\n }\n const [, isoString, timeZone] = match;\n return makeZoned(isoString, {\n timeZone\n });\n};\n/** @internal */\nexport const now = /*#__PURE__*/effect.map(Clock.currentTimeMillis, makeUtc);\n/** @internal */\nexport const nowAsDate = /*#__PURE__*/effect.map(Clock.currentTimeMillis, millis => new Date(millis));\n/** @internal */\nexport const nowUnsafe = () => makeUtc(Date.now());\n// =============================================================================\n// time zones\n// =============================================================================\n/** @internal */\nexport const toUtc = self => makeUtc(self.epochMilliseconds);\n/** @internal */\nexport const setZone = /*#__PURE__*/dual(isDateTimeArgs, (self, zone, options) => options?.adjustForTimeZone === true ? makeZonedFromAdjusted(self.epochMilliseconds, zone, options?.disambiguation ?? \"compatible\") : makeZonedProto(self.epochMilliseconds, zone, self.partsUtc));\n/** @internal */\nexport const setZoneOffset = /*#__PURE__*/dual(isDateTimeArgs, (self, offset, options) => setZone(self, zoneMakeOffset(offset), options));\nconst validZoneCache = /*#__PURE__*/new Map();\nconst formatOptions = {\n day: \"numeric\",\n month: \"numeric\",\n year: \"numeric\",\n hour: \"numeric\",\n minute: \"numeric\",\n second: \"numeric\",\n timeZoneName: \"longOffset\",\n fractionalSecondDigits: 3,\n hourCycle: \"h23\"\n};\nconst zoneMakeIntl = format => {\n const zoneId = format.resolvedOptions().timeZone;\n if (validZoneCache.has(zoneId)) {\n return validZoneCache.get(zoneId);\n }\n const zone = Object.create(ProtoTimeZoneNamed);\n zone.id = zoneId;\n zone.format = format;\n validZoneCache.set(zoneId, zone);\n return zone;\n};\n/** @internal */\nexport const zoneMakeNamedUnsafe = zoneId => {\n if (validZoneCache.has(zoneId)) {\n return validZoneCache.get(zoneId);\n }\n try {\n return zoneMakeIntl(new Intl.DateTimeFormat(\"en-US\", {\n ...formatOptions,\n timeZone: zoneId\n }));\n } catch {\n throw new IllegalArgumentError(`Invalid time zone: ${zoneId}`);\n }\n};\n/** @internal */\nexport const zoneMakeOffset = offset => {\n const zone = Object.create(ProtoTimeZoneOffset);\n zone.offset = offset;\n return zone;\n};\n/** @internal */\nexport const zoneMakeNamed = /*#__PURE__*/Option.liftThrowable(zoneMakeNamedUnsafe);\n/** @internal */\nexport const zoneMakeNamedEffect = zoneId => effect.try({\n try: () => zoneMakeNamedUnsafe(zoneId),\n catch: e => e\n});\n/** @internal */\nexport const zoneMakeLocal = () => zoneMakeIntl(new Intl.DateTimeFormat(\"en-US\", formatOptions));\nconst offsetZoneRegExp = /^(?:GMT|[+-])/;\n/** @internal */\nexport const zoneFromString = zone => {\n if (offsetZoneRegExp.test(zone)) {\n const offset = parseOffset(zone);\n return offset === null ? Option.none() : Option.some(zoneMakeOffset(offset));\n }\n return zoneMakeNamed(zone);\n};\n/** @internal */\nexport const zoneToString = self => {\n if (self._tag === \"Offset\") {\n return offsetToString(self.offset);\n }\n return self.id;\n};\n/** @internal */\nexport const setZoneNamed = /*#__PURE__*/dual(isDateTimeArgs, (self, zoneId, options) => Option.map(zoneMakeNamed(zoneId), zone => setZone(self, zone, options)));\n/** @internal */\nexport const setZoneNamedUnsafe = /*#__PURE__*/dual(isDateTimeArgs, (self, zoneId, options) => setZone(self, zoneMakeNamedUnsafe(zoneId), options));\n// =============================================================================\n// comparisons\n// =============================================================================\n/** @internal */\nexport const distance = /*#__PURE__*/dual(2, (self, other) => Duration.millis(toEpochMillis(other) - toEpochMillis(self)));\n/** @internal */\nexport const min = /*#__PURE__*/order.min(Order);\n/** @internal */\nexport const max = /*#__PURE__*/order.max(Order);\n/** @internal */\nexport const isGreaterThan = /*#__PURE__*/order.isGreaterThan(Order);\n/** @internal */\nexport const isGreaterThanOrEqualTo = /*#__PURE__*/order.isGreaterThanOrEqualTo(Order);\n/** @internal */\nexport const isLessThan = /*#__PURE__*/order.isLessThan(Order);\n/** @internal */\nexport const isLessThanOrEqualTo = /*#__PURE__*/order.isLessThanOrEqualTo(Order);\n/** @internal */\nexport const between = /*#__PURE__*/order.isBetween(Order);\n/** @internal */\nexport const isFuture = self => effect.map(now, isLessThan(self));\n/** @internal */\nexport const isFutureUnsafe = self => isLessThan(nowUnsafe(), self);\n/** @internal */\nexport const isPast = self => effect.map(now, isGreaterThan(self));\n/** @internal */\nexport const isPastUnsafe = self => isGreaterThan(nowUnsafe(), self);\n// =============================================================================\n// conversions\n// =============================================================================\n/** @internal */\nexport const toDateUtc = self => new Date(self.epochMilliseconds);\n/** @internal */\nexport const toDate = self => {\n if (self._tag === \"Utc\") {\n return new Date(self.epochMilliseconds);\n } else if (self.zone._tag === \"Offset\") {\n return new Date(self.epochMilliseconds + self.zone.offset);\n } else if (self.adjustedEpochMilliseconds !== undefined) {\n return new Date(self.adjustedEpochMilliseconds);\n }\n const parts = self.zone.format.formatToParts(self.epochMilliseconds).filter(_ => _.type !== \"literal\");\n const date = new Date(0);\n date.setUTCFullYear(Number(parts[2].value), Number(parts[0].value) - 1, Number(parts[1].value));\n date.setUTCHours(Number(parts[3].value), Number(parts[4].value), Number(parts[5].value), Number(parts[6].value));\n self.adjustedEpochMilliseconds = date.getTime();\n return date;\n};\n/** @internal */\nexport const zonedOffset = self => {\n const date = toDate(self);\n return date.getTime() - toEpochMillis(self);\n};\nconst offsetToString = offset => {\n const abs = Math.abs(offset);\n let hours = Math.floor(abs / (60 * 60 * 1000));\n let minutes = Math.round(abs % (60 * 60 * 1000) / (60 * 1000));\n if (minutes === 60) {\n hours += 1;\n minutes = 0;\n }\n return `${offset < 0 ? \"-\" : \"+\"}${String(hours).padStart(2, \"0\")}:${String(minutes).padStart(2, \"0\")}`;\n};\n/** @internal */\nexport const zonedOffsetIso = self => offsetToString(zonedOffset(self));\n/** @internal */\nexport const toEpochMillis = self => self.epochMilliseconds;\n/** @internal */\nexport const toEpochSeconds = self => Math.floor(self.epochMilliseconds / 1000);\n/** @internal */\nexport const fromEpochSeconds = seconds => makeUtc(seconds * 1000);\n/** @internal */\nexport const removeTime = self => withDate(self, date => {\n date.setUTCHours(0, 0, 0, 0);\n return makeUtc(date.getTime());\n});\n// =============================================================================\n// parts\n// =============================================================================\nconst dateToParts = date => ({\n millisecond: date.getUTCMilliseconds(),\n second: date.getUTCSeconds(),\n minute: date.getUTCMinutes(),\n hour: date.getUTCHours(),\n day: date.getUTCDate(),\n weekDay: date.getUTCDay(),\n month: date.getUTCMonth() + 1,\n year: date.getUTCFullYear()\n});\n/** @internal */\nexport const toParts = self => {\n if (self._tag === \"Utc\") {\n return toPartsUtc(self);\n } else if (self.partsAdjusted !== undefined) {\n return self.partsAdjusted;\n }\n self.partsAdjusted = withDate(self, dateToParts);\n return self.partsAdjusted;\n};\n/** @internal */\nexport const toPartsUtc = self => {\n if (self.partsUtc !== undefined) {\n return self.partsUtc;\n }\n self.partsUtc = withDateUtc(self, dateToParts);\n return self.partsUtc;\n};\n/** @internal */\nexport const getPartUtc = /*#__PURE__*/dual(2, (self, part) => toPartsUtc(self)[part]);\n/** @internal */\nexport const getPart = /*#__PURE__*/dual(2, (self, part) => toParts(self)[part]);\nconst setPartsDate = (date, parts) => {\n if (parts.year !== undefined || parts.month !== undefined || parts.day !== undefined) {\n date.setUTCFullYear(parts.year ?? date.getUTCFullYear(), parts.month !== undefined ? parts.month - 1 : date.getUTCMonth(), parts.day ?? date.getUTCDate());\n }\n if (parts.weekDay !== undefined) {\n const diff = parts.weekDay - date.getUTCDay();\n date.setUTCDate(date.getUTCDate() + diff);\n }\n if (parts.hour !== undefined) {\n date.setUTCHours(parts.hour);\n }\n if (parts.minute !== undefined) {\n date.setUTCMinutes(parts.minute);\n }\n if (parts.second !== undefined) {\n date.setUTCSeconds(parts.second);\n }\n if (parts.millisecond !== undefined) {\n date.setUTCMilliseconds(parts.millisecond);\n }\n};\n/** @internal */\nexport const setParts = /*#__PURE__*/dual(2, (self, parts) => mutate(self, date => setPartsDate(date, parts)));\n/** @internal */\nexport const setPartsUtc = /*#__PURE__*/dual(2, (self, parts) => mutateUtc(self, date => setPartsDate(date, parts)));\n// =============================================================================\n// mapping\n// =============================================================================\nconst constDayMillis = 24 * 60 * 60 * 1000;\nconst makeZonedFromAdjusted = (adjustedMillis, zone, disambiguation) => {\n if (zone._tag === \"Offset\") {\n return makeZonedProto(adjustedMillis - zone.offset, zone);\n }\n const beforeOffset = calculateNamedOffset(adjustedMillis - constDayMillis, adjustedMillis, zone);\n const afterOffset = calculateNamedOffset(adjustedMillis + constDayMillis, adjustedMillis, zone);\n // If there is no transition, we can return early\n if (beforeOffset === afterOffset) {\n return makeZonedProto(adjustedMillis - beforeOffset, zone);\n }\n const isForwards = beforeOffset < afterOffset;\n const transitionMillis = beforeOffset - afterOffset;\n // If the transition is forwards, we only need to check if we should move the\n // local wall clock time forward if it is inside the gap\n if (isForwards) {\n const currentAfterOffset = calculateNamedOffset(adjustedMillis - afterOffset, adjustedMillis, zone);\n if (currentAfterOffset === afterOffset) {\n return makeZonedProto(adjustedMillis - afterOffset, zone);\n }\n const before = makeZonedProto(adjustedMillis - beforeOffset, zone);\n const beforeAdjustedMillis = toDate(before).getTime();\n // If the wall clock time has changed, we are inside the gap\n if (adjustedMillis !== beforeAdjustedMillis) {\n switch (disambiguation) {\n case \"reject\":\n {\n const formatted = new Date(adjustedMillis).toISOString();\n throw new RangeError(`Gap time: ${formatted} does not exist in time zone ${zone.id}`);\n }\n case \"earlier\":\n return makeZonedProto(adjustedMillis - afterOffset, zone);\n case \"compatible\":\n case \"later\":\n return before;\n }\n }\n // The wall clock time is in the earlier offset, so we use that\n return before;\n }\n const currentBeforeOffset = calculateNamedOffset(adjustedMillis - beforeOffset, adjustedMillis, zone);\n // The wall clock time is in the earlier offset, so we use that\n if (currentBeforeOffset === beforeOffset) {\n if (disambiguation === \"earlier\" || disambiguation === \"compatible\") {\n return makeZonedProto(adjustedMillis - beforeOffset, zone);\n }\n const laterOffset = calculateNamedOffset(adjustedMillis - beforeOffset + transitionMillis, adjustedMillis + transitionMillis, zone);\n if (laterOffset === beforeOffset) {\n return makeZonedProto(adjustedMillis - beforeOffset, zone);\n }\n // If the offset changed in this period, then we are inside the period where\n // the wall clock time occurs twice, once in the earlier offset and once in\n // the later offset.\n if (disambiguation === \"reject\") {\n const formatted = new Date(adjustedMillis).toISOString();\n throw new RangeError(`Ambiguous time: ${formatted} occurs twice in time zone ${zone.id}`);\n }\n // If the disambiguation is \"later\", we return the later offset below\n }\n return makeZonedProto(adjustedMillis - afterOffset, zone);\n};\nconst offsetRegExp = /([+-])(\\d{2}):(\\d{2})$/;\nconst parseOffset = offset => {\n const match = offsetRegExp.exec(offset);\n if (match === null) {\n return null;\n }\n const [, sign, hours, minutes] = match;\n return (sign === \"+\" ? 1 : -1) * (Number(hours) * 60 + Number(minutes)) * 60 * 1000;\n};\nconst calculateNamedOffset = (utcMillis, adjustedMillis, zone) => {\n const offset = zone.format.formatToParts(utcMillis).find(_ => _.type === \"timeZoneName\")?.value ?? \"\";\n if (offset === \"GMT\") {\n return 0;\n }\n const result = parseOffset(offset);\n if (result === null) {\n // fallback to using the adjusted date\n return zonedOffset(makeZonedProto(adjustedMillis, zone));\n }\n return result;\n};\n/** @internal */\nexport const mutate = /*#__PURE__*/dual(isDateTimeArgs, (self, f, options) => {\n if (self._tag === \"Utc\") {\n const date = toDateUtc(self);\n f(date);\n return makeUtc(date.getTime());\n }\n const adjustedDate = toDate(self);\n const newAdjustedDate = new Date(adjustedDate.getTime());\n f(newAdjustedDate);\n return makeZonedFromAdjusted(newAdjustedDate.getTime(), self.zone, options?.disambiguation ?? \"compatible\");\n});\n/** @internal */\nexport const mutateUtc = /*#__PURE__*/dual(2, (self, f) => mapEpochMillis(self, millis => {\n const date = new Date(millis);\n f(date);\n return date.getTime();\n}));\n/** @internal */\nexport const mapEpochMillis = /*#__PURE__*/dual(2, (self, f) => {\n const millis = f(toEpochMillis(self));\n return self._tag === \"Utc\" ? makeUtc(millis) : makeZonedProto(millis, self.zone);\n});\n/** @internal */\nexport const withDate = /*#__PURE__*/dual(2, (self, f) => f(toDate(self)));\n/** @internal */\nexport const withDateUtc = /*#__PURE__*/dual(2, (self, f) => f(toDateUtc(self)));\n/** @internal */\nexport const match = /*#__PURE__*/dual(2, (self, options) => self._tag === \"Utc\" ? options.onUtc(self) : options.onZoned(self));\n// =============================================================================\n// math\n// =============================================================================\n/** @internal */\nexport const addDuration = /*#__PURE__*/dual(2, (self, duration) => mapEpochMillis(self, millis => millis + Duration.toMillis(Duration.fromInputUnsafe(duration))));\n/** @internal */\nexport const subtractDuration = /*#__PURE__*/dual(2, (self, duration) => mapEpochMillis(self, millis => millis - Duration.toMillis(Duration.fromInputUnsafe(duration))));\nconst addMillis = (date, amount) => {\n date.setTime(date.getTime() + amount);\n};\n/** @internal */\nexport const add = /*#__PURE__*/dual(2, (self, parts) => mutate(self, date => {\n if (parts.milliseconds) {\n addMillis(date, parts.milliseconds);\n }\n if (parts.seconds) {\n addMillis(date, parts.seconds * 1000);\n }\n if (parts.minutes) {\n addMillis(date, parts.minutes * 60 * 1000);\n }\n if (parts.hours) {\n addMillis(date, parts.hours * 60 * 60 * 1000);\n }\n if (parts.days) {\n date.setUTCDate(date.getUTCDate() + parts.days);\n }\n if (parts.weeks) {\n date.setUTCDate(date.getUTCDate() + parts.weeks * 7);\n }\n if (parts.months) {\n const day = date.getUTCDate();\n date.setUTCMonth(date.getUTCMonth() + parts.months + 1, 0);\n if (day < date.getUTCDate()) {\n date.setUTCDate(day);\n }\n }\n if (parts.years) {\n const day = date.getUTCDate();\n const month = date.getUTCMonth();\n date.setUTCFullYear(date.getUTCFullYear() + parts.years, month + 1, 0);\n if (day < date.getUTCDate()) {\n date.setUTCDate(day);\n }\n }\n}));\n/** @internal */\nexport const subtract = /*#__PURE__*/dual(2, (self, parts) => {\n const newParts = {};\n for (const key in parts) {\n newParts[key] = -1 * parts[key];\n }\n return add(self, newParts);\n});\nconst startOfDate = (date, part, options) => {\n switch (part) {\n case \"second\":\n {\n date.setUTCMilliseconds(0);\n break;\n }\n case \"minute\":\n {\n date.setUTCSeconds(0, 0);\n break;\n }\n case \"hour\":\n {\n date.setUTCMinutes(0, 0, 0);\n break;\n }\n case \"day\":\n {\n date.setUTCHours(0, 0, 0, 0);\n break;\n }\n case \"week\":\n {\n const weekStartsOn = options?.weekStartsOn ?? 0;\n const day = date.getUTCDay();\n const diff = (day - weekStartsOn + 7) % 7;\n date.setUTCDate(date.getUTCDate() - diff);\n date.setUTCHours(0, 0, 0, 0);\n break;\n }\n case \"month\":\n {\n date.setUTCDate(1);\n date.setUTCHours(0, 0, 0, 0);\n break;\n }\n case \"year\":\n {\n date.setUTCMonth(0, 1);\n date.setUTCHours(0, 0, 0, 0);\n break;\n }\n }\n};\n/** @internal */\nexport const startOf = /*#__PURE__*/dual(isDateTimeArgs, (self, part, options) => mutate(self, date => startOfDate(date, part, options)));\nconst endOfDate = (date, part, options) => {\n switch (part) {\n case \"second\":\n {\n date.setUTCMilliseconds(999);\n break;\n }\n case \"minute\":\n {\n date.setUTCSeconds(59, 999);\n break;\n }\n case \"hour\":\n {\n date.setUTCMinutes(59, 59, 999);\n break;\n }\n case \"day\":\n {\n date.setUTCHours(23, 59, 59, 999);\n break;\n }\n case \"week\":\n {\n const weekStartsOn = options?.weekStartsOn ?? 0;\n const day = date.getUTCDay();\n const diff = (day - weekStartsOn + 7) % 7;\n date.setUTCDate(date.getUTCDate() - diff + 6);\n date.setUTCHours(23, 59, 59, 999);\n break;\n }\n case \"month\":\n {\n date.setUTCMonth(date.getUTCMonth() + 1, 0);\n date.setUTCHours(23, 59, 59, 999);\n break;\n }\n case \"year\":\n {\n date.setUTCMonth(11, 31);\n date.setUTCHours(23, 59, 59, 999);\n break;\n }\n }\n};\n/** @internal */\nexport const endOf = /*#__PURE__*/dual(isDateTimeArgs, (self, part, options) => mutate(self, date => endOfDate(date, part, options)));\n/** @internal */\nexport const nearest = /*#__PURE__*/dual(isDateTimeArgs, (self, part, options) => mutate(self, date => {\n if (part === \"millisecond\") return;\n const millis = date.getTime();\n const start = new Date(millis);\n startOfDate(start, part, options);\n const startMillis = start.getTime();\n const end = new Date(millis);\n endOfDate(end, part, options);\n const endMillis = end.getTime() + 1;\n const diffStart = millis - startMillis;\n const diffEnd = endMillis - millis;\n if (diffStart < diffEnd) {\n date.setTime(startMillis);\n } else {\n date.setTime(endMillis);\n }\n}));\n// =============================================================================\n// formatting\n// =============================================================================\nconst intlTimeZone = self => {\n if (self._tag === \"Named\") {\n return self.id;\n }\n return offsetToString(self.offset);\n};\n/** @internal */\nexport const format = /*#__PURE__*/dual(isDateTimeArgs, (self, options) => {\n try {\n return new Intl.DateTimeFormat(options?.locale, {\n timeZone: self._tag === \"Utc\" ? \"UTC\" : intlTimeZone(self.zone),\n ...options\n }).format(self.epochMilliseconds);\n } catch {\n return new Intl.DateTimeFormat(options?.locale, {\n timeZone: \"UTC\",\n ...options\n }).format(toDate(self));\n }\n});\n/** @internal */\nexport const formatLocal = /*#__PURE__*/dual(isDateTimeArgs, (self, options) => new Intl.DateTimeFormat(options?.locale, options).format(self.epochMilliseconds));\n/** @internal */\nexport const formatUtc = /*#__PURE__*/dual(isDateTimeArgs, (self, options) => new Intl.DateTimeFormat(options?.locale, {\n ...options,\n timeZone: \"UTC\"\n}).format(self.epochMilliseconds));\n/** @internal */\nexport const formatIntl = /*#__PURE__*/dual(2, (self, format) => format.format(self.epochMilliseconds));\n/** @internal */\nexport const formatIso = self => toDateUtc(self).toISOString();\n/** @internal */\nexport const formatIsoDate = self => toDate(self).toISOString().slice(0, 10);\n/** @internal */\nexport const formatIsoDateUtc = self => toDateUtc(self).toISOString().slice(0, 10);\n/** @internal */\nexport const formatIsoOffset = self => {\n const date = toDate(self);\n return self._tag === \"Utc\" ? date.toISOString() : `${date.toISOString().slice(0, -1)}${zonedOffsetIso(self)}`;\n};\n/** @internal */\nexport const formatIsoZoned = self => self.zone._tag === \"Offset\" ? formatIsoOffset(self) : `${formatIsoOffset(self)}[${self.zone.id}]`;\n//# sourceMappingURL=dateTime.js.map","/**\n * Works with TypeScript `string` values.\n *\n * This module exposes common string operations in a pipe-friendly style. The\n * helpers cover checks, comparison, concatenation, trimming, casing, slicing,\n * padding, replacement, normalization, safe character access, search helpers\n * that return `Option`, and joining strings through a reducer.\n *\n * @since 2.0.0\n */\nimport * as Equ from \"./Equivalence.js\";\nimport { dual } from \"./Function.js\";\nimport * as readonlyArray from \"./internal/array.js\";\nimport * as Count from \"./internal/count.js\";\nimport * as number from \"./Number.js\";\nimport * as Option from \"./Option.js\";\nimport * as order from \"./Order.js\";\nimport * as predicate from \"./Predicate.js\";\nimport * as Reducer from \"./Reducer.js\";\n/**\n * Exposes the global string constructor.\n *\n * **When to use**\n *\n * Use to access native JavaScript string coercion or constructor behavior from\n * the Effect module namespace.\n *\n * **Gotchas**\n *\n * Calling `String(value)` returns a primitive string. Calling\n * `new String(value)` creates a boxed `String` object.\n *\n * @see {@link isString} for checking whether a value is a primitive string\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const String = globalThis.String;\n/**\n * Checks whether a value is a `string`.\n *\n * **Example** (Checking for strings)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.isString(\"a\") // => true\n * String.isString(1) // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isString = predicate.isString;\n/**\n * Provides an `Order` instance for comparing strings using lexicographic\n * ordering.\n *\n * **Example** (Comparing strings lexicographically)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.Order(\"apple\", \"banana\") // => -1\n * String.Order(\"banana\", \"apple\") // => 1\n * String.Order(\"apple\", \"apple\") // => 0\n * ```\n *\n * @category instances\n * @since 2.0.0\n */\nexport const Order = order.String;\n/**\n * Provides an `Equivalence` instance for strings using strict equality (`===`).\n *\n * **Example** (Comparing strings for equality)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.Equivalence(\"hello\", \"hello\") // => true\n * String.Equivalence(\"hello\", \"world\") // => false\n * ```\n *\n * @category instances\n * @since 2.0.0\n */\nexport const Equivalence = Equ.String;\n/**\n * Provides the empty string `\"\"`.\n *\n * **When to use**\n *\n * Use when you need the canonical empty string value from the `String` module.\n *\n * **Example** (Referencing the empty string)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.empty // => \"\"\n * String.isEmpty(String.empty) // => true\n * ```\n *\n * @category constants\n * @since 2.0.0\n */\nexport const empty = \"\";\n/**\n * Concatenates two strings at runtime.\n *\n * **Example** (Concatenating strings)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * String.concat(\"hello\", \"world\") // => \"helloworld\"\n * pipe(\"hello\", String.concat(\"world\")) // => \"helloworld\"\n * ```\n *\n * @category combining\n * @since 2.0.0\n */\nexport const concat = /*#__PURE__*/dual(2, (self, that) => self + that);\n/**\n * Converts a string to uppercase.\n *\n * **Example** (Converting strings to uppercase)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"a\", String.toUpperCase) // => \"A\"\n * String.toUpperCase(\"hello\") // => \"HELLO\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const toUpperCase = self => self.toUpperCase();\n/**\n * Converts a string to lowercase.\n *\n * **Example** (Converting strings to lowercase)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"A\", String.toLowerCase) // => \"a\"\n * String.toLowerCase(\"HELLO\") // => \"hello\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const toLowerCase = self => self.toLowerCase();\n/**\n * Capitalizes the first character of a string.\n *\n * **Example** (Capitalizing a string)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"abc\", String.capitalize) // => \"Abc\"\n * String.capitalize(\"hello\") // => \"Hello\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const capitalize = self => {\n if (self.length === 0) return self;\n return toUpperCase(self[0]) + self.slice(1);\n};\n/**\n * Uncapitalizes the first character of a string.\n *\n * **Example** (Uncapitalizing a string)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"ABC\", String.uncapitalize) // => \"aBC\"\n * String.uncapitalize(\"Hello\") // => \"hello\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const uncapitalize = self => {\n if (self.length === 0) return self;\n return toLowerCase(self[0]) + self.slice(1);\n};\n/**\n * Replaces matches in a string using `String.prototype.replace`.\n *\n * **Details**\n *\n * String search values and non-global regular expressions replace the first\n * match; global regular expressions replace every match.\n *\n * **Example** (Replacing a substring)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"abc\", String.replace(\"b\", \"d\")) // => \"adc\"\n * pipe(\"hello world\", String.replace(\"world\", \"Effect\")) // => \"hello Effect\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const replace = (searchValue, replaceValue) => self => self.replace(searchValue, replaceValue);\n/**\n * Removes whitespace from both ends of a string.\n *\n * **Example** (Trimming whitespace)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.trim(\" a \") // => \"a\"\n * String.trim(\" hello world \") // => \"hello world\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const trim = self => self.trim();\n/**\n * Removes whitespace from the start of a string.\n *\n * **Example** (Trimming leading whitespace)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.trimStart(\" a \") // => \"a \"\n * String.trimStart(\" hello world\") // => \"hello world\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const trimStart = self => self.trimStart();\n/**\n * Removes whitespace from the end of a string.\n *\n * **Example** (Trimming trailing whitespace)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.trimEnd(\" a \") // => \" a\"\n * String.trimEnd(\"hello world \") // => \"hello world\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const trimEnd = self => self.trimEnd();\n/**\n * Extracts a section of a string and returns it as a new string.\n *\n * **Example** (Slicing strings)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"abcd\", String.slice(1, 3)) // => \"bc\"\n * pipe(\"hello world\", String.slice(0, 5)) // => \"hello\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const slice = (start, end) => self => self.slice(start, end);\n/**\n * Checks whether a `string` is empty.\n *\n * **Example** (Checking for empty strings)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.isEmpty(\"\") // => true\n * String.isEmpty(\"a\") // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isEmpty = self => self.length === 0;\n/**\n * Checks whether a `string` is non-empty.\n *\n * **Example** (Checking for non-empty strings)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.isNonEmpty(\"\") // => false\n * String.isNonEmpty(\"a\") // => true\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isNonEmpty = self => self.length > 0;\n/**\n * Returns the JavaScript string length, measured in UTF-16 code units.\n *\n * **Example** (Getting string length)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.length(\"abc\") // => 3\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const length = self => self.length;\n/**\n * Splits a string into an array of substrings using a separator.\n *\n * **Example** (Splitting strings)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"abc\", String.split(\"\")) // => [\"a\", \"b\", \"c\"]\n * pipe(\"\", String.split(\"\")) // => [\"\"]\n * String.split(\"hello,world\", \",\") // => [\"hello\", \"world\"]\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const split = /*#__PURE__*/dual(2, (self, separator) => {\n const out = self.split(separator);\n return readonlyArray.isArrayNonEmpty(out) ? out : [self];\n});\n/**\n * Returns `true` if `searchString` appears as a substring of `self`, at one or more positions that are\n * greater than or equal to `position`; otherwise, returns `false`.\n *\n * **Example** (Checking for substrings)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"hello world\", String.includes(\"world\")) // => true\n * pipe(\"hello world\", String.includes(\"foo\")) // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const includes = (searchString, position) => self => self.includes(searchString, position);\n/**\n * Returns `true` if the string starts with the specified search string.\n *\n * **Example** (Checking string prefixes)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"hello world\", String.startsWith(\"hello\")) // => true\n * pipe(\"hello world\", String.startsWith(\"world\")) // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const startsWith = (searchString, position) => self => self.startsWith(searchString, position);\n/**\n * Returns `true` if the string ends with the specified search string.\n *\n * **Example** (Checking string suffixes)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"hello world\", String.endsWith(\"world\")) // => true\n * pipe(\"hello world\", String.endsWith(\"hello\")) // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const endsWith = (searchString, position) => self => self.endsWith(searchString, position);\n/**\n * Returns the character code at the specified index safely, or `None` if the index is out of bounds.\n *\n * **Example** (Reading character codes)\n *\n * ```ts import.meta.vitest\n * import { Option, String } from \"effect\"\n *\n * String.charCodeAt(\"abc\", 1) // => Option.some(98)\n * String.charCodeAt(\"abc\", 4) // => Option.none()\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const charCodeAt = /*#__PURE__*/dual(2, (self, index) => Option.filter(Option.some(self.charCodeAt(index)), charCode => !isNaN(charCode)));\n/**\n * Extracts characters from a string between two specified indices.\n *\n * **Example** (Extracting substrings)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"abcd\", String.substring(1)) // => \"bcd\"\n * pipe(\"abcd\", String.substring(1, 3)) // => \"bc\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const substring = (start, end) => self => self.substring(start, end);\n/**\n * Returns the character at the specified relative index safely, or `None` if the index is out of bounds.\n *\n * **Example** (Accessing characters safely)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe, String } from \"effect\"\n *\n * pipe(\"abc\", String.at(1)) // => Option.some(\"b\")\n * pipe(\"abc\", String.at(4)) // => Option.none()\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const at = /*#__PURE__*/dual(2, (self, index) => Option.fromUndefinedOr(self.at(index)));\n/**\n * Returns the character at the specified non-negative index safely, or `None` if the index is out of bounds.\n *\n * **Example** (Reading characters safely)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe, String } from \"effect\"\n *\n * pipe(\"abc\", String.charAt(1)) // => Option.some(\"b\")\n * pipe(\"abc\", String.charAt(4)) // => Option.none()\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const charAt = /*#__PURE__*/dual(2, (self, index) => Option.filter(Option.some(self.charAt(index)), isNonEmpty));\n/**\n * Returns the Unicode code point at the specified index safely, or `None` if the index is out of bounds.\n *\n * **Example** (Reading code points)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe, String } from \"effect\"\n *\n * pipe(\"abc\", String.codePointAt(1)) // => Option.some(98)\n * pipe(\"abc\", String.codePointAt(10)) // => Option.none()\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const codePointAt = /*#__PURE__*/dual(2, (self, index) => Option.fromUndefinedOr(self.codePointAt(index)));\n/**\n * Returns the index of the first occurrence of a substring safely, or `None` if not found.\n *\n * **Example** (Finding the first substring index)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe, String } from \"effect\"\n *\n * pipe(\"abbbc\", String.indexOf(\"b\")) // => Option.some(1)\n * pipe(\"abbbc\", String.indexOf(\"z\")) // => Option.none()\n * ```\n *\n * @category searching\n * @since 2.0.0\n */\nexport const indexOf = searchString => self => Option.filter(Option.some(self.indexOf(searchString)), number.isGreaterThanOrEqualTo(0));\n/**\n * Returns the index of the last occurrence of a substring safely, or `None` if not found.\n *\n * **Example** (Finding the last substring index)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe, String } from \"effect\"\n *\n * pipe(\"abbbc\", String.lastIndexOf(\"b\")) // => Option.some(3)\n * pipe(\"abbbc\", String.lastIndexOf(\"d\")) // => Option.none()\n * ```\n *\n * @category searching\n * @since 2.0.0\n */\nexport const lastIndexOf = searchString => self => Option.filter(Option.some(self.lastIndexOf(searchString)), number.isGreaterThanOrEqualTo(0));\n/**\n * Computes locale-aware ordering for two strings, with optional locales and\n * collator options, and returns the result as an `Ordering` (`-1`, `0`, or\n * `1`).\n *\n * **Example** (Comparing strings by locale)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"a\", String.localeCompare(\"b\")) // => -1\n * pipe(\"b\", String.localeCompare(\"a\")) // => 1\n * pipe(\"a\", String.localeCompare(\"a\")) // => 0\n * ```\n *\n * @category comparisons\n * @since 2.0.0\n */\nexport const localeCompare = (that, locales, options) => self => number.sign(self.localeCompare(that, locales, options));\n/**\n * Matches a string against a pattern safely and returns `Option.some` with the match\n * array, or `Option.none` when the pattern does not match.\n *\n * **Example** (Matching regular expressions)\n *\n * ```ts import.meta.vitest\n * import { Option, pipe, String } from \"effect\"\n *\n * pipe(\n * \"hello\",\n * String.match(/l+/),\n * Option.map((match) => [match[0], match.index])\n * ) // => Option.some([\"ll\", 2])\n * pipe(\"hello\", String.match(/x/)) // => Option.none()\n * ```\n *\n * @category searching\n * @since 2.0.0\n */\nexport const match = regExp => self => Option.fromNullOr(self.match(regExp));\n/**\n * Returns an iterator over all regular expression matches in the string using\n * native `String.prototype.matchAll` semantics.\n *\n * **Example** (Iterating regular expression matches)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * const matches = pipe(\"hello world\", String.matchAll(/l/g))\n *\n * Array.from(matches, (match) => [match[0], match.index]) // => [[\"l\", 2], [\"l\", 3], [\"l\", 9]]\n * ```\n *\n * @category searching\n * @since 2.0.0\n */\nexport const matchAll = regExp => self => self.matchAll(regExp);\n/**\n * Normalizes a string according to the specified Unicode normalization form.\n *\n * **Example** (Normalizing Unicode strings)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * const str = \"\\u1E9B\\u0323\"\n * Array.from(pipe(str, String.normalize()), (character) => character.codePointAt(0)) // => [0x1e9b, 0x323]\n * Array.from(pipe(str, String.normalize(\"NFC\")), (character) => character.codePointAt(0)) // => [0x1e9b, 0x323]\n * Array.from(\n * pipe(str, String.normalize(\"NFD\")),\n * (character) => character.codePointAt(0)\n * ) // => [0x17f, 0x323, 0x307]\n * Array.from(pipe(str, String.normalize(\"NFKC\")), (character) => character.codePointAt(0)) // => [0x1e69]\n * Array.from(\n * pipe(str, String.normalize(\"NFKD\")),\n * (character) => character.codePointAt(0)\n * ) // => [0x73, 0x323, 0x307]\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const normalize = form => self => self.normalize(form);\n/**\n * Pads the string from the end with a given fill string to a specified length.\n *\n * **Example** (Padding strings at the end)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"a\", String.padEnd(5)) // => \"a \"\n * pipe(\"a\", String.padEnd(5, \"_\")) // => \"a____\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const padEnd = (maxLength, fillString) => self => self.padEnd(maxLength, fillString);\n/**\n * Pads the string from the start with a given fill string to a specified length.\n *\n * **Example** (Padding strings at the start)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"a\", String.padStart(5)) // => \" a\"\n * pipe(\"a\", String.padStart(5, \"_\")) // => \"____a\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const padStart = (maxLength, fillString) => self => self.padStart(maxLength, fillString);\n/**\n * Repeats the string the specified number of times.\n *\n * **Details**\n *\n * `count` is rounded down. `NaN` and non-positive values are treated as `0`.\n *\n * **Example** (Repeating strings)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"a\", String.repeat(5)) // => \"aaaaa\"\n * pipe(\"hello\", String.repeat(3)) // => \"hellohellohello\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const repeat = count => self => self.repeat(Count.normalize(count));\n/**\n * Replaces all occurrences of a substring or pattern in a string.\n *\n * **Example** (Replacing all matches)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * pipe(\"ababb\", String.replaceAll(\"b\", \"c\")) // => \"acacc\"\n * pipe(\"ababb\", String.replaceAll(/ba/g, \"cc\")) // => \"accbb\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const replaceAll = (searchValue, replaceValue) => self => self.replaceAll(searchValue, replaceValue);\n/**\n * Returns the index of the first match for a string or regular expression safely, or\n * `Option.none` when no match is found.\n *\n * **Example** (Searching strings)\n *\n * ```ts import.meta.vitest\n * import { Option, String } from \"effect\"\n *\n * String.search(\"ababb\", \"b\") // => Option.some(1)\n * String.search(\"ababb\", /abb/) // => Option.some(2)\n * String.search(\"ababb\", \"d\") // => Option.none()\n * ```\n *\n * @category searching\n * @since 2.0.0\n */\nexport const search = /*#__PURE__*/dual(2, (self, regExp) => Option.filter(Option.some(self.search(regExp)), number.isGreaterThanOrEqualTo(0)));\n/**\n * Converts the string to lowercase according to the specified locale.\n *\n * **Example** (Lowercasing strings by locale)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * const str = \"\\u0130\"\n * pipe(str, String.toLocaleLowerCase(\"tr\")) // => \"i\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const toLocaleLowerCase = locale => self => self.toLocaleLowerCase(locale);\n/**\n * Converts the string to uppercase according to the specified locale.\n *\n * **Example** (Uppercasing strings by locale)\n *\n * ```ts import.meta.vitest\n * import { pipe, String } from \"effect\"\n *\n * const str = \"i\\u0307\"\n * pipe(str, String.toLocaleUpperCase(\"lt-LT\")) // => \"I\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const toLocaleUpperCase = locale => self => self.toLocaleUpperCase(locale);\n/**\n * Keeps the specified number of characters from the start of a string.\n *\n * **Details**\n *\n * If `n` is larger than the available number of characters, the string will\n * be returned whole.\n *\n * If `n` is not a positive number, including `NaN`, an empty string will be\n * returned.\n *\n * If `n` is a float, it will be rounded down to the nearest integer.\n *\n * **Example** (Taking characters from the start)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.takeLeft(\"Hello World\", 5) // => \"Hello\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const takeLeft = /*#__PURE__*/dual(2, (self, n) => self.slice(0, Count.normalize(n)));\n/**\n * Keeps the specified number of characters from the end of a string.\n *\n * **Details**\n *\n * If `n` is larger than the available number of characters, the string will\n * be returned whole.\n *\n * If `n` is not a positive number, including `NaN`, an empty string will be\n * returned.\n *\n * If `n` is a float, it will be rounded down to the nearest integer.\n *\n * **Example** (Taking characters from the end)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.takeRight(\"Hello World\", 5) // => \"World\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const takeRight = /*#__PURE__*/dual(2, (self, n) => self.slice(self.length - Math.min(Count.normalize(n), self.length), Infinity));\nconst CR = 0x0d;\nconst LF = 0x0a;\n/**\n * Returns an `IterableIterator` which yields each line contained within the\n * string, trimming off the trailing newline character.\n *\n * **Example** (Iterating lines without separators)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * Array.from(String.linesIterator(\"hello\\nworld\\n\")) // => [\"hello\", \"world\"]\n * ```\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const linesIterator = self => linesSeparated(self, true);\n/**\n * Returns an `IterableIterator` which yields each line contained within the\n * string as well as the trailing newline character.\n *\n * **Example** (Iterating lines with separators)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * Array.from(String.linesWithSeparators(\"hello\\nworld\\n\")) // => [\"hello\\n\", \"world\\n\"]\n * ```\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const linesWithSeparators = s => linesSeparated(s, false);\n/**\n * Strips a leading margin prefix from every line using the supplied margin\n * character.\n *\n * **Example** (Stripping custom margins)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.stripMarginWith(\" |hello\\n |world\", \"|\") // => \"hello\\nworld\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const stripMarginWith = /*#__PURE__*/dual(2, (self, marginChar) => {\n let out = \"\";\n for (const line of linesWithSeparators(self)) {\n let index = 0;\n while (index < line.length && line.charAt(index) <= \" \") {\n index = index + 1;\n }\n const stripped = index < line.length && line.charAt(index) === marginChar ? line.substring(index + 1) : line;\n out = out + stripped;\n }\n return out;\n});\n/**\n * Strips a leading `|` margin prefix from every line.\n *\n * **Example** (Stripping pipe margins)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.stripMargin(\" |hello\\n |world\") // => \"hello\\nworld\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const stripMargin = self => stripMarginWith(self, \"|\");\n/**\n * Converts a snake_case string to camelCase.\n *\n * **Example** (Converting snake_case to camelCase)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.snakeToCamel(\"hello_world\") // => \"helloWorld\"\n * String.snakeToCamel(\"foo_bar_baz\") // => \"fooBarBaz\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const snakeToCamel = self => {\n if (self.length === 0) return self;\n let str = self[0];\n for (let i = 1; i < self.length; i++) {\n str += self[i] === \"_\" ? self[++i].toUpperCase() : self[i];\n }\n return str;\n};\n/**\n * Converts a snake_case string to PascalCase.\n *\n * **Example** (Converting snake_case to PascalCase)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.snakeToPascal(\"hello_world\") // => \"HelloWorld\"\n * String.snakeToPascal(\"foo_bar_baz\") // => \"FooBarBaz\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const snakeToPascal = self => {\n if (self.length === 0) return self;\n let str = self[0].toUpperCase();\n for (let i = 1; i < self.length; i++) {\n str += self[i] === \"_\" ? self[++i].toUpperCase() : self[i];\n }\n return str;\n};\n/**\n * Converts a snake_case string to kebab-case.\n *\n * **Example** (Converting snake_case to kebab-case)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.snakeToKebab(\"hello_world\") // => \"hello-world\"\n * String.snakeToKebab(\"foo_bar_baz\") // => \"foo-bar-baz\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const snakeToKebab = self => self.replace(/_/g, \"-\");\n/**\n * Converts a camelCase string to snake_case.\n *\n * **Example** (Converting camelCase to snake_case)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.camelToSnake(\"helloWorld\") // => \"hello_world\"\n * String.camelToSnake(\"fooBarBaz\") // => \"foo_bar_baz\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const camelToSnake = self => self.replace(/([A-Z])/g, \"_$1\").toLowerCase();\n/**\n * Converts a PascalCase string to snake_case.\n *\n * **Example** (Converting PascalCase to snake_case)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.pascalToSnake(\"HelloWorld\") // => \"hello_world\"\n * String.pascalToSnake(\"FooBarBaz\") // => \"foo_bar_baz\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const pascalToSnake = self => (self.slice(0, 1) + self.slice(1).replace(/([A-Z])/g, \"_$1\")).toLowerCase();\n/**\n * Converts a kebab-case string to snake_case.\n *\n * **Example** (Converting kebab-case to snake_case)\n *\n * ```ts import.meta.vitest\n * import { String } from \"effect\"\n *\n * String.kebabToSnake(\"hello-world\") // => \"hello_world\"\n * String.kebabToSnake(\"foo-bar-baz\") // => \"foo_bar_baz\"\n * ```\n *\n * @category transforming\n * @since 2.0.0\n */\nexport const kebabToSnake = self => self.replace(/-/g, \"_\");\nclass LinesIterator {\n index;\n length;\n s;\n stripped;\n constructor(s, stripped = false) {\n this.s = s;\n this.stripped = stripped;\n this.index = 0;\n this.length = s.length;\n }\n next() {\n if (this.done) {\n return {\n done: true,\n value: undefined\n };\n }\n const start = this.index;\n while (!this.done && !isLineBreak(this.s[this.index])) {\n this.index = this.index + 1;\n }\n let end = this.index;\n if (!this.done) {\n const char = this.s[this.index];\n this.index = this.index + 1;\n if (!this.done && isLineBreak2(char, this.s[this.index])) {\n this.index = this.index + 1;\n }\n if (!this.stripped) {\n end = this.index;\n }\n }\n return {\n done: false,\n value: this.s.substring(start, end)\n };\n }\n [Symbol.iterator]() {\n return new LinesIterator(this.s, this.stripped);\n }\n get done() {\n return this.index >= this.length;\n }\n}\n/**\n * Checks whether the provided character is a line break character (i.e. either `\"\\r\"`\n * or `\"\\n\"`).\n */\nconst isLineBreak = char => {\n const code = char.charCodeAt(0);\n return code === CR || code === LF;\n};\n/**\n * Checks whether the provided characters combine to form a carriage return/line-feed\n * (i.e. `\"\\r\\n\"`).\n */\nconst isLineBreak2 = (char0, char1) => char0.charCodeAt(0) === CR && char1.charCodeAt(0) === LF;\nconst linesSeparated = (self, stripped) => new LinesIterator(self, stripped);\n/**\n * Normalizes a string by splitting it into word parts, transforming each part,\n * and joining the parts with a configurable delimiter.\n *\n * **When to use**\n *\n * Use when you need custom word-case output with a delimiter or part transform\n * that the fixed case helpers do not provide.\n *\n * @see {@link pascalCase} for fixed PascalCase output\n * @see {@link camelCase} for fixed lower-initial camelCase output\n * @see {@link constantCase} for fixed uppercase underscore-separated output\n * @see {@link kebabCase} for fixed lowercase hyphen-separated output\n * @see {@link snakeCase} for fixed lowercase underscore-separated output\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const noCase = /*#__PURE__*/dual(args => typeof args[0] === \"string\", (input, options) => {\n const splitRegExp = toRegExpArray(options?.splitRegExp ?? SPLIT_REGEXP);\n const stripRegExp = toRegExpArray(options?.stripRegExp ?? STRIP_REGEXP);\n const delimiter = options?.delimiter ?? \" \";\n const transform = options?.transform ?? toLowerCase;\n return normalizeCase(input, splitRegExp, stripRegExp, delimiter, transform);\n});\nconst toRegExpArray = regexp => predicate.isRegExp(regexp) ? [regexp] : regexp;\nconst normalizeCase = (input, splitRegExp, stripRegExp, delimiter, transform) => {\n let result = input;\n for (const regexp of splitRegExp) {\n result = result.replace(regexp, \"$1\\0$2\");\n }\n for (const regexp of stripRegExp) {\n result = result.replace(regexp, \"\\0\");\n }\n let start = 0;\n let end = result.length;\n // Trim the delimiter from around the output string.\n while (result.charAt(start) === \"\\0\") {\n start++;\n }\n while (result.charAt(end - 1) === \"\\0\") {\n end--;\n }\n // Transform each token independently.\n return result.slice(start, end).split(\"\\0\").map(transform).join(delimiter);\n};\n// Support camel case (\"camelCase\" -> \"camel Case\" and \"CAMELCase\" -> \"CAMEL Case\")\n// and digit boundaries (\"camel2case\" -> \"camel 2 case\").\nconst SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g, /([A-Z])([0-9])/gi, /([0-9])([A-Z])/gi];\n// Config paths preserve digit groups such as \"v2\" while still supporting camel case.\nconst CONFIG_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];\n// Remove all non-word characters.\nconst STRIP_REGEXP = /[^A-Z0-9]+/gi;\nconst pascalCaseTransform = input => {\n const firstChar = input.charAt(0);\n const lowerChars = input.substring(1).toLowerCase();\n return `${firstChar.toUpperCase()}${lowerChars}`;\n};\n/**\n * Converts a string to PascalCase.\n *\n * **When to use**\n *\n * Use to normalize strings from spaces, separators, or camel/Pascal word\n * boundaries into PascalCase.\n *\n * @see {@link camelCase} for lower-initial camelCase output\n * @see {@link noCase} for configurable delimiters and part transforms\n * @see {@link snakeToPascal} for converting known snake_case input only\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const pascalCase = /*#__PURE__*/noCase({\n delimiter: \"\",\n transform: pascalCaseTransform\n});\nconst camelCaseTransform = (input, index) => index === 0 ? input.toLowerCase() : pascalCaseTransform(input);\n/**\n * Converts a string to camelCase.\n *\n * **When to use**\n *\n * Use to normalize mixed word separators or existing PascalCase/camelCase text\n * into lower-initial camelCase identifiers.\n *\n * @see {@link noCase} for configurable delimiters and part transforms\n * @see {@link pascalCase} for upper-initial PascalCase output\n * @see {@link snakeCase} for lowercase underscore-separated output\n * @see {@link kebabCase} for lowercase hyphen-separated output\n * @see {@link constantCase} for uppercase underscore-separated output\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const camelCase = /*#__PURE__*/noCase({\n delimiter: \"\",\n transform: camelCaseTransform\n});\n/**\n * Converts a string to CONSTANT_CASE (uppercase with underscores).\n *\n * **When to use**\n *\n * Use to normalize words from mixed input formats into uppercase,\n * underscore-separated identifiers.\n *\n * @see {@link snakeCase} for lowercase underscore-separated output\n * @see {@link kebabCase} for lowercase hyphen-separated output\n * @see {@link camelCase} for lower-initial camelCase output\n * @see {@link pascalCase} for upper-initial PascalCase output\n * @see {@link configCase} for configuration key casing that preserves numeric word groups\n * @see {@link noCase} for configurable delimiters and part transforms\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const constantCase = /*#__PURE__*/noCase({\n delimiter: \"_\",\n transform: toUpperCase\n});\n/**\n * Converts a string to CONFIG_CASE (uppercase with underscores) for\n * configuration keys.\n *\n * **When to use**\n *\n * Use to normalize configuration path segments into environment-variable-like\n * keys while preserving numeric word groups such as `v2`.\n *\n * **Details**\n *\n * Unlike {@link constantCase}, digit-letter boundaries are not split. For\n * example, `\"api-v2 xml\"` becomes `\"API_V2_XML\"`.\n *\n * @see {@link constantCase} for standard uppercase underscore-separated output\n * @category transforming\n * @since 4.0.0\n */\nexport const configCase = self => normalizeCase(self, CONFIG_SPLIT_REGEXP, [STRIP_REGEXP], \"_\", toUpperCase);\n/**\n * Converts a string to kebab-case (lowercase with hyphens).\n *\n * **When to use**\n *\n * Use to normalize free-form labels, identifiers, or keys into lowercase\n * hyphen-separated text.\n *\n * @see {@link noCase} for configurable delimiters and part transforms\n * @see {@link snakeCase} for lowercase underscore-separated output\n * @see {@link constantCase} for uppercase underscore-separated output\n * @see {@link camelCase} for lower-initial camelCase output\n * @see {@link pascalCase} for upper-initial PascalCase output\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const kebabCase = /*#__PURE__*/noCase({\n delimiter: \"-\"\n});\n/**\n * Converts a string to snake_case (lowercase with underscores).\n *\n * **When to use**\n *\n * Use to normalize mixed-case or separator-delimited text into lowercase words\n * joined with underscores.\n *\n * @see {@link noCase} for configurable lower-level normalization\n * @see {@link kebabCase} for lowercase hyphen-separated output\n * @see {@link constantCase} for uppercase underscore-separated output\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const snakeCase = /*#__PURE__*/noCase({\n delimiter: \"_\"\n});\n/**\n * Reducer for concatenating `string`s.\n *\n * **When to use**\n *\n * Use to concatenate many strings through APIs that consume a `Reducer`.\n *\n * **Details**\n *\n * The reducer starts from `\"\"`, so combining an empty collection returns `\"\"`.\n *\n * @see {@link concat} for concatenating two strings directly\n *\n * @category combining\n * @since 4.0.0\n */\nexport const ReducerConcat = /*#__PURE__*/Reducer.make((a, b) => a + b, \"\");\n//# sourceMappingURL=String.js.map","import * as Context from \"../Context.js\";\n/** @internal */\nexport const Random = /*#__PURE__*/Context.Reference(\"effect/Random\", {\n defaultValue: () => ({\n nextIntUnsafe() {\n return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) + Number.MIN_SAFE_INTEGER;\n },\n nextDoubleUnsafe() {\n return Math.random();\n }\n })\n});\n/** @internal */\nexport const nextBetween = (min, max, draw) => {\n const value = draw * (max - min) + min;\n if (value !== max || min >= max || !Number.isFinite(max)) {\n return value;\n }\n // Rounding can reach the excluded endpoint even for a draw below 1.\n // Return its immediate predecessor, which is at least min for finite min < max.\n if (max === 0) {\n return -Number.MIN_VALUE;\n }\n const view = new DataView(new ArrayBuffer(8));\n view.setFloat64(0, max);\n const bits = view.getBigUint64(0);\n view.setBigUint64(0, max > 0 ? bits - BigInt(1) : bits + BigInt(1));\n return view.getFloat64(0);\n};\n//# sourceMappingURL=random.js.map","/**\n * Models one low-level pull step for stream-like consumers.\n *\n * A `Pull` is an `Effect` that can produce one `A`, fail with an\n * ordinary error `E`, or signal end-of-input with `Cause.Done`. The\n * separate done signal lets low-level consumers distinguish normal completion\n * from failure. This module includes type extractors and helpers for detecting,\n * filtering, catching, converting, and matching done signals separately from\n * ordinary failures.\n *\n * @since 4.0.0\n */\nimport * as Cause from \"./Cause.js\";\nimport * as Exit from \"./Exit.js\";\nimport * as Filter from \"./Filter.js\";\nimport { dual } from \"./Function.js\";\nimport * as internalEffect from \"./internal/effect.js\";\nimport * as Result from \"./Result.js\";\n// -----------------------------------------------------------------------------\n// Done\n// -----------------------------------------------------------------------------\n/**\n * Handles `Cause.Done` failures in an effect while leaving ordinary failures\n * in the error channel.\n *\n * **When to use**\n *\n * Use to recover from a `Cause.Done` completion signal in an effect, such as\n * turning a pull leftover value into a successful recovery effect while\n * preserving ordinary failures.\n *\n * **Details**\n *\n * The handler receives the done leftover value and may recover with a new\n * effect. Non-done errors are preserved.\n *\n * @see {@link matchEffect} for handling success, ordinary failure, and done outcomes explicitly\n * @see {@link filterDoneLeftover} for extracting a done leftover from an existing `Cause`\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchDone = /*#__PURE__*/dual(2, (effect, f) => internalEffect.catchCauseFilter(effect, filterDoneLeftover, l => f(l)));\n/**\n * Checks whether a Cause contains any done errors.\n *\n * **When to use**\n *\n * Use when you need to test whether a pull failure cause represents normal\n * completion and only need a boolean result.\n *\n * @see {@link isDoneFailure} for checking a single `Cause.Reason`\n * @see {@link filterDone} for extracting the `Cause.Done` value from a `Cause`\n * @see {@link filterNoDone} for selecting causes with no done failures\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isDoneCause = cause => cause.reasons.some(isDoneFailure);\n/**\n * Checks whether a `Cause.Reason` is a `Fail` reason whose error is a\n * `Cause.Done` signal.\n *\n * **When to use**\n *\n * Use when you need to identify done completion reasons while traversing\n * `cause.reasons`, before handling ordinary failures.\n *\n * @see {@link isDoneCause} for checking an entire `Cause` for any done reason\n * @see {@link filterDone} for extracting the `Cause.Done` value from a `Cause`\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isDoneFailure = failure => failure._tag === \"Fail\" && Cause.isDone(failure.error);\n/**\n * Finds a `Cause.Done` failure in a `Cause`.\n *\n * **When to use**\n *\n * Use to separate `Cause.Done` completion from ordinary causes while preserving\n * the typed done value.\n *\n * **Details**\n *\n * Returns a successful `Result` with the `Cause.Done` value when the cause\n * contains a done signal and no other failures besides interruptions. When the\n * done signal was merged with a real failure (for example a failing\n * finalizer), the `Result` fails with the remaining cause, stripped of the\n * done signal. Without a done signal the `Result` fails with the original\n * cause.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterDone = cause => {\n let done;\n let hasFailure = false;\n for (const reason of cause.reasons) {\n if (isDoneFailure(reason)) {\n done ??= reason.error;\n } else if (reason._tag !== \"Interrupt\") {\n hasFailure = true;\n }\n }\n if (done === undefined) return Result.fail(cause);\n return hasFailure ? Result.fail(Cause.fromReasons(cause.reasons.filter(reason => !isDoneFailure(reason)))) : Result.succeed(done);\n};\n/**\n * Finds a `Cause.Done` failure in a cause whose done value is not used.\n *\n * **When to use**\n *\n * Use to detect `Cause.Done` completion in a `Cause` when the completion value\n * is not part of the downstream logic.\n *\n * **Details**\n *\n * Returns a successful `Result` with the done marker when it is the only\n * failure, otherwise returns a failed `Result` with the non-done cause.\n *\n * @see {@link filterDone} for preserving the typed `Cause.Done` value when the done payload matters\n * @see {@link filterDoneLeftover} for extracting only the done leftover value\n * @see {@link filterNoDone} for the inverse filter that succeeds only when no done failure is present\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterDoneVoid = filterDone;\n/**\n * Keeps a `Cause` only when it contains no `Cause.Done` failures.\n *\n * **When to use**\n *\n * Use to select ordinary failure causes for handling while leaving `Cause.Done`\n * completion causes outside that handler.\n *\n * **Details**\n *\n * Returns a successful `Result` with the cause when every failure is non-done;\n * otherwise returns a failed `Result` with the original cause.\n *\n * @see {@link filterDone} for the inverse typed done filter\n * @see {@link filterDoneVoid} for done detection when the payload is not needed\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterNoDone = /*#__PURE__*/Filter.fromPredicate(cause => cause.reasons.every(failure => !isDoneFailure(failure)));\n/**\n * Filters a Cause to extract the leftover value from done errors.\n *\n * **When to use**\n *\n * Use to extract only the leftover value carried by a `Cause.Done` completion\n * signal.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterDoneLeftover = cause => {\n const done = filterDone(cause);\n return Result.isFailure(done) ? done : Result.succeed(done.success.value);\n};\n/**\n * Converts a `Cause` into an `Exit`, treating `Cause.Done` as successful\n * completion.\n *\n * **When to use**\n *\n * Use to produce an `Exit` for finalizing a low-level pull workflow when a\n * `Cause.Done` signal should be treated as success and any remaining cause\n * should fail.\n *\n * **Details**\n *\n * If the done signal is the only failure in the cause, its leftover becomes\n * the successful value. Otherwise the non-done cause becomes the failure\n * cause.\n *\n * @see {@link filterDone} for extracting the done signal without converting the cause to an `Exit`\n * @see {@link matchEffect} for handling `Pull` success, failure, and done outcomes directly\n *\n * @category converting\n * @since 4.0.0\n */\nexport const doneExitFromCause = cause => {\n const halt = filterDone(cause);\n return !Result.isFailure(halt) ? Exit.succeed(halt.success.value) : Exit.failCause(halt.failure);\n};\n/**\n * Pattern matches on a Pull, handling success, failure, and done cases.\n *\n * **When to use**\n *\n * Use to handle all three `Pull` outcomes with effectful handlers.\n *\n * **Example** (Matching Pull outcomes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Pull } from \"effect\"\n *\n * const pull = Cause.done(\"stream ended\")\n *\n * const result = Pull.matchEffect(pull, {\n * onSuccess: (value) => Effect.succeed(`Got value: ${value}`),\n * onFailure: (cause) => Effect.succeed(`Got error: ${cause}`),\n * onDone: (leftover) => Effect.succeed(`Stream halted with: ${leftover}`)\n * })\n *\n * await Effect.runPromise(result) // => \"Stream halted with: stream ended\"\n * ```\n *\n * @category pattern matching\n * @since 4.0.0\n */\nexport const matchEffect = /*#__PURE__*/dual(2, (self, options) => internalEffect.matchCauseEffect(self, {\n onSuccess: options.onSuccess,\n onFailure: cause => {\n const halt = filterDone(cause);\n return !Result.isFailure(halt) ? options.onDone(halt.success.value) : options.onFailure(halt.failure);\n }\n}));\n//# sourceMappingURL=Pull.js.map","import * as Cause from \"./Cause.js\";\nimport * as Context from \"./Context.js\";\nimport * as Cron from \"./Cron.js\";\nimport * as Duration from \"./Duration.js\";\nimport { constant, dual, identity } from \"./Function.js\";\nimport { isEffect } from \"./internal/core.js\";\nimport * as effect from \"./internal/effect.js\";\nimport * as random from \"./internal/random.js\";\nimport { pipeArguments } from \"./Pipeable.js\";\nimport { hasProperty } from \"./Predicate.js\";\nimport * as Pull from \"./Pull.js\";\nimport * as Result from \"./Result.js\";\nconst TypeId = \"~effect/Schedule\";\nconst randomNext = /*#__PURE__*/random.Random.useSync(random => random.nextDoubleUnsafe());\n/**\n * Context reference containing metadata for the currently running schedule step.\n *\n * **Details**\n *\n * Repeat, retry, stream, and channel scheduling operations provide this service\n * to effects run between schedule steps. The default value contains undefined\n * input and output values, zero duration, and zeroed timing fields before any\n * schedule step has produced metadata.\n *\n * @category services\n * @since 4.0.0\n */\nexport const CurrentMetadata = /*#__PURE__*/Context.Reference(\"effect/Schedule/CurrentMetadata\", {\n defaultValue: /*#__PURE__*/constant({\n input: undefined,\n output: undefined,\n duration: Duration.zero,\n attempt: 0,\n start: 0,\n now: 0,\n elapsed: 0,\n elapsedSincePrevious: 0\n })\n});\nconst ScheduleProto = {\n [TypeId]: {\n _Out: identity,\n _In: identity,\n _Env: identity\n },\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n/**\n * Type guard that checks if a value is a Schedule.\n *\n * **Example** (Checking for schedules)\n *\n * ```ts import.meta.vitest\n * import { Schedule } from \"effect\"\n *\n * const schedule = Schedule.exponential(\"100 millis\")\n * const notSchedule = { foo: \"bar\" }\n *\n * Schedule.isSchedule(schedule) // => true\n * Schedule.isSchedule(notSchedule) // => false\n * Schedule.isSchedule(null) // => false\n * Schedule.isSchedule(undefined) // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isSchedule = u => hasProperty(u, TypeId);\n/**\n * Creates a Schedule from a step function that returns a Pull.\n *\n * **Example** (Creating a custom schedule from a step function)\n *\n * ```ts import.meta.vitest\n * import { Cause, Duration, Effect, Schedule } from \"effect\"\n *\n * const schedule = Schedule.fromStep(Effect.sync(() => {\n * let count = 0\n *\n * return (_now: number, _input: string) => {\n * if (count >= 3) {\n * return Cause.done(count)\n * }\n * return Effect.succeed([count++, Duration.millis(100)] as [number, Duration.Duration])\n * }\n * }))\n *\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(schedule)\n * const [output] = yield* step(0, \"input\")\n * return output\n * })\n *\n * await Effect.runPromise(program) // => 0\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromStep = step => {\n const self = Object.create(ScheduleProto);\n self.step = step;\n return self;\n};\nconst metadataFn = () => {\n let n = 0;\n let previous;\n let start;\n return (now, input) => {\n if (start === undefined) start = now;\n const elapsed = now - start;\n const elapsedSincePrevious = previous === undefined ? 0 : now - previous;\n previous = now;\n return {\n input,\n attempt: ++n,\n start,\n now,\n elapsed,\n elapsedSincePrevious\n };\n };\n};\n/**\n * Creates a Schedule from a step function that receives metadata about the schedule's execution.\n *\n * **Example** (Creating a metadata-aware schedule)\n *\n * ```ts import.meta.vitest\n * import { Cause, Duration, Effect, Schedule } from \"effect\"\n *\n * const firstThreeInputs = Schedule.fromStepWithMetadata(Effect.succeed((metadata: Schedule.InputMetadata) => {\n * if (metadata.attempt > 3) {\n * return Cause.done(\"finished\")\n * }\n *\n * return Effect.succeed([\n * `attempt ${metadata.attempt}: ${metadata.input}`,\n * Duration.millis(250)\n * ] as [string, Duration.Duration])\n * }))\n *\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(firstThreeInputs)\n * const [output] = yield* step(0, \"input\")\n * return output\n * })\n *\n * await Effect.runPromise(program) // => \"attempt 1: input\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromStepWithMetadata = step => fromStep(effect.map(step, f => {\n const meta = metadataFn();\n return (now, input) => f(meta(now, input));\n}));\n/**\n * Extracts the step function from a Schedule.\n *\n * **Example** (Extracting a schedule step function)\n *\n * ```ts import.meta.vitest\n * import { Duration, Effect, Schedule } from \"effect\"\n *\n * // Extract step function from an existing schedule\n * const schedule = Schedule.exponential(\"100 millis\").pipe(Schedule.upTo({ times: 3 }))\n *\n * const program = Effect.gen(function*() {\n * const stepFn = yield* Schedule.toStep(schedule)\n *\n * // Use the step function directly for custom logic. The timestamp is\n * // supplied by the caller, so tests can pass a deterministic value.\n * const now = 0\n * return yield* stepFn(now, \"input\")\n * })\n *\n * await Effect.runPromise(program) // => [Duration.millis(100), Duration.millis(100)]\n * ```\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toStep = schedule => effect.catchCause(schedule.step, cause => effect.succeed(() => effect.failCause(cause)));\n/**\n * Extracts a step function from a `Schedule` that sleeps for each computed\n * delay and returns metadata for the completed step.\n *\n * **When to use**\n *\n * Use to drive a schedule manually while preserving the computed output,\n * delay, input, attempt, and elapsed timing metadata for each step.\n *\n * **Details**\n *\n * The returned step reads the current time from `Clock` when invoked, calls the\n * schedule step with that timestamp and input, sleeps for the returned\n * duration, and then yields `Metadata`.\n *\n * @see {@link toStep} for manually supplying the timestamp and handling the returned delay yourself\n * @see {@link toStepWithSleep} for the same automatic sleeping behavior when only the schedule output is needed\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toStepWithMetadata = schedule => effect.clockWith(clock => effect.map(toStep(schedule), step => {\n const metaFn = metadataFn();\n return input => effect.suspend(() => {\n const now = clock.currentTimeMillisUnsafe();\n return effect.flatMap(step(now, input), ([output, duration]) => {\n const meta = metaFn(now, input);\n meta.output = output;\n meta.duration = duration;\n return effect.as(effect.sleep(duration), meta);\n });\n });\n}));\n/**\n * Extracts a step function from a Schedule that automatically handles sleep delays.\n *\n * **Example** (Extracting a sleeping step function)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule } from \"effect\"\n * import { TestClock } from \"effect/testing\"\n *\n * const schedule = Schedule.recurs(3)\n *\n * const program = Effect.gen(function*() {\n * const stepWithSleep = yield* Schedule.toStepWithSleep(schedule)\n *\n * return [yield* stepWithSleep(\"first\"), yield* stepWithSleep(\"second\")]\n * })\n *\n * await Effect.runPromise(Effect.provide(program, TestClock.layer())) // => [0, 1]\n * ```\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toStepWithSleep = schedule => effect.map(toStepWithMetadata(schedule), step => input => effect.map(step(input), meta => meta.output));\n/**\n * Returns a new `Schedule` that adds the delay computed by the specified\n * effectful function to the next recurrence of the schedule.\n *\n * **Example** (Adding extra delay to a schedule)\n *\n * ```ts import.meta.vitest\n * import { Duration, Effect, Schedule } from \"effect\"\n *\n * const schedule = Schedule.recurs(1).pipe(\n * Schedule.addDelay(() => Effect.succeed(\"25 millis\"))\n * )\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(schedule)\n * const [, delay] = yield* step(0, undefined)\n * return delay\n * })\n *\n * await Effect.runPromise(program) // => Duration.millis(25)\n * ```\n *\n * @category delays & timeouts\n * @since 2.0.0\n */\nexport const addDelay = /*#__PURE__*/dual(2, (self, f) => modifyDelay(self, metadata => effect.map(f(metadata), d => Duration.sum(Duration.fromInputUnsafe(d), metadata.duration))));\n/**\n * Returns a schedule that runs `self` to completion, then runs `other`, and\n * merges their outputs.\n *\n * **Example** (Sequencing quick and slow retries)\n *\n * ```ts import.meta.vitest\n * import { Schedule } from \"effect\"\n *\n * const schedule = Schedule.concat(Schedule.recurs(1), Schedule.recurs(2))\n * Schedule.isSchedule(schedule) // => true\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const concat = /*#__PURE__*/dual(2, (self, other) => map(concatResult(self, other), ({\n output\n}) => effect.succeed(Result.merge(output))));\n/**\n * Returns a schedule that runs `self` to completion, then runs `other`, and\n * preserves which schedule produced each output.\n *\n * **Details**\n *\n * The resulting schedule emits a `Result` to indicate which phase produced\n * each output: outputs from `self` are emitted as `Failure`, and outputs from\n * `other` are emitted as `Success`.\n *\n * **Example** (Tracking sequential schedule phases)\n *\n * ```ts import.meta.vitest\n * import { Schedule } from \"effect\"\n *\n * const schedule = Schedule.concatResult(Schedule.recurs(1), Schedule.recurs(2))\n * Schedule.isSchedule(schedule) // => true\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const concatResult = /*#__PURE__*/dual(2, (self, other) => fromStep(effect.sync(() => {\n let currentSide = 0;\n let currentStep;\n const left = map(self, ({\n output\n }) => Result.fail(output));\n const right = map(other, ({\n output\n }) => Result.succeed(output));\n return function recur(now, input) {\n if (currentStep) return currentStep(now, input);\n return toStep(currentSide === 0 ? left : right).pipe(effect.flatMap(step => {\n currentSide++;\n if (currentSide === 1) {\n currentStep = (now, input) => Pull.catchDone(step(now, input), _ => {\n currentStep = undefined;\n return recur(now, input);\n });\n return currentStep(now, input);\n }\n currentStep = step;\n return currentStep(now, input);\n }));\n };\n})));\n/**\n * Combines schedules by recurring while all schedules want to recur, using the\n * maximum delay between recurrences and outputting that maximum delay.\n *\n * **When to use**\n *\n * Use when a combined policy should continue only while every schedule still\n * recurs, and should wait for the slowest schedule between recurrences.\n *\n * **Example** (Combining retry schedules by their maximum delay)\n *\n * ```ts import.meta.vitest\n * import { Schedule } from \"effect\"\n *\n * const schedule = Schedule.max([Schedule.fixed(\"5 seconds\"), Schedule.spaced(\"10 seconds\")])\n * Schedule.isSchedule(schedule) // => true\n * ```\n *\n * @category combining\n * @since 4.0.0\n */\nexport const max = schedules => fromStep(effect.map(effect.all(schedules.map(toStep)), steps => (now, input) => effect.flatMap(effect.forEach(steps, step => Pull.matchEffect(step(now, input), {\n onSuccess: result => effect.succeed(result[1]),\n onDone: () => effect.undefined,\n onFailure: effect.failCause\n})), results => {\n const duration = maxDuration(results);\n if (duration === undefined) {\n return Cause.done(Duration.zero);\n }\n return effect.succeed([duration, duration]);\n})));\nconst maxDuration = results => {\n let max = results[0];\n for (let i = 1; i < results.length; i++) {\n max = results[i] && max && Duration.max(max, results[i]);\n if (max === undefined) break;\n }\n return max;\n};\n/**\n * Returns a new `Schedule` that recurs on the specified `Cron` schedule and\n * outputs the duration between recurrences.\n *\n * **Example** (Scheduling work with cron expressions)\n *\n * ```ts import.meta.vitest\n * import { Schedule } from \"effect\"\n *\n * const everyMinute = Schedule.cron(\"* * * * *\")\n * Schedule.isSchedule(everyMinute) // => true\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const cron = (expression, tz) => {\n const parsed = Cron.isCron(expression) ? Result.succeed(expression) : Cron.parse(expression, tz);\n return fromStep(effect.map(effect.fromResult(parsed), cron => (now, _) => {\n if (now === Number.POSITIVE_INFINITY) {\n return Cause.done(Duration.zero);\n }\n return effect.sync(() => {\n const next = Cron.next(cron, now).getTime();\n const duration = Duration.millis(next - now);\n return [duration, duration];\n });\n }));\n};\n/**\n * Returns a schedule that recurs once after the specified duration.\n *\n * **When to use**\n *\n * Use when you need a schedule that recurs once after a fixed delay.\n *\n * **Details**\n *\n * The schedule outputs the configured duration for its first recurrence and\n * then completes.\n *\n * **Example** (Recurring once after a duration)\n *\n * ```ts import.meta.vitest\n * import { Schedule } from \"effect\"\n *\n * Schedule.isSchedule(Schedule.duration(\"1 second\")) // => true\n * ```\n *\n * @see {@link during} for recurring until a duration has elapsed\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const duration = durationInput => {\n const duration = Duration.fromInputUnsafe(durationInput);\n return fromStepWithMetadata(effect.succeed(meta => meta.attempt === 1 ? effect.succeed([duration, duration]) : Cause.done(Duration.zero)));\n};\n/**\n * Returns a new `Schedule` that will always recur, but only during the\n * specified `duration` of time.\n *\n * **When to use**\n *\n * Use to bound a repeating or retrying schedule by elapsed time.\n *\n * **Example** (Repeating work during a duration)\n *\n * ```ts import.meta.vitest\n * import { Schedule } from \"effect\"\n *\n * Schedule.isSchedule(Schedule.during(\"5 seconds\")) // => true\n * ```\n *\n * @see {@link duration} for one delayed recurrence\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const during = duration => {\n const durationMillis = Duration.toMillis(duration);\n return fromStepWithMetadata(effect.succeed(meta => {\n const elapsed = Duration.millis(meta.elapsed);\n return meta.elapsed > durationMillis ? Cause.done(elapsed) : effect.succeed([elapsed, Duration.zero]);\n }));\n};\n/**\n * Combines schedules by recurring while at least one schedule wants to recur,\n * using the minimum delay between recurrences and outputting that minimum delay.\n *\n * **When to use**\n *\n * Use when a combined policy should continue while any schedule still recurs,\n * and should wait for the fastest schedule between recurrences.\n *\n * **Example** (Combining retry schedules by their minimum delay)\n *\n * ```ts import.meta.vitest\n * import { Schedule } from \"effect\"\n *\n * const schedule = Schedule.min([Schedule.fixed(\"5 seconds\"), Schedule.spaced(\"10 seconds\")])\n * Schedule.isSchedule(schedule) // => true\n * ```\n *\n * @category combining\n * @since 4.0.0\n */\nexport const min = schedules => fromStep(effect.map(effect.all(schedules.map(toStep)), steps => (now, input) => effect.flatMap(effect.forEach(steps, step => Pull.matchEffect(step(now, input), {\n onSuccess: result => effect.succeed(result[1]),\n onDone: () => effect.undefined,\n onFailure: effect.failCause\n})), results => {\n const duration = minDuration(results);\n if (duration === undefined) {\n return Cause.done(Duration.zero);\n }\n return effect.succeed([duration, duration]);\n})));\nconst minDuration = results => {\n let min = undefined;\n for (let i = 0; i < results.length; i++) {\n const duration = results[i];\n if (duration !== undefined) {\n min = min === undefined ? duration : Duration.min(min, duration);\n }\n }\n return min;\n};\n/**\n * Schedule that always recurs, but will wait a certain amount between\n * repetitions, given by `base * factor.pow(n)`, where `n` is the number of\n * repetitions so far. Returns the current duration between recurrences.\n *\n * **Example** (Retrying with exponential backoff)\n *\n * ```ts import.meta.vitest\n * import { Duration, Effect, Schedule } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(Schedule.exponential(\"100 millis\"))\n * return yield* step(0, undefined)\n * })\n *\n * await Effect.runPromise(program) // => [Duration.millis(100), Duration.millis(100)]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const exponential = (base, factor = 2) => {\n const baseMillis = Duration.toMillis(Duration.fromInputUnsafe(base));\n return fromStepWithMetadata(effect.succeed(meta => {\n const duration = Duration.millis(baseMillis * Math.pow(factor, meta.attempt - 1));\n return effect.succeed([duration, duration]);\n }));\n};\n/**\n * Schedule that always recurs, increasing delays by summing the preceding\n * two delays (similar to the Fibonacci sequence). Returns the current\n * duration between recurrences.\n *\n * **Example** (Retrying with Fibonacci backoff)\n *\n * ```ts import.meta.vitest\n * import { Duration, Effect, Schedule } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(Schedule.fibonacci(\"100 millis\"))\n * return yield* step(0, undefined)\n * })\n *\n * await Effect.runPromise(program) // => [Duration.millis(100), Duration.millis(100)]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fibonacci = one => {\n const oneMillis = Duration.toMillis(Duration.fromInputUnsafe(one));\n return fromStep(effect.sync(() => {\n let a = 0;\n let b = oneMillis;\n return constant(effect.sync(() => {\n const next = a + b;\n a = b;\n b = next;\n const duration = Duration.millis(next);\n return [duration, duration];\n }));\n }));\n};\n/**\n * Returns a `Schedule` that recurs on the specified fixed `interval` and\n * outputs the number of repetitions of the schedule so far.\n *\n * **When to use**\n *\n * Use when recurrences should stay aligned to a regular cadence.\n *\n * **Gotchas**\n *\n * If the action run between recurrences takes longer than the interval, the\n * next recurrence happens immediately, but missed intervals are not replayed.\n *\n * ```text\n * |-----interval-----|-----interval-----|-----interval-----|\n * |---------action--------||action|-----|action|-----------|\n * ```\n *\n * **Example** (Repeating on fixed intervals)\n *\n * ```ts import.meta.vitest\n * import { Duration, Effect, Schedule } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(Schedule.fixed(\"1 second\"))\n * return yield* step(0, undefined)\n * })\n *\n * await Effect.runPromise(program) // => [0, Duration.seconds(1)]\n * ```\n *\n * @see {@link spaced} for delaying after each action completes\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fixed = interval => {\n const window = Duration.toMillis(Duration.fromInputUnsafe(interval));\n return fromStepWithMetadata(effect.sync(() => {\n let start = 0;\n let lastRun = 0;\n return meta => effect.sync(() => {\n if (window === 0) {\n return [meta.attempt - 1, Duration.zero];\n }\n if (meta.attempt === 1) {\n start = meta.now;\n lastRun = meta.now + window;\n return [0, Duration.millis(window)];\n }\n const runningBehind = meta.now > lastRun + window;\n const boundary = window - (meta.now - start) % window;\n const delay = runningBehind ? 0 : boundary === 0 ? window : boundary;\n lastRun = runningBehind ? meta.now : meta.now + delay;\n return [meta.attempt - 1, Duration.millis(delay)];\n });\n }));\n};\n/**\n * Returns a new `Schedule` that maps each schedule decision to a new output\n * using the full schedule metadata.\n *\n * **Details**\n *\n * The callback receives the schedule input, output, selected delay duration,\n * current attempt, and elapsed timing information. Return either a plain value\n * or an `Effect` that produces the new output.\n *\n * **Example** (Mapping schedule outputs)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule } from \"effect\"\n *\n * const countSchedule = Schedule.recurs(5).pipe(\n * Schedule.map(({ output: count }) => Effect.succeed(`Execution #${count + 1}`))\n * )\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(countSchedule)\n * const [output] = yield* step(0, undefined)\n * return output\n * })\n *\n * await Effect.runPromise(program) // => \"Execution #1\"\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(self), step => {\n const meta = metadataFn();\n return (now, input) => Pull.matchEffect(step(now, input), {\n onSuccess: ([output, duration]) => {\n const result = f({\n ...meta(now, input),\n output,\n duration\n });\n if (!isEffect(result)) return effect.succeed([result, duration]);\n return effect.map(result, output => [output, duration]);\n },\n onFailure: effect.failCause,\n onDone: output => {\n const result = f({\n ...meta(now, input),\n output,\n duration: Duration.zero\n });\n if (!isEffect(result)) return Cause.done(result);\n return effect.flatMap(result, Cause.done);\n }\n });\n})));\n/**\n * Returns a new `Schedule` that modifies the delay of the next recurrence\n * of the schedule using the specified effectful function.\n *\n * **Example** (Modifying delays from schedule metadata)\n *\n * ```ts import.meta.vitest\n * import { Duration, Effect, Schedule } from \"effect\"\n *\n * const schedule = Schedule.spaced(\"10 millis\").pipe(\n * Schedule.modifyDelay(({ duration }) => Effect.succeed(Duration.times(duration, 2)))\n * )\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(schedule)\n * const [, delay] = yield* step(0, undefined)\n * return delay\n * })\n *\n * await Effect.runPromise(program) // => Duration.millis(20)\n * ```\n *\n * @category delays & timeouts\n * @since 2.0.0\n */\nexport const modifyDelay = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(self), step => {\n const meta = metadataFn();\n return (now, input) => effect.flatMap(step(now, input), ([output, duration]) => effect.map(f({\n ...meta(now, input),\n output,\n duration\n }), replacement => [output, Duration.fromInputUnsafe(replacement)]));\n})));\n/**\n * Returns a new `Schedule` that randomly adjusts each recurrence delay.\n *\n * **When to use**\n *\n * Use to add random variation to an existing schedule's recurrence delays while\n * preserving its output and completion behavior.\n *\n * **Details**\n *\n * Each recurrence delay is scaled by a random factor between `0.8` and `1.2`.\n *\n * @see {@link modifyDelay} for replacing recurrence delays with a custom effectful transformation\n *\n * @category delays & timeouts\n * @since 2.0.0\n */\nexport const jittered = self => modifyDelay(self, ({\n duration\n}) => effect.map(randomNext, random => {\n const millis = Duration.toMillis(duration);\n return Duration.millis(millis * 0.8 * (1 - random) + millis * 1.2 * random);\n}));\n/**\n * Returns a new `Schedule` that outputs the inputs of the specified schedule.\n *\n * **Example** (Passing inputs through as outputs)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule } from \"effect\"\n *\n * const inputSchedule = Schedule.passthrough(\n * Schedule.exponential(\"100 millis\").pipe(Schedule.upTo({ times: 3 }))\n * )\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(inputSchedule)\n * const [output] = yield* step(0, \"input\")\n * return output\n * })\n *\n * await Effect.runPromise(program) // => \"input\"\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const passthrough = self => fromStep(effect.map(toStep(self), step => (now, input) => Pull.matchEffect(step(now, input), {\n onSuccess: result => effect.succeed([input, result[1]]),\n onFailure: effect.failCause,\n onDone: () => Cause.done(input)\n})));\n/**\n * Returns a `Schedule` which can only be stepped the specified number of\n * `times` before it terminates.\n *\n * **When to use**\n *\n * Use when you need a counter schedule with no additional delay.\n *\n * **Gotchas**\n *\n * `recurs(n)` counts schedule recurrences, not the first evaluation of the\n * effect being repeated or retried. For retrying, this means one initial\n * attempt plus at most `n` retries.\n *\n * **Example** (Limiting recurrences)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule } from \"effect\"\n * import { TestClock } from \"effect/testing\"\n *\n * const executions: Array = []\n * const program = Effect.sync(() => executions.push(executions.length + 1)).pipe(\n * Effect.repeat(Schedule.recurs(3)),\n * Effect.as(executions)\n * )\n *\n * await Effect.runPromise(Effect.provide(program, TestClock.layer())) // => [1, 2, 3, 4]\n * ```\n *\n * @see {@link upTo} for limiting an existing schedule\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const recurs = times => while_(forever, ({\n attempt\n}) => effect.succeed(attempt <= times));\n/**\n * Returns a schedule that recurs continuously, each repetition spaced the\n * specified duration from the last run.\n *\n * **When to use**\n *\n * Use when each delay should start after the previous action completes.\n *\n * **Example** (Repeating with fixed spacing)\n *\n * ```ts import.meta.vitest\n * import { Duration, Effect, Schedule } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(Schedule.spaced(\"2 seconds\"))\n * return yield* step(0, undefined)\n * })\n *\n * await Effect.runPromise(program) // => [0, Duration.seconds(2)]\n * ```\n *\n * @see {@link fixed} for recurrence aligned to a regular cadence\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const spaced = duration => {\n const decoded = Duration.fromInputUnsafe(duration);\n return fromStepWithMetadata(effect.succeed(meta => effect.succeed([meta.attempt - 1, decoded])));\n};\n/**\n * Returns a new `Schedule` that allows execution of an effectful function for\n * every decision of the schedule, but does not alter the inputs and outputs of\n * the schedule.\n *\n * **Details**\n *\n * The callback receives the full schedule metadata, including the input, output,\n * computed delay duration, current attempt, and elapsed timing information.\n *\n * **Example** (Tapping schedule metadata)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule } from \"effect\"\n *\n * const attempts: Array = []\n * const monitoredSchedule = Schedule.recurs(2).pipe(\n * Schedule.tap((metadata) => Effect.sync(() => attempts.push(metadata.attempt)))\n * )\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(monitoredSchedule)\n * const [output] = yield* step(0, undefined)\n * return { attempts, output }\n * })\n *\n * await Effect.runPromise(program) // => { attempts: [1], output: 0 }\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const tap = /*#__PURE__*/dual(2, (self, f) => fromStep(effect.map(toStep(self), step => {\n const meta = metadataFn();\n return (now, input) => effect.tap(step(now, input), ([output, duration]) => f({\n ...meta(now, input),\n output,\n duration\n }));\n})));\n/**\n * Returns a new `Schedule` that limits an existing schedule by elapsed\n * duration, number of outputs, or both.\n *\n * **When to use**\n *\n * Use to bound an existing schedule while preserving its output and delay\n * behavior. When both `duration` and `times` are specified, the schedule\n * stops as soon as either limit is reached.\n *\n * **Gotchas**\n *\n * The `times` option limits schedule outputs. When used with repeat or retry,\n * the effect is evaluated once before the schedule is stepped, so the total\n * number of evaluations can be one greater than the configured number of\n * outputs.\n *\n * The `duration` option is based on the elapsed time observed by the schedule\n * step. Long-running effects can cause the duration limit to be detected on the\n * following schedule step.\n *\n * **Example** (Limiting by duration and recurrence count)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule } from \"effect\"\n * import { TestClock } from \"effect/testing\"\n *\n * const executions: Array = []\n * const schedule = Schedule.forever.pipe(Schedule.upTo({ times: 2 }))\n * const program = Effect.sync(() => executions.push(executions.length + 1)).pipe(\n * Effect.repeat(schedule),\n * Effect.as(executions)\n * )\n *\n * await Effect.runPromise(Effect.provide(program, TestClock.layer())) // => [1, 2, 3]\n * ```\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const upTo = /*#__PURE__*/dual(2, (self, options) => {\n const duration = options.duration === undefined ? undefined : Duration.fromInputUnsafe(options.duration);\n return while_(self, ({\n attempt,\n elapsed\n }) => effect.succeed((options.times === undefined || attempt <= options.times) && (duration === undefined || Duration.isLessThanOrEqualTo(Duration.millis(elapsed), duration))));\n});\nconst while_ = /*#__PURE__*/dual(2, (self, predicate) => fromStep(effect.map(toStep(self), step => {\n const meta = metadataFn();\n return (now, input) => effect.flatMap(step(now, input), result => {\n const [output, duration] = result;\n const eff = predicate({\n ...meta(now, input),\n output,\n duration\n });\n return effect.flatMap(isEffect(eff) ? eff : effect.succeed(eff), check => check ? effect.succeed(result) : Cause.done(output));\n });\n})));\nexport {\n/**\n * Returns a new schedule that continues while the predicate returns `true`.\n *\n * **When to use**\n *\n * Use to stop an existing schedule based on its full metadata, such as the\n * current input, output, attempt, delay, or elapsed time.\n *\n * **Details**\n *\n * The predicate receives `Metadata`, may return `boolean` or an\n * `Effect`, preserves the output and delay when it returns\n * `true`, and stops the schedule when it returns `false`.\n *\n * @see {@link upTo} for stopping after a fixed number of schedule outputs\n *\n * @category filtering\n * @since 4.0.0\n */\nwhile_ as while };\n/**\n * Schedule that divides the timeline to `interval`-long windows, and sleeps\n * until the nearest window boundary every time it recurs.\n *\n * **Details**\n *\n * For example, `Schedule.windowed(\"10 seconds\")` would produce a schedule as\n * follows:\n *\n * ```text\n * 10s 10s 10s 10s\n * |----------|----------|----------|----------|\n * |action------|sleep---|act|-sleep|action----|\n * ```\n *\n * **Example** (Repeating on aligned windows)\n *\n * ```ts import.meta.vitest\n * import { Duration, Effect, Schedule } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const step = yield* Schedule.toStep(Schedule.windowed(\"5 seconds\"))\n * return yield* step(0, undefined)\n * })\n *\n * await Effect.runPromise(program) // => [0, Duration.seconds(5)]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const windowed = interval => {\n const window = Duration.toMillis(Duration.fromInputUnsafe(interval));\n return fromStepWithMetadata(effect.succeed(meta => effect.sync(() => [meta.attempt - 1, window === 0 ? Duration.zero : Duration.millis(window - meta.elapsed % window)])));\n};\n/**\n * Returns a new `Schedule` that will recur forever.\n *\n * **Details**\n *\n * The output of the schedule is the current count of its repetitions thus far\n * (i.e. `0, 1, 2, ...`).\n *\n * **Example** (Repeating forever)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule } from \"effect\"\n * import { TestClock } from \"effect/testing\"\n *\n * const executions: Array = []\n * const schedule = Schedule.forever.pipe(Schedule.upTo({ times: 2 }))\n * const program = Effect.sync(() => executions.push(executions.length + 1)).pipe(\n * Effect.repeat(schedule),\n * Effect.as(executions)\n * )\n *\n * await Effect.runPromise(Effect.provide(program, TestClock.layer())) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const forever = /*#__PURE__*/spaced(Duration.zero);\nconst constIdentity = /*#__PURE__*/fromStep(/*#__PURE__*/effect.succeed((_now, input) => effect.succeed([input, Duration.zero])));\nconst identity_ = () => constIdentity;\nexport {\n/**\n * Creates a schedule that always recurs, passing inputs directly as outputs.\n *\n * **When to use**\n *\n * Use when you need an infinite schedule that preserves input values as\n * outputs.\n *\n * **Details**\n *\n * This schedule runs indefinitely, returning each input value as its output\n * without modification. It effectively acts as a pass-through that simply\n * echoes its input values at each step.\n *\n * @see {@link forever} for an infinite schedule that returns incrementing step counts\n * @category constructors\n * @since 2.0.0\n */\nidentity_ as identity };\n/**\n * Sets the input type of the provided schedule without altering its behavior.\n *\n * **When to use**\n *\n * Use to adapt a schedule that does not depend on its input values.\n *\n * **Details**\n *\n * This helper is checked at compile time and does not change the schedule's\n * runtime behavior.\n *\n * **Example** (Setting a schedule input type)\n *\n * ```ts import.meta.vitest\n * import { Schedule } from \"effect\"\n *\n * const schedule = Schedule.recurs(3).pipe(\n * Schedule.setInputType()\n * )\n * Schedule.isSchedule(schedule) // => true\n * ```\n *\n * @category utility types\n * @since 4.0.0\n */\nexport const setInputType = () => self => self;\n//# sourceMappingURL=Schedule.js.map","import * as Context from \"../Context.js\";\nimport { dual } from \"../Function.js\";\nimport * as Layer from \"../Layer.js\";\nimport { isEffect } from \"./core.js\";\nimport * as effect from \"./effect.js\";\nconst provideLayer = (self, layer, options) => effect.scopedWith(scope => effect.flatMap(options?.local ? Layer.buildWithMemoMap(layer, Layer.makeMemoMapUnsafe(), scope) : Layer.buildWithScope(layer, scope), context => effect.provideContext(self, context)));\n/** @internal */\nexport const provide = /*#__PURE__*/dual(args => isEffect(args[0]), (self, source, options) => Context.isContext(source) ? effect.provideContext(self, source) : provideLayer(self, Array.isArray(source) ? Layer.mergeAll(...source) : source, options));\n//# sourceMappingURL=layer.js.map","import { constant, constTrue, dual, identity } from \"../Function.js\";\nimport * as Option from \"../Option.js\";\nimport * as Pull from \"../Pull.js\";\nimport * as Schedule from \"../Schedule.js\";\nimport { internalCall } from \"../Utils.js\";\nimport * as core from \"./core.js\";\nimport * as effect from \"./effect.js\";\n/** @internal */\nexport const repeatOrElse = /*#__PURE__*/dual(3, (self, schedule, orElse) => effect.flatMap(Schedule.toStepWithMetadata(schedule), step => {\n let meta = Schedule.CurrentMetadata.defaultValue();\n return effect.catch_(effect.forever(effect.tap(effect.flatMap(effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta)), step), meta_ => effect.sync(() => {\n meta = meta_;\n })), {\n disableYield: true\n }), error => core.isDone(error) ? effect.succeed(error.value) : orElse(error, meta.attempt === 0 ? Option.none() : Option.some(meta)));\n}));\n/** @internal */\nexport const retryOrElse = /*#__PURE__*/dual(3, (self, policy, orElse) => effect.flatMap(Schedule.toStepWithMetadata(policy), step => {\n let meta = Schedule.CurrentMetadata.defaultValue();\n let lastError;\n const loop = effect.catch_(effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta)), error => {\n lastError = error;\n return effect.flatMap(step(error), meta_ => {\n meta = meta_;\n return loop;\n });\n });\n return Pull.catchDone(loop, out => internalCall(() => orElse(lastError, out)));\n}));\n/** @internal */\nexport const repeat = /*#__PURE__*/dual(2, (self, options) => {\n const schedule = typeof options === \"function\" ? options(identity) : Schedule.isSchedule(options) ? options : buildFromOptions(options);\n return repeatOrElse(self, schedule, effect.fail);\n});\n/** @internal */\nexport const retry = /*#__PURE__*/dual(2, (self, options) => {\n const schedule = typeof options === \"function\" ? options(identity) : Schedule.isSchedule(options) ? options : buildFromOptions(options);\n return retryOrElse(self, schedule, effect.fail);\n});\n/** @internal */\nexport const scheduleFrom = /*#__PURE__*/dual(3, (self, initial, schedule) => effect.flatMap(Schedule.toStepWithMetadata(schedule), step => {\n let meta = Schedule.CurrentMetadata.defaultValue();\n const selfWithMeta = effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta));\n return effect.catch_(effect.flatMap(step(initial), meta_ => {\n meta = meta_;\n const body = constant(effect.flatMap(selfWithMeta, step));\n return effect.whileLoop({\n while: constTrue,\n body,\n step(meta_) {\n meta = meta_;\n }\n });\n }), error => core.isDone(error) ? effect.succeed(error.value) : effect.fail(error));\n}));\nconst passthroughForever = /*#__PURE__*/Schedule.passthrough(Schedule.forever);\n/** @internal */\nexport const buildFromOptions = options => {\n let schedule = options.schedule ? Schedule.passthrough(options.schedule) : passthroughForever;\n if (options.while) {\n schedule = Schedule.while(schedule, ({\n input\n }) => {\n const applied = options.while(input);\n return core.isEffect(applied) ? applied : effect.succeed(applied);\n });\n }\n if (options.until) {\n schedule = Schedule.while(schedule, ({\n input\n }) => {\n const applied = options.until(input);\n return core.isEffect(applied) ? effect.map(applied, b => !b) : effect.succeed(!applied);\n });\n }\n if (options.times !== undefined) {\n schedule = Schedule.while(schedule, ({\n attempt\n }) => effect.succeed(attempt <= options.times));\n }\n return schedule;\n};\n//# sourceMappingURL=schedule.js.map","import * as Context from \"./Context.js\";\nimport * as Duration from \"./Duration.js\";\nimport * as Exit from \"./Exit.js\";\nimport { constant, dual } from \"./Function.js\";\nimport * as core from \"./internal/core.js\";\nimport * as internal from \"./internal/effect.js\";\nimport * as internalExecutionPlan from \"./internal/executionPlan.js\";\nimport * as internalLayer from \"./internal/layer.js\";\nimport * as InternalRecord from \"./internal/record.js\";\nimport * as internalRequest from \"./internal/request.js\";\nimport * as internalSchedule from \"./internal/schedule.js\";\nimport * as Metric from \"./Metric.js\";\nimport { CurrentLogAnnotations, CurrentLogSpans } from \"./References.js\";\nimport { internalCall } from \"./Utils.js\";\n/**\n * Runtime identifier used to recognize `Effect` values.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = core.EffectTypeId;\n/**\n * Checks whether a value is an `Effect`.\n *\n * **Example** (Checking whether a value is an Effect)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * Effect.isEffect(Effect.succeed(1)) // => true\n * Effect.isEffect(\"hello\") // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isEffect = core.isEffect;\n/**\n * Combines an iterable or record of effects into one effect whose success shape\n * follows the input.\n *\n * **When to use**\n *\n * Use to run a known collection of effects and collect results in the same\n * tuple, iterable, or record shape.\n *\n * **Details**\n *\n * Tuple and iterable inputs collect results in order. Record inputs collect\n * results under the same keys. By default, the combined effect fails on the\n * first failure; with concurrent execution, effects that have already started\n * may be interrupted, while effects not yet started are skipped.\n *\n * Options:\n *\n * Use `concurrency` to control sequential or concurrent execution. Use\n * `mode: \"result\"` to run every effect and collect each success or failure as a\n * `Result` in the same output shape. Use `discard: true` to ignore successful\n * values and return `void`.\n *\n * **Example** (Collecting tuple results in order)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const tupleOfEffects = [\n * Effect.succeed(42),\n * Effect.succeed(\"Hello\")\n * ] as const\n *\n * // ┌─── Effect<[number, string], never, never>\n * // ▼\n * const resultsAsTuple = Effect.all(tupleOfEffects)\n *\n * await Effect.runPromise(resultsAsTuple) // => [42, \"Hello\"]\n * ```\n *\n * **Example** (Collecting iterable results in order)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const iterableOfEffects: Iterable> = [1, 2, 3].map(\n * Effect.succeed\n * )\n *\n * // ┌─── Effect\n * // ▼\n * const resultsAsArray = Effect.all(iterableOfEffects)\n *\n * await Effect.runPromise(resultsAsArray) // => [1, 2, 3]\n * ```\n *\n * **Example** (Collecting struct results by key)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const structOfEffects = {\n * a: Effect.succeed(42),\n * b: Effect.succeed(\"Hello\")\n * }\n *\n * // ┌─── Effect<{ a: number; b: string; }, never, never>\n * // ▼\n * const resultsAsStruct = Effect.all(structOfEffects)\n *\n * await Effect.runPromise(resultsAsStruct) // => { a: 42, b: \"Hello\" }\n * ```\n *\n * **Example** (Collecting record results by key)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const recordOfEffects: Record> = {\n * key1: Effect.succeed(1),\n * key2: Effect.succeed(2)\n * }\n *\n * // ┌─── Effect<{ [x: string]: number; }, never, never>\n * // ▼\n * const resultsAsRecord = Effect.all(recordOfEffects)\n *\n * await Effect.runPromise(resultsAsRecord) // => { key1: 1, key2: 2 }\n * ```\n *\n * **Example** (Stopping on the first failure)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n * const output: Array = []\n * const record = (value: unknown) => Effect.sync(() => { output.push(value) })\n *\n * const program = Effect.all([\n * Effect.succeed(\"Task1\").pipe(Effect.tap(record)),\n * Effect.fail(\"Task2: Oh no!\").pipe(Effect.tap(record)),\n * // Won't execute due to earlier failure\n * Effect.succeed(\"Task3\").pipe(Effect.tap(record))\n * ])\n *\n * const outcome = await Effect.runPromiseExit(program)\n * const observation = [output, outcome] // => [[\"Task1\"], Exit.fail(\"Task2: Oh no!\")]\n * ```\n *\n * @see {@link forEach} for iterating over elements and applying an effect.\n * @category combining\n * @since 2.0.0\n */\nexport const all = internal.all;\n/**\n * Applies an effectful function to each element and partitions failures and\n * successes.\n *\n * **Details**\n *\n * The returned tuple is `[excluded, satisfying]`, where `excluded` contains\n * all failures and `satisfying` contains all successes.\n *\n * This function runs every effect and never fails. Use `concurrency` to control\n * parallelism.\n *\n * **Example** (Separating successes and failures)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.partition([0, 1, 2, 3], (n) =>\n * n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)\n * )\n *\n * await Effect.runPromise(program) // => [['0 is even', '2 is even'], [1, 3]]\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const partition = internal.partition;\n/**\n * Reduces elements from left to right with an effectful accumulator function.\n *\n * **When to use**\n *\n * Use when each accumulation step is effectful and must run sequentially in\n * iteration order.\n *\n * **Details**\n *\n * The accumulator function receives the current accumulator, the current\n * element, and its zero-based index. The `zero` function is evaluated each\n * time the effect runs. An empty iterable succeeds with its result. If a step\n * fails, remaining elements are not processed.\n *\n * **Example** (Summing values sequentially)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.reduce(\n * [1, 2, 3],\n * () => 0,\n * (total, value, index) =>\n * Effect.sync(() => { output.push(`Adding ${value} at index ${index}`) }).pipe(\n * Effect.as(total + value)\n * )\n * )\n *\n * void output.push(await Effect.runPromise(program))\n * output // => [\"Adding 1 at index 0\", \"Adding 2 at index 1\", \"Adding 3 at index 2\", 6]\n * ```\n *\n * @category folding\n * @since 2.0.0\n */\nexport const reduce = internal.reduce;\n/**\n * Applies an effectful function to each element and accumulates all failures.\n *\n * **Details**\n *\n * This function always evaluates every element. If at least one effect fails,\n * all failures are returned as a non-empty array and successes are discarded.\n * If all effects succeed, it returns all collected successes.\n *\n * Use `discard: true` to ignore successful values while still validating all\n * elements.\n *\n * **Example** (Validating every element)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n *\n * const program = Effect.validate([0, 1, 2, 3], (n) =>\n * n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)\n * )\n *\n * await Effect.runPromiseExit(program) // => Exit.fail([\"0 is even\", \"2 is even\"])\n * ```\n *\n * @category validation\n * @since 2.0.0\n */\nexport const validate = internal.validate;\n/**\n * Returns the first element that satisfies an effectful predicate.\n *\n * **Details**\n *\n * The predicate receives the element and its index. Evaluation short-circuits\n * as soon as an element matches.\n *\n * **Example** (Finding the first successful match)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const program = Effect.findFirst([1, 2, 3, 4], (n) => Effect.succeed(n > 2))\n *\n * await Effect.runPromise(program) // => Option.some(3)\n * ```\n *\n * @category searching\n * @since 2.0.0\n */\nexport const findFirst = internal.findFirst;\n/**\n * Returns the first value that passes an effectful `FilterEffect`.\n *\n * **When to use**\n *\n * Use when you need to find the first element that satisfies an effectful\n * filter returning a `Result`, which also transforms the matching element.\n *\n * **Details**\n *\n * The filter receives the element and index. Evaluation short-circuits on the\n * first `Result.succeed` and returns the transformed value in `Option.some`.\n *\n * @see {@link findFirst} for the simpler effectful predicate-based variant\n *\n * @category searching\n * @since 4.0.0\n */\nexport const findFirstFilter = internal.findFirstFilter;\n/**\n * Executes an effectful operation for each element in an `Iterable`.\n *\n * **When to use**\n *\n * Use to traverse an iterable with an effectful function while preserving\n * element order in the collected results.\n *\n * **Details**\n *\n * The `forEach` function applies a provided operation to each element in the\n * iterable, producing a new effect that returns an array of results.\n *\n * If any effect fails, the iteration stops immediately (short-circuiting), and\n * the error is propagated.\n *\n * Concurrency:\n *\n * The `concurrency` option controls how many operations are performed\n * concurrently. By default, the operations are performed sequentially.\n *\n * Discarding Results:\n *\n * If the `discard` option is set to `true`, the intermediate results are not\n * collected, and the final result of the operation is `void`.\n *\n * **Example** (Mapping over an iterable with effects)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const result = Effect.forEach(\n * [1, 2, 3, 4, 5],\n * (n, index) =>\n * Effect.sync(() => { output.push(`Currently at index ${index}`) }).pipe(Effect.as(n * 2))\n * )\n *\n * void output.push(await Effect.runPromise(result))\n * output // => [\"Currently at index 0\", \"Currently at index 1\", \"Currently at index 2\", \"Currently at index 3\", \"Currently at index 4\", [2, 4, 6, 8, 10]]\n * ```\n *\n * **Example** (Running effects without collecting results)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * // Apply effects but discard the results\n * const result = Effect.forEach(\n * [1, 2, 3, 4, 5],\n * (n, index) =>\n * Effect.sync(() => { output.push(`Currently at index ${index}`) }).pipe(Effect.as(n * 2)),\n * { discard: true }\n * )\n *\n * void output.push(await Effect.runPromise(result))\n * output // => [\"Currently at index 0\", \"Currently at index 1\", \"Currently at index 2\", \"Currently at index 3\", \"Currently at index 4\", undefined]\n * ```\n *\n * @see {@link all} for combining multiple effects into one.\n * @category sequencing\n * @since 2.0.0\n */\nexport const forEach = internal.forEach;\n/**\n * Returns the first element of the iterable produced by an effect, or fails\n * with `NoSuchElementError` if the iterable is empty.\n *\n * **When to use**\n *\n * Use when an effect produces a collection that must contain at least one\n * element and absence should be represented in the typed error channel.\n *\n * **Example** (Getting the first element)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const first = await Effect.runPromise(Effect.head(Effect.succeed([1, 2, 3])))\n * first // => 1\n *\n * const empty = Effect.head(Effect.succeed([] as Array)).pipe(Effect.catchNoSuchElement)\n * await Effect.runPromise(empty) // => Option.none()\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const head = internal.head;\n/**\n * Executes a body effect repeatedly while a condition holds true.\n *\n * **Example** (Repeating an effectful loop)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * let counter = 0\n *\n * const program = Effect.whileLoop({\n * while: () => counter < 5,\n * body: () => Effect.sync(() => ++counter),\n * step: (n) => void output.push(`Current count: ${n}`)\n * })\n *\n * await Effect.runPromise(program)\n * output // => [\"Current count: 1\", \"Current count: 2\", \"Current count: 3\", \"Current count: 4\", \"Current count: 5\"]\n * ```\n *\n * @category repetition\n * @since 2.0.0\n */\nexport const whileLoop = internal.whileLoop;\n// -----------------------------------------------------------------------------\n// Creating Effects\n// -----------------------------------------------------------------------------\n/**\n * Creates an `Effect` that represents an asynchronous computation guaranteed to\n * succeed.\n *\n * **When to use**\n *\n * Use to convert a `Promise` into an `Effect` when the async operation is\n * guaranteed to succeed and will not reject.\n *\n * **Details**\n *\n * An optional `AbortSignal` can be provided to allow for interruption of the\n * wrapped `Promise` API.\n *\n * **Gotchas**\n *\n * The `Promise` must not reject. If it rejects, the rejection is treated as a\n * defect, not as a typed failure. Use `tryPromise` when rejection is expected.\n *\n * Interruption aborts the provided `AbortSignal`, but the underlying\n * asynchronous operation only stops if it observes that signal.\n *\n * **Example** (Wrapping a non-rejecting Promise)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const succeedAsync = (message: string) =>\n * Effect.promise(() => Promise.resolve(message))\n *\n * // ┌─── Effect\n * // ▼\n * const program = succeedAsync(\"Async operation completed successfully!\")\n * await Effect.runPromise(program) // => \"Async operation completed successfully!\"\n * ```\n *\n * @see {@link tryPromise} for a version that can handle failures.\n * @category constructors\n * @since 2.0.0\n */\nexport const promise = internal.promise;\n/**\n * Creates an `Effect` from an asynchronous computation that may throw or\n * reject, mapping failures into the error channel.\n *\n * **When to use**\n *\n * Use when you need to perform asynchronous operations that might fail, such\n * as fetching data from an API, and want thrown exceptions or rejected promises\n * captured as Effect errors.\n *\n * **Details**\n *\n * The promise thunk is evaluated when the effect runs. If it returns a promise\n * that resolves, the resolved value becomes the success value. If the thunk\n * throws before returning a promise, or if the returned promise rejects, the\n * thrown or rejected value is mapped into the error channel.\n *\n * Passing the thunk directly maps failures to {@link Cause.UnknownError}.\n * Passing `{ try, catch }` uses `catch` to map failures to an error of type\n * `E`.\n *\n * The thunk receives an `AbortSignal` that is aborted if the effect is\n * interrupted. The underlying asynchronous operation only stops if it observes\n * that signal.\n *\n * **Gotchas**\n *\n * If `catch` throws while mapping the error, that thrown value is treated as a\n * defect. Return the error value you want in the error channel instead of\n * throwing it.\n *\n * **Example** (Wrapping a fetch request that may fail)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const getTodo = (id: number) =>\n * Effect.tryPromise(() => Promise.resolve({ id, completed: false }))\n *\n * // ┌─── Effect<{ id: number; completed: boolean }, UnknownError, never>\n * // ▼\n * const program = getTodo(1)\n * await Effect.runPromise(program) // => { id: 1, completed: false }\n * ```\n *\n * **Example** (Mapping Promise rejections to a tagged error)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class TodoFetchError extends Data.TaggedError(\"TodoFetchError\")<{ readonly cause: unknown }> {}\n *\n * const getTodo = (id: number) =>\n * Effect.tryPromise({\n * try: () => Promise.reject(`Todo ${id} is unavailable`),\n * // remap the error\n * catch: (cause) => new TodoFetchError({ cause })\n * })\n *\n * // ┌─── Effect\n * // ▼\n * const program = Effect.flip(getTodo(1))\n * const error = await Effect.runPromise(program)\n * error._tag // => \"TodoFetchError\"\n * ```\n *\n * @see {@link promise} if the effectful computation is asynchronous and does not throw errors.\n * @category constructors\n * @since 2.0.0\n */\nexport const tryPromise = internal.tryPromise;\n/**\n * Creates an `Effect` that always succeeds with a given value.\n *\n * **When to use**\n *\n * Use when an effect should complete successfully with a specific value without any errors\n * or external dependencies.\n *\n * **Example** (Creating a successful effect)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // Creating an effect that represents a successful scenario\n * //\n * // ┌─── Effect\n * // ▼\n * const success = Effect.succeed(42)\n * Effect.runSync(success) // => 42\n * ```\n *\n * @see {@link fail} to create an effect that represents a failure.\n * @category constructors\n * @since 2.0.0\n */\nexport const succeed = internal.succeed;\n/**\n * Returns an effect which succeeds with `None`.\n *\n * **Example** (Succeeding with Option.none)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const program = Effect.succeedNone\n *\n * Effect.runSync(program) // => Option.none()\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const succeedNone = internal.succeedNone;\n/**\n * Returns an effect which succeeds with the value wrapped in a `Some`.\n *\n * **Example** (Succeeding with Option.some)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const program = Effect.succeedSome(42)\n *\n * Effect.runSync(program) // => Option.some(42)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const succeedSome = internal.succeedSome;\n/**\n * Creates an `Effect` lazily, delaying construction until it is needed.\n *\n * **When to use**\n *\n * Use when you need to defer the evaluation of an effect until it is required.\n *\n * **Details**\n *\n * `suspend` takes a thunk that represents an effect and delays creating it\n * until the suspended effect is evaluated. This is useful for optimizing\n * expensive computations, managing circular dependencies such as recursive\n * functions, and helping TypeScript unify return types when branches construct\n * different effects. Any side effects or scoped captures inside the thunk are\n * re-executed on each invocation.\n *\n * **Example** (Lazily evaluating side effects)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * let i = 0\n *\n * const bad = Effect.succeed(i++)\n *\n * const good = Effect.suspend(() => Effect.succeed(i++))\n *\n * Effect.runSync(bad) // => 0\n * Effect.runSync(bad) // => 0\n *\n * Effect.runSync(good) // => 1\n * Effect.runSync(good) // => 2\n * ```\n *\n * **Example** (Suspending recursive Fibonacci evaluation)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const blowsUp = (n: number): Effect.Effect =>\n * n < 2\n * ? Effect.succeed(1)\n * : Effect.zipWith(blowsUp(n - 1), blowsUp(n - 2), (a, b) => a + b)\n *\n * // console.log(Effect.runSync(blowsUp(32)))\n * // crash: JavaScript heap out of memory\n *\n * const allGood = (n: number): Effect.Effect =>\n * n < 2\n * ? Effect.succeed(1)\n * : Effect.zipWith(\n * Effect.suspend(() => allGood(n - 1)),\n * Effect.suspend(() => allGood(n - 2)),\n * (a, b) => a + b\n * )\n *\n * Effect.runSync(allGood(16)) // => 1597\n * ```\n *\n * **Example** (Helping TypeScript infer recursive effect types)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // Without suspend, TypeScript may struggle with type inference.\n * // Inferred type:\n * // (a: number, b: number) =>\n * // Effect | Effect\n * const withoutSuspend = (a: number, b: number) =>\n * b === 0\n * ? Effect.fail(new Error(\"Cannot divide by zero\"))\n * : Effect.succeed(a / b)\n *\n * // Using suspend to unify return types.\n * // Inferred type:\n * // (a: number, b: number) => Effect\n * const withSuspend = (a: number, b: number) =>\n * Effect.suspend(() =>\n * b === 0\n * ? Effect.fail(new Error(\"Cannot divide by zero\"))\n * : Effect.succeed(a / b)\n * )\n *\n * Effect.runSync(withSuspend(6, 2)) // => 3\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const suspend = internal.suspend;\n/**\n * Creates an `Effect` that represents a synchronous side-effectful computation.\n *\n * **When to use**\n *\n * Use when you need to wrap a synchronous side-effectful operation that is not\n * expected to throw.\n *\n * **Details**\n *\n * The provided function is evaluated lazily when the effect runs.\n *\n * **Gotchas**\n *\n * The function must not throw. If it throws, the thrown value is treated as a\n * defect, not as a typed failure. Use `try` when throwing is expected.\n *\n * **Example** (Capturing synchronous logging in an Effect)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const log = (message: string) =>\n * Effect.sync(() => {\n * void output.push(message) // side effect\n * })\n *\n * // ┌─── Effect\n * // ▼\n * const program = log(\"Hello, World!\")\n * Effect.runSync(program)\n * output // => [\"Hello, World!\"]\n * ```\n *\n * @see {@link try_ | try} for a version that can handle failures.\n * @category constructors\n * @since 2.0.0\n */\nexport const sync = internal.sync;\nconst void_ = internal.void;\nexport {\n/**\n * Returns an effect that succeeds with `void`.\n *\n * @category constructors\n * @since 2.0.0\n */\nvoid_ as void };\nconst undefined_ = internal.undefined;\nexport {\n/**\n * Returns an effect that succeeds with `undefined`.\n *\n * @category constructors\n * @since 4.0.0\n */\nundefined_ as undefined };\n/**\n * Creates an `Effect` from a callback-based asynchronous API.\n *\n * **When to use**\n *\n * Use when you need to integrate APIs that complete through callbacks instead\n * of returning a `Promise`.\n *\n * **Details**\n *\n * The registration function receives a `resume` callback and, when requested,\n * an `AbortSignal`. Call `resume` at most once with the effect that should\n * complete the fiber; later calls are ignored. Return an optional cleanup\n * effect from the registration function to run if the fiber is interrupted.\n *\n * **Example** (Integrating callback APIs)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const fromCallback = (message: string) =>\n * Effect.callback((resume) => {\n * queueMicrotask(() => {\n * void output.push(message)\n * resume(Effect.void)\n * })\n * })\n *\n * await Effect.runPromise(fromCallback(\"callback completed\"))\n * output // => [\"callback completed\"]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const callback = internal.callback;\n/**\n * Returns an effect that will never produce anything. The moral equivalent of\n * `while(true) {}`, only without the wasted CPU cycles.\n *\n * **Example** (Creating a never-ending effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const program = Effect.timeoutOption(Effect.never, 0)\n * await Effect.runPromise(program) // => Option.none()\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const never = internal.never;\n/**\n * Effect that succeeds with an empty record `{}`, used as the starting point\n * for do notation chains.\n *\n * **Example** (Starting do notation)\n *\n * ```ts import.meta.vitest\n * import { Effect, pipe } from \"effect\"\n *\n * const program = pipe(\n * Effect.Do,\n * Effect.bind(\"x\", () => Effect.succeed(2)),\n * Effect.bind(\"y\", ({ x }) => Effect.succeed(x + 1)),\n * Effect.let(\"sum\", ({ x, y }) => x + y)\n * )\n *\n * Effect.runSync(program) // => { x: 2, y: 3, sum: 5 }\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const Do = internal.Do;\n/**\n * Gives a name to the success value of an `Effect`, creating a single-key\n * record used in do notation pipelines.\n *\n * **When to use**\n *\n * Use to start a do-notation pipeline from an existing `Effect` when its\n * success value should become the first named field in the accumulated record.\n *\n * @see {@link Do} for starting from an empty accumulated record\n * @see {@link bind} for adding fields produced by effects\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const bindTo = internal.bindTo;\nconst let_ = internal.let;\nexport {\n/**\n * Adds a computed plain value to the do notation record.\n *\n * **When to use**\n *\n * Use to add a derived, synchronous value to a do-notation pipeline when it\n * depends on fields already accumulated in the record and does not need to run\n * another `Effect`.\n *\n * **Details**\n *\n * The new field is added with object spreading. If the name already exists in\n * the record, the computed value replaces it in the returned type.\n *\n * @see {@link bind} for adding fields produced by effects\n * @see {@link bindTo} for naming an existing success value\n * @see {@link Do} for starting from an empty accumulated record\n * @see {@link gen} for sequencing without accumulating a record\n *\n * @category mapping\n * @since 2.0.0\n */\nlet_ as let };\n/**\n * Adds an `Effect` value to the do notation record under a given name.\n *\n * **When to use**\n *\n * Use to sequence an effectful step in a do-notation pipeline when that step\n * depends on fields already accumulated in the record and its success value\n * should be stored under a name.\n *\n * **Details**\n *\n * The function receives the current record, runs the returned effect after the\n * input effect succeeds, and inserts its success value under `name`. The\n * resulting effect combines the error and service requirements of both steps.\n *\n * **Gotchas**\n *\n * Binding a name that already exists replaces that field in the resulting\n * record.\n *\n * @see {@link Do} for starting from an empty do-notation record\n * @see {@link bindTo} for naming the success value of an existing effect\n * @see {@link gen} for generator-based sequencing without accumulating a record\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const bind = internal.bind;\n/**\n * Provides a way to write effectful code using generator functions, simplifying\n * control flow and error handling.\n *\n * **When to use**\n *\n * Use when you want to write effectful code that looks and behaves like\n * synchronous code, while still handling asynchronous tasks, errors, and complex\n * control flow such as loops and conditions.\n *\n * Generator functions work similarly to `async/await` but keep errors,\n * requirements, and interruption in the Effect type. You can `yield*` values\n * from effects and return the final result at the end.\n *\n * **Example** (Sequencing effects with generators)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class DiscountRateError extends Data.TaggedError(\"DiscountRateError\")<{}> {}\n *\n * const addServiceCharge = (amount: number) => amount + 1\n *\n * const applyDiscount = (\n * total: number,\n * discountRate: number\n * ): Effect.Effect =>\n * discountRate === 0\n * ? Effect.fail(new DiscountRateError())\n * : Effect.succeed(total - (total * discountRate) / 100)\n *\n * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))\n *\n * const fetchDiscountRate = Effect.promise(() => Promise.resolve(5))\n *\n * export const program = Effect.gen(function*() {\n * const transactionAmount = yield* fetchTransactionAmount\n * const discountRate = yield* fetchDiscountRate\n * const discountedAmount = yield* applyDiscount(\n * transactionAmount,\n * discountRate\n * )\n * const finalAmount = addServiceCharge(discountedAmount)\n * return `Final amount to charge: ${finalAmount}`\n * })\n *\n * await Effect.runPromise(program) // => \"Final amount to charge: 96\"\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const gen = internal.gen;\n/**\n * Creates an `Effect` that represents a recoverable error.\n *\n * **When to use**\n *\n * Use to explicitly signal a recoverable error in an `Effect`.\n *\n * **Details**\n *\n * The error keeps propagating unless it is handled. You can handle tagged\n * errors with functions like {@link catchTag} or {@link catchTags}.\n *\n * **Example** (Creating a failed effect)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class OperationFailedError extends Data.TaggedError(\"OperationFailedError\")<{}> {}\n *\n * // ┌─── Effect\n * // ▼\n * const failure = Effect.fail(\n * new OperationFailedError()\n * )\n * Effect.runSync(Effect.flip(failure))._tag // => \"OperationFailedError\"\n * ```\n *\n * @see {@link succeed} to create an effect that represents a successful value.\n * @category constructors\n * @since 2.0.0\n */\nexport const fail = internal.fail;\n/**\n * Creates an `Effect` that represents a recoverable error using a lazy evaluation.\n *\n * **When to use**\n *\n * Use to defer computing a recoverable error value until the effect is run.\n *\n * **Details**\n *\n * The error-producing function is evaluated each time the effect is executed.\n *\n * **Example** (Lazily creating failures)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class ProgramError extends Data.TaggedError(\"ProgramError\")<{ readonly operation: string }> {}\n *\n * const program = Effect.failSync(() => new ProgramError({ operation: \"sync\" }))\n *\n * Effect.runSync(Effect.flip(program)).operation // => \"sync\"\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failSync = internal.failSync;\n/**\n * Creates an `Effect` that represents a failure with a specific `Cause`.\n *\n * **When to use**\n *\n * Use when you already have a full `Cause` and need to preserve defects,\n * interruptions, annotations, or combined failures in the effect's failure\n * channel.\n *\n * **Details**\n *\n * This function allows you to create effects that fail with complex error\n * structures, including multiple errors, defects, interruptions, and more.\n *\n * **Example** (Failing with a full Cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect } from \"effect\"\n *\n * const program = Effect.failCause(\n * Cause.fail(\"Network error\")\n * )\n *\n * Effect.runSync(Effect.flip(program)) // => \"Network error\"\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failCause = internal.failCause;\n/**\n * Creates an `Effect` that represents a failure with a `Cause` computed lazily.\n *\n * **When to use**\n *\n * Use to defer computing a full `Cause` until the effect is run.\n *\n * **Details**\n *\n * The cause-producing function is evaluated each time the effect is executed.\n *\n * **Example** (Lazily creating a Cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect } from \"effect\"\n *\n * const program = Effect.failCauseSync(() =>\n * Cause.fail(\"Error computed at runtime\")\n * )\n *\n * Effect.runSync(Effect.flip(program)) // => \"Error computed at runtime\"\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failCauseSync = internal.failCauseSync;\n/**\n * Creates an effect that terminates a fiber with a specified error.\n *\n * **When to use**\n *\n * Use when you need an `Effect` to report an unrecoverable defect instead of a\n * typed error.\n *\n * **Details**\n *\n * The `die` function is used to signal a defect, which represents a critical\n * and unexpected error in the code. When invoked, it produces an effect that\n * does not handle the error and instead terminates the fiber.\n *\n * The error channel of the resulting effect is of type `never`, indicating that\n * it cannot recover from this failure.\n *\n * **Example** (Failing on division by zero)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n *\n * const defect = new Error(\"Cannot divide by zero\")\n * const divide = (a: number, b: number) =>\n * b === 0\n * ? Effect.die(defect)\n * : Effect.succeed(a / b)\n *\n * // ┌─── Effect\n * // ▼\n * const program = divide(1, 0)\n *\n * Effect.runSyncExit(program) // => Exit.die(defect)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const die = internal.die;\nconst try_ = internal.try;\nexport {\n/**\n * Creates an `Effect` from a synchronous computation that may throw, mapping\n * thrown values into the error channel.\n *\n * **When to use**\n *\n * Use when you need to perform synchronous operations that might throw, such\n * as parsing JSON, and want thrown exceptions captured as Effect errors.\n *\n * **Details**\n *\n * The thunk is evaluated when the effect runs. If it returns normally, the\n * returned value becomes the success value. If it throws, the thrown value is\n * mapped into the error channel.\n *\n * Passing the thunk directly maps failures to {@link Cause.UnknownError}.\n * Passing `{ try, catch }` uses `catch` to map failures to an error of type\n * `E`.\n *\n * **Gotchas**\n *\n * If `catch` throws while mapping the error, that thrown value is treated as\n * a defect. Return the error value you want in the error channel instead of\n * throwing it.\n *\n * **Example** (Parsing JSON)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const parseJSON = (input: string) =>\n * Effect.try(() => JSON.parse(input))\n *\n * // Success case\n * await Effect.runPromise(parseJSON(\"{\\\"name\\\": \\\"Alice\\\"}\")) // => { name: 'Alice' }\n *\n * // Failure case maps the thrown value to UnknownError\n * const exit = await Effect.runPromiseExit(parseJSON(\"invalid json\"))\n * exit._tag // => \"Failure\"\n * ```\n *\n * **Example** (Mapping exceptions to a tagged error)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class JsonParsingError extends Data.TaggedError(\"JsonParsingError\")<{ readonly cause: unknown }> {}\n *\n * const parseJSON = (input: string) =>\n * Effect.try({\n * try: () => JSON.parse(input),\n * catch: (cause) => new JsonParsingError({ cause })\n * })\n *\n * const error = await Effect.runPromise(Effect.flip(parseJSON(\"invalid json\")))\n * error._tag // => \"JsonParsingError\"\n * ```\n *\n * @see {@link sync} if the effectful computation is synchronous and does not\n * throw errors.\n * @category constructors\n * @since 2.0.0\n */\ntry_ as try };\n/**\n * Yields control back to the Effect runtime, allowing other fibers to execute.\n *\n * **Example** (Yielding to other fibers)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * void output.push(\"Before yield\")\n * yield* Effect.yieldNow\n * void output.push(\"After yield\")\n * })\n *\n * await Effect.runPromise(program)\n * output // => [\"Before yield\", \"After yield\"]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const yieldNow = internal.yieldNow;\n/**\n * Yields control back to the Effect runtime with a specified priority, allowing other fibers to execute.\n *\n * **Example** (Yielding with priority)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * void output.push(\"High priority task\")\n * yield* Effect.yieldNowWith(10) // Higher priority\n * void output.push(\"Continued after yield\")\n * })\n *\n * await Effect.runPromise(program)\n * output // => [\"High priority task\", \"Continued after yield\"]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const yieldNowWith = internal.yieldNowWith;\n/**\n * Provides access to the current fiber within an effect computation.\n *\n * **Example** (Reading the current fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.withFiber((fiber) => Effect.succeed(typeof fiber.id))\n *\n * Effect.runSync(program) // => \"number\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const withFiber = core.withFiber;\n/**\n * Accesses the current fiber to compute a successful value.\n *\n * **Example** (Computing a value from the current fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.withFiberSucceed((fiber) => typeof fiber.id)\n *\n * Effect.runSync(program) // => \"number\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const withFiberSucceed = core.withFiberSucceed;\n// -----------------------------------------------------------------------------\n// Conversions\n// -----------------------------------------------------------------------------\n/**\n * Converts a `Result` to an `Effect`.\n *\n * **Example** (Converting a Result into an Effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Result } from \"effect\"\n * const output: Array = []\n *\n * const success = Result.succeed(42)\n * const failure = Result.fail(\"Something went wrong\")\n *\n * const effect1 = Effect.fromResult(success)\n * const effect2 = Effect.fromResult(failure)\n *\n * void output.push(Effect.runSync(effect1))\n * void output.push(Effect.runSync(Effect.flip(effect2)))\n * output // => [42, \"Something went wrong\"]\n * ```\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromResult = internal.fromResult;\n/**\n * Converts an `Option` into an `Effect`.\n *\n * **When to use**\n *\n * Use when absence should become a typed `NoSuchElementError` in the effect error\n * channel.\n *\n * **Details**\n *\n * `Option.some` becomes a successful effect with the contained value, while\n * `Option.none` becomes a failed effect. By default the failure is a\n * `NoSuchElementError`, but you can provide an `onNone` callback to customize\n * the error value.\n *\n * **Example** (Converting an Option into an Effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n * const output: Array = []\n *\n * const some = Option.some(42)\n * const none = Option.none()\n *\n * const effect1 = Effect.fromOption(some)\n * const effect2 = Effect.fromOption(none)\n * const effect3 = Effect.fromOption(none, () => new Error(\"missing\"))\n *\n * void output.push(Effect.runSync(effect1))\n * void output.push(Effect.runSync(Effect.flip(effect2))._tag)\n * void output.push(Effect.runSync(Effect.flip(effect3)).message)\n * output // => [42, \"NoSuchElementError\", \"missing\"]\n * ```\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromOption = internal.fromOption;\n/**\n * Converts an `Option` of an `Effect` into an `Effect` of an `Option`.\n *\n * **When to use**\n *\n * Use when an effect should run only when an optional value is present, while\n * preserving absence as a successful `None`.\n *\n * **Details**\n *\n * - `None` becomes an effect that succeeds with `None`\n * - `Some(effect)` runs the inner effect and wraps its success value in `Some`\n * - Inner failures are preserved in the resulting effect\n *\n * **Example** (Transposing an Option of an Effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const some = Option.some(Effect.succeed(42))\n *\n * // ┌─── Effect, never, never>\n * // ▼\n * const program = Effect.transposeOption(some)\n *\n * Effect.runSync(program) // => Option.some(42)\n * ```\n *\n * @category converting\n * @since 3.13.0\n */\nexport const transposeOption = internal.transposeOption;\n/**\n * Converts a nullable value to an `Effect`, failing with a `NoSuchElementError`\n * when the value is `null` or `undefined`.\n *\n * **Example** (Failing on nullish values)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.fn(function*(input: string | null) {\n * const value = yield* Effect.fromNullishOr(input)\n * yield* Effect.sync(() => { output.push(value) })\n * },\n * Effect.catch(() => Effect.sync(() => { output.push(\"missing\") }))\n * )\n *\n * await Effect.runPromise(program(null))\n * await Effect.runPromise(program(\"hello\"))\n * output // => [\"missing\", \"hello\"]\n * ```\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromNullishOr = internal.fromNullishOr;\n// -----------------------------------------------------------------------------\n// Mapping\n// -----------------------------------------------------------------------------\n/**\n * Chains effects to produce new `Effect` instances, useful for combining\n * operations that depend on previous results.\n *\n * **When to use**\n *\n * Use when you need to chain multiple effects, ensuring that each\n * step produces a new `Effect` while flattening any nested effects that may\n * occur.\n *\n * **Details**\n *\n * `flatMap` lets you sequence effects so that the result of one effect can be\n * used in the next step. It is similar to `flatMap` used with arrays but works\n * specifically with `Effect` instances, allowing you to avoid deeply nested\n * effect structures.\n *\n * Since effects are immutable, `flatMap` always returns a new effect instead of\n * changing the original one.\n *\n * **Example** (Choosing flatMap syntax variants)\n *\n * ```ts import.meta.vitest\n * import { Effect, pipe } from \"effect\"\n * const output: Array = []\n *\n * const myEffect = Effect.succeed(1)\n * const transformation = (n: number) => Effect.succeed(n + 1)\n *\n * const flatMappedWithPipe = pipe(myEffect, Effect.flatMap(transformation))\n * const flatMappedWithDataFirst = Effect.flatMap(myEffect, transformation)\n * const flatMappedWithMethod = myEffect.pipe(Effect.flatMap(transformation))\n *\n * void output.push(Effect.runSync(Effect.all([\n * flatMappedWithPipe,\n * flatMappedWithDataFirst,\n * flatMappedWithMethod\n * ])))\n * output // => [[2, 2, 2]]\n * ```\n *\n * **Example** (Sequencing dependent effects)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, pipe } from \"effect\"\n *\n * class DiscountRateError extends Data.TaggedError(\"DiscountRateError\")<{}> {}\n *\n * // Function to apply a discount safely to a transaction amount\n * const applyDiscount = (\n * total: number,\n * discountRate: number\n * ): Effect.Effect =>\n * discountRate === 0\n * ? Effect.fail(new DiscountRateError())\n * : Effect.succeed(total - (total * discountRate) / 100)\n *\n * // Simulated asynchronous task to fetch a transaction amount from database\n * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))\n *\n * // Chaining the fetch and discount application using `flatMap`\n * const finalAmount = pipe(\n * fetchTransactionAmount,\n * Effect.flatMap((amount) => applyDiscount(amount, 5))\n * )\n *\n * await Effect.runPromise(finalAmount) // => 95\n * ```\n *\n * @see {@link tap} for a version that ignores the result of the effect.\n * @category sequencing\n * @since 2.0.0\n */\nexport const flatMap = internal.flatMap;\n/**\n * Flattens an `Effect` that produces another `Effect` into a single effect.\n *\n * **Example** (Flattening nested effects)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const nested = Effect.succeed(Effect.succeed(\"hello\"))\n *\n * const program = Effect.gen(function*() {\n * const value = yield* Effect.flatten(nested)\n * yield* Effect.sync(() => { output.push(value) })\n * })\n *\n * Effect.runSync(program)\n * output // => [\"hello\"]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const flatten = internal.flatten;\n/**\n * Runs this effect and then runs another effect, optionally using the first\n * effect's success value to choose the next effect.\n *\n * **When to use**\n *\n * Use when you need one effect to run after another and the second effect may\n * depend on the first effect's success value.\n *\n * **Details**\n *\n * When the second argument is an `Effect`, the first success value is discarded\n * and the returned effect produces the second effect's value. When the second\n * argument is a function, it receives the first success value and must return\n * the next `Effect`.\n *\n * Failures or requirements from either effect are preserved in the returned\n * effect.\n *\n * **Example** (Choosing andThen syntax variants)\n *\n * ```ts import.meta.vitest\n * import { Effect, pipe } from \"effect\"\n * const output: Array = []\n *\n * const myEffect = Effect.succeed(1)\n * const anotherEffect = Effect.succeed(\"done\")\n *\n * const transformedWithPipe = pipe(myEffect, Effect.andThen(anotherEffect))\n * const transformedWithDataFirst = Effect.andThen(myEffect, anotherEffect)\n * const transformedWithMethod = myEffect.pipe(Effect.andThen(anotherEffect))\n *\n * void output.push(Effect.runSync(Effect.all([\n * transformedWithPipe,\n * transformedWithDataFirst,\n * transformedWithMethod\n * ])))\n * output // => [['done', 'done', 'done']]\n * ```\n *\n * **Example** (Sequencing a discount calculation after fetching a total)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, pipe } from \"effect\"\n *\n * class DiscountRateError extends Data.TaggedError(\"DiscountRateError\")<{}> {}\n *\n * // Function to apply a discount safely to a transaction amount\n * const applyDiscount = (\n * total: number,\n * discountRate: number\n * ): Effect.Effect =>\n * discountRate === 0\n * ? Effect.fail(new DiscountRateError())\n * : Effect.succeed(total - (total * discountRate) / 100)\n *\n * // Simulated asynchronous task to fetch a transaction amount from database\n * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))\n *\n * // Using Effect.map and Effect.flatMap\n * const result1 = pipe(\n * fetchTransactionAmount,\n * Effect.map((amount) => amount * 2),\n * Effect.flatMap((amount) => applyDiscount(amount, 5))\n * )\n *\n * await Effect.runPromise(result1) // => 190\n *\n * // Using Effect.andThen\n * const result2 = pipe(\n * fetchTransactionAmount,\n * Effect.andThen((amount) => Effect.succeed(amount * 2)),\n * Effect.andThen((amount) => applyDiscount(amount, 5))\n * )\n *\n * await Effect.runPromise(result2) // => 190\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const andThen = internal.andThen;\n/**\n * Runs a side effect with the result of an effect without changing the original\n * value.\n *\n * **When to use**\n *\n * Use when you need to run an effectful observation, such as logging or\n * tracking, while passing the original success value to the next step.\n *\n * **Details**\n *\n * `tap` works similarly to `flatMap`, but it ignores the result of the function\n * passed to it. The value from the previous effect remains available for the\n * next part of the chain. Note that if the side effect fails, the entire chain\n * will fail too.\n *\n * **Example** (Logging a step in a pipeline)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, pipe } from \"effect\"\n * const output: Array = []\n *\n * class DiscountRateError extends Data.TaggedError(\"DiscountRateError\")<{}> {}\n *\n * // Function to apply a discount safely to a transaction amount\n * const applyDiscount = (\n * total: number,\n * discountRate: number\n * ): Effect.Effect =>\n * discountRate === 0\n * ? Effect.fail(new DiscountRateError())\n * : Effect.succeed(total - (total * discountRate) / 100)\n *\n * // Simulated asynchronous task to fetch a transaction amount from database\n * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))\n *\n * const finalAmount = pipe(\n * fetchTransactionAmount,\n * // Log the fetched transaction amount\n * Effect.tap((amount) => Effect.sync(() => { output.push(`Apply a discount to: ${amount}`) })),\n * // `amount` is still available!\n * Effect.flatMap((amount) => applyDiscount(amount, 5))\n * )\n *\n * void output.push(await Effect.runPromise(finalAmount))\n * output // => [\"Apply a discount to: 100\", 95]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const tap = internal.tap;\n/**\n * Converts both success and failure of an `Effect` into a `Result` type.\n *\n * **When to use**\n *\n * Use when you want an `Effect`'s typed failures to be handled as `Result`\n * data while preserving the original error value.\n *\n * **Details**\n *\n * This function converts an effect that may fail into an effect that always\n * succeeds, wrapping the outcome in a `Result` type. The result will be\n * `Result.Failure` if the effect fails, containing the recoverable error, or\n * `Result.Success` if it succeeds, containing the result.\n *\n * Using this function, you can handle recoverable errors explicitly without\n * causing the effect to fail. This is particularly useful in scenarios where\n * you want to chain effects and manage both success and failure in the same\n * logical flow.\n *\n * The resulting effect cannot fail directly because all recoverable failures\n * are represented inside the `Result` type.\n *\n * **Gotchas**\n *\n * `result` only captures typed, recoverable failures. Defects and\n * interruptions are not captured inside the `Result` and still fail the\n * effect.\n *\n * **Example** (Capturing success or failure as Result)\n *\n * ```ts import.meta.vitest\n * import { Effect, Result } from \"effect\"\n *\n * const success = Effect.succeed(42)\n * const failure = Effect.fail(\"Something went wrong\")\n *\n * const program1 = Effect.result(success)\n * const program2 = Effect.result(failure)\n *\n * Effect.runSync(program1) // => Result.succeed(42)\n *\n * Effect.runSync(program2) // => Result.fail(\"Something went wrong\")\n * ```\n *\n * @see {@link option} for a version that uses `Option` instead.\n * @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const result = internal.result;\n/**\n * Converts success to `Option.some` and failure to `Option.none`.\n *\n * **When to use**\n *\n * Use when you only care whether an effect succeeds and want recoverable\n * failures represented as `Option.none`.\n *\n * **Details**\n *\n * Success values become `Option.some`, recoverable failures become\n * `Option.none`, and defects still fail the effect.\n *\n * **Gotchas**\n *\n * `option` only captures typed, recoverable failures as `Option.none`.\n * Defects and interruptions are not captured inside the `Option` and still\n * fail the effect.\n *\n * `option` also discards typed failure values. Use `result` if the failure\n * value matters.\n *\n * **Example** (Capturing success or failure as Option)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const program = Effect.all([\n * Effect.option(Effect.succeed(1)),\n * Effect.option(Effect.fail(\"missing\"))\n * ])\n *\n * Effect.runSync(program) // => [Option.some(1), Option.none()]\n * ```\n *\n * @see {@link result} for a version that uses `Result` instead.\n * @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`.\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const option = internal.option;\n/**\n * Transforms an effect to encapsulate both failure and success using the `Exit`\n * data type.\n *\n * **When to use**\n *\n * Use when you need to inspect the full outcome, including typed failures, defects,\n * and interruptions.\n *\n * **Details**\n *\n * `exit` wraps an effect's success or failure inside an `Exit` type, allowing\n * you to handle both cases explicitly.\n *\n * The resulting effect cannot fail because the failure is encapsulated within\n * the `Exit.Failure` type. The error type is set to `never`, indicating that\n * the effect is structured to never fail directly.\n *\n * **Example** (Capturing completion as Exit)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n *\n * const success = Effect.succeed(42)\n * const failure = Effect.fail(\"Something went wrong\")\n *\n * const program1 = Effect.exit(success)\n * const program2 = Effect.exit(failure)\n *\n * Effect.runSync(program1) // => Exit.succeed(42)\n *\n * Effect.runSync(program2) // => Exit.fail(\"Something went wrong\")\n * ```\n *\n * @see {@link option} for a version that uses `Option` instead.\n * @see {@link result} for a version that uses `Result` instead.\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const exit = internal.exit;\n/**\n * Transforms the value inside an effect by applying a function to it.\n *\n * **When to use**\n *\n * Use to transform an effect's success value with a function that returns a\n * plain value, producing a new effect without changing the original effect's\n * typed error or context requirements.\n *\n * **Details**\n *\n * `map` takes a function and applies it to the value contained within an\n * effect, creating a new effect with the transformed value.\n *\n * It's important to note that effects are immutable, meaning that the original\n * effect is not modified. Instead, a new effect is returned with the updated\n * value.\n *\n * **Example** (Choosing map syntax variants)\n *\n * ```ts import.meta.vitest\n * import { Effect, pipe } from \"effect\"\n * const output: Array = []\n *\n * const myEffect = Effect.succeed(1)\n * const transformation = (n: number) => n + 1\n *\n * const mappedWithPipe = pipe(myEffect, Effect.map(transformation))\n * const mappedWithDataFirst = Effect.map(myEffect, transformation)\n * const mappedWithMethod = myEffect.pipe(Effect.map(transformation))\n *\n * void output.push(Effect.runSync(Effect.all([\n * mappedWithPipe,\n * mappedWithDataFirst,\n * mappedWithMethod\n * ])))\n * output // => [[2, 2, 2]]\n * ```\n *\n * **Example** (Adding a service charge)\n *\n * ```ts import.meta.vitest\n * import { Effect, pipe } from \"effect\"\n *\n * const addServiceCharge = (amount: number) => amount + 1\n *\n * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))\n *\n * const finalAmount = pipe(\n * fetchTransactionAmount,\n * Effect.map(addServiceCharge)\n * )\n *\n * await Effect.runPromise(finalAmount) // => 101\n * ```\n *\n * @see {@link mapError} for a version that operates on the error channel.\n * @see {@link mapBoth} for a version that operates on both channels.\n * @see {@link flatMap} or {@link andThen} for a version that can return a new effect.\n * @category mapping\n * @since 2.0.0\n */\nexport const map = internal.map;\n/**\n * Replaces the value inside an effect with a constant value.\n *\n * **When to use**\n *\n * Use to replace a successful value with a constant while preserving failures\n * and requirements.\n *\n * **Details**\n *\n * `as` allows you to ignore the original value inside an effect and\n * replace it with a new constant value.\n *\n * **Example** (Replacing a success value)\n *\n * ```ts import.meta.vitest\n * import { Effect, pipe } from \"effect\"\n *\n * // Replaces the value 5 with the constant \"new value\"\n * const program = pipe(Effect.succeed(5), Effect.as(\"new value\"))\n *\n * Effect.runSync(program) // => \"new value\"\n * ```\n *\n * @see {@link map} for deriving the replacement value from the success value\n * @see {@link asVoid} for replacing the success value with `void`\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const as = internal.as;\n/**\n * Maps the success value of an `Effect` to `Some`, preserving failures.\n *\n * **Example** (Wrapping success in Option.some)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const program = Effect.asSome(Effect.succeed(42))\n *\n * Effect.runSync(program) // => Option.some(42)\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const asSome = internal.asSome;\n/**\n * Maps the success value of an `Effect` to `void`, preserving failures.\n *\n * **Example** (Discarding success values)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.asVoid(Effect.succeed(42))\n *\n * Effect.runSync(program) // => undefined\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const asVoid = internal.asVoid;\n/**\n * Swaps an effect's success and failure channels.\n *\n * **When to use**\n *\n * Use to swap an `Effect`'s success and failure channels.\n *\n * **Details**\n *\n * For an `Effect`, the returned effect has type `Effect`.\n *\n * **Example** (Swapping success and failure channels)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // ┌─── Effect\n * // ▼\n * const program = Effect.fail(\"Oh uh!\").pipe(Effect.as(2))\n *\n * // ┌─── Effect\n * // ▼\n * const flipped = Effect.flip(program)\n * Effect.runSync(flipped) // => \"Oh uh!\"\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const flip = internal.flip;\n// -----------------------------------------------------------------------------\n// Zipping\n// -----------------------------------------------------------------------------\n/**\n * Combines two effects into a single effect, producing a tuple with the results of both effects.\n *\n * **When to use**\n *\n * Use to combine exactly two effects into a tuple.\n *\n * **Details**\n *\n * The `zip` function executes the first effect (left) and then the second effect (right).\n * Once both effects succeed, their results are combined into a tuple.\n *\n * Concurrency:\n *\n * By default, `zip` processes the effects sequentially. To execute the effects concurrently,\n * use the `{ concurrent: true }` option.\n *\n * **Example** (Combining two effects sequentially)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const task1 = Effect.succeed(1)\n * const task2 = Effect.succeed(\"hello\")\n *\n * // Combine the two effects together\n * //\n * // ┌─── Effect<[number, string], never, never>\n * // ▼\n * const program = Effect.zip(task1, task2)\n *\n * Effect.runSync(program) // => [1, 'hello']\n * ```\n *\n * **Example** (Combining two effects concurrently)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const task1 = Effect.succeed(1)\n * const task2 = Effect.succeed(\"hello\")\n *\n * // Run both effects concurrently using the concurrent option\n * const program = Effect.zip(task1, task2, { concurrent: true })\n *\n * await Effect.runPromise(program) // => [1, 'hello']\n * ```\n *\n * @see {@link zipWith} for a version that combines the results with a custom function.\n * @see {@link all} for collecting a larger structure of effects.\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zip = internal.zip;\n/**\n * Combines two effects sequentially and applies a function to their results to\n * produce a single value.\n *\n * **When to use**\n *\n * Use when you need to run two effects sequentially and combine their results\n * with a function instead of keeping the results as a tuple.\n *\n * **Details**\n *\n * Concurrency:\n *\n * By default, the effects are run sequentially. To execute them concurrently,\n * use the `{ concurrent: true }` option.\n *\n * **Example** (Combining two success values with a function)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const task1 = Effect.succeed(1)\n * const task2 = Effect.succeed(\"hello\")\n *\n * const task3 = Effect.zipWith(\n * task1,\n * task2,\n * // Combines results into a single value\n * (number, string) => number + string.length\n * )\n *\n * Effect.runSync(task3) // => 6\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipWith = internal.zipWith;\n// -----------------------------------------------------------------------------\n// Error handling\n// -----------------------------------------------------------------------------\nconst catch_ = internal.catch_;\nexport {\n/**\n * Handles all errors in an effect by providing a fallback effect.\n *\n * **When to use**\n *\n * Use when every recoverable error from an effect should be handled by the same\n * fallback function while unrecoverable defects remain defects.\n *\n * **Details**\n *\n * The `catch` function catches any errors that may occur during the\n * execution of an effect and allows you to handle them by specifying a fallback\n * effect. This ensures that the program continues without failing by recovering\n * from errors using the provided fallback logic.\n *\n * **Gotchas**\n *\n * `catch` only handles recoverable errors. It will not recover from\n * unrecoverable defects.\n *\n * @see {@link catchCause} for a version that can recover from both recoverable and unrecoverable errors.\n *\n * @category error handling\n * @since 4.0.0\n */\ncatch_ as catch };\n/**\n * Catches and handles specific errors by their `_tag` field, which is used as a\n * discriminator.\n *\n * **When to use**\n *\n * Use when you need to recover from one specific tagged error in an effect\n * error channel.\n *\n * **Details**\n *\n * The error type must have a readonly `_tag` field. `catchTag` matches that\n * field and only handles errors with the requested tag.\n *\n * **Example** (Handling a tagged error)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * class NetworkError {\n * readonly _tag = \"NetworkError\"\n * constructor(readonly message: string) {}\n * }\n *\n * class ValidationError {\n * readonly _tag = \"ValidationError\"\n * constructor(readonly message: string) {}\n * }\n *\n * const task: Effect.Effect =\n * Effect.fail(new NetworkError(\"offline\"))\n *\n * const program = Effect.catchTag(\n * task,\n * \"NetworkError\",\n * (error) => Effect.succeed(`Recovered from network error: ${error.message}`)\n * )\n *\n * Effect.runSync(program) // => \"Recovered from network error: offline\"\n * ```\n *\n * @see {@link catchTags} for handling multiple tagged errors in one call\n * @see {@link catchIf} for recovering from errors that match a predicate\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const catchTag = internal.catchTag;\n/**\n * Handles multiple errors in a single block of code using their `_tag` field.\n *\n * **When to use**\n *\n * Use when one recovery step should handle several tagged error types by\n * matching their readonly `_tag` fields.\n *\n * **Details**\n *\n * Pass a handler table whose keys are tags, plus an optional fallback for\n * unmatched errors.\n *\n * The error type must have a readonly `_tag` field to use `catchTags`. This\n * field is used to identify and match errors.\n *\n * **Example** (Handling multiple tagged errors)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * // Define tagged error types\n * class ValidationError extends Data.TaggedError(\"ValidationError\")<{\n * message: string\n * }> {}\n *\n * class NetworkError extends Data.TaggedError(\"NetworkError\")<{\n * statusCode: number\n * }> {}\n *\n * // An effect that might fail with multiple error types\n * const program: Effect.Effect =\n * Effect.fail(new NetworkError({ statusCode: 503 }))\n *\n * // Handle multiple error types at once\n * const handled = Effect.catchTags(program, {\n * ValidationError: (error) =>\n * Effect.succeed(`Validation failed: ${error.message}`),\n * NetworkError: (error) => Effect.succeed(`Network error: ${error.statusCode}`)\n * })\n *\n * Effect.runSync(handled) // => \"Network error: 503\"\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const catchTags = internal.catchTags;\n/**\n * Catches a specific reason within a tagged error.\n *\n * **When to use**\n *\n * Use to handle one nested reason inside an `Effect`'s tagged error while\n * preserving the parent error shape for unmatched reasons.\n *\n * **Details**\n *\n * Use this to handle nested error causes without removing the parent error\n * from the error channel. The handler receives the unwrapped reason.\n *\n * **Example** (Handling an error reason)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class RateLimitError extends Data.TaggedError(\"RateLimitError\")<{\n * retryAfter: number\n * }> {}\n *\n * class QuotaExceededError extends Data.TaggedError(\"QuotaExceededError\")<{\n * limit: number\n * }> {}\n *\n * class AiError extends Data.TaggedError(\"AiError\")<{\n * reason: RateLimitError | QuotaExceededError\n * }> {}\n *\n * const program: Effect.Effect = Effect.fail(\n * new AiError({ reason: new RateLimitError({ retryAfter: 30 }) })\n * )\n *\n * // Handle rate limits specifically\n * const handled = program.pipe(\n * Effect.catchReason(\"AiError\", \"RateLimitError\", (reason) =>\n * Effect.succeed(`Retry after ${reason.retryAfter}s`)\n * )\n * )\n *\n * Effect.runSync(handled) // => \"Retry after 30s\"\n * ```\n *\n * @see {@link catchReasons} for handling several nested reason tags\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchReason = internal.catchReason;\n/**\n * Catches multiple reasons within a tagged error using an object of handlers.\n *\n * **Example** (Handling multiple error reasons)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class RateLimitError extends Data.TaggedError(\"RateLimitError\")<{\n * retryAfter: number\n * }> {}\n *\n * class QuotaExceededError extends Data.TaggedError(\"QuotaExceededError\")<{\n * limit: number\n * }> {}\n *\n * class AiError extends Data.TaggedError(\"AiError\")<{\n * reason: RateLimitError | QuotaExceededError\n * }> {}\n *\n * const program: Effect.Effect = Effect.fail(\n * new AiError({ reason: new QuotaExceededError({ limit: 100 }) })\n * )\n *\n * const handled = program.pipe(\n * Effect.catchReasons(\"AiError\", {\n * RateLimitError: (reason) =>\n * Effect.succeed(`Retry after ${reason.retryAfter}s`),\n * QuotaExceededError: (reason) =>\n * Effect.succeed(`Quota exceeded: ${reason.limit}`)\n * })\n * )\n *\n * Effect.runSync(handled) // => \"Quota exceeded: 100\"\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchReasons = internal.catchReasons;\n/**\n * Promotes nested reason errors into the Effect error channel, replacing\n * the parent error.\n *\n * **Example** (Extracting the reason from a tagged error)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class RateLimitError extends Data.TaggedError(\"RateLimitError\")<{\n * retryAfter: number\n * }> {}\n *\n * class QuotaExceededError extends Data.TaggedError(\"QuotaExceededError\")<{\n * limit: number\n * }> {}\n *\n * class AiError extends Data.TaggedError(\"AiError\")<{\n * reason: RateLimitError | QuotaExceededError\n * }> {}\n *\n * const program: Effect.Effect = Effect.fail(\n * new AiError({ reason: new RateLimitError({ retryAfter: 30 }) })\n * )\n *\n * // Before: Effect\n * // After: Effect\n * const unwrapped = program.pipe(Effect.unwrapReason(\"AiError\"))\n * Effect.runSync(Effect.flip(unwrapped))._tag // => \"RateLimitError\"\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const unwrapReason = internal.unwrapReason;\n/**\n * Handles both recoverable and unrecoverable errors by providing a recovery\n * effect.\n *\n * **When to use**\n *\n * Use when you need to recover from an `Effect` by inspecting the full `Cause`,\n * including recoverable failures, defects, and interruptions, instead of only\n * the typed error value.\n *\n * **Details**\n *\n * When to Recover from Defects:\n *\n * Defects are unexpected errors that typically shouldn't be recovered from, as\n * they often indicate serious issues. However, in some cases, such as\n * dynamically loaded plugins, controlled recovery might be needed.\n *\n * **Example** (Recovering from full failure causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect } from \"effect\"\n * const output: Array = []\n *\n * // An effect that might fail in different ways\n * const program = Effect.die(\"Something went wrong\")\n *\n * // Recover from any cause (including defects)\n * const recovered = Effect.catchCause(program, (cause) => {\n * if (Cause.hasDies(cause)) {\n * return Effect.sync(() => { output.push(\"Caught defect\") }).pipe(\n * Effect.as(\"Recovered from defect\")\n * )\n * }\n * return Effect.succeed(\"Unknown error\")\n * })\n *\n * void output.push(Effect.runSync(recovered))\n * output // => [\"Caught defect\", \"Recovered from defect\"]\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchCause = internal.catchCause;\n/**\n * Recovers from defects using a provided recovery function.\n *\n * **When to use**\n *\n * Use when you need to report or translate defects at integration boundaries.\n *\n * **Details**\n *\n * `catchDefect` handles unexpected defects, such as thrown exceptions or\n * values passed to `die`, without catching typed failures or interruptions.\n *\n * When to Recover from Defects:\n *\n * Defects are unexpected errors that typically should not be recovered from, as\n * they often indicate serious issues. In some cases, such as dynamically loaded\n * plugins, controlled recovery may be needed.\n *\n * **Example** (Recovering from defects)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * // An effect that might throw an unexpected error (defect)\n * const program = Effect.sync(() => {\n * throw new Error(\"Unexpected error\")\n * })\n *\n * // Recover from defects only\n * const recovered = Effect.catchDefect(program, (defect) => {\n * return Effect.sync(() => { output.push(`Caught defect: ${(defect as Error).message}`) }).pipe(\n * Effect.as(\"Recovered from defect\")\n * )\n * })\n *\n * void output.push(Effect.runSync(recovered))\n * output // => [\"Caught defect: Unexpected error\", \"Recovered from defect\"]\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchDefect = internal.catchDefect;\n/**\n * Recovers from specific errors using a `Predicate` or `Refinement`.\n *\n * **When to use**\n *\n * Use when you need to recover from errors that match a condition.\n *\n * **Details**\n *\n * Use a `Refinement` for type narrowing or a `Predicate` for simple boolean\n * matching. Non-matching errors re-fail with the original cause. Defects and\n * interrupts are not caught.\n *\n * **Example** (Recovering when a predicate matches)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Filter } from \"effect\"\n *\n * class NotFound extends Data.TaggedError(\"NotFound\")<{ id: string }> {}\n *\n * const program = Effect.fail(new NotFound({ id: \"user-1\" }))\n *\n * // With a refinement\n * const recovered = program.pipe(\n * Effect.catchIf(\n * (error): error is NotFound => error._tag === \"NotFound\",\n * (error) => Effect.succeed(`missing:${error.id}`)\n * )\n * )\n *\n * // With a Filter\n * const recovered2 = program.pipe(\n * Effect.catchFilter(\n * Filter.tagged(\"NotFound\"),\n * (error) => Effect.succeed(`missing:${error.id}`)\n * )\n * )\n *\n * Effect.runSync(Effect.all([recovered, recovered2])) // => ['missing:user-1', 'missing:user-1']\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const catchIf = internal.catchIf;\n/**\n * Recovers from specific errors using a `Filter`.\n *\n * **When to use**\n *\n * Use to recover from typed `Effect` errors with a reusable `Filter` when\n * matching can also narrow or transform the error before choosing the recovery\n * effect.\n *\n * **Details**\n *\n * The filter runs on typed failures extracted from the `Cause`. Successful\n * filter results are passed to `f`; failed filter results are passed to\n * `orElse` when provided. Without `orElse`, the original failure cause is\n * preserved.\n *\n * @see {@link catchIf} for predicate-based recovery from typed errors\n * @see {@link catchTag} for recovering from a single tagged error\n * @see {@link catchTags} for recovering from several tagged errors\n * @see {@link catchCauseFilter} for filtering full causes instead of typed errors\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchFilter = internal.catchFilter;\n/**\n * Catches `NoSuchElementError` failures and converts them to `Option.none`.\n *\n * **When to use**\n *\n * Use when you expect missing-value failures and want them to become an\n * optional success while all other failures keep failing.\n *\n * **Details**\n *\n * Success values become `Option.some`, `NoSuchElementError` becomes\n * `Option.none`, and all other errors are preserved.\n *\n * **Example** (Recovering from missing Option values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n * const output: Array = []\n *\n * const some = Effect.fromNullishOr(1).pipe(Effect.catchNoSuchElement)\n * const none = Effect.fromNullishOr(null).pipe(Effect.catchNoSuchElement)\n *\n * void output.push(Effect.runSync(some))\n * void output.push(Effect.runSync(none))\n * output // => [Option.some(1), Option.none()]\n * ```\n *\n * @see {@link fromOption} for converting `Option.none` into `NoSuchElementError`\n * @see {@link fromNullishOr} for converting nullish values into `NoSuchElementError`\n * @see {@link option} for converting any failure into `Option.none`\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchNoSuchElement = internal.catchNoSuchElement;\n/**\n * Recovers from specific failures based on a predicate.\n *\n * **When to use**\n *\n * Use to recover an `Effect` from full causes selected by a predicate.\n *\n * **Details**\n *\n * This function allows you to conditionally catch and recover from failures\n * that match a specific predicate. This is useful when you want to handle\n * only certain types of errors while letting others propagate.\n *\n * **Example** (Recovering from selected causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect } from \"effect\"\n * const output: Array = []\n *\n * const httpRequest = Effect.fail(\"Network Error\")\n *\n * // Only catch network-related failures\n * const program = Effect.catchCauseIf(\n * httpRequest,\n * Cause.hasFails,\n * (cause) =>\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(`Caught network error: ${Cause.squash(cause)}`) })\n * return \"Fallback response\"\n * })\n * )\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Caught network error: Network Error\", \"Fallback response\"]\n * ```\n *\n * @see {@link catchCause} for recovering from every cause\n * @see {@link catchCauseFilter} for selecting full causes with a `Filter`\n * @see {@link catchIf} for predicate-based recovery from typed errors\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchCauseIf = internal.catchCauseIf;\n/**\n * Recovers from specific failures based on a `Filter`.\n *\n * **When to use**\n *\n * Use when you need to recover an `Effect` only from causes selected by a\n * `Filter`, while giving the recovery both the selected value and the original\n * `Cause`.\n *\n * **Details**\n *\n * The filter is applied to the full `Cause`. When it succeeds, the handler\n * receives the selected value and the original cause. When it fails, the effect\n * re-fails with the residual cause returned by the filter.\n *\n * @see {@link catchCauseIf} for predicate-based cause selection\n * @see {@link catchFilter} for filtering typed error values instead of full causes\n * @see {@link catchCause} for recovering from every cause without filtering\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchCauseFilter = internal.catchCauseFilter;\n/**\n * Transforms the failure value of an effect without changing its success value.\n *\n * **When to use**\n *\n * Use to translate an `Effect`'s typed failures while leaving successful values\n * unchanged.\n *\n * **Details**\n *\n * Only the failure channel is transformed. The success channel and requirements\n * are preserved.\n *\n * **Example** (Transforming the error channel)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class TaskError extends Data.TaggedError(\"TaskError\")<{ readonly message: string }> {}\n *\n * // ┌─── Effect\n * // ▼\n * const simulatedTask = Effect.fail(\"Oh no!\").pipe(Effect.as(1))\n *\n * // ┌─── Effect\n * // ▼\n * const mapped = Effect.mapError(\n * simulatedTask,\n * (message) => new TaskError({ message })\n * )\n * Effect.runSync(Effect.flip(mapped)).message // => \"Oh no!\"\n * ```\n *\n * @see {@link map} for a version that operates on the success channel.\n * @see {@link mapBoth} for a version that operates on both channels.\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const mapError = internal.mapError;\n/**\n * Applies transformations to both the success and error channels of an effect.\n *\n * **When to use**\n *\n * Use to transform both success and failure channels of an `Effect` without\n * changing whether it succeeds or fails.\n *\n * **Details**\n *\n * This function takes two map functions as arguments: one for the error channel\n * and one for the success channel. You can use it when you want to modify both\n * the error and the success values without altering the overall success or\n * failure status of the effect.\n *\n * **Example** (Transforming success and failure channels)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class TaskError extends Data.TaggedError(\"TaskError\")<{ readonly message: string }> {}\n *\n * // ┌─── Effect\n * // ▼\n * const simulatedTask = Effect.fail(\"Oh no!\").pipe(Effect.as(1))\n *\n * // ┌─── Effect\n * // ▼\n * const modified = Effect.mapBoth(simulatedTask, {\n * onFailure: (message) => new TaskError({ message }),\n * onSuccess: (n) => n > 0\n * })\n * Effect.runSync(Effect.flip(modified)).message // => \"Oh no!\"\n * ```\n *\n * @see {@link map} for a version that operates on the success channel.\n * @see {@link mapError} for a version that operates on the error channel.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapBoth = internal.mapBoth;\n/**\n * Converts typed failures from the error channel into defects, removing the\n * error type from the returned effect.\n *\n * **When to use**\n *\n * Use when you need to turn an `Effect` typed failure that represents an\n * unrecoverable bug or invalid state into a defect.\n *\n * **Example** (Converting typed failures into defects)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Exit } from \"effect\"\n *\n * class DivideByZeroError extends Data.TaggedError(\"DivideByZeroError\")<{}> {}\n *\n * const divide = (a: number, b: number) =>\n * b === 0\n * ? Effect.fail(new DivideByZeroError())\n * : Effect.succeed(a / b)\n *\n * // ┌─── Effect\n * // ▼\n * const program = Effect.orDie(divide(1, 0))\n *\n * Effect.runSyncExit(program) // => Exit.die(new DivideByZeroError())\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const orDie = internal.orDie;\n/**\n * Runs an effectful operation when the source effect fails, while preserving\n * the original failure when the operation succeeds.\n *\n * **Details**\n *\n * Use this for logging, metrics, or other failure-side observations. If the\n * operation passed to `tapError` fails, that error is also represented in the\n * returned effect's error channel.\n *\n * **Example** (Running effects on failure)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * // Simulate a task that fails with an error\n * const task: Effect.Effect = Effect.fail(\"NetworkError\")\n *\n * // Use tapError to log the error message when the task fails\n * const tapping = Effect.tapError(\n * task,\n * (error) => Effect.sync(() => { output.push(`expected error: ${error}`) })\n * )\n *\n * void output.push(Effect.runSyncExit(tapping))\n * output // => [\"expected error: NetworkError\", Exit.fail(\"NetworkError\")]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const tapError = internal.tapError;\n/**\n * Runs an effectful handler when a failure's `_tag` matches.\n *\n * **Details**\n *\n * Use this with tagged-union errors to perform side effects for one tag or a\n * list of tags. When the handler succeeds, the original failure is preserved;\n * if the handler fails, its error is also included in the returned effect.\n *\n * **Example** (Running effects for tagged failures)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * class NetworkError extends Data.TaggedError(\"NetworkError\")<{\n * statusCode: number\n * }> {}\n *\n * class ValidationError extends Data.TaggedError(\"ValidationError\")<{\n * field: string\n * }> {}\n *\n * const task: Effect.Effect =\n * Effect.fail(new NetworkError({ statusCode: 504 }))\n *\n * const program = Effect.tapErrorTag(task, \"NetworkError\", (error) =>\n * Effect.sync(() => { output.push(`expected error: ${error.statusCode}`) })\n * )\n *\n * void output.push(Effect.runSyncExit(program))\n * output // => [\"expected error: 504\", Exit.fail(new NetworkError({ statusCode: 504 }))]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const tapErrorTag = internal.tapErrorTag;\n/**\n * Runs an effectful operation with the full `Cause` when the source effect\n * fails.\n *\n * **When to use**\n *\n * Use when failure observation needs typed failures, defects, and interruptions\n * rather than only the typed error value.\n *\n * **Details**\n *\n * Use this to log or inspect typed failures, defects, and interruptions. When\n * the operation succeeds, the original cause is preserved. If the operation\n * fails, its error is also represented in the returned effect.\n *\n * **Example** (Observing full failure causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * const task = Effect.fail(\"Something went wrong\")\n *\n * const program = Effect.tapCause(\n * task,\n * (cause) => Effect.sync(() => { output.push(`Logging cause: ${Cause.squash(cause)}`) })\n * )\n *\n * void output.push(Effect.runSyncExit(program))\n * output // => [\"Logging cause: Something went wrong\", Exit.fail(\"Something went wrong\")]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const tapCause = internal.tapCause;\n/**\n * Executes a side effect conditionally when a failed effect's cause matches a predicate.\n *\n * **Details**\n *\n * This function allows you to tap into the cause of an effect's failure only when\n * the cause matches a specific predicate. This is useful for conditional logging,\n * monitoring, or other side effects based on the type of failure.\n *\n * **Example** (Observing selected failure causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * const task = Effect.fail(\"Network timeout\")\n *\n * // Only log causes that contain failures (not interrupts or defects)\n * const program = Effect.tapCauseIf(\n * task,\n * Cause.hasFails,\n * (cause) => Effect.sync(() => { output.push(`Logging failure cause: ${Cause.squash(cause)}`) })\n * )\n *\n * void output.push(Effect.runSyncExit(program))\n * output // => [\"Logging failure cause: Network timeout\", Exit.fail(\"Network timeout\")]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const tapCauseIf = internal.tapCauseIf;\n/**\n * Executes a side effect conditionally when a failed effect's cause passes a filter.\n *\n * **When to use**\n *\n * Use when you need to observe only failure causes selected by a `Filter`,\n * while giving the side effect both the selected value and the original\n * `Cause`.\n *\n * **Details**\n *\n * A successful filter result runs the side effect with the selected value and\n * original cause. A failed filter result skips the side effect and preserves the\n * original cause.\n *\n * @see {@link tapCauseIf} for selecting causes with a boolean predicate\n * @see {@link tapCause} for observing every failure cause\n * @see {@link catchCauseFilter} for recovering from selected causes instead of only observing them\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const tapCauseFilter = internal.tapCauseFilter;\n/**\n * Runs an effectful operation when the source effect dies with a defect.\n *\n * **Details**\n *\n * Use this for diagnostics such as logging unexpected thrown exceptions or\n * values passed to `die`. Recoverable failures are not handled. When the\n * operation succeeds, the original defect is preserved; if the operation fails,\n * its error is also represented in the returned effect.\n *\n * **Example** (Observing defects)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * // Simulate a severe failure in the system\n * const task2: Effect.Effect = Effect.die(\n * \"Something went wrong\"\n * )\n *\n * // Log the defect using tapDefect\n * const tapping2 = Effect.tapDefect(\n * task2,\n * (defect) => Effect.sync(() => { output.push(`defect: ${defect}`) })\n * )\n *\n * void output.push(Effect.runSyncExit(tapping2))\n * output // => [\"defect: Something went wrong\", Exit.die(\"Something went wrong\")]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const tapDefect = internal.tapDefect;\n/**\n * Retries an effect until it succeeds, discarding failures.\n *\n * **Details**\n *\n * Yields between attempts so other fibers can run.\n *\n * **Example** (Retrying until success)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * let attempts = 0\n *\n * const flaky = Effect.gen(function*() {\n * attempts++\n * yield* Effect.sync(() => { output.push(`Attempt ${attempts}`) })\n * if (attempts < 3) {\n * return yield* Effect.fail(\"Not ready\")\n * }\n * return \"Ready\"\n * })\n *\n * const program = Effect.eventually(flaky)\n *\n * void output.push(await Effect.runPromise(program))\n * output // => [\"Attempt 1\", \"Attempt 2\", \"Attempt 3\", \"Ready\"]\n * ```\n *\n * @category repetition\n * @since 2.0.0\n */\nexport const eventually = internal.eventually;\n/**\n * Retries typed failures from an effect according to a retry policy.\n *\n * **When to use**\n *\n * Use when you need to rerun an effect after transient typed failures, such as\n * network issues or temporary resource unavailability.\n *\n * **Details**\n *\n * The policy can be a `Schedule`, a schedule builder, or a `Retry.Options`\n * object using `schedule`, `times`, `while`, or `until`. If a retry eventually\n * succeeds, the returned effect succeeds with that value. If the policy stops\n * while the effect is still failing, the last failure is propagated.\n *\n * **Gotchas**\n *\n * The source effect is always evaluated once before any retry policy is\n * applied. For example, `Schedule.recurs(3)` allows up to three retries after\n * the initial attempt.\n *\n * Defects and interruptions are not retried.\n *\n * **Example** (Retrying with a schedule)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Schedule } from \"effect\"\n *\n * class AttemptError extends Data.TaggedError(\"AttemptError\")<{ readonly attempt: number }> {}\n *\n * let attempt = 0\n * const task = Effect.callback((resume) => {\n * attempt++\n * if (attempt <= 2) {\n * resume(Effect.fail(new AttemptError({ attempt })))\n * } else {\n * resume(Effect.succeed(\"Success!\"))\n * }\n * })\n *\n * const policy = Schedule.recurs(5)\n * const program = Effect.retry(task, policy)\n *\n * await Effect.runPromise(program) // => \"Success!\"\n * ```\n *\n * @see {@link retryOrElse} for a version that allows you to run a fallback.\n * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.\n * @category error handling\n * @since 2.0.0\n */\nexport const retry = internalSchedule.retry;\n/**\n * Retries a failing effect and runs a fallback effect if retries are exhausted.\n *\n * **When to use**\n *\n * Use when you want to handle failures gracefully by specifying an alternative\n * action after repeated failures.\n *\n * **Details**\n *\n * The `Effect.retryOrElse` function attempts to retry a failing effect multiple\n * times according to a defined {@link Schedule} policy.\n *\n * If the retries are exhausted and the effect still fails, it runs a fallback\n * effect instead.\n *\n * **Example** (Falling back after retries are exhausted)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Schedule } from \"effect\"\n * const output: Array = []\n *\n * class NetworkTimeoutError extends Data.TaggedError(\"NetworkTimeoutError\")<{}> {}\n *\n * let attempt = 0\n * const networkRequest = Effect.gen(function*() {\n * attempt++\n * yield* Effect.sync(() => { output.push(`Network attempt ${attempt}`) })\n * if (attempt < 3) {\n * return yield* Effect.fail(new NetworkTimeoutError())\n * }\n * return \"Network data\"\n * })\n *\n * // Retry up to 2 times, then fall back to cached data\n * const program = Effect.retryOrElse(\n * networkRequest,\n * Schedule.recurs(2),\n * (error, retryCount) =>\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(`All ${retryCount} retries failed, using cache`) })\n * return \"Cached data\"\n * })\n * )\n *\n * void output.push(await Effect.runPromise(program))\n * output // => [\"Network attempt 1\", \"Network attempt 2\", \"Network attempt 3\", \"Network data\"]\n * ```\n *\n * @see {@link retry} for a version that does not run a fallback effect.\n * @category error handling\n * @since 2.0.0\n */\nexport const retryOrElse = internalSchedule.retryOrElse;\n/**\n * Exposes an effect's full failure cause in the error channel as `Cause`.\n *\n * **Details**\n *\n * Use `sandbox` when downstream error handling needs to distinguish typed\n * failures, defects, and interruptions. Use `unsandbox` to restore the original\n * typed error channel after cause-level handling.\n *\n * **Example** (Exposing failures as causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect } from \"effect\"\n *\n * const task = Effect.fail(\"Something went wrong\")\n *\n * // Sandbox exposes the full cause as the error type\n * const program = Effect.gen(function*() {\n * const result = yield* Effect.flip(Effect.sandbox(task))\n * return `Caught cause: ${Cause.squash(result)}`\n * })\n *\n * Effect.runSync(program) // => \"Caught cause: Something went wrong\"\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const sandbox = internal.sandbox;\n/**\n * Discards both the success and failure values of an effect.\n *\n * **When to use**\n *\n * Use when an effect should run for its side effects while both success and\n * failure values are discarded.\n *\n * **Details**\n *\n * Use the `log` option to emit the full {@link Cause} when the effect fails,\n * and `message` to prepend a custom log message.\n *\n * **Example** (Discarding success and failure values)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // ┌─── Effect\n * // ▼\n * const task = Effect.fail(\"Uh oh!\").pipe(Effect.as(5))\n *\n * // ┌─── Effect\n * // ▼\n * const program = task.pipe(Effect.ignore)\n * Effect.runSync(program) // => undefined\n * ```\n *\n * **Example** (Logging failures while ignoring results)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const task = Effect.fail(\"Uh oh!\")\n *\n * const program = task.pipe(Effect.ignore)\n * Effect.runSync(program) // => undefined\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const ignore = internal.ignore;\n/**\n * Ignores the effect's failure cause, including defects and interruptions.\n *\n * **When to use**\n *\n * Use when a best-effort effect should never fail, even from defects or\n * interruption, and optional cause logging is enough.\n *\n * **Details**\n *\n * Use the `log` option to emit the full {@link Cause} when the effect fails,\n * and `message` to prepend a custom log message.\n *\n * **Example** (Ignoring failures and logging causes)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const task = Effect.fail(\"boom\")\n *\n * const program = task.pipe(Effect.ignoreCause)\n * Effect.runSync(program) // => undefined\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const ignoreCause = internal.ignoreCause;\n/**\n * Applies an `ExecutionPlan` to an effect, retrying with step-provided resources\n * until it succeeds or the plan is exhausted.\n *\n * **Details**\n *\n * Each attempt updates `ExecutionPlan.CurrentMetadata` (attempt and step index),\n * and retry timing is derived per step (the first attempt uses the remaining\n * attempts schedule; later retries apply the step schedule at least once).\n *\n * Attempts can be observed from outside the effect by passing\n * `options.onEvent`, which receives an `ExecutionPlan.Event` before each\n * attempt and after it settles. The handler is awaited inline before and after\n * every attempt, so events are strictly ordered; keep it cheap. It cannot\n * fail, which keeps observation from changing the plan's outcome, and its\n * requirements are added to the resulting effect. Terminal events run like\n * finalizers, so they are emitted even when the attempt is interrupted.\n *\n * **Example** (Retrying with an execution plan)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, ExecutionPlan, Layer } from \"effect\"\n *\n * const Endpoint = Context.Service<{ url: string }>(\"Endpoint\")\n *\n * const fetchUrl = Effect.gen(function*() {\n * const endpoint = yield* Effect.service(Endpoint)\n * if (endpoint.url === \"bad\") {\n * return yield* Effect.fail(\"Unavailable\")\n * }\n * return endpoint.url\n * })\n *\n * const plan = ExecutionPlan.make(\n * { provide: Layer.succeed(Endpoint, { url: \"bad\" }), attempts: 2 },\n * { provide: Layer.succeed(Endpoint, { url: \"good\" }) }\n * )\n *\n * const program = Effect.withExecutionPlan(fetchUrl, plan)\n * Effect.runSync(program) // => \"good\"\n * ```\n *\n * **Example** (Observing execution-plan attempts)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, ExecutionPlan, Layer } from \"effect\"\n *\n * const Endpoint = Context.Service<{ url: string }>(\"Endpoint\")\n *\n * const fetchUrl = Effect.gen(function*() {\n * const endpoint = yield* Effect.service(Endpoint)\n * if (endpoint.url === \"bad\") {\n * return yield* Effect.fail(\"Unavailable\")\n * }\n * return endpoint.url\n * })\n *\n * const plan = ExecutionPlan.make(\n * { provide: Layer.succeed(Endpoint, { url: \"bad\" }) },\n * { provide: Layer.succeed(Endpoint, { url: \"good\" }) }\n * )\n *\n * const events: Array = []\n * const program = Effect.withExecutionPlan(fetchUrl, plan, {\n * onEvent: (event) => Effect.sync(() => events.push(`${event._tag}:${event.stepIndex}`))\n * })\n *\n * await Effect.runPromise(program) // => \"good\"\n *\n * events // => [\"AttemptStart:0\", \"AttemptFailure:0\", \"AttemptStart:1\", \"AttemptSuccess:1\"]\n * ```\n *\n * @category error handling\n * @since 3.16.0\n */\nexport const withExecutionPlan = internalExecutionPlan.withExecutionPlan;\n/**\n * Runs an effect and reports any errors to the configured `ErrorReporter`s.\n *\n * **Details**\n *\n * If the `defectsOnly` option is set to `true`, only defects (unrecoverable\n * errors) will be reported, while regular failures will be ignored.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const withErrorReporting = internal.withErrorReporting;\n// -----------------------------------------------------------------------------\n// Fallback\n// -----------------------------------------------------------------------------\n/**\n * Recovers from a typed failure by producing a fallback success value.\n *\n * **Details**\n *\n * If the source effect succeeds, its value is preserved. If it fails in the\n * error channel, `orElseSucceed` evaluates the fallback and succeeds with that\n * value, removing the typed error from the returned effect.\n *\n * Defects and interruptions are not recovered by this operator.\n *\n * **Example** (Replacing failures with a value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n *\n * const validate = (age: number): Effect.Effect => {\n * if (age < 0) {\n * return Effect.fail(\"NegativeAgeError\")\n * } else if (age < 18) {\n * return Effect.fail(\"IllegalAgeError\")\n * } else {\n * return Effect.succeed(age)\n * }\n * }\n *\n * const program = Effect.orElseSucceed(validate(-1), () => 18)\n *\n * Effect.runSyncExit(program) // => Exit.succeed(18)\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const orElseSucceed = internal.orElseSucceed;\n/**\n * Runs a sequence of effects and returns the result of the first successful\n * one.\n *\n * **When to use**\n *\n * Use when you have prioritized fallback `Effect`s, such as attempting\n * multiple APIs, reading configuration from several sources, or trying\n * alternative resource locations in order.\n *\n * **Details**\n *\n * This function executes the provided effects in sequence, stopping at the\n * first success. If an effect succeeds, its result is returned immediately and\n * no further effects in the sequence are executed.\n *\n * If all effects fail, the returned effect fails with the error from the last\n * effect. If the collection is empty, the returned effect defects with an\n * `Error` whose message is `\"Received an empty collection of effects\"`.\n *\n * **Example** (Trying alternatives until one succeeds)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const primary = Effect.fail(\"primary unavailable\")\n * const secondary = Effect.succeed(\"secondary result\")\n * const tertiary = Effect.sync(() => {\n * throw new Error(\"not evaluated\")\n * })\n *\n * const program = Effect.firstSuccessOf([\n * primary,\n * secondary,\n * tertiary\n * ])\n *\n * Effect.runSync(program) // => \"secondary result\"\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const firstSuccessOf = internal.firstSuccessOf;\n// -----------------------------------------------------------------------------\n// Delays & timeouts\n// -----------------------------------------------------------------------------\n/**\n * Adds a time limit to an effect, triggering a timeout if the effect exceeds\n * the duration.\n *\n * **When to use**\n *\n * Use when you need a timeout of an `Effect` to be represented as a typed\n * failure.\n *\n * **Details**\n *\n * The `timeout` function allows you to specify a time limit for an\n * effect's execution. If the effect does not complete within the given time, a\n * `TimeoutError` is raised. This can be useful for controlling how long your\n * program waits for a task to finish, ensuring that it doesn't hang\n * indefinitely if the task takes too long.\n *\n * **Gotchas**\n *\n * If the timeout wins, the source effect is interrupted.\n *\n * **Example** (Failing when work takes too long)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const timedEffect = Effect.never.pipe(Effect.timeout(0))\n * const error = await Effect.runPromise(Effect.flip(timedEffect))\n * error._tag // => \"TimeoutError\"\n * ```\n *\n * @see {@link timeoutOption} for returning `Option.none` on timeout.\n * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.\n *\n * @category delays & timeouts\n * @since 2.0.0\n */\nexport const timeout = internal.timeout;\n/**\n * Runs an effect with a time limit and represents only the timeout case as\n * `Option.none`.\n *\n * **When to use**\n *\n * Use when a timeout of an `Effect` should be handled as `Option.none`.\n *\n * **Details**\n *\n * If the source effect succeeds before the timeout, the returned effect\n * succeeds with `Option.some(value)`. If the timeout wins, the source effect is\n * interrupted and the returned effect succeeds with `Option.none`. If the\n * source effect fails before the timeout, that failure is preserved.\n *\n * **Example** (Returning None on timeout)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const timedOutEffect = Effect.never.pipe(Effect.timeoutOption(0))\n * await Effect.runPromise(timedOutEffect) // => Option.none()\n * ```\n *\n * @see {@link timeout} for a version that raises a `TimeoutError`.\n * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.\n *\n * @category delays & timeouts\n * @since 3.1.0\n */\nexport const timeoutOption = internal.timeoutOption;\n/**\n * Applies a timeout to an effect, lazily evaluating `orElse` after interrupting\n * the source if the timeout is reached.\n *\n * **Example** (Falling back on timeout)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.timeoutOrElse(Effect.never, {\n * duration: 0,\n * orElse: () => Effect.sync(() => { output.push(\"Query timed out, using cached data\") }).pipe(\n * Effect.as(\"Cached result\")\n * )\n * })\n *\n * void output.push(await Effect.runPromise(program))\n * output // => [\"Query timed out, using cached data\", \"Cached result\"]\n * ```\n *\n * @see {@link timeout} for failing with a `TimeoutError`.\n * @see {@link timeoutOption} for returning `Option.none` on timeout.\n *\n * @category delays & timeouts\n * @since 4.0.0\n */\nexport const timeoutOrElse = internal.timeoutOrElse;\n/**\n * Returns an effect that is delayed from this effect by the specified\n * `Duration`.\n *\n * **Example** (Delaying an effect)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.delay(Effect.sync(() => { output.push(\"Delayed message\") }), 0)\n *\n * await Effect.runPromise(program)\n * output // => [\"Delayed message\"]\n * ```\n *\n * @category delays & timeouts\n * @since 2.0.0\n */\nexport const delay = internal.delay;\n/**\n * Returns an effect that suspends the current fiber for the specified duration\n * without blocking a JavaScript thread.\n *\n * **Example** (Pausing without blocking)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Start\") })\n * yield* Effect.sleep(0)\n * yield* Effect.sync(() => { output.push(\"End\") })\n * })\n *\n * await Effect.runPromise(program)\n * output // => [\"Start\", \"End\"]\n * ```\n *\n * @category delays & timeouts\n * @since 2.0.0\n */\nexport const sleep = internal.sleep;\n/**\n * Returns the runtime duration of an effect together with its result.\n *\n * **Details**\n *\n * The original success, failure, or interruption is preserved; only the success\n * value is paired with the duration.\n *\n * **Example** (Measuring execution time)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const [, value] = yield* Effect.timed(Effect.succeed(\"ok\"))\n * return value\n * })\n *\n * Effect.runSync(program) // => \"ok\"\n * ```\n *\n * @category delays & timeouts\n * @since 2.0.0\n */\nexport const timed = internal.timed;\n// -----------------------------------------------------------------------------\n// Racing\n// -----------------------------------------------------------------------------\n/**\n * Runs multiple effects concurrently and returns the first successful result.\n *\n * **When to use**\n *\n * Use when early failures should be ignored until a success occurs\n * or all effects fail.\n *\n * **Details**\n *\n * Early failures do not finish the race; `raceAll` keeps waiting until one\n * effect succeeds or every effect has failed. When one effect succeeds, the\n * remaining effects are interrupted. If every effect fails, the returned effect\n * fails with a cause containing the collected failure reasons.\n *\n * **Example** (Racing many effects)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const raced = Effect.raceAll([\n * Effect.succeed(\"Fast\"),\n * Effect.never\n * ])\n * await Effect.runPromise(raced) // => \"Fast\"\n * ```\n *\n * @see {@link race} for a version that handles only two effects.\n * @category racing\n * @since 2.0.0\n */\nexport const raceAll = internal.raceAll;\n/**\n * Runs multiple effects concurrently and completes with the first effect to\n * finish, whether it succeeds or fails.\n *\n * **Details**\n *\n * After the first effect completes, all remaining effects are interrupted. Use\n * `raceAll` when early failures should be ignored until a success occurs or\n * all effects fail.\n *\n * **Example** (Taking the first settled result)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const raced = Effect.raceAllFirst([\n * Effect.fail(\"First failed\"),\n * Effect.never\n * ])\n * await Effect.runPromise(Effect.flip(raced)) // => \"First failed\"\n * ```\n *\n * @category racing\n * @since 4.0.0\n */\nexport const raceAllFirst = internal.raceAllFirst;\n/**\n * Races two effects and returns the first successful result.\n *\n * **Details**\n *\n * If one effect succeeds, the other is interrupted and `onWinner` can observe the\n * winning fiber. If both fail, the race fails.\n *\n * **Example** (Racing two effects)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const fastFail = Effect.fail(\"fast-fail\")\n * const slowSuccess = Effect.succeed(\"slow-success\")\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Effect.race(fastFail, slowSuccess)\n * yield* Effect.sync(() => { output.push(`winner: ${result}`) })\n * })\n *\n * await Effect.runPromise(program)\n * output // => [\"winner: slow-success\"]\n * ```\n *\n * @category racing\n * @since 2.0.0\n */\nexport const race = internal.race;\n/**\n * Races two effects and returns the result of the first one to complete, whether\n * it succeeds or fails.\n *\n * **When to use**\n *\n * Use when any completion, including failure, should decide the race and\n * interrupt the losing effect.\n *\n * **Details**\n *\n * The losing effect is interrupted, and `onWinner` can observe the winning fiber.\n *\n * **Example** (Observing the winning fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const fastFail = Effect.fail(\"fast-fail\")\n * const slowSuccess = Effect.never\n *\n * const program = Effect.gen(function*() {\n * const message = yield* Effect.match(Effect.raceFirst(fastFail, slowSuccess), {\n * onFailure: (error) => `failed: ${error}`,\n * onSuccess: (value) => `succeeded: ${value}`\n * })\n * yield* Effect.sync(() => { output.push(message) })\n * })\n *\n * await Effect.runPromise(program)\n * output // => [\"failed: fast-fail\"]\n * ```\n *\n * @category racing\n * @since 2.0.0\n */\nexport const raceFirst = internal.raceFirst;\n// -----------------------------------------------------------------------------\n// Filtering\n// -----------------------------------------------------------------------------\n/**\n * Filters elements of an iterable using a predicate, refinement, or effectful\n * predicate.\n *\n * **Example** (Filtering success values)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * // Sync predicate\n * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)\n *\n * // Effectful predicate\n * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))\n *\n * void output.push(Effect.runSync(evens))\n * void output.push(Effect.runSync(checked))\n * output // => [[2, 4], [2, 3]]\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filter = internal.filter;\n/**\n * Filters and maps elements of an iterable with a `Filter`.\n *\n * **When to use**\n *\n * Use when you need to filter an iterable with a `Filter` inside an `Effect`,\n * collecting each filter success value.\n *\n * **Details**\n *\n * `Result.succeed` values are collected in the returned array, and\n * `Result.fail` values are skipped.\n *\n * @see {@link filter} for keeping original elements with a boolean predicate, refinement, or effectful predicate\n * @see {@link filterMapEffect} for using an effectful `Filter`\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filterMap = internal.filterMap;\n/**\n * Filters and maps elements of an iterable effectfully with a `FilterEffect`.\n *\n * **When to use**\n *\n * Use when you need to filter each iterable element effectfully and transform\n * accepted elements into successful output values.\n *\n * **Details**\n *\n * `Result.succeed` values are collected in the returned array, and\n * `Result.fail` values are skipped.\n *\n * **Gotchas**\n *\n * With concurrent execution, successful values are collected in completion\n * order, not input order.\n *\n * @see {@link filterMap} for using a synchronous `Filter`\n * @see {@link filter} for keeping original elements with a predicate\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterMapEffect = internal.filterMapEffect;\n/**\n * Filters an effect, providing an alternative effect if the predicate fails.\n *\n * **When to use**\n *\n * Use when a successful value that fails a predicate should continue with an\n * effectful fallback instead of failing the effect.\n *\n * **Details**\n *\n * This function applies a predicate to the result of an effect. If the\n * predicate evaluates to `false`, it executes the `orElse` effect instead. The\n * `orElse` effect can produce an alternative value or perform additional\n * computations.\n *\n * **Example** (Filtering with a fallback effect)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // An effect that produces a number\n * const program = Effect.succeed(5)\n *\n * // Filter for even numbers, provide alternative for odd numbers\n * const filtered = Effect.filterOrElse(\n * program,\n * (n) => n % 2 === 0,\n * (n) => Effect.succeed(`Number ${n} is odd`)\n * )\n *\n * Effect.runSync(filtered) // => \"Number 5 is odd\"\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filterOrElse = internal.filterOrElse;\n/**\n * Filters an effect with a `Filter`, providing an alternative effect on failure.\n *\n * **When to use**\n *\n * Use when a successful effect value should be accepted and transformed by a\n * `Filter`, while rejected values should continue with an alternative effect\n * built from the filter failure.\n *\n * **Details**\n *\n * `Result.succeed` becomes the returned success value, and `Result.fail` is\n * passed to `orElse`.\n *\n * @see {@link filterOrElse} for using a predicate and fallback effect\n * @see {@link filterMapOrFail} for failing the effect when the filter fails\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterMapOrElse = internal.filterMapOrElse;\n/**\n * Filters an effect, failing with a custom error if the predicate fails.\n *\n * **Details**\n *\n * This function applies a predicate to the result of an effect. If the\n * predicate evaluates to `false`, the effect fails with either a custom\n * error (if `orFailWith` is provided) or a `NoSuchElementError`.\n *\n * **Example** (Filtering with a custom failure)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // An effect that produces a number\n * const program = Effect.succeed(5)\n *\n * // Filter for even numbers, fail for odd numbers\n * const filtered = Effect.filterOrFail(\n * program,\n * (n) => n % 2 === 0,\n * (n) => `Expected even number, got ${n}`\n * )\n *\n * Effect.runSync(Effect.flip(filtered)) // => \"Expected even number, got 5\"\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filterOrFail = internal.filterOrFail;\n/**\n * Filters and maps an effect with a `Filter`, failing when the filter fails.\n *\n * **When to use**\n *\n * Use when validating and transforming one effect success with a synchronous\n * `Filter`, while rejected values should fail the effect.\n *\n * **Details**\n *\n * `Result.succeed` becomes the returned success value. `Result.fail` is mapped\n * with `orFailWith` when provided, or fails with `NoSuchElementError`.\n *\n * @see {@link filterMapOrElse} for continuing with a fallback effect when the filter fails\n * @see {@link filterOrFail} for validating with a predicate instead of a `Filter`\n * @see {@link filterMap} for filtering and mapping iterable elements\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterMapOrFail = internal.filterMapOrFail;\n// -----------------------------------------------------------------------------\n// Conditional Operators\n// -----------------------------------------------------------------------------\n/**\n * Runs an effect conditionally based on the result of an effectful boolean\n * condition.\n *\n * **When to use**\n *\n * Use when you need an effectful check to decide whether another effect should\n * run while representing the skipped case explicitly.\n *\n * **Details**\n *\n * The condition effect is evaluated first. If it succeeds with `true`, the\n * source effect is run and its success value is wrapped in `Option.some`. If it\n * succeeds with `false`, the source effect is skipped and the result is\n * `Option.none`. If the condition effect fails, that failure is preserved.\n *\n * **Example** (Conditionally running an effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n * const output: Array = []\n *\n * const shouldLog = true\n *\n * const program = Effect.when(\n * Effect.sync(() => { output.push(\"Condition is true!\") }),\n * Effect.succeed(shouldLog)\n * )\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Condition is true!\", Option.some(undefined)]\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const when = internal.when;\n// -----------------------------------------------------------------------------\n// Pattern matching\n// -----------------------------------------------------------------------------\n/**\n * Handles both success and failure cases of an effect without performing side\n * effects.\n *\n * **When to use**\n *\n * Use when you need to fold an `Effect` into a value by handling success and\n * failure differently without triggering side effects.\n *\n * **Details**\n *\n * `match` lets you define custom handlers for both success and failure\n * scenarios. You provide separate functions to handle each case, allowing you\n * to process the result if the effect succeeds, or handle the error if the\n * effect fails.\n *\n * **Example** (Matching success and failure values)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class ExampleError extends Data.TaggedError(\"ExampleError\")<{ readonly message: string }> {}\n *\n * const success: Effect.Effect = Effect.succeed(42)\n *\n * const program1 = Effect.match(success, {\n * onFailure: (error) => `failure: ${error.message}`,\n * onSuccess: (value) => `success: ${value}`\n * })\n *\n * // Run and log the result of the successful effect\n * Effect.runSync(program1) // => \"success: 42\"\n *\n * const failure: Effect.Effect = Effect.fail(\n * new ExampleError({ message: \"Uh oh!\" })\n * )\n *\n * const program2 = Effect.match(failure, {\n * onFailure: (error) => `failure: ${error.message}`,\n * onSuccess: (value) => `success: ${value}`\n * })\n *\n * // Run and log the result of the failed effect\n * Effect.runSync(program2) // => \"failure: Uh oh!\"\n * ```\n *\n * @see {@link matchEffect} if you need to perform side effects in the handlers.\n * @category pattern matching\n * @since 2.0.0\n */\nexport const match = internal.match;\n/**\n * Handles both success and failure cases of an effect without performing side\n * effects, with eager evaluation for resolved effects.\n *\n * **When to use**\n *\n * Use when you need to handle both success and failure cases of an\n * already-resolved `Effect` with optimized handling.\n *\n * **Details**\n *\n * `matchEager` works like `match` but provides better performance for resolved\n * effects (Success or Failure). When the effect is already resolved, it applies\n * the handlers immediately without fiber scheduling. For unresolved effects,\n * it falls back to the regular `match` behavior.\n *\n * **Example** (Pattern matching eagerly when possible)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Effect.matchEager(Effect.succeed(42), {\n * onFailure: (error) => `Failed: ${error}`,\n * onSuccess: (value) => `Success: ${value}`\n * })\n * void output.push(result)\n * })\n *\n * Effect.runSync(program)\n * output // => [\"Success: 42\"]\n * ```\n *\n * @see {@link match} for the non-eager version.\n * @see {@link matchEffect} if you need to perform side effects in the handlers.\n * @category pattern matching\n * @since 4.0.0\n */\nexport const matchEager = internal.matchEager;\n/**\n * Handles failures by matching the cause of failure.\n *\n * **When to use**\n *\n * Use when you need to fold an `Effect` while the failure handler inspects the\n * full `Cause`.\n *\n * **Details**\n *\n * The `matchCause` function allows you to handle failures with access to the\n * full cause of the failure within a fiber.\n *\n * **Example** (Matching on success or failure causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect } from \"effect\"\n *\n * const task = Effect.fail(\"Something went wrong\")\n *\n * const program = Effect.matchCause(task, {\n * onFailure: (cause) => `Failed: ${Cause.squash(cause)}`,\n * onSuccess: (value) => `Success: ${value}`\n * })\n *\n * Effect.runSync(program) // => \"Failed: Something went wrong\"\n * ```\n *\n * @see {@link matchCauseEffect} if you need to perform side effects in the\n * handlers.\n * @see {@link match} if you don't need to handle the cause of the failure.\n * @category pattern matching\n * @since 2.0.0\n */\nexport const matchCause = internal.matchCause;\n/**\n * Handles failures by matching the cause of failure with eager evaluation.\n *\n * **When to use**\n *\n * Use when you expect an `Effect` to already be resolved and want to match the\n * `Cause` without regular effect pipeline overhead.\n *\n * **Details**\n *\n * `matchCauseEager` works like `matchCause` but provides better performance for resolved\n * effects by immediately applying the matching function instead of deferring it\n * through the effect pipeline.\n *\n * **Example** (Eagerly matching already completed effects)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const handleResult = Effect.matchCauseEager(Effect.succeed(42), {\n * onSuccess: (value) => `Success: ${value}`,\n * onFailure: (cause) => `Failed: ${cause}`\n * })\n * Effect.runSync(handleResult) // => \"Success: 42\"\n * ```\n *\n * @category pattern matching\n * @since 4.0.0\n */\nexport const matchCauseEager = internal.matchCauseEager;\n/**\n * Handles success or failure eagerly with effectful handlers when the effect is already resolved.\n *\n * **When to use**\n *\n * Use when you need effectful success and cause-aware failure handlers for\n * `Effect` inputs that may already be resolved.\n *\n * **Details**\n *\n * If the effect is an `Exit`, the matching handler runs immediately; otherwise it behaves like\n * {@link matchCauseEffect}.\n *\n * @see {@link matchCauseEffect} for the non-eager effectful variant\n * @see {@link matchCauseEager} for eager cause matching with pure handlers\n * @see {@link matchEffect} for effectful matching on typed failures instead of full causes\n *\n * @category pattern matching\n * @since 4.0.0\n */\nexport const matchCauseEffectEager = internal.matchCauseEffectEager;\n/**\n * Handles failures with access to the cause and allows performing side effects.\n *\n * **When to use**\n *\n * Use when you need to fold an `Effect` with effectful success handlers and\n * `Cause`-aware failure handlers.\n *\n * **Details**\n *\n * The `matchCauseEffect` function works similarly to {@link matchCause}, but it\n * also allows you to perform additional side effects based on the failure\n * cause. This function provides access to the complete cause of the failure,\n * making it possible to differentiate between various failure types, and allows\n * you to respond accordingly while performing side effects (like logging or\n * other operations).\n *\n * **Example** (Effectfully matching on causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Data, Effect, Result } from \"effect\"\n * const output: Array = []\n *\n * class TaskError extends Data.TaggedError(\"TaskError\")<{ readonly message: string }> {}\n *\n * const task = Effect.fail(new TaskError({ message: \"Task failed\" }))\n *\n * const program = Effect.matchCauseEffect(task, {\n * onFailure: (cause) =>\n * Effect.gen(function*() {\n * if (Cause.hasFails(cause)) {\n * const error = Cause.findError(cause)\n * if (Result.isSuccess(error)) {\n * yield* Effect.sync(() => { output.push(`Handling error: ${error.success.message}`) })\n * }\n * return \"recovered from error\"\n * } else {\n * yield* Effect.sync(() => { output.push(\"Handling interruption or defect\") })\n * return \"recovered from interruption/defect\"\n * }\n * }),\n * onSuccess: (value) =>\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(`Success: ${value}`) })\n * return `processed ${value}`\n * })\n * })\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Handling error: Task failed\", \"recovered from error\"]\n * ```\n *\n * @see {@link matchCause} if you don't need side effects and only want to handle the result or failure.\n * @see {@link matchEffect} if you don't need to handle the cause of the failure.\n *\n * @category pattern matching\n * @since 2.0.0\n */\nexport const matchCauseEffect = internal.matchCauseEffect;\n/**\n * Handles both success and failure by running effectful handlers.\n *\n * **When to use**\n *\n * Use when you need to handle an `Effect`'s failure or success with handlers\n * that return effects.\n *\n * **Details**\n *\n * Use `matchEffect` when either branch needs to return an `Effect`, such as\n * performing logging, recovery, notification, or other effectful work. The\n * returned effect succeeds or fails according to the handler that is run.\n *\n * **Example** (Matching success and failure with effectful handlers)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class ExampleError extends Data.TaggedError(\"ExampleError\")<{ readonly message: string }> {}\n *\n * const success: Effect.Effect = Effect.succeed(42)\n * const failure: Effect.Effect = Effect.fail(\n * new ExampleError({ message: \"Uh oh!\" })\n * )\n *\n * const program1 = Effect.matchEffect(success, {\n * onFailure: (error) =>\n * Effect.succeed(`failure: ${error.message}`),\n * onSuccess: (value) =>\n * Effect.succeed(`success: ${value}`)\n * })\n *\n * Effect.runSync(program1) // => \"success: 42\"\n *\n * const program2 = Effect.matchEffect(failure, {\n * onFailure: (error) =>\n * Effect.succeed(`failure: ${error.message}`),\n * onSuccess: (value) =>\n * Effect.succeed(`success: ${value}`)\n * })\n *\n * Effect.runSync(program2) // => \"failure: Uh oh!\"\n * ```\n *\n * @see {@link match} if you don't need side effects and only want to handle the\n * result or failure.\n * @category pattern matching\n * @since 2.0.0\n */\nexport const matchEffect = internal.matchEffect;\n// -----------------------------------------------------------------------------\n// Condition checking\n// -----------------------------------------------------------------------------\n/**\n * Determines whether an effect fails.\n *\n * **Details**\n *\n * Defects are not converted; if the effect dies, the resulting effect dies too.\n *\n * **Example** (Checking whether an effect fails)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * const failed = yield* Effect.isFailure(Effect.fail(\"Uh oh!\"))\n * yield* Effect.sync(() => { output.push(failed) })\n * })\n *\n * Effect.runSync(program)\n * output // => [true]\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isFailure = internal.isFailure;\n/**\n * Returns whether an effect completes successfully.\n *\n * **Details**\n *\n * Returns `false` for failures in the error channel, but defects still fail the\n * effect.\n *\n * **Example** (Checking whether an effect succeeds)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * const ok = yield* Effect.isSuccess(Effect.succeed(\"done\"))\n * const failed = yield* Effect.isSuccess(Effect.fail(\"Uh oh\"))\n * yield* Effect.sync(() => { output.push(`ok: ${ok}`) })\n * yield* Effect.sync(() => { output.push(`failed: ${failed}`) })\n * })\n *\n * Effect.runSync(program)\n * output // => [\"ok: true\", \"failed: false\"]\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isSuccess = internal.isSuccess;\n// -----------------------------------------------------------------------------\n// Environment\n// -----------------------------------------------------------------------------\n/**\n * Returns the complete context.\n *\n * **When to use**\n *\n * Use to read the complete `Context` available to the current effect.\n *\n * **Details**\n *\n * This function allows you to access all services that are currently available\n * in the effect's environment. This can be useful for debugging, introspection,\n * or when you need to pass the entire context to another function.\n *\n * **Example** (Reading the full context)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Option } from \"effect\"\n * const output: Array = []\n *\n * const Logger = Context.Service<{\n * log: (msg: string) => void\n * }>(\"Logger\")\n * const Database = Context.Service<{\n * query: (sql: string) => string\n * }>(\"Database\")\n *\n * const program = Effect.gen(function*() {\n * const allServices = yield* Effect.context()\n *\n * // Check if specific services are available\n * const loggerOption = Context.getOption(allServices, Logger)\n * const databaseOption = Context.getOption(allServices, Database)\n *\n * yield* Effect.sync(() => { output.push(`Logger available: ${Option.isSome(loggerOption)}`) })\n * yield* Effect.sync(() => { output.push(`Database available: ${Option.isSome(databaseOption)}`) })\n * })\n *\n * const context = Context.make(Logger, { log: () => {} })\n * .pipe(Context.add(Database, { query: () => \"result\" }))\n *\n * const provided = Effect.provideContext(program, context)\n * Effect.runSync(provided)\n * output // => [\"Logger available: true\", \"Database available: true\"]\n * ```\n *\n * @see {@link contextWith} for deriving an effect from the complete context\n * @see {@link service} for reading one service from the context\n *\n * @category accessors\n * @since 2.0.0\n */\nexport const context = internal.context;\n/**\n * Transforms the current context using the provided function.\n *\n * **When to use**\n *\n * Use to derive an effect from the complete `Context`.\n *\n * **Details**\n *\n * This function allows you to access the complete context and perform\n * computations based on all available services. This is useful when you need\n * to conditionally execute logic based on what services are available.\n *\n * **Example** (Deriving values from the context)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Option } from \"effect\"\n * const output: Array = []\n *\n * const Logger = Context.Service<{\n * log: (msg: string) => void\n * }>(\"Logger\")\n * const Cache = Context.Service<{\n * get: (key: string) => string | null\n * }>(\"Cache\")\n *\n * const program = Effect.contextWith((services: Context.Context>) => {\n * const cacheOption = Context.getOption(services, Cache)\n * const hasCache = Option.isSome(cacheOption)\n *\n * if (hasCache) {\n * return Effect.gen(function*() {\n * const cache = yield* Effect.service(Cache)\n * yield* Effect.sync(() => { output.push(\"Using cached data\") })\n * return cache.get(\"user:123\") || \"default\"\n * })\n * } else {\n * return Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"No cache available, using fallback\") })\n * return \"fallback data\"\n * })\n * }\n * })\n *\n * const withCache = Effect.provideService(program, Cache, {\n * get: () => \"cached_value\"\n * })\n * void output.push(Effect.runSync(withCache))\n * output // => [\"Using cached data\", \"cached_value\"]\n * ```\n *\n * @see {@link context} for reading the complete context as a value\n * @see {@link service} for reading one service from the context\n *\n * @category accessors\n * @since 2.0.0\n */\nexport const contextWith = internal.contextWith;\n/**\n * Provides dependencies to an effect using layers or a context. Use `options.local`\n * to build the layer every time; by default, layers are shared between provide\n * calls.\n *\n * **Example** (Providing dependencies with a layer)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Layer } from \"effect\"\n *\n * interface Database {\n * readonly query: (sql: string) => Effect.Effect\n * }\n *\n * const Database = Context.Service(\"Database\")\n *\n * const DatabaseLayer = Layer.succeed(Database)({\n * query: Effect.fn(\"Database.query\")((sql: string) => Effect.succeed(`Result for: ${sql}`))\n * })\n *\n * const program = Effect.gen(function*() {\n * const db = yield* Database\n * return yield* db.query(\"SELECT * FROM users\")\n * })\n *\n * const provided = Effect.provide(program, DatabaseLayer)\n *\n * await Effect.runPromise(provided) // => \"Result for: SELECT * FROM users\"\n * ```\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const provide = internalLayer.provide;\n/**\n * Provides a context to an effect, fulfilling its service requirements.\n *\n * **Details**\n *\n * This function provides multiple services at once by supplying a context\n * that contains all the required services. It removes the provided services\n * from the effect's requirements, making them available to the effect.\n *\n * **Example** (Providing a complete context)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n * const output: Array = []\n *\n * // Define service keys\n * const Logger = Context.Service<{\n * log: (msg: string) => void\n * }>(\"Logger\")\n * const Database = Context.Service<{\n * query: (sql: string) => string\n * }>(\"Database\")\n *\n * // Create a context with multiple services\n * const context = Context.make(Logger, { log: (message) => { output.push(message) } })\n * .pipe(Context.add(Database, { query: () => \"result\" }))\n *\n * // An effect that requires both services\n * const program = Effect.gen(function*() {\n * const logger = yield* Effect.service(Logger)\n * const db = yield* Effect.service(Database)\n * logger.log(\"Querying database\")\n * return db.query(\"SELECT * FROM users\")\n * })\n *\n * const provided = Effect.provideContext(program, context)\n * void output.push(Effect.runSync(provided))\n * output // => [\"Querying database\", \"result\"]\n * ```\n *\n * @category providing services\n * @since 4.0.0\n */\nexport const provideContext = internal.provideContext;\n/**\n * Runs an effect with the provided context as its complete environment.\n *\n * **When to use**\n *\n * Use when you already have a `Context` containing every service required by\n * the effect and want the wrapped effect to run with exactly that context.\n *\n * **Gotchas**\n *\n * `setContext` replaces the current context for the wrapped effect. Services\n * from an outer context are not inherited unless they are also present in the\n * context passed to `setContext`.\n *\n * **Example** (Running with a complete context)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n *\n * class Config extends Context.Service()(\"Config\") {}\n *\n * const program = Effect.gen(function*() {\n * const config = yield* Effect.service(Config)\n * return `${config.greeting}, World!`\n * })\n *\n * const context = Context.make(Config, { greeting: \"Hello\" })\n *\n * const runnable = Effect.setContext(program, context)\n *\n * Effect.runSync(runnable) // => \"Hello, World!\"\n * ```\n *\n * @see {@link provideContext} for partially satisfying an effect's context requirements.\n * @see {@link updateContext} for deriving the required context from the current one.\n *\n * @category providing services\n * @since 4.0.0\n */\nexport const setContext = internal.setContext;\n/**\n * Accesses a service from the context.\n *\n * **Example** (Accessing a required service)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n *\n * interface Database {\n * readonly query: (sql: string) => Effect.Effect\n * }\n *\n * const Database = Context.Service(\"Database\")\n *\n * const program = Effect.gen(function*() {\n * const db = yield* Effect.service(Database)\n * return yield* db.query(\"SELECT * FROM users\")\n * })\n *\n * const runnable = Effect.provideService(program, Database, {\n * query: (sql) => Effect.succeed(`Result for: ${sql}`)\n * })\n * Effect.runSync(runnable) // => \"Result for: SELECT * FROM users\"\n * ```\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const service = internal.service;\n/**\n * Optionally accesses a service from the environment.\n *\n * **When to use**\n *\n * Use to read an optional dependency from the current context without making\n * that dependency part of the effect's required environment.\n *\n * **Details**\n *\n * This function attempts to access a service from the environment. If the\n * service is available, it returns `Some(service)`. If the service is not\n * available, it returns `None`. Unlike `service`, this function does not\n * require the service to be present in the environment.\n *\n * **Example** (Accessing an optional service)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Option } from \"effect\"\n * const output: Array = []\n *\n * // Define a service key\n * const Logger = Context.Service<{\n * log: (msg: string) => void\n * }>(\"Logger\")\n *\n * // Use serviceOption to optionally access the logger\n * const program = Effect.gen(function*() {\n * const maybeLogger = yield* Effect.serviceOption(Logger)\n *\n * if (Option.isSome(maybeLogger)) {\n * maybeLogger.value.log(\"Service is available\")\n * } else {\n * void output.push(\"Service not available\")\n * }\n * })\n *\n * Effect.runSync(program)\n * output // => [\"Service not available\"]\n * ```\n *\n * @category accessors\n * @since 2.0.0\n */\nexport const serviceOption = internal.serviceOption;\n/**\n * Provides part of the required context while leaving the rest unchanged.\n *\n * **Details**\n *\n * This function allows you to transform the context required by an effect,\n * providing part of the context and leaving the rest to be fulfilled later.\n *\n * **Example** (Updating the context before running)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n *\n * // Define services\n * const Logger = Context.Service<{\n * log: (msg: string) => void\n * }>(\"Logger\")\n * const Config = Context.Service<{\n * name: string\n * }>(\"Config\")\n *\n * const program = Effect.service(Config).pipe(\n * Effect.map((config) => `Hello ${config.name}!`)\n * )\n *\n * // Transform services by providing Config while keeping Logger requirement\n * const configured = program.pipe(\n * Effect.updateContext((context: Context.Context>) =>\n * Context.add(context, Config, { name: \"World\" })\n * )\n * )\n *\n * // The effect now requires only Logger service\n * const result = Effect.provideService(configured, Logger, {\n * log: () => {}\n * })\n * Effect.runSync(result) // => \"Hello World!\"\n * ```\n *\n * @category providing services\n * @since 4.0.0\n */\nexport const updateContext = internal.updateContext;\n/**\n * Runs an effect with a service implementation transformed by the provided\n * function.\n *\n * **Details**\n *\n * The service must be available in the effect's context; `updateService`\n * replaces it for the wrapped effect with the value returned by the updater.\n *\n * **Example** (Replacing a service for one effect)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n * const output: Array = []\n *\n * // Define a counter service\n * const Counter = Context.Service<{ count: number }>(\"Counter\")\n *\n * const program = Effect.gen(function*() {\n * const updatedCounter = yield* Effect.service(Counter)\n * yield* Effect.sync(() => { output.push(`Updated count: ${updatedCounter.count}`) })\n * return updatedCounter.count\n * }).pipe(\n * Effect.updateService(Counter, (counter) => ({ count: counter.count + 1 }))\n * )\n *\n * // Provide initial service and run\n * const result = Effect.provideService(program, Counter, { count: 0 })\n * void output.push(Effect.runSync(result))\n * output // => [\"Updated count: 1\", 1]\n * ```\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const updateService = internal.updateService;\n/**\n * Updates a service for the lifetime of the current scope and restores its\n * previous value when the scope closes.\n *\n * **When to use**\n *\n * Use when you need a setup effect to change a service for subsequent effects\n * in the same scope.\n *\n * **Details**\n *\n * The updater receives the currently visible service value. A\n * `Context.Service` remains in the requirements, while a `Context.Reference`\n * uses its default when no override is present and adds no service requirement.\n * The returned effect always requires `Scope`. The optional `reset` function\n * receives the original, updated, and current values when the scope closes,\n * allowing changes to be merged during restoration. It defaults to returning\n * the original value.\n *\n * **Example** (Updating a reference within a scope)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n * const output: Array = []\n *\n * const CurrentNumber = Context.Reference(\"CurrentNumber\", {\n * defaultValue: () => 1\n * })\n *\n * const program = Effect.gen(function*() {\n * const before = yield* CurrentNumber\n * const during = yield* Effect.scoped(\n * Effect.gen(function*() {\n * yield* Effect.updateServiceScoped(\n * CurrentNumber,\n * (value) => value + 1,\n * {\n * // Optional: when omitted, the original value is restored\n * reset: (original, updated, current) =>\n * Math.max(original, updated, current) + 1\n * }\n * )\n * return yield* CurrentNumber\n * })\n * )\n * const after = yield* CurrentNumber\n *\n * void output.push([before, during, after])\n * })\n *\n * await Effect.runPromise(program)\n * output // => [[1, 2, 3]]\n * ```\n *\n * @see {@link updateService} for updating a service only within a wrapped effect\n *\n * @category providing services\n * @since 4.0.0\n */\nexport const updateServiceScoped = internal.updateServiceScoped;\n/**\n * Provides one concrete service implementation to an effect.\n *\n * **When to use**\n *\n * Use to satisfy one service requirement with an already-built implementation.\n *\n * **Details**\n *\n * The service requirement identified by the `Context.Key` is removed from the\n * effect requirements after the implementation is provided.\n *\n * **Example** (Providing a service value)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n * const output: Array = []\n *\n * // Define a service for configuration\n * const Config = Context.Service<{\n * apiUrl: string\n * timeout: number\n * }>(\"Config\")\n *\n * const fetchData = Effect.gen(function*() {\n * const config = yield* Effect.service(Config)\n * yield* Effect.sync(() => { output.push(`Fetching from: ${config.apiUrl}`) })\n * yield* Effect.sync(() => { output.push(`Timeout: ${config.timeout}ms`) })\n * return \"data\"\n * })\n *\n * // Provide the service implementation\n * const program = Effect.provideService(fetchData, Config, {\n * apiUrl: \"https://api.example.com\",\n * timeout: 5000\n * })\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Fetching from: https://api.example.com\", \"Timeout: 5000ms\", \"data\"]\n * ```\n *\n * @see {@link provide} for providing multiple layers to an effect.\n * @see {@link provideServiceEffect} for acquiring the service implementation effectfully.\n * @see {@link provideContext} for providing a complete context.\n * @category providing services\n * @since 2.0.0\n */\nexport const provideService = internal.provideService;\n/**\n * Provides one service to an effect using an effectful acquisition.\n *\n * **When to use**\n *\n * Use when the service implementation must be created by an effect and its\n * acquisition failure should remain in the returned effect.\n *\n * **Details**\n *\n * `provideServiceEffect` runs the acquisition effect to produce the service\n * implementation, removes that service from the wrapped effect's requirements,\n * and leaves any other requirements to be provided later. Acquisition failures\n * are included in the returned effect's error channel.\n *\n * **Example** (Providing a service with an effect)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n * const output: Array = []\n *\n * // Define a database connection service\n * interface DatabaseConnection {\n * readonly query: (sql: string) => Effect.Effect\n * }\n * const Database = Context.Service(\"Database\")\n *\n * // Effect that creates a database connection\n * const createConnection = Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Establishing database connection...\") })\n * yield* Effect.sync(() => { output.push(\"Database connected!\") })\n * return {\n * query: (sql: string) => Effect.succeed(`Result for: ${sql}`)\n * }\n * })\n *\n * const program = Effect.gen(function*() {\n * const db = yield* Effect.service(Database)\n * return yield* db.query(\"SELECT * FROM users\")\n * })\n *\n * // Provide the service through an effect\n * const withDatabase = Effect.provideServiceEffect(\n * program,\n * Database,\n * createConnection\n * )\n *\n * void output.push(await Effect.runPromise(withDatabase))\n * output // => [\"Establishing database connection...\", \"Database connected!\", \"Result for: SELECT * FROM users\"]\n * ```\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const provideServiceEffect = internal.provideServiceEffect;\n// -----------------------------------------------------------------------------\n// Resource management & finalization\n// -----------------------------------------------------------------------------\n/**\n * Returns the current scope for resource management.\n *\n * **Example** (Accessing the current scope)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * const currentScope = yield* Effect.scope\n * yield* Effect.sync(() => { output.push(\"Got scope for resource management\") })\n *\n * // Use the scope to manually manage resources if needed\n * const resource = yield* Effect.acquireRelease(\n * Effect.sync(() => { output.push(\"Acquiring resource\") }).pipe(Effect.as(\"resource\")),\n * () => Effect.sync(() => { output.push(\"Releasing resource\") })\n * )\n *\n * return resource\n * })\n *\n * void output.push(Effect.runSync(Effect.scoped(program)))\n * output // => [\"Got scope for resource management\", \"Acquiring resource\", \"Releasing resource\", \"resource\"]\n * ```\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const scope = internal.scope;\n/**\n * Runs an effect with a scope that closes when the effect completes.\n *\n * **When to use**\n *\n * Use to acquire scoped resources for the duration of a single workflow.\n *\n * **Details**\n *\n * Finalizers for resources acquired inside the workflow run as soon as the\n * workflow completes, whether by success, failure, or interruption.\n *\n * **Example** (Running a scoped acquisition)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const resource = Effect.acquireRelease(\n * Effect.sync(() => { output.push(\"Acquiring resource\") }).pipe(Effect.as(\"resource\")),\n * () => Effect.sync(() => { output.push(\"Releasing resource\") })\n * )\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * const res = yield* resource\n * yield* Effect.sync(() => { output.push(`Using ${res}`) })\n * return res\n * })\n * )\n *\n * Effect.runSync(program)\n * output // => [\"Acquiring resource\", \"Using resource\", \"Releasing resource\"]\n * ```\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const scoped = internal.scoped;\n/**\n * Creates a scoped effect by providing access to the scope.\n *\n * **When to use**\n *\n * Use when resource acquisition needs direct access to the scope being created,\n * for example to register finalizers manually.\n *\n * **Example** (Working with an explicit scope)\n *\n * ```ts import.meta.vitest\n * import { Effect, Scope } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.scopedWith((scope) =>\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Inside scoped context\") })\n *\n * // Manually add a finalizer to the scope\n * yield* Scope.addFinalizer(scope, Effect.sync(() => { output.push(\"Manual finalizer\") }))\n *\n * // Create a scoped resource\n * const resource = yield* Effect.scoped(\n * Effect.acquireRelease(\n * Effect.sync(() => { output.push(\"Acquiring resource\") }).pipe(Effect.as(\"resource\")),\n * () => Effect.sync(() => { output.push(\"Releasing resource\") })\n * )\n * )\n *\n * return resource\n * })\n * )\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Inside scoped context\", \"Acquiring resource\", \"Releasing resource\", \"Manual finalizer\", \"resource\"]\n * ```\n *\n * @category resource management\n * @since 3.11.0\n */\nexport const scopedWith = internal.scopedWith;\n/**\n * Constructs a scoped resource from an acquisition effect and a release\n * finalizer.\n *\n * **When to use**\n *\n * Use to acquire a scoped resource with an explicit release finalizer.\n *\n * **Details**\n *\n * If acquisition succeeds, the release finalizer is added to the current scope\n * and is guaranteed to run when that scope closes. The finalizer receives the\n * `Exit` value used to close the scope.\n *\n * By default, acquisition is protected by an uninterruptible region. Pass\n * `{ interruptible: true }` to allow the acquisition effect to be interrupted.\n *\n * **Example** (Acquiring and releasing a resource)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * // Simulate a resource that needs cleanup\n * interface FileHandle {\n * readonly path: string\n * readonly content: string\n * }\n *\n * // Acquire a file handle\n * const acquire = Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Opening file\") })\n * return { path: \"/tmp/file.txt\", content: \"file content\" }\n * })\n *\n * // Release the file handle\n * const release = (handle: FileHandle, exit: Exit.Exit) =>\n * Effect.sync(() => { output.push(\n * `Closing file ${handle.path} with exit: ${\n * Exit.isSuccess(exit) ? \"success\" : \"failure\"\n * }`\n * ) })\n *\n * // Create a scoped resource\n * const resource = Effect.acquireRelease(acquire, release)\n *\n * // Use the resource within a scope\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * const handle = yield* resource\n * yield* Effect.sync(() => { output.push(`Using file: ${handle.path}`) })\n * return handle.content\n * })\n * )\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Opening file\", \"Using file: /tmp/file.txt\", \"Closing file /tmp/file.txt with exit: success\", \"file content\"]\n * ```\n *\n * @see {@link acquireDisposable} for resources that implement JavaScript disposal protocols\n * @see {@link acquireUseRelease} for bracketing acquire, use, and release in one effect\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const acquireRelease = internal.acquireRelease;\n/**\n * Acquires a scoped resource that implements JavaScript disposal protocols.\n *\n * **When to use**\n *\n * Use when you work with JavaScript `Disposable` or `AsyncDisposable` resources\n * that should be closed with the surrounding scope.\n *\n * **Details**\n *\n * The resource is automatically disposed when the surrounding\n * {@link Scope} is closed, using {@link Symbol.dispose} for\n * synchronous disposables or {@link Symbol.asyncDispose} for asynchronous\n * disposables.\n *\n * This is similar to {@link acquireRelease}, but uses the standard\n * JavaScript disposal protocol instead of requiring an explicit release\n * function. It works with JavaScript `Disposable` and `AsyncDisposable`\n * resources.\n *\n * **Example** (Acquiring a disposable resource)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * class Resource implements Disposable {\n * [Symbol.dispose]() {\n * void output.push(\"disposed\")\n * }\n * }\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * yield* Effect.acquireDisposable(Effect.succeed(new Resource()))\n * void output.push(\"acquired\")\n * })\n * )\n *\n * Effect.runSync(program)\n * output // => [\"acquired\", \"disposed\"]\n * ```\n *\n * @see {@link acquireRelease} for resources that need an explicit finalizer\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const acquireDisposable = internal.acquireDisposable;\n/**\n * Runs resource acquisition, usage, and release as one bracketed effect.\n *\n * **When to use**\n *\n * Use to bracket acquire, use, and release logic in one effect.\n *\n * **Details**\n *\n * `acquireUseRelease` does the following:\n *\n * 1. Ensures that the `Effect` value that acquires the resource will not be\n * interrupted. Note that acquisition may still fail due to internal\n * reasons (such as an uncaught exception).\n * 2. Ensures that the `release` `Effect` value will not be interrupted,\n * and will be executed as long as the acquisition `Effect` value\n * successfully acquires the resource.\n *\n * During the time period between the acquisition and release of the resource,\n * the `use` `Effect` value will be executed.\n *\n * If the `release` `Effect` value fails, then the entire `Effect` value will\n * fail, even if the `use` `Effect` value succeeds. If this fail-fast behavior\n * is not desired, errors produced by the `release` `Effect` value can be caught\n * and ignored.\n *\n * **Example** (Acquiring resources with cleanup)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * interface Database {\n * readonly connection: string\n * readonly query: (sql: string) => Effect.Effect\n * }\n *\n * const program = Effect.acquireUseRelease(\n * // Acquire - connect to database\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Connecting to database...\") })\n * return {\n * connection: \"db://localhost:5432\",\n * query: (sql: string) => Effect.succeed(`Result for: ${sql}`)\n * }\n * }),\n * // Use - perform database operations\n * (db) =>\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(`Connected to ${db.connection}`) })\n * const result = yield* db.query(\"SELECT * FROM users\")\n * yield* Effect.sync(() => { output.push(`Query result: ${result}`) })\n * return result\n * }),\n * // Release - close database connection\n * (db, exit) =>\n * Effect.gen(function*() {\n * if (Exit.isSuccess(exit)) {\n * yield* Effect.sync(() => { output.push(`Closing connection to ${db.connection} (success)`) })\n * } else {\n * yield* Effect.sync(() => { output.push(`Closing connection to ${db.connection} (failure)`) })\n * }\n * })\n * )\n *\n * await Effect.runPromise(program)\n * output // => [\"Connecting to database...\", \"Connected to db://localhost:5432\", \"Query result: Result for: SELECT * FROM users\", \"Closing connection to db://localhost:5432 (success)\"]\n * ```\n *\n * @see {@link acquireRelease} for scoped resources whose use happens later\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const acquireUseRelease = internal.acquireUseRelease;\n/**\n * Adds a finalizer to the current scope.\n *\n * **When to use**\n *\n * Use to register low-level cleanup in the current scope.\n *\n * **Details**\n *\n * The finalizer runs when the surrounding scope is closed and receives the\n * `Exit` value used to close the scope.\n *\n * **Example** (Registering scope finalizers)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * // Add a finalizer that runs when the scope closes\n * yield* Effect.addFinalizer((exit) =>\n * Effect.sync(() => { output.push(\n * Exit.isSuccess(exit)\n * ? \"Cleanup: Operation completed successfully\"\n * : \"Cleanup: Operation failed, cleaning up resources\"\n * ) })\n * )\n *\n * yield* Effect.sync(() => { output.push(\"Performing main operation...\") })\n *\n * // This could succeed or fail\n * return \"operation result\"\n * })\n * )\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Performing main operation...\", \"Cleanup: Operation completed successfully\", \"operation result\"]\n * ```\n *\n * @see {@link acquireRelease} for resource acquisition with a release finalizer\n * @see {@link ensuring} for attaching a finalizer to one effect\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const addFinalizer = internal.addFinalizer;\n/**\n * Returns an effect that, if this effect _starts_ execution, then the\n * specified `finalizer` is guaranteed to be executed, whether this effect\n * succeeds, fails, or is interrupted.\n *\n * **Details**\n *\n * For use cases that need access to the effect's result, see `onExit`.\n *\n * Finalizers offer very powerful guarantees, but they are low-level, and\n * should generally not be used for releasing resources. For higher-level\n * logic built on `ensuring`, see the `acquireRelease` family of methods.\n *\n * **Example** (Always running cleanup)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const task = Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Task started\") })\n * yield* Effect.sync(() => { output.push(\"Task completed\") })\n * return 42\n * })\n *\n * // Ensure cleanup always runs, regardless of success or failure\n * const program = Effect.ensuring(\n * task,\n * Effect.sync(() => { output.push(\"Cleanup: This always runs!\") })\n * )\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Task started\", \"Task completed\", \"Cleanup: This always runs!\", 42]\n * ```\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const ensuring = internal.ensuring;\n/**\n * Runs the specified effect if this effect fails, providing the error to the\n * effect if it exists. The provided effect will not be interrupted.\n *\n * **Example** (Running cleanup on failure)\n *\n * ```ts import.meta.vitest\n * import { Cause, Data, Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * class TaskError extends Data.TaggedError(\"TaskError\")<{ readonly message: string }> {}\n *\n * const error = new TaskError({ message: \"Something went wrong\" })\n * const task = Effect.fail(error)\n *\n * const program = Effect.onError(\n * task,\n * (cause) => Effect.sync(() => { output.push(`Cleanup on error: ${Cause.squash(cause)}`) })\n * )\n *\n * void output.push(Effect.runSyncExit(program))\n * output // => [\"Cleanup on error: TaskError: Something went wrong\", Exit.fail(error)]\n * ```\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const onError = internal.onError;\n/**\n * Runs the finalizer only when this effect fails and the `Cause` matches the\n * provided predicate.\n *\n * **Example** (Running cleanup for selected failures)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * const task = Effect.fail(\"boom\")\n *\n * const program = Effect.onErrorIf(\n * task,\n * Cause.hasFails,\n * (cause) =>\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(`Cause: ${Cause.squash(cause)}`) })\n * })\n * )\n *\n * void output.push(Effect.runSyncExit(program))\n * output // => [\"Cause: boom\", Exit.fail(\"boom\")]\n * ```\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const onErrorIf = internal.onErrorIf;\n/**\n * Runs the finalizer only when this effect fails and the cause matches the provided `Filter`.\n *\n * **When to use**\n *\n * Use when cleanup or diagnostics should run only for failures whose full\n * `Cause` is accepted or transformed by a `Filter`, and the finalizer needs the\n * filter's pass value plus the original cause.\n *\n * @see {@link onError} for cleanup on every failure\n * @see {@link onErrorIf} for selecting failures with a boolean predicate\n * @see {@link onExitFilter} for selecting from every exit instead of only failures\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const onErrorFilter = internal.onErrorFilter;\n/**\n * Runs an optional finalizer with the effect's `Exit` value when the effect\n * completes.\n *\n * **When to use**\n *\n * Use when you are building a low-level `Effect` operator that must inspect the\n * source effect's `Exit`, may skip finalization by returning `undefined`, or\n * must choose whether finalization is forced into an uninterruptible region.\n *\n * **Details**\n *\n * This low-level operator preserves the source effect's result unless the\n * finalizer fails. If both the source effect and the finalizer fail, the two\n * causes are merged. Prefer `onExit` for normal cleanup logic.\n *\n * @see {@link onExit} for ordinary exit-aware cleanup whose finalizer always returns an effect\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const onExitPrimitive = internal.onExitPrimitive;\n/**\n * Ensures that a cleanup function runs whether this effect succeeds, fails, or\n * is interrupted.\n *\n * **Details**\n *\n * If both the effect and the cleanup function fail, the two causes are merged.\n *\n * **Example** (Observing every exit)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * const task = Effect.succeed(42)\n *\n * const program = Effect.onExit(task, (exit) =>\n * Effect.sync(() => { output.push(\n * Exit.isSuccess(exit)\n * ? `Task succeeded with: ${exit.value}`\n * : `Task failed: ${Exit.isFailure(exit) ? exit.cause : \"interrupted\"}`\n * ) }))\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Task succeeded with: 42\", 42]\n * ```\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const onExit = internal.onExit;\n/**\n * Runs the cleanup effect only when the `Exit` satisfies the provided\n * predicate.\n *\n * **Example** (Observing selected exits)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.onExitIf(\n * Effect.succeed(42),\n * Exit.isSuccess,\n * (exit) =>\n * Exit.isSuccess(exit)\n * ? Effect.sync(() => { output.push(`Succeeded with: ${exit.value}`) })\n * : Effect.void\n * )\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Succeeded with: 42\", 42]\n * ```\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const onExitIf = internal.onExitIf;\n/**\n * Runs the cleanup effect only when the `Exit` matches the provided `Filter`.\n *\n * **When to use**\n *\n * Use when cleanup should run only for `Exit` values selected by a `Filter`,\n * and the cleanup needs the extracted pass value together with the original\n * `Exit`.\n *\n * **Details**\n *\n * `Result.fail` skips cleanup, and `Result.succeed` runs cleanup with the\n * selected value and the original `Exit`.\n *\n * @see {@link onExit} for cleanup on every exit\n * @see {@link onExitIf} for selecting exits with a boolean predicate\n * @see {@link onErrorFilter} for selecting only failure causes\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const onExitFilter = internal.onExitFilter;\n// -----------------------------------------------------------------------------\n// Caching\n// -----------------------------------------------------------------------------\n/**\n * Returns an effect that lazily computes a result and caches it for subsequent\n * evaluations.\n *\n * **When to use**\n *\n * Use when you need an expensive or time-consuming operation to be evaluated\n * once and reused by later callers.\n *\n * **Details**\n *\n * This function wraps an effect and ensures that its result is computed only\n * once. Once the result is computed, it is cached, meaning that subsequent\n * evaluations of the same effect will return the cached result without\n * re-executing the logic.\n *\n * **Example** (Memoizing an effect until invalidated)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n * const record = (value: unknown) => Effect.sync(() => { output.push(value) })\n *\n * let i = 1\n * const expensiveTask = Effect.sync(() => {\n * void output.push(\"expensive task...\")\n * return `result ${i++}`\n * })\n *\n * const program = Effect.gen(function*() {\n * void output.push(\"non-cached version:\")\n * yield* expensiveTask.pipe(Effect.andThen(record))\n * yield* expensiveTask.pipe(Effect.andThen(record))\n * void output.push(\"cached version:\")\n * const cached = yield* Effect.cached(expensiveTask)\n * yield* cached.pipe(Effect.andThen(record))\n * yield* cached.pipe(Effect.andThen(record))\n * })\n *\n * await Effect.runPromise(program)\n * output // => [\"non-cached version:\", \"expensive task...\", \"result 1\", \"expensive task...\", \"result 2\", \"cached version:\", \"expensive task...\", \"result 3\", \"result 3\"]\n * ```\n *\n * @see {@link cachedWithTTL} for a similar function that includes a\n * time-to-live duration for the cached value.\n * @see {@link cachedInvalidateWithTTL} for a similar function that includes an\n * additional effect for manually invalidating the cached value.\n * @category caching\n * @since 2.0.0\n */\nexport const cached = internal.cached;\n/**\n * Returns an effect that caches its result for a fixed duration or a duration\n * computed from its `Exit`, known as \"timeToLive\" (TTL).\n *\n * **When to use**\n *\n * Use when you need a costly effect result to be reused for a bounded duration\n * before being recomputed.\n *\n * **Details**\n *\n * This function is used to cache the result of an effect for a specified amount\n * of time. This means that the first time the effect is evaluated, its result\n * is computed and stored.\n *\n * If the effect is evaluated again within the specified `timeToLive`, the\n * cached result will be used, avoiding recomputation.\n *\n * After the specified duration has passed, the cache expires, and the effect\n * will be recomputed upon the next evaluation.\n *\n * `timeToLive` accepts a `Duration.Input` or a function from `Exit` to\n * `Duration.Input`. The function runs once after each fresh computation,\n * including failures, so successes and failures can have different TTLs. It\n * does not run when the cache is created or when a cached result is reused.\n * The callback also receives interruption exits, which are cached for the\n * returned duration.\n *\n * The TTL starts when the computation completes. Concurrent callers share the\n * pending computation. A zero TTL expires immediately, and an infinite TTL\n * keeps the result indefinitely.\n *\n * **Example** (Memoizing an effect with TTL)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n * const record = (value: unknown) => Effect.sync(() => { output.push(value) })\n *\n * let i = 1\n * const expensiveTask = Effect.sync(() => {\n * void output.push(\"expensive task...\")\n * return `result ${i++}`\n * })\n *\n * const program = Effect.gen(function*() {\n * const cached = yield* Effect.cachedWithTTL(expensiveTask, \"1 hour\")\n * yield* cached.pipe(Effect.andThen(record))\n * yield* cached.pipe(Effect.andThen(record))\n * yield* cached.pipe(Effect.andThen(record))\n * })\n *\n * Effect.runSync(program)\n * output // => [\"expensive task...\", \"result 1\", \"result 1\", \"result 1\"]\n * ```\n *\n * **Example** (Caching successes while retrying failures)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n *\n * let attempts = 0\n * const task = Effect.suspend(() =>\n * ++attempts === 1 ? Effect.fail(\"temporary failure\") : Effect.succeed(42)\n * )\n * const program = Effect.gen(function*() {\n * const cached = yield* task.pipe(\n * Effect.cachedWithTTL((exit) => Exit.isSuccess(exit) ? \"1 hour\" : 0)\n * )\n * yield* Effect.exit(cached)\n * return yield* cached\n * })\n *\n * Effect.runSync(program) // => 42\n * ```\n *\n * @see {@link cached} for a similar function that caches the result\n * indefinitely.\n * @see {@link cachedInvalidateWithTTL} for a similar function that includes an\n * additional effect for manually invalidating the cached value.\n * @category caching\n * @since 2.0.0\n */\nexport const cachedWithTTL = internal.cachedWithTTL;\n/**\n * Creates a cached effect result for a specified duration and allows manual\n * invalidation before expiration.\n *\n * **When to use**\n *\n * Use when an effect result should be cached for a bounded time and callers\n * also need a manual invalidation effect to force recomputation before\n * expiration.\n *\n * **Details**\n *\n * This function behaves similarly to {@link cachedWithTTL} by caching the\n * result of an effect for a specified period of time. However, it introduces an\n * additional feature: it provides an effect that allows you to manually\n * invalidate the cached result before it naturally expires.\n *\n * This gives you more control over the cache, allowing you to refresh the\n * result when needed, even if the original cache has not yet expired.\n *\n * Once the cache is invalidated, the next time the effect is evaluated, the\n * result will be recomputed, and the cache will be refreshed.\n *\n * **Example** (Memoizing with TTL and invalidation)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n * const record = (value: unknown) => Effect.sync(() => { output.push(value) })\n *\n * let i = 1\n * const expensiveTask = Effect.sync(() => {\n * void output.push(\"expensive task...\")\n * return `result ${i++}`\n * })\n *\n * const program = Effect.gen(function*() {\n * const [cached, invalidate] = yield* Effect.cachedInvalidateWithTTL(\n * expensiveTask,\n * \"1 hour\"\n * )\n * yield* cached.pipe(Effect.andThen(record))\n * yield* cached.pipe(Effect.andThen(record))\n * yield* invalidate\n * yield* cached.pipe(Effect.andThen(record))\n * })\n *\n * Effect.runSync(program)\n * output // => [\"expensive task...\", \"result 1\", \"result 1\", \"expensive task...\", \"result 2\"]\n * ```\n *\n * @see {@link cached} for a similar function that caches the result\n * indefinitely.\n * @see {@link cachedWithTTL} for a similar function that caches the result for\n * a specified duration but does not include an effect for manual invalidation.\n * @category caching\n * @since 2.0.0\n */\nexport const cachedInvalidateWithTTL = internal.cachedInvalidateWithTTL;\n// -----------------------------------------------------------------------------\n// Interruption\n// -----------------------------------------------------------------------------\n/**\n * Returns an effect that is immediately interrupted.\n *\n * **Example** (Creating an interrupted effect)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * return yield* Effect.interrupt\n * yield* Effect.succeed(\"This won't execute and is unreachable\")\n * })\n *\n * Effect.runSyncExit(program)._tag // => \"Failure\"\n * ```\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const interrupt = internal.interrupt;\n/**\n * Returns a new effect that allows the effect to be interruptible.\n *\n * **Example** (Allowing interruption)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const program = Effect.interruptible(Effect.never).pipe(\n * Effect.timeoutOption(0)\n * )\n * await Effect.runPromise(program) // => Option.none()\n * ```\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const interruptible = internal.interruptible;\n/**\n * Runs the specified finalizer effect if this effect is interrupted.\n *\n * **Example** (Running cleanup on interruption)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n * const output: Array = []\n *\n * const task = Effect.forever(Effect.succeed(\"working...\"))\n *\n * const program = Effect.onInterrupt(\n * task,\n * () => Effect.sync(() => { output.push(\"Task was interrupted, cleaning up...\") })\n * )\n *\n * const fiber = Effect.runFork(program)\n * await Effect.runPromise(Fiber.interrupt(fiber))\n * output // => [\"Task was interrupted, cleaning up...\"]\n * ```\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const onInterrupt = internal.onInterrupt;\n/**\n * Returns a new effect that disables interruption for the given effect.\n *\n * **Example** (Preventing interruption)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const criticalTask = Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Starting critical section...\") })\n * yield* Effect.sync(() => { output.push(\"Critical section completed\") })\n * })\n *\n * const program = Effect.uninterruptible(criticalTask)\n *\n * Effect.runSync(program)\n * output // => [\"Starting critical section...\", \"Critical section completed\"]\n * ```\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const uninterruptible = internal.uninterruptible;\n/**\n * Disables interruption and provides a restore function to restore the\n * interruptible state within the effect.\n *\n * **Example** (Restoring interruption in protected regions)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.uninterruptibleMask((restore) =>\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Uninterruptible phase...\") })\n * // Restore interruptibility for this part\n * yield* restore(\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Interruptible phase...\") })\n * })\n * )\n *\n * yield* Effect.sync(() => { output.push(\"Back to uninterruptible\") })\n * })\n * )\n *\n * Effect.runSync(program)\n * output // => [\"Uninterruptible phase...\", \"Interruptible phase...\", \"Back to uninterruptible\"]\n * ```\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const uninterruptibleMask = internal.uninterruptibleMask;\n/**\n * Runs an effect in an interruptible region while providing `restore` for\n * locally restoring the previous interruptibility.\n *\n * **Example** (Controlling interruptibility locally)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.interruptibleMask((restore) =>\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Interruptible phase...\") })\n * // Make this part uninterruptible\n * yield* restore(\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Uninterruptible phase...\") })\n * })\n * )\n *\n * yield* Effect.sync(() => { output.push(\"Back to interruptible\") })\n * })\n * )\n *\n * Effect.runSync(program)\n * output // => [\"Interruptible phase...\", \"Uninterruptible phase...\", \"Back to interruptible\"]\n * ```\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const interruptibleMask = internal.interruptibleMask;\n/**\n * Creates an AbortSignal that is managed by the provided scope.\n *\n * **When to use**\n *\n * Use to obtain a scope-managed `AbortSignal` for APIs that accept cancellation\n * through a signal.\n *\n * **Details**\n *\n * Each acquisition creates a fresh `AbortController`. Closing the owning scope\n * runs a finalizer that aborts the controller and the effect succeeds with the\n * controller's signal.\n *\n * **Gotchas**\n *\n * The signal is aborted when its owning scope closes, so avoid keeping it for\n * work that outlives that scope.\n *\n * @see {@link scoped} for binding resource lifetime to a scope\n *\n * @category interruption\n * @since 4.0.0\n */\nexport const abortSignal = internal.abortSignal;\n/**\n * Repeats this effect forever (until the first error).\n *\n * **Example** (Repeating forever)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option } from \"effect\"\n *\n * const program = Effect.forever(Effect.never).pipe(Effect.timeoutOption(0))\n * await Effect.runPromise(program) // => Option.none()\n * ```\n *\n * @category repetition\n * @since 2.0.0\n */\nexport const forever = internal.forever;\n/**\n * Repeats an effect based on a specified schedule or until the first failure.\n *\n * **When to use**\n *\n * Use to rerun an effect after successful executions.\n *\n * **Details**\n *\n * This function executes an effect repeatedly according to the given schedule.\n * Each repetition occurs after the initial execution of the effect, meaning\n * that the schedule determines the number of additional repetitions. For\n * example, using `Schedule.once` will result in the effect being executed twice\n * (once initially and once as part of the repetition).\n *\n * If the effect succeeds, it is repeated according to the schedule. If it\n * fails, the repetition stops immediately, and the failure is returned.\n *\n * The schedule can also specify delays between repetitions, making it useful\n * for tasks like retrying operations with backoff, periodic execution, or\n * performing a series of dependent actions.\n *\n * You can combine schedules for more advanced repetition logic, such as adding\n * delays, limiting recursions, or dynamically adjusting based on the outcome of\n * each execution.\n *\n * **Gotchas**\n *\n * The source effect is always evaluated once before the schedule is stepped.\n * The schedule controls additional repetitions, not the initial execution.\n *\n * **Example** (Repeating successful effects with a schedule)\n *\n * ```ts import.meta.vitest\n * // Success Example\n * import { Effect, Schedule } from \"effect\"\n * const output: Array = []\n *\n * const action = Effect.sync(() => { output.push(\"success\") })\n * const policy = Schedule.recurs(2)\n * const program = Effect.repeat(action, policy)\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"success\", \"success\", \"success\", 2]\n * ```\n *\n * **Example** (Stopping repetition on failure)\n *\n * ```ts import.meta.vitest\n * // Failure Example\n * import { Effect, Schedule } from \"effect\"\n * const output: Array = []\n *\n * let count = 0\n *\n * // Define a callback effect that simulates an action with possible failures\n * const action = Effect.callback((resume) => {\n * if (count > 1) {\n * void output.push(\"failure\")\n * resume(Effect.fail(\"Uh oh!\"))\n * } else {\n * count++\n * void output.push(\"success\")\n * resume(Effect.succeed(\"yay!\"))\n * }\n * })\n *\n * const policy = Schedule.recurs(2)\n * const program = Effect.repeat(action, policy)\n *\n * void output.push((await Effect.runPromiseExit(program))._tag)\n * output // => [\"success\", \"success\", \"failure\", \"Failure\"]\n * ```\n *\n * @see {@link retry} for failure-based repetition\n * @see {@link repeatOrElse} for fallback handling when repetition fails\n *\n * @category repetition\n * @since 2.0.0\n */\nexport const repeat = internalSchedule.repeat;\n/**\n * Repeats an effect according to a schedule and runs a fallback effect if\n * repetition fails before the schedule completes.\n *\n * **When to use**\n *\n * Use when successful repetitions should follow a schedule, but failures from\n * the repeated effect or schedule need an effectful fallback.\n *\n * **Details**\n *\n * If the repeated effect or schedule step fails, `orElse` receives the failure\n * and the latest schedule metadata when at least one schedule step has run;\n * otherwise it receives `None`. If the schedule completes normally, the\n * returned effect succeeds with the schedule's output.\n *\n * **Example** (Recovering after repetition stops)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Schedule } from \"effect\"\n * const output: Array = []\n *\n * let attempt = 0\n * const task = Effect.gen(function*() {\n * attempt++\n * if (attempt <= 2) {\n * yield* Effect.sync(() => { output.push(`Attempt ${attempt} failed`) })\n * return yield* Effect.fail(`Error ${attempt}`)\n * }\n * yield* Effect.sync(() => { output.push(`Attempt ${attempt} succeeded`) })\n * return \"success\"\n * })\n *\n * const program = Effect.repeatOrElse(\n * task,\n * Schedule.recurs(3),\n * (error, previous) =>\n * Effect.sync(() => { output.push(\n * `Final failure: ${error}, after ${\n * Option.isSome(previous) ? previous.value.attempt : 0\n * } attempts`\n * ) }).pipe(Effect.map(() => 0))\n * )\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Attempt 1 failed\", \"Final failure: Error 1, after 0 attempts\", 0]\n * ```\n *\n * @category repetition\n * @since 2.0.0\n */\nexport const repeatOrElse = internalSchedule.repeatOrElse;\n/**\n * Returns an array of `n` identical effects.\n *\n * **When to use**\n *\n * Use when you need an array of identical effect values without running them\n * yet.\n *\n * **Details**\n *\n * This only creates the array of effects. It does not run or collect them.\n *\n * @see {@link all} for running the returned effects and collecting results\n * @see {@link replicateEffect} for repeating an effect and collecting results in one step with concurrency and discard options\n *\n * @category repetition\n * @since 2.0.0\n */\nexport const replicate = internal.replicate;\n/**\n * Performs this effect `n` times and collects results with `Effect.all` semantics.\n *\n * **When to use**\n *\n * Use when you want to run the repeated effects immediately, with optional\n * concurrency control or result discarding.\n *\n * **Details**\n *\n * Use `concurrency` to control parallelism and `discard: true` to ignore results.\n *\n * **Example** (Replicating an effect)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * const results = yield* Effect.replicateEffect(3)(Effect.succeed(1))\n * yield* Effect.sync(() => { output.push(results) })\n * })\n *\n * Effect.runSync(program)\n * output // => [[1, 1, 1]]\n * ```\n *\n * @category repetition\n * @since 2.0.0\n */\nexport const replicateEffect = internal.replicateEffect;\n/**\n * Runs an effect repeatedly according to a schedule and returns the schedule's\n * final output.\n *\n * **When to use**\n *\n * Use to rerun a successful effect according to a `Schedule` when the schedule\n * does not need a custom initial input.\n *\n * **Details**\n *\n * The schedule is first stepped with `undefined`. After each successful\n * execution, the effect's success value is fed to the schedule to decide\n * whether to run again. The returned effect fails if the effect or schedule\n * fails, and otherwise succeeds with the schedule output when the schedule\n * completes.\n *\n * **Example** (Scheduling repeated execution)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule } from \"effect\"\n * const output: Array = []\n *\n * const task = Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"Task executing...\") })\n * return 1\n * })\n *\n * const program = Effect.schedule(task, Schedule.recurs(2))\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Task executing...\", \"Task executing...\", 2]\n * ```\n *\n * @see {@link scheduleFrom} for a variant that allows the schedule's decision\n * to depend on the result of this effect.\n *\n * @category repetition\n * @since 2.0.0\n */\nexport const schedule = /*#__PURE__*/dual(2, (self, schedule) => scheduleFrom(self, undefined, schedule));\n/**\n * Runs an effect repeatedly according to a schedule that is initialized with a\n * specific schedule input.\n *\n * **Details**\n *\n * `initial` is passed to the schedule before the first execution, not to the\n * effect itself. After each successful execution, the effect's success value is\n * fed back into the schedule to decide whether to continue. The returned effect\n * succeeds with the schedule output when the schedule completes and fails if\n * the effect or schedule fails.\n *\n * **Example** (Scheduling from an initial value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule } from \"effect\"\n * const output: Array = []\n *\n * const task = (input: number) =>\n * Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(`Processing: ${input}`) })\n * return input + 1\n * })\n *\n * // Start with 0, repeat 3 times\n * const program = Effect.scheduleFrom(\n * task(0),\n * 0,\n * Schedule.recurs(2)\n * )\n *\n * void output.push(Effect.runSync(program))\n * output // => [\"Processing: 0\", \"Processing: 0\", 2]\n * ```\n *\n * @category repetition\n * @since 2.0.0\n */\nexport const scheduleFrom = internalSchedule.scheduleFrom;\n// -----------------------------------------------------------------------------\n// Tracing\n// -----------------------------------------------------------------------------\n/**\n * Returns the current tracer from the context.\n *\n * **Example** (Accessing the current tracer)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const currentTracer = yield* Effect.tracer\n * return typeof currentTracer.span\n * })\n *\n * Effect.runSync(program) // => \"function\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const tracer = internal.tracer;\n/**\n * Provides a tracer to an effect.\n *\n * **Example** (Providing a tracer)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const tracer = yield* Effect.tracer\n * return yield* Effect.withTracer(Effect.succeed(\"completed\"), tracer)\n * })\n *\n * Effect.runSync(program) // => \"completed\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const withTracer = internal.withTracer;\n/**\n * Enables or disables tracing for spans created by the given effect.\n *\n * **Details**\n *\n * When `enabled` is `false`, spans created inside the effect are not registered\n * with the current tracer and do not propagate as normal trace parents.\n *\n * **Example** (Enabling or disabling tracing)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.succeed(42).pipe(\n * Effect.withSpan(\"my-span\"),\n * // the span will not be registered with the tracer\n * Effect.withTracerEnabled(false)\n * )\n * Effect.runSync(program) // => 42\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const withTracerEnabled = internal.withTracerEnabled;\n/**\n * Enables or disables tracer timing for the given Effect.\n *\n * **Example** (Enabling or disabling tracing timing)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.succeed(42).pipe(\n * Effect.withSpan(\"my-span\"),\n * // the span will not have timing information\n * Effect.withTracerTiming(false)\n * )\n * Effect.runSync(program) // => 42\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const withTracerTiming = internal.withTracerTiming;\n/**\n * Adds an annotation to each span in this effect.\n *\n * **Example** (Annotating all spans)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.succeed(\"result\")\n *\n * // Add single annotation\n * const annotated1 = Effect.annotateSpans(program, \"user\", \"john\")\n *\n * // Add multiple annotations\n * const annotated2 = Effect.annotateSpans(program, {\n * operation: \"data-processing\",\n * version: \"1.0.0\",\n * environment: \"production\"\n * })\n *\n * Effect.runSync(Effect.all([annotated1, annotated2])) // => ['result', 'result']\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const annotateSpans = internal.annotateSpans;\n/**\n * Adds an annotation to the current span if available.\n *\n * **Example** (Annotating the current span)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.annotateCurrentSpan(\"userId\", \"123\")\n * yield* Effect.annotateCurrentSpan({\n * operation: \"user-lookup\"\n * })\n * return \"success\"\n * })\n *\n * const traced = Effect.withSpan(program, \"user-operation\")\n * Effect.runSync(traced) // => \"success\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const annotateCurrentSpan = internal.annotateCurrentSpan;\n/**\n * Returns the currently active local tracing span.\n *\n * **Details**\n *\n * The effect fails with `NoSuchElementError` when there is no active local\n * `Span`.\n *\n * **Example** (Reading the current span)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const span = yield* Effect.currentSpan\n * return span.name\n * })\n *\n * const traced = Effect.withSpan(program, \"my-span\")\n * Effect.runSync(traced) // => \"my-span\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const currentSpan = internal.currentSpan;\n/**\n * Returns the current parent span from the effect context.\n *\n * **Details**\n *\n * The effect succeeds with either a local span or external span when one is\n * present, and fails with `NoSuchElementError` when no parent span is\n * available.\n *\n * **Example** (Reading the parent span)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const childOperation = Effect.gen(function*() {\n * const parentSpan = yield* Effect.currentParentSpan\n * return parentSpan._tag\n * })\n *\n * const program = Effect.withSpan(childOperation, \"child-span\")\n *\n * const traced = Effect.withSpan(program, \"parent-span\")\n * Effect.runSync(traced) // => \"Span\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const currentParentSpan = internal.currentParentSpan;\n/**\n * Returns the tracing span annotations currently carried in the effect context.\n *\n * **Details**\n *\n * These annotations are applied to spans created inside the context, such as\n * spans created by `withSpan`, `useSpan`, or `makeSpan`.\n *\n * **Example** (Providing span annotations)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const annotations = yield* Effect.spanAnnotations\n * return annotations\n * }).pipe(Effect.annotateSpans({ userId: \"123\", operation: \"data-processing\" }))\n *\n * Effect.runSync(program) // => { userId: '123', operation: 'data-processing' }\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const spanAnnotations = internal.spanAnnotations;\n/**\n * Returns the tracing span links currently carried in the effect context.\n *\n * **Details**\n *\n * These links are attached to spans created inside the context. Span links\n * connect related spans without making one span the parent of another.\n *\n * **Example** (Providing span links)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * // Get the current span links\n * const links = yield* Effect.spanLinks\n * return links\n * })\n *\n * Effect.runSync(program).length // => 0\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const spanLinks = internal.spanLinks;\n/**\n * Adds a link with the provided span to all spans in this effect.\n *\n * **Details**\n *\n * This is useful for connecting spans that are related but not in a direct\n * parent-child relationship. For example, you might want to link spans from\n * parallel operations or connect spans across different traces.\n *\n * **Example** (Linking one span to another span)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.withSpan(Effect.gen(function*() {\n * const parentSpan = yield* Effect.currentSpan\n * return yield* Effect.spanLinks.pipe(\n * Effect.linkSpans(parentSpan, { relationship: \"follows\" })\n * )\n * }), \"parent-operation\")\n *\n * Effect.runSync(program).length // => 1\n * ```\n *\n * **Example** (Linking multiple spans at once)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const span1 = yield* Effect.makeSpan(\"span-1\")\n * const span2 = yield* Effect.makeSpan(\"span-2\")\n *\n * return yield* Effect.spanLinks.pipe(\n * Effect.linkSpans([span1, span2], {\n * type: \"dependency\",\n * source: \"multiple-operations\"\n * })\n * )\n * })\n *\n * Effect.runSync(program).length // => 2\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const linkSpans = internal.linkSpans;\n/**\n * Creates a new tracing span and returns it without managing its lifetime.\n *\n * **Details**\n *\n * The span is not added to the current span stack and is not ended\n * automatically. Use `withSpan`, `useSpan`, or `makeSpanScoped` when the span\n * should be installed as context or closed automatically.\n *\n * **Example** (Creating a span manually)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const span = yield* Effect.makeSpan(\"my-operation\")\n * return span.name\n * })\n *\n * Effect.runSync(program) // => \"my-operation\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const makeSpan = internal.makeSpan;\n/**\n * Create a new span for tracing, and automatically close it when the Scope\n * finalizes.\n *\n * **Details**\n *\n * The span is not added to the current span stack, so no child spans will be\n * created for it.\n *\n * **Example** (Creating a scoped standalone span)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * const span = yield* Effect.makeSpanScoped(\"scoped-operation\")\n * return span.name\n * // Span automatically closes when scope ends\n * })\n * )\n *\n * Effect.runSync(program) // => \"scoped-operation\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const makeSpanScoped = internal.makeSpanScoped;\n/**\n * Create a new span for tracing, and automatically close it when the effect\n * completes.\n *\n * **Details**\n *\n * The span is not added to the current span stack, so no child spans will be\n * created for it.\n *\n * **Example** (Running an effect with a standalone span)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.useSpan(\n * \"user-operation\",\n * (span) => Effect.succeed(`${span.name}: success`)\n * )\n * Effect.runSync(program) // => \"user-operation: success\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const useSpan = internal.useSpan;\n/**\n * Wraps the effect with a child span for tracing.\n *\n * **Example** (Wrapping an effect in a child span)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const task = Effect.succeed(\"result\")\n *\n * const traced = Effect.withSpan(task, \"my-task\", {\n * attributes: { version: \"1.0\" }\n * })\n * Effect.runSync(traced) // => \"result\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const withSpan = internal.withSpan;\n/**\n * Wraps the effect with a scoped child span for tracing.\n *\n * **Details**\n *\n * The span is ended when the Scope is finalized.\n *\n * **Example** (Creating a scoped child span)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * const task = Effect.succeed(\"working\")\n * yield* Effect.withSpanScoped(task, \"scoped-task\")\n * return \"completed\"\n * })\n * )\n * Effect.runSync(program) // => \"completed\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const withSpanScoped = internal.withSpanScoped;\n/**\n * Adds the provided span to the current span stack.\n *\n * **Example** (Setting a parent span)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const span = yield* Effect.makeSpan(\"parent-span\")\n * const childTask = Effect.succeed(\"child operation\")\n * yield* Effect.withParentSpan(childTask, span)\n * return \"completed\"\n * })\n * Effect.runSync(program) // => \"completed\"\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const withParentSpan = internal.withParentSpan;\n// -----------------------------------------------------------------------------\n// Batching\n// -----------------------------------------------------------------------------\n/**\n * Executes a request using the provided resolver.\n *\n * **When to use**\n *\n * Use when you need resolver-driven batching for a typed `Request`.\n *\n * **Example** (Executing a request through a resolver)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Request, RequestResolver } from \"effect\"\n * const output: Array = []\n *\n * interface GetUser extends Request.Request {\n * readonly _tag: \"GetUser\"\n * readonly id: number\n * }\n * const GetUser = Request.tagged(\"GetUser\")\n *\n * const resolver = RequestResolver.make(\n * Effect.fnUntraced(function*(entries) {\n * for (const entry of entries) {\n * yield* Request.complete(entry, Exit.succeed(`user-${entry.request.id}`))\n * }\n * })\n * )\n *\n * const program = Effect.gen(function*() {\n * const name = yield* Effect.request(GetUser({ id: 1 }), resolver)\n * yield* Effect.sync(() => { output.push(name) })\n * })\n *\n * await Effect.runPromise(program)\n * output // => [\"user-1\"]\n * ```\n *\n * @see {@link requestUnsafe} for the low-level entry point when you already have a `Context` and need to enqueue outside an `Effect`\n *\n * @category running\n * @since 2.0.0\n */\nexport const request = internalRequest.request;\n/**\n * Registers a request with a resolver and delivers the exit value via `onExit`.\n *\n * **When to use**\n *\n * Use when you already have a `Context` and need to enqueue a request outside\n * an `Effect` while receiving completion through `onExit`.\n *\n * **Details**\n *\n * It returns a canceler that removes the pending request entry.\n *\n * @see {@link request} for the `Effect`-returning API used for normal request execution\n *\n * @category unsafe\n * @since 4.0.0\n */\nexport const requestUnsafe = internalRequest.requestUnsafe;\n// -----------------------------------------------------------------------------\n// Supervision & Fiber's\n// -----------------------------------------------------------------------------\n/**\n * Returns an effect that forks this effect into its own separate fiber,\n * returning the fiber immediately, without waiting for it to begin executing\n * the effect.\n *\n * **Details**\n *\n * You can use the `forkChild` method whenever you want to execute an effect in a\n * new fiber, concurrently and without \"blocking\" the fiber executing other\n * effects. Using fibers can be tricky, so instead of using this method\n * directly, consider other higher-level methods, such as `raceWith`,\n * `zipPar`, and so forth.\n *\n * The fiber returned by this method has methods to interrupt the fiber and to\n * wait for it to finish executing the effect. See `Fiber` for more\n * information.\n *\n * Whenever you use this method to launch a new fiber, the new fiber is\n * attached to the parent fiber's scope. This means when the parent fiber\n * terminates, the child fiber will be terminated as well, ensuring that no\n * fibers leak. This behavior is called \"auto supervision\", and if this\n * behavior is not desired, you may use the `forkDetach` or `forkIn` methods.\n *\n * **Example** (Forking a child fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n *\n * const task = Effect.succeed(\"result\")\n *\n * const program = Effect.gen(function*() {\n * const fiber = yield* task.pipe(Effect.forkChild)\n * const result = yield* Fiber.join(fiber)\n * return result\n * })\n *\n * await Effect.runPromise(program) // => \"result\"\n * ```\n *\n * @category forking\n * @since 4.0.0\n */\nexport const forkChild = internal.forkChild;\n/**\n * Forks the effect in the specified scope. The fiber will be interrupted\n * when the scope is closed.\n *\n * **Example** (Forking into a supplied scope)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const task = Effect.never\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * const scope = yield* Effect.scope\n * const fiber = yield* Effect.forkIn(task, scope)\n * // Fiber will be interrupted when scope closes\n * return \"done\"\n * })\n * )\n *\n * await Effect.runPromise(program) // => \"done\"\n * ```\n *\n * @category forking\n * @since 2.0.0\n */\nexport const forkIn = internal.forkIn;\n/**\n * Forks the fiber in a `Scope`, interrupting it when the scope is closed.\n *\n * **Example** (Forking into the current scope)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const backgroundTask = Effect.never\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * yield* backgroundTask.pipe(Effect.forkScoped)\n *\n * // Fiber will be interrupted when scope closes\n * return \"scope completed\"\n * })\n * )\n *\n * await Effect.runPromise(program) // => \"scope completed\"\n * ```\n *\n * @category forking\n * @since 2.0.0\n */\nexport const forkScoped = internal.forkScoped;\n/**\n * Forks the effect into a new fiber attached to the global scope. Because the\n * new fiber is attached to the global scope, when the fiber executing the\n * returned effect terminates, the forked fiber will continue running.\n *\n * **Example** (Forking a detached fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n *\n * const daemonTask = Effect.succeed(\"daemon result\")\n *\n * const program = Effect.gen(function*() {\n * const fiber = yield* daemonTask.pipe(Effect.forkDetach)\n * return yield* Fiber.join(fiber)\n * })\n *\n * await Effect.runPromise(program) // => \"daemon result\"\n * ```\n *\n * @category forking\n * @since 4.0.0\n */\nexport const forkDetach = internal.forkDetach;\n/**\n * Waits for all child fibers forked by this effect to complete before this\n * effect completes.\n *\n * **When to use**\n *\n * Use to let an effect start child work concurrently while still delaying its\n * own completion until that child work is done.\n *\n * **Gotchas**\n *\n * Child fibers that already exist before the wrapped effect starts are not\n * awaited.\n *\n * @see {@link forkChild} for forking child fibers that are awaited by this operator\n * @see {@link forkDetach} for forking fibers outside the child scope\n * @see {@link forkIn} for forking into an explicit scope\n * @see {@link forkScoped} for forking fibers tied to the current scope\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const awaitAllChildren = internal.awaitAllChildren;\n/**\n * Accesses the fiber currently executing the effect.\n *\n * **Example** (Accessing the current fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * const fiber = yield* Effect.fiber\n * yield* Effect.sync(() => { output.push(typeof fiber.id) })\n * })\n *\n * Effect.runSync(program)\n * output // => [\"number\"]\n * ```\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const fiber = internal.fiber;\n/**\n * Accesses the current fiber id executing the effect.\n *\n * **Example** (Accessing the current fiber id)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.fiberId.pipe(Effect.map((id) => typeof id))\n * Effect.runSync(program) // => \"number\"\n * ```\n *\n * @category accessors\n * @since 2.0.0\n */\nexport const fiberId = internal.fiberId;\n/**\n * Runs an effect in the background, returning a fiber that can\n * be observed or interrupted.\n *\n * **When to use**\n *\n * Use when you need to start an effect in the background and receive a fiber.\n *\n * **Example** (Running an effect in the background)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n * const output: Array = []\n *\n * // ┌─── Effect\n * // ▼\n * const program = Effect.sync(() => { output.push(\"running...\") }).pipe(Effect.as(\"done\"))\n *\n * // ┌─── RuntimeFiber\n * // ▼\n * const fiber = Effect.runFork(program)\n *\n * void output.push(await Effect.runPromise(Fiber.join(fiber)))\n * output // => [\"running...\", \"done\"]\n * ```\n *\n * @category running\n * @since 2.0.0\n */\nexport const runFork = internal.runFork;\n/**\n * Runs an effect in the background with the provided services.\n *\n * **When to use**\n *\n * Use when an effect still requires services, you already have a `Context`, and\n * you want a background fiber.\n *\n * **Example** (Running with services in the background)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Fiber } from \"effect\"\n * const output: Array = []\n *\n * interface Logger {\n * log: (message: string) => void\n * }\n *\n * const Logger = Context.Service(\"Logger\")\n *\n * const services = Context.make(Logger, {\n * log: (message) => void output.push(message)\n * })\n *\n * const program = Effect.gen(function*() {\n * const logger = yield* Logger\n * logger.log(\"Hello from service!\")\n * return \"done\"\n * })\n *\n * const fiber = Effect.runForkWith(services)(program)\n * void output.push(await Effect.runPromise(Fiber.join(fiber)))\n * output // => [\"Hello from service!\", \"done\"]\n * ```\n *\n * @category running\n * @since 4.0.0\n */\nexport const runForkWith = internal.runForkWith;\n/**\n * Forks an effect with the provided services, registers `onExit` as a fiber observer, and returns an interruptor.\n *\n * **When to use**\n *\n * Use when embedding an effect into callback-style code with explicit services\n * and a synchronous interruptor.\n *\n * **Details**\n *\n * The returned interruptor calls `fiber.interruptUnsafe`, optionally with an interruptor id.\n *\n * **Example** (Running with services and a callback)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n * const output: Array = []\n *\n * interface Logger {\n * log: (message: string) => Effect.Effect\n * }\n *\n * const Logger = Context.Service(\"Logger\")\n *\n * const services = Context.make(Logger, {\n * log: (message) => Effect.sync(() => { output.push(message) })\n * })\n *\n * const program = Effect.gen(function*() {\n * const logger = yield* Logger\n * yield* logger.log(\"Started\")\n * return \"done\"\n * })\n *\n * await new Promise((resolve) => {\n * Effect.runCallbackWith(services)(program, {\n * onExit: (exit) => {\n * void output.push(exit._tag)\n * resolve()\n * }\n * })\n * })\n * output // => [\"Started\", \"Success\"]\n * ```\n *\n * @category running\n * @since 4.0.0\n */\nexport const runCallbackWith = internal.runCallbackWith;\n/**\n * Runs an effect asynchronously, registering `onExit` as a fiber observer and\n * returning an interruptor.\n *\n * **Details**\n *\n * The interruptor calls `fiber.interruptUnsafe` with the optional interruptor\n * id.\n *\n * **Example** (Running with a callback)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.sync(() => { output.push(\"working\") })\n * return \"done\"\n * })\n *\n * await new Promise((resolve) => {\n * Effect.runCallback(program, {\n * onExit: (exit) => {\n * Effect.runSync(\n * Exit.match(exit, {\n * onFailure: () => Effect.sync(() => { output.push(\"failed\") }),\n * onSuccess: (value) => Effect.sync(() => { output.push(`success: ${value}`) })\n * })\n * )\n * resolve()\n * }\n * })\n * })\n *\n * output // => [\"working\", \"success: done\"]\n * ```\n *\n * @category running\n * @since 2.0.0\n */\nexport const runCallback = internal.runCallback;\n/**\n * Executes an effect and returns the result as a `Promise`.\n *\n * **When to use**\n *\n * Use when you need to execute an effect and work with the\n * result using `Promise` syntax, typically for compatibility with other\n * promise-based code.\n *\n * If the effect succeeds, the promise will resolve with the result. If the\n * effect fails, the promise will reject with an error.\n *\n * **Example** (Running a successful effect as a Promise)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * await Effect.runPromise(Effect.succeed(1)) // => 1\n * ```\n *\n * **Example** (Running effects as promises)\n *\n * ```ts import.meta.vitest\n * //Example: Handling a Failing Effect as a Rejected Promise\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * await Effect.runPromise(Effect.fail(\"my error\")).catch(() => {\n * void output.push(\"rejected\")\n * })\n * output // => [\"rejected\"]\n * ```\n *\n * @see {@link runPromiseExit} for a version that returns an `Exit` type instead of rejecting.\n * @category running\n * @since 2.0.0\n */\nexport const runPromise = internal.runPromise;\n/**\n * Executes an effect as a Promise with the provided services.\n *\n * **When to use**\n *\n * Use when you already have a `Context` and need Promise interop that rejects on\n * effect failure.\n *\n * **Example** (Running with services as a promise)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n *\n * interface Config {\n * apiUrl: string\n * }\n *\n * const Config = Context.Service(\"Config\")\n *\n * const context = Context.make(Config, {\n * apiUrl: \"https://api.example.com\"\n * })\n *\n * const program = Effect.gen(function*() {\n * const config = yield* Config\n * return `Connecting to ${config.apiUrl}`\n * })\n *\n * await Effect.runPromiseWith(context)(program) // => \"Connecting to https://api.example.com\"\n * ```\n *\n * @category running\n * @since 4.0.0\n */\nexport const runPromiseWith = internal.runPromiseWith;\n/**\n * Runs an effect and returns a `Promise` that resolves to an `Exit`, which\n * represents the outcome (success or failure) of the effect.\n *\n * **When to use**\n *\n * Use when you need to determine if an effect succeeded\n * or failed, including any defects, and you want to work with a `Promise`.\n *\n * **Details**\n *\n * The `Exit` type represents the result of the effect. Successful effects are\n * wrapped in `Success`, and failed effects are wrapped in `Failure` with a\n * `Cause`.\n *\n * **Example** (Observing promise results as Exit)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n *\n * // Execute a successful effect and get the Exit result as a Promise\n * await Effect.runPromiseExit(Effect.succeed(1)) // => Exit.succeed(1)\n *\n * // Execute a failing effect and get the Exit result as a Promise\n * await Effect.runPromiseExit(Effect.fail(\"my error\")) // => Exit.fail(\"my error\")\n * ```\n *\n * @see {@link runPromise} for a version that rejects on failure.\n *\n * @category running\n * @since 2.0.0\n */\nexport const runPromiseExit = internal.runPromiseExit;\n/**\n * Runs an effect and returns a Promise of Exit with provided services.\n *\n * **When to use**\n *\n * Use when you already have a `Context` and need Promise interop that preserves\n * success and failure as an `Exit`.\n *\n * **Example** (Running with services as an Exit promise)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * interface Database {\n * query: (sql: string) => string\n * }\n *\n * const Database = Context.Service(\"Database\")\n *\n * const services = Context.make(Database, {\n * query: (sql) => `Result for: ${sql}`\n * })\n *\n * const program = Effect.gen(function*() {\n * const db = yield* Database\n * return db.query(\"SELECT * FROM users\")\n * })\n *\n * const exit = await Effect.runPromiseExitWith(services)(program)\n * if (Exit.isSuccess(exit)) {\n * void output.push(`Success: ${exit.value}`)\n * }\n * output // => [\"Success: Result for: SELECT * FROM users\"]\n * ```\n *\n * @category running\n * @since 4.0.0\n */\nexport const runPromiseExitWith = internal.runPromiseExitWith;\n/**\n * Executes an effect synchronously and returns its success value.\n *\n * **When to use**\n *\n * Use when you need to execute an effect that is guaranteed to complete\n * synchronously.\n *\n * **Details**\n *\n * If the effect fails, dies, is interrupted, or performs asynchronous work,\n * `runSync` throws a `FiberFailure` instead of returning a value. Use\n * `runSyncExit` when you want the failure captured as an `Exit`.\n *\n * **Example** (Running a synchronous effect)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.sync(() => {\n * void output.push(\"Hello, World!\")\n * return 1\n * })\n *\n * const result = Effect.runSync(program)\n * void output.push(result)\n * output // => [\"Hello, World!\", 1]\n * ```\n *\n * **Example** (Throwing for failed or async effects)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * try {\n * // Attempt to run an effect that fails\n * Effect.runSync(Effect.fail(\"my error\"))\n * } catch (e) {\n * void output.push(\"failed effect\")\n * }\n * try {\n * // Attempt to run an effect that involves async work\n * Effect.runSync(Effect.promise(() => Promise.resolve(1)))\n * } catch (e) {\n * void output.push(\"async effect\")\n * }\n * output // => [\"failed effect\", \"async effect\"]\n * ```\n *\n * @see {@link runSyncExit} for a version that returns an `Exit` type instead of\n * throwing an error.\n * @category running\n * @since 2.0.0\n */\nexport const runSync = internal.runSync;\n/**\n * Executes an effect synchronously with provided services.\n *\n * **When to use**\n *\n * Use when you already have a `Context`, the effect is known to complete\n * synchronously, and failures should throw.\n *\n * **Example** (Running synchronously with services)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect } from \"effect\"\n *\n * interface MathService {\n * add: (a: number, b: number) => number\n * }\n *\n * const MathService = Context.Service(\"MathService\")\n *\n * const context = Context.make(MathService, {\n * add: (a, b) => a + b\n * })\n *\n * const program = Effect.gen(function*() {\n * const math = yield* MathService\n * return math.add(2, 3)\n * })\n *\n * const result = Effect.runSyncWith(context)(program)\n * result // => 5\n * ```\n *\n * @category running\n * @since 4.0.0\n */\nexport const runSyncWith = internal.runSyncWith;\n/**\n * Runs an effect synchronously and captures the outcome safely as an `Exit` type, which\n * represents the outcome (success or failure) of the effect.\n *\n * **When to use**\n *\n * Use to find out whether an effect succeeded or failed,\n * including any defects, without dealing with asynchronous operations.\n *\n * **Details**\n *\n * The `Exit` type represents the result of the effect. Successful effects are\n * wrapped in `Success`, and failed effects are wrapped in `Failure` with a\n * `Cause`.\n *\n * If the effect contains asynchronous operations, `runSyncExit` will\n * return an `Failure` with a `Die` cause, indicating that the effect cannot be\n * resolved synchronously.\n *\n * **Example** (Observing synchronous results as Exit)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit } from \"effect\"\n *\n * Effect.runSyncExit(Effect.succeed(1)) // => Exit.succeed(1)\n *\n * Effect.runSyncExit(Effect.fail(\"my error\")) // => Exit.fail(\"my error\")\n * ```\n *\n * **Example** (Capturing async work as a Die cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit } from \"effect\"\n *\n * const exit = Effect.runSyncExit(Effect.promise(() => Promise.resolve(1)))\n * const isAsyncDie = Exit.hasDies(exit) && exit.cause.reasons.some(\n * (reason) => Cause.isDieReason(reason) && Cause.isAsyncFiberError(reason.defect)\n * )\n *\n * isAsyncDie // => true\n * ```\n *\n * @see {@link runSync} for a version that throws on failure.\n *\n * @category running\n * @since 2.0.0\n */\nexport const runSyncExit = internal.runSyncExit;\n/**\n * Runs an effect synchronously with provided services, returning an Exit result safely.\n *\n * **When to use**\n *\n * Use when you already have a `Context` and need a synchronous `Exit` instead of\n * throwing on failure.\n *\n * **Example** (Running synchronously with services as Exit)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Exit } from \"effect\"\n * const output: Array = []\n *\n * // Define a logger service\n * const Logger = Context.Service<{\n * log: (msg: string) => void\n * }>(\"Logger\")\n *\n * const program = Effect.gen(function*() {\n * const logger = yield* Effect.service(Logger)\n * logger.log(\"Computing result...\")\n * return 42\n * })\n *\n * // Prepare context\n * const context = Context.make(Logger, {\n * log: (msg) => void output.push(`[LOG] ${msg}`)\n * })\n *\n * const exit = Effect.runSyncExitWith(context)(program)\n *\n * if (Exit.isSuccess(exit)) {\n * void output.push(`Success: ${exit.value}`)\n * } else {\n * void output.push(`Failure: ${exit.cause}`)\n * }\n * output // => [\"[LOG] Computing result...\", \"Success: 42\"]\n * ```\n *\n * @category running\n * @since 4.0.0\n */\nexport const runSyncExitWith = internal.runSyncExitWith;\n/**\n * Creates an Effect-returning function without tracing.\n *\n * **When to use**\n *\n * Use when you are defining a reusable Effect function whose implementation\n * would otherwise be a normal function returning {@link gen}, especially when\n * tracing spans or stack-frame capture are not needed.\n *\n * **Details**\n *\n * Compared to a plain function that returns {@link gen}, `Effect.fnUntraced`\n * reuses the generator body instead of allocating a fresh generator closure\n * around the arguments on every call. It does not record an Effect stack-frame\n * boundary and does not create tracing spans. Use {@link fn} when you need\n * those stack frames or spans. Additional arguments after the generator body\n * act like `pipe` transforms: each transform receives the previous result and\n * the original function arguments. Annotate the generator return type with\n * `Effect.fn.Return` when the produced `Effect` type needs to be\n * stated explicitly.\n *\n * **Example** (Defining untraced effect functions)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const f = Effect.fnUntraced(function*(\n * value: string\n * ) {\n * return yield* Effect.succeed(value.length)\n * })\n *\n * // ┌─── Effect.Effect\n * // ▼\n * const program = f(\"hello\")\n * Effect.runSync(program) // => 5\n * ```\n *\n * **Example** (Transforming the returned Effect)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const f = Effect.fnUntraced(\n * function*(value: string) {\n * return yield* Effect.succeed(value.length)\n * },\n * (effect, value) =>\n * effect.pipe(Effect.map((length) => `${value}: ${length}`))\n * )\n *\n * // ┌─── Effect.Effect\n * // ▼\n * const program = f(\"hello\")\n * Effect.runSync(program) // => \"hello: 5\"\n * ```\n *\n * **Example** (Annotating an untraced non-parametric function)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const f = Effect.fnUntraced(function*(\n * value: string\n * ): Effect.fn.Return {\n * return yield* Effect.succeed(value.length)\n * })\n *\n * // ┌─── Effect.Effect\n * // ▼\n * const program = f(\"hello\")\n * Effect.runSync(program) // => 5\n * ```\n *\n * **Example** (Annotating an untraced parametric function)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const f = Effect.fnUntraced(function*(\n * value: A\n * ): Effect.fn.Return {\n * return yield* Effect.succeed(value)\n * })\n *\n * // ┌─── Effect.Effect\n * // ▼\n * const program = f(\"hello\")\n * Effect.runSync(program) // => \"hello\"\n * ```\n *\n * @category constructors\n * @since 3.12.0\n */\nexport const fnUntraced = internal.fnUntraced;\n/**\n * Creates a reusable traced function from an Effect body.\n *\n * **When to use**\n *\n * Use when you are defining a reusable Effect function whose implementation\n * would otherwise be a normal function returning {@link gen}, and you want\n * tracing spans or stack-frame capture.\n *\n * **Details**\n *\n * Compared to a plain function that returns {@link gen}, `Effect.fn` reuses the\n * generator body instead of allocating a fresh generator closure around the\n * arguments on every call. Call `Effect.fn(body, ...)` for a generic\n * stack-frame boundary without creating a span. Call\n * `Effect.fn(\"operationName\", options?)(body, ...)` when that boundary should\n * have a readable operation name and the returned `Effect` should create a\n * tracing span when run. {@link SpanOptionsNoTrace} configures span metadata\n * such as attributes, links, parent or root selection, kind, sampling, and log\n * level. Additional arguments after the generator body act like `pipe`\n * transforms: each transform receives the previous result and the original\n * function arguments. When those transforms return an `Effect`, the returned\n * effect includes stack-frame metadata and, for the named form, a tracing span.\n * Generator bodies may declare a `this` parameter; pass `{ self }` before the\n * body to bind `this` when the function is created.\n *\n * **Example** (Defining traced effect functions)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const f = Effect.fn(\"calculateLength\")(function*(value: string) {\n * return yield* Effect.succeed(value.length)\n * })\n *\n * // ┌─── Effect.Effect\n * // ▼\n * const program = f(\"hello\")\n * Effect.runSync(program) // => 5\n * ```\n *\n * **Example** (Transforming the returned Effect)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const f = Effect.fn(\"formatLength\")(\n * function*(value: string) {\n * return yield* Effect.succeed(value.length)\n * },\n * (effect, value) =>\n * effect.pipe(Effect.map((length) => `${value}: ${length}`))\n * )\n *\n * // ┌─── Effect.Effect\n * // ▼\n * const program = f(\"hello\")\n * Effect.runSync(program) // => \"hello: 5\"\n * ```\n *\n * **Example** (Binding this)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * class Counter {\n * count = 0\n *\n * increment = Effect.fn(\"Counter.increment\")(\n * { self: this },\n * function*(this: Counter, by: number) {\n * this.count += by\n * return yield* Effect.succeed(this.count)\n * }\n * )\n * }\n *\n * const counter = new Counter()\n *\n * // ┌─── Effect.Effect\n * // ▼\n * const program = counter.increment(1)\n * Effect.runSync(program) // => 1\n * ```\n *\n * **Example** (Annotating a traced non-parametric function)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const f = Effect.fn(\"calculateLength\")(function*(\n * value: string\n * ): Effect.fn.Return {\n * return yield* Effect.succeed(value.length)\n * })\n *\n * // ┌─── Effect.Effect\n * // ▼\n * const program = f(\"hello\")\n * Effect.runSync(program) // => 5\n * ```\n *\n * **Example** (Annotating a traced parametric function)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const f = Effect.fn(\"succeed\")(function*(\n * value: A\n * ): Effect.fn.Return {\n * return yield* Effect.succeed(value)\n * })\n *\n * // ┌─── Effect.Effect\n * // ▼\n * const program = f(\"hello\")\n * Effect.runSync(program) // => \"hello\"\n * ```\n *\n * @category constructors\n * @since 3.11.0\n */\nexport const fn = internal.fn;\n// ========================================================================\n// Clock\n// ========================================================================\n/**\n * Retrieves the `Clock` service from the context and provides it to the\n * specified effectful function.\n *\n * **Example** (Accessing the Clock service)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const program = Effect.clockWith((clock) =>\n * clock.currentTimeMillis.pipe(\n * Effect.map(() => \"Clock is available\")\n * )\n * )\n *\n * Effect.runSync(program) // => \"Clock is available\"\n * ```\n *\n * @category accessors\n * @since 2.0.0\n */\nexport const clockWith = internal.clockWith;\n// ========================================================================\n// Logging\n// ========================================================================\n/**\n * Creates a logger function that logs at the specified level.\n *\n * **Details**\n *\n * If no level is provided, the logger uses the fiber's current log level and\n * extracts any `Cause` values from the message list.\n *\n * **Example** (Logging at a dynamic level)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger, References } from \"effect\"\n * const output: Array = []\n *\n * const logWarn = Effect.logWithLevel(\"Warn\")\n *\n * const program = Effect.gen(function*() {\n * yield* logWarn(\"Cache miss\")\n * })\n * const logger = Logger.make(({ logLevel, message }) => {\n * void output.push(`${logLevel}: ${Array.isArray(message) ? message.map(String).join(\" \") : String(message)}`)\n * })\n * const runnable = program.pipe(\n * Effect.provideService(References.MinimumLogLevel, \"Debug\"),\n * Effect.provide(Logger.layer([logger]))\n * )\n * Effect.runSync(runnable)\n * output // => [\"Warn: Cache miss\"]\n * ```\n *\n * @category logging\n * @since 2.0.0\n */\nexport const logWithLevel = internal.logWithLevel;\n/**\n * Logs one or more messages using the default log level.\n *\n * **Example** (Logging at the default level)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * const result = 2 + 2\n * yield* Effect.log(\"Result:\", result)\n * return result\n * })\n *\n * const logger = Logger.make(({ logLevel, message }) => {\n * void output.push(`${logLevel}: ${Array.isArray(message) ? message.map(String).join(\" \") : String(message)}`)\n * })\n * const runnable = Effect.provide(program, Logger.layer([logger]))\n * void output.push(Effect.runSync(runnable))\n * output // => [\"Info: Result: 4\", 4]\n * ```\n *\n * @category logging\n * @since 2.0.0\n */\nexport const log = /*#__PURE__*/internal.logWithLevel();\n/**\n * Logs one or more messages at the FATAL level.\n *\n * **Example** (Logging fatal messages)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.logFatal(\"Critical system failure\")\n * })\n *\n * const logger = Logger.make(({ logLevel, message }) => {\n * void output.push(`${logLevel}: ${Array.isArray(message) ? message.map(String).join(\" \") : String(message)}`)\n * })\n * const runnable = Effect.provide(program, Logger.layer([logger]))\n * Effect.runSync(runnable)\n * output // => [\"Fatal: Critical system failure\"]\n * ```\n *\n * @category logging\n * @since 2.0.0\n */\nexport const logFatal = /*#__PURE__*/internal.logWithLevel(\"Fatal\");\n/**\n * Logs one or more messages at the WARNING level.\n *\n * **Example** (Logging warnings)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.logWarning(\"API rate limit approaching\")\n * })\n *\n * const logger = Logger.make(({ logLevel, message }) => {\n * void output.push(`${logLevel}: ${Array.isArray(message) ? message.map(String).join(\" \") : String(message)}`)\n * })\n * Effect.runSync(Effect.provide(program, Logger.layer([logger])))\n * output // => [\"Warn: API rate limit approaching\"]\n * ```\n *\n * @category logging\n * @since 2.0.0\n */\nexport const logWarning = /*#__PURE__*/internal.logWithLevel(\"Warn\");\n/**\n * Logs one or more messages at the ERROR level.\n *\n * **Example** (Logging errors)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.logError(\"Database connection failed\")\n * })\n *\n * const logger = Logger.make(({ logLevel, message }) => {\n * void output.push(`${logLevel}: ${Array.isArray(message) ? message.map(String).join(\" \") : String(message)}`)\n * })\n * Effect.runSync(Effect.provide(program, Logger.layer([logger])))\n * output // => [\"Error: Database connection failed\"]\n * ```\n *\n * @category logging\n * @since 2.0.0\n */\nexport const logError = /*#__PURE__*/internal.logWithLevel(\"Error\");\n/**\n * Logs one or more messages at the INFO level.\n *\n * **Example** (Logging information)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.logInfo(\"Application starting up\")\n * })\n *\n * const logger = Logger.make(({ logLevel, message }) => {\n * void output.push(`${logLevel}: ${Array.isArray(message) ? message.map(String).join(\" \") : String(message)}`)\n * })\n * Effect.runSync(Effect.provide(program, Logger.layer([logger])))\n * output // => [\"Info: Application starting up\"]\n * ```\n *\n * @category logging\n * @since 2.0.0\n */\nexport const logInfo = /*#__PURE__*/internal.logWithLevel(\"Info\");\n/**\n * Logs one or more messages at the DEBUG level.\n *\n * **Example** (Logging debug messages)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger, References } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.logDebug(\"Debug mode enabled\")\n * })\n *\n * const logger = Logger.make(({ logLevel, message }) => {\n * void output.push(`${logLevel}: ${Array.isArray(message) ? message.map(String).join(\" \") : String(message)}`)\n * })\n * const runnable = program.pipe(\n * Effect.provideService(References.MinimumLogLevel, \"Debug\"),\n * Effect.provide(Logger.layer([logger]))\n * )\n * Effect.runSync(runnable)\n * output // => [\"Debug: Debug mode enabled\"]\n * ```\n *\n * @category logging\n * @since 2.0.0\n */\nexport const logDebug = /*#__PURE__*/internal.logWithLevel(\"Debug\");\n/**\n * Logs one or more messages at the TRACE level.\n *\n * **Example** (Logging trace messages)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger, References } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.logTrace(\"Entering function processData\")\n * })\n *\n * const logger = Logger.make(({ logLevel, message }) => {\n * void output.push(`${logLevel}: ${Array.isArray(message) ? message.map(String).join(\" \") : String(message)}`)\n * })\n * const runnable = program.pipe(\n * Effect.provideService(References.MinimumLogLevel, \"Trace\"),\n * Effect.provide(Logger.layer([logger]))\n * )\n * Effect.runSync(runnable)\n * output // => [\"Trace: Entering function processData\"]\n * ```\n *\n * @category logging\n * @since 2.0.0\n */\nexport const logTrace = /*#__PURE__*/internal.logWithLevel(\"Trace\");\n/**\n * Adds a logger to the set of loggers which will output logs for this effect.\n *\n * **Example** (Adding a logger to an effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger } from \"effect\"\n * const output: Array = []\n *\n * // Create a custom logger that logs to the console\n * const customLogger = Logger.make(({ message }) =>\n * void output.push(`[CUSTOM]: ${Array.isArray(message) ? message.map(String).join(\" \") : String(message)}`)\n * )\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.log(\"This will go to both default and custom logger\")\n * return \"completed\"\n * })\n *\n * // Add the custom logger to the effect\n * const programWithLogger = Effect.withLogger(program, customLogger)\n *\n * Effect.runSync(Effect.provide(programWithLogger, Logger.layer([])))\n * output // => [\"[CUSTOM]: This will go to both default and custom logger\"]\n * ```\n *\n * @category logging\n * @since 4.0.0\n */\nexport const withLogger = /*#__PURE__*/dual(2, (effect, logger) => internal.updateService(effect, internal.CurrentLoggers, loggers => new Set([...loggers, logger])));\n/**\n * Adds an annotation to each log line in this effect.\n *\n * **Example** (Adding log annotations)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * yield* Effect.log(\"Starting operation\")\n * })\n *\n * // Add annotations to all log messages\n * const annotatedProgram = Effect.annotateLogs(program, {\n * userId: \"user123\",\n * operation: \"data-processing\"\n * })\n *\n * // Also supports single key-value annotations\n * const singleAnnotated = Effect.annotateLogs(program, \"requestId\", \"req-456\")\n *\n * const logger = Logger.make(({ message }) =>\n * void output.push(Array.isArray(message) ? message.join(\" \") : String(message))\n * )\n * const run = (effect: Effect.Effect) =>\n * Effect.runSync(Effect.provide(effect, Logger.layer([logger])))\n * run(annotatedProgram)\n * run(singleAnnotated)\n * output // => [\"Starting operation\", \"Starting operation\"]\n * ```\n *\n * @category logging\n * @since 2.0.0\n */\nexport const annotateLogs = /*#__PURE__*/dual(args => isEffect(args[0]), (effect, ...args) => internal.updateService(effect, CurrentLogAnnotations, annotations => {\n const newAnnotations = args.length === 1 ? {\n ...annotations,\n ...args[0]\n } : {\n ...annotations\n };\n if (args.length === 1) {\n return newAnnotations;\n } else {\n InternalRecord.assignProperty(newAnnotations, args[0], args[1]);\n }\n return newAnnotations;\n}));\n/**\n * Adds log annotations to the current scope.\n *\n * **When to use**\n *\n * Use to attach log annotations that last until the current scope closes.\n *\n * **Details**\n *\n * This differs from `annotateLogs`, which only annotates a specific effect.\n * `annotateLogsScoped` updates annotations for the entire current `Scope` and\n * restores the previous annotations when the scope closes.\n *\n * **Example** (Adding scoped log annotations)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * yield* Effect.log(\"before\")\n * yield* Effect.annotateLogsScoped({ requestId: \"req-123\" })\n * yield* Effect.log(\"inside scope\")\n * })\n * )\n *\n * const logger = Logger.make(({ message }) =>\n * void output.push(Array.isArray(message) ? message.join(\" \") : String(message))\n * )\n * Effect.runSync(Effect.provide(program, Logger.layer([logger])))\n * output // => [\"before\", \"inside scope\"]\n * ```\n *\n * @see {@link annotateLogs} for annotating one effect\n *\n * @category logging\n * @since 3.1.0\n */\nexport const annotateLogsScoped = internal.annotateLogsScoped;\n/**\n * Adds a span to each log line in this effect.\n *\n * **Example** (Adding a log span)\n *\n * ```ts import.meta.vitest\n * import { Effect, Logger } from \"effect\"\n * const output: Array = []\n *\n * const databaseOperation = Effect.gen(function*() {\n * yield* Effect.log(\"Connecting to database\")\n * yield* Effect.log(\"Executing query\")\n * yield* Effect.log(\"Processing results\")\n * return \"data\"\n * })\n *\n * const httpRequest = Effect.gen(function*() {\n * yield* Effect.log(\"Making HTTP request\")\n * const data = yield* Effect.withLogSpan(databaseOperation, \"db-operation\")\n * yield* Effect.log(\"Sending response\")\n * return data\n * })\n *\n * const program = Effect.withLogSpan(httpRequest, \"http-handler\")\n *\n * const logger = Logger.make(({ message }) =>\n * void output.push(Array.isArray(message) ? message.join(\" \") : String(message))\n * )\n * void output.push(Effect.runSync(Effect.provide(program, Logger.layer([logger]))))\n * output // => [\"Making HTTP request\", \"Connecting to database\", \"Executing query\", \"Processing results\", \"Sending response\", \"data\"]\n * ```\n *\n * @category logging\n * @since 2.0.0\n */\nexport const withLogSpan = /*#__PURE__*/dual(2, (effect, label) => internal.flatMap(internal.currentTimeMillis, now => internal.updateService(effect, CurrentLogSpans, spans => {\n const span = [label, now];\n return [span, ...spans];\n})));\n// -----------------------------------------------------------------------------\n// Metrics\n// -----------------------------------------------------------------------------\n/**\n * Updates a metric after each effect execution, optionally mapping its `Exit` to\n * the metric's input.\n *\n * **Example** (Counting executions)\n *\n * ```ts import.meta.vitest\n * import { Effect, Metric } from \"effect\"\n *\n * const counter = Metric.counter(\"effect_executions\", {\n * description: \"Counts effect executions\"\n * }).pipe(Metric.withConstantInput(1))\n *\n * const program = Effect.succeed(\"Hello\").pipe(\n * Effect.track(counter)\n * )\n *\n * Effect.runSync(program)\n * Effect.runSync(Metric.value(counter)).count // => 1\n * ```\n *\n * **Example** (Mapping exits)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Metric } from \"effect\"\n *\n * const exitTracker = Metric.frequency(\"exit_types\", {\n * description: \"Tracks success/failure/defect counts\"\n * })\n *\n * const mapExitToString = (exit: Exit.Exit) => {\n * if (Exit.isSuccess(exit)) return \"success\"\n * if (Exit.isFailure(exit)) return \"failure\"\n * return \"defect\"\n * }\n *\n * const effect = Effect.succeed(\"result\").pipe(\n * Effect.track(exitTracker, mapExitToString)\n * )\n * Effect.runSync(effect)\n * Effect.runSync(Metric.value(exitTracker)).occurrences.get(\"success\") // => 1\n * ```\n *\n * @category metrics\n * @since 4.0.0\n */\nexport const track = /*#__PURE__*/dual(args => isEffect(args[0]), (self, metric, f) => onExit(self, exit => {\n const input = f === undefined ? exit : internalCall(() => f(exit));\n return Metric.update(metric, input);\n}));\n/**\n * Updates the provided `Metric` every time the wrapped `Effect` succeeds with\n * a value.\n *\n * **Details**\n *\n * Also accepts an optional function which can be used to map the success value\n * of the `Effect` into a valid `Input` for the `Metric`.\n *\n * **Example** (Counting successful results)\n *\n * ```ts import.meta.vitest\n * import { Effect, Metric } from \"effect\"\n *\n * const successCounter = Metric.counter(\"successes\").pipe(\n * Metric.withConstantInput(1)\n * )\n *\n * const program = Effect.succeed(42).pipe(\n * Effect.trackSuccesses(successCounter)\n * )\n *\n * Effect.runSync(program)\n * Effect.runSync(Metric.value(successCounter)).count // => 1\n * ```\n *\n * **Example** (Mapping successes before tracking)\n *\n * ```ts import.meta.vitest\n * import { Effect, Metric } from \"effect\"\n *\n * // Track successful request sizes\n * const requestSizeGauge = Metric.gauge(\"request_size_bytes\")\n *\n * const program = Effect.succeed(\"Hello World!\").pipe(\n * Effect.trackSuccesses(requestSizeGauge, (value: string) => value.length)\n * )\n *\n * Effect.runSync(program)\n * Effect.runSync(Metric.value(requestSizeGauge)).value // => 12\n * ```\n *\n * @category metrics\n * @since 4.0.0\n */\nexport const trackSuccesses = /*#__PURE__*/dual(args => isEffect(args[0]), (self, metric, f) => tap(self, value => {\n const input = f === undefined ? value : f(value);\n return Metric.update(metric, input);\n}));\n/**\n * Updates the provided `Metric` every time the wrapped `Effect` fails with an\n * **expected** error.\n *\n * **Details**\n *\n * Also accepts an optional function which can be used to map the error value\n * of the `Effect` into a valid `Input` for the `Metric`.\n *\n * **Example** (Counting expected failures)\n *\n * ```ts import.meta.vitest\n * import { Effect, Metric } from \"effect\"\n *\n * const errorCounter = Metric.counter(\"errors\").pipe(\n * Metric.withConstantInput(1)\n * )\n *\n * const program = Effect.fail(\"Network timeout\").pipe(\n * Effect.trackErrors(errorCounter)\n * )\n *\n * Effect.runSyncExit(program)\n * Effect.runSync(Metric.value(errorCounter)).count // => 1\n * ```\n *\n * **Example** (Mapping errors before tracking)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Metric } from \"effect\"\n *\n * class ConnectionFailedError extends Data.TaggedError(\"ConnectionFailedError\")<{}> {}\n *\n * // Track error types using frequency metric\n * const errorTypeFrequency = Metric.frequency(\"error_types\")\n *\n * const program = Effect.fail(new ConnectionFailedError()).pipe(\n * Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)\n * )\n *\n * Effect.runSyncExit(program)\n * Effect.runSync(Metric.value(errorTypeFrequency)).occurrences.get(\"ConnectionFailedError\") // => 1\n * ```\n *\n * @category metrics\n * @since 4.0.0\n */\nexport const trackErrors = /*#__PURE__*/dual(args => isEffect(args[0]), (self, metric, f) => tapError(self, error => {\n const input = f === undefined ? error : internalCall(() => f(error));\n return Metric.update(metric, input);\n}));\n/**\n * Updates the provided `Metric` every time the wrapped `Effect` fails with an\n * **unexpected** error (i.e. a defect).\n *\n * **Details**\n *\n * Also accepts an optional function which can be used to map the defect value\n * of the `Effect` into a valid `Input` for the `Metric`.\n *\n * **Example** (Counting defects)\n *\n * ```ts import.meta.vitest\n * import { Effect, Metric } from \"effect\"\n *\n * const defectCounter = Metric.counter(\"defects\").pipe(\n * Metric.withConstantInput(1)\n * )\n *\n * const program = Effect.die(\"Critical system failure\").pipe(\n * Effect.trackDefects(defectCounter)\n * )\n *\n * Effect.runSyncExit(program)\n * Effect.runSync(Metric.value(defectCounter)).count // => 1\n * ```\n *\n * **Example** (Mapping defects before tracking)\n *\n * ```ts import.meta.vitest\n * import { Effect, Metric } from \"effect\"\n *\n * // Track defect types using frequency metric\n * const defectTypeFrequency = Metric.frequency(\"defect_types\")\n *\n * const program = Effect.die(new Error(\"Null pointer exception\")).pipe(\n * Effect.trackDefects(defectTypeFrequency, (defect: unknown) => {\n * if (defect instanceof Error) return defect.constructor.name\n * return typeof defect\n * })\n * )\n *\n * Effect.runSyncExit(program)\n * Effect.runSync(Metric.value(defectTypeFrequency)).occurrences.get(\"Error\") // => 1\n * ```\n *\n * @category metrics\n * @since 4.0.0\n */\nexport const trackDefects = /*#__PURE__*/dual(args => isEffect(args[0]), (self, metric, f) => tapDefect(self, defect => {\n const input = f === undefined ? defect : internalCall(() => f(defect));\n return Metric.update(metric, input);\n}));\n/**\n * Updates the provided `Metric` with the `Duration` of time (in nanoseconds)\n * that the wrapped `Effect` took to complete.\n *\n * **Details**\n *\n * Also accepts an optional function which can be used to map the `Duration`\n * that the wrapped `Effect` took to complete into a valid `Input` for the\n * `Metric`.\n *\n * **Example** (Recording execution duration)\n *\n * ```ts import.meta.vitest\n * import { Effect, Metric } from \"effect\"\n *\n * const executionTimer = Metric.timer(\"execution_time\")\n *\n * const program = Effect.succeed(\"done\").pipe(\n * Effect.trackDuration(executionTimer)\n * )\n *\n * Effect.runSync(program)\n * Effect.runSync(Metric.value(executionTimer)).count // => 1\n * ```\n *\n * **Example** (Mapping duration before tracking)\n *\n * ```ts import.meta.vitest\n * import { Effect, Metric } from \"effect\"\n *\n * // Track execution time in milliseconds using custom mapping\n * const durationGauge = Metric.gauge(\"execution_millis\")\n *\n * const program = Effect.succeed(\"done\").pipe(\n * Effect.trackDuration(durationGauge, () => 1)\n * )\n *\n * Effect.runSync(program)\n * Effect.runSync(Metric.value(durationGauge)).value // => 1\n * ```\n *\n * @category metrics\n * @since 4.0.0\n */\nexport const trackDuration = /*#__PURE__*/dual(args => isEffect(args[0]), (self, metric, f) => clockWith(clock => {\n const startTime = clock.monotonicTimeNanosUnsafe();\n return onExit(self, () => {\n const endTime = clock.monotonicTimeNanosUnsafe();\n const duration = Duration.subtract(Duration.fromInputUnsafe(endTime), Duration.fromInputUnsafe(startTime));\n const input = f === undefined ? duration : internalCall(() => f(duration));\n return Metric.update(metric, input);\n });\n}));\n// -----------------------------------------------------------------------------\n// Transactions\n// -----------------------------------------------------------------------------\n/**\n * Service that holds the current transaction state.\n *\n * **Details**\n *\n * It includes a journal that stores non-committed changes to `TxRef` values and\n * a retry flag that records whether the transaction should be retried.\n *\n * **Example** (Building transactions)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // Transaction class for software transactional memory operations\n * const txEffect = Effect.gen(function*() {\n * const tx = yield* Effect.Transaction\n * // Use transaction for coordinated state changes\n * return \"Transaction complete\"\n * })\n *\n * const runnable = Effect.provideService(txEffect, Effect.Transaction, {\n * retry: false,\n * journal: new Map()\n * })\n * Effect.runSync(runnable) // => \"Transaction complete\"\n * ```\n *\n * @category services\n * @since 4.0.0\n */\nexport class Transaction extends /*#__PURE__*/Context.Service()(\"effect/Effect/Transaction\") {}\n/**\n * Defines a transaction boundary. Transactions are \"all or nothing\" with respect to changes\n * made to transactional values (i.e. TxRef) that occur within the transaction body.\n *\n * **Details**\n *\n * If called inside an active transaction, `tx` composes with the current transaction and reuses\n * its journal and retry state instead of creating a nested boundary.\n *\n * Effect transactions are optimistic with retry. A transaction is retried when\n * its body explicitly calls `Effect.txRetry` and any accessed transactional\n * value changes, or when any accessed transactional value changes because a\n * different transaction commits before the current one.\n *\n * The outermost `tx` call creates the transaction boundary and commits or rolls back the full\n * composed transaction.\n *\n * **Example** (Running a transaction)\n *\n * ```ts import.meta.vitest\n * import { Effect, TxRef } from \"effect\"\n * const output: Array = []\n *\n * const program = Effect.gen(function*() {\n * const ref1 = yield* TxRef.make(0)\n * const ref2 = yield* TxRef.make(0)\n *\n * // Nested tx calls compose into the same transaction\n * yield* Effect.tx(Effect.gen(function*() {\n * yield* TxRef.set(ref1, 10)\n * yield* Effect.tx(TxRef.set(ref2, 20))\n * const sum = (yield* TxRef.get(ref1)) + (yield* TxRef.get(ref2))\n * void output.push(`Transaction sum: ${sum}`)\n * }))\n *\n * void output.push(`Final ref1: ${yield* TxRef.get(ref1)}`)\n * void output.push(`Final ref2: ${yield* TxRef.get(ref2)}`)\n * })\n *\n * Effect.runSync(program)\n * output // => [\"Transaction sum: 30\", \"Final ref1: 10\", \"Final ref2: 20\"]\n * ```\n *\n * @category transactions\n * @since 4.0.0\n */\nexport const tx = effect => withFiber(fiber => {\n let state = Context.getOrUndefined(fiber.context, Transaction);\n if (state) {\n return effect;\n }\n // Create transaction state only at the outermost boundary\n state = {\n journal: new Map(),\n retry: false\n };\n let result;\n return uninterruptibleMask(restore => flatMap(whileLoop({\n while: () => !result,\n body: constant(restore(effect).pipe(provideService(Transaction, state), tapCause(() => {\n if (!state.retry) return void_;\n return restore(awaitPendingTransaction(state));\n }), exit)),\n step(exit) {\n if (state.retry || !isTransactionConsistent(state)) {\n return clearTransaction(state);\n }\n if (Exit.isSuccess(exit)) {\n commitTransaction(fiber, state);\n } else {\n clearTransaction(state);\n }\n result = exit;\n }\n }), () => result));\n});\nconst isTransactionConsistent = state => {\n for (const [ref, {\n version\n }] of state.journal) {\n if (ref.version !== version) {\n return false;\n }\n }\n return true;\n};\nconst awaitPendingTransaction = state => suspend(() => {\n const key = {};\n const refs = Array.from(state.journal.keys());\n const clearPending = () => {\n for (const clear of refs) {\n clear.pending.delete(key);\n }\n };\n return callback(resume => {\n const onCall = () => {\n clearPending();\n resume(void_);\n };\n for (const ref of refs) {\n ref.pending.set(key, onCall);\n }\n return sync(clearPending);\n });\n});\nfunction commitTransaction(fiber, state) {\n for (const [ref, {\n value\n }] of state.journal) {\n if (value !== ref.value) {\n ref.version = ref.version + 1;\n ref.value = value;\n }\n for (const pending of ref.pending.values()) {\n fiber.currentDispatcher.scheduleTask(pending, 0);\n }\n ref.pending.clear();\n }\n}\nfunction clearTransaction(state) {\n state.retry = false;\n state.journal.clear();\n}\n/**\n * Retries the current transaction by signaling that it must be retried.\n *\n * **Details**\n *\n * NOTE: the transaction retries on any change to transactional values (i.e. TxRef) accessed in its body.\n *\n * **Example** (Retrying transactions)\n *\n * ```ts import.meta.vitest\n * import { Deferred, Effect, TxRef } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const ref = yield* TxRef.make(0)\n * const update = yield* Deferred.make()\n *\n * yield* Effect.forkChild(\n * Deferred.await(update).pipe(Effect.andThen(Effect.tx(TxRef.set(ref, 1))))\n * )\n *\n * return yield* Effect.tx(Effect.gen(function*() {\n * const value = yield* TxRef.get(ref)\n * if (value === 0) {\n * yield* Deferred.succeed(update, undefined)\n * return yield* Effect.txRetry\n * }\n * return value\n * }))\n * })\n *\n * await Effect.runPromise(program) // => 1\n * ```\n *\n * @category transactions\n * @since 4.0.0\n */\nexport const txRetry = /*#__PURE__*/flatMap(Transaction, state => {\n state.retry = true;\n return interrupt;\n});\n/**\n * Converts an error-first callback API into a function that returns an\n * `Effect`.\n *\n * **Details**\n *\n * The original function is called with the supplied arguments plus a final\n * callback. A non-null callback error fails the returned effect, while a\n * successful callback value becomes the effect success. Use `onError` to map\n * callback errors and `onSyncError` to turn synchronous throws into typed\n * failures; otherwise synchronous throws become defects.\n *\n * **Example** (Converting callbacks to effects)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const uppercase = (\n * input: string,\n * callback: (error: Error | null, value?: string) => void\n * ) => queueMicrotask(() => callback(null, input.toUpperCase()))\n *\n * const effectfulUppercase = Effect.effectify(uppercase)\n * const program = effectfulUppercase(\"hello\")\n *\n * await Effect.runPromise(program) // => \"HELLO\"\n * ```\n *\n * **Example** (Mapping callback errors to typed failures)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const fail = (\n * input: string,\n * callback: (error: Error | null, value?: string) => void\n * ) => queueMicrotask(() => callback(new Error(\"unavailable\")))\n *\n * const effectfulFail = Effect.effectify(\n * fail,\n * (error, args) => new Error(`Failed to process ${args[0]}: ${error.message}`)\n * )\n *\n * const program = Effect.flip(effectfulFail(\"hello\"))\n *\n * const error = await Effect.runPromise(program)\n * error.message // => \"Failed to process hello: unavailable\"\n * ```\n *\n * @category converting\n * @since 4.0.0\n */\nexport const effectify = (fn, onError, onSyncError) => (...args) => callback(resume => {\n try {\n fn(...args, (err, result) => {\n if (err) {\n resume(fail(onError ? onError(err, args) : err));\n } else {\n resume(succeed(result));\n }\n });\n } catch (err) {\n resume(onSyncError ? fail(onSyncError(err, args)) : die(err));\n }\n});\n// -----------------------------------------------------------------------------\n// Type constraints\n// -----------------------------------------------------------------------------\n/**\n * Ensures that an effect's success type extends a given type `A`.\n *\n * **Details**\n *\n * This helper is checked at compile time and does not change the effect's\n * runtime behavior.\n *\n * **Example** (Constraining the success type)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // Define a constraint that the success type must be a number\n * const satisfiesNumber = Effect.satisfiesSuccessType()\n *\n * // This works - Effect<42, never, never> extends Effect\n * const validEffect = satisfiesNumber(Effect.succeed(42))\n * Effect.runSync(validEffect) // => 42\n *\n * // This would cause a TypeScript compilation error:\n * // const invalidEffect = satisfiesNumber(Effect.succeed(\"string\"))\n * // ^^^^^^^^^^^^^^^^^^^^^^\n * // Type 'string' is not assignable to type 'number'\n * ```\n *\n * @category utility types\n * @since 4.0.0\n */\nexport const satisfiesSuccessType = () => effect => effect;\n/**\n * Ensures that an effect's error type extends a given type `E`.\n *\n * **Details**\n *\n * This helper is checked at compile time and does not change the effect's\n * runtime behavior.\n *\n * **Example** (Constraining the error type)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect } from \"effect\"\n *\n * class ValidationError extends Data.TaggedError(\"ValidationError\")<{}> {}\n *\n * // Define a constraint that the error type must be a ValidationError\n * const satisfiesError = Effect.satisfiesErrorType()\n *\n * // This works - Effect extends the constrained type\n * const validEffect = satisfiesError(Effect.fail(new ValidationError()))\n * Effect.runSync(Effect.flip(validEffect))._tag // => \"ValidationError\"\n *\n * // This would cause a TypeScript compilation error:\n * // const invalidEffect = satisfiesError(Effect.fail(\"string error\"))\n * // ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n * // Type 'string' is not assignable to type 'ValidationError'\n * ```\n *\n * @category utility types\n * @since 4.0.0\n */\nexport const satisfiesErrorType = () => effect => effect;\n/**\n * Ensures that an effect's requirements type extends a given type `R`.\n *\n * **Details**\n *\n * This helper is checked at compile time and does not change the effect's\n * runtime behavior.\n *\n * **Example** (Constraining the services type)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // Define a constraint that requires a string as the requirements type\n * const satisfiesStringServices = Effect.satisfiesServicesType()\n *\n * // This works - effect requires string\n * const validEffect: Effect.Effect = Effect.succeed(42)\n * const constrainedEffect = satisfiesStringServices(validEffect)\n *\n * // This would cause a TypeScript compilation error if uncommented:\n * // const invalidEffect: Effect.Effect = Effect.succeed(42)\n * // const constrainedInvalid = satisfiesStringServices(invalidEffect)\n * ```\n *\n * @category utility types\n * @since 4.0.0\n */\nexport const satisfiesServicesType = () => effect => effect;\n/**\n * Applies `map` eagerly when an effect is already resolved.\n *\n * **When to use**\n *\n * Use when an already-resolved effect should apply a success transformation\n * immediately while pending effects still use regular mapping.\n *\n * **Details**\n *\n * Success effects apply the mapping function immediately. Failure effects pass\n * through unchanged, and pending effects fall back to regular `map` behavior.\n *\n * **Example** (Mapping already completed effects)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // For resolved effects, the mapping is applied immediately\n * const resolved = Effect.succeed(5)\n * const mapped = Effect.mapEager(resolved, (n) => n * 2) // Applied eagerly\n *\n * // For pending effects, behaves like regular map\n * const pending = Effect.delay(Effect.succeed(5), 0)\n * const mappedPending = Effect.mapEager(pending, (n) => n * 2) // Uses regular map\n *\n * await Effect.runPromise(Effect.all([mapped, mappedPending])) // => [10, 10]\n * ```\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapEager = internal.mapEager;\n/**\n * Applies `mapError` eagerly when an effect is already resolved.\n *\n * **When to use**\n *\n * Use when an already-resolved failed effect should apply an error\n * transformation immediately while pending effects still use regular error\n * mapping.\n *\n * **Details**\n *\n * Success effects pass through unchanged because there is no error to\n * transform. Failure effects apply the mapping function immediately, and\n * pending effects fall back to regular `mapError` behavior.\n *\n * **Example** (Mapping errors eagerly when possible)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * // For resolved failure effects, the error mapping is applied immediately\n * const failed = Effect.fail(\"original error\")\n * const mapped = Effect.mapErrorEager(failed, (err: string) => `mapped: ${err}`) // Applied eagerly\n *\n * // For pending effects, behaves like regular mapError\n * const pending = Effect.delay(Effect.fail(\"error\"), 0)\n * const mappedPending = Effect.mapErrorEager(\n * pending,\n * (err: string) => `mapped: ${err}`\n * ) // Uses regular mapError\n *\n * void output.push(await Effect.runPromise(Effect.all([\n * Effect.flip(mapped),\n * Effect.flip(mappedPending)\n * ])))\n * output // => [['mapped: original error', 'mapped: error']]\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const mapErrorEager = internal.mapErrorEager;\n/**\n * Applies `mapBoth` eagerly when an effect is already resolved.\n *\n * **When to use**\n *\n * Use when an already-resolved effect should transform either success or\n * failure immediately while pending effects still use regular channel mapping.\n *\n * **Details**\n *\n * Success effects apply `onSuccess` immediately, and failure effects apply\n * `onFailure` immediately. Pending effects fall back to regular `mapBoth`\n * behavior.\n *\n * **Example** (Mapping both channels eagerly when possible)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * // For resolved effects, the appropriate mapping is applied immediately\n * const success = Effect.succeed(5)\n * const mapped = Effect.mapBothEager(success, {\n * onFailure: (err: string) => `Failed: ${err}`,\n * onSuccess: (n: number) => n * 2\n * }) // onSuccess applied eagerly\n *\n * const failure = Effect.fail(\"error\")\n * const mappedError = Effect.mapBothEager(failure, {\n * onFailure: (err: string) => `Failed: ${err}`,\n * onSuccess: (n: number) => n * 2\n * }) // onFailure applied eagerly\n *\n * void output.push(Effect.runSync(mapped))\n * void output.push(Effect.runSync(Effect.flip(mappedError)))\n * output // => [10, \"Failed: error\"]\n * ```\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapBothEager = internal.mapBothEager;\n/**\n * Applies `flatMap` eagerly when an effect is already resolved.\n *\n * **When to use**\n *\n * Use when an already-resolved successful effect should bind immediately to the\n * next effect while pending effects still use regular flat mapping.\n *\n * **Details**\n *\n * Success effects apply the flatMap function immediately. Failure effects pass\n * through unchanged, and pending effects fall back to regular `flatMap`\n * behavior.\n *\n * **Example** (Flat mapping eagerly when possible)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * // For resolved effects, the flatMap is applied immediately\n * const resolved = Effect.succeed(5)\n * const flatMapped = Effect.flatMapEager(resolved, (n) => Effect.succeed(n * 2)) // Applied eagerly\n *\n * // For pending effects, behaves like regular flatMap\n * const pending = Effect.delay(Effect.succeed(5), 0)\n * const flatMappedPending = Effect.flatMapEager(\n * pending,\n * (n) => Effect.succeed(n * 2)\n * ) // Uses regular flatMap\n *\n * await Effect.runPromise(Effect.all([flatMapped, flatMappedPending])) // => [10, 10]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const flatMapEager = internal.flatMapEager;\n/**\n * Applies `catch` eagerly when an effect is already resolved.\n *\n * **When to use**\n *\n * Use when an already-resolved failed effect should recover immediately while\n * pending effects still use regular error recovery.\n *\n * **Details**\n *\n * Success effects pass through unchanged because there is no error to catch.\n * Failure effects apply the catch function immediately, and pending effects\n * fall back to regular `catch` behavior.\n *\n * **Example** (Catching failures eagerly when possible)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * const output: Array = []\n *\n * // For resolved failure effects, the catch function is applied immediately\n * const failed = Effect.fail(\"original error\")\n * const recovered = Effect.catchEager(\n * failed,\n * (err: string) => Effect.succeed(`recovered from: ${err}`)\n * ) // Applied eagerly\n *\n * // For success effects, returns success as-is\n * const success = Effect.succeed(42)\n * const unchanged = Effect.catchEager(\n * success,\n * (err: string) => Effect.succeed(`recovered from: ${err}`)\n * ) // Returns success as-is\n *\n * // For pending effects, behaves like regular catch\n * const pending = Effect.delay(Effect.fail(\"error\"), 0)\n * const recoveredPending = Effect.catchEager(\n * pending,\n * (err: string) => Effect.succeed(`recovered from: ${err}`)\n * ) // Uses regular catch\n *\n * void output.push(await Effect.runPromise(Effect.all([\n * recovered,\n * unchanged,\n * recoveredPending\n * ])))\n * output // => [['recovered from: original error', 42, 'recovered from: error']]\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchEager = internal.catchEager;\n/**\n * Creates untraced function effects with eager evaluation optimization.\n *\n * **Details**\n *\n * Executes generator functions eagerly when all yielded effects are synchronous,\n * stopping at the first async effect and deferring to normal execution.\n *\n * **Example** (Defining eager untraced effect functions)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n *\n * const computation = Effect.fnUntracedEager(function*() {\n * yield* Effect.succeed(1)\n * yield* Effect.succeed(2)\n * return \"computed eagerly\"\n * })\n *\n * const effect = computation() // Executed immediately if all effects are sync\n * Effect.runSync(effect) // => \"computed eagerly\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fnUntracedEager = internal.fnUntracedEager;\n//# sourceMappingURL=Effect.js.map","/**\n * Works with JavaScript `bigint` values.\n *\n * This module exposes the native `BigInt` constructor together with helpers for\n * checking, arithmetic, comparison, range checks, safe parsing and conversions\n * that return `Option`, integer square roots, aggregation, ordering,\n * equivalence, reducers, and combiners.\n *\n * @since 2.0.0\n */\nimport * as Combiner from \"./Combiner.js\";\nimport * as Equ from \"./Equivalence.js\";\nimport { dual } from \"./Function.js\";\nimport * as Option from \"./Option.js\";\nimport * as order from \"./Order.js\";\nimport * as predicate from \"./Predicate.js\";\nimport * as Reducer from \"./Reducer.js\";\n/**\n * Exposes the global bigint constructor for JavaScript bigint coercion.\n *\n * **When to use**\n *\n * Use to access native JavaScript bigint constructor coercion from the Effect\n * module namespace.\n *\n * **Gotchas**\n *\n * This follows native `BigInt` coercion rules. It throws for invalid strings or\n * non-integral numbers, and whitespace-only strings coerce to `0n`.\n *\n * @see {@link fromString} for parsing strings into an `Option`\n * @see {@link fromNumber} for converting safe integers into an `Option`\n *\n * **Example** (Constructing bigints)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.BigInt(123) // => 123n\n * BigInt.BigInt(\"456\") // => 456n\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const BigInt = globalThis.BigInt;\nconst bigint0 = /*#__PURE__*/BigInt(0);\nconst bigint1 = /*#__PURE__*/BigInt(1);\nconst bigint2 = /*#__PURE__*/BigInt(2);\n/**\n * Checks whether a value is a `bigint`.\n *\n * **When to use**\n *\n * Use to validate unknown input and narrow it to `bigint`.\n *\n * **Example** (Checking for bigints)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.isBigInt(1n) // => true\n * BigInt.isBigInt(1) // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isBigInt = predicate.isBigInt;\n/**\n * Provides an addition operation on `bigint`s.\n *\n * **When to use**\n *\n * Use when you need a binary addition function for piping or higher-order APIs\n * instead of the infix addition operator.\n *\n * **Example** (Adding bigints)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.sum(2n, 3n) // => 5n\n * ```\n *\n * @see {@link sumAll} for summing an iterable of `bigint` values\n *\n * @category math\n * @since 2.0.0\n */\nexport const sum = /*#__PURE__*/dual(2, (self, that) => self + that);\n/**\n * Provides a multiplication operation on `bigint`s.\n *\n * **When to use**\n *\n * Use to multiply two `bigint` values.\n *\n * **Example** (Multiplying bigints)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.multiply(2n, 3n) // => 6n\n * ```\n *\n * @see {@link multiplyAll} for multiplying an iterable of `bigint` values\n *\n * @category math\n * @since 2.0.0\n */\nexport const multiply = /*#__PURE__*/dual(2, (self, that) => self * that);\n/**\n * Provides a subtraction operation on `bigint`s.\n *\n * **When to use**\n *\n * Use to subtract one `bigint` value from another.\n *\n * **Example** (Subtracting bigints)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.subtract(2n, 3n) // => -1n\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const subtract = /*#__PURE__*/dual(2, (self, that) => self - that);\n/**\n * Divides one `bigint` by another safely.\n *\n * **When to use**\n *\n * Use to divide `bigint` values while representing division by zero as\n * `Option.none`.\n *\n * **Details**\n *\n * Uses JavaScript `bigint` division, so non-exact quotients are truncated\n * toward zero. Returns `Option.none()` when the divisor is `0n`.\n *\n * **Example** (Dividing bigints safely)\n *\n * ```ts import.meta.vitest\n * import { BigInt, Option } from \"effect\"\n *\n * BigInt.divide(6n, 3n) // => Option.some(2n)\n * BigInt.divide(6n, 0n) // => Option.none()\n * ```\n *\n * @see {@link divideUnsafe} for division that throws when the divisor is `0n`\n * @see {@link remainder} for the JavaScript remainder operation\n *\n * @category math\n * @since 2.0.0\n */\nexport const divide = /*#__PURE__*/dual(2, (self, that) => that === bigint0 ? Option.none() : Option.some(self / that));\n/**\n * Divides one `bigint` by another, throwing if the divisor is zero.\n *\n * **When to use**\n *\n * Use to divide `bigint` values where the divisor is known to be non-zero and\n * division by zero should be a thrown exception.\n *\n * **Details**\n *\n * Uses JavaScript `bigint` division, so non-exact quotients are truncated\n * toward zero.\n *\n * **Gotchas**\n *\n * Throws a `RangeError` when the divisor is `0n`.\n *\n * **Example** (Dividing bigints unsafely)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.divideUnsafe(6n, 3n) // => 2n\n * BigInt.divideUnsafe(6n, 4n) // => 1n\n * ```\n *\n * @see {@link divide} for division that returns `Option.none` when the divisor is `0n`\n *\n * @category math\n * @since 4.0.0\n */\nexport const divideUnsafe = /*#__PURE__*/dual(2, (self, that) => self / that);\n/**\n * Returns the result of adding `1n` to a `bigint`.\n *\n * **When to use**\n *\n * Use to increment a `bigint` counter by one.\n *\n * **Example** (Incrementing a bigint)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.increment(2n) // => 3n\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const increment = n => n + bigint1;\n/**\n * Returns the result of subtracting `1n` from a `bigint`.\n *\n * **When to use**\n *\n * Use to decrement a `bigint` counter by one.\n *\n * **Example** (Decrementing a bigint)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.decrement(3n) // => 2n\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const decrement = n => n - bigint1;\n/**\n * Provides an `Order` instance for `bigint` that allows comparing and sorting BigInt values.\n *\n * **When to use**\n *\n * Use when you need to sort or compare bigint values through APIs that accept\n * an ordering instance.\n *\n * **Example** (Comparing bigints with Order)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * const a = 123n\n * const b = 456n\n * const c = 123n\n *\n * BigInt.Order(a, b) // => -1\n * BigInt.Order(b, a) // => 1\n * BigInt.Order(a, c) // => 0\n * ```\n *\n * @category instances\n * @since 2.0.0\n */\nexport const Order = order.BigInt;\n/**\n * Equivalence instance for bigints using strict equality (`===`).\n *\n * **When to use**\n *\n * Use when checking bigint equality through APIs that accept an equivalence\n * relation.\n *\n * **Example** (Comparing bigints for equivalence)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.Equivalence(1n, 1n) // => true\n * BigInt.Equivalence(1n, 2n) // => false\n * ```\n *\n * @category instances\n * @since 2.0.0\n */\nexport const Equivalence = Equ.BigInt;\n/**\n * Returns `true` if the first argument is less than the second, otherwise `false`.\n *\n * **When to use**\n *\n * Use to test whether one `bigint` is strictly less than another.\n *\n * **Example** (Checking less-than comparisons)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.isLessThan(2n, 3n) // => true\n * BigInt.isLessThan(3n, 3n) // => false\n * BigInt.isLessThan(4n, 3n) // => false\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isLessThan = /*#__PURE__*/order.isLessThan(Order);\n/**\n * Returns a function that checks if a given `bigint` is less than or equal to the provided one.\n *\n * **When to use**\n *\n * Use to test whether one `bigint` is less than or equal to another.\n *\n * **Example** (Checking less-than-or-equal comparisons)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.isLessThanOrEqualTo(2n, 3n) // => true\n * BigInt.isLessThanOrEqualTo(3n, 3n) // => true\n * BigInt.isLessThanOrEqualTo(4n, 3n) // => false\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isLessThanOrEqualTo = /*#__PURE__*/order.isLessThanOrEqualTo(Order);\n/**\n * Returns `true` if the first argument is greater than the second, otherwise `false`.\n *\n * **When to use**\n *\n * Use to test whether one `bigint` is strictly greater than another.\n *\n * **Example** (Checking greater-than comparisons)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.isGreaterThan(2n, 3n) // => false\n * BigInt.isGreaterThan(3n, 3n) // => false\n * BigInt.isGreaterThan(4n, 3n) // => true\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isGreaterThan = /*#__PURE__*/order.isGreaterThan(Order);\n/**\n * Returns a function that checks if a given `bigint` is greater than or equal to the provided one.\n *\n * **When to use**\n *\n * Use to test whether one `bigint` is greater than or equal to another.\n *\n * **Example** (Checking greater-than-or-equal comparisons)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.isGreaterThanOrEqualTo(2n, 3n) // => false\n * BigInt.isGreaterThanOrEqualTo(3n, 3n) // => true\n * BigInt.isGreaterThanOrEqualTo(4n, 3n) // => true\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isGreaterThanOrEqualTo = /*#__PURE__*/order.isGreaterThanOrEqualTo(Order);\n/**\n * Checks whether a `bigint` is between a `minimum` and `maximum` value (inclusive).\n *\n * **When to use**\n *\n * Use to test whether a `bigint` falls inside an inclusive range.\n *\n * **Example** (Checking whether a bigint is within bounds)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * const between = BigInt.between({ minimum: 0n, maximum: 5n })\n *\n * between(3n) // => true\n * between(-1n) // => false\n * between(6n) // => false\n * ```\n *\n * @see {@link clamp} for forcing a `bigint` into an inclusive range\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const between = /*#__PURE__*/order.isBetween(Order);\n/**\n * Restricts the given `bigint` to be within the range specified by the `minimum` and `maximum` values.\n *\n * **When to use**\n *\n * Use to force a `bigint` into an inclusive range.\n *\n * **Details**\n *\n * If the `bigint` is less than the minimum, the function returns the minimum.\n * If the `bigint` is greater than the maximum, the function returns the\n * maximum. Otherwise, it returns the original `bigint`.\n *\n * **Example** (Clamping a bigint to bounds)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })\n *\n * clamp(3n) // => 3n\n * clamp(0n) // => 1n\n * clamp(6n) // => 5n\n * ```\n *\n * @see {@link between} for checking whether a `bigint` is already inside a range\n *\n * @category math\n * @since 2.0.0\n */\nexport const clamp = /*#__PURE__*/order.clamp(Order);\n/**\n * Returns the minimum between two `bigint`s.\n *\n * **When to use**\n *\n * Use to select the smaller of two `bigint` values.\n *\n * **Example** (Finding the minimum bigint)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.min(2n, 3n) // => 2n\n * ```\n *\n * @see {@link max} for selecting the larger value\n *\n * @category math\n * @since 2.0.0\n */\nexport const min = /*#__PURE__*/order.min(Order);\n/**\n * Returns the maximum between two `bigint`s.\n *\n * **When to use**\n *\n * Use to select the larger of two `bigint` values.\n *\n * **Example** (Finding the maximum bigint)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.max(2n, 3n) // => 3n\n * ```\n *\n * @see {@link min} for selecting the smaller value\n *\n * @category math\n * @since 2.0.0\n */\nexport const max = /*#__PURE__*/order.max(Order);\n/**\n * Determines the sign of a given `bigint`.\n *\n * **When to use**\n *\n * Use to classify a `bigint` as negative, zero, or positive.\n *\n * **Example** (Determining bigint signs)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.sign(-5n) // => -1\n * BigInt.sign(0n) // => 0\n * BigInt.sign(5n) // => 1\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const sign = n => order.BigInt(n, bigint0);\n/**\n * Determines the absolute value of a given `bigint`.\n *\n * **When to use**\n *\n * Use to remove the sign from a `bigint` while preserving its magnitude.\n *\n * **Example** (Calculating absolute values)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.abs(-5n) // => 5n\n * BigInt.abs(0n) // => 0n\n * BigInt.abs(5n) // => 5n\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const abs = n => n < bigint0 ? -n : n;\n/**\n * Determines the greatest common divisor of two `bigint`s.\n *\n * **When to use**\n *\n * Use to compute the greatest common divisor of two integer values.\n *\n * **Example** (Calculating greatest common divisors)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.gcd(2n, 3n) // => 1n\n * BigInt.gcd(2n, 4n) // => 2n\n * BigInt.gcd(16n, 24n) // => 8n\n * ```\n *\n * @see {@link lcm} for computing the least common multiple\n *\n * @category math\n * @since 2.0.0\n */\nexport const gcd = /*#__PURE__*/dual(2, (self, that) => {\n while (that !== bigint0) {\n const t = that;\n that = self % that;\n self = t;\n }\n return abs(self);\n});\n/**\n * Determines the least common multiple of two `bigint`s.\n *\n * **When to use**\n *\n * Use to compute the least common multiple of two integer values.\n *\n * **Example** (Calculating least common multiples)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.lcm(2n, 3n) // => 6n\n * BigInt.lcm(2n, 4n) // => 4n\n * BigInt.lcm(16n, 24n) // => 48n\n * ```\n *\n * @see {@link gcd} for computing the greatest common divisor\n *\n * @category math\n * @since 2.0.0\n */\nexport const lcm = /*#__PURE__*/dual(2, (self, that) => self === bigint0 || that === bigint0 ? bigint0 : abs(self * that / gcd(self, that)));\n/**\n * Returns the integer square root of a non-negative `bigint`.\n *\n * **When to use**\n *\n * Use when you need to compute an integer square root for a `bigint` that has\n * already been validated as non-negative, and you want negative input to throw\n * instead of returning `Option.none`.\n *\n * **Details**\n *\n * For non-perfect squares, returns the largest `bigint` whose square is less\n * than or equal to the input.\n *\n * **Gotchas**\n *\n * Throws a `RangeError` if the input is negative.\n *\n * **Example** (Calculating square roots unsafely)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.sqrtUnsafe(4n) // => 2n\n * BigInt.sqrtUnsafe(9n) // => 3n\n * BigInt.sqrtUnsafe(16n) // => 4n\n * ```\n *\n * @see {@link sqrt} for returning `Option.none` when the input is negative\n *\n * @category math\n * @since 4.0.0\n */\nexport const sqrtUnsafe = n => {\n if (n < bigint0) {\n throw new RangeError(\"Cannot take the square root of a negative number\");\n }\n if (n < bigint2) {\n return n;\n }\n let x = n / bigint2;\n while (x * x > n) {\n x = (n / x + x) / bigint2;\n }\n return x;\n};\n/**\n * Computes the integer square root of a `bigint` safely.\n *\n * **When to use**\n *\n * Use to compute an integer square root while representing negative input as\n * `Option.none`.\n *\n * **Details**\n *\n * For non-perfect squares, returns the largest `bigint` whose square is less\n * than or equal to the input. Returns `Option.none()` when the input is\n * negative.\n *\n * **Example** (Calculating square roots safely)\n *\n * ```ts import.meta.vitest\n * import { BigInt, Option } from \"effect\"\n *\n * BigInt.sqrt(4n) // => Option.some(2n)\n * BigInt.sqrt(9n) // => Option.some(3n)\n * BigInt.sqrt(16n) // => Option.some(4n)\n * BigInt.sqrt(-1n) // => Option.none()\n * ```\n *\n * @see {@link sqrtUnsafe} for square root computation that throws on negative input\n *\n * @category math\n * @since 2.0.0\n */\nexport const sqrt = n => isGreaterThanOrEqualTo(n, bigint0) ? Option.some(sqrtUnsafe(n)) : Option.none();\n/**\n * Takes an `Iterable` of `bigint`s and returns their sum as a single `bigint`. Returns `0n` for an empty iterable.\n *\n * **When to use**\n *\n * Use when you want an immediate aggregate from an iterable instead of a\n * folding reducer owned by another API.\n *\n * **Example** (Summing iterable bigints)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.sumAll([2n, 3n, 4n]) // => 9n\n * ```\n *\n * @see {@link sum} for adding two `bigint` values\n * @see {@link ReducerSum} for summing through APIs that consume a `Reducer`\n *\n * @category math\n * @since 2.0.0\n */\nexport const sumAll = collection => {\n let out = bigint0;\n for (const n of collection) {\n out += n;\n }\n return out;\n};\n/**\n * Takes an `Iterable` of `bigint`s and returns their product as a single `bigint`. Returns `1n` for an empty iterable.\n *\n * **When to use**\n *\n * Use to multiply all `bigint` values in an iterable.\n *\n * **Example** (Multiplying iterable bigints)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.multiplyAll([2n, 3n, 4n]) // => 24n\n * ```\n *\n * @see {@link multiply} for multiplying two `bigint` values\n * @see {@link ReducerMultiply} for multiplying through APIs that consume a `Reducer`\n *\n * @category math\n * @since 2.0.0\n */\nexport const multiplyAll = collection => {\n let out = bigint1;\n for (const n of collection) {\n if (n === bigint0) {\n return bigint0;\n }\n out *= n;\n }\n return out;\n};\n/**\n * Converts a `bigint` to a `number` safely.\n *\n * **When to use**\n *\n * Use to convert a `bigint` to a JavaScript number only when it is a safe\n * integer.\n *\n * **Details**\n *\n * If the `bigint` is outside the safe integer range for JavaScript (`Number.MAX_SAFE_INTEGER`\n * and `Number.MIN_SAFE_INTEGER`), it returns `Option.none()`.\n *\n * **Example** (Converting bigints to numbers)\n *\n * ```ts import.meta.vitest\n * import { BigInt as BI, Option } from \"effect\"\n *\n * BI.toNumber(42n) // => Option.some(42)\n * BI.toNumber(9007199254740992n) // => Option.none()\n * BI.toNumber(-9007199254740992n) // => Option.none()\n * ```\n *\n * @see {@link fromNumber} for converting a safe integer number to `bigint`\n *\n * @category converting\n * @since 2.0.0\n */\nexport const toNumber = b => {\n if (b > BigInt(Number.MAX_SAFE_INTEGER) || b < BigInt(Number.MIN_SAFE_INTEGER)) {\n return Option.none();\n }\n return Option.some(Number(b));\n};\n/**\n * Parses a string into a `bigint` safely.\n *\n * **When to use**\n *\n * Use to parse a string as a `bigint` without throwing on invalid input.\n *\n * **Details**\n *\n * If the string is empty or contains characters that cannot be converted into a\n * `bigint`, it returns `Option.none()`.\n *\n * **Example** (Parsing strings as bigints)\n *\n * ```ts import.meta.vitest\n * import { BigInt, Option } from \"effect\"\n *\n * BigInt.fromString(\"42\") // => Option.some(42n)\n * BigInt.fromString(\" \") // => Option.none()\n * BigInt.fromString(\"a\") // => Option.none()\n * ```\n *\n * @see {@link BigInt} for native constructor coercion that throws on invalid input\n *\n * @category converting\n * @since 2.4.12\n */\nexport const fromString = s => {\n try {\n return s.trim() === \"\" ? Option.none() : Option.some(BigInt(s));\n } catch {\n return Option.none();\n }\n};\n/**\n * Converts a number to a `bigint`.\n *\n * **When to use**\n *\n * Use to convert a JavaScript number to `bigint` only when it is a safe integer.\n *\n * **Details**\n *\n * If the number is outside the safe integer range for JavaScript\n * (`Number.MAX_SAFE_INTEGER` and `Number.MIN_SAFE_INTEGER`) or if the number is\n * not a valid `bigint`, it returns `Option.none()`.\n *\n * **Example** (Converting numbers to bigints)\n *\n * ```ts import.meta.vitest\n * import { BigInt, Option } from \"effect\"\n *\n * BigInt.fromNumber(42) // => Option.some(42n)\n * BigInt.fromNumber(Number.MAX_SAFE_INTEGER + 1) // => Option.none()\n * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // => Option.none()\n * ```\n *\n * @see {@link toNumber} for converting `bigint` values back to safe integer numbers\n * @see {@link BigInt} for native constructor coercion\n *\n * @category converting\n * @since 2.4.12\n */\nexport function fromNumber(n) {\n if (n > Number.MAX_SAFE_INTEGER || n < Number.MIN_SAFE_INTEGER) {\n return Option.none();\n }\n try {\n return Option.some(BigInt(n));\n } catch {\n return Option.none();\n }\n}\n/**\n * Returns the JavaScript remainder of dividing one `bigint` by another.\n *\n * **When to use**\n *\n * Use when you want native remainder semantics, including signed remainders and\n * a thrown division-by-zero error.\n *\n * **Gotchas**\n *\n * Throws a `RangeError` when the divisor is `0n`.\n *\n * **Example** (Calculating remainders)\n *\n * ```ts import.meta.vitest\n * import { BigInt } from \"effect\"\n *\n * BigInt.remainder(10n, 3n) // => 1n\n * BigInt.remainder(15n, 4n) // => 3n\n * ```\n *\n * @see {@link divide} for quotient calculation with division-by-zero represented as `Option.none`\n *\n * @category math\n * @since 4.0.0\n */\nexport const remainder = /*#__PURE__*/dual(2, (self, divisor) => self % divisor);\n/**\n * Reducer for combining `bigint`s using addition.\n *\n * **When to use**\n *\n * Use to sum many `bigint` values through APIs that consume a `Reducer`.\n *\n * **Details**\n *\n * The initial value is `0n`, so `combineAll([])` returns `0n`.\n *\n * @see {@link sumAll} for summing an iterable directly\n * @see {@link ReducerMultiply} for multiplying `bigint` values\n *\n * @category math\n * @since 4.0.0\n */\nexport const ReducerSum = /*#__PURE__*/Reducer.make((a, b) => a + b, bigint0);\n/**\n * Reducer for combining `bigint`s using multiplication.\n *\n * **When to use**\n *\n * Use to multiply many `bigint` values through APIs that consume a `Reducer`.\n *\n * **Details**\n *\n * The initial value is `1n`, so `combineAll([])` returns `1n`.\n *\n * @see {@link multiplyAll} for multiplying an iterable directly\n * @see {@link ReducerSum} for summing `bigint` values\n *\n * @category math\n * @since 4.0.0\n */\nexport const ReducerMultiply = /*#__PURE__*/Reducer.make((a, b) => a * b, bigint1, collection => {\n let acc = bigint1;\n for (const n of collection) {\n if (n === bigint0) return bigint0;\n acc *= n;\n }\n return acc;\n});\n/**\n * Combiner that returns the maximum `bigint`.\n *\n * **When to use**\n *\n * Use to keep the largest `bigint` when an API consumes a `Combiner`.\n *\n * @see {@link CombinerMin} for keeping the smallest `bigint`\n * @see {@link max} for comparing two `bigint` values directly\n *\n * @category math\n * @since 4.0.0\n */\nexport const CombinerMax = /*#__PURE__*/Combiner.max(Order);\n/**\n * Combiner that returns the minimum `bigint`.\n *\n * **When to use**\n *\n * Use to keep the smallest `bigint` through APIs that consume a `Combiner`.\n *\n * @see {@link CombinerMax} for keeping the largest `bigint`\n * @see {@link min} for comparing two `bigint` values directly\n *\n * @category math\n * @since 4.0.0\n */\nexport const CombinerMin = /*#__PURE__*/Combiner.min(Order);\n//# sourceMappingURL=BigInt.js.map","/**\n * Represents exact, non-negative, integral byte counts.\n *\n * Decimal units use powers of 1,000 and binary units use powers of 1,024.\n *\n * @since 4.0.0\n */\nimport * as BI from \"./BigInt.js\";\nimport { dual } from \"./Function.js\";\nimport * as Option from \"./Option.js\";\nconst TypeId = \"~effect/ByteSize\";\nconst bigint0 = /*#__PURE__*/BigInt(0);\nconst bigint1 = /*#__PURE__*/BigInt(1);\nconst decimalBase = /*#__PURE__*/BigInt(1000);\nconst binaryBase = /*#__PURE__*/BigInt(1024);\nconst decimalUnits = [{\n symbol: \"B\",\n factor: bigint1,\n names: [\"B\", \"byte\", \"bytes\"]\n}, {\n symbol: \"kB\",\n factor: decimalBase,\n names: [\"kB\", \"kilobyte\", \"kilobytes\"]\n}, {\n symbol: \"MB\",\n factor: decimalBase ** /*#__PURE__*/BigInt(2),\n names: [\"MB\", \"megabyte\", \"megabytes\"]\n}, {\n symbol: \"GB\",\n factor: decimalBase ** /*#__PURE__*/BigInt(3),\n names: [\"GB\", \"gigabyte\", \"gigabytes\"]\n}, {\n symbol: \"TB\",\n factor: decimalBase ** /*#__PURE__*/BigInt(4),\n names: [\"TB\", \"terabyte\", \"terabytes\"]\n}, {\n symbol: \"PB\",\n factor: decimalBase ** /*#__PURE__*/BigInt(5),\n names: [\"PB\", \"petabyte\", \"petabytes\"]\n}, {\n symbol: \"EB\",\n factor: decimalBase ** /*#__PURE__*/BigInt(6),\n names: [\"EB\", \"exabyte\", \"exabytes\"]\n}, {\n symbol: \"ZB\",\n factor: decimalBase ** /*#__PURE__*/BigInt(7),\n names: [\"ZB\", \"zettabyte\", \"zettabytes\"]\n}, {\n symbol: \"YB\",\n factor: decimalBase ** /*#__PURE__*/BigInt(8),\n names: [\"YB\", \"yottabyte\", \"yottabytes\"]\n}, {\n symbol: \"RB\",\n factor: decimalBase ** /*#__PURE__*/BigInt(9),\n names: [\"RB\", \"ronnabyte\", \"ronnabytes\"]\n}, {\n symbol: \"QB\",\n factor: decimalBase ** /*#__PURE__*/BigInt(10),\n names: [\"QB\", \"quettabyte\", \"quettabytes\"]\n}];\nconst binaryUnits = [decimalUnits[0], {\n symbol: \"KiB\",\n factor: binaryBase,\n names: [\"KiB\", \"kibibyte\", \"kibibytes\"]\n}, {\n symbol: \"MiB\",\n factor: binaryBase ** /*#__PURE__*/BigInt(2),\n names: [\"MiB\", \"mebibyte\", \"mebibytes\"]\n}, {\n symbol: \"GiB\",\n factor: binaryBase ** /*#__PURE__*/BigInt(3),\n names: [\"GiB\", \"gibibyte\", \"gibibytes\"]\n}, {\n symbol: \"TiB\",\n factor: binaryBase ** /*#__PURE__*/BigInt(4),\n names: [\"TiB\", \"tebibyte\", \"tebibytes\"]\n}, {\n symbol: \"PiB\",\n factor: binaryBase ** /*#__PURE__*/BigInt(5),\n names: [\"PiB\", \"pebibyte\", \"pebibytes\"]\n}, {\n symbol: \"EiB\",\n factor: binaryBase ** /*#__PURE__*/BigInt(6),\n names: [\"EiB\", \"exbibyte\", \"exbibytes\"]\n}, {\n symbol: \"ZiB\",\n factor: binaryBase ** /*#__PURE__*/BigInt(7),\n names: [\"ZiB\", \"zebibyte\", \"zebibytes\"]\n}, {\n symbol: \"YiB\",\n factor: binaryBase ** /*#__PURE__*/BigInt(8),\n names: [\"YiB\", \"yobibyte\", \"yobibytes\"]\n}];\nconst allUnits = [...decimalUnits, ... /*#__PURE__*/binaryUnits.slice(1)];\nconst unitsByName = /*#__PURE__*/new Map(/*#__PURE__*/allUnits.flatMap(unit => unit.names.map(name => [name, unit])));\nconst unitsBySymbol = /*#__PURE__*/new Map(/*#__PURE__*/allUnits.map(unit => [unit.symbol, unit]));\nconst make = value => value;\n/**\n * The byte size containing zero bytes.\n *\n * @category constants\n * @since 4.0.0\n */\nexport const zero = /*#__PURE__*/make(bigint0);\nconst invalid = message => {\n throw new Error(`Invalid ByteSize: ${message}`);\n};\nconst fromNumber = input => {\n if (!Number.isSafeInteger(input) || input < 0) {\n return invalid(`expected a non-negative safe integer, received ${input}`);\n }\n return make(BigInt(input));\n};\nconst fromQuantity = (quantity, unit) => {\n if (typeof quantity === \"bigint\") {\n if (quantity < bigint0) return invalid(`expected a non-negative quantity, received ${quantity}`);\n return make(quantity * unit.factor);\n }\n const value = quantity * Number(unit.factor);\n if (!Number.isSafeInteger(value) || value < 0) {\n return invalid(`expected an exact non-negative safe-integer byte result, received ${quantity} ${unit.symbol}`);\n }\n return make(BigInt(value));\n};\nconst parse = input => {\n const match = /^\\s*(\\d+)(?:\\.(\\d+))?\\s*([A-Za-z]+)\\s*$/.exec(input);\n if (match === null) return invalid(`unsupported syntax ${JSON.stringify(input)}`);\n const unit = unitsByName.get(match[3]);\n if (unit === undefined) return invalid(`unsupported unit ${JSON.stringify(match[3])}`);\n const fraction = match[2] ?? \"\";\n const scale = BigInt(10) ** BigInt(fraction.length);\n const numerator = BigInt(match[1] + fraction) * unit.factor;\n if (numerator % scale !== bigint0) {\n return invalid(`${JSON.stringify(input)} does not represent an integral number of bytes`);\n }\n return make(numerator / scale);\n};\n/**\n * Decodes a trusted input into a byte size and throws for invalid input.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromInputUnsafe = input => {\n switch (typeof input) {\n case \"bigint\":\n if (input < bigint0) return invalid(`expected a non-negative bigint, received ${input}`);\n return make(input);\n case \"number\":\n return fromNumber(input);\n case \"string\":\n return parse(input);\n }\n return invalid(`unsupported input ${input}`);\n};\n/**\n * Decodes an input into a byte size, returning `None` for invalid input.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromInput = /*#__PURE__*/Option.liftThrowable(fromInputUnsafe);\n/**\n * Creates a byte size from a non-negative byte count.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const bytes = value => typeof value === \"bigint\" ? fromInputUnsafe(value) : fromNumber(value);\nconst unitConstructor = symbol => value => fromQuantity(value, unitsBySymbol.get(symbol));\n/**\n * Creates a decimal kilobyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const kilobytes = /*#__PURE__*/unitConstructor(\"kB\");\n/**\n * Creates a decimal megabyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const megabytes = /*#__PURE__*/unitConstructor(\"MB\");\n/**\n * Creates a decimal gigabyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const gigabytes = /*#__PURE__*/unitConstructor(\"GB\");\n/**\n * Creates a decimal terabyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const terabytes = /*#__PURE__*/unitConstructor(\"TB\");\n/**\n * Creates a decimal petabyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const petabytes = /*#__PURE__*/unitConstructor(\"PB\");\n/**\n * Creates a decimal exabyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const exabytes = /*#__PURE__*/unitConstructor(\"EB\");\n/**\n * Creates a decimal zettabyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const zettabytes = /*#__PURE__*/unitConstructor(\"ZB\");\n/**\n * Creates a decimal yottabyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const yottabytes = /*#__PURE__*/unitConstructor(\"YB\");\n/**\n * Creates a decimal ronnabyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const ronnabytes = /*#__PURE__*/unitConstructor(\"RB\");\n/**\n * Creates a decimal quettabyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const quettabytes = /*#__PURE__*/unitConstructor(\"QB\");\n/**\n * Creates a binary kibibyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const kibibytes = /*#__PURE__*/unitConstructor(\"KiB\");\n/**\n * Creates a binary mebibyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const mebibytes = /*#__PURE__*/unitConstructor(\"MiB\");\n/**\n * Creates a binary gibibyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const gibibytes = /*#__PURE__*/unitConstructor(\"GiB\");\n/**\n * Creates a binary tebibyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const tebibytes = /*#__PURE__*/unitConstructor(\"TiB\");\n/**\n * Creates a binary pebibyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const pebibytes = /*#__PURE__*/unitConstructor(\"PiB\");\n/**\n * Creates a binary exbibyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const exbibytes = /*#__PURE__*/unitConstructor(\"EiB\");\n/**\n * Creates a binary zebibyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const zebibytes = /*#__PURE__*/unitConstructor(\"ZiB\");\n/**\n * Creates a binary yobibyte value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const yobibytes = /*#__PURE__*/unitConstructor(\"YiB\");\n/**\n * Checks whether a value is a byte size.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isByteSize = input => typeof input === \"bigint\" && input >= bigint0;\n/**\n * Checks whether a byte size is zero.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isZero = self => self === bigint0;\n/**\n * Returns the exact byte count as a bigint.\n *\n * @category getters\n * @since 4.0.0\n */\nexport const toBigInt = self => self;\n/**\n * Converts a byte size to a safe integer, returning `None` when it is too large.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toNumber = BI.toNumber;\n/**\n * Converts a byte size to a safe integer and throws when it is too large.\n *\n * @category unsafe\n * @since 4.0.0\n */\nexport const toNumberUnsafe = self => Option.getOrThrowWith(toNumber(self), () => new Error(`ByteSize exceeds Number.MAX_SAFE_INTEGER: ${self}`));\n/**\n * Converts a byte size to an approximate number of the specified unit.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toUnit = /*#__PURE__*/dual(2, (self, unit) => Number(self) / Number(unitsBySymbol.get(unit).factor));\n/**\n * Provides an order for byte sizes.\n *\n * @category instances\n * @since 4.0.0\n */\nexport const Order = BI.Order;\n/**\n * Provides an equivalence for byte sizes.\n *\n * @category instances\n * @since 4.0.0\n */\nexport const Equivalence = BI.Equivalence;\n/**\n * Returns whether a byte size is in an inclusive range.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const between = BI.between;\n/**\n * Returns the smaller byte size.\n *\n * @category ordering\n * @since 4.0.0\n */\nexport const min = BI.min;\n/**\n * Returns the larger byte size.\n *\n * @category ordering\n * @since 4.0.0\n */\nexport const max = BI.max;\n/**\n * Constrains a byte size to an inclusive range.\n *\n * @category ordering\n * @since 4.0.0\n */\nexport const clamp = BI.clamp;\n/**\n * Checks whether the first byte size is less than the second.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isLessThan = BI.isLessThan;\n/**\n * Checks whether the first byte size is at most the second.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isLessThanOrEqualTo = BI.isLessThanOrEqualTo;\n/**\n * Checks whether the first byte size is greater than the second.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isGreaterThan = BI.isGreaterThan;\n/**\n * Checks whether the first byte size is at least the second.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isGreaterThanOrEqualTo = BI.isGreaterThanOrEqualTo;\n/**\n * Checks whether two byte sizes contain the same count.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const equals = /*#__PURE__*/dual(2, Equivalence);\n/**\n * Adds two byte sizes exactly.\n *\n * @category math\n * @since 4.0.0\n */\nexport const sum = BI.sum;\n/**\n * Subtracts byte sizes, returning `None` on underflow.\n *\n * @category math\n * @since 4.0.0\n */\nexport const subtract = /*#__PURE__*/dual(2, (self, that) => self < that ? Option.none() : Option.some(make(self - that)));\n/**\n * Subtracts byte sizes and throws on underflow.\n *\n * @category unsafe\n * @since 4.0.0\n */\nexport const subtractUnsafe = /*#__PURE__*/dual(2, (self, that) => {\n if (self < that) throw new Error(`ByteSize subtraction underflow: ${self} - ${that}`);\n return make(self - that);\n});\nconst scalar = (input, positive) => {\n if (typeof input === \"bigint\") return input >= (positive ? bigint1 : bigint0) ? input : undefined;\n return Number.isSafeInteger(input) && input >= (positive ? 1 : 0) ? BigInt(input) : undefined;\n};\n/**\n * Multiplies a byte size by a non-negative integer scalar.\n *\n * @category math\n * @since 4.0.0\n */\nexport const times = /*#__PURE__*/dual(2, (self, multiplier) => {\n const value = scalar(multiplier, false);\n return value === undefined ? Option.none() : Option.some(make(self * value));\n});\n/**\n * Divides a byte size by a positive integer, discarding any remainder.\n *\n * @category math\n * @since 4.0.0\n */\nexport const divide = /*#__PURE__*/dual(2, (self, divisor) => {\n const value = scalar(divisor, true);\n return value === undefined ? Option.none() : Option.some(make(self / value));\n});\nconst validatePrecision = precision => {\n if (!Number.isSafeInteger(precision) || precision < 0 || precision > 20) {\n throw new Error(`ByteSize format precision must be an integer from 0 to 20, received ${precision}`);\n }\n return precision;\n};\nconst formatWithUnit = (value, unit, precision, trailingZeros) => {\n const scale = BigInt(10) ** BigInt(precision);\n const rounded = (value * scale * BigInt(2) + unit.factor) / (unit.factor * BigInt(2));\n const whole = rounded / scale;\n if (precision === 0) return `${whole} ${unit.symbol}`;\n let fraction = `${rounded % scale}`.padStart(precision, \"0\");\n if (!trailingZeros) fraction = fraction.replace(/0+$/, \"\");\n return `${whole}${fraction.length === 0 ? \"\" : `.${fraction}`} ${unit.symbol}`;\n};\n/**\n * Formats a byte size with canonical decimal or binary unit symbols.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const format = (self, options = {}) => {\n const precision = validatePrecision(options.precision ?? 2);\n const trailingZeros = options.trailingZeros ?? false;\n if (options.unit !== undefined) {\n return formatWithUnit(self, unitsBySymbol.get(options.unit), precision, trailingZeros);\n }\n const units = options.system === \"decimal\" ? decimalUnits : binaryUnits;\n if (self === bigint0) return \"0 B\";\n let index = units.length - 1;\n while (index > 0 && self < units[index].factor) index--;\n if (index < units.length - 1) {\n const scale = BigInt(10) ** BigInt(precision);\n const rounded = (self * scale * BigInt(2) + units[index].factor) / (units[index].factor * BigInt(2));\n const base = options.system === \"decimal\" ? decimalBase : binaryBase;\n if (rounded >= base * scale) index++;\n }\n return formatWithUnit(self, units[index], precision, trailingZeros);\n};\n/**\n * Reducer that sums byte sizes from zero.\n *\n * @category math\n * @since 4.0.0\n */\nexport const ReducerSum = BI.ReducerSum;\n/**\n * Combiner that keeps the largest byte size.\n *\n * @category math\n * @since 4.0.0\n */\nexport const CombinerMax = BI.CombinerMax;\n/**\n * Combiner that keeps the smallest byte size.\n *\n * @category math\n * @since 4.0.0\n */\nexport const CombinerMin = BI.CombinerMin;\n//# sourceMappingURL=ByteSize.js.map","/**\n * Normalized errors for platform APIs.\n *\n * Platform services such as file systems, terminals, and sockets use\n * `PlatformError` to report host-level failures in a consistent shape. The\n * wrapper records whether the problem came from an invalid argument or from the\n * operating system, while preserving useful details such as the module, method,\n * path, descriptor, description, and original cause when available.\n *\n * @since 4.0.0\n */\nimport * as Data from \"./Data.js\";\nconst TypeId = \"~effect/PlatformError\";\n/**\n * Error data for an invalid argument passed to a platform API.\n *\n * **When to use**\n *\n * Use when you need to model caller input rejected before a platform operation\n * runs, including invalid-argument reason data.\n *\n * **Details**\n *\n * The error records the module and method that rejected the argument, with an\n * optional description and cause. It is usually wrapped in `PlatformError`.\n *\n * @see {@link badArgument} for creating a wrapped `PlatformError` whose reason is `BadArgument`\n * @see {@link SystemError} for failures reported by the host platform or operating system\n * @see {@link PlatformError} for the wrapper used by most platform APIs\n *\n * @category errors\n * @since 4.0.0\n */\nexport class BadArgument extends /*#__PURE__*/Data.TaggedError(\"BadArgument\") {\n /**\n * Formats the module, method, and optional description that rejected the argument.\n *\n * **When to use**\n *\n * Use to read the formatted error message for a rejected platform argument.\n *\n * @since 4.0.0\n */\n get message() {\n return `${this.module}.${this.method}${this.description ? `: ${this.description}` : \"\"}`;\n }\n}\n/**\n * Error data for a platform or system operation failure.\n *\n * **When to use**\n *\n * Use when you need normalized reason data for a platform or system operation\n * failure, including the operation details.\n *\n * **Details**\n *\n * The error records a normalized `_tag`, the module and method that failed,\n * and optional details such as the syscall, path or descriptor, description,\n * and original cause. It is usually wrapped in `PlatformError`.\n *\n * @see {@link systemError} for creating the usual `PlatformError` wrapper from this reason data\n * @see {@link BadArgument} for platform API failures caused by rejected caller input before an operation runs\n * @see {@link SystemErrorTag} for the normalized tag values stored in `_tag`\n *\n * @category errors\n * @since 4.0.0\n */\nexport class SystemError extends Data.Error {\n /**\n * Formats the normalized system error tag with operation and path details.\n *\n * **When to use**\n *\n * Use to read the formatted error message for a normalized system failure.\n *\n * @since 4.0.0\n */\n get message() {\n return `${this._tag}: ${this.module}.${this.method}${this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : \"\"}${this.description ? `: ${this.description}` : \"\"}`;\n }\n}\n/**\n * Tagged error used by platform APIs to report either invalid arguments or\n * system-level failures.\n *\n * **When to use**\n *\n * Use as the shared error type for platform APIs that expose invalid arguments\n * and host or operating-system failures through a single `Effect` error\n * channel.\n *\n * **Details**\n *\n * The `reason` field contains the underlying `BadArgument` or `SystemError`.\n * When that reason has a cause, the cause is preserved on the wrapper.\n *\n * @see {@link BadArgument} for invalid inputs rejected before an operation runs\n * @see {@link SystemError} for failures reported by the host platform or operating system\n * @see {@link badArgument} for creating this wrapper from rejected caller input\n * @see {@link systemError} for creating this wrapper from a host or operating-system failure\n *\n * @category errors\n * @since 4.0.0\n */\nexport class PlatformError extends /*#__PURE__*/Data.TaggedError(\"PlatformError\") {\n constructor(reason) {\n if (\"cause\" in reason) {\n super({\n reason,\n cause: reason.cause\n });\n } else {\n super({\n reason\n });\n }\n }\n /**\n * Marks this value as a platform error wrapper for runtime guards.\n *\n * **When to use**\n *\n * Use to identify `PlatformError` values through their runtime type marker.\n *\n * @since 4.0.0\n */\n [TypeId] = TypeId;\n get message() {\n return this.reason.message;\n }\n}\n/**\n * Creates a `PlatformError` whose reason is a `SystemError`.\n *\n * **When to use**\n *\n * Use to adapt an operating-system or platform failure into the normalized\n * platform error model.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const systemError = options => new PlatformError(new SystemError(options));\n/**\n * Creates a `PlatformError` whose reason is a `BadArgument`.\n *\n * **When to use**\n *\n * Use to report a platform API rejecting caller input before performing the\n * underlying operation.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const badArgument = options => new PlatformError(new BadArgument(options));\n//# sourceMappingURL=PlatformError.js.map","import * as effect from \"./internal/effect.js\";\nimport { hasProperty } from \"./Predicate.js\";\nconst TypeId = \"~effect/Fiber\";\nconst await_ = effect.fiberAwait;\nexport {\n/**\n * Waits for a fiber to complete and returns its exit value.\n *\n * **When to use**\n *\n * Use when you need to inspect whether the fiber succeeded,\n * failed, died, or was interrupted without propagating the failure.\n *\n * **Details**\n *\n * The returned Effect always succeeds with an `Exit` describing the fiber's\n * outcome.\n *\n * **Gotchas**\n *\n * This does not flatten the fiber result into the current Effect. Use\n * {@link join} when you want fiber failures to fail the current Effect.\n *\n * **Example** (Awaiting a fiber exit)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Fiber } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const fiber = yield* Effect.forkChild(Effect.succeed(42))\n * return yield* Fiber.await(fiber)\n * })\n *\n * const actual = await Effect.runPromise(program)\n * actual // => Exit.succeed(42)\n * ```\n *\n * @category combinators\n * @since 2.0.0\n */\nawait_ as await };\n/**\n * Waits for all fibers in the provided iterable to complete and returns\n * an array of their exit values.\n *\n * **When to use**\n *\n * Use when you need every fiber outcome as data, including failures and\n * interruptions.\n *\n * **Details**\n *\n * The returned array is ordered like the input iterable.\n *\n * **Gotchas**\n *\n * Failures are captured as `Exit.Failure` values. Use {@link joinAll} when you\n * want the first failed fiber to fail the returned Effect.\n *\n * **Example** (Awaiting multiple fiber exits)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Fiber } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const fiber1 = yield* Effect.forkChild(Effect.succeed(1))\n * const fiber2 = yield* Effect.forkChild(Effect.succeed(2))\n * return yield* Fiber.awaitAll([fiber1, fiber2])\n * })\n *\n * const actual = await Effect.runPromise(program)\n * actual // => [Exit.succeed(1), Exit.succeed(2)]\n * ```\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const awaitAll = effect.fiberAwaitAll;\n/**\n * Joins a fiber, blocking until it completes. If the fiber succeeds,\n * returns its value. If it fails, the error is propagated.\n *\n * **When to use**\n *\n * Use when you need a forked fiber's failure to fail the current Effect because\n * that fiber is part of the current workflow.\n *\n * **Gotchas**\n *\n * Joining a failed fiber propagates the fiber's Cause. Use {@link await_ await} when\n * you need to inspect the `Exit` instead of failing.\n *\n * **Example** (Joining a fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const fiber = yield* Effect.forkChild(Effect.succeed(42))\n * return yield* Fiber.join(fiber)\n * })\n *\n * const actual = await Effect.runPromise(program)\n * actual // => 42\n * ```\n *\n * @see {@link await_ await} for inspecting the fiber outcome as an Exit\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const join = effect.fiberJoin;\n/**\n * Waits for all fibers to succeed and returns their values in input order.\n *\n * **When to use**\n *\n * Use when you need every fiber to succeed and want the successful values\n * rather than the `Exit` values.\n *\n * **Details**\n *\n * If any fiber fails, the returned `Effect` fails with that fiber's cause and\n * stops waiting for additional results. This does not interrupt the remaining\n * fibers.\n *\n * **Gotchas**\n *\n * A failure stops waiting, but it does not interrupt any other fibers. Use\n * {@link interruptAll} separately when remaining fibers should be stopped.\n *\n * @see {@link awaitAll} for collecting every fiber outcome as an Exit\n *\n * @category combinators\n * @since 2.0.0\n */\nexport const joinAll = effect.fiberJoinAll;\n/**\n * Interrupts a fiber, causing it to stop executing and clean up any\n * acquired resources.\n *\n * **When to use**\n *\n * Use when you need to cancel a forked fiber and wait for its cleanup to\n * complete.\n *\n * **Details**\n *\n * The returned Effect completes only after the interrupted fiber has completed.\n *\n * **Gotchas**\n *\n * Interruption is cooperative. A fiber can continue running while it is inside\n * uninterruptible work or finalizers.\n *\n * **Example** (Interrupting a fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const fiber = yield* Effect.forkChild(\n * Effect.delay(\"1 second\")(Effect.succeed(42))\n * )\n * yield* Fiber.interrupt(fiber)\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @see {@link interruptAs} for specifying the interrupting fiber ID\n * @see {@link await_ await} for observing the interrupted fiber's Exit\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const interrupt = effect.fiberInterrupt;\n/**\n * Interrupts a fiber with a specific fiber ID as the interruptor. This allows\n * tracking which fiber initiated the interruption.\n *\n * **When to use**\n *\n * Use when runtime diagnostics or tracing should attribute the interruption to\n * a specific fiber ID.\n *\n * **Details**\n *\n * The returned Effect completes only after the interrupted fiber has completed.\n *\n * **Gotchas**\n *\n * The supplied ID affects the recorded interruptor. It does not make\n * interruption synchronous or force uninterruptible regions to stop early.\n *\n * **Example** (Interrupting a fiber as another fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const targetFiber = yield* Effect.forkChild(\n * Effect.delay(\"5 seconds\")(Effect.succeed(\"task completed\"))\n * )\n *\n * // Interrupt the fiber, specifying fiber ID 123 as the interruptor\n * yield* Fiber.interruptAs(targetFiber, 123)\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @see {@link interrupt} for using the current fiber as the interruptor\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const interruptAs = effect.fiberInterruptAs;\n/**\n * Interrupts all fibers in the provided iterable, causing them to stop executing\n * and clean up any acquired resources.\n *\n * **When to use**\n *\n * Use when you need to cancel several forked fibers and wait for their cleanup\n * to complete.\n *\n * **Details**\n *\n * The current fiber is recorded as the interruptor. The returned Effect\n * completes only after all interrupted fibers have completed.\n *\n * **Gotchas**\n *\n * Interruption is cooperative for each fiber. The returned Effect can wait for\n * uninterruptible work and finalizers in any interrupted fiber.\n *\n * **Example** (Interrupting multiple fibers)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const fiber1 = yield* Effect.forkChild(Effect.never)\n * const fiber2 = yield* Effect.forkChild(Effect.never)\n * const fiber3 = yield* Effect.forkChild(Effect.never)\n * yield* Fiber.interruptAll([fiber1, fiber2, fiber3])\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @see {@link interruptAllAs} for specifying the interrupting fiber ID\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const interruptAll = effect.fiberInterruptAll;\n/**\n * Interrupts all fibers in the provided iterable using the specified fiber ID as the\n * interrupting fiber. This allows you to control which fiber is considered the source\n * of the interruption, which can be useful for debugging and tracing.\n *\n * **When to use**\n *\n * Use to interrupt several fibers while recording a specific fiber ID as the\n * interruptor.\n *\n * **Details**\n *\n * The returned Effect completes only after all interrupted fibers have\n * completed.\n *\n * **Gotchas**\n *\n * The supplied ID affects the recorded interruptor. It does not make\n * interruption synchronous or force uninterruptible regions to stop early.\n *\n * **Example** (Interrupting multiple fibers as another fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * // Create a controlling fiber\n * const controllerFiber = yield* Effect.forkChild(Effect.succeed(\"controller\"))\n *\n * const worker1 = yield* Effect.forkChild(Effect.never)\n * const worker2 = yield* Effect.forkChild(Effect.never)\n *\n * yield* Fiber.interruptAllAs([worker1, worker2], controllerFiber.id)\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @see {@link interruptAll} for using the current fiber as the interruptor\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const interruptAllAs = effect.fiberInterruptAllAs;\n/**\n * Checks whether a value is a Fiber. This is a type guard that can be used to\n * determine if an unknown value is a Fiber instance.\n *\n * **When to use**\n *\n * Use when checking values at boundaries where an unknown value may be a\n * runtime fiber.\n *\n * **Details**\n *\n * The check looks for the internal Fiber type ID marker and does not inspect\n * the fiber's current state.\n *\n * **Example** (Checking for fibers)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * // Create a fiber\n * const fiber = yield* Effect.forkChild(Effect.succeed(42))\n *\n * // Test if values are fibers\n * return [Fiber.isFiber(fiber), Fiber.isFiber(\"hello\"), Fiber.isFiber(42), Fiber.isFiber(null)]\n * })\n *\n * const actual = await Effect.runPromise(program)\n * actual // => [true, false, false, false]\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isFiber = u => hasProperty(u, effect.FiberTypeId);\n/**\n * Returns the current fiber if called from within a fiber context,\n * otherwise returns `undefined`.\n *\n * **When to use**\n *\n * Use when you need low-level runtime integrations that need access to the currently\n * executing fiber.\n *\n * **Gotchas**\n *\n * This is a synchronous accessor, not an Effect. It returns `undefined` outside\n * an active fiber runtime context.\n *\n * **Example** (Getting the current fiber)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const current = Fiber.getCurrent()\n * return current !== undefined\n * })\n *\n * const actual = await Effect.runPromise(program)\n * actual // => true\n * ```\n *\n * @category getters\n * @since 4.0.0\n */\nexport const getCurrent = effect.getCurrentFiber;\n/**\n * Adds a fiber to a `Scope` and returns the same fiber.\n *\n * **When to use**\n *\n * Use when a manually managed fiber should be interrupted when a Scope closes.\n *\n * **Details**\n *\n * When the scope is closed, the fiber is interrupted. If the scope is already\n * closed, the fiber is interrupted immediately.\n *\n * **Gotchas**\n *\n * This does not wait for the fiber to complete. It only registers the\n * interruption finalizer and returns the same fiber.\n *\n * @see {@link interrupt} for interrupting and waiting for completion\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const runIn = effect.fiberRunIn;\n//# sourceMappingURL=Fiber.js.map","import * as internal from \"./internal/effect.js\";\n/**\n * Creates a `Latch` synchronously, outside of `Effect`.\n *\n * **When to use**\n *\n * Use when you need to allocate a `Latch` synchronously outside an Effect\n * workflow.\n *\n * **Details**\n *\n * The latch starts closed by default; pass `true` to create it open.\n *\n * **Example** (Creating a latch unsafely)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber, Latch } from \"effect\"\n *\n * const latch = Latch.makeUnsafe(false)\n * const waiter = latch.await.pipe(Effect.as(\"opened\"))\n *\n * const program = Effect.gen(function*() {\n * const fiber = yield* Effect.forkChild(waiter)\n * yield* latch.open\n * return yield* Fiber.join(fiber)\n * })\n *\n * await Effect.runPromise(program) // => \"opened\"\n * ```\n *\n * @see {@link make} for creating a latch inside Effect code\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeUnsafe = internal.makeLatchUnsafe;\n/**\n * Creates a `Latch` inside `Effect`.\n *\n * **When to use**\n *\n * Use to create a latch for coordinating fibers inside Effect code.\n *\n * **Details**\n *\n * The latch starts closed by default; pass `true` to create it open.\n *\n * **Example** (Creating a latch)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber, Latch } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const latch = yield* Latch.make(false)\n * const waiter = latch.await.pipe(Effect.as(\"opened\"))\n *\n * const fiber = yield* Effect.forkChild(waiter)\n * yield* latch.open\n * return yield* Fiber.join(fiber)\n * })\n *\n * await Effect.runPromise(program) // => \"opened\"\n * ```\n *\n * @see {@link makeUnsafe} for synchronous allocation outside Effect code\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = internal.makeLatch;\n/**\n * Opens the latch and releases fibers waiting on it.\n *\n * **When to use**\n *\n * Use to open a latch and release all fibers that are waiting on it.\n *\n * **Details**\n *\n * The returned effect succeeds with `true` when this call changed the latch\n * from closed to open, or `false` if it was already open.\n *\n * @see {@link openUnsafe} for a synchronous variant\n * @see {@link release} to release waiting fibers without opening the latch\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const open = self => self.open;\n/**\n * Opens the latch synchronously and releases fibers waiting on it.\n *\n * **When to use**\n *\n * Use when you need synchronous code to open a latch immediately and release\n * the fibers waiting on it.\n *\n * **Details**\n *\n * Returns `true` when this call changed the latch from closed to open, or\n * `false` if it was already open. This unsafe variant performs the state\n * change immediately instead of returning an `Effect`.\n *\n * @see {@link open} for the effectful variant\n * @see {@link release} to release waiting fibers without opening the latch\n * @see {@link closeUnsafe} for the synchronous inverse operation\n *\n * @category unsafe\n * @since 4.0.0\n */\nexport const openUnsafe = self => self.openUnsafe();\n/**\n * Releases the fibers currently waiting on a closed latch without opening it.\n *\n * **When to use**\n *\n * Use to let the fibers currently waiting on a latch proceed while keeping the\n * latch closed for future waiters.\n *\n * **Details**\n *\n * The returned effect succeeds with `true` when release was requested while\n * the latch was closed, or `false` if the latch was already open. Future\n * waiters still suspend until the latch is opened or released again.\n *\n * @see {@link open} for opening the latch for current and future waiters\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const release = self => self.release;\nconst _await = self => self.await;\nexport {\n/**\n * Waits for the latch to be opened.\n *\n * **When to use**\n *\n * Use to suspend the current fiber until the latch is opened or the current\n * set of waiters is released.\n *\n * **Details**\n *\n * Awaiting an already open latch completes immediately. Awaiting a closed\n * latch suspends until `open` or `release` resumes the waiters.\n *\n * **Gotchas**\n *\n * `release` can resume current waiters without opening the latch, so later\n * waiters may still suspend.\n *\n * @see {@link open} for opening the latch for current and future waiters\n * @see {@link release} for resuming current waiters without opening the latch\n * @see {@link whenOpen} for waiting before running another effect\n *\n * @category getters\n * @since 4.0.0\n */\n_await as await };\n/**\n * Closes the latch so future `await` and `whenOpen` calls suspend.\n *\n * **When to use**\n *\n * Use to re-enable waiting on a latch after it was opened, so later `await`\n * and `whenOpen` calls suspend again.\n *\n * **Details**\n *\n * The returned effect succeeds with `true` when this call changed the latch\n * from open to closed, or `false` if it was already closed.\n *\n * @see {@link closeUnsafe} for a synchronous variant\n * @see {@link open} for opening the latch for current and future waiters\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const close = self => self.close;\n/**\n * Closes the latch synchronously so future `await` and `whenOpen` calls\n * suspend.\n *\n * **When to use**\n *\n * Use to close a latch synchronously when the state change must happen outside\n * an `Effect`.\n *\n * **Details**\n *\n * Returns `true` when this call changed the latch from open to closed, or\n * `false` if it was already closed. This unsafe variant performs the state\n * change immediately instead of returning an `Effect`.\n *\n * @see {@link close} for the effectful variant\n * @see {@link openUnsafe} to synchronously open the latch and release waiting\n * fibers\n *\n * @category unsafe\n * @since 4.0.0\n */\nexport const closeUnsafe = self => self.closeUnsafe();\n/**\n * Waits on the latch, then runs the provided effect.\n *\n * **When to use**\n *\n * Use to gate another effect so it starts only after the latch is opened or\n * the current waiters are released.\n *\n * **Details**\n *\n * If the latch is open, the effect runs immediately. If it is closed, the\n * returned effect suspends until the latch is opened or the current waiters are\n * released. The provided effect's success, failure, and requirements are\n * preserved.\n *\n * @see `await` for waiting without running another effect\n * @see {@link open} for opening the latch for current and future waiters\n * @see {@link release} for resuming current waiters without opening the latch\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const whenOpen = (...args) => {\n if (args.length === 1) {\n const [self] = args;\n return effect => self.whenOpen(effect);\n }\n const [self, effect] = args;\n return self.whenOpen(effect);\n};\n/**\n * Checks whether the latch is currently open or closed.\n *\n * **When to use**\n *\n * Use to check the state of the latch without suspending or changing its state.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isOpen = self => self.isOpen();\n//# sourceMappingURL=Latch.js.map","/**\n * Stores synchronous mutable state in a small reference object.\n *\n * A `MutableRef` stores one current value and exposes it through `.current`.\n * Unlike `Ref`, its operations are synchronous and update the same object in\n * place. This module includes pipeable helpers for reading, setting, comparing,\n * and updating the value, plus numeric increment/decrement helpers and a\n * boolean toggle helper.\n *\n * @since 2.0.0\n */\nimport * as Equal from \"./Equal.js\";\nimport * as Dual from \"./Function.js\";\nimport { toJson } from \"./Inspectable.js\";\nimport { PipeInspectableProto } from \"./internal/core.js\";\nconst TypeId = \"~effect/MutableRef\";\nconst MutableRefProto = {\n [TypeId]: TypeId,\n ...PipeInspectableProto,\n toJSON() {\n return {\n _id: \"MutableRef\",\n current: toJson(this.current)\n };\n }\n};\n/**\n * Creates a new MutableRef with the specified initial value.\n *\n * **When to use**\n *\n * Use to create a synchronous `MutableRef` initialized with a value.\n *\n * **Example** (Creating mutable refs)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * // Create a counter reference\n * const counter = MutableRef.make(0)\n *\n * MutableRef.get(counter) // => 0\n *\n * // Create a configuration reference\n * const config = MutableRef.make({ debug: false, timeout: 5000 })\n *\n * MutableRef.get(config) // => { debug: false, timeout: 5000 }\n *\n * // Create a string reference\n * const status = MutableRef.make(\"idle\")\n * MutableRef.set(status, \"running\")\n *\n * MutableRef.get(status) // => \"running\"\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const make = value => {\n const ref = Object.create(MutableRefProto);\n ref.current = value;\n return ref;\n};\n/**\n * Sets the value to newValue atomically if the current value equals oldValue.\n * Returns true if the value was updated, false otherwise.\n * Uses Effect's Equal interface for value comparison.\n *\n * **When to use**\n *\n * Use to replace a `MutableRef` value only when the current value still matches\n * an expected value.\n *\n * **Example** (Comparing and setting values)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const ref = MutableRef.make(\"initial\")\n *\n * // Successful compare and set\n * const updated = MutableRef.compareAndSet(ref, \"initial\", \"updated\")\n *\n * updated // => true\n * MutableRef.get(ref) // => \"updated\"\n *\n * // Failed compare and set (value doesn't match)\n * const failed = MutableRef.compareAndSet(ref, \"initial\", \"failed\")\n *\n * failed // => false\n * MutableRef.get(ref) // => \"updated\"\n *\n * // Thread-safe counter increment\n * const counter = MutableRef.make(5)\n * let current: number\n * do {\n * current = MutableRef.get(counter)\n * } while (!MutableRef.compareAndSet(counter, current, current + 1))\n *\n * MutableRef.get(counter) // => 6\n *\n * // Pipe-able version\n * const casUpdate = MutableRef.compareAndSet(\"updated\", \"final\")\n *\n * casUpdate(ref) // => true\n * MutableRef.get(ref) // => \"final\"\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const compareAndSet = /*#__PURE__*/Dual.dual(3, (self, oldValue, newValue) => {\n if (Equal.equals(oldValue, self.current)) {\n self.current = newValue;\n return true;\n }\n return false;\n});\n/**\n * Decrements a numeric MutableRef by 1 and returns the reference.\n *\n * **When to use**\n *\n * Use when you need an in-place `MutableRef` decrement that returns the same\n * `MutableRef`.\n *\n * **Example** (Decrementing numeric refs)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const counter = MutableRef.make(5)\n *\n * // Decrement the counter\n * MutableRef.decrement(counter)\n *\n * MutableRef.get(counter) // => 4\n *\n * // Chain operations\n * MutableRef.decrement(counter)\n * MutableRef.decrement(counter)\n *\n * MutableRef.get(counter) // => 2\n *\n * // Useful for countdown scenarios\n * const countdown = MutableRef.make(10)\n * while (MutableRef.get(countdown) > 0) {\n * MutableRef.decrement(countdown)\n * }\n *\n * MutableRef.get(countdown) // => 0\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const decrement = self => update(self, n => n - 1);\n/**\n * Decrements a numeric MutableRef by 1 and returns the new value.\n *\n * **When to use**\n *\n * Use to decrement a numeric `MutableRef` and immediately read the updated\n * value.\n *\n * **Example** (Decrementing and reading refs)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const counter = MutableRef.make(5)\n *\n * // Decrement and get the new value\n * const newValue = MutableRef.decrementAndGet(counter)\n *\n * newValue // => 4\n * MutableRef.get(counter) // => 4\n *\n * // Use in expressions\n * const lives = MutableRef.make(3)\n * const message = `Lives remaining: ${MutableRef.decrementAndGet(lives)}`\n *\n * message // => \"Lives remaining: 2\"\n *\n * // Conditional logic based on decremented value\n * const attempts = MutableRef.make(3)\n * let retries = 0\n * while (MutableRef.decrementAndGet(attempts) >= 0) {\n * retries += 1\n * }\n *\n * retries // => 3\n * MutableRef.get(attempts) // => -1\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const decrementAndGet = self => updateAndGet(self, n => n - 1);\n/**\n * Gets the current value of the MutableRef.\n *\n * **When to use**\n *\n * Use to read the current `MutableRef` value without mutating it.\n *\n * **Example** (Reading current values)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const ref = MutableRef.make(\"hello\")\n *\n * MutableRef.get(ref) // => \"hello\"\n *\n * MutableRef.set(ref, \"world\")\n *\n * MutableRef.get(ref) // => \"world\"\n *\n * // Reading complex objects\n * const config = MutableRef.make({ port: 3000, host: \"localhost\" })\n * const currentConfig = MutableRef.get(config)\n *\n * currentConfig // => { port: 3000, host: \"localhost\" }\n *\n * // Multiple reads return the same value\n * const value1 = MutableRef.get(ref)\n * const value2 = MutableRef.get(ref)\n *\n * value1 === value2 // => true\n * ```\n *\n * @category getters\n * @since 2.0.0\n */\nexport const get = self => self.current;\n/**\n * Decrements a numeric MutableRef by 1 and returns the previous value.\n *\n * **When to use**\n *\n * Use to read the current numeric `MutableRef` value before decrementing it.\n *\n * **Example** (Reading before decrementing)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const counter = MutableRef.make(5)\n *\n * // Get current value and then decrement\n * const previousValue = MutableRef.getAndDecrement(counter)\n *\n * previousValue // => 5\n * MutableRef.get(counter) // => 4\n *\n * // Useful for processing where you need the original value\n * const itemsLeft = MutableRef.make(10)\n * const processedItems: Array = []\n * while (MutableRef.get(itemsLeft) > 0) {\n * const currentItem = MutableRef.getAndDecrement(itemsLeft)\n * processedItems.push(currentItem)\n * }\n *\n * processedItems // => [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n * MutableRef.get(itemsLeft) // => 0\n *\n * // Post-decrement semantics (like i-- in other languages)\n * const index = MutableRef.make(3)\n * const currentIndex = MutableRef.getAndDecrement(index)\n * const nextIndex = MutableRef.get(index)\n *\n * currentIndex // => 3\n * nextIndex // => 2\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const getAndDecrement = self => getAndUpdate(self, n => n - 1);\n/**\n * Increments a numeric MutableRef by 1 and returns the previous value.\n *\n * **When to use**\n *\n * Use to read the current numeric `MutableRef` value before incrementing it.\n *\n * **Example** (Reading before incrementing)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const counter = MutableRef.make(5)\n *\n * // Get current value and then increment\n * const previousValue = MutableRef.getAndIncrement(counter)\n *\n * previousValue // => 5\n * MutableRef.get(counter) // => 6\n *\n * // Useful for ID generation\n * const idGenerator = MutableRef.make(0)\n * const getId = () => MutableRef.getAndIncrement(idGenerator)\n * const ids = [getId(), getId(), getId()]\n *\n * ids // => [0, 1, 2]\n *\n * // Post-increment semantics (like i++ in other languages)\n * const position = MutableRef.make(0)\n * const currentPos = MutableRef.getAndIncrement(position)\n * const nextPos = MutableRef.get(position)\n *\n * currentPos // => 0\n * nextPos // => 1\n *\n * // Useful for iteration counters\n * const iterations = MutableRef.make(0)\n * const visited: Array = []\n * while (MutableRef.get(iterations) < 5) {\n * const iteration = MutableRef.getAndIncrement(iterations)\n * visited.push(iteration)\n * }\n *\n * visited // => [0, 1, 2, 3, 4]\n * MutableRef.get(iterations) // => 5\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const getAndIncrement = self => getAndUpdate(self, n => n + 1);\n/**\n * Sets the MutableRef to a new value and returns the previous value.\n *\n * **When to use**\n *\n * Use to replace the current `MutableRef` value while keeping the previous\n * value.\n *\n * **Example** (Reading before setting)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const ref = MutableRef.make(\"old\")\n *\n * // Set new value and get the previous one\n * const previous = MutableRef.getAndSet(ref, \"new\")\n *\n * previous // => \"old\"\n * MutableRef.get(ref) // => \"new\"\n *\n * // Swapping values\n * const counter = MutableRef.make(5)\n * const oldValue = MutableRef.getAndSet(counter, 10)\n * const newValue = MutableRef.get(counter)\n *\n * oldValue // => 5\n * newValue // => 10\n *\n * // Pipe-able version\n * const setValue = MutableRef.getAndSet(\"final\")\n * const previousValue = setValue(ref)\n *\n * previousValue // => \"new\"\n * MutableRef.get(ref) // => \"final\"\n *\n * // Useful for atomic swaps in algorithms\n * const buffer = MutableRef.make>([\"a\", \"b\", \"c\"])\n * const oldBuffer = MutableRef.getAndSet(buffer, [])\n *\n * oldBuffer // => [\"a\", \"b\", \"c\"]\n * MutableRef.get(buffer) // => []\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const getAndSet = /*#__PURE__*/Dual.dual(2, (self, value) => {\n const ret = self.current;\n self.current = value;\n return ret;\n});\n/**\n * Updates the MutableRef with the result of applying a function to its current value,\n * and returns the previous value.\n *\n * **When to use**\n *\n * Use to transform the current `MutableRef` value while keeping the previous\n * value.\n *\n * **Example** (Reading before updating)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const counter = MutableRef.make(5)\n *\n * // Increment and get the old value\n * const oldValue = MutableRef.getAndUpdate(counter, (n) => n + 1)\n *\n * oldValue // => 5\n * MutableRef.get(counter) // => 6\n *\n * // Double the value and get the previous one\n * const previous = MutableRef.getAndUpdate(counter, (n) => n * 2)\n *\n * previous // => 6\n * MutableRef.get(counter) // => 12\n *\n * // Transform string and get old value\n * const message = MutableRef.make(\"hello\")\n * const oldMessage = MutableRef.getAndUpdate(message, (s) => s.toUpperCase())\n *\n * oldMessage // => \"hello\"\n * MutableRef.get(message) // => \"HELLO\"\n *\n * // Pipe-able version\n * const addOne = MutableRef.getAndUpdate((n: number) => n + 1)\n * const result = addOne(counter)\n *\n * result // => 12\n * MutableRef.get(counter) // => 13\n *\n * // Useful for implementing atomic operations\n * const list = MutableRef.make>([1, 2, 3])\n * const oldList = MutableRef.getAndUpdate(list, (arr) => [...arr, 4])\n *\n * oldList // => [1, 2, 3]\n * MutableRef.get(list) // => [1, 2, 3, 4]\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const getAndUpdate = /*#__PURE__*/Dual.dual(2, (self, f) => getAndSet(self, f(get(self))));\n/**\n * Increments a numeric MutableRef by 1 and returns the reference.\n *\n * **When to use**\n *\n * Use when you need an in-place `MutableRef` increment that returns the same\n * `MutableRef`.\n *\n * **Example** (Incrementing numeric refs)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const counter = MutableRef.make(5)\n *\n * // Increment the counter\n * MutableRef.increment(counter)\n *\n * MutableRef.get(counter) // => 6\n *\n * // Chain operations\n * MutableRef.increment(counter)\n * MutableRef.increment(counter)\n *\n * MutableRef.get(counter) // => 8\n *\n * // Useful for simple counting\n * const visits = MutableRef.make(0)\n * MutableRef.increment(visits) // User visited\n * MutableRef.increment(visits) // Another visit\n *\n * MutableRef.get(visits) // => 2\n *\n * // Returns the reference for chaining\n * const result = MutableRef.increment(counter)\n *\n * result === counter // => true\n * MutableRef.get(counter) // => 9\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const increment = self => update(self, n => n + 1);\n/**\n * Increments a numeric MutableRef by 1 and returns the new value.\n *\n * **When to use**\n *\n * Use to increment a numeric `MutableRef` and immediately read the updated\n * value.\n *\n * **Example** (Incrementing and reading refs)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const counter = MutableRef.make(5)\n *\n * // Increment and get the new value\n * const newValue = MutableRef.incrementAndGet(counter)\n *\n * newValue // => 6\n * MutableRef.get(counter) // => 6\n *\n * // Use in expressions\n * const score = MutableRef.make(100)\n * const message = `New score: ${MutableRef.incrementAndGet(score)}`\n *\n * message // => \"New score: 101\"\n *\n * // Pre-increment semantics (like ++i in other languages)\n * const level = MutableRef.make(0)\n * const nextLevel = MutableRef.incrementAndGet(level)\n *\n * nextLevel // => 1\n *\n * // Conditional logic based on incremented value\n * const attempts = MutableRef.make(0)\n * const tooManyAttempts = MutableRef.incrementAndGet(attempts) > 3\n *\n * tooManyAttempts // => false\n * MutableRef.get(attempts) // => 1\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const incrementAndGet = self => updateAndGet(self, n => n + 1);\n/**\n * Sets the MutableRef to a new value and returns the reference.\n *\n * **When to use**\n *\n * Use when you need an in-place `MutableRef` replacement that returns the same\n * `MutableRef`.\n *\n * **Example** (Setting values)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const ref = MutableRef.make(\"initial\")\n *\n * // Set a new value\n * MutableRef.set(ref, \"updated\")\n *\n * MutableRef.get(ref) // => \"updated\"\n *\n * // Chain set operations (since it returns the ref)\n * const result = MutableRef.set(ref, \"final\")\n *\n * result === ref // => true\n * MutableRef.get(ref) // => \"final\"\n *\n * // Set complex objects\n * const config = MutableRef.make({ debug: false, verbose: false })\n * MutableRef.set(config, { debug: true, verbose: true })\n *\n * MutableRef.get(config) // => { debug: true, verbose: true }\n *\n * // Pipe-able version\n * const setValue = MutableRef.set(\"new value\")\n * setValue(ref)\n *\n * MutableRef.get(ref) // => \"new value\"\n *\n * // Useful for state management\n * const state = MutableRef.make<\"idle\" | \"loading\" | \"success\" | \"error\">(\"idle\")\n * MutableRef.set(state, \"loading\")\n * // ... perform async operation\n * MutableRef.set(state, \"success\")\n *\n * MutableRef.get(state) // => \"success\"\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const set = /*#__PURE__*/Dual.dual(2, (self, value) => {\n self.current = value;\n return self;\n});\n/**\n * Sets the MutableRef to a new value and returns the new value.\n *\n * **When to use**\n *\n * Use to replace the current `MutableRef` value and immediately read the\n * replacement.\n *\n * **Example** (Setting and reading values)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const ref = MutableRef.make(\"old\")\n *\n * // Set and get the new value\n * const newValue = MutableRef.setAndGet(ref, \"new\")\n *\n * newValue // => \"new\"\n * MutableRef.get(ref) // => \"new\"\n *\n * // Useful for assignments that need the value\n * const counter = MutableRef.make(0)\n * const currentValue = MutableRef.setAndGet(counter, 42)\n *\n * currentValue // => 42\n *\n * // Pipe-able version\n * const setValue = MutableRef.setAndGet(\"final\")\n * const result = setValue(ref)\n *\n * result // => \"final\"\n *\n * // Difference from set: returns value instead of reference\n * const ref1 = MutableRef.make(1)\n * const returnedRef = MutableRef.set(ref1, 2) // Returns MutableRef\n * const returnedValue = MutableRef.setAndGet(ref1, 3) // Returns value\n *\n * returnedRef === ref1 // => true\n * returnedValue // => 3\n * MutableRef.get(ref1) // => 3\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const setAndGet = /*#__PURE__*/Dual.dual(2, (self, value) => {\n self.current = value;\n return self.current;\n});\n/**\n * Updates the MutableRef with the result of applying a function to its current value,\n * and returns the reference.\n *\n * **When to use**\n *\n * Use when you need an in-place `MutableRef` value transformation that returns\n * the same `MutableRef`.\n *\n * **Example** (Updating values)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const counter = MutableRef.make(5)\n *\n * // Increment the counter\n * MutableRef.update(counter, (n) => n + 1)\n *\n * MutableRef.get(counter) // => 6\n *\n * // Chain updates (since it returns the ref)\n * const result = MutableRef.update(counter, (n) => n * 2)\n *\n * result === counter // => true\n * MutableRef.get(counter) // => 12\n *\n * // Transform string\n * const message = MutableRef.make(\"hello\")\n * MutableRef.update(message, (s) => s.toUpperCase())\n *\n * MutableRef.get(message) // => \"HELLO\"\n *\n * // Update complex objects\n * const user = MutableRef.make({ name: \"Alice\", age: 30 })\n * MutableRef.update(user, (u) => ({ ...u, age: u.age + 1 }))\n *\n * MutableRef.get(user) // => { name: \"Alice\", age: 31 }\n *\n * // Pipe-able version\n * const double = MutableRef.update((n: number) => n * 2)\n * double(counter)\n *\n * MutableRef.get(counter) // => 24\n *\n * // Array operations\n * const list = MutableRef.make>([1, 2, 3])\n * MutableRef.update(list, (arr) => [...arr, 4])\n *\n * MutableRef.get(list) // => [1, 2, 3, 4]\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const update = /*#__PURE__*/Dual.dual(2, (self, f) => set(self, f(get(self))));\n/**\n * Updates the MutableRef with the result of applying a function to its current value,\n * and returns the new value.\n *\n * **When to use**\n *\n * Use to transform the current `MutableRef` value and immediately read the\n * updated value.\n *\n * **Example** (Updating and reading values)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const counter = MutableRef.make(5)\n *\n * // Increment and get the new value\n * const newValue = MutableRef.updateAndGet(counter, (n) => n + 1)\n *\n * newValue // => 6\n * MutableRef.get(counter) // => 6\n *\n * // Double the value and get the result\n * const doubled = MutableRef.updateAndGet(counter, (n) => n * 2)\n *\n * doubled // => 12\n *\n * // Transform string and get result\n * const message = MutableRef.make(\"hello\")\n * const upperCase = MutableRef.updateAndGet(message, (s) => s.toUpperCase())\n *\n * upperCase // => \"HELLO\"\n *\n * // Pipe-able version\n * const increment = MutableRef.updateAndGet((n: number) => n + 1)\n * const result = increment(counter)\n *\n * result // => 13\n *\n * // Useful for calculations that need the result\n * const score = MutableRef.make(100)\n * const bonus = 50\n * const newScore = MutableRef.updateAndGet(score, (s) => s + bonus)\n *\n * newScore // => 150\n *\n * // Array transformations\n * const list = MutableRef.make>([1, 2, 3])\n * const newList = MutableRef.updateAndGet(list, (arr) => arr.map((x) => x * 2))\n *\n * newList // => [2, 4, 6]\n * MutableRef.get(list) // => [2, 4, 6]\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const updateAndGet = /*#__PURE__*/Dual.dual(2, (self, f) => setAndGet(self, f(get(self))));\n/**\n * Switches a boolean `MutableRef` between `true` and `false`, then returns the\n * reference.\n *\n * **When to use**\n *\n * Use when you need an in-place boolean `MutableRef` toggle that returns the\n * same `MutableRef`.\n *\n * **Example** (Toggling boolean refs)\n *\n * ```ts import.meta.vitest\n * import { MutableRef } from \"effect\"\n *\n * const flag = MutableRef.make(false)\n *\n * // Toggle the flag\n * MutableRef.toggle(flag)\n *\n * MutableRef.get(flag) // => true\n *\n * // Toggle again\n * MutableRef.toggle(flag)\n *\n * MutableRef.get(flag) // => false\n *\n * // Useful for state switches\n * const isVisible = MutableRef.make(true)\n * MutableRef.toggle(isVisible) // Hide\n *\n * MutableRef.get(isVisible) // => false\n *\n * // Toggle button implementation\n * const darkMode = MutableRef.make(false)\n * const toggleDarkMode = () => {\n * MutableRef.toggle(darkMode)\n * return MutableRef.get(darkMode) ? \"ON\" : \"OFF\"\n * }\n *\n * toggleDarkMode() // => \"ON\"\n * toggleDarkMode() // => \"OFF\"\n *\n * // Returns the reference for chaining\n * const result = MutableRef.toggle(flag)\n *\n * result === flag // => true\n * MutableRef.get(flag) // => true\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const toggle = self => update(self, _ => !_);\n//# sourceMappingURL=MutableRef.js.map","/**\n * Mutable lists for collecting ordered values and draining them from the front.\n * A `MutableList` can append values to the end, prepend values to the\n * beginning, take one or more values from the front, inspect its contents as an\n * array, filter values, remove values, and clear itself. All operations update\n * the same list object in place and keep its `length` field current. Taking\n * from an empty list returns the `Empty` symbol.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"./Array.js\";\nimport * as Count from \"./internal/count.js\";\n/**\n * Defines the unique symbol used to represent an empty result when taking elements from a MutableList.\n * This symbol is returned by `take` when the list is empty, allowing for safe type checking.\n *\n * **When to use**\n *\n * Use to detect that `take` returned no element before handling the result as a\n * list item.\n *\n * **Example** (Checking for empty results)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n *\n * MutableList.take(list) === MutableList.Empty // => true\n * ```\n *\n * @category symbols\n * @since 4.0.0\n */\nexport const Empty = /*#__PURE__*/Symbol.for(\"effect/MutableList/Empty\");\n/**\n * Creates an empty MutableList.\n *\n * **Example** (Creating an empty mutable list)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n *\n * list.length // => 0\n * MutableList.append(list, \"first\")\n * MutableList.take(list) // => \"first\"\n * list.length // => 0\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const make = () => ({\n head: undefined,\n tail: undefined,\n length: 0\n});\nconst emptyBucket = () => ({\n array: [],\n mutable: true,\n offset: 0,\n next: undefined\n});\n/**\n * Appends an element to the end of the MutableList.\n * This operation is optimized for high-frequency usage.\n *\n * **Example** (Appending elements)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.append(list, 1)\n * MutableList.append(list, 2)\n * MutableList.append(list, 3)\n *\n * MutableList.toArray(list) // => [1, 2, 3]\n * list.length // => 3\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const append = (self, message) => {\n if (!self.tail) {\n self.head = self.tail = emptyBucket();\n } else if (!self.tail.mutable) {\n self.tail.next = emptyBucket();\n self.tail = self.tail.next;\n }\n self.tail.array.push(message);\n self.length++;\n};\n/**\n * Prepends an element to the beginning of the MutableList.\n * This operation is optimized for high-frequency usage.\n *\n * **Example** (Prepending elements)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.append(list, \"last\")\n * MutableList.prepend(list, \"third\")\n * MutableList.prepend(list, \"second\")\n * MutableList.prepend(list, \"first\")\n *\n * MutableList.toArray(list) // => [\"first\", \"second\", \"third\", \"last\"]\n * ```\n *\n * @category mutations\n * @since 2.0.0\n */\nexport const prepend = (self, message) => {\n self.head = {\n array: [message],\n mutable: true,\n offset: 0,\n next: self.head\n };\n if (!self.tail) self.tail = self.head;\n self.length++;\n};\n/**\n * Prepends all elements from an iterable to the beginning of the MutableList.\n * The elements are added in order, so the first element in the iterable becomes\n * the new head of the list.\n *\n * **Example** (Prepending multiple elements)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.append(list, 4)\n * MutableList.append(list, 5)\n * MutableList.prependAll(list, [1, 2, 3])\n *\n * MutableList.toArray(list) // => [1, 2, 3, 4, 5]\n * ```\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const prependAll = (self, messages) => prependAllUnsafe(self, Arr.fromIterable(messages), !Array.isArray(messages));\n/**\n * Prepends all elements from a ReadonlyArray to the beginning of the MutableList.\n * This is an optimized version that can reuse the array when mutable=true.\n *\n * **When to use**\n *\n * Use when prepending a trusted array directly is worth the optimized path and\n * you can transfer ownership of the input when enabling mutation.\n *\n * **Gotchas**\n *\n * When mutable=true, ownership of the input array transfers to the list. Do not\n * read or modify the array afterward.\n *\n * **Example** (Transferring an array when prepending)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.append(list, 4)\n * const items = [1, 2, 3]\n * MutableList.prependAllUnsafe(list, items, true)\n *\n * MutableList.toArray(list) // => [1, 2, 3, 4]\n * ```\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const prependAllUnsafe = (self, messages, mutable = false) => {\n self.head = {\n array: messages,\n mutable,\n offset: 0,\n next: self.head\n };\n if (!self.tail && messages.length > 0) self.tail = self.head;\n self.length += self.head.array.length;\n};\n/**\n * Appends all elements from an iterable to the end of the MutableList.\n * Returns the number of elements added.\n *\n * **Example** (Appending multiple elements)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.append(list, 1)\n * MutableList.append(list, 2)\n *\n * MutableList.appendAll(list, [3, 4, 5]) // => 3\n * MutableList.toArray(list) // => [1, 2, 3, 4, 5]\n * list.length // => 5\n * ```\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const appendAll = (self, messages) => appendAllUnsafe(self, Arr.fromIterable(messages), !Array.isArray(messages));\n/**\n * Appends all elements from a ReadonlyArray to the end of the MutableList.\n * This is an optimized version that can reuse the array when mutable=true.\n * Returns the number of elements added.\n *\n * **When to use**\n *\n * Use when appending a trusted array directly is worth the optimized path and\n * you can transfer ownership of the input when enabling mutation.\n *\n * **Gotchas**\n *\n * When mutable=true, ownership of the input array transfers to the list. Do not\n * read or modify the array afterward.\n *\n * **Example** (Transferring an array when appending)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.append(list, 1)\n * const items = [2, 3, 4]\n * MutableList.appendAllUnsafe(list, items, true) // => 3\n *\n * MutableList.toArray(list) // => [1, 2, 3, 4]\n * ```\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const appendAllUnsafe = (self, messages, mutable = false) => {\n if (messages.length === 0) {\n return 0;\n }\n const chunk = {\n array: messages,\n mutable,\n offset: 0,\n next: undefined\n };\n if (self.head) {\n self.tail = self.tail.next = chunk;\n } else {\n self.head = self.tail = chunk;\n }\n self.length += messages.length;\n return messages.length;\n};\n/**\n * Removes all elements from the MutableList, resetting it to an empty state.\n * This operation is highly optimized and releases all internal memory.\n *\n * **Example** (Clearing a mutable list)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.appendAll(list, [1, 2, 3, 4, 5])\n *\n * MutableList.clear(list)\n *\n * MutableList.toArray(list) // => []\n * list.length // => 0\n * MutableList.take(list) === MutableList.Empty // => true\n * ```\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const clear = self => {\n self.head = self.tail = undefined;\n self.length = 0;\n};\n/**\n * Takes up to N elements from the beginning of the MutableList and returns them as an array.\n * The taken elements are removed from the list. This operation is optimized for performance\n * and includes zero-copy optimizations when possible.\n *\n * **Details**\n *\n * Finite fractional values of `n` are rounded down. `NaN` and non-positive\n * values leave the list unchanged and return an empty array.\n *\n * **Example** (Taking batches)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.appendAll(list, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n *\n * MutableList.takeN(list, 3) // => [1, 2, 3]\n * MutableList.toArray(list) // => [4, 5, 6, 7, 8, 9, 10]\n * list.length // => 7\n * ```\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const takeN = (self, n) => {\n n = Count.normalize(n);\n if (n <= 0 || !self.head) return [];\n n = Math.min(n, self.length);\n if (n === self.length && self.head?.offset === 0 && !self.head.next) {\n const array = self.head.array;\n clear(self);\n return array;\n }\n const array = new Array(n);\n let index = 0;\n let chunk = self.head;\n while (chunk) {\n while (chunk.offset < chunk.array.length) {\n array[index++] = chunk.array[chunk.offset];\n if (chunk.mutable) chunk.array[chunk.offset] = undefined;\n chunk.offset++;\n if (index === n) {\n self.head = chunk;\n self.length -= n;\n if (self.length === 0) clear(self);\n return array;\n }\n }\n chunk = chunk.next;\n }\n clear(self);\n return array;\n};\n/**\n * Removes up to `n` elements from the beginning of the `MutableList` without\n * returning them.\n *\n * **When to use**\n *\n * Use to discard a bounded number of values from the head of a `MutableList`\n * when the removed values are not needed.\n *\n * **Details**\n *\n * Finite fractional values of `n` are rounded down. If `n` is `NaN` or\n * non-positive, or the list is empty, the list is left unchanged. If the\n * normalized count is greater than or equal to the current length, the list is\n * cleared.\n *\n * @see {@link takeN} for removing up to `n` values and returning them as an array\n * @see {@link clear} for removing every value from the list\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const takeNVoid = (self, n) => {\n n = Count.normalize(n);\n if (n <= 0 || !self.head) return;\n n = Math.min(n, self.length);\n if (n === self.length && self.head?.offset === 0 && !self.head.next) {\n clear(self);\n return;\n }\n let count = 0;\n let chunk = self.head;\n while (chunk) {\n const size = chunk.array.length - chunk.offset;\n if (count + size > n) {\n chunk.offset += n - count;\n self.head = chunk;\n self.length -= n;\n return;\n }\n count += size;\n chunk = chunk.next;\n }\n clear(self);\n return;\n};\n/**\n * Takes all elements from the MutableList and returns them as an array.\n * The list becomes empty after this operation. This is equivalent to takeN(list, list.length).\n *\n * **Example** (Draining all elements)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.appendAll(list, [\"apple\", \"banana\", \"cherry\"])\n *\n * MutableList.takeAll(list) // => [\"apple\", \"banana\", \"cherry\"]\n * list.length // => 0\n * ```\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const takeAll = self => takeN(self, self.length);\n/**\n * Takes a single element from the beginning of the MutableList.\n * Returns the element if available, or the Empty symbol if the list is empty.\n * The taken element is removed from the list.\n *\n * **Example** (Taking one element)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.appendAll(list, [\"first\", \"second\", \"third\"])\n *\n * MutableList.take(list) // => \"first\"\n * MutableList.toArray(list) // => [\"second\", \"third\"]\n * list.length // => 2\n * ```\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const take = self => {\n if (!self.head) return Empty;\n const message = self.head.array[self.head.offset];\n if (self.head.mutable) self.head.array[self.head.offset] = undefined;\n self.head.offset++;\n self.length--;\n if (self.head.offset === self.head.array.length) {\n if (self.head.next) {\n self.head = self.head.next;\n } else {\n clear(self);\n }\n }\n return message;\n};\n/**\n * Copies up to `n` elements from the beginning of the `MutableList` into a new\n * array without modifying the list.\n *\n * **When to use**\n *\n * Use when you need to inspect or snapshot a bounded prefix of the list without\n * consuming it.\n *\n * **Details**\n *\n * Finite fractional values of `n` are rounded down. `NaN` and non-positive\n * values return an empty array.\n *\n * @see {@link takeN} for removing up to `n` values and returning them as an array\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toArrayN = (self, n) => {\n n = Count.normalize(n);\n if (n <= 0) return [];\n const length = Math.min(n, self.length);\n const out = new Array(length);\n let index = 0;\n let bucket = self.head;\n while (bucket) {\n for (let i = bucket.offset; i < bucket.array.length; i++) {\n out[index++] = bucket.array[i];\n if (index === length) return out;\n }\n bucket = bucket.next;\n }\n return out;\n};\n/**\n * Copies all current elements of the `MutableList` into a new array without\n * modifying the list.\n *\n * **When to use**\n *\n * Use when you need a snapshot of all current elements while keeping the list\n * unchanged.\n *\n * @see {@link takeAll} for converting all elements to an array and clearing the list\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toArray = self => toArrayN(self, self.length);\n/**\n * Filters the MutableList in place, keeping only elements that satisfy the predicate.\n * This operation modifies the list and rebuilds its internal structure for efficiency.\n *\n * **Example** (Filtering in place)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.appendAll(list, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n *\n * MutableList.filter(list, (n) => n % 2 === 0)\n *\n * MutableList.toArray(list) // => [2, 4, 6, 8, 10]\n * ```\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const filter = (self, f) => {\n const array = [];\n let chunk = self.head;\n while (chunk) {\n for (let i = chunk.offset; i < chunk.array.length; i++) {\n if (f(chunk.array[i], i)) {\n array.push(chunk.array[i]);\n }\n }\n chunk = chunk.next;\n }\n if (array.length === 0) {\n clear(self);\n return;\n }\n self.head = self.tail = {\n array,\n mutable: true,\n offset: 0,\n next: undefined\n };\n self.length = array.length;\n};\n/**\n * Removes all occurrences of a value from the `MutableList` using JavaScript\n * strict equality semantics.\n *\n * **When to use**\n *\n * Use when in-place removal should use JavaScript identity/strict equality\n * rather than Effect structural equality.\n *\n * **Details**\n *\n * The list is modified in place.\n *\n * **Gotchas**\n *\n * Values are compared with `!==`, so this does not use Effect structural\n * equality.\n *\n * **Example** (Removing matching values)\n *\n * ```ts import.meta.vitest\n * import { MutableList } from \"effect\"\n *\n * const list = MutableList.make()\n * MutableList.appendAll(list, [\"apple\", \"banana\", \"apple\", \"cherry\", \"apple\"])\n *\n * MutableList.remove(list, \"apple\")\n *\n * MutableList.toArray(list) // => [\"banana\", \"cherry\"]\n * ```\n *\n * @category mutations\n * @since 4.0.0\n */\nexport const remove = (self, value) => filter(self, v => v !== value);\n//# sourceMappingURL=MutableList.js.map","/**\n * Passes values asynchronously between fibers.\n *\n * A `Queue` accepts values, hands each value to one consumer in offer\n * order, and can complete, fail, interrupt, or shut down. Queues can be bounded\n * or unbounded, and bounded queues can suspend, drop, or slide values when\n * producers are faster than consumers.\n *\n * @since 3.8.0\n */\nimport * as Arr from \"./Array.js\";\nimport { constant, constTrue, dual, identity } from \"./Function.js\";\nimport * as core from \"./internal/core.js\";\nimport { PipeInspectableProto } from \"./internal/core.js\";\nimport * as Count from \"./internal/count.js\";\nimport * as internalEffect from \"./internal/effect.js\";\nimport * as MutableList from \"./MutableList.js\";\nimport * as Option from \"./Option.js\";\nimport { hasProperty } from \"./Predicate.js\";\nimport * as Pull from \"./Pull.js\";\nconst TypeId = \"~effect/Queue\";\nconst EnqueueTypeId = \"~effect/Queue/Enqueue\";\nconst DequeueTypeId = \"~effect/Queue/Dequeue\";\n/**\n * Type guard to check if a value is a Queue.\n *\n * **When to use**\n *\n * Use to narrow an unknown value to a full `Queue` before passing it to APIs\n * that need both offering and taking capabilities.\n *\n * @see {@link isEnqueue} for checking values that only need write access\n * @see {@link isDequeue} for checking values that only need read access\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isQueue = u => hasProperty(u, TypeId);\n/**\n * Type guard to check if a value is an Enqueue.\n *\n * **When to use**\n *\n * Use to narrow an unknown value before calling queue operations that require\n * write-side access.\n *\n * **Gotchas**\n *\n * A full `Queue` also satisfies this guard because every queue includes the\n * enqueue side.\n *\n * @see {@link isQueue} for checking for a full read-write queue handle\n * @see {@link isDequeue} for checking for the read side of a queue\n * @see {@link asEnqueue} for narrowing an existing `Queue` to its write-only interface\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isEnqueue = u => hasProperty(u, EnqueueTypeId);\n/**\n * Type guard to check if a value is a Dequeue.\n *\n * **When to use**\n *\n * Use to narrow an unknown value before passing it to read-side queue\n * operations.\n *\n * @see {@link Dequeue} for the read-side queue handle checked by this guard\n * @see {@link isQueue} for checking for a full read-write queue handle\n * @see {@link isEnqueue} for checking for the write side of a queue\n * @see {@link asDequeue} for narrowing an existing `Queue` to its read-only interface\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isDequeue = u => hasProperty(u, DequeueTypeId);\n/**\n * Converts a `Queue` to its write-only `Enqueue` interface.\n *\n * **When to use**\n *\n * Use to expose only the producer side of a `Queue` to code that should offer\n * values or signal queue lifecycle.\n *\n * **Gotchas**\n *\n * This is a type-level capability restriction. It returns the same queue\n * object, so it does not hide read operations at runtime.\n *\n * @see {@link asDequeue} for exposing only the read side of a `Queue`\n * @see {@link Enqueue} for the write-only queue handle returned by this conversion\n *\n * @category converting\n * @since 4.0.0\n */\nexport const asEnqueue = self => self;\n/**\n * Narrows a `Queue` to a `Dequeue`, exposing the consumer side of the queue.\n *\n * **When to use**\n *\n * Use to pass a queue to code that should consume values while keeping\n * producer-side operations out of that code's TypeScript type.\n *\n * **Gotchas**\n *\n * This is a type-level narrowing operation. It returns the same queue object\n * and does not create a runtime wrapper.\n *\n * @see {@link asEnqueue} for narrowing a queue to its producer side\n * @see {@link Dequeue} for the consumer-side queue handle returned by this function\n *\n * @category converting\n * @since 4.0.0\n */\nexport const asDequeue = identity;\nconst variance = {\n _A: identity,\n _E: identity\n};\nconst QueueProto = {\n [TypeId]: variance,\n [EnqueueTypeId]: variance,\n [DequeueTypeId]: variance,\n ...PipeInspectableProto,\n toJSON() {\n return {\n _id: \"effect/Queue\",\n state: this.state._tag,\n size: sizeUnsafe(this)\n };\n }\n};\n/**\n * Creates a `Queue` with optional capacity and overflow strategy.\n *\n * **Details**\n *\n * By default the queue is unbounded and uses the `\"suspend\"` strategy. Provide\n * `capacity` for a bounded queue and choose `\"suspend\"`, `\"dropping\"`, or\n * `\"sliding\"` to control what happens when the queue is full. The returned\n * queue can be offered to, taken from, failed, ended, interrupted, or shut down.\n *\n * **Example** (Creating queues)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.make()\n *\n * // add messages to the queue\n * yield* Queue.offer(queue, 1)\n * yield* Queue.offer(queue, 2)\n * yield* Queue.offerAll(queue, [3, 4, 5])\n *\n * // take messages from the queue\n * const messages = yield* Queue.takeAll(queue)\n *\n * // signal that the queue is done\n * yield* Queue.end(queue)\n * const done = yield* Effect.flip(Queue.take(queue))\n *\n * // signal that another queue has failed\n * const failedQueue = yield* Queue.make()\n * const failed = yield* Queue.fail(failedQueue, \"boom\")\n * return { messages, done, failed }\n * })\n *\n * await Effect.runPromise(program) // => { messages: [1, 2, 3, 4, 5], done: Cause.Done(), failed: true }\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = options => core.withFiber(fiber => {\n const self = Object.create(QueueProto);\n self.dispatcher = fiber.currentDispatcher;\n self.capacity = options?.capacity ?? Number.POSITIVE_INFINITY;\n self.strategy = options?.strategy ?? \"suspend\";\n self.messages = MutableList.make();\n self.scheduleRunning = false;\n self.state = {\n _tag: \"Open\",\n takers: new Set(),\n offers: new Set(),\n awaiters: new Set()\n };\n return internalEffect.succeed(self);\n});\n/**\n * Creates a bounded queue with the specified capacity that uses backpressure strategy.\n *\n * **Details**\n *\n * When the queue reaches capacity, producers will be suspended until space becomes available.\n * This ensures all messages are processed but may slow down producers.\n *\n * **Example** (Creating bounded queues)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(5)\n *\n * // This will succeed as queue has capacity\n * yield* Queue.offer(queue, \"first\")\n * yield* Queue.offer(queue, \"second\")\n *\n * const size = yield* Queue.size(queue)\n * return size\n * })\n *\n * await Effect.runPromise(program) // => 2\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const bounded = capacity => make({\n capacity\n});\n/**\n * Creates a bounded queue with sliding strategy. When the queue reaches capacity,\n * new elements are added and the oldest elements are dropped.\n *\n * **When to use**\n *\n * Use when you need producer offers not to block and can accept dropping the\n * oldest messages, such as when maintaining a rolling window of recent values.\n *\n * **Example** (Creating sliding queues)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.sliding(3)\n *\n * // Fill the queue to capacity\n * yield* Queue.offer(queue, 1)\n * yield* Queue.offer(queue, 2)\n * yield* Queue.offer(queue, 3)\n *\n * // This will succeed, dropping the oldest element (1)\n * yield* Queue.offer(queue, 4)\n *\n * const all = yield* Queue.takeAll(queue)\n * return all\n * })\n *\n * await Effect.runPromise(program) // => [2, 3, 4]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const sliding = capacity => make({\n capacity,\n strategy: \"sliding\"\n});\n/**\n * Creates a bounded queue with dropping strategy. When the queue reaches capacity,\n * new elements are dropped and the offer operation returns false.\n *\n * **When to use**\n *\n * Use when you need producer offers not to block while preserving existing\n * queued messages, even if new messages may be dropped when the queue is full.\n *\n * **Example** (Creating dropping queues)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.dropping(2)\n *\n * // Fill the queue to capacity\n * const success1 = yield* Queue.offer(queue, 1)\n * const success2 = yield* Queue.offer(queue, 2)\n *\n * // This will be dropped\n * const success3 = yield* Queue.offer(queue, 3)\n *\n * const all = yield* Queue.takeAll(queue)\n * return [success1, success2, success3, all]\n * })\n *\n * await Effect.runPromise(program) // => [true, true, false, [1, 2]]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const dropping = capacity => make({\n capacity,\n strategy: \"dropping\"\n});\n/**\n * Creates an unbounded queue that can grow to any size without blocking producers.\n *\n * **When to use**\n *\n * Use when you need producers to add messages without backpressure and accept\n * unbounded memory growth.\n *\n * **Example** (Creating unbounded queues)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.unbounded()\n *\n * // Producers can always add messages without blocking\n * yield* Queue.offer(queue, \"message1\")\n * yield* Queue.offer(queue, \"message2\")\n * yield* Queue.offerAll(queue, [\"message3\", \"message4\", \"message5\"])\n *\n * // Check current size\n * const size = yield* Queue.size(queue)\n *\n * // Take all messages\n * const messages = yield* Queue.takeAll(queue)\n * return { size, messages }\n * })\n *\n * await Effect.runPromise(program) // => { size: 5, messages: [\"message1\", \"message2\", \"message3\", \"message4\", \"message5\"] }\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const unbounded = () => make();\n/**\n * Adds a message to the queue. Returns `false` if the queue is done.\n *\n * **Details**\n *\n * For bounded queues, this operation may suspend if the queue is at capacity,\n * depending on the backpressure strategy. For dropping/sliding queues, it may\n * return false or succeed immediately by dropping/sliding existing messages.\n *\n * **Example** (Offering a value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(3)\n *\n * // Successfully add messages to queue\n * const success1 = yield* Queue.offer(queue, 1)\n * const success2 = yield* Queue.offer(queue, 2)\n *\n * // Queue state\n * const size = yield* Queue.size(queue)\n * return { offered: [success1, success2], size }\n * })\n *\n * await Effect.runPromise(program) // => { offered: [true, true], size: 2 }\n * ```\n *\n * @category offering\n * @since 2.0.0\n */\nexport const offer = (self, message) => internalEffect.suspend(() => {\n if (self.state._tag !== \"Open\") {\n return exitFalse;\n } else if (self.messages.length >= self.capacity) {\n switch (self.strategy) {\n case \"dropping\":\n return exitFalse;\n case \"suspend\":\n if (self.capacity <= 0 && self.state.takers.size > 0) {\n MutableList.append(self.messages, message);\n releaseTakers(self);\n return exitTrue;\n }\n return offerRemainingSingle(self, message);\n case \"sliding\":\n MutableList.take(self.messages);\n MutableList.append(self.messages, message);\n return exitTrue;\n }\n }\n MutableList.append(self.messages, message);\n scheduleReleaseTaker(self);\n return exitTrue;\n});\n/**\n * Adds a message to the queue synchronously. Returns `false` if the queue is done.\n *\n * **When to use**\n *\n * Use when you are already in synchronous queue internals or a performance\n * boundary where wrapping the mutation in `Effect` is intentionally avoided.\n *\n * **Gotchas**\n *\n * This is an unsafe operation that directly modifies the queue without Effect wrapping.\n * Use this only when you're certain about the synchronous nature of the operation.\n *\n * **Example** (Offering a value synchronously)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue } from \"effect\"\n *\n * // Create a queue effect and extract the queue for unsafe operations\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(3)\n *\n * // Add messages synchronously using unsafe API\n * const success1 = Queue.offerUnsafe(queue, 1)\n * const success2 = Queue.offerUnsafe(queue, 2)\n *\n * // Check current size\n * const size = Queue.sizeUnsafe(queue)\n * return { offered: [success1, success2], size }\n * })\n *\n * await Effect.runPromise(program) // => { offered: [true, true], size: 2 }\n * ```\n *\n * @category offering\n * @since 4.0.0\n */\nexport const offerUnsafe = (self, message) => {\n if (self.state._tag !== \"Open\") {\n return false;\n } else if (self.messages.length >= self.capacity) {\n if (self.strategy === \"sliding\") {\n MutableList.take(self.messages);\n MutableList.append(self.messages, message);\n return true;\n } else if (self.capacity <= 0 && self.state.takers.size > 0) {\n MutableList.append(self.messages, message);\n releaseTakers(self);\n return true;\n }\n return false;\n }\n MutableList.append(self.messages, message);\n scheduleReleaseTaker(self);\n return true;\n};\n/**\n * Adds multiple messages to the queue. Returns the remaining messages that\n * were not added.\n *\n * **When to use**\n *\n * Use when producers can submit a batch at once and need to know which messages\n * did not fit under the queue's capacity strategy.\n *\n * **Details**\n *\n * For bounded queues, this operation may suspend if the queue doesn't have\n * enough capacity. The operation returns an array of messages that couldn't\n * be added (empty array means all messages were successfully added).\n *\n * **Example** (Offering multiple values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.dropping(3)\n *\n * // Try to add more messages than capacity without suspending\n * const remaining1 = yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])\n * return remaining1\n * })\n *\n * await Effect.runPromise(program) // => [4, 5]\n * ```\n *\n * @category offering\n * @since 2.0.0\n */\nexport const offerAll = (self, messages) => internalEffect.suspend(() => {\n if (self.state._tag !== \"Open\") {\n return internalEffect.succeed(Arr.fromIterable(messages));\n }\n const remaining = offerAllUnsafe(self, messages);\n if (remaining.length === 0) {\n return core.exitSucceed([]);\n } else if (self.strategy === \"dropping\") {\n return internalEffect.succeed(remaining);\n }\n return offerRemainingArray(self, remaining);\n});\n/**\n * Adds multiple messages to the queue synchronously. Returns the remaining messages that\n * were not added.\n *\n * **When to use**\n *\n * Use when queue internals or a performance boundary need a synchronous batch\n * offer and can handle any messages that do not fit.\n *\n * **Gotchas**\n *\n * This is an unsafe operation that directly modifies the queue without Effect wrapping.\n *\n * **Example** (Offering multiple values synchronously)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue } from \"effect\"\n *\n * // Create a bounded queue and use unsafe API\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(3)\n *\n * // Try to add 5 messages to capacity-3 queue using unsafe API\n * const remaining = Queue.offerAllUnsafe(queue, [1, 2, 3, 4, 5])\n *\n * // Check what's in the queue\n * const size = Queue.sizeUnsafe(queue)\n * return { remaining, size }\n * })\n *\n * await Effect.runPromise(program) // => { remaining: [4, 5], size: 3 }\n * ```\n *\n * @category offering\n * @since 4.0.0\n */\nexport const offerAllUnsafe = (self, messages) => {\n if (self.state._tag !== \"Open\") {\n return Arr.fromIterable(messages);\n } else if (self.capacity === Number.POSITIVE_INFINITY || self.strategy === \"sliding\") {\n MutableList.appendAll(self.messages, messages);\n if (self.strategy === \"sliding\") {\n MutableList.takeN(self.messages, self.messages.length - self.capacity);\n }\n scheduleReleaseTaker(self);\n return [];\n }\n const free = self.capacity <= 0 ? self.state.takers.size : self.capacity - self.messages.length;\n if (free === 0) {\n return Arr.fromIterable(messages);\n }\n const remaining = [];\n let i = 0;\n for (const message of messages) {\n if (i < free) {\n MutableList.append(self.messages, message);\n } else {\n remaining.push(message);\n }\n i++;\n }\n scheduleReleaseTaker(self);\n return remaining;\n};\n/**\n * Fails the queue with an error. If the queue is already done, `false` is\n * returned.\n *\n * **Example** (Failing queues with an error)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Fail the queue with an error\n * const failed = yield* Queue.fail(queue, \"Something went wrong\")\n *\n * // Taking from the failed queue fails with the error\n * const exit = yield* Effect.exit(Queue.take(queue))\n * return [failed, exit]\n * })\n *\n * await Effect.runPromise(program) // => [true, Exit.fail(\"Something went wrong\")]\n * ```\n *\n * @category completion\n * @since 4.0.0\n */\nexport const fail = (self, error) => failCause(self, core.causeFail(error));\n/**\n * Fails the queue with a cause. If the queue is already done, `false` is\n * returned.\n *\n * **Example** (Failing queues with a cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Create a cause and fail the queue\n * const cause = Cause.fail(\"Queue processing failed\")\n * const failed = yield* Queue.failCause(queue, cause)\n *\n * // The queue is now done with the specified failure cause\n * const exit = yield* Effect.exit(Queue.take(queue))\n * return [failed, exit]\n * })\n *\n * await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail(\"Queue processing failed\"))]\n * ```\n *\n * @category completion\n * @since 4.0.0\n */\nexport const failCause = /*#__PURE__*/dual(2, (self, cause) => internalEffect.sync(() => failCauseUnsafe(self, cause)));\n/**\n * Fails the queue with a cause synchronously. If the queue is already done, `false` is\n * returned.\n *\n * **When to use**\n *\n * Use when queue completion must be driven from synchronous internals while\n * preserving the full failure `Cause`.\n *\n * **Gotchas**\n *\n * This is an unsafe operation that directly modifies the queue without Effect wrapping.\n *\n * **Example** (Failing queues with a cause synchronously)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Create a cause and fail the queue synchronously\n * const cause = Cause.fail(\"Processing error\")\n * const failed = Queue.failCauseUnsafe(queue, cause)\n *\n * // The queue is now done with the specified failure cause\n * const exit = Queue.takeUnsafe(queue)\n * return [failed, exit]\n * })\n *\n * await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail(\"Processing error\"))]\n * ```\n *\n * @category completion\n * @since 4.0.0\n */\nexport const failCauseUnsafe = (self, cause) => {\n if (self.state._tag !== \"Open\") {\n return false;\n }\n const exit = core.exitFailCause(cause);\n const fail = internalEffect.exitZipRight(exit, exitFailDone);\n if (self.state.offers.size === 0 && self.messages.length === 0) {\n finalize(self, fail);\n return true;\n }\n self.state = {\n ...self.state,\n _tag: \"Closing\",\n exit: fail\n };\n return true;\n};\n/**\n * Signals queue completion.\n *\n * **When to use**\n *\n * Use to stop accepting new offers while allowing already queued messages to be\n * consumed.\n *\n * **Details**\n *\n * Returns `false` if the queue is already done.\n *\n * **Example** (Ending queues)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Add some messages\n * yield* Queue.offer(queue, 1)\n * yield* Queue.offer(queue, 2)\n *\n * // Signal completion - no more messages will be accepted\n * const ended = yield* Queue.end(queue)\n *\n * // Trying to offer more messages will return false\n * const offerResult = yield* Queue.offer(queue, 3)\n *\n * // But we can still take existing messages\n * const message = yield* Queue.take(queue)\n * return [ended, offerResult, message]\n * })\n *\n * await Effect.runPromise(program) // => [true, false, 1]\n * ```\n *\n * @category completion\n * @since 4.0.0\n */\nexport const end = self => failCause(self, core.causeFail(core.Done()));\n/**\n * Signals queue completion synchronously.\n *\n * **When to use**\n *\n * Use when implementing low-level queue integrations that must complete a queue\n * without wrapping the operation in `Effect`.\n *\n * **Details**\n *\n * Returns `false` if the queue is already done.\n *\n * **Gotchas**\n *\n * This is an unsafe operation that directly modifies the queue without Effect wrapping.\n *\n * **Example** (Ending queues synchronously)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * // Create a queue and use unsafe operations\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Add some messages\n * Queue.offerUnsafe(queue, 1)\n * Queue.offerUnsafe(queue, 2)\n *\n * // End the queue synchronously\n * const ended = Queue.endUnsafe(queue)\n *\n * // Existing messages can still be consumed while the queue is closing\n * const states = [queue.state._tag]\n *\n * Queue.takeUnsafe(queue)\n * Queue.takeUnsafe(queue)\n *\n * // After buffered messages are consumed, the queue is done\n * states.push(queue.state._tag)\n * return { ended, states }\n * })\n *\n * await Effect.runPromise(program) // => { ended: true, states: [\"Closing\", \"Done\"] }\n * ```\n *\n * @category completion\n * @since 4.0.0\n */\nexport const endUnsafe = self => failCauseUnsafe(self, core.causeFail(core.Done()));\n/**\n * Interrupts the queue gracefully, transitioning it to a closing state.\n *\n * **Details**\n *\n * This operation stops accepting new offers but allows existing messages to be consumed.\n * Once all messages are drained, the queue transitions to the Done state with an interrupt cause.\n *\n * **Example** (Interrupting queues gracefully)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Add some messages\n * yield* Queue.offer(queue, 1)\n * yield* Queue.offer(queue, 2)\n *\n * // Interrupt gracefully - no more offers accepted, but messages can be consumed\n * const interrupted = yield* Queue.interrupt(queue)\n *\n * // Trying to offer more messages will return false\n * const offerResult = yield* Queue.offer(queue, 3)\n *\n * // But we can still take existing messages\n * const message1 = yield* Queue.take(queue)\n *\n * const message2 = yield* Queue.take(queue)\n *\n * // After all messages are consumed, queue is done\n * const isDone = queue.state._tag === \"Done\"\n * return { interrupted, offerResult, messages: [message1, message2], isDone }\n * })\n *\n * await Effect.runPromise(program) // => { interrupted: true, offerResult: false, messages: [1, 2], isDone: true }\n * ```\n *\n * @category completion\n * @since 4.0.0\n */\nexport const interrupt = self => core.withFiber(fiber => failCause(self, internalEffect.causeInterrupt(fiber.id)));\n/**\n * Shuts down the queue immediately, discarding buffered messages and resuming\n * pending operations.\n *\n * **Details**\n *\n * The operation is idempotent and returns `true`, including when the queue has\n * already been shut down or completed.\n *\n * **Example** (Shutting down queues)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(2)\n *\n * // Add messages\n * yield* Queue.offer(queue, 1)\n * yield* Queue.offer(queue, 2)\n *\n * // Shutdown clears buffered messages and prevents further offers\n * const wasShutdown = yield* Queue.shutdown(queue)\n *\n * // Queue is now done and cleared\n * const size = yield* Queue.size(queue)\n * return { wasShutdown, size }\n * })\n *\n * await Effect.runPromise(program) // => { wasShutdown: true, size: 0 }\n * ```\n *\n * @category completion\n * @since 2.0.0\n */\nexport const shutdown = self => internalEffect.sync(() => {\n if (self.state._tag === \"Done\") {\n return true;\n }\n MutableList.clear(self.messages);\n const offers = self.state.offers;\n finalize(self, self.state._tag === \"Open\" ? exitInterrupt : self.state.exit);\n if (offers.size > 0) {\n for (const entry of offers) {\n if (entry._tag === \"Single\") {\n entry.resume(exitFalse);\n } else {\n entry.resume(core.exitSucceed(entry.remaining.slice(entry.offset)));\n }\n }\n offers.clear();\n }\n return true;\n});\n/**\n * Takes and returns all currently buffered messages without waiting for more.\n *\n * **Details**\n *\n * Returns an empty array when the queue is empty or has completed normally. If\n * the queue has failed, the effect fails with the queue's error.\n *\n * **Example** (Clearing queued values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Add several messages\n * yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])\n *\n * // Clear all messages from the queue\n * const messages = yield* Queue.clear(queue)\n *\n * // Queue is now empty\n * const size = yield* Queue.size(queue)\n *\n * // Clearing empty queue returns empty array\n * const empty = yield* Queue.clear(queue)\n * return { messages, size, empty }\n * })\n *\n * await Effect.runPromise(program) // => { messages: [1, 2, 3, 4, 5], size: 0, empty: [] }\n * ```\n *\n * @category taking\n * @since 4.0.0\n */\nexport const clear = self => internalEffect.suspend(() => {\n if (self.state._tag === \"Done\") {\n if (Pull.isDoneCause(self.state.exit.cause)) {\n return internalEffect.succeed([]);\n }\n return self.state.exit;\n }\n const messages = takeAllUnsafe(self);\n releaseCapacity(self);\n return internalEffect.succeed(messages);\n});\n/**\n * Takes all currently available messages, waiting until at least one message\n * is available when the queue is empty.\n *\n * **When to use**\n *\n * Use when consumers should process the next non-empty batch of buffered\n * messages instead of repeatedly taking one message at a time.\n *\n * **Details**\n *\n * Returns a non-empty array. If the queue completes or fails before a message\n * can be taken, the effect fails with the queue's terminal error.\n *\n * **Example** (Taking all available values)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(5)\n *\n * // Add several messages\n * yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])\n *\n * // Take all available messages\n * const messages1 = yield* Queue.takeAll(queue)\n * return messages1\n * })\n *\n * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]\n * ```\n *\n * @category taking\n * @since 2.0.0\n */\nexport const takeAll = self => takeBetween(self, 1, Number.POSITIVE_INFINITY);\n/**\n * Takes all messages from the queue, until the queue has errored or is done.\n *\n * **Example** (Collecting values until completion)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(5)\n *\n * // Add several messages\n * yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])\n * yield* Queue.end(queue)\n *\n * // Collect all available messages\n * return yield* Queue.collect(queue)\n * })\n *\n * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]\n * ```\n *\n * @category taking\n * @since 4.0.0\n */\nexport const collect = self => internalEffect.suspend(() => {\n const out = Arr.empty();\n return internalEffect.as(Pull.catchDone(internalEffect.whileLoop({\n while: constTrue,\n body: constant(takeAll(self)),\n step(items) {\n for (let i = 0; i < items.length; i++) {\n out.push(items[i]);\n }\n }\n }), () => internalEffect.void), out);\n});\n/**\n * Takes up to `n` messages from the queue.\n *\n * **Details**\n *\n * The operation may wait until enough messages are available to satisfy the\n * queue's batching rules. Finite fractional values of `n` are rounded down.\n * If `n` is `NaN` or non-positive, it succeeds with an empty array. If the\n * queue completes or fails before messages can be taken, the effect fails with\n * the queue's terminal error.\n *\n * **Example** (Taking a fixed number of values)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Add several messages\n * yield* Queue.offerAll(queue, [1, 2, 3, 4, 5, 6, 7])\n *\n * // Take exactly 3 messages\n * const first3 = yield* Queue.takeN(queue, 3)\n *\n * // Take exactly 2 more messages\n * const next2 = yield* Queue.takeN(queue, 2)\n *\n * // Take remaining messages\n * const remaining = yield* Queue.takeN(queue, 2)\n * return [first3, next2, remaining]\n * })\n *\n * await Effect.runPromise(program) // => [[1, 2, 3], [4, 5], [6, 7]]\n * ```\n *\n * @category taking\n * @since 2.0.0\n */\nexport const takeN = (self, n) => takeBetween(self, n, n);\n/**\n * Takes between `min` and `max` messages from the queue.\n *\n * **Details**\n *\n * The operation waits when fewer than the required minimum messages are\n * available. It returns at most `max` messages. Finite fractional bounds are\n * rounded down, while `NaN` and non-positive bounds are treated as `0`. If the\n * queue completes or fails before the minimum can be satisfied, the effect\n * fails with the queue's terminal error.\n *\n * **Example** (Taking a bounded batch of values)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Add several messages\n * yield* Queue.offerAll(queue, [1, 2, 3, 4, 5, 6, 7, 8])\n *\n * // Take between 2 and 5 messages\n * const batch1 = yield* Queue.takeBetween(queue, 2, 5)\n *\n * // Take between 1 and 10 messages (but only 3 remain)\n * const batch2 = yield* Queue.takeBetween(queue, 1, 10)\n *\n * // No more messages available, will wait or return done\n * // const batch3 = yield* Queue.takeBetween(queue, 1, 3)\n * return [batch1, batch2]\n * })\n *\n * await Effect.runPromise(program) // => [[1, 2, 3, 4, 5], [6, 7, 8]]\n * ```\n *\n * @category taking\n * @since 2.0.0\n */\nexport const takeBetween = (self, min, max) => {\n min = Count.normalize(min);\n max = Count.normalize(max);\n return internalEffect.suspend(() => takeBetweenUnsafe(self, min, max) ?? internalEffect.andThen(awaitTake(self), takeBetween(self, 1, max)));\n};\n/**\n * Takes a single message from the queue, or wait for a message to be\n * available.\n *\n * **Details**\n *\n * If the queue is done, it will fail with `Done`. If the\n * queue fails, the Effect will fail with the error.\n *\n * **Example** (Taking one value)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(3)\n *\n * // Add some messages\n * yield* Queue.offer(queue, \"first\")\n * yield* Queue.offer(queue, \"second\")\n *\n * // Take messages one by one\n * const msg1 = yield* Queue.take(queue)\n * const msg2 = yield* Queue.take(queue)\n *\n * // End the queue\n * yield* Queue.end(queue)\n *\n * // Taking from an ended queue fails with Done\n * const result = yield* Effect.exit(Queue.take(queue))\n * return [[msg1, msg2], result]\n * })\n *\n * await Effect.runPromise(program) // => [[\"first\", \"second\"], Exit.fail(Cause.Done())]\n * ```\n *\n * @category taking\n * @since 2.0.0\n */\nexport const take = self => internalEffect.suspend(() => takeUnsafe(self) ?? internalEffect.andThen(awaitTake(self), take(self)));\n/**\n * Attempts to take one item from the queue without waiting.\n *\n * **Details**\n *\n * Returns `Option.some` when an item is immediately available. Returns\n * `Option.none` when no item is available, when the queue is done, or when the\n * immediate take observes a queue failure.\n *\n * **Example** (Polling without blocking)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Poll returns Option.none if empty\n * const maybe1 = yield* Queue.poll(queue)\n *\n * // Add an item\n * yield* Queue.offer(queue, 42)\n *\n * // Poll returns Option.some with the item\n * const maybe2 = yield* Queue.poll(queue)\n * return [maybe1, maybe2]\n * })\n *\n * await Effect.runPromise(program) // => [Option.none(), Option.some(42)]\n * ```\n *\n * @category taking\n * @since 2.0.0\n */\nexport const poll = self => internalEffect.suspend(() => {\n const result = takeUnsafe(self);\n if (result === undefined) {\n return internalEffect.succeed(Option.none());\n }\n if (result._tag === \"Success\") {\n return internalEffect.succeed(Option.some(result.value));\n }\n return internalEffect.succeed(Option.none());\n});\n/**\n * Peeks at the next item without removing it.\n *\n * **Details**\n *\n * Blocks until an item is available. If the queue is done or fails, the error is propagated.\n *\n * **Example** (Peeking at the next value)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n * yield* Queue.offer(queue, 42)\n *\n * // Peek at the next item without removing it\n * const item = yield* Queue.peek(queue)\n * return item\n * })\n *\n * await Effect.runPromise(program) // => 42\n * ```\n *\n * @category taking\n * @since 4.0.0\n */\nexport const peek = self => internalEffect.suspend(() => {\n if (self.state._tag === \"Done\") {\n return self.state.exit;\n }\n if (self.messages.length > 0 && self.messages.head) {\n return internalEffect.succeed(self.messages.head.array[self.messages.head.offset]);\n }\n return internalEffect.andThen(awaitTake(self), peek(self));\n});\n/**\n * Attempts to take one message from the queue synchronously.\n *\n * **When to use**\n *\n * Use when polling queue internals must not suspend or register a waiting taker,\n * and `undefined` is an acceptable result for an empty queue.\n *\n * **Details**\n *\n * Returns an `Exit` for an immediately available message or for the queue's\n * terminal state. Returns `undefined` when no message is immediately available.\n * This operation does not wait or register a taker.\n *\n * **Example** (Taking one value synchronously)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Queue } from \"effect\"\n *\n * // Create a queue and use unsafe operations\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Add some messages\n * Queue.offerUnsafe(queue, 1)\n * Queue.offerUnsafe(queue, 2)\n *\n * // Take a message synchronously\n * const result1 = Queue.takeUnsafe(queue)\n *\n * const result2 = Queue.takeUnsafe(queue)\n *\n * // No more messages - returns undefined\n * const result3 = Queue.takeUnsafe(queue)\n * return [result1, result2, result3]\n * })\n *\n * await Effect.runPromise(program) // => [Exit.succeed(1), Exit.succeed(2), undefined]\n * ```\n *\n * @category taking\n * @since 4.0.0\n */\nexport const takeUnsafe = self => {\n if (self.state._tag === \"Done\") {\n return self.state.exit;\n }\n if (self.messages.length > 0) {\n const message = MutableList.take(self.messages);\n releaseCapacity(self);\n return core.exitSucceed(message);\n } else if (self.capacity <= 0 && self.state.offers.size > 0) {\n const message = takeOfferUnsafe(self.state.offers);\n releaseCapacity(self);\n return core.exitSucceed(message);\n }\n return undefined;\n};\n/**\n * Manually releases current queue takers synchronously.\n *\n * **When to use**\n *\n * Use when synchronous offers should release waiting consumers immediately\n * instead of waiting for the scheduled release task.\n *\n * **Details**\n *\n * This immediately runs the queue's taker-release pass instead of waiting for\n * its scheduled task. It does not complete the queue or resume fibers waiting\n * on `Queue.await`.\n *\n * **Example** (Releasing a waiting taker synchronously)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.unbounded()\n * const taker = yield* Queue.take(queue).pipe(Effect.forkChild)\n * yield* Effect.yieldNow\n *\n * Queue.offerUnsafe(queue, 1)\n * Queue.flushUnsafe(queue)\n *\n * return yield* Fiber.join(taker)\n * })\n *\n * await Effect.runPromise(program) // => 1\n * ```\n *\n * @category offering\n * @since 4.0.0\n */\nexport const flushUnsafe = self => releaseTakers(self);\n/**\n * Manually releases current queue takers.\n *\n * **When to use**\n *\n * Use when synchronous offers should release waiting consumers through an\n * `Effect` instead of waiting for the scheduled release task.\n *\n * **Details**\n *\n * This immediately runs the queue's taker-release pass instead of waiting for\n * its scheduled task. It does not complete the queue or resume fibers waiting\n * on `Queue.await`.\n *\n * **Example** (Releasing a waiting taker)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.unbounded()\n * const taker = yield* Queue.take(queue).pipe(Effect.forkChild)\n * yield* Effect.yieldNow\n *\n * Queue.offerUnsafe(queue, 1)\n * yield* Queue.flush(queue)\n *\n * return yield* Fiber.join(taker)\n * })\n *\n * await Effect.runPromise(program) // => 1\n * ```\n *\n * @category offering\n * @since 4.0.0\n */\nexport const flush = self => internalEffect.sync(() => flushUnsafe(self));\nconst await_ = self => internalEffect.callback(resume => {\n const awaiter = effect => resume(Pull.catchDone(effect, () => internalEffect.exitVoid));\n if (self.state._tag === \"Done\") {\n return awaiter(self.state.exit);\n }\n self.state.awaiters.add(awaiter);\n return internalEffect.sync(() => {\n if (self.state._tag !== \"Done\") {\n self.state.awaiters.delete(awaiter);\n }\n });\n});\nexport {\n/**\n * Waits until a queue reaches the `Done` state.\n *\n * **When to use**\n *\n * Use to suspend a fiber until no further values can be taken from the queue\n * and its terminal outcome is known.\n *\n * **Details**\n *\n * The effect succeeds with `void` for normal `Done` completion. Other\n * terminal causes are preserved, so failures and interruptions complete this\n * effect with the same terminal outcome.\n *\n * **Gotchas**\n *\n * A queue can be closing before it is done. `await` resumes at `Done`, not at\n * the first completion signal, so buffered messages may need to be drained\n * first.\n *\n * @see {@link end} for signaling normal completion while preserving buffered messages for consumers\n * @see {@link fail} for signaling an error while preserving buffered messages for consumers\n * @see {@link interrupt} for graceful interruption after buffered messages are drained\n * @see {@link shutdown} for immediately discarding buffered messages and resuming pending operations\n *\n * @category completion\n * @since 4.0.0\n */\nawait_ as await };\n/**\n * Returns the current number of buffered messages in the queue.\n *\n * **Details**\n *\n * After `end`, a queue remains `Closing` while buffered messages are drained,\n * and its size continues to include those messages. A `Done` queue reports a\n * size of `0`.\n *\n * **Example** (Checking queue size)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Check size of empty queue\n * const size1 = yield* Queue.size(queue)\n *\n * // Add some messages\n * yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])\n *\n * // Check size after adding messages\n * const size2 = yield* Queue.size(queue)\n *\n * // End the queue\n * yield* Queue.end(queue)\n *\n * // Ending retains the buffered size while the queue is Closing\n * const size3 = yield* Queue.size(queue)\n * return [size1, size2, size3]\n * })\n *\n * await Effect.runPromise(program) // => [0, 5, 5]\n * ```\n *\n * @category sizes\n * @since 2.0.0\n */\nexport const size = self => internalEffect.sync(() => sizeUnsafe(self));\n/**\n * Checks whether the queue is full.\n *\n * **Example** (Checking if queues are full)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(3)\n *\n * const before = yield* Queue.isFull(queue)\n *\n * // Add some messages\n * yield* Queue.offerAll(queue, [1, 2, 3])\n *\n * const after = yield* Queue.isFull(queue)\n * return [before, after]\n * })\n *\n * await Effect.runPromise(program) // => [false, true]\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isFull = self => internalEffect.sync(() => isFullUnsafe(self));\n/**\n * Returns the current number of buffered messages in the queue synchronously.\n *\n * **When to use**\n *\n * Use when you need an immediate `Queue` size snapshot for diagnostics or\n * internals and do not need the read wrapped in `Effect`.\n *\n * **Details**\n *\n * After `endUnsafe`, a queue remains `Closing` while buffered messages are\n * drained, and its size continues to include those messages. A `Done` queue\n * reports a size of `0`. This unsafe operation reads the queue state directly\n * without Effect wrapping.\n *\n * **Example** (Checking queue size synchronously)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Check size of empty queue\n * const size1 = Queue.sizeUnsafe(queue)\n *\n * // Add some messages\n * Queue.offerUnsafe(queue, 1)\n * Queue.offerUnsafe(queue, 2)\n * Queue.offerUnsafe(queue, 3)\n *\n * // Check size after adding messages\n * const size2 = Queue.sizeUnsafe(queue)\n *\n * // End the queue\n * Queue.endUnsafe(queue)\n *\n * // Ending retains the buffered size while the queue is Closing\n * const size3 = Queue.sizeUnsafe(queue)\n * return [size1, size2, size3]\n * })\n *\n * await Effect.runPromise(program) // => [0, 3, 3]\n * ```\n *\n * @category sizes\n * @since 4.0.0\n */\nexport const sizeUnsafe = self => self.state._tag === \"Done\" ? 0 : self.messages.length;\n/**\n * Checks whether the queue is full synchronously.\n *\n * **When to use**\n *\n * Use when an immediate `Queue` capacity snapshot is needed outside effectful\n * code and racing queue changes are acceptable.\n *\n * **Example** (Checking fullness synchronously)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(3)\n *\n * const before = Queue.isFullUnsafe(queue)\n *\n * // Add some messages\n * yield* Queue.offerAll(queue, [1, 2, 3])\n *\n * const after = Queue.isFullUnsafe(queue)\n * return [before, after]\n * })\n *\n * await Effect.runPromise(program) // => [false, true]\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isFullUnsafe = self => sizeUnsafe(self) === self.capacity;\n/**\n * Runs an `Effect` into a `Queue`, where success ends the queue and failure\n * fails the queue.\n *\n * **Example** (Running effects into queues)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(10)\n *\n * // Create an effect that succeeds\n * const dataProcessing = Effect.gen(function*() {\n * yield* Effect.yieldNow\n * return \"Processing completed successfully\"\n * })\n *\n * // Pipe the effect into the queue\n * // If dataProcessing succeeds, queue ends successfully\n * // If dataProcessing fails, queue fails with the error\n * const effectIntoQueue = Queue.into(queue)(dataProcessing)\n *\n * const wasCompleted = yield* effectIntoQueue\n * const exit = yield* Effect.exit(Queue.take(queue))\n * return [wasCompleted, exit]\n * })\n *\n * await Effect.runPromise(program) // => [true, Exit.fail(Cause.Done())]\n * ```\n *\n * @category completion\n * @since 4.0.0\n */\nexport const into = /*#__PURE__*/dual(2, (effect, self) => internalEffect.uninterruptibleMask(restore => internalEffect.matchCauseEffect(restore(effect), {\n onFailure: cause => failCause(self, cause),\n onSuccess: _ => end(self)\n})));\n// -----------------------------------------------------------------------------\n// internals\n// -----------------------------------------------------------------------------\n//\nconst exitFalse = /*#__PURE__*/core.exitSucceed(false);\nconst exitTrue = /*#__PURE__*/core.exitSucceed(true);\nconst exitFailDone = /*#__PURE__*/core.exitFail(/*#__PURE__*/core.Done());\nconst exitInterrupt = /*#__PURE__*/internalEffect.exitInterrupt();\nconst releaseTakers = self => {\n if (self.state._tag === \"Done\" || self.state.takers.size === 0) {\n return;\n }\n for (const taker of self.state.takers) {\n self.state.takers.delete(taker);\n taker(internalEffect.exitVoid);\n if (self.messages.length === 0) {\n break;\n }\n }\n};\nconst scheduleReleaseTaker = self => {\n if (self.scheduleRunning || self.state._tag === \"Done\" || self.state.takers.size === 0) {\n return;\n }\n self.scheduleRunning = true;\n self.dispatcher.scheduleTask(() => {\n self.scheduleRunning = false;\n releaseTakers(self);\n }, 0);\n};\nconst takeBetweenUnsafe = (self, min, max) => {\n if (self.state._tag === \"Done\") {\n return self.state.exit;\n } else if (max <= 0 || min <= 0) {\n return core.exitSucceed([]);\n } else if (self.capacity <= 0 && self.messages.length === 0 && self.state.offers.size > 0) {\n const messages = [takeOfferUnsafe(self.state.offers)];\n releaseCapacity(self);\n return core.exitSucceed(messages);\n }\n min = Math.min(min, self.capacity || 1);\n if (min <= self.messages.length) {\n const messages = MutableList.takeN(self.messages, max);\n releaseCapacity(self);\n return core.exitSucceed(messages);\n }\n};\nconst offerRemainingSingle = (self, message) => {\n return internalEffect.callback(resume => {\n if (self.state._tag !== \"Open\") {\n return resume(exitFalse);\n }\n const entry = {\n _tag: \"Single\",\n message,\n resume\n };\n self.state.offers.add(entry);\n return internalEffect.sync(() => {\n if (self.state._tag === \"Open\") {\n self.state.offers.delete(entry);\n }\n });\n });\n};\nconst offerRemainingArray = (self, remaining) => {\n return internalEffect.callback(resume => {\n if (self.state._tag !== \"Open\") {\n return resume(core.exitSucceed(remaining));\n }\n const entry = {\n _tag: \"Array\",\n remaining,\n offset: 0,\n resume\n };\n self.state.offers.add(entry);\n return internalEffect.sync(() => {\n if (self.state._tag === \"Open\") {\n self.state.offers.delete(entry);\n }\n });\n });\n};\n// Reserve a pending message for the consumer before the producer can reenter.\nconst takeOfferUnsafe = offers => {\n const entry = offers.values().next().value;\n if (entry._tag === \"Single\") {\n offers.delete(entry);\n entry.resume(exitTrue);\n return entry.message;\n }\n const message = entry.remaining[entry.offset++];\n if (entry.offset === entry.remaining.length) {\n offers.delete(entry);\n entry.resume(core.exitSucceed([]));\n }\n return message;\n};\nconst releaseCapacity = self => {\n if (self.state._tag === \"Done\") {\n return Pull.isDoneCause(self.state.exit.cause);\n } else if (self.state.offers.size === 0) {\n if (self.state._tag === \"Closing\" && self.messages.length === 0) {\n finalize(self, self.state.exit);\n return Pull.isDoneCause(self.state.exit.cause);\n }\n return false;\n }\n // Resuming a producer can synchronously take, offer, or shut down this queue.\n for (const entry of self.state.offers) {\n let n = self.capacity - self.messages.length;\n if (n <= 0) break;else if (entry._tag === \"Single\") {\n MutableList.append(self.messages, entry.message);\n self.state.offers.delete(entry);\n entry.resume(exitTrue);\n } else {\n for (; entry.offset < entry.remaining.length; entry.offset++) {\n if (n === 0) return false;\n MutableList.append(self.messages, entry.remaining[entry.offset]);\n n--;\n }\n self.state.offers.delete(entry);\n entry.resume(core.exitSucceed([]));\n }\n }\n return false;\n};\nconst awaitTake = self => internalEffect.callback(resume => {\n if (self.state._tag === \"Done\") {\n return resume(self.state.exit);\n }\n self.state.takers.add(resume);\n return internalEffect.sync(() => {\n if (self.state._tag !== \"Done\") {\n self.state.takers.delete(resume);\n }\n });\n});\nconst takeAllUnsafe = self => {\n if (self.messages.length > 0) {\n const messages = MutableList.takeAll(self.messages);\n releaseCapacity(self);\n return messages;\n } else if (self.state._tag !== \"Done\" && self.state.offers.size > 0) {\n const messages = [takeOfferUnsafe(self.state.offers)];\n releaseCapacity(self);\n return messages;\n }\n return [];\n};\nconst finalize = (self, exit) => {\n if (self.state._tag === \"Done\") {\n return;\n }\n const openState = self.state;\n self.state = {\n _tag: \"Done\",\n exit\n };\n for (const taker of openState.takers) {\n taker(exit);\n }\n openState.takers.clear();\n for (const awaiter of openState.awaiters) {\n awaiter(exit);\n }\n openState.awaiters.clear();\n};\n//# sourceMappingURL=Queue.js.map","import { dual } from \"./Function.js\";\nimport * as core from \"./internal/core.js\";\nimport * as internal from \"./internal/effect.js\";\n/**\n * Creates a `Semaphore` synchronously with the specified total\n * number of permits.\n *\n * **When to use**\n *\n * Use to construct a semaphore synchronously when an immediate value is\n * required outside an Effect workflow.\n *\n * **Example** (Creating an unsafe semaphore)\n *\n * ```ts import.meta.vitest\n * import { Effect, Semaphore } from \"effect\"\n *\n * const semaphore = Semaphore.makeUnsafe(3)\n *\n * const task = (id: number) =>\n * semaphore.withPermits(1)(\n * Effect.gen(function*() {\n * yield* Effect.yieldNow\n * return id\n * })\n * )\n *\n * // Only 3 tasks can run concurrently\n * const program = Effect.all([\n * task(1),\n * task(2),\n * task(3),\n * task(4),\n * task(5)\n * ], { concurrency: \"unbounded\" })\n *\n * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeUnsafe = permits => new SemaphoreImpl(permits);\nconst waitForPermits = (self, n, effect) => internal.callback(resume => {\n if (self.free >= n) return resume(effect);\n const observer = () => {\n if (self.free < n) return;\n self.waiters.delete(observer);\n resume(effect);\n };\n self.waiters.add(observer);\n return internal.sync(() => {\n self.waiters.delete(observer);\n });\n});\nclass SemaphoreImpl {\n waiters = /*#__PURE__*/new Set();\n taken = 0;\n permits;\n constructor(permits) {\n this.permits = permits;\n }\n get free() {\n return this.permits - this.taken;\n }\n take(n) {\n const take = internal.suspend(() => {\n if (this.free < n) {\n return waitForPermits(this, n, take);\n }\n this.taken += n;\n return internal.succeed(n);\n });\n return take;\n }\n takeIfAvailable(n) {\n return internal.suspend(() => {\n if (this.free < n) return internal.succeed(false);\n this.taken += n;\n return internal.succeed(true);\n });\n }\n releaseUnsafe(fiber, n) {\n this.taken -= n;\n if (this.waiters.size > 0) {\n fiber.currentDispatcher.scheduleTask(() => {\n for (const observer of this.waiters) {\n if (this.free <= 0) break;\n observer();\n }\n }, 0);\n }\n return this.free;\n }\n resize(permits) {\n return core.withFiber(fiber => {\n this.permits = permits;\n if (this.free < 0) return internal.void;\n this.releaseUnsafe(fiber, 0);\n return internal.void;\n });\n }\n release(n) {\n return core.withFiber(fiber => internal.succeed(this.releaseUnsafe(fiber, n)));\n }\n get releaseAll() {\n return core.withFiber(fiber => internal.succeed(this.releaseUnsafe(fiber, this.taken)));\n }\n withPermits(n) {\n return self => internal.uninterruptibleMask(restore => {\n const acquire = internal.suspend(() => {\n if (this.free < n) {\n const wait = waitForPermits(this, n, internal.void);\n return internal.flatMap(restore(wait), () => acquire);\n }\n this.taken += n;\n return internal.onExitPrimitive(restore(self), () => {\n this.releaseUnsafe(internal.getCurrentFiber(), n);\n return undefined;\n }, true);\n });\n return acquire;\n });\n }\n withPermit = /*#__PURE__*/this.withPermits(1);\n withPermitsIfAvailable(n) {\n return self => internal.uninterruptibleMask(restore => {\n if (this.free < n) return internal.succeedNone;\n this.taken += n;\n return internal.onExitPrimitive(restore(internal.asSome(self)), () => {\n this.releaseUnsafe(internal.getCurrentFiber(), n);\n return undefined;\n }, true);\n });\n }\n}\n/**\n * Creates a `Semaphore` initialized with the specified total number of permits.\n *\n * **When to use**\n *\n * Use to create a semaphore inside Effect code for bounding concurrency with\n * automatic or manual permit management.\n *\n * **Example** (Creating a semaphore)\n *\n * ```ts import.meta.vitest\n * import { Effect, Semaphore } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const semaphore = yield* Semaphore.make(2)\n *\n * const task = (id: number) =>\n * semaphore.withPermits(1)(\n * Effect.gen(function*() {\n * yield* Effect.yieldNow\n * return id\n * })\n * )\n *\n * // Run 4 tasks, but only 2 can run concurrently\n * return yield* Effect.all([task(1), task(2), task(3), task(4)])\n * })\n *\n * await Effect.runPromise(program) // => [1, 2, 3, 4]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = permits => internal.sync(() => new SemaphoreImpl(permits));\n/**\n * Sets the total number of permits managed by the semaphore.\n *\n * **When to use**\n *\n * Use to change the concurrency limit of an existing semaphore while keeping\n * current acquisitions in place.\n *\n * **Details**\n *\n * Existing acquisitions remain taken after resizing. If the new total is less\n * than the currently taken permit count, new acquisitions wait until enough\n * permits are released.\n *\n * @see {@link make} for creating a semaphore with an initial permit count\n * @see {@link release} for returning permits without changing semaphore capacity\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const resize = /*#__PURE__*/dual(2, (self, permits) => self.resize(permits));\n/**\n * Runs an effect with the given number of permits and releases the permits when\n * the effect completes.\n *\n * **When to use**\n *\n * Use to run an effect while holding a specified number of semaphore permits\n * for the duration of that effect.\n *\n * **Details**\n *\n * The effect waits until enough permits are available. Acquired permits are\n * released when the wrapped effect exits.\n *\n * @see {@link withPermit} for acquiring exactly one permit\n * @see {@link withPermitsIfAvailable} for running only when permits are immediately available\n * @see {@link take} for manually acquiring permits\n * @see {@link release} for manually returning permits\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const withPermits = (self, permits, effect) => {\n const withPermits = self.withPermits(permits);\n return effect ? withPermits(effect) : withPermits;\n};\n/**\n * Runs an effect with a single permit and releases the permit when the effect\n * completes.\n *\n * **When to use**\n *\n * Use to guard an effect with exactly one semaphore permit while automatically\n * releasing that permit when the effect exits.\n *\n * @see {@link withPermits} for acquiring more than one permit\n * @see {@link withPermitsIfAvailable} for running only when permits are immediately available\n * @see {@link take} for manually acquiring permits\n * @see {@link release} for manually returning permits\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const withPermit = (self, effect) => {\n if (!effect) return self.withPermit;\n return self.withPermit(effect);\n};\n/**\n * Runs an effect only if the specified number of permits are immediately\n * available.\n *\n * **When to use**\n *\n * Use when guarded work should run only if the requested permits are\n * immediately available.\n *\n * **Details**\n *\n * When the permits are unavailable, the effect is not run and the result is\n * `Option.none`. When permits are available, the effect is run, its result is\n * wrapped in `Option.some`, and the acquired permits are released when the\n * effect exits.\n *\n * @see {@link withPermits} for the variant that waits until permits are available\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const withPermitsIfAvailable = (self, permits, effect) => {\n const withPermits = self.withPermitsIfAvailable(permits);\n return effect ? withPermits(effect) : withPermits;\n};\n/**\n * Acquires the specified number of permits and returns the acquired permit\n * count.\n *\n * **When to use**\n *\n * Use when you need manual permit acquisition for a lower-level protocol with\n * explicit acquisition and release control.\n *\n * **Details**\n *\n * The effect waits until enough permits are available.\n *\n * @see {@link withPermit} for automatically acquiring and releasing one permit around an effect\n * @see {@link withPermits} for automatically acquiring and releasing multiple permits around an effect\n * @see {@link takeIfAvailable} for manually acquiring permits without waiting\n * @see {@link release} for returning manually acquired permits\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const take = /*#__PURE__*/dual(2, (self, permits) => self.take(permits));\n/**\n * Acquires the specified number of permits only if they are immediately\n * available.\n *\n * **When to use**\n *\n * Use when you need fail-fast manual permit acquisition for a lower-level\n * protocol with explicit acquisition and release control.\n *\n * **Details**\n *\n * If enough permits are available, they are acquired and the effect returns\n * `true`. Otherwise, the effect returns `false` immediately without acquiring\n * any permits.\n *\n * @see {@link take} for the variant that waits until permits are available\n * @see {@link release} for returning manually acquired permits\n * @see {@link withPermitsIfAvailable} for automatic acquisition and release around an effect\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const takeIfAvailable = /*#__PURE__*/dual(2, (self, permits) => self.takeIfAvailable(permits));\n/**\n * Releases the specified number of permits and returns the resulting available\n * permits.\n *\n * **When to use**\n *\n * Use when you need to return permits acquired with `take` in a lower-level\n * permit protocol with explicit release control.\n *\n * **Details**\n *\n * Running the effect releases the requested permits, wakes waiting acquirers\n * when permits become available, and returns the current available permit\n * count.\n *\n * **Gotchas**\n *\n * Manual `take` / `release` usage must keep permit counts balanced. Prefer\n * `withPermit` or `withPermits` when the acquisition can be scoped to one\n * effect.\n *\n * @see {@link take} for manually acquiring permits\n * @see {@link releaseAll} for returning every currently taken permit\n * @see {@link withPermits} for automatic acquire and release around an effect\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const release = /*#__PURE__*/dual(2, (self, permits) => self.release(permits));\n/**\n * Releases all permits held by this semaphore and returns the resulting\n * available permits.\n *\n * **When to use**\n *\n * Use to return every currently taken permit to a semaphore at once, typically\n * during cleanup of manual `take` / `release` protocols.\n *\n * @see {@link release} for releasing a known permit count\n * @see {@link withPermits} for automatic acquire and release around an effect\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const releaseAll = self => self.releaseAll;\n//# sourceMappingURL=Semaphore.js.map","/**\n * Provides low-level building blocks for streaming data through Effect.\n *\n * A `Channel` can read input elements, write output elements, fail with a typed\n * error, and finish with a typed result while managing resources safely.\n * Streams and sinks are built on channels, so most application code uses those\n * higher-level modules instead. This module is useful when implementing stream\n * operators or specialized streaming workflows.\n *\n * @since 2.0.0\n */\n// @effect-diagnostics returnEffectInGen:off\nimport * as Arr from \"./Array.js\";\nimport * as Cause from \"./Cause.js\";\nimport * as Chunk from \"./Chunk.js\";\nimport * as Context from \"./Context.js\";\nimport * as Effect from \"./Effect.js\";\nimport * as Exit from \"./Exit.js\";\nimport * as Fiber from \"./Fiber.js\";\nimport { constant, constTrue, constVoid, dual, identity as identity_ } from \"./Function.js\";\nimport * as Count from \"./internal/count.js\";\nimport { ClockRef, endSpan, scopeFinalizerCountUnsafe } from \"./internal/effect.js\";\nimport { addSpanStackTrace } from \"./internal/tracer.js\";\nimport * as Iterable from \"./Iterable.js\";\nimport * as Latch from \"./Latch.js\";\nimport * as Layer from \"./Layer.js\";\nimport * as MutableRef from \"./MutableRef.js\";\nimport * as Option from \"./Option.js\";\nimport { pipeArguments } from \"./Pipeable.js\";\nimport { hasProperty, isTagged } from \"./Predicate.js\";\nimport * as PubSub from \"./PubSub.js\";\nimport * as Pull from \"./Pull.js\";\nimport * as Queue from \"./Queue.js\";\nimport { TracerTimingEnabled } from \"./References.js\";\nimport * as Result from \"./Result.js\";\nimport * as Schedule from \"./Schedule.js\";\nimport * as Scope from \"./Scope.js\";\nimport * as Semaphore from \"./Semaphore.js\";\nimport * as String from \"./String.js\";\nimport * as Take from \"./Take.js\";\nimport { ParentSpan } from \"./Tracer.js\";\n/**\n * Runtime identifier stored on `Channel` values and used by `isChannel` to\n * recognize them.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = \"~effect/Channel\";\n/**\n * Checks whether a value is a `Channel`.\n *\n * **Example** (Checking for channels)\n *\n * ```ts import.meta.vitest\n * import { Channel } from \"effect\"\n *\n * const channel = Channel.succeed(42)\n * Channel.isChannel(channel) // => true\n * Channel.isChannel(\"not a channel\") // => false\n * ```\n *\n * @category guards\n * @since 3.5.4\n */\nexport const isChannel = u => hasProperty(u, TypeId);\nconst ChannelProto = {\n [TypeId]: {\n _Env: identity_,\n _InErr: identity_,\n _InElem: identity_,\n _OutErr: identity_,\n _OutElem: identity_\n },\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n// -----------------------------------------------------------------------------\n// Constructors\n// -----------------------------------------------------------------------------\n/**\n * Creates a `Channel` from a transformation function that operates on upstream pulls.\n *\n * **Example** (Creating channels from transforms)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const channel = Channel.fromTransform((upstream, scope) =>\n * Effect.succeed(upstream)\n * )\n * await Effect.runPromise(Channel.runCollect(channel)) // => []\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromTransform = transform => {\n const self = Object.create(ChannelProto);\n self.transform = (upstream, scope) => Effect.catchCause(transform(upstream, scope), cause => Effect.succeed(Effect.failCause(cause)));\n return self;\n};\n/**\n * Transforms a Channel by applying a function to its Pull implementation.\n *\n * **Example** (Transforming pull behavior)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * // Transform a channel by modifying its pull behavior\n * const originalChannel = Channel.fromIterable([1, 2, 3])\n *\n * const transformedChannel = Channel.transformPull(\n * originalChannel,\n * (pull, scope) =>\n * Effect.succeed(\n * Effect.map(pull, (value) => value * 2)\n * )\n * )\n * await Effect.runPromise(Channel.runCollect(transformedChannel)) // => [2, 4, 6]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const transformPull = (self, f) => fromTransform((upstream, scope) => Effect.flatMap(toTransform(self)(upstream, scope), pull => f(pull, scope)));\n/**\n * Creates a `Channel` from an `Effect` that produces a `Pull`.\n *\n * **Example** (Creating channels from pulls)\n *\n * ```ts import.meta.vitest\n * import { Cause, Channel, Effect } from \"effect\"\n *\n * const channel = Channel.fromPull(Effect.sync(() => {\n * let emitted = false\n * return Effect.suspend(() => {\n * if (emitted) return Cause.done()\n * emitted = true\n * return Effect.succeed(42)\n * })\n * }))\n * await Effect.runPromise(Channel.runCollect(channel)) // => [42]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromPull = effect => fromTransform((_, __) => effect);\n/**\n * Creates a `Channel` from a transformation function that operates on upstream\n * pulls, but also provides a forked scope that closes when the resulting\n * Channel completes.\n *\n * **When to use**\n *\n * Use when building channels that require scoped resource lifecycle management,\n * providing both the channel scope and a forked scope that automatically closes\n * when the channel completes.\n *\n * @see {@link fromTransform} for a simpler transformation without a forked scope\n * @category constructors\n * @since 4.0.0\n */\nexport const fromTransformBracket = f => fromTransform(Effect.fnUntraced(function* (upstream, scope) {\n const closableScope = Scope.forkUnsafe(scope);\n const onCause = cause => Scope.close(closableScope, Pull.doneExitFromCause(cause));\n const pull = yield* Effect.onError(f(upstream, scope, closableScope), onCause);\n return Effect.onError(pull, onCause);\n}));\n/**\n * Converts a `Channel` back to its underlying transformation function.\n *\n * **Example** (Extracting channel transforms)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const channel = Channel.succeed(42)\n * const transform = Channel.toTransform(channel)\n * typeof transform // => \"function\"\n * Effect.runSync(Channel.runCollect(channel)) // => [42]\n * ```\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toTransform = channel => channel.transform;\n/**\n * The default chunk size used by channels for batching operations.\n *\n * **Example** (Reading the default chunk size)\n *\n * ```ts import.meta.vitest\n * import { Channel } from \"effect\"\n *\n * Channel.DefaultChunkSize // => 4096\n * ```\n *\n * @category constants\n * @since 4.0.0\n */\nexport const DefaultChunkSize = 4096;\nconst asyncQueue = (scope, f, options) => Queue.make({\n capacity: options?.bufferSize,\n strategy: options?.strategy\n}).pipe(Effect.tap(queue => Scope.addFinalizer(scope, Queue.shutdown(queue))), Effect.tap(queue => Effect.forkIn(Scope.provide(f(queue), scope), scope)));\n/**\n * Creates a `Channel` that interacts with a callback function using a queue.\n *\n * **Example** (Creating channels from callbacks)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Queue } from \"effect\"\n *\n * const channel = Channel.callback((queue) =>\n * Effect.gen(function*() {\n * yield* Queue.offer(queue, 1)\n * yield* Queue.offer(queue, 2)\n * yield* Queue.offer(queue, 3)\n * yield* Queue.end(queue)\n * })\n * )\n * await Effect.runPromise(Channel.runCollect(channel)) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const callback = (f, options) => fromTransform((_, scope) => Effect.map(asyncQueue(scope, f, options), Queue.take));\n/**\n * Creates a `Channel` that interacts with a callback function using a queue, emitting arrays.\n *\n * **Example** (Creating array channels from callbacks)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Queue } from \"effect\"\n *\n * const channel = Channel.callbackArray(Effect.fn(function*(queue) {\n * yield* Queue.offer(queue, 1)\n * yield* Queue.offer(queue, 2)\n * yield* Queue.end(queue)\n * }))\n * await Effect.runPromise(Channel.runCollect(channel)) // => [[1, 2]]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const callbackArray = (f, options) => fromTransform((_, scope) => Effect.map(asyncQueue(scope, f, options), Queue.takeAll));\n/**\n * Creates a `Channel` that lazily evaluates to another channel.\n *\n * **Example** (Suspending channel creation)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const channel = Channel.suspend(() => Channel.succeed(42))\n * Effect.runSync(Channel.runCollect(channel)) // => [42]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const suspend = evaluate => fromTransform((upstream, scope) => Effect.suspend(() => toTransform(evaluate())(upstream, scope)));\n/**\n * Acquires a resource, uses it to build a `Channel`, and guarantees that\n * `release` runs with the channel's `Exit` when the channel completes, fails,\n * or is interrupted.\n *\n * **Details**\n *\n * Acquisition is uninterruptible. If acquisition fails, `use` is not run and\n * `release` is not registered.\n *\n * **Example** (Managing resources with acquire-use-release)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const released: Array = []\n * const channel = Channel.acquireUseRelease(\n * Effect.succeed(\"resource\"),\n * (resource) => Channel.succeed(resource.toUpperCase()),\n * (resource, exit) => Effect.sync(() => released.push(resource))\n * )\n * const observed = [await Effect.runPromise(Channel.runCollect(channel)), released] // => [[\"RESOURCE\"], [\"resource\"]]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const acquireUseRelease = (acquire, use, release) => fromTransformBracket(Effect.fnUntraced(function* (upstream, scope, forkedScope) {\n let option = Option.none();\n yield* Scope.addFinalizerExit(forkedScope, exit => Option.isSome(option) ? release(option.value, exit) : Effect.void);\n const value = yield* Effect.uninterruptible(acquire);\n option = Option.some(value);\n return yield* toTransform(use(value))(upstream, scope);\n}));\n/**\n * Acquires a resource, emits the acquired value as a single channel element,\n * and registers `release` in the channel scope.\n *\n * **Details**\n *\n * The release action runs when the channel scope closes and receives the scope\n * exit. If acquisition fails, no element is emitted and `release` is not\n * registered.\n *\n * **Example** (Managing resources with acquire-release)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const released: Array = []\n * const channel = Channel.acquireRelease(\n * Effect.succeed(\"resource\"),\n * (resource, exit) => Effect.sync(() => released.push(resource))\n * )\n * const observed = [await Effect.runPromise(Channel.runCollect(channel)), released] // => [[\"resource\"], [\"resource\"]]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const acquireRelease = /*#__PURE__*/dual(2, (self, release) => unwrap(Effect.map(Effect.acquireRelease(self, release), succeed)));\n/**\n * Creates a `Channel` from an iterator.\n *\n * **Example** (Creating channels from iterators)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const numbers = [1, 2, 3, 4, 5]\n * const channel = Channel.fromIterator(() => numbers[Symbol.iterator]())\n * Effect.runSync(Channel.runCollect(channel)) // => [1, 2, 3, 4, 5]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromIterator = iterator => fromPull(Effect.sync(() => {\n const iter = iterator();\n return Effect.suspend(() => {\n const state = iter.next();\n return state.done ? Cause.done(state.value) : Effect.succeed(state.value);\n });\n}));\n/**\n * Creates a `Channel` that emits all elements from an array.\n *\n * **Example** (Creating channels from arrays)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const channel = Channel.fromArray([1, 2, 3, 4, 5])\n * Effect.runSync(Channel.runCollect(channel)) // => [1, 2, 3, 4, 5]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromArray = array => fromPull(Effect.sync(() => {\n let index = 0;\n return Effect.suspend(() => index >= array.length ? Cause.done() : Effect.succeed(array[index++]));\n}));\n/**\n * Creates a `Channel` that emits all elements from a chunk.\n *\n * **Example** (Creating channels from chunks)\n *\n * ```ts import.meta.vitest\n * import { Channel, Chunk, Effect } from \"effect\"\n *\n * const chunk = Chunk.make(1, 2, 3)\n * const channel = Channel.fromChunk(chunk)\n * Effect.runSync(Channel.runCollect(channel)) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromChunk = chunk => fromArray(Chunk.toReadonlyArray(chunk));\n/**\n * Creates a `Channel` from an iterator that emits arrays of elements.\n *\n * **Details**\n *\n * Finite fractional `chunkSize` values are rounded down. `NaN` and non-positive\n * values are treated as `1` so every successful pull emits a non-empty array.\n *\n * **Example** (Batching iterator output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * // Create a channel from a simple iterator\n * const numberIterator = (): Iterator => {\n * let count = 0\n * return {\n * next: () => {\n * if (count < 3) {\n * return { value: count++, done: false }\n * }\n * return { value: \"finished\", done: true }\n * }\n * }\n * }\n *\n * const channel = Channel.fromIteratorArray(() => numberIterator(), 2)\n * Effect.runSync(Channel.runCollect(channel)) // => [[0, 1], [2]]\n * ```\n *\n * **Example** (Batching generator output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * // Create channel from a generator function\n * function* fibonacci(): Generator {\n * let a = 0, b = 1\n * for (let i = 0; i < 5; i++) {\n * yield a\n * ;[a, b] = [b, a + b]\n * }\n * }\n *\n * const fibChannel = Channel.fromIteratorArray(() => fibonacci(), 3)\n * Effect.runSync(Channel.runCollect(fibChannel)) // => [[0, 1, 1], [2, 3]]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromIteratorArray = (iterator, chunkSize = DefaultChunkSize) => {\n const size = Count.normalizeNonEmpty(chunkSize);\n return fromPull(Effect.sync(() => {\n const iter = iterator();\n let done = Option.none();\n return Effect.suspend(() => {\n if (done._tag === \"Some\") return Cause.done(done.value);\n const buffer = [];\n while (buffer.length < size) {\n const state = iter.next();\n if (state.done) {\n if (buffer.length === 0) {\n return Cause.done(state.value);\n }\n done = Option.some(state.value);\n break;\n }\n buffer.push(state.value);\n }\n return Effect.succeed(buffer);\n });\n }));\n};\n/**\n * Creates a `Channel` that emits all elements from an iterable.\n *\n * **Example** (Creating channels from iterables)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const set = new Set([1, 2, 3])\n * const channel = Channel.fromIterable(set)\n * Effect.runSync(Channel.runCollect(channel)) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromIterable = iterable => fromIterator(() => iterable[Symbol.iterator]());\n/**\n * Creates a `Channel` that emits arrays of elements from an iterable.\n *\n * **Details**\n *\n * Finite fractional `chunkSize` values are rounded down. `NaN` and non-positive\n * values are treated as `1`.\n *\n * **Example** (Batching iterable output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const numbers = [1, 2, 3, 4, 5]\n * const channel = Channel.fromIterableArray(numbers, 4)\n * Effect.runSync(Channel.runCollect(channel)) // => [[1, 2, 3, 4], [5]]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromIterableArray = (iterable, chunkSize = DefaultChunkSize) => fromIteratorArray(() => iterable[Symbol.iterator](), chunkSize);\n/**\n * Creates a `Channel` that emits a single value and then ends.\n *\n * **Example** (Creating channels that succeed)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const channel = Channel.succeed(42)\n * Effect.runSync(Channel.runCollect(channel)) // => [42]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const succeed = value => fromEffect(Effect.succeed(value));\n/**\n * Creates a `Channel` that immediately ends with the specified value.\n *\n * **Example** (Ending with a value)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const channel = Channel.end(\"done\")\n * Effect.runSync(Channel.runCollect(channel)) // => []\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const end = value => fromPull(Effect.succeed(Cause.done(value)));\n/**\n * Creates a `Channel` that immediately ends with the lazily evaluated value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const endSync = evaluate => fromPull(Effect.sync(() => Cause.done(evaluate())));\n/**\n * Creates a `Channel` that emits a single value computed by a lazy evaluation.\n *\n * **Example** (Computing values lazily)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * let requests = 0\n *\n * const channel = Channel.sync(() => {\n * requests += 1\n * return `request-${requests}`\n * })\n * Effect.runSync(Channel.runCollect(channel)) // => [\"request-1\"]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const sync = evaluate => fromEffect(Effect.sync(evaluate));\n/**\n * Represents a `Channel` that emits no elements.\n *\n * **Example** (Creating empty channels)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * // Create an empty channel\n * const emptyChannel = Channel.empty\n *\n * // Use empty channel in composition\n * const combined = Channel.concatWith(emptyChannel, () => Channel.succeed(42))\n * // Will immediately provide the second channel's output\n *\n * // Empty channel can be used as a no-op in conditional logic\n * const conditionalChannel = (shouldEmit: boolean) =>\n * shouldEmit ? Channel.succeed(\"data\") : Channel.empty\n *\n * Effect.runSync(Channel.runCollect(conditionalChannel(true))) // => [\"data\"]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const empty = /*#__PURE__*/fromPull(/*#__PURE__*/Effect.succeed(/*#__PURE__*/Cause.done()));\n/**\n * Represents a `Channel` that never completes.\n *\n * **Example** (Creating non-terminating channels)\n *\n * ```ts import.meta.vitest\n * import { Channel } from \"effect\"\n *\n * // Create a channel that never completes\n * const neverChannel = Channel.never\n *\n * // Use in conditional logic\n * const withFallback = Channel.concatWith(\n * neverChannel,\n * () => Channel.succeed(\"fallback\")\n * )\n *\n * // Never channel is useful for testing or as a placeholder\n * const conditionalChannel = (shouldComplete: boolean) =>\n * shouldComplete ? Channel.succeed(\"done\") : Channel.never\n *\n * Channel.isChannel(conditionalChannel(false)) // => true\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const never = /*#__PURE__*/fromPull(/*#__PURE__*/Effect.succeed(Effect.never));\n/**\n * Constructs a channel that fails immediately with the specified error.\n *\n * **Example** (Failing with an error)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Exit } from \"effect\"\n *\n * const failedChannel = Channel.fail(\"Something went wrong\")\n * Effect.runSync(Effect.exit(Channel.runCollect(failedChannel))) // => Exit.fail(\"Something went wrong\")\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fail = error => fromPull(Effect.succeed(Effect.fail(error)));\n/**\n * Constructs a channel that fails immediately with the specified lazily\n * evaluated error.\n *\n * **When to use**\n *\n * Use when the error value should be computed each time the channel runs instead\n * of when the channel is constructed.\n *\n * **Example** (Failing with a lazy error)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Exit } from \"effect\"\n *\n * let attempts = 0\n * const conditionalError = Channel.failSync(() => {\n * attempts += 1\n * return `Error after attempt ${attempts}`\n * })\n * const observed = [\n * Effect.runSync(Effect.exit(Channel.runCollect(conditionalError))),\n * attempts\n * ] // => [Exit.fail(\"Error after attempt 1\"), 1]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failSync = evaluate => fromPull(Effect.failSync(evaluate));\n/**\n * Constructs a channel that fails immediately with the specified `Cause`.\n *\n * **When to use**\n *\n * Use when the channel failure must preserve a full `Cause`, such as defects,\n * interruptions, or combined failures.\n *\n * **Example** (Failing with causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Channel, Effect, Exit } from \"effect\"\n *\n * const simpleCause = Cause.fail(\"Simple error\")\n * const failedChannel = Channel.failCause(simpleCause)\n * Effect.runSync(Effect.exit(Channel.runCollect(failedChannel))) // => Exit.failCause(simpleCause)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failCause = cause => fromPull(Effect.failCause(cause));\n/**\n * Constructs a channel that fails immediately with the specified lazily\n * evaluated `Cause`.\n *\n * **Example** (Failing with lazy causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Channel, Effect, Exit } from \"effect\"\n *\n * // Create a channel that fails with a lazily computed cause\n * let attempts = 0\n * const failedChannel = Channel.failCauseSync(() => {\n * attempts += 1\n * return Cause.fail(`Runtime error after attempt ${attempts}`)\n * })\n *\n * const observed = [\n * Effect.runSync(Effect.exit(Channel.runCollect(failedChannel))),\n * attempts\n * ] // => [Exit.fail(\"Runtime error after attempt 1\"), 1]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failCauseSync = evaluate => fromPull(Effect.failCauseSync(evaluate));\n/**\n * Constructs a channel that fails immediately with the specified defect.\n *\n * **Example** (Dying with defects)\n *\n * ```ts import.meta.vitest\n * import { Cause, Channel, Effect, Exit } from \"effect\"\n *\n * const defect = \"Unrecoverable error\"\n * const diedChannel = Channel.die(defect)\n * Effect.runSync(Effect.exit(Channel.runCollect(diedChannel))) // => Exit.failCause(Cause.die(defect))\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const die = defect => failCause(Cause.die(defect));\n/**\n * Uses an effect to write a single value to the channel.\n *\n * **Example** (Creating channels from effects)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const successChannel = Channel.fromEffect(\n * Effect.succeed(\"Hello from effect!\")\n * )\n * Effect.runSync(Channel.runCollect(successChannel)) // => [\"Hello from effect!\"]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromEffect = effect => fromPull(Effect.sync(() => {\n let done = false;\n return Effect.suspend(() => {\n if (done) return Cause.done();\n done = true;\n return effect;\n });\n}));\n/**\n * Creates a channel that evaluates an effect and uses its successful value as\n * the channel's done value without emitting any output elements.\n *\n * **Details**\n *\n * If the effect fails, the channel fails with the effect's error.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromEffectDone = effect => fromPull(Effect.succeed(Effect.flatMap(effect, Cause.done)));\n/**\n * Uses an effect and discards its result.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromEffectDrain = effect => fromPull(Effect.flatMap(effect, () => Cause.done()));\n/**\n * Creates a channel from an effect that produces a `Take`.\n *\n * **Details**\n *\n * A successful `Take` emits a non-empty array of output elements. A failed\n * `Take` fails the channel. A done `Take` completes the channel with its done\n * value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromEffectTake = effect => fromPull(Effect.succeed(Effect.flatMap(effect, Take.toPull)));\n/**\n * Creates a channel from a queue.\n *\n * **Example** (Creating channels from queues)\n *\n * ```ts import.meta.vitest\n * import { Cause, Channel, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(3)\n * yield* Queue.offerAll(queue, [\"item1\", \"item2\", \"item3\"])\n * yield* Queue.end(queue)\n * const channel = Channel.fromQueue(queue)\n * return yield* Channel.runCollect(channel)\n * })\n * await Effect.runPromise(program) // => [\"item1\", \"item2\", \"item3\"]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromQueue = queue => fromPull(Effect.succeed(Queue.take(queue)));\n/**\n * Creates a channel from a queue that emits arrays of elements.\n *\n * **Example** (Creating batched channels from queues)\n *\n * ```ts import.meta.vitest\n * import { Cause, Channel, Effect, Queue } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(4)\n * yield* Queue.offerAll(queue, [1, 2, 3, 4])\n * yield* Queue.end(queue)\n * const arrayChannel = Channel.fromQueueArray(queue)\n * return yield* Channel.runCollect(arrayChannel)\n * })\n * await Effect.runPromise(program) // => [[1, 2, 3, 4]]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromQueueArray = queue => fromPull(Effect.succeed(Queue.takeAll(queue)));\n/**\n * Creates a channel that forwards upstream input elements, input errors, and\n * the upstream done value unchanged.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const identity = () => fromTransform((upstream, _scope) => Effect.succeed(upstream));\n/**\n * Creates a channel from a PubSub subscription.\n *\n * **Example** (Creating channels from subscriptions)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect, Option, PubSub } from \"effect\"\n *\n * class SubscriptionError extends Data.TaggedError(\"SubscriptionError\")<{\n * readonly reason: string\n * }> {}\n *\n * const program = Effect.gen(function*() {\n * // Create a PubSub\n * const pubsub = yield* PubSub.bounded(32)\n *\n * // Create a subscription\n * const subscription = yield* PubSub.subscribe(pubsub)\n *\n * // Publish some messages\n * yield* PubSub.publish(pubsub, \"Hello\")\n * yield* PubSub.publish(pubsub, \"World\")\n * yield* PubSub.publish(pubsub, \"from\")\n * yield* PubSub.publish(pubsub, \"PubSub\")\n *\n * // Create a channel from the subscription\n * const channel = Channel.fromSubscription(subscription)\n *\n * // The channel will receive all published messages\n * return channel\n * })\n * const result = Effect.scoped(Effect.flatMap(program, Channel.runHead))\n * await Effect.runPromise(result) // => Option.some(\"Hello\")\n *\n * // Real-time notifications example\n * const notificationChannel = Effect.gen(function*() {\n * const eventBus = yield* PubSub.unbounded<{ type: string; payload: any }>()\n * const userSubscription = yield* PubSub.subscribe(eventBus)\n *\n * return Channel.fromSubscription(userSubscription)\n * })\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromSubscription = subscription => fromPull(Effect.succeed(Effect.onInterrupt(PubSub.take(subscription), () => Cause.done())));\n/**\n * Creates a channel from a PubSub subscription that outputs arrays of values.\n *\n * **Details**\n *\n * This constructor creates a channel that reads from a PubSub subscription and outputs\n * arrays of values in chunks. It's useful when you want to process multiple values at once\n * for better performance.\n *\n * **Example** (Batching subscription values)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect, Option, PubSub } from \"effect\"\n *\n * class StreamError extends Data.TaggedError(\"StreamError\")<{\n * readonly message: string\n * }> {}\n *\n * const program = Effect.gen(function*() {\n * const pubsub = yield* PubSub.bounded(16)\n * const subscription = yield* PubSub.subscribe(pubsub)\n *\n * // Create a channel that reads arrays of values\n * const channel = Channel.fromSubscriptionArray(subscription)\n *\n * // Publish some values\n * yield* PubSub.publish(pubsub, 1)\n * yield* PubSub.publish(pubsub, 2)\n * yield* PubSub.publish(pubsub, 3)\n * yield* PubSub.publish(pubsub, 4)\n *\n * // The channel will output arrays like [1, 2, 3] and [4]\n * return channel\n * })\n * const result = Effect.scoped(Effect.flatMap(program, Channel.runHead))\n * await Effect.runPromise(result) // => Option.some([1, 2, 3, 4])\n * ```\n *\n * **Example** (Processing subscription values in batches)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect, Option, PubSub } from \"effect\"\n *\n * class BatchProcessingError extends Data.TaggedError(\"BatchProcessingError\")<{\n * readonly reason: string\n * }> {}\n *\n * const batchProcessor = Effect.gen(function*() {\n * const pubsub = yield* PubSub.bounded(32)\n * const subscription = yield* PubSub.subscribe(pubsub)\n *\n * // Create a channel that processes items in batches\n * const batchChannel = Channel.fromSubscriptionArray(subscription)\n *\n * // Transform to process each batch\n * const processedChannel = Channel.map(batchChannel, (batch) =>\n * batch.map((item) => item.toUpperCase())\n * )\n *\n * yield* PubSub.publishAll(pubsub, [\"one\", \"two\"])\n * return processedChannel\n * })\n * const batch = Effect.scoped(Effect.flatMap(batchProcessor, Channel.runHead))\n * await Effect.runPromise(batch) // => Option.some([\"ONE\", \"TWO\"])\n * ```\n *\n * **Example** (Aggregating subscription metrics)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Option, PubSub } from \"effect\"\n *\n * const metricsAggregator = Effect.gen(function*() {\n * const metricsPubSub = yield* PubSub.bounded<\n * { timestamp: number; value: number }\n * >(100)\n * const subscription = yield* PubSub.subscribe(metricsPubSub)\n *\n * // Create a channel that collects metrics in chunks\n * const metricsChannel = Channel.fromSubscriptionArray(subscription)\n *\n * // Transform to calculate aggregate statistics\n * const aggregatedChannel = Channel.map(metricsChannel, (metrics) => {\n * const values = metrics.map((m) => m.value)\n * const sum = values.reduce((a, b) => a + b, 0)\n * const avg = sum / values.length\n * const min = Math.min(...values)\n * const max = Math.max(...values)\n *\n * return {\n * count: values.length,\n * sum,\n * average: avg,\n * min,\n * max,\n * firstTimestamp: Math.min(...metrics.map((m) => m.timestamp)),\n * lastTimestamp: Math.max(...metrics.map((m) => m.timestamp))\n * }\n * })\n *\n * yield* PubSub.publish(metricsPubSub, { timestamp: 1, value: 10 })\n * return aggregatedChannel\n * })\n * const metric = Effect.scoped(Effect.flatMap(metricsAggregator, Channel.runHead))\n * const result = await Effect.runPromise(metric)\n * Option.map(result, ({ count, sum, average, min, max }) => ({ count, sum, average, min, max })) // => Option.some({ count: 1, sum: 10, average: 10, min: 10, max: 10 })\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromSubscriptionArray = subscription => fromPull(Effect.succeed(Effect.onInterrupt(PubSub.takeAll(subscription), () => Cause.done())));\n/**\n * Creates a channel from a PubSub that outputs individual values.\n *\n * **Details**\n *\n * This constructor creates a channel that reads from a PubSub by automatically\n * subscribing to it. The channel outputs individual values as they are published\n * to the PubSub, making it ideal for real-time streaming scenarios.\n *\n * **Example** (Creating channels from PubSubs)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect, Option, PubSub } from \"effect\"\n *\n * class StreamError extends Data.TaggedError(\"StreamError\")<{\n * readonly message: string\n * }> {}\n *\n * const program = Effect.gen(function*() {\n * const pubsub = yield* PubSub.unbounded({ replay: 3 })\n *\n * // Create a channel that reads individual values\n * const channel = Channel.fromPubSub(pubsub)\n *\n * // Publish some values\n * yield* PubSub.publish(pubsub, 1)\n * yield* PubSub.publish(pubsub, 2)\n * yield* PubSub.publish(pubsub, 3)\n *\n * // The channel will output: 1, 2, 3 (individual values)\n * return channel\n * })\n * const result = Effect.scoped(Effect.flatMap(program, Channel.runHead))\n * await Effect.runPromise(result) // => Option.some(1)\n * ```\n *\n * **Example** (Streaming PubSub notifications)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Option, PubSub } from \"effect\"\n *\n * const notificationService = Effect.gen(function*() {\n * const notificationPubSub = yield* PubSub.unbounded({ replay: 1 })\n *\n * // Create a channel for real-time notifications\n * const notificationChannel = Channel.fromPubSub(notificationPubSub)\n *\n * // Transform notifications to add timestamps\n * const receivedAt = \"2024-01-01T00:00:00.000Z\"\n * const timestampedChannel = Channel.map(notificationChannel, (message) => ({\n * message,\n * receivedAt,\n * id: `notification:${message}`\n * }))\n *\n * yield* PubSub.publish(notificationPubSub, \"ready\")\n * return timestampedChannel\n * })\n * const notification = Effect.scoped(Effect.flatMap(notificationService, Channel.runHead))\n * await Effect.runPromise(notification) // => Option.some({ message: \"ready\", receivedAt: \"2024-01-01T00:00:00.000Z\", id: \"notification:ready\" })\n * ```\n *\n * **Example** (Processing PubSub events)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Option, PubSub } from \"effect\"\n *\n * interface DomainEvent {\n * readonly type: string\n * readonly payload: unknown\n * readonly timestamp: number\n * }\n *\n * const eventProcessor = Effect.gen(function*() {\n * const eventPubSub = yield* PubSub.unbounded({ replay: 1 })\n *\n * // Create a channel for processing domain events\n * const eventChannel = Channel.fromPubSub(eventPubSub)\n *\n * // Filter and transform events\n * const processedChannel = Channel.map(eventChannel, (event) => {\n * if (event.type === \"user.created\") {\n * return {\n * ...event,\n * processed: true,\n * processedAt: event.timestamp + 1\n * }\n * }\n * return event\n * })\n *\n * yield* PubSub.publish(eventPubSub, { type: \"user.created\", payload: {}, timestamp: 1 })\n * return processedChannel\n * })\n * const event = Effect.scoped(Effect.flatMap(eventProcessor, Channel.runHead))\n * const result = await Effect.runPromise(event) // => Option.some({ type: \"user.created\", payload: {}, timestamp: 1, processed: true, processedAt: 2 })\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromPubSub = pubsub => unwrap(Effect.map(PubSub.subscribe(pubsub), fromSubscription));\n/**\n * Creates a channel from a PubSub that outputs arrays of values.\n *\n * **Details**\n *\n * This constructor creates a channel that reads from a PubSub by automatically\n * subscribing to it and collecting values into arrays. The channel outputs\n * arrays of values in chunks, making it ideal for batch processing scenarios.\n *\n * **Example** (Batching PubSub values)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect, Option, PubSub } from \"effect\"\n *\n * class BatchError extends Data.TaggedError(\"BatchError\")<{\n * readonly message: string\n * }> {}\n *\n * const program = Effect.gen(function*() {\n * const pubsub = yield* PubSub.unbounded({ replay: 4 })\n *\n * // Create a channel that reads arrays of values\n * const channel = Channel.fromPubSubArray(pubsub)\n *\n * // Publish some values\n * yield* PubSub.publish(pubsub, 1)\n * yield* PubSub.publish(pubsub, 2)\n * yield* PubSub.publish(pubsub, 3)\n * yield* PubSub.publish(pubsub, 4)\n *\n * // The channel will output arrays like [1, 2, 3] and [4]\n * return channel\n * })\n * const result = Effect.scoped(Effect.flatMap(program, Channel.runHead))\n * await Effect.runPromise(result) // => Option.some([1, 2, 3, 4])\n * ```\n *\n * **Example** (Processing PubSub orders in batches)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Option, PubSub } from \"effect\"\n *\n * interface Order {\n * readonly id: string\n * readonly customerId: string\n * readonly items: ReadonlyArray\n * readonly total: number\n * readonly submittedAt: number\n * }\n *\n * const orderBatchProcessor = Effect.gen(function*() {\n * const orderPubSub = yield* PubSub.unbounded({ replay: 1 })\n *\n * // Create a channel that processes orders in batches\n * const orderChannel = Channel.fromPubSubArray(orderPubSub)\n *\n * // Transform to process each batch of orders\n * const processedChannel = Channel.map(orderChannel, (orderBatch) => {\n * const totalRevenue = orderBatch.reduce((sum, order) => sum + order.total, 0)\n * const customerCount = new Set(orderBatch.map((order) =>\n * order.customerId\n * )).size\n *\n * return {\n * batchSize: orderBatch.length,\n * totalRevenue,\n * uniqueCustomers: customerCount,\n * firstSubmittedAt: Math.min(...orderBatch.map((order) => order.submittedAt)),\n * orders: orderBatch\n * }\n * })\n *\n * yield* PubSub.publish(orderPubSub, {\n * id: \"1\", customerId: \"a\", items: [\"book\"], total: 10, submittedAt: 1\n * })\n * return processedChannel\n * })\n * const order = Effect.scoped(Effect.flatMap(orderBatchProcessor, Channel.runHead))\n * const result = await Effect.runPromise(order)\n * Option.map(result, (batch) => [batch.batchSize, batch.totalRevenue, batch.uniqueCustomers]) // => Option.some([1, 10, 1])\n * ```\n *\n * **Example** (Processing PubSub logs in batches)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Option, PubSub } from \"effect\"\n *\n * interface LogEntry {\n * readonly timestamp: number\n * readonly level: \"info\" | \"warn\" | \"error\"\n * readonly message: string\n * readonly source: string\n * }\n *\n * const logAggregator = Effect.gen(function*() {\n * const logPubSub = yield* PubSub.unbounded({ replay: 1 })\n *\n * // Create a channel that collects logs in batches\n * const logChannel = Channel.fromPubSubArray(logPubSub)\n *\n * // Transform to analyze log batches\n * const analysisChannel = Channel.map(logChannel, (logBatch) => {\n * const errorCount = logBatch.filter((log) => log.level === \"error\").length\n * const warnCount = logBatch.filter((log) => log.level === \"warn\").length\n * const infoCount = logBatch.filter((log) => log.level === \"info\").length\n *\n * const timeRange = {\n * start: Math.min(...logBatch.map((log) => log.timestamp)),\n * end: Math.max(...logBatch.map((log) => log.timestamp))\n * }\n *\n * return {\n * batchId: `${timeRange.start}-${timeRange.end}`,\n * totalEntries: logBatch.length,\n * errorCount,\n * warnCount,\n * infoCount,\n * timeRange,\n * sources: [...new Set(logBatch.map((log) => log.source))]\n * }\n * })\n *\n * yield* PubSub.publish(logPubSub, {\n * timestamp: 1,\n * level: \"info\",\n * message: \"ready\",\n * source: \"app\"\n * } satisfies LogEntry)\n * return analysisChannel\n * })\n * const log = Effect.scoped(Effect.flatMap(logAggregator, Channel.runHead))\n * const result = await Effect.runPromise(log)\n * Option.map(result, (batch) => [batch.batchId, batch.totalEntries, batch.infoCount]) // => Option.some([\"1-1\", 1, 1])\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromPubSubArray = pubsub => unwrap(Effect.map(PubSub.subscribe(pubsub), fromSubscriptionArray));\n/**\n * Subscribes to a `PubSub` of `Take` values and exposes them as a channel.\n *\n * **Details**\n *\n * Output `Take` values are emitted as non-empty arrays. Failed `Take` values\n * fail the channel. Done `Take` values complete the channel.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromPubSubTake = pubsub => unwrap(Effect.map(PubSub.subscribe(pubsub), sub => fromEffectTake(PubSub.take(sub))));\n/**\n * Creates a Channel from a Schedule.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromSchedule = schedule => fromPull(Effect.map(Schedule.toStepWithSleep(schedule), step => step(void 0)));\n/**\n * Creates a channel from a lazily supplied Web `ReadableStream`.\n *\n * **Example** (Reading from a Web stream)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const channel = Channel.fromReadableStream({\n * evaluate: () => new ReadableStream({\n * start(controller) {\n * controller.enqueue(1)\n * controller.close()\n * }\n * }),\n * onError: (cause) => new Error(String(cause))\n * })\n *\n * await Effect.runPromise(Channel.runCollect(channel)) // => [[1]]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromReadableStream = options => fromTransform((_, scope) => readableStreamToPullUnsafe({\n scope,\n readable: options.evaluate(),\n onError: options.onError,\n releaseLockOnEnd: options.releaseLockOnEnd\n}));\n/** @internal */\nexport const pullIntoWritableStream = options => Effect.acquireUseRelease(Effect.sync(() => options.writable.getWriter()), writer => {\n const loop = options.pull.pipe(Effect.flatMap(chunk => Effect.forEach(chunk, value => Effect.tryPromise({\n try: () => writer.ready.then(() => writer.write(value)),\n catch: options.onError\n }), {\n discard: true\n })), Effect.forever({\n disableYield: true\n }));\n const withClose = options.closeOnDone !== false ? Pull.catchDone(loop, done => Effect.andThen(Effect.tryPromise({\n try: () => writer.close(),\n catch: options.onError\n }), Cause.done(done))) : loop;\n return Effect.onError(withClose, cause => Pull.isDoneCause(cause) ? Effect.void : Effect.promise(() => writer.abort(cause).catch(constVoid)));\n}, writer => Effect.sync(() => writer.releaseLock()));\n/**\n * Creates a channel that writes upstream values to a lazily supplied Web\n * `WritableStream`.\n *\n * **Example** (Writing channel input)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const written: Array = []\n * const sink = Channel.fromWritableStream({\n * evaluate: () => new WritableStream({\n * write(value) {\n * written.push(value)\n * }\n * }),\n * onError: (cause) => new Error(String(cause))\n * })\n *\n * const program = Channel.fromArray([[1, 2] as [number, number]]).pipe(\n * Channel.pipeTo(sink),\n * Channel.runDrain\n * )\n *\n * await Effect.runPromise(program)\n * written // => [1, 2]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromWritableStream = options => fromTransform(pull => {\n const writable = options.evaluate();\n return Effect.succeed(pullIntoWritableStream({\n ...options,\n writable,\n pull\n }));\n});\n/**\n * Creates a channel backed by a Web `TransformStream`, writing upstream values\n * while emitting transformed values from its readable side.\n *\n * **Example** (Transforming channel input)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const transform = Channel.fromTransformStream({\n * evaluate: () => new TransformStream({\n * transform(value, controller) {\n * controller.enqueue(value * 2)\n * }\n * }),\n * onError: (cause) => new Error(String(cause))\n * })\n *\n * const program = Channel.fromArray([[1, 2] as [number, number]]).pipe(\n * Channel.pipeTo(transform),\n * Channel.runCollect\n * )\n *\n * await Effect.runPromise(program) // => [[2], [4]]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromTransformStream = options => fromTransform((upstream, scope) => {\n const transform = options.evaluate();\n const exit = MutableRef.make(undefined);\n return pullIntoWritableStream({\n pull: upstream,\n writable: transform.writable,\n onError: options.onError,\n closeOnDone: options.closeOnDone\n }).pipe(Effect.catchCause(cause => {\n if (!Pull.isDoneCause(cause)) {\n exit.current = Exit.failCause(cause);\n }\n return Effect.void;\n }), Effect.forkIn(scope), Effect.flatMap(() => readableStreamToPullUnsafe({\n scope,\n exit,\n readable: transform.readable,\n onError: options.onError,\n releaseLockOnEnd: options.releaseLockOnEnd\n })));\n});\nconst readableStreamToPullUnsafe = options => {\n const reader = options.readable.getReader();\n const exit = options.exit ?? MutableRef.make(undefined);\n const pull = Effect.suspend(() => {\n if (exit.current) return exit.current;\n return Effect.matchCauseEffect(Effect.tryPromise({\n try: () => reader.read(),\n catch: options.onError\n }), {\n onFailure: cause => exit.current ?? Effect.failCause(cause),\n onSuccess: ({\n done,\n value\n }) => {\n if (exit.current) return exit.current;\n return done ? Cause.done() : Effect.succeed(Arr.of(value));\n }\n });\n });\n return Effect.as(Scope.addFinalizer(options.scope, options.releaseLockOnEnd ? Effect.sync(() => reader.releaseLock()) : Effect.promise(() => reader.cancel().catch(constVoid))), pull);\n};\n/**\n * Creates a channel that pulls values from an `AsyncIterable`.\n *\n * **Details**\n *\n * Each yielded value is emitted as an output element. The iterator's return\n * value becomes the channel's done value. Thrown or rejected iterator errors\n * are converted with `onError`. If the channel scope closes early and the\n * iterator has a `return` method, that method is called.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromAsyncIterable = (iterable, onError) => fromTransform(Effect.fnUntraced(function* (_, scope) {\n const iter = iterable[Symbol.asyncIterator]();\n if (iter.return) {\n yield* Scope.addFinalizer(scope, Effect.promise(() => iter.return()));\n }\n return Effect.flatMap(Effect.tryPromise({\n try: () => iter.next(),\n catch: onError\n }), result => result.done ? Cause.done(result.value) : Effect.succeed(result.value));\n}));\n/**\n * Creates a channel from an `AsyncIterable`, emitting each yielded value as a\n * single-element non-empty array.\n *\n * **Details**\n *\n * The iterator's return value becomes the channel's done value. Thrown or\n * rejected iterator errors are converted with `onError`. If the channel scope\n * closes early and the iterator has a `return` method, that method is called.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromAsyncIterableArray = (iterable, onError) => map(fromAsyncIterable(iterable, onError), Arr.of);\n/**\n * Maps the output of this channel using the specified function.\n *\n * **Example** (Mapping channel output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class TransformError extends Data.TaggedError(\"TransformError\")<{\n * readonly reason: string\n * }> {}\n *\n * // Basic mapping of channel values\n * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])\n * const doubledChannel = Channel.map(numbersChannel, (n) => n * 2)\n * Effect.runSync(Channel.runCollect(doubledChannel)) // => [2, 4, 6, 8, 10]\n *\n * // Transform string data\n * const wordsChannel = Channel.fromIterable([\"hello\", \"world\", \"effect\"])\n * const upperCaseChannel = Channel.map(wordsChannel, (word) => word.toUpperCase())\n * Effect.runSync(Channel.runCollect(upperCaseChannel)) // => [\"HELLO\", \"WORLD\", \"EFFECT\"]\n *\n * // Complex object transformation\n * type User = { id: number; name: string }\n * type UserDisplay = { displayName: string; isActive: boolean }\n *\n * const usersChannel = Channel.fromIterable([\n * { id: 1, name: \"Alice\" },\n * { id: 2, name: \"Bob\" }\n * ])\n * const displayChannel = Channel.map(usersChannel, (user): UserDisplay => ({\n * displayName: `User: ${user.name}`,\n * isActive: true\n * }))\n * Effect.runSync(Channel.runCollect(displayChannel)) // => [{ displayName: \"User: Alice\", isActive: true }, { displayName: \"User: Bob\", isActive: true }]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, f) => transformPull(self, pull => Effect.sync(() => {\n let i = 0;\n return Effect.map(pull, o => f(o, i++));\n})));\n/**\n * Maps the done value of this channel using the specified function.\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const mapDone = /*#__PURE__*/dual(2, (self, f) => mapDoneEffect(self, o => Effect.succeed(f(o))));\n/**\n * Maps the done value of this channel using the specified effectful function.\n *\n * **When to use**\n *\n * Use when the terminal done value transformation needs services or can fail,\n * while emitted elements should pass through unchanged.\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const mapDoneEffect = /*#__PURE__*/dual(2, (self, f) => transformPull(self, pull => Effect.succeed(Pull.catchDone(pull, done => Effect.flatMap(f(done), Cause.done)))));\nconst concurrencyIsSequential = concurrency => concurrency === undefined || concurrency !== \"unbounded\" && concurrency <= 1;\n/**\n * Maps each output element with an effectful function, preserving the source\n * channel's done value.\n *\n * **When to use**\n *\n * Use when transforming each channel output needs an Effect, service\n * dependency, failure channel, or configured concurrency.\n *\n * **Details**\n *\n * The mapping function receives the output element and its zero-based index.\n * By default elements are mapped sequentially. Use `options.concurrency` to\n * map multiple elements concurrently, and `options.unordered` to allow\n * concurrently mapped outputs to be emitted as soon as they complete.\n *\n * **Example** (Mapping channel output with effects)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])\n * const processedChannel = Channel.mapEffect(\n * numbersChannel,\n * (n) => Effect.succeed(n * n)\n * )\n * await Effect.runPromise(Channel.runCollect(processedChannel)) // => [1, 4, 9, 16, 25]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const mapEffect = /*#__PURE__*/dual(args => isChannel(args[0]), (self, f, options) => concurrencyIsSequential(options?.concurrency) ? mapEffectSequential(self, f) : mapEffectConcurrent(self, f, options));\nconst mapEffectSequential = (self, f) => fromTransform((upstream, scope) => {\n let i = 0;\n return Effect.map(toTransform(self)(upstream, scope), Effect.flatMap(o => f(o, i++)));\n});\nconst mapEffectConcurrent = (self, f, options) => fromTransformBracket(Effect.fnUntraced(function* (upstream, scope, forkedScope) {\n let i = 0;\n const pull = yield* toTransform(self)(upstream, scope);\n const concurrencyN = options.concurrency === \"unbounded\" ? Number.MAX_SAFE_INTEGER : options.concurrency;\n const queue = yield* Queue.bounded(0);\n yield* Scope.addFinalizer(forkedScope, Queue.shutdown(queue));\n const runFork = Effect.runForkWith(yield* Effect.context());\n const trackFiber = Fiber.runIn(forkedScope);\n if (options.unordered) {\n const semaphore = Semaphore.makeUnsafe(concurrencyN);\n const release = constant(semaphore.release(1));\n const handle = Effect.matchCauseEffect({\n onFailure: cause => Effect.flatMap(Queue.failCause(queue, cause), release),\n onSuccess: value => Effect.flatMap(Queue.offer(queue, value), release)\n });\n yield* semaphore.take(1).pipe(Effect.flatMap(() => pull), Effect.flatMap(value => {\n trackFiber(runFork(handle(f(value, i++))));\n return Effect.void;\n }), Effect.forever({\n disableYield: true\n }), Effect.catchCause(cause => semaphore.withPermits(concurrencyN - 1)(Queue.failCause(queue, cause))), Effect.forkIn(forkedScope));\n } else {\n // capacity is n - 2 because\n // - 1 for the offer *after* starting a fiber\n // - 1 for the current processing fiber\n const effects = yield* Queue.bounded(concurrencyN - 2);\n yield* Scope.addFinalizer(forkedScope, Queue.shutdown(effects));\n yield* Queue.take(effects).pipe(Effect.flatten, Effect.flatMap(value => Queue.offer(queue, value)), Effect.forever({\n disableYield: true\n }), Effect.catchCause(cause => Queue.failCause(queue, cause)), Effect.forkIn(forkedScope));\n let errorCause;\n const onExit = exit => {\n if (exit._tag === \"Success\") return;\n errorCause = exit.cause;\n Queue.failCauseUnsafe(queue, exit.cause);\n };\n yield* pull.pipe(Effect.flatMap(value => {\n if (errorCause) return Effect.failCause(errorCause);\n const fiber = runFork(f(value, i++));\n trackFiber(fiber);\n fiber.addObserver(onExit);\n return Queue.offer(effects, Fiber.join(fiber));\n }), Effect.forever({\n disableYield: true\n }), Effect.catchCause(cause => Queue.offer(effects, Exit.failCause(cause)).pipe(Effect.andThen(Queue.failCause(effects, cause)))), Effect.forkIn(forkedScope));\n }\n return Queue.take(queue);\n}));\n/**\n * Returns a new channel which is the same as this one but applies the given\n * function to the input channel’s input elements.\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const mapInput = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => toTransform(self)(Effect.flatMap(upstream, el => f(el)), scope)));\n/**\n * Returns a new channel which is the same as this one but applies the given\n * function to the input errors.\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const mapInputError = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => toTransform(self)(Effect.catch(upstream, err => {\n if (Cause.isDone(err)) return Effect.fail(err);\n return Effect.flatMap(f(err), Effect.fail);\n}), scope)));\n/**\n * Applies a side effect function to each output element of the channel,\n * returning a new channel that emits the same elements.\n *\n * **Details**\n *\n * The `tap` function allows you to perform side effects (like logging or\n * debugging) on each element emitted by a channel without modifying the\n * elements themselves.\n *\n * **Example** (Tapping channel output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class LogError extends Data.TaggedError(\"LogError\")<{\n * readonly message: string\n * }> {}\n *\n * // Create a channel that outputs numbers\n * const numberChannel = Channel.fromIterable([1, 2, 3])\n *\n * // Tap into each output element to perform side effects\n * const processed: Array = []\n * const tappedChannel = Channel.tap(\n * numberChannel,\n * (n) => Effect.sync(() => processed.push(n))\n * )\n *\n * const observed = [await Effect.runPromise(Channel.runCollect(tappedChannel)), processed] // => [[1, 2, 3], [1, 2, 3]]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const tap = /*#__PURE__*/dual(args => isChannel(args[0]), (self, f, options) => mapEffect(self, a => Effect.as(f(a), a), options));\n/**\n * Maps each output element to a channel and flattens the child channel\n * outputs.\n *\n * **Details**\n *\n * The source channel's done value is preserved. Child channel done values are\n * used only for child-channel completion. By default child channels are run\n * sequentially. Use `options.concurrency` and `options.bufferSize` to run child\n * channels concurrently.\n *\n * **Example** (Flat mapping channel output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class ProcessError extends Data.TaggedError(\"ProcessError\")<{\n * readonly cause: string\n * }> {}\n *\n * // Create a channel that outputs numbers\n * const numberChannel = Channel.fromIterable([1, 2, 3])\n *\n * // FlatMap each number to create new channels\n * const flatMappedChannel = Channel.flatMap(\n * numberChannel,\n * (n) =>\n * Channel.fromIterable(Array.from({ length: n }, (_, i) => `item-${n}-${i}`))\n * )\n *\n * Effect.runSync(Channel.runCollect(flatMappedChannel)) // => [\"item-1-0\", \"item-2-0\", \"item-2-1\", \"item-3-0\", \"item-3-1\", \"item-3-2\"]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const flatMap = /*#__PURE__*/dual(args => isChannel(args[0]), (self, f, options) => concurrencyIsSequential(options?.concurrency) ? flatMapSequential(self, f) : flatMapConcurrent(self, f, options));\nconst flatMapSequential = (self, f) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => {\n let childPull;\n let childScope;\n const makePull = Effect.flatMap(pull, value => {\n childScope ??= Scope.forkUnsafe(scope);\n return Effect.flatMapEager(toTransform(f(value))(upstream, childScope), pull => {\n childPull = catchHalt(pull);\n return childPull;\n });\n });\n const catchHalt = Pull.catchDone(_ => {\n childPull = undefined;\n // we can reuse the scope if the only finalizer is the \"fork\" one\n if (childScope.state._tag === \"Open\" && scopeFinalizerCountUnsafe(childScope) === 1) {\n return makePull;\n }\n const close = Scope.close(childScope, Exit.void);\n childScope = undefined;\n return Effect.flatMap(close, () => makePull);\n });\n return Effect.suspend(() => childPull ?? makePull);\n}));\nconst flatMapConcurrent = (self, f, options) => self.pipe(map(f), mergeAll(options));\n/**\n * Concatenates this channel with another channel created from the terminal value\n * of this channel. The new channel is created using the provided function.\n *\n * **Example** (Concatenating with completion values)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class ConcatError extends Data.TaggedError(\"ConcatError\")<{\n * readonly reason: string\n * }> {}\n *\n * // Create a channel that outputs numbers and terminates with sum\n * const numberChannel = Channel.fromIterable([1, 2, 3]).pipe(\n * Channel.concatWith((sum: void) => Channel.succeed(`Completed processing`))\n * )\n *\n * Effect.runSync(Channel.runCollect(numberChannel)) // => [1, 2, 3, \"Completed processing\"]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const concatWith = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => Effect.sync(() => {\n let currentPull;\n const forkedScope = Scope.forkUnsafe(scope);\n const makePull = Effect.flatMap(toTransform(self)(upstream, forkedScope), pull => {\n currentPull = Pull.catchDone(pull, leftover => {\n return Scope.close(forkedScope, Exit.void).pipe(Effect.flatMap(() => toTransform(f(leftover))(upstream, scope)), Effect.flatMap(pull => {\n currentPull = pull;\n return pull;\n }));\n });\n return currentPull;\n });\n return Effect.suspend(() => currentPull ?? makePull);\n})));\n/**\n * Concatenates this channel with another channel, so that the second channel\n * starts emitting values after the first channel has completed.\n *\n * **Example** (Concatenating channels)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class ConcatError extends Data.TaggedError(\"ConcatError\")<{\n * readonly reason: string\n * }> {}\n *\n * // Create two channels\n * const firstChannel = Channel.fromIterable([1, 2, 3])\n * const secondChannel = Channel.fromIterable([\"a\", \"b\", \"c\"])\n *\n * // Concatenate them\n * const concatenatedChannel = Channel.concat(firstChannel, secondChannel)\n *\n * Effect.runSync(Channel.runCollect(concatenatedChannel)) // => [1, 2, 3, \"a\", \"b\", \"c\"]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const concat = /*#__PURE__*/dual(2, (self, that) => concatWith(self, _ => that));\n/**\n * Combines two channels with a stateful pull function.\n *\n * **When to use**\n *\n * Use to coordinate pulling from two channels when each output element depends\n * on both sides and local state.\n *\n * **Details**\n *\n * The combining function receives the current state and pull functions for the\n * left and right channels. It returns the next output element together with the\n * next state.\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const combine = /*#__PURE__*/dual(4, (self, that, s, f) => fromTransform(Effect.fnUntraced(function* (upstream, scope) {\n const leftPull = yield* toTransform(self)(upstream, scope);\n const rightPull = yield* toTransform(that)(upstream, scope);\n let state = s();\n return Effect.suspend(() => {\n const combinedPull = f(state, leftPull, rightPull);\n return Effect.map(combinedPull, ([a, s1]) => {\n state = s1;\n return a;\n });\n });\n})));\n/**\n * Runs a fallback channel if this channel completes without emitting any\n * output elements.\n *\n * **Details**\n *\n * If the source emits at least one element, the source is used unchanged. If\n * the source completes before emitting an element, the fallback function\n * receives the source done value and returns the replacement channel.\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const orElseIfEmpty = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => Effect.sync(() => {\n let currentPull;\n const forkedScope = Scope.forkUnsafe(scope);\n const makePull = Effect.flatMap(toTransform(self)(upstream, forkedScope), pull => {\n const next = pull.pipe(Effect.tap(() => {\n currentPull = pull;\n return Effect.void;\n }), Pull.catchDone(leftover => Scope.close(forkedScope, Exit.succeed(leftover)).pipe(Effect.andThen(toTransform(f(leftover))(upstream, scope)), Effect.flatMap(pull => {\n currentPull = pull;\n return pull;\n }))));\n currentPull = next;\n return next;\n });\n return Effect.suspend(() => currentPull ?? makePull);\n})));\n/**\n * Flattens a channel of channels.\n *\n * **Example** (Flattening nested channels)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class FlattenError extends Data.TaggedError(\"FlattenError\")<{\n * readonly cause: string\n * }> {}\n *\n * // Create a channel that outputs channels\n * const nestedChannels = Channel.fromIterable([\n * Channel.fromIterable([1, 2]),\n * Channel.fromIterable([3, 4]),\n * Channel.fromIterable([5, 6])\n * ])\n *\n * // Flatten the nested channels\n * const flattenedChannel = Channel.flatten(nestedChannels)\n *\n * Effect.runSync(Channel.runCollect(flattenedChannel)) // => [1, 2, 3, 4, 5, 6]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const flatten = channels => flatMap(channels, identity_);\n/**\n * Flattens a channel that outputs arrays into a channel that outputs individual elements.\n *\n * **Example** (Flattening arrays of channel output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class FlattenError extends Data.TaggedError(\"FlattenError\")<{\n * readonly message: string\n * }> {}\n *\n * // Create a channel that outputs arrays\n * const arrayChannel = Channel.fromIterable([\n * [1, 2, 3],\n * [4, 5],\n * [6, 7, 8, 9]\n * ])\n *\n * // Flatten the arrays into individual elements\n * const flattenedChannel = Channel.flattenArray(arrayChannel)\n *\n * Effect.runSync(Channel.runCollect(flattenedChannel)) // => [1, 2, 3, 4, 5, 6, 7, 8, 9]\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const flattenArray = self => transformPull(self, pull => {\n let array;\n let index = 0;\n const pump = Effect.suspend(function loop() {\n if (array === undefined) {\n return Effect.flatMap(pull, array_ => {\n switch (array_.length) {\n case 0:\n return loop();\n case 1:\n return Effect.succeed(array_[0]);\n default:\n {\n array = array_;\n return Effect.succeed(array_[index++]);\n }\n }\n });\n }\n const next = array[index++];\n if (index >= array.length) {\n array = undefined;\n index = 0;\n }\n return Effect.succeed(next);\n });\n return Effect.succeed(pump);\n});\n/**\n * Flattens a channel that emits `Take` values into a channel that emits the\n * `Take` outputs directly.\n *\n * **Details**\n *\n * Output `Take` values are emitted as non-empty arrays. Failed `Take` values\n * fail the returned channel. Done `Take` values complete the returned channel.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const flattenTake = self => mapEffectSequential(self, Take.toPull);\n/**\n * Creates a new channel that consumes all output from the source channel\n * but emits nothing, preserving only the completion value.\n *\n * **Example** (Draining channel output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * // Create a channel that outputs values\n * const sourceChannel = Channel.fromIterable([1, 2, 3, 4, 5])\n *\n * // Drain all output, keeping only the completion\n * const drainedChannel = Channel.drain(sourceChannel)\n *\n * Effect.runSync(Channel.runCollect(drainedChannel)) // => []\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const drain = self => transformPull(self, pull => Effect.succeed(Effect.forever(pull, {\n disableYield: true\n})));\n/**\n * Repeats this channel according to the provided schedule.\n *\n * @category repetition\n * @since 4.0.0\n */\nexport const repeat = /*#__PURE__*/dual(2, (self, schedule) => Schedule.toStepWithMetadata(typeof schedule === \"function\" ? schedule(identity_) : schedule).pipe(Effect.map(step => {\n let meta = Schedule.CurrentMetadata.defaultValue();\n const loop = concatWith(provideServiceEffect(self, Schedule.CurrentMetadata, Effect.sync(() => meta)), done => step(done).pipe(Effect.map(meta_ => {\n meta = meta_;\n return loop;\n }), Pull.catchDone(() => Effect.succeed(end(done))), unwrap));\n return loop;\n}), unwrap));\n/**\n * Repeats this channel forever.\n *\n * @category repetition\n * @since 4.0.0\n */\nexport const forever = self => concatWith(self, () => forever(self));\n/**\n * Runs a schedule step for each output element while preserving the emitted\n * elements.\n *\n * **Details**\n *\n * The schedule receives each output element as input. Schedule delays are\n * applied between emitted elements. If the schedule fails, the returned channel\n * fails. If the schedule finishes, the returned channel completes with the\n * schedule output.\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const schedule = /*#__PURE__*/dual(2, (self, schedule) => transformPull(self, (pull, _scope) => Effect.map(Schedule.toStepWithSleep(schedule), step => {\n const pullWithStep = Effect.tap(pull, step);\n return pullWithStep;\n})));\n/**\n * Filters the output elements of a channel using a predicate function.\n * Elements that don't match the predicate are discarded.\n *\n * **Example** (Filtering channel output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * // Create a channel with mixed numbers\n * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5, 6, 7, 8])\n *\n * // Filter to keep only even numbers\n * const evenChannel = Channel.filter(numbersChannel, (n) => n % 2 === 0)\n * Effect.runSync(Channel.runCollect(evenChannel)) // => [2, 4, 6, 8]\n *\n * // Filter with type refinement\n * const mixedChannel = Channel.fromIterable([1, \"hello\", 2, \"world\", 3])\n * const numbersOnlyChannel = Channel.filter(\n * mixedChannel,\n * (value): value is number => typeof value === \"number\"\n * )\n * Effect.runSync(Channel.runCollect(numbersOnlyChannel)) // => [1, 2, 3]\n * ```\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filter = /*#__PURE__*/dual(2, (self, predicate) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => Effect.flatMap(pull, function loop(elem) {\n return predicate(elem) ? Effect.succeed(elem) : Effect.flatMap(pull, loop);\n}))));\n/**\n * Filters and maps output elements using a `Filter`.\n *\n * **When to use**\n *\n * Use to keep only channel output elements accepted by a `Filter` and emit\n * each filter success value.\n *\n * **Details**\n *\n * Successful filter results are emitted as mapped values. Failed filter\n * results are discarded. The source channel's errors and done value are\n * preserved.\n *\n * @see {@link filter} for keeping original output elements with a predicate\n * @see {@link filterMapEffect} for using an effectful `Filter`\n * @see {@link filterMapArray} for filtering arrays of output elements\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterMap = /*#__PURE__*/dual(2, (self, filter) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => Effect.flatMap(pull, function loop(elem) {\n const result = filter(elem);\n return Result.isFailure(result) ? Effect.flatMap(pull, loop) : Effect.succeed(result.success);\n}))));\n/**\n * Filters output elements with an effectful predicate.\n *\n * **When to use**\n *\n * Use when the keep/discard decision depends on an Effect or service and\n * predicate failures should fail the returned channel.\n *\n * **Details**\n *\n * Elements for which the predicate succeeds with `true` are emitted. Elements\n * for which the predicate succeeds with `false` are discarded. Predicate\n * failures fail the returned channel.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterEffect = /*#__PURE__*/dual(2, (self, predicate) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => Effect.flatMap(pull, function loop(elem) {\n return Effect.flatMap(predicate(elem), passes => passes ? Effect.succeed(elem) : Effect.flatMap(pull, loop));\n}))));\n/**\n * Filters and maps output elements using an effectful `Filter`.\n *\n * **When to use**\n *\n * Use to apply effectful logic that can discard channel output elements and\n * emit transformed values for the elements that pass.\n *\n * **Details**\n *\n * Successful filter results are emitted as mapped values. Failed filter\n * results are discarded. Failures from the effectful filter fail the returned\n * channel.\n *\n * @see {@link filterMap} for using a synchronous `Filter`\n * @see {@link filterEffect} for effectfully keeping original output elements\n * @see {@link mapEffect} for effectfully transforming every output element\n * @see {@link filterMapArrayEffect} for effectful filtering of array outputs\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterMapEffect = /*#__PURE__*/dual(2, (self, filter) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => Effect.flatMap(pull, function loop(elem) {\n return Effect.flatMap(filter(elem), result => Result.isFailure(result) ? Effect.flatMap(pull, loop) : Effect.succeed(result.success));\n}))));\n/**\n * Filters arrays of elements emitted by a channel, applying the filter\n * to each element within the arrays and only emitting non-empty filtered arrays.\n *\n * **Example** (Filtering array output)\n *\n * ```ts import.meta.vitest\n * import { Array, Channel, Effect } from \"effect\"\n *\n * const nonEmptyArrayPredicate = Array.isReadonlyArrayNonEmpty\n *\n * // Create a channel that outputs arrays of mixed data\n * const arrayChannel = Channel.fromIterable([\n * Array.make(1, 2, 3, 4, 5),\n * Array.make(6, 7, 8, 9, 10),\n * Array.make(11, 12, 13, 14, 15)\n * ]).pipe(Channel.filter(nonEmptyArrayPredicate))\n *\n * // Filter arrays to keep only even numbers\n * const evenArraysChannel = Channel.filterArray(arrayChannel, (n) => n % 2 === 0)\n * Effect.runSync(Channel.runCollect(evenArraysChannel)) // => [[2, 4], [6, 8, 10], [12, 14]]\n * // Note: Only non-empty filtered arrays are emitted\n *\n * // Arrays that would become empty after filtering are discarded entirely\n * const oddChannel = Channel.fromIterable([\n * Array.make(1, 3, 5),\n * Array.make(2, 4),\n * Array.make(7, 9)\n * ]).pipe(Channel.filter(nonEmptyArrayPredicate))\n * const filteredOddChannel = Channel.filterArray(oddChannel, (n) => n % 2 === 0)\n * Effect.runSync(Channel.runCollect(filteredOddChannel)) // => [[2, 4]]\n * ```\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterArray = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, pull => Effect.succeed(Effect.flatMap(pull, function loop(arr) {\n const passes = [];\n for (let i = 0; i < arr.length; i++) {\n if (predicate(arr[i])) {\n passes.push(arr[i]);\n }\n }\n return Arr.isReadonlyArrayNonEmpty(passes) ? Effect.succeed(passes) : Effect.flatMap(pull, loop);\n}))));\n/**\n * Filters and maps each element inside emitted non-empty arrays using a\n * `Filter`.\n *\n * **Details**\n *\n * Successful filter results are kept as mapped values. Failed filter results\n * are removed from the array. Arrays that become empty are discarded.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterMapArray = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, pull => Effect.succeed(Effect.flatMap(pull, function loop(arr) {\n const passes = [];\n for (let i = 0; i < arr.length; i++) {\n const result = filter(arr[i]);\n if (Result.isSuccess(result)) {\n passes.push(result.success);\n }\n }\n return Arr.isReadonlyArrayNonEmpty(passes) ? Effect.succeed(passes) : Effect.flatMap(pull, loop);\n}))));\n/**\n * Filters each element inside emitted non-empty arrays with an effectful\n * predicate.\n *\n * **When to use**\n *\n * Use when filtering array-valued channel outputs requires Effects or services,\n * and arrays that become empty should be skipped.\n *\n * **Details**\n *\n * The predicate receives the element and its index within the array. Elements\n * for which the predicate succeeds with `true` are kept. Arrays that become\n * empty are discarded. Predicate failures fail the returned channel.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterArrayEffect = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, pull => {\n const f = Effect.flatMap(pull, arr => Effect.filter(arr, predicate));\n return Effect.succeed(Effect.flatMap(f, function loop(arr) {\n return Arr.isReadonlyArrayNonEmpty(arr) ? Effect.succeed(arr) : Effect.flatMap(f, loop);\n }));\n}));\n/**\n * Filters and maps each element inside emitted non-empty arrays using an\n * effectful `Filter`.\n *\n * **When to use**\n *\n * Use when array-valued channel outputs need an effectful filter-map that can\n * fail and can discard arrays that become empty.\n *\n * **Details**\n *\n * Successful filter results are kept as mapped values. Failed filter results\n * are removed from the array. Arrays that become empty are discarded. Failures\n * from the effectful filter fail the returned channel.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterMapArrayEffect = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, pull => Effect.succeed(Effect.flatMap(pull, function loop(arr) {\n return Effect.flatMap(Effect.filterMapEffect(arr, filter), passes => Arr.isReadonlyArrayNonEmpty(passes) ? Effect.succeed(passes) : Effect.flatMap(pull, loop));\n}))));\n/**\n * Maps over a channel statefully with an accumulator, where each element can produce multiple output values.\n *\n * **Example** (Mapping with accumulated state)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * // Create a channel with numbers\n * const numbersChannel = Channel.fromIterable([1, 2, 3, 4])\n *\n * // Use mapAccum to create running sums and emit both current and sum\n * const runningSum = Channel.mapAccum(\n * numbersChannel,\n * () => 0, // initial accumulator state\n * (sum, current) => {\n * const newSum = sum + current\n * // Return [newState, outputValues]\n * return [newSum, [current, newSum]] as const\n * }\n * )\n * // Using with Effect for async processing\n * const asyncMapAccum = Channel.mapAccum(\n * numbersChannel,\n * () => \"\",\n * (acc, value) =>\n * Effect.gen(function*() {\n * const newAcc = acc + value.toString()\n * return [newAcc, [`${value}-processed`, newAcc]] as const\n * })\n * )\n * Effect.runSync(Channel.runCollect(runningSum)) // => [1, 1, 2, 3, 3, 6, 4, 10]\n * Effect.runSync(Channel.runCollect(asyncMapAccum)) // => [\"1-processed\", \"1\", \"2-processed\", \"12\", \"3-processed\", \"123\", \"4-processed\", \"1234\"]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const mapAccum = /*#__PURE__*/dual(args => isChannel(args[0]), (self, initial, f, options) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => {\n let state = initial();\n let current;\n let index = 0;\n let cause;\n const pullNext = Effect.matchCauseEffect(pull, {\n onFailure(cause_) {\n cause = cause_;\n const b = options?.onHalt && options.onHalt(state);\n return b && b.length > 0 ? Effect.succeed([state, b]) : Effect.failCause(cause_);\n },\n onSuccess(a) {\n const b = f(state, a);\n return Arr.isArray(b) ? Effect.succeed(b) : b;\n }\n });\n const pump = Effect.suspend(function loop() {\n if (current === undefined) {\n if (cause) return Effect.failCause(cause);\n return Effect.flatMap(pullNext, ([newState, values]) => {\n state = newState;\n if (values.length === 0) {\n return loop();\n } else if (values.length === 1) {\n return Effect.succeed(values[0]);\n }\n current = values;\n return loop();\n });\n }\n const next = current[index++];\n if (index >= current.length) {\n current = undefined;\n index = 0;\n }\n return Effect.succeed(next);\n });\n return pump;\n})));\n/**\n * Transforms a channel statefully by scanning over its output with an accumulator function.\n * Emits the intermediate results of the scan operation.\n *\n * **Example** (Scanning channel output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * // Create a channel with numbers\n * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])\n *\n * // Scan to create running sum\n * const runningSumChannel = Channel.scan(numbersChannel, 0, (sum, n) => sum + n)\n * Effect.runSync(Channel.runCollect(runningSumChannel)) // => [0, 1, 3, 6, 10, 15]\n * // Note: emits the initial value and each intermediate result\n *\n * // Scan with string concatenation\n * const wordsChannel = Channel.fromIterable([\"hello\", \"world\", \"from\", \"effect\"])\n * const sentenceChannel = Channel.scan(\n * wordsChannel,\n * \"\",\n * (sentence, word) => sentence === \"\" ? word : `${sentence} ${word}`\n * )\n * Effect.runSync(Channel.runCollect(sentenceChannel)) // => [\"\", \"hello\", \"hello world\", \"hello world from\", \"hello world from effect\"]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const scan = /*#__PURE__*/dual(3, (self, initial, f) => scanEffect(self, initial, (s, a) => Effect.succeed(f(s, a))));\n/**\n * Transforms a channel statefully by scanning over its output with an effectful accumulator function.\n * Emits the intermediate results of the scan operation.\n *\n * **When to use**\n *\n * Use when maintaining accumulated state over channel output requires Effects\n * or can fail, while still emitting each intermediate state.\n *\n * **Example** (Scanning channel output with effects)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class ScanError extends Data.TaggedError(\"ScanError\")<{\n * readonly reason: string\n * }> {}\n *\n * // Create a channel with numbers\n * const numbersChannel = Channel.fromIterable([1, 2, 3, 4])\n *\n * // Effectful scan with async operations\n * const asyncScanChannel = Channel.scanEffect(\n * numbersChannel,\n * \"\",\n * (acc, value) =>\n * Effect.gen(function*() {\n * return acc + value.toString()\n * })\n * )\n * await Effect.runPromise(Channel.runCollect(asyncScanChannel)) // => [\"\", \"1\", \"12\", \"123\", \"1234\"]\n *\n * // Scan with error handling\n * const errorHandlingScan = Channel.scanEffect(\n * numbersChannel,\n * 0,\n * (sum, n) => {\n * if (n < 0) {\n * return Effect.fail(new ScanError({ reason: \"negative number\" }))\n * }\n * return Effect.succeed(sum + n)\n * }\n * )\n * await Effect.runPromise(Channel.runCollect(errorHandlingScan)) // => [0, 1, 3, 6, 10]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const scanEffect = /*#__PURE__*/dual(3, (self, initial, f) => fromTransform((upstream, scope) => Effect.map(toTransform(self)(upstream, scope), pull => {\n let state = initial;\n let isFirst = true;\n return Effect.suspend(() => {\n if (isFirst) {\n isFirst = false;\n return Effect.succeed(state);\n }\n return Effect.map(Effect.flatMap(pull, a => f(state, a)), newState => {\n state = newState;\n return state;\n });\n });\n})));\n/**\n * Catches any cause of failure from the channel and allows recovery by\n * creating a new channel based on the caught cause.\n *\n * **Example** (Recovering from failure causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Channel, Data, Effect } from \"effect\"\n *\n * class ProcessError extends Data.TaggedError(\"ProcessError\")<{\n * readonly reason: string\n * }> {}\n *\n * class RecoveryError extends Data.TaggedError(\"RecoveryError\")<{\n * readonly message: string\n * }> {}\n *\n * // Create a failing channel\n * const failingChannel = Channel.fail(\n * new ProcessError({ reason: \"network error\" })\n * )\n *\n * // Catch the cause and provide recovery\n * const recoveredChannel = Channel.catchCause(failingChannel, (cause) => {\n * if (Cause.hasFails(cause)) {\n * return Channel.succeed(\"Recovered from failure\")\n * }\n * return Channel.succeed(\"Recovered from interruption\")\n * })\n *\n * Effect.runSync(Channel.runCollect(recoveredChannel)) // => [\"Recovered from failure\"]\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const catchCause = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => {\n let forkedScope = Scope.forkUnsafe(scope);\n return Effect.map(toTransform(self)(upstream, forkedScope), pull => {\n let currentPull = pull.pipe(Effect.catchCause(cause => {\n if (Pull.isDoneCause(cause)) {\n return Effect.failCause(cause);\n }\n const toClose = forkedScope;\n forkedScope = Scope.forkUnsafe(scope);\n return Scope.close(toClose, Exit.failCause(cause)).pipe(Effect.andThen(toTransform(f(cause))(upstream, forkedScope)), Effect.flatMap(childPull => {\n currentPull = childPull;\n return childPull;\n }));\n }));\n return Effect.suspend(() => currentPull);\n });\n}));\n/**\n * Recovers from defects using the provided function.\n *\n * **Details**\n *\n * Typed failures and interruptions are not caught.\n *\n * **Example** (Recovering from a defect)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const channel = Channel.fromEffect(Effect.die(\"boom\")).pipe(\n * Channel.catchDefect((defect) => Channel.succeed(`recovered: ${defect}`))\n * )\n *\n * Effect.runSync(Channel.runCollect(channel)) // => [\"recovered: boom\"]\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchDefect = /*#__PURE__*/dual(2, (self, f) => catchCauseFilter(self, Cause.findDefect, f));\n/**\n * Runs an effect with the full failure `Cause` when the channel fails, then\n * fails the returned channel with the original cause.\n *\n * **When to use**\n *\n * Use when observing the full channel failure `Cause` is needed without\n * changing successful output or replacing the original cause.\n *\n * **Details**\n *\n * Use this for observing failures, such as logging or metrics. If the observer\n * effect fails, that failure can fail the returned channel.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const tapCause = /*#__PURE__*/dual(2, (self, f) => catchCause(self, cause => fromEffectDrain(Effect.flatMap(f(cause), _ => Effect.failCause(cause)))));\n/**\n * Catches causes of failure that match a specific filter, allowing\n * conditional error recovery based on the type of failure.\n *\n * **When to use**\n *\n * Use to recover a channel only when its full `Cause` satisfies a boolean\n * predicate.\n *\n * **Details**\n *\n * When the predicate matches, the recovery function receives the original\n * cause. When it does not match, the returned channel fails with the original\n * cause.\n *\n * @see {@link catchCauseFilter} for selecting causes with a `Filter`\n * @see {@link catchCause} for recovering from every cause\n * @see {@link catchIf} for recovering from typed channel errors\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchCause(self, cause => {\n return predicate(cause) ? f(cause) : failCause(cause);\n}));\n/**\n * Recovers from channel failures whose full `Cause` is selected by a `Filter`.\n *\n * **When to use**\n *\n * Use when you need to recover a channel only from causes selected by a\n * `Filter`, while giving the recovery both the selected value and the original\n * `Cause`.\n *\n * **Details**\n *\n * When the filter succeeds, the recovery function receives the selected value\n * and the original cause. When the filter fails, the returned channel fails\n * with the residual cause produced by the filter.\n *\n * @see {@link catchCauseIf} for selecting causes with a predicate\n * @see {@link catchFilter} for selecting typed errors with a `Filter`\n * @see {@link catchCause} for recovering from every cause\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchCauseFilter = /*#__PURE__*/dual(3, (self, filter, f) => catchCause(self, cause => {\n const result = filter(cause);\n return Result.isFailure(result) ? failCause(result.failure) : f(result.success, cause);\n}));\nconst catch_ = /*#__PURE__*/dual(2, (self, f) => catchCauseFilter(self, Cause.findError, e => f(e)));\nexport {\n/**\n * Recovers from typed channel errors by running a fallback channel.\n *\n * @category error handling\n * @since 4.0.0\n */\ncatch_ as catch };\n/**\n * Runs an effect when the channel fails with a typed error, then preserves the\n * original channel failure.\n *\n * **Details**\n *\n * The effect is not run for normal channel completion. If the observer effect\n * fails, that failure can fail the returned channel.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const tapError = /*#__PURE__*/dual(2, (self, f) => transformPull(self, pull => Effect.succeed(Effect.tapError(pull, err => Cause.isDone(err) ? Effect.void : Effect.asVoid(f(err))))));\n/**\n * Recovers from typed channel errors that match a predicate or refinement.\n *\n * **When to use**\n *\n * Use to recover from typed channel errors when a predicate or refinement\n * selects the failures that should switch to a recovery channel.\n *\n * **Details**\n *\n * Matching errors are handled by the recovery function. Non-matching errors\n * are handled by `orElse` when provided. Without `orElse`, non-matching errors\n * are re-failed.\n *\n * @see {@link catch_ catch} for recovering from every typed channel error\n * @see {@link catchFilter} for selecting typed errors with a `Filter`\n * @see {@link catchTag} for selecting tagged typed errors\n * @see {@link catchCauseFilter} for selecting full causes with a `Filter`\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchIf = /*#__PURE__*/dual(args => isChannel(args[0]), (self, predicate, f, orElse) => catch_(self, err => {\n return predicate(err) ? f(err) : orElse ? orElse(err) : fail(err);\n}));\n/**\n * Recovers from typed channel errors selected by a `Filter`.\n *\n * **When to use**\n *\n * Use to recover from channel errors with a reusable `Filter` when matching\n * can also narrow or transform the error before choosing the recovery channel.\n *\n * **Details**\n *\n * Successful filter results are handled by the recovery function. Failed\n * filter results are handled by `orElse` when provided. Without `orElse`,\n * failed filter results are re-failed.\n *\n * @see {@link catchIf} for selecting typed errors with a predicate\n * @see {@link catchTag} for selecting tagged typed errors\n * @see {@link catchCauseFilter} for selecting full causes with a `Filter`\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchFilter = /*#__PURE__*/dual(args => isChannel(args[0]), (self, filter, f, orElse) => catch_(self, err => {\n const result = filter(err);\n return Result.isFailure(result) ? orElse ? orElse(result.failure) : fail(result.failure) : f(result.success);\n}));\n/**\n * Recovers from tagged channel errors whose `_tag` matches one or more tags.\n *\n * **Details**\n *\n * Matching tagged errors are handled by the recovery function. Non-matching\n * errors are handled by `orElse` when provided. Without `orElse`,\n * non-matching errors are re-failed.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchTag = /*#__PURE__*/dual(args => isChannel(args[0]), (self, k, f, orElse) => {\n const pred = Array.isArray(k) ? e => hasProperty(e, \"_tag\") && k.includes(e._tag) : isTagged(k);\n return catchIf(self, pred, f, orElse);\n});\n/**\n * Catches a specific reason within a tagged error.\n *\n * **Example** (Recovering from nested reasons)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class RateLimitError extends Data.TaggedError(\"RateLimitError\")<{\n * retryAfter: number\n * }> {}\n *\n * class QuotaExceededError extends Data.TaggedError(\"QuotaExceededError\")<{\n * limit: number\n * }> {}\n *\n * class AiError extends Data.TaggedError(\"AiError\")<{\n * reason: RateLimitError | QuotaExceededError\n * }> {}\n *\n * const reason = new RateLimitError({ retryAfter: 60 })\n * const channel = Channel.fail(new AiError({ reason }))\n *\n * const recovered = channel.pipe(\n * Channel.catchReason(\"AiError\", \"RateLimitError\", (reason) =>\n * Channel.succeed(`retry: ${reason.retryAfter}`)\n * )\n * )\n * Effect.runSync(Channel.runCollect(recovered)) // => [\"retry: 60\"]\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchReason = /*#__PURE__*/dual(args => isChannel(args[0]), (self, errorTag, reasonTag, f, orElse) => catch_(self, error => {\n if (isTagged(error, errorTag) && hasProperty(error, \"reason\")) {\n const reason = error.reason;\n if (isTagged(reason, reasonTag)) {\n return f(reason, error);\n }\n return orElse ? orElse(reason, error) : fail(error);\n }\n return fail(error);\n}));\n/**\n * Catches multiple reasons within a tagged error using an object of handlers.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchReasons = /*#__PURE__*/dual(args => isChannel(args[0]), (self, errorTag, cases, orElse) => {\n let keys;\n return catch_(self, error => {\n if (isTagged(error, errorTag) && hasProperty(error, \"reason\") && hasProperty(error.reason, \"_tag\") && String.isString(error.reason._tag)) {\n const reason = error.reason;\n keys ??= new Set(Object.keys(cases));\n if (keys.has(reason._tag)) {\n return cases[reason._tag](reason, error);\n }\n return orElse ? orElse(reason, error) : fail(error);\n }\n return fail(error);\n });\n});\n/**\n * Promotes nested reason errors into the channel error, replacing the parent error.\n *\n * **Example** (Promoting nested reasons)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect, Exit } from \"effect\"\n *\n * class RateLimitError extends Data.TaggedError(\"RateLimitError\")<{\n * retryAfter: number\n * }> {}\n *\n * class QuotaExceededError extends Data.TaggedError(\"QuotaExceededError\")<{\n * limit: number\n * }> {}\n *\n * class AiError extends Data.TaggedError(\"AiError\")<{\n * reason: RateLimitError | QuotaExceededError\n * }> {}\n *\n * const reason = new RateLimitError({ retryAfter: 60 })\n * const channel = Channel.fail(new AiError({ reason }))\n *\n * const unwrapped = channel.pipe(Channel.unwrapReason(\"AiError\"))\n * Effect.runSync(Effect.exit(Channel.runCollect(unwrapped))) // => Exit.fail(reason)\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const unwrapReason = /*#__PURE__*/dual(2, (self, errorTag) => catchFilter(self, error => isTagged(error, errorTag) && hasProperty(error, \"reason\") ? Result.succeed(error.reason) : Result.fail(error), fail));\n/**\n * Returns a new channel, which is the same as this one, except the failure\n * value of the returned channel is created by applying the specified function\n * to the failure value of this channel.\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const mapError = /*#__PURE__*/dual(2, (self, f) => catch_(self, err => fail(f(err))));\n/**\n * Converts all errors in the channel to defects (unrecoverable failures).\n * This is useful when you want to treat errors as programming errors.\n *\n * **Example** (Converting failures to defects)\n *\n * ```ts import.meta.vitest\n * import { Cause, Channel, Data, Effect, Exit } from \"effect\"\n *\n * class ValidationError extends Data.TaggedError(\"ValidationError\")<{\n * readonly field: string\n * }> {}\n *\n * // Create a channel that might fail\n * const error = new ValidationError({ field: \"email\" })\n * const failingChannel = Channel.fail(error)\n *\n * // Convert failures to defects\n * const fatalChannel = Channel.orDie(failingChannel)\n *\n * Effect.runSync(Effect.exit(Channel.runCollect(fatalChannel))) // => Exit.failCause(Cause.die(error))\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const orDie = self => catch_(self, die);\n/**\n * Ignores all errors in the channel, converting them to an empty channel.\n *\n * **Details**\n *\n * Use the `log` option to emit the full {@link Cause} when the channel fails.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const ignore = /*#__PURE__*/dual(args => isChannel(args[0]), (self, options) => {\n if (!options?.log) {\n return catch_(self, () => empty);\n }\n const logEffect = Effect.logWithLevel(options.log === true ? undefined : options.log);\n return catch_(tapCause(self, cause => Cause.hasFails(cause) ? logEffect(cause) : Effect.void), () => empty);\n});\nconst ignoreCause_ = self => catchCause(self, () => empty);\n/**\n * Ignores all errors in the channel including defects, converting them to an empty channel.\n *\n * **When to use**\n *\n * Use when a channel should become best-effort and all failure causes, including\n * defects and interruptions, can be converted to empty output.\n *\n * **Details**\n *\n * Use the `log` option to emit the full {@link Cause} when the channel fails.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const ignoreCause = /*#__PURE__*/dual(args => isChannel(args[0]), (self, options) => {\n if (!options?.log) return ignoreCause_(self);\n const logEffect = Effect.logWithLevel(options.log === true ? undefined : options.log);\n return ignoreCause_(tapCause(self, cause => logEffect(cause)));\n});\n/**\n * Returns a new channel that retries this channel according to the specified\n * schedule whenever it fails.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const retry = /*#__PURE__*/dual(2, (self, schedule) => suspend(() => {\n let step = undefined;\n let meta = Schedule.CurrentMetadata.defaultValue();\n const selfWithMeta = provideServiceEffect(self, Schedule.CurrentMetadata, Effect.sync(() => meta));\n const withReset = onFirst(selfWithMeta, () => {\n step = undefined;\n return Effect.void;\n });\n const resolvedSchedule = typeof schedule === \"function\" ? schedule(identity_) : schedule;\n const loop = catch_(withReset, Effect.fnUntraced(function* (error) {\n if (!step) {\n step = yield* Schedule.toStepWithMetadata(resolvedSchedule);\n }\n meta = yield* step(error);\n return loop;\n }, (effect, error) => Pull.catchDone(effect, () => Effect.succeed(fail(error))), unwrap));\n return loop;\n}));\n/**\n * Maps each output element to a channel and emits values from the most recent\n * active child channels.\n *\n * **Details**\n *\n * With the default concurrency of `1`, starting a new child channel interrupts\n * the previous child channel. Use `options.concurrency` to allow more active\n * child channels. The source channel's done value is preserved.\n *\n * **Example** (Switching mapped channels)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class SwitchError extends Data.TaggedError(\"SwitchError\")<{\n * readonly reason: string\n * }> {}\n *\n * // Create a channel that outputs numbers\n * const numberChannel = Channel.fromIterable([1, 2, 3])\n *\n * // Switch to new channels based on each value\n * const switchedChannel = Channel.switchMap(\n * numberChannel,\n * (n) => Channel.fromIterable([`value-${n}`])\n * )\n *\n * await Effect.runPromise(Channel.runCollect(switchedChannel)) // => [\"value-3\"]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const switchMap = /*#__PURE__*/dual(args => isChannel(args[0]), (self, f, options) => self.pipe(map(f), mergeAll({\n ...options,\n concurrency: options?.concurrency ?? 1,\n switch: true\n})));\n/**\n * Merges multiple channels with specified concurrency and buffering options.\n *\n * **When to use**\n *\n * Use when channel outputs are themselves channels and multiple inner channels\n * should run with configured concurrency and buffering.\n *\n * **Example** (Merging nested channels)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class MergeAllError extends Data.TaggedError(\"MergeAllError\")<{\n * readonly reason: string\n * }> {}\n *\n * // Create channels that output other channels\n * const nestedChannels = Channel.fromIterable([\n * Channel.fromIterable([1, 2]),\n * Channel.fromIterable([3, 4]),\n * Channel.fromIterable([5, 6])\n * ])\n *\n * // Merge all channels with bounded concurrency\n * const mergedChannel = Channel.mergeAll({\n * concurrency: 1,\n * bufferSize: 16\n * })(nestedChannels)\n *\n * await Effect.runPromise(Channel.runCollect(mergedChannel)) // => [1, 2, 3, 4, 5, 6]\n * ```\n *\n * @category combining\n * @since 2.0.0\n */\nexport const mergeAll = /*#__PURE__*/dual(2, (channels, {\n bufferSize = 16,\n concurrency,\n switch: switch_ = false\n}) => fromTransformBracket(Effect.fnUntraced(function* (upstream, scope, forkedScope) {\n const concurrencyN = concurrency === \"unbounded\" ? Number.MAX_SAFE_INTEGER : Math.max(1, concurrency);\n const semaphore = switch_ ? undefined : Semaphore.makeUnsafe(concurrencyN);\n const doneLatch = yield* Latch.make(true);\n const fibers = new Set();\n const queue = yield* Queue.bounded(bufferSize);\n yield* Scope.addFinalizer(forkedScope, Queue.shutdown(queue));\n const pull = yield* toTransform(channels)(upstream, scope);\n yield* Effect.gen(function* () {\n while (true) {\n let pullFiber;\n if (semaphore) {\n if (fibers.size < concurrencyN) {\n yield* semaphore.take(1);\n } else {\n pullFiber = yield* Effect.forkChild(pull);\n yield* Effect.raceFirst(semaphore.take(1), Effect.andThen(Fiber.join(pullFiber), Effect.never));\n }\n }\n const channel = pullFiber === undefined ? yield* pull : yield* Fiber.join(pullFiber);\n const childScope = Scope.forkUnsafe(forkedScope);\n const childPull = yield* toTransform(channel)(upstream, childScope);\n while (fibers.size >= concurrencyN) {\n const fiber = Iterable.headUnsafe(fibers);\n fibers.delete(fiber);\n if (fibers.size === 0) yield* doneLatch.open;\n yield* Fiber.interrupt(fiber);\n }\n const fiber = yield* childPull.pipe(Effect.tap(() => Effect.yieldNow), Effect.flatMap(value => Queue.offer(queue, value)), Effect.forever({\n disableYield: true\n }), Effect.onError(Effect.fnUntraced(function* (cause) {\n const halt = Pull.filterDone(cause);\n yield* Effect.exit(Scope.close(childScope, !Result.isFailure(halt) ? Exit.succeed(halt.success.value) : Exit.failCause(halt.failure)));\n if (!fibers.has(fiber)) return;\n fibers.delete(fiber);\n if (semaphore) yield* semaphore.release(1);\n if (fibers.size === 0) yield* doneLatch.open;\n if (Result.isSuccess(halt)) return;\n return yield* Queue.failCause(queue, cause);\n })), Effect.forkChild);\n doneLatch.closeUnsafe();\n fibers.add(fiber);\n }\n }).pipe(Effect.catchCause(cause => {\n const halt = Pull.filterDone(cause);\n if (Result.isSuccess(halt)) {\n return doneLatch.whenOpen(Queue.failCause(queue, cause));\n }\n return Queue.failCause(queue, cause);\n }), Effect.forkIn(forkedScope));\n return Queue.take(queue);\n})));\n/**\n * Returns a new channel, which is the merge of this channel and the specified\n * channel.\n *\n * **Example** (Merging channels)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * // Create two channels\n * const leftChannel = Channel.fromIterable([1, 2, 3])\n * const rightChannel = Channel.fromIterable([\"a\", \"b\", \"c\"])\n *\n * // The default \"both\" strategy waits for both channels to complete\n * const mergedChannel = Channel.merge(leftChannel, rightChannel)\n *\n * const values = await Effect.runPromise(Channel.runCollect(mergedChannel))\n * values.map(String).sort() // => [\"1\", \"2\", \"3\", \"a\", \"b\", \"c\"]\n * ```\n *\n * @category combining\n * @since 4.0.0\n */\nexport const merge = /*#__PURE__*/dual(args => isChannel(args[0]) && isChannel(args[1]), (left, right, options) => fromTransformBracket(Effect.fnUntraced(function* (upstream, _scope, forkedScope) {\n const strategy = options?.haltStrategy ?? \"both\";\n const queue = yield* Queue.bounded(0);\n yield* Scope.addFinalizer(forkedScope, Queue.shutdown(queue));\n let done = 0;\n function onExit(side, cause) {\n done++;\n if (!Pull.isDoneCause(cause)) {\n return Queue.failCause(queue, cause);\n }\n switch (strategy) {\n case \"both\":\n {\n return done === 2 ? Queue.failCause(queue, cause) : Effect.void;\n }\n case \"left\":\n case \"right\":\n {\n return side === strategy ? Queue.failCause(queue, cause) : Effect.void;\n }\n case \"either\":\n {\n return Queue.failCause(queue, cause);\n }\n }\n }\n const runSide = (side, channel, scope) => toTransform(channel)(upstream, scope).pipe(Effect.flatMap(pull => pull.pipe(Effect.flatMap(value => Queue.offer(queue, value)), Effect.forever)), Effect.onError(cause => Effect.andThen(Scope.close(scope, Pull.doneExitFromCause(cause)), onExit(side, cause))), Effect.forkIn(forkedScope));\n yield* runSide(\"left\", left, Scope.forkUnsafe(forkedScope));\n yield* runSide(\"right\", right, Scope.forkUnsafe(forkedScope));\n return Queue.take(queue);\n})));\n/**\n * Runs an effect concurrently with a channel while emitting only the channel's\n * output elements.\n *\n * **When to use**\n *\n * Use when a side effect should run for the lifetime of a channel and only the\n * channel's output elements should be emitted.\n *\n * **Details**\n *\n * The effect's successful value is ignored. If the effect fails while the\n * channel is running, the returned channel fails with that error.\n *\n * @category combining\n * @since 4.0.0\n */\nexport const mergeEffect = /*#__PURE__*/dual(2, (self, effect) => merge(self, fromEffectDrain(effect), {\n haltStrategy: \"left\"\n}));\n/**\n * Splits upstream string chunks into lines, recognizing `\\n`, `\\r\\n`, and\n * standalone `\\r` as line terminators. The behavior matches\n * `String.linesIterator` regardless of how the input is chunked.\n *\n * **Details**\n *\n * A line terminator at the very end of the stream does **not** produce a\n * trailing empty line (consistent with `String.linesIterator`). Conversely,\n * if the stream ends without a terminator the final partial line is still\n * emitted.\n *\n * **Example** (Splitting string chunks into lines)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const result = await Effect.runPromise(Stream.runCollect(\n * Stream.splitLines(Stream.make(\"hel\", \"lo\\r\\nwor\", \"ld\\n\"))\n * ))\n * result // => [\"hello\", \"world\"]\n * ```\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const splitLines = () => fromTransform((upstream, _scope) => Effect.sync(() => {\n // Accumulates text that has not yet been terminated by a line break.\n // Content is carried across chunks until a terminator is found.\n let stringBuilder = \"\";\n // A trailing \\r completes the line immediately. Remember it only to\n // suppress a leading \\n in the next nonempty string.\n let midCRLF = false;\n // Remembers the upstream Done value after the first time the upstream\n // signals completion, so subsequent pulls return Done immediately\n // without pulling upstream again.\n let done = Option.none();\n function splitLinesArray(chunk) {\n const chunkBuilder = [];\n function pushLine(segment) {\n if (stringBuilder.length === 0) {\n chunkBuilder.push(segment);\n } else {\n chunkBuilder.push(stringBuilder + segment);\n stringBuilder = \"\";\n }\n }\n for (let i = 0; i < chunk.length; i++) {\n const str = chunk[i];\n if (str.length !== 0) {\n let from = 0;\n let indexOfCR = str.indexOf(\"\\r\");\n let indexOfLF = str.indexOf(\"\\n\");\n if (midCRLF) {\n if (indexOfLF === 0) {\n from = 1;\n indexOfLF = str.indexOf(\"\\n\", from);\n }\n midCRLF = false;\n }\n while (indexOfCR !== -1 || indexOfLF !== -1) {\n if (indexOfCR === -1 || indexOfLF !== -1 && indexOfLF < indexOfCR) {\n pushLine(str.substring(from, indexOfLF));\n from = indexOfLF + 1;\n indexOfLF = str.indexOf(\"\\n\", from);\n } else {\n pushLine(str.substring(from, indexOfCR));\n if (str.length === indexOfCR + 1) {\n midCRLF = true;\n from = str.length;\n indexOfCR = -1;\n } else {\n from = indexOfCR + (indexOfLF === indexOfCR + 1 ? 2 : 1);\n indexOfCR = str.indexOf(\"\\r\", from);\n indexOfLF = str.indexOf(\"\\n\", from);\n }\n }\n }\n stringBuilder = stringBuilder + str.substring(from);\n }\n }\n return Arr.isReadonlyArrayNonEmpty(chunkBuilder) ? chunkBuilder : null;\n }\n const pullOrFlush = Effect.suspend(() => {\n if (done._tag === \"Some\") {\n return Cause.done(done.value);\n }\n return Pull.matchEffect(upstream, {\n onSuccess: loop,\n onFailure: Effect.failCause,\n onDone: leftover => {\n done = Option.some(leftover);\n if (stringBuilder.length > 0) {\n const last = stringBuilder;\n stringBuilder = \"\";\n midCRLF = false;\n return Effect.succeed([last]);\n }\n return Cause.done(leftover);\n }\n });\n });\n function loop(chunk) {\n const lines = splitLinesArray(chunk);\n return lines !== null ? Effect.succeed(lines) : pullOrFlush;\n }\n return pullOrFlush;\n}));\n/**\n * Decodes incoming `Uint8Array` chunks into strings using `TextDecoder`.\n *\n * **Details**\n *\n * Input chunks are decoded with streaming enabled so multi-byte characters may\n * span `Uint8Array` boundaries. The optional `encoding` and `options` are\n * passed to `TextDecoder`.\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeText = (encoding, options) => fromTransform((upstream, _scope) => Effect.sync(() => {\n const decoder = new TextDecoder(encoding, options);\n const streamOptions = {\n stream: true\n };\n return Effect.map(upstream, Arr.map(line => decoder.decode(line, streamOptions)));\n}));\n/**\n * Encodes incoming string chunks into `Uint8Array` values using `TextEncoder`.\n *\n * **Details**\n *\n * Each string inside an emitted array is encoded independently.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encodeText = () => fromTransform((upstream, _scope) => Effect.sync(() => {\n const encoder = new TextEncoder();\n return Effect.map(upstream, Arr.map(line => encoder.encode(line)));\n}));\n/**\n * Returns a new channel that pipes the output of this channel into the\n * specified channel. The returned channel has the input type of this channel,\n * and the output type of the specified channel, terminating with the value of\n * the specified channel.\n *\n * **Example** (Piping one channel into another)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class PipeError extends Data.TaggedError(\"PipeError\")<{\n * readonly stage: string\n * }> {}\n *\n * // Create source and transform channels\n * const sourceChannel = Channel.fromIterable([1, 2, 3])\n * const transformChannel = Channel.map(sourceChannel, (n: number) => n * 2)\n *\n * // Pipe the source into the transform\n * const pipedChannel = Channel.pipeTo(sourceChannel, transformChannel)\n *\n * Effect.runSync(Channel.runCollect(pipedChannel)) // => [2, 4, 6]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const pipeTo = /*#__PURE__*/dual(2, (self, that) => fromTransform((upstream, scope) => Effect.flatMap(toTransform(self)(upstream, scope), upstream => toTransform(that)(upstream, scope))));\n/**\n * Returns a new channel that pipes the output of this channel into the\n * specified channel and preserves this channel's failures without providing\n * them to the other channel for observation.\n *\n * **Example** (Piping while preserving failures)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect, Exit } from \"effect\"\n *\n * class SourceError extends Data.TaggedError(\"SourceError\")<{\n * readonly code: number\n * }> {}\n *\n * // Create a failing source channel\n * const error = new SourceError({ code: 404 })\n * const failingSource = Channel.fail(error)\n * const safeTransform = Channel.identity()\n *\n * // Pipe while preserving source failures\n * const safePipedChannel = Channel.pipeToOrFail(failingSource, safeTransform)\n *\n * Effect.runSync(Effect.exit(Channel.runCollect(safePipedChannel))) // => Exit.fail(error)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const pipeToOrFail = /*#__PURE__*/dual(2, (self, that) => fromTransform((upstream, scope) => Effect.flatMap(toTransform(self)(upstream, scope), upstream => {\n const upstreamPull = Effect.catchCause(upstream, cause => Pull.isDoneCause(cause) ? Effect.failCause(cause) : Effect.die(Cause.Done(cause)));\n return Effect.map(toTransform(that)(upstreamPull, scope), pull => Effect.catchDefect(pull, defect => Cause.isDone(defect) ? Effect.failCause(defect.value) : Effect.die(defect)));\n})));\n/**\n * Constructs a `Channel` from a scoped effect that will result in a\n * `Channel` if successful.\n *\n * **Example** (Unwrapping channel effects)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class UnwrapError extends Data.TaggedError(\"UnwrapError\")<{\n * readonly reason: string\n * }> {}\n *\n * // Create an effect that produces a channel\n * const channelEffect = Effect.succeed(\n * Channel.fromIterable([1, 2, 3])\n * )\n *\n * // Unwrap the effect to get the channel\n * const unwrappedChannel = Channel.unwrap(channelEffect)\n *\n * Effect.runSync(Channel.runCollect(unwrappedChannel)) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const unwrap = channel => fromTransform((upstream, scope) => {\n let pull;\n return Effect.succeed(Effect.suspend(() => {\n if (pull) return pull;\n return channel.pipe(Scope.provide(scope), Effect.flatMap(channel => toTransform(channel)(upstream, scope)), Effect.flatMap(pull_ => pull = pull_));\n }));\n});\n/**\n * Runs a channel with a scope provided for the duration of the channel\n * execution, removing the channel's `Scope` requirement.\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const scoped = self => fromTransformBracket((upstream, scope, forkedScope) => Effect.map(Scope.provide(toTransform(self)(upstream, scope), forkedScope), Scope.provide(forkedScope)));\n/**\n * Runs an input handler against the upstream pull while the wrapped channel\n * runs without receiving upstream input directly.\n *\n * **Details**\n *\n * The input handler is forked in the channel scope. The wrapped channel is run\n * with an already-completed input.\n *\n * **Example** (Embedding custom input handling)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * // Create a base channel\n * const baseChannel = Channel.fromIterable([1, 2, 3])\n *\n * // Drain the embedded input while the base channel runs\n * const embeddedChannel = Channel.embedInput(\n * baseChannel,\n * (upstream) =>\n * upstream.pipe(\n * Effect.forever,\n * Effect.ignore\n * )\n * )\n * await Effect.runPromise(Channel.runCollect(embeddedChannel)) // => [1, 2, 3]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const embedInput = /*#__PURE__*/dual(2, (self, input) => fromTransformBracket((upstream, scope, forkedScope) => Effect.andThen(Effect.forkIn(input(upstream), forkedScope), toTransform(self)(Cause.done(), scope))));\n/**\n * Buffers individual output elements in a queue with the configured `capacity`\n * so a faster producer can progress independently of a slower consumer.\n *\n * **When to use**\n *\n * Use when output elements can be decoupled from downstream demand and the\n * configured backpressure or loss strategy is acceptable.\n *\n * **Details**\n *\n * Finite queues use the `strategy` option. The default `\"suspend\"` strategy\n * applies backpressure, while `\"dropping\"` and `\"sliding\"` can discard output\n * elements when the queue is full. `\"unbounded\"` capacity does not use a finite\n * capacity strategy.\n *\n * **Gotchas**\n *\n * Dropping and sliding strategies can lose output elements under backpressure.\n *\n * @see {@link bufferArray} for buffering elements from array outputs\n *\n * @category buffering\n * @since 2.0.0\n */\nexport const buffer = /*#__PURE__*/dual(2, (self, options) => fromTransform(Effect.fnUntraced(function* (upstream, scope) {\n const pull = yield* toTransform(self)(upstream, scope);\n const queue = yield* Queue.make({\n capacity: options.capacity === \"unbounded\" ? undefined : options.capacity,\n strategy: options.capacity === \"unbounded\" ? undefined : options.strategy\n });\n yield* Scope.addFinalizer(scope, Queue.shutdown(queue));\n yield* pull.pipe(Effect.flatMap(value => Queue.offer(queue, value)), Effect.forever({\n disableYield: true\n }), Effect.onError(cause => Queue.failCause(queue, cause)), Effect.forkIn(scope));\n return Queue.take(queue);\n})));\n/**\n * Buffers array output elements in a queue with the configured `capacity` so a\n * faster producer can progress independently of a slower consumer.\n *\n * **When to use**\n *\n * Use when emitted arrays are batches of elements and it is acceptable for\n * buffering to flatten and rebuild those batches.\n *\n * **Details**\n *\n * Finite queues use the `strategy` option. The default `\"suspend\"` strategy\n * applies backpressure, while `\"dropping\"` and `\"sliding\"` can discard output\n * elements when the queue is full. `\"unbounded\"` capacity does not use a finite\n * capacity strategy.\n *\n * **Gotchas**\n *\n * Input arrays are offered to the queue element-by-element and outputs are\n * rebuilt from the currently available queued elements, so upstream array\n * boundaries are not preserved.\n *\n * @see {@link buffer} for buffering output elements without flattening arrays\n *\n * @category buffering\n * @since 4.0.0\n */\nexport const bufferArray = /*#__PURE__*/dual(2, (self, options) => fromTransform(Effect.fnUntraced(function* (upstream, scope) {\n const pull = yield* toTransform(self)(upstream, scope);\n const queue = yield* Queue.make({\n capacity: options.capacity === \"unbounded\" ? undefined : options.capacity,\n strategy: options.capacity === \"unbounded\" ? undefined : options.strategy\n });\n yield* Scope.addFinalizer(scope, Queue.shutdown(queue));\n yield* pull.pipe(Effect.flatMap(value => Queue.offerAll(queue, value)), Effect.forever({\n disableYield: true\n }), Effect.onError(cause => Queue.failCause(queue, cause)), Effect.forkIn(scope));\n return Queue.takeAll(queue);\n})));\n/**\n * Interrupts a channel when another effect completes.\n *\n * **When to use**\n *\n * Use to race channel execution against an external effect whose success can\n * become the channel's done value.\n *\n * **Details**\n *\n * If the effect completes first, its success value becomes the returned\n * channel's done value. If the channel completes first, the original channel's\n * done value is preserved.\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const interruptWhen = /*#__PURE__*/dual(2, (self, effect) => merge(self, fromPull(Effect.succeed(Effect.flatMap(effect, Cause.done))), {\n haltStrategy: \"either\"\n}));\n/**\n * Stops a channel when the specified effect completes or fails.\n *\n * **Details**\n *\n * If the effect completes before the channel is done, its success value becomes\n * the returned channel's done value. If the effect fails, the returned channel\n * fails with that error. If the channel completes first, the channel's done\n * value is preserved.\n *\n * @category interruption\n * @since 4.0.0\n */\nexport const haltWhen = /*#__PURE__*/dual(2, (self, effect) => fromTransformBracket(Effect.fnUntraced(function* (upstream, scope, forkedScope) {\n const pull = yield* toTransform(self)(upstream, scope);\n const fiber = yield* Effect.forkIn(effect, forkedScope, {\n startImmediately: true\n });\n return Effect.suspend(() => {\n const exit = fiber.pollUnsafe();\n return exit === undefined ? pull : Exit.match(exit, {\n onFailure: Effect.failCause,\n onSuccess: Cause.done\n });\n });\n})));\n/**\n * Attaches a finalizer that runs only when the channel exits with failure.\n *\n * **Details**\n *\n * The finalizer receives the failure `Cause`. The original channel failure is\n * preserved. The finalizer itself must not fail.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const onError = /*#__PURE__*/dual(2, (self, finalizer) => onExit(self, exit => Exit.isFailure(exit) ? finalizer(exit.cause) : Effect.void));\n/**\n * Returns a channel with an exit-aware finalizer that is guaranteed to run once\n * the channel begins execution, whether it succeeds or fails.\n *\n * **Example** (Running exit finalizers)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect, Exit } from \"effect\"\n *\n * class ExitError extends Data.TaggedError(\"ExitError\")<{\n * readonly stage: string\n * }> {}\n *\n * // Create a channel\n * const dataChannel = Channel.fromIterable([1, 2, 3])\n *\n * // Attach exit handler\n * const exits: Array> = []\n * const channelWithExit = Channel.onExit(dataChannel, (exit) => {\n * exits.push(exit)\n * return Effect.void\n * })\n * const observed = [await Effect.runPromise(Channel.runCollect(channelWithExit)), exits] // => [[1, 2, 3], [Exit.void]]\n * ```\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const onExit = /*#__PURE__*/dual(2, (self, finalizer) => fromTransformBracket((upstream, scope, forkedScope) => Scope.addFinalizerExit(forkedScope, finalizer).pipe(Effect.andThen(toTransform(self)(upstream, scope)))));\n/**\n * Runs an effect before the channel starts.\n *\n * **Details**\n *\n * The effect's successful value is ignored. If the effect fails, the returned\n * channel fails before running the source channel.\n *\n * @category hooks\n * @since 4.0.0\n */\nexport const onStart = /*#__PURE__*/dual(2, (self, onStart) => unwrap(Effect.as(onStart, self)));\n/**\n * Runs an effect the first time the channel emits an output element.\n *\n * **When to use**\n *\n * Use when initialization depends on the first output element rather than only\n * on channel startup.\n *\n * **Details**\n *\n * The effect receives the first emitted element. The first element is still\n * emitted unchanged. The effect is not run if the channel completes without\n * emitting an element.\n *\n * @category hooks\n * @since 4.0.0\n */\nexport const onFirst = /*#__PURE__*/dual(2, (self, onFirst) => transformPull(self, pull => Effect.sync(() => {\n let isFirst = true;\n const pullFirst = Effect.tap(pull, element => {\n isFirst = false;\n return onFirst(element);\n });\n return Effect.suspend(() => isFirst ? pullFirst : pull);\n})));\n/**\n * Runs an effect when the channel completes successfully.\n *\n * **Details**\n *\n * The effect runs before the original done value is propagated. The effect is\n * not run when the channel fails. If the effect fails, the returned channel\n * fails with that error.\n *\n * @category hooks\n * @since 4.0.0\n */\nexport const onEnd = /*#__PURE__*/dual(2, (self, onEnd) => transformPull(self, pull => Effect.succeed(Pull.catchDone(pull, leftover => Effect.flatMap(onEnd, () => Cause.done(leftover))))));\n/**\n * Returns a channel with a finalizer effect that is guaranteed to run once the\n * channel begins execution, whether it succeeds or fails.\n *\n * **Example** (Ensuring cleanup runs)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class EnsureError extends Data.TaggedError(\"EnsureError\")<{\n * readonly operation: string\n * }> {}\n *\n * // Create a channel\n * const dataChannel = Channel.fromIterable([1, 2, 3])\n *\n * // Ensure cleanup always runs\n * const events: Array = []\n * const channelWithCleanup = Channel.ensuring(\n * dataChannel,\n * Effect.sync(() => events.push(\"cleanup\"))\n * )\n * const observed = [await Effect.runPromise(Channel.runCollect(channelWithCleanup)), events] // => [[1, 2, 3], [\"cleanup\"]]\n * ```\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => onExit(self, _ => finalizer));\nconst runWith = (self, f, onHalt) => Effect.suspend(() => {\n const scope = Scope.makeUnsafe();\n const makePull = toTransform(self)(Cause.done(), scope);\n return Pull.catchDone(Effect.flatMap(makePull, f), onHalt ? onHalt : Effect.succeed).pipe(Effect.onExit(exit => Scope.close(scope, exit)));\n});\n/**\n * Creates a channel from the specified services.\n *\n * @category accessors\n * @since 2.0.0\n */\nexport const contextWith = f => fromTransform((upstream, scope) => Effect.contextWith(context => toTransform(f(context))(upstream, scope)));\n/**\n * Provides a `Context` to the channel, removing the corresponding service\n * requirements from the returned channel.\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const provideContext = /*#__PURE__*/dual(2, (self, context) => fromTransform((upstream, scope) => Effect.map(Effect.provideContext(toTransform(self)(upstream, scope), context), Effect.provideContext(context))));\n/**\n * Provides a concrete service for a context key, removing that service\n * requirement from the returned channel.\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const provideService = /*#__PURE__*/dual(3, (self, key, service) => fromTransform((upstream, scope) => Effect.map(Effect.provideService(toTransform(self)(upstream, scope), key, service), Effect.provideService(key, service))));\n/**\n * Provides a service to the channel after obtaining it from an effect.\n *\n * **When to use**\n *\n * Use to supply a channel dependency when constructing the service itself is\n * effectful or can fail.\n *\n * **Details**\n *\n * If the service effect fails, the returned channel fails. The provided service\n * removes the corresponding service requirement from the returned channel.\n *\n * @category providing services\n * @since 4.0.0\n */\nexport const provideServiceEffect = /*#__PURE__*/dual(3, (self, key, service) => fromTransform((upstream, scope) => Effect.flatMap(service, s => toTransform(provideService(self, key, s))(upstream, scope))));\n/**\n * Provides a `Layer` or `Context` to the channel, removing the corresponding\n * service requirements.\n *\n * **Details**\n *\n * Providing a `Context` delegates to `provideContext`. Providing a `Layer`\n * builds the layer in the channel scope. Use `options.local` to build a fresh\n * layer instance for this provision.\n *\n * @category providing services\n * @since 4.0.0\n */\nexport const provide = /*#__PURE__*/dual(args => isChannel(args[0]), (self, layer, options) => Context.isContext(layer) ? provideContext(self, layer) : fromTransform((upstream, scope) => Effect.flatMap(options?.local ? Layer.buildWithMemoMap(layer, Layer.makeMemoMapUnsafe(), scope) : Layer.buildWithScope(layer, scope), context => Effect.map(Effect.provideContext(toTransform(self)(upstream, scope), context), Effect.provideContext(context)))));\n/**\n * Transforms the current context before running the channel.\n *\n * **Details**\n *\n * The function receives the surrounding context and returns the context to\n * provide to the channel. The returned channel requires the services needed to\n * build that context.\n *\n * @category providing services\n * @since 4.0.0\n */\nexport const updateContext = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => Effect.contextWith(context => {\n const toProvide = f(context);\n return toTransform(provideContext(self, toProvide))(upstream, scope);\n})));\n/**\n * Updates a service in the current context before running the channel.\n *\n * **Details**\n *\n * The existing service is read from the context. The updated service is\n * provided to the channel under the same key.\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateContext(self, context => Context.add(context, service, f(Context.get(context, service)))));\n/**\n * Runs the channel inside a tracing span with the specified name and options.\n *\n * **Details**\n *\n * The created span is provided as the current parent span while the channel\n * runs. The span is ended with the channel's exit value.\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const withSpan = function () {\n const dataFirst = isChannel(arguments[0]);\n const name = dataFirst ? arguments[1] : arguments[0];\n const options = addSpanStackTrace(dataFirst ? arguments[2] : arguments[1]);\n if (dataFirst) {\n const self = arguments[0];\n return withSpanImpl(self, name, options);\n }\n return self => withSpanImpl(self, name, options);\n};\nconst withSpanImpl = (self, name, options) => acquireUseRelease(Effect.makeSpan(name, options), span => provideService(self, ParentSpan, span), (span, exit) => Effect.withFiber(fiber => {\n const clock = fiber.getRef(ClockRef);\n const timingEnabled = fiber.getRef(TracerTimingEnabled);\n return endSpan(span, exit, clock, timingEnabled);\n}));\n/**\n * The starting channel for Do notation, emitting an empty object.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Do = /*#__PURE__*/succeed({});\nconst let_ = /*#__PURE__*/dual(3, (self, name, f) => map(self, elem => ({\n ...elem,\n [name]: f(elem)\n})));\nexport {\n/**\n * Adds a computed field to each object emitted by a channel.\n *\n * @category mapping\n * @since 4.0.0\n */\nlet_ as let };\n/**\n * Adds a field to each object emitted by a channel by running another channel\n * derived from that object.\n *\n * **Details**\n *\n * The field name must not already exist on the emitted object. The derived\n * channel's output becomes the value of the new field. `options.concurrency`\n * and `options.bufferSize` control how derived channels are flattened.\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const bind = /*#__PURE__*/dual(args => isChannel(args[0]), (self, name, f, options) => flatMap(self, elem => map(f(elem), b => ({\n ...elem,\n [name]: b\n})), options));\n/**\n * Wraps each output element in an object under the specified field name.\n *\n * **When to use**\n *\n * Use when you need to start a Channel Do-notation chain from an existing\n * output value by assigning that value to a field name.\n *\n * @see {@link Do} for starting Do notation from an empty object\n * @see {@link bind} for adding a field produced by another channel\n * @see {@link let_ let} for adding a computed field\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const bindTo = /*#__PURE__*/dual(2, (self, name) => map(self, elem => ({\n [name]: elem\n})));\n/**\n * Runs a channel and counts the number of elements it outputs.\n *\n * **Example** (Counting channel output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class CountError extends Data.TaggedError(\"CountError\")<{\n * readonly reason: string\n * }> {}\n *\n * // Create a channel with multiple elements\n * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])\n *\n * // Count the elements\n * const countEffect = Channel.runCount(numbersChannel)\n *\n * Effect.runSync(countEffect) // => 5\n * ```\n *\n * @category running\n * @since 4.0.0\n */\nexport const runCount = self => runFold(self, () => 0, acc => acc + 1);\n/**\n * Runs a channel and discards all output elements, returning only the final result.\n *\n * **Example** (Draining channel output at runtime)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class DrainError extends Data.TaggedError(\"DrainError\")<{\n * readonly stage: string\n * }> {}\n *\n * // Create a channel that outputs elements and completes with a result\n * const resultChannel = Channel.fromIterable([1, 2, 3])\n * const completedChannel = Channel.concat(resultChannel, Channel.end(\"completed\"))\n *\n * // Drain all elements and get only the final result\n * const drainEffect = Channel.runDrain(completedChannel)\n *\n * Effect.runSync(drainEffect) // => \"completed\"\n * ```\n *\n * @category running\n * @since 2.0.0\n */\nexport const runDrain = self => runWith(self, pull => Effect.forever(pull, {\n disableYield: true\n}));\n/**\n * Runs a channel and applies an effect to each output element.\n *\n * **Example** (Running effects for each output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class ForEachError extends Data.TaggedError(\"ForEachError\")<{\n * readonly element: unknown\n * }> {}\n *\n * // Create a channel with numbers\n * const numbersChannel = Channel.fromIterable([1, 2, 3])\n *\n * // Run forEach to process each element\n * const processed: Array = []\n * const forEachEffect = Channel.runForEach(\n * numbersChannel,\n * (n) => Effect.sync(() => processed.push(n))\n * )\n *\n * await Effect.runPromise(forEachEffect)\n * processed // => [1, 2, 3]\n * ```\n *\n * @category running\n * @since 4.0.0\n */\nexport const runForEach = /*#__PURE__*/dual(2, (self, f) => runWith(self, pull => Effect.forever(Effect.flatMap(pull, f), {\n disableYield: true\n})));\n/**\n * Runs a channel and applies an effectful predicate to each output element\n * until the predicate returns `false`.\n *\n * **Details**\n *\n * Returning `true` continues consuming the channel. Returning `false` stops\n * consumption early. The returned effect completes with `void`.\n *\n * @category running\n * @since 4.0.0\n */\nexport const runForEachWhile = /*#__PURE__*/dual(2, (self, f) => runWith(self, pull => pull.pipe(Effect.flatMap(f), Effect.flatMap(cont => cont ? Effect.void : Cause.done()), Effect.forever({\n disableYield: true\n}))));\n/**\n * Concatenates a channel's `Uint8Array` chunks into a single `Uint8Array`.\n *\n * **Gotchas**\n *\n * This materializes the full content in memory. The source channel must not\n * reuse or mutate emitted buffers, which are retained until collection completes.\n *\n * **Example** (Joining channel byte chunks)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect } from \"effect\"\n *\n * const channel = Channel.fromArray([\n * [new Uint8Array([1, 2])],\n * [new Uint8Array([3, 4])]\n * ] as const)\n *\n * const bytes = Effect.runSync(Channel.mkUint8Array(channel))\n * Array.from(bytes) // => [1, 2, 3, 4]\n * ```\n *\n * @category running\n * @since 4.0.0\n */\nexport const mkUint8Array = self => Effect.map(runFold(self, () => ({\n bytes: 0,\n arrays: []\n}), (acc, chunk) => {\n for (let i = 0; i < chunk.length; i++) {\n acc.bytes += chunk[i].length;\n acc.arrays.push(chunk[i]);\n }\n return acc;\n}), ({\n arrays,\n bytes\n}) => {\n const result = new Uint8Array(bytes);\n let offset = 0;\n for (let i = 0; i < arrays.length; i++) {\n const array = arrays[i];\n result.set(array, offset);\n offset += array.length;\n }\n return result;\n});\n/**\n * Runs a channel and collects all output elements into an array.\n *\n * **Example** (Collecting channel output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class CollectError extends Data.TaggedError(\"CollectError\")<{\n * readonly reason: string\n * }> {}\n *\n * // Create a channel with elements\n * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])\n *\n * // Collect all elements into an array\n * const collectEffect = Channel.runCollect(numbersChannel)\n *\n * Effect.runSync(collectEffect) // => [1, 2, 3, 4, 5]\n * ```\n *\n * @category running\n * @since 2.0.0\n */\nexport const runCollect = self => runFold(self, () => [], (acc, o) => {\n acc.push(o);\n return acc;\n});\n/**\n * Runs a channel until the first output element is available, returning it in\n * an `Option`.\n *\n * **Details**\n *\n * Returns `Option.some` with the first output element, or `Option.none` if the\n * channel completes without emitting output.\n *\n * @category running\n * @since 4.0.0\n */\nexport const runHead = self => Effect.suspend(() => {\n let head = Option.none();\n return runWith(self, pull => pull.pipe(Effect.asSome, Effect.flatMap(head_ => {\n head = head_;\n return Cause.done();\n })), () => Effect.succeed(head));\n});\n/**\n * Runs a channel to completion and returns the last output element in an\n * `Option`.\n *\n * **Details**\n *\n * Returns `Option.some` with the last emitted element, or `Option.none` if the\n * channel completes without emitting output.\n *\n * @category running\n * @since 4.0.0\n */\nexport const runLast = self => Effect.suspend(() => {\n const absent = Symbol(); // Prevent boxing\n let last = absent;\n return runWith(self, pull => Effect.forever(Effect.flatMap(pull, item => {\n last = item;\n return Effect.void;\n }), {\n disableYield: true\n }), () => last === absent ? Effect.succeedNone : Effect.succeedSome(last));\n});\n/**\n * Runs a channel and folds over all output elements with an accumulator.\n *\n * **Example** (Folding channel output)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class FoldError extends Data.TaggedError(\"FoldError\")<{\n * readonly operation: string\n * }> {}\n *\n * // Create a channel with numbers\n * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])\n *\n * // Fold to calculate sum\n * const sumEffect = Channel.runFold(numbersChannel, () => 0, (acc, n) => acc + n)\n *\n * Effect.runSync(sumEffect) // => 15\n * ```\n *\n * @category running\n * @since 4.0.0\n */\nexport const runFold = /*#__PURE__*/dual(3, (self, initial, f) => Effect.suspend(() => {\n let state = initial();\n return runWith(self, pull => Effect.whileLoop({\n while: constTrue,\n body: () => pull,\n step: value => {\n state = f(state, value);\n }\n }), () => Effect.succeed(state));\n}));\n/**\n * Runs a channel and effectfully folds all output elements with an accumulator.\n *\n * **When to use**\n *\n * Use when folding channel output needs effects, services, or an additional\n * failure channel during accumulation.\n *\n * **Details**\n *\n * The initial accumulator is evaluated lazily. Each output element is passed to\n * the effectful accumulator function. The returned effect succeeds with the\n * final accumulator value.\n *\n * @category running\n * @since 4.0.0\n */\nexport const runFoldEffect = /*#__PURE__*/dual(3, (self, initial, f) => Effect.suspend(() => {\n let state = initial();\n return runWith(self, pull => Effect.whileLoop({\n while: constTrue,\n body: constant(pull.pipe(Effect.flatMap(o => f(state, o)), Effect.map(s => {\n state = s;\n }))),\n step: constVoid\n }), () => Effect.succeed(state));\n}));\n/**\n * Converts a channel to a scoped `Pull` for low-level consumption.\n *\n * **Details**\n *\n * The effect requires a `Scope`. The returned pull should be consumed only\n * while that scope remains open. Pulls are serialized so only one pull is\n * evaluated at a time.\n *\n * **Example** (Converting channels to pulls)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect } from \"effect\"\n *\n * class PullError extends Data.TaggedError(\"PullError\")<{\n * readonly step: string\n * }> {}\n *\n * // Create a channel\n * const numbersChannel = Channel.fromIterable([1, 2, 3])\n *\n * const program = Effect.scoped(Effect.gen(function*() {\n * const pull = yield* Channel.toPull(numbersChannel)\n * return [yield* pull, yield* pull, yield* pull]\n * }))\n * await Effect.runPromise(program) // => [1, 2, 3]\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const toPull = /*#__PURE__*/Effect.fnUntraced(function* (self) {\n const semaphore = Semaphore.makeUnsafe(1);\n const context = yield* Effect.context();\n const scope = Context.get(context, Scope.Scope);\n const pull = yield* toTransform(self)(Cause.done(), scope);\n return pull.pipe(Effect.provideContext(context), semaphore.withPermits(1));\n},\n/*#__PURE__*/\n// ensure errors are redirected to the pull effect\nEffect.catchCause(cause => Effect.succeed(Effect.failCause(cause))));\n/**\n * Converts a channel to a Pull within an existing scope.\n *\n * **Example** (Converting channels to scoped pulls)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect, Scope } from \"effect\"\n *\n * class ScopedPullError extends Data.TaggedError(\"ScopedPullError\")<{\n * readonly reason: string\n * }> {}\n *\n * // Create a channel\n * const numbersChannel = Channel.fromIterable([1, 2, 3])\n *\n * // Convert to Pull with explicit scope\n * const scopedPullEffect = Effect.gen(function*() {\n * const scope = yield* Effect.scope\n * const pull = yield* Channel.toPullScoped(numbersChannel, scope)\n * return [yield* pull, yield* pull, yield* pull]\n * })\n * await Effect.runPromise(Effect.scoped(scopedPullEffect)) // => [1, 2, 3]\n * ```\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toPullScoped = (self, scope) => toTransform(self)(Cause.done(), scope);\n/**\n * Runs a channel and offers each output element into a queue.\n *\n * **Details**\n *\n * When the channel completes, the queue is ended. When the channel fails, the\n * queue is failed with the channel's cause. The returned effect itself\n * completes with `void`.\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const runIntoQueue = /*#__PURE__*/dual(args => isChannel(args[0]), (self, queue) => Effect.uninterruptibleMask(restore => runForEach(self, value => Queue.offer(queue, value)).pipe(restore, Effect.exit, Effect.flatMap(exit => {\n if (Exit.isSuccess(exit)) {\n Queue.endUnsafe(queue);\n } else {\n Queue.failCauseUnsafe(queue, exit.cause);\n }\n return Effect.void;\n}))));\n/**\n * Runs a channel that emits non-empty arrays and offers each array element into\n * a queue.\n *\n * **Details**\n *\n * When the channel completes, the queue is ended. When the channel fails, the\n * queue is failed with the channel's cause. The returned effect itself\n * completes with `void`.\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const runIntoQueueArray = /*#__PURE__*/dual(args => isChannel(args[0]), (self, queue) => Effect.uninterruptibleMask(restore => runForEach(self, value => Queue.offerAll(queue, value)).pipe(restore, Effect.exit, Effect.flatMap(exit => {\n if (Exit.isSuccess(exit)) {\n Queue.endUnsafe(queue);\n } else {\n Queue.failCauseUnsafe(queue, exit.cause);\n }\n return Effect.void;\n}))));\n/**\n * Creates a scoped queue and forks the channel to feed it for concurrent\n * consumption.\n *\n * **Details**\n *\n * Output elements are offered to the queue. Channel completion and failure are\n * signaled through the queue. The queue is shut down when the surrounding scope\n * closes.\n *\n * **Example** (Converting channels to queues)\n *\n * ```ts import.meta.vitest\n * import { Channel, Data, Effect, Queue } from \"effect\"\n *\n * class QueueError extends Data.TaggedError(\"QueueError\")<{\n * readonly operation: string\n * }> {}\n *\n * // Create a channel with data\n * const dataChannel = Channel.fromIterable([1, 2, 3, 4, 5])\n *\n * // Convert to queue for concurrent processing\n * const program = Effect.scoped(Effect.gen(function*() {\n * const queue = yield* Channel.toQueue(dataChannel, { capacity: 32 })\n * return yield* Queue.takeBetween(queue, 5, 5)\n * }))\n * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const toQueue = /*#__PURE__*/dual(args => isChannel(args[0]), /*#__PURE__*/Effect.fnUntraced(function* (self, options) {\n const scope = yield* Effect.scope;\n const queue = yield* Queue.make({\n capacity: typeof options.capacity === \"number\" ? options.capacity : undefined,\n strategy: typeof options.capacity === \"number\" ? options.strategy : undefined\n });\n yield* Scope.addFinalizer(scope, Queue.shutdown(queue));\n yield* Effect.forkIn(runIntoQueue(self, queue), scope);\n return queue;\n}));\n/**\n * Creates a scoped queue and forks an array-emitting channel to feed it.\n *\n * **Details**\n *\n * Each element inside emitted non-empty arrays is offered to the queue. Channel\n * completion and failure are signaled through the queue. The queue is shut down\n * when the surrounding scope closes.\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toQueueArray = /*#__PURE__*/dual(args => isChannel(args[0]), /*#__PURE__*/Effect.fnUntraced(function* (self, options) {\n const scope = yield* Effect.scope;\n const queue = yield* Queue.make({\n capacity: typeof options.capacity === \"number\" ? options.capacity : undefined,\n strategy: typeof options.capacity === \"number\" ? options.strategy : undefined\n });\n yield* Scope.addFinalizer(scope, Queue.shutdown(queue));\n yield* Effect.forkIn(runIntoQueueArray(self, queue), scope);\n return queue;\n}));\n/**\n * Converts a channel to a PubSub for concurrent consumption.\n *\n * **Details**\n *\n * `shutdownOnEnd` indicates whether the PubSub should be shut down when the\n * channel ends. By default this is `true`.\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const toPubSub = /*#__PURE__*/dual(2, /*#__PURE__*/Effect.fnUntraced(function* (self, options) {\n const pubsub = yield* makePubSub(options);\n yield* Effect.forkScoped(runIntoPubSub(self, pubsub, {\n shutdownOnEnd: options.shutdownOnEnd !== false\n }));\n return pubsub;\n}));\n/**\n * Runs a channel and publishes each output element to a `PubSub`.\n *\n * **Details**\n *\n * The channel's output values are published as individual PubSub messages. Use\n * `options.shutdownOnEnd` to shut down the PubSub when channel execution ends.\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const runIntoPubSub = /*#__PURE__*/dual(args => isChannel(args[0]), (self, pubsub, options) => runForEach(self, value => PubSub.publish(pubsub, value)).pipe(options?.shutdownOnEnd === true ? Effect.ensuring(PubSub.shutdown(pubsub)) : identity_));\nconst makePubSub = options => Effect.acquireRelease(options.capacity === \"unbounded\" ? PubSub.unbounded(options) : options.strategy === \"dropping\" ? PubSub.dropping(options) : options.strategy === \"sliding\" ? PubSub.sliding(options) : PubSub.bounded(options), PubSub.shutdown);\n/**\n * Converts an array-emitting channel to a scoped `PubSub` for concurrent\n * consumption.\n *\n * **Details**\n *\n * Each element inside emitted non-empty arrays is published as an individual\n * PubSub message. `shutdownOnEnd` indicates whether the PubSub should be shut\n * down when the channel ends. By default this is `true`.\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toPubSubArray = /*#__PURE__*/dual(2, /*#__PURE__*/Effect.fnUntraced(function* (self, options) {\n const pubsub = yield* makePubSub(options);\n yield* Effect.forkScoped(runIntoPubSubArray(self, pubsub, {\n shutdownOnEnd: options.shutdownOnEnd !== false\n }));\n return pubsub;\n}));\n/**\n * Runs an array-emitting channel and publishes each array element to a\n * `PubSub`.\n *\n * **Details**\n *\n * Each element inside emitted non-empty arrays is published as an individual\n * PubSub message. Use `options.shutdownOnEnd` to shut down the PubSub when\n * channel execution ends.\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const runIntoPubSubArray = /*#__PURE__*/dual(args => isChannel(args[0]), (self, pubsub, options) => runForEach(self, value => PubSub.publishAll(pubsub, value)).pipe(options?.shutdownOnEnd === true ? Effect.ensuring(PubSub.shutdown(pubsub)) : identity_));\n/**\n * Converts a channel to a scoped `PubSub` of `Take` values.\n *\n * **Details**\n *\n * Emitted non-empty arrays are published as output `Take` values. When the\n * channel ends, its final `Exit` is published so subscribers can observe\n * completion or failure.\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toPubSubTake = /*#__PURE__*/dual(2, /*#__PURE__*/Effect.fnUntraced(function* (self, options) {\n const pubsub = yield* makePubSub(options);\n yield* runForEach(self, value => PubSub.publish(pubsub, value)).pipe(Effect.onExit(exit => PubSub.publish(pubsub, exit)), Effect.forkScoped);\n return pubsub;\n}));\n//# sourceMappingURL=Channel.js.map","import { identity } from \"../Function.js\";\nimport { pipeArguments } from \"../Pipeable.js\";\nconst TypeId = \"~effect/Stream\";\nconst streamVariance = {\n _R: identity,\n _E: identity,\n _A: identity\n};\nconst Stream = function (channel) {\n this.channel = channel;\n};\nStream.prototype = {\n [TypeId]: streamVariance,\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n/** @internal */\nexport const fromChannel = channel => new Stream(channel);\n//# sourceMappingURL=stream.js.map","import * as Arr from \"./Array.js\";\nimport * as Cause from \"./Cause.js\";\nimport * as Channel from \"./Channel.js\";\nimport * as Clock from \"./Clock.js\";\nimport * as Duration from \"./Duration.js\";\nimport * as Effect from \"./Effect.js\";\nimport * as Exit from \"./Exit.js\";\nimport { constant, constFalse, constTrue, constVoid, dual, identity, pipe } from \"./Function.js\";\nimport * as Count from \"./internal/count.js\";\nimport * as internalStream from \"./internal/stream.js\";\nimport * as Option from \"./Option.js\";\nimport { pipeArguments } from \"./Pipeable.js\";\nimport { hasProperty } from \"./Predicate.js\";\nimport * as PubSub from \"./PubSub.js\";\nimport * as Pull from \"./Pull.js\";\nimport * as Queue from \"./Queue.js\";\nimport * as Result from \"./Result.js\";\nimport * as Scope from \"./Scope.js\";\nconst TypeId = \"~effect/Sink\";\nconst endVoid = /*#__PURE__*/Effect.succeed([void 0]);\nconst sinkVariance = {\n _A: identity,\n _In: identity,\n _L: identity,\n _E: identity,\n _R: identity\n};\nconst SinkProto = {\n [TypeId]: sinkVariance,\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n/**\n * Checks whether a value is a Sink.\n *\n * **Example** (Checking for a sink)\n *\n * ```ts import.meta.vitest\n * import { Sink } from \"effect\"\n *\n * const sink = Sink.never\n * const notStream = { data: [1, 2, 3] }\n *\n * Sink.isSink(sink) // => true\n * Sink.isSink(notStream) // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isSink = u => hasProperty(u, TypeId);\n/**\n * Creates a sink from a `Channel`.\n *\n * **When to use**\n *\n * Use to create a `Sink` from a `Channel` that processes non-empty arrays of\n * input values.\n *\n * **Example** (Using channel completion as the sink result)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Sink, Stream } from \"effect\"\n *\n * const channel = Channel.identity], never, void>().pipe(\n * Channel.drain,\n * Channel.mapDone(() => [\"consumed\"] as const)\n * )\n * const sink = Sink.fromChannel(channel)\n *\n * await Effect.runPromise(Stream.run(Stream.make(1, 2, 3), sink)) // => \"consumed\"\n * ```\n *\n * @see {@link toChannel} for converting a `Sink` back to a `Channel`\n * @category constructors\n * @since 2.0.0\n */\nexport const fromChannel = channel => fromTransform((upstream, scope) => Channel.toTransform(channel)(upstream, scope).pipe(Effect.flatMap(Effect.forever({\n disableYield: true\n})), Pull.catchDone(Effect.succeed)));\n/**\n * Creates a sink that writes its input to a Web `WritableStream`.\n *\n * **Example** (Collecting values in a Web stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Sink, Stream } from \"effect\"\n *\n * const written: Array = []\n * const sink = Sink.fromWritableStream({\n * evaluate: () => new WritableStream({\n * write(value) {\n * written.push(value)\n * }\n * }),\n * onError: (cause) => new Error(String(cause))\n * })\n *\n * await Effect.runPromise(Stream.run(Stream.make(1, 2, 3), sink))\n * written // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromWritableStream = options => fromChannel(Channel.mapDone(Channel.fromWritableStream(options), _ => [_]));\n/**\n * Creates a `Sink` from a low-level transform function.\n *\n * **Details**\n *\n * The transform receives the upstream pull of non-empty input arrays and the\n * active scope, and returns an effect that completes with the sink's `End`\n * value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromTransform = transform => {\n const self = Object.create(SinkProto);\n self.transform = transform;\n return self;\n};\n/**\n * Creates a `Channel` from a Sink.\n *\n * **Example** (Running a sink as a channel)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Sink, Stream } from \"effect\"\n *\n * const channel = Stream.toChannel(Stream.make(1, 2, 3)).pipe(\n * Channel.pipeTo(Sink.toChannel(Sink.sum))\n * )\n *\n * await Effect.runPromise(Channel.runDrain(channel)) // => [6]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const toChannel = self => Channel.fromTransform((upstream, scope) => Effect.succeed(Effect.flatMap(self.transform(upstream, scope), Cause.done)));\n/**\n * Creates a pipe-style constructor for sinks over input type `In`.\n *\n * **Details**\n *\n * The returned function exposes the sink input as a `Stream`, applies the\n * provided pipeline, and uses the final effect's success value as the sink\n * result.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = () => (...fns) => fromTransform((upstream, scope) => pipe(internalStream.fromChannel(Channel.fromPull(Effect.succeed(upstream))), ...fns, Effect.flatMap(a => Cause.done([a])), Scope.provide(scope)));\n/**\n * Creates a sink that ignores upstream input and completes from an effect that\n * already returns an `End`.\n *\n * **When to use**\n *\n * Use when you need to create a sink from an effect that returns both the sink\n * result value and optional leftovers.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromEffectEnd = effect => fromTransform(() => effect);\n/**\n * Creates a sink that ignores upstream input and completes with the success\n * value of the provided effect.\n *\n * **Details**\n *\n * If the effect fails, the sink fails with the same error.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromEffect = effect => fromEffectEnd(Effect.map(effect, a => [a]));\n/**\n * Creates a sink that offers every consumed input element to a queue.\n *\n * **Details**\n *\n * When the upstream stream ends, the sink ends the queue and completes with\n * `void`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromQueue = queue => fromTransform(upstream => upstream.pipe(Effect.flatMap(arr => Queue.offerAll(queue, arr)), Effect.forever({\n disableYield: true\n}), Pull.catchDone(_ => {\n Queue.endUnsafe(queue);\n return endVoid;\n})));\n/**\n * Creates a sink that publishes every consumed input element to a `PubSub`.\n *\n * **Details**\n *\n * The sink completes with `void` when the upstream stream ends.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromPubSub = pubsub => forEachArray(arr => PubSub.publishAll(pubsub, arr));\n/**\n * A sink that immediately ends with the specified value.\n *\n * **Example** (Succeeding with a value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Sink, Stream } from \"effect\"\n *\n * // Create a sink that always yields the same value\n * const sink = Sink.succeed(42)\n *\n * // Use it with a stream\n * const stream = Stream.make(1, 2, 3)\n * await Effect.runPromise(Stream.run(stream, sink)) // => 42\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const succeed = (a, leftovers) => fromEffectEnd(Effect.succeed([a, leftovers]));\n/**\n * A sink that immediately ends with the specified lazily evaluated value.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const sync = a => fromEffect(Effect.sync(a));\n/**\n * A sink that is created from a lazily evaluated sink.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const suspend = evaluate => fromTransform((upstream, scope) => evaluate().transform(upstream, scope));\n/**\n * A sink that always fails with the specified error.\n *\n * **Example** (Failing with an error)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Sink, Stream } from \"effect\"\n *\n * // Create a sink that always fails\n * const sink = Sink.fail(\"Sink failed\")\n *\n * // Use it with a stream\n * const stream = Stream.make(1, 2, 3)\n * await Effect.runPromiseExit(Stream.run(stream, sink)) // => Exit.fail(\"Sink failed\")\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fail = e => fromEffectEnd(Effect.fail(e));\n/**\n * A sink that always fails with the specified lazily evaluated error.\n *\n * **Example** (Failing with a lazy error)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Sink, Stream } from \"effect\"\n *\n * // Create a sink that fails with a lazy error\n * const sink = Sink.failSync(() => \"Lazy error\")\n *\n * // Use it with a stream\n * const stream = Stream.make(1, 2, 3)\n * await Effect.runPromiseExit(Stream.run(stream, sink)) // => Exit.fail(\"Lazy error\")\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failSync = evaluate => fromEffectEnd(Effect.failSync(evaluate));\n/**\n * Creates a sink halting with a specified `Cause`.\n *\n * **Example** (Failing with a cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit, Sink, Stream } from \"effect\"\n *\n * // Create a sink that fails with a specific cause\n * const sink = Sink.failCause(Cause.fail(\"Custom cause\"))\n *\n * // Use it with a stream\n * const stream = Stream.make(1, 2, 3)\n * await Effect.runPromiseExit(Stream.run(stream, sink)) // => Exit.fail(\"Custom cause\")\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failCause = cause => fromEffectEnd(Effect.failCause(cause));\n/**\n * Creates a sink halting with a specified lazily evaluated `Cause`.\n *\n * **Example** (Failing with a lazy cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit, Sink, Stream } from \"effect\"\n *\n * // Create a sink that fails with a lazy cause\n * const sink = Sink.failCauseSync(() => Cause.fail(\"Lazy cause\"))\n *\n * // Use it with a stream\n * const stream = Stream.make(1, 2, 3)\n * await Effect.runPromiseExit(Stream.run(stream, sink)) // => Exit.fail(\"Lazy cause\")\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failCauseSync = evaluate => fromEffectEnd(Effect.failCauseSync(evaluate));\n/**\n * Creates a sink halting with a specified defect.\n *\n * **Example** (Dying with a defect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Sink, Stream } from \"effect\"\n *\n * // Create a sink that dies with a defect\n * const sink = Sink.die(\"Defect error\")\n *\n * // Use it with a stream\n * const stream = Stream.make(1, 2, 3)\n * await Effect.runPromiseExit(Stream.run(stream, sink)) // => Exit.die(\"Defect error\")\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const die = defect => fromEffectEnd(Effect.die(defect));\n/**\n * A sink that never completes.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const never = /*#__PURE__*/fromEffectEnd(Effect.never);\n/**\n * Drops leftovers produced by a sink.\n *\n * **Details**\n *\n * The sink result is preserved, but any leftover elements are discarded\n * instead of being returned to downstream sink composition. This does not\n * continue pulling additional elements from the upstream stream.\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const ignoreLeftover = self => mapEnd(self, ([a]) => [a]);\n/**\n * Consumes and ignores all stream inputs.\n *\n * **When to use**\n *\n * Use to consume all upstream input and complete with void when the input\n * values and any aggregate result are not needed.\n *\n * @see {@link count} for consuming all input while returning the number of elements\n * @see {@link forEach} for consuming all input while running an effect for each element\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const drain = /*#__PURE__*/fromTransform(upstream => Pull.catchDone(Effect.forever(upstream, {\n disableYield: true\n}), () => endVoid));\n/**\n * A sink that folds its inputs with the provided function, termination\n * predicate and initial state.\n *\n * **When to use**\n *\n * Use to accumulate stream input element by element with an effectful step and\n * stop based on the accumulated state.\n *\n * **Details**\n *\n * The initial state is evaluated lazily. Each input element is folded with the\n * effectful function, and the sink continues while `contFn` returns `true`. If\n * the sink stops in the middle of a pulled array, the remaining elements from\n * that array are returned as leftovers.\n *\n * @see {@link foldArray} for folding each pulled non-empty input array at once\n * @see {@link foldUntil} for folding until a fixed maximum number of elements is consumed\n *\n * @category folding\n * @since 2.0.0\n */\nexport const fold = (s, contFn, f) => fromTransform(upstream => {\n let state = s();\n return Effect.gen(function* () {\n while (true) {\n const arr = yield* upstream;\n for (let i = 0; i < arr.length; i++) {\n state = yield* f(state, arr[i]);\n if (contFn(state)) continue;\n return [state, i + 1 < arr.length ? arr.slice(i + 1) : undefined];\n }\n }\n }).pipe(Pull.catchDone(() => Effect.succeed([state])));\n});\n/**\n * Folds non-empty input arrays into state with an effectful function.\n *\n * **When to use**\n *\n * Use to update state with an effectful function once per pulled non-empty\n * input array when batch-level processing is the natural unit.\n *\n * **Details**\n *\n * The initial state is evaluated lazily. After each pulled array is folded,\n * the sink continues while `contFn` returns `true`; otherwise it completes\n * with the current state.\n *\n * @see {@link fold} for folding element by element and returning leftovers when stopping mid-array\n * @see {@link reduceWhileArrayEffect} for array-level effectful reducing that checks the predicate before consuming input\n *\n * @category folding\n * @since 4.0.0\n */\nexport const foldArray = (s, contFn, f) => fromTransform(upstream => {\n let state = s();\n return Effect.gen(function* () {\n while (true) {\n const arr = yield* upstream;\n state = yield* f(state, arr);\n if (contFn(state)) continue;\n return [state];\n }\n }).pipe(Pull.catchDone(() => Effect.succeed([state])));\n});\n/**\n * Folds input elements into state until the specified maximum number of\n * elements has been consumed or the upstream stream ends.\n *\n * **Details**\n *\n * Finite fractional values of `max` are rounded down. If `max` is `NaN` or\n * non-positive, the sink completes with the initial state without consuming\n * input.\n *\n * If the sink stops in the middle of a pulled array, the remaining elements\n * from that array are returned as leftovers.\n *\n * @category folding\n * @since 2.0.0\n */\nexport const foldUntil = (s, max, f) => {\n const count = Count.normalize(max);\n if (count === 0) return sync(s);\n return fold(() => [s(), 0], tuple => tuple[1] < count, ([output, consumed], input) => Effect.map(f(output, input), s => [s, consumed + 1])).pipe(map(tuple => tuple[0]));\n};\n/**\n * A sink that returns whether all elements satisfy the specified predicate.\n *\n * **When to use**\n *\n * Use to reduce a stream to a boolean that is true only when every input\n * satisfies a pure predicate.\n *\n * @see {@link some} for the dual any-match check\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const every = predicate => fold(constTrue, identity, (_, a) => Effect.succeed(predicate(a)));\n/**\n * A sink that returns whether an element satisfies the specified predicate.\n *\n * **When to use**\n *\n * Use to reduce a stream to a boolean that is true when any input satisfies a\n * pure predicate.\n *\n * @see {@link every} for the all-match check\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const some = predicate => fold(constFalse, b => !b, (_, a) => Effect.succeed(predicate(a)));\n/**\n * Transforms this sink's result.\n *\n * **When to use**\n *\n * Use to compute a new result from the original sink result while preserving\n * the sink's input consumption behavior.\n *\n * **Details**\n *\n * The transformed sink preserves the original sink's input type, leftovers,\n * errors, and requirements.\n *\n * @see {@link mapEffect} for effectful result transformations\n * @see {@link as} for replacing the result with a constant value\n * @see {@link mapEnd} for transforming both the result and leftovers\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, f) => mapEnd(self, ([a, l]) => [f(a), l]));\n/**\n * Sets the sink's result to a constant value.\n *\n * **When to use**\n *\n * Use to keep a sink's input consumption, errors, requirements, and leftovers\n * while replacing only its result with a known value.\n *\n * @see {@link map} for computing the replacement from the original result\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const as = /*#__PURE__*/dual(2, (self, a2) => map(self, () => a2));\n/**\n * Transforms this sink's input elements.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapInput = /*#__PURE__*/dual(2, (self, f) => mapInputArray(self, Arr.map(f)));\n/**\n * Transforms this sink's input elements effectfully.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapInputEffect = /*#__PURE__*/dual(2, (self, f) => mapInputArrayEffect(self, Effect.forEach(f)));\n/**\n * Transforms each non-empty array of upstream input before it is fed to this\n * sink.\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapInputArray = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => self.transform(Effect.map(upstream, f), scope)));\n/**\n * Transforms each non-empty array of upstream input effectfully before it is\n * fed to this sink.\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapInputArrayEffect = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => self.transform(Effect.flatMap(upstream, f), scope)));\n/**\n * Transforms the full `End` produced by this sink.\n *\n * **Details**\n *\n * This can change both the result value and the optional leftovers.\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapEnd = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => Effect.map(self.transform(upstream, scope), f)));\nconst transformEffect = (self, f) => fromTransform((upstream, scope) => f(self.transform(upstream, scope)));\n/**\n * Transforms the full `End` produced by this sink effectfully.\n *\n * **Details**\n *\n * This can change both the result value and the optional leftovers, and the\n * transformation can fail or require services.\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapEffectEnd = /*#__PURE__*/dual(2, (self, f) => transformEffect(self, Effect.flatMap(f)));\n/**\n * Transforms this sink's result effectfully.\n *\n * **When to use**\n *\n * Use when you need a sink result transformation that is effectful, can fail,\n * or requires services.\n *\n * **Details**\n *\n * The transformed sink preserves the original sink's input consumption and\n * leftovers while adding the errors and requirements of the transformation.\n *\n * @see {@link map} for pure result transformations\n * @see {@link mapEffectEnd} for effectfully transforming both the result and leftovers\n * @see {@link flatMap} for continuing with another sink based on the result\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapEffect = /*#__PURE__*/dual(2, (self, f) => mapEffectEnd(self, ([a, l]) => Effect.map(f(a), a2 => [a2, l])));\n/**\n * Transforms the errors emitted by this sink using `f`.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapError = /*#__PURE__*/dual(2, (self, f) => transformEffect(self, Effect.mapError(f)));\n/**\n * Transforms the leftovers emitted by this sink using `f`.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapLeftover = /*#__PURE__*/dual(2, (self, f) => mapEnd(self, ([a, l]) => [a, l && Arr.map(l, f)]));\n/**\n * Collects up to `n` input elements into an array.\n *\n * **Details**\n *\n * Finite fractional values of `n` are rounded down. If `n` is `NaN` or\n * non-positive, the sink completes with an empty array. If more elements are\n * pulled than needed, the remaining elements from the same array are returned\n * as leftovers.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const take = n => {\n const count = Count.normalize(n);\n return fromTransform(upstream => {\n const taken = [];\n if (count === 0) {\n return Effect.succeed([taken]);\n }\n let leftover = undefined;\n return upstream.pipe(Effect.flatMap(arr => {\n if (taken.length + arr.length <= count) {\n taken.push(...arr);\n if (taken.length === count) {\n return Cause.done();\n }\n return Effect.void;\n }\n for (let i = 0; i < arr.length; i++) {\n taken.push(arr[i]);\n if (taken.length === count) {\n if (i + 1 < arr.length) {\n leftover = arr.slice(i + 1);\n }\n return Cause.done();\n }\n }\n return Effect.void;\n }), Effect.forever({\n disableYield: true\n }), Pull.catchDone(() => Effect.succeed([taken, leftover])));\n });\n};\n/**\n * Runs this sink until it yields a result, then uses that result to create\n * another sink from the provided function which will continue to run until it\n * yields a result.\n *\n * **When to use**\n *\n * Use to compose sinks when the next sink depends on the result produced by the\n * previous sink.\n *\n * **Details**\n *\n * Leftovers from the first sink are fed to the sink returned by `f` before more\n * upstream input is pulled.\n *\n * @see {@link map} for transforming the result without switching sinks\n * @see {@link mapEffect} for effectfully transforming the result without switching sinks\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const flatMap = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => {\n let upstreamDone = false;\n const pull = Effect.catchCause(upstream, cause => {\n upstreamDone = true;\n return Effect.failCause(cause);\n });\n return Effect.flatMap(self.transform(pull, scope), ([a, leftover]) => f(a).transform(Effect.suspend(() => {\n if (leftover) {\n const arr = leftover;\n leftover = undefined;\n return Effect.succeed(arr);\n } else if (upstreamDone) {\n return Cause.done();\n }\n return upstream;\n }), scope).pipe(Effect.map(end => {\n if (!leftover) {\n return end;\n }\n return [end[0], end[1] ? [...end[1], ...leftover] : leftover];\n })));\n}));\n/**\n * A sink that reduces input elements from the provided `initial` state with\n * `f` while the specified `predicate` returns `true`.\n *\n * @category folding\n * @since 4.0.0\n */\nexport const reduceWhile = (initial, predicate, f) => fromTransform(upstream => {\n let state = initial();\n let leftover = undefined;\n if (!predicate(state)) {\n return Effect.succeed([state]);\n }\n return upstream.pipe(Effect.flatMap(arr => {\n for (let i = 0; i < arr.length; i++) {\n state = f(state, arr[i]);\n if (!predicate(state)) {\n if (i + 1 < arr.length) {\n leftover = arr.slice(i + 1);\n }\n return Cause.done();\n }\n }\n return Effect.void;\n }), Effect.forever({\n disableYield: true\n }), Pull.catchDone(() => Effect.succeed([state, leftover])));\n});\n/**\n * A sink that effectfully reduces input elements from the provided `initial`\n * state with `f` while the specified `predicate` returns `true`.\n *\n * @category folding\n * @since 4.0.0\n */\nexport const reduceWhileEffect = (initial, predicate, f) => fromTransform(upstream => {\n let state = initial();\n let leftover = undefined;\n if (!predicate(state)) {\n return Effect.succeed([state]);\n }\n return upstream.pipe(Effect.flatMap(arr => {\n let i = 0;\n return Effect.whileLoop({\n while: () => i < arr.length,\n body: constant(Effect.flatMap(Effect.suspend(() => f(state, arr[i++])), s => {\n state = s;\n if (!predicate(state)) {\n if (i < arr.length) {\n leftover = arr.slice(i);\n }\n return Cause.done();\n }\n return Effect.void;\n })),\n step: constVoid\n });\n }), Effect.forever({\n disableYield: true\n }), Pull.catchDone(() => Effect.succeed([state, leftover])));\n});\n/**\n * A sink that reduces non-empty input arrays from the provided `initial` state\n * with `f` while the specified `predicate` returns `true`.\n *\n * @category folding\n * @since 4.0.0\n */\nexport const reduceWhileArray = (initial, contFn, f) => fromTransform(upstream => {\n let state = initial();\n if (!contFn(state)) {\n return Effect.succeed([state]);\n }\n return upstream.pipe(Effect.flatMap(arr => {\n state = f(state, arr);\n if (!contFn(state)) {\n return Cause.done();\n }\n return Effect.void;\n }), Effect.forever({\n disableYield: true\n }), Pull.catchDone(() => Effect.succeed([state])));\n});\n/**\n * A sink that effectfully reduces non-empty input arrays from the provided\n * `initial` state with `f` while the specified `predicate` returns `true`.\n *\n * @category folding\n * @since 4.0.0\n */\nexport const reduceWhileArrayEffect = (initial, predicate, f) => fromTransform(upstream => {\n let state = initial();\n if (!predicate(state)) {\n return Effect.succeed([state]);\n }\n return upstream.pipe(Effect.flatMap(arr => f(state, arr)), Effect.flatMap(s => {\n state = s;\n if (!predicate(state)) {\n return Cause.done();\n }\n return Effect.void;\n }), Effect.forever({\n disableYield: true\n }), Pull.catchDone(() => Effect.succeed([state])));\n});\n/**\n * A sink that reduces its inputs using the provided function `f` starting from\n * the provided `initial` state.\n *\n * @category folding\n * @since 4.0.0\n */\nexport const reduce = (initial, f) => reduceArray(initial, (s, arr) => {\n for (let i = 0; i < arr.length; i++) {\n s = f(s, arr[i]);\n }\n return s;\n});\n/**\n * A sink that reduces its inputs using the provided function `f` starting from\n * the specified `initial` state.\n *\n * @category folding\n * @since 4.0.0\n */\nexport const reduceArray = (initial, f) => fromTransform(upstream => {\n let state = initial();\n return upstream.pipe(Effect.flatMap(arr => {\n state = f(state, arr);\n return Effect.void;\n }), Effect.forever({\n disableYield: true\n }), Pull.catchDone(() => Effect.succeed([state])));\n});\n/**\n * A sink that reduces its inputs using the provided effectful function `f`\n * starting from the specified `initial` state.\n *\n * @category folding\n * @since 4.0.0\n */\nexport const reduceEffect = (initial, f) => reduceWhileEffect(initial, constTrue, f);\nconst head_ = /*#__PURE__*/reduceWhile(Option.none, Option.isNone, (_, in_) => Option.some(in_));\n/**\n * Creates a sink containing the first value.\n *\n * **Details**\n *\n * Returns `Option.some(first)` for non-empty input, or `Option.none` when the\n * upstream ends without input. The first element is consumed; later elements\n * from the same pulled array are emitted as leftovers.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const head = () => head_;\nconst last_ = /*#__PURE__*/reduceArray(Option.none, (_, arr) => Arr.last(arr));\n/**\n * Creates a sink containing the last value.\n *\n * **When to use**\n *\n * Use when you need to consume all upstream input and keep only the final\n * element.\n *\n * **Details**\n *\n * Returns `Option.some(last)` with the final input value, or `Option.none` when\n * the upstream ends without input.\n *\n * **Gotchas**\n *\n * This sink produces a result only when the upstream ends, so it does not\n * complete for a stream that does not end.\n *\n * @see {@link head} for taking the first input value instead\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const last = () => last_;\n/**\n * Creates a sink containing the first value matched by a synchronous predicate.\n *\n * **When to use**\n *\n * Use to scan stream input until the first matching element is found and return\n * that element as an `Option`.\n *\n * **Details**\n *\n * Returns `Option.none` if the upstream stream ends before a match is found.\n * Refinement predicates narrow the returned value type. The matching input is\n * consumed; any later elements from the same pulled array are returned as\n * leftovers.\n *\n * @see {@link findEffect} for an effectful predicate that can fail or require services\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const find = predicate => reduceWhile(Option.none, Option.isNone, (acc, in_) => predicate(in_) ? Option.some(in_) : acc);\n/**\n * Creates a sink containing the first value matched by an effectful predicate.\n *\n * **When to use**\n *\n * Use when you need to run effects, fail, or use services while searching for\n * the first matching input.\n *\n * **Details**\n *\n * Returns `Option.some` with the first input whose predicate result is `true`,\n * or `Option.none` if the upstream stream ends first. If the predicate effect\n * fails, the sink fails with the same error.\n *\n * @see {@link find} for the synchronous predicate variant\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const findEffect = predicate => reduceWhileEffect(Option.none, Option.isNone, (acc, in_) => Effect.map(predicate(in_), b => b ? Option.some(in_) : acc));\n/**\n * Creates a sink which sums up its inputs.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const sum = /*#__PURE__*/reduceArray(() => 0, (s, arr) => {\n for (let i = 0; i < arr.length; i++) {\n s += arr[i];\n }\n return s;\n});\n/**\n * A sink that counts the number of elements fed to it.\n *\n * **When to use**\n *\n * Use to consume input and return only the number of elements received.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const count = /*#__PURE__*/reduceArray(() => 0, (s, arr) => s + arr.length);\n/**\n * Accumulates incoming elements into an array.\n *\n * **When to use**\n *\n * Use when you need a sink result containing all upstream input elements.\n *\n * @see {@link take} for collecting only a fixed number of input elements\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const collect = () => reduceArray(Arr.empty, (s, arr) => {\n s.push(...arr);\n return s;\n});\n/**\n * Collects the longest input prefix whose elements satisfy the predicate or\n * refinement.\n *\n * **Details**\n *\n * The first failing input is consumed and excluded from the result. Any later\n * elements from the same pulled array are returned as leftovers.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const takeWhile = predicate => fromTransform(upstream => {\n const out = Arr.empty();\n return upstream.pipe(Effect.flatMap(arr => {\n for (let i = 0; i < arr.length; i++) {\n if (!predicate(arr[i])) {\n const leftover = i + 1 < arr.length ? arr.slice(i + 1) : undefined;\n return Cause.done([out, leftover]);\n }\n out.push(arr[i]);\n }\n return Effect.void;\n }), Effect.forever({\n disableYield: true\n }), Pull.catchDone(end => Effect.succeed(end ?? [out])));\n});\n/**\n * Applies a `Filter` to input elements while it succeeds, collecting each\n * successful output.\n *\n * **Details**\n *\n * The first input for which the filter fails is consumed and excluded from the\n * result. Any later elements from the same pulled array are returned as\n * leftovers.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const takeWhileFilter = filter => fromTransform(upstream => {\n const out = Arr.empty();\n return upstream.pipe(Effect.flatMap(arr => {\n for (let i = 0; i < arr.length; i++) {\n const result = filter(arr[i]);\n if (Result.isFailure(result)) {\n const leftover = i + 1 < arr.length ? arr.slice(i + 1) : undefined;\n return Cause.done([out, leftover]);\n }\n out.push(result.success);\n }\n return Effect.void;\n }), Effect.forever({\n disableYield: true\n }), Pull.catchDone(end => Effect.succeed(end ?? [out])));\n});\n/**\n * Collects input elements effectfully while the predicate succeeds.\n *\n * **Details**\n *\n * The first input for which the predicate returns `false` is consumed and\n * excluded from the result. Any later elements from the same pulled array are\n * returned as leftovers.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const takeWhileEffect = predicate => fromTransform(upstream => {\n const out = Arr.empty();\n let leftover = undefined;\n return upstream.pipe(Effect.flatMap(arr => {\n let i = 0;\n return Effect.whileLoop({\n while: () => i < arr.length,\n body: constant(Effect.flatMap(Effect.suspend(() => {\n const input = arr[i++];\n return Effect.map(predicate(input), passes => [input, passes]);\n }), ([input, passes]) => {\n if (!passes) {\n if (i < arr.length) {\n leftover = arr.slice(i);\n }\n return Cause.done();\n }\n out.push(input);\n return Effect.void;\n })),\n step: constVoid\n });\n }), Effect.forever({\n disableYield: true\n }), Pull.catchDone(() => Effect.succeed([out, leftover])));\n});\n/**\n * Applies a `FilterEffect` to input elements effectfully while it succeeds,\n * collecting each successful output.\n *\n * **Details**\n *\n * The first input for which the filter fails is consumed and excluded from the\n * result. Any later elements from the same pulled array are returned as\n * leftovers.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const takeWhileFilterEffect = filter => fromTransform(upstream => {\n const out = Arr.empty();\n let leftover = undefined;\n return upstream.pipe(Effect.flatMap(arr => {\n let i = 0;\n return Effect.whileLoop({\n while: () => i < arr.length,\n body: constant(Effect.flatMap(Effect.suspend(() => filter(arr[i++])), result => {\n if (Result.isFailure(result)) {\n if (i < arr.length) {\n leftover = arr.slice(i);\n }\n return Cause.done();\n }\n out.push(result.success);\n return Effect.void;\n })),\n step: constVoid\n });\n }), Effect.forever({\n disableYield: true\n }), Pull.catchDone(() => Effect.succeed([out, leftover])));\n});\n/**\n * Collects input elements until the predicate returns `true`, including the\n * matching element in the result.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const takeUntil = predicate => suspend(() => {\n let done = false;\n return takeWhile(i => {\n if (done) return false;\n done = predicate(i);\n return true;\n });\n});\n/**\n * Collects input elements effectfully until the predicate returns `true`,\n * including the matching element in the result.\n *\n * **Details**\n *\n * If the predicate effect fails, the sink fails with the same error.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const takeUntilEffect = predicate => suspend(() => {\n let done = false;\n return takeWhileEffect(input => {\n if (done) {\n return Effect.succeed(false);\n }\n return Effect.map(predicate(input), b => {\n done = b;\n return true;\n });\n });\n});\n/**\n * A sink that executes the provided effectful function for every item fed\n * to it.\n *\n * **Example** (Running effects for each item)\n *\n * ```ts import.meta.vitest\n * import { Effect, Sink, Stream } from \"effect\"\n *\n * const processed: Array = []\n * const sink = Sink.forEach((item: number) => Effect.sync(() => processed.push(item)))\n *\n * // Use it with a stream\n * const stream = Stream.make(1, 2, 3)\n * await Effect.runPromise(Stream.run(stream, sink))\n * processed // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const forEach = f => forEachArray(Effect.forEach(_ => f(_), {\n discard: true\n}));\n/**\n * A sink that executes the provided effectful function for every Chunk fed\n * to it.\n *\n * **Example** (Running effects for each chunk)\n *\n * ```ts import.meta.vitest\n * import { Effect, Sink, Stream } from \"effect\"\n *\n * const processed: Array> = []\n * const sink = Sink.forEachArray((chunk: ReadonlyArray) => Effect.sync(() => processed.push([...chunk])))\n *\n * // Use it with a stream\n * const stream = Stream.make(1, 2, 3, 4, 5)\n * await Effect.runPromise(Stream.run(stream, sink))\n * processed // => [[1, 2, 3, 4, 5]]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const forEachArray = f => fromTransform(upstream => upstream.pipe(Effect.flatMap(f), Effect.forever({\n disableYield: true\n}), Pull.catchDone(() => endVoid)));\n/**\n * Runs an effectful function for each input element while it returns `true`.\n *\n * **Details**\n *\n * The sink stops consuming input when the function returns `false` or when the\n * upstream stream ends, and completes with `void`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const forEachWhile = f => forEachWhileArray(Effect.fnUntraced(function* (input) {\n for (let i = 0; i < input.length; i++) {\n const cont = yield* f(input[i]);\n if (!cont) return false;\n }\n return true;\n}));\n/**\n * Runs an effectful function for each non-empty input array while it returns\n * `true`.\n *\n * **Details**\n *\n * The sink stops consuming input when the function returns `false` or when the\n * upstream stream ends, and completes with `void`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const forEachWhileArray = f => fromTransform(upstream => upstream.pipe(Effect.flatMap(f), Effect.flatMap(cont => cont ? Effect.void : Cause.done()), Effect.forever({\n disableYield: true\n}), Pull.catchDone(() => endVoid)));\n/**\n * Creates a sink produced from a scoped effect.\n *\n * **Example** (Unwrapping a sink effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Sink, Stream } from \"effect\"\n *\n * // Create a sink from an effect that produces a sink\n * const processed: Array = []\n * const sinkEffect = Effect.succeed(\n * Sink.forEach((item: number) => Effect.sync(() => processed.push(item)))\n * )\n * const sink = Sink.unwrap(sinkEffect)\n *\n * // Use it with a stream\n * const stream = Stream.make(1, 2, 3)\n * await Effect.runPromise(Stream.run(stream, sink))\n * processed // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const unwrap = effect => fromChannel(Channel.unwrap(Effect.map(effect, toChannel)));\n/**\n * Runs a summary effect when the sink starts and again when it completes.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const summarized = /*#__PURE__*/dual(3, (self, summary, f) => fromTransform(Effect.fnUntraced(function* (upstream, scope) {\n const start = yield* summary;\n const [done, leftover] = yield* self.transform(upstream, scope);\n const end = yield* summary;\n return [[done, f(start, end)], leftover];\n})));\n/**\n * Returns the sink that executes this one and times its execution.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const withDuration = self => summarized(self, Clock.monotonicTimeNanos, (start, end) => Duration.nanos(end - start));\n/**\n * A sink that drains all input and returns the elapsed duration.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const timed = /*#__PURE__*/map(/*#__PURE__*/withDuration(drain), ([, duration]) => duration);\n/**\n * Provides a `Context` to this sink.\n *\n * **Details**\n *\n * Services contained in the provided context are removed from the sink's\n * service requirements.\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const provideContext = /*#__PURE__*/dual(2, (self, context) => fromTransform((upstream, scope) => self.transform(upstream, scope).pipe(Effect.provideContext(context))));\n/**\n * Provides a single service implementation to this sink.\n *\n * **Details**\n *\n * The service identified by `key` is removed from the sink's service\n * requirements.\n *\n * @category providing services\n * @since 4.0.0\n */\nexport const provideService = /*#__PURE__*/dual(3, (self, key, value) => fromTransform((upstream, scope) => self.transform(upstream, scope).pipe(Effect.provideService(key, value))));\n/**\n * Runs a fallback sink if this sink fails with a typed error.\n *\n * **Details**\n *\n * The fallback is built from the error and continues consuming from the same\n * upstream stream. If the upstream stream had already ended, the fallback sees\n * the upstream end instead.\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const orElse = /*#__PURE__*/dual(2, (self, f) => fromTransform((upstream, scope) => {\n let upstreamDone = false;\n const pull = Effect.catchCause(upstream, cause => {\n upstreamDone = true;\n return Effect.failCause(cause);\n });\n return Effect.catch(self.transform(pull, scope), error => f(error).transform(Effect.suspend(() => {\n if (upstreamDone) {\n return Cause.done();\n }\n return upstream;\n }), scope));\n}));\n/**\n * Handles failures from this sink by inspecting the full `Cause`.\n *\n * **When to use**\n *\n * Use to recover from a sink failure based on the full `Cause` instead of only\n * the typed error value.\n *\n * **Details**\n *\n * When this sink fails, the handler effect is run and its success value\n * becomes the sink result. If the handler fails, the returned sink fails with\n * that error.\n *\n * @see {@link catch_ catch} for recovering from typed errors only\n * @see {@link orElse} for recovering by switching to another sink\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchCause = /*#__PURE__*/dual(2, (self, f) => transformEffect(self, Effect.catchCause(cause => Effect.map(f(cause), a2 => [a2]))));\nconst catch_ = /*#__PURE__*/dual(2, (self, f) => transformEffect(self, Effect.catch(error => Effect.map(f(error), a2 => [a2]))));\nexport {\n/**\n * Handles typed errors from this sink with an effectful fallback value.\n *\n * **When to use**\n *\n * Use to recover from a typed sink failure by producing the replacement\n * result with an `Effect`.\n *\n * @see {@link catchCause} for recovering from the full failure cause\n * @see {@link orElse} for recovering by switching to another sink\n *\n * @category error handling\n * @since 4.0.0\n */\ncatch_ as catch };\n/**\n * Runs an effect after this sink completes, fails, or is interrupted.\n *\n * **Details**\n *\n * The effect receives the sink's `Exit` for the result value. The original\n * sink result and leftovers are preserved unless the finalizer itself fails.\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const onExit = /*#__PURE__*/dual(2, (self, f) => transformEffect(self, Effect.onExit(exit => f(Exit.map(exit, ([a]) => a)))));\n/**\n * Runs a finalizer effect after this sink completes, fails, or is interrupted.\n *\n * **Details**\n *\n * The original sink result and leftovers are preserved unless the finalizer\n * itself fails.\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const ensuring = /*#__PURE__*/dual(2, (self, effect) => onExit(self, () => effect));\n//# sourceMappingURL=Sink.js.map","import * as Context from \"../Context.js\";\nimport * as Duration from \"../Duration.js\";\nimport * as Effect from \"../Effect.js\";\nimport * as Exit from \"../Exit.js\";\nimport * as Fiber from \"../Fiber.js\";\nimport { identity } from \"../Function.js\";\nimport { pipeArguments } from \"../Pipeable.js\";\nimport * as Scope from \"../Scope.js\";\nimport * as Semaphore from \"../Semaphore.js\";\nconst TypeId = \"~effect/RcRef\";\nconst stateEmpty = {\n _tag: \"Empty\"\n};\nconst stateClosed = {\n _tag: \"Closed\"\n};\nconst variance = {\n _A: identity,\n _E: identity\n};\nclass RcRefImpl {\n [TypeId] = variance;\n pipe() {\n return pipeArguments(this, arguments);\n }\n state = stateEmpty;\n semaphore = /*#__PURE__*/Semaphore.makeUnsafe(1);\n acquire;\n context;\n scope;\n idleTimeToLive;\n constructor(acquire, context, scope, idleTimeToLive) {\n this.acquire = acquire;\n this.context = context;\n this.scope = scope;\n this.idleTimeToLive = idleTimeToLive;\n }\n}\n/** @internal */\nexport const make = options => Effect.withFiber(fiber => {\n const context = fiber.context;\n const scope = Context.get(context, Scope.Scope);\n const ref = new RcRefImpl(options.acquire, context, scope, options.idleTimeToLive ? Duration.fromInputUnsafe(options.idleTimeToLive) : undefined);\n return Effect.as(Scope.addFinalizerExit(scope, () => {\n const close = ref.state._tag === \"Acquired\" ? Scope.close(ref.state.scope, Exit.void) : Effect.void;\n ref.state = stateClosed;\n return close;\n }), ref);\n});\nconst getState = self => Effect.uninterruptibleMask(function loop(restore) {\n switch (self.state._tag) {\n case \"Closed\":\n {\n return Effect.interrupt;\n }\n case \"Acquired\":\n {\n self.state.refCount++;\n return self.state.fiber ? Effect.as(Fiber.interrupt(self.state.fiber), self.state) : Effect.succeed(self.state);\n }\n case \"Empty\":\n {\n const scope = Scope.makeUnsafe();\n return self.semaphore.withPermit(Effect.suspend(() => {\n if (self.state._tag !== \"Empty\") {\n return loop(restore);\n }\n return restore(Effect.provideContext(self.acquire, Context.add(self.context, Scope.Scope, scope))).pipe(Effect.flatMap(value => {\n if (self.state._tag === \"Closed\") {\n return Effect.interrupt;\n }\n const state = {\n _tag: \"Acquired\",\n value,\n scope,\n fiber: undefined,\n refCount: 1,\n invalidated: false\n };\n self.state = state;\n return Effect.succeed(state);\n }), Effect.onExit(exit => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void));\n }));\n }\n }\n});\n/** @internal */\nexport const get = /*#__PURE__*/Effect.fnUntraced(function* (self_) {\n const self = self_;\n const state = yield* getState(self);\n const scope = yield* Effect.scope;\n const isFinite = self.idleTimeToLive !== undefined && Duration.isFinite(self.idleTimeToLive);\n yield* Scope.addFinalizerExit(scope, () => {\n state.refCount--;\n if (state.refCount > 0) {\n return Effect.void;\n }\n if (self.idleTimeToLive === undefined || state.invalidated) {\n if (self.state === state) {\n self.state = stateEmpty;\n }\n return Scope.close(state.scope, Exit.void);\n } else if (!isFinite) {\n return Effect.void;\n }\n state.fiber = Effect.sleep(self.idleTimeToLive).pipe(Effect.flatMap(() => {\n if (self.state === state && state.refCount === 0) {\n self.state = stateEmpty;\n return Scope.close(state.scope, Exit.void);\n }\n return Effect.void;\n }), Effect.ensuring(Effect.sync(() => {\n state.fiber = undefined;\n })), Effect.runForkWith(self.context), Fiber.runIn(self.scope));\n return Effect.void;\n });\n return state.value;\n});\n/** @internal */\nexport const invalidate = self_ => {\n const self = self_;\n return Effect.uninterruptible(Effect.suspend(() => {\n if (self.state._tag !== \"Acquired\") {\n return Effect.void;\n }\n const state = self.state;\n self.state = stateEmpty;\n state.invalidated = true;\n if (state.refCount > 0) {\n return Effect.void;\n }\n state.fiber?.interruptUnsafe();\n return Scope.close(state.scope, Exit.void);\n }));\n};\n//# sourceMappingURL=rcRef.js.map","import * as internal from \"./internal/rcRef.js\";\nconst TypeId = \"~effect/RcRef\";\n/**\n * Creates an `RcRef` from an acquire effect.\n *\n * **When to use**\n *\n * Use to create a lazily acquired, reference-counted resource from an acquire\n * effect.\n *\n * **Details**\n *\n * The resource is acquired lazily on the first `get` and shared by subsequent\n * gets while it remains cached. Each `get` adds a reference to the current\n * `Scope`. When the last reference is released, the resource is closed\n * immediately by default, or after `idleTimeToLive` when that option is\n * provided.\n *\n * **Example** (Creating a reference-counted resource)\n *\n * ```ts import.meta.vitest\n * import { Effect, RcRef } from \"effect\"\n *\n * const events: Array = []\n *\n * const program = Effect.gen(function*() {\n * const ref = yield* RcRef.make({\n * acquire: Effect.acquireRelease(\n * Effect.succeed(\"foo\"),\n * () => Effect.sync(() => events.push(\"released foo\"))\n * )\n * })\n *\n * // will only acquire the resource once, and release it\n * // when the scope is closed\n * yield* RcRef.get(ref).pipe(\n * Effect.andThen(RcRef.get(ref)),\n * Effect.scoped\n * )\n * })\n *\n * await Effect.runPromise(Effect.scoped(program))\n * events // => [\"released foo\"]\n * ```\n *\n * @category constructors\n * @since 3.5.0\n */\nexport const make = internal.make;\n/**\n * Gets the value from an `RcRef`, acquiring it first if needed.\n *\n * **When to use**\n *\n * Use to borrow the current resource within a `Scope`, acquiring it first if\n * necessary.\n *\n * **Details**\n *\n * The reference count is incremented for the current `Scope`, and a release\n * finalizer is added to that scope. When the current scope closes, the\n * reference is released; the resource is closed when the final reference is\n * released, subject to any configured idle time-to-live.\n *\n * **Example** (Sharing one acquired value)\n *\n * ```ts import.meta.vitest\n * import { Effect, RcRef } from \"effect\"\n *\n * const events: Array = []\n *\n * const program = Effect.gen(function*() {\n * // Create an RcRef with a resource\n * const ref = yield* RcRef.make({\n * acquire: Effect.acquireRelease(\n * Effect.succeed(\"shared resource\"),\n * (resource) => Effect.sync(() => events.push(`released ${resource}`))\n * )\n * })\n *\n * // Get the value from the RcRef\n * const value1 = yield* RcRef.get(ref)\n * const value2 = yield* RcRef.get(ref)\n *\n * return [value1 === value2, events] as const\n * })\n *\n * await Effect.runPromise(Effect.scoped(program)) // => [true, [\"released shared resource\"]]\n * ```\n *\n * @category combinators\n * @since 3.5.0\n */\nexport const get = internal.get;\n/**\n * Invalidates the currently cached resource, if one has been acquired.\n *\n * **When to use**\n *\n * Use to force future `RcRef.get` calls to acquire a fresh resource when the\n * currently cached resource should no longer be reused.\n *\n * **Details**\n *\n * After invalidation, the next `get` acquires a fresh resource.\n *\n * **Gotchas**\n *\n * Invalidation does not revoke resources already borrowed by active scopes;\n * those remain usable until their scopes close.\n *\n * @see {@link get} for acquiring the current cached resource or the fresh resource after invalidation\n *\n * @category combinators\n * @since 3.19.6\n */\nexport const invalidate = internal.invalidate;\n//# sourceMappingURL=RcRef.js.map","/**\n * Describes effectful sources that emit values over time.\n *\n * A `Stream` can emit many `A` values, fail with `E`, and require\n * services `R` while it is being consumed. Streams are useful for data that is\n * pulled in steps, such as values from collections, queues, pubsubs, schedules,\n * callbacks, async iterables, or platform streams. The APIs here cover the full\n * stream lifecycle: create a stream, transform or combine it, control buffering\n * and timing, handle failures, and finally consume it.\n *\n * @since 2.0.0\n */\n// @effect-diagnostics returnEffectInGen:off\nimport * as Arr from \"./Array.js\";\nimport * as ByteSize from \"./ByteSize.js\";\nimport * as Cause from \"./Cause.js\";\nimport * as Channel from \"./Channel.js\";\nimport { Clock } from \"./Clock.js\";\nimport * as Context from \"./Context.js\";\nimport * as Duration from \"./Duration.js\";\nimport * as Effect from \"./Effect.js\";\nimport * as Equal from \"./Equal.js\";\nimport * as ExecutionPlan from \"./ExecutionPlan.js\";\nimport * as Exit from \"./Exit.js\";\nimport * as Fiber from \"./Fiber.js\";\nimport { constant, constTrue, constVoid, dual, identity } from \"./Function.js\";\nimport * as Count from \"./internal/count.js\";\nimport * as internalExecutionPlan from \"./internal/executionPlan.js\";\nimport * as internal from \"./internal/stream.js\";\nimport { addSpanStackTrace } from \"./internal/tracer.js\";\nimport * as Iterable from \"./Iterable.js\";\nimport * as Latch from \"./Latch.js\";\nimport * as MutableHashMap from \"./MutableHashMap.js\";\nimport * as MutableList from \"./MutableList.js\";\nimport * as Option from \"./Option.js\";\nimport { hasProperty, isNotUndefined, isTagged } from \"./Predicate.js\";\nimport * as PubSub from \"./PubSub.js\";\nimport * as Pull from \"./Pull.js\";\nimport * as Queue from \"./Queue.js\";\nimport * as RcMap from \"./RcMap.js\";\nimport * as RcRef from \"./RcRef.js\";\nimport * as Result from \"./Result.js\";\nimport * as Schedule from \"./Schedule.js\";\nimport * as Scope from \"./Scope.js\";\nimport * as Sink from \"./Sink.js\";\nimport { isString } from \"./String.js\";\n/**\n * Runtime identifier stored on `Stream` values and used by `isStream` to\n * recognize them.\n *\n * **Details**\n *\n * This marker is part of the runtime representation of `Stream` values. Prefer\n * `isStream` when narrowing unknown values.\n *\n * @see {@link isStream} for the public guard that checks this identifier\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = \"~effect/Stream\";\n/**\n * Checks whether a value is a Stream.\n *\n * **Example** (Checking whether a value is a Stream)\n *\n * ```ts import.meta.vitest\n * import { Stream } from \"effect\"\n *\n * Stream.isStream(Stream.make(1, 2, 3)) // => true\n * Stream.isStream({ data: [1, 2, 3] }) // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isStream = u => hasProperty(u, TypeId);\n/**\n * The default chunk size used by Stream constructors and combinators.\n *\n * **Example** (Reading the default chunk size)\n *\n * ```ts import.meta.vitest\n * import { Stream } from \"effect\"\n *\n * Stream.DefaultChunkSize // => 4096\n * ```\n *\n * @category constants\n * @since 2.0.0\n */\nexport const DefaultChunkSize = Channel.DefaultChunkSize;\n/**\n * Creates a stream from a array-emitting `Channel`.\n *\n * **Example** (Creating a stream from an array-emitting channel)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Stream } from \"effect\"\n *\n * const channel = Channel.succeed([1, 2, 3] as const)\n * const stream = Stream.fromChannel(channel)\n * await Effect.runPromise(Stream.runCollect(stream)) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromChannel = internal.fromChannel;\n/**\n * Creates a stream from an effect.\n *\n * **Example** (Creating a stream from an effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.fromEffect(Effect.succeed(42))\n * await Effect.runPromise(Stream.runCollect(stream)) // => [42]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromEffect = effect => fromChannel(Channel.fromEffect(Effect.map(effect, Arr.of)));\n/**\n * Accesses a service from the context and emits it as a single element.\n *\n * **Example** (Accessing a service as a stream)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Stream } from \"effect\"\n *\n * class Greeter extends Context.Service string\n * }>()(\"Greeter\") {}\n *\n * const stream = Stream.service(Greeter).pipe(\n * Stream.map((greeter) => greeter.greet(\"World\"))\n * )\n *\n * await Effect.runPromise(\n * stream.pipe(\n * Stream.provideService(Greeter, {\n * greet: (name) => `Hello, ${name}!`\n * }),\n * Stream.runCollect\n * )\n * ) // => [\"Hello, World!\"]\n * ```\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const service = service => fromEffect(Effect.service(service));\n/**\n * Optionally accesses a service from the context and emits the result as a\n * single element.\n *\n * **When to use**\n *\n * Use when you need a stream that emits an optional service from the context\n * without requiring that service to be present.\n *\n * **Example** (Accessing an optional service as a stream)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Option, Stream } from \"effect\"\n *\n * class Greeter extends Context.Service string\n * }>()(\"Greeter\") {}\n *\n * const stream = Stream.serviceOption(Greeter).pipe(\n * Stream.map((maybeGreeter) =>\n * Option.match(maybeGreeter, {\n * onNone: () => \"No greeter\",\n * onSome: (greeter) => greeter.greet(\"World\")\n * })\n * )\n * )\n *\n * await Effect.runPromise(\n * stream.pipe(\n * Stream.provideService(Greeter, {\n * greet: (name) => `Hello, ${name}!`\n * }),\n * Stream.runCollect\n * )\n * ) // => [\"Hello, World!\"]\n * ```\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const serviceOption = service => fromEffect(Effect.serviceOption(service));\n/**\n * Creates a stream that runs the effect and emits no elements.\n *\n * **Example** (Draining an effect into a stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * let drained = false\n * await Effect.runPromise(\n * Stream.fromEffectDrain(Effect.sync(() => {\n * drained = true\n * })).pipe(Stream.runDrain)\n * )\n * drained // => true\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromEffectDrain = effect => fromPull(Effect.succeed(Effect.flatMap(effect, () => Cause.done())));\n/**\n * Creates a stream from an effect producing a value of type `A` which repeats forever.\n *\n * **Example** (Repeating an effect forever)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * let n = 0\n * const stream = Stream.fromEffectRepeat(Effect.sync(() => ++n)).pipe(Stream.take(5))\n * await Effect.runPromise(Stream.runCollect(stream)) // => [1, 2, 3, 4, 5]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromEffectRepeat = effect => fromPull(Effect.succeed(Effect.map(effect, Arr.of)));\n/**\n * Creates a stream from an effect producing a value of type `A`, which is\n * repeated using the specified schedule.\n *\n * **Example** (Repeating an effect with a schedule)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule, Stream } from \"effect\"\n *\n * const stream = Stream.fromEffectSchedule(Effect.succeed(\"ping\"), Schedule.recurs(2))\n * await Effect.runPromise(Stream.runCollect(stream)) // => [\"ping\", \"ping\", \"ping\"]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromEffectSchedule = (effect, schedule) => fromPull(Effect.gen(function* () {\n const step = yield* Schedule.toStepWithMetadata(schedule);\n let s = yield* Effect.provideService(effect, Schedule.CurrentMetadata, Schedule.CurrentMetadata.defaultValue());\n let initial = true;\n const pull = Effect.suspend(() => step(s)).pipe(Effect.flatMap(meta => Effect.provideService(effect, Schedule.CurrentMetadata, meta)), Effect.map(next => {\n s = next;\n return Arr.of(next);\n }));\n return Effect.suspend(() => {\n if (initial) {\n initial = false;\n return Effect.succeed(Arr.of(s));\n }\n return pull;\n });\n}));\n/**\n * Creates a stream that emits `void` immediately once, then emits another\n * `void` after each specified interval.\n *\n * **Example** (Emitting ticks on an interval)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * await Effect.runPromise(Stream.tick(0).pipe(Stream.take(3), Stream.runCollect)) // => [undefined, undefined, undefined]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const tick = interval => fromPull(Effect.sync(() => {\n let first = true;\n const effect = Effect.succeed(Arr.of(undefined));\n const delayed = Effect.delay(effect, interval);\n return Effect.suspend(() => {\n if (first) {\n first = false;\n return effect;\n }\n return delayed;\n });\n}));\n/**\n * Creates a stream from a pull effect, such as one produced by `Stream.toPull`.\n *\n * **Details**\n *\n * A pull effect yields chunks on demand and completes when the upstream stream ends.\n * See `Stream.toPull` for a matching producer.\n *\n * **Example** (Creating a stream from a pull effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * const source = Stream.make(1, 2, 3)\n * const pull = yield* Stream.toPull(source)\n * const stream = Stream.fromPull(Effect.succeed(pull))\n * return yield* Stream.runCollect(stream)\n * })\n * )\n *\n * await Effect.runPromise(program) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromPull = pull => fromChannel(Channel.fromPull(pull));\n/**\n * Derives a stream by transforming its pull effect.\n *\n * **Example** (Transforming a pull effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3)\n *\n * const transformed = Stream.transformPull(stream, (pull) => Effect.succeed(pull))\n *\n * await Effect.runPromise(Stream.runCollect(transformed)) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const transformPull = (self, f) => fromChannel(Channel.fromTransform((_, scope) => Effect.flatMap(Channel.toPullScoped(self.channel, scope), pull => f(pull, scope))));\n/**\n * Transforms a stream by effectfully transforming its pull effect.\n *\n * **Details**\n *\n * A forked scope is also provided to the transformation function, which is\n * closed once the resulting stream has finished processing.\n *\n * **Example** (Transforming a stream by effectfully transforming its pull effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Scope, Stream } from \"effect\"\n *\n * const finalized: Array = []\n * const stream = Stream.make(1, 2, 3)\n *\n * const transformed = Stream.transformPullBracket(\n * stream,\n * (pull, _scope, forkedScope) =>\n * Effect.gen(function*() {\n * yield* Scope.addFinalizer(forkedScope, Effect.sync(() => finalized.push(true)))\n * return pull\n * })\n * )\n *\n * await Effect.runPromise(Stream.runCollect(transformed)) // => [1, 2, 3]\n * finalized // => [true]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const transformPullBracket = (self, f) => fromChannel(Channel.fromTransformBracket((_, scope, forkedScope) => Effect.flatMap(Channel.toPullScoped(self.channel, scope), pull => f(pull, scope, forkedScope))));\n/**\n * Creates a channel from a stream.\n *\n * **Example** (Converting a stream to a channel)\n *\n * ```ts import.meta.vitest\n * import { Channel, Effect, Stream } from \"effect\"\n *\n * const channel = Stream.toChannel(Stream.make(1, 2, 3))\n * const values = await Effect.runPromise(Channel.runCollect(channel))\n * values.flat() // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const toChannel = stream => stream.channel;\n/**\n * Creates a stream from a callback that can emit values into a queue.\n *\n * **When to use**\n *\n * Use when you need callback-based code to emit stream values by offering to a\n * `Queue`, or signal stream completion through the `Queue` module APIs.\n *\n * By default it uses an \"unbounded\" buffer size.\n * You can customize the buffer size and strategy by passing an object as the\n * second argument with the `bufferSize` and `strategy` fields.\n *\n * **Example** (Creating a stream from a callback that can emit values into a queue)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue, Stream } from \"effect\"\n *\n * const stream = Stream.callback((queue) =>\n * Effect.sync(() => {\n * // Emit values to the stream\n * Queue.offerUnsafe(queue, 1)\n * Queue.offerUnsafe(queue, 2)\n * Queue.offerUnsafe(queue, 3)\n * // Signal completion\n * Queue.endUnsafe(queue)\n * })\n * )\n *\n * await Effect.runPromise(Stream.runCollect(stream)) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const callback = (f, options) => fromChannel(Channel.callbackArray(f, options));\n/**\n * Creates an empty stream.\n *\n * **Example** (Creating an empty stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * await Effect.runPromise(Stream.runCollect(Stream.empty)) // => []\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const empty = /*#__PURE__*/fromChannel(Channel.empty);\n/**\n * Creates a single-valued pure stream.\n *\n * **Example** (Creating a single-valued pure stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * await Effect.runPromise(Stream.runCollect(Stream.succeed(3))) // => [3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const succeed = value => fromChannel(Channel.succeed(Arr.of(value)));\n/**\n * Creates a stream from a sequence of values.\n *\n * **Example** (Creating a stream from a sequence of values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3)\n *\n * await Effect.runPromise(Stream.runCollect(stream)) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const make = (...values) => fromArray(values);\n/**\n * Creates a stream that synchronously evaluates a function and emits the result as a single value.\n *\n * **Details**\n *\n * The function is evaluated each time the stream is run.\n *\n * **Example** (Evaluating a value synchronously)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * await Effect.runPromise(Stream.sync(() => 2 + 1).pipe(Stream.runCollect)) // => [3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const sync = evaluate => fromChannel(Channel.sync(() => Arr.of(evaluate())));\n/**\n * Creates a lazily constructed stream.\n *\n * **Details**\n *\n * The stream factory is evaluated each time the stream is run.\n *\n * **Example** (Creating a lazily constructed stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * await Effect.runPromise(Stream.suspend(() => Stream.make(1, 2, 3)).pipe(Stream.runCollect)) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const suspend = stream => fromChannel(Channel.suspend(() => stream().channel));\n/**\n * Terminates with the specified error.\n *\n * **Example** (Failing a stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Stream } from \"effect\"\n *\n * await Effect.runPromise(Effect.exit(Stream.runCollect(Stream.fail(\"Uh oh!\")))) // => Exit.fail(\"Uh oh!\")\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fail = error => fromChannel(Channel.fail(error));\n/**\n * Terminates with the specified lazily evaluated error.\n *\n * **Example** (Failing a stream lazily)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Stream } from \"effect\"\n *\n * const stream = Stream.failSync(() => \"Uh oh!\")\n *\n * await Effect.runPromise(Stream.runCollect(stream).pipe(Effect.exit)) // => Exit.fail(\"Uh oh!\")\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failSync = evaluate => fromChannel(Channel.failSync(evaluate));\n/**\n * Creates a stream that fails with the specified `Cause`.\n *\n * **Example** (Failing with a cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Stream } from \"effect\"\n *\n * const stream = Stream.failCause(Cause.fail(\"Database connection failed\")).pipe(\n * Stream.catchCause(() => Stream.succeed(\"recovered\"))\n * )\n *\n * await Effect.runPromise(Stream.runCollect(stream)) // => [\"recovered\"]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failCause = cause => fromChannel(Channel.failCause(cause));\n/**\n * The stream that dies with the specified defect.\n *\n * **Example** (Dying with a defect)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit, Stream } from \"effect\"\n *\n * const defect = new Error(\"Boom\")\n * const stream = Stream.die(defect)\n *\n * await Effect.runPromise(Effect.exit(Stream.runCollect(stream))) // => Exit.failCause(Cause.die(defect))\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const die = defect => fromChannel(Channel.die(defect));\n/**\n * The stream that always fails with the specified lazily evaluated `Cause`.\n *\n * **Example** (Failing with a lazy cause)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Exit, Stream } from \"effect\"\n *\n * const stream = Stream.failCauseSync(() =>\n * Cause.fail(\"Connection timeout after retries\")\n * )\n *\n * await Effect.runPromise(Stream.runCollect(stream).pipe(Effect.exit)) // => Exit.fail(\"Connection timeout after retries\")\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const failCauseSync = evaluate => fromChannel(Channel.failCauseSync(evaluate));\n/**\n * Creates a stream that consumes values from an iterator.\n *\n * **Details**\n *\n * The `maxChunkSize` parameter controls how many values are pulled per chunk.\n * Finite fractional values are rounded down, while `NaN` and non-positive\n * values are treated as `1`.\n *\n * **Example** (Consuming values from an iterator)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * function* numbers() {\n * yield 1\n * yield 2\n * yield 3\n * }\n *\n * const stream = Stream.fromIteratorSucceed(numbers())\n *\n * const program = Effect.gen(function* () {\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 3]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromIteratorSucceed = (iterator, maxChunkSize) => fromChannel(Channel.fromIteratorArray(() => iterator, maxChunkSize));\n/**\n * Creates a new `Stream` from an iterable collection of values.\n *\n * **Details**\n *\n * - `chunkSize`: Maximum number of values emitted per chunk. Finite fractional\n * values are rounded down, while `NaN` and non-positive values are treated as\n * `1`.\n *\n * **Example** (Creating a stream from an iterable)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const numbers = [1, 2, 3]\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.fromIterable(numbers)\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 3]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromIterable = (iterable, options) => Array.isArray(iterable) && options?.chunkSize === undefined ? fromArray(iterable) : fromChannel(Channel.fromIterableArray(iterable, options?.chunkSize));\n/**\n * Creates a stream from an effect producing an iterable of values.\n *\n * **When to use**\n *\n * Use when the iterable must be acquired from an Effect before the stream emits,\n * and acquisition services or failures should be part of the stream.\n *\n * **Example** (Creating a stream from an iterable effect)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Stream } from \"effect\"\n *\n * class UserRepo extends Context.Service>\n * }>()(\"UserRepo\") {}\n *\n * const listUsers = Effect.service(UserRepo).pipe(\n * Effect.andThen((repo) => repo.list)\n * )\n *\n * const stream = Stream.fromIterableEffect(listUsers)\n *\n * const program = Effect.gen(function*() {\n * const users = yield* stream.pipe(\n * Stream.provideService(UserRepo, {\n * list: Effect.succeed([\"user1\", \"user2\"])\n * }),\n * Stream.runCollect\n * )\n * users // => [\"user1\", \"user2\"]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromIterableEffect = iterable => unwrap(Effect.map(iterable, fromIterable));\n/**\n * Creates a stream by repeatedly running an effect that yields an iterable of values.\n *\n * **Example** (Repeating an iterable effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.fromIterableEffectRepeat(Effect.succeed([1, 2])).pipe(\n * Stream.take(5)\n * )\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 1, 2, 1]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromIterableEffectRepeat = iterable => flatMap(fromEffectRepeat(iterable), fromIterable);\n/**\n * Creates a stream from an array of values.\n *\n * **Example** (Creating a stream from an array of values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.fromArray([1, 2, 3])\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 3]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromArray = array => Arr.isReadonlyArrayNonEmpty(array) ? fromChannel(Channel.succeed(array)) : empty;\n/**\n * Creates a stream from an effect that produces an array of values.\n *\n * **When to use**\n *\n * Use when the array must be acquired from an Effect before the stream emits,\n * and acquisition services or failures should be part of the stream.\n *\n * **Example** (Creating a stream from an effect that produces an array of values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.fromArrayEffect(Effect.succeed([\"Ada\", \"Grace\"]))\n * const values = yield* Stream.runCollect(stream)\n * values // => [\"Ada\", \"Grace\"]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromArrayEffect = effect => unwrap(Effect.map(effect, fromArray));\n/**\n * Creates a stream from an arbitrary number of arrays.\n *\n * **Example** (Creating a stream from an arbitrary number of arrays)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.fromArrays([1, 2], [3, 4])\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 3, 4]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromArrays = (...arrays) => fromChannel(Channel.fromArray(Arr.filter(arrays, Arr.isReadonlyArrayNonEmpty)));\n/**\n * Creates a stream that pulls values from a `Queue.Dequeue`.\n *\n * **Details**\n *\n * The stream emits non-empty batches of queued values and ends when the queue\n * fails with `Cause.Done`; other queue failures are propagated.\n *\n * **Example** (Creating a stream from a queue of values)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.unbounded()\n * yield* Queue.offer(queue, 1)\n * yield* Queue.offer(queue, 2)\n * yield* Queue.offer(queue, 3)\n * yield* Queue.end(queue)\n *\n * const stream = Stream.fromQueue(queue)\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 3]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromQueue = queue => fromChannel(Channel.fromQueueArray(queue));\n/**\n * Creates a stream from a subscription to a `PubSub`.\n *\n * **Example** (Creating a stream from a subscription to a PubSub)\n *\n * ```ts import.meta.vitest\n * import { Effect, Fiber, PubSub, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const pubsub = yield* PubSub.unbounded({ replay: 3 })\n *\n * const fiber = yield* Stream.fromPubSub(pubsub).pipe(\n * Stream.take(3),\n * Stream.runCollect,\n * Effect.forkChild\n * )\n *\n * yield* PubSub.publish(pubsub, 1)\n * yield* PubSub.publish(pubsub, 2)\n * yield* PubSub.publish(pubsub, 3)\n *\n * const values = yield* Fiber.join(fiber)\n * values // => [1, 2, 3]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromPubSub = pubsub => fromChannel(Channel.fromPubSubArray(pubsub));\n/**\n * Creates a stream from a PubSub of `Take` values.\n *\n * **Details**\n *\n * `Take` values include end and failure signals.\n *\n * **Example** (Creating a stream from PubSub takes)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, PubSub, Stream, Take } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const pubsub = yield* PubSub.unbounded>({\n * replay: 3\n * })\n *\n * yield* PubSub.publish(pubsub, [1])\n * yield* PubSub.publish(pubsub, [2])\n * yield* PubSub.publish(pubsub, Exit.succeed(undefined))\n *\n * const values = yield* Stream.fromPubSubTake(pubsub).pipe(Stream.runCollect)\n * values // => [1, 2]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromPubSubTake = pubsub => fromChannel(Channel.fromPubSubTake(pubsub));\n/**\n * Creates a stream from a lazily supplied Web `ReadableStream`.\n *\n * **Details**\n *\n * The stream reads from a `ReadableStreamDefaultReader`, maps read failures\n * with `onError`, and closes the reader when the stream finalizes. By default\n * the reader is canceled; set `releaseLockOnEnd` to release the lock instead.\n *\n * **Example** (Creating a stream from a ReadableStream)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Stream } from \"effect\"\n *\n * class StreamError extends Data.TaggedError(\"StreamError\")<{ readonly cause: unknown }> {}\n *\n * const readableStream = new ReadableStream({\n * start(controller) {\n * controller.enqueue(1)\n * controller.enqueue(2)\n * controller.enqueue(3)\n * controller.close()\n * }\n * })\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.fromReadableStream({\n * evaluate: () => readableStream,\n * onError: (cause) => new StreamError({ cause })\n * })\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 3]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromReadableStream = options => fromChannel(Channel.fromReadableStream(options));\n/**\n * Creates a stream from an AsyncIterable.\n *\n * **Example** (Creating a stream from an AsyncIterable)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Stream } from \"effect\"\n *\n * class StreamError extends Data.TaggedError(\"StreamError\")<{ readonly cause: unknown }> {}\n *\n * const iterable = (async function*() {\n * yield 1\n * yield 2\n * yield 3\n * })()\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const stream = Stream.fromAsyncIterable(iterable, (cause) => new StreamError({ cause }))\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 3]\n * }))\n *\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromAsyncIterable = (iterable, onError) => fromChannel(Channel.fromAsyncIterableArray(iterable, onError));\n/**\n * Creates a stream that emits each output of a schedule that does not require input,\n * for as long as the schedule continues.\n *\n * **Example** (Creating a stream from a schedule)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const schedule = Schedule.recurs(3)\n * const stream = Stream.fromSchedule(schedule)\n * const values = yield* Stream.runCollect(stream)\n * values // => [0, 1, 2]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromSchedule = schedule => fromPull(Effect.map(Schedule.toStepWithSleep(schedule), step => Pull.catchDone(Effect.map(step(void 0), Arr.of), () => Cause.done())));\n/**\n * Creates a stream from a PubSub subscription.\n *\n * **When to use**\n *\n * Use when you already have a `PubSub.Subscription` and want to expose its\n * messages as a `Stream`, with `Stream.take` or cancellation controlling how\n * many values are consumed.\n *\n * **Example** (Creating a stream from a PubSub subscription)\n *\n * ```ts import.meta.vitest\n * import { Effect, PubSub, Stream } from \"effect\"\n *\n * const program = Effect.scoped(Effect.gen(function*() {\n * const pubsub = yield* PubSub.unbounded()\n * const subscription = yield* PubSub.subscribe(pubsub)\n *\n * yield* PubSub.publish(pubsub, 1)\n * yield* PubSub.publish(pubsub, 2)\n *\n * const stream = Stream.fromSubscription(subscription)\n * const values = yield* stream.pipe(Stream.take(2), Stream.runCollect)\n * values // => [1, 2]\n * }))\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromSubscription = pubsub => fromChannel(Channel.fromSubscriptionArray(pubsub));\n/**\n * Creates a stream from an event listener.\n *\n * **Example** (Creating a stream from an event listener)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * class NumberTarget implements Stream.EventListener {\n * addEventListener(event: string, f: (event: number) => void) {\n * if (event === \"data\") {\n * f(1)\n * f(2)\n * f(3)\n * }\n * }\n * removeEventListener(_event: string, _f: (event: number) => void) {}\n * }\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const stream = Stream.fromEventListener(new NumberTarget(), \"data\").pipe(\n * Stream.take(3)\n * )\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 3]\n * }))\n *\n * ```\n *\n * @category constructors\n * @since 3.1.0\n */\nexport const fromEventListener = (target, type, options) => callback(queue => {\n const once = typeof options === \"object\" && options.once;\n function emit(event) {\n Queue.offerUnsafe(queue, event);\n if (once) Queue.endUnsafe(queue);\n }\n return Effect.acquireRelease(Effect.sync(() => target.addEventListener(type, emit, options)), () => Effect.sync(() => target.removeEventListener(type, emit, options)));\n}, {\n bufferSize: typeof options === \"object\" ? options.bufferSize : undefined\n});\n/**\n * Creates a stream by repeatedly applying an effectful step function to a\n * state.\n *\n * **Details**\n *\n * Each `readonly [value, nextState]` result emits `value` and continues with\n * `nextState`; returning `undefined` ends the stream.\n *\n * **Example** (Unfolding stream state)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.unfold(1, (n) => Effect.succeed([n, n + 1] as const))\n * const values = yield* Stream.runCollect(stream.pipe(Stream.take(5)))\n * values // => [ 1, 2, 3, 4, 5 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const unfold = (s, f) => fromPull(Effect.sync(() => {\n let state = s;\n return Effect.flatMap(Effect.suspend(() => f(state)), next => {\n if (next === undefined) return Cause.done();\n state = next[1];\n return Effect.succeed(Arr.of(next[0]));\n });\n}));\n/**\n * Creates a stream by repeatedly evaluating an effectful page function.\n *\n * **When to use**\n *\n * Use to consume paginated APIs where each step returns a batch of values\n * together with an optional next state.\n *\n * **Details**\n *\n * This is similar to {@link unfold}, but each step can emit zero or more values\n * and independently decide whether another state should be requested.\n *\n * **Example** (Paginating stream state)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Stream } from \"effect\"\n *\n * const stream = Stream.paginate(0, (n: number) =>\n * Effect.succeed(\n * [\n * [n],\n * n < 3 ? Option.some(n + 1) : Option.none()\n * ] as const\n * ))\n *\n * await Effect.runPromise(Stream.runCollect(stream)) // => [0, 1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const paginate = (s, f) => fromPull(Effect.sync(() => {\n let state = s;\n let done = false;\n return Effect.suspend(function loop() {\n if (done) return Cause.done();\n return Effect.flatMap(f(state), ([a, s]) => {\n if (Option.isNone(s)) {\n done = true;\n } else {\n state = s.value;\n }\n if (!Arr.isReadonlyArrayNonEmpty(a)) return loop();\n return Effect.succeed(a);\n });\n });\n}));\n/**\n * Creates an infinite stream by repeatedly applying a function to a seed value.\n *\n * **Example** (Iterating from a seed value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.iterate(1, (n) => n + 1).pipe(Stream.take(3))\n *\n * const program = Effect.gen(function* () {\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const iterate = (value, next) => unfold(value, a => Effect.succeed([a, next(a)]));\n/**\n * Constructs a stream from a range of integers, including both endpoints.\n *\n * **Details**\n *\n * If the provided `min` is greater than `max`, the stream will not emit any\n * values. Finite fractional `chunkSize` values are rounded down, while `NaN`\n * and non-positive values are treated as `1`.\n *\n * **Example** (Creating a numeric range)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.range(1, 5).pipe(Stream.runCollect)\n * values // => [ 1, 2, 3, 4, 5 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const range = (min, max, chunkSize = Channel.DefaultChunkSize) => min > max ? empty : fromPull(Effect.sync(() => {\n const size = Count.normalizeNonEmpty(chunkSize);\n let start = min;\n let done = false;\n return Effect.suspend(() => {\n if (done) return Cause.done();\n const remaining = max - start + 1;\n if (remaining > size) {\n const chunk = Arr.range(start, start + size - 1);\n start += size;\n return Effect.succeed(chunk);\n }\n const chunk = Arr.range(start, start + remaining - 1);\n done = true;\n return Effect.succeed(chunk);\n });\n}));\n/**\n * The stream that never produces any value or fails with any error.\n *\n * **Example** (Creating a never-ending stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Stream.never.pipe(\n * Stream.take(0),\n * Stream.runCollect\n * )\n *\n * await Effect.runPromise(program) // => []\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const never = /*#__PURE__*/fromChannel(Channel.never);\n/**\n * Creates a stream produced from an `Effect`.\n *\n * **Example** (Unwrapping a stream effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const effect = Effect.succeed(Stream.make(1, 2, 3))\n *\n * const stream = Stream.unwrap(effect)\n *\n * const program = Effect.gen(function*() {\n * const chunk = yield* Stream.runCollect(stream)\n * chunk // => [ 1, 2, 3 ]\n * })\n * await Effect.runPromise(program)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const unwrap = effect => fromChannel(Channel.unwrap(Effect.map(effect, toChannel)));\n/**\n * Runs a stream that requires `Scope` in a managed scope, ensuring its\n * finalizers are run when the stream completes.\n *\n * **Example** (Scoping a stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const events: Array = []\n * const stream = Stream.scoped(\n * Stream.fromEffect(\n * Effect.acquireRelease(\n * Effect.sync(() => {\n * events.push(\"acquire\")\n * return \"resource\"\n * }),\n * () => Effect.sync(() => events.push(\"release\"))\n * )\n * )\n * )\n *\n * await Effect.runPromise(Stream.runCollect(stream)) // => [\"resource\"]\n * events // => [\"acquire\", \"release\"]\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const scoped = self => fromChannel(Channel.scoped(self.channel));\n/**\n * Transforms the elements of this stream using the supplied function.\n *\n * **Example** (Mapping stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Stream } from \"effect\"\n *\n * const stream = Stream.fromArray([1, 2, 3]).pipe(Stream.map((n, i) => n + i))\n * await Effect.runPromise(Stream.runCollect(stream)) // => [1, 3, 5]\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, f) => suspend(() => {\n let i = 0;\n return fromChannel(Channel.map(self.channel, Arr.map(o => f(o, i++))));\n}));\n/**\n * Maps both the failure and success channels of a stream.\n *\n * **Example** (Mapping both the failure and success channels of a stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const mapper = {\n * onFailure: (error: string) => `error: ${error}`,\n * onSuccess: (value: number) => value * 2\n * }\n *\n * const program = Effect.gen(function*() {\n * const success = yield* Stream.make(1, 2).pipe(\n * Stream.mapBoth(mapper),\n * Stream.runCollect\n * )\n * success // => [ 2, 4 ]\n *\n * const failure = yield* Stream.fail(\"boom\").pipe(\n * Stream.mapBoth(mapper),\n * Stream.catch((error: string) => Stream.succeed(error)),\n * Stream.runCollect\n * )\n * failure // => [ 'error: boom' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapBoth = /*#__PURE__*/dual(2, (self, options) => self.pipe(map(options.onSuccess), mapError(options.onFailure)));\n/**\n * Transforms each emitted chunk using the provided function, which receives the chunk and its index.\n *\n * **Example** (Mapping stream chunks)\n *\n * ```ts import.meta.vitest\n * import { Array, Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.make(1, 2, 3, 4).pipe(\n * Stream.rechunk(2),\n * Stream.mapArray((chunk, index) => Array.map(chunk, (n) => n + index)),\n * Stream.runCollect\n * )\n * result // => [ 1, 2, 4, 5 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapArray = /*#__PURE__*/dual(2, (self, f) => fromChannel(Channel.map(self.channel, f)));\n/**\n * Maps over elements of the stream with the specified effectful function.\n *\n * **When to use**\n *\n * Use when each stream element transformation needs an Effect, service\n * dependency, failure channel, or configured concurrency.\n *\n * **Example** (Effectfully mapping stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const events: Array = []\n * const stream = Stream.make(1, 2, 3)\n *\n * const mappedStream = stream.pipe(\n * Stream.mapEffect((n) =>\n * Effect.sync(() => {\n * events.push(`Processing: ${n}`)\n * return n * 2\n * })\n * )\n * )\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(mappedStream)\n * result // => [2, 4, 6]\n * })\n *\n * await Effect.runPromise(program)\n * events // => [\"Processing: 1\", \"Processing: 2\", \"Processing: 3\"]\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, options) => self.channel.pipe(Channel.flattenArray, Channel.mapEffect(f, options), Channel.map(Arr.of), fromChannel));\n/**\n * Flattens a stream of `Effect` values into a stream of their results.\n *\n * **When to use**\n *\n * Use when stream elements already are effects and their successes should become\n * stream elements while their failures enter the stream error channel.\n *\n * **Example** (Flattening a stream of Effect values into a stream of their results)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(Effect.succeed(1), Effect.succeed(2), Effect.succeed(3))\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(stream.pipe(Stream.flattenEffect()))\n * result // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const flattenEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => mapEffect(self, identity, options));\n/**\n * Maps over non-empty array chunks emitted by the stream effectfully.\n *\n * **When to use**\n *\n * Use when transformation needs to see and replace each non-empty emitted chunk\n * effectfully instead of mapping individual stream elements.\n *\n * **Example** (Effectfully mapping stream chunks)\n *\n * ```ts import.meta.vitest\n * import { Array, Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.fromArray([1, 2, 3, 4]).pipe(\n * Stream.rechunk(2),\n * Stream.mapArrayEffect((chunk, index) =>\n * Effect.succeed(Array.map(chunk, (n) => n + index * 10))\n * ),\n * Stream.runCollect\n * )\n * result // => [ 1, 2, 13, 14 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapArrayEffect = /*#__PURE__*/dual(2, (self, f) => fromChannel(Channel.mapEffect(self.channel, f)));\n/**\n * Lifts failures and successes into a `Result`, yielding a stream that cannot fail.\n *\n * **Details**\n *\n * The stream ends after the first failure, emitting a `Result.fail` value.\n *\n * **Example** (Converting failures to results)\n *\n * ```ts import.meta.vitest\n * import { Effect, Result, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const results = yield* Stream.make(1, 2).pipe(\n * Stream.concat(Stream.fail(\"boom\")),\n * Stream.result,\n * Stream.map(Result.match({\n * onFailure: (error) => `failure: ${error}`,\n * onSuccess: (value) => `success: ${value}`\n * })),\n * Stream.runCollect\n * )\n * results // => [ 'success: 1', 'success: 2', 'failure: boom' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const result = self => self.pipe(map(Result.succeed), catch_(e => succeed(Result.fail(e))));\n/**\n * Runs the provided effect for each element while preserving the elements.\n *\n * **Example** (Tapping stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const events: Array = []\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.fromArray([1, 2, 3]).pipe(\n * Stream.tap((n) => Effect.sync(() => events.push(`before mapping: ${n}`))),\n * Stream.map((n) => n * 2),\n * Stream.tap((n) => Effect.sync(() => events.push(`after mapping: ${n}`))),\n * Stream.runCollect\n * )\n *\n * result // => [2, 4, 6]\n * })\n *\n * await Effect.runPromise(program)\n * events // => [\"before mapping: 1\", \"after mapping: 2\", \"before mapping: 2\", \"after mapping: 4\", \"before mapping: 3\", \"after mapping: 6\"]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const tap = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, options) => mapEffect(self, a => Effect.as(f(a), a), options));\n/**\n * Returns a stream that effectfully \"peeks\" at elements and failures.\n *\n * **Example** (Tapping values and errors)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const events: Array = []\n * const program = Effect.gen(function*() {\n * const stream = Stream.make(1, 2).pipe(\n * Stream.concat(Stream.fail(\"boom\")),\n * Stream.tapBoth({\n * onElement: (value) => Effect.sync(() => events.push(`seen: ${value}`)),\n * onError: (error) => Effect.sync(() => events.push(`error: ${error}`))\n * }),\n * Stream.catch(() => Stream.make(3))\n * )\n * const result = yield* Stream.runCollect(stream)\n * result // => [1, 2, 3]\n * })\n *\n * await Effect.runPromise(program)\n * events // => [\"seen: 1\", \"seen: 2\", \"error: boom\"]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const tapBoth = /*#__PURE__*/dual(2, (self, options) => self.pipe(tapError(options.onError), tap(options.onElement, {\n concurrency: options.concurrency\n})));\n/**\n * Runs a sink for all stream elements while still emitting them downstream.\n *\n * **Example** (Tapping values with a sink)\n *\n * ```ts import.meta.vitest\n * import { Effect, Ref, Sink, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const seen = yield* Ref.make>([])\n * const sink = Sink.forEach((value: number) =>\n * Ref.update(seen, (items) => [...items, value])\n * )\n * const result = yield* Stream.make(1, 2, 3).pipe(\n * Stream.tapSink(sink),\n * Stream.runCollect\n * )\n * const tapped = yield* Ref.get(seen)\n * tapped // => [ 1, 2, 3 ]\n * result // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const tapSink = /*#__PURE__*/dual(2, (self, sink) => transformPullBracket(self, Effect.fnUntraced(function* (pull, _, scope) {\n const upstreamLatch = Latch.makeUnsafe();\n const sinkLatch = Latch.makeUnsafe();\n let chunk = undefined;\n let causeSink = undefined;\n let sinkDone = false;\n let streamDone = false;\n const sinkUpstream = upstreamLatch.whenOpen(Effect.suspend(() => {\n if (chunk) {\n const arr = chunk;\n chunk = undefined;\n if (!streamDone) upstreamLatch.closeUnsafe();\n return Effect.as(sinkLatch.open, arr);\n }\n return Cause.done();\n }));\n yield* Effect.suspend(() => sink.transform(sinkUpstream, scope)).pipe(eff => Effect.onExitPrimitive(eff, exit => {\n sinkDone = true;\n if (Exit.isFailure(exit)) {\n causeSink = exit.cause;\n }\n return sinkLatch.open;\n }, true), Effect.forkIn(scope));\n const pullAndOffer = pull.pipe(Effect.flatMap(chunk_ => {\n chunk = chunk_;\n sinkLatch.closeUnsafe();\n upstreamLatch.openUnsafe();\n return Effect.as(sinkLatch.await, chunk_);\n }), Pull.catchDone(() => {\n streamDone = true;\n sinkLatch.closeUnsafe();\n upstreamLatch.openUnsafe();\n return Effect.flatMap(sinkLatch.await, () => Cause.done());\n }));\n return Effect.suspend(() => {\n if (causeSink) {\n return Effect.failCause(causeSink);\n } else if (sinkDone) {\n return pull;\n }\n return pullAndOffer;\n });\n})));\n/**\n * Maps each element to a stream and flattens the resulting streams.\n *\n * **Details**\n *\n * With the default sequential concurrency, inner streams are concatenated in\n * input order. When `concurrency` is greater than `1` or `\"unbounded\"`,\n * multiple inner streams may run at the same time and their outputs are merged\n * as they arrive.\n *\n * **Example** (Flat mapping stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3).pipe(\n * Stream.flatMap((n) => Stream.make(n, n * 2)),\n * Stream.runCollect\n * )\n * values // => [ 1, 2, 2, 4, 3, 6 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const flatMap = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, options) => self.channel.pipe(Channel.flattenArray, Channel.flatMap(a => f(a).channel, options), fromChannel));\n/**\n * Switches to the latest stream produced by the mapping function, interrupting\n * the previous stream when a new element arrives.\n *\n * **Example** (Switching to the latest stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Stream.make(1, 2, 3).pipe(\n * Stream.switchMap((n) => (n === 3 ? Stream.make(n) : Stream.never)),\n * Stream.runCollect\n * )\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const result = yield* program\n * result // => [ 3 ]\n * }))\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const switchMap = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, options) => self.channel.pipe(Channel.flattenArray, Channel.switchMap(a => f(a).channel, options), fromChannel));\n/**\n * Flattens a stream of streams into a single stream.\n *\n * **Details**\n *\n * With the default sequential concurrency, inner streams are concatenated in\n * strict order. When `concurrency` is greater than `1` or `\"unbounded\"`,\n * multiple inner streams may run at the same time and their outputs are merged\n * as they arrive.\n *\n * **Example** (Flattening nested streams)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const streamOfStreams = Stream.make(\n * Stream.make(1, 2),\n * Stream.make(3, 4),\n * Stream.make(5, 6)\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.runCollect(Stream.flatten(streamOfStreams))\n * values // => [ 1, 2, 3, 4, 5, 6 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const flatten = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => flatMap(self, identity, options));\n/**\n * Flattens a stream of non-empty arrays into a stream of elements.\n *\n * **Example** (Flattening a stream of non-empty arrays into a stream of elements)\n *\n * ```ts import.meta.vitest\n * import { Array, Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(Array.make(1, 2), Array.make(3))\n *\n * const program = Effect.gen(function* () {\n * const result = yield* Stream.runCollect(Stream.flattenArray(stream))\n * result // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const flattenArray = self => fromChannel(Channel.flattenArray(self.channel));\n/**\n * Converts this stream to one that runs its effects but emits no elements.\n *\n * **Example** (Draining stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.range(1, 6).pipe(Stream.drain, Stream.runCollect)\n * result // => []\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const drain = self => fromChannel(Channel.drain(self.channel));\n/**\n * Runs the provided stream in the background while this stream runs, interrupting it\n * when this stream completes and failing if the background stream fails or defects.\n *\n * **Example** (Draining a stream in the background)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const events: Array = []\n * const foreground = Stream.make(1, 2)\n * const background = Stream.fromEffect(Effect.sync(() => events.push(\"background task\")))\n *\n * const program = Effect.gen(function*() {\n * const values = yield* foreground.pipe(\n * Stream.drainFork(background),\n * Stream.runCollect\n * )\n * values // => [1, 2]\n * })\n *\n * await Effect.runPromise(program)\n * events // => [\"background task\"]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const drainFork = /*#__PURE__*/dual(2, (self, that) => mergeEffect(self, runDrain(that)));\n/**\n * Repeats the entire stream according to the provided schedule.\n *\n * **Example** (Repeating a stream on a schedule)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule, Stream } from \"effect\"\n *\n * const program = Effect.gen(function* () {\n * const result = yield* Stream.make(1).pipe(\n * Stream.repeat(Schedule.recurs(4)),\n * Stream.runCollect\n * )\n *\n * result // => [ 1, 1, 1, 1, 1 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const repeat = /*#__PURE__*/dual(2, (self, schedule) => fromChannel(Channel.repeat(self.channel, schedule)));\n/**\n * Schedules the stream's elements according to the provided schedule.\n *\n * **Example** (Scheduling stream elements)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.make(1, 2, 3).pipe(\n * Stream.schedule(Schedule.recurs(3)),\n * Stream.runCollect\n * )\n *\n * result // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category rate limiting\n * @since 2.0.0\n */\nexport const schedule = /*#__PURE__*/dual(2, (self, schedule) => self.channel.pipe(Channel.flattenArray, Channel.schedule(schedule), Channel.map(Arr.of), fromChannel));\n/**\n * Ends the stream if it does not produce a value within the specified duration.\n *\n * **Example** (Timing out a stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1).pipe(\n * Stream.concat(Stream.never),\n * Stream.timeout(\"1 second\"),\n * Stream.runCollect\n * )\n * values // => [ 1 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category delays & timeouts\n * @since 2.0.0\n */\nexport const timeout = /*#__PURE__*/dual(2, (self, duration) => timeoutOrElse(self, {\n duration,\n orElse: () => empty\n}));\n/**\n * Switches to a fallback stream if this stream does not emit a value within\n * the specified duration.\n *\n * **When to use**\n *\n * Use when a stream should continue with another stream if an upstream pull\n * waits longer than the allowed duration.\n *\n * **Details**\n *\n * The timeout is checked for each pull. A zero duration uses `orElse`\n * immediately, while an infinite duration leaves the original stream\n * unchanged.\n *\n * **Gotchas**\n *\n * The fallback stream is not timed after the switch.\n *\n * @see {@link timeout} for ending the stream instead of switching to a fallback stream\n *\n * @category delays & timeouts\n * @since 4.0.0\n */\nexport const timeoutOrElse = /*#__PURE__*/dual(2, (self, options) => {\n const duration = Duration.fromInputUnsafe(options.duration);\n if (!Duration.isFinite(duration)) return self;\n if (Duration.isZero(duration)) return suspend(options.orElse);\n const timeoutSymbol = Symbol();\n return catchCause(suspend(() => {\n const parent = Fiber.getCurrent();\n const clock = parent.getRef(Clock);\n const durationMs = Duration.toMillis(duration);\n let deadline = undefined;\n const latch = Latch.makeUnsafe(false);\n return merge(transformPull(self, (pull, _scope) => Effect.suspend(() => {\n deadline = clock.currentTimeMillisUnsafe() + durationMs;\n latch.openUnsafe();\n return pull;\n }).pipe(Effect.map(arr => {\n latch.closeUnsafe();\n deadline = undefined;\n return arr;\n }), Effect.succeed)), fromEffectDrain(Effect.gen(function* () {\n while (true) {\n yield* latch.await;\n if (deadline === undefined) continue;\n yield* Effect.sleep(deadline - clock.currentTimeMillisUnsafe());\n if (deadline === undefined) continue;\n const remaining = deadline - clock.currentTimeMillisUnsafe();\n if (remaining > 0) continue;\n return yield* Effect.die(timeoutSymbol);\n }\n })), {\n haltStrategy: \"left\"\n });\n }), cause => {\n const isTimeout = cause.reasons.find(r => r._tag === \"Die\" && r.defect === timeoutSymbol);\n if (isTimeout) return options.orElse();\n return failCause(cause);\n });\n});\n/**\n * Repeats each element of the stream according to the provided schedule,\n * including the original emission.\n *\n * **Example** (Repeating stream elements)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(\"A\", \"B\", \"C\").pipe(\n * Stream.repeatElements(Schedule.recurs(1)),\n * Stream.runCollect\n * )\n * values // => [ 'A', 'A', 'B', 'B', 'C', 'C' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const repeatElements = /*#__PURE__*/dual(2, (self, schedule) => fromChannel(Channel.fromTransform((upstream, scope) => Effect.map(Channel.toTransform(Channel.flattenArray(self.channel))(upstream, scope), pullElement => {\n let pullRepeat = undefined;\n const pull = Effect.gen(function* () {\n const element = yield* pullElement;\n const chunk = Arr.of(element);\n const step = yield* Schedule.toStepWithSleep(schedule);\n pullRepeat = step(element).pipe(Effect.as(chunk), Pull.catchDone(_ => {\n pullRepeat = undefined;\n return pull;\n }));\n return chunk;\n });\n return Effect.suspend(() => pullRepeat ?? pull);\n}))));\n/**\n * Repeats this stream forever.\n *\n * **Example** (Repeating a stream forever)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(\"A\", \"B\").pipe(\n * Stream.forever,\n * Stream.take(5)\n * )\n *\n * const program = Effect.gen(function*() {\n * const output = yield* Stream.runCollect(stream)\n * output // => [ 'A', 'B', 'A', 'B', 'A' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const forever = self => fromChannel(Channel.forever(self.channel));\n/**\n * Flattens the iterables emitted by this stream into the stream's structure.\n *\n * **Example** (Flattening iterable values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.make([1, 2], [3, 4]).pipe(Stream.flattenIterable)\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 1, 2, 3, 4 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const flattenIterable = self => flatMap(self, fromIterable);\n/**\n * Unwraps `Take` values, emitting elements from non-empty arrays and ending or\n * failing when the `Exit` signals completion.\n *\n * **Example** (Flattening Take values)\n *\n * ```ts import.meta.vitest\n * import { Array, Effect, Exit, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const takes = Stream.make(\n * Array.make(1, 2),\n * Array.make(3),\n * Exit.succeed(undefined)\n * )\n *\n * const values = yield* Stream.flattenTake(takes).pipe(Stream.runCollect)\n * values // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const flattenTake = self => self.channel.pipe(Channel.flattenArray, Channel.flattenTake, fromChannel);\n/**\n * Concatenates two streams, emitting all elements from the first stream\n * followed by all elements from the second stream.\n *\n * **Example** (Concatenating streams)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.concat(Stream.make(1, 2, 3), Stream.make(4, 5, 6))\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 1, 2, 3, 4, 5, 6 ]\n * }))\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const concat = /*#__PURE__*/dual(2, (self, that) => flatten(fromArray([self, that])));\n/**\n * Prepends the values from the provided iterable before the stream's elements.\n *\n * **Example** (Prepending values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(3, 4).pipe(\n * Stream.prepend([1, 2]),\n * Stream.runCollect\n * )\n *\n * values // => [ 1, 2, 3, 4 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const prepend = /*#__PURE__*/dual(2, (self, values) => concat(fromIterable(values), self));\n/**\n * Merges two streams, emitting elements from both as they arrive.\n *\n * **Details**\n *\n * By default, the merged stream ends when both streams end. Use\n * `haltStrategy` to change the termination behavior.\n *\n * **Example** (Merging stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const fast = Stream.make(1, 2, 3)\n * const slow = Stream.fromEffect(Effect.delay(Effect.succeed(4), \"50 millis\"))\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(Stream.merge(fast, slow))\n * result // => [ 1, 2, 3, 4 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category merging\n * @since 2.0.0\n */\nexport const merge = /*#__PURE__*/dual(args => isStream(args[0]) && isStream(args[1]), (self, that, options) => fromChannel(Channel.merge(toChannel(self), toChannel(that), options)));\n/**\n * Merges this stream with a background effect, keeping the stream's elements.\n *\n * **When to use**\n *\n * Use when an effect should run concurrently for the lifetime of a stream while\n * only the stream's elements remain in the output.\n *\n * **Details**\n *\n * The effect runs concurrently, fails the stream if it fails, and is interrupted\n * when the stream completes.\n *\n * **Example** (Merging with a background effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const events: Array = []\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3).pipe(\n * Stream.mergeEffect(Effect.sync(() => events.push(\"side task\"))),\n * Stream.runCollect\n * )\n *\n * values // => [1, 2, 3]\n * })\n *\n * await Effect.runPromise(program)\n * events // => [\"side task\"]\n * ```\n *\n * @category merging\n * @since 4.0.0\n */\nexport const mergeEffect = /*#__PURE__*/dual(2, (self, effect) => self.channel.pipe(Channel.mergeEffect(effect), fromChannel));\n/**\n * Merges this stream and the specified stream together, tagging values from the\n * left stream as `Result.succeed` and values from the right stream as `Result.fail`.\n *\n * **When to use**\n *\n * Use when values from both streams should be emitted and downstream code needs\n * left values wrapped as successful `Result` values and right values wrapped as\n * failed `Result` values.\n *\n * **Example** (Merging streams into results)\n *\n * ```ts import.meta.vitest\n * import { Effect, Result, Stream } from \"effect\"\n *\n * const left = Stream.fromEffect(Effect.succeed(\"left\"))\n * const right = Stream.fromEffect(Effect.delay(Effect.succeed(\"right\"), \"10 millis\"))\n *\n * const merged = left.pipe(\n * Stream.mergeResult(right),\n * Stream.map(\n * Result.match({\n * onFailure: (value) => `right:${value}`,\n * onSuccess: (value) => `left:${value}`\n * })\n * )\n * )\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(merged)\n * result // => [ 'left:left', 'right:right' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category merging\n * @since 4.0.0\n */\nexport const mergeResult = /*#__PURE__*/dual(2, (self, that) => merge(map(self, Result.succeed), map(that, Result.fail)));\n/**\n * Merges two streams while emitting only the values from the left stream.\n *\n * **When to use**\n *\n * Use when the right stream is needed for its effects or failures, but downstream\n * consumers should only receive values from the left stream.\n *\n * **Details**\n *\n * The right stream still runs for its effects, and any failures from the right\n * stream are propagated. The merged stream completes when the left stream\n * completes, interrupting the right stream.\n *\n * **Example** (Merging streams while keeping left values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const left = Stream.make(1, 2)\n * const right = Stream.make(\"a\", \"b\")\n * const values = yield* left.pipe(Stream.mergeLeft(right), Stream.runCollect)\n * values // => [ 1, 2 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category merging\n * @since 2.0.0\n */\nexport const mergeLeft = /*#__PURE__*/dual(2, (left, right) => mergeEffect(left, runDrain(right)));\n/**\n * Merges this stream and the specified stream together, emitting only the\n * values from the right stream while the left stream runs for its effects.\n *\n * **When to use**\n *\n * Use when the left stream is needed for its effects or failures, but downstream\n * consumers should only receive values from the right stream.\n *\n * **Details**\n *\n * The merged stream ends when the right stream completes, interrupting the\n * left stream. Failures from the left stream still fail the merged stream.\n *\n * **Example** (Merging streams while keeping right values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const left = Stream.make(\"left-1\", \"left-2\").pipe(\n * Stream.tap(() => Effect.sync(() => undefined))\n * )\n * const right = Stream.make(1, 2)\n *\n * const merged = Stream.mergeRight(left, right)\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(merged)\n * result // => [ 1, 2 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category merging\n * @since 2.0.0\n */\nexport const mergeRight = /*#__PURE__*/dual(2, (left, right) => mergeEffect(right, runDrain(left)));\n/**\n * Merges a collection of streams, running up to the specified number concurrently.\n *\n * **When to use**\n *\n * Use to merge an iterable of already-created streams while bounding how many\n * inner streams may run at the same time.\n *\n * **Details**\n *\n * The `concurrency` option is required and may be a number or `\"unbounded\"`.\n * `bufferSize` controls buffering between inner streams, and outputs are\n * emitted as they arrive under concurrent merging.\n *\n * **Example** (Merging streams with bounded concurrency)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const streams = [\n * Stream.fromEffect(Effect.delay(Effect.succeed(\"A\"), \"20 millis\")),\n * Stream.fromEffect(Effect.delay(Effect.succeed(\"B\"), \"10 millis\"))\n * ]\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.mergeAll(streams, { concurrency: 2 }).pipe(\n * Stream.runCollect\n * )\n * values // => [ 'B', 'A' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @see {@link merge} for merging exactly two streams and choosing a halt strategy\n * @see {@link flatten} for flattening a stream that already emits streams\n *\n * @category merging\n * @since 2.0.0\n */\nexport const mergeAll = /*#__PURE__*/dual(2, (streams, options) => flatten(fromIterable(streams), options));\n/**\n * Creates the cartesian product of two streams, running the `right` stream for\n * each element in the `left` stream.\n *\n * **Details**\n *\n * See also `Stream.zip` for the more common point-wise variant.\n *\n * **Example** (Computing cartesian products)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const left = Stream.make(1, 2)\n * const right = Stream.make(\"a\", \"b\")\n * const values = yield* Stream.runCollect(Stream.cross(left, right))\n * values // => [ [ 1, 'a' ], [ 1, 'b' ], [ 2, 'a' ], [ 2, 'b' ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const cross = /*#__PURE__*/dual(2, (left, right) => crossWith(left, right, (l, r) => [l, r]));\n/**\n * Creates a cartesian product of elements from two streams using a function.\n *\n * **Details**\n *\n * The `right` stream is rerun for every element in the `left` stream.\n *\n * See also `Stream.zipWith` for the more common point-wise variant.\n *\n * **Example** (Combining cartesian products)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const left = Stream.make(1, 2)\n * const right = Stream.make(\"a\", \"b\")\n * const combined = Stream.crossWith(left, right, (n, s) => `${n}-${s}`)\n * const result = yield* Stream.runCollect(combined)\n * result // => [ '1-a', '1-b', '2-a', '2-b' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const crossWith = /*#__PURE__*/dual(3, (left, right, f) => flatMap(left, l => map(right, r => f(l, r))));\n/**\n * Zips two streams point-wise with a combining function, ending when either stream ends.\n *\n * **Example** (Zipping streams with a function)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream1 = Stream.make(1, 2, 3, 4, 5, 6)\n * const stream2 = Stream.make(\"a\", \"b\", \"c\")\n *\n * const zipped = Stream.zipWith(stream1, stream2, (n, s) => `${n}-${s}`)\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(zipped)\n * result // => [ '1-a', '2-b', '3-c' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipWith = /*#__PURE__*/dual(3, (left, right, f) => zipWithArray(left, right, zipArrays(f)));\nconst zipArrays = f => (leftArr, rightArr) => {\n const minLength = Math.min(leftArr.length, rightArr.length);\n const result = [];\n for (let i = 0; i < minLength; i++) {\n result.push(f(leftArr[i], rightArr[i]));\n }\n return [result, leftArr.slice(minLength), rightArr.slice(minLength)];\n};\n/**\n * Zips two streams by applying a function to non-empty arrays of elements.\n *\n * **Details**\n *\n * The function returns output plus leftover arrays that carry into the next pull.\n *\n * **Example** (Zipping stream chunks)\n *\n * ```ts import.meta.vitest\n * import { Array, Effect, Stream } from \"effect\"\n *\n * const left = Stream.fromArrays([1, 2, 3], [4, 5])\n * const right = Stream.fromArrays([\"a\", \"b\"], [\"c\", \"d\", \"e\"])\n *\n * const zipped = Stream.zipWithArray(left, right, (leftChunk, rightChunk) => {\n * const minLength = Math.min(leftChunk.length, rightChunk.length)\n * const output = Array.makeBy(minLength, (i) => [leftChunk[i], rightChunk[i]] as const)\n *\n * return [output, leftChunk.slice(minLength), rightChunk.slice(minLength)]\n * })\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(zipped)\n * result // => [ [ 1, 'a' ], [ 2, 'b' ], [ 3, 'c' ], [ 4, 'd' ], [ 5, 'e' ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 4.0.0\n */\nexport const zipWithArray = /*#__PURE__*/dual(3, (left, right, f) => fromChannel(Channel.fromTransformBracket(Effect.fnUntraced(function* (_, scope) {\n const pullLeft = yield* Channel.toPullScoped(left.channel, scope);\n const pullRight = yield* Channel.toPullScoped(right.channel, scope);\n const pullBoth = Effect.gen(function* () {\n const fiberLeft = yield* Effect.forkIn(pullLeft, scope);\n const fiberRight = yield* Effect.forkIn(pullRight, scope);\n return yield* Fiber.joinAll([fiberLeft, fiberRight]);\n });\n let state = {\n _tag: \"PullBoth\"\n };\n const pull = Effect.gen(function* () {\n const [left, right] = state._tag === \"PullBoth\" ? yield* pullBoth : state._tag === \"PullLeft\" ? [yield* pullLeft, state.rightArray] : [state.leftArray, yield* pullRight];\n const result = f(left, right);\n if (Arr.isReadonlyArrayNonEmpty(result[1])) {\n state = {\n _tag: \"PullRight\",\n leftArray: result[1]\n };\n } else if (Arr.isReadonlyArrayNonEmpty(result[2])) {\n state = {\n _tag: \"PullLeft\",\n rightArray: result[2]\n };\n } else {\n state = {\n _tag: \"PullBoth\"\n };\n }\n return result[0];\n });\n return pull;\n}))));\n/**\n * Zips this stream with another point-wise and emits tuples of elements from\n * both streams. The new stream ends when either stream ends.\n *\n * **Example** (Zipping streams)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream1 = Stream.make(1, 2, 3)\n * const stream2 = Stream.make(\"a\", \"b\", \"c\")\n *\n * const zipped = Stream.zip(stream1, stream2)\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(zipped)\n * result // => [ [ 1, 'a' ], [ 2, 'b' ], [ 3, 'c' ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zip = /*#__PURE__*/dual(2, (self, that) => zipWith(self, that, (a, a2) => [a, a2]));\n/**\n * Zips this stream with another point-wise and keeps only the values from\n * the left stream.\n *\n * **Details**\n *\n * The resulting stream ends when either side ends.\n *\n * **Example** (Zipping streams while keeping left values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream1 = Stream.make(1, 2, 3, 4)\n * const stream2 = Stream.make(\"a\", \"b\")\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.zipLeft(stream1, stream2).pipe(Stream.runCollect)\n * result // => [ 1, 2 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipLeft = /*#__PURE__*/dual(2, (left, right) => zipWithArray(left, right, (leftArr, rightArr) => {\n const minLength = Math.min(leftArr.length, rightArr.length);\n const output = leftArr.slice(0, minLength);\n const leftoverLeft = leftArr.slice(minLength);\n const leftoverRight = rightArr.slice(minLength);\n return [output, leftoverLeft, leftoverRight];\n}));\n/**\n * Zips this stream with another point-wise, keeping only right values and ending when either stream ends.\n *\n * **Example** (Zipping streams while keeping right values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream1 = Stream.make(1, 2)\n * const stream2 = Stream.make(\"a\", \"b\", \"c\", \"d\")\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.zipRight(stream1, stream2).pipe(Stream.runCollect)\n * result // => [ 'a', 'b' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipRight = /*#__PURE__*/dual(2, (left, right) => zipWithArray(left, right, (leftArr, rightArr) => {\n const minLength = Math.min(leftArr.length, rightArr.length);\n const output = rightArr.slice(0, minLength);\n const leftoverLeft = leftArr.slice(minLength);\n const leftoverRight = rightArr.slice(minLength);\n return [output, leftoverLeft, leftoverRight];\n}));\n/**\n * Zips this stream with another point-wise and emits tuples of elements from\n * both streams, flattening the left tuple.\n *\n * **Details**\n *\n * The new stream will end when one of the sides ends.\n *\n * **Example** (Zipping and flattening tuples)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream1 = Stream.make(\n * [1, \"a\"] as const,\n * [2, \"b\"] as const,\n * [3, \"c\"] as const\n * )\n * const stream2 = Stream.make(\"x\", \"y\", \"z\")\n * const result = yield* Stream.zipFlatten(stream1, stream2).pipe(Stream.runCollect)\n *\n * result // => [ [ 1, 'a', 'x' ], [ 2, 'b', 'y' ], [ 3, 'c', 'z' ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipFlatten = /*#__PURE__*/dual(2, (self, that) => zipWith(self, that, (a, a2) => [...a, a2]));\n/**\n * Zips this stream together with the index of elements.\n *\n * **Example** (Zipping elements with indices)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const indexed = yield* Stream.make(\"a\", \"b\", \"c\", \"d\").pipe(\n * Stream.zipWithIndex,\n * Stream.runCollect\n * )\n * indexed // => [ [ 'a', 0 ], [ 'b', 1 ], [ 'c', 2 ], [ 'd', 3 ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipWithIndex = self => map(self, (a, i) => [a, i]);\n/**\n * Zips each element with the next element, pairing the final element with\n * `Option.none()`.\n *\n * **Example** (Zipping elements with next values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Stream } from \"effect\"\n *\n * const stream = Stream.zipWithNext(Stream.make(1, 2, 3, 4))\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const values = yield* Stream.runCollect(stream)\n * values // => [[1, Option.some(2)], [2, Option.some(3)], [3, Option.some(4)], [4, Option.none()]]\n * }))\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipWithNext = self => mapAccumArray(self, Option.none, (acc, arr) => {\n let i = 0;\n if (acc._tag === \"None\") {\n i = 1;\n acc = Option.some(arr[0]);\n }\n const pairs = Arr.empty();\n for (; i < arr.length; i++) {\n const value = acc.value;\n acc = Option.some(arr[i]);\n pairs.push([value, acc]);\n }\n return [acc, pairs];\n}, {\n onHalt(state) {\n return state._tag === \"Some\" ? [[state.value, Option.none()]] : [];\n }\n});\n/**\n * Zips each element with its previous element, starting with `None`.\n *\n * **Example** (Zipping elements with previous values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Stream } from \"effect\"\n *\n * const stream = Stream.zipWithPrevious(Stream.make(1, 2, 3, 4))\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(stream)\n * result // => [[Option.none(), 1], [Option.some(1), 2], [Option.some(2), 3], [Option.some(3), 4]]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipWithPrevious = self => mapAccumArray(self, Option.none, (acc, arr) => {\n const pairs = Arr.empty();\n for (let i = 0; i < arr.length; i++) {\n const value = arr[i];\n pairs.push([acc, value]);\n acc = Option.some(arr[i]);\n }\n return [acc, pairs];\n});\n/**\n * Zips each element with its previous and next values.\n *\n * **Example** (Zipping elements with neighbors)\n *\n * ```ts import.meta.vitest\n * import { Console, Effect, Option, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3).pipe(\n * Stream.zipWithPreviousAndNext,\n * Stream.runCollect\n * )\n * values // => [[Option.none(), 1, Option.some(2)], [Option.some(1), 2, Option.some(3)], [Option.some(2), 3, Option.none()]]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipWithPreviousAndNext = self => mapAccumArray(self, () => ({\n prev: Option.none(),\n current: Option.none()\n}), (acc, arr) => {\n let i = 0;\n let current;\n if (acc.current._tag === \"None\") {\n i = 1;\n current = arr[0];\n acc.current = Option.some(current);\n } else {\n current = acc.current.value;\n }\n const pairs = Arr.empty();\n for (; i < arr.length; i++) {\n const element = arr[i];\n acc.current = Option.some(element);\n pairs.push([acc.prev, current, acc.current]);\n acc.prev = Option.some(current);\n current = element;\n }\n return [acc, pairs];\n}, {\n onHalt(acc) {\n return acc.current._tag === \"Some\" ? [[acc.prev, acc.current.value, Option.none()]] : [];\n }\n});\n/**\n * Zips multiple streams so that when a value is emitted by any stream, it is\n * combined with the latest values from the other streams to produce a result.\n *\n * **When to use**\n *\n * Use when each stream should contribute its latest value after all streams have\n * emitted at least once.\n *\n * **Gotchas**\n *\n * Note: tracking the latest value is done on a per-array basis. That means\n * that emitted elements that are not the last value in arrays will never be\n * used for zipping.\n *\n * **Example** (Zipping latest values from many streams)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.zipLatestAll(\n * Stream.make(1, 2, 3).pipe(Stream.rechunk(1)),\n * Stream.make(\"a\", \"b\", \"c\").pipe(Stream.rechunk(1)),\n * Stream.make(true, false, true).pipe(Stream.rechunk(1))\n * )\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(stream)\n * result // => [[1, \"a\", true], [2, \"a\", true], [2, \"b\", true], [2, \"b\", false], [3, \"b\", false], [3, \"c\", false], [3, \"c\", true]]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 3.3.0\n */\nexport const zipLatestAll = (...streams) => fromChannel(Channel.suspend(() => {\n const latest = [];\n const emitted = new Set();\n const readyLatch = Latch.makeUnsafe();\n return Channel.mergeAll(Channel.fromArray(streams.map((s, i) => s.channel.pipe(Channel.flattenArray, Channel.mapEffect(a => {\n latest[i] = a;\n if (!emitted.has(i)) {\n emitted.add(i);\n if (emitted.size < streams.length) {\n return readyLatch.await;\n }\n return Effect.as(readyLatch.open, Arr.of(latest.slice()));\n }\n return Effect.succeed(Arr.of(latest.slice()));\n }), Channel.filter(isNotUndefined)))), {\n concurrency: \"unbounded\",\n bufferSize: 0\n });\n}));\n/**\n * Combines two streams by emitting each new element with the latest value from the other stream.\n *\n * **When to use**\n *\n * Use when two streams should start emitting combined pairs after both have\n * produced at least one value.\n *\n * **Gotchas**\n *\n * Note: tracking the latest value is done on a per-array basis. That means\n * that emitted elements that are not the last value in arrays will never be\n * used for zipping.\n *\n * **Example** (Zipping latest values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.zipLatest(\n * Stream.make(1),\n * Stream.make(\"a\")\n * ).pipe(Stream.runCollect)\n *\n * result // => [ [ 1, 'a' ] ]\n * })\n * await Effect.runPromise(program)\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipLatest = /*#__PURE__*/dual(2, (left, right) => zipLatestAll(left, right));\n/**\n * Combines the latest values from both streams whenever either emits, using\n * the provided function.\n *\n * **When to use**\n *\n * Use when two streams should start emitting custom combined values after both\n * have produced at least one value.\n *\n * **Gotchas**\n *\n * Note: tracking the latest value is done on a per-array basis. That means\n * that emitted elements that are not the last value in arrays will never be\n * used for zipping.\n *\n * **Example** (Zipping latest values with a function)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const result = yield* Stream.make(1, 2, 3).pipe(\n * Stream.rechunk(1),\n * Stream.zipLatestWith(\n * Stream.make(10, 20).pipe(Stream.rechunk(1)),\n * (n, m) => n + m\n * ),\n * Stream.runCollect\n * )\n *\n * result // => [ 11, 12, 22, 23 ]\n * }))\n * ```\n *\n * @category zipping\n * @since 2.0.0\n */\nexport const zipLatestWith = /*#__PURE__*/dual(3, (left, right, f) => map(zipLatestAll(left, right), ([a, a2]) => f(a, a2)));\n/**\n * Runs all streams concurrently until one stream emits its first value, then\n * mirrors that winning stream and interrupts the rest.\n *\n * **Details**\n *\n * Failures or completion from losing streams before a winner is chosen are\n * ignored unless every stream fails or completes before emitting. After a\n * winner is chosen, that stream's later failures are propagated.\n *\n * **Example** (Racing multiple streams)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.raceAll(\n * Stream.empty,\n * Stream.make(0, 1, 2)\n * ).pipe(Stream.runCollect)\n * result // => [ 0, 1, 2 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category racing\n * @since 3.5.0\n */\nexport const raceAll = (...streams) => fromChannel(Channel.fromTransform((_, scope) => Effect.sync(() => {\n let winner;\n const race = Effect.raceAll(streams.map(stream => {\n const childScope = Scope.forkUnsafe(scope);\n return Channel.toPullScoped(stream.channel, childScope).pipe(Effect.flatMap(pull => Effect.zip(Effect.succeed(pull), pull)), Effect.onExit(exit => {\n if (exit._tag === \"Success\") {\n if (winner) {\n return Scope.close(childScope, exit);\n }\n winner = exit.value[0];\n return Effect.void;\n }\n return Scope.close(childScope, exit);\n }), Effect.map(([, chunk]) => chunk));\n }));\n return Effect.suspend(() => winner ?? race);\n})));\n/**\n * Runs both streams concurrently until one stream emits its first value, then\n * mirrors that winning stream and interrupts the other.\n *\n * **Details**\n *\n * A failure or completion from one side before the other side emits does not\n * win the race unless both sides fail or complete before emitting. After a\n * winner is chosen, that stream's later failures are propagated.\n *\n * **Example** (Racing two streams)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.race(\n * Stream.empty,\n * Stream.make(0, 1, 2)\n * )\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(stream)\n * result // => [ 0, 1, 2 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category racing\n * @since 3.7.0\n */\nexport const race = /*#__PURE__*/dual(2, (left, right) => raceAll(left, right));\n/**\n * Filters a stream to the elements that satisfy a predicate.\n *\n * **Example** (Filtering stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.make(1, 2, 3, 4).pipe(\n * Stream.filter((n) => n % 2 === 0)\n * )\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 2, 4 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filter = /*#__PURE__*/dual(2, (self, predicate) => fromChannel(Channel.filterArray(toChannel(self), predicate)));\n/**\n * Filters and maps stream elements in one pass using a `Filter`.\n *\n * **When to use**\n *\n * Use to keep only stream elements accepted by a `Filter` and emit each filter\n * success value.\n *\n * **Details**\n *\n * `Result.succeed` values are emitted and `Result.fail` values are skipped.\n *\n * @see {@link filter} for keeping original elements with a boolean predicate or refinement\n * @see {@link filterMapEffect} for an effectful `Filter`\n * @see {@link partition} for consuming both filter success and failure values\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filterMap = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterMapArray(toChannel(self), filter)));\n/**\n * Filters elements in a single pass effectfully.\n *\n * **Example** (Effectfully filtering stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(stream)\n * result // => [ 3, 4 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filterEffect = /*#__PURE__*/dual(2, (self, predicate) => fromChannel(Channel.filterArrayEffect(toChannel(self), predicate)));\n/**\n * Filters and maps elements in one pass effectfully using a `FilterEffect`.\n *\n * **When to use**\n *\n * Use to apply effectful logic that can reject stream elements or emit\n * transformed values before they continue downstream.\n *\n * **Details**\n *\n * `Result.succeed` values are emitted, `Result.fail` values are skipped, and\n * effect failures fail the stream.\n *\n * @see {@link filterMap} for the synchronous `Filter` variant\n * @see {@link filterEffect} for effectfully keeping original elements\n * @see {@link mapEffect} for effectfully transforming every element\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const filterMapEffect = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterMapArrayEffect(toChannel(self), filter)));\n/**\n * Partitions a stream using a `Filter` and exposes passing and failing values\n * as scoped queues.\n *\n * **Details**\n *\n * The queues are backed by a fiber in the current scope and should be consumed\n * while that scope remains open. Each queue fails with the stream error or\n * `Cause.Done` when the source ends.\n *\n * **Example** (Partitioning a stream into queues)\n *\n * ```ts import.meta.vitest\n * import { Effect, Result, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(\n * Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))\n * )\n *\n * const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)\n * const failValues = yield* Stream.fromQueue(fails).pipe(Stream.runCollect)\n *\n * passValues // => [ 2, 4 ]\n * failValues // => [ 1, 3 ]\n * })\n *\n * await Effect.runPromise(Effect.scoped(program))\n * ```\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const partitionQueue = /*#__PURE__*/dual(args => isStream(args[0]), /*#__PURE__*/Effect.fnUntraced(function* (self, filter, options) {\n const scope = yield* Effect.scope;\n const pull = yield* Channel.toPullScoped(self.channel, scope);\n const capacity = options?.capacity === \"unbounded\" ? undefined : options?.capacity ?? DefaultChunkSize;\n const passes = yield* Queue.make({\n capacity\n });\n const fails = yield* Queue.make({\n capacity\n });\n yield* Effect.gen(function* () {\n while (true) {\n const chunk = yield* pull;\n const excluded = [];\n const satisfying = [];\n for (let i = 0; i < chunk.length; i++) {\n const result = filter(chunk[i]);\n if (Result.isFailure(result)) {\n excluded.push(result.failure);\n } else {\n satisfying.push(result.success);\n }\n }\n let passFiber = undefined;\n if (satisfying.length > 0) {\n const leftover = Queue.offerAllUnsafe(passes, satisfying);\n if (leftover.length > 0) {\n passFiber = yield* Effect.forkChild(Queue.offerAll(passes, leftover));\n }\n }\n if (excluded.length > 0) {\n const leftover = Queue.offerAllUnsafe(fails, excluded);\n if (leftover.length > 0) {\n yield* Queue.offerAll(fails, leftover);\n }\n }\n if (passFiber) yield* Fiber.join(passFiber);\n }\n }).pipe(Effect.onError(cause => {\n Queue.failCauseUnsafe(passes, cause);\n Queue.failCauseUnsafe(fails, cause);\n return Effect.void;\n }), Effect.forkIn(scope));\n return [passes, fails];\n}));\n/**\n * Splits a stream with an effectful `Filter`, returning scoped streams for\n * filter successes and failures.\n *\n * **When to use**\n *\n * Use when you need to classify each stream element with an effectful `Filter`\n * and consume both passing and failing mapped values as streams.\n *\n * **Details**\n *\n * The returned streams are backed by queues in the current scope and should be\n * consumed while that scope remains open. The first stream emits success values\n * from the filter, and the second emits failure values.\n *\n * @see {@link partition} for the pure `Filter` variant, which returns the failing stream before the passing stream\n * @see {@link partitionQueue} for the lower-level queue result\n * @see {@link filterMapEffect} for effectful filtering that discards failed filter results\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(mapEffect(self, a => filter(a), options), result => result, options), ([passes, fails]) => [fromQueue(passes), fromQueue(fails)]));\n/**\n * Splits a stream into scoped excluded and satisfying substreams using a\n * `Filter`.\n *\n * **Details**\n *\n * The returned streams are backed by queues in the current scope and should be\n * consumed while that scope remains open. The faster stream may advance up to\n * `bufferSize` elements ahead of the slower one.\n *\n * **Example** (Partitioning a stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Result, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const [excluded, satisfying] = yield* Stream.partition(\n * Stream.make(1, 2, 3, 4),\n * (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)\n * )\n * const left = yield* Stream.runCollect(excluded)\n * const right = yield* Stream.runCollect(satisfying)\n * left // => [ 1, 3 ]\n * right // => [ 2, 4 ]\n * })\n * await Effect.runPromise(Effect.scoped(program))\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const partition = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(self, filter, {\n capacity: options?.bufferSize ?? 16\n}), ([passes, fails]) => [fromQueue(fails), fromQueue(passes)]));\n/**\n * Returns the specified stream if the given condition is satisfied, otherwise\n * returns an empty stream.\n *\n * **Example** (Conditionally keeping a stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(\n * Stream.when(Stream.make(1, 2, 3), Effect.succeed(false))\n * )\n * result // => []\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const when = /*#__PURE__*/dual(2, (self, test) => test.pipe(Effect.map(pass => pass ? self : empty), unwrap));\n/**\n * Runs a sink to peel off enough elements to produce a value and returns that\n * value with the remaining stream in a scope.\n *\n * **Details**\n *\n * The returned stream is only valid within the scope.\n *\n * **Example** (Peeling a stream with a sink)\n *\n * ```ts import.meta.vitest\n * import { Effect, Sink, Stream } from \"effect\"\n *\n * const stream = Stream.fromArrays([1, 2, 3], [4, 5, 6])\n * const sink = Sink.take(3)\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * const [peeled, rest] = yield* Stream.peel(stream, sink)\n * const remaining = yield* Stream.runCollect(rest)\n * const result = [peeled, remaining] // => [[1, 2, 3], [4, 5, 6]]\n * })\n * )\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const peel = /*#__PURE__*/dual(2, /*#__PURE__*/Effect.fnUntraced(function* (self, sink) {\n let cause = undefined;\n const originalPull = yield* Channel.toPull(self.channel);\n const pull = Effect.catchCause(originalPull, cause_ => {\n cause = cause_;\n return Effect.failCause(cause_);\n });\n let stream = fromPull(Effect.succeed(pull));\n const leftover = yield* run(stream, sink);\n if (cause) return [leftover, empty];\n stream = fromPull(Effect.succeed(originalPull));\n return [leftover, stream];\n}));\n/**\n * Buffers up to `capacity` elements so a faster producer can progress\n * independently of a slower consumer.\n *\n * **Details**\n *\n * Finite buffers use the configured queue strategy: `\"suspend\"` applies\n * backpressure, while `\"dropping\"` and `\"sliding\"` may discard elements when\n * the buffer is full. This combinator destroys chunking; use `Stream.rechunk`\n * afterward if you need fixed chunk sizes.\n *\n * **Example** (Buffering stream elements)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3).pipe(\n * Stream.buffer({ capacity: 1 }),\n * Stream.runCollect\n * )\n * values // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category buffering\n * @since 2.0.0\n */\nexport const buffer = /*#__PURE__*/dual(2, (self, options) => fromChannel(Channel.bufferArray(self.channel, options)));\n/**\n * Allows a faster producer to progress independently of a slower consumer by\n * buffering up to `capacity` chunks in a queue.\n *\n * **Details**\n *\n * Finite buffers use the configured queue strategy: `\"suspend\"` applies\n * backpressure, while `\"dropping\"` and `\"sliding\"` may discard chunks when the\n * buffer is full. This combinator preserves chunking and is best with\n * power-of-2 capacities.\n *\n * **Example** (Buffering stream chunks)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.fromArrays([1, 2], [3, 4]).pipe(\n * Stream.bufferArray({ capacity: 2 }),\n * Stream.runCollect\n * )\n * result // => [ 1, 2, 3, 4 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category buffering\n * @since 4.0.0\n */\nexport const bufferArray = /*#__PURE__*/dual(2, (self, options) => fromChannel(Channel.buffer(self.channel, options)));\n/**\n * Switches over to the stream produced by the provided function in case this\n * one fails. Allows recovery from all causes of failure, including\n * interruption if the stream is uninterruptible.\n *\n * **Example** (Catching stream causes)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2).pipe(\n * Stream.concat(Stream.fail(\"Oops!\")),\n * Stream.concat(Stream.make(3, 4))\n * )\n *\n * const recovered = stream.pipe(\n * Stream.catchCause(() => Stream.make(999))\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.runCollect(recovered)\n * values // => [ 1, 2, 999 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const catchCause = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Channel.catchCause(cause => f(cause).channel), fromChannel));\n/**\n * Recovers from defects using the provided function.\n *\n * **Details**\n *\n * Typed failures and interruptions are not caught.\n *\n * **Example** (Recovering from a defect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.die(\"boom\").pipe(\n * Stream.catchDefect((defect) => Stream.succeed(`recovered: ${defect}`))\n * )\n *\n * const result = Effect.runSync(Stream.runCollect(stream))\n * result // => [\"recovered: boom\"]\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchDefect = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Channel.catchDefect(defect => f(defect).channel), fromChannel));\n/**\n * Runs an effect when the stream fails without changing its values or error,\n * unless the tap effect itself fails.\n *\n * **Example** (Tapping stream causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Stream } from \"effect\"\n *\n * const observations: Array = []\n * const stream = Stream.make(1, 2).pipe(\n * Stream.concat(Stream.fail(\"boom\")),\n * Stream.tapCause((cause) => Effect.sync(() => observations.push(Cause.isReason(cause)))),\n * Stream.catch(() => Stream.succeed(0))\n * )\n *\n * const program = Effect.gen(function* () {\n * const result = yield* Stream.runCollect(stream)\n * result // => [1, 2, 0]\n * })\n *\n * await Effect.runPromise(program)\n * observations // => [false]\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const tapCause = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Channel.tapCause(f), fromChannel));\nconst catch_ = /*#__PURE__*/dual(2, (self, f) => fromChannel(Channel.catch(self.channel, error => f(error).channel)));\nexport {\n/**\n * Switches over to the stream produced by the provided function if this one fails.\n *\n * **Example** (Catching stream failures)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2).pipe(\n * Stream.concat(Stream.fail(\"Oops!\")),\n * Stream.catch(() => Stream.make(999))\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 1, 2, 999 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\ncatch_ as catch };\n/**\n * Peeks at errors effectfully without changing the stream unless the tap fails.\n *\n * **Example** (Effectfully peeking at errors)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const errors: Array = []\n * const stream = Stream.make(1, 2).pipe(\n * Stream.concat(Stream.fail(\"boom\")),\n * Stream.tapError((error) => Effect.sync(() => errors.push(error))),\n * Stream.catch(() => Stream.make(999))\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 999]\n * })\n *\n * await Effect.runPromise(program)\n * errors // => [\"boom\"]\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Channel.tapError(f), fromChannel));\n/**\n * Recovers from errors that match a predicate by switching to a recovery stream.\n *\n * **Details**\n *\n * When a failure matches the filter, the stream switches to the recovery\n * stream. Non-matching failures propagate downstream, so the error type is\n * preserved unless the filter narrows it.\n *\n * **Example** (Catching matching failures)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2).pipe(\n * Stream.concat(Stream.fail(42)),\n * Stream.catchIf(\n * (error): error is 42 => error === 42,\n * () => Stream.make(999)\n * )\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 1, 2, 999 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchIf = /*#__PURE__*/dual(args => isStream(args[0]), (self, predicate, f, orElse) => fromChannel(Channel.catchIf(toChannel(self), predicate, e => f(e).channel, orElse && (e => orElse(e).channel))));\n/**\n * Recovers from errors that match a `Filter` by switching to a recovery\n * stream.\n *\n * **When to use**\n *\n * Use to recover from stream errors with a reusable `Filter` when matching can\n * also narrow or transform the error before choosing the recovery stream.\n *\n * **Details**\n *\n * Successful filter results are passed to `f`. Failed filter results go to\n * `orElse` when provided; otherwise the filter failure is re-failed.\n *\n * @see {@link catchIf} for predicate or refinement based recovery\n * @see {@link catchTag} for `_tag` based recovery from one tagged error\n * @see {@link catchTags} for `_tag` based recovery from multiple tagged errors\n * @see {@link catchCauseFilter} for filtering full causes\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchFilter = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, f, orElse) => fromChannel(Channel.catchFilter(toChannel(self), filter, e => f(e).channel, orElse && (e => orElse(e).channel))));\n/**\n * Recovers from failures whose `_tag` matches the provided value by switching to\n * the stream returned by `f`.\n *\n * **When to use**\n *\n * Use when you need to handle a specific error case from a stream whose error\n * type is a tagged union with a readonly `_tag` field.\n *\n * **Example** (Catching tagged failures)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Stream } from \"effect\"\n *\n * class HttpError extends Data.TaggedError(\"HttpError\")<{ message: string }> {}\n *\n * const stream = Stream.fail(new HttpError({ message: \"timeout\" }))\n *\n * const recovered = Stream.catchTag(stream, \"HttpError\", (error) =>\n * Stream.make(`Recovered: ${error.message}`)\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.runCollect(recovered)\n * values // => [ 'Recovered: timeout' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const catchTag = /*#__PURE__*/dual(args => isStream(args[0]), (self, k, f, orElse) => {\n const pred = Array.isArray(k) ? e => hasProperty(e, \"_tag\") && k.includes(e._tag) : isTagged(k);\n return catchIf(self, pred, f, orElse);\n});\n/**\n * Switches to a recovery stream based on matching `_tag` handlers.\n *\n * **Example** (Catching tagged failures with handlers)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * class NotFound {\n * readonly _tag = \"NotFound\"\n * constructor(readonly resource: string) {}\n * }\n *\n * class Unauthorized {\n * readonly _tag = \"Unauthorized\"\n * constructor(readonly user: string) {}\n * }\n *\n * const stream = Stream.fail(new NotFound(\"profile\"))\n *\n * const program = Effect.gen(function* () {\n * const result = yield* stream.pipe(\n * Stream.catchTags({\n * NotFound: () => Stream.succeed(\"fallback\"),\n * Unauthorized: () => Stream.succeed(\"login\")\n * }),\n * Stream.runCollect\n * )\n * result // => [ 'fallback' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const catchTags = /*#__PURE__*/dual(args => isStream(args[0]), (self, cases, orElse) => {\n let keys;\n return catchFilter(self, e => {\n keys ??= Object.keys(cases);\n return hasProperty(e, \"_tag\") && isString(e[\"_tag\"]) && keys.includes(e[\"_tag\"]) ? Result.succeed(e) : Result.fail(e);\n }, e => cases[e[\"_tag\"]](e), orElse);\n});\n/**\n * Catches a specific reason within a tagged error.\n *\n * **When to use**\n *\n * Use to handle nested error causes without removing the parent error\n * from the error channel.\n *\n * **Details**\n *\n * The handler receives the unwrapped reason.\n *\n * **Example** (Catching a tagged error reason)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Stream } from \"effect\"\n *\n * class RateLimitError extends Data.TaggedError(\"RateLimitError\")<{\n * retryAfter: number\n * }> {}\n *\n * class QuotaExceededError extends Data.TaggedError(\"QuotaExceededError\")<{\n * limit: number\n * }> {}\n *\n * class AiError extends Data.TaggedError(\"AiError\")<{\n * reason: RateLimitError | QuotaExceededError\n * }> {}\n *\n * const stream = Stream.fail(\n * new AiError({ reason: new RateLimitError({ retryAfter: 60 }) })\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* stream.pipe(\n * Stream.catchReason(\"AiError\", \"RateLimitError\", (reason) =>\n * Stream.succeed(`retry: ${reason.retryAfter}`)\n * ),\n * Stream.runCollect\n * )\n * values // => [ 'retry: 60' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchReason = /*#__PURE__*/dual(args => isStream(args[0]), (self, errorTag, reasonTag, f, orElse) => fromChannel(Channel.catchReason(toChannel(self), errorTag, reasonTag, (reason, error) => f(reason, error).channel, orElse && ((reason, error) => orElse(reason, error).channel))));\n/**\n * Catches multiple reasons within a tagged error using an object of handlers.\n *\n * **Example** (Catching tagged error reasons)\n *\n * ```ts import.meta.vitest\n * import { Data, Effect, Stream } from \"effect\"\n *\n * class RateLimitError extends Data.TaggedError(\"RateLimitError\")<{\n * retryAfter: number\n * }> {}\n *\n * class QuotaExceededError extends Data.TaggedError(\"QuotaExceededError\")<{\n * limit: number\n * }> {}\n *\n * class AiError extends Data.TaggedError(\"AiError\")<{\n * reason: RateLimitError | QuotaExceededError\n * }> {}\n *\n * const stream = Stream.fail(\n * new AiError({ reason: new RateLimitError({ retryAfter: 60 }) })\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* stream.pipe(\n * Stream.catchReasons(\"AiError\", {\n * RateLimitError: (reason) => Stream.succeed(`retry: ${reason.retryAfter}`),\n * QuotaExceededError: (reason) => Stream.succeed(`quota: ${reason.limit}`)\n * }),\n * Stream.runCollect\n * )\n * values // => [ 'retry: 60' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchReasons = /*#__PURE__*/dual(args => isStream(args[0]), (self, errorTag, cases, orElse) => {\n const handlers = Object.create(null);\n for (const key of Object.keys(cases)) {\n const handler = cases[key];\n handlers[key] = (reason, error) => handler(reason, error).channel;\n }\n const orElseHandler = orElse && ((reason, error) => orElse(reason, error).channel);\n return fromChannel(Channel.catchReasons(self.channel, errorTag, handlers, orElseHandler));\n});\n/**\n * Transforms the errors emitted by this stream using `f`.\n *\n * **Example** (Mapping stream errors)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.fail(\"bad\").pipe(\n * Stream.mapError((error) => `mapped: ${error}`),\n * Stream.catch((error) => Stream.make(`recovered from ${error}`)),\n * Stream.runCollect\n * )\n * result // => [ 'recovered from mapped: bad' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const mapError = /*#__PURE__*/dual(2, (self, f) => fromChannel(Channel.mapError(self.channel, f)));\n/**\n * Recovers from stream failures by filtering the `Cause` and switching to a recovery stream.\n * Non-matching causes are re-emitted as failures.\n *\n * **Example** (Catching matching causes)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const failingStream = Stream.fail(\"NetworkError\")\n * const recovered = Stream.catchCauseIf(\n * failingStream,\n * (cause) => Cause.hasFails(cause),\n * (cause) => Stream.make(`Recovered: ${Cause.squash(cause)}`)\n * )\n *\n * const output = yield* Stream.runCollect(recovered)\n * output // => [ 'Recovered: NetworkError' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => fromChannel(Channel.catchCauseIf(self.channel, predicate, cause => f(cause).channel)));\n/**\n * Recovers from stream failures by filtering the `Cause` and switching to a\n * recovery stream.\n *\n * **When to use**\n *\n * Use when you need to recover a stream only from causes selected by a\n * `Filter`, while giving the recovery both the selected value and the original\n * `Cause`.\n *\n * **Details**\n *\n * The filter is applied to the full `Cause`. A successful filter result is\n * passed to `f` together with the original cause; a failed filter result\n * re-fails with the residual cause.\n *\n * @see {@link catchCauseIf} for predicate-based cause selection\n * @see {@link catchFilter} for filtering typed error values instead of full causes\n * @see {@link catchCause} for recovering from every cause without filtering\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchCauseFilter = /*#__PURE__*/dual(3, (self, filter, f) => fromChannel(Channel.catchCauseFilter(self.channel, filter, (failure, cause) => f(failure, cause).channel)));\n/**\n * Switches to a fallback stream if this stream is empty.\n *\n * **Example** (Switching on empty streams)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.empty.pipe(\n * Stream.orElseIfEmpty(() => Stream.make(1, 2)),\n * Stream.runCollect\n * )\n * values // => [ 1, 2 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const orElseIfEmpty = /*#__PURE__*/dual(2, (self, orElse) => fromChannel(Channel.orElseIfEmpty(self.channel, _ => toChannel(orElse()))));\n/**\n * Returns a stream that emits a fallback value when this stream fails.\n *\n * **Example** (Recovering with a fallback value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.fail(\"NetworkError\").pipe(\n * Stream.orElseSucceed((error) => `Recovered: ${error}`)\n * )\n *\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 'Recovered: NetworkError' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const orElseSucceed = /*#__PURE__*/dual(2, (self, f) => catch_(self, e => succeed(f(e))));\n/**\n * Turns typed failures into defects, making the stream infallible.\n *\n * **Example** (Turning failures into defects)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3).pipe(\n * Stream.orDie,\n * Stream.runCollect\n * )\n *\n * values // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const orDie = self => fromChannel(Channel.orDie(self.channel));\n/**\n * Ignores failures and ends the stream on error.\n *\n * **When to use**\n *\n * Use when you want a failing stream to end gracefully rather than propagate\n * the error.\n *\n * **Details**\n *\n * The `log` option controls whether the failure is logged before the stream\n * terminates.\n *\n * **Example** (Ignoring stream failures)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3).pipe(\n * Stream.concat(Stream.fail(\"boom\")),\n * Stream.ignore,\n * Stream.runCollect\n * )\n * values // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * **Example** (Configuring ignore logging)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const values = yield* Stream.fail(\"boom\").pipe(\n * Stream.ignore({ log: false }),\n * Stream.runCollect\n * )\n * values // => []\n * }))\n *\n * ```\n *\n * @see {@link ignoreCause} for a variant that also ignores defects, not just typed failures\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const ignore = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => fromChannel(Channel.ignore(self.channel, options)));\n/**\n * Ignores the stream's failure cause, including defects, and ends the stream.\n *\n * **When to use**\n *\n * Use when you need to silently suppress a stream's entire failure cause,\n * including both typed errors and defects, rather than propagate it downstream.\n *\n * **Example** (Ignoring stream failure causes)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2).pipe(\n * Stream.concat(Stream.die(\"boom\")),\n * Stream.ignoreCause({ log: false }),\n * Stream.runCollect\n * )\n * values // => [1, 2]\n * }))\n *\n * ```\n *\n * @see {@link ignore} to ignore only typed failures without suppressing defects\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const ignoreCause = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => fromChannel(Channel.ignoreCause(self.channel, options)));\n/**\n * Retries the stream according to the given schedule when it fails.\n *\n * **Details**\n *\n * This retries the entire stream, so will re-execute all of the stream's\n * acquire operations.\n *\n * The schedule is reset as soon as the first element passes through the\n * stream again.\n *\n * **Example** (Retrying stream failures)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1).pipe(\n * Stream.concat(Stream.fail(\"boom\")),\n * Stream.retry(Schedule.recurs(1)),\n * Stream.take(2),\n * Stream.runCollect\n * )\n *\n * values // => [ 1, 1 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const retry = /*#__PURE__*/dual(2, (self, policy) => fromChannel(Channel.retry(self.channel, policy)));\nconst retryWithoutReset = (self, schedule) => unwrap(Effect.map(Schedule.toStepWithMetadata(schedule), step => {\n let meta = Schedule.CurrentMetadata.defaultValue();\n const loop = () => catch_(provideServiceEffect(self, Schedule.CurrentMetadata, Effect.sync(() => meta)), error => unwrap(Pull.catchDone(Effect.map(step(error), meta_ => {\n meta = meta_;\n return unwrap(Effect.as(Effect.yieldNow, loop()));\n }), () => Effect.succeed(fail(error)))));\n return loop();\n}));\n/**\n * Applies an `ExecutionPlan` to a stream, retrying with step-provided resources\n * until it succeeds or the plan is exhausted.\n *\n * **Details**\n *\n * By default, a failing step can fallback even after emitting elements; set\n * `preventFallbackOnPartialStream` to fail instead of mixing partial output with\n * a later fallback.\n *\n * Attempts can be observed from outside the stream by passing\n * `options.onEvent`, which receives an `ExecutionPlan.Event` before each\n * attempt and after it settles; see `Effect.withExecutionPlan` for the handler\n * semantics. When a downstream consumer stops pulling early (for example\n * `Stream.take` outside the plan), the truncated attempt reports\n * `AttemptSuccess`: the consumer stopped, not the source.\n *\n * **Example** (Applying an execution plan)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, ExecutionPlan, Layer, Stream } from \"effect\"\n *\n * class Service extends Context.Service()(\"Service\", {\n * make: Effect.succeed({\n * stream: Stream.fail(\"A\") as Stream.Stream\n * })\n * }) {\n * static Bad = Layer.succeed(Service, Service.of({ stream: Stream.fail(\"A\") }))\n * static Good = Layer.succeed(Service, Service.of({ stream: Stream.make(1, 2, 3) }))\n * }\n *\n * const plan = ExecutionPlan.make(\n * { provide: Service.Bad },\n * { provide: Service.Good }\n * )\n *\n * const stream = Stream.unwrap(Effect.map(Service, (_) => _.stream))\n *\n * const program = Effect.gen(function*() {\n * const items = yield* stream.pipe(Stream.withExecutionPlan(plan), Stream.runCollect)\n * items // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category error handling\n * @since 3.16.0\n */\nexport const withExecutionPlan = /*#__PURE__*/dual(args => isStream(args[0]), (self, policy, options) => suspend(() => {\n const preventFallbackOnPartialStream = options?.preventFallbackOnPartialStream ?? false;\n let i = 0;\n let meta = {\n attempt: 0,\n stepIndex: 0\n };\n const provideMeta = provideServiceEffect(ExecutionPlan.CurrentMetadata, Effect.sync(() => {\n meta = {\n attempt: meta.attempt + 1,\n stepIndex: i\n };\n return meta;\n }));\n const emitter = options?.onEvent === undefined ? undefined : internalExecutionPlan.makeEventEmitter(options.onEvent, () => meta);\n let attemptState;\n const instrument = emitter === undefined ? identity : attempt => onExit(onStart(attempt, Effect.map(emitter.begin, state => {\n attemptState = state;\n })), exit => Effect.suspend(() => {\n if (attemptState === undefined) return Effect.void;\n const state = attemptState;\n attemptState = undefined;\n return emitter.end(state, exit);\n }));\n let lastError = Option.none();\n const loop = suspend(() => {\n const step = policy.steps[i];\n if (!step) {\n return fail(Option.getOrThrow(lastError));\n }\n let nextStream = provideMeta(instrument(provide(self, step.provide)));\n let receivedElements = false;\n if (Option.isSome(lastError)) {\n const error = lastError.value;\n let attempted = false;\n const wrapped = nextStream;\n // ensure the schedule is applied at least once\n nextStream = suspend(() => {\n if (attempted) return wrapped;\n attempted = true;\n return fail(error);\n });\n nextStream = retryWithoutReset(nextStream, internalExecutionPlan.scheduleFromStep(step, false));\n } else {\n const schedule = internalExecutionPlan.scheduleFromStep(step, true);\n nextStream = schedule ? retryWithoutReset(nextStream, schedule) : nextStream;\n }\n return catch_(preventFallbackOnPartialStream ? onFirst(nextStream, _ => {\n receivedElements = true;\n return Effect.void;\n }) : nextStream, error => {\n i++;\n if (preventFallbackOnPartialStream && receivedElements) {\n return fail(error);\n }\n lastError = Option.some(error);\n return loop;\n });\n });\n return loop;\n}));\n/**\n * Takes the first `n` elements from this stream.\n *\n * **Details**\n *\n * Finite fractional values of `n` are rounded down. `NaN` and non-positive\n * values return `Stream.empty` without evaluating the source stream.\n *\n * **Example** (Taking values from the left)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3, 4, 5).pipe(\n * Stream.take(3),\n * Stream.runCollect\n * )\n * values // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const take = /*#__PURE__*/dual(2, (self, n) => {\n const count = Count.normalize(n);\n return count === 0 ? empty : takeUntil(self, (_, i) => i === count - 1);\n});\n/**\n * Emits byte chunks until the configured limit would be exceeded, then drops\n * the crossing chunk and switches to a fallback stream.\n *\n * **Example** (Truncating at a byte limit)\n *\n * ```ts import.meta.vitest\n * import { ByteSize, Effect, Stream } from \"effect\"\n *\n * const program = Stream.make(\n * new Uint8Array([1, 2]),\n * new Uint8Array([3, 4, 5])\n * ).pipe(\n * Stream.limitBytes(ByteSize.bytes(4), () => Stream.empty),\n * Stream.runCollect,\n * Effect.map((chunks) => chunks.map((chunk) => [...chunk]))\n * )\n *\n * await Effect.runPromise(program) // => [[1, 2]]\n * ```\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const limitBytes = /*#__PURE__*/dual(3, (self, bytes, onLimitReached) => suspend(() => {\n const limit = ByteSize.fromInputUnsafe(bytes);\n let size = BigInt(0);\n let limitReached = false;\n return concat(takeWhile(self, chunk => {\n const nextSize = size + BigInt(chunk.length);\n if (nextSize > limit) {\n limitReached = true;\n return false;\n }\n size = nextSize;\n return true;\n }), suspend(() => limitReached ? onLimitReached() : empty));\n}));\n/**\n * Keeps the last `n` elements from this stream.\n *\n * **Details**\n *\n * Finite fractional values of `n` are rounded down. `NaN` and non-positive\n * values return `Stream.empty` without evaluating the source stream.\n *\n * **Example** (Taking elements from the right)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.range(1, 6).pipe(\n * Stream.takeRight(3),\n * Stream.runCollect\n * )\n * values // => [ 4, 5, 6 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const takeRight = /*#__PURE__*/dual(2, (self, n) => {\n const count = Count.normalize(n);\n if (count === 0) return empty;\n return mapAccumArray(self, MutableList.make, (list, arr) => {\n MutableList.appendAll(list, arr);\n if (list.length > count) {\n MutableList.takeNVoid(list, list.length - count);\n }\n return [list, emptyArr];\n }, {\n onHalt(list) {\n return MutableList.takeAll(list);\n }\n });\n});\n/**\n * Takes elements until the predicate matches.\n *\n * **Details**\n *\n * When `excludeLast` is `true`, the matching element is dropped.\n *\n * **Example** (Taking until a predicate matches)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.range(1, 5)\n *\n * const program = Effect.gen(function*() {\n * const inclusive = yield* stream.pipe(\n * Stream.takeUntil((n) => n % 3 === 0),\n * Stream.runCollect\n * )\n * inclusive // => [ 1, 2, 3 ]\n *\n * const exclusive = yield* stream.pipe(\n * Stream.takeUntil((n) => n % 3 === 0, { excludeLast: true }),\n * Stream.runCollect\n * )\n * exclusive // => [ 1, 2 ]\n * })\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const takeUntil = /*#__PURE__*/dual(args => isStream(args[0]), (self, predicate, options) => transformPull(self, (pull, _scope) => Effect.sync(() => {\n let i = 0;\n let done = false;\n const pump = Effect.flatMap(Effect.suspend(() => done ? Cause.done() : pull), chunk => {\n const index = chunk.findIndex(a => predicate(a, i++));\n if (index >= 0) {\n done = true;\n const arr = chunk.slice(0, options?.excludeLast ? index : index + 1);\n return Arr.isReadonlyArrayNonEmpty(arr) ? Effect.succeed(arr) : Cause.done();\n }\n return Effect.succeed(chunk);\n });\n return pump;\n})));\n/**\n * Takes stream elements until an effectful predicate returns `true`.\n *\n * **When to use**\n *\n * Use when the stopping condition needs an Effect or service and predicate\n * failure should fail the stream.\n *\n * **Example** (Taking until an effectful predicate matches)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.range(1, 5).pipe(\n * Stream.takeUntilEffect((n) => Effect.succeed(n % 3 === 0)),\n * Stream.runCollect\n * )\n * result // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const takeUntilEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, predicate, options) => transformPull(self, (pull, _scope) => Effect.sync(() => {\n let i = 0;\n let done = false;\n return Effect.gen(function* () {\n if (done) return yield* Cause.done();\n const chunk = yield* pull;\n for (let j = 0; j < chunk.length; j++) {\n if (yield* predicate(chunk[j], i++)) {\n done = true;\n const arr = chunk.slice(0, options?.excludeLast ? j : j + 1);\n return Arr.isReadonlyArrayNonEmpty(arr) ? arr : yield* Cause.done();\n }\n }\n return chunk;\n });\n})));\n/**\n * Takes the longest initial prefix of elements that satisfy the predicate.\n *\n * **Example** (Taking while a predicate holds)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.range(1, 5).pipe(\n * Stream.takeWhile((n) => n % 3 !== 0)\n * )\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(stream)\n * result // => [ 1, 2 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const takeWhile = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, (pull, _scope) => Effect.sync(() => {\n let i = 0;\n let done = false;\n const pump = Effect.flatMap(Effect.suspend(() => done ? Cause.done() : pull), chunk => {\n const out = [];\n for (let j = 0; j < chunk.length; j++) {\n if (!predicate(chunk[j], i++)) {\n done = true;\n break;\n }\n out.push(chunk[j]);\n }\n return Arr.isReadonlyArrayNonEmpty(out) ? Effect.succeed(out) : done ? Cause.done() : pump;\n });\n return pump;\n})));\n/**\n * Takes the longest initial prefix accepted by a `Filter` and emits the\n * filter's success values.\n *\n * **When to use**\n *\n * Use to keep the leading stream elements that a `Filter` accepts, emit the\n * filter's success values, and stop at the first filter failure.\n *\n * **Details**\n *\n * The stream stops at the first `Result.fail` returned by the filter.\n *\n * @see {@link takeWhile} for keeping original elements with a boolean predicate or refinement\n * @see {@link filterMap} for filtering across the whole stream instead of only the leading prefix\n * @see {@link dropWhileFilter} for dropping the accepted prefix and keeping the remaining original elements\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const takeWhileFilter = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, (pull, _scope) => Effect.sync(() => {\n let done = false;\n const pump = Effect.flatMap(Effect.suspend(() => done ? Cause.done() : pull), chunk => {\n const out = [];\n for (let j = 0; j < chunk.length; j++) {\n const result = filter(chunk[j]);\n if (Result.isFailure(result)) {\n done = true;\n break;\n }\n out.push(result.success);\n }\n return Arr.isReadonlyArrayNonEmpty(out) ? Effect.succeed(out) : done ? Cause.done() : pump;\n });\n return pump;\n})));\n/**\n * Takes elements from the stream while the effectful predicate is `true`.\n *\n * **When to use**\n *\n * Use when the leading-prefix predicate needs an Effect or service and the\n * stream should stop before the first false result.\n *\n * **Example** (Effectfully taking while a predicate holds)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.range(1, 5).pipe(\n * Stream.takeWhileEffect((n) => Effect.succeed(n % 3 !== 0)),\n * Stream.runCollect\n * )\n * result // => [ 1, 2 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const takeWhileEffect = /*#__PURE__*/dual(2, (self, predicate) => takeUntilEffect(self, (a, n) => Effect.map(predicate(a, n), b => !b), {\n excludeLast: true\n}));\n/**\n * Drops the first `n` elements from this stream.\n *\n * **Details**\n *\n * Finite fractional values of `n` are rounded down. `NaN` and non-positive\n * values return the source stream unchanged.\n *\n * **Example** (Dropping values from the left)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3, 4, 5)\n * const result = Stream.drop(stream, 2)\n *\n * const program = Effect.gen(function*() {\n * const items = yield* Stream.runCollect(result)\n * items // => [ 3, 4, 5 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const drop = /*#__PURE__*/dual(2, (self, n) => {\n const count = Count.normalize(n);\n if (count === 0) return self;\n return transformPull(self, (pull, _scope) => Effect.sync(() => {\n let dropped = 0;\n const pump = pull.pipe(Effect.flatMap(chunk => {\n if (dropped >= count) return Effect.succeed(chunk);\n dropped += chunk.length;\n if (dropped <= count) return pump;\n return Effect.succeed(chunk.slice(count - dropped));\n }));\n return pump;\n }));\n});\n/**\n * Drops elements until the specified predicate evaluates to `true`, then drops\n * that matching element.\n *\n * **Example** (Dropping until a predicate matches)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3, 4, 5)\n * const result = Stream.dropUntil(stream, (n) => n >= 3)\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const output = yield* Stream.runCollect(result)\n * output // => [ 4, 5 ]\n * }))\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const dropUntil = /*#__PURE__*/dual(2, (self, predicate) => drop(dropWhile(self, (a, i) => !predicate(a, i)), 1));\n/**\n * Drops all elements of the stream until the specified effectful predicate\n * evaluates to `true`.\n *\n * **When to use**\n *\n * Use when dropping the leading prefix requires an Effect or service and the\n * first matching element should also be dropped.\n *\n * **Example** (Dropping until an effectful predicate matches)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.range(1, 5).pipe(\n * Stream.dropUntilEffect((n) => Effect.succeed(n % 3 === 0)),\n * Stream.runCollect\n * )\n * result // => [ 4, 5 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const dropUntilEffect = /*#__PURE__*/dual(2, (self, predicate) => drop(dropWhileEffect(self, (a, i) => Effect.map(predicate(a, i), b => !b)), 1));\n/**\n * Drops elements from the stream while the specified predicate evaluates to `true`.\n *\n * **Example** (Dropping while a predicate holds)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3, 4, 5).pipe(\n * Stream.dropWhile((n) => n < 3),\n * Stream.runCollect\n * )\n * values // => [ 3, 4, 5 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, (pull, _scope) => Effect.sync(() => {\n let dropping = true;\n let index = 0;\n const filtered = Effect.flatMap(pull, arr => {\n const found = arr.findIndex(a => !predicate(a, index++));\n if (found === -1) return filtered;\n dropping = false;\n return Effect.succeed(arr.slice(found));\n });\n return Effect.suspend(() => dropping ? filtered : pull);\n})));\n/**\n * Drops elements while the filter succeeds.\n *\n * **When to use**\n *\n * Use when you need to remove a leading stream prefix based on a synchronous\n * `Filter` result while preserving the remaining original stream elements.\n *\n * **Details**\n *\n * `Result.succeed` drops the current element. The first `Result.fail` stops\n * dropping, emits that original element, and the rest of the source stream is\n * emitted without further filtering.\n *\n * @see {@link dropWhile} for boolean predicate prefix dropping\n * @see {@link takeWhileFilter} for keeping the accepted prefix as filter success values\n * @see {@link dropWhileEffect} for effectful predicate prefix dropping\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const dropWhileFilter = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, (pull, _scope) => Effect.sync(() => {\n let dropping = true;\n const filtered = Effect.flatMap(pull, arr => {\n const found = arr.findIndex(a => Result.isFailure(filter(a)));\n if (found === -1) return filtered;\n dropping = false;\n return Effect.succeed(arr.slice(found));\n });\n return Effect.suspend(() => dropping ? filtered : pull);\n})));\n/**\n * Drops elements while the specified effectful predicate evaluates to `true`.\n *\n * **Example** (Effectfully dropping while a predicate holds)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.make(1, 2, 3, 4, 5).pipe(\n * Stream.dropWhileEffect((n) => Effect.succeed(n < 3)),\n * Stream.runCollect\n * )\n * result // => [ 3, 4, 5 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const dropWhileEffect = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, (pull, _scope) => Effect.sync(() => {\n let dropping = true;\n let index = 0;\n const filtered = Effect.gen(function* () {\n while (true) {\n const arr = yield* pull;\n for (let i = 0; i < arr.length; i++) {\n const drop = yield* predicate(arr[i], index++);\n if (drop) continue;\n dropping = false;\n return arr.slice(i);\n }\n }\n });\n return Effect.suspend(() => dropping ? filtered : pull);\n})));\n/**\n * Drops the last specified number of elements from this stream.\n *\n * **Details**\n *\n * Keeps the last `n` elements in memory to drop them on completion. Finite\n * fractional values of `n` are rounded down. `NaN` and non-positive values\n * return the source stream unchanged.\n *\n * **Example** (Dropping values from the right)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.make(1, 2, 3, 4, 5).pipe(\n * Stream.dropRight(2),\n * Stream.runCollect\n * )\n * result // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category filtering\n * @since 2.0.0\n */\nexport const dropRight = /*#__PURE__*/dual(2, (self, n) => {\n const count = Count.normalize(n);\n if (count === 0) return self;\n return transformPull(self, (pull, _scope) => Effect.sync(() => {\n const list = MutableList.make();\n const emit = Effect.flatMap(pull, arr => {\n MutableList.appendAllUnsafe(list, arr);\n const toTake = list.length - count;\n const items = MutableList.takeN(list, toTake);\n return Arr.isArrayNonEmpty(items) ? Effect.succeed(items) : emit;\n });\n return emit;\n }));\n});\n/**\n * Exposes the underlying chunks as a stream of non-empty arrays.\n *\n * **Example** (Exposing stream chunks)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const chunks = yield* Stream.make(1, 2, 3, 4).pipe(\n * Stream.rechunk(2),\n * Stream.chunks,\n * Stream.runCollect\n * )\n * chunks // => [ [ 1, 2 ], [ 3, 4 ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const chunks = self => self.channel.pipe(Channel.map(Arr.of), fromChannel);\n/**\n * Groups the stream into arrays of the specified size, preserving element order.\n *\n * **Details**\n *\n * Finite fractional sizes are rounded down. `NaN` and non-positive sizes are\n * treated as `1`.\n *\n * **Example** (Rechunking stream elements)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.make(1, 2, 3, 4, 5).pipe(\n * Stream.rechunk(2),\n * Stream.chunks,\n * Stream.runCollect\n * )\n * result // => [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const rechunk = /*#__PURE__*/dual(2, (self, target) => {\n target = Count.normalizeNonEmpty(target);\n return transformPull(self, (pull, _scope) => Effect.sync(() => {\n let chunk = Arr.empty();\n let index = 0;\n let current;\n let done = false;\n return Effect.suspend(function loop() {\n if (done) return Cause.done();else if (current === undefined) {\n return Effect.flatMap(pull, arr => {\n if (chunk.length === 0 && arr.length === target) {\n return Effect.succeed(arr);\n } else if (chunk.length + arr.length < target) {\n for (let i = 0; i < arr.length; i++) {\n chunk.push(arr[i]);\n }\n return loop();\n }\n current = arr;\n return loop();\n });\n }\n for (; index < current.length;) {\n chunk.push(current[index++]);\n if (chunk.length === target) {\n const result = chunk;\n chunk = [];\n return Effect.succeed(result);\n }\n }\n index = 0;\n current = undefined;\n return loop();\n }).pipe(Pull.catchDone(() => {\n if (chunk.length === 0) return Cause.done();\n const result = chunk;\n done = true;\n chunk = [];\n return Effect.succeed(result);\n }));\n }));\n});\n/**\n * Emits a sliding window of `n` elements.\n *\n * **Details**\n *\n * Finite fractional window sizes are rounded down. `NaN` and non-positive\n * sizes are treated as `1`.\n *\n * **Example** (Emitting sliding windows)\n *\n * ```ts import.meta.vitest\n * import { Effect, pipe, Stream } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const result = yield* pipe(\n * Stream.make(1, 2, 3, 4, 5),\n * Stream.sliding(2),\n * Stream.runCollect\n * )\n * result // => [ [ 1, 2 ], [ 2, 3 ], [ 3, 4 ], [ 4, 5 ] ]\n * }))\n * ```\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const sliding = /*#__PURE__*/dual(2, (self, chunkSize) => slidingSize(self, chunkSize, 1));\n/**\n * Emits sliding windows of `chunkSize` elements, advancing by `stepSize`.\n *\n * **Details**\n *\n * Finite fractional window and step sizes are rounded down. `NaN` and\n * non-positive sizes are treated as `1`.\n *\n * **Example** (Emitting sliding windows with a step size)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const chunks = yield* Stream.make(1, 2, 3, 4, 5).pipe(\n * Stream.slidingSize(3, 2),\n * Stream.runCollect\n * )\n * chunks // => [ [ 1, 2, 3 ], [ 3, 4, 5 ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const slidingSize = /*#__PURE__*/dual(3, (self, chunkSize, stepSize) => {\n const windowSize = Count.normalizeNonEmpty(chunkSize);\n const step = Count.normalizeNonEmpty(stepSize);\n return transformPull(self, (upstream, _scope) => Effect.sync(() => {\n let cause = null;\n const list = MutableList.make();\n let emitted = false;\n let skip = 0;\n const pull = Effect.matchCauseEffect(upstream, {\n onSuccess(arr) {\n MutableList.appendAllUnsafe(list, arr);\n if (skip > 0) {\n const length = list.length;\n MutableList.takeNVoid(list, skip);\n skip = Math.max(0, skip - length);\n }\n if (list.length < windowSize) return pull;\n emitted = true;\n const chunks = [];\n while (list.length >= windowSize) {\n if (windowSize === step) {\n chunks.push(MutableList.takeN(list, windowSize));\n } else {\n chunks.push(MutableList.toArrayN(list, windowSize));\n const length = list.length;\n MutableList.takeNVoid(list, step);\n skip = Math.max(0, step - length);\n }\n }\n return Effect.succeed(chunks);\n },\n onFailure(cause_) {\n if (emitted) MutableList.takeNVoid(list, windowSize - step);\n if (list.length === 0) return Effect.failCause(cause_);\n cause = cause_;\n return Effect.succeed(Arr.of(MutableList.takeAll(list)));\n }\n });\n return Effect.suspend(() => cause ? Effect.failCause(cause) : pull);\n }));\n});\n/**\n * Splits the stream into non-empty groups whenever the predicate matches.\n *\n * **Details**\n *\n * Matching elements act as delimiters and are not included in the output.\n *\n * **Example** (Splitting on matching values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.range(0, 9).pipe(\n * Stream.split((n) => n % 4 === 0),\n * Stream.runCollect\n * )\n * result // => [ [ 1, 2, 3 ], [ 5, 6, 7 ], [ 9 ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const split = /*#__PURE__*/dual(2, (self, predicate) => mapAccumArray(self, Arr.empty, (acc, arr) => {\n const out = Arr.empty();\n for (let i = 0; i < arr.length; i++) {\n if (predicate(arr[i])) {\n if (Arr.isArrayNonEmpty(acc)) {\n out.push(acc);\n acc = [];\n }\n } else {\n acc.push(arr[i]);\n }\n }\n return [acc, out];\n}, {\n onHalt(arr) {\n return Arr.isArrayNonEmpty(arr) ? Arr.of(arr) : emptyArr;\n }\n}));\n/**\n * Combines elements from this stream and the specified stream by repeatedly\n * applying a stateful function that can pull from either side.\n *\n * **Details**\n *\n * Where possible, prefer `Stream.combineArray` for a more efficient\n * implementation.\n *\n * **Example** (Combining streams with state)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.combine(\n * Stream.make(\"A\", \"B\", \"C\"),\n * Stream.make(1, 2, 3),\n * () => true,\n * (takeLeft, pullLeft, pullRight) =>\n * takeLeft\n * ? Effect.map(pullLeft, (value) => [`L:${value}`, false] as const)\n * : Effect.map(pullRight, (value) => [`R:${value}`, true] as const)\n * )\n *\n * const program = Effect.gen(function*() {\n * const output = yield* Stream.runCollect(stream)\n * output // => [ 'L:A', 'R:1', 'L:B', 'R:2', 'L:C', 'R:3' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category merging\n * @since 2.0.0\n */\nexport const combine = /*#__PURE__*/dual(4, (self, that, s, f) => Channel.combine(Channel.flattenArray(self.channel), Channel.flattenArray(that.channel), s, f).pipe(Channel.map(Arr.of), fromChannel));\n/**\n * Combines two streams chunk-by-chunk with a stateful pull function.\n *\n * **When to use**\n *\n * Use to coordinate pulling chunks from two streams when each emitted chunk\n * depends on both sides and local state.\n *\n * **Details**\n *\n * The combining function receives the current state and pull functions for the\n * left and right streams. It returns the next non-empty chunk together with the\n * next state.\n *\n * **Example** (Combining stream chunks with state)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2).pipe(\n * Stream.combineArray(\n * Stream.make(10, 20),\n * () => true,\n * (useLeft, pullLeft, pullRight) =>\n * Effect.gen(function*() {\n * const array = useLeft ? yield* pullLeft : yield* pullRight\n * return [array, !useLeft] as const\n * })\n * )\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 1, 2, 10, 20 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const combineArray = /*#__PURE__*/dual(4, (self, that, s, f) => fromChannel(Channel.combine(self.channel, that.channel, s, f)));\n/**\n * Maps elements statefully, emitting zero or more outputs per input.\n *\n * **Example** (Statefully mapping stream values)\n *\n * ```ts import.meta.vitest\n * import { Console, Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const totals = yield* Stream.make(0, 1, 2, 3, 4, 5, 6).pipe(\n * Stream.mapAccum(() => 0, (total, n) => {\n * const next = total + n\n * return [next, [next]] as const\n * }),\n * Stream.runCollect\n * )\n *\n * totals // => [0, 1, 3, 6, 10, 15, 21]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapAccum = /*#__PURE__*/dual(args => isStream(args[0]), (self, initial, f, options) => fromChannel(Channel.mapAccum(self.channel, initial, (state, arr) => {\n const acc = Arr.empty();\n for (let index = 0; index < arr.length; index++) {\n const [newState, values] = f(state, arr[index]);\n state = newState;\n acc.push(...values);\n }\n return [state, Arr.isArrayNonEmpty(acc) ? Arr.of(acc) : emptyArr];\n}, options?.onHalt ? {\n onHalt(state) {\n const arr = options.onHalt(state);\n return Arr.isReadonlyArrayNonEmpty(arr) ? Arr.of(arr) : emptyArr;\n }\n} : undefined)));\n/**\n * Maps over non-empty chunk arrays statefully, emitting zero or more values per chunk.\n *\n * **Details**\n *\n * The mapping function runs once per chunk and the state is threaded across chunks.\n *\n * **Example** (Statefully mapping stream chunks)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const output = yield* Stream.make(1, 2, 3, 4, 5, 6).pipe(\n * Stream.rechunk(2),\n * Stream.mapAccumArray(() => 0, (sum: number, chunk) => {\n * const next = chunk.reduce((acc, n) => acc + n, sum)\n * return [next, [next]]\n * }),\n * Stream.runCollect\n * )\n * output // => [ 3, 10, 21 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapAccumArray = /*#__PURE__*/dual(args => isStream(args[0]), (self, initial, f, options) => fromChannel(Channel.mapAccum(self.channel, initial, (state, arr) => {\n const [newState, values] = f(state, arr);\n state = newState;\n return [state, Arr.isReadonlyArrayNonEmpty(values) ? Arr.of(values) : emptyArr];\n}, options?.onHalt ? {\n onHalt(state) {\n const arr = options.onHalt(state);\n return Arr.isReadonlyArrayNonEmpty(arr) ? Arr.of(arr) : emptyArr;\n }\n} : undefined)));\nconst emptyArr = /*#__PURE__*/Arr.empty();\n/**\n * Maps each element statefully and effectfully, emitting zero or more output\n * values per input.\n *\n * **When to use**\n *\n * Use when stateful element mapping needs Effects or can fail while emitting\n * zero or more values per input element.\n *\n * **Details**\n *\n * The mapping effect receives the current state and element, then returns the\n * next state plus the values to emit. The state is threaded through the\n * stream.\n *\n * **Example** (Effectfully mapping stream values with state)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.make(1, 1, 1).pipe(\n * Stream.mapAccumEffect(() => 0, (total, n) =>\n * Effect.succeed([total + n, [total + n]])\n * ),\n * Stream.runCollect\n * )\n *\n * result // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const mapAccumEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, initial, f, options) => self.channel.pipe(Channel.flattenArray, Channel.mapAccum(initial, (state, a) => Effect.map(f(state, a), ([state, values]) => [state, Arr.isReadonlyArrayNonEmpty(values) ? Arr.of(values) : Arr.empty()]), options?.onHalt ? {\n onHalt(state) {\n const arr = options.onHalt(state);\n return Arr.isReadonlyArrayNonEmpty(arr) ? Arr.of(arr) : emptyArr;\n }\n} : undefined), fromChannel));\n/**\n * Maps each non-empty input chunk statefully and effectfully, emitting zero or\n * more output values per chunk.\n *\n * **When to use**\n *\n * Use when stateful mapping should process each emitted non-empty chunk with an\n * Effect instead of each element separately.\n *\n * **Details**\n *\n * The mapping effect receives the current state and chunk, then returns the\n * next state plus the values to emit. The state is threaded across chunks.\n *\n * **Example** (Effectfully mapping stream chunks with state)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const totals = yield* Stream.make(1, 2, 3, 4).pipe(\n * Stream.rechunk(2),\n * Stream.mapAccumArrayEffect(() => 0, (total, chunk) =>\n * Effect.gen(function*() {\n * const next = chunk.reduce((sum, value) => sum + value, total)\n * return [next, [next]] as const\n * })\n * ),\n * Stream.runCollect\n * )\n * totals // => [ 3, 10 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapAccumArrayEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, initial, f, options) => self.channel.pipe(Channel.mapAccum(initial, (state, a) => Effect.map(f(state, a), ([state, values]) => [state, Arr.isReadonlyArrayNonEmpty(values) ? Arr.of(values) : emptyArr]), options?.onHalt ? {\n onHalt(state) {\n const arr = options.onHalt(state);\n return Arr.isReadonlyArrayNonEmpty(arr) ? Arr.of(arr) : emptyArr;\n }\n} : undefined), fromChannel));\n/**\n * Accumulates state across the stream, emitting the initial state and each updated state.\n *\n * **Example** (Scanning stream state)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3).pipe(\n * Stream.scan(0, (acc, n) => acc + n),\n * Stream.runCollect\n * )\n * values // => [ 0, 1, 3, 6 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category accumulation\n * @since 2.0.0\n */\nexport const scan = /*#__PURE__*/dual(3, (self, initial, f) => suspend(() => {\n let isFirst = true;\n return fromChannel(Channel.mapAccum(self.channel, constant(initial), (state, arr) => {\n const states = Arr.empty();\n if (isFirst) {\n isFirst = false;\n states.push(state);\n }\n for (let index = 0; index < arr.length; index++) {\n state = f(state, arr[index]);\n states.push(state);\n }\n return [state, Arr.of(states)];\n }));\n}));\n/**\n * Accumulates state effectfully and emits the initial state plus each accumulated state.\n *\n * **Example** (Effectfully scanning stream state)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const states = yield* Stream.make(1, 2, 3).pipe(\n * Stream.scanEffect(0, (sum, n) => Effect.succeed(sum + n)),\n * Stream.runCollect\n * )\n * states // => [ 0, 1, 3, 6 ]\n * })\n * await Effect.runPromise(program)\n * ```\n *\n * @category accumulation\n * @since 2.0.0\n */\nexport const scanEffect = /*#__PURE__*/dual(3, (self, initial, f) => self.channel.pipe(Channel.flattenArray, Channel.scanEffect(initial, f), Channel.map(Arr.of), fromChannel));\n/**\n * Drops earlier elements within the debounce window and emits only the latest element after the pause.\n *\n * **Example** (Debouncing stream elements)\n *\n * ```ts import.meta.vitest\n * import { Duration, Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3).pipe(Stream.debounce(Duration.zero))\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 3 ]\n * })\n * await Effect.runPromise(program)\n * ```\n *\n * @category rate limiting\n * @since 2.0.0\n */\nexport const debounce = /*#__PURE__*/dual(2, (self, duration) => transformPull(self, Effect.fnUntraced(function* (pull, scope) {\n const clock = yield* Clock;\n const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration));\n let lastArr;\n let cause;\n let emitAtMs = Infinity;\n const pullLatch = Latch.makeUnsafe();\n const emitLatch = Latch.makeUnsafe();\n const endLatch = Latch.makeUnsafe();\n yield* pull.pipe(pullLatch.whenOpen, Effect.flatMap(arr => {\n emitLatch.openUnsafe();\n lastArr = arr;\n emitAtMs = clock.currentTimeMillisUnsafe() + durationMs;\n return Effect.void;\n }), Effect.forever({\n disableYield: true\n }), Effect.onError(cause_ => {\n cause = cause_;\n emitAtMs = clock.currentTimeMillisUnsafe();\n emitLatch.openUnsafe();\n endLatch.openUnsafe();\n return Effect.void;\n }), Effect.forkIn(scope));\n const sleepLoop = Effect.suspend(function loop() {\n const now = clock.currentTimeMillisUnsafe();\n const timeMs = emitAtMs < now ? durationMs : Math.min(durationMs, emitAtMs - now);\n return Effect.flatMap(Effect.raceFirst(Effect.sleep(timeMs), endLatch.await), () => {\n const now = clock.currentTimeMillisUnsafe();\n if (now < emitAtMs) {\n return loop();\n } else if (lastArr) {\n emitLatch.closeUnsafe();\n pullLatch.closeUnsafe();\n const eff = Effect.succeed(Arr.of(Arr.lastNonEmpty(lastArr)));\n lastArr = undefined;\n return eff;\n } else if (cause) {\n return Effect.failCause(cause);\n }\n return loop();\n });\n });\n return Effect.suspend(() => {\n if (cause) {\n if (lastArr) {\n const eff = Effect.succeed(Arr.of(Arr.lastNonEmpty(lastArr)));\n lastArr = undefined;\n return eff;\n }\n return Effect.failCause(cause);\n }\n pullLatch.openUnsafe();\n return emitLatch.whenOpen(sleepLoop);\n });\n})));\n/**\n * Rate-limits stream chunks with an effectful cost function.\n *\n * **When to use**\n *\n * Use to throttle chunks when computing each chunk's cost requires an effect.\n *\n * **Details**\n *\n * Uses a token bucket. The bucket can accumulate up to `units + burst` tokens,\n * and each chunk consumes the cost returned by the effectful `cost` function.\n *\n * If using the \"enforce\" strategy, arrays that do not meet the bandwidth\n * constraints are dropped. If using the \"shape\" strategy, arrays are delayed\n * until they can be emitted without exceeding the bandwidth constraints.\n *\n * Defaults to the \"shape\" strategy.\n *\n * **Example** (Throttling stream chunks effectfully)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.range(0, 5).pipe(\n * Stream.rechunk(1),\n * Stream.throttleEffect({\n * cost: (arr) => Effect.succeed(arr.length),\n * units: 1,\n * duration: 0,\n * strategy: \"shape\"\n * })\n * )\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const result = yield* Stream.runCollect(stream)\n * result // => [ 0, 1, 2, 3, 4, 5 ]\n * }))\n * ```\n *\n * @category rate limiting\n * @since 2.0.0\n */\nexport const throttleEffect = /*#__PURE__*/dual(2, (self, options) => {\n const burst = options.burst ?? 0;\n if (options.strategy === \"enforce\") {\n return throttleEnforceEffect(self, options.cost, options.units, options.duration, burst);\n }\n return throttleShapeEffect(self, options.cost, options.units, options.duration, burst);\n});\nconst throttleEnforceEffect = (self, cost, units, duration, burst) => transformPull(self, pull => Effect.clockWith(clock => {\n const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration));\n const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst;\n let tokens = units;\n let timestampMs = clock.currentTimeMillisUnsafe();\n return Effect.succeed(Effect.flatMap(pull, function loop(arr) {\n return Effect.flatMap(cost(arr), weight => {\n const currentMs = clock.currentTimeMillisUnsafe();\n const elapsed = currentMs - timestampMs;\n const cycles = elapsed / durationMs;\n const sum = tokens + cycles * units;\n const available = sum < 0 ? max : Math.min(sum, max);\n if (weight <= available) {\n tokens = available - weight;\n timestampMs = currentMs;\n return Effect.succeed(arr);\n }\n // Drop the array and continue\n return Effect.flatMap(pull, loop);\n });\n }));\n}));\nconst throttleShapeEffect = (self, cost, units, duration, burst) => transformPull(self, pull => Effect.clockWith(clock => {\n const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration));\n const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst;\n let tokens = units;\n let timestampMs = clock.currentTimeMillisUnsafe();\n return Effect.succeed(Effect.flatMap(pull, arr => Effect.flatMap(cost(arr), weight => {\n const currentMs = clock.currentTimeMillisUnsafe();\n const elapsed = currentMs - timestampMs;\n const cycles = elapsed / durationMs;\n const sum = tokens + cycles * units;\n const available = sum < 0 ? max : Math.min(sum, max);\n const remaining = available - weight;\n if (remaining >= 0) {\n tokens = remaining;\n timestampMs = currentMs;\n return Effect.succeed(arr);\n }\n // Calculate delay needed\n const waitCycles = -remaining / units;\n const delayMs = Math.max(0, waitCycles * durationMs);\n if (delayMs > 0) {\n return Effect.flatMap(Effect.sleep(delayMs), () => {\n tokens = remaining;\n timestampMs = currentMs;\n return Effect.succeed(arr);\n });\n }\n tokens = remaining;\n timestampMs = currentMs;\n return Effect.succeed(arr);\n })));\n}));\n/**\n * Rate-limits stream chunks with a synchronous cost function.\n *\n * **When to use**\n *\n * Use to throttle chunks when each chunk's cost can be computed synchronously.\n *\n * **Details**\n *\n * Uses a token bucket. The bucket can accumulate up to `units + burst` tokens,\n * and each chunk consumes the cost returned by `cost`.\n *\n * If using the \"enforce\" strategy, arrays that do not meet the bandwidth\n * constraints are dropped. If using the \"shape\" strategy, arrays are delayed\n * until they can be emitted without exceeding the bandwidth constraints.\n *\n * Defaults to the \"shape\" strategy.\n *\n * **Example** (Throttling stream chunks)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.range(0, 5).pipe(\n * Stream.rechunk(1),\n * Stream.throttle({\n * cost: (arr) => arr.length,\n * units: 1,\n * duration: 0,\n * strategy: \"shape\"\n * })\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 0, 1, 2, 3, 4, 5 ]\n * })\n * await Effect.runPromise(program)\n * ```\n *\n * @category rate limiting\n * @since 2.0.0\n */\nexport const throttle = /*#__PURE__*/dual(2, (self, options) => throttleEffect(self, {\n ...options,\n cost: arr => Effect.succeed(options.cost(arr))\n}));\n/**\n * Partitions the stream into non-empty arrays of the specified size.\n *\n * **Details**\n *\n * The final array may be smaller if there are not enough elements to fill it.\n * Finite fractional sizes are rounded down. `NaN` and non-positive sizes are\n * treated as `1`.\n *\n * **Example** (Grouping elements by size)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const grouped = yield* Stream.range(1, 8).pipe(\n * Stream.grouped(3),\n * Stream.runCollect\n * )\n * grouped // => [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8 ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const grouped = /*#__PURE__*/dual(2, (self, n) => chunks(rechunk(self, n)));\n/**\n * Partitions the stream into arrays, emitting when the chunk size is reached\n * or the duration passes.\n *\n * **Details**\n *\n * Finite fractional chunk sizes are rounded down. `NaN` and non-positive sizes\n * are treated as `1`.\n *\n * **Example** (Grouping elements by size or time)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3).pipe(\n * Stream.groupedWithin(2, \"5 seconds\"),\n * Stream.runCollect\n * )\n * values // => [ [ 1, 2 ], [ 3 ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const groupedWithin = /*#__PURE__*/dual(3, (self, chunkSize, duration) => aggregateWithin(self, Sink.take(Count.normalizeNonEmpty(chunkSize)), Schedule.spaced(duration)));\n/**\n * Groups elements into keyed substreams using an effectful classifier.\n *\n * **Example** (Grouping elements into keyed substreams using an effectful classifier)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const grouped = yield* Stream.make(1, 2, 3, 4, 5).pipe(\n * Stream.groupBy((n) =>\n * Effect.succeed([n % 2 === 0 ? \"even\" : \"odd\", n] as const)\n * ),\n * Stream.mapEffect(\n * Effect.fnUntraced(function*([key, stream]) {\n * return [key, yield* Stream.runCollect(stream)] as const\n * }),\n * { concurrency: \"unbounded\" }\n * ),\n * Stream.runCollect\n * )\n *\n * grouped // => [ [ 'odd', [ 1, 3, 5 ] ], [ 'even', [ 2, 4 ] ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const groupBy = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, options) => groupByImpl(self, Effect.fnUntraced(function* (arr, queues, queueMap) {\n for (let i = 0; i < arr.length; i++) {\n const [key, value] = yield* f(arr[i]);\n const oentry = MutableHashMap.get(queueMap, key);\n const queue = Option.isSome(oentry) ? oentry.value : yield* Effect.scoped(RcMap.get(queues, key));\n yield* RcMap.touch(queues, key);\n yield* Queue.offer(queue, value);\n }\n}), options));\n/**\n * Groups elements by a key and emits a stream per key.\n *\n * **Example** (Grouping elements by key)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const grouped = yield* Stream.make(1, 2, 3, 4, 5).pipe(\n * Stream.groupByKey((n) => n % 2 === 0 ? \"even\" : \"odd\"),\n * Stream.mapEffect(\n * ([key, stream]) =>\n * Stream.runCollect(stream).pipe(\n * Effect.map((values) => [key, values] as const)\n * ),\n * { concurrency: \"unbounded\" }\n * ),\n * Stream.runCollect\n * )\n * grouped // => [ [ 'odd', [ 1, 3, 5 ] ], [ 'even', [ 2, 4 ] ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const groupByKey = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, options) => suspend(() => {\n const batch = MutableHashMap.empty();\n return groupByImpl(self, Effect.fnUntraced(function* (arr, queues, queueMap) {\n for (let i = 0; i < arr.length; i++) {\n const key = f(arr[i]);\n const ovalues = MutableHashMap.get(batch, key);\n if (Option.isNone(ovalues)) {\n MutableHashMap.set(batch, key, [arr[i]]);\n } else {\n ovalues.value.push(arr[i]);\n }\n }\n for (const [key, values] of batch) {\n const oentry = MutableHashMap.get(queueMap, key);\n const queue = Option.isSome(oentry) ? oentry.value : yield* Effect.scoped(RcMap.get(queues, key));\n yield* RcMap.touch(queues, key);\n yield* Queue.offerAll(queue, values);\n }\n MutableHashMap.clear(batch);\n }), options);\n}));\nconst groupByImpl = (self, f, options) => transformPullBracket(self, Effect.fnUntraced(function* (pull, scope, forkedScope) {\n const out = yield* Queue.unbounded();\n yield* Scope.addFinalizer(scope, Queue.shutdown(out));\n const queueMap = MutableHashMap.empty();\n const queues = yield* RcMap.make({\n lookup: key => Effect.acquireRelease(Queue.make({\n capacity: options?.bufferSize ?? 4096\n }).pipe(Effect.tap(queue => {\n MutableHashMap.set(queueMap, key, queue);\n return Queue.offer(out, [key, fromQueue(queue)]);\n })), queue => {\n MutableHashMap.remove(queueMap, key);\n return Queue.end(queue);\n }),\n idleTimeToLive: options?.idleTimeToLive ?? Duration.infinity\n }).pipe(Scope.provide(forkedScope));\n yield* Effect.whileLoop({\n while: constTrue,\n body: constant(Effect.flatMap(pull, arr => f(arr, queues, queueMap))),\n step: constVoid\n }).pipe(Effect.catchCause(cause => Queue.failCause(out, cause)), Effect.forkIn(scope));\n return Queue.takeAll(out);\n}));\n/**\n * Groups consecutive elements that have equal keys into non-empty arrays.\n *\n * **When to use**\n *\n * Use when you already have a stream ordered by the grouping key and want to\n * emit each consecutive run as a non-empty array while keeping later\n * non-adjacent runs separate.\n *\n * **Details**\n *\n * The key is computed with `f`; adjacent elements whose keys are equal by\n * `Equal.equals` are emitted as one `[key, group]`. Later non-adjacent runs\n * with the same key are emitted separately.\n *\n * @see {@link groupByKey} for grouping all elements with the same key across the stream\n * @see {@link groupBy} for custom grouped stream construction\n *\n * @category grouping\n * @since 2.0.0\n */\nexport const groupAdjacentBy = /*#__PURE__*/dual(2, (self, f) => transformPull(self, (pull, _scope) => Effect.sync(() => {\n let currentKey = undefined;\n let group;\n let toEmit = Arr.empty();\n const loop = pull.pipe(Effect.flatMap(chunk => {\n for (let i = 0; i < chunk.length; i++) {\n const item = chunk[i];\n const key = f(item);\n if (group === undefined) {\n currentKey = key;\n group = [item];\n continue;\n } else if (Equal.equals(key, currentKey)) {\n group.push(item);\n continue;\n }\n toEmit.push([currentKey, group]);\n currentKey = key;\n group = [item];\n }\n if (Arr.isArrayNonEmpty(toEmit)) {\n const out = toEmit;\n toEmit = [];\n return Effect.succeed(out);\n }\n return loop;\n }));\n let done = false;\n return Pull.catchDone(Effect.suspend(() => done ? Cause.done() : loop), () => {\n done = true;\n const out = group;\n group = undefined;\n return out && Arr.isArrayNonEmpty(out) ? Effect.succeed(Arr.of([currentKey, out])) : Cause.done();\n });\n})));\n/**\n * Applies a sink transducer to the stream and emits each sink result.\n *\n * **Example** (Transducing with a sink)\n *\n * ```ts import.meta.vitest\n * import { Effect, Sink, Stream } from \"effect\"\n *\n * const program = Effect.gen(function* () {\n * const result = yield* Stream.make(1, 2, 3, 4).pipe(\n * Stream.transduce(Sink.take(2)),\n * Stream.runCollect\n * )\n *\n * result // => [ [ 1, 2 ], [ 3, 4 ], [] ]\n * })\n * await Effect.runPromise(program)\n * ```\n *\n * @category aggregation\n * @since 2.0.0\n */\nexport const transduce = /*#__PURE__*/dual(2, (self, sink) => transformPull(self, (upstream, scope) => Effect.sync(() => {\n let done;\n let leftover;\n const upstreamWithLeftover = Effect.suspend(() => {\n if (leftover !== undefined) {\n const chunk = leftover;\n leftover = undefined;\n return Effect.succeed(chunk);\n }\n return upstream;\n }).pipe(Effect.catch(error => {\n done = Exit.fail(error);\n return Cause.done();\n }));\n const pull = Effect.map(Effect.suspend(() => sink.transform(upstreamWithLeftover, scope)), ([value, leftover_]) => {\n leftover = leftover_;\n return Arr.of(value);\n });\n return Effect.suspend(() => done ? done : pull);\n})));\n/**\n * Aggregates elements using the provided sink and emits each sink result as a stream element.\n *\n * **Details**\n *\n * The stream runs the upstream and downstream in separate fibers, so the sink can keep\n * consuming input while downstream is busy processing the previous output.\n *\n * **Example** (Aggregating with a sink)\n *\n * ```ts import.meta.vitest\n * import { Effect, Sink, Stream } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function* () {\n * const aggregated = yield* Stream.runCollect(\n * Stream.make(1, 2, 3, 4, 5, 6).pipe(\n * Stream.aggregate(\n * Sink.foldUntil(() => 0, 3, (sum, n) => Effect.succeed(sum + n))\n * )\n * )\n * )\n * aggregated // => [ 6, 15 ]\n * }))\n * ```\n *\n * @category aggregation\n * @since 2.0.0\n */\nexport const aggregate = /*#__PURE__*/dual(2, (self, sink) => aggregateWithin(self, sink, Schedule.forever));\n/**\n * Aggregates elements with a sink, emitting each result when the sink completes or the schedule triggers.\n *\n * **Details**\n *\n * The schedule can flush the current aggregation even if the sink has not finished.\n *\n * **Example** (Aggregating with a sink and schedule)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schedule, Sink, Stream } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function* () {\n * const aggregated = yield* Stream.runCollect(\n * Stream.make(1, 2, 3, 4, 5, 6).pipe(\n * Stream.aggregateWithin(\n * Sink.foldUntil(() => 0, 3, (sum, n) => Effect.succeed(sum + n)),\n * Schedule.forever\n * )\n * )\n * )\n * aggregated // => [ 6, 15 ]\n * }))\n * ```\n *\n * @category aggregation\n * @since 2.0.0\n */\nexport const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => fromChannel(Channel.fromTransformBracket(Effect.fnUntraced(function* (_upstream, _, scope) {\n const pull = yield* Channel.toPullScoped(self.channel, _);\n const pullLatch = Latch.makeUnsafe(false);\n const scheduleStep = Symbol();\n const buffer = yield* Queue.make({\n capacity: 0\n });\n // upstream -> buffer\n yield* pull.pipe(pullLatch.whenOpen, Effect.flatMap(arr => {\n pullLatch.closeUnsafe();\n return Queue.offer(buffer, arr);\n }), Effect.forever,\n // don't disable autoYield to prevent choking the schedule\n Effect.catchCause(cause => Queue.failCause(buffer, cause)), Effect.forkIn(scope));\n // schedule -> buffer\n let lastOutput = Option.none();\n let leftover;\n let sinkHasInput = false;\n const step = yield* Schedule.toStepWithSleep(schedule);\n const stepLoop = Effect.suspend(function loop() {\n return Effect.flatMap(step(lastOutput), () => !sinkHasInput ? loop() : Queue.offer(buffer, scheduleStep));\n });\n const stepToBuffer = stepLoop.pipe(Effect.flatMap(() => Effect.never), Pull.catchDone(() => Cause.done()));\n // buffer -> sink\n const pullFromBuffer = Queue.take(buffer).pipe(Effect.flatMap(arr => {\n if (arr === scheduleStep) {\n return Cause.done();\n }\n sinkHasInput = true;\n return Effect.succeed(arr);\n }));\n const sinkUpstream = Effect.suspend(() => {\n if (leftover !== undefined) {\n const chunk = leftover;\n leftover = undefined;\n sinkHasInput = true;\n return Effect.succeed(chunk);\n }\n pullLatch.openUnsafe();\n return pullFromBuffer;\n });\n const catchSinkHalt = Effect.flatMap(([value, leftover_]) => {\n // ignore the last output if the upstream only pulled a halt\n if (!sinkHasInput && buffer.state._tag === \"Done\") return Cause.done();\n lastOutput = Option.some(value);\n leftover = leftover_;\n return Effect.succeed(Arr.of(value));\n });\n return Effect.suspend(() => {\n // if the buffer has exited and there is no more data to process\n if (buffer.state._tag === \"Done\" && leftover === undefined) {\n return buffer.state.exit;\n }\n sinkHasInput = leftover !== undefined;\n return Effect.succeed(Effect.suspend(() => sink.transform(sinkUpstream, scope)));\n }).pipe(Effect.flatMap(pull => Effect.raceFirst(catchSinkHalt(pull), stepToBuffer)));\n}))));\n/**\n * Creates a fixed-size tuple of streams that each emit\n * the same elements as the source stream.\n *\n * **Details**\n *\n * The source stream starts after all downstream streams have been subscribed.\n * With the default suspend strategy, the source can only advance `capacity`\n * chunks ahead of the slowest downstream stream. If a downstream stream is\n * interrupted, it unsubscribes from the broadcast so it no longer contributes\n * backpressure. Finite fractional values of `n` are rounded down. `NaN` and\n * non-positive values create no downstream streams.\n *\n * **Example** (Broadcasting to two consumers)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * const [left, right] = yield* Stream.make(1, 2, 3).pipe(\n * Stream.broadcastN({ n: 2, capacity: 8 })\n * )\n *\n * const values = yield* Effect.all([\n * Stream.runCollect(left),\n * Stream.runCollect(right)\n * ], { concurrency: \"unbounded\" })\n *\n * values // => [ [ 1, 2, 3 ], [ 1, 2, 3 ] ]\n * })\n * )\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category broadcasting\n * @since 4.0.0\n */\nexport const broadcastN = /*#__PURE__*/dual(2, /*#__PURE__*/Effect.fnUntraced(function* (self, options) {\n const n = Count.normalize(options.n);\n const pubsub = yield* makePubSub(options);\n const streams = new Array(n);\n const parentScope = yield* Scope.Scope;\n for (let i = 0; i < n; i++) {\n const scope = Scope.forkUnsafe(parentScope);\n const subscription = yield* PubSub.subscribe(pubsub).pipe(Effect.provideService(Scope.Scope, scope));\n streams[i] = Channel.fromEffectTake(PubSub.take(subscription)).pipe(Channel.onExit(exit => Scope.close(scope, exit)), fromChannel);\n }\n yield* Channel.runForEach(self.channel, value => PubSub.publish(pubsub, value)).pipe(Effect.onExit(exit => PubSub.publish(pubsub, exit)), Effect.forkScoped);\n return streams;\n}));\nconst makePubSub = options => Effect.acquireRelease(options.capacity === \"unbounded\" ? PubSub.unbounded(options) : options.strategy === \"dropping\" ? PubSub.dropping(options) : options.strategy === \"sliding\" ? PubSub.sliding(options) : PubSub.bounded(options), PubSub.shutdown);\n/**\n * Creates a PubSub-backed stream that multicasts the source to all subscribers.\n *\n * **Details**\n *\n * The returned stream is scoped and uses the provided PubSub capacity and replay settings.\n *\n * **Example** (Broadcasting a stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.scoped(\n * Effect.gen(function* () {\n * const broadcasted = yield* Stream.broadcast(Stream.fromArray([1, 2, 3]), {\n * capacity: 8,\n * replay: 3\n * })\n *\n * const [left, right] = yield* Effect.all([\n * Stream.runCollect(broadcasted),\n * Stream.runCollect(broadcasted)\n * ], { concurrency: \"unbounded\" })\n *\n * const result = [left, right] // => [[1, 2, 3], [1, 2, 3]]\n * })\n * )\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category broadcasting\n * @since 2.0.0\n */\nexport const broadcast = /*#__PURE__*/dual(2, (self, options) => Effect.map(toPubSubTake(self, options), fromPubSubTake));\n/**\n * Returns a new Stream that multicasts the original stream, subscribing when the first consumer starts.\n *\n * **Details**\n *\n * The upstream continues running while there is at least one consumer and is finalized after the last one exits.\n * If `idleTimeToLive` is set, the upstream is kept alive for that duration so a later subscriber can continue from\n * the next element instead of restarting.\n *\n * **Example** (Sharing a stream)\n *\n * ```ts import.meta.vitest\n * import { Deferred, Effect, Ref, Stream } from \"effect\"\n *\n * const result = await Effect.runPromise(\n * Effect.scoped(\n * Effect.gen(function*() {\n * const firstReady = yield* Deferred.make()\n * const secondReady = yield* Deferred.make()\n * const acquisitions = yield* Ref.make(0)\n * const source = Stream.fromEffect(Ref.update(acquisitions, (n) => n + 1)).pipe(\n * Stream.drain,\n * Stream.concat(Stream.make(0)),\n * Stream.concat(\n * Stream.fromEffect(Effect.all([Deferred.await(firstReady), Deferred.await(secondReady)])).pipe(Stream.drain)\n * ),\n * Stream.concat(Stream.make(1, 2, 3))\n * )\n * const shared = yield* Stream.share(source, { capacity: 16, replay: 1 })\n * const consume = (ready: Deferred.Deferred) =>\n * shared.pipe(\n * Stream.tap((value) => value === 0 ? Deferred.succeed(ready, void 0) : Effect.void),\n * Stream.filter((value) => value !== 0),\n * Stream.runCollect\n * )\n *\n * const values = yield* Effect.all([consume(firstReady), consume(secondReady)], { concurrency: \"unbounded\" })\n * return { values, acquisitions: yield* Ref.get(acquisitions) }\n * })\n * )\n * )\n * result // => { values: [[1, 2, 3], [1, 2, 3]], acquisitions: 1 }\n * ```\n *\n * @category broadcasting\n * @since 3.8.0\n */\nexport const share = /*#__PURE__*/dual(2, (self, options) => Effect.map(RcRef.make({\n acquire: broadcast(self, options),\n idleTimeToLive: options.idleTimeToLive\n}), ref => unwrap(RcRef.get(ref))));\n/**\n * Pipes this stream through a channel that consumes and emits chunked elements.\n *\n * **Details**\n *\n * The channel receives `NonEmptyReadonlyArray` chunks and can transform both the\n * output elements and error type.\n *\n * **Example** (Piping through a channel)\n *\n * ```ts import.meta.vitest\n * import { Array, Channel, Effect, Stream } from \"effect\"\n *\n * type NumberChunk = readonly [number, ...Array]\n *\n * const doubleChunks = Channel.identity().pipe(\n * Channel.map((chunk) => Array.map(chunk, (n) => n * 2))\n * )\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.fromArray([1, 2, 3]).pipe(\n * Stream.rechunk(2),\n * Stream.pipeThroughChannel(doubleChunks),\n * Stream.runCollect\n * )\n * result // => [ 2, 4, 6 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const pipeThroughChannel = /*#__PURE__*/dual(2, (self, channel) => fromChannel(Channel.pipeTo(self.channel, channel)));\n/**\n * Pipes values through the provided channel while preserving this stream's\n * failures alongside any channel failures.\n *\n * **Details**\n *\n * Upstream failures are not passed to the channel, so the resulting stream can\n * fail with either the original stream error or the channel error.\n *\n * **Example** (Piping through a channel with failures)\n *\n * ```ts import.meta.vitest\n * import { Array, Channel, Effect, Stream } from \"effect\"\n *\n * type NumberChunk = readonly [number, ...Array]\n *\n * const stringifyChunks = Channel.identity().pipe(\n * Channel.map((chunk) => Array.map(chunk, String))\n * )\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const result = yield* Stream.make(1, 2, 3).pipe(\n * Stream.rechunk(2),\n * Stream.pipeThroughChannelOrFail(stringifyChunks),\n * Stream.runCollect\n * )\n *\n * result // => [\"1\", \"2\", \"3\"]\n * }))\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const pipeThroughChannelOrFail = /*#__PURE__*/dual(2, (self, channel) => fromChannel(Channel.pipeToOrFail(self.channel, channel)));\n/**\n * Pipes the stream through `Sink.toChannel`, emitting only the sink leftovers.\n *\n * **Details**\n *\n * If the sink completes mid-chunk, the remaining elements become the output stream.\n *\n * **Example** (Piping through a sink)\n *\n * ```ts import.meta.vitest\n * import { Effect, Sink, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const leftovers = yield* Stream.make(1, 2, 3, 4).pipe(\n * Stream.pipeThrough(Sink.take(2)),\n * Stream.runCollect\n * )\n *\n * leftovers // => [ 3, 4 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const pipeThrough = /*#__PURE__*/dual(2, (self, sink) => self.channel.pipe(Channel.pipeToOrFail(Sink.toChannel(sink)), Channel.concatWith(([_, leftover]) => leftover ? Channel.succeed(leftover) : Channel.empty), fromChannel));\n/**\n * Collects all elements into an array and emits it as a single element.\n *\n * **Example** (Collecting values into a stream element)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3)\n *\n * const program = Effect.gen(function*() {\n * const collected = yield* stream.pipe(Stream.collect, Stream.runCollect)\n * collected[0] // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category accumulation\n * @since 4.0.0\n */\nexport const collect = self => fromEffect(runCollect(self));\n/**\n * Accumulates elements into a growing array, emitting the cumulative array for each input chunk.\n *\n * **Example** (Accumulating stream elements)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const accumulated = yield* Stream.runCollect(\n * Stream.fromArray([1, 2, 3]).pipe(\n * Stream.rechunk(1),\n * Stream.accumulate\n * )\n * )\n * accumulated // => [ [ 1 ], [ 1, 2 ], [ 1, 2, 3 ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category accumulation\n * @since 2.0.0\n */\nexport const accumulate = self => mapAccumArray(self, Arr.empty, (acc, as) => {\n const combined = Arr.appendAll(acc, as);\n return [combined, [combined]];\n});\n/**\n * Emits only elements that differ from the previous one.\n *\n * **Example** (Emitting changed values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.fromIterable([1, 1, 2, 2, 3]).pipe(\n * Stream.changes,\n * Stream.runCollect\n * )\n *\n * values // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category deduplication\n * @since 2.0.0\n */\nexport const changes = self => changesWith(self, Equal.equals);\n/**\n * Returns a stream that only emits elements that are not equal to the previously emitted element, as determined by the specified predicate.\n *\n * **Example** (Emitting values that changed by equivalence)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(\"A\", \"a\", \"B\", \"b\", \"b\").pipe(\n * Stream.changesWith((left, right) => left.toLowerCase() === right.toLowerCase())\n * )\n *\n * await Effect.runPromise(\n * Effect.gen(function*() {\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 'A', 'B' ]\n * })\n * )\n * ```\n *\n * @category deduplication\n * @since 2.0.0\n */\nexport const changesWith = /*#__PURE__*/dual(2, (self, f) => transformPull(self, (pull, _scope) => Effect.sync(() => {\n let first = true;\n let last;\n return Effect.flatMap(pull, function loop(arr) {\n const out = [];\n let i = 0;\n if (first) {\n first = false;\n last = arr[0];\n i = 1;\n out.push(last);\n }\n for (; i < arr.length; i++) {\n const a = arr[i];\n if (f(a, last)) continue;\n last = a;\n out.push(a);\n }\n return Arr.isArrayNonEmpty(out) ? Effect.succeed(out) : Effect.flatMap(pull, loop);\n });\n})));\n/**\n * Emits only elements that differ from the previous element, using an effectful equality check.\n *\n * **Details**\n *\n * The predicate runs for each element after the first; returning `true` treats it as equal and skips it.\n *\n * **Example** (Effectfully emitting changed values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.make(1, 1, 2, 2, 3, 3).pipe(\n * Stream.changesWithEffect((a, b) => Effect.succeed(a === b))\n * )\n * const result = yield* Stream.runCollect(stream)\n * result // => [ 1, 2, 3 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category deduplication\n * @since 2.0.0\n */\nexport const changesWithEffect = /*#__PURE__*/dual(2, (self, f) => transformPull(self, (pull, _scope) => Effect.sync(() => {\n let first = true;\n let last;\n return Effect.flatMap(pull, Effect.fnUntraced(function* loop(arr) {\n const out = [];\n let i = 0;\n if (first) {\n first = false;\n last = arr[0];\n i = 1;\n out.push(last);\n }\n for (; i < arr.length; i++) {\n const a = arr[i];\n if (yield* f(a, last)) continue;\n last = a;\n out.push(a);\n }\n return Arr.isArrayNonEmpty(out) ? out : yield* Effect.flatMap(pull, Effect.fnUntraced(loop));\n }));\n})));\n/**\n * Decodes Uint8Array chunks into strings using TextDecoder with an optional encoding.\n *\n * **Example** (Decoding Uint8Array chunks into strings using TextDecoder with an optional encoding)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const encoder = new TextEncoder()\n * const stream = Stream.make(\n * encoder.encode(\"Hello\"),\n * encoder.encode(\" World\")\n * )\n *\n * const program = Effect.gen(function*() {\n * const decoded = yield* stream.pipe(\n * Stream.decodeText,\n * Stream.runCollect\n * )\n * decoded // => [ 'Hello', ' World' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category decoding\n * @since 2.0.0\n */\nexport const decodeText = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => suspend(() => {\n const decoder = new TextDecoder(options?.encoding);\n return map(self, chunk => decoder.decode(chunk, {\n stream: true\n }));\n}));\n/**\n * Encodes a stream of strings into UTF-8 `Uint8Array` chunks.\n *\n * **Example** (Encoding a stream of strings into UTF-8 Uint8Array chunks)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(\"Hello\", \" \", \"World\")\n * const program = Effect.gen(function*() {\n * const encoded = Stream.encodeText(stream)\n * const chunks = yield* Stream.runCollect(encoded)\n * const bytes = chunks.map((chunk) => [...chunk])\n * bytes // => [ [ 72, 101, 108, 108, 111 ], [ 32 ], [ 87, 111, 114, 108, 100 ] ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category encoding\n * @since 2.0.0\n */\nexport const encodeText = self => suspend(() => {\n const encoder = new TextEncoder();\n return map(self, chunk => encoder.encode(chunk));\n});\n/**\n * Splits a stream of strings into lines, handling `\\n`, `\\r`, and `\\r\\n` delimiters across chunks.\n *\n * **Example** (Splitting streamed text into lines)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function* () {\n * const lines = yield* Stream.runCollect(\n * Stream.make(\"a\\nb\\r\\n\", \"c\\n\").pipe(Stream.splitLines)\n * )\n * lines // => [ 'a', 'b', 'c' ]\n * }))\n * ```\n *\n * @category splitting\n * @since 2.0.0\n */\nexport const splitLines = self => self.channel.pipe(Channel.pipeTo(Channel.splitLines()), fromChannel);\n/**\n * Inserts the provided element between emitted elements.\n *\n * **Example** (Interspersing stream elements)\n *\n * ```ts import.meta.vitest\n * import { Console, Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.intersperse(0))\n * const result = yield* Stream.runCollect(stream)\n * result // => [1, 0, 2, 0, 3, 0, 4]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const intersperse = /*#__PURE__*/dual(2, (self, element) => mapArray(self, (arr, i) => {\n const out = i === 0 ? [] : [element];\n const lastIndex = arr.length - 1;\n for (let j = 0; j < arr.length; j++) {\n if (j === lastIndex) {\n out.push(arr[j]);\n } else {\n out.push(arr[j], element);\n }\n }\n return out;\n}));\n/**\n * Adds a start value, middle value, and end value around stream elements.\n *\n * **Details**\n *\n * The start and end values are always emitted, even when the stream is empty.\n *\n * **Example** (Interspersing stream affixes)\n *\n * ```ts import.meta.vitest\n * import { Console, Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(\"a\", \"b\", \"c\").pipe(\n * Stream.intersperseAffixes({ start: \"[\", middle: \",\", end: \"]\" })\n * )\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(stream)\n * result // => [\"[\", \"a\", \",\", \"b\", \",\", \"c\", \"]\"]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const intersperseAffixes = /*#__PURE__*/dual(2, (self, options) => succeed(options.start).pipe(concat(intersperse(self, options.middle)), concat(succeed(options.end))));\n/**\n * Interleaves this stream with the specified stream by alternating pulls from\n * each stream; when one ends, the remaining values from the other stream are\n * emitted.\n *\n * **Example** (Interleaving streams)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.interleave(\n * Stream.make(2, 3),\n * Stream.make(5, 6, 7)\n * )\n *\n * const program = Effect.gen(function*() {\n * const collected = yield* Stream.runCollect(stream)\n * collected // => [ 2, 5, 3, 6, 7 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category merging\n * @since 2.0.0\n */\nexport const interleave = /*#__PURE__*/dual(2, (self, that) => interleaveWith(self, that, fromIterable(Iterable.forever([true, false]))));\n/**\n * Interleaves two streams deterministically by following a boolean decider stream.\n *\n * **Details**\n *\n * The decider controls how many elements are pulled; if one side ends, pulls for\n * that side are ignored.\n *\n * **Example** (Interleaving two streams deterministically by following a boolean decider stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const left = Stream.make(1, 3, 5)\n * const right = Stream.make(2, 4, 6)\n * const decider = Stream.make(true, false, false, true, true)\n *\n * const values = yield* Stream.runCollect(\n * Stream.interleaveWith(left, right, decider)\n * )\n *\n * values // => [ 1, 2, 4, 3, 5 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category merging\n * @since 2.0.0\n */\nexport const interleaveWith = /*#__PURE__*/dual(3, (self, that, decider) => fromChannel(Channel.fromTransform(Effect.fnUntraced(function* (upstream, scope) {\n const pullDecider = yield* Channel.toTransform(Channel.flattenArray(decider.channel))(upstream, scope);\n const retry = Symbol();\n let leftDone = false;\n let rightDone = false;\n const pullLeft = (yield* Channel.toTransform(Channel.flattenArray(self.channel))(upstream, scope)).pipe(Pull.catchDone(() => {\n leftDone = true;\n return Effect.succeed(retry);\n }));\n const pullRight = (yield* Channel.toTransform(Channel.flattenArray(that.channel))(upstream, scope)).pipe(Pull.catchDone(() => {\n rightDone = true;\n return Effect.succeed(retry);\n }));\n return Effect.gen(function* () {\n while (true) {\n if (leftDone && rightDone) {\n return yield* Cause.done();\n }\n const side = yield* pullDecider;\n if (side && leftDone) continue;\n if (!side && rightDone) continue;\n const elem = yield* side ? pullLeft : pullRight;\n if (elem === retry) continue;\n return Arr.of(elem);\n }\n });\n}))));\n/**\n * Interrupts the evaluation of this stream when the provided effect\n * completes. The given effect will be forked as part of this stream, and its\n * success will be discarded. This combinator will also interrupt any\n * in-progress element being pulled from upstream.\n *\n * **Details**\n *\n * If the effect completes with a failure before the stream completes, the\n * returned stream will emit that failure.\n *\n * **Example** (Interrupting when an effect completes)\n *\n * ```ts import.meta.vitest\n * import { Deferred, Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const interrupt = yield* Deferred.make()\n * const stream = Stream.make(1, 2, 3).pipe(\n * Stream.tap((value) =>\n * value === 2\n * ? Deferred.succeed(interrupt, void 0)\n * : Effect.void\n * ),\n * Stream.interruptWhen(Deferred.await(interrupt))\n * )\n *\n * const result = yield* Stream.runCollect(stream)\n * result // => [ 1 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const interruptWhen = /*#__PURE__*/dual(2, (self, effect) => fromChannel(Channel.interruptWhen(self.channel, effect)));\n/**\n * Stops a stream after the current pull when an effect completes.\n *\n * **When to use**\n *\n * Use to stop before the next pull after an external signal completes.\n *\n * **Details**\n *\n * The effect is forked, its success value is discarded, and its failure fails\n * the stream.\n *\n * **Gotchas**\n *\n * This does not interrupt or truncate an in-progress pull. A pull may emit\n * multiple elements in a single chunk, in which case the entire chunk is\n * emitted. Use {@link interruptWhen} when the stream should be interrupted\n * immediately.\n *\n * **Example** (Halting a stream after an effect completes)\n *\n * ```ts import.meta.vitest\n * import { Deferred, Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const halt = yield* Deferred.make()\n * const values = yield* Stream.fromArray([1, 2, 3]).pipe(\n * Stream.tap((value) => value === 2 ? Deferred.succeed(halt, void 0) : Effect.void),\n * Stream.haltWhen(Deferred.await(halt)),\n * Stream.runCollect\n * )\n * values // => [ 1, 2 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category interruption\n * @since 2.0.0\n */\nexport const haltWhen = /*#__PURE__*/dual(2, (self, effect) => fromChannel(Channel.haltWhen(self.channel, effect)));\n/**\n * Runs the provided finalizer when the stream exits, passing the exit value.\n *\n * **Example** (Running a finalizer on exit)\n *\n * ```ts import.meta.vitest\n * import { Effect, Exit, Stream } from \"effect\"\n *\n * const exits: Array = []\n * const stream = Stream.make(1, 2, 3).pipe(\n * Stream.onExit((exit) =>\n * Exit.isSuccess(exit)\n * ? Effect.sync(() => exits.push(\"success\"))\n * : Effect.sync(() => exits.push(\"failure\"))\n * )\n * )\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * yield* Stream.runCollect(stream)\n * }))\n * exits // => [\"success\"]\n * ```\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const onExit = /*#__PURE__*/dual(2, (self, finalizer) => fromChannel(Channel.onExit(self.channel, finalizer)));\n/**\n * Runs the provided effect when the stream fails, passing the failure cause.\n *\n * **Gotchas**\n *\n * Note: Unlike `Effect.onError` there is no guarantee that the provided\n * effect will not be interrupted.\n *\n * **Example** (Running an effect on errors)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Stream } from \"effect\"\n *\n * const errors: Array = []\n * const program = Effect.gen(function*() {\n * const stream = Stream.make(1, 2, 3).pipe(\n * Stream.concat(Stream.fail(\"boom\")),\n * Stream.onError((cause) => Effect.sync(() => errors.push(String(Cause.squash(cause)))))\n * )\n *\n * yield* Stream.runCollect(stream)\n * })\n *\n * await Effect.runPromise(Effect.exit(program))\n * errors // => [\"boom\"]\n * ```\n *\n * @category error handling\n * @since 2.0.0\n */\nexport const onError = /*#__PURE__*/dual(2, (self, cleanup) => fromChannel(Channel.onError(self.channel, cleanup)));\n/**\n * Runs the provided effect before this stream starts.\n *\n * **Example** (Running an effect on start)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const events: Array = []\n * const program = Effect.gen(function*() {\n * const stream = Stream.fromArray([1, 2, 3]).pipe(\n * Stream.onStart(Effect.sync(() => events.push(\"started\")))\n * )\n *\n * const values = yield* Stream.runCollect(stream)\n * values // => [1, 2, 3]\n * })\n *\n * await Effect.runPromise(program)\n * events // => [\"started\"]\n * ```\n *\n * @category sequencing\n * @since 3.6.0\n */\nexport const onStart = /*#__PURE__*/dual(2, (self, onStart) => fromChannel(Channel.onStart(self.channel, onStart)));\n/**\n * Runs the provided effect with the first element emitted by the stream.\n *\n * **Example** (Running an effect on the first value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const first: Array = []\n * await Effect.runPromise(Effect.gen(function* () {\n * yield* Stream.fromArray([1, 2, 3]).pipe(\n * Stream.onFirst((value) => Effect.sync(() => first.push(value))),\n * Stream.runDrain\n * )\n * }))\n * first // => [1]\n * ```\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const onFirst = /*#__PURE__*/dual(2, (self, onFirst) => fromChannel(Channel.onFirst(self.channel, arr => onFirst(arr[0]))));\n/**\n * Runs the provided effect when the stream ends successfully.\n *\n * **Example** (Running an effect on end)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const events: Array = []\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.make(1, 2, 3).pipe(\n * Stream.onEnd(Effect.sync(() => events.push(\"ended\"))),\n * Stream.runCollect\n * )\n * values // => [1, 2, 3]\n * })\n *\n * await Effect.runPromise(program)\n * events // => [\"ended\"]\n * ```\n *\n * @category sequencing\n * @since 3.6.0\n */\nexport const onEnd = /*#__PURE__*/dual(2, (self, onEnd) => fromChannel(Channel.onEnd(self.channel, onEnd)));\n/**\n * Executes the provided finalizer after this stream's finalizers run.\n *\n * **Example** (Ensuring finalization)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const events: Array = []\n * const stream = Stream.fromArray([1, 2]).pipe(\n * Stream.ensuring(Effect.sync(() => events.push(\"cleanup\")))\n * )\n *\n * const program = Effect.gen(function*() {\n * const collected = yield* Stream.runCollect(stream)\n * collected // => [1, 2]\n * })\n *\n * await Effect.runPromise(program)\n * events // => [\"cleanup\"]\n * ```\n *\n * @category resource management\n * @since 2.0.0\n */\nexport const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => fromChannel(Channel.ensuring(self.channel, finalizer)));\n/**\n * Provides a layer or context to the stream, removing the corresponding\n * service requirements. Use `options.local` to build the layer every time; by\n * default, layers are shared between provide calls.\n *\n * **Example** (Providing stream requirements)\n *\n * ```ts import.meta.vitest\n * import { Console, Context, Effect, Layer, Stream } from \"effect\"\n *\n * class Env extends Context.Service()(\"Env\") {}\n *\n * const layer = Layer.succeed(Env)({ name: \"Ada\" })\n *\n * const stream = Stream.fromEffect(\n * Effect.gen(function*() {\n * const env = yield* Effect.service(Env)\n * return `Hello, ${env.name}`\n * })\n * )\n *\n * const withEnv = stream.pipe(Stream.provide(layer))\n *\n * await Effect.runPromise(Stream.runCollect(withEnv)) // => [\"Hello, Ada\"]\n * ```\n *\n * @category providing services\n * @since 4.0.0\n */\nexport const provide = /*#__PURE__*/dual(args => isStream(args[0]), (self, layer, options) => fromChannel(Channel.provide(self.channel, layer, options)));\n/**\n * Provides multiple services to the stream using a context.\n *\n * **Example** (Providing multiple services to the stream using a context)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Stream } from \"effect\"\n *\n * class Config extends Context.Service()(\"Config\") {}\n * class Greeter extends Context.Service string }>()(\"Greeter\") {}\n *\n * const context = Context.make(Config, { prefix: \"Hello\" }).pipe(\n * Context.add(Greeter, { greet: (name: string) => `${name}!` })\n * )\n *\n * const stream = Stream.fromEffect(\n * Effect.gen(function*() {\n * const config = yield* Effect.service(Config)\n * const greeter = yield* Effect.service(Greeter)\n * return greeter.greet(config.prefix)\n * })\n * )\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(Stream.provideContext(stream, context))\n * result // => [ 'Hello!' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const provideContext = /*#__PURE__*/dual(2, (self, context) => fromChannel(Channel.provideContext(self.channel, context)));\n/**\n * Provides the stream with a single required service, eliminating that\n * requirement from its environment.\n *\n * **Example** (Providing a stream service)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Stream } from \"effect\"\n *\n * class Greeter extends Context.Service string\n * }>()(\"Greeter\") {}\n *\n * const stream = Stream.fromEffect(\n * Effect.service(Greeter).pipe(\n * Effect.map((greeter) => greeter.greet(\"Ada\"))\n * )\n * )\n *\n * const program = Effect.gen(function*() {\n * const collected = yield* Stream.runCollect(\n * stream.pipe(\n * Stream.provideService(Greeter, {\n * greet: (name) => `Hello, ${name}`\n * })\n * )\n * )\n * collected // => [ 'Hello, Ada' ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const provideService = /*#__PURE__*/dual(3, (self, key, service) => fromChannel(Channel.provideService(self.channel, key, service)));\n/**\n * Provides a service to the stream using an effect, removing the requirement and adding the effect's error and environment.\n *\n * **Example** (Providing a stream service effectfully)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Stream } from \"effect\"\n *\n * class ApiConfig extends Context.Service()(\"ApiConfig\") {}\n *\n * const stream = Stream.fromEffect(\n * Effect.gen(function*() {\n * const config = yield* Effect.service(ApiConfig)\n * return config.baseUrl\n * })\n * )\n *\n * const events: Array = []\n * const withConfig = stream.pipe(\n * Stream.provideServiceEffect(\n * ApiConfig,\n * Effect.succeed({ baseUrl: \"https://example.com\" }).pipe(\n * Effect.tap(() => Effect.sync(() => events.push(\"loading\")))\n * )\n * )\n * )\n *\n * await Effect.runPromise(Stream.runCollect(withConfig)) // => [\"https://example.com\"]\n * events // => [\"loading\"]\n * ```\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const provideServiceEffect = /*#__PURE__*/dual(3, (self, key, service) => fromChannel(Channel.provideServiceEffect(self.channel, key, service)));\n/**\n * Transforms the stream's required services by mapping the current context\n * to a new one.\n *\n * **Example** (Updating the stream context)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Stream } from \"effect\"\n *\n * class Logger extends Context.Service()(\"Logger\") {}\n * class Config extends Context.Service()(\"Config\") {}\n *\n * const stream = Stream.fromEffect(\n * Effect.gen(function*() {\n * const logger = yield* Effect.service(Logger)\n * const config = yield* Effect.service(Config)\n * return `${logger.prefix}${config.name}`\n * })\n * )\n *\n * const updated = stream.pipe(\n * Stream.updateContext((context: Context.Context) =>\n * Context.add(context, Config, { name: \"World\" })\n * )\n * )\n *\n * const program = Effect.gen(function*() {\n * const values = yield* Stream.runCollect(updated)\n * values // => [ 'Hello World' ]\n * })\n *\n * await Effect.runPromise(\n * Effect.provideService(program, Logger, { prefix: \"Hello \" })\n * )\n * ```\n *\n * @category providing services\n * @since 4.0.0\n */\nexport const updateContext = /*#__PURE__*/dual(2, (self, f) => fromChannel(Channel.updateContext(self.channel, f)));\n/**\n * Updates a single service in the stream environment by applying a function.\n *\n * **Example** (Updating a stream service)\n *\n * ```ts import.meta.vitest\n * import { Context, Effect, Stream } from \"effect\"\n *\n * class Counter extends Context.Service()(\"Counter\") {}\n *\n * const stream = Stream.fromEffect(Effect.service(Counter)).pipe(\n * Stream.updateService(Counter, (counter) => ({ count: counter.count + 1 }))\n * )\n *\n * const program = Effect.gen(function*() {\n * const counters = yield* Stream.runCollect(stream)\n * const message = `Updated count: ${counters[0].count}` // => \"Updated count: 1\"\n * })\n *\n * await Effect.runPromise(Effect.provideService(program, Counter, { count: 0 }))\n * ```\n *\n * @category providing services\n * @since 2.0.0\n */\nexport const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateContext(self, context => Context.add(context, service, f(Context.get(context, service)))));\n/**\n * Wraps the stream with a new span for tracing.\n *\n * **Example** (Wrapping a stream in a span)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.fromArray([1, 2, 3]).pipe(Stream.withSpan(\"numbers\"))\n *\n * await Effect.runPromise(\n * Effect.gen(function*() {\n * const values = yield* Stream.runCollect(stream)\n * values // => [ 1, 2, 3 ]\n * })\n * )\n * ```\n *\n * @category tracing\n * @since 2.0.0\n */\nexport const withSpan = function () {\n const dataFirst = isStream(arguments[0]);\n const name = dataFirst ? arguments[1] : arguments[0];\n const options = addSpanStackTrace(dataFirst ? arguments[2] : arguments[1]);\n if (dataFirst) {\n const self = arguments[0];\n return fromChannel(Channel.withSpan(self.channel, name, options));\n }\n return self => fromChannel(Channel.withSpan(self.channel, name, options));\n};\n/**\n * Provides the entry point for do-notation style stream composition.\n *\n * **Example** (Starting stream do notation)\n *\n * ```ts import.meta.vitest\n * import { Effect, pipe, Stream } from \"effect\"\n *\n * const program = pipe(\n * Stream.Do,\n * Stream.bind(\"value\", () => Stream.fromArray([1, 2])),\n * Stream.let(\"next\", ({ value }) => value + 1)\n * )\n *\n * const effect = Effect.gen(function*() {\n * const collected = yield* Stream.runCollect(program)\n * collected // => [ { value: 1, next: 2 }, { value: 2, next: 3 } ]\n * })\n *\n * await Effect.runPromise(effect)\n * ```\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const Do = /*#__PURE__*/succeed({});\nconst let_ = /*#__PURE__*/dual(3, (self, name, f) => map(self, a => ({\n ...a,\n [name]: f(a)\n})));\nexport {\n/**\n * Adds a computed field to the current Do-notation record.\n *\n * **Example** (Adding a computed field)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.Do.pipe(\n * Stream.let(\"x\", () => 2),\n * Stream.let(\"y\", ({ x }) => x * 3)\n * )\n *\n * const program = Effect.gen(function*() {\n * const records = yield* Stream.runCollect(stream)\n * records // => [ { x: 2, y: 6 } ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nlet_ as let };\n/**\n * Binds the result of a stream to a field in the do-notation record.\n *\n * **Example** (Binding a stream value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Stream.Do.pipe(\n * Stream.bind(\"a\", () => Stream.make(1, 2)),\n * Stream.bind(\"b\", ({ a }) => Stream.succeed(a + 1))\n * )\n *\n * const result = Stream.runCollect(program)\n *\n * await Effect.runPromise(result) // => [{ a: 1, b: 2 }, { a: 2, b: 3 }]\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const bind = /*#__PURE__*/dual(args => isStream(args[0]), (self, tag, f, options) => flatMap(self, a => map(f(a), b => ({\n ...a,\n [tag]: b\n})), options));\n/**\n * Binds an Effect-produced value into the do-notation record for each stream element.\n *\n * **Example** (Binding an effect value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.Do.pipe(\n * Stream.bind(\"value\", () => Stream.make(1, 2)),\n * Stream.bindEffect(\"double\", ({ value }) => Effect.succeed(value * 2))\n * )\n *\n * const program = Effect.gen(function*() {\n * const result = yield* Stream.runCollect(stream)\n * result // => [ { value: 1, double: 2 }, { value: 2, double: 4 } ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category sequencing\n * @since 2.0.0\n */\nexport const bindEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, tag, f, options) => mapEffect(self, a => Effect.map(f(a), b => ({\n ...a,\n [tag]: b\n})), options));\n/**\n * Maps each element into a record keyed by the provided name.\n *\n * **Example** (Binding values to a record key)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3).pipe(Stream.bindTo(\"value\"))\n *\n * await Effect.runPromise(Stream.runCollect(stream)) // => [{ value: 1 }, { value: 2 }, { value: 3 }]\n * ```\n *\n * @category mapping\n * @since 2.0.0\n */\nexport const bindTo = /*#__PURE__*/dual(2, (self, name) => map(self, a => ({\n [name]: a\n})));\n/**\n * Runs a stream with a sink and returns the sink result.\n *\n * **Example** (Running a stream with a sink)\n *\n * ```ts import.meta.vitest\n * import { Effect, Sink, Stream } from \"effect\"\n *\n * const program = Stream.run(Stream.make(1, 2, 3), Sink.sum)\n *\n * await Effect.runPromise(program) // => 6\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const run = /*#__PURE__*/dual(2, (self, sink) => Effect.scopedWith(scope => Channel.toPullScoped(self.channel, scope).pipe(Effect.flatMap(upstream => sink.transform(upstream, scope)), Effect.map(([a]) => a))));\n/**\n * Runs the stream and collects all elements into an array.\n *\n * **Example** (Collecting stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3, 4, 5)\n *\n * const program = Effect.gen(function*() {\n * const collected = yield* Stream.runCollect(stream)\n * collected // => [ 1, 2, 3, 4, 5 ]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runCollect = self => Channel.runFold(self.channel, () => [], (acc, chunk) => {\n for (let i = 0; i < chunk.length; i++) {\n acc.push(chunk[i]);\n }\n return acc;\n});\n/**\n * Runs the stream and returns the number of elements emitted.\n *\n * **Example** (Counting stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3, 4, 5)\n *\n * const program = Effect.gen(function* () {\n * const count = yield* Stream.runCount(stream)\n * count // => 5\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runCount = self => Channel.runFold(self.channel, () => 0, (acc, chunk) => acc + chunk.length);\n/**\n * Runs the stream and returns the numeric sum of its elements.\n *\n * **Example** (Summing stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const total = yield* Stream.runSum(Stream.make(1, 2, 3))\n * total // => 6\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runSum = self => Channel.runFold(self.channel, () => 0, (acc, chunk) => {\n for (let i = 0; i < chunk.length; i++) {\n acc += chunk[i];\n }\n return acc;\n});\n/**\n * Runs the stream and folds elements using a pure reducer.\n *\n * **Example** (Folding stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const total = yield* Stream.runFold(\n * Stream.make(1, 2, 3),\n * () => 0,\n * (acc, n) => acc + n\n * )\n * total // => 6\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runFold = /*#__PURE__*/dual(3, (self, initial, f) => Channel.runFold(self.channel, initial, (acc, arr) => {\n for (let i = 0; i < arr.length; i++) {\n acc = f(acc, arr[i]);\n }\n return acc;\n}));\n/**\n * Runs the stream and folds elements using an effectful reducer.\n *\n * **When to use**\n *\n * Use when reducing stream elements needs Effects, services, or failures in the\n * reducer.\n *\n * **Example** (Effectfully folding stream values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const total = yield* Stream.runFoldEffect(\n * Stream.make(1, 2, 3),\n * () => 0,\n * (acc, n) => Effect.succeed(acc + n)\n * )\n * total // => 6\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runFoldEffect = /*#__PURE__*/dual(3, (self, initial, f) => Channel.runFoldEffect(self.channel, initial, (acc, arr) => {\n let i = 0;\n let s = acc;\n return Effect.map(Effect.whileLoop({\n while: () => i < arr.length,\n body: () => f(s, arr[i]),\n step(z) {\n s = z;\n i++;\n }\n }), () => s);\n}));\n/**\n * Runs the stream and returns the first element as an `Option`.\n *\n * **Example** (Getting the first stream value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const head = yield* Stream.runHead(Stream.make(1, 2, 3))\n * Option.getOrThrow(head) // => 1\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runHead = self => Effect.map(Channel.runHead(self.channel), Option.map(Arr.getUnsafe(0)));\n/**\n * Runs the stream and returns the last element as an `Option`.\n *\n * **When to use**\n *\n * Use to consume a finite stream when only the final emitted element matters.\n *\n * **Details**\n *\n * `Option.some` contains the last emitted element. `Option.none` means the\n * stream completed without emitting.\n *\n * **Gotchas**\n *\n * The returned effect waits for the stream to complete before it can produce a\n * value.\n *\n * @see {@link runHead} for consuming only the first emitted element\n * @see {@link runCollect} for collecting every emitted element\n * @see {@link runDrain} for consuming the stream while discarding emitted elements\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runLast = self => Effect.map(Channel.runLast(self.channel), Option.map(Arr.lastNonEmpty));\n/**\n * Runs the provided effectful callback for each element of the stream.\n *\n * **Example** (Running an effect for each value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3)\n * const values: Array = []\n *\n * const program = Effect.gen(function*() {\n * yield* Stream.runForEach(stream, (n) => Effect.sync(() => values.push(`Processing: ${n}`)))\n * })\n *\n * await Effect.runPromise(program)\n * values // => [\"Processing: 1\", \"Processing: 2\", \"Processing: 3\"]\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runForEach = /*#__PURE__*/dual(2, (self, f) => Channel.runForEach(self.channel, arr => {\n let i = 0;\n return Effect.whileLoop({\n while: () => i < arr.length,\n body: () => f(arr[i++]),\n step: constVoid\n });\n}));\n/**\n * Runs the stream, applying the effectful predicate to each element and\n * stopping when it returns `false`.\n *\n * **Example** (Running effects while a predicate holds)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const values: Array = []\n * const program = Effect.gen(function*() {\n * const stream = Stream.make(1, 2, 3, 4, 5)\n *\n * yield* Stream.runForEachWhile(stream, (n) =>\n * Effect.gen(function*() {\n * yield* Effect.sync(() => values.push(n))\n * return n < 3\n * })\n * )\n * })\n *\n * await Effect.runPromise(program)\n * values // => [1, 2, 3]\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runForEachWhile = /*#__PURE__*/dual(2, (self, f) => Channel.runForEachWhile(self.channel, arr => {\n let done = false;\n let i = 0;\n return Effect.map(Effect.whileLoop({\n while: () => !done && i < arr.length,\n body: () => f(arr[i]),\n step(b) {\n i++;\n if (!b) done = true;\n }\n }), () => !done);\n}));\n/**\n * Consumes the stream in chunks, passing each non-empty array to the callback.\n *\n * **Example** (Consuming stream chunks)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3, 4, 5)\n * const chunks: Array = []\n * const program = Effect.gen(function*() {\n * yield* Stream.runForEachArray(\n * stream,\n * (chunk) => Effect.sync(() => chunks.push(chunk.join(\", \")))\n * )\n * })\n *\n * await Effect.runPromise(program)\n * chunks // => [\"1, 2, 3, 4, 5\"]\n * ```\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const runForEachArray = /*#__PURE__*/dual(2, (self, f) => Channel.runForEach(self.channel, f));\n/**\n * Runs the stream for its effects, discarding emitted elements.\n *\n * **Example** (Draining a stream run)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const values: Array = []\n * const program = Effect.gen(function*() {\n * const stream = Stream.make(1, 2, 3).pipe(\n * Stream.mapEffect((n) => Effect.sync(() => values.push(n)))\n * )\n *\n * yield* Stream.runDrain(stream)\n * })\n *\n * await Effect.runPromise(program)\n * values // => [1, 2, 3]\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runDrain = self => Channel.runDrain(self.channel);\n/**\n * Returns a scoped pull for manually consuming the stream's output chunks.\n *\n * **Details**\n *\n * The pull fails with `Cause.Done` when the stream ends and with the stream\n * error on failure.\n *\n * **Example** (Creating a scoped pull)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3)\n *\n * const program = Effect.scoped(\n * Effect.gen(function*() {\n * const pull = yield* Stream.toPull(stream)\n * const chunk = yield* pull\n * chunk // => [ 1, 2, 3 ]\n * })\n * )\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const toPull = self => Channel.toPull(self.channel);\n/**\n * Concatenates all emitted strings into a single string.\n *\n * **Example** (Joining strings from a stream)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(\"Hello\", \" \", \"World\", \"!\")\n * const program = Effect.gen(function*() {\n * const text = yield* Stream.mkString(stream)\n * text // => \"Hello World!\"\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const mkString = self => Channel.runFold(self.channel, () => \"\", (acc, chunk) => acc + chunk.join(\"\"));\n/**\n * Concatenates the stream's `Uint8Array` chunks into a single `ArrayBuffer`.\n *\n * **Gotchas**\n *\n * This materializes the full content in memory. The source stream must not\n * reuse or mutate emitted buffers, which are retained until collection completes.\n *\n * **Example** (Joining byte chunks into an ArrayBuffer)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const program = Stream.make(\n * new Uint8Array([1, 2]),\n * new Uint8Array([3, 4])\n * ).pipe(\n * Stream.mkArrayBuffer,\n * Effect.map((buffer) => [...new Uint8Array(buffer)])\n * )\n *\n * await Effect.runPromise(program) // => [1, 2, 3, 4]\n * ```\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const mkArrayBuffer = self => Effect.map(Channel.mkUint8Array(self.channel), bytes => bytes.buffer);\n/**\n * Concatenates the stream's `Uint8Array` chunks into a single `Uint8Array`.\n *\n * **Gotchas**\n *\n * This materializes the full content in memory. The source stream must not\n * reuse or mutate emitted buffers, which are retained until collection completes.\n *\n * **Example** (Joining Uint8Array chunks)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(new Uint8Array([1, 2]), new Uint8Array([3, 4]))\n * const program = Effect.gen(function*() {\n * const bytes = yield* Stream.mkUint8Array(stream)\n * const values = Array.from(bytes) // => [1, 2, 3, 4]\n * })\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const mkUint8Array = self => Channel.mkUint8Array(self.channel);\n/**\n * Converts the stream to a `ReadableStream` using the provided services.\n *\n * **When to use**\n *\n * Use when bridging to Web Streams and you already have the `Context` required\n * to run the stream outside an `Effect`.\n *\n * **Details**\n *\n * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.\n *\n * **Example** (Converting to a ReadableStream with services)\n *\n * ```ts import.meta.vitest\n * import { Context, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3, 4, 5)\n * const readableStream = Stream.toReadableStreamWith(stream, Context.empty())\n * const values = await Array.fromAsync(readableStream)\n * values // => [ 1, 2, 3, 4, 5 ]\n * ```\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toReadableStreamWith = /*#__PURE__*/dual(args => isStream(args[0]), (self, context, options) => {\n let currentResolve = undefined;\n let fiber = undefined;\n const latch = Latch.makeUnsafe(false);\n return new ReadableStream({\n start(controller) {\n fiber = Effect.runFork(Effect.provideContext(runForEachArray(self, chunk => latch.whenOpen(Effect.sync(() => {\n latch.closeUnsafe();\n for (let i = 0; i < chunk.length; i++) {\n controller.enqueue(chunk[i]);\n }\n currentResolve();\n currentResolve = undefined;\n }))), context));\n fiber.addObserver(exit => {\n if (exit._tag === \"Failure\") {\n controller.error(Cause.squash(exit.cause));\n } else {\n controller.close();\n }\n });\n },\n pull() {\n return new Promise(resolve => {\n currentResolve = resolve;\n latch.openUnsafe();\n });\n },\n cancel() {\n if (!fiber) return;\n return Effect.runPromise(Effect.asVoid(Fiber.interrupt(fiber)));\n }\n }, options?.strategy);\n});\n/**\n * Converts a stream to a `ReadableStream`.\n *\n * **Details**\n *\n * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.\n *\n * **Example** (Converting a stream to a ReadableStream)\n *\n * ```ts import.meta.vitest\n * import { Stream } from \"effect\"\n *\n * const readableStream = Stream.toReadableStream(Stream.make(1, 2, 3))\n * const values = await Array.fromAsync(readableStream)\n * values // => [ 1, 2, 3 ]\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const toReadableStream = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => toReadableStreamWith(self, Context.empty(), options));\n/**\n * Creates an Effect that builds a ReadableStream from the stream.\n *\n * **When to use**\n *\n * Use when bridging to Web Streams from inside an `Effect` so the required\n * services can be captured from the current context.\n *\n * **Details**\n *\n * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.\n *\n * **Example** (Creating a ReadableStream effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3, 4, 5)\n *\n * const effect = Effect.gen(function*() {\n * const readableStream = yield* Stream.toReadableStreamEffect(stream)\n * readableStream instanceof ReadableStream // => true\n * })\n *\n * await Effect.runPromise(effect)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const toReadableStreamEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) => Effect.map(Effect.context(), context => toReadableStreamWith(self, context, options)));\n/**\n * Converts the stream to an `AsyncIterable` using the provided services.\n *\n * **When to use**\n *\n * Use when converting outside an Effect and you already have the `Context`\n * needed to run the stream.\n *\n * **Example** (Converting to an AsyncIterable with services)\n *\n * ```ts import.meta.vitest\n * import { Context, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3)\n * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())\n *\n * await Array.fromAsync(iterable) // => [1, 2, 3]\n * ```\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toAsyncIterableWith = /*#__PURE__*/dual(2, (self, context) => ({\n [Symbol.asyncIterator]() {\n const runPromise = Effect.runPromiseWith(context);\n const runFork = Effect.runForkWith(context);\n const scope = Scope.makeUnsafe();\n let pull;\n let currentIter;\n let currentFiber;\n let closePromise;\n const close = exit => {\n if (closePromise) return closePromise;\n const fiber = currentFiber;\n closePromise = runPromise(Effect.as(Effect.andThen(fiber ? Fiber.interrupt(fiber) : Effect.void, Scope.close(scope, exit)), {\n done: true,\n value: undefined\n }));\n return closePromise;\n };\n const closeAndReportError = async exit => {\n try {\n await close(exit);\n } catch (error) {\n await runPromise(Effect.logError(\"Suppressed error while closing Stream async iterator\", error));\n }\n };\n return {\n async next() {\n if (closePromise) return closePromise;\n if (currentIter) {\n const next = currentIter.next();\n if (!next.done) return next;\n currentIter = undefined;\n }\n const fiber = runFork(pull ?? Effect.flatMap(Channel.toPullScoped(self.channel, scope), nextPull => {\n pull = nextPull;\n return nextPull;\n }));\n currentFiber = fiber;\n const exit = await runPromise(Fiber.await(fiber));\n if (currentFiber === fiber) {\n currentFiber = undefined;\n }\n if (Exit.isSuccess(exit)) {\n currentIter = exit.value[Symbol.iterator]();\n return currentIter.next();\n } else if (Pull.isDoneCause(exit.cause)) {\n return close(Exit.void);\n }\n if (closePromise && Cause.hasInterruptsOnly(exit.cause)) {\n return closePromise;\n }\n await closeAndReportError(exit);\n throw Cause.squash(exit.cause);\n },\n return() {\n return close(Exit.void);\n },\n async throw(error) {\n await closeAndReportError(Exit.die(error));\n throw error;\n }\n };\n }\n}));\n/**\n * Creates an effect that yields an `AsyncIterable` using the current services.\n *\n * **When to use**\n *\n * Use when the `AsyncIterable` should be created inside Effect with the current\n * context supplying the stream's services.\n *\n * **Example** (Creating an AsyncIterable effect)\n *\n * ```ts import.meta.vitest\n * import { Effect, Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3)\n *\n * const program = Effect.gen(function*() {\n * const iterable = yield* Stream.toAsyncIterableEffect(stream)\n * return yield* Effect.promise(() => Array.fromAsync(iterable))\n * })\n *\n * await Effect.runPromise(program) // => [1, 2, 3]\n * ```\n *\n * @category destructors\n * @since 3.15.0\n */\nexport const toAsyncIterableEffect = self => Effect.map(Effect.context(), context => toAsyncIterableWith(self, context));\n/**\n * Converts a stream to an `AsyncIterable` for `for await...of` consumption.\n *\n * **Example** (Converting to an async iterable)\n *\n * ```ts import.meta.vitest\n * import { Stream } from \"effect\"\n *\n * const stream = Stream.make(1, 2, 3)\n *\n * await Array.fromAsync(Stream.toAsyncIterable(stream)) // => [1, 2, 3]\n * ```\n *\n * @category destructors\n * @since 3.15.0\n */\nexport const toAsyncIterable = self => toAsyncIterableWith(self, Context.empty());\n/**\n * Runs the stream, publishing elements into the provided PubSub.\n *\n * **Details**\n *\n * `shutdownOnEnd` controls whether the PubSub is shut down when the stream ends.\n * It only shuts down when set to `true`.\n *\n * **Example** (Running a stream into a PubSub)\n *\n * ```ts import.meta.vitest\n * import { Effect, PubSub, Stream } from \"effect\"\n *\n * const program = Effect.scoped(Effect.gen(function* () {\n * const pubsub = yield* PubSub.unbounded()\n * const subscription = yield* PubSub.subscribe(pubsub)\n *\n * yield* Stream.runIntoPubSub(Stream.fromIterable([1, 2]), pubsub)\n *\n * const first = yield* PubSub.take(subscription)\n * const second = yield* PubSub.take(subscription)\n *\n * first // => 1\n * second // => 2\n * }))\n *\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runIntoPubSub = /*#__PURE__*/dual(args => isStream(args[0]), (self, pubsub, options) => Channel.runIntoPubSubArray(self.channel, pubsub, options));\n/**\n * Converts a stream to a PubSub of emitted values for concurrent consumption.\n *\n * **Details**\n *\n * `shutdownOnEnd` indicates whether the PubSub should be shut down when the\n * stream ends. By default this is `true`.\n *\n * **Example** (Converting a stream to a PubSub for concurrent consumption)\n *\n * ```ts import.meta.vitest\n * import { Effect, PubSub, Stream } from \"effect\"\n *\n * const program = Effect.scoped(Effect.gen(function* () {\n * const pubsub = yield* Stream.fromArray([1, 2]).pipe(\n * Stream.toPubSub({ capacity: 8 })\n * )\n * const subscription = yield* PubSub.subscribe(pubsub)\n * const first = yield* PubSub.take(subscription)\n *\n * first // => 1\n * }))\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const toPubSub = /*#__PURE__*/dual(2, (self, options) => Channel.toPubSubArray(self.channel, options));\n/**\n * Converts a stream to a PubSub of `Take` values for concurrent consumption.\n *\n * **Details**\n *\n * `Take` values include the stream's end and failure signals.\n *\n * **Example** (Converting to a PubSub of takes)\n *\n * ```ts import.meta.vitest\n * import { Effect, PubSub, Stream } from \"effect\"\n *\n * const program = Effect.gen(function* () {\n * const pubsub = yield* Stream.fromArray([1, 2, 3]).pipe(\n * Stream.toPubSubTake({ capacity: 8 })\n * )\n * const subscription = yield* PubSub.subscribe(pubsub)\n * const take = yield* PubSub.take(subscription)\n *\n * if (Array.isArray(take)) {\n * take // => [ 1, 2, 3 ]\n * }\n * })\n * await Effect.runPromise(Effect.scoped(program))\n * ```\n *\n * @category destructors\n * @since 4.0.0\n */\nexport const toPubSubTake = /*#__PURE__*/dual(2, (self, options) => Channel.toPubSubTake(self.channel, options));\n/**\n * Creates a scoped dequeue that is fed by the stream for concurrent\n * consumption.\n *\n * **Details**\n *\n * Elements are offered to the queue as the stream runs. Stream completion is\n * signaled with `Cause.Done`, stream failures fail the queue, and the queue is\n * shut down when the surrounding scope closes.\n *\n * **Example** (Converting a stream to a Queue for concurrent consumption)\n *\n * ```ts import.meta.vitest\n * import { Effect, Queue, Stream } from \"effect\"\n *\n * const program = Effect.gen(function* () {\n * const queue = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })\n * const chunk = yield* Queue.takeBetween(queue, 1, 3)\n * chunk // => [ 1, 2, 3 ]\n * })\n * await Effect.runPromise(Effect.scoped(program))\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const toQueue = /*#__PURE__*/dual(2, (self, options) => Channel.toQueueArray(self.channel, options));\n/**\n * Runs the stream, offering each element to the provided queue and ending it\n * with `Cause.Done` when the stream completes.\n *\n * **Example** (Running a stream into a queue)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, Queue, Stream } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const queue = yield* Queue.bounded(4)\n *\n * yield* Effect.forkChild(\n * Stream.runIntoQueue(Stream.fromIterable([1, 2, 3]), queue)\n * )\n *\n * const values = [\n * yield* Queue.take(queue),\n * yield* Queue.take(queue),\n * yield* Queue.take(queue)\n * ]\n * const done = yield* Effect.flip(Queue.take(queue))\n *\n * values // => [ 1, 2, 3 ]\n * done._tag === \"Done\" // => true\n * })\n * await Effect.runPromise(program)\n * ```\n *\n * @category destructors\n * @since 2.0.0\n */\nexport const runIntoQueue = /*#__PURE__*/dual(2, (self, queue) => Channel.runIntoQueueArray(self.channel, queue));\n//# sourceMappingURL=Stream.js.map","/**\n * Defines the portable file system service for Effect programs.\n *\n * `FileSystem` is the boundary between Effect code and the host file system.\n * Platform packages provide concrete layers, while this module defines the\n * operations for reading, writing, inspecting, streaming, and watching files.\n * Operations return `Effect`, `Stream`, or `Sink` values and fail with\n * `PlatformError`. The module also includes file handles, open flags, watch\n * events, and the watch backend service.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"./Array.js\";\nimport * as ByteSize from \"./ByteSize.js\";\nimport * as Cause from \"./Cause.js\";\nimport * as Context from \"./Context.js\";\nimport * as Effect from \"./Effect.js\";\nimport { pipe } from \"./Function.js\";\nimport * as Layer from \"./Layer.js\";\nimport * as Option from \"./Option.js\";\nimport { badArgument, systemError } from \"./PlatformError.js\";\nimport { hasProperty } from \"./Predicate.js\";\nimport * as Sink from \"./Sink.js\";\nimport * as Stream from \"./Stream.js\";\nconst TypeId = \"~effect/FileSystem\";\n/**\n * Service tag for platform file-system operations.\n *\n * **When to use**\n *\n * Use to access or provide operations for files, directories, permissions,\n * streams, and sinks through the Effect context.\n *\n * **Details**\n *\n * This key is used to provide and access the FileSystem service in the Effect context.\n *\n * **Example** (Accessing and providing FileSystem)\n *\n * ```ts import.meta.vitest\n * import { Effect, FileSystem } from \"effect\"\n *\n * const customFs = FileSystem.makeNoop({\n * exists: () => Effect.succeed(true),\n * readFileString: () => Effect.succeed(\"contents\")\n * })\n *\n * // Access the FileSystem service\n * const program = Effect.gen(function*() {\n * const fs = yield* FileSystem.FileSystem\n *\n * const exists = yield* fs.exists(\"./data.txt\")\n * return exists ? yield* fs.readFileString(\"./data.txt\") : undefined\n * })\n *\n * const withCustomFs = Effect.provideService(\n * program,\n * FileSystem.FileSystem,\n * customFs\n * )\n * Effect.runSync(withCustomFs) // => \"contents\"\n * ```\n *\n * @category services\n * @since 4.0.0\n */\nexport const FileSystem = /*#__PURE__*/Context.Service(\"effect/FileSystem\");\n/**\n * Creates a FileSystem implementation from a partial implementation.\n *\n * **When to use**\n *\n * Use to build a concrete `FileSystem` service from platform-specific core\n * operations while deriving the convenience methods that can be implemented\n * from them.\n *\n * **Details**\n *\n * This function takes a partial FileSystem implementation and automatically provides\n * default implementations for `exists`, `readFileString`, `stream`, `sink`, and\n * `writeFileString` methods based on the provided core methods.\n *\n * @see {@link makeNoop} for a testing stub that accepts method overrides without requiring a complete implementation\n * @see {@link layerNoop} for providing a no-op `FileSystem` as a `Layer` in tests\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = impl => FileSystem.of({\n ...impl,\n [TypeId]: TypeId,\n exists: path => pipe(impl.access(path), Effect.as(true), Effect.catchTag(\"PlatformError\", e => e.reason._tag === \"NotFound\" ? Effect.succeed(false) : Effect.fail(e))),\n readFileString: (path, encoding) => Effect.flatMap(impl.readFile(path), _ => Effect.try({\n try: () => new TextDecoder(encoding).decode(_),\n catch: cause => badArgument({\n module: \"FileSystem\",\n method: \"readFileString\",\n description: \"invalid encoding\",\n cause\n })\n })),\n stream: Effect.fnUntraced(function* (path, options) {\n const file = yield* impl.open(path, {\n flag: \"r\"\n });\n const offset = options?.offset === undefined ? undefined : ByteSize.fromInputUnsafe(options.offset);\n if (offset) {\n yield* file.seek(offset, \"start\");\n }\n const bytesToRead = options?.bytesToRead === undefined ? undefined : ByteSize.fromInputUnsafe(options.bytesToRead);\n let totalBytesRead = BigInt(0);\n // Validate chunk sizes even for zero-byte reads.\n const chunkSize = Number(BigInt(options?.chunkSize ?? 64 * 1024));\n const readChunk = file.readAlloc(chunkSize);\n return Stream.fromPull(Effect.succeed(Effect.flatMap(Effect.suspend(() => {\n if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {\n return Cause.done();\n }\n return bytesToRead !== undefined && bytesToRead - totalBytesRead < chunkSize ? file.readAlloc(Number(bytesToRead - totalBytesRead)) : readChunk;\n }), Option.match({\n onNone: () => Cause.done(),\n onSome: buf => {\n totalBytesRead += BigInt(buf.length);\n return Effect.succeed(Arr.of(buf));\n }\n }))));\n }, Stream.unwrap),\n sink: (path, options) => pipe(impl.open(path, {\n ...options,\n flag: options?.flag ?? \"w\"\n }), Effect.map(file => Sink.forEach(_ => file.writeAll(_))), Sink.unwrap),\n writeFileString: (path, data, options) => Effect.flatMap(Effect.try({\n try: () => new TextEncoder().encode(data),\n catch: cause => badArgument({\n module: \"FileSystem\",\n method: \"writeFileString\",\n description: \"could not encode string\",\n cause\n })\n }), _ => impl.writeFile(path, _, options))\n});\nconst notFound = (method, path) => systemError({\n module: \"FileSystem\",\n method,\n _tag: \"NotFound\",\n description: \"No such file or directory\",\n pathOrDescriptor: path\n});\n/**\n * Creates a stub `FileSystem` implementation for tests.\n *\n * **Details**\n *\n * By default, `exists` returns `false`, `remove` succeeds, many file operations\n * fail with `PlatformError` `NotFound`, and temporary-directory/file operations\n * die as not implemented. Pass method overrides to provide the behavior needed\n * by a specific test without touching the real file system.\n *\n * **Example** (Creating a no-op FileSystem)\n *\n * ```ts import.meta.vitest\n * import { Effect, FileSystem, PlatformError } from \"effect\"\n *\n * // Create a test filesystem that only allows reading specific files\n * const testFs = FileSystem.makeNoop({\n * readFileString: (path) => {\n * if (path === \"test-config.json\") {\n * return Effect.succeed(\"{\\\"test\\\": true}\")\n * }\n * return Effect.fail(\n * PlatformError.systemError({\n * _tag: \"NotFound\",\n * module: \"FileSystem\",\n * method: \"readFileString\",\n * description: \"File not found\",\n * pathOrDescriptor: path\n * })\n * )\n * },\n * exists: (path) => Effect.succeed(path === \"test-config.json\")\n * })\n *\n * // Use in tests\n * const program = Effect.gen(function*() {\n * const content = yield* testFs.readFileString(\"test-config.json\")\n * return content\n * })\n *\n * // Test with the no-op filesystem\n * const testProgram = Effect.provideService(\n * program,\n * FileSystem.FileSystem,\n * testFs\n * )\n * Effect.runSync(testProgram) // => \"{\\\"test\\\": true}\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeNoop = fileSystem => FileSystem.of({\n [TypeId]: TypeId,\n access(path) {\n return Effect.fail(notFound(\"access\", path));\n },\n chmod(path) {\n return Effect.fail(notFound(\"chmod\", path));\n },\n chown(path) {\n return Effect.fail(notFound(\"chown\", path));\n },\n copy(path) {\n return Effect.fail(notFound(\"copy\", path));\n },\n copyFile(path) {\n return Effect.fail(notFound(\"copyFile\", path));\n },\n glob(pattern) {\n return Effect.fail(notFound(\"glob\", pattern));\n },\n exists() {\n return Effect.succeed(false);\n },\n link(path) {\n return Effect.fail(notFound(\"link\", path));\n },\n makeDirectory() {\n return Effect.die(\"not implemented\");\n },\n makeTempDirectory() {\n return Effect.die(\"not implemented\");\n },\n makeTempDirectoryScoped() {\n return Effect.die(\"not implemented\");\n },\n makeTempFile() {\n return Effect.die(\"not implemented\");\n },\n makeTempFileScoped() {\n return Effect.die(\"not implemented\");\n },\n open(path) {\n return Effect.fail(notFound(\"open\", path));\n },\n readDirectory(path) {\n return Effect.fail(notFound(\"readDirectory\", path));\n },\n readFile(path) {\n return Effect.fail(notFound(\"readFile\", path));\n },\n readFileString(path) {\n return Effect.fail(notFound(\"readFileString\", path));\n },\n readLink(path) {\n return Effect.fail(notFound(\"readLink\", path));\n },\n realPath(path) {\n return Effect.fail(notFound(\"realPath\", path));\n },\n remove() {\n return Effect.void;\n },\n rename(oldPath) {\n return Effect.fail(notFound(\"rename\", oldPath));\n },\n sink(path) {\n return Sink.fail(notFound(\"sink\", path));\n },\n stat(path) {\n return Effect.fail(notFound(\"stat\", path));\n },\n stream(path) {\n return Stream.fail(notFound(\"stream\", path));\n },\n symlink(fromPath) {\n return Effect.fail(notFound(\"symlink\", fromPath));\n },\n truncate(path) {\n return Effect.fail(notFound(\"truncate\", path));\n },\n utimes(path) {\n return Effect.fail(notFound(\"utimes\", path));\n },\n watch(path) {\n return Stream.fail(notFound(\"watch\", path));\n },\n writeFile(path) {\n return Effect.fail(notFound(\"writeFile\", path));\n },\n writeFileString(path) {\n return Effect.fail(notFound(\"writeFileString\", path));\n },\n ...fileSystem\n});\n/**\n * Creates a Layer that provides a no-op FileSystem implementation for testing.\n *\n * **Details**\n *\n * This is a convenience function that wraps `makeNoop` in a Layer, making it easy\n * to provide the test filesystem to your Effect programs.\n *\n * **Example** (Providing a no-op FileSystem layer)\n *\n * ```ts import.meta.vitest\n * import { Effect, FileSystem } from \"effect\"\n *\n * // Create a test layer with specific behaviors\n * const testLayer = FileSystem.layerNoop({\n * readFileString: (path) => Effect.succeed(\"mocked content\"),\n * exists: () => Effect.succeed(true)\n * })\n *\n * const program = Effect.gen(function*() {\n * const fs = yield* FileSystem.FileSystem\n * const content = yield* fs.readFileString(\"any-file.txt\")\n * return content\n * })\n *\n * // Provide the test layer\n * const testProgram = Effect.provide(program, testLayer)\n * Effect.runSync(testProgram) // => \"mocked content\"\n * ```\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layerNoop = fileSystem => Layer.succeed(FileSystem)(makeNoop(fileSystem));\n/**\n * Runtime type identifier attached to `FileSystem.File` handles and used by\n * `isFile` to recognize them.\n *\n * **Details**\n *\n * This marker is part of the runtime representation of file handles. Prefer\n * `isFile` when narrowing unknown values.\n *\n * @see {@link File} for the open file handle shape that carries this marker\n * @see {@link isFile} for the public guard that checks this marker\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const FileTypeId = \"~effect/FileSystem/File\";\n/**\n * Returns `true` if a value is a `File` handle by checking for the\n * `FileTypeId` marker.\n *\n * **When to use**\n *\n * Use when accepting an unknown value and you need to narrow it to a `File`\n * before calling file-handle operations.\n *\n * **Details**\n *\n * This is a structural marker check. It does not validate the marker value or\n * the shape of the file handle.\n *\n * @see {@link File} for the file-handle interface narrowed by this guard\n * @see {@link FileTypeId} for the runtime marker checked by this guard\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isFile = u => hasProperty(u, FileTypeId);\n/**\n * Service key for file system watch backend implementations.\n *\n * **Details**\n *\n * This service provides the low-level file watching capabilities that can be\n * implemented differently on various platforms (e.g., inotify on Linux,\n * FSEvents on macOS, etc.).\n *\n * **Example** (Providing a custom watch backend)\n *\n * ```ts import.meta.vitest\n * import { Effect, FileSystem, Option, Stream } from \"effect\"\n *\n * // Custom watch backend implementation\n * const customWatchBackend = {\n * register: (path: string, stat: FileSystem.File.Info) => {\n * // Implementation would depend on platform\n * return Option.some(Stream.empty) // Placeholder implementation\n * }\n * }\n *\n * const program = Effect.gen(function*() {\n * const backend = yield* FileSystem.WatchBackend\n * return Option.isSome(\n * backend.register(\"./directory\", { type: \"Directory\" } as FileSystem.File.Info)\n * )\n * })\n *\n * const withCustomBackend = Effect.provideService(\n * program,\n * FileSystem.WatchBackend,\n * customWatchBackend\n * )\n * Effect.runSync(withCustomBackend) // => true\n * ```\n *\n * @category services\n * @since 4.0.0\n */\nexport class WatchBackend extends /*#__PURE__*/Context.Service()(\"effect/FileSystem/WatchBackend\") {}\n//# sourceMappingURL=FileSystem.js.map","/**\n * Provides path operations through the Effect environment.\n *\n * The `Path` service works with file system paths without tying code to one\n * concrete platform module. It exposes common operations such as joining,\n * normalizing, parsing, formatting, resolving, and converting paths to or from\n * file URLs. This module includes the service interface, parsed path type,\n * service tag, runtime marker, and built-in POSIX path layer.\n *\n * @since 4.0.0\n */\nimport * as Context from \"./Context.js\";\nimport * as Effect from \"./Effect.js\";\nimport { identity } from \"./Function.js\";\nimport * as Layer from \"./Layer.js\";\nimport { BadArgument } from \"./PlatformError.js\";\n/**\n * Runtime type identifier used to mark implementations of the `Path` service.\n *\n * **Details**\n *\n * The marker is the exact string stored on `Path` service implementations.\n * Most code should depend on the `Path` service instead of inspecting this\n * value directly.\n *\n * @see {@link layer} for the built-in POSIX `Path` service layer\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = \"~effect/Path\";\n/**\n * Service tag for accessing the current `Path` implementation.\n *\n * **When to use**\n *\n * Use when you need path operations supplied by an effect's environment.\n *\n * **Example** (Providing a custom Path service)\n *\n * ```ts import.meta.vitest\n * import { Effect, Layer, Path } from \"effect\"\n *\n * // Create a custom path implementation\n * const customPath: Path.Path = {\n * [Path.TypeId]: Path.TypeId,\n * sep: \"/\",\n * basename: (path: string, suffix?: string) => {\n * const base = path.split(\"/\").pop() || \"\"\n * return suffix && base.endsWith(suffix)\n * ? base.slice(0, -suffix.length)\n * : base\n * },\n * dirname: (path: string) => path.split(\"/\").slice(0, -1).join(\"/\") || \"/\",\n * extname: (path: string) => {\n * const match = path.match(/\\.[^.]*$/)\n * return match ? match[0] : \"\"\n * },\n * format: (pathObject) => {\n * const dir = pathObject.dir || \"\"\n * const name = pathObject.name || \"\"\n * const ext = pathObject.ext || \"\"\n * return dir ? `${dir}/${name}${ext}` : `${name}${ext}`\n * },\n * fromFileUrl: (url: URL) => Effect.succeed(url.pathname),\n * isAbsolute: (path: string) => path.startsWith(\"/\"),\n * join: (...paths: ReadonlyArray) => paths.join(\"/\"),\n * normalize: (path: string) => path.replace(/\\/+/g, \"/\"),\n * parse: (path: string) => ({\n * root: path.startsWith(\"/\") ? \"/\" : \"\",\n * dir: path.split(\"/\").slice(0, -1).join(\"/\") || \"/\",\n * base: path.split(\"/\").pop() || \"\",\n * ext: path.match(/\\.[^.]*$/)?.[0] || \"\",\n * name: path.split(\"/\").pop()?.replace(/\\.[^.]*$/, \"\") || \"\"\n * }),\n * relative: (from: string, to: string) => to.replace(from, \"\"),\n * resolve: (...pathSegments: ReadonlyArray) => pathSegments.join(\"/\"),\n * toFileUrl: (path: string) => Effect.succeed(new URL(`file://${path}`)),\n * toNamespacedPath: (path: string) => path\n * }\n *\n * // Provide the path service\n * const customPathLayer = Layer.succeed(Path.Path)(customPath)\n *\n * const program = Effect.gen(function*() {\n * const path = yield* Path.Path\n * return path.join(\"home\", \"user\", \"file.txt\")\n * })\n *\n * // Run with custom path implementation\n * Effect.runSync(Effect.provide(program, customPathLayer)) // => \"home/user/file.txt\"\n * ```\n *\n * @category services\n * @since 4.0.0\n */\nexport const Path = /*#__PURE__*/Context.Service(\"effect/Path\");\n/**\n * The following functions are adapted from the Node.js source code:\n * https://github.com/nodejs/node/blob/main/lib/internal/url.js\n *\n * The following license applies to these functions:\n * - MIT\n */\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path, allowAboveRoot) {\n let res = \"\";\n let lastSegmentLength = 0;\n let lastSlash = -1;\n let dots = 0;\n let code;\n for (let i = 0; i <= path.length; ++i) {\n if (i < path.length) {\n code = path.charCodeAt(i);\n } else if (code === 47 /*/*/) {\n break;\n } else {\n code = 47; /*/*/\n }\n if (code === 47 /*/*/) {\n if (lastSlash === i - 1 || dots === 1) {\n // NOOP\n } else if (lastSlash !== i - 1 && dots === 2) {\n if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {\n if (res.length > 2) {\n const lastSlashIndex = res.lastIndexOf(\"/\");\n if (lastSlashIndex !== res.length - 1) {\n if (lastSlashIndex === -1) {\n res = \"\";\n lastSegmentLength = 0;\n } else {\n res = res.slice(0, lastSlashIndex);\n lastSegmentLength = res.length - 1 - res.lastIndexOf(\"/\");\n }\n lastSlash = i;\n dots = 0;\n continue;\n }\n } else if (res.length === 2 || res.length === 1) {\n res = \"\";\n lastSegmentLength = 0;\n lastSlash = i;\n dots = 0;\n continue;\n }\n }\n if (allowAboveRoot) {\n if (res.length > 0) {\n res += \"/..\";\n } else {\n res = \"..\";\n }\n lastSegmentLength = 2;\n }\n } else {\n if (res.length > 0) {\n res += \"/\" + path.slice(lastSlash + 1, i);\n } else {\n res = path.slice(lastSlash + 1, i);\n }\n lastSegmentLength = i - lastSlash - 1;\n }\n lastSlash = i;\n dots = 0;\n } else if (code === 46 /*.*/ && dots !== -1) {\n ++dots;\n } else {\n dots = -1;\n }\n }\n return res;\n}\nfunction _format(sep, pathObject) {\n const dir = pathObject.dir || pathObject.root;\n const base = pathObject.base || (pathObject.name || \"\") + (pathObject.ext || \"\");\n if (!dir) {\n return base;\n }\n if (dir === pathObject.root) {\n return dir + base;\n }\n return dir + sep + base;\n}\nfunction fromFileUrl(url) {\n if (url.protocol !== \"file:\") {\n return Effect.fail(new BadArgument({\n module: \"Path\",\n method: \"fromFileUrl\",\n description: \"URL must be of scheme file\"\n }));\n } else if (url.hostname !== \"\") {\n return Effect.fail(new BadArgument({\n module: \"Path\",\n method: \"fromFileUrl\",\n description: \"Invalid file URL host\"\n }));\n }\n const pathname = url.pathname;\n for (let n = 0; n < pathname.length; n++) {\n if (pathname[n] === \"%\") {\n const third = pathname.codePointAt(n + 2) | 0x20;\n if (pathname[n + 1] === \"2\" && third === 102) {\n return Effect.fail(new BadArgument({\n module: \"Path\",\n method: \"fromFileUrl\",\n description: \"must not include encoded / characters\"\n }));\n }\n }\n }\n return Effect.succeed(decodeURIComponent(pathname));\n}\nconst resolve = function resolve() {\n let resolvedPath = \"\";\n let resolvedAbsolute = false;\n let cwd = undefined;\n for (let i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n let path;\n if (i >= 0) {\n path = arguments[i];\n } else {\n const process = globalThis.process;\n if (cwd === undefined && \"process\" in globalThis && typeof process === \"object\" && process !== null && typeof process.cwd === \"function\") {\n cwd = process.cwd();\n }\n path = cwd;\n }\n // Skip empty entries\n if (path.length === 0) {\n continue;\n }\n resolvedPath = path + \"/\" + resolvedPath;\n resolvedAbsolute = path.charCodeAt(0) === 47; /*/*/\n }\n // At this point the path should be resolved to a full absolute path, but\n // handle relative paths to be safe (might happen when process.cwd() fails)\n // Normalize the path\n resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n if (resolvedAbsolute) {\n if (resolvedPath.length > 0) {\n return \"/\" + resolvedPath;\n } else {\n return \"/\";\n }\n } else if (resolvedPath.length > 0) {\n return resolvedPath;\n } else {\n return \".\";\n }\n};\nconst CHAR_FORWARD_SLASH = 47;\nfunction toFileUrl(filepath) {\n const outURL = new URL(\"file://\");\n let resolved = resolve(filepath);\n // path.resolve strips trailing slashes so we must add them back\n const filePathLast = filepath.charCodeAt(filepath.length - 1);\n if (filePathLast === CHAR_FORWARD_SLASH && resolved[resolved.length - 1] !== \"/\") {\n resolved += \"/\";\n }\n outURL.pathname = encodePathChars(resolved);\n return Effect.succeed(outURL);\n}\nconst percentRegExp = /%/g;\nconst backslashRegExp = /\\\\/g;\nconst newlineRegExp = /\\n/g;\nconst carriageReturnRegExp = /\\r/g;\nconst tabRegExp = /\\t/g;\nfunction encodePathChars(filepath) {\n if (filepath.includes(\"%\")) {\n filepath = filepath.replace(percentRegExp, \"%25\");\n }\n if (filepath.includes(\"\\\\\")) {\n filepath = filepath.replace(backslashRegExp, \"%5C\");\n }\n if (filepath.includes(\"\\n\")) {\n filepath = filepath.replace(newlineRegExp, \"%0A\");\n }\n if (filepath.includes(\"\\r\")) {\n filepath = filepath.replace(carriageReturnRegExp, \"%0D\");\n }\n if (filepath.includes(\"\\t\")) {\n filepath = filepath.replace(tabRegExp, \"%09\");\n }\n return filepath;\n}\nconst posixImpl = /*#__PURE__*/Path.of({\n [TypeId]: TypeId,\n resolve,\n normalize(path) {\n if (path.length === 0) return \".\";\n const isAbsolute = path.charCodeAt(0) === 47; /*/*/\n const trailingSeparator = path.charCodeAt(path.length - 1) === 47; /*/*/\n // Normalize the path\n path = normalizeStringPosix(path, !isAbsolute);\n if (path.length === 0 && !isAbsolute) path = \".\";\n if (path.length > 0 && trailingSeparator) path += \"/\";\n if (isAbsolute) return \"/\" + path;\n return path;\n },\n isAbsolute(path) {\n return path.length > 0 && path.charCodeAt(0) === 47; /*/*/\n },\n join() {\n if (arguments.length === 0) {\n return \".\";\n }\n let joined;\n for (let i = 0; i < arguments.length; ++i) {\n const arg = arguments[i];\n if (arg.length > 0) {\n if (joined === undefined) {\n joined = arg;\n } else {\n joined += \"/\" + arg;\n }\n }\n }\n if (joined === undefined) {\n return \".\";\n }\n return posixImpl.normalize(joined);\n },\n relative(from, to) {\n if (from === to) return \"\";\n from = posixImpl.resolve(from);\n to = posixImpl.resolve(to);\n if (from === to) return \"\";\n // Trim any leading backslashes\n let fromStart = 1;\n for (; fromStart < from.length; ++fromStart) {\n if (from.charCodeAt(fromStart) !== 47 /*/*/) {\n break;\n }\n }\n const fromEnd = from.length;\n const fromLen = fromEnd - fromStart;\n // Trim any leading backslashes\n let toStart = 1;\n for (; toStart < to.length; ++toStart) {\n if (to.charCodeAt(toStart) !== 47 /*/*/) {\n break;\n }\n }\n const toEnd = to.length;\n const toLen = toEnd - toStart;\n // Compare paths to find the longest common path from root\n const length = fromLen < toLen ? fromLen : toLen;\n let lastCommonSep = -1;\n let i = 0;\n for (; i <= length; ++i) {\n if (i === length) {\n if (toLen > length) {\n if (to.charCodeAt(toStart + i) === 47 /*/*/) {\n // We get here if `from` is the exact base path for `to`.\n // For example: from='/foo/bar'; to='/foo/bar/baz'\n return to.slice(toStart + i + 1);\n } else if (i === 0) {\n // We get here if `from` is the root\n // For example: from='/'; to='/foo'\n return to.slice(toStart + i);\n }\n } else if (fromLen > length) {\n if (from.charCodeAt(fromStart + i) === 47 /*/*/) {\n // We get here if `to` is the exact base path for `from`.\n // For example: from='/foo/bar/baz'; to='/foo/bar'\n lastCommonSep = i;\n } else if (i === 0) {\n // We get here if `to` is the root.\n // For example: from='/foo'; to='/'\n lastCommonSep = 0;\n }\n }\n break;\n }\n const fromCode = from.charCodeAt(fromStart + i);\n const toCode = to.charCodeAt(toStart + i);\n if (fromCode !== toCode) {\n break;\n } else if (fromCode === 47 /*/*/) {\n lastCommonSep = i;\n }\n }\n let out = \"\";\n // Generate the relative path based on the path difference between `to`\n // and `from`\n for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {\n if (out.length === 0) {\n out += \"..\";\n } else {\n out += \"/..\";\n }\n }\n }\n // Lastly, append the rest of the destination (`to`) path that comes after\n // the common path parts\n if (out.length > 0) {\n return out + to.slice(toStart + lastCommonSep);\n } else {\n toStart += lastCommonSep;\n if (to.charCodeAt(toStart) === 47 /*/*/) {\n ++toStart;\n }\n return to.slice(toStart);\n }\n },\n dirname(path) {\n if (path.length === 0) return \".\";\n let code = path.charCodeAt(0);\n const hasRoot = code === 47; /*/*/\n let end = -1;\n let matchedSlash = true;\n for (let i = path.length - 1; i >= 1; --i) {\n code = path.charCodeAt(i);\n if (code === 47 /*/*/) {\n if (!matchedSlash) {\n end = i;\n break;\n }\n } else {\n // We saw the first non-path separator\n matchedSlash = false;\n }\n }\n if (end === -1) return hasRoot ? \"/\" : \".\";\n if (hasRoot && end === 1) return \"//\";\n return path.slice(0, end);\n },\n basename(path, ext) {\n let start = 0;\n let end = -1;\n let matchedSlash = true;\n let i;\n if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n if (ext.length === path.length && ext === path) return \"\";\n let extIdx = ext.length - 1;\n let firstNonSlashEnd = -1;\n for (i = path.length - 1; i >= 0; --i) {\n const code = path.charCodeAt(i);\n if (code === 47 /*/*/) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n start = i + 1;\n break;\n }\n } else {\n if (firstNonSlashEnd === -1) {\n // We saw the first non-path separator, remember this index in case\n // we need it if the extension ends up not matching\n matchedSlash = false;\n firstNonSlashEnd = i + 1;\n }\n if (extIdx >= 0) {\n // Try to match the explicit extension\n if (code === ext.charCodeAt(extIdx)) {\n if (--extIdx === -1) {\n // We matched the extension, so mark this as the end of our path\n // component\n end = i;\n }\n } else {\n // Extension does not match, so our result is the entire path\n // component\n extIdx = -1;\n end = firstNonSlashEnd;\n }\n }\n }\n }\n if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;\n return path.slice(start, end);\n } else {\n for (i = path.length - 1; i >= 0; --i) {\n if (path.charCodeAt(i) === 47 /*/*/) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n start = i + 1;\n break;\n }\n } else if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // path component\n matchedSlash = false;\n end = i + 1;\n }\n }\n if (end === -1) return \"\";\n return path.slice(start, end);\n }\n },\n extname(path) {\n let startDot = -1;\n let startPart = 0;\n let end = -1;\n let matchedSlash = true;\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find\n let preDotState = 0;\n for (let i = path.length - 1; i >= 0; --i) {\n const code = path.charCodeAt(i);\n if (code === 47 /*/*/) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n startPart = i + 1;\n break;\n }\n continue;\n }\n if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // extension\n matchedSlash = false;\n end = i + 1;\n }\n if (code === 46 /*.*/) {\n // If this is our first dot, mark it as the start of our extension\n if (startDot === -1) {\n startDot = i;\n } else if (preDotState !== 1) {\n preDotState = 1;\n }\n } else if (startDot !== -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension\n preDotState = -1;\n }\n }\n if (startDot === -1 || end === -1 ||\n // We saw a non-dot character immediately before the dot\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly '..'\n preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n return \"\";\n }\n return path.slice(startDot, end);\n },\n format: function format(pathObject) {\n if (pathObject === null || typeof pathObject !== \"object\") {\n throw new TypeError(\"The \\\"pathObject\\\" argument must be of type Object. Received type \" + typeof pathObject);\n }\n return _format(\"/\", pathObject);\n },\n parse(path) {\n const ret = {\n root: \"\",\n dir: \"\",\n base: \"\",\n ext: \"\",\n name: \"\"\n };\n if (path.length === 0) return ret;\n let code = path.charCodeAt(0);\n const isAbsolute = code === 47; /*/*/\n let start;\n if (isAbsolute) {\n ret.root = \"/\";\n start = 1;\n } else {\n start = 0;\n }\n let startDot = -1;\n let startPart = 0;\n let end = -1;\n let matchedSlash = true;\n let i = path.length - 1;\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find\n let preDotState = 0;\n // Get non-dir info\n for (; i >= start; --i) {\n code = path.charCodeAt(i);\n if (code === 47 /*/*/) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n startPart = i + 1;\n break;\n }\n continue;\n }\n if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // extension\n matchedSlash = false;\n end = i + 1;\n }\n if (code === 46 /*.*/) {\n // If this is our first dot, mark it as the start of our extension\n if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n } else if (startDot !== -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension\n preDotState = -1;\n }\n }\n if (startDot === -1 || end === -1 ||\n // We saw a non-dot character immediately before the dot\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly '..'\n preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n if (end !== -1) {\n if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);\n }\n } else {\n if (startPart === 0 && isAbsolute) {\n ret.name = path.slice(1, startDot);\n ret.base = path.slice(1, end);\n } else {\n ret.name = path.slice(startPart, startDot);\n ret.base = path.slice(startPart, end);\n }\n ret.ext = path.slice(startDot, end);\n }\n if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = \"/\";\n return ret;\n },\n sep: \"/\",\n fromFileUrl,\n toFileUrl,\n toNamespacedPath: identity\n});\n/**\n * Layer that provides the built-in POSIX `Path` implementation.\n *\n * **When to use**\n *\n * Use when you need an effect that requires the `Path` service to run with the\n * built-in POSIX path implementation.\n *\n * **Details**\n *\n * The layer provides a static service whose separator is `/` and whose\n * operations use POSIX path semantics.\n *\n * @see {@link Path} for accessing the `Path` service from an effect\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = /*#__PURE__*/Layer.succeed(Path)(posixImpl);\n//# sourceMappingURL=Path.js.map","import { memoize } from \"../../Function.js\";\n/** @internal */\nexport function resolve(ast) {\n return ast.checks ? ast.checks[ast.checks.length - 1].annotations : ast.annotations;\n}\n/** @internal */\nexport function resolveAt(key) {\n return ast => resolve(ast)?.[key];\n}\n/** @internal */\nexport const STRUCTURAL_ANNOTATION_KEY = \"~structural\";\n/** @internal */\nexport const IDENTIFIER_FALLBACK_KEY = \"~identifier\";\n/** @internal */\nexport const SENTINELS_ANNOTATION_KEY = \"~sentinels\";\n/** @internal */\nexport const CONSTRUCTOR_ANNOTATION_KEY = \"~constructor\";\n/** @internal */\nexport const jsonSchemaAnnotationKeys = [\"title\", \"description\", \"default\", \"examples\", \"readOnly\", \"writeOnly\", \"format\", \"contentEncoding\", \"contentMediaType\", \"contentSchema\"];\n/** @internal */\nexport const resolveIdentifier = /*#__PURE__*/resolveAt(\"identifier\");\n/** @internal */\nexport const resolveIdentifierFallback = /*#__PURE__*/resolveAt(IDENTIFIER_FALLBACK_KEY);\n/** @internal */\nexport const resolveTitle = /*#__PURE__*/resolveAt(\"title\");\n/** @internal */\nexport const resolveDescription = /*#__PURE__*/resolveAt(\"description\");\n/** @internal */\nexport const resolveBrands = /*#__PURE__*/resolveAt(\"brands\");\n/** @internal */\nexport const getExpected = /*#__PURE__*/memoize(ast => {\n const identifier = resolve(ast)?.identifier;\n if (typeof identifier === \"string\") return identifier;\n return ast.getExpected(getExpected);\n});\n/** @internal */\nexport function collectBrands(annotations) {\n return annotations !== undefined && Array.isArray(annotations.brands) ? annotations.brands : [];\n}\n/** @internal */\nexport const annotationExcludedKeys = /*#__PURE__*/new Set([SENTINELS_ANNOTATION_KEY, STRUCTURAL_ANNOTATION_KEY, \"representation\", \"arbitraryConstraint\", \"brands\", \"toJsonSchema\", \"toCode\", \"toEquivalence\", \"toFormatter\", \"toCodec\", \"toCodecJson\", \"toCodecStringTree\", \"toCodecIso\", \"toCodecArbitrary\"]);\n//# sourceMappingURL=annotations.js.map","import * as Exit from \"../../Exit.js\";\nimport * as Option from \"../../Option.js\";\nimport { args } from \"../core.js\";\n/** @internal */\nexport const missing = /*#__PURE__*/Symbol();\n/** @internal */\nexport { args };\n/** @internal */\nexport const succeed = Exit.succeed;\n/** @internal */\nexport const missingExit = /*#__PURE__*/succeed(missing);\n// Shared success for a present input returned unchanged. It must be resolved\n// before crossing an asynchronous or transformation boundary.\n/** @internal */\nexport const sameExit = /*#__PURE__*/succeed(missing);\n/** @internal */\nexport const toOption = value => value === missing ? Option.none() : Option.some(value);\n/** @internal */\nexport const fromOptionExit = option => option._tag === \"None\" ? missingExit : succeed(option.value);\n//# sourceMappingURL=parser.js.map","/**\n * Describes problems found while decoding, encoding, or checking data with\n * schemas.\n *\n * An `Issue` records what failed and, for nested data, where the failure\n * happened. The Schema system uses these values for missing keys, unexpected\n * keys, invalid types, invalid values, failed filters, failed transformations,\n * and alternatives that did not match. This module also formats issues.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"./Array.js\";\nimport { format, formatPath } from \"./Formatter.js\";\nimport * as InternalAnnotations from \"./internal/schema/annotations.js\";\nimport * as InternalParser from \"./internal/schema/parser.js\";\nimport { hasProperty } from \"./Predicate.js\";\nconst TypeId = \"~effect/SchemaIssue/Issue\";\n/**\n * Returns `true` if the given value is an {@link Issue}.\n *\n * **When to use**\n *\n * Use when you need to narrow an `unknown` value to `Issue` in error-handling\n * code, such as distinguishing an `Issue` from other error types in a catch-all\n * handler.\n *\n * **Details**\n *\n * - Checks for the internal `TypeId` brand on the value.\n *\n * **Example** (Type-guarding an unknown error)\n *\n * ```ts import.meta.vitest\n * import { SchemaIssue } from \"effect\"\n *\n * const issue = new SchemaIssue.MissingKey(undefined)\n * SchemaIssue.isIssue(issue) // => true\n * SchemaIssue.isIssue(\"not an issue\") // => false\n * ```\n *\n * @see {@link Issue}\n *\n * @category guards\n * @since 4.0.0\n */\nexport function isIssue(u) {\n return hasProperty(u, TypeId) && u[TypeId] === TypeId;\n}\n/**\n * Returns `true` when an issue contains an input reported by the schema parser.\n *\n * **When to use**\n *\n * Use when reading `Issue.input`, especially when `undefined` is a valid input\n * value.\n *\n * **Details**\n *\n * Reported input is stored as an own property. This guard checks for that\n * property and narrows `input` from optional to required.\n *\n * **Example** (Reading a reported input)\n *\n * ```ts import.meta.vitest\n * import { Result, Schema, SchemaIssue } from \"effect\"\n *\n * const result = Schema.decodeUnknownResult(Schema.String)(1, { reportInput: true })\n * if (Result.isFailure(result) && SchemaIssue.hasInput(result.failure.issue)) {\n * result.failure.issue.input // => 1\n * }\n * ```\n *\n * @see {@link Issue} for the complete issue model\n *\n * @category guards\n * @since 4.0.0\n */\nexport function hasInput(issue) {\n return Object.hasOwn(issue, \"input\");\n}\nclass IssueNodeImpl {\n [TypeId] = TypeId;\n constructor(input, options) {\n if (options?.reportInput === true && input !== InternalParser.missing) {\n this.input = input;\n }\n }\n}\n/**\n * Constructs a schema issue for a failed refinement check.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Filter = class extends IssueNodeImpl {\n _tag = \"Filter\";\n /**\n * The filter that failed.\n */\n filter;\n /**\n * The issue that occurred.\n */\n issue;\n constructor(\n /**\n * The filter that failed.\n */\n filter,\n /**\n * The issue that occurred.\n */\n issue,\n /**\n * The present input associated with the issue. It is retained only when\n * `options.reportInput` is `true`.\n */\n input,\n /**\n * The effective parse options controlling input retention.\n */\n options) {\n super(input, options);\n this.filter = filter;\n this.issue = issue;\n }\n};\n/**\n * Constructs a schema issue for a failed transformation.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Encoding = class extends IssueNodeImpl {\n _tag = \"Encoding\";\n /**\n * The schema that caused the issue.\n */\n ast;\n /**\n * The issue that occurred.\n */\n issue;\n constructor(\n /**\n * The schema that caused the issue.\n */\n ast,\n /**\n * The issue that occurred.\n */\n issue,\n /**\n * The present input associated with the issue. It is retained only when\n * `options.reportInput` is `true`.\n */\n input,\n /**\n * The effective parse options controlling input retention.\n */\n options) {\n super(input, options);\n this.ast = ast;\n this.issue = issue;\n }\n};\n/**\n * Constructs a schema issue that points to a nested location.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Pointer = class extends IssueNodeImpl {\n _tag = \"Pointer\";\n /**\n * The path to the location in the input that caused the issue.\n */\n path;\n /**\n * The issue that occurred.\n */\n issue;\n constructor(\n /**\n * The path to the location in the input that caused the issue.\n */\n path,\n /**\n * The issue that occurred.\n */\n issue) {\n super();\n this.path = path;\n this.issue = issue;\n }\n};\n/**\n * Constructs a schema issue for a missing key or tuple index.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const MissingKey = class extends IssueNodeImpl {\n _tag = \"MissingKey\";\n /**\n * The metadata for the issue.\n */\n annotations;\n constructor(\n /**\n * The metadata for the issue.\n */\n annotations) {\n super();\n this.annotations = annotations;\n }\n};\n/**\n * Constructs a schema issue for an unexpected key or tuple index.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const UnexpectedKey = class extends IssueNodeImpl {\n _tag = \"UnexpectedKey\";\n /**\n * The schema that caused the issue.\n */\n ast;\n constructor(\n /**\n * The schema that caused the issue.\n */\n ast,\n /**\n * The present input associated with the issue. It is retained only when\n * `options.reportInput` is `true`.\n */\n input,\n /**\n * The effective parse options controlling input retention.\n */\n options) {\n super(input, options);\n this.ast = ast;\n }\n};\n/**\n * Constructs a schema issue that groups multiple child issues.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Composite = class extends IssueNodeImpl {\n _tag = \"Composite\";\n /**\n * The schema that caused the issue.\n */\n ast;\n /**\n * The issues that occurred.\n */\n issues;\n constructor(\n /**\n * The schema that caused the issue.\n */\n ast,\n /**\n * The issues that occurred.\n */\n issues,\n /**\n * The present input associated with the issue. It is retained only when\n * `options.reportInput` is `true`.\n */\n input,\n /**\n * The effective parse options controlling input retention.\n */\n options) {\n super(input, options);\n this.ast = ast;\n this.issues = issues;\n }\n};\n/**\n * Constructs a schema issue for an input with an invalid runtime type.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const InvalidType = class extends IssueNodeImpl {\n _tag = \"InvalidType\";\n /**\n * The schema that caused the issue.\n */\n ast;\n constructor(\n /**\n * The schema that caused the issue.\n */\n ast,\n /**\n * The present input associated with the issue. It is retained only when\n * `options.reportInput` is `true`.\n */\n input,\n /**\n * The effective parse options controlling input retention.\n */\n options) {\n super(input, options);\n this.ast = ast;\n }\n};\n/**\n * Constructs a schema issue for a value that violates a constraint.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const InvalidValue = class extends IssueNodeImpl {\n _tag = \"InvalidValue\";\n /**\n * The metadata for the issue.\n */\n annotations;\n constructor(\n /**\n * The metadata for the issue.\n */\n annotations,\n /**\n * The present input associated with the issue. It is retained only when\n * `options.reportInput` is `true`.\n */\n input,\n /**\n * The effective parse options controlling input retention.\n */\n options) {\n super(input, options);\n this.annotations = annotations;\n }\n};\n/** @internal */\nexport function makeCompositeAtKey(compositeAst, pointerKey, pointerIssue, compositeInput, parseOptions) {\n return new Composite(compositeAst, [new Pointer([pointerKey], pointerIssue)], compositeInput, parseOptions);\n}\n/**\n * Constructs a schema issue for a forbidden parsing operation.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Forbidden = class extends IssueNodeImpl {\n _tag = \"Forbidden\";\n /**\n * The metadata for the issue.\n */\n annotations;\n constructor(\n /**\n * The metadata for the issue.\n */\n annotations,\n /**\n * The present input associated with the issue. It is retained only when\n * `options.reportInput` is `true`.\n */\n input,\n /**\n * The effective parse options controlling input retention.\n */\n options) {\n super(input, options);\n this.annotations = annotations;\n }\n};\n/**\n * Constructs a schema issue for a value that matches no union member.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const AnyOf = class extends IssueNodeImpl {\n _tag = \"AnyOf\";\n /**\n * The schema that caused the issue.\n */\n ast;\n /**\n * The issues that occurred.\n */\n issues;\n constructor(\n /**\n * The schema that caused the issue.\n */\n ast,\n /**\n * The issues that occurred.\n */\n issues,\n /**\n * The present input associated with the issue. It is retained only when\n * `options.reportInput` is `true`.\n */\n input,\n /**\n * The effective parse options controlling input retention.\n */\n options) {\n super(input, options);\n this.ast = ast;\n this.issues = issues;\n }\n};\n/**\n * Constructs a schema issue for a value that matches multiple union members.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const OneOf = class extends IssueNodeImpl {\n _tag = \"OneOf\";\n /**\n * The schema that caused the issue.\n */\n ast;\n /**\n * The schemas that were successful.\n */\n successes;\n constructor(\n /**\n * The schema that caused the issue.\n */\n ast,\n /**\n * The schemas that were successful.\n */\n successes,\n /**\n * The present input associated with the issue. It is retained only when\n * `options.reportInput` is `true`.\n */\n input,\n /**\n * The effective parse options controlling input retention.\n */\n options) {\n super(input, options);\n this.ast = ast;\n this.successes = successes;\n }\n};\nfunction makeFilterIssue(entry, input, options) {\n if (isIssue(entry)) {\n return entry;\n }\n if (typeof entry === \"string\") {\n return new InvalidValue({\n message: entry\n }, input, options);\n }\n const inner = typeof entry.issue === \"string\" ? new InvalidValue({\n message: entry.issue\n }, input, options) : entry.issue;\n return new Pointer(entry.path, inner);\n}\n/** @internal */\nexport function makeSingle(out, input, options) {\n if (out === undefined) {\n return undefined;\n }\n if (typeof out === \"boolean\") {\n return out ? undefined : new InvalidValue(undefined, input, options);\n }\n return makeFilterIssue(out, input, options);\n}\n/** @internal */\nexport function normalizeFilterOutput(ast, out, input, options) {\n if (Array.isArray(out)) {\n if (!Arr.isReadonlyArrayNonEmpty(out)) {\n return undefined;\n }\n return out.length === 1 ? makeFilterIssue(out[0], input, options) : new Composite(ast, Arr.map(out, entry => makeFilterIssue(entry, input, options)), input, options);\n }\n return makeSingle(out, input, options);\n}\n/**\n * Returns the built-in {@link LeafHook} used by default formatters.\n *\n * **When to use**\n *\n * Use as the default leaf renderer when customizing only the {@link CheckHook}.\n *\n * **Details**\n *\n * - Checks for a `message` annotation first; returns it if present.\n * - For `InvalidValue`, an `expected` annotation uses the standard expected\n * value message and includes reported input when available.\n * - Otherwise generates a default message per `_tag`. When the issue reports\n * input, the message includes its formatted value where applicable:\n * - `InvalidType` → `\"Expected \"` or `\"Expected , got \"`\n * - `InvalidValue` → `\"Expected a valid value\"` or `\"Invalid data \"`\n * - `MissingKey` → `\"Missing key\"`\n * - `UnexpectedKey` → `\"Expected no excess property\"` or\n * `\"Unexpected key with value \"`\n * - `Forbidden` → `\"Forbidden operation\"`\n * - `OneOf` → `\"Expected exactly one member to match\"` or\n * `\"Expected exactly one member to match the input \"`\n *\n * **Example** (Formatting Standard Schema issues with defaultLeafHook)\n *\n * ```ts import.meta.vitest\n * import { SchemaIssue } from \"effect\"\n *\n * const formatter = SchemaIssue.makeFormatterStandardSchemaV1({\n * leafHook: SchemaIssue.defaultLeafHook\n * })\n * formatter(new SchemaIssue.MissingKey(undefined)) // => { issues: [{ path: [], message: \"Missing key\" }] }\n * ```\n *\n * @see {@link LeafHook}\n * @see {@link makeFormatterStandardSchemaV1}\n *\n * @category formatting\n * @since 4.0.0\n */\nexport const defaultLeafHook = issue => {\n const message = findMessage(issue);\n if (message !== undefined) return message;\n switch (issue._tag) {\n case \"InvalidType\":\n return getExpectedMessage(InternalAnnotations.getExpected(issue.ast), issue);\n case \"InvalidValue\":\n {\n const expected = findExpected(issue);\n if (expected !== undefined) return getExpectedMessage(expected, issue);\n const input = formatInput(issue);\n return input === undefined ? \"Expected a valid value\" : `Invalid data ${input}`;\n }\n case \"MissingKey\":\n return \"Missing key\";\n case \"UnexpectedKey\":\n {\n const input = formatInput(issue);\n return input === undefined ? \"Expected no excess property\" : `Unexpected key with value ${input}`;\n }\n case \"Forbidden\":\n return \"Forbidden operation\";\n case \"OneOf\":\n {\n const input = formatInput(issue);\n return input === undefined ? \"Expected exactly one member to match\" : `Expected exactly one member to match the input ${input}`;\n }\n }\n};\n/**\n * Returns the built-in {@link CheckHook} used by default formatters.\n *\n * **When to use**\n *\n * Use as the default filter renderer when customizing only the {@link LeafHook}.\n *\n * **Details**\n *\n * - Looks for a `message` annotation on the inner issue first, then on the\n * filter itself.\n * - Returns `undefined` when no annotation is found, causing the formatter to\n * fall back to `\"Expected \"` or, when the filter reports input,\n * `\"Expected , got \"`.\n *\n * @see {@link CheckHook}\n * @see {@link makeFormatterStandardSchemaV1}\n *\n * @category formatting\n * @since 4.0.0\n */\nexport const defaultCheckHook = issue => findMessage(issue.issue) ?? findMessage(issue);\n/**\n * Creates a {@link Formatter} that produces a `StandardSchemaV1.FailureResult`.\n *\n * **When to use**\n *\n * Use when you need schema parse errors in\n * [Standard Schema V1](https://github.com/standard-schema/standard-schema)\n * format, optionally customizing leaf or check issue rendering.\n *\n * **Details**\n *\n * - Returns a `Formatter`.\n * - Each leaf issue is flattened into `{ message, path }` entries.\n * - `Pointer` paths are accumulated to produce full property paths.\n * - Falls back to {@link defaultLeafHook} / {@link defaultCheckHook} when no\n * hooks are provided.\n * - Default messages include reported input when the issue that produces the\n * message has an `input` field. The returned Standard Schema issues do not\n * receive an `input` field.\n *\n * **Gotchas**\n *\n * Reported input can appear inside the Standard Schema `message` string even\n * though it is not exposed as a separate property. Custom hooks control their\n * complete message and are not modified.\n *\n * **Example** (Creating a Standard Schema V1 formatter)\n *\n * ```ts import.meta.vitest\n * import { SchemaIssue } from \"effect\"\n *\n * const formatter = SchemaIssue.makeFormatterStandardSchemaV1()\n * formatter(new SchemaIssue.MissingKey(undefined)).issues[0].message // => \"Missing key\"\n * ```\n *\n * @see {@link makeFormatterDefault} — produces a plain string instead\n * @see {@link LeafHook}\n * @see {@link CheckHook}\n *\n * @category formatting\n * @since 4.0.0\n */\nexport function makeFormatterStandardSchemaV1(options) {\n return issue => ({\n issues: toDefaultIssues(issue, [], options?.leafHook ?? defaultLeafHook, options?.checkHook ?? defaultCheckHook)\n });\n}\nfunction formatInput(issue) {\n return hasInput(issue) ? format(issue.input) : undefined;\n}\nfunction findExpected(issue) {\n const expected = issue.annotations?.expected;\n return typeof expected === \"string\" ? expected : undefined;\n}\nfunction getExpectedMessage(expected, issue) {\n const input = formatInput(issue);\n return input === undefined ? `Expected ${expected}` : `Expected ${expected}, got ${input}`;\n}\nfunction toDefaultIssues(issue, path, leafHook, checkHook) {\n switch (issue._tag) {\n case \"Filter\":\n {\n const message = checkHook(issue);\n if (message !== undefined) {\n return [{\n path,\n message\n }];\n }\n if (issue.issue._tag !== \"InvalidValue\") {\n return toDefaultIssues(issue.issue, path, leafHook, checkHook);\n }\n const expected = findExpected(issue.issue);\n return [{\n path,\n message: expected === undefined ? getExpectedMessage(formatCheck(issue.filter), issue) : getExpectedMessage(expected, issue.issue)\n }];\n }\n case \"Encoding\":\n return toDefaultIssues(issue.issue, path, leafHook, checkHook);\n case \"Pointer\":\n return toDefaultIssues(issue.issue, [...path, ...issue.path], leafHook, checkHook);\n case \"Composite\":\n return issue.issues.flatMap(issue => toDefaultIssues(issue, path, leafHook, checkHook));\n case \"AnyOf\":\n {\n if (issue.issues.length === 0) {\n return [{\n path,\n message: findMessage(issue) ?? getExpectedMessage(InternalAnnotations.getExpected(issue.ast), issue)\n }];\n }\n return issue.issues.flatMap(issue => toDefaultIssues(issue, path, leafHook, checkHook));\n }\n default:\n return [{\n path,\n message: leafHook(issue)\n }];\n }\n}\nfunction formatCheck(check) {\n const expected = check.annotations?.expected;\n if (typeof expected === \"string\") return expected;\n switch (check._tag) {\n case \"Filter\":\n return \"\";\n case \"FilterGroup\":\n return check.checks.map(check => formatCheck(check)).join(\" & \");\n }\n}\n/**\n * Creates a {@link Formatter} that converts an {@link Issue} into a\n * human-readable multi-line string.\n *\n * **When to use**\n *\n * Use when you need to format a `SchemaIssue.Issue` as error messages for\n * logging, CLI output, or developer-facing diagnostics.\n *\n * **Details**\n *\n * - Flattens the issue tree into `{ message, path }` entries using\n * {@link defaultLeafHook} and {@link defaultCheckHook}.\n * - Includes reported input in default messages when the node producing the\n * message has an `input` field.\n * - Each entry is rendered as `\"\"` or `\"\\n at \"`.\n * - Multiple entries are joined with newlines.\n *\n * **Gotchas**\n *\n * Formatting an issue can disclose input retained with `reportInput: true`.\n * Wrapper inputs are not inherited by child messages, and custom messages are\n * returned unchanged.\n *\n * **Example** (Formatting an issue as a string)\n *\n * ```ts import.meta.vitest\n * import { SchemaIssue } from \"effect\"\n *\n * const formatter = SchemaIssue.makeFormatterDefault()\n * formatter(new SchemaIssue.MissingKey(undefined)) // => \"Missing key\"\n * ```\n *\n * @see {@link makeFormatterStandardSchemaV1} — produces Standard Schema V1 format instead\n * @see {@link Formatter}\n *\n * @category formatting\n * @since 4.0.0\n */\nexport function makeFormatterDefault() {\n return issue => formatIssue(issue, \"\");\n}\n/** @internal */\nexport const defaultFormatter = /*#__PURE__*/makeFormatterDefault();\nfunction formatIssue(issue, path) {\n let message;\n switch (issue._tag) {\n case \"Filter\":\n {\n const annotated = defaultCheckHook(issue);\n if (annotated !== undefined) {\n message = annotated;\n } else {\n if (issue.issue._tag !== \"InvalidValue\") {\n return formatIssue(issue.issue, path);\n }\n const expected = findExpected(issue.issue);\n message = expected === undefined ? getExpectedMessage(formatCheck(issue.filter), issue) : getExpectedMessage(expected, issue.issue);\n }\n break;\n }\n case \"Encoding\":\n return formatIssue(issue.issue, path);\n case \"Pointer\":\n return formatIssue(issue.issue, path + formatPath(issue.path));\n case \"Composite\":\n case \"AnyOf\":\n {\n if (issue._tag === \"Composite\" || issue.issues.length > 0) {\n return issue.issues.map(issue => formatIssue(issue, path)).join(\"\\n\");\n }\n message = findMessage(issue) ?? getExpectedMessage(InternalAnnotations.getExpected(issue.ast), issue);\n break;\n }\n default:\n message = defaultLeafHook(issue);\n break;\n }\n return path ? `${message}\\n at ${path}` : message;\n}\nfunction findMessage(issue) {\n if (issue._tag === \"Pointer\") return;\n if (issue._tag === \"Encoding\") return findMessage(issue.issue);\n const annotations = issue._tag === \"Filter\" ? issue.filter.annotations : \"annotations\" in issue ? issue.annotations : issue.ast.annotations;\n const message = annotations?.[issue._tag === \"MissingKey\" ? \"messageMissingKey\" : issue._tag === \"UnexpectedKey\" ? \"messageUnexpectedKey\" : \"message\"];\n if (typeof message === \"string\") return message;\n}\n//# sourceMappingURL=SchemaIssue.js.map","import * as Cause from \"../../Cause.js\";\nimport * as SchemaIssue from \"../../SchemaIssue.js\";\n/** @internal */\nexport function getSchemaIssue(cause) {\n let issue;\n for (const reason of cause.reasons) {\n if (!Cause.isFailReason(reason) || !SchemaIssue.isIssue(reason.error)) {\n return undefined;\n }\n issue ??= reason.error;\n }\n return issue;\n}\n/** @internal */\nexport function getSchemaIssueOrThrow(cause, message) {\n const issue = getSchemaIssue(cause);\n if (issue === undefined) {\n throw new Error(message, {\n cause\n });\n }\n return issue;\n}\n//# sourceMappingURL=cause.js.map","import * as Context from \"./Context.js\";\nimport * as Effect from \"./Effect.js\";\nimport { dual, flow } from \"./Function.js\";\nimport * as Internal from \"./internal/dateTime.js\";\nimport { provideService } from \"./internal/effect.js\";\nimport * as Layer from \"./Layer.js\";\nconst TypeId = Internal.TypeId;\nconst TimeZoneTypeId = Internal.TimeZoneTypeId;\n// =============================================================================\n// guards\n// =============================================================================\n/**\n * Checks whether a value is a `DateTime`.\n *\n * **When to use**\n *\n * Use to narrow an unknown value before treating it as a `DateTime`.\n *\n * @see {@link isUtc} for narrowing a known `DateTime` to UTC\n * @see {@link isZoned} for narrowing a known `DateTime` to zoned\n *\n * @category guards\n * @since 3.6.0\n */\nexport const isDateTime = Internal.isDateTime;\n/**\n * Checks whether a value is a `TimeZone`.\n *\n * **When to use**\n *\n * Use to narrow unknown input to any `TimeZone` before passing it to APIs that\n * accept either fixed-offset or named time zones.\n *\n * @see {@link isTimeZoneOffset} for narrowing to fixed-offset time zones\n * @see {@link isTimeZoneNamed} for narrowing to named time zones\n *\n * @category guards\n * @since 3.6.0\n */\nexport const isTimeZone = Internal.isTimeZone;\n/**\n * Checks whether a value is an offset-based `TimeZone`.\n *\n * **When to use**\n *\n * Use when you need to narrow an unknown or union `TimeZone` value to the\n * fixed-offset variant before reading its offset in milliseconds.\n *\n * @see {@link isTimeZone} for checking either time zone variant\n * @see {@link isTimeZoneNamed} for narrowing to named time zones\n *\n * @category guards\n * @since 3.6.0\n */\nexport const isTimeZoneOffset = Internal.isTimeZoneOffset;\n/**\n * Checks whether a value is a named `TimeZone` (IANA time zone).\n *\n * **When to use**\n *\n * Use to narrow an unknown value to the `TimeZone.Named` variant before\n * reading named-zone fields such as `id`.\n *\n * @see {@link isTimeZone} for checking either time zone variant\n * @see {@link isTimeZoneOffset} for narrowing to fixed-offset time zones\n *\n * @category guards\n * @since 3.6.0\n */\nexport const isTimeZoneNamed = Internal.isTimeZoneNamed;\n/**\n * Checks whether a `DateTime` is a UTC `DateTime` (no time zone information).\n *\n * **When to use**\n *\n * Use to narrow a `DateTime` before passing it to code that requires a UTC\n * value without an associated time zone.\n *\n * @see {@link isZoned} for narrowing to zoned date-times\n * @see {@link match} for handling both UTC and zoned cases\n *\n * @category guards\n * @since 3.6.0\n */\nexport const isUtc = Internal.isUtc;\n/**\n * Checks whether a `DateTime` is a zoned `DateTime` (has time zone information).\n *\n * **When to use**\n *\n * Use to narrow a known `DateTime` before reading its zone or passing it to\n * APIs that require `DateTime.Zoned`.\n *\n * @see {@link isUtc} for narrowing to UTC date-times\n * @see {@link match} for handling both UTC and zoned cases\n *\n * @category guards\n * @since 3.6.0\n */\nexport const isZoned = Internal.isZoned;\n// =============================================================================\n// instances\n// =============================================================================\n/**\n * Provides an `Equivalence` for comparing two `DateTime` values for equality.\n *\n * **Details**\n *\n * Two `DateTime` values are considered equivalent if they represent the same\n * point in time, regardless of their time zone.\n *\n * **Example** (Comparing DateTime values for equivalence)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const utc = DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\")\n * const zoned = DateTime.makeZonedUnsafe(\"2024-01-01T12:00:00Z\", {\n * timeZone: \"Europe/London\"\n * })\n *\n * DateTime.Equivalence(utc, zoned) // => true\n * ```\n *\n * @category instances\n * @since 3.6.0\n */\nexport const Equivalence = Internal.Equivalence;\n/**\n * Provides an `Order` for comparing and sorting `DateTime` values.\n *\n * **Details**\n *\n * `DateTime` values are ordered by their epoch milliseconds, so earlier times\n * come before later times regardless of time zone.\n *\n * **Example** (Sorting DateTime values chronologically)\n *\n * ```ts import.meta.vitest\n * import { Array, DateTime } from \"effect\"\n *\n * const dates = [\n * DateTime.makeUnsafe(\"2024-03-01\"),\n * DateTime.makeUnsafe(\"2024-01-01\"),\n * DateTime.makeUnsafe(\"2024-02-01\")\n * ]\n *\n * Array.sort(dates, DateTime.Order).map(DateTime.formatIsoDateUtc) // => [\"2024-01-01\", \"2024-02-01\", \"2024-03-01\"]\n * ```\n *\n * @category instances\n * @since 3.6.0\n */\nexport const Order = Internal.Order;\n/**\n * Returns a `DateTime` constrained between a minimum and maximum value.\n *\n * **Details**\n *\n * If the `DateTime` is before the minimum, the minimum is returned.\n * If the `DateTime` is after the maximum, the maximum is returned.\n * Otherwise, the original `DateTime` is returned.\n *\n * **Example** (Clamping DateTime values)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const min = DateTime.makeUnsafe(\"2024-01-01\")\n * const max = DateTime.makeUnsafe(\"2024-12-31\")\n * const date = DateTime.makeUnsafe(\"2025-06-15\")\n *\n * DateTime.clamp(date, { minimum: min, maximum: max }) // => DateTime.makeUnsafe(\"2024-12-31\")\n * ```\n *\n * @category ordering\n * @since 3.6.0\n */\nexport const clamp = Internal.clamp;\n// =============================================================================\n// constructors\n// =============================================================================\n/**\n * Create a `DateTime` from a `Date`.\n *\n * **Details**\n *\n * If the `Date` is invalid, an `IllegalArgumentError` will be thrown.\n *\n * **Example** (Creating DateTime values from Dates)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * DateTime.fromDateUnsafe(new Date(\"2024-01-01T12:00:00Z\")) // => DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\")\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromDateUnsafe = Internal.fromDateUnsafe;\n/**\n * Create a `DateTime` from supported input values.\n *\n * **When to use**\n *\n * Use when creating a `DateTime` from trusted input and construction failures\n * should throw an `IllegalArgumentError` instead of returning `Option.none`.\n *\n * **Details**\n *\n * - A `DateTime`\n * - A `Date` instance (invalid dates will throw an `IllegalArgumentError`)\n * - The `number` of milliseconds since the Unix epoch\n * - An object with the parts of a date\n * - A `string` that can be parsed by `Date.parse`\n *\n * **Example** (Creating DateTime values unsafely)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // from Date\n * DateTime.makeUnsafe(new Date(\"2024-01-01T12:00:00Z\")) // => DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\")\n *\n * // from parts\n * DateTime.makeUnsafe({ year: 2024 }) // => DateTime.makeUnsafe(\"2024-01-01T00:00:00Z\")\n *\n * // from string\n * DateTime.makeUnsafe(\"2024-01-01\") // => DateTime.makeUnsafe(\"2024-01-01T00:00:00Z\")\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeUnsafe = Internal.makeUnsafe;\n/**\n * Creates a `DateTime.Utc` from the number of seconds since the Unix epoch.\n *\n * **Example** (Creating from epoch seconds)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * DateTime.fromEpochSeconds(1704067200).toJSON() // => \"2024-01-01T00:00:00.000Z\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromEpochSeconds = Internal.fromEpochSeconds;\n/**\n * Create a `DateTime.Zoned` using `DateTime.makeUnsafe` and a time zone.\n *\n * **When to use**\n *\n * Use when the date/time input and zone options are trusted and invalid or\n * rejected ambiguous times should throw instead of returning `Option.none`.\n *\n * **Details**\n *\n * The input is treated as UTC and then the time zone is attached, unless\n * `adjustForTimeZone` is set to `true`. In that case, the input is treated as\n * already in the time zone.\n *\n * When `adjustForTimeZone` is true and ambiguous times occur during DST transitions,\n * the `disambiguation` option controls how to resolve the ambiguity:\n * - `compatible` (default): Choose earlier time for repeated times, later for gaps\n * - `earlier`: Always choose the earlier of two possible times\n * - `later`: Always choose the later of two possible times\n * - `reject`: Throw an error when ambiguous times are encountered\n *\n * **Example** (Creating zoned DateTime values unsafely)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const zoned = DateTime.makeZonedUnsafe(\"2024-06-15T14:30:00Z\", {\n * timeZone: \"Europe/London\"\n * })\n *\n * DateTime.formatIsoZoned(zoned) // => \"2024-06-15T15:30:00.000+01:00[Europe/London]\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeZonedUnsafe = Internal.makeZonedUnsafe;\n/**\n * Creates a `DateTime.Zoned` safely from an input and a time zone.\n *\n * **Details**\n *\n * By default, the input is interpreted as a UTC instant and the time zone is\n * attached without changing that instant. When `adjustForTimeZone` is `true`,\n * the input is interpreted as wall-clock time in the target zone.\n *\n * When `adjustForTimeZone` is `true`, `disambiguation` controls\n * daylight-saving gaps and repeated times:\n *\n * - `\"compatible\"` (default): chooses the earlier occurrence for repeated\n * times and the later interpretation for gaps\n * - `\"earlier\"`: chooses the earlier possible instant\n * - `\"later\"`: chooses the later possible instant\n * - `\"reject\"`: rejects ambiguous or nonexistent wall-clock times\n *\n * Returns `Some` when construction succeeds, or `None` when the input, time\n * zone, or disambiguation cannot be resolved.\n *\n * **Example** (Creating optional zoned DateTime values)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Option } from \"effect\"\n *\n * const result = DateTime.makeZoned(\"2024-06-15T14:30:00Z\", {\n * timeZone: \"Europe/London\"\n * })\n *\n * result.pipe(Option.map(DateTime.formatIsoZoned)) // => Option.some(\"2024-06-15T15:30:00.000+01:00[Europe/London]\")\n * ```\n *\n * @category constructors\n * @since 3.6.0\n */\nexport const makeZoned = Internal.makeZoned;\n/**\n * Creates a `DateTime` safely from supported input values.\n *\n * **Details**\n *\n * - A `DateTime`\n * - A JavaScript `Date`\n * - The number of milliseconds since the Unix epoch\n * - An object with date and time parts\n * - A string that can be parsed as a date\n *\n * Returns `Some` with the constructed `DateTime` when the input is valid, or\n * `None` when construction would fail, including invalid `Date` instances or\n * unparseable strings.\n *\n * **Example** (Creating optional DateTime values)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Option } from \"effect\"\n *\n * // from Date\n * DateTime.make(new Date(\"2024-01-01T12:00:00Z\")) // => Option.some(DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\"))\n *\n * // from parts\n * DateTime.make({ year: 2024 }) // => Option.some(DateTime.makeUnsafe(\"2024-01-01T00:00:00Z\"))\n *\n * // from string\n * DateTime.make(\"2024-01-01\") // => Option.some(DateTime.makeUnsafe(\"2024-01-01T00:00:00Z\"))\n *\n * DateTime.make(\"not a date\") // => Option.none()\n * ```\n *\n * @category constructors\n * @since 3.6.0\n */\nexport const make = Internal.make;\n/**\n * Parses an ISO zoned date-time string into a `DateTime.Zoned` safely.\n *\n * **Details**\n *\n * Accepts named-zone strings such as\n * `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]` and offset-only strings such as\n * `YYYY-MM-DDTHH:mm:ss.sss+HH:MM`. Returns `None` when the input cannot be\n * parsed.\n *\n * **Example** (Parsing zoned DateTime strings)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Option } from \"effect\"\n *\n * DateTime.makeZonedFromString(\n * \"2024-01-01T12:00:00+02:00[Europe/Berlin]\"\n * ).pipe(Option.map(DateTime.formatIsoZoned)) // => Option.some(\"2024-01-01T11:00:00.000+01:00[Europe/Berlin]\")\n *\n * DateTime.makeZonedFromString(\"2024-01-01T12:00:00Z\") // => Option.none()\n * DateTime.makeZonedFromString(\"invalid\") // => Option.none()\n * ```\n *\n * @category constructors\n * @since 3.6.0\n */\nexport const makeZonedFromString = Internal.makeZonedFromString;\n/**\n * Gets the current time using the `Clock` service and converts it to a `DateTime`.\n *\n * **Example** (Getting the current DateTime)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n * import { TestClock } from \"effect/testing\"\n *\n * await Effect.runPromise(Effect.map(DateTime.now, DateTime.isDateTime)) // => true\n * ```\n *\n * @category constructors\n * @since 3.6.0\n */\nexport const now = Internal.now;\n/**\n * Gets the current time from the `Clock` service and returns it as a\n * JavaScript `Date`.\n *\n * **Example** (Getting the current Date)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n * import { TestClock } from \"effect/testing\"\n *\n * await Effect.runPromise(Effect.map(DateTime.nowAsDate, (now) => now instanceof Date)) // => true\n * ```\n *\n * @category constructors\n * @since 3.14.0\n */\nexport const nowAsDate = Internal.nowAsDate;\n/**\n * Gets the current time using `Date.now`.\n *\n * **When to use**\n *\n * Use when synchronous wall-clock access outside an Effect program is\n * acceptable and testability through the `Clock` service is not needed.\n *\n * **Details**\n *\n * This is a synchronous version of `now` that directly uses `Date.now()`\n * instead of the Effect `Clock` service.\n *\n * **Example** (Getting the current DateTime unsafely)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * Number.isFinite(DateTime.toEpochMillis(DateTime.nowUnsafe())) // => true\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const nowUnsafe = Internal.nowUnsafe;\n// =============================================================================\n// time zones\n// =============================================================================\n/**\n * Converts a `DateTime` to a UTC `DateTime`.\n *\n * **When to use**\n *\n * Use to represent the same instant in UTC instead of its current time zone.\n *\n * **Details**\n *\n * The returned value keeps the same epoch milliseconds and changes only the\n * `DateTime` representation to UTC.\n *\n * **Example** (Converting DateTime values to UTC)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const now = DateTime.makeZonedUnsafe({ year: 2024 }, {\n * timeZone: \"Europe/London\"\n * })\n *\n * // set as UTC\n * const utc: DateTime.Utc = DateTime.toUtc(now)\n * utc // => DateTime.makeUnsafe(\"2024-01-01T00:00:00Z\")\n * ```\n *\n * @category converting\n * @since 3.13.0\n */\nexport const toUtc = Internal.toUtc;\n/**\n * Sets the time zone of a `DateTime`, returning a new `DateTime.Zoned`.\n *\n * **Example** (Setting time zones)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const zone = DateTime.zoneMakeNamedUnsafe(\"Europe/London\")\n * const zoned: DateTime.Zoned = DateTime.setZone(DateTime.makeUnsafe(\"2024-01-01\"), zone)\n *\n * DateTime.isZoned(zoned) // => true\n * ```\n *\n * @category transforming\n * @since 3.6.0\n */\nexport const setZone = Internal.setZone;\n/**\n * Adds a fixed offset time zone to a `DateTime`.\n *\n * **Details**\n *\n * The offset is in milliseconds.\n *\n * **Example** (Setting fixed-offset time zones)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dateTime = DateTime.makeUnsafe(\"2024-01-01\")\n * const zoned: DateTime.Zoned = DateTime.setZoneOffset(dateTime, 3 * 60 * 60 * 1000)\n *\n * DateTime.zoneToString(zoned.zone) // => \"+03:00\"\n * ```\n *\n * @category transforming\n * @since 3.6.0\n */\nexport const setZoneOffset = Internal.setZoneOffset;\n/**\n * Attempts to create a named time zone from an IANA time zone identifier.\n *\n * **When to use**\n *\n * Use when the IANA zone id is trusted and invalid zones should throw instead\n * of returning `Option.none` or failing in `Effect`.\n *\n * **Details**\n *\n * If the time zone is invalid, an `IllegalArgumentError` will be thrown.\n *\n * **Example** (Creating named time zones unsafely)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * DateTime.zoneToString(DateTime.zoneMakeNamedUnsafe(\"Europe/London\")) // => \"Europe/London\"\n * DateTime.zoneToString(DateTime.zoneMakeNamedUnsafe(\"Asia/Tokyo\")) // => \"Asia/Tokyo\"\n *\n * // This would throw an IllegalArgumentError:\n * // DateTime.zoneMakeNamedUnsafe(\"Invalid/Zone\")\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const zoneMakeNamedUnsafe = Internal.zoneMakeNamedUnsafe;\n/**\n * Create a fixed offset time zone.\n *\n * **Details**\n *\n * The offset is specified in milliseconds from UTC. Positive values are\n * ahead of UTC, negative values are behind UTC.\n *\n * **Example** (Creating fixed-offset time zones)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // Create a time zone with +3 hours offset\n * const zone = DateTime.zoneMakeOffset(3 * 60 * 60 * 1000)\n *\n * const dt = DateTime.makeZonedUnsafe(\"2024-01-01T12:00:00Z\", {\n * timeZone: zone\n * })\n * DateTime.formatIsoZoned(dt) // => \"2024-01-01T15:00:00.000+03:00\"\n * ```\n *\n * @category constructors\n * @since 3.6.0\n */\nexport const zoneMakeOffset = Internal.zoneMakeOffset;\n/**\n * Creates a named time zone safely from an IANA time zone identifier.\n *\n * **Details**\n *\n * If the time zone is invalid, `None` will be returned.\n *\n * **Example** (Creating optional named time zones)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Option } from \"effect\"\n *\n * DateTime.zoneMakeNamed(\"Europe/London\").pipe(Option.map(DateTime.zoneToString)) // => Option.some(\"Europe/London\")\n * DateTime.zoneMakeNamed(\"Invalid/Zone\") // => Option.none()\n * ```\n *\n * @category constructors\n * @since 3.6.0\n */\nexport const zoneMakeNamed = Internal.zoneMakeNamed;\n/**\n * Creates a named time zone effectfully from an IANA time zone identifier.\n *\n * **When to use**\n *\n * Use when invalid IANA zone ids should fail in the Effect error channel\n * instead of returning `Option.none` or throwing.\n *\n * **Example** (Creating named time zones effectfully)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const zone = yield* DateTime.zoneMakeNamedEffect(\"Europe/London\")\n * const now = yield* DateTime.now\n * return DateTime.setZone(now, zone)\n * })\n *\n * DateTime.zoneToString((await Effect.runPromise(program)).zone) // => \"Europe/London\"\n * ```\n *\n * @category constructors\n * @since 3.6.0\n */\nexport const zoneMakeNamedEffect = Internal.zoneMakeNamedEffect;\n/**\n * Create a named time zone from the system's local time zone.\n *\n * **Details**\n *\n * This uses the system's configured time zone, which may vary depending\n * on the runtime environment.\n *\n * **Example** (Creating local time zones)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * DateTime.isTimeZoneNamed(DateTime.zoneMakeLocal()) // => true\n * ```\n *\n * @category constructors\n * @since 3.6.0\n */\nexport const zoneMakeLocal = Internal.zoneMakeLocal;\n/**\n * Tries to parse a `TimeZone` from a string safely.\n *\n * **Details**\n *\n * Supports both IANA time zone identifiers and offset formats like \"+03:00\".\n *\n * **Example** (Parsing time zones)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Option } from \"effect\"\n *\n * DateTime.zoneFromString(\"Europe/London\").pipe(Option.map(DateTime.zoneToString)) // => Option.some(\"Europe/London\")\n * DateTime.zoneFromString(\"+03:00\").pipe(Option.map(DateTime.zoneToString)) // => Option.some(\"+03:00\")\n * DateTime.zoneFromString(\"invalid\") // => Option.none()\n * ```\n *\n * @category decoding\n * @since 3.6.0\n */\nexport const zoneFromString = Internal.zoneFromString;\n/**\n * Formats a `TimeZone` as a string.\n *\n * **Example** (Formatting time zones)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * DateTime.zoneToString(DateTime.zoneMakeOffset(3 * 60 * 60 * 1000)) // => \"+03:00\"\n * DateTime.zoneToString(DateTime.zoneMakeNamedUnsafe(\"Europe/London\")) // => \"Europe/London\"\n * ```\n *\n * @category encoding\n * @since 3.6.0\n */\nexport const zoneToString = Internal.zoneToString;\n/**\n * Sets the time zone of a `DateTime` safely from an IANA time zone identifier. If the\n * time zone is invalid, `None` will be returned.\n *\n * **Example** (Setting named time zones safely)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Option } from \"effect\"\n *\n * const dateTime = DateTime.makeUnsafe(\"2024-01-01\")\n * const result = DateTime.setZoneNamed(dateTime, \"Europe/London\").pipe(Option.map(DateTime.formatIsoZoned))\n *\n * result // => Option.some(\"2024-01-01T00:00:00.000+00:00[Europe/London]\")\n * ```\n *\n * @category transforming\n * @since 3.6.0\n */\nexport const setZoneNamed = Internal.setZoneNamed;\n/**\n * Sets the time zone of a `DateTime` from an IANA time zone identifier. If the\n * time zone is invalid, an `IllegalArgumentError` will be thrown.\n *\n * **Example** (Setting named time zones unsafely)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dateTime = DateTime.makeUnsafe(\"2024-01-01\")\n * const zoned = DateTime.setZoneNamedUnsafe(dateTime, \"Europe/London\")\n *\n * DateTime.zoneToString(zoned.zone) // => \"Europe/London\"\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const setZoneNamedUnsafe = Internal.setZoneNamedUnsafe;\n// =============================================================================\n// comparisons\n// =============================================================================\n/**\n * Computes the difference between two `DateTime` values, returning a\n * `Duration` representing the amount of time between them.\n *\n * **Details**\n *\n * If `other` is *after* `self`, the result will be a positive `Duration`. If\n * `other` is *before* `self`, the result will be a negative `Duration`. If they\n * are equal, the result will be a `Duration` of zero.\n *\n * **Example** (Measuring distance between DateTime values)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Duration } from \"effect\"\n *\n * const start = DateTime.makeUnsafe(\"2024-01-01T00:00:00Z\")\n * const end = DateTime.add(start, { minutes: 1 })\n *\n * DateTime.distance(start, end) // => Duration.minutes(1)\n * ```\n *\n * @category comparisons\n * @since 3.6.0\n */\nexport const distance = Internal.distance;\n/**\n * Returns the earlier of two `DateTime` values.\n *\n * **Example** (Selecting the earlier DateTime)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const date1 = DateTime.makeUnsafe(\"2024-01-01\")\n * const date2 = DateTime.makeUnsafe(\"2024-02-01\")\n *\n * DateTime.min(date1, date2) // => DateTime.makeUnsafe(\"2024-01-01\")\n * ```\n *\n * @category comparisons\n * @since 3.6.0\n */\nexport const min = Internal.min;\n/**\n * Returns the later of two `DateTime` values.\n *\n * **Example** (Selecting the later DateTime)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const date1 = DateTime.makeUnsafe(\"2024-01-01\")\n * const date2 = DateTime.makeUnsafe(\"2024-02-01\")\n *\n * DateTime.max(date1, date2) // => DateTime.makeUnsafe(\"2024-02-01\")\n * ```\n *\n * @category comparisons\n * @since 3.6.0\n */\nexport const max = Internal.max;\n/**\n * Checks whether the first `DateTime` is after the second `DateTime`.\n *\n * **Example** (Checking whether a DateTime is later)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const date1 = DateTime.makeUnsafe(\"2024-02-01\")\n * const date2 = DateTime.makeUnsafe(\"2024-01-01\")\n *\n * DateTime.isGreaterThan(date1, date2) // => true\n * DateTime.isGreaterThan(date2, date1) // => false\n * ```\n *\n * @category comparisons\n * @since 4.0.0\n */\nexport const isGreaterThan = Internal.isGreaterThan;\n/**\n * Checks whether the first `DateTime` is after or equal to the second `DateTime`.\n *\n * **Example** (Checking whether a DateTime is later or equal)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const date1 = DateTime.makeUnsafe(\"2024-01-01\")\n * const date2 = DateTime.makeUnsafe(\"2024-01-01\")\n * const date3 = DateTime.makeUnsafe(\"2024-02-01\")\n *\n * DateTime.isGreaterThanOrEqualTo(date1, date2) // => true\n * DateTime.isGreaterThanOrEqualTo(date3, date1) // => true\n * DateTime.isGreaterThanOrEqualTo(date1, date3) // => false\n * ```\n *\n * @category comparisons\n * @since 4.0.0\n */\nexport const isGreaterThanOrEqualTo = Internal.isGreaterThanOrEqualTo;\n/**\n * Checks whether the first `DateTime` is before the second `DateTime`.\n *\n * **Example** (Checking whether a DateTime is earlier)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const date1 = DateTime.makeUnsafe(\"2024-01-01\")\n * const date2 = DateTime.makeUnsafe(\"2024-02-01\")\n *\n * DateTime.isLessThan(date1, date2) // => true\n * DateTime.isLessThan(date2, date1) // => false\n * ```\n *\n * @category comparisons\n * @since 4.0.0\n */\nexport const isLessThan = Internal.isLessThan;\n/**\n * Checks whether the first `DateTime` is before or equal to the second `DateTime`.\n *\n * **Example** (Checking whether a DateTime is earlier or equal)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const date1 = DateTime.makeUnsafe(\"2024-01-01\")\n * const date2 = DateTime.makeUnsafe(\"2024-01-01\")\n * const date3 = DateTime.makeUnsafe(\"2024-02-01\")\n *\n * DateTime.isLessThanOrEqualTo(date1, date2) // => true\n * DateTime.isLessThanOrEqualTo(date1, date3) // => true\n * DateTime.isLessThanOrEqualTo(date3, date1) // => false\n * ```\n *\n * @category comparisons\n * @since 4.0.0\n */\nexport const isLessThanOrEqualTo = Internal.isLessThanOrEqualTo;\n/**\n * Checks whether a `DateTime` is between two other `DateTime` values (inclusive).\n *\n * **Example** (Checking whether a DateTime is within bounds)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const min = DateTime.makeUnsafe(\"2024-01-01\")\n * const max = DateTime.makeUnsafe(\"2024-12-31\")\n * const date = DateTime.makeUnsafe(\"2024-06-15\")\n *\n * DateTime.between(date, { minimum: min, maximum: max }) // => true\n * ```\n *\n * @category comparisons\n * @since 3.6.0\n */\nexport const between = Internal.between;\n/**\n * Checks effectfully if a `DateTime` is in the future compared to the current time.\n *\n * **Details**\n *\n * This is an effectful operation that uses the current time from the `Clock` service.\n *\n * **Example** (Checking future DateTime values effectfully)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n * import { TestClock } from \"effect/testing\"\n *\n * const futureDate = DateTime.makeUnsafe(1)\n * await Effect.runPromise(Effect.provide(DateTime.isFuture(futureDate), TestClock.layer())) // => true\n * ```\n *\n * @category comparisons\n * @since 3.6.0\n */\nexport const isFuture = Internal.isFuture;\n/**\n * Checks synchronously if a `DateTime` is in the future compared to the current time.\n *\n * **When to use**\n *\n * Use when checking whether a `DateTime` is in the future with a synchronous\n * live-clock read and `Clock`-based testability is not needed.\n *\n * **Details**\n *\n * This is a synchronous version that uses `Date.now()` directly.\n *\n * **Example** (Checking future DateTime values unsafely)\n *\n * ```ts\n * import { DateTime } from \"effect\"\n *\n * const oneHourFromNow = DateTime.add(DateTime.nowUnsafe(), { hours: 1 })\n * DateTime.isFutureUnsafe(oneHourFromNow)\n * ```\n *\n * @category comparisons\n * @since 4.0.0\n */\nexport const isFutureUnsafe = Internal.isFutureUnsafe;\n/**\n * Checks effectfully if a `DateTime` is in the past compared to the current time.\n *\n * **Details**\n *\n * This is an effectful operation that uses the current time from the `Clock` service.\n *\n * **Example** (Checking past DateTime values effectfully)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n * import { TestClock } from \"effect/testing\"\n *\n * const pastDate = DateTime.makeUnsafe(-1)\n * await Effect.runPromise(Effect.provide(DateTime.isPast(pastDate), TestClock.layer())) // => true\n * ```\n *\n * @category comparisons\n * @since 3.6.0\n */\nexport const isPast = Internal.isPast;\n/**\n * Checks synchronously if a `DateTime` is in the past compared to the current time.\n *\n * **When to use**\n *\n * Use when checking whether a `DateTime` is in the past with a synchronous\n * live-clock read and `Clock`-based testability is not needed.\n *\n * **Details**\n *\n * This is a synchronous version that uses `Date.now()` directly.\n *\n * **Example** (Checking past DateTime values unsafely)\n *\n * ```ts\n * import { DateTime } from \"effect\"\n *\n * const oneHourAgo = DateTime.subtract(DateTime.nowUnsafe(), { hours: 1 })\n * DateTime.isPastUnsafe(oneHourAgo)\n * ```\n *\n * @category comparisons\n * @since 4.0.0\n */\nexport const isPastUnsafe = Internal.isPastUnsafe;\n// =============================================================================\n// conversions\n// =============================================================================\n/**\n * Gets the UTC `Date` of a `DateTime`.\n *\n * **Details**\n *\n * This always returns the UTC representation, ignoring any time zone information.\n *\n * **Example** (Converting DateTime values to UTC Dates)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeZonedUnsafe(\"2024-01-01T12:00:00Z\", {\n * timeZone: \"Europe/London\"\n * })\n *\n * DateTime.toDateUtc(dt).toISOString() // => \"2024-01-01T12:00:00.000Z\"\n * ```\n *\n * @category converting\n * @since 3.6.0\n */\nexport const toDateUtc = Internal.toDateUtc;\n/**\n * Converts a `DateTime` to a `Date`, applying the time zone first.\n *\n * **Details**\n *\n * For `DateTime.Zoned`, this adjusts for the time zone before converting.\n * For `DateTime.Utc`, this is equivalent to `toDateUtc`.\n *\n * **Example** (Converting DateTime values to Dates)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const utc = DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\")\n * const zoned = DateTime.makeZonedUnsafe(\"2024-01-01T12:00:00Z\", {\n * timeZone: \"Europe/London\"\n * })\n *\n * DateTime.toDate(utc).toISOString() // => \"2024-01-01T12:00:00.000Z\"\n * DateTime.toDate(zoned).toISOString() // => \"2024-01-01T12:00:00.000Z\"\n * ```\n *\n * @category converting\n * @since 3.6.0\n */\nexport const toDate = Internal.toDate;\n/**\n * Computes the time zone offset of a `DateTime.Zoned` in milliseconds.\n *\n * **Details**\n *\n * Returns the offset from UTC in milliseconds. Positive values indicate\n * time zones ahead of UTC, negative values indicate time zones behind UTC.\n *\n * **Example** (Reading zoned offsets)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const zoned = DateTime.makeZonedUnsafe(\"2024-01-01T12:00:00Z\", {\n * timeZone: \"Europe/London\"\n * })\n *\n * DateTime.zonedOffset(zoned) // => 0\n * ```\n *\n * @category converting\n * @since 3.6.0\n */\nexport const zonedOffset = Internal.zonedOffset;\n/**\n * Formats the time zone offset of a `DateTime.Zoned` as an ISO string.\n *\n * **Details**\n *\n * The offset is formatted as \"±HH:MM\".\n *\n * **Example** (Formatting zoned offsets)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const zoned = DateTime.makeZonedUnsafe(\"2024-01-01T12:00:00Z\", {\n * timeZone: DateTime.zoneMakeOffset(3 * 60 * 60 * 1000) // +3 hours\n * })\n *\n * DateTime.zonedOffsetIso(zoned) // => \"+03:00\"\n * ```\n *\n * @category converting\n * @since 3.6.0\n */\nexport const zonedOffsetIso = Internal.zonedOffsetIso;\n/**\n * Gets the milliseconds since the Unix epoch of a `DateTime`.\n *\n * **Details**\n *\n * This returns the UTC timestamp regardless of any time zone information.\n *\n * **Example** (Reading epoch milliseconds)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeUnsafe(\"2024-01-01T00:00:00Z\")\n * DateTime.toEpochMillis(dt) // => 1704067200000\n * ```\n *\n * @category converting\n * @since 3.6.0\n */\nexport const toEpochMillis = Internal.toEpochMillis;\n/**\n * Converts a `DateTime` to the number of seconds since the Unix epoch.\n *\n * **Details**\n *\n * This returns the UTC timestamp regardless of any time zone information.\n * The result is floored to the nearest second.\n *\n * **Example** (Reading epoch seconds)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeUnsafe(\"2024-01-01T00:00:00Z\")\n * DateTime.toEpochSeconds(dt) // => 1704067200\n * ```\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toEpochSeconds = Internal.toEpochSeconds;\n/**\n * Removes the time aspect of a `DateTime`, first adjusting for the time\n * zone. It will return a `DateTime.Utc` only containing the date.\n *\n * **Example** (Removing time components)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // returns \"2024-01-01T00:00:00Z\"\n * DateTime.makeZonedUnsafe(\"2024-01-01T05:00:00Z\", {\n * timeZone: \"Pacific/Auckland\",\n * adjustForTimeZone: true\n * }).pipe(\n * DateTime.removeTime,\n * DateTime.formatIso\n * ) // => \"2024-01-01T00:00:00.000Z\"\n * ```\n *\n * @category converting\n * @since 3.6.0\n */\nexport const removeTime = Internal.removeTime;\n// =============================================================================\n// parts\n// =============================================================================\n/**\n * Gets the time-zone-adjusted parts of a `DateTime` as an object.\n *\n * **Details**\n *\n * The parts will be time zone adjusted if the `DateTime` is zoned.\n *\n * **Example** (Reading DateTime parts)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeUnsafe(\"2024-01-01T12:30:45.123Z\")\n * const parts = DateTime.toParts(dt)\n *\n * const selectedParts = [parts.year, parts.month, parts.day, parts.hour] // => [2024, 1, 1, 12]\n * ```\n *\n * @category getters\n * @since 3.6.0\n */\nexport const toParts = Internal.toParts;\n/**\n * Gets the UTC parts of a `DateTime` as an object.\n *\n * **Details**\n *\n * The parts will always be in UTC, ignoring any time zone information.\n *\n * **Example** (Reading UTC DateTime parts)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const zoned = DateTime.makeZonedUnsafe(\"2024-01-01T12:30:45.123Z\", {\n * timeZone: \"Europe/London\"\n * })\n * const parts = DateTime.toPartsUtc(zoned)\n *\n * const selectedParts = [parts.year, parts.month, parts.day, parts.hour] // => [2024, 1, 1, 12]\n * ```\n *\n * @category getters\n * @since 3.6.0\n */\nexport const toPartsUtc = Internal.toPartsUtc;\n/**\n * Gets one UTC part of a `DateTime` as a number.\n *\n * **Details**\n *\n * The part will be in the UTC time zone.\n *\n * **Example** (Reading UTC DateTime parts by key)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dateTime = DateTime.makeUnsafe({ year: 2024 })\n * DateTime.getPartUtc(dateTime, \"year\") // => 2024\n * ```\n *\n * @category getters\n * @since 3.6.0\n */\nexport const getPartUtc = Internal.getPartUtc;\n/**\n * Gets one time-zone-adjusted part of a `DateTime` as a number.\n *\n * **Details**\n *\n * The part will be time zone adjusted.\n *\n * **Example** (Reading DateTime parts by key)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dateTime = DateTime.makeZonedUnsafe({ year: 2024 }, {\n * timeZone: \"Europe/London\"\n * })\n * DateTime.getPart(dateTime, \"year\") // => 2024\n * ```\n *\n * @category getters\n * @since 3.6.0\n */\nexport const getPart = Internal.getPart;\n/**\n * Sets time-zone-adjusted parts on a `DateTime`.\n *\n * **Details**\n *\n * The date will be time zone adjusted for `DateTime.Zoned`.\n *\n * **Example** (Updating DateTime parts)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeZonedUnsafe(\"2024-01-01T12:00:00Z\", { timeZone: \"UTC\" })\n * const updated = DateTime.setParts(dt, {\n * year: 2025,\n * month: 6,\n * day: 15\n * })\n *\n * updated // => DateTime.makeZonedUnsafe(\"2025-06-15T12:00:00Z\", { timeZone: \"UTC\" })\n * ```\n *\n * @category transforming\n * @since 3.6.0\n */\nexport const setParts = Internal.setParts;\n/**\n * Sets UTC parts on a `DateTime`.\n *\n * **Details**\n *\n * The parts are always interpreted as UTC, ignoring any time zone information.\n *\n * **Example** (Updating UTC DateTime parts)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\")\n * const updated = DateTime.setPartsUtc(dt, {\n * year: 2025,\n * hour: 18\n * })\n *\n * updated // => DateTime.makeUnsafe(\"2025-01-01T18:00:00Z\")\n * ```\n *\n * @category transforming\n * @since 3.6.0\n */\nexport const setPartsUtc = Internal.setPartsUtc;\n// =============================================================================\n// current time zone\n// =============================================================================\n/**\n * Context service that supplies the ambient `TimeZone` for APIs that work in\n * the current zone, such as `DateTime.setZoneCurrent` and\n * `DateTime.nowInCurrentZone`.\n *\n * **Details**\n *\n * Provide it with `DateTime.withCurrentZone`, one of the `withCurrentZone*`\n * helpers, or one of the `layerCurrentZone*` layers.\n *\n * **Example** (Accessing the current time zone service)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * return DateTime.zoneToString(yield* DateTime.CurrentTimeZone)\n * })\n *\n * // Provide a time zone\n * const layer = DateTime.layerCurrentZoneNamed(\"Europe/London\")\n * await Effect.runPromise(Effect.provide(program, layer)) // => \"Europe/London\"\n * ```\n *\n * @category services\n * @since 3.11.0\n */\nexport class CurrentTimeZone extends /*#__PURE__*/Context.Service()(\"effect/DateTime/CurrentTimeZone\") {}\n/**\n * Sets the time zone of a `DateTime` to the current time zone, which is\n * determined by the `CurrentTimeZone` service.\n *\n * **Example** (Setting the current time zone)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const zoned = yield* DateTime.setZoneCurrent(DateTime.makeUnsafe(\"2024-01-01\"))\n * return DateTime.zoneToString(zoned.zone)\n * }).pipe(DateTime.withCurrentZoneNamed(\"Europe/London\"))) // => \"Europe/London\"\n * ```\n *\n * @category accessors\n * @since 3.6.0\n */\nexport const setZoneCurrent = self => Effect.map(CurrentTimeZone, zone => setZone(self, zone));\n/**\n * Provides the `CurrentTimeZone` to an effect.\n *\n * **Example** (Providing the current time zone)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * const zone = DateTime.zoneMakeNamedUnsafe(\"Europe/London\")\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const zoned = yield* DateTime.setZoneCurrent(DateTime.makeUnsafe(\"2024-01-01\"))\n * return DateTime.zoneToString(zoned.zone)\n * }).pipe(DateTime.withCurrentZone(zone))) // => \"Europe/London\"\n * ```\n *\n * @category providing services\n * @since 3.6.0\n */\nexport const withCurrentZone = /*#__PURE__*/provideService(CurrentTimeZone);\n/**\n * Provides the `CurrentTimeZone` to an effect, using the system's local time\n * zone.\n *\n * **Example** (Providing the local time zone)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * return DateTime.isZoned(yield* DateTime.nowInCurrentZone)\n * }).pipe(DateTime.withCurrentZoneLocal)) // => true\n * ```\n *\n * @category providing services\n * @since 3.6.0\n */\nexport const withCurrentZoneLocal = effect => Effect.provideServiceEffect(effect, CurrentTimeZone, Effect.sync(zoneMakeLocal));\n/**\n * Provides the `CurrentTimeZone` to an effect, using an offset.\n *\n * **Example** (Providing a fixed-offset time zone)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * return DateTime.zoneToString(yield* DateTime.CurrentTimeZone)\n * }).pipe(DateTime.withCurrentZoneOffset(3 * 60 * 60 * 1000))\n *\n * await Effect.runPromise(program) // => \"+03:00\"\n * ```\n *\n * @category providing services\n * @since 3.6.0\n */\nexport const withCurrentZoneOffset = /*#__PURE__*/dual(2, (effect, offset) => Effect.provideService(effect, CurrentTimeZone, zoneMakeOffset(offset)));\n/**\n * Provides the `CurrentTimeZone` to an effect using an IANA time zone\n * identifier.\n *\n * **Details**\n *\n * If the time zone is invalid, it will fail with an `IllegalArgumentError`.\n *\n * **Example** (Providing a named time zone)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * const zoned = yield* DateTime.setZoneCurrent(DateTime.makeUnsafe(\"2024-01-01\"))\n * return DateTime.zoneToString(zoned.zone)\n * }).pipe(DateTime.withCurrentZoneNamed(\"Europe/London\"))) // => \"Europe/London\"\n * ```\n *\n * @category providing services\n * @since 3.6.0\n */\nexport const withCurrentZoneNamed = /*#__PURE__*/dual(2, (effect, zone) => Effect.provideServiceEffect(effect, CurrentTimeZone, zoneMakeNamedEffect(zone)));\n/**\n * Gets the current time as a `DateTime.Zoned`, using the `CurrentTimeZone`.\n *\n * **Example** (Getting the current time in the current zone)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * await Effect.runPromise(Effect.gen(function*() {\n * return DateTime.zoneToString((yield* DateTime.nowInCurrentZone).zone)\n * }).pipe(DateTime.withCurrentZoneNamed(\"Europe/London\"))) // => \"Europe/London\"\n * ```\n *\n * @category accessors\n * @since 3.6.0\n */\nexport const nowInCurrentZone = /*#__PURE__*/Effect.flatMap(now, setZoneCurrent);\n// =============================================================================\n// mapping\n// =============================================================================\n/**\n * Modifies a `DateTime` with a mutable local `Date` copy.\n *\n * **When to use**\n *\n * Use to adjust calendar fields in the `DateTime`'s own time zone with an\n * existing `Date` mutation API.\n *\n * **Details**\n *\n * The `Date` will first have the time zone applied if possible, and then be\n * converted back to a `DateTime` within the same time zone.\n *\n * Supports `disambiguation` when the new wall clock time is ambiguous.\n *\n * **Example** (Mutating DateTime values with Dates)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\")\n *\n * DateTime.mutate(dt, (date) => {\n * date.setHours(15) // Set to 3 PM\n * date.setMinutes(30) // Set to 30 minutes\n * })\n * ```\n *\n * @category mapping\n * @since 3.6.0\n */\nexport const mutate = Internal.mutate;\n/**\n * Modifies a `DateTime` with a mutable UTC `Date` copy.\n *\n * **When to use**\n *\n * Use to adjust the instant with an existing `Date` mutation API that works on\n * UTC calendar fields.\n *\n * **Example** (Mutating DateTime values with UTC Dates)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeZonedUnsafe(\"2024-01-01T12:00:00Z\", {\n * timeZone: \"Europe/London\"\n * })\n *\n * const modified = DateTime.mutateUtc(dt, (date) => {\n * date.setUTCHours(18) // Set UTC time to 6 PM\n * })\n *\n * modified // => DateTime.makeZonedUnsafe(\"2024-01-01T18:00:00Z\", { timeZone: \"Europe/London\" })\n * ```\n *\n * @category mapping\n * @since 3.6.0\n */\nexport const mutateUtc = Internal.mutateUtc;\n/**\n * Transforms a `DateTime` by applying a function to the number of milliseconds\n * since the Unix epoch.\n *\n * **Example** (Mapping epoch milliseconds)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // add 10 milliseconds\n * const result = DateTime.makeUnsafe(0).pipe(\n * DateTime.mapEpochMillis((millis) => millis + 10)\n * )\n * result // => DateTime.makeUnsafe(10)\n * ```\n *\n * @category mapping\n * @since 3.6.0\n */\nexport const mapEpochMillis = Internal.mapEpochMillis;\n/**\n * Applies a function to a JavaScript `Date` representing the `DateTime` and\n * returns the function's result.\n *\n * **Details**\n *\n * The callback receives the time-zone-adjusted wall-clock date for\n * `DateTime.Zoned` values. Use `DateTime.withDateUtc` when the callback should\n * receive the UTC instant.\n *\n * **Example** (Applying time zone adjusted Dates)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // get the time zone adjusted date in milliseconds\n * DateTime.makeZonedUnsafe(0, { timeZone: \"Europe/London\" }).pipe(\n * DateTime.withDate((date) => date.getTime())\n * ) // => 3600000\n * ```\n *\n * @category mapping\n * @since 3.6.0\n */\nexport const withDate = Internal.withDate;\n/**\n * Applies a function to a JavaScript `Date` representing the `DateTime`'s UTC\n * instant and returns the function's result.\n *\n * **Details**\n *\n * This ignores any associated time zone. Use `DateTime.withDate` when the\n * callback should receive the time-zone-adjusted wall-clock date.\n *\n * **Example** (Applying UTC Dates)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // get the date in milliseconds\n * DateTime.makeUnsafe(0).pipe(\n * DateTime.withDateUtc((date) => date.getTime())\n * ) // => 0\n * ```\n *\n * @category mapping\n * @since 3.6.0\n */\nexport const withDateUtc = Internal.withDateUtc;\n/**\n * Pattern match on a `DateTime` to handle `Utc` and `Zoned` cases differently.\n *\n * **Example** (Pattern matching DateTime variants)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt1 = DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\") // Utc\n * const dt2 = DateTime.makeZonedUnsafe(\"2024-06-15T14:30:00Z\", {\n * timeZone: \"Europe/London\"\n * }) // Zoned\n *\n * const result1 = DateTime.match(dt1, {\n * onUtc: (utc) => `UTC: ${DateTime.formatIso(utc)}`,\n * onZoned: (zoned) => `Zoned: ${DateTime.formatIsoZoned(zoned)}`\n * })\n *\n * const result2 = DateTime.match(dt2, {\n * onUtc: (utc) => `UTC: ${DateTime.formatIso(utc)}`,\n * onZoned: (zoned) => `Zoned: ${DateTime.formatIsoZoned(zoned)}`\n * })\n *\n * result1 // => \"UTC: 2024-01-01T12:00:00.000Z\"\n * result2 // => \"Zoned: 2024-06-15T15:30:00.000+01:00[Europe/London]\"\n * ```\n *\n * @category mapping\n * @since 3.6.0\n */\nexport const match = Internal.match;\n// =============================================================================\n// math\n// =============================================================================\n/**\n * Adds the given `Duration` to a `DateTime`.\n *\n * **When to use**\n *\n * Use to move a `DateTime` by an elapsed duration such as minutes, seconds, or\n * milliseconds.\n *\n * **Details**\n *\n * The duration is converted to milliseconds and added to the epoch\n * milliseconds. Zoned values keep their original time zone.\n *\n * **Gotchas**\n *\n * This is elapsed-time arithmetic, not calendar-aware local date arithmetic.\n * Use `add` when adding days, weeks, months, or years should account for the\n * date/time zone rules.\n *\n * **Example** (Adding durations)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // add 5 minutes\n * DateTime.makeUnsafe(0).pipe(\n * DateTime.addDuration(\"5 minutes\")\n * ) // => DateTime.makeUnsafe(300000)\n * ```\n *\n * @see {@link add} for calendar-aware date/time part arithmetic\n * @see {@link subtractDuration} for subtracting an elapsed duration\n *\n * @category math\n * @since 3.6.0\n */\nexport const addDuration = Internal.addDuration;\n/**\n * Subtracts the given `Duration` from a `DateTime`.\n *\n * **Example** (Subtracting durations)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // subtract 5 minutes\n * DateTime.makeUnsafe(0).pipe(\n * DateTime.subtractDuration(\"5 minutes\")\n * ) // => DateTime.makeUnsafe(-300000)\n * ```\n *\n * @category math\n * @since 3.6.0\n */\nexport const subtractDuration = Internal.subtractDuration;\n/**\n * Adds the given `amount` of `unit` to a `DateTime`.\n *\n * **Details**\n *\n * The time zone is taken into account when adding days, weeks, months, and\n * years.\n *\n * **Example** (Adding date and time parts)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // add 5 minutes\n * DateTime.makeUnsafe(0).pipe(\n * DateTime.add({ minutes: 5 })\n * ) // => DateTime.makeUnsafe(300000)\n * ```\n *\n * @category math\n * @since 3.6.0\n */\nexport const add = Internal.add;\n/**\n * Subtracts the given `amount` of `unit` from a `DateTime`.\n *\n * **Example** (Subtracting date and time parts)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // subtract 5 minutes\n * DateTime.makeUnsafe(0).pipe(\n * DateTime.subtract({ minutes: 5 })\n * ) // => DateTime.makeUnsafe(-300000)\n * ```\n *\n * @category math\n * @since 3.6.0\n */\nexport const subtract = Internal.subtract;\n/**\n * Converts a `DateTime` to the start of the given `part`.\n *\n * **Details**\n *\n * If the part is `week`, the `weekStartsOn` option can be used to specify the\n * day of the week that the week starts on. The default is 0 (Sunday).\n *\n * **Example** (Rounding down DateTime values)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // returns \"2024-01-01T00:00:00Z\"\n * DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\").pipe(\n * DateTime.startOf(\"day\"),\n * ) // => DateTime.makeUnsafe(\"2024-01-01T00:00:00Z\")\n * ```\n *\n * @category math\n * @since 3.6.0\n */\nexport const startOf = Internal.startOf;\n/**\n * Converts a `DateTime` to the end of the given `part`.\n *\n * **Details**\n *\n * If the part is `week`, the `weekStartsOn` option can be used to specify the\n * day of the week that the week starts on. The default is 0 (Sunday).\n *\n * **Example** (Rounding up DateTime values)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // returns \"2024-01-01T23:59:59.999Z\"\n * DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\").pipe(\n * DateTime.endOf(\"day\"),\n * ) // => DateTime.makeUnsafe(\"2024-01-01T23:59:59.999Z\")\n * ```\n *\n * @category math\n * @since 3.6.0\n */\nexport const endOf = Internal.endOf;\n/**\n * Converts a `DateTime` to the nearest given `part`.\n *\n * **Details**\n *\n * If the part is `week`, the `weekStartsOn` option can be used to specify the\n * day of the week that the week starts on. The default is 0 (Sunday).\n *\n * **Example** (Rounding DateTime values to nearest units)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * // returns \"2024-01-02T00:00:00Z\"\n * DateTime.makeUnsafe(\"2024-01-01T12:01:00Z\").pipe(\n * DateTime.nearest(\"day\"),\n * ) // => DateTime.makeUnsafe(\"2024-01-02T00:00:00Z\")\n * ```\n *\n * @category math\n * @since 3.6.0\n */\nexport const nearest = Internal.nearest;\n// =============================================================================\n// formatting\n// =============================================================================\n/**\n * Formats a `DateTime` with `Intl.DateTimeFormat`.\n *\n * **Details**\n *\n * Unless a `timeZone` option is supplied, UTC values are formatted in UTC and\n * zoned values are formatted in their named zone or fixed-offset zone.\n *\n * Fixed-offset zones depend on runtime support for offset `timeZone`\n * identifiers. When unsupported, formatting falls back to UTC with the\n * `DateTime` adjusted to the offset.\n *\n * **Example** (Formatting DateTime values with Intl options)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeZonedUnsafe(\"2024-06-15T14:30:00Z\", {\n * timeZone: \"Europe/London\"\n * })\n *\n * DateTime.format(dt, {\n * dateStyle: \"full\",\n * timeStyle: \"short\",\n * locale: \"en-US\"\n * }) // => \"Saturday, June 15, 2024 at 3:30 PM\"\n * ```\n *\n * @category formatting\n * @since 3.6.0\n */\nexport const format = Internal.format;\n/**\n * Formats a `DateTime` with `Intl.DateTimeFormat` using the system local time\n * zone and locale.\n *\n * **Example** (Formatting DateTime values locally)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeUnsafe(\"2024-06-15T14:30:00Z\")\n *\n * // Uses system local time zone and locale\n * DateTime.formatLocal(dt, {\n * year: \"numeric\",\n * month: \"long\",\n * day: \"numeric\",\n * hour: \"2-digit\",\n * minute: \"2-digit\"\n * })\n * ```\n *\n * @category formatting\n * @since 3.6.0\n */\nexport const formatLocal = Internal.formatLocal;\n/**\n * Formats a `DateTime` with `Intl.DateTimeFormat` using the UTC time zone.\n *\n * **Details**\n *\n * This forces the time zone to be UTC.\n *\n * **Example** (Formatting DateTime values in UTC)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeZonedUnsafe(\"2024-06-15T14:30:00Z\", {\n * timeZone: \"Europe/London\"\n * })\n *\n * // Force UTC formatting regardless of time zone\n * DateTime.formatUtc(dt, {\n * year: \"numeric\",\n * month: \"2-digit\",\n * day: \"2-digit\",\n * hour: \"2-digit\",\n * minute: \"2-digit\",\n * timeZoneName: \"short\"\n * })\n * ```\n *\n * @category formatting\n * @since 3.6.0\n */\nexport const formatUtc = Internal.formatUtc;\n/**\n * Formats a `DateTime` as a string using the `Intl.DateTimeFormat` API.\n *\n * **When to use**\n *\n * Use when you already have an `Intl.DateTimeFormat` and want it to control the\n * locale, time zone, and formatting options.\n *\n * **Details**\n *\n * The formatter receives the `DateTime` epoch milliseconds. Any time zone\n * conversion comes from the supplied formatter.\n *\n * **Example** (Formatting DateTime values with custom formatters)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeUnsafe(\"2024-06-15T14:30:00Z\")\n *\n * // Create a custom formatter\n * const formatter = new Intl.DateTimeFormat(\"de-DE\", {\n * year: \"numeric\",\n * month: \"long\",\n * day: \"numeric\",\n * hour: \"2-digit\",\n * minute: \"2-digit\",\n * timeZone: \"Europe/Berlin\"\n * })\n *\n * DateTime.formatIntl(dt, formatter).length > 0 // => true\n * ```\n *\n * @see {@link formatUtc} for formatting with options forced to UTC\n * @see {@link formatIso} for stable ISO formatting\n *\n * @category formatting\n * @since 3.6.0\n */\nexport const formatIntl = Internal.formatIntl;\n/**\n * Formats a `DateTime` as a UTC ISO string.\n *\n * **Details**\n *\n * Always returns the UTC representation in ISO 8601 format, ignoring any time zone.\n *\n * **Example** (Formatting DateTime values as ISO strings)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * DateTime.formatIso(DateTime.makeUnsafe(\"2024-01-01T12:30:45.123Z\")) // => \"2024-01-01T12:30:45.123Z\"\n *\n * const zoned = DateTime.makeZonedUnsafe(\"2024-01-01T12:30:45.123Z\", {\n * timeZone: \"Europe/London\"\n * })\n * DateTime.formatIso(zoned) // => \"2024-01-01T12:30:45.123Z\"\n * ```\n *\n * @category formatting\n * @since 3.6.0\n */\nexport const formatIso = Internal.formatIso;\n/**\n * Formats a `DateTime` as a time zone adjusted ISO date string.\n *\n * **Details**\n *\n * Returns only the date part (YYYY-MM-DD) after applying time zone adjustments.\n *\n * **Example** (Formatting DateTime values as ISO dates)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeUnsafe(\"2024-01-01T23:30:00Z\")\n * DateTime.formatIsoDate(dt) // => \"2024-01-01\"\n *\n * const zoned = DateTime.makeZonedUnsafe(\"2024-01-01T23:30:00Z\", {\n * timeZone: \"Pacific/Auckland\" // UTC+12/13\n * })\n * DateTime.formatIsoDate(zoned) // => \"2024-01-02\"\n * ```\n *\n * @category formatting\n * @since 3.6.0\n */\nexport const formatIsoDate = Internal.formatIsoDate;\n/**\n * Formats a `DateTime` as a UTC ISO date string.\n *\n * **Details**\n *\n * Returns only the date part (YYYY-MM-DD) in UTC, ignoring any time zone.\n *\n * **Example** (Formatting DateTime values as UTC ISO dates)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const dt = DateTime.makeUnsafe(\"2024-01-01T23:30:00Z\")\n * DateTime.formatIsoDateUtc(dt) // => \"2024-01-01\"\n *\n * const zoned = DateTime.makeZonedUnsafe(\"2024-01-01T23:30:00Z\", {\n * timeZone: \"Pacific/Auckland\"\n * })\n * DateTime.formatIsoDateUtc(zoned) // => \"2024-01-01\"\n * ```\n *\n * @category formatting\n * @since 3.6.0\n */\nexport const formatIsoDateUtc = Internal.formatIsoDateUtc;\n/**\n * Formats a `DateTime.Zoned` as an ISO string with an offset.\n *\n * **Details**\n *\n * For `DateTime.Utc`, returns the same as `formatIso`. For `DateTime.Zoned`,\n * includes the time zone offset in the format.\n *\n * **Example** (Formatting DateTime values with offsets)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const utc = DateTime.makeUnsafe(\"2024-01-01T12:00:00Z\")\n * DateTime.formatIsoOffset(utc) // => \"2024-01-01T12:00:00.000Z\"\n *\n * const zoned = DateTime.makeZonedUnsafe(\"2024-01-01T12:00:00Z\", {\n * timeZone: DateTime.zoneMakeOffset(3 * 60 * 60 * 1000)\n * })\n * DateTime.formatIsoOffset(zoned) // => \"2024-01-01T15:00:00.000+03:00\"\n * ```\n *\n * @category formatting\n * @since 3.6.0\n */\nexport const formatIsoOffset = Internal.formatIsoOffset;\n/**\n * Formats a `DateTime.Zoned` as a string.\n *\n * **Details**\n *\n * It uses the format: `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`.\n *\n * **Example** (Formatting zoned DateTime values)\n *\n * ```ts import.meta.vitest\n * import { DateTime } from \"effect\"\n *\n * const zoned = DateTime.makeZonedUnsafe(\"2024-06-15T14:30:45.123Z\", {\n * timeZone: \"Europe/London\"\n * })\n *\n * DateTime.formatIsoZoned(zoned) // => \"2024-06-15T15:30:45.123+01:00[Europe/London]\"\n *\n * const offsetZone = DateTime.makeZonedUnsafe(\"2024-06-15T14:30:45.123Z\", {\n * timeZone: DateTime.zoneMakeOffset(3 * 60 * 60 * 1000)\n * })\n *\n * DateTime.formatIsoZoned(offsetZone) // => \"2024-06-15T17:30:45.123+03:00\"\n * ```\n *\n * @category formatting\n * @since 3.6.0\n */\nexport const formatIsoZoned = Internal.formatIsoZoned;\n/**\n * Create a Layer from the given time zone.\n *\n * **Details**\n *\n * This layer provides the `CurrentTimeZone` service with the specified time zone.\n *\n * **Example** (Providing current time zone layers)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * const zone = DateTime.zoneMakeNamedUnsafe(\"Europe/London\")\n * const layer = DateTime.layerCurrentZone(zone)\n *\n * const program = Effect.gen(function*() {\n * const now = yield* DateTime.nowInCurrentZone\n * return DateTime.zoneToString(now.zone)\n * })\n *\n * // Use the layer to provide the time zone\n * await Effect.runPromise(Effect.provide(program, layer)) // => \"Europe/London\"\n * ```\n *\n * @category layers\n * @since 3.6.0\n */\nexport const layerCurrentZone = /*#__PURE__*/Layer.succeed(CurrentTimeZone);\n/**\n * Create a Layer from the given time zone offset.\n *\n * **Details**\n *\n * This layer provides the `CurrentTimeZone` service with a fixed offset time zone.\n *\n * **Example** (Providing fixed-offset time zone layers)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * // Create a layer for UTC+3\n * const layer = DateTime.layerCurrentZoneOffset(3 * 60 * 60 * 1000)\n *\n * const program = Effect.gen(function*() {\n * const now = yield* DateTime.nowInCurrentZone\n * return DateTime.zoneToString(now.zone)\n * })\n *\n * await Effect.runPromise(Effect.provide(program, layer)) // => \"+03:00\"\n * ```\n *\n * @category layers\n * @since 3.6.0\n */\nexport const layerCurrentZoneOffset = offset => Layer.succeed(CurrentTimeZone)(Internal.zoneMakeOffset(offset));\n/**\n * Create a Layer from the given IANA time zone identifier.\n *\n * **Details**\n *\n * This layer provides the `CurrentTimeZone` service with a named time zone.\n * If the time zone identifier is invalid, the layer will fail.\n *\n * **Example** (Providing named time zone layers)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * const layer = DateTime.layerCurrentZoneNamed(\"Europe/London\")\n *\n * const program = Effect.gen(function*() {\n * const now = yield* DateTime.nowInCurrentZone\n * return DateTime.zoneToString(now.zone)\n * })\n *\n * await Effect.runPromise(Effect.provide(program, layer)) // => \"Europe/London\"\n * ```\n *\n * @category layers\n * @since 3.6.0\n */\nexport const layerCurrentZoneNamed = /*#__PURE__*/flow(Internal.zoneMakeNamedEffect, /*#__PURE__*/Layer.effect(CurrentTimeZone));\n/**\n * Create a Layer from the system's local time zone.\n *\n * **Details**\n *\n * This layer provides the `CurrentTimeZone` service using the system's\n * configured local time zone.\n *\n * **Example** (Providing local time zone layers)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n * const now = yield* DateTime.nowInCurrentZone\n * return DateTime.isZoned(now)\n * })\n *\n * // Use the system's local time zone\n * await Effect.runPromise(Effect.provide(program, DateTime.layerCurrentZoneLocal)) // => true\n * ```\n *\n * @category layers\n * @since 3.6.0\n */\nexport const layerCurrentZoneLocal = /*#__PURE__*/Layer.sync(CurrentTimeZone)(zoneMakeLocal);\n//# sourceMappingURL=DateTime.js.map","/**\n * Builds one-way conversions used by schemas.\n *\n * A `Getter` receives an optional encoded value and returns an\n * optional decoded value. It can also report a schema issue or require Effect\n * services. Schema transformations use getters to describe one direction of a\n * conversion, for example decoding a field from input data. This module\n * includes basic getters, validation helpers, pure and effectful conversions,\n * and ready-made conversions for common string, number, binary, date, form, and\n * URL-related values.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"./Array.js\";\nimport * as DateTime from \"./DateTime.js\";\nimport * as Effect from \"./Effect.js\";\nimport * as Encoding from \"./Encoding.js\";\nimport * as InternalRecord from \"./internal/record.js\";\nimport * as Option from \"./Option.js\";\nimport * as Pipeable from \"./Pipeable.js\";\nimport * as Predicate from \"./Predicate.js\";\nimport * as Result from \"./Result.js\";\nimport * as SchemaIssue from \"./SchemaIssue.js\";\nimport * as Str from \"./String.js\";\n/**\n * Constructs a composable schema getter.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Getter = class extends Pipeable.Class {\n run;\n constructor(run) {\n super();\n this.run = run;\n }\n map(f) {\n return new Getter((oe, options) => this.run(oe, options).pipe(Effect.mapEager(Option.map(f))));\n }\n compose(other) {\n if (isPassthrough(this)) {\n return other;\n }\n if (isPassthrough(other)) {\n return this;\n }\n return new Getter((oe, options) => this.run(oe, options).pipe(Effect.flatMapEager(ot => other.run(ot, options))));\n }\n};\n/**\n * Creates a getter that always produces the given constant value, ignoring the input.\n *\n * **When to use**\n *\n * Use when you need a schema getter that always decodes a field to a fixed\n * value.\n *\n * **Details**\n *\n * The getter is pure and always returns `Option.some(t)` regardless of whether\n * the input is `Some` or `None`.\n *\n * **Example** (Returning a constant getter)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const alwaysZero = SchemaGetter.succeed(0)\n * await Effect.runPromise(alwaysZero.run(Option.none(), {})) // => Option.some(0)\n * ```\n *\n * @see {@link transform} when you need to use the input value\n * @see {@link passthrough} when you want to keep the input as-is\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function succeed(t) {\n return new Getter(() => Effect.succeedSome(t));\n}\n/**\n * Creates a getter that always fails with the given issue.\n *\n * **When to use**\n *\n * Use when you need a schema getter that unconditionally rejects input.\n * - Building custom validation getters that produce specific error types.\n *\n * **Details**\n *\n * - Always fails with the `Issue` returned by `f`.\n * - The failure function receives the original `Option` input and the\n * effective `ParseOptions` for error context.\n *\n * **Example** (Defining an always-failing getter)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter, SchemaIssue } from \"effect\"\n *\n * const rejectAll = SchemaGetter.fail(\n * () => new SchemaIssue.InvalidValue({ message: \"not allowed\" })\n * )\n * const issue = await Effect.runPromise(Effect.flip(rejectAll.run(Option.some(\"x\"), {})))\n * issue._tag // => \"InvalidValue\"\n * ```\n *\n * @see {@link forbidden} for a convenience helper for `Forbidden` issues\n * @see {@link checkEffect} to fail conditionally based on input value\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function fail(f) {\n return new Getter((oe, options) => Effect.fail(f(oe, options)));\n}\n/**\n * Creates a getter that always fails with a `Forbidden` issue.\n *\n * **When to use**\n *\n * Use when you need a schema getter to disallow a field or direction\n * (encode/decode) entirely.\n * - You want a clear \"forbidden\" error message in schema validation output.\n *\n * **Details**\n *\n * - Always fails with `SchemaIssue.Forbidden`.\n * - The message function receives the `Option` input for context.\n *\n * **Example** (Forbidding a decode direction)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const noEncode = SchemaGetter.forbidden(\n * () => \"encoding is not supported\"\n * )\n * const issue = await Effect.runPromise(Effect.flip(noEncode.run(Option.some(1), {})))\n * issue._tag // => \"Forbidden\"\n * ```\n *\n * @see {@link fail} to fail with a custom issue type\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function forbidden(message) {\n return fail((oe, options) => {\n const annotations = {\n message: message(oe)\n };\n return Option.isSome(oe) ? new SchemaIssue.Forbidden(annotations, oe.value, options) : new SchemaIssue.Forbidden(annotations);\n });\n}\n/**\n * Getter that always fails with a `Forbidden` issue indicating that encoding is unsupported.\n *\n * **When to use**\n *\n * Use as the encode side of a decode-only Schema transformation.\n *\n * **Details**\n *\n * Its `Getter` type is assignable to every encoding getter because it accepts any input and never\n * produces an output value.\n *\n * **Example** (Rejecting encoding)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const issue = await Effect.runPromise(\n * Effect.flip(SchemaGetter.forbiddenEncoding.run(Option.some(\"value\"), {}))\n * )\n * issue._tag // => \"Forbidden\"\n * ```\n *\n * @see {@link forbidden} for a forbidden getter with a custom message\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const forbiddenEncoding = /*#__PURE__*/forbidden(() => \"Encoding is not supported\");\nconst passthrough_ = /*#__PURE__*/new Getter(Effect.succeed);\nfunction isPassthrough(getter) {\n return getter.run === passthrough_.run;\n}\nexport function passthrough() {\n return passthrough_;\n}\nexport function passthroughSupertype() {\n return passthrough_;\n}\nexport function passthroughSubtype() {\n return passthrough_;\n}\n/**\n * Creates a getter that handles the case when the input is absent (`Option.None`).\n *\n * **When to use**\n *\n * Use when you need a schema getter to provide a fallback or computed value for\n * missing struct keys.\n * - Building custom \"default value\" logic more complex than {@link withDefault}.\n *\n * **Details**\n *\n * - When input is `None`, calls `f` to produce the result.\n * - When input is `Some`, passes it through unchanged.\n * - `f` receives the parse options and may return `None` to keep the value absent.\n *\n * **Example** (Providing a default timestamp for a missing field)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const withTimestamp = SchemaGetter.onNone(() =>\n * Effect.succeed(Option.some(0))\n * )\n * await Effect.runPromise(withTimestamp.run(Option.none(), {})) // => Option.some(0)\n * ```\n *\n * @see {@link required} when absent input should fail\n * @see {@link withDefault} for a simpler default value for undefined inputs\n * @see {@link onSome} to handle only present values\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function onNone(f) {\n return new Getter((ot, options) => Option.isNone(ot) ? f(options) : Effect.succeed(ot));\n}\n/**\n * Creates a getter that fails with `MissingKey` if the input is absent (`Option.None`).\n *\n * **When to use**\n *\n * Use when you need a schema getter to require a struct field in the encoded\n * input and report a missing key error when it is absent.\n *\n * **Details**\n *\n * - When input is `None`, fails with `SchemaIssue.MissingKey`.\n * - When input is `Some`, passes it through unchanged.\n * - Optional `annotations` customize the error message for the missing key.\n *\n * **Example** (Defining a required struct field)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const mustExist = SchemaGetter.required()\n * const issue = await Effect.runPromise(Effect.flip(mustExist.run(Option.none(), {})))\n * issue._tag // => \"MissingKey\"\n * ```\n *\n * @see {@link onNone} to provide a fallback instead of failing\n * @see {@link withDefault} to substitute a default for undefined values\n *\n * @category validation\n * @since 4.0.0\n */\nexport function required(annotations) {\n return onNone(() => Effect.fail(new SchemaIssue.MissingKey(annotations)));\n}\n/**\n * Creates a getter that handles present values (`Option.Some`), passing `None` through.\n *\n * **When to use**\n *\n * Use when you need a schema getter to transform or validate only when a field\n * value is present.\n * - Missing keys should remain absent in the output.\n *\n * **Details**\n *\n * - When input is `None`, returns `None` (no-op).\n * - When input is `Some(e)`, calls `f(e, options)` to produce the result.\n * - `f` may return `None` to omit the value, or fail with an `Issue`.\n *\n * **Example** (Transforming only present values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const parseIfPresent = SchemaGetter.onSome(\n * (s) => Effect.succeed(Option.some(Number(s)))\n * )\n * await Effect.runPromise(parseIfPresent.run(Option.some(\"42\"), {})) // => Option.some(42)\n * ```\n *\n * @see {@link onNone} to handle only absent values\n * @see {@link transform} for a simpler pure transformation of present values\n * @see {@link transformEffect} for effectful transformation of present values\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function onSome(f) {\n return new Getter((oe, options) => Option.isNone(oe) ? Effect.succeedNone : f(oe.value, options));\n}\n/**\n * Creates a getter that validates a value using an effectful check function.\n *\n * **When to use**\n *\n * Use when you need a schema getter to validate a decoded value (e.g. check a\n * constraint or call an external service).\n * - The validation may be asynchronous or require Effect services.\n *\n * **Details**\n *\n * - Only runs when input is `Some` — `None` passes through.\n * - The check function returns a validation result:\n * - `undefined` or `true` — value is valid, passes through.\n * - `false` or a `string` — value is invalid, fails with an `Issue`.\n * - An `Issue` object — fails with that issue directly.\n * - `{ path, issue }` — fails with a nested path issue (`issue` may be a\n * message string or a full {@link SchemaIssue.Issue}).\n * - Does not transform the value — input and output types are the same.\n *\n * **Example** (Validating effectfully)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const nonNegative = SchemaGetter.checkEffect((n) =>\n * Effect.succeed(n >= 0 ? undefined : \"must be non-negative\")\n * )\n * await Effect.runPromise(nonNegative.run(Option.some(1), {})) // => Option.some(1)\n * ```\n *\n * @see {@link transform} when you need to change the value, not just validate\n * @see {@link fail} for unconditional failure\n *\n * @category validation\n * @since 4.0.0\n */\nexport function checkEffect(f) {\n return onSome((t, options) => {\n return f(t, options).pipe(Effect.flatMapEager(out => {\n const issue = SchemaIssue.makeSingle(out, t, options);\n return issue ? Effect.fail(issue) : Effect.succeed(Option.some(t));\n }));\n });\n}\n/**\n * Creates a getter that applies a pure function to present values.\n *\n * **When to use**\n *\n * Use when you need a schema getter for a pure, infallible transformation\n * between types.\n * - Building encode/decode pairs for `Schema.decodeTo`.\n *\n * **Details**\n *\n * - This is the most commonly used constructor.\n * - Transforms `Some(e)` to `Some(f(e))` and leaves `None` unchanged.\n * - Skips `None` inputs — only called when a value is present.\n * - Never fails.\n *\n * **Example** (Transforming strings to numbers)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaGetter } from \"effect\"\n *\n * const NumberFromString = Schema.String.pipe(\n * Schema.decodeTo(Schema.Number, {\n * decode: SchemaGetter.transform((s) => Number(s)),\n * encode: SchemaGetter.transform((n) => String(n))\n * })\n * )\n * Schema.decodeSync(NumberFromString)(\"42\") // => 42\n * ```\n *\n * @see {@link transformEffect} when the transformation returns an `Effect`\n * @see {@link transformOptional} when you need to handle `None` inputs\n * @see {@link passthrough} when no transformation is needed\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function transform(f) {\n return transformOptional(Option.map(f));\n}\n/**\n * Creates a getter that applies an effectful transformation to present values.\n *\n * **When to use**\n *\n * Use when you need a schema getter for a transformation that may fail, require\n * Effect services, or run asynchronously.\n *\n * **Details**\n *\n * - Skips `None` inputs — only called when a value is present.\n * - On success, wraps the result in `Some`.\n * - On failure, propagates the `Issue`.\n *\n * **Example** (Parsing with failure)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter, SchemaIssue } from \"effect\"\n *\n * const safeParseInt = SchemaGetter.transformEffect(\n * (s, options) => {\n * const n = parseInt(s, 10)\n * return isNaN(n)\n * ? Effect.fail(new SchemaIssue.InvalidValue({ message: \"not an integer\" }, s, options))\n * : Effect.succeed(n)\n * }\n * )\n * await Effect.runPromise(safeParseInt.run(Option.some(\"42\"), {})) // => Option.some(42)\n * ```\n *\n * @see {@link transform} when transformation cannot fail\n * @see {@link onSome} when you need full `Option` control over the output\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function transformEffect(f) {\n return onSome((e, options) => f(e, options).pipe(Effect.mapEager(Option.some)));\n}\n/**\n * Creates a getter that transforms the full `Option` — both present and absent values.\n *\n * **When to use**\n *\n * Use when you need a schema getter to handle both `Some` and `None` cases.\n *\n * **Details**\n *\n * The getter is pure and never fails. It receives the full `Option` and\n * must return `Option`, so it can turn a present value into absent or an\n * absent value into present.\n *\n * **Example** (Filtering out empty strings)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const skipEmpty = SchemaGetter.transformOptional((o) =>\n * Option.filter(o, (s) => s.length > 0)\n * )\n * await Effect.runPromise(skipEmpty.run(Option.some(\"\"), {})) // => Option.none()\n * ```\n *\n * @see {@link transform} when you only need to transform present values\n * @see {@link omit} when you always want `None`\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function transformOptional(f) {\n return new Getter(oe => Effect.succeed(f(oe)));\n}\n/**\n * Creates a getter that always returns `None`, effectively omitting the value from output.\n *\n * **When to use**\n *\n * Use when you need a schema getter to exclude a field during decoding or\n * encoding.\n *\n * **Details**\n *\n * - Always returns `Option.None` regardless of input.\n * - Never fails.\n *\n * **Example** (Omitting a field during encoding)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const omitField = SchemaGetter.omit()\n * await Effect.runPromise(omitField.run(Option.some(\"hidden\"), {})) // => Option.none()\n * ```\n *\n * @see {@link transformOptional} when you want conditional omission\n * @see {@link forbidden} when you want to fail instead of silently omit\n *\n * @category filtering\n * @since 4.0.0\n */\nexport function omit() {\n return new Getter(() => Effect.succeedNone);\n}\n/**\n * Creates a getter that replaces `undefined` values with a default.\n *\n * **When to use**\n *\n * Use when you need a schema getter to provide a fallback for a field that may\n * be `undefined` in the encoded input.\n *\n * **Details**\n *\n * - If the input is `Some(undefined)` or `None`, produces `Some(T)`.\n * - If the input is `Some(value)` where value is not `undefined`, passes it through.\n * - `defaultValue` is an `Effect` that will be executed each time a default is needed.\n *\n * **Example** (Providing a default value for an optional field)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const withZero = SchemaGetter.withDefault(Effect.succeed(0))\n * await Effect.runPromise(withZero.run(Option.some(undefined), {})) // => Option.some(0)\n * ```\n *\n * @see {@link onNone} to handle only absent keys (not `undefined` values)\n * @see {@link required} when absent input should fail instead of using a default\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function withDefault(defaultValue) {\n return new Getter(o => {\n const filtered = Option.filter(o, Predicate.isNotUndefined);\n return Option.isSome(filtered) ? Effect.succeed(filtered) : Effect.mapEager(defaultValue, Option.some);\n });\n}\n/**\n * Coerces any value to a `string` using the global `String()` constructor.\n *\n * **When to use**\n *\n * Use when you need a schema getter to coerce a present encoded value to a\n * string with `String()`.\n *\n * **Details**\n *\n * The getter is pure, never fails, and delegates to `globalThis.String`.\n *\n * **Example** (Coercing to a string)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const toString = SchemaGetter.String()\n * await Effect.runPromise(toString.run(Option.some(42), {})) // => Option.some(\"42\")\n * ```\n *\n * @see {@link transform} for custom string conversions\n *\n * @category converting\n * @since 4.0.0\n */\nexport function String() {\n return transform(globalThis.String);\n}\n/**\n * Coerces any value to a `number` using the global `Number()` constructor.\n *\n * **When to use**\n *\n * Use when you need a schema getter to coerce a present encoded value to a\n * number with `Number()`.\n *\n * **Details**\n *\n * The getter is pure, never fails, and delegates to `globalThis.Number`. It may\n * produce `NaN` for non-numeric inputs.\n *\n * **Example** (Coercing to a number)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const toNumber = SchemaGetter.Number()\n * await Effect.runPromise(toNumber.run(Option.some(\"42\"), {})) // => Option.some(42)\n * ```\n *\n * @see {@link transformEffect} for effectful or validated number parsing\n *\n * @category converting\n * @since 4.0.0\n */\nexport function Number() {\n return transform(globalThis.Number);\n}\n/**\n * Coerces any value to a `boolean` using the global `Boolean()` constructor.\n *\n * **When to use**\n *\n * Use when you need a schema getter to coerce a present encoded value to a\n * boolean with `Boolean()`.\n *\n * **Details**\n *\n * The getter is pure, never fails, and delegates to `globalThis.Boolean`.\n *\n * **Example** (Coercing to a boolean)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const toBool = SchemaGetter.Boolean()\n * await Effect.runPromise(toBool.run(Option.some(\"true\"), {})) // => Option.some(true)\n * ```\n *\n * @category converting\n * @since 4.0.0\n */\nexport function Boolean() {\n return transform(globalThis.Boolean);\n}\n/**\n * Coerces a value to `bigint` using the global `BigInt()` constructor.\n *\n * **When to use**\n *\n * Use when you need a schema getter to convert a present string, number, or\n * boolean value to `bigint`.\n *\n * **Details**\n *\n * - Delegates to `globalThis.BigInt`.\n * - Throws at runtime if the input cannot be converted (e.g. non-numeric string).\n *\n * **Example** (Coercing to a bigint)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const toBigInt = SchemaGetter.BigInt()\n * await Effect.runPromise(toBigInt.run(Option.some(\"42\"), {})) // => Option.some(42n)\n * ```\n *\n * @category converting\n * @since 4.0.0\n */\nexport function BigInt() {\n return transform(globalThis.BigInt);\n}\n/**\n * Coerces a value to a `Date` using `new Date(input)`.\n *\n * **When to use**\n *\n * Use when you need a schema getter to coerce a present string, number, or\n * existing date object into a new date object.\n *\n * **Details**\n *\n * - Delegates to `new globalThis.Date(input)`.\n * - Does not validate the result — may produce an invalid Date.\n *\n * **Example** (Coercing to a Date)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const toDate = SchemaGetter.Date()\n * const result = await Effect.runPromise(toDate.run(Option.some(\"1970-01-01\"), {}))\n * Option.map(result, (date) => date.toISOString()) // => Option.some(\"1970-01-01T00:00:00.000Z\")\n * ```\n *\n * @see {@link dateTimeUtcFromInput} for validated DateTime parsing\n *\n * @category converting\n * @since 4.0.0\n */\nexport function Date() {\n return transform(u => new globalThis.Date(u));\n}\n/**\n * Strips whitespace from both ends of a string.\n *\n * **Details**\n *\n * - Pure, delegates to `String.trim`.\n *\n * **Example** (Trimming whitespace)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const trimmed = SchemaGetter.trim()\n * await Effect.runPromise(trimmed.run(Option.some(\" hello \"), {})) // => Option.some(\"hello\")\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function trim() {\n return transform(Str.trim);\n}\n/**\n * Capitalizes the first character of a string.\n *\n * **Details**\n *\n * - Pure, delegates to `String.capitalize`.\n *\n * **Example** (Capitalizing a string)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const cap = SchemaGetter.capitalize()\n * await Effect.runPromise(cap.run(Option.some(\"hello\"), {})) // => Option.some(\"Hello\")\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function capitalize() {\n return transform(Str.capitalize);\n}\n/**\n * Uncapitalizes the first character of a string.\n *\n * **Details**\n *\n * - Pure, delegates to `String.uncapitalize`.\n *\n * **Example** (Uncapitalizing a string)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const uncap = SchemaGetter.uncapitalize()\n * await Effect.runPromise(uncap.run(Option.some(\"Hello\"), {})) // => Option.some(\"hello\")\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function uncapitalize() {\n return transform(Str.uncapitalize);\n}\n/**\n * Converts a `snake_case` string to `camelCase`.\n *\n * **Details**\n *\n * - Pure, delegates to `String.snakeToCamel`.\n *\n * **Example** (Converting snake case to camel case)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const toCamel = SchemaGetter.snakeToCamel()\n * await Effect.runPromise(toCamel.run(Option.some(\"user_name\"), {})) // => Option.some(\"userName\")\n * ```\n *\n * @see {@link camelToSnake} for the inverse operation\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function snakeToCamel() {\n return transform(Str.snakeToCamel);\n}\n/**\n * Converts a `camelCase` string to `snake_case`.\n *\n * **Details**\n *\n * - Pure, delegates to `String.camelToSnake`.\n *\n * **Example** (Converting camel case to snake case)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const toSnake = SchemaGetter.camelToSnake()\n * await Effect.runPromise(toSnake.run(Option.some(\"userName\"), {})) // => Option.some(\"user_name\")\n * ```\n *\n * @see {@link snakeToCamel} for the inverse operation\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function camelToSnake() {\n return transform(Str.camelToSnake);\n}\n/**\n * Converts a string to lowercase.\n *\n * **Details**\n *\n * - Pure, delegates to `String.toLowerCase`.\n *\n * **Example** (Converting to lowercase)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const lower = SchemaGetter.toLowerCase()\n * await Effect.runPromise(lower.run(Option.some(\"HELLO\"), {})) // => Option.some(\"hello\")\n * ```\n *\n * @see {@link toUpperCase} for the inverse operation\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function toLowerCase() {\n return transform(Str.toLowerCase);\n}\n/**\n * Converts a string to uppercase.\n *\n * **Details**\n *\n * - Pure, delegates to `String.toUpperCase`.\n *\n * **Example** (Converting to uppercase)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const upper = SchemaGetter.toUpperCase()\n * await Effect.runPromise(upper.run(Option.some(\"hello\"), {})) // => Option.some(\"HELLO\")\n * ```\n *\n * @see {@link toLowerCase} for the inverse operation\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function toUpperCase() {\n return transform(Str.toUpperCase);\n}\nexport function parseJson(options) {\n return onSome((input, parseOptions) => Effect.try({\n try: () => Option.some(JSON.parse(input, options?.reviver)),\n catch: () => new SchemaIssue.InvalidValue({\n expected: \"a valid JSON string\"\n }, input, parseOptions)\n }));\n}\n/**\n * Stringifies a present value using `JSON.stringify`.\n *\n * **When to use**\n *\n * Use when you need a schema getter to serialize a present decoded value to\n * JSON text during encoding.\n *\n * **Details**\n *\n * - Skips `None` inputs.\n * - If `JSON.stringify` throws or returns `undefined`, fails with\n * `SchemaIssue.InvalidValue`.\n * - Supports optional `replacer` and `space` options, matching\n * `JSON.stringify`.\n *\n * **Example** (Stringifying JSON)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const stringify = SchemaGetter.stringifyJson()\n * await Effect.runPromise(stringify.run(Option.some({ a: 1 }), {})) // => Option.some(\"{\\\"a\\\":1}\")\n * ```\n *\n * @see {@link parseJson} for the inverse operation\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function stringifyJson(options) {\n return onSome((input, parseOptions) => Effect.try({\n try: () => {\n const output = JSON.stringify(input, options?.replacer, options?.space);\n if (output === undefined) {\n throw new TypeError(\"Value cannot be represented as JSON\");\n }\n return Option.some(output);\n },\n catch: () => new SchemaIssue.InvalidValue({\n expected: \"a JSON-serializable value\"\n }, input, parseOptions)\n }));\n}\n/**\n * Parses a string into a record of key-value pairs.\n *\n * **When to use**\n *\n * Use when you need a schema getter to parse a present encoded string that\n * contains delimited key-value pairs (e.g. `\"a=1,b=2\"`).\n *\n * **Details**\n *\n * The getter is pure and never fails. It splits the string by `separator`\n * (default `,`) and then each pair by `keyValueSeparator` (default `=`). Pairs\n * missing a key or value are silently skipped.\n *\n * **Example** (Parsing a key-value string)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const parse = SchemaGetter.splitKeyValue()\n * await Effect.runPromise(parse.run(Option.some(\"a=1,b=2\"), {})) // => Option.some({ a: \"1\", b: \"2\" })\n * ```\n *\n * @see {@link joinKeyValue} for the inverse operation\n * @see {@link split} to split into an array of strings\n *\n * @category splitting\n * @since 4.0.0\n */\nexport function splitKeyValue(options) {\n const separator = options?.separator ?? \",\";\n const keyValueSeparator = options?.keyValueSeparator ?? \"=\";\n return transform(input => input.split(separator).reduce((acc, pair) => {\n const [key, value] = pair.split(keyValueSeparator);\n if (key && value) {\n InternalRecord.assignProperty(acc, key, value);\n }\n return acc;\n }, {}));\n}\n/**\n * Joins a record of key-value pairs into a delimited string.\n *\n * **When to use**\n *\n * Use when you need a schema getter to serialize a present decoded record as a\n * delimited key-value string.\n *\n * **Details**\n *\n * The getter is pure and never fails. It joins entries with `separator`\n * (default `,`) and joins each key and value with `keyValueSeparator` (default\n * `=`).\n *\n * **Example** (Joining key-value records)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const join = SchemaGetter.joinKeyValue()\n * await Effect.runPromise(join.run(Option.some({ a: \"1\", b: \"2\" }), {})) // => Option.some(\"a=1,b=2\")\n * ```\n *\n * @see {@link splitKeyValue} for the inverse operation\n *\n * @category combining\n * @since 4.0.0\n */\nexport function joinKeyValue(options) {\n const separator = options?.separator ?? \",\";\n const keyValueSeparator = options?.keyValueSeparator ?? \"=\";\n return transform(input => Object.entries(input).map(([key, value]) => `${key}${keyValueSeparator}${value}`).join(separator));\n}\n/**\n * Splits a string into an array of strings by a separator.\n *\n * **When to use**\n *\n * Use when you need a schema getter to split a present encoded string\n * containing a delimited list, such as CSV values.\n *\n * **Details**\n *\n * The getter is pure and never fails. It splits by `separator` (default `,`).\n * An empty string produces an empty array, not `[\"\"]`.\n *\n * **Example** (Splitting a comma-separated string)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const splitComma = SchemaGetter.split()\n * await Effect.runPromise(splitComma.run(Option.some(\"a,b,c\"), {})) // => Option.some([\"a\", \"b\", \"c\"])\n * ```\n *\n * @see {@link splitKeyValue} when values are key-value pairs\n *\n * @category splitting\n * @since 4.0.0\n */\nexport function split(options) {\n const separator = options?.separator ?? \",\";\n return transform(input => input === \"\" ? [] : input.split(separator));\n}\n/**\n * Encodes a `Uint8Array` or string to a Base64 string.\n *\n * **Details**\n *\n * The getter is pure and never fails.\n *\n * **Example** (Encoding to Base64)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const encode = SchemaGetter.encodeBase64()\n * await Effect.runPromise(encode.run(Option.some(new Uint8Array([1, 2, 3])), {})) // => Option.some(\"AQID\")\n * ```\n *\n * @see {@link decodeBase64} for the inverse operation to `Uint8Array`\n * @see {@link decodeBase64String} for the inverse operation to `string`\n * @see {@link encodeBase64Url} for the URL-safe variant\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeBase64() {\n return transform(Encoding.encodeBase64);\n}\n/**\n * Encodes a `Uint8Array` or string to a URL-safe Base64 string.\n *\n * **Details**\n *\n * The getter is pure and never fails.\n *\n * **Example** (Encoding to Base64Url)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const encode = SchemaGetter.encodeBase64Url()\n * await Effect.runPromise(encode.run(Option.some(new Uint8Array([251, 255])), {})) // => Option.some(\"-_8\")\n * ```\n *\n * @see {@link decodeBase64Url} for the inverse operation to `Uint8Array`\n * @see {@link decodeBase64UrlString} for the inverse operation to `string`\n * @see {@link encodeBase64} for the standard Base64 variant\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeBase64Url() {\n return transform(Encoding.encodeBase64Url);\n}\n/**\n * Encodes a `Uint8Array` or string to a hexadecimal string.\n *\n * **Details**\n *\n * The getter is pure and never fails.\n *\n * **Example** (Encoding to hex)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const encode = SchemaGetter.encodeHex()\n * await Effect.runPromise(encode.run(Option.some(new Uint8Array([1, 2, 3])), {})) // => Option.some(\"010203\")\n * ```\n *\n * @see {@link decodeHex} for the inverse operation to `Uint8Array`\n * @see {@link decodeHexString} for the inverse operation to `string`\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeHex() {\n return transform(Encoding.encodeHex);\n}\n/**\n * Decodes a Base64 string to a `Uint8Array`.\n *\n * **Details**\n *\n * - Fails with `SchemaIssue.InvalidValue` if the input is not valid Base64.\n *\n * **Example** (Decoding Base64 to bytes)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const decode = SchemaGetter.decodeBase64()\n * const result = await Effect.runPromise(decode.run(Option.some(\"AQID\"), {}))\n * Option.map(result, Array.from) // => Option.some([1, 2, 3])\n * ```\n *\n * @see {@link decodeBase64String} to decode to `string` instead\n * @see {@link encodeBase64} for the inverse operation\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeBase64() {\n return transformEffect((input, options) => Effect.mapErrorEager(Effect.fromResult(Encoding.decodeBase64(input)), () => new SchemaIssue.InvalidValue({\n expected: \"a valid Base64 string\"\n }, input, options)));\n}\n/**\n * Decodes a Base64 string to a UTF-8 `string`.\n *\n * **Details**\n *\n * - Fails with `SchemaIssue.InvalidValue` if the input is not valid Base64.\n *\n * **Example** (Decoding Base64 to string)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const decode = SchemaGetter.decodeBase64String()\n * await Effect.runPromise(decode.run(Option.some(\"aGVsbG8=\"), {})) // => Option.some(\"hello\")\n * ```\n *\n * @see {@link decodeBase64} to decode to `Uint8Array` instead\n * @see {@link encodeBase64} for the inverse operation\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeBase64String() {\n return transformEffect((input, options) => Result.match(Encoding.decodeBase64String(input), {\n onFailure: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid Base64 string\"\n }, input, options)),\n onSuccess: Effect.succeed\n }));\n}\n/**\n * Decodes a URL-safe Base64 string to a `Uint8Array`.\n *\n * **Details**\n *\n * - Fails with `SchemaIssue.InvalidValue` if the input is not valid Base64Url.\n *\n * **Example** (Decoding Base64Url to bytes)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const decode = SchemaGetter.decodeBase64Url()\n * const result = await Effect.runPromise(decode.run(Option.some(\"-_8=\"), {}))\n * Option.map(result, Array.from) // => Option.some([251, 255])\n * ```\n *\n * @see {@link decodeBase64UrlString} to decode to `string` instead\n * @see {@link encodeBase64Url} for the inverse operation\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeBase64Url() {\n return transformEffect((input, options) => Result.match(Encoding.decodeBase64Url(input), {\n onFailure: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid Base64Url string\"\n }, input, options)),\n onSuccess: Effect.succeed\n }));\n}\n/**\n * Decodes a URL-safe Base64 string to a UTF-8 `string`.\n *\n * **Details**\n *\n * - Fails with `SchemaIssue.InvalidValue` if the input is not valid Base64Url.\n *\n * **Example** (Decoding Base64Url to string)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const decode = SchemaGetter.decodeBase64UrlString()\n * await Effect.runPromise(decode.run(Option.some(\"aGVsbG8\"), {})) // => Option.some(\"hello\")\n * ```\n *\n * @see {@link decodeBase64Url} to decode to `Uint8Array` instead\n * @see {@link encodeBase64Url} for the inverse operation\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeBase64UrlString() {\n return transformEffect((input, options) => Result.match(Encoding.decodeBase64UrlString(input), {\n onFailure: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid Base64Url string\"\n }, input, options)),\n onSuccess: Effect.succeed\n }));\n}\n/**\n * Decodes a hexadecimal string to a `Uint8Array`.\n *\n * **Details**\n *\n * - Fails with `SchemaIssue.InvalidValue` if the input is not valid hex.\n *\n * **Example** (Decoding hex to bytes)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const decode = SchemaGetter.decodeHex()\n * const result = await Effect.runPromise(decode.run(Option.some(\"010203\"), {}))\n * Option.map(result, Array.from) // => Option.some([1, 2, 3])\n * ```\n *\n * @see {@link decodeHexString} to decode to `string` instead\n * @see {@link encodeHex} for the inverse operation\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeHex() {\n return transformEffect((input, options) => Result.match(Encoding.decodeHex(input), {\n onFailure: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid hexadecimal string\"\n }, input, options)),\n onSuccess: Effect.succeed\n }));\n}\n/**\n * Decodes a hexadecimal string to a UTF-8 `string`.\n *\n * **Details**\n *\n * - Fails with `SchemaIssue.InvalidValue` if the input is not valid hex.\n *\n * **Example** (Decoding hex to string)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const decode = SchemaGetter.decodeHexString()\n * await Effect.runPromise(decode.run(Option.some(\"68656c6c6f\"), {})) // => Option.some(\"hello\")\n * ```\n *\n * @see {@link decodeHex} to decode to `Uint8Array` instead\n * @see {@link encodeHex} for the inverse operation\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeHexString() {\n return transformEffect((input, options) => Result.match(Encoding.decodeHexString(input), {\n onFailure: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid hexadecimal string\"\n }, input, options)),\n onSuccess: Effect.succeed\n }));\n}\n/**\n * Encodes a present string using `encodeURIComponent`.\n *\n * **Details**\n *\n * - Skips `None` inputs.\n * - May throw a `URIError` for malformed surrogate pairs; this exception is not\n * converted into an `Issue`.\n *\n * **Example** (Encoding a URI component)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const encode = SchemaGetter.encodeUriComponent()\n * await Effect.runPromise(encode.run(Option.some(\"hello world\"), {})) // => Option.some(\"hello%20world\")\n * ```\n *\n * @see {@link decodeUriComponent} for the inverse operation\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeUriComponent() {\n return transform(encodeURIComponent);\n}\n/**\n * Decodes a URI component encoded string using `decodeURIComponent`.\n *\n * **Details**\n *\n * - Fails with `SchemaIssue.InvalidValue` if the input contains malformed percent-encoding sequences.\n *\n * **Example** (Decoding a URI component)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const decode = SchemaGetter.decodeUriComponent()\n * await Effect.runPromise(decode.run(Option.some(\"hello%20world\"), {})) // => Option.some(\"hello world\")\n * ```\n *\n * @see {@link encodeUriComponent} for the inverse operation\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeUriComponent() {\n return transformEffect((input, options) => {\n try {\n return Effect.succeed(globalThis.decodeURIComponent(input));\n } catch {\n return Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid URI component\"\n }, input, options));\n }\n });\n}\n/**\n * Parses a `DateTime.Input` value into a `DateTime.Utc`.\n *\n * **When to use**\n *\n * Use when you need a schema getter to decode a present encoded date/time value\n * to a `DateTime.Utc`.\n *\n * **Details**\n *\n * - Accepted input includes existing `DateTime` values, partial date/time parts,\n * instant objects, zoned instant objects, JavaScript `Date` instances, epoch\n * milliseconds, and date strings.\n * - Converts successfully parsed values to UTC.\n * - Fails with `SchemaIssue.InvalidValue` if the input cannot be parsed as a valid\n * `DateTime`.\n *\n * **Example** (Parsing DateTime)\n *\n * ```ts import.meta.vitest\n * import { DateTime, Effect, Option, SchemaGetter } from \"effect\"\n *\n * const parseDate = SchemaGetter.dateTimeUtcFromInput()\n * const result = await Effect.runPromise(parseDate.run(Option.some(\"2024-01-01T00:00:00Z\"), {}))\n * Option.map(result, DateTime.toEpochMillis) // => Option.some(1704067200000)\n * ```\n *\n * @see {@link Date} for a simpler coercion to `Date` (no validation)\n *\n * @category converting\n * @since 4.0.0\n */\nexport function dateTimeUtcFromInput() {\n return transformEffect((input, options) => {\n return Option.match(DateTime.make(input), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n message: \"Invalid DateTime input\"\n }, input, options)),\n onSome: dt => Effect.succeed(DateTime.toUtc(dt))\n });\n });\n}\n/**\n * Decodes a `FormData` object into a nested tree structure using bracket-path notation.\n *\n * **When to use**\n *\n * Use when you need a schema getter to parse `FormData` from HTTP requests into\n * structured objects.\n *\n * **Details**\n *\n * The getter is pure and never fails. It interprets bracket-path keys such as\n * `user[name]` and `items[0]` to build nested objects or arrays, and each leaf\n * value is a `string` or `Blob`.\n *\n * **Example** (Decoding FormData)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const decode = SchemaGetter.decodeFormData()\n * const formData = new FormData()\n * formData.append(\"user[name]\", \"Alice\")\n * await Effect.runPromise(decode.run(Option.some(formData), {})) // => Option.some({ user: { name: \"Alice\" } })\n * ```\n *\n * @see {@link encodeFormData} for the corresponding encoder\n * @see {@link makeTreeRecord} for the underlying bracket-path parser\n * @see {@link decodeURLSearchParams} for the URLSearchParams variant\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeFormData() {\n return transform(input => makeTreeRecord(Array.from(input.entries())));\n}\nconst collectFormDataEntries = /*#__PURE__*/collectBracketPathEntries(value => typeof value === \"string\" || typeof Blob !== \"undefined\" && value instanceof Blob);\n/**\n * Encodes a nested object into a `FormData` instance using bracket-path notation.\n *\n * **When to use**\n *\n * Use when you need a schema getter to serialize structured data to `FormData`\n * for HTTP requests.\n *\n * **Details**\n *\n * The getter is pure and never fails. It flattens nested objects or arrays into\n * bracket-path keys such as `user[name]` and `items[0]`. Non-object inputs\n * produce an empty `FormData`.\n *\n * **Example** (Encoding to FormData)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const encode = SchemaGetter.encodeFormData()\n * const result = await Effect.runPromise(encode.run(Option.some({ name: \"Alice\" }), {}))\n * Option.map(result, (formData) => formData.get(\"name\")) // => Option.some(\"Alice\")\n * ```\n *\n * @see {@link decodeFormData} for the corresponding decoder\n * @see {@link collectBracketPathEntries} for the underlying flattener\n * @see {@link encodeURLSearchParams} for the URLSearchParams variant\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeFormData() {\n return transform(input => {\n const out = new FormData();\n if (typeof input === \"object\" && input !== null) {\n const entries = collectFormDataEntries(input);\n entries.forEach(([key, value]) => {\n out.append(key, value);\n });\n }\n return out;\n });\n}\n/**\n * Decodes a `URLSearchParams` object into a nested tree structure using bracket-path notation.\n *\n * **When to use**\n *\n * Use when you need a schema getter to parse query parameters from URLs into\n * structured objects.\n *\n * **Details**\n *\n * The getter is pure and never fails. It interprets bracket-path keys such as\n * `user[name]` and `items[0]` to build nested objects or arrays, and each leaf\n * value is a `string`.\n *\n * **Example** (Decoding URLSearchParams)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const decode = SchemaGetter.decodeURLSearchParams()\n * const params = new URLSearchParams(\"user[name]=Alice\")\n * await Effect.runPromise(decode.run(Option.some(params), {})) // => Option.some({ user: { name: \"Alice\" } })\n * ```\n *\n * @see {@link encodeURLSearchParams} for the corresponding encoder\n * @see {@link makeTreeRecord} for the underlying bracket-path parser\n * @see {@link decodeFormData} for the FormData variant\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeURLSearchParams() {\n return transform(input => makeTreeRecord(Array.from(input.entries())));\n}\nconst collectURLSearchParamsEntries = /*#__PURE__*/collectBracketPathEntries(Predicate.isString);\n/**\n * Encodes a nested object into a `URLSearchParams` instance using bracket-path notation.\n *\n * **When to use**\n *\n * Use when you need a schema getter to serialize structured data to query\n * parameters for URLs.\n *\n * **Details**\n *\n * The getter is pure and never fails. It flattens nested objects or arrays into\n * bracket-path keys. Non-object inputs produce an empty `URLSearchParams`.\n *\n * **Example** (Encoding to URLSearchParams)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, SchemaGetter } from \"effect\"\n *\n * const encode = SchemaGetter.encodeURLSearchParams()\n * const result = await Effect.runPromise(encode.run(Option.some({ name: \"Alice\" }), {}))\n * Option.map(result, (params) => params.toString()) // => Option.some(\"name=Alice\")\n * ```\n *\n * @see {@link decodeURLSearchParams} for the corresponding decoder\n * @see {@link collectBracketPathEntries} for the underlying flattener\n * @see {@link encodeFormData} for the FormData variant\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeURLSearchParams() {\n return transform(input => {\n if (typeof input === \"object\" && input !== null) {\n return new URLSearchParams(collectURLSearchParamsEntries(input));\n }\n return new URLSearchParams();\n });\n}\nfunction bracketPathToTokens(bracketPath) {\n // real empty path (from append(\"\", value))\n if (bracketPath === \"\") {\n return [\"\"];\n }\n const replaced = bracketPath.replace(/\\[(.*?)\\]/g, \".$1\");\n const parts = replaced.split(\".\");\n // if bracket path started with \"[...]\" we get \".foo\" => [\"\", \"foo\"]; drop the synthetic first \"\"\n const start = replaced.startsWith(\".\") ? 1 : 0;\n return parts.slice(start).map(part => Arr.isCanonicalArrayIndex(part) ? globalThis.Number(part) : part);\n}\n/**\n * Builds a nested tree object from a list of bracket-path entries.\n *\n * **When to use**\n *\n * Use when you need a schema getter to parse FormData or URLSearchParams\n * entries into structured objects.\n * - You have flat key-value pairs with bracket-path keys that need nesting.\n *\n * **Details**\n *\n * - A bracket path is a string like `\"user[address][city]\"` that describes nested\n * object/array structure.\n * - Interprets bracket paths and constructs the corresponding nested object.\n * - Builds and returns a nested object from the input entries.\n * - Supported syntax:\n * - `\"foo\"` → object key `\"foo\"`\n * - `\"foo[bar]\"` → nested `{ foo: { bar: ... } }`\n * - `\"foo[0]\"` → array index `{ foo: [value] }`\n * - `\"foo[]\"` → append to array `foo`\n * - `\"\"` → real empty key\n * - Numeric bracket segments become array indices only when they are valid\n * JavaScript array-index strings; otherwise they remain object keys.\n * - Duplicate keys for the same path are merged into arrays.\n * - If a structural path conflicts with a previous leaf or a different container\n * type, the later structural path replaces the conflicting value.\n * - The notation has no escaping for `.`, `[` or `]`, so keys containing these\n * delimiters cannot be round-tripped without changing their structure.\n *\n * **Example** (Building a tree from bracket paths)\n *\n * ```ts import.meta.vitest\n * import { SchemaGetter } from \"effect\"\n *\n * SchemaGetter.makeTreeRecord([\n * [\"user[name]\", \"Alice\"],\n * [\"user[tags][]\", \"admin\"],\n * [\"user[tags][]\", \"editor\"]\n * ]) // => { user: { name: \"Alice\", tags: [\"admin\", \"editor\"] } }\n * ```\n *\n * @see {@link collectBracketPathEntries} for flattening trees into bracket-path entries\n * @see {@link decodeFormData} for a higher-level FormData decoder\n * @see {@link decodeURLSearchParams} for a higher-level URLSearchParams decoder\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeTreeRecord(bracketPathEntries) {\n const out = {};\n const containers = new WeakSet();\n const duplicates = new WeakSet();\n function getOrCreateContainer(self, key, shouldBeArray) {\n const current = Object.hasOwn(self, key) ? self[key] : undefined;\n if (containers.has(current) && Array.isArray(current) === shouldBeArray) {\n return current;\n }\n const container = shouldBeArray ? [] : {};\n containers.add(container);\n InternalRecord.assignProperty(self, key, container);\n return container;\n }\n bracketPathEntries.forEach(([key, value]) => {\n const tokens = bracketPathToTokens(key);\n let cur = out;\n tokens.forEach((token, i) => {\n const isLast = i === tokens.length - 1;\n // We are inside an array and see \"[]\" (empty token) => append\n if (Array.isArray(cur) && token === \"\") {\n if (isLast) {\n cur.push(value);\n } else {\n // bracket path: \"foo[][bar]\" => push a new element and descend into it\n const next = tokens[i + 1];\n const shouldBeArray = typeof next === \"number\" || next === \"\";\n const index = cur.length;\n cur = getOrCreateContainer(cur, index, shouldBeArray);\n }\n } else if (isLast) {\n // If we're setting a value at a path that already exists\n // convert it to an array to support multiple values for the same key\n const hasOwn = Object.hasOwn(cur, token);\n if (hasOwn && Array.isArray(cur[token]) && (containers.has(cur[token]) || duplicates.has(cur[token]))) {\n cur[token].push(value);\n } else if (hasOwn) {\n const values = [cur[token], value];\n duplicates.add(values);\n InternalRecord.assignProperty(cur, token, values);\n } else {\n InternalRecord.assignProperty(cur, token, value);\n }\n } else {\n const next = tokens[i + 1];\n // if next is a number OR \"\" (from []), we are building an array\n const shouldBeArray = typeof next === \"number\" || next === \"\";\n cur = getOrCreateContainer(cur, token, shouldBeArray);\n }\n });\n });\n return out;\n}\n/**\n * Flattens a nested object into bracket-path entries, filtering leaf values by a type guard.\n *\n * **When to use**\n *\n * Use when you need a schema getter to serialize structured objects to flat\n * key-value entries.\n * - Building custom `FormData` or `URLSearchParams` encoders.\n *\n * **Details**\n *\n * - Takes a nested object and produces flat `[bracketPath, value]` pairs suitable for\n * `FormData` or `URLSearchParams`.\n * - Returns a curried function: first call provides the leaf type guard, second call provides the object.\n * - Recursively traverses objects and arrays.\n * - If all elements of an array are leaves, encodes them as multiple entries with the same key\n * (e.g. `tags=a&tags=b`). Otherwise uses indexed bracket paths (e.g. `items[0]`, `items[1]`).\n * - Non-leaf values that aren't objects or arrays are silently skipped.\n * - Empty arrays and objects produce no entries, and path delimiters in property\n * names are not escaped. The resulting format is therefore lossy.\n *\n * **Example** (Flattening an object to bracket paths)\n *\n * ```ts import.meta.vitest\n * import { Predicate, SchemaGetter } from \"effect\"\n *\n * const collectStrings = SchemaGetter.collectBracketPathEntries(Predicate.isString)\n * const entries = collectStrings({ user: { name: \"Alice\", tags: [\"admin\", \"editor\"] } })\n *\n * entries // => [[\"user[name]\", \"Alice\"], [\"user[tags]\", \"admin\"], [\"user[tags]\", \"editor\"]]\n * ```\n *\n * @see {@link makeTreeRecord} for building trees from bracket-path entries\n * @see {@link encodeFormData} for a higher-level FormData encoder\n * @see {@link encodeURLSearchParams} for a higher-level URLSearchParams encoder\n *\n * @category converting\n * @since 4.0.0\n */\nexport function collectBracketPathEntries(isLeaf) {\n return input => {\n const bracketPathEntries = [];\n function append(key, value) {\n if (isLeaf(value)) {\n bracketPathEntries.push([key, value]);\n } else if (Array.isArray(value)) {\n // If all values are leaves, encode as multiple entries with the same key\n const allLeaves = value.every(isLeaf);\n if (allLeaves) {\n value.forEach(v => {\n bracketPathEntries.push([key, v]);\n });\n } else {\n value.forEach((v, i) => {\n append(`${key}[${i}]`, v);\n });\n }\n } else if (typeof value === \"object\" && value !== null) {\n for (const [k, v] of Object.entries(value)) {\n append(`${key}[${k}]`, v);\n }\n }\n }\n for (const [key, value] of Object.entries(input)) {\n append(key, value);\n }\n return bracketPathEntries;\n };\n}\n//# sourceMappingURL=SchemaGetter.js.map","/**\n * Decimal numbers and arithmetic for cases where JavaScript `number` rounding\n * is not precise enough. A `BigDecimal` stores digits as a `bigint` plus a\n * decimal scale, which lets the module parse, compare, add, subtract, multiply,\n * divide, round, and format decimal values such as money, quantities, and\n * measurements.\n *\n * @since 2.0.0\n */\nimport * as Equal from \"./Equal.js\";\nimport * as Equ from \"./Equivalence.js\";\nimport { dual } from \"./Function.js\";\nimport * as Hash from \"./Hash.js\";\nimport { NodeInspectSymbol } from \"./Inspectable.js\";\nimport * as Option from \"./Option.js\";\nimport * as order from \"./Order.js\";\nimport { pipeArguments } from \"./Pipeable.js\";\nimport { hasProperty } from \"./Predicate.js\";\nconst DEFAULT_PRECISION = 100;\nconst FINITE_INT_REGEXP = /^[+-]?\\d+$/;\nconst TypeId = \"~effect/BigDecimal\";\nconst BigDecimalProto = {\n [TypeId]: TypeId,\n [Hash.symbol]() {\n const normalized = normalize(this);\n return Hash.combine(Hash.hash(normalized.value), Hash.number(normalized.scale));\n },\n [Equal.symbol](that) {\n return isBigDecimal(that) && equals(this, that);\n },\n toString() {\n return `BigDecimal(${format(this)})`;\n },\n toJSON() {\n return {\n _id: \"BigDecimal\",\n value: String(this.value),\n scale: this.scale\n };\n },\n [NodeInspectSymbol]() {\n return this.toJSON();\n },\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n/**\n * Checks whether a given value is a `BigDecimal`.\n *\n * **When to use**\n *\n * Use to validate unknown input and narrow it to `BigDecimal`.\n *\n * **Example** (Checking BigDecimal values)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const decimal = BigDecimal.fromNumber(123.45)\n * BigDecimal.isBigDecimal(decimal) // => false\n * BigDecimal.isBigDecimal(BigDecimal.fromStringUnsafe(\"123.45\")) // => true\n * BigDecimal.isBigDecimal(123.45) // => false\n * BigDecimal.isBigDecimal(\"123.45\") // => false\n * ```\n *\n * @category guards\n * @since 2.0.0\n */\nexport const isBigDecimal = u => hasProperty(u, TypeId);\n/**\n * Creates a `BigDecimal` from a `bigint` value and a safe integer scale.\n *\n * **When to use**\n *\n * Use to construct a decimal directly from its unscaled integer value and\n * decimal scale.\n *\n * **Gotchas**\n *\n * Throws a `RangeError` if `scale` is not a safe integer.\n *\n * **Example** (Creating decimals from bigint and scale)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * // Create 123.45 (12345 with scale 2)\n * const decimal = BigDecimal.make(12345n, 2)\n * decimal // => BigDecimal.fromStringUnsafe(\"123.45\")\n *\n * // Create 42 (42 with scale 0)\n * const integer = BigDecimal.make(42n, 0)\n * integer // => BigDecimal.fromBigInt(42n)\n * ```\n *\n * @see {@link fromBigInt} for constructing an integer decimal from a `bigint`\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const make = (value, scale) => {\n if (!Number.isSafeInteger(scale)) {\n throw new RangeError(`Scale must be a safe integer, got ${scale}`);\n }\n const o = Object.create(BigDecimalProto);\n o.value = value;\n o.scale = scale;\n return o;\n};\n/**\n * Internal function used to create pre-normalized `BigDecimal`s.\n *\n * @internal\n */\nexport const makeNormalizedUnsafe = (value, scale) => {\n if (value !== bigint0 && value % bigint10 === bigint0) {\n throw new RangeError(\"Value must be normalized\");\n }\n const o = make(value, scale);\n o.normalized = o;\n return o;\n};\nconst bigint0 = /*#__PURE__*/BigInt(0);\nconst bigint1 = /*#__PURE__*/BigInt(1);\nconst bigint_1 = /*#__PURE__*/BigInt(-1);\nconst bigint2 = /*#__PURE__*/BigInt(2);\nconst bigint5 = /*#__PURE__*/BigInt(5);\nconst bigint_5 = /*#__PURE__*/BigInt(-5);\nconst bigint10 = /*#__PURE__*/BigInt(10);\nconst zero = /*#__PURE__*/makeNormalizedUnsafe(bigint0, 0);\nconst one = /*#__PURE__*/makeNormalizedUnsafe(bigint1, 0);\n/**\n * Normalizes a given `BigDecimal` by removing trailing zeros.\n *\n * **When to use**\n *\n * Use to canonicalize decimals that have equivalent values but different\n * internal scales.\n *\n * **Example** (Normalizing trailing zeros)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const decimal = BigDecimal.normalize(BigDecimal.fromStringUnsafe(\"123.00000\"))\n * const decimalStorage = [decimal.value, decimal.scale] // => [123n, 0]\n *\n * const largeDecimal = BigDecimal.normalize(BigDecimal.fromStringUnsafe(\"12300000\"))\n * const largeDecimalStorage = [largeDecimal.value, largeDecimal.scale] // => [123n, -5]\n * ```\n *\n * @see {@link format} for rendering normalized decimals as strings\n *\n * @category scaling\n * @since 2.0.0\n */\nexport const normalize = self => {\n if (self.normalized === undefined) {\n if (self.value === bigint0) {\n self.normalized = zero;\n } else {\n const digits = `${self.value}`;\n let trail = 0;\n for (let i = digits.length - 1; i >= 0; i--) {\n if (digits[i] === \"0\") {\n trail++;\n } else {\n break;\n }\n }\n if (trail === 0) {\n self.normalized = self;\n }\n const value = BigInt(digits.substring(0, digits.length - trail));\n const scale = self.scale - trail;\n self.normalized = makeNormalizedUnsafe(value, scale);\n }\n }\n return self.normalized;\n};\n/**\n * Changes a `BigDecimal` to the specified scale.\n *\n * **When to use**\n *\n * Use to change how many decimal places are represented by a `BigDecimal`.\n *\n * **Details**\n *\n * Increasing the scale appends decimal zeros. Decreasing the scale discards\n * digits beyond the target scale by `bigint` division, which truncates toward\n * zero.\n *\n * **Example** (Scaling decimal precision)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const decimal = BigDecimal.fromNumberUnsafe(123.45)\n *\n * // Increase scale (add more precision)\n * const scaled = BigDecimal.scale(decimal, 4)\n * const scaledStorage = [scaled.value, scaled.scale] // => [1234500n, 4]\n *\n * // Decrease scale (reduce precision, truncating toward zero)\n * const reduced = BigDecimal.scale(decimal, 1)\n * reduced // => BigDecimal.fromStringUnsafe(\"123.4\")\n * ```\n *\n * @see {@link round} for changing scale with configurable rounding\n *\n * @category scaling\n * @since 2.0.0\n */\nexport const scale = /*#__PURE__*/dual(2, (self, scale) => {\n if (scale > self.scale) {\n return make(self.value * bigint10 ** BigInt(scale - self.scale), scale);\n }\n if (scale < self.scale) {\n return make(self.value / bigint10 ** BigInt(self.scale - scale), scale);\n }\n return self;\n});\n/**\n * Provides an addition operation on `BigDecimal`s.\n *\n * **When to use**\n *\n * Use when you need a decimal addition function for piping or higher-order APIs\n * while preserving decimal precision.\n *\n * **Example** (Adding decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const result = BigDecimal.sum(\n * BigDecimal.fromStringUnsafe(\"2\"),\n * BigDecimal.fromStringUnsafe(\"3\")\n * ) // => BigDecimal.fromBigInt(5n)\n * ```\n *\n * @see {@link sumAll} for summing an iterable of `BigDecimal` values\n *\n * @category math\n * @since 2.0.0\n */\nexport const sum = /*#__PURE__*/dual(2, (self, that) => {\n if (that.value === bigint0) {\n return self;\n }\n if (self.value === bigint0) {\n return that;\n }\n if (self.scale > that.scale) {\n return make(scale(that, self.scale).value + self.value, self.scale);\n }\n if (self.scale < that.scale) {\n return make(scale(self, that.scale).value + that.value, that.scale);\n }\n return make(self.value + that.value, self.scale);\n});\n/**\n * Takes an `Iterable` of `BigDecimal`s and returns their sum as a single `BigDecimal`.\n *\n * **When to use**\n *\n * Use when you need to aggregate decimal quantities with decimal precision\n * instead of converting through JavaScript numbers.\n *\n * **Example** (Adding multiple decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const result = BigDecimal.sumAll([\n * BigDecimal.fromStringUnsafe(\"2\"),\n * BigDecimal.fromStringUnsafe(\"3\"),\n * BigDecimal.fromStringUnsafe(\"4\")\n * ]) // => BigDecimal.fromBigInt(9n)\n * ```\n *\n * @see {@link sum} for adding two `BigDecimal` values\n *\n * @category math\n * @since 3.16.0\n */\nexport const sumAll = collection => {\n let out = zero;\n for (const n of collection) {\n out = sum(out, n);\n }\n return out;\n};\n/**\n * Provides a multiplication operation on `BigDecimal`s.\n *\n * **When to use**\n *\n * Use to multiply two `BigDecimal` values.\n *\n * **Example** (Multiplying decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const result = BigDecimal.multiply(\n * BigDecimal.fromStringUnsafe(\"2\"),\n * BigDecimal.fromStringUnsafe(\"3\")\n * ) // => BigDecimal.fromBigInt(6n)\n * ```\n *\n * @see {@link multiplyAll} for multiplying an iterable of `BigDecimal` values\n *\n * @category math\n * @since 2.0.0\n */\nexport const multiply = /*#__PURE__*/dual(2, (self, that) => {\n if (that.value === bigint0 || self.value === bigint0) {\n return zero;\n }\n return make(self.value * that.value, self.scale + that.scale);\n});\n/**\n * Takes an `Iterable` of `BigDecimal`s and returns their multiplication as a single `BigDecimal`.\n *\n * **When to use**\n *\n * Use to multiply all `BigDecimal` values in an iterable.\n *\n * **Example** (Multiplying multiple decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const result = BigDecimal.multiplyAll([\n * BigDecimal.fromStringUnsafe(\"2\"),\n * BigDecimal.fromStringUnsafe(\"3\"),\n * BigDecimal.fromStringUnsafe(\"4\")\n * ]) // => BigDecimal.fromBigInt(24n)\n * ```\n *\n * @see {@link multiply} for multiplying two `BigDecimal` values\n *\n * @category math\n * @since 4.0.0\n */\nexport const multiplyAll = collection => {\n let out = one;\n for (const n of collection) {\n if (n.value === bigint0) {\n return zero;\n }\n out = multiply(out, n);\n }\n return out;\n};\n/**\n * Provides a subtraction operation on `BigDecimal`s.\n *\n * **When to use**\n *\n * Use to subtract one `BigDecimal` value from another.\n *\n * **Example** (Subtracting decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const result = BigDecimal.subtract(\n * BigDecimal.fromStringUnsafe(\"2\"),\n * BigDecimal.fromStringUnsafe(\"3\")\n * ) // => BigDecimal.fromBigInt(-1n)\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const subtract = /*#__PURE__*/dual(2, (self, that) => {\n if (that.value === bigint0) {\n return self;\n }\n if (self.value === bigint0) {\n return make(-that.value, that.scale);\n }\n if (self.scale > that.scale) {\n return make(self.value - scale(that, self.scale).value, self.scale);\n }\n if (self.scale < that.scale) {\n return make(scale(self, that.scale).value - that.value, that.scale);\n }\n return make(self.value - that.value, self.scale);\n});\n/**\n * Internal function used for arbitrary precision division.\n */\nconst divideWithPrecision = (num, den, scale, precision) => {\n const numNegative = num < bigint0;\n const denNegative = den < bigint0;\n const negateResult = numNegative !== denNegative;\n num = numNegative ? -num : num;\n den = denNegative ? -den : den;\n // Shift digits until numerator is larger than denominator (set scale appropriately).\n while (num < den) {\n num *= bigint10;\n scale++;\n }\n // First division.\n let quotient = num / den;\n let remainder = num % den;\n if (remainder === bigint0) {\n // No remainder, return immediately.\n return make(negateResult ? -quotient : quotient, scale);\n }\n // The quotient is guaranteed to be non-negative at this point. No need to consider sign.\n let count = `${quotient}`.length;\n // Shift the remainder by 1 decimal; The quotient will be 1 digit upon next division.\n remainder *= bigint10;\n while (remainder !== bigint0 && count < precision) {\n const q = remainder / den;\n const r = remainder % den;\n quotient = quotient * bigint10 + q;\n remainder = r * bigint10;\n count++;\n scale++;\n }\n if (remainder !== bigint0) {\n // Round final number with remainder.\n quotient += roundTerminal(remainder / den);\n }\n return make(negateResult ? -quotient : quotient, scale);\n};\n/**\n * Internal function used for rounding.\n *\n * Returns 1 if the most significant digit is >= 5, otherwise 0.\n *\n * This is used after dividing a number by a power of ten and rounding the last digit.\n *\n * @internal\n */\nexport const roundTerminal = n => {\n const pos = n >= bigint0 ? 0 : 1;\n return Number(`${n}`[pos]) < 5 ? bigint0 : bigint1;\n};\n/**\n * Divides `BigDecimal`s safely.\n *\n * **When to use**\n *\n * Use to divide `BigDecimal` values while representing division by zero as\n * `Option.none`.\n *\n * **Details**\n *\n * If the dividend is not a multiple of the divisor, the result will be a `BigDecimal` value\n * with up to the default division precision. If the divisor is `0`, the result\n * will be `Option.none()`.\n *\n * **Example** (Dividing decimals safely)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal, Option } from \"effect\"\n *\n * const six = BigDecimal.fromBigInt(6n)\n *\n * BigDecimal.divide(six, BigDecimal.fromBigInt(3n)) // => Option.some(BigDecimal.fromBigInt(2n))\n * BigDecimal.divide(six, BigDecimal.fromBigInt(4n)) // => Option.some(BigDecimal.fromStringUnsafe(\"1.5\"))\n * BigDecimal.divide(six, BigDecimal.fromBigInt(0n)) // => Option.none()\n * ```\n *\n * @see {@link divideUnsafe} for division that throws when the divisor is zero\n * @see {@link remainder} for the decimal remainder operation\n *\n * @category math\n * @since 2.0.0\n */\nexport const divide = /*#__PURE__*/dual(2, (self, that) => {\n if (that.value === bigint0) {\n return Option.none();\n }\n if (self.value === bigint0) {\n return Option.some(zero);\n }\n const scale = self.scale - that.scale;\n if (self.value === that.value) {\n return Option.some(make(bigint1, scale));\n }\n return Option.some(divideWithPrecision(self.value, that.value, scale, DEFAULT_PRECISION));\n});\n/**\n * Provides an unsafe division operation on `BigDecimal`s.\n *\n * **When to use**\n *\n * Use when you need to divide `BigDecimal` values where the divisor is known\n * to be non-zero, so division by zero should be a thrown exception.\n *\n * **Details**\n *\n * If the dividend is not a multiple of the divisor, the result will be a `BigDecimal` value\n * with up to the default division precision.\n *\n * **Gotchas**\n *\n * Throws a `RangeError` if the divisor is `0`.\n *\n * **Example** (Dividing decimals unsafely)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe(\"6\"), BigDecimal.fromStringUnsafe(\"3\")) // => BigDecimal.fromBigInt(2n)\n * BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe(\"6\"), BigDecimal.fromStringUnsafe(\"4\")) // => BigDecimal.fromStringUnsafe(\"1.5\")\n * ```\n *\n * @see {@link divide} for division that returns `Option.none` when the divisor is zero\n *\n * @category math\n * @since 4.0.0\n */\nexport const divideUnsafe = /*#__PURE__*/dual(2, (self, that) => {\n if (that.value === bigint0) {\n throw new RangeError(\"Division by zero\");\n }\n if (self.value === bigint0) {\n return zero;\n }\n const scale = self.scale - that.scale;\n if (self.value === that.value) {\n return make(bigint1, scale);\n }\n return divideWithPrecision(self.value, that.value, scale, DEFAULT_PRECISION);\n});\nconst MAX_COMPARISON_SCALE_ALIGNMENT = 100;\nconst comparisonPowersOfTen = [bigint1];\nconst compareBigInt = (self, that) => self === that ? 0 : self < that ? -1 : 1;\nconst compareMagnitude = (self, that) => {\n const selfDigits = `${self.value < bigint0 ? -self.value : self.value}`;\n const thatDigits = `${that.value < bigint0 ? -that.value : that.value}`;\n const exponentDifference = BigInt(selfDigits.length - thatDigits.length) - BigInt(self.scale) + BigInt(that.scale);\n if (exponentDifference !== bigint0) return exponentDifference < bigint0 ? -1 : 1;\n const length = Math.max(selfDigits.length, thatDigits.length);\n for (let i = 0; i < length; i++) {\n const selfDigit = i < selfDigits.length ? selfDigits.charCodeAt(i) : 48;\n const thatDigit = i < thatDigits.length ? thatDigits.charCodeAt(i) : 48;\n if (selfDigit !== thatDigit) return selfDigit < thatDigit ? -1 : 1;\n }\n return 0;\n};\nconst compare = (self, that) => {\n if (self.scale === that.scale) return compareBigInt(self.value, that.value);\n const selfSign = sign(self);\n const thatSign = sign(that);\n if (selfSign !== thatSign) return selfSign < thatSign ? -1 : 1;\n if (selfSign === 0) return 0;\n const scaleDifference = self.scale - that.scale;\n const absoluteScaleDifference = Math.abs(scaleDifference);\n if (absoluteScaleDifference > MAX_COMPARISON_SCALE_ALIGNMENT) {\n return selfSign === -1 ? compareMagnitude(that, self) : compareMagnitude(self, that);\n }\n const powerOfTen = comparisonPowersOfTen[absoluteScaleDifference] ??= bigint10 ** BigInt(absoluteScaleDifference);\n return scaleDifference > 0 ? compareBigInt(self.value, that.value * powerOfTen) : compareBigInt(self.value * powerOfTen, that.value);\n};\n/**\n * Provides an `Order` instance for `BigDecimal` that allows comparing and sorting BigDecimal values.\n *\n * **When to use**\n *\n * Use when you need to sort or compare decimal values through APIs that accept\n * an ordering instance.\n *\n * **Example** (Comparing decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const a = BigDecimal.fromNumberUnsafe(1.5)\n * const b = BigDecimal.fromNumberUnsafe(2.3)\n * const c = BigDecimal.fromNumberUnsafe(1.5)\n *\n * BigDecimal.Order(a, b) // => -1\n * BigDecimal.Order(b, a) // => 1\n * BigDecimal.Order(a, c) // => 0\n * ```\n *\n * @category instances\n * @since 2.0.0\n */\nexport const Order = /*#__PURE__*/order.make(compare);\n/**\n * Returns `true` if the first argument is less than the second, otherwise `false`.\n *\n * **When to use**\n *\n * Use to test whether one `BigDecimal` is strictly less than another.\n *\n * **Example** (Checking less-than comparisons)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const two = BigDecimal.fromStringUnsafe(\"2\")\n * const three = BigDecimal.fromStringUnsafe(\"3\")\n * const four = BigDecimal.fromStringUnsafe(\"4\")\n *\n * BigDecimal.isLessThan(two, three) // => true\n * BigDecimal.isLessThan(three, three) // => false\n * BigDecimal.isLessThan(four, three) // => false\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isLessThan = /*#__PURE__*/order.isLessThan(Order);\n/**\n * Checks whether a given `BigDecimal` is less than or equal to the provided one.\n *\n * **When to use**\n *\n * Use to test whether one `BigDecimal` is less than or equal to another.\n *\n * **Example** (Checking less-than-or-equal comparisons)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const two = BigDecimal.fromStringUnsafe(\"2\")\n * const three = BigDecimal.fromStringUnsafe(\"3\")\n * const four = BigDecimal.fromStringUnsafe(\"4\")\n *\n * BigDecimal.isLessThanOrEqualTo(two, three) // => true\n * BigDecimal.isLessThanOrEqualTo(three, three) // => true\n * BigDecimal.isLessThanOrEqualTo(four, three) // => false\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isLessThanOrEqualTo = /*#__PURE__*/order.isLessThanOrEqualTo(Order);\n/**\n * Returns `true` if the first argument is greater than the second, otherwise `false`.\n *\n * **When to use**\n *\n * Use to test whether one `BigDecimal` is strictly greater than another.\n *\n * **Example** (Checking greater-than comparisons)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const two = BigDecimal.fromStringUnsafe(\"2\")\n * const three = BigDecimal.fromStringUnsafe(\"3\")\n * const four = BigDecimal.fromStringUnsafe(\"4\")\n *\n * BigDecimal.isGreaterThan(two, three) // => false\n * BigDecimal.isGreaterThan(three, three) // => false\n * BigDecimal.isGreaterThan(four, three) // => true\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isGreaterThan = /*#__PURE__*/order.isGreaterThan(Order);\n/**\n * Checks whether a given `BigDecimal` is greater than or equal to the provided one.\n *\n * **When to use**\n *\n * Use to test whether one `BigDecimal` is greater than or equal to another.\n *\n * **Example** (Checking greater-than-or-equal comparisons)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const two = BigDecimal.fromStringUnsafe(\"2\")\n * const three = BigDecimal.fromStringUnsafe(\"3\")\n * const four = BigDecimal.fromStringUnsafe(\"4\")\n *\n * BigDecimal.isGreaterThanOrEqualTo(two, three) // => false\n * BigDecimal.isGreaterThanOrEqualTo(three, three) // => true\n * BigDecimal.isGreaterThanOrEqualTo(four, three) // => true\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isGreaterThanOrEqualTo = /*#__PURE__*/order.isGreaterThanOrEqualTo(Order);\n/**\n * Checks whether a `BigDecimal` is between a `minimum` and `maximum` value (inclusive).\n *\n * **When to use**\n *\n * Use to test whether a `BigDecimal` falls inside an inclusive range.\n *\n * **Example** (Checking decimal ranges)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const between = BigDecimal.between({\n * minimum: BigDecimal.fromStringUnsafe(\"1\"),\n * maximum: BigDecimal.fromStringUnsafe(\"5\")\n * })\n *\n * between(BigDecimal.fromStringUnsafe(\"3\")) // => true\n * between(BigDecimal.fromStringUnsafe(\"0\")) // => false\n * between(BigDecimal.fromStringUnsafe(\"6\")) // => false\n * ```\n *\n * @see {@link clamp} for forcing a `BigDecimal` into an inclusive range\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const between = /*#__PURE__*/order.isBetween(Order);\n/**\n * Restricts the given `BigDecimal` to be within the range specified by the `minimum` and `maximum` values.\n *\n * **When to use**\n *\n * Use to force a `BigDecimal` into an inclusive range.\n *\n * **Details**\n *\n * If the `BigDecimal` is less than the `minimum` value, the function returns\n * the `minimum` value. If it is greater than the `maximum` value, the function\n * returns the `maximum` value. Otherwise, it returns the original `BigDecimal`.\n *\n * **Example** (Clamping decimals to a range)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const clamp = BigDecimal.clamp({\n * minimum: BigDecimal.fromStringUnsafe(\"1\"),\n * maximum: BigDecimal.fromStringUnsafe(\"5\")\n * })\n *\n * clamp(BigDecimal.fromStringUnsafe(\"3\")) // => BigDecimal.fromBigInt(3n)\n * clamp(BigDecimal.fromStringUnsafe(\"0\")) // => BigDecimal.fromBigInt(1n)\n * clamp(BigDecimal.fromStringUnsafe(\"6\")) // => BigDecimal.fromBigInt(5n)\n * ```\n *\n * @see {@link between} for checking whether a `BigDecimal` is already inside a range\n *\n * @category math\n * @since 2.0.0\n */\nexport const clamp = /*#__PURE__*/order.clamp(Order);\n/**\n * Returns the minimum between two `BigDecimal`s.\n *\n * **When to use**\n *\n * Use to select the smaller of two `BigDecimal` values.\n *\n * **Example** (Selecting the smaller decimal)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const result = BigDecimal.min(\n * BigDecimal.fromStringUnsafe(\"2\"),\n * BigDecimal.fromStringUnsafe(\"3\")\n * ) // => BigDecimal.fromBigInt(2n)\n * ```\n *\n * @see {@link max} for selecting the larger value\n *\n * @category math\n * @since 2.0.0\n */\nexport const min = /*#__PURE__*/order.min(Order);\n/**\n * Returns the maximum between two `BigDecimal`s.\n *\n * **When to use**\n *\n * Use to select the larger of two `BigDecimal` values.\n *\n * **Example** (Selecting the larger decimal)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const result = BigDecimal.max(\n * BigDecimal.fromStringUnsafe(\"2\"),\n * BigDecimal.fromStringUnsafe(\"3\")\n * ) // => BigDecimal.fromBigInt(3n)\n * ```\n *\n * @see {@link min} for selecting the smaller value\n *\n * @category math\n * @since 2.0.0\n */\nexport const max = /*#__PURE__*/order.max(Order);\n/**\n * Determines the sign of a given `BigDecimal`.\n *\n * **When to use**\n *\n * Use to classify a `BigDecimal` as negative, zero, or positive.\n *\n * **Example** (Reading decimal signs)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.sign(BigDecimal.fromStringUnsafe(\"-5\")) // => -1\n * BigDecimal.sign(BigDecimal.fromStringUnsafe(\"0\")) // => 0\n * BigDecimal.sign(BigDecimal.fromStringUnsafe(\"5\")) // => 1\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const sign = n => n.value === bigint0 ? 0 : n.value < bigint0 ? -1 : 1;\n/**\n * Determines the absolute value of a given `BigDecimal`.\n *\n * **When to use**\n *\n * Use to remove the sign from a `BigDecimal` while preserving its magnitude.\n *\n * **Example** (Calculating absolute values)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.abs(BigDecimal.fromStringUnsafe(\"-5\")) // => BigDecimal.fromBigInt(5n)\n * BigDecimal.abs(BigDecimal.fromStringUnsafe(\"0\")) // => BigDecimal.fromBigInt(0n)\n * BigDecimal.abs(BigDecimal.fromStringUnsafe(\"5\")) // => BigDecimal.fromBigInt(5n)\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const abs = n => n.value < bigint0 ? make(-n.value, n.scale) : n;\n/**\n * Provides a negate operation on `BigDecimal`s.\n *\n * **When to use**\n *\n * Use to flip the sign of a `BigDecimal`.\n *\n * **Example** (Negating decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.negate(BigDecimal.fromStringUnsafe(\"3\")) // => BigDecimal.fromBigInt(-3n)\n * BigDecimal.negate(BigDecimal.fromStringUnsafe(\"-6\")) // => BigDecimal.fromBigInt(6n)\n * ```\n *\n * @category math\n * @since 2.0.0\n */\nexport const negate = n => make(-n.value, n.scale);\n/**\n * Computes the decimal remainder safely when one operand is divided by a second\n * operand.\n *\n * **When to use**\n *\n * Use to compute a decimal remainder while representing division by zero as\n * `Option.none`.\n *\n * **Details**\n *\n * If the divisor is `0`, the result will be `Option.none()`.\n *\n * **Example** (Computing remainders safely)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal, Option } from \"effect\"\n *\n * const two = BigDecimal.fromStringUnsafe(\"2\")\n * const three = BigDecimal.fromStringUnsafe(\"3\")\n * const zero = BigDecimal.fromStringUnsafe(\"0\")\n *\n * BigDecimal.remainder(three, two) // => Option.some(BigDecimal.fromBigInt(1n))\n * BigDecimal.remainder(two, zero) // => Option.none()\n * ```\n *\n * @see {@link remainderUnsafe} for remainder calculation that throws when the divisor is zero\n * @see {@link divide} for decimal quotient calculation\n *\n * @category math\n * @since 2.0.0\n */\nexport const remainder = /*#__PURE__*/dual(2, (self, divisor) => {\n if (divisor.value === bigint0) {\n return Option.none();\n }\n const max = Math.max(self.scale, divisor.scale);\n return Option.some(make(scale(self, max).value % scale(divisor, max).value, max));\n});\n/**\n * Returns the decimal remainder left over when one operand is divided by a\n * non-zero second operand.\n *\n * **When to use**\n *\n * Use when you need to compute a `BigDecimal` remainder with a divisor known to\n * be non-zero and want a plain `BigDecimal` result instead of an `Option`.\n *\n * **Gotchas**\n *\n * Throws a `RangeError` if the divisor is `0`.\n *\n * **Example** (Computing remainders unsafely)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.remainderUnsafe(\n * BigDecimal.fromStringUnsafe(\"3\"),\n * BigDecimal.fromStringUnsafe(\"2\")\n * ) // => BigDecimal.fromBigInt(1n)\n * ```\n *\n * @see {@link remainder} for returning `Option.none` when the divisor is zero\n *\n * @category math\n * @since 4.0.0\n */\nexport const remainderUnsafe = /*#__PURE__*/dual(2, (self, divisor) => {\n if (divisor.value === bigint0) {\n throw new RangeError(\"Division by zero\");\n }\n const max = Math.max(self.scale, divisor.scale);\n return make(scale(self, max).value % scale(divisor, max).value, max);\n});\n/**\n * Provides an `Equivalence` instance for `BigDecimal` that determines equality between BigDecimal values.\n *\n * **When to use**\n *\n * Use when comparing decimal values through APIs that accept an equivalence\n * relation.\n *\n * **Example** (Checking decimal equivalence)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const a = BigDecimal.fromStringUnsafe(\"1.50\")\n * const b = BigDecimal.fromStringUnsafe(\"1.5\")\n * const c = BigDecimal.fromStringUnsafe(\"2.0\")\n *\n * BigDecimal.Equivalence(a, b) // => true\n * BigDecimal.Equivalence(a, c) // => false\n * ```\n *\n * @category instances\n * @since 2.0.0\n */\nexport const Equivalence = /*#__PURE__*/Equ.make((self, that) => compare(self, that) === 0);\n/**\n * Checks whether two `BigDecimal`s are equal.\n *\n * **When to use**\n *\n * Use to compare two `BigDecimal` values for numeric equality.\n *\n * **Example** (Checking decimal equality)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const a = BigDecimal.fromStringUnsafe(\"1.5\")\n * const b = BigDecimal.fromStringUnsafe(\"1.50\")\n * const c = BigDecimal.fromStringUnsafe(\"2.0\")\n *\n * BigDecimal.equals(a, b) // => true\n * BigDecimal.equals(a, c) // => false\n * ```\n *\n * @see {@link Equivalence} for passing decimal equality to APIs that require an `Equivalence`\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const equals = /*#__PURE__*/dual(2, (self, that) => Equivalence(self, that));\n/**\n * Creates a `BigDecimal` from a `bigint` value.\n *\n * **When to use**\n *\n * Use to construct an integer `BigDecimal` from a `bigint`.\n *\n * **Example** (Creating decimals from bigint)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const decimal = BigDecimal.fromBigInt(123n)\n * decimal // => BigDecimal.fromStringUnsafe(\"123\")\n *\n * const largeBigInt = BigDecimal.fromBigInt(9007199254740991n)\n * largeBigInt // => BigDecimal.fromStringUnsafe(\"9007199254740991\")\n * ```\n *\n * @see {@link make} for constructing a decimal with an explicit scale\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromBigInt = n => make(n, 0);\n/**\n * Creates a `BigDecimal` from a finite `number`.\n *\n * **When to use**\n *\n * Use when you need to convert a trusted finite JavaScript number to a\n * `BigDecimal` and want a plain result instead of an `Option`.\n *\n * **Gotchas**\n *\n * It is not recommended to convert a floating point number to a decimal\n * directly, as the floating point representation may be unexpected. Throws a\n * `RangeError` if the number is not finite (`NaN`, `+Infinity` or `-Infinity`).\n *\n * **Example** (Creating decimals from finite numbers)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.fromNumberUnsafe(123) // => BigDecimal.fromBigInt(123n)\n * BigDecimal.fromNumberUnsafe(123.456) // => BigDecimal.fromStringUnsafe(\"123.456\")\n * ```\n *\n * @see {@link fromNumber} for returning `Option.none` when the number is not finite\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromNumberUnsafe = n => {\n return Option.getOrThrowWith(fromNumber(n), () => new RangeError(`Number must be finite, got ${n}`));\n};\n/**\n * Creates a `BigDecimal` safely from a finite `number`.\n *\n * **When to use**\n *\n * Use to convert a finite JavaScript number to a `BigDecimal` without throwing\n * on invalid input.\n *\n * **Details**\n *\n * Returns `Option.none()` for `NaN`, `+Infinity` or `-Infinity`.\n *\n * **Gotchas**\n *\n * It is not recommended to convert a floating point number to a decimal\n * directly, as the floating point representation may be unexpected.\n *\n * **Example** (Creating decimals from numbers safely)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal, Option } from \"effect\"\n *\n * BigDecimal.fromNumber(123.456) // => Option.some(BigDecimal.fromStringUnsafe(\"123.456\"))\n * BigDecimal.fromNumber(Infinity) // => Option.none()\n * ```\n *\n * @see {@link fromNumberUnsafe} for throwing when the number is not finite\n * @see {@link fromString} for parsing decimal strings directly\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromNumber = n => {\n if (!Number.isFinite(n)) {\n return Option.none();\n }\n const string = `${n}`;\n if (string.includes(\"e\")) {\n return fromString(string);\n }\n const [lead, trail = \"\"] = string.split(\".\");\n return Option.some(make(BigInt(`${lead}${trail}`), trail.length));\n};\n/**\n * Parses a decimal string into a `BigDecimal` safely.\n *\n * **When to use**\n *\n * Use to parse external decimal text without throwing on invalid input.\n *\n * **Details**\n *\n * Returns `Option.some` for valid decimal or exponent notation and\n * `Option.none` when the string cannot be parsed or would produce an unsafe\n * scale. The empty string parses as zero.\n *\n * **Example** (Parsing decimal strings safely)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal, Option } from \"effect\"\n *\n * BigDecimal.fromString(\"123.456\") // => Option.some(BigDecimal.make(123456n, 3))\n * BigDecimal.fromString(\"123.abc\") // => Option.none()\n * ```\n *\n * @see {@link fromStringUnsafe} for parsing that throws on invalid input\n * @see {@link fromNumber} for converting finite JavaScript numbers\n *\n * @category constructors\n * @since 2.0.0\n */\nexport const fromString = s => {\n if (s === \"\") {\n return Option.some(zero);\n }\n let base;\n let exp;\n const seperator = s.search(/[eE]/);\n if (seperator !== -1) {\n const trail = s.slice(seperator + 1);\n base = s.slice(0, seperator);\n exp = Number(trail);\n if (base === \"\" || !Number.isSafeInteger(exp) || !FINITE_INT_REGEXP.test(trail)) {\n return Option.none();\n }\n } else {\n base = s;\n exp = 0;\n }\n let digits;\n let offset;\n const dot = base.search(/\\./);\n if (dot !== -1) {\n const lead = base.slice(0, dot);\n const trail = base.slice(dot + 1);\n digits = `${lead}${trail}`;\n offset = trail.length;\n } else {\n digits = base;\n offset = 0;\n }\n if (!FINITE_INT_REGEXP.test(digits)) {\n return Option.none();\n }\n const scale = offset - exp;\n if (!Number.isSafeInteger(scale)) {\n return Option.none();\n }\n return Option.some(make(BigInt(digits), scale));\n};\n/**\n * Parses a decimal string into a `BigDecimal`, throwing if the string is\n * invalid.\n *\n * **When to use**\n *\n * Use when you expect decimal text to be valid and want parse errors to throw.\n *\n * **Details**\n *\n * Accepts the same syntax as `fromString`. Use `fromString` when invalid input\n * should be represented as `Option.none` instead of throwing.\n *\n * **Example** (Parsing decimal strings unsafely)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.fromStringUnsafe(\"123\") // => BigDecimal.fromBigInt(123n)\n * BigDecimal.fromStringUnsafe(\"123.456\") // => BigDecimal.make(123456n, 3)\n * ```\n *\n * @see {@link fromString} for returning `Option.none` on invalid input\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromStringUnsafe = s => {\n return Option.getOrThrowWith(fromString(s), () => new Error(`Invalid numerical string: ${s}`));\n};\n/**\n * Formats a `BigDecimal` as a string.\n *\n * **When to use**\n *\n * Use to render a `BigDecimal` as plain decimal text when possible.\n *\n * **Details**\n *\n * The value is normalized before formatting. Scientific notation is used when\n * the absolute value of the normalized scale is at least `16`; otherwise plain\n * decimal notation is used.\n *\n * **Example** (Formatting decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.format(BigDecimal.fromStringUnsafe(\"-5\")) // => \"-5\"\n * BigDecimal.format(BigDecimal.fromStringUnsafe(\"123.456\")) // => \"123.456\"\n * BigDecimal.format(BigDecimal.fromStringUnsafe(\"-0.00000123\")) // => \"-0.00000123\"\n * ```\n *\n * @see {@link toExponential} for always rendering scientific notation\n *\n * @category converting\n * @since 2.0.0\n */\nexport const format = n => {\n const normalized = normalize(n);\n if (Math.abs(normalized.scale) >= 16) {\n return toExponential(normalized);\n }\n const negative = normalized.value < bigint0;\n const absolute = negative ? `${normalized.value}`.substring(1) : `${normalized.value}`;\n let before;\n let after;\n if (normalized.scale >= absolute.length) {\n before = \"0\";\n after = \"0\".repeat(normalized.scale - absolute.length) + absolute;\n } else {\n const location = absolute.length - normalized.scale;\n if (location > absolute.length) {\n const zeros = location - absolute.length;\n before = `${absolute}${\"0\".repeat(zeros)}`;\n after = \"\";\n } else {\n after = absolute.slice(location);\n before = absolute.slice(0, location);\n }\n }\n const complete = after === \"\" ? before : `${before}.${after}`;\n return negative ? `-${complete}` : complete;\n};\n/**\n * Formats a given `BigDecimal` as a `string` in scientific notation.\n *\n * **When to use**\n *\n * Use to render a `BigDecimal` in scientific notation.\n *\n * **Example** (Formatting decimals exponentially)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.toExponential(BigDecimal.make(123456n, -5)) // => \"1.23456e+10\"\n * ```\n *\n * @see {@link format} for plain decimal formatting when possible\n *\n * @category converting\n * @since 3.11.0\n */\nexport const toExponential = n => {\n if (isZero(n)) {\n return \"0e+0\";\n }\n const normalized = normalize(n);\n const digits = `${abs(normalized).value}`;\n const head = digits.slice(0, 1);\n const tail = digits.slice(1);\n let output = `${isNegative(normalized) ? \"-\" : \"\"}${head}`;\n if (tail !== \"\") {\n output += `.${tail}`;\n }\n const exp = tail.length - normalized.scale;\n return `${output}e${exp >= 0 ? \"+\" : \"\"}${exp}`;\n};\n/**\n * Converts a `BigDecimal` to a JavaScript `number`.\n *\n * **When to use**\n *\n * Use when you need a JavaScript number at an interop boundary where precision\n * loss is acceptable.\n *\n * **Gotchas**\n *\n * This conversion is unsafe because the result can lose integer or fractional\n * precision, round to a nearby representable value, or become `Infinity` when\n * the decimal cannot be represented as a finite JavaScript `number`.\n *\n * **Example** (Converting decimals to numbers)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.toNumberUnsafe(BigDecimal.fromStringUnsafe(\"123.456\")) // => 123.456\n * ```\n *\n * @see {@link format} for preserving decimal precision as text\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toNumberUnsafe = n => Number(format(n));\n/**\n * Checks whether a given `BigDecimal` is an integer.\n *\n * **When to use**\n *\n * Use to test whether a `BigDecimal` has no fractional decimal part.\n *\n * **Example** (Checking integer decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.isInteger(BigDecimal.fromStringUnsafe(\"0\")) // => true\n * BigDecimal.isInteger(BigDecimal.fromStringUnsafe(\"1\")) // => true\n * BigDecimal.isInteger(BigDecimal.fromStringUnsafe(\"1.1\")) // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isInteger = n => normalize(n).scale <= 0;\n/**\n * Checks whether a given `BigDecimal` is `0`.\n *\n * **When to use**\n *\n * Use to test whether a `BigDecimal` is exactly zero.\n *\n * **Example** (Checking zero decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.isZero(BigDecimal.fromStringUnsafe(\"0\")) // => true\n * BigDecimal.isZero(BigDecimal.fromStringUnsafe(\"1\")) // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isZero = n => n.value === bigint0;\n/**\n * Checks whether a given `BigDecimal` is negative.\n *\n * **When to use**\n *\n * Use to test whether a `BigDecimal` is less than zero.\n *\n * **Example** (Checking negative decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.isNegative(BigDecimal.fromStringUnsafe(\"-1\")) // => true\n * BigDecimal.isNegative(BigDecimal.fromStringUnsafe(\"0\")) // => false\n * BigDecimal.isNegative(BigDecimal.fromStringUnsafe(\"1\")) // => false\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isNegative = n => n.value < bigint0;\n/**\n * Checks whether a given `BigDecimal` is positive.\n *\n * **When to use**\n *\n * Use to test whether a `BigDecimal` is greater than zero.\n *\n * **Example** (Checking positive decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.isPositive(BigDecimal.fromStringUnsafe(\"-1\")) // => false\n * BigDecimal.isPositive(BigDecimal.fromStringUnsafe(\"0\")) // => false\n * BigDecimal.isPositive(BigDecimal.fromStringUnsafe(\"1\")) // => true\n * ```\n *\n * @category predicates\n * @since 2.0.0\n */\nexport const isPositive = n => n.value > bigint0;\nconst isBigDecimalArgs = args => isBigDecimal(args[0]);\n/**\n * Computes a rounded `BigDecimal` at the given scale with the specified rounding mode.\n *\n * **When to use**\n *\n * Use to round a decimal at a requested scale with an explicit rounding mode.\n *\n * **Example** (Rounding decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * const positive = BigDecimal.round(BigDecimal.fromStringUnsafe(\"145\"), { mode: \"from-zero\", scale: -1 })\n * positive // => BigDecimal.fromBigInt(150n)\n *\n * const negative = BigDecimal.round(BigDecimal.fromStringUnsafe(\"-14.5\"))\n * negative // => BigDecimal.fromBigInt(-15n)\n * ```\n *\n * @see {@link ceil} for fixed rounding toward positive infinity\n * @see {@link floor} for fixed rounding toward negative infinity\n * @see {@link truncate} for fixed rounding toward zero\n *\n * @category math\n * @since 3.16.0\n */\nexport const round = /*#__PURE__*/dual(isBigDecimalArgs, (self, options) => {\n const mode = options?.mode ?? \"half-from-zero\";\n const scale = options?.scale ?? 0;\n switch (mode) {\n case \"ceil\":\n return ceil(self, scale);\n case \"floor\":\n return floor(self, scale);\n case \"to-zero\":\n return truncate(self, scale);\n case \"from-zero\":\n return isPositive(self) ? ceil(self, scale) : floor(self, scale);\n case \"half-ceil\":\n return floor(sum(self, make(bigint5, scale + 1)), scale);\n case \"half-floor\":\n return ceil(sum(self, make(bigint_5, scale + 1)), scale);\n case \"half-to-zero\":\n return isNegative(self) ? floor(sum(self, make(bigint5, scale + 1)), scale) : ceil(sum(self, make(bigint_5, scale + 1)), scale);\n case \"half-from-zero\":\n return isNegative(self) ? ceil(sum(self, make(bigint_5, scale + 1)), scale) : floor(sum(self, make(bigint5, scale + 1)), scale);\n }\n const halfCeil = floor(sum(self, make(bigint5, scale + 1)), scale);\n const halfFloor = ceil(sum(self, make(bigint_5, scale + 1)), scale);\n const digit = digitAt(halfCeil, scale);\n switch (mode) {\n case \"half-even\":\n return equals(halfCeil, halfFloor) ? halfCeil : digit % bigint2 === bigint0 ? halfCeil : halfFloor;\n case \"half-odd\":\n return equals(halfCeil, halfFloor) ? halfCeil : digit % bigint2 === bigint0 ? halfFloor : halfCeil;\n }\n});\n/**\n * Computes a truncated `BigDecimal` at the given scale. This removes fractional digits beyond the scale,\n * rounding toward zero.\n *\n * **When to use**\n *\n * Use when you need to discard fractional digits beyond a scale rather than\n * round half up, half down, or toward an infinity.\n *\n * **Example** (Truncating decimals)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.truncate(BigDecimal.fromStringUnsafe(\"145\"), -1) // => BigDecimal.fromBigInt(140n)\n * BigDecimal.truncate(BigDecimal.fromStringUnsafe(\"-14.5\")) // => BigDecimal.fromBigInt(-14n)\n * ```\n *\n * @see {@link round} for configurable rounding modes\n * @see {@link ceil} for rounding toward positive infinity\n * @see {@link floor} for rounding toward negative infinity\n *\n * @category math\n * @since 3.16.0\n */\nexport const truncate = /*#__PURE__*/dual(isBigDecimalArgs, (self, scale = 0) => {\n if (self.scale <= scale) {\n return self;\n }\n // BigInt division truncates towards zero\n return make(self.value / bigint10 ** BigInt(self.scale - scale), scale);\n});\n/**\n * Computes the ceiling of a `BigDecimal` at the given scale.\n *\n * **When to use**\n *\n * Use to round a decimal toward positive infinity at a requested scale.\n *\n * **Details**\n *\n * The default scale is `0`. Positive scales keep digits to the right of the\n * decimal point, and negative scales round positions to the left of the decimal\n * point.\n *\n * @see {@link floor} for rounding toward negative infinity\n * @see {@link truncate} for rounding toward zero\n * @see {@link round} for configurable rounding modes\n *\n * **Example** (Rounding decimals up)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.ceil(BigDecimal.fromStringUnsafe(\"145\"), -1) // => BigDecimal.fromBigInt(150n)\n * BigDecimal.ceil(BigDecimal.fromStringUnsafe(\"-14.5\")) // => BigDecimal.fromBigInt(-14n)\n * ```\n *\n * @category math\n * @since 3.16.0\n */\nexport const ceil = /*#__PURE__*/dual(isBigDecimalArgs, (self, scale = 0) => {\n const truncated = truncate(self, scale);\n if (isPositive(self) && isLessThan(truncated, self)) {\n return sum(truncated, make(bigint1, scale));\n }\n return truncated;\n});\n/**\n * Internal function used by `round` for `half-even` and `half-odd` rounding modes.\n *\n * Returns the digit at the position of the given `scale` within the `BigDecimal`.\n *\n * @internal\n */\nexport const digitAt = /*#__PURE__*/dual(2, (self, scale) => {\n if (self.scale < scale) {\n return bigint0;\n }\n const scaled = self.value / bigint10 ** BigInt(self.scale - scale);\n return scaled % bigint10;\n});\n/**\n * Computes the floor of a `BigDecimal` at the given scale.\n *\n * **When to use**\n *\n * Use to round a decimal toward negative infinity at a requested scale.\n *\n * **Example** (Rounding decimals down)\n *\n * ```ts import.meta.vitest\n * import { BigDecimal } from \"effect\"\n *\n * BigDecimal.floor(BigDecimal.fromStringUnsafe(\"145\"), -1) // => BigDecimal.fromBigInt(140n)\n * BigDecimal.floor(BigDecimal.fromStringUnsafe(\"-14.5\")) // => BigDecimal.fromBigInt(-15n)\n * ```\n *\n * @see {@link ceil} for rounding toward positive infinity\n * @see {@link truncate} for rounding toward zero\n * @see {@link round} for configurable rounding modes\n *\n * @category math\n * @since 3.16.0\n */\nexport const floor = /*#__PURE__*/dual(isBigDecimalArgs, (self, scale = 0) => {\n const truncated = truncate(self, scale);\n if (isNegative(self) && isGreaterThan(truncated, self)) {\n return sum(truncated, make(bigint_1, scale));\n }\n return truncated;\n});\n//# sourceMappingURL=BigDecimal.js.map","/**\n * Builds two-way conversions used by schemas.\n *\n * A `Transformation` describes how to decode an encoded value into a\n * decoded value and how to encode it back again. Schema APIs use\n * transformations to connect two representations, such as a string and a\n * number, a JSON value and a richer TypeScript value, or a form field and an\n * application value. This module includes transformation and middleware types,\n * constructors for pure or effectful conversions, and common conversions used\n * by the Schema module.\n *\n * @since 4.0.0\n */\nimport * as BigDecimal from \"./BigDecimal.js\";\nimport * as ByteSize from \"./ByteSize.js\";\nimport * as DateTime from \"./DateTime.js\";\nimport * as Duration from \"./Duration.js\";\nimport * as Effect from \"./Effect.js\";\nimport { format, formatDate, formatJson } from \"./Formatter.js\";\nimport * as Option from \"./Option.js\";\nimport * as Predicate from \"./Predicate.js\";\nimport * as SchemaGetter from \"./SchemaGetter.js\";\nimport * as SchemaIssue from \"./SchemaIssue.js\";\n/**\n * Constructs schema middleware from its decode and encode functions.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Middleware = class {\n _tag = \"Middleware\";\n decode;\n encode;\n constructor(decode, encode) {\n this.decode = decode;\n this.encode = encode;\n }\n flip() {\n return new Middleware(this.encode, this.decode);\n }\n};\nconst TypeId = \"~effect/SchemaTransformation/Transformation\";\n/**\n * Constructs a bidirectional schema transformation from its decode and encode getters.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Transformation = class {\n [TypeId] = TypeId;\n _tag = \"Transformation\";\n decode;\n encode;\n constructor(decode, encode) {\n this.decode = decode;\n this.encode = encode;\n }\n flip() {\n return new Transformation(this.encode, this.decode);\n }\n compose(other) {\n return new Transformation(this.decode.compose(other.decode), other.encode.compose(this.encode));\n }\n};\n/**\n * Returns `true` if `u` is a `Transformation` instance.\n *\n * **When to use**\n *\n * Use to check whether a value is already a schema transformation before\n * wrapping it.\n *\n * **Details**\n *\n * - Pure predicate, no side effects.\n * - Acts as a TypeScript type guard.\n *\n * **Example** (Checking a value)\n *\n * ```ts import.meta.vitest\n * import { SchemaTransformation } from \"effect\"\n *\n * SchemaTransformation.isTransformation(SchemaTransformation.trim()) // => true\n * SchemaTransformation.isTransformation({ decode: null, encode: null }) // => false\n * ```\n *\n * @see {@link Transformation}\n * @see {@link make}\n *\n * @category guards\n * @since 4.0.0\n */\nexport function isTransformation(u) {\n return Predicate.hasProperty(u, TypeId) && u[TypeId] === TypeId;\n}\n/**\n * Constructs a `Transformation` from an object with `decode` and `encode`\n * `Getter`s. If the input is already a `Transformation`, returns it as-is.\n *\n * **When to use**\n *\n * Use when you already have schema getter instances and want to pair them into\n * a schema transformation.\n * - You want idempotent wrapping (won't double-wrap).\n *\n * **Details**\n *\n * - Returns the input unchanged if it is already a `Transformation`.\n *\n * **Example** (Wrapping existing getters)\n *\n * ```ts import.meta.vitest\n * import { SchemaGetter, SchemaTransformation } from \"effect\"\n *\n * const t = SchemaTransformation.make({\n * decode: SchemaGetter.transform((s) => Number(s)),\n * encode: SchemaGetter.transform((n) => String(n))\n * })\n * t._tag // => \"Transformation\"\n * ```\n *\n * @see {@link transform} — simpler constructor from pure functions\n * @see {@link transformEffect} — constructor from effectful functions\n * @see {@link Transformation}\n *\n * @category constructors\n * @since 3.10.0\n */\nexport const make = options => {\n if (isTransformation(options)) {\n return options;\n }\n return new Transformation(options.decode, options.encode);\n};\n/**\n * Creates a `Transformation` from effectful decode and encode functions.\n *\n * **When to use**\n *\n * Use when you need a schema transformation that may fail or require Effect\n * services.\n *\n * **Details**\n *\n * - Each function receives the input value and `ParseOptions`.\n * - Must return an `Effect` that succeeds with the output or fails with `Issue`.\n * - Skips `None` inputs (missing keys) — functions are only called on present values.\n *\n * **Example** (Parsing a date string that can fail)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Schema, SchemaIssue, SchemaTransformation } from \"effect\"\n *\n * const DateFromString = Schema.String.pipe(\n * Schema.decodeTo(\n * Schema.Date,\n * SchemaTransformation.transformEffect({\n * decode: (s, options) => {\n * const d = new Date(s)\n * return isNaN(d.getTime())\n * ? Effect.fail(new SchemaIssue.InvalidValue({ message: \"Invalid date\" }, s, options))\n * : Effect.succeed(d)\n * },\n * encode: (d) => Effect.succeed(d.toISOString())\n * })\n * )\n * )\n * Schema.decodeSync(DateFromString)(\"2024-01-01\").toISOString() // => \"2024-01-01T00:00:00.000Z\"\n * ```\n *\n * @see {@link transform} — for infallible, pure transformations\n * @see {@link transformOptional} — for transformations that handle missing keys\n * @see {@link make} — for transformations from existing Getters\n *\n * @category transforming\n * @since 3.10.0\n */\nexport function transformEffect(options) {\n return new Transformation(SchemaGetter.transformEffect(options.decode), SchemaGetter.transformEffect(options.encode));\n}\n/**\n * Creates a `Transformation` from pure (sync, infallible) decode and encode\n * functions.\n *\n * **When to use**\n *\n * Use when you need an infallible schema transformation that does not require\n * Effect services.\n *\n * **Details**\n *\n * - Each function receives the input and returns the output directly.\n * - Skips `None` inputs (missing keys) — functions are only called on present values.\n * - Does not allocate Effects internally; uses optimized sync path.\n *\n * **Example** (Converting between cents and dollars)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const CentsFromDollars = Schema.Number.pipe(\n * Schema.decodeTo(\n * Schema.Number,\n * SchemaTransformation.transform({\n * decode: (dollars) => dollars * 100,\n * encode: (cents) => cents / 100\n * })\n * )\n * )\n * Schema.decodeSync(CentsFromDollars)(2.5) // => 250\n * ```\n *\n * @see {@link transformEffect} — for fallible or effectful transformations\n * @see {@link transformOptional} — for transformations that handle missing keys\n * @see {@link passthrough} — when no conversion is needed\n *\n * @category transforming\n * @since 3.10.0\n */\nexport function transform(options) {\n return new Transformation(SchemaGetter.transform(options.decode), SchemaGetter.transform(options.encode));\n}\n/**\n * Creates a `Transformation` where decode and encode operate on `Option`\n * values, giving full control over missing-key handling.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to produce or consume `Option.None`\n * for absent keys.\n * - You are working with optional struct fields.\n *\n * **Details**\n *\n * - Each function receives `Option` and returns `Option`.\n * - `Option.None` input means the key is absent; returning `Option.None`\n * omits the key from the output.\n * - Pure and synchronous.\n *\n * **Example** (Converting an optional key to Option)\n *\n * ```ts import.meta.vitest\n * import { Option, Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.Struct({\n * a: Schema.optionalKey(Schema.Number).pipe(\n * Schema.decodeTo(\n * Schema.Option(Schema.Number),\n * SchemaTransformation.transformOptional({\n * decode: Option.some,\n * encode: Option.flatten\n * })\n * )\n * )\n * })\n * Schema.decodeSync(schema)({}).a // => Option.none()\n * ```\n *\n * @see {@link transform} — when you don't need Option-level control\n * @see {@link optionFromOptionalKey} — built-in for the common optional-key-to-Option pattern\n * @see {@link optionFromOptional} — built-in for optional (undefined) to Option\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function transformOptional(options) {\n return new Transformation(SchemaGetter.transformOptional(options.decode), SchemaGetter.transformOptional(options.encode));\n}\n/**\n * Transforms strings by trimming whitespace on decode.\n * Encode is passthrough (no change).\n *\n * **When to use**\n *\n * Use when you need a schema transformation to normalize user input by\n * stripping leading/trailing whitespace.\n *\n * **Details**\n *\n * Decoding applies `String.prototype.trim()`. Encoding is passthrough and\n * returns the string unchanged. This is not round-trippable if the original had\n * whitespace.\n *\n * **Example** (Trimming on decode)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const Trimmed = Schema.String.pipe(\n * Schema.decode(SchemaTransformation.trim())\n * )\n * Schema.decodeSync(Trimmed)(\" hello \") // => \"hello\"\n * ```\n *\n * @see {@link toLowerCase}\n * @see {@link toUpperCase}\n * @see {@link snakeToCamel}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function trim() {\n return new Transformation(SchemaGetter.trim(), SchemaGetter.passthrough());\n}\n/**\n * Transforms strings by converting snake_case to camelCase\n * on decode and camelCase to snake_case on encode.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to convert API field names between\n * snake_case and camelCase conventions.\n *\n * **Details**\n *\n * Decoding converts values such as `\"my_field_name\"` to `\"myFieldName\"`.\n * Encoding converts values such as `\"myFieldName\"` back to `\"my_field_name\"`.\n * The transformation is round-trippable for standard snake_case and camelCase.\n *\n * **Example** (Converting snake case to camel case)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const SnakeToCamel = Schema.String.pipe(\n * Schema.decode(SchemaTransformation.snakeToCamel())\n * )\n * Schema.decodeSync(SnakeToCamel)(\"user_name\") // => \"userName\"\n * ```\n *\n * @see {@link trim}\n * @see {@link toLowerCase}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function snakeToCamel() {\n return new Transformation(SchemaGetter.snakeToCamel(), SchemaGetter.camelToSnake());\n}\n/**\n * Transforms strings by lowercasing on decode.\n * Encode is passthrough.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to normalize strings to lowercase\n * (e.g. email addresses).\n *\n * **Details**\n *\n * Decoding applies `String.prototype.toLowerCase()`. Encoding is passthrough.\n * This is not round-trippable if the original had uppercase characters.\n *\n * **Example** (Lowercasing on decode)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const Lowered = Schema.String.pipe(\n * Schema.decode(SchemaTransformation.toLowerCase())\n * )\n * Schema.decodeSync(Lowered)(\"HELLO\") // => \"hello\"\n * ```\n *\n * @see {@link toUpperCase}\n * @see {@link trim}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function toLowerCase() {\n return new Transformation(SchemaGetter.toLowerCase(), SchemaGetter.passthrough());\n}\n/**\n * Transforms strings by uppercasing on decode.\n * Encode is passthrough.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to normalize strings to uppercase\n * (e.g. country codes).\n *\n * **Details**\n *\n * Decoding applies `String.prototype.toUpperCase()`. Encoding is passthrough.\n * This is not round-trippable if the original had lowercase characters.\n *\n * **Example** (Uppercasing on decode)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const Uppered = Schema.String.pipe(\n * Schema.decode(SchemaTransformation.toUpperCase())\n * )\n * Schema.decodeSync(Uppered)(\"hello\") // => \"HELLO\"\n * ```\n *\n * @see {@link toLowerCase}\n * @see {@link trim}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function toUpperCase() {\n return new Transformation(SchemaGetter.toUpperCase(), SchemaGetter.passthrough());\n}\n/**\n * Transforms strings by capitalizing the first character on\n * decode. Encode is passthrough.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to normalize display names or\n * titles.\n *\n * **Details**\n *\n * Decoding uppercases the first character and leaves the rest unchanged.\n * Encoding is passthrough.\n *\n * **Example** (Capitalizing on decode)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const Capitalized = Schema.String.pipe(\n * Schema.decode(SchemaTransformation.capitalize())\n * )\n * Schema.decodeSync(Capitalized)(\"hello\") // => \"Hello\"\n * ```\n *\n * @see {@link uncapitalize}\n * @see {@link toUpperCase}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function capitalize() {\n return new Transformation(SchemaGetter.capitalize(), SchemaGetter.passthrough());\n}\n/**\n * Transforms strings by lowercasing the first character on\n * decode. Encode is passthrough.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to normalize identifiers or field\n * names.\n *\n * **Details**\n *\n * Decoding lowercases the first character and leaves the rest unchanged.\n * Encoding is passthrough.\n *\n * **Example** (Uncapitalizing on decode)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const Uncapitalized = Schema.String.pipe(\n * Schema.decode(SchemaTransformation.uncapitalize())\n * )\n * Schema.decodeSync(Uncapitalized)(\"Hello\") // => \"hello\"\n * ```\n *\n * @see {@link capitalize}\n * @see {@link toLowerCase}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function uncapitalize() {\n return new Transformation(SchemaGetter.uncapitalize(), SchemaGetter.passthrough());\n}\n/**\n * Transforms a string into a record of key-value pairs and\n * encodes a record of key-value pairs into a string.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to parse query-string-like or\n * config-file-like strings into records.\n *\n * **Details**\n *\n * Decoding splits the string by `separator` (default `\",\"`) into pairs, then\n * splits each pair by `keyValueSeparator` (default `\"=\"`). Encoding joins the\n * record back into a string using the same separators. The transformation is\n * round-trippable when keys and values do not contain the separators.\n *\n * **Example** (Parsing key-value pairs)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const Config = Schema.String.pipe(\n * Schema.decodeTo(\n * Schema.Record(Schema.String, Schema.String),\n * SchemaTransformation.splitKeyValue({ separator: \";\", keyValueSeparator: \":\" })\n * )\n * )\n * Schema.decodeSync(Config)(\"host:localhost;port:3000\") // => { host: \"localhost\", port: \"3000\" }\n * ```\n *\n * @see {@link trim}\n * @see {@link snakeToCamel}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function splitKeyValue(options) {\n return new Transformation(SchemaGetter.splitKeyValue(options), SchemaGetter.joinKeyValue(options));\n}\nconst passthrough_ = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.passthrough(), /*#__PURE__*/SchemaGetter.passthrough());\nexport function passthrough() {\n return passthrough_;\n}\nexport function passthroughSupertype() {\n return passthrough_;\n}\nexport function passthroughSubtype() {\n return passthrough_;\n}\n/**\n * Decodes a `string` into a `number` and encodes a `number` back to a\n * `string`.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to parse numeric strings from APIs,\n * form data, or URL parameters.\n *\n * **Details**\n *\n * Decoding coerces the string to a number like `Number(s)`. Encoding coerces\n * the number to a string like `String(n)`. This does not validate that the\n * result is finite; combine with `Schema.Finite` or `Schema.Int` for stricter\n * checks.\n *\n * **Example** (Converting a string to a number)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.Number, SchemaTransformation.numberFromString)\n * )\n * Schema.decodeSync(schema)(\"42\") // => 42\n * ```\n *\n * @see {@link bigintFromString}\n * @see {@link transform}\n *\n * @category converting\n * @since 4.0.0\n */\nexport const numberFromString = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.Number(), /*#__PURE__*/SchemaGetter.String());\n/**\n * Decodes a `string` into a `bigint` and encodes a `bigint` back to a\n * `string`.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to parse large integer strings\n * (e.g. database IDs, blockchain values).\n *\n * **Details**\n *\n * Decoding coerces the string to a bigint like `BigInt(s)`. Encoding coerces\n * the bigint to a string like `String(n)`. Decoding fails if the string is not\n * a valid bigint representation.\n *\n * **Example** (Converting a string to a BigInt)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.BigInt, SchemaTransformation.bigintFromString)\n * )\n * Schema.decodeSync(schema)(\"42\") // => 42n\n * ```\n *\n * @see {@link numberFromString}\n * @see {@link transform}\n *\n * @category converting\n * @since 4.0.0\n */\nexport const bigintFromString = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.BigInt(), /*#__PURE__*/SchemaGetter.String());\n/**\n * Decodes a `string` into a `Date` and encodes a `Date` back to a `string`.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to parse date strings from APIs or\n * user input.\n *\n * **Details**\n *\n * Decoding creates a `Date` from the string like `new Date(s)`. Encoding\n * converts the `Date` to an ISO string like `date.toISOString()`, returning\n * `\"Invalid Date\"` for invalid dates.\n *\n * **Example** (Converting a string to a Date)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.Date, SchemaTransformation.dateFromString)\n * )\n * Schema.decodeSync(schema)(\"2024-01-01\").toISOString() // => \"2024-01-01T00:00:00.000Z\"\n * ```\n *\n * @see {@link dateFromMillis}\n * @see {@link dateTimeUtcFromString}\n *\n * @category converting\n * @since 4.0.0\n */\nexport const dateFromString = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.Date(), /*#__PURE__*/SchemaGetter.transform(formatDate));\n/**\n * Decodes epoch milliseconds into a `Date` and encodes a `Date` back to epoch\n * milliseconds.\n *\n * **When to use**\n *\n * Use when you need a schema transformation for numeric timestamps represented\n * as milliseconds since the Unix epoch.\n *\n * **Details**\n *\n * Decoding creates a `Date` from the number like `new Date(ms)`. Encoding\n * returns the `Date` timestamp like `date.getTime()`.\n *\n * **Gotchas**\n *\n * This transformation does not validate date validity. `NaN`, `Infinity`, and\n * `-Infinity` decode to invalid `Date` instances.\n *\n * **Example** (Converting milliseconds to a Date)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.Number.pipe(\n * Schema.decodeTo(Schema.Date, SchemaTransformation.dateFromMillis)\n * )\n * Schema.decodeSync(schema)(0).toISOString() // => \"1970-01-01T00:00:00.000Z\"\n * ```\n *\n * @see {@link dateFromString}\n * @see {@link SchemaGetter.dateTimeUtcFromInput}\n *\n * @category converting\n * @since 4.0.0\n */\nexport const dateFromMillis = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.Date(), /*#__PURE__*/SchemaGetter.transform(date => date.getTime()));\n/**\n * Decodes a `string` into a `Duration` and encodes a `Duration` back to a\n * parseable `string`.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to parse human-readable duration\n * strings from APIs, config, or user input.\n *\n * **Details**\n *\n * Decoding accepts any string that `Duration.fromInput` can parse, including\n * `\"Infinity\"` and `\"-Infinity\"`. Encoding returns `String(duration)`,\n * producing strings such as `\"2000 millis\"` or `\"10 nanos\"` that round-trip\n * through the parser.\n *\n * **Example** (Converting a string to a Duration)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.Duration, SchemaTransformation.durationFromString)\n * )\n * String(Schema.decodeSync(schema)(\"5 seconds\")) // => \"5000 millis\"\n * ```\n *\n * @see {@link durationFromNanos}\n * @see {@link durationFromMillis}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const durationFromString = /*#__PURE__*/transformEffect({\n decode: (s, options) => Option.match(Duration.fromInput(s), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid Duration string\"\n }, s, options)),\n onSome: Effect.succeed\n }),\n encode: duration => Effect.succeed(String(duration))\n});\n/**\n * Decodes a `bigint` (nanoseconds) into a `Duration` and encodes a\n * `Duration` back to `bigint` nanoseconds.\n *\n * **When to use**\n *\n * Use when you need a schema transformation for nanosecond-precision timestamps\n * or intervals.\n *\n * **Details**\n *\n * Decoding always succeeds and creates a `Duration` from nanoseconds. Encoding\n * fails with `InvalidValue` if the `Duration` cannot be represented as a\n * `bigint`, such as `Duration.infinity`.\n *\n * **Example** (Converting nanoseconds to a Duration)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.BigInt.pipe(\n * Schema.decodeTo(Schema.Duration, SchemaTransformation.durationFromNanos)\n * )\n * String(Schema.decodeSync(schema)(5n)) // => \"5 nanos\"\n * ```\n *\n * @see {@link durationFromMillis}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const durationFromNanos = /*#__PURE__*/transformEffect({\n decode: i => Effect.succeed(Duration.nanos(i)),\n encode: (a, options) => Option.match(Duration.toNanos(a), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a Duration representable as a bigint\"\n }, a, options)),\n onSome: nanos => Effect.succeed(nanos)\n })\n});\n/**\n * Decodes a `number` of milliseconds into a `Duration` and encodes a `Duration`\n * back to milliseconds.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to decode timeouts, delays, elapsed\n * intervals, or other duration values stored as millisecond counts.\n *\n * **Details**\n *\n * Decode creates a duration from the number, and encode returns the duration\n * length in milliseconds.\n *\n * **Example** (Converting milliseconds to a Duration)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.Number.pipe(\n * Schema.decodeTo(Schema.Duration, SchemaTransformation.durationFromMillis)\n * )\n * String(Schema.decodeSync(schema)(5000)) // => \"5000 millis\"\n * ```\n *\n * @see {@link durationFromNanos}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const durationFromMillis = /*#__PURE__*/transform({\n decode: i => Duration.millis(i),\n encode: a => Duration.toMillis(a)\n});\n/**\n * Decodes a string into a `ByteSize` and encodes it as an exact string.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const byteSizeFromString = /*#__PURE__*/transformEffect({\n decode: (input, options) => Option.match(ByteSize.fromInput(input), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid ByteSize string\"\n }, input, options)),\n onSome: Effect.succeed\n }),\n encode: byteSize => Effect.succeed(`${byteSize} ${byteSize === BigInt(1) ? \"byte\" : \"bytes\"}`)\n});\n/**\n * Decodes a non-negative bigint byte count into a `ByteSize`.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const byteSizeFromBigInt = /*#__PURE__*/transformEffect({\n decode: (input, options) => Option.match(ByteSize.fromInput(input), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a non-negative bigint byte count\"\n }, input, options)),\n onSome: Effect.succeed\n }),\n encode: byteSize => Effect.succeed(ByteSize.toBigInt(byteSize))\n});\n/**\n * Decodes a non-negative safe-integer byte count into a `ByteSize`.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const byteSizeFromNumber = /*#__PURE__*/transformEffect({\n decode: (input, options) => Option.match(ByteSize.fromInput(input), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a non-negative safe-integer byte count\"\n }, input, options)),\n onSome: Effect.succeed\n }),\n encode: (byteSize, options) => Option.match(ByteSize.toNumber(byteSize), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a ByteSize representable as a safe integer\"\n }, byteSize, options)),\n onSome: Effect.succeed\n })\n});\nconst isJsonError = input => Predicate.isObject(input) && typeof input[\"message\"] === \"string\";\nconst decodeJsonError = input => {\n const hasCause = Object.hasOwn(input, \"cause\");\n const err = hasCause ? new Error(input.message, {\n cause: decodeDefect(input.cause)\n }) : new Error(input.message);\n if (typeof input.name === \"string\" && input.name !== \"Error\") err.name = input.name;\n if (typeof input.stack === \"string\") err.stack = input.stack;\n return err;\n};\nconst encodeUnknownAsJson = input => {\n try {\n const json = formatJson(input);\n return json === undefined ? format(input) : JSON.parse(json);\n } catch {\n return format(input);\n }\n};\nconst encodeJsonError = (input, options, encodeDefect) => {\n const encoded = {\n name: input.name,\n message: typeof input.message === \"string\" ? input.message : \"\"\n };\n if (options?.includeStack && typeof input.stack === \"string\") {\n encoded.stack = input.stack;\n }\n if (!options?.excludeCause && input.cause !== undefined) {\n encoded.cause = encodeDefect(input.cause);\n }\n return encoded;\n};\nconst makeEncodeDefect = options => {\n const seen = new WeakSet();\n const encode = input => {\n if (Predicate.isError(input)) {\n if (seen.has(input)) {\n return \"[Circular]\";\n }\n seen.add(input);\n const encoded = encodeJsonError(input, options, encode);\n seen.delete(input);\n return encoded;\n }\n return encodeUnknownAsJson(input);\n };\n return encode;\n};\nconst decodeDefect = input => isJsonError(input) ? decodeJsonError(input) : input;\n/** @internal */\nexport const errorFromJsonError = options => transform({\n decode: decodeJsonError,\n encode: input => makeEncodeDefect(options)(input)\n});\n/** @internal */\nexport const defectFromJson = options => transform({\n decode: decodeDefect,\n encode: makeEncodeDefect(options)\n});\n/**\n * Decodes `T | null` into `Option` and encodes `Option` back to\n * `T | null`.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to convert nullable API fields to\n * `Option`.\n *\n * **Details**\n *\n * Decoding maps `null` to `Option.none()` and non-null values to\n * `Option.some(value)`. Encoding maps `Option.none()` to `null` and\n * `Option.some(value)` to `value`. The transformation is pure and synchronous.\n *\n * **Example** (Converting nullable values to an Option)\n *\n * ```ts import.meta.vitest\n * import { Option, Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.NullOr(Schema.String).pipe(\n * Schema.decodeTo(\n * Schema.Option(Schema.String),\n * SchemaTransformation.optionFromNullOr()\n * )\n * )\n * Schema.decodeSync(schema)(null) // => Option.none()\n * ```\n *\n * @see {@link optionFromNullishOr}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function optionFromNullOr() {\n return transform({\n decode: Option.fromNullOr,\n encode: Option.getOrNull\n });\n}\n/**\n * Decodes `T | undefined` into `Option` and encodes `Option.none()` back to\n * `undefined`.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to convert API fields that use\n * `undefined` for absence to `Option`.\n *\n * **Details**\n *\n * Decoding maps `undefined` to `Option.none()` and non-undefined values to\n * `Option.some(value)`. Encoding maps `Option.none()` to `undefined` and\n * `Option.some(value)` to `value`. The transformation is pure and synchronous.\n *\n * **Example** (Converting undefined-or values to an Option)\n *\n * ```ts import.meta.vitest\n * import { Option, Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.UndefinedOr(Schema.String).pipe(\n * Schema.decodeTo(\n * Schema.Option(Schema.String),\n * SchemaTransformation.optionFromUndefinedOr()\n * )\n * )\n * Schema.decodeSync(schema)(undefined) // => Option.none()\n * ```\n *\n * @see {@link optionFromOptionalKey}\n * @see {@link optionFromOptional}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function optionFromUndefinedOr() {\n return transform({\n decode: Option.fromUndefinedOr,\n encode: Option.getOrUndefined\n });\n}\n/**\n * Decodes `T | null | undefined` into `Option` and encodes `Option`\n * back to `T | null` or `T | undefined` depending on the provided\n * `options.onNoneEncoding` (defaults to `undefined`).\n *\n * **When to use**\n *\n * Use when you need a schema transformation to convert nullish API fields to\n * `Option` when both `null` and `undefined` represent absence.\n *\n * **Details**\n *\n * Decoding maps `null` and `undefined` to `Option.none()` and all other values\n * to `Option.some(value)`. Encoding maps `Option.none()` to `null` or\n * `undefined` according to `options.onNoneEncoding`, and maps\n * `Option.some(value)` to `value`. The transformation is pure and synchronous.\n *\n * **Example** (Converting nullish values to an Option and encoding None as null)\n *\n * ```ts import.meta.vitest\n * import { Option, Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.NullishOr(Schema.String).pipe(\n * Schema.decodeTo(\n * Schema.Option(Schema.String),\n * SchemaTransformation.optionFromNullishOr({ onNoneEncoding: null })\n * )\n * )\n * Schema.encodeSync(schema)(Option.none()) // => null\n * ```\n *\n * @see {@link optionFromNullOr}\n * @see {@link optionFromUndefinedOr}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function optionFromNullishOr(options) {\n return transform({\n decode: Option.fromNullishOr,\n encode: options?.onNoneEncoding === null ? Option.getOrNull : Option.getOrUndefined\n });\n}\n/**\n * Decodes an optional struct key into `Option` and encodes `Option`\n * back to an optional key.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to convert optional struct keys\n * (declared with `Schema.optionalKey`) to `Option` values.\n *\n * **Details**\n *\n * Decoding maps an absent key (`None`) to `Some(None)` and a present key\n * (`Some(v)`) to `Some(Some(v))`. Encoding maps `Some(None)` to `None` to omit\n * the key, and maps `Some(Some(v))` to `Some(v)`. This uses\n * `transformOptional` under the hood.\n *\n * **Example** (Converting an optional key to an Option)\n *\n * ```ts import.meta.vitest\n * import { Option, Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.Struct({\n * name: Schema.optionalKey(Schema.String).pipe(\n * Schema.decodeTo(\n * Schema.Option(Schema.String),\n * SchemaTransformation.optionFromOptionalKey()\n * )\n * )\n * })\n * Schema.decodeSync(schema)({}).name // => Option.none()\n * ```\n *\n * @see {@link optionFromOptional}\n * @see {@link optionFromUndefinedOr}\n * @see {@link transformOptional}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function optionFromOptionalKey() {\n return transformOptional({\n decode: Option.some,\n encode: Option.flatten\n });\n}\n/**\n * Decodes optional values into `Option` and encodes `Option.none()` back to\n * an omitted optional value.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to convert optional (possibly\n * `undefined`) values to `Option`.\n *\n * **Details**\n *\n * Decoding maps an absent or `undefined` value to `Some(None)` and a present\n * value to `Some(Some(v))`. Encoding maps `Some(None)` to `None` to omit the\n * value, and maps `Some(Some(v))` to `Some(v)`. This uses\n * `transformOptional` under the hood and filters out `undefined` on decode.\n *\n * **Example** (Converting an optional value to an Option)\n *\n * ```ts import.meta.vitest\n * import { Option, Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.Struct({\n * age: Schema.optional(Schema.Number).pipe(\n * Schema.decodeTo(\n * Schema.Option(Schema.Number),\n * SchemaTransformation.optionFromOptional()\n * )\n * )\n * })\n * Schema.decodeSync(schema)({ age: undefined }).age // => Option.none()\n * ```\n *\n * @see {@link optionFromOptionalKey}\n * @see {@link optionFromUndefinedOr}\n * @see {@link transformOptional}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function optionFromOptional() {\n return transformOptional({\n decode: ot => ot.pipe(Option.filter(Predicate.isNotUndefined), Option.some),\n encode: Option.flatten\n });\n}\n/**\n * Decodes a `string` into a `URL` and encodes a `URL` back to its `href`\n * string.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to parse URL strings from user\n * input or API responses.\n *\n * **Details**\n *\n * Decoding checks `URL.canParse(s)` and fails with `InvalidValue` if the string\n * is not a valid URL. Encoding returns `url.href`.\n *\n * **Example** (Converting a string to a URL)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.URL, SchemaTransformation.urlFromString)\n * )\n * Schema.decodeSync(schema)(\"https://example.com/path\").href // => \"https://example.com/path\"\n * ```\n *\n * @see {@link numberFromString}\n * @see {@link transformEffect}\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const urlFromString = /*#__PURE__*/transformEffect({\n decode: (s, options) => URL.canParse(s) ? Effect.succeed(new URL(s)) : Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid URL string\"\n }, s, options)),\n encode: url => Effect.succeed(url.href)\n});\n/**\n * Decodes a `string` into a `BigDecimal` and encodes a `BigDecimal` back to\n * its string representation.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to parse decimal number strings\n * from APIs or user input.\n *\n * **Details**\n *\n * Decoding calls `BigDecimal.fromString(s)` and fails with `InvalidValue` if\n * the string is not a valid `BigDecimal` representation. Encoding returns\n * `BigDecimal.format(bd)`.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const bigDecimalFromString = /*#__PURE__*/transformEffect({\n decode: (s, options) => {\n const result = BigDecimal.fromString(s);\n return Option.isNone(result) ? Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid BigDecimal string\"\n }, s, options)) : Effect.succeed(result.value);\n },\n encode: bd => Effect.succeed(BigDecimal.format(bd))\n});\n/**\n * Decodes a Base64-encoded `string` into a `Uint8Array` and encodes a\n * `Uint8Array` back to a Base64 string.\n *\n * **When to use**\n *\n * Use when you need a schema transformation for binary data transmitted as\n * Base64 strings (e.g. file uploads, API payloads).\n *\n * **Details**\n *\n * Decoding parses the Base64 string into bytes. Encoding writes the byte array\n * as a Base64 string.\n *\n * **Example** (Converting Base64 to a Uint8Array)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.Uint8Array, SchemaTransformation.uint8ArrayFromBase64String)\n * )\n * Array.from(Schema.decodeSync(schema)(\"AQID\")) // => [1, 2, 3]\n * ```\n *\n * @see {@link fromJsonString}\n * @see `Schema.Uint8ArrayFromBase64` - a ready-made schema wrapping this transformation.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const uint8ArrayFromBase64String = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.decodeBase64(), /*#__PURE__*/SchemaGetter.encodeBase64());\n/**\n * Decodes a Base64-encoded `string` into a UTF-8 `string` and encodes a\n * UTF-8 `string` back to a Base64 string.\n *\n * **When to use**\n *\n * Use when you need a schema transformation for text data transmitted as Base64\n * strings.\n *\n * **Details**\n *\n * Decoding parses the Base64 string into a UTF-8 string. Encoding writes the\n * string as a Base64 string.\n *\n * **Example** (Converting Base64 to a string)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.String, SchemaTransformation.stringFromBase64String)\n * )\n * Schema.decodeSync(schema)(\"aGVsbG8=\") // => \"hello\"\n * ```\n *\n * @see {@link uint8ArrayFromBase64String}\n * @see `Schema.StringFromBase64` - a ready-made schema wrapping this transformation.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const stringFromBase64String = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.decodeBase64String(), /*#__PURE__*/SchemaGetter.encodeBase64());\n/**\n * Decodes a base64 (URL) encoded `string` into a UTF-8 `string` and encodes it back.\n *\n * **When to use**\n *\n * Use when you need a schema transformation for text data transmitted as Base64\n * URL-safe strings.\n *\n * **Details**\n *\n * Decoding parses the Base64 URL string into a UTF-8 string. Encoding writes\n * the string as a Base64 URL string.\n *\n * **Example** (Converting Base64Url to a string)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.String, SchemaTransformation.stringFromBase64UrlString)\n * )\n * Schema.decodeSync(schema)(\"aGVsbG8\") // => \"hello\"\n * ```\n *\n * @see {@link stringFromBase64String}\n * @see `Schema.StringFromBase64Url` - a ready-made schema wrapping this transformation.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const stringFromBase64UrlString = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.decodeBase64UrlString(), /*#__PURE__*/SchemaGetter.encodeBase64Url());\n/**\n * Decodes a hex encoded `string` into a UTF-8 `string` and encodes it back.\n *\n * **When to use**\n *\n * Use when you need a schema transformation for text data transmitted as\n * hexadecimal strings.\n *\n * **Details**\n *\n * Decoding parses the hex string into a UTF-8 string. Encoding writes the\n * string as a hex string.\n *\n * **Example** (Converting hex to a string)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.String, SchemaTransformation.stringFromHexString)\n * )\n * Schema.decodeSync(schema)(\"68656c6c6f\") // => \"hello\"\n * ```\n *\n * @see {@link stringFromBase64String}\n * @see `Schema.StringFromHex` - a ready-made schema wrapping this transformation.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const stringFromHexString = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.decodeHexString(), /*#__PURE__*/SchemaGetter.encodeHex());\n/**\n * Decodes a URI component encoded string into a UTF-8 string and encodes a\n * UTF-8 string into a URI component encoded string.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to store structured data in URL\n * query parameters or fragments, such as composing with `Schema.parseJson` to\n * round-trip JSON through a URL.\n *\n * **Details**\n *\n * Decoding calls `decodeURIComponent` and fails if the input contains malformed\n * percent-encoding sequences. Encoding calls `encodeURIComponent`.\n *\n * **Example** (Defining a URI component schema)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.String, SchemaTransformation.stringFromUriComponent)\n * )\n * Schema.decodeSync(schema)(\"hello%20world\") // => \"hello world\"\n * ```\n *\n * @see {@link stringFromBase64String}\n * @see `Schema.StringFromUriComponent` - a ready-made schema wrapping this transformation.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const stringFromUriComponent = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.decodeUriComponent(), /*#__PURE__*/SchemaGetter.encodeUriComponent());\n/**\n * Decodes a JSON string with `JSON.parse` and encodes a value with\n * `JSON.stringify`.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to decode JSON stored or\n * transmitted as a string, usually before composing with another schema that\n * validates the parsed structure.\n *\n * **Details**\n *\n * The `reviver` option is passed to `JSON.parse` during decoding. The\n * `replacer` and `space` options are passed to `JSON.stringify` during\n * encoding. Decode fails with `InvalidValue` for invalid JSON, and encode can\n * fail with `InvalidValue` when `JSON.stringify` cannot serialize the value.\n *\n * **Example** (Parsing JSON)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.String.pipe(\n * Schema.decodeTo(Schema.Unknown, SchemaTransformation.fromJsonString())\n * )\n * Schema.decodeSync(schema)(\"{\\\"ok\\\":true}\") // => { ok: true }\n * ```\n *\n * @see {@link uint8ArrayFromBase64String}\n * @see {@link fromFormData}\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function fromJsonString(options) {\n return new Transformation(SchemaGetter.parseJson(options ?? {}), SchemaGetter.stringifyJson(options));\n}\n/**\n * Decodes a `FormData` instance into a nested record using bracket-path keys and\n * encodes object-like values back into `FormData`.\n *\n * **When to use**\n *\n * Use when you need a schema transformation for form or multipart payloads\n * whose keys, such as `user[name]` or `items[0]`, should become nested data.\n *\n * **Details**\n *\n * Decode preserves string and `Blob` leaves. Encode flattens nested objects and\n * arrays into bracket-path entries and returns an empty `FormData` for\n * non-object inputs.\n *\n * **Example** (Decoding FormData)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.instanceOf(FormData).pipe(\n * Schema.decodeTo(Schema.Unknown, SchemaTransformation.fromFormData)\n * )\n * const formData = new FormData()\n * formData.append(\"user[name]\", \"Alice\")\n * Schema.decodeSync(schema)(formData) // => { user: { name: \"Alice\" } }\n * ```\n *\n * @see {@link fromURLSearchParams}\n * @see {@link fromJsonString}\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const fromFormData = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.decodeFormData(), /*#__PURE__*/SchemaGetter.encodeFormData());\n/**\n * Decodes `URLSearchParams` into a nested record using bracket-path keys and\n * encodes object-like values back into `URLSearchParams`.\n *\n * **When to use**\n *\n * Use when you need a schema transformation for query strings whose keys, such\n * as `filter[name]` or `items[0]`, should become nested data.\n *\n * **Details**\n *\n * Decode produces string leaves. Encode flattens nested objects and arrays into\n * bracket-path entries and returns empty `URLSearchParams` for non-object\n * inputs.\n *\n * **Example** (Decoding URLSearchParams)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaTransformation } from \"effect\"\n *\n * const schema = Schema.instanceOf(URLSearchParams).pipe(\n * Schema.decodeTo(Schema.Unknown, SchemaTransformation.fromURLSearchParams)\n * )\n * Schema.decodeSync(schema)(new URLSearchParams(\"user[name]=Alice\")) // => { user: { name: \"Alice\" } }\n * ```\n *\n * @see {@link fromFormData}\n * @see {@link fromJsonString}\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const fromURLSearchParams = /*#__PURE__*/new Transformation(/*#__PURE__*/SchemaGetter.decodeURLSearchParams(), /*#__PURE__*/SchemaGetter.encodeURLSearchParams());\n/**\n * Decodes a numeric time-zone offset in milliseconds into a\n * `DateTime.TimeZone.Offset` and encodes it back to the offset number.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to represent fixed-offset time\n * zones with numeric millisecond offsets.\n *\n * **Details**\n *\n * Decode uses `DateTime.zoneMakeOffset`; encode returns the offset's `offset`\n * field.\n *\n * @see {@link timeZoneFromString} for IANA or offset string encodings\n * @see {@link timeZoneNamedFromString} for IANA named-zone strings\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const timeZoneOffsetFromNumber = /*#__PURE__*/transform({\n decode: n => DateTime.zoneMakeOffset(n),\n encode: tz => tz.offset\n});\n/**\n * Decodes an IANA time-zone identifier string into a\n * `DateTime.TimeZone.Named` and encodes a named time zone back to its `id`.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to accept only IANA time-zone\n * identifier strings and produce `DateTime.TimeZone.Named` values.\n *\n * **Details**\n *\n * Decode fails with `InvalidValue` when the string is not a valid IANA time-zone\n * identifier.\n *\n * @see {@link timeZoneFromString} for time-zone strings that may be either IANA identifiers or offset strings\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const timeZoneNamedFromString = /*#__PURE__*/transformEffect({\n decode: (s, options) => {\n return Option.match(DateTime.zoneMakeNamed(s), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid IANA time zone\"\n }, s, options)),\n onSome: Effect.succeed\n });\n },\n encode: tz => Effect.succeed(tz.id)\n});\n/**\n * Decodes a string into a `DateTime.TimeZone` and encodes a time zone back to\n * its string representation.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to accept either an IANA time-zone\n * identifier or an offset string and produce a general `DateTime.TimeZone`.\n *\n * **Details**\n *\n * Accepted decode inputs include valid IANA identifiers and offset strings such\n * as `\"+03:00\"`. Decode fails with `InvalidValue` when the string cannot be\n * parsed as a time zone.\n *\n * @see {@link timeZoneNamedFromString} for IANA named-zone strings only\n * @see {@link timeZoneOffsetFromNumber} for fixed-offset zones encoded as numbers\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const timeZoneFromString = /*#__PURE__*/transformEffect({\n decode: (s, options) => {\n return Option.match(DateTime.zoneFromString(s), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid time zone\"\n }, s, options)),\n onSome: Effect.succeed\n });\n },\n encode: tz => Effect.succeed(DateTime.zoneToString(tz))\n});\n/**\n * Decodes a date-time string into a `DateTime.Utc` and encodes it back to an ISO\n * string.\n *\n * **When to use**\n *\n * Use when you need a schema transformation to decode date-time strings to a\n * normalized `DateTime.Utc` and encode back as a UTC ISO string.\n *\n * **Details**\n *\n * Decode accepts strings supported by `DateTime.make`, converts the result to\n * UTC, and fails with `InvalidValue` when parsing fails. Encode uses\n * `DateTime.formatIso`.\n *\n * @see {@link dateFromString} for decoding into JavaScript `Date`\n * @see {@link dateTimeZonedFromString} for ISO strings that should preserve zoned date-time information\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const dateTimeUtcFromString = /*#__PURE__*/transformEffect({\n decode: (s, options) => {\n return Option.match(DateTime.make(s), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid UTC DateTime string\"\n }, s, options)),\n onSome: result => Effect.succeed(DateTime.toUtc(result))\n });\n },\n encode: utc => Effect.succeed(DateTime.formatIso(utc))\n});\n/**\n * Decodes a zoned date-time string into a `DateTime.Zoned` and encodes it back\n * to an ISO zoned string.\n *\n * **When to use**\n *\n * Use when you need a schema transformation for ISO zoned date-time strings\n * that decode to `DateTime.Zoned` and encode with `DateTime.formatIsoZoned`.\n *\n * **Details**\n *\n * Decode uses `DateTime.makeZonedFromString` and fails with `InvalidValue` when\n * the input is not a valid zoned date-time. Encode uses\n * `DateTime.formatIsoZoned`.\n *\n * @see {@link dateTimeUtcFromString} for date-time strings that should decode to `DateTime.Utc` and encode as UTC ISO strings\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const dateTimeZonedFromString = /*#__PURE__*/transformEffect({\n decode: (s, options) => {\n return Option.match(DateTime.makeZonedFromString(s), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid Zoned DateTime string\"\n }, s, options)),\n onSome: Effect.succeed\n });\n },\n encode: zoned => Effect.succeed(DateTime.formatIsoZoned(zoned))\n});\n//# sourceMappingURL=SchemaTransformation.js.map","/**\n * Represents Effect schemas as runtime trees.\n *\n * Every `Schema` has an AST made from nodes for declarations, primitives,\n * literals, arrays, objects, unions, suspended schemas, checks, annotations,\n * encoding links, and parsing context. Most users work with the higher-level\n * `Schema` module. Use `SchemaAST` when you need to inspect schema nodes, build\n * ASTs programmatically, change encoded or decoded views, collect issues, or\n * run low-level schema checks.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"./Array.js\";\nimport * as Cause from \"./Cause.js\";\nimport * as Effect from \"./Effect.js\";\nimport * as Exit from \"./Exit.js\";\nimport { format, formatPropertyKey } from \"./Formatter.js\";\nimport { identity, memoize, memoizeIdempotent } from \"./Function.js\";\nimport { effectIsExit, iterateConcurrent, iterateEager, resolveConcurrency } from \"./internal/effect.js\";\nimport * as InternalRecord from \"./internal/record.js\";\nimport * as InternalAnnotations from \"./internal/schema/annotations.js\";\nimport * as InternalSchemaCause from \"./internal/schema/cause.js\";\nimport * as InternalParser from \"./internal/schema/parser.js\";\nimport * as Pipeable from \"./Pipeable.js\";\nimport * as Predicate from \"./Predicate.js\";\nimport * as Result from \"./Result.js\";\nimport * as SchemaGetter from \"./SchemaGetter.js\";\nimport * as SchemaIssue from \"./SchemaIssue.js\";\nimport * as SchemaTransformation from \"./SchemaTransformation.js\";\nfunction makeGuard(tag) {\n return ast => ast._tag === tag;\n}\n/**\n * Returns `true` if the value is an {@link AST} node (any variant).\n *\n * **Details**\n *\n * Uses the internal `TypeId` brand to distinguish AST nodes from arbitrary\n * objects.\n *\n * @see {@link AST}\n * @category guards\n * @since 4.0.0\n */\nexport function isAST(u) {\n return Predicate.hasProperty(u, TypeId) && u[TypeId] === TypeId;\n}\n/**\n * Narrows an {@link AST} to {@link Declaration}.\n *\n * **When to use**\n *\n * Use to recognize declaration AST nodes before running declaration-specific\n * handling.\n *\n * @see {@link Declaration} for the AST node type narrowed by this guard\n *\n * @category guards\n * @since 3.10.0\n */\nexport const isDeclaration = /*#__PURE__*/makeGuard(\"Declaration\");\n/**\n * Narrows an {@link AST} to {@link Null}.\n *\n * **When to use**\n *\n * Use to recognize an AST node that represents exactly the `null` literal when\n * inspecting, traversing, or transforming schema ASTs.\n *\n * @see {@link Null} for the AST node type narrowed by this guard\n * @see {@link null_ null} for the singleton `Null` AST instance\n * @see {@link isLiteral} for exact primitive literal AST nodes\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isNull = /*#__PURE__*/makeGuard(\"Null\");\n/**\n * Narrows an {@link AST} to {@link Undefined}.\n *\n * **When to use**\n *\n * Use to identify AST nodes that represent exactly the JavaScript `undefined`\n * value.\n *\n * @see {@link isVoid} for narrowing AST nodes that represent TypeScript `void` instead of exact `undefined`\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isUndefined = /*#__PURE__*/makeGuard(\"Undefined\");\n/**\n * Narrows an {@link AST} to {@link Void}.\n *\n * **When to use**\n *\n * Use to identify AST nodes that represent the TypeScript `void` type before\n * handling `Void`-specific schema behavior.\n *\n * @see {@link isUndefined} for narrowing AST nodes that represent the literal `undefined` value instead of TypeScript `void`\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isVoid = /*#__PURE__*/makeGuard(\"Void\");\n/**\n * Narrows an {@link AST} to {@link Never}.\n *\n * **When to use**\n *\n * Use to detect the AST node for a schema that can never match before handling\n * other schema variants.\n *\n * @see {@link Never} for the AST node type narrowed by this guard\n * @see {@link never} for the singleton `Never` AST instance\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isNever = /*#__PURE__*/makeGuard(\"Never\");\n/**\n * Narrows an {@link AST} to {@link Unknown}.\n *\n * **When to use**\n *\n * Use when you need to inspect a schema AST and handle the `Unknown` node\n * variant specifically.\n *\n * @see {@link isAny} for the guard for the `Any` node, whose parsed result is typed as `any` rather than `unknown`\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isUnknown = /*#__PURE__*/makeGuard(\"Unknown\");\n/**\n * Narrows an {@link AST} to {@link Any}.\n *\n * **When to use**\n *\n * Use when you need to inspect a schema AST and handle the `Any` node\n * variant specifically.\n *\n * @see {@link isUnknown} for the guard for the `Unknown` node, whose parsed result is typed as `unknown` rather than `any`\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isAny = /*#__PURE__*/makeGuard(\"Any\");\n/**\n * Narrows an {@link AST} to {@link String}.\n *\n * **When to use**\n *\n * Use to detect schema AST nodes that match any string value while inspecting\n * or transforming a Schema AST.\n *\n * @see {@link String} for the AST node class narrowed by this guard\n * @see {@link string} for the singleton `String` AST instance\n * @see {@link isLiteral} for exact primitive literal AST nodes, including exact string literals\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isString = /*#__PURE__*/makeGuard(\"String\");\n/**\n * Narrows an {@link AST} to {@link Number}.\n *\n * **When to use**\n *\n * Use to detect `Number` AST nodes while inspecting, traversing, or transforming\n * schema ASTs.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isNumber = /*#__PURE__*/makeGuard(\"Number\");\n/**\n * Narrows an {@link AST} to {@link Boolean}.\n *\n * **When to use**\n *\n * Use to identify the `Boolean` AST variant while inspecting, traversing, or\n * transforming schema definitions.\n *\n * @see {@link Boolean} for the AST node type matched by this guard\n * @see {@link boolean} for the singleton instance to use when constructing a boolean AST directly\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isBoolean = /*#__PURE__*/makeGuard(\"Boolean\");\n/**\n * Narrows an {@link AST} to {@link BigInt}.\n *\n * **When to use**\n *\n * Use to identify bigint AST nodes while inspecting or transforming schema ASTs.\n *\n * @see {@link BigInt} for the AST node matched by this guard\n * @see {@link bigInt} for the singleton instance; use `isBigInt` when narrowing an existing `AST` value\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isBigInt = /*#__PURE__*/makeGuard(\"BigInt\");\n/**\n * Narrows an {@link AST} to {@link Symbol}.\n *\n * **When to use**\n *\n * Use to narrow an `AST` node before handling the `Symbol` variant for schemas\n * that accept any JavaScript symbol value.\n *\n * @see {@link isUniqueSymbol} for the sibling guard that narrows the `UniqueSymbol` variant for one exact symbol value\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isSymbol = /*#__PURE__*/makeGuard(\"Symbol\");\n/**\n * Narrows an {@link AST} to {@link Literal}.\n *\n * **When to use**\n *\n * Use to recognize exact string, number, boolean, or bigint literal AST nodes.\n *\n * @see {@link Literal} for the AST node type narrowed by this guard\n * @see {@link LiteralValue} for the values stored by literal nodes\n *\n * @category guards\n * @since 3.10.0\n */\nexport const isLiteral = /*#__PURE__*/makeGuard(\"Literal\");\n/**\n * Narrows an {@link AST} to {@link UniqueSymbol}.\n *\n * @category guards\n * @since 3.10.0\n */\nexport const isUniqueSymbol = /*#__PURE__*/makeGuard(\"UniqueSymbol\");\n/**\n * Narrows an {@link AST} to {@link ObjectKeyword}.\n *\n * **When to use**\n *\n * Use to identify the AST node for the TypeScript `object` keyword when\n * inspecting or transforming a Schema AST.\n *\n * @see {@link ObjectKeyword} for the AST node matched by this guard\n * @see {@link objectKeyword} for the singleton `ObjectKeyword` AST instance\n * @see {@link isObjects} for struct and record AST nodes\n *\n * @category guards\n * @since 3.10.0\n */\nexport const isObjectKeyword = /*#__PURE__*/makeGuard(\"ObjectKeyword\");\n/**\n * Narrows an {@link AST} to {@link Enum}.\n *\n * **When to use**\n *\n * Use to recognize enum AST nodes before reading enum cases or running\n * enum-specific handling.\n *\n * @see {@link Enum} for the AST node type narrowed by this guard\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isEnum = /*#__PURE__*/makeGuard(\"Enum\");\n/**\n * Narrows an {@link AST} to {@link TemplateLiteral}.\n *\n * @category guards\n * @since 3.10.0\n */\nexport const isTemplateLiteral = /*#__PURE__*/makeGuard(\"TemplateLiteral\");\n/**\n * Narrows an {@link AST} to {@link Arrays}.\n *\n * **When to use**\n *\n * Use to recognize array-like AST nodes before reading their element, rest, or\n * mutability metadata.\n *\n * @see {@link Arrays} for the AST node type narrowed by this guard\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isArrays = /*#__PURE__*/makeGuard(\"Arrays\");\n/**\n * Narrows an {@link AST} to {@link Objects}.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isObjects = /*#__PURE__*/makeGuard(\"Objects\");\n/**\n * Narrows an {@link AST} to {@link Union}.\n *\n * @category guards\n * @since 3.10.0\n */\nexport const isUnion = /*#__PURE__*/makeGuard(\"Union\");\n/**\n * Narrows an {@link AST} to {@link Suspend}.\n *\n * @category guards\n * @since 3.10.0\n */\nexport const isSuspend = /*#__PURE__*/makeGuard(\"Suspend\");\n/**\n * Constructs a {@link Link}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Link = class {\n to;\n transformation;\n constructor(to, transformation) {\n this.to = to;\n this.transformation = transformation;\n }\n};\n/** @internal */\nexport const defaultParseOptions = {};\n/**\n * Constructs a {@link Context}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Context = class {\n isOptional;\n isMutable;\n /** Used for constructor default values (e.g. `withConstructorDefault` API) */\n constructorDefault;\n annotations;\n constructor(isOptional, isMutable, /** Used for constructor default values (e.g. `withConstructorDefault` API) */\n constructorDefault = undefined, annotations = undefined) {\n this.isOptional = isOptional;\n this.isMutable = isMutable;\n this.constructorDefault = constructorDefault;\n this.annotations = annotations;\n }\n};\nconst TypeId = \"~effect/Schema\";\nclass ASTNodeImpl {\n [TypeId] = TypeId;\n annotations;\n checks;\n encoding;\n context;\n constructor(annotations = undefined, checks = undefined, encoding = undefined, context = undefined) {\n this.annotations = annotations;\n this.checks = checks;\n this.encoding = encoding;\n this.context = context;\n }\n toString() {\n return `<${this._tag}>`;\n }\n}\n/**\n * Constructs a {@link Declaration}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Declaration = class extends ASTNodeImpl {\n _tag = \"Declaration\";\n typeParameters;\n run;\n encodingChecks;\n /**\n * Parser factory {@link flip} swaps in, so a declaration can behave\n * differently when encoding. `undefined` reuses `run`.\n */\n encodingRun;\n constructor(typeParameters, run, annotations, checks, encoding, context, encodingChecks, encodingRun) {\n super(annotations, checks, encoding, context);\n this.typeParameters = typeParameters;\n this.run = run;\n this.encodingChecks = encodingChecks;\n this.encodingRun = encodingRun;\n }\n /** @internal */\n getParser() {\n let run;\n return (input, options) => {\n if (input === InternalParser.missing) return InternalParser.missingExit;\n return (run ??= this.run(this.typeParameters))(input, this, options);\n };\n }\n _rebuild(recur, checks, encodingChecks, run, encodingRun) {\n const tps = mapOrSame(this.typeParameters, recur);\n return tps === this.typeParameters && checks === this.checks && encodingChecks === this.encodingChecks && run === this.run && encodingRun === this.encodingRun ? this : new Declaration(tps, run, this.annotations, checks, undefined, this.context, encodingChecks, encodingRun);\n }\n /** @internal */\n recur(recur) {\n return this._rebuild(recur, this.checks, this.encodingChecks, this.run, this.encodingRun);\n }\n /** @internal */\n flip(recur) {\n return this._rebuild(recur, this.encodingChecks, this.checks, this.encodingRun ?? this.run, this.run);\n }\n /** @internal */\n getExpected() {\n const expected = this.annotations?.expected;\n if (typeof expected === \"string\") return expected;\n return \"\";\n }\n};\n/**\n * Constructs a {@link Null}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Null = class extends ASTNodeImpl {\n _tag = \"Null\";\n /** @internal */\n getParser() {\n return fromConst(this, null);\n }\n /** @internal */\n getExpected() {\n return \"null\";\n }\n};\nconst null_ = /*#__PURE__*/new Null();\nexport {\n/**\n * Provides the singleton {@link Null} AST instance.\n *\n * **When to use**\n *\n * Use when you need the shared AST node for exact null values while inspecting\n * or constructing schema ASTs.\n *\n * @category constants\n * @since 4.0.0\n */\nnull_ as null };\n/**\n * Constructs a {@link Undefined}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Undefined = class extends ASTNodeImpl {\n _tag = \"Undefined\";\n /** @internal */\n getParser() {\n return fromConst(this, undefined);\n }\n /** @internal */\n toCodecJson() {\n return replaceEncoding(this, [undefinedToNull]);\n }\n /** @internal */\n getExpected() {\n return \"undefined\";\n }\n};\nconst undefinedToNull = /*#__PURE__*/new Link(null_, /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(() => undefined), /*#__PURE__*/SchemaGetter.transform(() => null)));\nconst undefined_ = /*#__PURE__*/new Undefined();\nexport {\n/**\n * Provides the singleton {@link Undefined} AST instance.\n *\n * **When to use**\n *\n * Use when you need the shared AST node for exact undefined values while\n * inspecting or constructing schema ASTs.\n *\n * @category constants\n * @since 4.0.0\n */\nundefined_ as undefined };\n/**\n * Constructs a {@link Void}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Void = class extends ASTNodeImpl {\n _tag = \"Void\";\n /** @internal */\n getParser() {\n const succeed = InternalParser.succeed(undefined);\n return input => input === InternalParser.missing ? InternalParser.missingExit : succeed;\n }\n /** @internal */\n toCodecJson() {\n return replaceEncoding(this, [undefinedToNull]);\n }\n /** @internal */\n getExpected() {\n return \"void\";\n }\n};\nconst void_ = /*#__PURE__*/new Void();\nexport {\n/**\n * Provides the singleton {@link Void} AST instance.\n *\n * **When to use**\n *\n * Use when constructing or comparing AST nodes for TypeScript `void` return\n * values whose result is intentionally ignored.\n *\n * **Details**\n *\n * The node parses any present runtime value as `undefined`; schemas may still\n * expose `void` on their typed decoded and encoded sides.\n *\n * @see {@link Void} for the AST node class\n * @see {@link undefined} for the sibling AST singleton that matches exactly `undefined`\n * @see {@link isVoid} for narrowing an AST to a `Void` node\n *\n * @category constructors\n * @since 4.0.0\n */\nvoid_ as void };\n/**\n * Constructs a {@link Never}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Never = class extends ASTNodeImpl {\n _tag = \"Never\";\n /** @internal */\n getParser() {\n return fromRefinement(this, Predicate.isNever);\n }\n /** @internal */\n getExpected() {\n return \"never\";\n }\n};\n/**\n * Provides the singleton {@link Never} AST instance.\n *\n * **When to use**\n *\n * Use to reuse the canonical bottom-type AST node when constructing,\n * comparing, or returning ASTs.\n *\n * @see {@link Never} for the AST node class\n * @see {@link isNever} for narrowing an AST to a `Never` node\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const never = /*#__PURE__*/new Never();\n/**\n * Constructs a {@link Any}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Any = class extends ASTNodeImpl {\n _tag = \"Any\";\n /** @internal */\n getParser() {\n return fromRefinement(this, Predicate.isUnknown);\n }\n /** @internal */\n getExpected() {\n return \"any\";\n }\n};\n/**\n * Provides the singleton {@link Any} AST instance.\n *\n * **When to use**\n *\n * Use when you need the singleton AST node for the TypeScript `any` type and\n * intentionally want parsing to accept every input value.\n *\n * @see {@link unknown} for the sibling AST singleton that also accepts every value while preserving the safer `unknown` type\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const any = /*#__PURE__*/new Any();\n/**\n * Constructs a {@link Unknown}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Unknown = class extends ASTNodeImpl {\n _tag = \"Unknown\";\n /** @internal */\n getParser() {\n return fromRefinement(this, Predicate.isUnknown);\n }\n /** @internal */\n getExpected() {\n return \"unknown\";\n }\n};\n/**\n * Provides the singleton {@link Unknown} AST instance.\n *\n * **When to use**\n *\n * Use when you need the reusable AST singleton for a schema node that accepts\n * every value while keeping parsed values opaque.\n *\n * @see {@link any} for the singleton that accepts every value as `any`\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const unknown = /*#__PURE__*/new Unknown();\n/**\n * Constructs a {@link ObjectKeyword}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const ObjectKeyword = class extends ASTNodeImpl {\n _tag = \"ObjectKeyword\";\n /** @internal */\n getParser() {\n return fromRefinement(this, Predicate.isObjectKeyword);\n }\n /** @internal */\n getExpected() {\n return \"object | array | function\";\n }\n};\n/**\n * Provides the singleton {@link ObjectKeyword} AST instance.\n *\n * **When to use**\n *\n * Use to reuse the canonical AST node for the TypeScript `object` keyword when\n * building or comparing `SchemaAST` values directly.\n *\n * @see {@link ObjectKeyword} for the AST node class\n * @see {@link isObjectKeyword} for narrowing an AST to an `ObjectKeyword` node\n *\n * @category constructors\n * @since 3.10.0\n */\nexport const objectKeyword = /*#__PURE__*/new ObjectKeyword();\n/**\n * Constructs a {@link Enum}. Numeric values must be finite.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Enum = class extends ASTNodeImpl {\n _tag = \"Enum\";\n enums;\n constructor(enums, annotations, checks, encoding, context) {\n super(annotations, checks, encoding, context);\n for (const [, value] of enums) {\n if (typeof value === \"number\" && !globalThis.Number.isFinite(value)) {\n throw new Error(`A numeric enum value must be finite, got ${format(value)}`);\n }\n }\n this.enums = enums;\n }\n /** @internal */\n getParser() {\n const values = new Set(this.enums.map(([, v]) => v));\n return fromRefinement(this, input => values.has(input));\n }\n /** @internal */\n toCodecStringTree() {\n if (this.enums.some(([_, v]) => typeof v === \"number\")) {\n const coercions = Object.fromEntries(this.enums.map(([_, v]) => [globalThis.String(v), v]));\n return replaceEncoding(this, [new Link(new Union(Object.keys(coercions).map(k => new Literal(k))), new SchemaTransformation.Transformation(SchemaGetter.transform(s => coercions[s]), SchemaGetter.String()))]);\n }\n return this;\n }\n /** @internal */\n getExpected() {\n return this.enums.map(([_, value]) => JSON.stringify(value)).join(\" | \");\n }\n};\nfunction formatTemplateLiteralPath(path) {\n return typeof path === \"number\" ? `parts[${path}]` : path;\n}\nfunction isTemplateLiteralPart(ast, path, validated) {\n if (validated.has(ast)) return true;\n if (ast.encoding) {\n throw new Error(`TemplateLiteral parts cannot have an encoding at ${formatTemplateLiteralPath(path)}`);\n }\n let valid;\n switch (ast._tag) {\n case \"String\":\n case \"Number\":\n case \"BigInt\":\n valid = true;\n break;\n case \"Literal\":\n valid = !ast.checks;\n break;\n case \"TemplateLiteral\":\n {\n const currentPath = formatTemplateLiteralPath(path);\n valid = !ast.checks && ast.parts.every((part, index) => isTemplateLiteralPart(part, `${currentPath}.parts[${index}]`, validated));\n break;\n }\n case \"Union\":\n {\n const currentPath = formatTemplateLiteralPath(path);\n valid = !ast.checks && ast.types.every((part, index) => isTemplateLiteralPart(part, `${currentPath}.types[${index}]`, validated));\n break;\n }\n default:\n return false;\n }\n if (valid) validated.add(ast);\n return valid;\n}\n/**\n * Constructs a {@link TemplateLiteral}.\n *\n * **Gotchas**\n *\n * Throws if a part contains an encoding, including inside unions or nested\n * template literals. Parts must describe their values without transformations.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const TemplateLiteral = class extends ASTNodeImpl {\n _tag = \"TemplateLiteral\";\n parts;\n /** @internal */\n encodedParts;\n /** @internal */\n literals;\n /** @internal */\n suffixLengths;\n constructor(parts, annotations, checks, encoding, context) {\n super(annotations, checks, encoding, context);\n const encodedParts = [];\n const literals = [];\n const validated = new Set();\n for (let index = 0; index < parts.length; index++) {\n const part = parts[index];\n if (!isTemplateLiteralPart(part, index, validated)) {\n throw new Error(`Invalid TemplateLiteral part ${part._tag}`);\n }\n encodedParts.push(part);\n literals.push(part._tag === \"Literal\" ? globalThis.String(part.literal) : undefined);\n }\n const suffixLengths = new Array(encodedParts.length + 1);\n suffixLengths[encodedParts.length] = 0;\n for (let i = encodedParts.length - 1; i >= 0; i--) {\n suffixLengths[i] = suffixLengths[i + 1] + (literals[i]?.length ?? 0);\n }\n this.parts = parts;\n this.encodedParts = encodedParts;\n this.literals = literals;\n this.suffixLengths = suffixLengths;\n }\n /** @internal */\n getParser(compile) {\n const tuple = new Arrays(false, this.parts.map(partFromString), []);\n const parser = compile(decodeTo(string, tuple, templateLiteralTransformation(this)));\n return (input, options) => {\n if (input === InternalParser.missing) return InternalParser.missingExit;\n const result = parser(input, options);\n if (result._tag === \"Success\") {\n return InternalParser.sameExit;\n }\n return Effect.mapBothEager(result, {\n onSuccess: () => input,\n onFailure: issue => new SchemaIssue.Composite(this, [issue], input, options)\n });\n };\n }\n /** @internal */\n getExpected() {\n return \"string\";\n }\n /** @internal */\n matchPart(s, options) {\n return segmentTemplateLiteralParts(this, s, options) === undefined ? undefined : s;\n }\n};\n/** @internal */\nexport function templateLiteralParser(parts) {\n // Encoded members can overlap even when decoding selects exactly one member.\n // Match their spellings here; the original tuple enforces the union's mode.\n const normalize = memoize(encoded => {\n if (encoded._tag !== \"Union\") return encoded;\n const types = mapOrSame(encoded.types, normalize);\n return (encoded.options?.mode ?? \"anyOf\") === \"anyOf\" && types === encoded.types ? encoded : new Union(types, encoded.options === undefined ? undefined : {\n ...encoded.options,\n mode: \"anyOf\"\n }, encoded.annotations, encoded.checks, undefined, encoded.context);\n });\n const template = new TemplateLiteral(parts.map(part => normalize(toEncoded(part))));\n const tuple = new Arrays(false, parts.map(partFromString), []);\n return decodeTo(template, tuple, templateLiteralTransformation(template));\n}\nfunction templateLiteralTransformation(template) {\n return new SchemaTransformation.Transformation(SchemaGetter.transformEffect((s, options) => {\n const segments = segmentTemplateLiteralParts(template, s, options);\n if (segments) return Effect.succeed(segments);\n return Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a string matching template literal parts\"\n }, s, options));\n }), SchemaGetter.transform(parts => parts.join(\"\")));\n}\n/**\n * Constructs a {@link UniqueSymbol}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const UniqueSymbol = class extends ASTNodeImpl {\n _tag = \"UniqueSymbol\";\n symbol;\n constructor(symbol, annotations, checks, encoding, context) {\n super(annotations, checks, encoding, context);\n this.symbol = symbol;\n }\n /** @internal */\n getParser() {\n return fromConst(this, this.symbol);\n }\n /** @internal */\n toCodecStringTree() {\n const key = globalThis.Symbol.keyFor(this.symbol);\n return replaceEncoding(this, [new Link(key === undefined ? never : new Literal(globalThis.String(this.symbol)), symbolToString.transformation)]);\n }\n /** @internal */\n getExpected() {\n return globalThis.String(this.symbol);\n }\n};\n/**\n * Constructs a {@link Literal}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Literal = class extends ASTNodeImpl {\n _tag = \"Literal\";\n literal;\n constructor(literal, annotations, checks, encoding, context) {\n super(annotations, checks, encoding, context);\n if (typeof literal === \"number\" && !globalThis.Number.isFinite(literal)) {\n throw new Error(`A numeric literal must be finite, got ${format(literal)}`);\n }\n this.literal = literal;\n }\n /** @internal */\n getParser() {\n return fromConst(this, this.literal);\n }\n /** @internal */\n matchPart(s, _options) {\n return s === globalThis.String(this.literal) ? this.literal : undefined;\n }\n /** @internal */\n toCodecJson() {\n return typeof this.literal === \"bigint\" ? literalToString(this) : this;\n }\n /** @internal */\n toCodecStringTree() {\n return typeof this.literal === \"string\" ? this : literalToString(this);\n }\n /** @internal */\n getExpected() {\n return typeof this.literal === \"string\" ? JSON.stringify(this.literal) : globalThis.String(this.literal);\n }\n};\nfunction literalToString(ast) {\n const literalAsString = globalThis.String(ast.literal);\n return replaceEncoding(ast, [new Link(new Literal(literalAsString), new SchemaTransformation.Transformation(SchemaGetter.transform(() => ast.literal), SchemaGetter.transform(() => literalAsString)))]);\n}\n/**\n * Constructs a {@link String}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const String = class extends ASTNodeImpl {\n _tag = \"String\";\n /** @internal */\n getParser() {\n return fromRefinement(this, Predicate.isString);\n }\n /** @internal */\n matchPart(s, options) {\n const checks = this.checks;\n return checks && !options.disableChecks && collectIssues(checks, s, undefined, this, options) ? undefined : s;\n }\n /** @internal */\n getExpected() {\n return \"string\";\n }\n};\n/**\n * Provides the singleton {@link String} AST instance.\n *\n * **When to use**\n *\n * Use as the shared `SchemaAST` node for unconstrained JavaScript strings.\n *\n * @see {@link String} for the AST node class\n * @see {@link isString} for narrowing an AST to a string node\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const string = /*#__PURE__*/new String();\n/**\n * Constructs a {@link Number}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Number = class extends ASTNodeImpl {\n _tag = \"Number\";\n /** @internal */\n getParser() {\n return fromRefinement(this, Predicate.isNumber);\n }\n /** @internal */\n matchKey(s, options) {\n return this._match(isStringNumberRegExp, s, options);\n }\n /** @internal */\n matchPart(s, options) {\n return this._match(isStringFiniteRegExp, s, options);\n }\n _match(regexp, s, options) {\n if (!regexp.test(s)) return undefined;\n const value = globalThis.Number(s);\n if (options.disableChecks || !this.checks) return value;\n return collectIssues(this.checks, value, undefined, this, options) ? undefined : value;\n }\n /** @internal */\n toCodecJson() {\n if (this.checks && (hasCheck(this.checks, \"effect/schema/isFinite\") || hasCheck(this.checks, \"effect/schema/isInt\"))) {\n return this;\n }\n return replaceEncoding(this, [numberToJson]);\n }\n /** @internal */\n toCodecStringTree() {\n if (this.toCodecJson() === this) {\n return replaceEncoding(this, [finiteToString]);\n }\n return replaceEncoding(this, [numberToString]);\n }\n /** @internal */\n getExpected() {\n return \"number\";\n }\n};\nfunction hasCheck(checks, id) {\n return checks.some(check => check.annotations?.representation?.id === id || check._tag === \"FilterGroup\" && hasCheck(check.checks, id));\n}\n/**\n * Provides the singleton {@link Number} AST instance.\n *\n * **When to use**\n *\n * Use when you need the canonical `SchemaAST` node for schemas that accept any\n * JavaScript number value.\n *\n * @see {@link Number} for the AST node class and serialization behavior\n * @see {@link Literal} for exact finite numeric literal AST nodes\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const number = /*#__PURE__*/new Number();\n/**\n * Constructs a {@link Boolean}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Boolean = class extends ASTNodeImpl {\n _tag = \"Boolean\";\n /** @internal */\n getParser() {\n return fromRefinement(this, Predicate.isBoolean);\n }\n /** @internal */\n getExpected() {\n return \"boolean\";\n }\n};\n/**\n * Provides the singleton {@link Boolean} AST instance.\n *\n * **When to use**\n *\n * Use to reuse the standard AST node that accepts either `true` or `false` when\n * constructing schema ASTs directly.\n *\n * @see {@link Boolean} for the AST node class\n * @see {@link Literal} for exact boolean literal AST nodes\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const boolean = /*#__PURE__*/new Boolean();\n/**\n * Constructs a {@link Symbol}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Symbol = class extends ASTNodeImpl {\n _tag = \"Symbol\";\n /** @internal */\n getParser() {\n return fromRefinement(this, Predicate.isSymbol);\n }\n /** @internal */\n matchKey(s, options) {\n if (options.disableChecks || !this.checks) return s;\n return collectIssues(this.checks, s, undefined, this, options) ? undefined : s;\n }\n /** @internal */\n toCodecStringTree() {\n return replaceEncoding(this, [symbolToString]);\n }\n /** @internal */\n getExpected() {\n return \"symbol\";\n }\n};\n/**\n * Provides the singleton {@link Symbol} AST instance.\n *\n * **When to use**\n *\n * Use to reuse the singleton AST node for schemas that match any JavaScript\n * symbol value.\n *\n * **Gotchas**\n *\n * String-based codecs can encode only symbols registered with `Symbol.for`,\n * because the implementation uses `Symbol.keyFor`.\n *\n * @see {@link UniqueSymbol} for an AST node that matches one specific symbol\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const symbol = /*#__PURE__*/new Symbol();\n/**\n * Constructs a {@link BigInt}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const BigInt = class extends ASTNodeImpl {\n _tag = \"BigInt\";\n /** @internal */\n getParser() {\n return fromRefinement(this, Predicate.isBigInt);\n }\n /** @internal */\n matchPart(s, options) {\n if (!isStringBigIntRegExp.test(s)) return undefined;\n const value = globalThis.BigInt(s);\n if (options.disableChecks || !this.checks) return value;\n return collectIssues(this.checks, value, undefined, this, options) ? undefined : value;\n }\n /** @internal */\n toCodecStringTree() {\n return replaceEncoding(this, [bigIntToString]);\n }\n /** @internal */\n getExpected() {\n return \"bigint\";\n }\n};\n/**\n * Provides the singleton {@link BigInt} AST instance.\n *\n * **When to use**\n *\n * Use to reuse the canonical `BigInt` AST node when constructing, inspecting,\n * or transforming schemas at the AST level.\n *\n * @see {@link BigInt} for the AST node class and string-codec behavior\n * @see {@link isBigInt} for narrowing an AST to a `BigInt` node\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const bigInt = /*#__PURE__*/new BigInt();\n/**\n * Constructs a {@link Arrays}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Arrays = class extends ASTNodeImpl {\n _tag = \"Arrays\";\n isMutable;\n elements;\n rest;\n encodingChecks;\n constructor(isMutable, elements, rest, annotations, checks, encoding, context, encodingChecks) {\n super(annotations, checks, encoding, context);\n this.isMutable = isMutable;\n this.elements = elements;\n this.rest = rest;\n this.encodingChecks = encodingChecks;\n let hasOptional = false;\n for (let i = 0; i < elements.length; i++) {\n if (isOptional(elements[i])) {\n hasOptional = true;\n } else if (hasOptional) {\n throw new Error(\"A required element cannot follow an optional element. ts(1257)\");\n }\n }\n if (hasOptional && rest.length > 1) {\n throw new Error(\"A required element cannot follow an optional element. ts(1257)\");\n }\n // An optional element cannot follow a rest element.ts(1266)\n for (let i = 1; i < rest.length; i++) {\n if (isOptional(rest[i])) {\n throw new Error(\"An optional element cannot follow a rest element. ts(1266)\");\n }\n }\n }\n /** @internal */\n getParser(compile, compileConstructorDefault = compile) {\n // oxlint-disable-next-line @typescript-eslint/no-this-alias\n const ast = this;\n let elements;\n let rest;\n const elementLen = ast.elements.length;\n const tailLen = Math.max(0, ast.rest.length - 1);\n function getParser(tailThreshold, index) {\n if (index < elementLen) {\n return elements[index];\n } else if (index >= tailThreshold) {\n return rest[index - tailThreshold + 1];\n }\n return rest[0];\n }\n return Effect.fnUntracedEager(function* (input, options) {\n if (input === InternalParser.missing) {\n return InternalParser.missing;\n }\n // If the input is not an array, return early with an error\n if (!Array.isArray(input)) {\n return yield* Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n }\n if (!elements) {\n elements = ast.elements.map(ast => ({\n ast,\n parser: compileConstructorDefault(ast)\n }));\n rest = ast.rest.map(ast => ({\n ast,\n parser: compileConstructorDefault(ast)\n }));\n }\n const len = input.length;\n const state = {\n ast,\n getParser,\n input,\n len,\n tailThreshold: Math.max(elementLen, len - tailLen),\n output: new globalThis.Array(len),\n issues: undefined,\n options\n };\n const end = ast.rest.length === 0 ? elementLen : Math.max(len, elementLen + tailLen);\n const concurrency = options.concurrency === undefined ? 1 : resolveConcurrency(options.concurrency);\n const eff = concurrency === 1 ? parseArray(state, input, 0, end) : parseArrayConcurrent(state, input, {\n concurrency,\n end\n });\n if (eff) yield* eff;\n // ---------------------------------------------\n // handle excess indexes\n // ---------------------------------------------\n if (ast.rest.length === 0 && len > elementLen) {\n for (let i = elementLen; i <= len - 1; i++) {\n const unexpected = new SchemaIssue.UnexpectedKey(ast, input[i], options);\n const issue = new SchemaIssue.Pointer([i], unexpected);\n if (options.errors === \"all\") {\n if (state.issues) state.issues.push(issue);else state.issues = [issue];\n } else {\n return yield* Effect.fail(new SchemaIssue.Composite(ast, [issue], input, options));\n }\n }\n }\n if (state.issues) {\n return yield* Effect.fail(new SchemaIssue.Composite(ast, state.issues, input, options));\n }\n return state.output;\n });\n }\n _rebuild(recur, checks, encodingChecks) {\n const elements = mapOrSame(this.elements, recur);\n const rest = mapOrSame(this.rest, recur);\n return elements === this.elements && rest === this.rest && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Arrays(this.isMutable, elements, rest, this.annotations, checks, undefined, this.context, encodingChecks);\n }\n /** @internal */\n recur(recur) {\n return this._rebuild(recur, this.checks, this.encodingChecks);\n }\n /** @internal */\n flip(recur) {\n return this._rebuild(recur, this.encodingChecks, this.checks);\n }\n /** @internal */\n getExpected() {\n return \"array\";\n }\n};\nconst parseArrayOptions = {\n onItem(s, item, i) {\n const value = i < s.len ? item : InternalParser.missing;\n return s.getParser(s.tailThreshold, i).parser(value, s.options);\n },\n step(s, item, exit, i) {\n if (exit._tag === \"Failure\") {\n return wrapPropertyKeyIssue(s, s.ast, i, exit);\n }\n const value = exit === InternalParser.sameExit ? item : exit[InternalParser.args];\n if (value !== InternalParser.missing) {\n s.output[i] = value;\n } else {\n const p = s.getParser(s.tailThreshold, i);\n if (isOptional(p.ast)) return;\n const issue = new SchemaIssue.Pointer([i], new SchemaIssue.MissingKey(p.ast.context?.annotations));\n if (s.options.errors === \"all\") {\n if (s.issues) s.issues.push(issue);else s.issues = [issue];\n } else {\n return Exit.fail(new SchemaIssue.Composite(s.ast, [issue], s.input, s.options));\n }\n }\n }\n};\nconst parseArray = /*#__PURE__*/iterateEager()(parseArrayOptions);\nconst parseArrayConcurrent = /*#__PURE__*/iterateConcurrent()(parseArrayOptions);\nconst wrapPropertyKeyIssue = (s, ast, key, exit) => {\n if (exit.cause.reasons.length === 0) {\n return exit;\n }\n const issue = InternalSchemaCause.getSchemaIssue(exit.cause);\n if (issue === undefined) {\n return Exit.failCause(Cause.map(exit.cause, issue => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer([key], issue)], s.input, s.options)));\n }\n const pointer = new SchemaIssue.Pointer([key], issue);\n if (s.options.errors === \"all\") {\n if (s.issues) s.issues.push(pointer);else s.issues = [pointer];\n } else {\n return Exit.fail(new SchemaIssue.Composite(ast, [pointer], s.input, s.options));\n }\n};\n/**\n * floating point or integer, with optional exponent\n * @internal\n */\nexport const FINITE_PATTERN = \"[+-]?\\\\d*\\\\.?\\\\d+(?:[Ee][+-]?\\\\d+)?\";\n/**\n * Returns the object keys that match the index signature parameter schema.\n * @internal\n */\nexport function getIndexSignatureKeys(input, parameter, options = defaultParseOptions) {\n let stringKeys;\n let symbolKeys;\n function go(parameter) {\n switch (parameter._tag) {\n case \"String\":\n case \"TemplateLiteral\":\n return (stringKeys ??= Object.keys(input)).filter(k => parameter.matchPart(k, options) !== undefined);\n case \"Number\":\n return (stringKeys ??= Object.keys(input)).filter(k => parameter.matchKey(k, options) !== undefined);\n case \"Symbol\":\n return (symbolKeys ??= Object.getOwnPropertySymbols(input)).filter(k => parameter.matchKey(k, options) !== undefined);\n case \"Union\":\n return [...new Set(parameter.types.flatMap(go))];\n default:\n return [];\n }\n }\n return go(parameterFromPropertyKey(toEncoded(parameter)));\n}\n/**\n * Constructs a {@link PropertySignature}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const PropertySignature = class {\n name;\n type;\n constructor(name, type) {\n this.name = name;\n this.type = type;\n }\n};\nfunction isIndexSignatureParameterSide(ast) {\n switch (ast._tag) {\n case \"String\":\n case \"Number\":\n case \"Symbol\":\n case \"TemplateLiteral\":\n return true;\n case \"Union\":\n return ast.types.every(isIndexSignatureParameterSide);\n default:\n return false;\n }\n}\nfunction isIndexSignatureParameterEncodedSide(ast) {\n const encoded = getLastEncoding(ast);\n switch (encoded._tag) {\n case \"String\":\n case \"Number\":\n case \"Symbol\":\n case \"TemplateLiteral\":\n return true;\n case \"Union\":\n return encoded.types.every(isIndexSignatureParameterEncodedSide);\n default:\n return false;\n }\n}\nfunction isIndexSignatureParameter(ast) {\n return isIndexSignatureParameterSide(ast) && isIndexSignatureParameterEncodedSide(ast);\n}\n/**\n * Constructs a {@link IndexSignature}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const IndexSignature = class {\n parameter;\n type;\n constructor(parameter, type) {\n if (!isIndexSignatureParameter(parameter)) {\n throw new Error(`Invalid index signature parameter ${parameter._tag}`);\n }\n this.parameter = parameter;\n this.type = type;\n if (isOptional(type) && !containsUndefined(type)) {\n throw new Error(\"Cannot use `Schema.optionalKey` with index signatures, use `Schema.optional` instead.\");\n }\n }\n};\n/**\n * Constructs a {@link Objects}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Objects = class extends ASTNodeImpl {\n _tag = \"Objects\";\n propertySignatures;\n indexSignatures;\n encodingChecks;\n constructor(propertySignatures, indexSignatures, annotations, checks, encoding, context, encodingChecks) {\n super(annotations, checks, encoding, context);\n this.propertySignatures = propertySignatures;\n this.indexSignatures = indexSignatures;\n this.encodingChecks = encodingChecks;\n // Duplicate property signatures\n const seen = new Set();\n const duplicates = [];\n for (const propertySignature of propertySignatures) {\n const name = propertySignature.name;\n if (seen.has(name)) {\n duplicates.push(name);\n } else {\n seen.add(name);\n }\n }\n if (duplicates.length > 0) {\n throw new Error(`Duplicate identifiers: ${JSON.stringify(duplicates)}. ts(2300)`);\n }\n }\n /** @internal */\n getParser(compile, compileConstructorDefault = compile) {\n // oxlint-disable-next-line @typescript-eslint/no-this-alias\n const ast = this;\n const expectedKeys = [];\n for (const ps of ast.propertySignatures) {\n expectedKeys.push(typeof ps.name === \"number\" ? globalThis.String(ps.name) : ps.name);\n }\n const hasProperties = expectedKeys.length;\n const indexCount = ast.indexSignatures.length;\n let expectedKeysSet = hasProperties && indexCount ? new Set(expectedKeys) : undefined;\n // ---------------------------------------------\n // handle empty struct\n // ---------------------------------------------\n if (!hasProperties && !indexCount) {\n return fromRefinement(ast, Predicate.isNotNullish);\n }\n let properties;\n let indexes;\n const finishIndex = (s, key, k2, inputValue, exitValue) => {\n if (exitValue._tag === \"Failure\") {\n return wrapPropertyKeyIssue(s, ast, key, exitValue) ?? Exit.void;\n }\n const value = exitValue === InternalParser.sameExit ? inputValue : exitValue[InternalParser.args];\n if (k2 !== InternalParser.missing && value !== InternalParser.missing) {\n if (hasProperties && (expectedKeysSet.has(key) || expectedKeysSet.has(typeof k2 === \"number\" ? globalThis.String(k2) : k2))) return Exit.void;\n InternalRecord.assignProperty(s.out, k2, value);\n }\n return Exit.void;\n };\n const parseIndex = (s, key, index, exitKey) => {\n if (!exitKey) {\n const eff = index.parserKey(key, s.options);\n if (!effectIsExit(eff)) {\n return Effect.flatMap(Effect.exit(eff), exit => parseIndex(s, key, index, exit));\n }\n exitKey = eff;\n }\n if (exitKey._tag === \"Failure\") {\n return wrapPropertyKeyIssue(s, ast, key, exitKey) ?? Exit.void;\n }\n const k2 = exitKey === InternalParser.sameExit ? key : exitKey[InternalParser.args];\n const inputValue = s.input[key];\n const result = index.parserValue(inputValue, s.options);\n return effectIsExit(result) ? finishIndex(s, key, k2, inputValue, result) : Effect.flatMap(Effect.exit(result), exit => finishIndex(s, key, k2, inputValue, exit));\n };\n const parseStringIndex = (s, key, index) => {\n const inputValue = s.input[key];\n const result = index.parserValue(inputValue, s.options);\n return effectIsExit(result) ? finishIndex(s, key, key, inputValue, result) : Effect.flatMap(Effect.exit(result), exit => finishIndex(s, key, key, inputValue, exit));\n };\n const parseIndexes = indexCount ? iterateConcurrent()({\n onItem: (s, [key, index]) => index.is.parameter === string ? parseStringIndex(s, key, index) : parseIndex(s, key, index),\n step: (_s, _item, exit) => exit._tag === \"Failure\" ? exit : undefined\n }) : undefined;\n const compileMembers = () => {\n if (!properties) {\n properties = ast.propertySignatures.map(ps => ({\n parser: compileConstructorDefault(ps.type),\n name: ps.name,\n type: ps.type\n }));\n indexes = indexCount ? ast.indexSignatures.map(is => ({\n is,\n parserKey: compile(parameterFromPropertyKey(is.parameter)),\n parserValue: compileConstructorDefault(is.type)\n })) : undefined;\n }\n return properties;\n };\n const fallback = Effect.fnUntracedEager(function* (input, options) {\n if (input === InternalParser.missing) {\n return InternalParser.missing;\n }\n // If the input is not a record, return early with an error\n if (!(typeof input === \"object\" && input !== null && !Array.isArray(input))) {\n return yield* Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n }\n compileMembers();\n const record = input;\n const out = {};\n const state = {\n ast,\n input: record,\n out,\n issues: undefined,\n options\n };\n const errorsAllOption = options.errors === \"all\";\n const onExcessPropertyError = options.onExcessProperty === \"error\";\n const concurrency = options.concurrency === undefined ? 1 : resolveConcurrency(options.concurrency);\n // ---------------------------------------------\n // handle excess properties\n // ---------------------------------------------\n const indexKeys = indexCount && onExcessPropertyError ? ast.indexSignatures.map(index => getIndexSignatureKeys(record, index.parameter, options)) : undefined;\n if (onExcessPropertyError) {\n expectedKeysSet ??= new Set(expectedKeys);\n const coveredKeys = indexKeys ? new Set(expectedKeysSet) : expectedKeysSet;\n if (indexKeys) {\n for (const keys of indexKeys) {\n for (const key of keys) coveredKeys.add(key);\n }\n }\n const inputKeys = Reflect.ownKeys(record);\n for (let i = 0; i < inputKeys.length; i++) {\n const key = inputKeys[i];\n if (!coveredKeys.has(key)) {\n // key is unexpected\n const unexpected = new SchemaIssue.UnexpectedKey(ast, record[key], options);\n const issue = new SchemaIssue.Pointer([key], unexpected);\n if (errorsAllOption) {\n if (state.issues) {\n state.issues.push(issue);\n } else {\n state.issues = [issue];\n }\n continue;\n } else {\n return yield* Effect.fail(new SchemaIssue.Composite(ast, [issue], input, options));\n }\n }\n }\n }\n // ---------------------------------------------\n // handle property signatures\n // ---------------------------------------------\n if (hasProperties) {\n const eff = concurrency === 1 ? parseProperties(state, properties) : parsePropertiesConcurrent(state, properties, {\n concurrency\n });\n if (eff) yield* eff;\n }\n // ---------------------------------------------\n // handle index signatures\n // ---------------------------------------------\n if (indexCount && concurrency === 1) {\n for (let i = 0; i < indexCount; i++) {\n const index = indexes[i];\n const parse = index.is.parameter === string ? parseStringIndex : parseIndex;\n const keys = indexKeys?.[i] ?? (index.is.parameter === string ? Object.keys(record) : getIndexSignatureKeys(record, index.is.parameter, options));\n for (let j = 0; j < keys.length; j++) {\n const eff = parse(state, keys[j], index);\n if (!effectIsExit(eff)) yield* eff;else if (eff._tag === \"Failure\") return yield* eff;\n }\n }\n } else if (parseIndexes) {\n const keyPairs = Arr.empty();\n for (let i = 0; i < indexCount; i++) {\n const index = indexes[i];\n const keys = indexKeys?.[i] ?? (index.is.parameter === string ? Object.keys(record) : getIndexSignatureKeys(record, index.is.parameter, options));\n for (let j = 0; j < keys.length; j++) {\n keyPairs.push([keys[j], index]);\n }\n }\n const eff = parseIndexes(state, keyPairs, {\n concurrency\n });\n if (eff) yield* eff;\n }\n if (state.issues) {\n return yield* Effect.fail(new SchemaIssue.Composite(ast, state.issues, input, options));\n }\n return out;\n });\n if (indexCount) return fallback;\n // Resumes at the property whose parser suspended, without replaying the\n // properties already parsed.\n const resume = (state, index, pending) => {\n const property = properties[index];\n return Effect.flatMap(Effect.exit(pending), exit => {\n const terminal = stepProperty(state, property, exit);\n if (terminal) return terminal;\n const done = () => InternalParser.succeed(state.out);\n const eff = parseProperties(state, properties.slice(index + 1));\n return eff ? Effect.flatMapEager(eff, done) : done();\n });\n };\n // Fast path: a struct without index signatures, under the default parse\n // options, needs none of the generator the fallback runs per value.\n return (input, options) => {\n if (input === InternalParser.missing) return InternalParser.missingExit;\n if (options.errors === \"all\" || options.onExcessProperty !== undefined || options.concurrency !== undefined && resolveConcurrency(options.concurrency) !== 1) {\n return fallback(input, options);\n }\n if (!(typeof input === \"object\" && input !== null && !Array.isArray(input))) {\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n }\n const props = compileMembers();\n const record = input;\n const out = {};\n const state = {\n ast,\n input: record,\n out,\n issues: undefined,\n options\n };\n try {\n for (let index = 0; index < props.length; index++) {\n const property = props[index];\n const name = property.name;\n const hasKey = hasPropertySignature(record, name);\n const value = hasKey ? record[name] : InternalParser.missing;\n const exit = property.parser(value, options);\n if (!effectIsExit(exit)) {\n return resume(state, index, exit);\n }\n if (exit === InternalParser.sameExit) {\n if (hasKey) InternalRecord.assignProperty(out, name, value);\n continue;\n }\n const terminal = stepProperty(state, property, exit);\n if (terminal) return terminal;\n }\n } catch (error) {\n // `Effect.fnUntracedEager` turns a synchronous throw into a defect\n return Effect.die(error);\n }\n return InternalParser.succeed(out);\n };\n }\n _rebuild(recur, recurParameter, checks, encodingChecks) {\n const props = mapOrSame(this.propertySignatures, ps => {\n const t = recur(ps.type);\n return t === ps.type ? ps : new PropertySignature(ps.name, t);\n });\n const indexes = mapOrSame(this.indexSignatures, is => {\n const p = recurParameter(is.parameter);\n const t = recur(is.type);\n return p === is.parameter && t === is.type ? is : new IndexSignature(p, t);\n });\n return props === this.propertySignatures && indexes === this.indexSignatures && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Objects(props, indexes, this.annotations, checks, undefined, this.context, encodingChecks);\n }\n /** @internal */\n flip(recur) {\n return this._rebuild(recur, recur, this.encodingChecks, this.checks);\n }\n /** @internal */\n recur(recur, recurParameter = recur) {\n return this._rebuild(recur, recurParameter, this.checks, this.encodingChecks);\n }\n /** @internal */\n getExpected() {\n if (this.propertySignatures.length === 0 && this.indexSignatures.length === 0) return \"object | array\";\n return \"object\";\n }\n};\nfunction stepProperty(s, p, exit) {\n if (exit._tag === \"Failure\") {\n return wrapPropertyKeyIssue(s, s.ast, p.name, exit);\n }\n if (exit === InternalParser.sameExit) return;\n const value = exit[InternalParser.args];\n if (value !== InternalParser.missing) {\n InternalRecord.assignProperty(s.out, p.name, value);\n return;\n }\n delete s.out[p.name];\n if (!isOptional(p.type)) {\n const issue = new SchemaIssue.Pointer([p.name], new SchemaIssue.MissingKey(p.type.context?.annotations));\n if (s.options.errors === \"all\") {\n if (s.issues) s.issues.push(issue);else s.issues = [issue];\n return;\n } else {\n return Exit.fail(new SchemaIssue.Composite(s.ast, [issue], s.input, s.options));\n }\n }\n}\nconst parsePropertiesOptions = {\n onItem(s, p) {\n if (!hasPropertySignature(s.input, p.name)) {\n return p.parser(InternalParser.missing, s.options);\n }\n const value = s.input[p.name];\n InternalRecord.assignProperty(s.out, p.name, value);\n return p.parser(value, s.options);\n },\n step: stepProperty\n};\nconst parseProperties = /*#__PURE__*/iterateEager()(parsePropertiesOptions);\nconst parsePropertiesConcurrent = /*#__PURE__*/iterateConcurrent()(parsePropertiesOptions);\nfunction combineChecks(a, b) {\n if (!a) return b;\n if (!b) return a;\n return [...a, ...b];\n}\n/** @internal */\nexport function struct(fields, checks, annotations) {\n return new Objects(Reflect.ownKeys(fields).map(key => {\n return new PropertySignature(key, fields[key].ast);\n }), [], annotations, checks);\n}\n/** @internal */\nexport function getAST(self) {\n return self.ast;\n}\n/** @internal */\nexport function tuple(elements, checks = undefined) {\n return new Arrays(false, elements.map(e => e.ast), [], undefined, checks);\n}\n/** @internal */\nexport function union(members, options, checks) {\n return new Union(members.map(getAST), options, undefined, checks);\n}\n/** @internal */\nexport function structWithRest(ast, records) {\n if (ast.encoding || records.some(r => r.encoding)) {\n throw new Error(\"StructWithRest does not support encodings\");\n }\n let propertySignatures = ast.propertySignatures;\n let indexSignatures = ast.indexSignatures;\n let checks = ast.checks;\n for (const record of records) {\n propertySignatures = propertySignatures.concat(record.propertySignatures);\n indexSignatures = indexSignatures.concat(record.indexSignatures);\n checks = combineChecks(checks, record.checks);\n }\n return new Objects(propertySignatures, indexSignatures, undefined, checks);\n}\n/** @internal */\nexport function tupleWithRest(ast, rest) {\n if (ast.encoding) {\n throw new Error(\"TupleWithRest does not support encodings\");\n }\n return new Arrays(ast.isMutable, ast.elements, rest, undefined, ast.checks);\n}\n/** @internal */\nexport function mutable(ast) {\n if (ast.encoding) {\n throw new Error(\"mutable does not support encodings\");\n }\n return new Arrays(true, ast.elements, ast.rest, ast.annotations, ast.checks, undefined, ast.context, ast.encodingChecks);\n}\nconst toCandidate = /*#__PURE__*/memoizeIdempotent(ast => {\n while (true) {\n if (isSuspend(ast)) return unknown;\n const encoding = ast.encoding;\n if (!encoding) {\n // Index signature parameters do not participate in union selection.\n return ast.recur?.(toCandidate, identity) ?? ast;\n }\n if (encoding.some(link => link.transformation._tag === \"Middleware\" && link.transformation.decode !== identity)) return unknown;\n ast = encoding[encoding.length - 1].to;\n }\n});\nfunction getCandidateTypes(ast) {\n switch (ast._tag) {\n case \"Null\":\n return [\"null\"];\n case \"Undefined\":\n return [\"undefined\"];\n case \"String\":\n case \"TemplateLiteral\":\n return [\"string\"];\n case \"Number\":\n return [\"number\"];\n case \"Boolean\":\n return [\"boolean\"];\n case \"Symbol\":\n case \"UniqueSymbol\":\n return [\"symbol\"];\n case \"BigInt\":\n return [\"bigint\"];\n case \"Arrays\":\n return [\"array\"];\n case \"ObjectKeyword\":\n return [\"object\", \"array\", \"function\"];\n case \"Objects\":\n return ast.propertySignatures.length || ast.indexSignatures.length ? [\"object\"] : [\"string\", \"number\", \"boolean\", \"symbol\", \"bigint\", \"object\", \"array\", \"function\"];\n case \"Enum\":\n return Array.from(new Set(ast.enums.map(([, v]) => typeof v)));\n case \"Literal\":\n return [typeof ast.literal];\n case \"Union\":\n return Array.from(new Set(ast.types.flatMap(getCandidateTypes)));\n default:\n return [\"null\", \"undefined\", \"string\", \"number\", \"boolean\", \"symbol\", \"bigint\", \"object\", \"array\", \"function\"];\n }\n}\n/** @internal */\nexport function collectSentinels(ast) {\n switch (ast._tag) {\n default:\n return [];\n case \"Declaration\":\n {\n const s = ast.annotations?.[InternalAnnotations.SENTINELS_ANNOTATION_KEY];\n return Array.isArray(s) ? s : [];\n }\n case \"Objects\":\n return ast.propertySignatures.flatMap(ps => {\n const type = ps.type;\n if (!isOptional(type)) {\n if (isLiteral(type)) {\n return [{\n key: ps.name,\n literal: type.literal\n }];\n }\n if (isUniqueSymbol(type)) {\n return [{\n key: ps.name,\n literal: type.symbol\n }];\n }\n }\n return [];\n });\n case \"Arrays\":\n return ast.elements.flatMap((e, i) => {\n if (!isOptional(e)) {\n if (isLiteral(e)) {\n return [{\n key: i,\n literal: e.literal\n }];\n }\n if (isUniqueSymbol(e)) {\n return [{\n key: i,\n literal: e.symbol\n }];\n }\n }\n return [];\n });\n case \"Union\":\n {\n if (ast.types.length === 0) return [];\n const members = ast.types.map(type => collectSentinels(toCandidate(type)));\n return members[0].filter(s => members.every(sentinels => sentinels.some(o => o.key === s.key && o.literal === s.literal)));\n }\n case \"Suspend\":\n return collectSentinels(ast.thunk());\n }\n}\nconst candidateIndexCache = /*#__PURE__*/new WeakMap();\nconst emptyCandidates = /*#__PURE__*/Object.freeze([]);\nconst hasPropertySignature = (input, key) => key === \"__proto__\" ? Object.hasOwn(input, key) : key in input;\nfunction getIndex(types) {\n let index = candidateIndexCache.get(types);\n if (index) return index;\n let bySentinel;\n let sentinelCandidateCount = 0;\n let otherwise;\n let literalCandidates;\n let onlyLiterals = true;\n for (let i = 0; i < types.length; i++) {\n const a = types[i];\n const encoded = toCandidate(a);\n if (isNever(encoded)) continue;\n if (onlyLiterals) {\n if (isLiteral(encoded) || isUniqueSymbol(encoded)) {\n literalCandidates ??= new Map();\n const literal = isLiteral(encoded) ? encoded.literal : encoded.symbol;\n let arr = literalCandidates.get(literal);\n if (!arr) literalCandidates.set(literal, arr = []);\n arr.push(a);\n } else {\n onlyLiterals = false;\n }\n }\n const sentinels = collectSentinels(encoded);\n if (sentinels.length) {\n // discriminated variants\n bySentinel ??= new Map();\n sentinelCandidateCount++;\n for (const {\n key,\n literal\n } of sentinels) {\n let entry = bySentinel.get(key);\n if (!entry) bySentinel.set(key, entry = [new Map(), new Set()]);\n entry[1].add(i);\n let indexes = entry[0].get(literal);\n if (!indexes) entry[0].set(literal, indexes = new Set());\n indexes.add(i);\n }\n } else {\n // non-discriminated\n otherwise ??= {};\n const candidateTypes = getCandidateTypes(encoded);\n for (const t of candidateTypes) (otherwise[t] ??= []).push(i);\n }\n }\n if (onlyLiterals && literalCandidates) {\n literalCandidates.forEach(Object.freeze);\n index = input => literalCandidates.get(input) ?? emptyCandidates;\n } else if (bySentinel?.size === 1 && !otherwise) {\n const [key, [byValue]] = bySentinel.entries().next().value;\n const candidates = byValue;\n for (const [literal, indexes] of byValue) {\n candidates.set(literal, Object.freeze(Array.from(indexes, index => types[index])));\n }\n index = (input, isConstructor) => {\n if (Predicate.isObjectKeyword(input)) {\n const value = hasPropertySignature(input, key) ? input[key] : undefined;\n if (value !== undefined) return candidates.get(value) ?? emptyCandidates;\n if (isConstructor) return types;\n }\n return emptyCandidates;\n };\n } else if (bySentinel) {\n // A key owned by every discriminated candidate is safe to use as the initial selector: no candidate can\n // be excluded merely because it uses a different sentinel key. Prefer the key with the most distinct values\n // to minimize the matching bucket.\n let commonSentinel;\n for (const entry of bySentinel) {\n if ((!commonSentinel || entry[1][0].size > commonSentinel[1][0].size) && entry[1][1].size === sentinelCandidateCount) {\n commonSentinel = entry;\n }\n }\n index = (input, isConstructor) => {\n const runtimeType = input === null ? \"null\" : Array.isArray(input) ? \"array\" : typeof input;\n const base = otherwise?.[runtimeType] ?? emptyCandidates;\n if (!Predicate.isObjectKeyword(input)) return base.map(i => types[i]);\n // Non-discriminated candidates are runtime-type fallbacks and are never removed by sentinel checks.\n const selected = new Set(base);\n let directKey;\n // An observed common key can seed the selection directly; an unknown value rules out every\n // discriminated candidate.\n if (commonSentinel) {\n const [key, [byValue]] = commonSentinel;\n const hasKey = hasPropertySignature(input, key);\n const value = hasKey ? input[key] : undefined;\n if (hasKey && (!isConstructor || value !== undefined)) {\n const match = byValue.get(value);\n if (!match) return base.map(i => types[i]);\n for (const i of match) selected.add(i);\n directKey = key;\n }\n }\n // Without an observed common key, collect positive matches from every sentinel. Constructor mode treats\n // absent and undefined keys as unconstrained and therefore selects every candidate that owns the key.\n if (directKey === undefined) {\n for (const [key, [byValue, all]] of bySentinel) {\n const hasKey = hasPropertySignature(input, key);\n const value = hasKey ? input[key] : undefined;\n if (hasKey && (!isConstructor || value !== undefined)) {\n const match = byValue.get(value);\n if (match) {\n for (const i of match) selected.add(i);\n }\n } else if (isConstructor) {\n for (const i of all) selected.add(i);\n }\n }\n }\n // Missing keys are neutral. An observed key rejects only selected candidates that own it and do not match.\n for (const [key, [byValue, all]] of bySentinel) {\n if (key === directKey) continue;\n const hasKey = hasPropertySignature(input, key);\n const value = hasKey ? input[key] : undefined;\n if (hasKey && (!isConstructor || value !== undefined)) {\n const match = byValue.get(value);\n for (const i of selected) {\n if (all.has(i) && !match?.has(i)) selected.delete(i);\n }\n }\n }\n return Array.from(selected).sort((a, b) => a - b).map(i => types[i]);\n };\n } else {\n index = input => {\n const runtimeType = input === null ? \"null\" : Array.isArray(input) ? \"array\" : typeof input;\n return (otherwise?.[runtimeType] ?? emptyCandidates).map(i => types[i]).filter(filterLiterals(input));\n };\n }\n candidateIndexCache.set(types, index);\n return index;\n}\nfunction filterLiterals(input) {\n return ast => {\n const encoded = toCandidate(ast);\n return encoded._tag === \"Literal\" ? encoded.literal === input : encoded._tag === \"UniqueSymbol\" ? encoded.symbol === input : true;\n };\n}\n/**\n * The goal is to reduce the number of a union members that will be checked.\n * This is useful to reduce the number of issues that will be returned.\n *\n * @internal\n */\nexport function getCandidates(input, types, isConstructor = false) {\n return getIndex(types)(input, isConstructor);\n}\n/**\n * Constructs a {@link Union}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Union = class extends ASTNodeImpl {\n _tag = \"Union\";\n types;\n options;\n encodingChecks;\n constructor(types, options, annotations, checks, encoding, context, encodingChecks) {\n super(annotations, checks, encoding, context);\n this.types = types;\n this.options = options;\n this.encodingChecks = encodingChecks;\n }\n /** @internal */\n getParser(compile, compileConstructorDefault) {\n // oxlint-disable-next-line @typescript-eslint/no-this-alias\n const ast = this;\n return (input, options) => {\n if (input === InternalParser.missing) {\n return InternalParser.missingExit;\n }\n const candidates = getCandidates(input, ast.types, compileConstructorDefault !== undefined);\n if (candidates.length === 0) {\n return Effect.fail(new SchemaIssue.AnyOf(ast, [], input, options));\n }\n if (candidates.length === 1) {\n const result = compile(candidates[0])(input, options);\n if (result._tag === \"Success\") return result;\n return effectIsExit(result) ? failSingleUnionCandidate(ast, result.cause, input, options) : Effect.catchCause(result, cause => failSingleUnionCandidate(ast, cause, input, options));\n }\n const state = {\n ast,\n compile,\n input,\n out: undefined,\n successes: ast.options?.mode === \"oneOf\" ? [] : undefined,\n issues: undefined,\n options\n };\n const eff = parseUnion(state, candidates);\n if (!eff) {\n if (state.out) return state.out;\n return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options));\n }\n return Effect.flatMapEager(eff, _ => {\n if (state.out === InternalParser.sameExit) return Effect.succeed(input);\n if (state.out) return state.out;\n return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options));\n });\n };\n }\n _rebuild(recur, checks, encodingChecks) {\n const types = mapOrSame(this.types, recur);\n return types === this.types && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Union(types, this.options, this.annotations, checks, undefined, this.context, encodingChecks);\n }\n /** @internal */\n recur(recur) {\n return this._rebuild(recur, this.checks, this.encodingChecks);\n }\n /** @internal */\n flip(recur) {\n return this._rebuild(recur, this.encodingChecks, this.checks);\n }\n /** @internal */\n matchPart(s, options) {\n for (const type of this.types) {\n const out = type.matchPart(s, options);\n if (out !== undefined) return out;\n }\n return undefined;\n }\n /** @internal */\n getExpected(getExpected) {\n const expected = this.annotations?.expected;\n if (typeof expected === \"string\") return expected;\n if (this.types.length === 0) return \"never\";\n const types = this.types.map(type => {\n const encoded = toEncoded(type);\n switch (encoded._tag) {\n case \"Arrays\":\n {\n const literals = encoded.elements.filter(isLiteral);\n if (literals.length > 0) {\n return `${formatIsMutable(encoded.isMutable)}[ ${literals.map(e => getExpected(e) + formatIsOptional(e.context?.isOptional)).join(\", \")}, ... ]`;\n }\n break;\n }\n case \"Objects\":\n {\n const literals = encoded.propertySignatures.filter(ps => isLiteral(ps.type));\n if (literals.length > 0) {\n return `{ ${literals.map(ps => `${formatIsMutable(ps.type.context?.isMutable)}${formatPropertyKey(ps.name)}${formatIsOptional(ps.type.context?.isOptional)}: ${getExpected(ps.type)}`).join(\", \")}, ... }`;\n }\n break;\n }\n }\n return getExpected(encoded);\n });\n return Array.from(new Set(types)).join(\" | \");\n }\n};\nfunction failSingleUnionCandidate(ast, cause, input, options) {\n const issue = InternalSchemaCause.getSchemaIssue(cause);\n if (!issue) return Exit.failCause(cause);\n return Exit.fail(new SchemaIssue.AnyOf(ast, [issue], input, options));\n}\nconst parseUnion = /*#__PURE__*/iterateEager()({\n onItem(s, ast) {\n const parser = s.compile(ast);\n return parser(s.input, s.options);\n },\n step(s, candidate, exit) {\n if (exit._tag === \"Failure\") {\n const issue = InternalSchemaCause.getSchemaIssue(exit.cause);\n if (issue === undefined) {\n return exit;\n }\n if (s.issues) s.issues.push(issue);else s.issues = [issue];\n } else {\n if (s.out && s.successes) {\n s.successes.push(candidate);\n return Exit.fail(new SchemaIssue.OneOf(s.ast, s.successes, s.input, s.options));\n }\n s.out = exit;\n if (s.successes) {\n s.successes.push(candidate);\n } else {\n return Exit.void;\n }\n }\n }\n});\nconst nonFiniteLiterals = /*#__PURE__*/new Union([/*#__PURE__*/new Literal(\"Infinity\"), /*#__PURE__*/new Literal(\"-Infinity\"), /*#__PURE__*/new Literal(\"NaN\")]);\nfunction formatIsMutable(isMutable) {\n return isMutable ? \"\" : \"readonly \";\n}\nfunction formatIsOptional(isOptional) {\n return isOptional ? \"?\" : \"\";\n}\n/**\n * Constructs a {@link Suspend}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Suspend = class extends ASTNodeImpl {\n _tag = \"Suspend\";\n thunk;\n constructor(thunk, annotations, checks, encoding, context) {\n if (checks) {\n throw new Error(\"Cannot add checks to Suspend\");\n }\n super(annotations, undefined, encoding, context);\n let ast;\n this.thunk = () => ast ??= thunk();\n }\n /** @internal */\n getParser(compile) {\n let parser;\n return (input, options) => (parser ??= compile(this.thunk()))(input, options);\n }\n /** @internal */\n recur(recur) {\n return new Suspend(() => recur(this.thunk()), this.annotations, undefined, undefined, this.context);\n }\n /** @internal */\n getExpected(getExpected) {\n return getExpected(this.thunk());\n }\n};\n/**\n * Constructs a {@link Filter}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Filter = class extends Pipeable.Class {\n _tag = \"Filter\";\n run;\n annotations;\n /**\n * Whether the parsing process should be aborted after this check has failed.\n */\n aborted;\n constructor(run, annotations = undefined,\n /**\n * Whether the parsing process should be aborted after this check has failed.\n */\n aborted = false) {\n super();\n this.run = run;\n this.annotations = annotations;\n this.aborted = aborted;\n }\n annotate(annotations) {\n return new Filter(this.run, {\n ...this.annotations,\n ...annotations\n }, this.aborted);\n }\n abort() {\n return new Filter(this.run, this.annotations, true);\n }\n and(other, annotations) {\n return new FilterGroup([this, other], annotations);\n }\n};\n/**\n * Constructs a {@link FilterGroup}.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const FilterGroup = class extends Pipeable.Class {\n _tag = \"FilterGroup\";\n checks;\n annotations;\n constructor(checks, annotations = undefined) {\n super();\n this.checks = checks;\n this.annotations = annotations;\n }\n annotate(annotations) {\n return new FilterGroup(this.checks, {\n ...this.annotations,\n ...annotations\n });\n }\n and(other, annotations) {\n return new FilterGroup([this, other], annotations);\n }\n};\n/** @internal */\nexport function makeFilter(filter, annotations, aborted = false) {\n return new Filter((input, ast, options) => SchemaIssue.normalizeFilterOutput(ast, filter(input, ast, options), input, options), annotations, aborted);\n}\n/** @internal */\nexport function makeFilterByGuard(is, annotations) {\n return new Filter((input, _ast, options) => is(input) ? undefined : new SchemaIssue.InvalidValue(undefined, input, options), annotations, true // after a guard, we always want to abort\n );\n}\n/** @internal */\nexport function isFinite(annotations) {\n return makeFilter(n => globalThis.Number.isFinite(n), {\n expected: \"a finite number\",\n representation: {\n id: \"effect/schema/isFinite\",\n payload: null\n },\n toJsonSchema: () => ({\n type: \"number\"\n }),\n toCode: () => ({\n runtime: \"Schema.isFinite()\"\n }),\n arbitraryConstraint: {\n number: \"finite\"\n },\n ...annotations\n });\n}\n/** @internal */\nexport const finite = /*#__PURE__*/appendChecks(number, [/*#__PURE__*/isFinite()]);\nconst numberToJson = /*#__PURE__*/new Link(/*#__PURE__*/new Union([finite, nonFiniteLiterals]), /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.Number(), /*#__PURE__*/SchemaGetter.transform(n => globalThis.Number.isFinite(n) ? n : globalThis.String(n))));\n/**\n * Creates a {@link Filter} that validates strings by running `RegExp.test`.\n *\n * **When to use**\n *\n * Use when string validation should be represented as a schema `Filter` backed\n * by a regular expression.\n *\n * **Details**\n *\n * The filter can be used with `Schema.filter` or attached directly to a\n * `String` AST node through checks. The regular expression is cloned and its\n * `lastIndex` is reset before each test, so global and sticky expressions are\n * deterministic and the provided regular expression is not mutated. The\n * regular expression source is stored in annotations for serialization and\n * arbitrary generation.\n *\n * **Gotchas**\n *\n * Arbitrary metadata preserves both `regExp.source` and `regExp.flags`.\n * Implementations that cannot consume all flags may still use the source as a\n * generation hint because the Schema filter validates every generated value.\n * JSON Schema has no way to carry JavaScript regular-expression flags. The\n * generated `pattern` contains the source only, so validation can differ when\n * the RegExp uses flags or relies on JavaScript's non-Unicode behavior.\n *\n * **Example** (Validating an email pattern)\n *\n * ```ts import.meta.vitest\n * import { SchemaAST } from \"effect\"\n *\n * const emailFilter = SchemaAST.isPattern(/^[^@]+@[^@]+$/)\n * emailFilter.run(\"alice@example.com\", SchemaAST.string, {}) // => undefined\n * emailFilter.run(\"invalid\", SchemaAST.string, {})?._tag // => \"InvalidValue\"\n * ```\n *\n * @see {@link Filter}\n * @category constructors\n * @since 4.0.0\n */\nexport function isPattern(regExp, annotations) {\n const source = regExp.source;\n const pattern = new globalThis.RegExp(source, regExp.flags);\n return makeFilter(s => {\n pattern.lastIndex = 0;\n return pattern.test(s);\n }, {\n expected: `a string matching the RegExp ${source}`,\n representation: {\n id: \"effect/schema/isPattern\",\n payload: {\n source,\n flags: regExp.flags\n }\n },\n toJsonSchema: () => ({\n pattern: source\n }),\n arbitraryConstraint: {\n patterns: [{\n source: regExp.source,\n flags: regExp.flags\n }]\n },\n ...annotations\n });\n}\nfunction modifyOwnPropertyDescriptors(ast, f) {\n const d = Object.getOwnPropertyDescriptors(ast);\n f(d);\n return Object.create(Object.getPrototypeOf(ast), d);\n}\nconst contextOwners = /*#__PURE__*/new WeakMap();\n/** @internal */\nexport function getContextOwner(ast) {\n return contextOwners.get(ast) ?? ast;\n}\n/** @internal */\nexport function replaceEncoding(ast, encoding) {\n if (ast.encoding === encoding) {\n return ast;\n }\n return modifyOwnPropertyDescriptors(ast, d => {\n d.encoding.value = encoding;\n });\n}\n/** @internal */\nexport function replaceContext(ast, context) {\n if (ast.context === context) {\n return ast;\n }\n const owner = getContextOwner(ast);\n if (owner.context === context) {\n return owner;\n }\n const out = modifyOwnPropertyDescriptors(ast, d => {\n d.context.value = context;\n });\n contextOwners.set(out, owner);\n return out;\n}\n/** @internal */\nexport function getLastEncoding(ast) {\n return ast.encoding ? getLastEncoding(ast.encoding[ast.encoding.length - 1].to) : ast;\n}\n/** @internal */\nexport function annotate(ast, annotations) {\n if (ast.checks) {\n const last = ast.checks[ast.checks.length - 1];\n return replaceChecks(ast, Arr.append(ast.checks.slice(0, -1), last.annotate(annotations)));\n }\n return modifyOwnPropertyDescriptors(ast, d => {\n d.annotations.value = {\n ...d.annotations.value,\n ...annotations\n };\n });\n}\n/** @internal */\nexport function replaceChecks(ast, checks) {\n if (ast._tag === \"Suspend\" && checks) {\n throw new Error(\"Cannot add checks to Suspend\");\n }\n if (ast.checks === checks) {\n return ast;\n }\n return modifyOwnPropertyDescriptors(ast, d => {\n d.checks.value = checks;\n });\n}\n/** @internal */\nexport function appendChecks(ast, checks) {\n return replaceChecks(ast, combineChecks(ast.checks, checks));\n}\n/** @internal */\nexport function mapLink(link, f) {\n const to = f(link.to);\n return to === link.to ? link : new Link(to, link.transformation);\n}\nfunction updateLastLink(encoding, f) {\n const links = encoding;\n const last = links[links.length - 1];\n const out = mapLink(last, f);\n return out === last ? encoding : Arr.append(encoding.slice(0, encoding.length - 1), out);\n}\n/** @internal */\nexport function applyToLastLink(f) {\n return ast => ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, f)) : ast;\n}\n/** @internal */\nexport function replaceContextLastLink(ast, context) {\n return applyToLastLink(ast => replaceContext(ast, context))(ast);\n}\n/** @internal */\nexport function applyToSelfOrLastLinkEncoding(f) {\n function out(ast) {\n return ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, out)) : f(ast);\n }\n return memoize(out);\n}\n/** @internal */\nexport function applyToSelfOrLastLinkEncodingIdempotent(f, options) {\n function out(ast) {\n if (ast.encoding) {\n const last = ast.encoding[ast.encoding.length - 1];\n return options?.stopAt?.(last) ? ast : replaceEncoding(ast, updateLastLink(ast.encoding, out));\n }\n return f(ast);\n }\n return memoizeIdempotent(out);\n}\n/** @internal */\nexport function middlewareDecoding(ast, middleware) {\n return appendTransformation(ast, middleware, toType(ast));\n}\n/** @internal */\nexport function middlewareEncoding(ast, middleware) {\n return appendTransformation(toEncoded(ast), middleware, ast);\n}\nfunction appendTransformation(from, transformation, to) {\n const link = new Link(from, transformation);\n return replaceEncoding(to, to.encoding ? [...to.encoding, link] : [link]);\n}\n/** @internal */\nexport function brand(ast, brand) {\n const existing = InternalAnnotations.resolveBrands(ast);\n const brands = existing ? [...existing, brand] : [brand];\n return annotate(ast, {\n brands\n });\n}\nexport function mapOrSame(as, f) {\n let changed = false;\n const out = new Array(as.length);\n for (let i = 0; i < as.length; i++) {\n const a = as[i];\n const fa = f(a);\n if (fa !== a) {\n changed = true;\n }\n out[i] = fa;\n }\n return changed ? out : as;\n}\n/** @internal */\nexport function annotateKey(ast, annotations) {\n const context = ast.context ? new Context(ast.context.isOptional, ast.context.isMutable, ast.context.constructorDefault, {\n ...ast.context.annotations,\n ...annotations\n }) : new Context(false, false, undefined, annotations);\n return replaceContext(ast, context);\n}\n/** @internal */\nexport const optionalKey = /*#__PURE__*/memoizeIdempotent(ast => {\n const context = ast.context ? ast.context.isOptional === false ? new Context(true, ast.context.isMutable, ast.context.constructorDefault, ast.context.annotations) : ast.context : new Context(true, false);\n return optionalKeyLastLink(replaceContext(ast, context));\n});\nconst optionalKeyLastLink = /*#__PURE__*/applyToLastLink(optionalKey);\n/** @internal */\nexport const optional = /*#__PURE__*/memoize(ast => optionalKey(new Union([ast, undefined_])));\n/** @internal */\nexport const mutableKey = /*#__PURE__*/memoizeIdempotent(ast => {\n const context = ast.context ? ast.context.isMutable === false ? new Context(ast.context.isOptional, true, ast.context.constructorDefault, ast.context.annotations) : ast.context : new Context(false, true);\n return mutableKeyLastLink(replaceContext(ast, context));\n});\nconst mutableKeyLastLink = /*#__PURE__*/applyToLastLink(mutableKey);\n/** @internal */\nexport function withConstructorDefault(ast, defaultValue) {\n const transformation = new SchemaTransformation.Transformation(SchemaGetter.withDefault(defaultValue), SchemaGetter.passthrough());\n const constructorDefault = new Link(unknown, transformation);\n const context = ast.context ? new Context(ast.context.isOptional, ast.context.isMutable, constructorDefault, ast.context.annotations) : new Context(false, false, constructorDefault);\n return replaceContext(ast, context);\n}\n/**\n * Attaches a `Transformation` to the `to` AST, making it decode from the\n * `from` AST and encode back to it.\n *\n * **Details**\n *\n * This is the low-level primitive behind `Schema.decodeTo`. It appends a\n * {@link Link} to the `to` node's encoding chain.\n *\n * - Returns a new AST with the same type as `to`.\n *\n * @see {@link Link}\n * @see {@link Encoding}\n * @see {@link flip}\n * @category transforming\n * @since 4.0.0\n */\nexport function decodeTo(from, to, transformation) {\n return appendTransformation(from, transformation, to);\n}\nfunction parseParameter(ast) {\n const literals = [];\n const parameters = [];\n function go(ast) {\n switch (ast._tag) {\n case \"Literal\":\n if (Predicate.isPropertyKey(ast.literal)) {\n literals.push(ast.literal);\n }\n return;\n case \"UniqueSymbol\":\n literals.push(ast.symbol);\n return;\n case \"Never\":\n return;\n case \"Union\":\n for (let i = 0; i < ast.types.length; i++) {\n go(ast.types[i]);\n }\n return;\n default:\n parameters.push(ast);\n }\n }\n go(ast);\n return {\n literals,\n parameters\n };\n}\n/** @internal */\nexport function record(key, value) {\n const {\n literals,\n parameters: indexSignatures\n } = parseParameter(key);\n return new Objects(literals.map(literal => new PropertySignature(literal, value)), indexSignatures.map(parameter => new IndexSignature(parameter, value)));\n}\n// -------------------------------------------------------------------------------------\n// Public APIs\n// -------------------------------------------------------------------------------------\n/**\n * Returns `true` if the AST node represents an optional property.\n *\n * **Details**\n *\n * Checks `ast.context?.isOptional`. Defaults to `false` when no\n * {@link Context} is set.\n *\n * @see `Schema.optionalKey`\n * @see {@link Context}\n * @category predicates\n * @since 4.0.0\n */\nexport function isOptional(ast) {\n return ast.context?.isOptional ?? false;\n}\n/** @internal */\nexport function isMutable(ast) {\n return ast.context?.isMutable ?? false;\n}\nfunction isStructuralCheck(check) {\n return check.annotations?.[InternalAnnotations.STRUCTURAL_ANNOTATION_KEY] === true || check._tag === \"FilterGroup\" && check.checks.every(isStructuralCheck);\n}\nfunction extractStructuralChecks(checks) {\n function extract(check) {\n if (isStructuralCheck(check)) return [check];\n return check._tag === \"FilterGroup\" ? check.checks.flatMap(extract) : [];\n }\n const out = checks.flatMap(extract);\n return Arr.isArrayNonEmpty(out) ? out : undefined;\n}\n/**\n * Strips all encoding transformations from an AST, returning the decoded\n * (type-level) representation.\n *\n * **Details**\n *\n * - Memoized: same input reference → same output reference.\n * - Recursively walks into composite nodes ({@link Arrays}, {@link Objects},\n * {@link Union}, {@link Suspend}).\n *\n * **Example** (Getting the type AST)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaAST } from \"effect\"\n *\n * const schema = Schema.NumberFromString\n * const typeAst = SchemaAST.toType(schema.ast)\n * typeAst._tag // => \"Number\"\n * ```\n *\n * @see {@link toEncoded}\n * @see {@link flip}\n * @category transforming\n * @since 4.0.0\n */\nexport const toType = /*#__PURE__*/memoizeIdempotent(ast => {\n if (ast.encoding) {\n return toType(replaceEncoding(ast, undefined));\n }\n const out = ast;\n const type = out.recur?.(toType) ?? out;\n const encodingChecks = type.encodingChecks;\n if (encodingChecks) {\n const checks = type === ast ? encodingChecks : isArrays(type) || isObjects(type) || isDeclaration(type) && type.typeParameters.length > 0 ? extractStructuralChecks(encodingChecks) : undefined;\n return modifyOwnPropertyDescriptors(type, d => {\n d.encodingChecks.value = undefined;\n d.checks.value = combineChecks(type.checks, checks);\n });\n }\n return type;\n});\n/**\n * Returns the encoded (wire-format) AST by flipping and then stripping\n * encodings.\n *\n * **Details**\n *\n * Equivalent to `toType(flip(ast))`. This gives you the AST that describes\n * the shape of the serialized/encoded data.\n *\n * - Memoized: same input reference → same output reference.\n *\n * **Example** (Getting the encoded AST)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaAST } from \"effect\"\n *\n * const schema = Schema.NumberFromString\n * const encodedAst = SchemaAST.toEncoded(schema.ast)\n * encodedAst._tag // => \"String\"\n * ```\n *\n * @see {@link toType}\n * @see {@link flip}\n * @category transforming\n * @since 4.0.0\n */\nexport const toEncoded = /*#__PURE__*/memoizeIdempotent(ast => {\n return toType(flip(ast));\n});\nfunction flipEncoding(ast, encoding) {\n const links = encoding;\n const len = links.length;\n const last = links[len - 1];\n const ls = [new Link(flip(replaceEncoding(ast, undefined)), links[0].transformation.flip())];\n for (let i = 1; i < len; i++) {\n ls.unshift(new Link(flip(links[i - 1].to), links[i].transformation.flip()));\n }\n const to = flip(last.to);\n if (to.encoding) {\n return replaceEncoding(to, [...to.encoding, ...ls]);\n } else {\n return replaceEncoding(to, ls);\n }\n}\n/**\n * Swaps the decode and encode directions of an AST's {@link Encoding} chain.\n *\n * **Details**\n *\n * After flipping, what was decoding becomes encoding and vice versa. This is\n * the core operation behind `Schema.encode` — encoding a value is decoding\n * with a flipped SchemaAST.\n *\n * - Memoized: same input reference → same output reference.\n * - Recursively walks composite nodes.\n *\n * @see {@link toType}\n * @see {@link toEncoded}\n * @category transforming\n * @since 4.0.0\n */\nexport const flip = /*#__PURE__*/memoize(ast => {\n if (ast.encoding) {\n return flipEncoding(ast, ast.encoding);\n }\n const out = ast;\n return out.flip?.(flip) ?? out.recur?.(flip) ?? out;\n});\n/** @internal */\nexport function containsUndefined(ast) {\n switch (ast._tag) {\n case \"Undefined\":\n return true;\n case \"Union\":\n return ast.types.some(containsUndefined);\n default:\n return false;\n }\n}\nfunction fromConst(ast, value) {\n const succeed = value === 0 ? InternalParser.sameExit : InternalParser.succeed(value);\n return (input, options) => {\n if (input === InternalParser.missing) return InternalParser.missingExit;\n if (input === value) return succeed;\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n };\n}\nfunction fromRefinement(ast, refinement) {\n return (input, options) => {\n if (input === InternalParser.missing) return InternalParser.missingExit;\n if (refinement(input)) return InternalParser.sameExit;\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n };\n}\nfunction segmentTemplateLiteralParts(ast, input, options) {\n const parts = ast.encodedParts;\n const literals = ast.literals;\n const inputLength = input.length;\n for (let i = 0; i < literals.length; i++) {\n const literal = literals[i];\n if (literal && !input.includes(literal)) return undefined;\n }\n if (ast.suffixLengths[0] > inputLength) return undefined;\n const out = new Array(parts.length);\n let failures;\n function go(i, pos) {\n if (i === parts.length) return pos === inputLength;\n if (failures?.has(i * (inputLength + 1) + pos)) return false;\n const part = parts[i];\n if (i === parts.length - 1) {\n const s = input.slice(pos);\n if (part.matchPart(s, options) !== undefined) {\n out[i] = s;\n return true;\n }\n } else if (part._tag === \"Literal\") {\n const s = literals[i];\n if (input.startsWith(s, pos) && go(i + 1, pos + s.length)) {\n out[i] = s;\n return true;\n }\n } else {\n const maximumEnd = inputLength - ast.suffixLengths[i + 1];\n // Splits preceding a literal only need to consider occurrences of that literal.\n const anchor = literals[i + 1];\n let end = anchor === undefined ? maximumEnd : input.lastIndexOf(anchor, maximumEnd);\n while (end >= pos) {\n const s = input.slice(pos, end);\n if (part.matchPart(s, options) !== undefined && go(i + 1, end)) {\n out[i] = s;\n return true;\n }\n if (end === 0) break;\n end = anchor === undefined ? end - 1 : input.lastIndexOf(anchor, end - 1);\n }\n }\n failures ??= new Set();\n failures.add(i * (inputLength + 1) + pos);\n return false;\n }\n return go(0, 0) ? out : undefined;\n}\nconst parameterFromPropertyKey = /*#__PURE__*/applyToSelfOrLastLinkEncodingIdempotent(ast => {\n switch (ast._tag) {\n default:\n return ast;\n case \"Number\":\n return ast.toCodecStringTree();\n case \"Union\":\n return ast.recur(parameterFromPropertyKey);\n }\n});\n/** @internal */\nexport const parameterFromString = /*#__PURE__*/applyToSelfOrLastLinkEncodingIdempotent(ast => {\n switch (ast._tag) {\n default:\n return ast;\n case \"Symbol\":\n case \"UniqueSymbol\":\n return ast.toCodecStringTree();\n case \"Union\":\n return ast.recur(parameterFromString);\n }\n});\nconst partFromString = /*#__PURE__*/applyToSelfOrLastLinkEncodingIdempotent(ast => {\n switch (ast._tag) {\n default:\n return ast;\n case \"Number\":\n case \"Literal\":\n case \"BigInt\":\n return ast.toCodecStringTree();\n case \"Union\":\n return ast.recur(partFromString);\n }\n});\n/**\n * any string, including newlines\n * @internal\n */\nexport const STRING_PATTERN = \"[\\\\s\\\\S]*?\";\nconst isStringFiniteRegExp = /*#__PURE__*/new globalThis.RegExp(`^${FINITE_PATTERN}$`);\nconst isStringNumberRegExp = /*#__PURE__*/new globalThis.RegExp(`^(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)$`);\n/** @internal */\nexport function isStringFinite(annotations) {\n return isPattern(isStringFiniteRegExp, {\n expected: \"a string representing a finite number\",\n representation: {\n id: \"effect/schema/isStringFinite\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: isStringFiniteRegExp.source\n }),\n ...annotations\n });\n}\nconst finiteString = /*#__PURE__*/appendChecks(string, [/*#__PURE__*/isStringFinite()]);\nconst finiteToString = /*#__PURE__*/new Link(finiteString, SchemaTransformation.numberFromString);\nconst numberToString = /*#__PURE__*/new Link(/*#__PURE__*/new Union([finiteString, nonFiniteLiterals]), SchemaTransformation.numberFromString);\n/**\n * signed integer only (no leading \"+\" because TypeScript doesn't support it)\n */\nconst BIGINT_PATTERN = \"-?\\\\d+\";\nconst isStringBigIntRegExp = /*#__PURE__*/new globalThis.RegExp(`^${BIGINT_PATTERN}$`);\n/** @internal */\nexport function isStringBigInt(annotations) {\n return isPattern(isStringBigIntRegExp, {\n expected: \"a string representing a bigint\",\n representation: {\n id: \"effect/schema/isStringBigInt\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: isStringBigIntRegExp.source\n }),\n ...annotations\n });\n}\n/** @internal */\nexport const bigIntString = /*#__PURE__*/appendChecks(string, [/*#__PURE__*/isStringBigInt({\n expected: \"a string representing a bigint\"\n})]);\nconst bigIntToString = /*#__PURE__*/new Link(bigIntString, SchemaTransformation.bigintFromString);\nconst REGEXP_PATTERN = \"Symbol\\\\(([\\\\s\\\\S]*)\\\\)\";\nconst isStringSymbolRegExp = /*#__PURE__*/new globalThis.RegExp(`^${REGEXP_PATTERN}$`);\n/** @internal */\nexport const symbolString = /*#__PURE__*/appendChecks(string, [/*#__PURE__*/isStringSymbol()]);\n/**\n * to distinguish between Symbol and String, we need to add a check to the string keyword\n */\nconst symbolToString = /*#__PURE__*/new Link(symbolString, /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(description => globalThis.Symbol.for(isStringSymbolRegExp.exec(description)[1])), /*#__PURE__*/SchemaGetter.transformEffect((sym, options) => {\n const key = globalThis.Symbol.keyFor(sym);\n if (key !== undefined) {\n return Effect.succeed(globalThis.String(sym));\n }\n return Effect.fail(new SchemaIssue.Forbidden({\n message: \"cannot serialize to string, Symbol is not registered\"\n }, sym, options));\n})));\n/** @internal */\nexport function isStringSymbol(annotations) {\n return isPattern(isStringSymbolRegExp, {\n expected: \"a string representing a symbol\",\n representation: {\n id: \"effect/schema/isStringSymbol\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: isStringSymbolRegExp.source\n }),\n ...annotations\n });\n}\n/** @internal */\nexport function collectIssues(checks, value, issues, ast, options) {\n for (let i = 0; i < checks.length; i++) {\n const check = checks[i];\n if (check._tag === \"FilterGroup\") {\n issues = collectIssues(check.checks, value, issues, ast, options);\n if (issues && (options.errors !== \"all\" || issues[issues.length - 1].filter.aborted)) {\n return issues;\n }\n } else {\n const issue = check.run(value, ast, options);\n if (issue) {\n const filter = new SchemaIssue.Filter(check, issue, value, options);\n if (issues) issues.push(filter);else issues = [filter];\n if (options.errors !== \"all\" || check.aborted) {\n return issues;\n }\n }\n }\n }\n return issues;\n}\n/** @internal */\nexport function runChecks(checks, s) {\n const issues = collectIssues(checks, s, undefined, unknown, {\n errors: \"all\"\n });\n if (issues) {\n const issue = new SchemaIssue.Composite(unknown, issues);\n return Result.fail(issue);\n }\n return Result.succeed(s);\n}\n/** @internal */\nexport function getConstructorDescriptor(ast) {\n if (!isDeclaration(ast)) return undefined;\n const getDescriptor = ast.annotations?.[InternalAnnotations.CONSTRUCTOR_ANNOTATION_KEY];\n return Predicate.isFunction(getDescriptor) ? getDescriptor(ast.typeParameters) : undefined;\n}\n/**\n * Returns all annotations from the AST node.\n *\n * **Details**\n *\n * If the node has {@link Checks}, returns annotations from the last check\n * (which is where user-supplied annotations end up after `.pipe(Schema.annotations(...))`).\n * Otherwise returns the node's `annotations` directly.\n *\n * **Example** (Reading annotations)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaAST } from \"effect\"\n *\n * const schema = Schema.String.annotate({ title: \"Name\" })\n * const annotations = SchemaAST.resolve(schema.ast)\n * annotations?.title // => \"Name\"\n * ```\n *\n * @see {@link resolveAt}\n * @see {@link resolveIdentifier}\n * @see {@link resolveTitle}\n * @see {@link resolveDescription}\n * @category annotations\n * @since 4.0.0\n */\nexport const resolve = InternalAnnotations.resolve;\n/**\n * Returns a single annotation value by key from the AST node.\n *\n * **Details**\n *\n * Like {@link resolve}, reads from the last check's annotations when checks\n * are present. Returns `undefined` if the key is not found.\n *\n * @see {@link resolve}\n * @category annotations\n * @since 4.0.0\n */\nexport const resolveAt = InternalAnnotations.resolveAt;\n/**\n * Returns the `identifier` annotation from the AST node, if set.\n *\n * **Details**\n *\n * The identifier is typically set by `Schema.annotations({ identifier: \"...\" })`\n * and is used for error messages and schema identification.\n *\n * @see {@link resolve}\n * @see {@link resolveTitle}\n * @category annotations\n * @since 4.0.0\n */\nexport const resolveIdentifier = InternalAnnotations.resolveIdentifier;\n/**\n * Returns the `title` annotation from the AST node, if set.\n *\n * @see {@link resolve}\n * @see {@link resolveIdentifier}\n * @see {@link resolveDescription}\n *\n * @category annotations\n * @since 4.0.0\n */\nexport const resolveTitle = InternalAnnotations.resolveTitle;\n/**\n * Returns the `description` annotation from the AST node, if set.\n *\n * @see {@link resolve}\n * @see {@link resolveTitle}\n * @see {@link resolveIdentifier}\n *\n * @category annotations\n * @since 4.0.0\n */\nexport const resolveDescription = InternalAnnotations.resolveDescription;\nfunction isJsonLeaf(u) {\n return u === null || typeof u === \"string\" || typeof u === \"boolean\" || typeof u === \"number\" && globalThis.Number.isFinite(u);\n}\nfunction isStringTreeLeaf(u) {\n return u === undefined || typeof u === \"string\";\n}\nfunction isTree(u, isLeaf) {\n const cache = new WeakMap();\n const stack = [];\n outer: while (true) {\n if (typeof u !== \"object\" || u === null) {\n if (!isLeaf(u)) {\n return false;\n }\n } else {\n const value = u;\n const cached = cache.get(value);\n // `false` marks a node on the current path, while `true` marks a fully\n // validated node that can be safely reused by a DAG.\n if (cached === false) {\n return false;\n }\n if (cached === undefined) {\n const isArray = Array.isArray(value);\n if (!isArray) {\n const prototype = Object.getPrototypeOf(value);\n // A plain object from another realm has a different Object.prototype,\n // but that prototype still has a null prototype.\n if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {\n return false;\n }\n }\n cache.set(value, false);\n stack.push({\n value,\n keys: isArray ? value.length : Object.keys(value),\n index: 0\n });\n }\n }\n while (stack.length > 0) {\n const frame = stack[stack.length - 1];\n const keys = frame.keys;\n if (typeof keys === \"number\") {\n if (frame.index < keys) {\n // A sparse slot is read as `undefined`; the leaf predicate determines\n // whether that is valid for the current tree.\n u = frame.value[frame.index++];\n continue outer;\n }\n } else if (frame.index < keys.length) {\n u = frame.value[keys[frame.index++]];\n continue outer;\n }\n cache.set(frame.value, true);\n stack.pop();\n }\n return true;\n }\n}\n/**\n * Returns true if the value is a JSON value.\n *\n * When a cyclic reference is detected, returns false.\n *\n * @internal\n */\nexport function isJson(u) {\n return isTree(u, isJsonLeaf);\n}\n/** @internal */\nexport const Json = /*#__PURE__*/new Declaration([], () => (input, ast, options) => isJson(input) ? InternalParser.sameExit : Effect.fail(new SchemaIssue.InvalidType(ast, input, options)), {\n representation: {\n id: \"effect/schema/Json\",\n payload: null\n },\n expected: \"JSON value\",\n toCodecJson: () => undefined,\n toCodecStringTree: () => unknownToStringTree\n});\n/** @internal */\nexport const MutableJson = /*#__PURE__*/annotate(Json, {\n representation: {\n id: \"effect/schema/MutableJson\",\n payload: null\n }\n});\n/** @internal */\nexport const unknownToJson = /*#__PURE__*/new Link(Json, /*#__PURE__*/SchemaTransformation.passthrough());\n/** @internal */\nexport const objectKeywordToJson = /*#__PURE__*/new Link(/*#__PURE__*/new Union([/*#__PURE__*/new Arrays(false, [], [Json]), /*#__PURE__*/new Objects([], [/*#__PURE__*/new IndexSignature(string, Json)])]), /*#__PURE__*/SchemaTransformation.passthrough());\n/**\n * Returns true if the value is a StringTree value.\n *\n * When a cyclic reference is detected, returns false.\n *\n * @internal\n */\nexport function isStringTree(u) {\n return isTree(u, isStringTreeLeaf);\n}\nconst StringTree = /*#__PURE__*/new Declaration([], () => (input, ast, options) => isStringTree(input) ? InternalParser.sameExit : Effect.fail(new SchemaIssue.InvalidType(ast, input, options)), {\n expected: \"StringTree\",\n toCodecStringTree: () => undefined\n});\n/** @internal */\nexport const unknownToStringTree = /*#__PURE__*/new Link(StringTree, /*#__PURE__*/SchemaTransformation.passthrough());\n//# sourceMappingURL=SchemaAST.js.map","/**\n * The `Brand` module adds compile-time names to ordinary TypeScript values so\n * structurally identical values cannot be mixed accidentally. A branded value\n * has the same runtime representation as its unbranded value; the extra\n * information lives in the type system unless you choose a validating\n * constructor.\n *\n * @since 2.0.0\n */\nimport * as Arr from \"./Array.js\";\nimport * as Option from \"./Option.js\";\nimport * as Result from \"./Result.js\";\nimport * as SchemaAST from \"./SchemaAST.js\";\nimport * as SchemaIssue from \"./SchemaIssue.js\";\nconst TypeId = \"~effect/Brand\";\n/**\n * Error returned when a branded type is constructed from an invalid value.\n *\n * **Details**\n *\n * The error wraps a `SchemaIssue.Issue`, renders `message` with the default\n * schema issue formatter, and formats as `BrandError()`.\n *\n * **Gotchas**\n *\n * `BrandError` is an error-like model with `_tag`, `name`, `message`, and\n * `toString`; it does not extend JavaScript `Error`.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class BrandError {\n constructor(issue) {\n this.issue = issue;\n }\n /**\n * Discriminant used to identify brand construction failures.\n *\n * @since 4.0.0\n */\n _tag = \"BrandError\";\n /**\n * Error name used by tools that inspect JavaScript error-like objects.\n *\n * @since 4.0.0\n */\n name = \"BrandError\";\n /**\n * Schema issue describing why brand validation failed.\n *\n * @since 4.0.0\n */\n issue;\n /**\n * Human-readable rendering of the validation issue.\n *\n * @since 4.0.0\n */\n get message() {\n return SchemaIssue.defaultFormatter(this.issue);\n }\n /**\n * Formats the brand error together with its validation message.\n *\n * @since 4.0.0\n */\n toString() {\n return `BrandError(${this.message})`;\n }\n}\n/**\n * Returns a `Constructor` that **does not apply any runtime checks** and just\n * returns the provided value.\n *\n * **When to use**\n *\n * Use to create nominal types that allow distinguishing between two values\n * of the same type but with different meanings.\n *\n * @see {@link make} for constructing branded values with validation.\n * @see {@link check} for constructing branded values from schema checks.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function nominal() {\n return Object.assign(input => input, {\n option: input => Option.some(input),\n result: input => Result.succeed(input),\n is: _ => true\n });\n}\n/**\n * Returns a `Constructor` that can construct a branded type from an unbranded\n * value using the provided `filter` predicate as validation of the input data.\n *\n * **When to use**\n *\n * Use when you want validation while constructing the branded type.\n *\n * @see {@link nominal} for a brand constructor that performs no validation.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function make(filter) {\n return check(SchemaAST.makeFilter(filter));\n}\n/**\n * Creates a branded type `Constructor` from one or more schema checks.\n *\n * **When to use**\n *\n * Use when you need a branded type constructor that performs runtime validation\n * via schema checks.\n *\n * **Details**\n *\n * Calling the returned constructor validates the unbranded value and throws on\n * failure. Use the returned `option`, `result`, or `is` methods for\n * non-throwing validation.\n *\n * @see {@link nominal} for a brand constructor without runtime validation\n * @see {@link all} for combining multiple brand constructors\n * @category constructors\n * @since 4.0.0\n */\nexport function check(...checks) {\n const result = input => {\n return Result.mapError(SchemaAST.runChecks(checks, input), issue => new BrandError(issue));\n };\n return Object.assign(input => Result.getOrThrow(result(input)), {\n option: input => Option.getSuccess(result(input)),\n result,\n is: input => Result.isSuccess(result(input)),\n checks\n });\n}\n/**\n * Combines one or more brand constructors to form a single branded type.\n *\n * **When to use**\n *\n * Use to require an input to satisfy every runtime check collected by the\n * provided brand constructors.\n *\n * **Details**\n *\n * If the provided constructors contain runtime checks, the combined\n * constructor succeeds only when all checks pass. If no runtime checks are\n * present, it behaves as a nominal constructor.\n *\n * @category combining\n * @since 2.0.0\n */\nexport function all(...brands) {\n const checks = brands.flatMap(brand => brand.checks ?? []);\n return Arr.isArrayNonEmpty(checks) ? check(...checks) : nominal();\n}\n//# sourceMappingURL=Brand.js.map","/**\n * Service boundary for starting and controlling child processes.\n *\n * `ChildProcessSpawner` is the service used by `ChildProcess` commands to start\n * operating-system processes. A spawner turns a command description into a\n * handle that can write to stdin, read stdout and stderr, wait for exit, kill\n * the process, and manage whether the process keeps its parent alive. Platform\n * backends implement this service, while most application code uses the higher\n * level `ChildProcess` module.\n *\n * @since 4.0.0\n */\nimport * as Brand from \"../../Brand.js\";\nimport * as Context from \"../../Context.js\";\nimport * as Effect from \"../../Effect.js\";\nimport * as Inspectable from \"../../Inspectable.js\";\nimport * as Stream from \"../../Stream.js\";\n/**\n * Constructs branded child process `ExitCode` values.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const ExitCode = /*#__PURE__*/Brand.nominal();\n/**\n * Constructs branded child process `ProcessId` values.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const ProcessId = /*#__PURE__*/Brand.nominal();\nconst HandleTypeId = \"~effect/process/ChildProcessSpawner/ChildProcessHandle\";\nconst HandleProto = {\n [HandleTypeId]: HandleTypeId,\n ...Inspectable.BaseProto,\n toJSON() {\n return {\n _id: \"ChildProcessHandle\",\n pid: this.pid\n };\n }\n};\n/**\n * Constructs a new `ChildProcessHandle`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeHandle = params => Object.setPrototypeOf({\n ...params\n}, HandleProto);\n/**\n * Creates a `ChildProcessSpawner` service from a `spawn` function, deriving\n * helpers for exit codes and output collection from that implementation.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = spawn => {\n const streamString = (command, options) => spawn(command).pipe(Effect.map(handle => Stream.decodeText(options?.includeStderr === true ? handle.all : handle.stdout)), Stream.unwrap);\n const streamLines = (command, options) => Stream.splitLines(streamString(command, options));\n return ChildProcessSpawner.of({\n spawn,\n exitCode: command => Effect.scoped(Effect.flatMap(spawn(command), handle => handle.exitCode)),\n streamString,\n streamLines,\n lines: (command, options) => Stream.runCollect(streamLines(command, options)),\n string: (command, options) => Stream.mkString(streamString(command, options))\n });\n};\n/**\n * Service tag for child process spawning.\n *\n * @category services\n * @since 4.0.0\n */\nexport class ChildProcessSpawner extends /*#__PURE__*/Context.Service()(\"effect/process/ChildProcessSpawner\") {}\n//# sourceMappingURL=ChildProcessSpawner.js.map","/**\n * Describes child processes before they are started.\n *\n * A `Command` stores the executable, arguments, environment, standard streams,\n * working directory, and other process options. Commands can also be piped\n * together. A command is an `Effect`; running it asks the\n * `ChildProcessSpawner` service to start the process and returns a\n * `ChildProcessHandle`.\n *\n * @since 4.0.0\n */\nimport * as Context from \"../../Context.js\";\nimport * as Effectable from \"../../Effectable.js\";\nimport { dual } from \"../../Function.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport { ChildProcessSpawner } from \"./ChildProcessSpawner.js\";\nconst TypeId = \"~effect/process/ChildProcess\";\n// =============================================================================\n// Constructors\n// =============================================================================\nconst Proto = {\n ... /*#__PURE__*/Effectable.Prototype({\n label: \"Command\",\n evaluate(fiber) {\n return Context.getUnsafe(fiber.context, ChildProcessSpawner).spawn(this);\n }\n }),\n [TypeId]: TypeId\n};\n/**\n * Checks whether a value is a `Command`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isCommand = u => Predicate.hasProperty(u, TypeId);\n/**\n * Checks whether a command is a `StandardCommand`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isStandardCommand = command => command._tag === \"StandardCommand\";\n/**\n * Checks whether a command is a `PipedCommand`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isPipedCommand = command => command._tag === \"PipedCommand\";\nconst makeStandardCommand = (command, args, options) => Object.assign(Object.create(Proto), {\n _tag: \"StandardCommand\",\n command,\n args,\n options\n});\nconst makePipedCommand = (left, right, options = {}) => Object.assign(Object.create(Proto), {\n _tag: \"PipedCommand\",\n left,\n right,\n options\n});\n/**\n * Create a command from a template literal, options + template, or array form.\n *\n * **Details**\n *\n * This function supports three calling conventions:\n * 1. Template literal: `make\\`npm run build\\``\n * 2. Options + template literal: `make({ cwd: \"/app\" })\\`npm run build\\``\n * 3. Array form: `make(\"npm\", [\"run\", \"build\"], options?)`\n *\n * Template literals are not parsed until execution time, allowing parsing\n * errors to flow through Effect's error channel.\n *\n * **Example** (Creating commands)\n *\n * ```ts import.meta.vitest\n * import { ChildProcess } from \"effect/unstable/process\"\n *\n * // Template literal form\n * const cmd1 = ChildProcess.make`echo \"hello\"`\n *\n * // With options\n * const cmd2 = ChildProcess.make({ cwd: \"/tmp\" })`ls -la`\n *\n * // Array form\n * const cmd3 = ChildProcess.make(\"git\", [\"status\"])\n *\n * const result = [cmd1.command, cmd2.options.cwd, cmd3.args[0]] // => [\"echo\", \"/tmp\", \"status\"]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = function make(...args) {\n // Template literal form: make`command`\n if (isTemplateString(args[0])) {\n const [templates, ...expressions] = args;\n const tokens = parseTemplates(templates, expressions);\n return makeStandardCommand(tokens[0] ?? \"\", tokens.slice(1), {});\n }\n // Options form: make({ cwd: \"/tmp\" })`command`\n if (typeof args[0] === \"object\" && !Array.isArray(args[0]) && !isTemplateString(args[0])) {\n const options = args[0];\n return function (templates, ...expressions) {\n const tokens = parseTemplates(templates, expressions);\n return makeStandardCommand(tokens[0] ?? \"\", tokens.slice(1), options);\n };\n }\n // Standard form without arguments: make(\"command\", options?)\n if (typeof args[0] === \"string\" && !Array.isArray(args[1])) {\n const [command, options = {}] = args;\n return makeStandardCommand(command, [], options);\n }\n // Standard form with arguments: make(\"command\", [\"arg1\", \"arg2\"], options?)\n const [command, cmdArgs = [], options = {}] = args;\n return makeStandardCommand(command, cmdArgs, options);\n};\n/**\n * Pipes the output of one command to the input of another.\n *\n * **Details**\n *\n * By default, pipes `stdout` from the source to `stdin` of the destination.\n * Use the `options` parameter to customize which streams are connected.\n *\n * **Example** (Piping command output)\n *\n * ```ts import.meta.vitest\n * import { ChildProcess } from \"effect/unstable/process\"\n *\n * // Pipe stdout (default)\n * const pipeline1 = ChildProcess.make`cat file.txt`.pipe(\n * ChildProcess.pipeTo(ChildProcess.make`grep pattern`)\n * )\n *\n * // Pipe stderr instead of stdout\n * const pipeline2 = ChildProcess.make`my-program`.pipe(\n * ChildProcess.pipeTo(ChildProcess.make`grep error`, { from: \"stderr\" })\n * )\n *\n * // Pipe combined stdout and stderr\n * const pipeline3 = ChildProcess.make`my-program`.pipe(\n * ChildProcess.pipeTo(ChildProcess.make`tee output.log`, { from: \"all\" })\n * )\n *\n * const result = [pipeline1._tag, pipeline2.options.from, pipeline3.options.from]\n * result // => [\"PipedCommand\", \"stderr\", \"all\"]\n * ```\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const pipeTo = /*#__PURE__*/dual(args => isCommand(args[0]) && isCommand(args[1]), (self, that, options) => makePipedCommand(self, that, options ?? {}));\n/**\n * Prepends another command to a command.\n *\n * **Details**\n *\n * For pipelines, only the leftmost command is prefixed.\n *\n * **Example** (Prefixing commands)\n *\n * ```ts import.meta.vitest\n * import { ChildProcess } from \"effect/unstable/process\"\n *\n * const command = ChildProcess.make`echo \"foo\"`\n *\n * const prefixed = command.pipe(\n * ChildProcess.prefix`time`\n * )\n *\n * // now prefixed will execute `time echo \"foo\"`\n * const result = prefixed._tag === \"StandardCommand\" ? `${prefixed.command} ${prefixed.args[0]}` : prefixed._tag\n * result // => \"time echo\"\n * ```\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const prefix = function prefix(...args) {\n if (isCommand(args[0]) && args.length > 1) {\n const [self, ...rest] = args;\n const prefixSpec = parsePrefixArgs(rest);\n return applyPrefix(self, prefixSpec);\n }\n const prefixSpec = parsePrefixArgs(args);\n return self => applyPrefix(self, prefixSpec);\n};\nconst parsePrefixArgs = args => {\n if (isTemplateString(args[0])) {\n const [templates, ...expressions] = args;\n const tokens = parseTemplates(templates, expressions);\n return {\n command: tokens[0] ?? \"\",\n args: tokens.slice(1)\n };\n }\n const [command, cmdArgs = []] = args;\n return {\n command,\n args: cmdArgs\n };\n};\nconst applyPrefix = (self, prefixSpec) => {\n switch (self._tag) {\n case \"StandardCommand\":\n {\n return makeStandardCommand(prefixSpec.command, [...prefixSpec.args, self.command, ...self.args], self.options);\n }\n case \"PipedCommand\":\n {\n return makePipedCommand(applyPrefix(self.left, prefixSpec), self.right, self.options);\n }\n }\n};\n/**\n * Sets the current working directory for a command.\n *\n * **Details**\n *\n * For pipelines, applies to each command in the pipeline.\n *\n * **Example** (Setting command working directories)\n *\n * ```ts import.meta.vitest\n * import { ChildProcess } from \"effect/unstable/process\"\n *\n * const cmd = ChildProcess.make`ls -la`.pipe(\n * ChildProcess.setCwd(\"/tmp\")\n * )\n * const result = cmd._tag === \"StandardCommand\" && cmd.options.cwd // => \"/tmp\"\n * ```\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setCwd = /*#__PURE__*/dual(2, (self, cwd) => {\n switch (self._tag) {\n case \"StandardCommand\":\n {\n return makeStandardCommand(self.command, self.args, {\n ...self.options,\n cwd\n });\n }\n case \"PipedCommand\":\n {\n return makePipedCommand(setCwd(self.left, cwd), setCwd(self.right, cwd), self.options);\n }\n }\n});\n/**\n * Adds environment variables to a command, merging them with any existing\n * command environment and overriding duplicate keys.\n *\n * **Details**\n *\n * For pipelines, applies to each command in the pipeline.\n *\n * **Example** (Setting command environment variables)\n *\n * ```ts import.meta.vitest\n * import { ChildProcess } from \"effect/unstable/process\"\n *\n * const cmd = ChildProcess.make`node script.js`.pipe(\n * ChildProcess.setEnv({ NODE_ENV: \"test\" })\n * )\n * const result = cmd._tag === \"StandardCommand\" && cmd.options.env?.NODE_ENV // => \"test\"\n * ```\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setEnv = /*#__PURE__*/dual(2, (self, env) => {\n switch (self._tag) {\n case \"StandardCommand\":\n {\n const nextEnv = self.options.env === undefined ? env : {\n ...self.options.env,\n ...env\n };\n return makeStandardCommand(self.command, self.args, {\n ...self.options,\n env: nextEnv\n });\n }\n case \"PipedCommand\":\n {\n return makePipedCommand(setEnv(self.left, env), setEnv(self.right, env), self.options);\n }\n }\n});\nconst isTemplateString = u => Array.isArray(u) && \"raw\" in u && Array.isArray(u.raw);\n// =============================================================================\n// Utilities\n// =============================================================================\n/**\n * Parses an fd name like \"fd3\" to its numeric index.\n * Returns undefined if the name is invalid.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const parseFdName = name => {\n const match = /^fd(\\d+)$/.exec(name);\n if (match === null) return undefined;\n const fd = parseInt(match[1], 10);\n return fd >= 3 ? fd : undefined;\n};\n/**\n * Create an fd name from its numeric index.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fdName = fd => `fd${fd}`;\n// =============================================================================\n// Template Parsing\n// =============================================================================\nconst parseTemplates = (templates, expressions) => {\n let tokens = [];\n for (const [index, template] of templates.entries()) {\n tokens = parseTemplate(templates, expressions, tokens, template, index);\n }\n return tokens;\n};\nconst parseTemplate = (templates, expressions, prevTokens, template, index) => {\n const rawTemplate = templates.raw[index];\n if (rawTemplate === undefined) {\n throw new Error(`Invalid backslash sequence: ${templates.raw[index]}`);\n }\n const {\n hasLeadingWhitespace,\n hasTrailingWhitespace,\n tokens\n } = splitByWhitespaces(template, rawTemplate);\n const nextTokens = concatTokens(prevTokens, tokens, hasLeadingWhitespace);\n if (index === expressions.length) {\n return nextTokens;\n }\n const expression = expressions[index];\n const expressionTokens = Array.isArray(expression) ? expression.map(expression => parseExpression(expression)) : [parseExpression(expression)];\n return concatTokens(nextTokens, expressionTokens, hasTrailingWhitespace);\n};\n/**\n * Convert valid expressions defined in a template string command (i.e. using\n * `${expression}` into strings.\n */\nconst parseExpression = expression => {\n const type = typeof expression;\n if (type === \"string\") {\n return expression; // Return strings directly\n }\n return String(expression); // Convert numbers to strings\n};\nconst DELIMITERS = /*#__PURE__*/new Set([\" \", \"\\t\", \"\\r\", \"\\n\"]);\n/**\n * Number of characters in backslash escape sequences: \\0 \\xXX or \\uXXXX\n * \\cX is allowed in RegExps but not in strings\n * Octal sequences are not allowed in strict mode\n */\nconst ESCAPE_LENGTH = {\n x: 3,\n u: 5\n};\n/**\n * Splits a template string by whitespace while also properly handling escape\n * sequences.\n *\n * As an example, let's review the following valid commands:\n *\n * ```ts\n * ChildProcess.exec`echo foo\\n bar`\n * // We should run `[\"echo\", \"foo\\n\", \"bar\"]`\n *\n * ChildProcess.exec`echo foo\n * bar`\n * // We should run `[\"echo\", \"foo\", \"bar]`\n * ```\n *\n * The problem is that when we evaluate the template string for both of the above\n * commands, we will end up with the same string \"echo foo\\n bar\".\n *\n * What we really want is to include the escaped character in the arguments for\n * the first command, since it was written explicitly by the user.\n *\n * This is why also having access to the raw template string is useful - in a\n * template string, there are two representations of the same string:\n * 1. `template` - The processed string (escape sequences are evaluated).\n * 2. `template.raw` - The raw string (escape sequences are literal).\n */\nconst splitByWhitespaces = (template, rawTemplate) => {\n if (rawTemplate.length === 0) {\n return {\n tokens: [],\n hasLeadingWhitespace: false,\n hasTrailingWhitespace: false\n };\n }\n const hasLeadingWhitespace = DELIMITERS.has(rawTemplate[0]);\n const tokens = [];\n // Given that escape sequences will have different lengths in the template\n // versus the raw template, we must maintain two indices:\n // - One for the index into the template string\n // - One for the index into the raw template string\n // We also maintain the current cursor position for where we are in the template\n let templateCursor = 0;\n for (let templateIndex = 0, rawIndex = 0; templateIndex < template.length; templateIndex += 1, rawIndex += 1) {\n // Use the raw template character to check for actual whitespace\n const rawCharacter = rawTemplate[rawIndex];\n if (DELIMITERS.has(rawCharacter)) {\n // Whitespace found, extract token from template if necessary\n if (templateCursor !== templateIndex) {\n tokens.push(template.slice(templateCursor, templateIndex));\n }\n // Advance the template start index to the current position\n templateCursor = templateIndex + 1;\n } else if (rawCharacter === \"\\\\\") {\n // Escape sequence detected, check the next raw character\n const nextRawCharacter = rawTemplate[rawIndex + 1];\n if (nextRawCharacter === \"\\n\") {\n // Handle `\\` character followed by a newline (i.e. a line continuation) by:\n // - Reversing the template index (backslash-newline is erased in template)\n // - Advancing the raw template index past the line continuation\n templateIndex -= 1;\n rawIndex += 1;\n } else if (nextRawCharacter === \"u\" && rawTemplate[rawIndex + 2] === \"{\") {\n // Handle variable-length unicode escape sequences (i.e. `\\u{1F600}`) by:\n // - Advancing the template index an extra code unit for astral code points\n // - Advancing the raw template index past the unicode escape sequence\n const end = rawTemplate.indexOf(\"}\", rawIndex + 3);\n if (parseInt(rawTemplate.slice(rawIndex + 3, end), 16) > 0xffff) {\n templateIndex += 1;\n }\n rawIndex = end;\n } else {\n // Advance raw template index past fixed-length escape sequences:\n // - \\n → 2 chars (backslash + n)\n // - \\t → 2 chars (backslash + t)\n // - \\xHH → 4 chars (backslash + x + H + H)\n // - \\uHHHH → 6 chars (backslash + u + H + H + H + H)\n rawIndex += ESCAPE_LENGTH[nextRawCharacter] ?? 1;\n }\n }\n }\n // Trailing whitespace only exists if the template cursor is equivalent to the\n // length of the template\n const hasTrailingWhitespace = templateCursor === template.length;\n // If we did not end with trailing whitespace, ensure the final token is added\n if (!hasTrailingWhitespace) {\n tokens.push(template.slice(templateCursor));\n }\n return {\n tokens,\n hasLeadingWhitespace,\n hasTrailingWhitespace\n };\n};\n/**\n * Concatenates two separate sets of string tokens together.\n *\n * If either set is empty or `isSeparated=false`, the last element of `prevTokens`\n * and the first element of `nextTokens` will be joined into a single token.\n */\nconst concatTokens = (prevTokens, nextTokens, isSeparated) => isSeparated || prevTokens.length === 0 || nextTokens.length === 0\n// Keep the previous and next tokens separate from one another\n? [...prevTokens, ...nextTokens]\n// Join the last token from the previous set and the first token from the next set\n: [...prevTokens.slice(0, -1), `${prevTokens.at(-1)}${nextTokens.at(0)}`, ...nextTokens.slice(1)];\n//# sourceMappingURL=ChildProcess.js.map","export const buildSpawnOptions = (options, base, platform) => {\n const detached = options.detached ?? platform !== \"win32\";\n return {\n ...base,\n detached,\n shell: options.shell,\n windowsHide: options.windowsHide ?? !detached\n };\n};\n//# sourceMappingURL=nodeChildProcessSpawner.js.map","import * as PlatformError from \"effect/PlatformError\";\n/** @internal */\nexport const handleErrnoException = (module, method) => (err, [path]) => {\n let reason = \"Unknown\";\n switch (err.code) {\n case \"ENOENT\":\n reason = \"NotFound\";\n break;\n case \"EACCES\":\n reason = \"PermissionDenied\";\n break;\n case \"EEXIST\":\n reason = \"AlreadyExists\";\n break;\n case \"EISDIR\":\n reason = \"BadResource\";\n break;\n case \"ENOTDIR\":\n reason = \"BadResource\";\n break;\n case \"EBUSY\":\n reason = \"Busy\";\n break;\n case \"ELOOP\":\n reason = \"BadResource\";\n break;\n }\n return PlatformError.systemError({\n _tag: reason,\n module,\n method,\n pathOrDescriptor: path,\n syscall: err.syscall,\n cause: err\n });\n};\n//# sourceMappingURL=utils.js.map","import * as Cause from \"effect/Cause\";\nimport * as Channel from \"effect/Channel\";\nimport * as Effect from \"effect/Effect\";\nimport { identity } from \"effect/Function\";\nimport * as Pull from \"effect/Pull\";\nimport * as Sink from \"effect/Sink\";\n/**\n * Creates a `Sink` that writes chunks to a Node writable stream, respecting\n * backpressure, mapping writable errors with `onError`, and ending the stream\n * on completion unless `endOnDone` is `false`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromWritable = options => Sink.fromChannel(Channel.mapDone(fromWritableChannel(options), _ => [_]));\n/**\n * Creates a `Channel` that pulls chunks from upstream and writes them to a\n * Node writable stream, respecting backpressure and optionally ending the\n * writable when upstream is done.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromWritableChannel = options => Channel.fromTransform(pull => {\n const writable = options.evaluate();\n return Effect.succeed(pullIntoWritable({\n ...options,\n writable,\n pull\n }));\n});\n/**\n * Writes Effect chunks into a Node writable stream.\n *\n * **When to use**\n *\n * Use to implement custom Node stream adapters that already have an upstream\n * pull and need direct control over a writable stream.\n *\n * **Details**\n *\n * The loop waits for `drain` when needed, fails on writable errors, and ends\n * the writable on upstream completion unless `endOnDone` is `false`.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const pullIntoWritable = options => options.pull.pipe(Effect.flatMap(chunk => {\n let i = 0;\n return Effect.callback(resume => {\n let cancelled = false;\n const loop = () => {\n for (; i < chunk.length;) {\n if (cancelled) {\n return;\n }\n const success = options.writable.write(chunk[i++], options.encoding);\n if (!success) {\n if (!cancelled) {\n options.writable.once(\"drain\", loop);\n }\n return;\n }\n }\n if (!cancelled) {\n resume(Effect.void);\n }\n };\n loop();\n return Effect.sync(() => {\n cancelled = true;\n options.writable.off(\"drain\", loop);\n });\n });\n}), Effect.forever({\n disableYield: true\n}), options.endOnDone !== false ? Pull.catchDone(_ => {\n if (\"closed\" in options.writable && options.writable.closed) {\n return Cause.done(_);\n }\n return Effect.callback(resume => {\n const onFinish = () => resume(Cause.done(_));\n options.writable.once(\"finish\", onFinish);\n options.writable.end();\n return Effect.sync(() => {\n options.writable.off(\"finish\", onFinish);\n });\n });\n}) : identity, Effect.raceFirst(Effect.callback(resume => {\n const onError = error => resume(Effect.fail(options.onError(error)));\n options.writable.once(\"error\", onError);\n return Effect.sync(() => {\n options.writable.off(\"error\", onError);\n });\n})));\n//# sourceMappingURL=NodeSink.js.map","/**\n * Adapters between Node streams and Effect streams, channels, and readables.\n *\n * This module is the stream boundary for Node APIs. It wraps `Readable` and\n * `Duplex` values as Effect `Stream`s and `Channel`s, pipes Effect streams\n * through Node duplex streams, exposes an Effect `Stream` back to Node as a\n * `Readable`, and collects readable payloads into strings, array buffers, or\n * `Uint8Array`s with optional byte limits.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"effect/Array\";\nimport * as ByteSize from \"effect/ByteSize\";\nimport * as Cause from \"effect/Cause\";\nimport * as Channel from \"effect/Channel\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Exit from \"effect/Exit\";\nimport * as Fiber from \"effect/Fiber\";\nimport { dual } from \"effect/Function\";\nimport * as Latch from \"effect/Latch\";\nimport * as MutableRef from \"effect/MutableRef\";\nimport * as Pull from \"effect/Pull\";\nimport * as Scope from \"effect/Scope\";\nimport * as Stream from \"effect/Stream\";\nimport { Readable } from \"node:stream\";\nimport { pullIntoWritable } from \"./NodeSink.js\";\n/**\n * Converts a Node readable stream into an Effect `Stream`, reading chunks with\n * an optional chunk size, mapping stream errors with `onError`, and destroying\n * the readable on completion unless `closeOnDone` is `false`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromReadable = options => Stream.fromChannel(fromReadableChannel(options));\n/**\n * Creates a `Channel` that pulls chunks from a Node readable stream, mapping\n * errors with `onError` and destroying the readable on completion unless\n * `closeOnDone` is `false`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromReadableChannel = options => Channel.fromTransform((_, scope) => readableToPullUnsafe({\n scope,\n readable: options.evaluate(),\n onError: options.onError ?? defaultOnError,\n chunkSize: options.chunkSize,\n closeOnDone: options.closeOnDone\n}));\n/**\n * Creates a `Channel` over a Node `Duplex`, writing upstream chunks with\n * backpressure while emitting chunks read from the duplex and optionally ending\n * the writable side when upstream completes.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromDuplex = options => Channel.fromTransform((upstream, scope) => {\n const duplex = options.evaluate();\n const exit = MutableRef.make(undefined);\n const latch = Latch.makeUnsafe(false);\n return pullIntoWritable({\n pull: upstream,\n writable: duplex,\n onError: options.onError ?? defaultOnError,\n endOnDone: options.endOnDone,\n encoding: options.encoding\n }).pipe(Effect.catchCause(cause => {\n if (Pull.isDoneCause(cause)) return Effect.void;\n exit.current = Exit.failCause(cause);\n latch.openUnsafe();\n return Effect.void;\n }), Effect.forkIn(scope), Effect.flatMap(() => readableToPullUnsafe({\n scope,\n exit,\n latch,\n readable: duplex,\n onError: options.onError ?? defaultOnError,\n chunkSize: options.chunkSize\n })));\n});\n/**\n * Pipes an Effect `Stream` through a Node `Duplex`, writing the stream's\n * chunks to the duplex and emitting chunks read back from it.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const pipeThroughDuplex = /*#__PURE__*/dual(2, (self, options) => Stream.pipeThroughChannelOrFail(self, fromDuplex(options)));\n/**\n * Pipes a stream of strings or bytes through a Node `Duplex` using default\n * options and `Cause.UnknownError` for stream failures.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const pipeThroughSimple = /*#__PURE__*/dual(2, (self, duplex) => pipeThroughDuplex(self, {\n evaluate: duplex\n}));\n/**\n * Converts an Effect `Stream` into a Node `Readable`, using the caller's\n * Effect context to run the stream and destroying the readable if the stream\n * fails.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toReadable = stream => Effect.map(Effect.context(), context => new StreamAdapter(context, stream));\n/**\n * Converts a service-free Effect `Stream` into a Node `Readable` using an\n * empty Effect context.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toReadableNever = stream => new StreamAdapter(Context.empty(), stream);\n/**\n * Consumes a Node readable stream into a string using the selected encoding,\n * failing through `onError` on stream errors or when `maxBytes` is exceeded\n * and destroying the stream on interruption or failure.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toString = (readable, options) => {\n const maxBytesNumber = toMaxBytes(options?.maxBytes);\n const onError = options?.onError ?? defaultOnError;\n const encoding = options?.encoding ?? \"utf8\";\n return Effect.callback(resume => {\n const stream = readable();\n stream.setEncoding(encoding);\n stream.once(\"error\", err => {\n if (\"closed\" in stream && !stream.closed) {\n stream.destroy();\n }\n resume(Effect.fail(onError(err)));\n });\n let string = \"\";\n let bytes = 0;\n stream.once(\"end\", () => {\n resume(Effect.succeed(string));\n });\n stream.on(\"data\", chunk => {\n string += chunk;\n bytes += Buffer.byteLength(chunk);\n if (maxBytesNumber !== undefined && bytes > maxBytesNumber) {\n if (\"closed\" in stream && !stream.closed) {\n stream.destroy();\n }\n resume(Effect.fail(onError(new Error(\"maxBytes exceeded\"))));\n }\n });\n return Effect.sync(() => {\n if (\"closed\" in stream && !stream.closed) {\n stream.destroy();\n }\n });\n });\n};\n/**\n * Consumes a Node readable stream into an `ArrayBuffer`, failing through\n * `onError` on stream errors or when `maxBytes` is exceeded and destroying the\n * stream on interruption or failure.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toArrayBuffer = (readable, options) => {\n const maxBytesNumber = toMaxBytes(options?.maxBytes);\n const onError = options?.onError ?? defaultOnError;\n return Effect.callback(resume => {\n const stream = readable();\n const buffers = [];\n let bytes = 0;\n stream.once(\"error\", err => {\n if (\"closed\" in stream && !stream.closed) {\n stream.destroy();\n }\n resume(Effect.fail(onError(err)));\n });\n stream.once(\"end\", () => {\n const buffer = buffers.length === 1 ? buffers[0] : Buffer.concat(buffers);\n if (buffer.byteOffset === 0 && buffer.buffer.byteLength === buffer.byteLength) {\n return resume(Effect.succeed(buffer.buffer));\n }\n resume(Effect.succeed(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)));\n });\n stream.on(\"data\", chunk => {\n buffers.push(chunk);\n bytes += chunk.length;\n if (maxBytesNumber !== undefined && bytes > maxBytesNumber) {\n if (\"closed\" in stream && !stream.closed) {\n stream.destroy();\n }\n resume(Effect.fail(onError(new Error(\"maxBytes exceeded\"))));\n }\n });\n return Effect.sync(() => {\n if (\"closed\" in stream && !stream.closed) {\n stream.destroy();\n }\n });\n });\n};\n/**\n * Consumes a Node readable stream into a `Uint8Array`, using the same error\n * mapping and `maxBytes` handling as `toArrayBuffer`.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toUint8Array = (readable, options) => Effect.map(toArrayBuffer(readable, options), buffer => new Uint8Array(buffer));\n// ----------------------------------------------------------------------------\n// internal\n// ----------------------------------------------------------------------------\nconst readableToPullUnsafe = options => {\n const readable = options.readable;\n const closeOnDone = options.closeOnDone ?? true;\n const exit = options.exit ?? MutableRef.make(undefined);\n const latch = options.latch ?? Latch.makeUnsafe(false);\n function onReadable() {\n latch.openUnsafe();\n }\n function onError(error) {\n exit.current = Exit.fail(options.onError(error));\n latch.openUnsafe();\n }\n function onEnd() {\n exit.current = Exit.fail(Cause.Done());\n latch.openUnsafe();\n }\n readable.on(\"readable\", onReadable);\n readable.once(\"error\", onError);\n readable.once(\"end\", onEnd);\n const pull = Effect.suspend(function loop() {\n let item = options.readable.read(options.chunkSize);\n if (item === null) {\n if (exit.current) {\n return exit.current;\n }\n if (readable.readableEnded) {\n return Effect.fail(Cause.Done());\n }\n latch.closeUnsafe();\n return Effect.flatMap(latch.await, loop);\n }\n const chunk = Arr.of(item);\n while (true) {\n item = options.readable.read(options.chunkSize);\n if (item === null) break;\n chunk.push(item);\n }\n return Effect.succeed(chunk);\n });\n return Effect.as(Scope.addFinalizer(options.scope, Effect.sync(() => {\n readable.off(\"readable\", onReadable);\n readable.off(\"error\", onError);\n readable.off(\"end\", onEnd);\n if (closeOnDone && \"closed\" in options.readable && !options.readable.closed) {\n options.readable.destroy();\n }\n })), pull);\n};\nclass StreamAdapter extends Readable {\n readLatch;\n fiber = undefined;\n constructor(context, stream) {\n super({});\n this.readLatch = Latch.makeUnsafe(false);\n this.fiber = Stream.runForEachArray(stream, chunk => this.readLatch.whenOpen(Effect.sync(() => {\n this.readLatch.closeUnsafe();\n for (let i = 0; i < chunk.length; i++) {\n const item = chunk[i];\n if (typeof item === \"string\") {\n this.push(item, \"utf8\");\n } else {\n this.push(item);\n }\n }\n }))).pipe(this.readLatch.whenOpen, Effect.provideContext(context), Effect.runFork);\n this.fiber.addObserver(exit => {\n this.fiber = undefined;\n if (Exit.isSuccess(exit)) {\n this.push(null);\n } else {\n this.destroy(Cause.squash(exit.cause));\n }\n });\n }\n _read(_size) {\n this.readLatch.openUnsafe();\n }\n _destroy(error, callback) {\n if (!this.fiber) {\n return callback(error);\n }\n Effect.runFork(Fiber.interrupt(this.fiber)).addObserver(exit => {\n callback(exit._tag === \"Failure\" ? Cause.squash(exit.cause) : error);\n });\n }\n}\nconst defaultOnError = error => new Cause.UnknownError(error);\nconst toMaxBytes = maxBytes => maxBytes === undefined || maxBytes === Infinity ? undefined : Number(ByteSize.fromInputUnsafe(maxBytes));\n//# sourceMappingURL=NodeStream.js.map","import * as Deferred from \"effect/Deferred\";\nimport * as Duration from \"effect/Duration\";\nimport * as Effect from \"effect/Effect\";\nimport * as Exit from \"effect/Exit\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport * as Layer from \"effect/Layer\";\nimport * as Path from \"effect/Path\";\nimport * as Predicate from \"effect/Predicate\";\nimport * as Sink from \"effect/Sink\";\nimport * as Stream from \"effect/Stream\";\nimport * as ChildProcess from \"effect/unstable/process/ChildProcess\";\nimport { ChildProcessSpawner, ExitCode, make as makeSpawner, makeHandle, ProcessId } from \"effect/unstable/process/ChildProcessSpawner\";\nimport * as NodeChildProcess from \"node:child_process\";\nimport { PassThrough } from \"node:stream\";\nimport { buildSpawnOptions } from \"./internal/nodeChildProcessSpawner.js\";\nimport { handleErrnoException } from \"./internal/utils.js\";\nimport * as NodeSink from \"./NodeSink.js\";\nimport * as NodeStream from \"./NodeStream.js\";\nconst toError = error => error instanceof globalThis.Error ? error : new globalThis.Error(String(error));\nconst toPlatformError = (method, error, command) => {\n const {\n commands\n } = flattenCommand(command);\n const commandStr = commands.reduce((acc, curr) => {\n const cmd = `${curr.command} ${curr.args.join(\" \")}`;\n return acc.length === 0 ? cmd : `${acc} | ${cmd}`;\n }, \"\");\n return handleErrnoException(\"ChildProcess\", method)(error, [commandStr]);\n};\nconst processGroupGraceMillis = 1_000;\nconst processGroupPollIntervalMillis = 10;\n/** The leader has not exited, or a member of its process group still exists. */\nconst isProcessAlive = (childProcess, exitSignal) => {\n if (!Deferred.isDoneUnsafe(exitSignal)) {\n return true;\n }\n if (globalThis.process.platform === \"win32\") {\n return false;\n }\n try {\n globalThis.process.kill(-childProcess.pid, 0);\n return true;\n } catch {\n return false;\n }\n};\nconst taskkill = (childProcess, onExit = () => {}) => NodeChildProcess.execFile(\"taskkill\", [\"/pid\", String(childProcess.pid), \"/T\", \"/F\"], {\n windowsHide: true\n}, onExit);\nconst make = /*#__PURE__*/Effect.gen(function* () {\n const fs = yield* FileSystem.FileSystem;\n const path = yield* Path.Path;\n const resolveWorkingDirectory = Effect.fnUntraced(function* (options) {\n if (Predicate.isUndefined(options.cwd)) return undefined;\n // Validate that the specified directory is accessible\n yield* fs.access(options.cwd);\n return path.resolve(options.cwd);\n });\n const resolveEnvironment = options => {\n return options.extendEnv ? {\n ...globalThis.process.env,\n ...options.env\n } : options.env;\n };\n const inputToStdioOption = input => Stream.isStream(input) ? \"pipe\" : input;\n const outputToStdioOption = input => Sink.isSink(input) ? \"pipe\" : input;\n const resolveStdinOption = options => {\n const defaultConfig = {\n stream: \"pipe\",\n encoding: \"utf-8\",\n endOnDone: true\n };\n if (Predicate.isUndefined(options.stdin)) {\n return defaultConfig;\n }\n if (typeof options.stdin === \"string\") {\n return {\n ...defaultConfig,\n stream: options.stdin\n };\n }\n if (Stream.isStream(options.stdin)) {\n return {\n ...defaultConfig,\n stream: options.stdin\n };\n }\n return {\n stream: options.stdin.stream,\n encoding: options.stdin.encoding ?? defaultConfig.encoding,\n endOnDone: options.stdin.endOnDone ?? defaultConfig.endOnDone\n };\n };\n const resolveOutputOption = (options, streamName) => {\n const option = options[streamName];\n if (Predicate.isUndefined(option)) {\n return {\n stream: \"pipe\"\n };\n }\n if (typeof option === \"string\") {\n return {\n stream: option\n };\n }\n if (Sink.isSink(option)) {\n return {\n stream: option\n };\n }\n return {\n stream: option.stream\n };\n };\n const resolveAdditionalFds = options => {\n if (Predicate.isUndefined(options.additionalFds)) {\n return [];\n }\n const result = [];\n for (const [name, config] of Object.entries(options.additionalFds)) {\n const fd = ChildProcess.parseFdName(name);\n if (Predicate.isNotUndefined(fd)) {\n result.push({\n fd,\n config\n });\n }\n }\n // Sort by fd number to ensure correct ordering\n return result.sort((a, b) => a.fd - b.fd);\n };\n const buildStdioArray = (stdinConfig, stdoutConfig, stderrConfig, additionalFds) => {\n const stdio = [inputToStdioOption(stdinConfig.stream), outputToStdioOption(stdoutConfig.stream), outputToStdioOption(stderrConfig.stream)];\n if (additionalFds.length === 0) {\n return stdio;\n }\n // Find the maximum fd number to size the array correctly\n const maxFd = additionalFds.reduce((max, {\n fd\n }) => Math.max(max, fd), 2);\n // Fill gaps with \"ignore\"\n for (let i = 3; i <= maxFd; i++) {\n stdio[i] = \"ignore\";\n }\n // Set up additional fds as \"pipe\"\n for (const {\n fd\n } of additionalFds) {\n stdio[fd] = \"pipe\";\n }\n return stdio;\n };\n const setupAdditionalFds = Effect.fnUntraced(function* (command, childProcess, additionalFds) {\n if (additionalFds.length === 0) {\n return {\n getInputFd: () => Sink.drain,\n getOutputFd: () => Stream.empty\n };\n }\n const inputSinks = new Map();\n const outputStreams = new Map();\n for (const {\n config,\n fd\n } of additionalFds) {\n const nodeStream = childProcess.stdio[fd];\n switch (config.type) {\n case \"input\":\n {\n // Create a sink to write to for input file descriptors\n let sink = Sink.drain;\n if (nodeStream && \"write\" in nodeStream) {\n sink = NodeSink.fromWritable({\n evaluate: () => nodeStream,\n onError: error => toPlatformError(`fromWritable(fd${fd})`, toError(error), command)\n });\n }\n // If user provided a stream, pipe it into the sink\n if (config.stream) {\n yield* Effect.forkScoped(Stream.run(config.stream, sink));\n }\n inputSinks.set(fd, sink);\n break;\n }\n case \"output\":\n {\n // Create a stream to read from for output file descriptors\n let stream = Stream.empty;\n if (nodeStream && \"read\" in nodeStream) {\n const passThrough = new PassThrough();\n nodeStream.on(\"error\", error => passThrough.destroy(error));\n nodeStream.pipe(passThrough);\n stream = NodeStream.fromReadable({\n evaluate: () => passThrough,\n onError: error => toPlatformError(`fromReadable(fd${fd})`, toError(error), command)\n });\n }\n // If user provided a sink, transduce the stream through it\n if (config.sink) {\n stream = Stream.transduce(stream, config.sink);\n }\n outputStreams.set(fd, stream);\n break;\n }\n }\n }\n return {\n getInputFd: fd => inputSinks.get(fd) ?? Sink.drain,\n getOutputFd: fd => outputStreams.get(fd) ?? Stream.empty\n };\n });\n const setupChildStdin = (command, childProcess, config) => Effect.suspend(() => {\n // If the child process has a standard input stream, connect it to the\n // sink that will attached to the process handle\n let sink = Sink.drain;\n if (Predicate.isNotNull(childProcess.stdin)) {\n sink = NodeSink.fromWritable({\n evaluate: () => childProcess.stdin,\n onError: error => toPlatformError(\"fromWritable(stdin)\", toError(error), command),\n endOnDone: config.endOnDone,\n encoding: config.encoding\n });\n }\n // If the user provided a `Stream`, run it into the stdin sink\n if (Stream.isStream(config.stream)) {\n return Effect.as(Effect.forkScoped(Stream.run(config.stream, sink)), sink);\n }\n return Effect.succeed(sink);\n });\n const setupChildOutputStreams = (command, childProcess, stdoutConfig, stderrConfig) => {\n let stdout = childProcess.stdout ? (() => {\n const passThrough = new PassThrough();\n childProcess.stdout.on(\"error\", error => passThrough.destroy(error));\n childProcess.stdout.pipe(passThrough);\n return NodeStream.fromReadable({\n evaluate: () => passThrough,\n onError: error => toPlatformError(\"fromReadable(stdout)\", toError(error), command)\n });\n })() : Stream.empty;\n let stderr = childProcess.stderr ? (() => {\n const passThrough = new PassThrough();\n childProcess.stderr.on(\"error\", error => passThrough.destroy(error));\n childProcess.stderr.pipe(passThrough);\n return NodeStream.fromReadable({\n evaluate: () => passThrough,\n onError: error => toPlatformError(\"fromReadable(stderr)\", toError(error), command)\n });\n })() : Stream.empty;\n if (Sink.isSink(stdoutConfig.stream)) {\n stdout = Stream.transduce(stdout, stdoutConfig.stream);\n }\n if (Sink.isSink(stderrConfig.stream)) {\n stderr = Stream.transduce(stderr, stderrConfig.stream);\n }\n const all = Stream.merge(stdout, stderr);\n return {\n stdout,\n stderr,\n all\n };\n };\n const spawn = (command, spawnOptions) => Effect.callback(resume => {\n const deferred = Deferred.makeUnsafe();\n const handle = NodeChildProcess.spawn(command.command, command.args, spawnOptions);\n handle.on(\"error\", error => {\n resume(Effect.fail(toPlatformError(\"spawn\", error, command)));\n });\n handle.on(\"exit\", (...args) => {\n Deferred.doneUnsafe(deferred, Exit.succeed(args));\n });\n handle.on(\"spawn\", () => {\n resume(Effect.succeed([handle, deferred]));\n });\n return Effect.sync(() => {\n handle.kill(\"SIGTERM\");\n });\n });\n const killProcessGroup = (command, childProcess, signal) => {\n if (globalThis.process.platform === \"win32\") {\n return Effect.callback(resume => {\n taskkill(childProcess, error => {\n if (error) {\n resume(Effect.fail(toPlatformError(\"kill\", toError(error), command)));\n } else {\n resume(Effect.void);\n }\n });\n });\n }\n return Effect.try({\n try: () => {\n globalThis.process.kill(-childProcess.pid, signal);\n },\n catch: error => toPlatformError(\"kill\", toError(error), command)\n });\n };\n const killProcessGroupOnExit = (childProcess, signal) => {\n if (globalThis.process.platform === \"win32\") {\n // ignore errors during best-effort cleanup\n taskkill(childProcess);\n return;\n }\n try {\n globalThis.process.kill(-childProcess.pid, signal);\n } catch {\n // ignore errors during best-effort cleanup\n }\n };\n const killProcess = (command, childProcess, signal) => Effect.suspend(() => {\n const killed = childProcess.kill(signal);\n if (!killed) {\n const error = new globalThis.Error(\"Failed to kill child process\");\n return Effect.fail(toPlatformError(\"kill\", error, command));\n }\n return Effect.void;\n });\n /** Waits for the leader and its process group, bounded by native time. */\n const awaitProcessExit = (childProcess, exitSignal, timeoutMillis) => Effect.callback(resume => {\n const deadline = Date.now() + timeoutMillis;\n let timer;\n const stop = () => {\n clearTimeout(timer);\n childProcess.removeListener(\"exit\", poll);\n };\n const poll = () => {\n clearTimeout(timer);\n if (Date.now() >= deadline || !isProcessAlive(childProcess, exitSignal)) {\n stop();\n resume(Effect.void);\n return;\n }\n timer = setTimeout(poll, processGroupPollIntervalMillis);\n };\n // spawn's exit listener completes exitSignal before this listener runs\n childProcess.on(\"exit\", poll);\n poll();\n return Effect.sync(stop);\n });\n const terminateProcessGroup = Effect.fnUntraced(function* (command, childProcess, exitSignal, options) {\n const signalGroup = signal => killProcessGroup(command, childProcess, signal).pipe(Effect.catch(() => killProcess(command, childProcess, signal)));\n yield* signalGroup(options?.killSignal ?? \"SIGTERM\");\n if (Predicate.isUndefined(options?.forceKillAfter)) {\n yield* awaitProcessExit(childProcess, exitSignal, processGroupGraceMillis);\n } else {\n yield* awaitProcessExit(childProcess, exitSignal, Duration.toMillis(options.forceKillAfter));\n if (isProcessAlive(childProcess, exitSignal)) {\n yield* signalGroup(\"SIGKILL\");\n yield* awaitProcessExit(childProcess, exitSignal, processGroupGraceMillis);\n }\n }\n yield* Deferred.await(exitSignal);\n });\n /**\n * Get the appropriate source stream from a process handle based on the\n * `from` pipe option.\n */\n const getSourceStream = (handle, from) => {\n const fromOption = from ?? \"stdout\";\n switch (fromOption) {\n case \"stdout\":\n return handle.stdout;\n case \"stderr\":\n return handle.stderr;\n case \"all\":\n return handle.all;\n default:\n {\n // Handle fd3, fd4, etc.\n const fd = ChildProcess.parseFdName(fromOption);\n if (Predicate.isNotUndefined(fd)) {\n return handle.getOutputFd(fd);\n }\n // Fallback to stdout for invalid fd names\n return handle.stdout;\n }\n }\n };\n const spawnCommand = Effect.fnUntraced(function* (cmd) {\n switch (cmd._tag) {\n case \"StandardCommand\":\n {\n const stdinConfig = resolveStdinOption(cmd.options);\n const stdoutConfig = resolveOutputOption(cmd.options, \"stdout\");\n const stderrConfig = resolveOutputOption(cmd.options, \"stderr\");\n const resolvedAdditionalFds = resolveAdditionalFds(cmd.options);\n let isReferenced = true;\n const cwd = yield* resolveWorkingDirectory(cmd.options);\n const env = resolveEnvironment(cmd.options);\n const stdio = buildStdioArray(stdinConfig, stdoutConfig, stderrConfig, resolvedAdditionalFds);\n const [childProcess, exitSignal] = yield* Effect.acquireRelease(spawn(cmd, buildSpawnOptions(cmd.options, {\n cwd,\n env,\n stdio\n }, process.platform)), Effect.fnUntraced(function* ([childProcess, exitSignal]) {\n const exited = yield* Deferred.isDone(exitSignal);\n if (exited) {\n const [code] = yield* Deferred.await(exitSignal);\n if (code !== 0 && Predicate.isNotNull(code)) {\n yield* Effect.ignore(killProcessGroup(cmd, childProcess, cmd.options.killSignal ?? \"SIGTERM\"));\n }\n return;\n }\n if (!isReferenced) {\n return;\n }\n yield* Effect.ignore(terminateProcessGroup(cmd, childProcess, exitSignal, cmd.options));\n }));\n const pid = ProcessId(childProcess.pid);\n childProcess.on(\"exit\", code => {\n if (code !== 0 && Predicate.isNotNull(code)) {\n killProcessGroupOnExit(childProcess, cmd.options.killSignal ?? \"SIGTERM\");\n }\n });\n const reref = Effect.sync(() => {\n if (!isReferenced) {\n childProcess.ref();\n isReferenced = true;\n }\n });\n const unref = Effect.sync(() => {\n if (isReferenced) {\n childProcess.unref();\n isReferenced = false;\n }\n return reref;\n });\n const stdin = yield* setupChildStdin(cmd, childProcess, stdinConfig);\n const {\n all,\n stderr,\n stdout\n } = setupChildOutputStreams(cmd, childProcess, stdoutConfig, stderrConfig);\n const {\n getInputFd,\n getOutputFd\n } = yield* setupAdditionalFds(cmd, childProcess, resolvedAdditionalFds);\n const isRunning = Effect.map(Deferred.isDone(exitSignal), done => !done);\n const exitCode = Effect.flatMap(Deferred.await(exitSignal), ([code, signal]) => {\n if (Predicate.isNotNull(code)) {\n return Effect.succeed(ExitCode(code));\n }\n // If code is `null`, then `signal` must be defined. See the NodeJS\n // documentation for the `\"exit\"` event on a `child_process`.\n // https://nodejs.org/api/child_process.html#child_process_event_exit\n const error = new globalThis.Error(`Process interrupted due to receipt of signal: '${signal}'`);\n return Effect.fail(toPlatformError(\"exitCode\", error, cmd));\n });\n const kill = options => terminateProcessGroup(cmd, childProcess, exitSignal, options);\n return makeHandle({\n pid,\n exitCode,\n isRunning,\n kill,\n stdin,\n stdout,\n stderr,\n all,\n getInputFd,\n getOutputFd,\n unref\n });\n }\n case \"PipedCommand\":\n {\n const {\n commands,\n pipeOptions\n } = flattenCommand(cmd);\n const [root, ...pipeline] = commands;\n const handles = [yield* spawnCommand(root)];\n for (let i = 0; i < pipeline.length; i++) {\n const command = pipeline[i];\n const options = pipeOptions[i] ?? {};\n const stdinConfig = resolveStdinOption(command.options);\n // Get the appropriate stream from the source based on `from` option\n const sourceStream = Stream.unwrap(Effect.succeed(getSourceStream(handles[handles.length - 1], options.from)));\n // Determine where to pipe: stdin or custom fd\n const toOption = options.to ?? \"stdin\";\n if (toOption === \"stdin\") {\n // Pipe to stdin (default behavior)\n handles.push(yield* spawnCommand(ChildProcess.make(command.command, command.args, {\n ...command.options,\n stdin: {\n ...stdinConfig,\n stream: sourceStream\n }\n })));\n } else {\n // Pipe to custom fd (fd3, fd4, etc.)\n const fd = ChildProcess.parseFdName(toOption);\n if (Predicate.isNotUndefined(fd)) {\n const fdName = ChildProcess.fdName(fd);\n const existingFds = command.options.additionalFds ?? {};\n handles.push(yield* spawnCommand(ChildProcess.make(command.command, command.args, {\n ...command.options,\n additionalFds: {\n ...existingFds,\n [fdName]: {\n type: \"input\",\n stream: sourceStream\n }\n }\n })));\n } else {\n // Invalid fd name, fall back to stdin\n handles.push(yield* spawnCommand(ChildProcess.make(command.command, command.args, {\n ...command.options,\n stdin: {\n ...stdinConfig,\n stream: sourceStream\n }\n })));\n }\n }\n }\n const handle = handles[handles.length - 1];\n const kill = options => Effect.forEach([...handles].reverse(), handle => Effect.ignore(handle.kill(options)), {\n discard: true\n });\n const unref = Effect.gen(function* () {\n const rerefs = [];\n for (const handle of handles) {\n rerefs.push(yield* handle.unref);\n }\n return Effect.forEach([...rerefs].reverse(), reref => reref, {\n discard: true\n });\n });\n return makeHandle({\n pid: handle.pid,\n exitCode: handle.exitCode,\n isRunning: handle.isRunning,\n kill,\n stdin: handles[0].stdin,\n stdout: handle.stdout,\n stderr: handle.stderr,\n all: handle.all,\n getInputFd: handle.getInputFd,\n getOutputFd: handle.getOutputFd,\n unref\n });\n }\n }\n });\n return makeSpawner(spawnCommand);\n});\n/**\n * Layer that provides the `NodeChildProcessSpawner` implementation.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = /*#__PURE__*/Layer.effect(ChildProcessSpawner, make);\n/**\n * Flattens a `Command` into an array of `StandardCommand`s along with pipe\n * options for each connection.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const flattenCommand = command => {\n const commands = [];\n const pipeOptions = [];\n const flatten = cmd => {\n switch (cmd._tag) {\n case \"StandardCommand\":\n {\n commands.push(cmd);\n break;\n }\n case \"PipedCommand\":\n {\n // Recursively flatten left side first\n flatten(cmd.left);\n // Store the pipe options for this connection\n pipeOptions.push(cmd.options);\n // Then flatten right side\n flatten(cmd.right);\n break;\n }\n }\n };\n flatten(command);\n // The commands array is guaranteed to be non-empty since we always have at\n // least one command in the input. We validate this at runtime and return a\n // properly typed tuple.\n if (commands.length === 0) {\n // This should never happen given a valid Command input\n throw new Error(\"flattenCommand produced empty commands array\");\n }\n const [first, ...rest] = commands;\n const nonEmptyCommands = [first, ...rest];\n return {\n commands: nonEmptyCommands,\n pipeOptions\n };\n};\n//# sourceMappingURL=NodeChildProcessSpawner.js.map","const hex = byte => byte.toString(16).padStart(2, \"0\");\n/** @internal */\nexport const stringify = bytes => {\n const segments = [bytes.subarray(0, 4), bytes.subarray(4, 6), bytes.subarray(6, 8), bytes.subarray(8, 10), bytes.subarray(10, 16)];\n return segments.map(segment => Array.from(segment, hex).join(\"\")).join(\"-\");\n};\nconst randomBytes = () => globalThis.crypto.getRandomValues(new Uint8Array(16));\n/** @internal */\nexport function v4Bytes(bytes = randomBytes()) {\n bytes[6] = bytes[6] & 0x0f | 0x40;\n bytes[8] = bytes[8] & 0x3f | 0x80;\n return bytes;\n}\n/** @internal */\nexport const v4String = bytes => stringify(bytes === undefined ? v4Bytes() : v4Bytes(bytes));\nconst maxV7Timestamp = 2 ** 48 - 1;\n/** @internal */\nexport function v7Bytes(timestampMillis, bytes = randomBytes()) {\n const timestamp = Math.min(Math.max(0, Math.trunc(timestampMillis)), maxV7Timestamp);\n bytes[0] = Math.floor(timestamp / 2 ** 40);\n bytes[1] = Math.floor(timestamp / 2 ** 32) & 0xff;\n bytes[2] = Math.floor(timestamp / 2 ** 24) & 0xff;\n bytes[3] = Math.floor(timestamp / 2 ** 16) & 0xff;\n bytes[4] = Math.floor(timestamp / 2 ** 8) & 0xff;\n bytes[5] = timestamp & 0xff;\n bytes[6] = bytes[6] & 0x0f | 0x70;\n bytes[8] = bytes[8] & 0x3f | 0x80;\n return bytes;\n}\n/** @internal */\nexport const v7String = (timestampMillis, bytes) => stringify(bytes === undefined ? v7Bytes(timestampMillis) : v7Bytes(timestampMillis, bytes));\n//# sourceMappingURL=uuid.js.map","/**\n * Defines a platform-independent service for cryptographic operations.\n *\n * Runtime packages provide concrete implementations backed by the host\n * platform's cryptography APIs. This module defines the service interface and a\n * constructor from random-byte and digest primitives. The service provides\n * secure random bytes and numbers, UUIDv4 and UUIDv7 generation, shuffling, and\n * SHA message digests.\n *\n * @since 4.0.0\n */\nimport * as Context from \"./Context.js\";\nimport * as Effect from \"./Effect.js\";\nimport * as random from \"./internal/random.js\";\nimport * as Uuid from \"./internal/uuid.js\";\nimport * as PlatformError from \"./PlatformError.js\";\nconst TypeId = \"~effect/Crypto\";\n/**\n * Service tag for platform cryptography.\n *\n * **When to use**\n *\n * Use when you need to provide or retrieve the full platform cryptography\n * service from an effect's context.\n *\n * **Details**\n *\n * Providing this service supplies platform-agnostic cryptographic operations\n * such as hashing, UUID generation, and secure random values.\n *\n * @see {@link make} for constructing a Crypto service from primitive operations\n *\n * @category services\n * @since 4.0.0\n */\nexport const Crypto = /*#__PURE__*/Context.Service(\"effect/Crypto\");\n/**\n * Creates a `Crypto` service from the primitive implementation, deriving the\n * random generator helpers and UUID generation from those primitives.\n *\n * **When to use**\n *\n * Use to build a Crypto service for a platform integration, test layer, or\n * custom runtime from primitive random-byte and digest operations.\n *\n * **Details**\n *\n * The constructor derives random numbers, booleans, integer ranges, shuffling,\n * and UUID generation from `impl.randomBytes`. Digest operations delegate to\n * `impl.digest`.\n *\n * **Gotchas**\n *\n * `impl.randomBytes` must return cryptographically secure bytes of the\n * requested length. UUID formatting mutates the byte array returned for UUID\n * generation, so the implementation should return a fresh array for each call.\n *\n * **Example** (Creating a Crypto service)\n *\n * ```ts import.meta.vitest\n * import { Crypto, Effect } from \"effect\"\n *\n * const testCrypto = Crypto.make({\n * randomBytes: (size) => new Uint8Array(size),\n * digest: (_algorithm, data) => Effect.succeed(data)\n * })\n *\n * await Effect.runPromise(testCrypto.randomBytes(4)) // => new Uint8Array([0, 0, 0, 0])\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = impl => {\n const randomBytesUnsafe = impl.randomBytes;\n const randomBytes = size => Effect.map(validateSize(\"randomBytes\", size), randomBytesUnsafe);\n const readUint53 = bytes => (bytes[0] & 0x1f) * 2 ** 48 + bytes[1] * 2 ** 40 + bytes[2] * 2 ** 32 + bytes[3] * 2 ** 24 + bytes[4] * 2 ** 16 + bytes[5] * 2 ** 8 + bytes[6];\n const nextDoubleUnsafe = () => readUint53(randomBytesUnsafe(7)) / 2 ** 53;\n const nextIntUnsafe = () => {\n while (true) {\n const bytes = randomBytesUnsafe(7);\n const value = readUint53(bytes);\n if ((bytes[0] & 0x20) === 0) {\n return value + Number.MIN_SAFE_INTEGER;\n }\n if (value < Number.MAX_SAFE_INTEGER) {\n return value + 1;\n }\n }\n };\n return Crypto.of({\n [TypeId]: TypeId,\n randomBytes,\n nextDoubleUnsafe,\n nextIntUnsafe,\n digest: impl.digest,\n random: Effect.sync(() => nextDoubleUnsafe()),\n randomBoolean: Effect.sync(() => nextDoubleUnsafe() > 0.5),\n randomInt: Effect.sync(() => nextIntUnsafe()),\n randomBetween: (min, max) => Effect.sync(() => random.nextBetween(min, max, nextDoubleUnsafe())),\n randomIntBetween(min, max, options) {\n const extra = options?.halfOpen === true ? 0 : 1;\n return Effect.sync(() => {\n const minInt = Math.ceil(min);\n const maxInt = Math.floor(max);\n return Math.floor(nextDoubleUnsafe() * (maxInt - minInt + extra)) + minInt;\n });\n },\n randomShuffle: elements => Effect.sync(() => {\n const buffer = Array.from(elements);\n for (let i = buffer.length - 1; i >= 1; i = i - 1) {\n const index = Math.min(i, Math.floor(nextDoubleUnsafe() * (i + 1)));\n const value = buffer[i];\n buffer[i] = buffer[index];\n buffer[index] = value;\n }\n return buffer;\n }),\n randomUUIDv4: Effect.sync(() => Uuid.v4String(randomBytesUnsafe(16))),\n randomUUIDv7: Effect.clockWith(clock => Effect.succeed(Uuid.v7String(clock.currentTimeMillisUnsafe(), randomBytesUnsafe(16))))\n });\n};\nconst validateSize = (method, size) => Number.isSafeInteger(size) && size >= 0 ? Effect.succeed(size) : Effect.fail(PlatformError.badArgument({\n module: \"Crypto\",\n method,\n description: \"size must be a non-negative safe integer\"\n}));\n//# sourceMappingURL=Crypto.js.map","/**\n * Node-compatible implementation of Effect's `Crypto` service.\n *\n * This module builds the service from `node:crypto`, using `randomBytes` for\n * random data and `createHash` for supported digest algorithms. It exports\n * `make` as the concrete service value and `layer` for providing it through\n * Effect context.\n *\n * @since 1.0.0\n */\nimport * as EffectCrypto from \"effect/Crypto\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as PlatformError from \"effect/PlatformError\";\nimport * as NodeCrypto from \"node:crypto\";\nconst toHashAlgorithm = algorithm => {\n switch (algorithm) {\n case \"SHA-1\":\n return \"sha1\";\n case \"SHA-256\":\n return \"sha256\";\n case \"SHA-384\":\n return \"sha384\";\n case \"SHA-512\":\n return \"sha512\";\n }\n};\nconst digest = (algorithm, data) => Effect.try({\n try: () => Uint8Array.from(NodeCrypto.createHash(toHashAlgorithm(algorithm)).update(data).digest()),\n catch: cause => PlatformError.systemError({\n module: \"Crypto\",\n method: \"digest\",\n _tag: \"Unknown\",\n description: \"Could not compute digest\",\n cause\n })\n});\n/**\n * The default Node.js Crypto service implementation.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const make = /*#__PURE__*/EffectCrypto.make({\n randomBytes: NodeCrypto.randomBytes,\n digest\n});\n/**\n * Layer that provides the Node.js Crypto service implementation.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layer = /*#__PURE__*/Layer.succeed(EffectCrypto.Crypto, make);\n//# sourceMappingURL=NodeCrypto.js.map","/**\n * The `NodeCrypto` module provides the Node.js `Crypto` service layer for\n * Effect programs. Provide {@link layer} at the edge of a Node application,\n * CLI, script, or test to satisfy `effect/Crypto` with Node's `node:crypto`\n * implementation for secure random bytes, UUID generation, random values, and\n * SHA digest operations.\n *\n * This module is the public Node adapter around the shared Node-compatible\n * implementation. Digest failures are reported as platform errors, and SHA-1\n * remains available only for interoperability with existing protocols.\n *\n * @since 1.0.0\n */\nimport * as NodeCrypto from \"@effect/platform-node-shared/NodeCrypto\";\n/**\n * Layer that provides the Node.js Crypto service implementation.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layer = NodeCrypto.layer;\n//# sourceMappingURL=NodeCrypto.js.map","/**\n * Shared Node-compatible implementation of Effect's `FileSystem` service.\n *\n * This module adapts Node's `node:fs`, `node:os`, and `node:path` APIs into a\n * `FileSystem` layer for Effect programs running on Node-compatible runtimes.\n * Platform packages use it to provide file and directory I/O, permissions,\n * links, metadata, temporary files and directories, and file watching through\n * the shared `FileSystem` service.\n *\n * @since 4.0.0\n */\nimport * as BI from \"effect/BigInt\";\nimport * as ByteSize from \"effect/ByteSize\";\nimport * as Cause from \"effect/Cause\";\nimport * as Effect from \"effect/Effect\";\nimport { effectify } from \"effect/Effect\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport { pipe } from \"effect/Function\";\nimport * as Layer from \"effect/Layer\";\nimport * as Option from \"effect/Option\";\nimport * as Error from \"effect/PlatformError\";\nimport * as Queue from \"effect/Queue\";\nimport * as Stream from \"effect/Stream\";\nimport * as Crypto from \"node:crypto\";\nimport * as NFS from \"node:fs\";\nimport * as OS from \"node:os\";\nimport * as Path from \"node:path\";\nimport { handleErrnoException } from \"./internal/utils.js\";\nconst handleBadArgument = method => err => Error.badArgument({\n module: \"FileSystem\",\n method,\n description: err.message ?? String(err)\n});\nconst bigintToNumber = (value, field) => {\n const number = Number(value);\n if (!Number.isSafeInteger(number)) {\n throw new RangeError(`${field} exceeds the safe integer range: ${value}`);\n }\n return number;\n};\nconst bigintToNumberOption = value => Option.flatMap(Option.fromNullishOr(value), BI.toNumber);\n// fs.write ignores bigint positions.\nconst positionToNumber = (position, method) => Effect.try({\n try: () => bigintToNumber(position, \"position\"),\n catch: handleBadArgument(method)\n});\n// == access\nconst access = /*#__PURE__*/(() => {\n const nodeAccess = /*#__PURE__*/effectify(NFS.access, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"access\"), /*#__PURE__*/handleBadArgument(\"access\"));\n return (path, options) => {\n let mode = NFS.constants.F_OK;\n if (options?.readable) {\n mode |= NFS.constants.R_OK;\n }\n if (options?.writable) {\n mode |= NFS.constants.W_OK;\n }\n return nodeAccess(path, mode);\n };\n})();\n// == copy\nconst copy = /*#__PURE__*/(() => {\n const nodeCp = /*#__PURE__*/effectify(NFS.cp, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"copy\"), /*#__PURE__*/handleBadArgument(\"copy\"));\n return (fromPath, toPath, options) => nodeCp(fromPath, toPath, {\n force: options?.overwrite ?? false,\n preserveTimestamps: options?.preserveTimestamps ?? false,\n recursive: true\n });\n})();\n// == copyFile\nconst copyFile = /*#__PURE__*/(() => {\n const nodeCopyFile = /*#__PURE__*/effectify(NFS.copyFile, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"copyFile\"), /*#__PURE__*/handleBadArgument(\"copyFile\"));\n return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);\n})();\n// == chmod\nconst chmod = /*#__PURE__*/(() => {\n const nodeChmod = /*#__PURE__*/effectify(NFS.chmod, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"chmod\"), /*#__PURE__*/handleBadArgument(\"chmod\"));\n return (path, mode) => nodeChmod(path, mode);\n})();\n// == chown\nconst chown = /*#__PURE__*/(() => {\n const nodeChown = /*#__PURE__*/effectify(NFS.chown, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"chown\"), /*#__PURE__*/handleBadArgument(\"chown\"));\n return (path, uid, gid) => nodeChown(path, uid, gid);\n})();\n// == glob\nconst glob = /*#__PURE__*/(() => {\n const nodeGlob = /*#__PURE__*/effectify(NFS.glob, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"glob\"), /*#__PURE__*/handleBadArgument(\"glob\"));\n return (pattern, options) => nodeGlob(pattern, {\n cwd: options?.root,\n exclude: options?.exclude\n });\n})();\n// == link\nconst link = /*#__PURE__*/(() => {\n const nodeLink = /*#__PURE__*/effectify(NFS.link, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"link\"), /*#__PURE__*/handleBadArgument(\"link\"));\n return (existingPath, newPath) => nodeLink(existingPath, newPath);\n})();\n// == makeDirectory\nconst makeDirectory = /*#__PURE__*/(() => {\n const nodeMkdir = /*#__PURE__*/effectify(NFS.mkdir, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"makeDirectory\"), /*#__PURE__*/handleBadArgument(\"makeDirectory\"));\n return (path, options) => nodeMkdir(path, {\n recursive: options?.recursive ?? false,\n mode: options?.mode\n });\n})();\n// == makeTempDirectory\nconst makeTempDirectoryFactory = method => {\n const nodeMkdtemp = effectify(NFS.mkdtemp, handleErrnoException(\"FileSystem\", method), handleBadArgument(method));\n return options => Effect.suspend(() => {\n const prefix = options?.prefix ?? \"\";\n const directory = typeof options?.directory === \"string\" ? Path.join(options.directory, \".\") : OS.tmpdir();\n return nodeMkdtemp(prefix ? Path.join(directory, prefix) : directory + \"/\");\n });\n};\nconst makeTempDirectory = /*#__PURE__*/makeTempDirectoryFactory(\"makeTempDirectory\");\n// == remove\nconst removeFactory = method => {\n const nodeRm = effectify(NFS.rm, handleErrnoException(\"FileSystem\", method), handleBadArgument(method));\n return (path, options) => nodeRm(path, {\n recursive: options?.recursive ?? false,\n force: options?.force ?? false\n });\n};\nconst remove = /*#__PURE__*/removeFactory(\"remove\");\n// == makeTempDirectoryScoped\nconst makeTempDirectoryScoped = /*#__PURE__*/(() => {\n const makeDirectory = /*#__PURE__*/makeTempDirectoryFactory(\"makeTempDirectoryScoped\");\n const removeDirectory = /*#__PURE__*/removeFactory(\"makeTempDirectoryScoped\");\n return options => Effect.acquireRelease(makeDirectory(options), directory => Effect.orDie(removeDirectory(directory, {\n recursive: true\n })));\n})();\n// == open\nconst openFactory = method => {\n const nodeOpen = effectify(NFS.open, handleErrnoException(\"FileSystem\", method), handleBadArgument(method));\n const nodeClose = effectify(NFS.close, handleErrnoException(\"FileSystem\", method), handleBadArgument(method));\n return (path, options) => pipe(Effect.acquireRelease(nodeOpen(path, options?.flag ?? \"r\", options?.mode), fd => Effect.orDie(nodeClose(fd))), Effect.map(fd => makeFile(fd, options?.flag?.startsWith(\"a\") ?? false)));\n};\nconst open = /*#__PURE__*/openFactory(\"open\");\nconst makeFile = /*#__PURE__*/(() => {\n const nodeReadFactory = method => effectify(NFS.read, handleErrnoException(\"FileSystem\", method), handleBadArgument(method));\n const nodeRead = /*#__PURE__*/nodeReadFactory(\"read\");\n const nodeReadAlloc = /*#__PURE__*/nodeReadFactory(\"readAlloc\");\n const nodeStat = /*#__PURE__*/effectify(NFS.fstat, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"stat\"), /*#__PURE__*/handleBadArgument(\"stat\"));\n const nodeTruncate = /*#__PURE__*/effectify(NFS.ftruncate, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"truncate\"), /*#__PURE__*/handleBadArgument(\"truncate\"));\n const nodeSync = /*#__PURE__*/effectify(NFS.fsync, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"sync\"), /*#__PURE__*/handleBadArgument(\"sync\"));\n const nodeWriteFactory = method => effectify(NFS.write, handleErrnoException(\"FileSystem\", method), handleBadArgument(method));\n const nodeWrite = /*#__PURE__*/nodeWriteFactory(\"write\");\n const nodeWriteAll = /*#__PURE__*/nodeWriteFactory(\"writeAll\");\n class FileImpl {\n [FileSystem.FileTypeId];\n fd;\n append;\n position = /*#__PURE__*/BigInt(0);\n constructor(fd, append) {\n this[FileSystem.FileTypeId] = FileSystem.FileTypeId;\n this.fd = fd;\n this.append = append;\n }\n get stat() {\n return Effect.flatMap(nodeStat(this.fd, {\n bigint: true\n }), makeFileInfo);\n }\n get sync() {\n return nodeSync(this.fd);\n }\n seek(offset, from) {\n return Effect.suspend(() => {\n const position = from === \"start\" ? offset : this.position + offset;\n if (position < BigInt(0)) {\n return Effect.fail(Error.badArgument({\n module: \"FileSystem\",\n method: \"seek\",\n description: \"Cannot seek before the start of the file\"\n }));\n }\n this.position = position;\n return Effect.succeed(position);\n });\n }\n read(buffer) {\n return Effect.suspend(() => {\n const position = this.position;\n return Effect.map(nodeRead(this.fd, {\n buffer,\n position\n }), bytesRead => {\n this.position = position + BigInt(bytesRead);\n return bytesRead;\n });\n });\n }\n readAlloc(size) {\n return Effect.suspend(() => {\n try {\n if (!Number.isInteger(size) || size < 0) {\n throw new RangeError(\"size must be a non-negative integer\");\n }\n const buffer = Buffer.allocUnsafeSlow(size);\n const position = this.position;\n return Effect.map(nodeReadAlloc(this.fd, {\n buffer,\n position\n }), bytesRead => {\n if (bytesRead === 0) {\n return Option.none();\n }\n this.position = position + BigInt(bytesRead);\n if (bytesRead === size) {\n return Option.some(buffer);\n }\n const dst = Buffer.allocUnsafeSlow(bytesRead);\n buffer.copy(dst, 0, 0, bytesRead);\n return Option.some(dst);\n });\n } catch (cause) {\n return Effect.fail(handleBadArgument(\"readAlloc\")(cause));\n }\n });\n }\n truncate(length) {\n return Effect.map(nodeTruncate(this.fd, length || undefined), () => {\n if (!this.append) {\n const len = BigInt(length ?? 0);\n if (this.position > len) {\n this.position = len;\n }\n }\n });\n }\n write(buffer) {\n return Effect.suspend(() => {\n const position = this.position;\n return Effect.flatMap(this.append ? Effect.succeed(undefined) : positionToNumber(position, \"write\"), nodePosition => Effect.map(nodeWrite(this.fd, buffer, undefined, undefined, nodePosition), bytesWritten => {\n if (!this.append) {\n this.position = position + BigInt(bytesWritten);\n }\n return bytesWritten;\n }));\n });\n }\n writeAllChunk(buffer) {\n return Effect.suspend(() => {\n const position = this.position;\n return Effect.flatMap(this.append ? Effect.succeed(undefined) : positionToNumber(position, \"writeAll\"), nodePosition => Effect.flatMap(nodeWriteAll(this.fd, buffer, undefined, undefined, nodePosition), bytesWritten => {\n if (bytesWritten === 0) {\n return Effect.fail(Error.systemError({\n module: \"FileSystem\",\n method: \"writeAll\",\n _tag: \"WriteZero\",\n pathOrDescriptor: this.fd,\n description: \"write returned 0 bytes written\"\n }));\n }\n if (!this.append) {\n this.position = position + BigInt(bytesWritten);\n }\n return bytesWritten < buffer.length ? this.writeAllChunk(buffer.subarray(bytesWritten)) : Effect.void;\n }));\n });\n }\n writeAll(buffer) {\n return buffer.length === 0 ? Effect.void : this.writeAllChunk(buffer);\n }\n }\n return (fd, append) => new FileImpl(fd, append);\n})();\n// == makeTempFile\nconst makeTempFileFactory = method => {\n const makeDirectory = makeTempDirectoryFactory(method);\n return Effect.fnUntraced(function* (options) {\n const directory = yield* makeDirectory(options);\n const random = Crypto.randomBytes(6).toString(\"hex\");\n const name = Path.join(directory, options?.suffix ? `${random}${options.suffix}` : random);\n yield* writeFile(name, new Uint8Array(0));\n return name;\n });\n};\nconst makeTempFile = /*#__PURE__*/makeTempFileFactory(\"makeTempFile\");\n// == makeTempFileScoped\nconst makeTempFileScoped = /*#__PURE__*/(() => {\n const makeFile = /*#__PURE__*/makeTempFileFactory(\"makeTempFileScoped\");\n const removeDirectory = /*#__PURE__*/removeFactory(\"makeTempFileScoped\");\n return options => Effect.acquireRelease(makeFile(options), file => Effect.orDie(removeDirectory(Path.dirname(file), {\n recursive: true\n })));\n})();\n// == readDirectory\nconst readDirectory = (path, options) => Effect.tryPromise({\n try: () => NFS.promises.readdir(path, options),\n catch: err => handleErrnoException(\"FileSystem\", \"readDirectory\")(err, [path])\n});\n// == readFile\nconst readFile = path => Effect.callback((resume, signal) => {\n try {\n NFS.readFile(path, {\n signal\n }, (err, data) => {\n if (err) {\n resume(Effect.fail(handleErrnoException(\"FileSystem\", \"readFile\")(err, [path])));\n } else {\n resume(Effect.succeed(data));\n }\n });\n } catch (err) {\n resume(Effect.fail(handleBadArgument(\"readFile\")(err)));\n }\n});\n// == readLink\nconst readLink = /*#__PURE__*/(() => {\n const nodeReadLink = /*#__PURE__*/effectify(NFS.readlink, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"readLink\"), /*#__PURE__*/handleBadArgument(\"readLink\"));\n return path => nodeReadLink(path);\n})();\n// == realPath\nconst realPath = /*#__PURE__*/(() => {\n const nodeRealPath = /*#__PURE__*/effectify(NFS.realpath, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"realPath\"), /*#__PURE__*/handleBadArgument(\"realPath\"));\n return path => nodeRealPath(path);\n})();\n// == rename\nconst rename = /*#__PURE__*/(() => {\n const nodeRename = /*#__PURE__*/effectify(NFS.rename, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"rename\"), /*#__PURE__*/handleBadArgument(\"rename\"));\n return (oldPath, newPath) => nodeRename(oldPath, newPath);\n})();\n// == stat\nconst makeFileInfo = stat => Effect.try({\n try: () => ({\n type: stat.isFile() ? \"File\" : stat.isDirectory() ? \"Directory\" : stat.isSymbolicLink() ? \"SymbolicLink\" : stat.isBlockDevice() ? \"BlockDevice\" : stat.isCharacterDevice() ? \"CharacterDevice\" : stat.isFIFO() ? \"FIFO\" : stat.isSocket() ? \"Socket\" : \"Unknown\",\n mtime: Option.fromNullishOr(stat.mtime),\n atime: Option.fromNullishOr(stat.atime),\n birthtime: Option.fromNullishOr(stat.birthtime),\n dev: bigintToNumber(stat.dev, \"dev\"),\n rdev: bigintToNumberOption(stat.rdev),\n ino: bigintToNumberOption(stat.ino),\n mode: bigintToNumber(stat.mode, \"mode\"),\n nlink: bigintToNumberOption(stat.nlink),\n uid: bigintToNumberOption(stat.uid),\n gid: bigintToNumberOption(stat.gid),\n size: ByteSize.bytes(stat.size),\n blksize: stat.blksize !== undefined ? Option.some(ByteSize.bytes(stat.blksize)) : Option.none(),\n blocks: bigintToNumberOption(stat.blocks)\n }),\n catch: handleBadArgument(\"stat\")\n});\nconst stat = /*#__PURE__*/(() => {\n const nodeStat = /*#__PURE__*/effectify(NFS.stat, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"stat\"), /*#__PURE__*/handleBadArgument(\"stat\"));\n return path => Effect.flatMap(nodeStat(path, {\n bigint: true\n }), makeFileInfo);\n})();\n// == symlink\nconst symlink = /*#__PURE__*/(() => {\n const nodeSymlink = /*#__PURE__*/effectify(NFS.symlink, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"symlink\"), /*#__PURE__*/handleBadArgument(\"symlink\"));\n return (target, path) => nodeSymlink(target, path);\n})();\n// == truncate\nconst truncate = /*#__PURE__*/(() => {\n const nodeTruncate = /*#__PURE__*/effectify(NFS.truncate, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"truncate\"), /*#__PURE__*/handleBadArgument(\"truncate\"));\n return (path, length) => nodeTruncate(path, length);\n})();\n// == utimes\nconst utimes = /*#__PURE__*/(() => {\n const nodeUtimes = /*#__PURE__*/effectify(NFS.utimes, /*#__PURE__*/handleErrnoException(\"FileSystem\", \"utime\"), /*#__PURE__*/handleBadArgument(\"utime\"));\n return (path, atime, mtime) => nodeUtimes(path, atime, mtime);\n})();\n// == watch\nconst watchNode = (path, info, options) => Stream.callback(queue => Effect.acquireRelease(Effect.sync(() => {\n const directory = info.type === \"Directory\" ? path : Path.dirname(path);\n const watcher = NFS.watch(path, {\n recursive: options?.recursive ?? false\n }, (event, path) => {\n if (!path) return;\n switch (event) {\n case \"rename\":\n {\n Effect.runFork(Effect.matchEffect(stat(Path.resolve(directory, path)), {\n onSuccess: _ => Queue.offer(queue, {\n _tag: \"Create\",\n path\n }),\n onFailure: _ => Queue.offer(queue, {\n _tag: \"Remove\",\n path\n })\n }));\n return;\n }\n case \"change\":\n {\n Queue.offerUnsafe(queue, {\n _tag: \"Update\",\n path\n });\n return;\n }\n }\n });\n watcher.on(\"error\", error => {\n Queue.failCauseUnsafe(queue, Cause.fail(Error.systemError({\n module: \"FileSystem\",\n _tag: \"Unknown\",\n method: \"watch\",\n pathOrDescriptor: path,\n cause: error\n })));\n });\n watcher.on(\"close\", () => {\n Queue.endUnsafe(queue);\n });\n return watcher;\n}), watcher => Effect.sync(() => watcher.close())));\nconst watch = (backend, path, options) => stat(path).pipe(Effect.map(stat => backend.pipe(Option.flatMap(_ => _.register(path, stat, options)), Option.getOrElse(() => watchNode(path, stat, options)))), Stream.unwrap);\n// == writeFile\nconst writeFile = (path, data, options) => Effect.callback((resume, signal) => {\n try {\n NFS.writeFile(path, data, {\n signal,\n flag: options?.flag,\n mode: options?.mode\n }, err => {\n if (err) {\n resume(Effect.fail(handleErrnoException(\"FileSystem\", \"writeFile\")(err, [path])));\n } else {\n resume(Effect.void);\n }\n });\n } catch (err) {\n resume(Effect.fail(handleBadArgument(\"writeFile\")(err)));\n }\n});\nconst makeFileSystem = /*#__PURE__*/Effect.map(/*#__PURE__*/Effect.serviceOption(FileSystem.WatchBackend), backend => FileSystem.make({\n access,\n chmod,\n chown,\n copy,\n copyFile,\n glob,\n link,\n makeDirectory,\n makeTempDirectory,\n makeTempDirectoryScoped,\n makeTempFile,\n makeTempFileScoped,\n open,\n readDirectory,\n readFile,\n readLink,\n realPath,\n remove,\n rename,\n stat,\n symlink,\n truncate,\n utimes,\n watch(path, options) {\n return watch(backend, path, options);\n },\n writeFile\n}));\n/**\n * Provides the `FileSystem` service backed by Node filesystem APIs, including\n * file operations, directory operations, links, metadata, and file watching.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = /*#__PURE__*/Layer.effect(FileSystem.FileSystem)(makeFileSystem);\n//# sourceMappingURL=NodeFileSystem.js.map","/**\n * Node.js `FileSystem` layer for programs that perform real filesystem I/O.\n *\n * The exported layer satisfies the platform-independent `FileSystem` service\n * with Node-backed operations for files, directories, metadata, permissions,\n * links, temporary paths, and path watching. Effects still call the service from\n * `effect/FileSystem`; this module only chooses the Node implementation.\n *\n * @since 4.0.0\n */\nimport * as NodeFileSystem from \"@effect/platform-node-shared/NodeFileSystem\";\n/**\n * Provides the `FileSystem` service backed by Node filesystem APIs.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = NodeFileSystem.layer;\n//# sourceMappingURL=NodeFileSystem.js.map","/**\n * Node-backed provider for Effect's `Path` service.\n *\n * This module turns Node's `node:path` and `node:url` APIs into `Path` layers.\n * `layer` uses the host platform path implementation, while `layerPosix` and\n * `layerWin32` provide fixed POSIX and Windows variants. All three layers also\n * include helpers for converting between file paths and file URLs.\n *\n * @since 4.0.0\n */\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport { Path, TypeId } from \"effect/Path\";\nimport { BadArgument } from \"effect/PlatformError\";\nimport * as NodePath from \"node:path\";\nimport * as NodeUrl from \"node:url\";\nconst fileUrlOps = windows => ({\n fromFileUrl: url => Effect.try({\n try: () => NodeUrl.fileURLToPath(url, {\n windows\n }),\n catch: cause => new BadArgument({\n module: \"Path\",\n method: \"fromFileUrl\",\n cause\n })\n }),\n toFileUrl: path => Effect.try({\n try: () => NodeUrl.pathToFileURL(path, {\n windows\n }),\n catch: cause => new BadArgument({\n module: \"Path\",\n method: \"toFileUrl\",\n cause\n })\n })\n});\n/**\n * Provides the `Path` service using Node's POSIX path implementation plus\n * file URL conversion helpers.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layerPosix = /*#__PURE__*/Layer.succeed(Path)({\n [TypeId]: TypeId,\n ...NodePath.posix,\n ... /*#__PURE__*/fileUrlOps(false)\n});\n/**\n * Provides the `Path` service using Node's Windows path implementation plus\n * file URL conversion helpers.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layerWin32 = /*#__PURE__*/Layer.succeed(Path)({\n [TypeId]: TypeId,\n ...NodePath.win32,\n ... /*#__PURE__*/fileUrlOps(true)\n});\n/**\n * Provides the default `Path` service using the host platform's Node path\n * implementation plus file URL conversion helpers.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = /*#__PURE__*/Layer.succeed(Path)({\n [TypeId]: TypeId,\n ...NodePath,\n ... /*#__PURE__*/fileUrlOps(undefined)\n});\n//# sourceMappingURL=NodePath.js.map","/**\n * Node.js layers for Effect's `Path` service.\n *\n * This module provides the default, POSIX, and Windows variants of the\n * platform-independent `Path` service by reusing the shared Node path\n * implementation. The provided path services include Node file URL conversion\n * behavior.\n *\n * @since 4.0.0\n */\nimport * as NodePath from \"@effect/platform-node-shared/NodePath\";\n/**\n * Provides the default Node `Path` service using the platform's `node:path`\n * implementation.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = NodePath.layer;\n/**\n * Provides the `Path` service using Node's POSIX path implementation,\n * regardless of the host platform.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layerPosix = NodePath.layerPosix;\n/**\n * Provides the `Path` service using Node's Windows path implementation,\n * regardless of the host platform.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layerWin32 = NodePath.layerWin32;\n//# sourceMappingURL=NodePath.js.map","/**\n * Service contract for command-line arguments and standard input, output, and\n * error output. It lets programs depend on standard I/O through the Effect\n * environment instead of reading from or writing to global process handles\n * directly.\n *\n * The service exposes arguments as an `Effect`, stdout and stderr as `Sink`s\n * that accept strings or bytes, and stdin as a byte `Stream`. This module also\n * provides a constructor for service values and a small test layer with\n * overridable defaults.\n *\n * @since 4.0.0\n */\nimport * as Context from \"./Context.js\";\nimport * as Effect from \"./Effect.js\";\nimport * as Layer from \"./Layer.js\";\nimport * as Sink from \"./Sink.js\";\nimport * as Stream from \"./Stream.js\";\n/**\n * Runtime identifier stored on `Stdio` service implementations.\n *\n * **Details**\n *\n * This marker is part of the runtime representation of `Stdio` service\n * implementations.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = \"~effect/Stdio\";\n/**\n * Service tag for process standard I/O.\n *\n * **When to use**\n *\n * Use when you need command-line arguments or standard I/O streams supplied by\n * an effect's environment.\n *\n * @see {@link make} for constructing a `Stdio` service directly\n * @see {@link layerTest} for a test layer with defaults and overrides\n *\n * @category services\n * @since 4.0.0\n */\nexport const Stdio = /*#__PURE__*/Context.Service(TypeId);\n/**\n * Creates a `Stdio` service implementation from the provided fields and\n * attaches the `Stdio` type identifier.\n *\n * **When to use**\n *\n * Use when you need to assemble a concrete `Stdio` service from command-line\n * arguments and standard I/O implementations.\n *\n * **Details**\n *\n * The returned service reuses the supplied fields unchanged and adds the\n * `Stdio` type identifier. Omitted terminal-detection fields default to\n * effects that succeed with `false`.\n *\n * @see {@link layerTest} for a test layer with default fields that can be overridden\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = options => ({\n [TypeId]: TypeId,\n stdinIsTerminal: Effect.succeed(false),\n stdoutIsTerminal: Effect.succeed(false),\n ...options\n});\n/**\n * Creates a test layer for `Stdio`.\n *\n * **When to use**\n *\n * Use to provide deterministic standard I/O in tests while overriding only the\n * command-line arguments, input stream, or output sinks relevant to the case.\n *\n * **Details**\n *\n * Any provided fields override defaults. By default, arguments are empty,\n * standard output and error are draining sinks, and standard input is an empty\n * stream, and terminal-detection effects succeed with `false`.\n *\n * @see {@link make} for constructing a `Stdio` service directly without a `Layer` or defaults\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layerTest = impl => Layer.succeed(Stdio, make({\n args: Effect.succeed([]),\n stdout: () => Sink.drain,\n stderr: () => Sink.drain,\n stdin: Stream.empty,\n ...impl\n}));\n//# sourceMappingURL=Stdio.js.map","/**\n * Shared Node.js implementation of the Effect `Stdio` service.\n *\n * `NodeStdio` provides {@link Stdio.Stdio} from the current Node process. The\n * exported {@link layer} reads command-line arguments from `process.argv`,\n * consumes input from `process.stdin`, and writes normal and error output to\n * `process.stdout` and `process.stderr`. Standard input remains open, and\n * standard output and error output are not ended unless requested.\n *\n * @since 4.0.0\n */\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport { systemError } from \"effect/PlatformError\";\nimport * as Stdio from \"effect/Stdio\";\nimport { fromWritable } from \"./NodeSink.js\";\nimport { fromReadable } from \"./NodeStream.js\";\n/**\n * Provides `Stdio` from `process.argv`, `process.stdin`, `process.stdout`,\n * and `process.stderr`; stdin remains open and stdout/stderr are not ended by\n * default.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = /*#__PURE__*/Layer.succeed(Stdio.Stdio, /*#__PURE__*/Stdio.make({\n args: /*#__PURE__*/Effect.sync(() => process.argv.slice(2)),\n stdinIsTerminal: /*#__PURE__*/Effect.sync(() => process.stdin.isTTY === true),\n stdoutIsTerminal: /*#__PURE__*/Effect.sync(() => process.stdout.isTTY === true),\n stdout: options => fromWritable({\n evaluate: () => process.stdout,\n onError: cause => systemError({\n module: \"Stdio\",\n method: \"stdout\",\n _tag: \"Unknown\",\n cause\n }),\n endOnDone: options?.endOnDone ?? false\n }),\n stderr: options => fromWritable({\n evaluate: () => process.stderr,\n onError: cause => systemError({\n module: \"Stdio\",\n method: \"stderr\",\n _tag: \"Unknown\",\n cause\n }),\n endOnDone: options?.endOnDone ?? false\n }),\n stdin: /*#__PURE__*/fromReadable({\n evaluate: () => process.stdin,\n onError: cause => systemError({\n module: \"Stdio\",\n method: \"stdin\",\n _tag: \"Unknown\",\n cause\n }),\n closeOnDone: false\n })\n}));\n//# sourceMappingURL=NodeStdio.js.map","/**\n * Node.js `Stdio` layer for the current process.\n *\n * The exported layer reuses the shared Node stdio implementation. It satisfies\n * the platform-independent `Stdio` service by reading command-line arguments\n * from `process.argv`, consuming input from `process.stdin`, and writing output\n * streams to `process.stdout` and `process.stderr`.\n *\n * @since 4.0.0\n */\nimport * as NodeStdio from \"@effect/platform-node-shared/NodeStdio\";\n/**\n * Provides the `Stdio` service backed by the current process arguments,\n * stdin, stdout, and stderr streams.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = NodeStdio.layer;\n//# sourceMappingURL=NodeStdio.js.map","/**\n * Runs schemas against real values.\n *\n * Schema parsers construct values from schema input, check whether a value\n * matches a schema, decode encoded input, and encode decoded values back to\n * their external form. This module exposes those operations through several\n * result styles, including `Effect`, `Promise`, `Exit`, `Option`, `Result`, and\n * synchronous functions that throw. It also contains the lower-level runner that\n * walks a schema AST and reports schema failures as `SchemaIssue.Issue` values.\n *\n * @since 4.0.0\n */\nimport * as Cause from \"./Cause.js\";\nimport * as Effect from \"./Effect.js\";\nimport * as Exit from \"./Exit.js\";\nimport { memoize } from \"./Function.js\";\nimport { effectIsExit } from \"./internal/effect.js\";\nimport * as InternalSchemaCause from \"./internal/schema/cause.js\";\nimport * as InternalParser from \"./internal/schema/parser.js\";\nimport * as Option from \"./Option.js\";\nimport * as Result from \"./Result.js\";\nimport * as SchemaAST from \"./SchemaAST.js\";\nimport * as SchemaIssue from \"./SchemaIssue.js\";\n/**\n * Creates an effectful maker for the schema's decoded type side.\n *\n * **When to use**\n *\n * Use to construct decoded schema values in `Effect` while preserving\n * construction failures as `SchemaIssue.Issue` values in the error channel.\n *\n * **Details**\n *\n * The returned function accepts constructor input, applies constructor defaults,\n * runs type-side validation unless checks are disabled, and fails with a\n * `SchemaIssue.Issue` when construction fails.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeEffect(schema) {\n const ast = schema.ast;\n let parser;\n return (input, options) => {\n return (parser ??= runWithCompiler(constructorCompiler, SchemaAST.toType(ast)))(input, options?.disableChecks ? options?.parseOptions ? {\n ...options.parseOptions,\n disableChecks: true\n } : {\n disableChecks: true\n } : options?.parseOptions);\n };\n}\n/**\n * Creates a synchronous maker that returns `Option.some` with the constructed\n * value on success, or `Option.none` when construction fails with schema issues.\n *\n * **When to use**\n *\n * Use when you need to validate schema constructor input and only care whether\n * construction succeeds, without exposing `SchemaIssue.Issue` details.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are converted to `Option.none`.\n * Causes that contain defects, interruptions, or asynchronous work at this\n * synchronous boundary throw an `Error` whose cause is the underlying `Cause`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeOption(schema) {\n const parser = makeEffect(schema);\n return (input, options) => {\n const exit = Effect.runSyncExit(parser(input, options));\n if (Exit.isSuccess(exit)) {\n return Option.some(exit.value);\n }\n InternalSchemaCause.getSchemaIssueOrThrow(exit.cause, \"Option adapter can only return none for schema issues\");\n return Option.none();\n };\n}\n/**\n * Creates a synchronous maker for the schema's decoded type side.\n *\n * **When to use**\n *\n * Use to construct decoded schema values synchronously when invalid input\n * should throw an `Error` whose cause is `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function constructs a value from constructor input and throws an\n * `Error` with the `SchemaIssue.Issue` in its `cause` when construction fails.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or asynchronous work at this\n * synchronous boundary throw an `Error` whose cause is the underlying `Cause`,\n * instead of being converted to a schema validation error.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function make(schema) {\n const parser = makeEffect(schema);\n return (input, options) => {\n const exit = Effect.runSyncExit(parser(input, options));\n if (Exit.isSuccess(exit)) {\n return exit.value;\n }\n const issue = InternalSchemaCause.getSchemaIssueOrThrow(exit.cause, \"Constructor adapter can only throw schema issues\");\n throw new Error(\"Schema validation failed\", {\n cause: issue\n });\n };\n}\n/**\n * Creates a type guard that checks whether an input satisfies the schema's decoded\n * type side.\n *\n * **When to use**\n *\n * Use to build a type guard for checking the decoded side of a schema without\n * exposing issue details.\n *\n * **Details**\n *\n * The guard returns `true` on successful validation and `false` when validation\n * fails only with schema issues, without exposing issue details.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are converted to `false`. Causes\n * that contain defects, interruptions, or asynchronous work at this synchronous\n * boundary throw an `Error` whose cause is the underlying `Cause`.\n *\n * @category guards\n * @since 3.10.0\n */\nexport function is(schema) {\n return _is(schema.ast);\n}\n/** @internal */\nexport function _is(ast) {\n const parser = asExit(run(SchemaAST.toType(ast)));\n return input => {\n const exit = parser(input, SchemaAST.defaultParseOptions);\n if (Exit.isSuccess(exit)) {\n return true;\n }\n InternalSchemaCause.getSchemaIssueOrThrow(exit.cause, \"Type guard adapter can only return false for schema issues\");\n return false;\n };\n}\n/** @internal */\nexport function _issue(ast) {\n const parser = run(ast);\n return (input, options) => {\n const exit = Effect.runSyncExit(parser(input, options));\n if (Exit.isSuccess(exit)) {\n return undefined;\n }\n return InternalSchemaCause.getSchemaIssueOrThrow(exit.cause, \"Issue adapter can only return schema issues\");\n };\n}\n/**\n * Asserts that an input satisfies the schema's decoded type side.\n *\n * **When to use**\n *\n * Use to assert that an input satisfies the decoded side of a schema when schema\n * validation failures should throw an `Error` whose cause is `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The assertion returns normally when validation succeeds. When the input does\n * not satisfy the schema with a schema-only failure, it throws an `Error` with\n * the `SchemaIssue.Issue` in its `cause`.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or asynchronous work at this\n * synchronous boundary throw an `Error` whose cause is the underlying `Cause`,\n * instead of being converted to a schema validation error.\n *\n * @category guards\n * @since 4.0.0\n */\nexport function asserts(schema, input) {\n const parser = asExit(run(SchemaAST.toType(schema.ast)));\n const exit = parser(input, SchemaAST.defaultParseOptions);\n if (Exit.isFailure(exit)) {\n const issue = InternalSchemaCause.getSchemaIssueOrThrow(exit.cause, \"Assertion adapter can only throw schema issues\");\n throw new Error(\"Schema validation failed\", {\n cause: issue\n });\n }\n}\n/**\n * Creates an effectful decoder for `unknown` input.\n *\n * **When to use**\n *\n * Use when you need to decode untyped boundary input in an `Effect` whose\n * failure channel is `SchemaIssue.Issue`, while preserving transformations\n * and service requirements.\n *\n * **Details**\n *\n * The returned function succeeds with the schema's decoded `Type` or fails with a\n * `SchemaIssue.Issue`. Decoding service requirements are preserved in the returned\n * `Effect`. Parse options may be provided when creating the decoder and overridden\n * when applying it.\n *\n * @see {@link decodeEffect} for input already typed as the schema's `Encoded` type\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeUnknownEffect(schema, options) {\n const parser = run(schema.ast);\n return options === undefined ? parser : (input, overrideOptions) => parser(input, mergeParseOptions(options, overrideOptions));\n}\n/**\n * Creates an effectful decoder for input already typed as the schema's `Encoded`\n * type.\n *\n * **When to use**\n *\n * Use when you already have input typed as the schema's `Encoded` type and\n * need an `Effect` whose failure channel is `SchemaIssue.Issue`, while\n * preserving decoding service requirements.\n *\n * **Details**\n *\n * The returned function succeeds with the decoded `Type` or fails with a\n * `SchemaIssue.Issue`, preserving any decoding service requirements in the\n * returned `Effect`.\n *\n * @see {@link decodeUnknownEffect} for untyped boundary input\n * @see {@link encodeEffect} for the opposite direction\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeEffect = decodeUnknownEffect;\n/**\n * Creates a Promise-based decoder for `unknown` input.\n *\n * **When to use**\n *\n * Use when you need to decode untyped input with a service-free schema and\n * return a JavaScript `Promise`.\n *\n * **Details**\n *\n * The returned function resolves with the decoded `Type` on success and rejects\n * with an `Error` whose cause is a `SchemaIssue.Issue` on decoding failure.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or other non-schema reasons reject\n * with an `Error` whose cause is the underlying `Cause`.\n *\n * @see {@link decodePromise} for input already typed as the schema's `Encoded` type\n * @see {@link decodeUnknownEffect} for schemas that require decoding services or when failures should remain in `Effect`\n *\n * @category decoding\n * @since 3.10.0\n */\nexport function decodeUnknownPromise(schema, options) {\n return asPromise(decodeUnknownEffect(schema, options));\n}\n/**\n * Creates a Promise-based decoder for input already typed as the schema's\n * `Encoded` type.\n *\n * **When to use**\n *\n * Use when you already have input typed as the schema's `Encoded` type and need\n * decoding to return a JavaScript `Promise`.\n *\n * **Details**\n *\n * The returned function resolves with the decoded `Type` on success and rejects\n * with an `Error` whose cause is a `SchemaIssue.Issue` on decoding failure.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or other non-schema reasons reject\n * with an `Error` whose cause is the underlying `Cause`.\n *\n * @see {@link decodeUnknownPromise} for untyped input returning a JavaScript `Promise`\n * @see {@link decodeEffect} for preserving decoding services and failures in `Effect`\n *\n * @category decoding\n * @since 3.10.0\n */\nexport function decodePromise(schema, options) {\n return asPromise(decodeEffect(schema, options));\n}\n/**\n * Creates a synchronous decoder for `unknown` input that reports failure safely\n * as an `Exit`.\n *\n * **When to use**\n *\n * Use when you need to decode unknown input synchronously into an `Exit` whose\n * failure contains `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function produces `Exit.Success` with the decoded `Type`.\n * Schema issues are represented by an `Exit.Failure` cause containing a\n * `SchemaIssue.Issue`.\n *\n * **Gotchas**\n *\n * Because this adapter runs synchronously, async decoding work can produce an\n * `Exit.Failure` with a defect cause. When the cause contains both schema\n * issues and non-schema reasons, all reasons remain in the returned `Cause`.\n *\n * @see {@link decodeExit} for input already typed as the schema's `Encoded` type\n * @see {@link decodeUnknownEffect} for preserving decoding services and failures in `Effect`\n * @see {@link decodeUnknownResult} for returning schema issues as data\n * @see {@link decodeUnknownSync} for throwing on decoding failure\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeUnknownExit(schema, options) {\n return asExit(decodeUnknownEffect(schema, options));\n}\n/**\n * Creates a synchronous decoder for input already typed as the schema's `Encoded`\n * type, reporting failure safely as an `Exit`.\n *\n * **When to use**\n *\n * Use when you need synchronous decoding of already typed `Encoded` input into\n * an `Exit` whose failure contains `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function produces `Exit.Success` with the decoded `Type` or\n * `Exit.Failure` with a `SchemaIssue.Issue`.\n *\n * **Gotchas**\n *\n * Because this adapter runs synchronously, async decoding work can produce an\n * `Exit.Failure` with a defect cause. When the cause contains both schema\n * issues and non-schema reasons, all reasons remain in the returned `Cause`.\n *\n * @see {@link decodeUnknownExit} for untyped input with the same `Exit` result shape\n * @see {@link decodeEffect} for preserving decoding services and failures in `Effect`\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeExit = decodeUnknownExit;\n/** @internal */\nexport function decodeUnknownOption(schema, options) {\n return asOption(decodeUnknownEffect(schema, options));\n}\n/** @internal */\nexport const decodeOption = decodeUnknownOption;\n/**\n * Creates a decoder for `unknown` input that reports failure safely as a\n * `Result`.\n *\n * **When to use**\n *\n * Use when decoding untyped boundary input and you want `SchemaIssue.Issue`\n * failures returned as data in a `Result`.\n *\n * **Details**\n *\n * The returned function produces `Result.succeed` with the decoded `Type` on\n * success or `Result.fail` with a `SchemaIssue.Issue` on decoding failure.\n *\n * **Gotchas**\n *\n * This adapter runs synchronously. Causes made entirely of schema issues become\n * `Result.fail`, but causes that contain defects, interruptions, or asynchronous\n * work at this synchronous boundary throw instead.\n *\n * @see {@link decodeResult} for input already typed as the schema's `Encoded` type\n * @see {@link decodeUnknownEffect} for effectful or service-requiring decoding\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeUnknownResult(schema, options) {\n return asResult(decodeUnknownEffect(schema, options));\n}\n/**\n * Creates a decoder for input already typed as the schema's `Encoded` type,\n * reporting failure safely as a `Result`.\n *\n * **When to use**\n *\n * Use when you already have input typed as the schema's `Encoded` type and want\n * schema decoding failures represented as `Result.fail` with `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function produces `Result.succeed` with the decoded `Type` on\n * success or `Result.fail` with a `SchemaIssue.Issue` on decoding failure.\n *\n * **Gotchas**\n *\n * This synchronous adapter returns `Result.fail` for causes made entirely of\n * schema issues, but causes that contain defects, interruptions, or other\n * non-schema reasons throw instead.\n *\n * @see {@link decodeUnknownResult} for untyped input with the same `Result` shape\n * @see {@link decodeEffect} for effectful or service-requiring decoding\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeResult = decodeUnknownResult;\n/**\n * Creates a synchronous decoder for `unknown` input.\n *\n * **When to use**\n *\n * Use to decode untrusted or dynamically typed input at a synchronous boundary\n * where invalid data should throw an `Error` whose cause is `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function returns the decoded `Type` on success and throws an\n * `Error` with the `SchemaIssue.Issue` in its `cause` on decoding failure.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or asynchronous work at this\n * synchronous boundary throw an `Error` whose cause is the underlying `Cause`,\n * instead of being converted to a schema validation error.\n *\n * @see {@link decodeSync} for input already typed as the schema's `Encoded` type\n * @see {@link decodeUnknownEffect} for preserving decoding failures in `Effect`\n * @see {@link decodeUnknownResult} for returning schema issues as data\n *\n * @category decoding\n * @since 3.10.0\n */\nexport function decodeUnknownSync(schema, options) {\n return asSync(decodeUnknownEffect(schema, options));\n}\n/**\n * Creates a synchronous decoder for input already typed as the schema's `Encoded`\n * type.\n *\n * **When to use**\n *\n * Use to decode values already typed as the schema's `Encoded` input when\n * decoding failure should throw an `Error` whose cause is `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function returns the decoded `Type` on success and throws an\n * `Error` with the `SchemaIssue.Issue` in its `cause` on decoding failure.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or asynchronous work at this\n * synchronous boundary throw an `Error` whose cause is the underlying `Cause`,\n * instead of being converted to a schema validation error.\n *\n * @see {@link decodeUnknownSync} for untrusted or dynamically typed input\n * @see {@link decodeResult} for returning schema issues as data\n * @see {@link decodeEffect} for preserving decoding failures in `Effect`\n *\n * @category decoding\n * @since 3.10.0\n */\nexport const decodeSync = decodeUnknownSync;\n/**\n * Creates an effectful encoder for `unknown` input.\n *\n * **When to use**\n *\n * Use when you need to encode untyped boundary input in an `Effect` whose\n * failure channel is `SchemaIssue.Issue`, while preserving service\n * requirements.\n *\n * **Details**\n *\n * The returned function succeeds with the schema's `Encoded` value or fails with a\n * `SchemaIssue.Issue`. Encoding service requirements are preserved in the returned\n * `Effect`. Parse options may be provided when creating the encoder and overridden\n * when applying it.\n *\n * @see {@link encodeEffect} for the typed-input variant when the value is already typed as the schema's decoded `Type`\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeUnknownEffect(schema, options) {\n const parser = run(SchemaAST.flip(schema.ast));\n return options === undefined ? parser : (input, overrideOptions) => parser(input, mergeParseOptions(options, overrideOptions));\n}\n/**\n * Creates an effectful encoder for input already typed as the schema's decoded\n * `Type`.\n *\n * **When to use**\n *\n * Use when you need to encode values already typed as the schema's decoded\n * `Type` in an `Effect` whose failure channel is `SchemaIssue.Issue`, while\n * preserving service requirements.\n *\n * **Details**\n *\n * The returned function succeeds with the schema's `Encoded` value or fails with a\n * `SchemaIssue.Issue`, preserving any encoding service requirements in the\n * returned `Effect`.\n *\n * @see {@link encodeUnknownEffect} for encoding unknown input before the value is statically typed as the schema's `Type`\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encodeEffect = encodeUnknownEffect;\n/**\n * Creates a Promise-based encoder for `unknown` input.\n *\n * **When to use**\n *\n * Use when you need to encode untrusted or dynamically typed values with a\n * service-free schema and return a JavaScript `Promise`.\n *\n * **Details**\n *\n * The returned function resolves with the schema's `Encoded` value on success and\n * rejects with an `Error` whose cause is a `SchemaIssue.Issue` on encoding failure.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or other non-schema reasons reject\n * with an `Error` whose cause is the underlying `Cause`.\n *\n * @see {@link encodePromise} for input already typed as the schema's decoded `Type`\n * @see {@link encodeUnknownEffect} for schemas that require encoding services or when failures should remain in `Effect`\n *\n * @category encoding\n * @since 3.10.0\n */\nexport const encodeUnknownPromise = (schema, options) => asPromise(encodeUnknownEffect(schema, options));\n/**\n * Creates a Promise-based encoder for input already typed as the schema's decoded\n * `Type`.\n *\n * **When to use**\n *\n * Use when you already have values typed as the schema's decoded `Type` and\n * need encoding to return a JavaScript `Promise`.\n *\n * **Details**\n *\n * The returned function resolves with the schema's `Encoded` value on success and\n * rejects with an `Error` whose cause is a `SchemaIssue.Issue` on encoding failure.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or other non-schema reasons reject\n * with an `Error` whose cause is the underlying `Cause`.\n *\n * @see {@link encodeUnknownPromise} for encoding untyped input\n * @see {@link encodeEffect} for effectful encoding or schemas with encoding service requirements\n *\n * @category encoding\n * @since 3.10.0\n */\nexport const encodePromise = encodeUnknownPromise;\n/**\n * Creates a synchronous encoder for `unknown` input that reports failure safely\n * as an `Exit`.\n *\n * **When to use**\n *\n * Use when you need synchronous encoding of unknown input into an `Exit` whose\n * failure contains `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function produces `Exit.Success` with the schema's `Encoded` value\n * or `Exit.Failure` with a `SchemaIssue.Issue`.\n *\n * **Gotchas**\n *\n * Because this adapter runs synchronously, async encoding work can produce an\n * `Exit.Failure` with a defect cause. When the cause contains both schema\n * issues and non-schema reasons, all reasons remain in the returned `Cause`.\n *\n * @see {@link encodeExit} for input already typed as the schema's decoded `Type`\n * @see {@link encodeUnknownEffect} for effectful encoding that preserves service requirements\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeUnknownExit(schema, options) {\n return asExit(encodeUnknownEffect(schema, options));\n}\n/**\n * Creates a synchronous encoder for input already typed as the schema's decoded\n * `Type`, reporting failure safely as an `Exit`.\n *\n * **When to use**\n *\n * Use when you need synchronous encoding of already typed schema values into\n * an `Exit` whose failure contains `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function produces `Exit.Success` with the schema's `Encoded` value\n * or `Exit.Failure` with a `SchemaIssue.Issue`.\n *\n * **Gotchas**\n *\n * Because this adapter runs synchronously, async encoding work can produce an\n * `Exit.Failure` with a defect cause. When the cause contains both schema\n * issues and non-schema reasons, all reasons remain in the returned `Cause`.\n *\n * @see {@link encodeUnknownExit} for unknown input with the same `Exit` result shape\n * @see {@link encodeEffect} for effectful encoding that preserves service requirements\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encodeExit = encodeUnknownExit;\n/** @internal */\nexport function encodeUnknownOption(schema, options) {\n return asOption(encodeUnknownEffect(schema, options));\n}\n/** @internal */\nexport const encodeOption = encodeUnknownOption;\n/**\n * Creates an encoder for `unknown` input that reports failure safely as a\n * `Result`.\n *\n * **When to use**\n *\n * Use when encoding values from an unknown or dynamically typed boundary\n * synchronously, and you want `SchemaIssue.Issue` failures returned as `Result`\n * data.\n *\n * **Details**\n *\n * The returned function produces `Result.succeed` with the schema's `Encoded`\n * value on success or `Result.fail` with a `SchemaIssue.Issue` on encoding\n * failure.\n *\n * **Gotchas**\n *\n * This adapter runs synchronously. Causes made entirely of schema issues become\n * `Result.fail`, but causes that contain defects, interruptions, or asynchronous\n * work at this synchronous boundary throw instead.\n *\n * @see {@link encodeResult} for input already typed as the schema's decoded `Type`\n * @see {@link encodeUnknownEffect} for effectful encoding, including schemas with encoding service requirements\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeUnknownResult(schema, options) {\n return asResult(encodeUnknownEffect(schema, options));\n}\n/**\n * Creates an encoder for input already typed as the schema's decoded `Type`,\n * reporting failure safely as a `Result`.\n *\n * **When to use**\n *\n * Use when you already have input typed as the schema's decoded `Type` and want\n * encoding failures returned as `Result.fail` with `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function produces `Result.succeed` with the schema's `Encoded`\n * value on success or `Result.fail` with a `SchemaIssue.Issue` on encoding\n * failure.\n *\n * **Gotchas**\n *\n * This synchronous adapter returns `Result.fail` for causes made entirely of\n * schema issues, but causes that contain defects, interruptions, or other\n * non-schema reasons throw instead.\n *\n * @see {@link encodeUnknownResult} for the same `Result` shape when the input is not already typed\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encodeResult = encodeUnknownResult;\n/**\n * Creates a synchronous encoder for `unknown` input.\n *\n * **When to use**\n *\n * Use when you need to encode values from untyped input in synchronous code and\n * want encoding failures to throw an `Error` whose cause is `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function returns the schema's `Encoded` value on success and throws\n * an `Error` with the `SchemaIssue.Issue` in its `cause` on encoding failure.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or asynchronous work at this\n * synchronous boundary throw an `Error` whose cause is the underlying `Cause`,\n * instead of being converted to a schema validation error.\n *\n * @see {@link encodeSync} for input already typed as the schema's decoded `Type`\n * @see {@link encodeUnknownEffect} for effectful encoding that preserves service requirements\n *\n * @category encoding\n * @since 3.10.0\n */\nexport function encodeUnknownSync(schema, options) {\n return asSync(encodeUnknownEffect(schema, options));\n}\n/**\n * Creates a synchronous encoder for input already typed as the schema's decoded\n * `Type`.\n *\n * **When to use**\n *\n * Use to encode already typed schema values synchronously when encoding failure\n * should throw an `Error` whose cause is `SchemaIssue.Issue`.\n *\n * **Details**\n *\n * The returned function returns the schema's `Encoded` value on success and throws\n * an `Error` with the `SchemaIssue.Issue` in its `cause` on encoding failure.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or asynchronous work at this\n * synchronous boundary throw an `Error` whose cause is the underlying `Cause`,\n * instead of being converted to a schema validation error.\n *\n * @see {@link encodeUnknownSync} for unknown input with the same throwing boundary\n * @see {@link encodeResult} for returning schema issues as data\n * @see {@link encodeEffect} for effectful encoding that preserves service requirements\n *\n * @category encoding\n * @since 3.10.0\n */\nexport const encodeSync = encodeUnknownSync;\nconst mergeParseOptions = (options, overrideOptions) => overrideOptions ? {\n ...options,\n ...overrideOptions\n} : options;\nconst getValue = value => {\n if (value === InternalParser.missing) {\n return Effect.fail(new SchemaIssue.InvalidValue());\n }\n return Effect.succeed(value);\n};\n/** @internal */\nexport function run(ast) {\n return runWithCompiler(normalCompiler, ast);\n}\nfunction runWithCompiler(compiler, ast) {\n let parser;\n return (input, options) => {\n const result = (parser ??= compiler(ast))(input, options ?? SchemaAST.defaultParseOptions);\n if (result === InternalParser.sameExit) {\n return Effect.succeed(input);\n }\n if (!effectIsExit(result)) {\n return Effect.flatMapEager(result, getValue);\n }\n return result[InternalParser.args] === InternalParser.missing ? getValue(InternalParser.missing) : result;\n };\n}\nfunction asPromise(parser) {\n return (input, options) => Effect.runPromiseExit(parser(input, options)).then(exit => {\n if (Exit.isSuccess(exit)) {\n return exit.value;\n }\n const issue = InternalSchemaCause.getSchemaIssueOrThrow(exit.cause, \"Promise adapter can only reject schema issues\");\n throw new Error(\"Schema validation failed\", {\n cause: issue\n });\n });\n}\nfunction asExit(parser) {\n return (input, options) => Effect.runSyncExit(parser(input, options));\n}\n/** @internal */\nexport function asOption(parser) {\n const parserExit = asExit(parser);\n return (input, options) => {\n const exit = parserExit(input, options);\n if (Exit.isSuccess(exit)) {\n return Option.some(exit.value);\n }\n InternalSchemaCause.getSchemaIssueOrThrow(exit.cause, \"Option adapter can only return none for schema issues\");\n return Option.none();\n };\n}\nfunction asResult(parser) {\n const parserExit = asExit(parser);\n return (input, options) => {\n const exit = parserExit(input, options);\n if (Exit.isSuccess(exit)) {\n return Result.succeed(exit.value);\n }\n return Result.fail(InternalSchemaCause.getSchemaIssueOrThrow(exit.cause, \"Result adapter can only return schema issues\"));\n };\n}\nfunction asSync(parser) {\n const parserExit = asExit(parser);\n return (input, options) => {\n const exit = parserExit(input, options);\n if (Exit.isSuccess(exit)) {\n return exit.value;\n }\n const issue = InternalSchemaCause.getSchemaIssueOrThrow(exit.cause, \"Sync adapter can only throw schema issues\");\n throw new Error(\"Schema validation failed\", {\n cause: issue\n });\n };\n}\nconst normalCompiler = /*#__PURE__*/memoize(ast => makeParser(ast, normalCompiler));\nconst constructorCompiler = /*#__PURE__*/memoize(ast => makeParser(ast, constructorCompiler, compileConstructorDefault));\nconst compileDefaulted = /*#__PURE__*/memoize(ast => makeParser(ast, constructorCompiler, compileConstructorDefault, ast.context?.constructorDefault));\nfunction compileConstructorDefault(ast) {\n return ast.context?.constructorDefault ? compileDefaulted(ast) : constructorCompiler(ast);\n}\nfunction applyTransformation(result, current, transformation, options) {\n let transformed;\n if (effectIsExit(result) && result._tag === \"Success\") {\n const optional = InternalParser.toOption(result === InternalParser.sameExit ? current : result[InternalParser.args]);\n transformed = transformation._tag === \"Transformation\" ? transformation.decode.run(optional, options) : transformation.decode(InternalParser.succeed(optional), options);\n } else if (transformation._tag === \"Transformation\") {\n transformed = Effect.flatMapEager(result, value => transformation.decode.run(InternalParser.toOption(value), options));\n } else {\n transformed = transformation.decode(Effect.mapEager(result, InternalParser.toOption), options);\n }\n return effectIsExit(transformed) && transformed._tag === \"Success\" ? InternalParser.fromOptionExit(transformed[InternalParser.args]) : Effect.flatMapEager(transformed, InternalParser.fromOptionExit);\n}\nfunction makeConstructorParser(descriptor, compile) {\n let sourceParser;\n return (input, options) => {\n if (input === InternalParser.missing) return InternalParser.missingExit;\n if (descriptor.isConstructed(input)) return InternalParser.sameExit;\n const result = (sourceParser ??= compile(descriptor.link.to))(input, options);\n return applyTransformation(result, input, descriptor.link.transformation, options);\n };\n}\nfunction makeParser(ast, compile, compileConstructorDefault, constructorDefault) {\n const descriptor = compileConstructorDefault ? SchemaAST.getConstructorDescriptor(ast) : undefined;\n const parser = descriptor ? makeConstructorParser(descriptor, compile) : ast.getParser(compile, compileConstructorDefault);\n const checks = ast.checks;\n const links = constructorDefault ? ast.encoding ? [...ast.encoding, constructorDefault] : [constructorDefault] : ast.encoding;\n const encodingChecks = ast.encodingChecks;\n if (!links && !checks && !encodingChecks) {\n return parser;\n }\n let encodingParsers;\n const parseLocal = (input, options) => {\n let result = parser(input, options);\n if (encodingChecks && !options.disableChecks) {\n if (effectIsExit(result)) {\n if (result._tag === \"Success\") {\n const output = result === InternalParser.sameExit ? input : result[InternalParser.args];\n if (input !== InternalParser.missing && output !== InternalParser.missing) {\n const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options);\n if (issues) {\n result = Effect.fail(new SchemaIssue.Composite(ast, issues, input, options));\n }\n }\n }\n } else {\n result = Effect.flatMap(result, value => {\n if (input !== InternalParser.missing && value !== InternalParser.missing) {\n const issues = SchemaAST.collectIssues(encodingChecks, input, undefined, ast, options);\n if (issues) {\n return Effect.fail(new SchemaIssue.Composite(ast, issues, input, options));\n }\n }\n return Effect.succeed(value);\n });\n }\n }\n if (checks && !options.disableChecks) {\n if (effectIsExit(result)) {\n if (result._tag === \"Success\") {\n const value = result === InternalParser.sameExit ? input : result[InternalParser.args];\n if (value === InternalParser.missing) return result;\n const issues = SchemaAST.collectIssues(checks, value, undefined, ast, options);\n if (issues) {\n result = Effect.fail(new SchemaIssue.Composite(ast, issues, value, options));\n }\n }\n } else {\n result = Effect.flatMap(result, value => {\n if (value !== InternalParser.missing) {\n const issues = SchemaAST.collectIssues(checks, value, undefined, ast, options);\n if (issues) {\n return Effect.fail(new SchemaIssue.Composite(ast, issues, value, options));\n }\n }\n return Effect.succeed(value);\n });\n }\n }\n return result;\n };\n if (!links) {\n return parseLocal;\n }\n return (input, options) => {\n const parsers = encodingParsers ??= links.map(link => compile(link.to));\n let current = input;\n let result = parsers[parsers.length - 1](input, options);\n for (let i = links.length - 1; i >= 0; i--) {\n result = applyTransformation(result, current, links[i].transformation, options);\n if (i !== 0) {\n const next = parsers[i - 1];\n if (result._tag === \"Success\") {\n current = result[InternalParser.args];\n result = next(current, options);\n } else {\n result = Effect.flatMapEager(result, value => {\n const nextResult = next(value, options);\n return nextResult === InternalParser.sameExit ? InternalParser.succeed(value) : nextResult;\n });\n }\n }\n }\n if (result._tag === \"Success\") {\n const value = result[InternalParser.args];\n const local = parseLocal(value, options);\n return local === InternalParser.sameExit ? result : local;\n }\n result = Effect.catchCause(result, cause => Effect.failCauseSync(() => Cause.map(cause, issue => new SchemaIssue.Encoding(ast, issue, input, options))));\n return Effect.flatMapEager(result, value => {\n const local = parseLocal(value, options);\n return local === InternalParser.sameExit ? InternalParser.succeed(value) : local;\n });\n };\n}\n//# sourceMappingURL=SchemaParser.js.map","import * as Pipeable from \"../../Pipeable.js\";\nimport * as SchemaAST from \"../../SchemaAST.js\";\nimport * as SchemaParser from \"../../SchemaParser.js\";\n/** @internal */\nexport const TypeId = \"~effect/Schema/Schema\";\nconst SchemaProto = {\n [TypeId]: TypeId,\n pipe() {\n return Pipeable.pipeArguments(this, arguments);\n },\n annotate(annotations) {\n return this.rebuild(SchemaAST.annotate(this.ast, annotations));\n },\n annotateKey(annotations) {\n return this.rebuild(SchemaAST.annotateKey(this.ast, annotations));\n },\n check(...checks) {\n return this.rebuild(SchemaAST.appendChecks(this.ast, checks));\n }\n};\n/** @internal */\nexport function make(ast, options) {\n function Schema() {}\n const self = Object.setPrototypeOf(Schema, SchemaProto);\n if (options && (Object.hasOwn(options, \"name\") || Object.hasOwn(options, \"length\") || Object.hasOwn(options, \"__proto__\"))) {\n Object.defineProperties(self, Object.getOwnPropertyDescriptors({\n ...options\n }));\n } else {\n Object.assign(self, options);\n }\n self.ast = ast;\n self.rebuild = ast => make(ast, options);\n self.makeEffect = SchemaParser.makeEffect(self);\n self.make = SchemaParser.make(self);\n self.makeOption = SchemaParser.makeOption(self);\n return self;\n}\n//# sourceMappingURL=make.js.map","import { memoize } from \"../../Function.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as SchemaAST from \"../../SchemaAST.js\";\nimport * as SchemaGetter from \"../../SchemaGetter.js\";\nimport * as InternalTransformation from \"../../SchemaTransformation.js\";\nimport * as InternalMake from \"./make.js\";\n/** @internal */\nexport function toCodecJson(schema) {\n return InternalMake.make(toCodecJsonAST(schema.ast), {\n schema\n });\n}\n/** @internal */\nexport const toCodecJsonAST = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncodingIdempotent(ast => {\n const out = toCodecJsonASTStep(ast, toCodecJsonAST);\n const context = ast.context;\n if (out === ast || context === undefined) return out;\n return SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(context));\n});\nfunction withoutConstructorDefault(context) {\n return context.constructorDefault === undefined ? context : new SchemaAST.Context(context.isOptional, context.isMutable, undefined, context.annotations);\n}\nfunction validateCanonicalObjectPropertyNames(ast) {\n if (ast.propertySignatures.some(ps => typeof ps.name !== \"string\")) {\n throw new globalThis.Error(\"Objects property names must be strings\", {\n cause: ast\n });\n }\n}\nfunction makeReorder(getPriority) {\n return types => {\n // Create a map of original indices for O(1) lookup\n const indexMap = new Map();\n for (let i = 0; i < types.length; i++) {\n indexMap.set(SchemaAST.toEncoded(types[i]), i);\n }\n // Create a sorted copy of the types array\n const sortedTypes = [...types].sort((a, b) => {\n a = SchemaAST.toEncoded(a);\n b = SchemaAST.toEncoded(b);\n const pa = getPriority(a);\n const pb = getPriority(b);\n if (pa !== pb) return pa - pb;\n // If priorities are equal, maintain original order (stable sort)\n return indexMap.get(a) - indexMap.get(b);\n });\n // Check if order changed by comparing arrays\n const orderChanged = sortedTypes.some((ast, index) => ast !== types[index]);\n if (!orderChanged) return types;\n return sortedTypes;\n };\n}\nconst toCodecJsonReorder = /*#__PURE__*/makeReorder(ast => {\n switch (ast._tag) {\n case \"BigInt\":\n case \"Symbol\":\n case \"UniqueSymbol\":\n return 0;\n default:\n return 1;\n }\n});\nfunction toCodecJsonASTStep(ast, recur) {\n switch (ast._tag) {\n case \"Declaration\":\n {\n const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec;\n if (!Predicate.isFunction(getLink)) {\n return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToJson]);\n }\n const typeParameters = ast.typeParameters.map(tp => InternalMake.make(SchemaAST.toEncoded(tp)));\n const link = getLink(typeParameters);\n return link === undefined ? ast : SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)]);\n }\n case \"Unknown\":\n return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToJson]);\n case \"ObjectKeyword\":\n return SchemaAST.replaceEncoding(ast, [SchemaAST.objectKeywordToJson]);\n case \"Undefined\":\n case \"Void\":\n case \"Literal\":\n case \"Number\":\n return ast.toCodecJson();\n case \"UniqueSymbol\":\n case \"Symbol\":\n case \"BigInt\":\n return ast.toCodecStringTree();\n case \"Objects\":\n {\n validateCanonicalObjectPropertyNames(ast);\n return ast.recur(recur, SchemaAST.parameterFromString);\n }\n case \"Union\":\n {\n const sortedTypes = toCodecJsonReorder(ast.types);\n if (sortedTypes !== ast.types) {\n return new SchemaAST.Union(sortedTypes, ast.options, ast.annotations, ast.checks, ast.encoding, ast.context, ast.encodingChecks).recur(recur);\n }\n return ast.recur(recur);\n }\n case \"Arrays\":\n case \"Suspend\":\n return ast.recur(recur);\n }\n // `Schema.Any` is used as an escape hatch\n return ast;\n}\n/** @internal */\nexport function toCodecIso(schema) {\n return InternalMake.make(toCodecIsoAST(SchemaAST.toType(schema.ast)));\n}\nconst toCodecIsoAST = /*#__PURE__*/memoize(ast => {\n const out = toCodecIsoASTStep(ast, toCodecIsoAST);\n return out !== ast && ast.context !== undefined ? SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(ast.context)) : out;\n});\nfunction toCodecIsoASTStep(ast, recur) {\n switch (ast._tag) {\n case \"Declaration\":\n {\n const getLink = ast.annotations?.toCodecIso ?? ast.annotations?.toCodec;\n if (Predicate.isFunction(getLink)) {\n const link = getLink(ast.typeParameters.map(tp => InternalMake.make(tp)));\n return SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)]);\n }\n return ast;\n }\n case \"Arrays\":\n case \"Objects\":\n case \"Union\":\n case \"Suspend\":\n return ast.recur(recur);\n }\n return ast;\n}\n/** @internal */\nexport function toCodecStringTree(schema) {\n return InternalMake.make(toCodecStringTreeAST(schema.ast), {\n schema\n });\n}\n/** @internal */\nexport function toCodecArrayFromSingle(schema) {\n return InternalMake.make(toCodecArrayFromSingleAST(schema.ast));\n}\nconst toStringTreeReorder = /*#__PURE__*/makeReorder(ast => {\n switch (ast._tag) {\n case \"Null\":\n case \"Boolean\":\n case \"Number\":\n case \"BigInt\":\n case \"Symbol\":\n case \"UniqueSymbol\":\n return 0;\n default:\n return 1;\n }\n});\nfunction toCodecStringTreeASTStep(ast, recur, onMissingAnnotation) {\n switch (ast._tag) {\n case \"Declaration\":\n {\n const typeParameters = ast.typeParameters.map(tp => InternalMake.make(recur(SchemaAST.toEncoded(tp))));\n const getStringTreeLink = ast.annotations?.toCodecStringTree;\n if (Predicate.isFunction(getStringTreeLink)) {\n const link = getStringTreeLink(typeParameters);\n if (link === undefined) return ast;\n return SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)]);\n }\n const getJsonLink = ast.annotations?.toCodecJson;\n const jsonLink = Predicate.isFunction(getJsonLink) ? getJsonLink(typeParameters) : undefined;\n const getLink = jsonLink === undefined ? ast.annotations?.toCodec : undefined;\n const link = jsonLink ?? (Predicate.isFunction(getLink) ? getLink(typeParameters) : undefined);\n return link === undefined ? onMissingAnnotation(ast) : SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)]);\n }\n case \"Null\":\n return SchemaAST.replaceEncoding(ast, [nullToString]);\n case \"Boolean\":\n return SchemaAST.replaceEncoding(ast, [booleanToString]);\n case \"Unknown\":\n case \"ObjectKeyword\":\n return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToStringTree]);\n case \"Enum\":\n case \"Number\":\n case \"Literal\":\n case \"UniqueSymbol\":\n case \"Symbol\":\n case \"BigInt\":\n return ast.toCodecStringTree();\n case \"Objects\":\n {\n validateCanonicalObjectPropertyNames(ast);\n return ast.recur(recur, SchemaAST.parameterFromString);\n }\n case \"Union\":\n {\n const sortedTypes = toStringTreeReorder(ast.types);\n if (sortedTypes !== ast.types) {\n return new SchemaAST.Union(sortedTypes, ast.options, ast.annotations, ast.checks, ast.encoding, ast.context, ast.encodingChecks).recur(recur);\n }\n return ast.recur(recur);\n }\n case \"Arrays\":\n case \"Suspend\":\n return ast.recur(recur);\n }\n // `Schema.Any` is used as an escape hatch\n return ast;\n}\nconst nullToString = /*#__PURE__*/new SchemaAST.Link(/*#__PURE__*/new SchemaAST.Literal(\"null\"), /*#__PURE__*/new InternalTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(() => null), /*#__PURE__*/SchemaGetter.transform(() => \"null\")));\nconst booleanToString = /*#__PURE__*/new SchemaAST.Link(/*#__PURE__*/new SchemaAST.Union([/*#__PURE__*/new SchemaAST.Literal(\"true\"), /*#__PURE__*/new SchemaAST.Literal(\"false\")]), /*#__PURE__*/new InternalTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(s => s === \"true\"), /*#__PURE__*/SchemaGetter.String()));\nconst arrayFromSingleTransformation = /*#__PURE__*/new InternalTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(input => typeof input === \"string\" ? [input] : input), /*#__PURE__*/SchemaGetter.passthrough());\nconst isCodecArrayFromSingleLink = link => link.transformation === arrayFromSingleTransformation;\nconst toCodecStringTreeAST = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncodingIdempotent(ast => {\n const out = toCodecStringTreeASTStep(ast, toCodecStringTreeAST, ast => {\n throw new globalThis.Error(\"Missing structural codec for StringTree\", {\n cause: ast\n });\n });\n if (out !== ast && ast.context !== undefined) {\n return SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(ast.context));\n }\n return out;\n}, {\n stopAt: isCodecArrayFromSingleLink\n});\nconst toArrayFromSingleInputElement = ast => SchemaAST.isOptional(ast) ? SchemaAST.optionalKey(SchemaAST.unknown) : SchemaAST.unknown;\nconst toCodecArrayFromSingleAST = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncodingIdempotent(ast => {\n const out = toCodecArrayFromSingleASTStep(ast);\n if (SchemaAST.isArrays(out)) {\n const ensure = SchemaAST.decodeTo(new SchemaAST.Union([new SchemaAST.Arrays(out.isMutable, out.elements.map(toArrayFromSingleInputElement), out.rest.map(toArrayFromSingleInputElement)), SchemaAST.string], {\n mode: \"anyOf\"\n }), out, arrayFromSingleTransformation);\n return SchemaAST.isOptional(ast) ? SchemaAST.optionalKey(ensure) : ensure;\n }\n return out;\n}, {\n stopAt: isCodecArrayFromSingleLink\n});\nfunction toCodecArrayFromSingleASTStep(ast) {\n return ast._tag === \"Declaration\" || ast._tag === \"Arrays\" || ast._tag === \"Objects\" || ast._tag === \"Union\" || ast._tag === \"Suspend\" ? ast.recur(toCodecArrayFromSingleAST) : ast;\n}\n//# sourceMappingURL=toCodec.js.map","/**\n * Works with plain TypeScript objects, also called structs.\n *\n * The runtime helpers in this module create new objects instead of mutating\n * their inputs. They cover common object workflows such as reading properties,\n * listing typed keys, picking or omitting fields, assigning and renaming keys,\n * transforming values, deriving comparison helpers, and creating records from a\n * list of keys. The module also includes type-level helpers for simplifying and\n * merging object shapes.\n *\n * @since 2.0.0\n */\nimport * as Combiner from \"./Combiner.js\";\nimport * as Equivalence from \"./Equivalence.js\";\nimport { dual } from \"./Function.js\";\nimport * as InternalRecord from \"./internal/record.js\";\nimport * as order from \"./Order.js\";\nimport * as Reducer from \"./Reducer.js\";\n/**\n * Retrieves the value at `key` from a struct.\n *\n * **When to use**\n *\n * Use to extract a single property from a struct in a pipeline.\n *\n * **Details**\n *\n * The return type is narrowed to `S[K]`.\n *\n * **Example** (Extracting a property in a pipeline)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * pipe({ name: \"Alice\", age: 30 }, Struct.get(\"name\")) // => \"Alice\"\n * ```\n *\n * @see {@link keys} – list all string keys of a struct\n * @see {@link pick} – extract multiple properties into a new struct\n * @category getters\n * @since 2.0.0\n */\nexport const get = /*#__PURE__*/dual(2, (self, key) => self[key]);\n/**\n * Returns the string keys of a struct as a properly typed `Array`.\n *\n * **When to use**\n *\n * Use when you want a typed replacement for `Object.keys` that narrows the result\n * to the known string keys of the struct.\n *\n * **Gotchas**\n *\n * Symbol keys are excluded; only string keys are returned.\n *\n * **Example** (Reading typed keys)\n *\n * ```ts import.meta.vitest\n * import { Struct } from \"effect\"\n *\n * const user = { name: \"Alice\", age: 30, [Symbol.for(\"id\")]: 1 }\n *\n * const k: Array<\"name\" | \"age\"> = Struct.keys(user)\n * k // => [\"name\", \"age\"]\n * ```\n *\n * @see {@link get} – access a single key's value\n * @see {@link pick} – select a subset of keys into a new struct\n * @category getters\n * @since 3.6.0\n */\nexport const keys = self => Object.keys(self);\n/**\n * Creates a new struct containing only the specified keys.\n *\n * **When to use**\n *\n * Use to narrow a struct down to a subset of its properties.\n *\n * **Gotchas**\n *\n * Keys not present in the struct are silently ignored.\n *\n * **Example** (Selecting specific properties)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * const user = { name: \"Alice\", age: 30, admin: true }\n * pipe(user, Struct.pick([\"name\", \"age\"])) // => { name: \"Alice\", age: 30 }\n * ```\n *\n * @see {@link omit} – the inverse (exclude keys instead)\n * @see {@link get} – extract a single value\n * @category filtering\n * @since 2.0.0\n */\nexport const pick = /*#__PURE__*/dual(2, (self, keys) => {\n return buildStruct(self, (k, v) => hasPropertyKey(keys, k) ? [k, v] : undefined);\n});\n/**\n * Creates a new struct with the specified keys removed.\n *\n * **When to use**\n *\n * Use to exclude sensitive or irrelevant fields from a struct.\n *\n * **Gotchas**\n *\n * Keys not present in the struct are silently ignored.\n *\n * **Example** (Removing a property)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * const user = { name: \"Alice\", age: 30, password: \"secret\" }\n * pipe(user, Struct.omit([\"password\"])) // => { name: \"Alice\", age: 30 }\n * ```\n *\n * @see {@link pick} – the inverse (keep only specified keys)\n * @category filtering\n * @since 2.0.0\n */\nexport const omit = /*#__PURE__*/dual(2, (self, keys) => {\n return buildStruct(self, (k, v) => !hasPropertyKey(keys, k) ? [k, v] : undefined);\n});\n/**\n * Merges two structs into a new struct. When both structs share a key, the\n * value from `that` (the second struct) wins.\n *\n * **When to use**\n *\n * Use when you want `{ ...self, ...that }` with proper types.\n *\n * **Details**\n *\n * The result type is `Simplify>`.\n *\n * **Example** (Merging structs with overlapping keys)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * const defaults = { theme: \"light\", lang: \"en\" }\n * const overrides = { theme: \"dark\", fontSize: 14 }\n * pipe(defaults, Struct.assign(overrides)) // => { theme: \"dark\", lang: \"en\", fontSize: 14 }\n * ```\n *\n * @see {@link Assign} – the type-level equivalent\n * @see {@link evolve} – transform individual values instead of replacing them\n * @category combining\n * @since 4.0.0\n */\nexport const assign = /*#__PURE__*/dual(2, (self, that) => {\n return {\n ...self,\n ...that\n };\n});\n/**\n * Transforms values of a struct selectively using per-key functions. Keys\n * without a corresponding function are copied unchanged.\n *\n * **When to use**\n *\n * Use when you want to update specific fields while keeping the rest intact.\n *\n * **Details**\n *\n * Each transform function receives the current value and returns the new value;\n * the return type can differ from the input type.\n *\n * **Example** (Transforming selected values)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * const result = pipe(\n * { name: \"alice\", age: 30, active: true },\n * Struct.evolve({\n * name: (s) => s.toUpperCase(),\n * age: (n) => n + 1\n * })\n * )\n * result // => { name: \"ALICE\", age: 31, active: true }\n * ```\n *\n * @see {@link evolveKeys} – transform keys instead of values\n * @see {@link evolveEntries} – transform both keys and values\n * @see {@link map} – apply the same transformation to all values\n * @category transforming\n * @since 2.0.0\n */\nexport const evolve = /*#__PURE__*/dual(2, (self, e) => {\n return buildStruct(self, (k, v) => [k, Object.hasOwn(e, k) ? e[k](v) : v]);\n});\n/**\n * Transforms keys of a struct selectively using per-key functions. Keys without\n * a corresponding function are copied unchanged.\n *\n * **When to use**\n *\n * Use when you need computed key names, such as uppercasing or prefixing.\n *\n * **Details**\n *\n * Each transform function receives the key name and must return a new\n * `PropertyKey`.\n *\n * **Example** (Renaming keys with functions)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * const result = pipe(\n * { name: \"Alice\", age: 30 },\n * Struct.evolveKeys({\n * name: (k) => k.toUpperCase()\n * })\n * )\n * result // => { NAME: \"Alice\", age: 30 }\n * ```\n *\n * @see {@link renameKeys} – rename keys with a static mapping\n * @see {@link evolve} – transform values instead of keys\n * @see {@link evolveEntries} – transform both keys and values\n * @category transforming\n * @since 4.0.0\n */\nexport const evolveKeys = /*#__PURE__*/dual(2, (self, e) => {\n return buildStruct(self, (k, v) => [Object.hasOwn(e, k) ? e[k](k) : k, v]);\n});\n/**\n * Transforms both keys and values of a struct selectively. Each per-key\n * function receives `(key, value)` and must return a `[newKey, newValue]`\n * tuple. Keys without a corresponding function are copied unchanged.\n *\n * **When to use**\n *\n * Use when you need to rename a key and change its value in one step.\n *\n * **Details**\n *\n * The return type is fully tracked at the type level.\n *\n * **Example** (Transforming keys and values together)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * const result = pipe(\n * { amount: 100, label: \"total\" },\n * Struct.evolveEntries({\n * amount: (k, v) => [`${k}Cents`, v * 100],\n * label: (k, v) => [k, v.toUpperCase()]\n * })\n * )\n * result // => { amountCents: 10000, label: \"TOTAL\" }\n * ```\n *\n * @see {@link evolve} – transform values only\n * @see {@link evolveKeys} – transform keys only\n * @category transforming\n * @since 4.0.0\n */\nexport const evolveEntries = /*#__PURE__*/dual(2, (self, e) => {\n return buildStruct(self, (k, v) => Object.hasOwn(e, k) ? e[k](k, v) : [k, v]);\n});\n/**\n * Renames keys in a struct using a static `{ oldKey: newKey }` mapping. Keys\n * not mentioned in the mapping are copied unchanged.\n *\n * **When to use**\n *\n * Use when you need simple, declarative key renaming without custom logic.\n *\n * **Details**\n *\n * For computed key names, use {@link evolveKeys} instead.\n *\n * **Example** (Renaming keys)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * const result = pipe(\n * { firstName: \"Alice\", lastName: \"Smith\", age: 30 },\n * Struct.renameKeys({ firstName: \"first\", lastName: \"last\" })\n * )\n * result // => { first: \"Alice\", last: \"Smith\", age: 30 }\n * ```\n *\n * @see {@link evolveKeys} – rename keys using functions\n * @see {@link evolveEntries} – rename keys and transform values\n * @category transforming\n * @since 4.0.0\n */\nexport const renameKeys = /*#__PURE__*/dual(2, (self, mapping) => {\n return buildStruct(self, (k, v) => [Object.hasOwn(mapping, k) ? mapping[k] : k, v]);\n});\n/**\n * Creates an `Equivalence` for a struct by providing an `Equivalence` for each\n * property. Two structs are equivalent when all their corresponding properties\n * are equivalent.\n *\n * **When to use**\n *\n * Use when you need equality for a record-like object to be decided field by\n * field, with a custom equality rule for each property.\n *\n * **Details**\n *\n * This is an alias of `Equivalence.Struct`. Each property's equivalence is\n * checked independently; all must return `true` for the overall result to be\n * `true`.\n *\n * **Example** (Comparing structs for equivalence)\n *\n * ```ts import.meta.vitest\n * import { Equivalence, Struct } from \"effect\"\n *\n * const PersonEquivalence = Struct.makeEquivalence({\n * name: Equivalence.strictEqual(),\n * age: Equivalence.strictEqual()\n * })\n *\n * PersonEquivalence({ name: \"Alice\", age: 30 }, { name: \"Alice\", age: 30 }) // => true\n * PersonEquivalence({ name: \"Alice\", age: 30 }, { name: \"Bob\", age: 30 }) // => false\n * ```\n *\n * @see {@link makeOrder} – create an `Order` for structs\n * @category instances\n * @since 4.0.0\n */\nexport const makeEquivalence = Equivalence.Struct;\n/**\n * Creates an `Order` for a struct by providing an `Order` for each property.\n * Properties are compared in the order they appear in the fields object; the\n * first non-zero comparison determines the result.\n *\n * **When to use**\n *\n * Use when you need to sort record-like objects lexicographically by several\n * fields, with each field using its own ordering rule.\n *\n * **Details**\n *\n * This is an alias of `Order.Struct`. The order of keys in the `fields` object\n * determines comparison priority.\n *\n * **Example** (Ordering structs by name then age)\n *\n * ```ts import.meta.vitest\n * import { Number, String, Struct } from \"effect\"\n *\n * const PersonOrder = Struct.makeOrder({\n * name: String.Order,\n * age: Number.Order\n * })\n *\n * PersonOrder({ name: \"Alice\", age: 30 }, { name: \"Bob\", age: 25 }) // => -1\n * ```\n *\n * @see {@link makeEquivalence} – create an `Equivalence` for structs\n * @category ordering\n * @since 4.0.0\n */\nexport const makeOrder = order.Struct;\n/**\n * Wraps a plain function as a {@link Lambda} value so it can be used with\n * {@link map}, {@link mapPick}, and {@link mapOmit}.\n *\n * **When to use**\n *\n * Use to create a typed lambda for struct mapping APIs that need type-level\n * input and output tracking.\n *\n * **Details**\n *\n * The type parameter `L` encodes both the input and output types at the type\n * level, allowing the compiler to track how struct value types change. At\n * runtime, the returned value is the same function; `lambda` only adjusts the\n * type.\n *\n * **Example** (Wrapping values in arrays)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * interface AsArray extends Struct.Lambda {\n * (self: A): Array\n * readonly \"~lambda.out\": Array\n * }\n *\n * const asArray = Struct.lambda((a) => [a])\n * const result = pipe({ x: 1, y: \"hello\" }, Struct.map(asArray))\n * result // => { x: [1], y: [\"hello\"] }\n * ```\n *\n * @see {@link Lambda} – the type-level interface\n * @see {@link map} – apply a lambda to all struct values\n * @category constructors\n * @since 4.0.0\n */\nexport const lambda = f => f;\n/**\n * Applies a {@link Lambda} transformation to every value in a struct.\n *\n * **When to use**\n *\n * Use when you want to apply the same function to every value in a struct.\n *\n * **Details**\n *\n * The lambda must be created with {@link lambda} so the compiler can track the\n * output types.\n *\n * **Example** (Wrapping every value in an array)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * interface AsArray extends Struct.Lambda {\n * (self: A): Array\n * readonly \"~lambda.out\": Array\n * }\n *\n * const asArray = Struct.lambda((a) => [a])\n * const result = pipe({ width: 10, height: 20 }, Struct.map(asArray))\n * result // => { width: [10], height: [20] }\n * ```\n *\n * @see {@link mapPick} – apply a lambda only to selected keys\n * @see {@link mapOmit} – apply a lambda to all keys except selected ones\n * @see {@link evolve} – apply different functions to different keys\n * @category mapping\n * @since 4.0.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, lambda) => {\n return buildStruct(self, (k, v) => [k, lambda(v)]);\n});\n/**\n * Applies a {@link Lambda} transformation only to the specified keys; all\n * other keys are copied unchanged.\n *\n * **When to use**\n *\n * Use when you want to apply the same transformation to a subset of properties.\n *\n * **Example** (Wrapping only selected values in arrays)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * interface AsArray extends Struct.Lambda {\n * (self: A): Array\n * readonly \"~lambda.out\": Array\n * }\n *\n * const asArray = Struct.lambda((a) => [a])\n * const result = pipe(\n * { x: 1, y: 2, z: 3 },\n * Struct.mapPick([\"x\", \"z\"], asArray)\n * )\n * result // => { x: [1], y: 2, z: [3] }\n * ```\n *\n * @see {@link map} – apply a lambda to all keys\n * @see {@link mapOmit} – apply a lambda to all keys except selected ones\n * @category mapping\n * @since 4.0.0\n */\nexport const mapPick = /*#__PURE__*/dual(3, (self, keys, lambda) => {\n return buildStruct(self, (k, v) => [k, hasPropertyKey(keys, k) ? lambda(v) : v]);\n});\n/**\n * Applies a {@link Lambda} transformation to all keys except the specified\n * ones; the excluded keys are copied unchanged.\n *\n * **When to use**\n *\n * Use when most keys should be transformed but a few should be preserved.\n *\n * **Example** (Wrapping all values except one in arrays)\n *\n * ```ts import.meta.vitest\n * import { pipe, Struct } from \"effect\"\n *\n * interface AsArray extends Struct.Lambda {\n * (self: A): Array\n * readonly \"~lambda.out\": Array\n * }\n *\n * const asArray = Struct.lambda((a) => [a])\n * const result = pipe(\n * { x: 1, y: 2, z: 3 },\n * Struct.mapOmit([\"y\"], asArray)\n * )\n * result // => { x: [1], y: 2, z: [3] }\n * ```\n *\n * @see {@link map} – apply a lambda to all keys\n * @see {@link mapPick} – apply a lambda only to selected keys\n * @category mapping\n * @since 4.0.0\n */\nexport const mapOmit = /*#__PURE__*/dual(3, (self, keys, lambda) => {\n return buildStruct(self, (k, v) => [k, !hasPropertyKey(keys, k) ? lambda(v) : v]);\n});\nfunction hasPropertyKey(keys, key) {\n return keys.some(candidate => candidate === key || typeof candidate === \"number\" && String(candidate) === key);\n}\n/**\n * Walk `source`; for each key decide what to emit via the small callback.\n *\n * The callback returns either\n * • `undefined` → nothing is copied, or\n * • `[newKey, newVal]`\n *\n * so every public API just supplies a different callback.\n */\nfunction buildStruct(source, f) {\n const out = {};\n for (const k of Reflect.ownKeys(source)) {\n if (!Object.prototype.propertyIsEnumerable.call(source, k)) continue;\n const res = f(k, source[k]);\n if (res) {\n const [nk, nv] = res;\n InternalRecord.assignProperty(out, nk, nv);\n }\n }\n return out;\n}\n/**\n * Creates a `Combiner` for a struct shape by providing a `Combiner` for each\n * property. When two structs are combined, each property is merged using its\n * corresponding combiner.\n *\n * **When to use**\n *\n * Use when you need to merge two same-shape records by combining each property\n * independently, such as summing counters or concatenating strings.\n *\n * **Details**\n *\n * Pass `omitKeyWhen` to drop properties whose merged value matches a predicate,\n * such as omitting zero counters.\n *\n * **Example** (Combining struct properties)\n *\n * ```ts import.meta.vitest\n * import { Number, String, Struct } from \"effect\"\n *\n * const C = Struct.makeCombiner<{ readonly n: number; readonly s: string }>({\n * n: Number.ReducerSum,\n * s: String.ReducerConcat\n * })\n *\n * C.combine({ n: 1, s: \"hello\" }, { n: 2, s: \" world\" }) // => { n: 3, s: \"hello world\" }\n * ```\n *\n * @see {@link makeReducer} – like `makeCombiner` but with an initial value\n * @category combining\n * @since 4.0.0\n */\nexport function makeCombiner(combiners, options) {\n const omitKeyWhen = options?.omitKeyWhen ?? (() => false);\n return Combiner.make((self, that) => {\n const keys = Reflect.ownKeys(combiners);\n const out = {};\n for (const key of keys) {\n const merge = combiners[key].combine(self[key], that[key]);\n if (omitKeyWhen(merge)) continue;\n InternalRecord.assignProperty(out, key, merge);\n }\n return out;\n });\n}\n/**\n * Creates a `Reducer` for a struct shape by providing a `Reducer` for each\n * property. The initial value is derived from each property's\n * `Reducer.initialValue`. When reducing a collection of structs, each property\n * is combined independently.\n *\n * **When to use**\n *\n * Use when you need to fold same-shape records by accumulating each property\n * independently into one summary record.\n *\n * **Details**\n *\n * Pass `omitKeyWhen` to drop properties whose reduced value matches a\n * predicate.\n *\n * **Example** (Reducing a collection of structs)\n *\n * ```ts import.meta.vitest\n * import { Number, String, Struct } from \"effect\"\n *\n * const R = Struct.makeReducer<{ readonly n: number; readonly s: string }>({\n * n: Number.ReducerSum,\n * s: String.ReducerConcat\n * })\n *\n * const result = R.combineAll([\n * { n: 1, s: \"a\" },\n * { n: 2, s: \"b\" },\n * { n: 3, s: \"c\" }\n * ])\n * result // => { n: 6, s: \"abc\" }\n * ```\n *\n * @see {@link makeCombiner} – like `makeReducer` but without an initial value\n * @category folding\n * @since 4.0.0\n */\nexport function makeReducer(reducers, options) {\n const combine = makeCombiner(reducers, options).combine;\n const initialValue = {};\n for (const key of Reflect.ownKeys(reducers)) {\n const iv = reducers[key].initialValue;\n if (options?.omitKeyWhen?.(iv)) continue;\n InternalRecord.assignProperty(initialValue, key, iv);\n }\n return Reducer.make(combine, initialValue);\n}\n/**\n * Creates a record with the given keys and value.\n *\n * **When to use**\n *\n * Use to build an object where each provided key receives the same value.\n *\n * **Example** (Creating a record)\n *\n * ```ts import.meta.vitest\n * import { Struct } from \"effect\"\n *\n * Struct.Record([\"a\", \"b\"], \"value\") // => { a: \"value\", b: \"value\" }\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function Record(keys, value) {\n const out = {};\n for (const key of keys) {\n InternalRecord.assignProperty(out, key, value);\n }\n return out;\n}\n//# sourceMappingURL=Struct.js.map","import * as Predicate from \"../Predicate.js\";\nexport const SchemaErrorTypeId = \"~effect/Schema/SchemaError\";\nexport function isSchemaError(u) {\n return Predicate.hasProperty(u, SchemaErrorTypeId) && u[SchemaErrorTypeId] === SchemaErrorTypeId;\n}\n//# sourceMappingURL=schemaError.js.map","/** @internal */\nexport const redactedRegistry = /*#__PURE__*/new WeakMap();\n/** @internal */\nexport const value = self => {\n if (redactedRegistry.has(self)) {\n return redactedRegistry.get(self);\n } else {\n throw new Error(\"Unable to get redacted value\" + (self.label ? ` with label: \"${self.label}\"` : \"\"));\n }\n};\n/** @internal */\nexport const stringOrRedacted = val => typeof val === \"string\" ? val : value(val);\n//# sourceMappingURL=redacted.js.map","/**\n * Wraps sensitive values so normal output does not reveal them.\n *\n * A `Redacted` shows a redacted placeholder in string, JSON, and inspection\n * output, while still storing the original value for trusted code that needs to\n * recover it. This helps reduce accidental leaks in logs and diagnostics. This\n * module includes constructors, runtime checks, value recovery, wiping of stored\n * values, and comparison helpers that avoid exposing the wrapped value at the\n * call site.\n *\n * @since 3.3.0\n */\nimport * as Equal from \"./Equal.js\";\nimport * as Equivalence from \"./Equivalence.js\";\nimport * as Hash from \"./Hash.js\";\nimport { PipeInspectableProto } from \"./internal/core.js\";\nimport * as redacted from \"./internal/redacted.js\";\nimport { hasProperty, isString } from \"./Predicate.js\";\nconst TypeId = \"~effect/Redacted\";\n/**\n * Returns `true` if a value is a `Redacted` wrapper.\n *\n * **When to use**\n *\n * Use to validate unknown input and narrow it to `Redacted`.\n *\n * **Details**\n *\n * When this function returns `true`, TypeScript narrows the value to\n * `Redacted`.\n *\n * **Example** (Checking for redacted values)\n *\n * ```ts import.meta.vitest\n * import { Redacted } from \"effect\"\n *\n * const secret = Redacted.make(\"my-secret\")\n * const plainString = \"not-secret\"\n *\n * Redacted.isRedacted(secret) // => true\n * Redacted.isRedacted(plainString) // => false\n * ```\n *\n * @category guards\n * @since 3.3.0\n */\nexport const isRedacted = u => hasProperty(u, TypeId);\n/**\n * Creates a `Redacted` wrapper for a sensitive value.\n *\n * **When to use**\n *\n * Use to wrap a sensitive value so normal string, JSON, and inspection output\n * is redacted.\n *\n * **Details**\n *\n * The wrapper redacts string, JSON, and inspection output to reduce accidental\n * disclosure. The original value remains retrievable with `Redacted.value`\n * until the wrapper is wiped or becomes unreachable.\n *\n * **Example** (Creating a redacted value)\n *\n * ```ts import.meta.vitest\n * import { Redacted } from \"effect\"\n *\n * const API_KEY = Redacted.make(\"1234567890\")\n * String(API_KEY) // => \"\"\n * ```\n *\n * @category constructors\n * @since 3.3.0\n */\nexport const make = (value, options) => {\n const self = Object.create(Proto);\n if (options?.label) {\n self.label = options.label;\n }\n redacted.redactedRegistry.set(self, value);\n return self;\n};\nconst Proto = {\n [TypeId]: {\n _A: _ => _\n },\n label: undefined,\n ...PipeInspectableProto,\n toJSON() {\n return this.toString();\n },\n toString() {\n return ``;\n },\n [Hash.symbol]() {\n return Hash.hash(redacted.redactedRegistry.get(this));\n },\n [Equal.symbol](that) {\n return isRedacted(that) && Equal.equals(redacted.redactedRegistry.get(this), redacted.redactedRegistry.get(that));\n }\n};\n/**\n * Retrieves the original value from a `Redacted` instance. Use this function\n * with caution, as it exposes the sensitive data.\n *\n * **When to use**\n *\n * Use when you need the underlying sensitive value at a trusted boundary.\n *\n * **Example** (Retrieving a redacted value)\n *\n * ```ts import.meta.vitest\n * import { Redacted } from \"effect\"\n *\n * const API_KEY = Redacted.make(\"1234567890\")\n *\n * Redacted.value(API_KEY) // => \"1234567890\"\n * ```\n *\n * @category getters\n * @since 3.3.0\n */\nexport const value = redacted.value;\n/**\n * Deletes the stored value for a `Redacted` wrapper, making future\n * `Redacted.value` calls on that wrapper fail.\n *\n * **When to use**\n *\n * Use when a `Redacted` wrapper should no longer be able to reveal its stored\n * value.\n *\n * **Gotchas**\n *\n * This unsafe operation does not zero memory and does not affect other\n * references to the original value. It only removes the value from the\n * internal redacted registry.\n *\n * **Example** (Wiping a redacted value)\n *\n * ```ts import.meta.vitest\n * import { Redacted, Result } from \"effect\"\n *\n * const API_KEY = Redacted.make(\"1234567890\")\n *\n * Redacted.value(API_KEY) // => \"1234567890\"\n *\n * Redacted.wipeUnsafe(API_KEY)\n *\n * const failure = Result.try({\n * try: () => Redacted.value(API_KEY),\n * catch: (error) => (error as Error).message\n * })\n * failure // => Result.fail(\"Unable to get redacted value\")\n * ```\n *\n * @category unsafe\n * @since 4.0.0\n */\nexport const wipeUnsafe = self => redacted.redactedRegistry.delete(self);\n/**\n * Generates an equivalence relation for `Redacted` values based on an\n * equivalence relation for the underlying values `A`. This function is useful\n * for comparing `Redacted` instances without exposing their contents.\n *\n * **When to use**\n *\n * Use when you need to compare wrapped secrets through an approved equality\n * rule without exposing the underlying values at each comparison site.\n *\n * **Example** (Comparing redacted values)\n *\n * ```ts import.meta.vitest\n * import { Equivalence, Redacted } from \"effect\"\n *\n * const API_KEY1 = Redacted.make(\"1234567890\")\n * const API_KEY2 = Redacted.make(\"1-34567890\")\n * const API_KEY3 = Redacted.make(\"1234567890\")\n *\n * const equivalence = Redacted.makeEquivalence(Equivalence.strictEqual())\n *\n * equivalence(API_KEY1, API_KEY2) // => false\n * equivalence(API_KEY1, API_KEY3) // => true\n * ```\n *\n * @category instances\n * @since 4.0.0\n */\nexport const makeEquivalence = isEquivalent => Equivalence.make((x, y) => isEquivalent(value(x), value(y)));\n//# sourceMappingURL=Redacted.js.map","/**\n * Models HTTP cookies and cookie collections for requests and responses.\n *\n * A `Cookie` stores a name, value, encoded value, and standard cookie\n * attributes. A `Cookies` value is an immutable collection keyed by cookie\n * name. This module parses request `Cookie` headers, builds response\n * `Set-Cookie` headers, and provides helpers for adding, removing, merging, and\n * expiring cookies.\n *\n * @since 4.0.0\n */\nimport * as Data from \"../../Data.js\";\nimport * as Duration from \"../../Duration.js\";\nimport { dual } from \"../../Function.js\";\nimport * as Inspectable from \"../../Inspectable.js\";\nimport * as InternalRecord from \"../../internal/record.js\";\nimport * as Option from \"../../Option.js\";\nimport { pipeArguments } from \"../../Pipeable.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as Record from \"../../Record.js\";\nimport * as Result from \"../../Result.js\";\nconst TypeId = \"~effect/http/Cookies\";\n/**\n * Returns `true` when a value is a `Cookies` collection.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isCookies = u => Predicate.hasProperty(u, TypeId);\nconst CookieTypeId = \"~effect/http/Cookies/Cookie\";\n/**\n * Returns `true` when a value is a `Cookie`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isCookie = u => Predicate.hasProperty(u, CookieTypeId);\nconst CookieErrorTypeId = \"~effect/http/Cookies/CookieError\";\n/**\n * Error reason describing why cookie construction failed, such as invalid name,\n * value, domain, path, or infinite max-age.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class CookiesErrorReason extends Data.Error {}\n/**\n * Error returned when a cookie name, value, domain, path, or max-age option is invalid.\n *\n * **Details**\n *\n * Inspect `reason` to determine the specific validation failure.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class CookiesError extends /*#__PURE__*/Data.TaggedError(\"CookiesError\") {\n /**\n * Creates a cookie error from a reason tag and optional cause.\n *\n * @since 4.0.0\n */\n static fromReason(reason, cause) {\n return new CookiesError({\n reason: new CookiesErrorReason({\n _tag: reason,\n cause\n })\n });\n }\n /**\n * Marks this value as a cookie validation error for runtime guards.\n *\n * @since 4.0.0\n */\n [CookieErrorTypeId] = CookieErrorTypeId;\n /**\n * Uses the concrete cookie error reason as the public message.\n *\n * @since 4.0.0\n */\n get message() {\n return this.reason._tag;\n }\n}\nconst Proto = {\n [TypeId]: TypeId,\n ...Inspectable.BaseProto,\n toJSON() {\n return {\n _id: \"effect/Cookies\",\n cookies: Record.map(this.cookies, cookie => cookie.toJSON())\n };\n },\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n/**\n * Creates a `Cookies` collection from an existing readonly record of cookies keyed by cookie name.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromReadonlyRecord = cookies => {\n const self = Object.create(Proto);\n self.cookies = cookies;\n return self;\n};\n/**\n * Create a Cookies object from an Iterable\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromIterable = cookies => {\n const record = {};\n for (const cookie of cookies) {\n InternalRecord.assignProperty(record, cookie.name, cookie);\n }\n return fromReadonlyRecord(record);\n};\n/**\n * Create a Cookies object from a set of Set-Cookie headers\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromSetCookie = headers => {\n const arrayHeaders = typeof headers === \"string\" ? [headers] : headers;\n const cookies = [];\n for (const header of arrayHeaders) {\n const cookie = parseSetCookie(header.trim());\n if (cookie) {\n cookies.push(cookie);\n }\n }\n return fromIterable(cookies);\n};\nfunction parseSetCookie(header) {\n const parts = header.split(\";\").map(_ => _.trim()).filter(_ => _ !== \"\");\n if (parts.length === 0) {\n return undefined;\n }\n const firstEqual = parts[0].indexOf(\"=\");\n if (firstEqual === -1) {\n return undefined;\n }\n const name = parts[0].slice(0, firstEqual);\n if (!cookieNameRegExp.test(name)) {\n return undefined;\n }\n const valueEncoded = parts[0].slice(firstEqual + 1);\n const value = tryDecodeURIComponent(valueEncoded);\n if (parts.length === 1) {\n return Object.assign(Object.create(CookieProto), {\n name,\n value,\n valueEncoded\n });\n }\n const options = {};\n for (let i = 1; i < parts.length; i++) {\n const part = parts[i];\n const equalIndex = part.indexOf(\"=\");\n const key = equalIndex === -1 ? part : part.slice(0, equalIndex).trim();\n const value = equalIndex === -1 ? undefined : part.slice(equalIndex + 1).trim();\n switch (key.toLowerCase()) {\n case \"domain\":\n {\n if (value === undefined) {\n break;\n }\n const domain = value.trim().replace(/^\\./, \"\");\n if (domain) {\n options.domain = domain;\n }\n break;\n }\n case \"expires\":\n {\n if (value === undefined) {\n break;\n }\n const date = new Date(value);\n if (!isNaN(date.getTime())) {\n options.expires = date;\n }\n break;\n }\n case \"max-age\":\n {\n if (value === undefined) {\n break;\n }\n const maxAge = parseInt(value, 10);\n if (!isNaN(maxAge)) {\n options.maxAge = Duration.seconds(maxAge);\n }\n break;\n }\n case \"path\":\n {\n if (value === undefined) {\n break;\n }\n if (value[0] === \"/\") {\n options.path = value;\n }\n break;\n }\n case \"priority\":\n {\n if (value === undefined) {\n break;\n }\n switch (value.toLowerCase()) {\n case \"low\":\n options.priority = \"low\";\n break;\n case \"medium\":\n options.priority = \"medium\";\n break;\n case \"high\":\n options.priority = \"high\";\n break;\n }\n break;\n }\n case \"httponly\":\n {\n options.httpOnly = true;\n break;\n }\n case \"secure\":\n {\n options.secure = true;\n break;\n }\n case \"partitioned\":\n {\n options.partitioned = true;\n break;\n }\n case \"samesite\":\n {\n if (value === undefined) {\n break;\n }\n switch (value.toLowerCase()) {\n case \"lax\":\n options.sameSite = \"lax\";\n break;\n case \"strict\":\n options.sameSite = \"strict\";\n break;\n case \"none\":\n options.sameSite = \"none\";\n break;\n }\n break;\n }\n }\n }\n return Object.assign(Object.create(CookieProto), {\n name,\n value,\n valueEncoded,\n options: Object.keys(options).length > 0 ? options : undefined\n });\n}\n/**\n * An empty Cookies object\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const empty = /*#__PURE__*/fromIterable([]);\n/**\n * Returns `true` when the `Cookies` collection contains no cookies.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isEmpty = self => Record.isEmptyRecord(self.cookies);\n// oxlint-disable-next-line no-control-regex\nconst fieldContentRegExp = /^[\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+$/;\nconst cookieNameRegExp = /^[!#$%&'*+\\-.^_`|~0-9A-Za-z]+$/;\n// oxlint-disable-next-line no-control-regex\nconst cookieDomainRegExp = /^[\\u0009\\u0020-\\u003a\\u003c-\\u007e\\u0080-\\u00ff]+$/;\nconst cookiePathRegExp = /^[\\u0020-\\u003a\\u003c-\\u007e]+$/;\nconst CookieProto = {\n [CookieTypeId]: CookieTypeId,\n ...Inspectable.BaseProto,\n toJSON() {\n return {\n _id: \"effect/Cookies/Cookie\",\n name: this.name,\n value: this.value,\n options: this.options\n };\n }\n};\n/**\n * Creates a cookie, validating the name, encoded value, domain, path, and finite `maxAge`.\n *\n * **Details**\n *\n * Returns a `CookiesError` in the `Result` failure channel when validation fails.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeCookie(name, value, options) {\n const encodedValue = encodeURIComponent(value);\n const error = validateCookie(name, encodedValue, options);\n if (error !== undefined) {\n return Result.fail(error);\n }\n return Result.succeed(Object.assign(Object.create(CookieProto), {\n name,\n value,\n valueEncoded: encodedValue,\n options\n }));\n}\nfunction validateCookie(name, encodedValue, options) {\n if (!cookieNameRegExp.test(name)) {\n return CookiesError.fromReason(\"InvalidCookieName\");\n }\n if (encodedValue && !fieldContentRegExp.test(encodedValue)) {\n return CookiesError.fromReason(\"InvalidCookieValue\");\n }\n if (options?.domain !== undefined && !cookieDomainRegExp.test(options.domain)) {\n return CookiesError.fromReason(\"InvalidCookieDomain\");\n }\n if (options?.path !== undefined && !cookiePathRegExp.test(options.path)) {\n return CookiesError.fromReason(\"InvalidCookiePath\");\n }\n if (options?.maxAge !== undefined && !Duration.isFinite(Duration.fromInputUnsafe(options.maxAge))) {\n return CookiesError.fromReason(\"CookieInfinityMaxAge\");\n }\n}\n/**\n * Create a new cookie, throwing an error if invalid\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeCookieUnsafe = (name, value, options) => Result.getOrThrow(makeCookie(name, value, options));\n/**\n * Adds a cookie to a Cookies object\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setCookie = /*#__PURE__*/dual(2, (self, cookie) => fromReadonlyRecord(Record.set(self.cookies, cookie.name, cookie)));\n/**\n * Adds multiple cookies to a Cookies object\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setAllCookie = /*#__PURE__*/dual(2, (self, cookies) => {\n const record = {\n ...self.cookies\n };\n for (const cookie of cookies) {\n InternalRecord.assignProperty(record, cookie.name, cookie);\n }\n return fromReadonlyRecord(record);\n});\n/**\n * Combines two Cookies objects, removing duplicates from the first\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const merge = /*#__PURE__*/dual(2, (self, that) => fromReadonlyRecord({\n ...self.cookies,\n ...that.cookies\n}));\n/**\n * Removes a cookie by name\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const remove = /*#__PURE__*/dual(2, (self, name) => fromReadonlyRecord(Record.remove(self.cookies, name)));\n/**\n * Gets a cookie from a Cookies object safely.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const get = /*#__PURE__*/dual(args => isCookies(args[0]), (self, name) => Option.fromUndefinedOr(Object.hasOwn(self.cookies, name) ? self.cookies[name] : undefined));\n/**\n * Gets the decoded value of a cookie by name safely.\n *\n * **Details**\n *\n * Returns `Option.none()` when the cookie is not present.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const getValue = /*#__PURE__*/dual(args => isCookies(args[0]), (self, name) => Option.map(get(self, name), cookie => cookie.value));\n/**\n * Creates and adds a cookie safely by name and value.\n *\n * **Details**\n *\n * The cookie fields are validated first; invalid input returns a `CookiesError` in the `Result` failure channel.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const set = /*#__PURE__*/dual(args => isCookies(args[0]), (self, name, value, options) => Result.map(makeCookie(name, value, options), cookie => fromReadonlyRecord(Record.set(self.cookies, name, cookie))));\n/**\n * Creates and adds a cookie by name and value, throwing if the cookie fields are invalid.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setUnsafe = /*#__PURE__*/dual(args => isCookies(args[0]), (self, name, value, options) => fromReadonlyRecord(Record.set(self.cookies, name, makeCookieUnsafe(name, value, options))));\n/**\n * Adds an expired cookie safely with an empty value, `Max-Age=0`, and an epoch `Expires` value.\n *\n * **Details**\n *\n * Returns a `CookiesError` in the `Result` failure channel when the name or options are invalid.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const expireCookie = /*#__PURE__*/dual(args => isCookies(args[0]), (self, name, options) => set(self, name, \"\", {\n ...options,\n maxAge: 0,\n expires: new Date(0)\n}));\n/**\n * Adds an expired cookie to a Cookies object, throwing an error if invalid\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const expireCookieUnsafe = /*#__PURE__*/dual(args => isCookies(args[0]), (self, name, options) => setUnsafe(self, name, \"\", {\n ...options,\n maxAge: 0,\n expires: new Date(0)\n}));\n/**\n * Creates and adds multiple cookies safely from name/value/options tuples.\n *\n * **Details**\n *\n * If any tuple is invalid, returns the first `CookiesError` and leaves the original collection unchanged.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setAll = /*#__PURE__*/dual(2, (self, cookies) => {\n const record = {\n ...self.cookies\n };\n for (const [name, value, options] of cookies) {\n const result = makeCookie(name, value, options);\n if (Result.isFailure(result)) {\n return result;\n }\n InternalRecord.assignProperty(record, name, result.success);\n }\n return Result.succeed(fromReadonlyRecord(record));\n});\n/**\n * Adds multiple cookies to a Cookies object, throwing an error if invalid\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setAllUnsafe = /*#__PURE__*/dual(2, (self, cookies) => Result.getOrThrow(setAll(self, cookies)));\n/**\n * Serializes a cookie into a string.\n *\n * **Details**\n *\n * Adapted from https://github.com/fastify/fastify-cookie under MIT License\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function serializeCookie(self) {\n const error = validateCookie(self.name, self.valueEncoded, self.options);\n if (error !== undefined) {\n throw error;\n }\n let str = self.name + \"=\" + self.valueEncoded;\n if (self.options === undefined) {\n return str;\n }\n const options = self.options;\n if (options.maxAge !== undefined) {\n const maxAge = Duration.toSeconds(Duration.fromInputUnsafe(options.maxAge));\n str += \"; Max-Age=\" + Math.trunc(maxAge);\n }\n if (options.domain !== undefined) {\n str += \"; Domain=\" + options.domain;\n }\n if (options.path !== undefined) {\n str += \"; Path=\" + options.path;\n }\n if (options.priority !== undefined) {\n switch (options.priority) {\n case \"low\":\n str += \"; Priority=Low\";\n break;\n case \"medium\":\n str += \"; Priority=Medium\";\n break;\n case \"high\":\n str += \"; Priority=High\";\n break;\n }\n }\n if (options.expires !== undefined) {\n str += \"; Expires=\" + options.expires.toUTCString();\n }\n if (options.httpOnly) {\n str += \"; HttpOnly\";\n }\n if (options.secure) {\n str += \"; Secure\";\n }\n // Draft implementation to support Chrome from 2024-Q1 forward.\n // See https://datatracker.ietf.org/doc/html/draft-cutler-httpbis-partitioned-cookies#section-2.1\n if (options.partitioned) {\n str += \"; Partitioned\";\n }\n if (options.sameSite !== undefined) {\n switch (options.sameSite) {\n case \"lax\":\n str += \"; SameSite=Lax\";\n break;\n case \"strict\":\n str += \"; SameSite=Strict\";\n break;\n case \"none\":\n str += \"; SameSite=None\";\n break;\n }\n }\n return str;\n}\n/**\n * Serializes a `Cookies` object into a Cookie header.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const toCookieHeader = self => Object.values(self.cookies).map(cookie => `${cookie.name}=${cookie.valueEncoded}`).join(\"; \");\n/**\n * Converts a `Cookies` collection to a record of decoded cookie values keyed by cookie name.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const toRecord = self => {\n const record = {};\n const cookies = Object.values(self.cookies);\n for (let index = 0; index < cookies.length; index++) {\n const cookie = cookies[index];\n InternalRecord.assignProperty(record, cookie.name, cookie.value);\n }\n return record;\n};\n/**\n * Serializes a `Cookies` collection into an array of `Set-Cookie` header values.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const toSetCookieHeaders = self => Object.values(self.cookies).map(serializeCookie);\n/**\n * Parses a cookie header into a record of key-value pairs\n *\n * **Details**\n *\n * Adapted from https://github.com/fastify/fastify-cookie under MIT License\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function parseHeader(header) {\n const result = {};\n const strLen = header.length;\n let pos = 0;\n let terminatorPos = 0;\n while (true) {\n if (terminatorPos === strLen) break;\n terminatorPos = header.indexOf(\";\", pos);\n if (terminatorPos === -1) terminatorPos = strLen; // This is the last pair\n let eqIdx = header.indexOf(\"=\", pos);\n if (eqIdx === -1) break; // No key-value pairs left\n if (eqIdx > terminatorPos) {\n // Malformed key-value pair\n pos = terminatorPos + 1;\n continue;\n }\n const key = header.substring(pos, eqIdx++).trim();\n if (!Object.hasOwn(result, key)) {\n const val = header.charCodeAt(eqIdx) === 0x22 ? header.substring(eqIdx + 1, terminatorPos - 1).trim() : header.substring(eqIdx, terminatorPos).trim();\n InternalRecord.assignProperty(result, key, !(val.indexOf(\"%\") === -1) ? tryDecodeURIComponent(val) : val);\n }\n pos = terminatorPos + 1;\n }\n return result;\n}\nconst tryDecodeURIComponent = str => {\n try {\n return decodeURIComponent(str);\n // oxlint-disable-next-line @typescript-eslint/no-unused-vars\n } catch (_) {\n return str;\n }\n};\n//# sourceMappingURL=Cookies.js.map","/**\n * Models HTTP headers for the unstable HTTP client and server modules.\n *\n * `Headers` values are immutable maps keyed by lowercase header name. This\n * module converts common header inputs into that shape, provides helpers for\n * reading and updating header values, and redacts configured sensitive headers\n * when values are inspected.\n *\n * @since 4.0.0\n */\nimport * as Context from \"../../Context.js\";\nimport * as Equal from \"../../Equal.js\";\nimport * as Equ from \"../../Equivalence.js\";\nimport { dual } from \"../../Function.js\";\nimport * as Hash from \"../../Hash.js\";\nimport * as Inspectable from \"../../Inspectable.js\";\nimport * as Option from \"../../Option.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as Record from \"../../Record.js\";\nimport * as Redactable from \"../../Redactable.js\";\nimport * as Redacted from \"../../Redacted.js\";\n/**\n * Runtime type identifier for `Headers` values.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = /*#__PURE__*/Symbol.for(\"~effect/http/Headers\");\n/**\n * Returns `true` if the provided value is a `Headers` value.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHeaders = u => Predicate.hasProperty(u, TypeId);\n// the properties are folded into the initializer (rather than a separate\n// `Object.defineProperties(Proto, ...)` statement) so the whole definition\n// is pure-annotated by the build and tree-shakable.\nconst Proto = /*#__PURE__*/Object.defineProperties(/*#__PURE__*/Object.create(null), {\n [TypeId]: {\n value: TypeId\n },\n [Redactable.symbolRedactable]: {\n value(context) {\n return redact(this, Context.get(context, CurrentRedactedNames));\n }\n },\n toJSON: {\n value() {\n return Redactable.redact(this);\n }\n },\n [Equal.symbol]: {\n value(that) {\n return Equivalence(this, that);\n }\n },\n [Hash.symbol]: {\n value() {\n return Hash.structure(this);\n }\n },\n toString: {\n value: Inspectable.BaseProto.toString\n },\n [Inspectable.NodeInspectSymbol]: {\n value: Inspectable.BaseProto[Inspectable.NodeInspectSymbol]\n }\n});\nconst make = input => Object.assign(Object.create(Proto), input);\n/**\n * Provides an `Equivalence` instance that compares `Headers` by header names\n * and string values.\n *\n * @category instances\n * @since 4.0.0\n */\nexport const Equivalence = /*#__PURE__*/Record.makeEquivalence(/*#__PURE__*/Equ.strictEqual());\n/**\n * An empty `Headers` collection.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const empty = /*#__PURE__*/Object.create(Proto);\n/**\n * Creates `Headers` from a record or iterable of header entries.\n *\n * **Details**\n *\n * Header names are normalized to lowercase. Array values in record input are joined with `\", \"`, and `undefined` values are omitted.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromInput = input => {\n if (input === undefined) {\n return empty;\n } else if (Symbol.iterator in input) {\n const out = Object.create(Proto);\n for (const [k, v] of input) {\n out[k.toLowerCase()] = v;\n }\n return out;\n }\n const out = Object.create(Proto);\n for (const [k, v] of Object.entries(input)) {\n if (Array.isArray(v)) {\n out[k.toLowerCase()] = v.join(\", \");\n } else if (v !== undefined) {\n out[k.toLowerCase()] = v;\n }\n }\n return out;\n};\n/**\n * Treats an existing record as `Headers` unsafely.\n *\n * **Gotchas**\n *\n * This mutates the record's prototype and does not normalize header names; callers must provide the expected lowercase keys.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromRecordUnsafe = input => Object.setPrototypeOf(input, Proto);\n/**\n * Returns `true` when a header with the given name is present.\n *\n * **Details**\n *\n * The lookup lowercases the provided header name.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const has = /*#__PURE__*/dual(2, (self, key) => key.toLowerCase() in self);\n/**\n * Gets a header value by name safely.\n *\n * **Details**\n *\n * The lookup lowercases the provided header name and returns `Option.none()` when absent.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const get = /*#__PURE__*/dual(2, (self, key) => Option.fromUndefinedOr(self[key.toLowerCase()]));\n/**\n * Returns a new `Headers` collection with the given header set.\n *\n * **Details**\n *\n * The header name is normalized to lowercase.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const set = /*#__PURE__*/dual(3, (self, key, value) => {\n const out = make(self);\n out[key.toLowerCase()] = value;\n return out;\n});\n/**\n * Returns a new `Headers` collection with all provided headers set.\n *\n * **Details**\n *\n * Input headers are normalized with `fromInput` and override existing headers with the same lowercase name.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setAll = /*#__PURE__*/dual(2, (self, headers) => make({\n ...self,\n ...fromInput(headers)\n}));\n/**\n * Returns a new `Headers` collection containing headers from both collections.\n *\n * **Details**\n *\n * Headers from the second collection override headers from the first collection with the same name.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const merge = /*#__PURE__*/dual(2, (self, headers) => {\n const out = make(self);\n Object.assign(out, headers);\n return out;\n});\n/**\n * Returns a new `Headers` collection with the named header removed.\n *\n * **Details**\n *\n * The provided header name is normalized to lowercase before removal.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const remove = /*#__PURE__*/dual(2, (self, key) => {\n const out = make(self);\n delete out[key.toLowerCase()];\n return out;\n});\n/**\n * Returns a new `Headers` collection with each named header removed.\n *\n * **Details**\n *\n * Each provided header name is normalized to lowercase before removal.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const removeMany = /*#__PURE__*/dual(2, (self, keys) => {\n const out = make(self);\n for (const key of keys) {\n delete out[key.toLowerCase()];\n }\n return out;\n});\n/**\n * Returns a plain record with selected header values wrapped in `Redacted`.\n *\n * **Details**\n *\n * String keys are normalized to lowercase before matching; regular expressions are tested against the stored header names.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const redact = /*#__PURE__*/dual(2, (self, key) => {\n const out = {\n ...self\n };\n const modify = key => {\n if (typeof key === \"string\") {\n const k = key.toLowerCase();\n if (k in self) {\n out[k] = Redacted.make(self[k]);\n }\n } else {\n for (const name in self) {\n if (name.search(key) !== -1) {\n out[name] = Redacted.make(self[name]);\n }\n }\n }\n };\n if (Array.isArray(key)) {\n for (let i = 0; i < key.length; i++) {\n modify(key[i]);\n }\n } else {\n modify(key);\n }\n return out;\n});\n/**\n * Checks whether a header name matches one of the redaction patterns.\n *\n * **Details**\n *\n * String patterns are compared case-insensitively against the header name;\n * regular expressions are tested against it. Use to avoid the record copy of\n * `redact` when only a membership check is needed.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const isRedactedName = (name, patterns) => {\n for (let i = 0; i < patterns.length; i++) {\n const pattern = patterns[i];\n if (typeof pattern === \"string\") {\n if (pattern.toLowerCase() === name.toLowerCase()) {\n return true;\n }\n } else if (name.search(pattern) !== -1) {\n return true;\n }\n }\n return false;\n};\n/**\n * Context reference listing header names or patterns that should be redacted when `Headers` are inspected or rendered.\n *\n * **Details**\n *\n * Defaults include `authorization`, `cookie`, `set-cookie`, and `x-api-key`.\n *\n * @category services\n * @since 4.0.0\n */\nexport const CurrentRedactedNames = /*#__PURE__*/Context.Reference(\"effect/Headers/CurrentRedactedNames\", {\n defaultValue: () => [\"authorization\", \"cookie\", \"set-cookie\", \"x-api-key\"]\n});\n//# sourceMappingURL=Headers.js.map","/**\n * Models URL query parameters as ordered string pairs.\n *\n * `UrlParams` is used for HTTP client query strings, URL-encoded form bodies,\n * and server-side decoding. Values can be built from records, iterables, or\n * native `URLSearchParams`, then updated, serialized, converted to a `URL`, or\n * decoded with schemas.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"../../Array.js\";\nimport * as Equal from \"../../Equal.js\";\nimport * as Equ from \"../../Equivalence.js\";\nimport { dual } from \"../../Function.js\";\nimport * as Hash from \"../../Hash.js\";\nimport { PipeInspectableProto } from \"../../internal/core.js\";\nimport * as InternalRecord from \"../../internal/record.js\";\nimport * as Option from \"../../Option.js\";\nimport { hasProperty } from \"../../Predicate.js\";\nimport * as Tuple from \"../../Tuple.js\";\nconst TypeId = \"~effect/http/UrlParams\";\n/**\n * Returns `true` when a value is a `UrlParams` instance.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isUrlParams = u => hasProperty(u, TypeId);\nconst Proto = {\n ...PipeInspectableProto,\n [TypeId]: TypeId,\n [Symbol.iterator]() {\n return this.params[Symbol.iterator]();\n },\n toJSON() {\n return {\n _id: \"UrlParams\",\n params: Object.fromEntries(this.params)\n };\n },\n [Equal.symbol](that) {\n return Equivalence(this, that);\n },\n [Hash.symbol]() {\n return Hash.array(this.params.flat());\n }\n};\n/**\n * Creates `UrlParams` from ordered string key-value pairs.\n *\n * **Details**\n *\n * The input pairs are used as-is and are not coerced or normalized.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = params => {\n const self = Object.create(Proto);\n self.params = params;\n return self;\n};\n/**\n * Creates `UrlParams` from a supported input shape.\n *\n * **Details**\n *\n * Primitive values are converted to strings, arrays produce repeated parameters,\n * nested records use bracket notation, and `undefined` values are omitted.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromInput = input => {\n if (isUrlParams(input)) {\n return input;\n }\n const parsed = fromInputNested(input);\n const out = [];\n for (let i = 0; i < parsed.length; i++) {\n if (Array.isArray(parsed[i][0])) {\n const [keys, value] = parsed[i];\n out.push([`${keys[0]}[${keys.slice(1).join(\"][\")}]`, value]);\n } else {\n out.push(parsed[i]);\n }\n }\n return make(out);\n};\nconst fromInputNested = input => {\n const entries = typeof input[Symbol.iterator] === \"function\" ? Arr.fromIterable(input) : Object.entries(input);\n const out = [];\n for (const [key, value] of entries) {\n if (Array.isArray(value)) {\n for (let i = 0; i < value.length; i++) {\n if (value[i] !== undefined) {\n out.push([key, String(value[i])]);\n }\n }\n } else if (value !== null && typeof value === \"object\") {\n const nested = fromInputNested(value);\n for (const [k, v] of nested) {\n out.push([[key, ...(typeof k === \"string\" ? [k] : k)], v]);\n }\n } else if (value !== undefined) {\n out.push([key, String(value)]);\n }\n }\n return out;\n};\n/**\n * Provides an order-sensitive `Equivalence` instance for `UrlParams`.\n *\n * **Details**\n *\n * Two values are equivalent when they contain the same key-value pairs in the same\n * order.\n *\n * @category instances\n * @since 4.0.0\n */\nexport const Equivalence = /*#__PURE__*/Equ.make((a, b) => arrayEquivalence(a.params, b.params));\nconst arrayEquivalence = /*#__PURE__*/Arr.makeEquivalence(/*#__PURE__*/Tuple.makeEquivalence([/*#__PURE__*/Equ.strictEqual(), /*#__PURE__*/Equ.strictEqual()]));\n/**\n * An empty `UrlParams` value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const empty = /*#__PURE__*/make([]);\n/**\n * Returns all values for a query parameter key in insertion order.\n *\n * **Details**\n *\n * Returns an empty array when the key is absent.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const getAll = /*#__PURE__*/dual(2, (self, key) => Arr.reduce(self.params, [], (acc, [k, value]) => {\n if (k === key) {\n acc.push(value);\n }\n return acc;\n}));\n/**\n * Returns the first value for a query parameter key safely.\n *\n * **When to use**\n *\n * Use when duplicate query parameters are ordered and the first occurrence has\n * precedence.\n *\n * **Details**\n *\n * Returns `Option.none` when the key is absent.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const getFirst = /*#__PURE__*/dual(2, (self, key) => Arr.findFirst(self.params, ([k]) => k === key).pipe(Option.map(([, value]) => value)));\n/**\n * Returns the last value for a query parameter key safely.\n *\n * **When to use**\n *\n * Use when duplicate query parameters are ordered and the last occurrence has\n * precedence.\n *\n * **Details**\n *\n * Returns `Option.none` when the key is absent.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const getLast = /*#__PURE__*/dual(2, (self, key) => Arr.findLast(self.params, ([k]) => k === key).pipe(Option.map(([, value]) => value)));\n/**\n * Sets a query parameter to a single value.\n *\n * **Details**\n *\n * Existing values for the same key are removed, and the new value is appended to\n * the end.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const set = /*#__PURE__*/dual(3, (self, key, value) => make(Arr.append(Arr.filter(self.params, ([k]) => k !== key), [key, String(value)])));\n/**\n * Transforms the underlying ordered key-value pairs of `UrlParams`.\n *\n * **Details**\n *\n * The result is wrapped in a new `UrlParams` value.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const transform = /*#__PURE__*/dual(2, (self, f) => make(f(self.params)));\n/**\n * Sets multiple query parameters from input.\n *\n * **Details**\n *\n * Keys present in the input replace existing values for those keys, while\n * unmentioned existing parameters are preserved.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setAll = /*#__PURE__*/dual(2, (self, input) => {\n const params = fromInput(input).params.slice();\n const keys = new Set();\n for (let i = 0; i < params.length; i++) {\n keys.add(params[i][0]);\n }\n for (let i = 0; i < self.params.length; i++) {\n if (keys.has(self.params[i][0])) continue;\n params.push(self.params[i]);\n }\n return make(params);\n});\n/**\n * Appends a query parameter value without removing existing values for the key.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const append = /*#__PURE__*/dual(3, (self, key, value) => make(Arr.append(self.params, [key, String(value)])));\n/**\n * Appends all query parameters produced from the supplied input.\n *\n * **Details**\n *\n * Existing parameters are preserved.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const appendAll = /*#__PURE__*/dual(2, (self, input) => transform(self, Arr.appendAll(fromInput(input).params)));\n/**\n * Removes all query parameter values for the specified key.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const remove = /*#__PURE__*/dual(2, (self, key) => transform(self, Arr.filter(([k]) => k !== key)));\n/**\n * Serializes `UrlParams` to a URL query string without a leading question mark.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toString = input => new URLSearchParams(fromInput(input).params).toString();\n/**\n * Builds a `Record` containing all the key-value pairs in the given `UrlParams`\n * as `string` (if only one value for a key) or a `NonEmptyArray`\n * (when more than one value for a key)\n *\n * **Example** (Converting parameters to a record)\n *\n * ```ts import.meta.vitest\n * import { UrlParams } from \"effect/unstable/http\"\n *\n * const urlParams = UrlParams.fromInput({\n * a: 1,\n * b: true,\n * c: \"string\",\n * e: [1, 2, 3]\n * })\n * UrlParams.toRecord(urlParams) // => { a: \"1\", b: \"true\", c: \"string\", e: [\"1\", \"2\", \"3\"] }\n * ```\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toRecord = self => {\n const out = {};\n for (const [k, value] of self.params) {\n if (!Object.hasOwn(out, k)) {\n InternalRecord.assignProperty(out, k, value);\n } else {\n const current = out[k];\n if (typeof current === \"string\") {\n InternalRecord.assignProperty(out, k, [current, value]);\n } else {\n current.push(value);\n }\n }\n }\n return out;\n};\n/**\n * Builds a readonly record from `UrlParams`.\n *\n * **Details**\n *\n * Keys with one value map to a string, and keys with multiple values map to a\n * non-empty readonly array of strings.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toReadonlyRecord = toRecord;\n//# sourceMappingURL=UrlParams.js.map","/**\n * Describes data shapes and how unknown input becomes trusted values.\n *\n * A schema can validate input, decode it into an application type, and encode\n * that value back to another representation. This module contains the main\n * schema, codec, decoder, and encoder APIs, together with schemas for common\n * JavaScript values and Effect data types. It also supports refinements,\n * transformations, defaults, classes, JSON Schema generation, test data\n * generation, formatting, equivalence, optics, and differs derived from schema\n * definitions.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"./Array.js\";\nimport * as BigDecimal_ from \"./BigDecimal.js\";\nimport * as ByteSize_ from \"./ByteSize.js\";\nimport * as Cause_ from \"./Cause.js\";\nimport * as Chunk_ from \"./Chunk.js\";\nimport * as Data from \"./Data.js\";\nimport * as DateTime from \"./DateTime.js\";\nimport * as Duration_ from \"./Duration.js\";\nimport * as Effect from \"./Effect.js\";\nimport * as Encoding from \"./Encoding.js\";\nimport * as Equal from \"./Equal.js\";\nimport * as Exit_ from \"./Exit.js\";\nimport { format, formatPropertyKey } from \"./Formatter.js\";\nimport { identity } from \"./Function.js\";\nimport * as HashMap_ from \"./HashMap.js\";\nimport * as HashSet_ from \"./HashSet.js\";\nimport * as core from \"./internal/core.js\";\nimport { effectIsExit } from \"./internal/effect.js\";\nimport * as InternalGraph from \"./internal/graph.js\";\nimport * as InternalRecord from \"./internal/record.js\";\nimport * as InternalAnnotations from \"./internal/schema/annotations.js\";\nimport * as InternalMake from \"./internal/schema/make.js\";\nimport * as InternalStandardSchema from \"./internal/schema/standardSchema.js\";\nimport * as InternalToCodec from \"./internal/schema/toCodec.js\";\nimport * as InternalToDifferJsonPatch from \"./internal/schema/toDifferJsonPatch.js\";\nimport * as InternalToEncoderXml from \"./internal/schema/toEncoderXml.js\";\nimport * as InternalEquivalence from \"./internal/schema/toEquivalence.js\";\nimport * as InternalToFormatter from \"./internal/schema/toFormatter.js\";\nimport * as InternalToIso from \"./internal/schema/toIso.js\";\nimport * as InternalToJsonSchemaDocument from \"./internal/schema/toJsonSchemaDocument.js\";\nimport * as InternalToRepresentation from \"./internal/schema/toRepresentation.js\";\nimport { isSchemaError as isSchemaErrorInternal, SchemaErrorTypeId } from \"./internal/schemaError.js\";\nimport { getStackTraceLimit, setStackTraceLimit } from \"./internal/stackTraceLimit.js\";\nimport { remainder } from \"./Number.js\";\nimport * as Option_ from \"./Option.js\";\nimport * as Order from \"./Order.js\";\nimport * as Pipeable from \"./Pipeable.js\";\nimport * as Predicate from \"./Predicate.js\";\nimport * as Record_ from \"./Record.js\";\nimport * as Redacted_ from \"./Redacted.js\";\nimport * as RegExp_ from \"./RegExp.js\";\nimport * as Result_ from \"./Result.js\";\nimport * as SchemaAST from \"./SchemaAST.js\";\nimport * as SchemaGetter from \"./SchemaGetter.js\";\nimport * as SchemaIssue from \"./SchemaIssue.js\";\nimport * as SchemaParser from \"./SchemaParser.js\";\nimport * as SchemaTransformation from \"./SchemaTransformation.js\";\nimport * as Struct_ from \"./Struct.js\";\nimport * as Cookies_ from \"./unstable/http/Cookies.js\";\nimport * as Headers_ from \"./unstable/http/Headers.js\";\nimport * as UrlParams_ from \"./unstable/http/UrlParams.js\";\nimport * as IpInterface_ from \"./unstable/net/IpInterface.js\";\nimport * as IpNetwork_ from \"./unstable/net/IpNetwork.js\";\nimport * as NetAddress_ from \"./unstable/net/NetAddress.js\";\nconst TypeId = InternalMake.TypeId;\n/**\n * Creates a schema for a **parametric** type (a generic container such as\n * `Array`, `Option`, etc.) by accepting a list of type-parameter schemas\n * and a decoder factory.\n *\n * **When to use**\n *\n * Use when you are defining a schema for a generic container whose validation\n * depends on one or more type-parameter schemas.\n *\n * **Details**\n *\n * The outer call `declareConstructor()` fixes the decoded type `T`,\n * the encoded type `E`, and the optional iso type. The inner call receives:\n * - `typeParameters` — the concrete schemas for each type variable\n * - `run` — a factory that, given resolved codecs for each type parameter,\n * returns a parsing function `(u, ast, options) => Effect`\n * - `annotations` — optional metadata\n *\n * @see {@link declare} for creating schemas for non-parametric types.\n *\n * **Example** (Schema for a parametric `Box` type)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schema, SchemaIssue, SchemaParser } from \"effect\"\n *\n * interface Box {\n * readonly value: A\n * }\n *\n * const isBox = (u: unknown): u is Box =>\n * typeof u === \"object\" && u !== null && \"value\" in u\n *\n * const Box = (item: A) =>\n * Schema.declareConstructor, Box>()(\n * [item],\n * ([itemCodec]) =>\n * (u, ast, options) => {\n * if (!isBox(u)) {\n * return Effect.fail(new SchemaIssue.InvalidType(ast, u, options))\n * }\n * return Effect.map(\n * SchemaParser.decodeUnknownEffect(itemCodec)(u.value, options),\n * (value) => ({ value })\n * )\n * }\n * )\n *\n * const schema = Box(Schema.Number)\n * Effect.runSync(Schema.decodeUnknownEffect(schema)({ value: 1 })) // => { value: 1 }\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function declareConstructor() {\n return (typeParameters, run, annotations) => {\n return make(new SchemaAST.Declaration(typeParameters.map(SchemaAST.getAST), typeParameters => run(typeParameters.map(ast => make(ast))), annotations));\n };\n}\n/**\n * Creates a schema for a **non-parametric** opaque type using a type-guard\n * function. The schema accepts any unknown value and succeeds when `is` returns\n * `true`, failing with an `InvalidType` issue otherwise.\n *\n * **When to use**\n *\n * Use when you are defining a schema for an opaque type with no type parameters\n * and validation can be expressed as a type guard.\n *\n * **Example** (Defining a schema for a custom `UserId` branded type)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * type UserId = string & { readonly _tag: \"UserId\" }\n *\n * const isUserId = (u: unknown): u is UserId =>\n * typeof u === \"string\" && u.startsWith(\"user_\")\n *\n * const UserId = Schema.declare(isUserId, {\n * title: \"UserId\",\n * description: \"A user identifier starting with 'user_'\"\n * })\n * Schema.decodeUnknownSync(UserId)(\"user_123\") // => \"user_123\"\n * ```\n *\n * @see {@link declareConstructor} for creating schemas for parametric types.\n *\n * @category constructors\n * @since 3.10.0\n */\nexport function declare(is, annotations) {\n return declareConstructor()([], () => (input, ast, options) => is(input) ? Effect.succeed(input) : Effect.fail(new SchemaIssue.InvalidType(ast, input, options)), annotations);\n}\n/**\n * Returns a schema widened to the fully-parameterized {@link Bottom} interface,\n * making all 14 type parameters visible to TypeScript.\n *\n * **Details**\n *\n * Normally, concrete schema interfaces (e.g. `Schema`) hide most type\n * parameters. `revealBottom` is useful when writing generic utilities that need\n * to inspect or propagate the complete set of type parameters.\n *\n * **Example** (Inspecting all type parameters of a schema)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.String\n *\n * // Widen to Bottom to access all 14 type parameters\n * const bottom = Schema.revealBottom(schema)\n *\n * // `bottom` now exposes Type, Encoded, DecodingServices, EncodingServices,\n * // ast, Rebuild, ~type.make.in, Iso, ~type.parameters, etc.\n * type T = typeof bottom[\"Type\"] // string\n * type E = typeof bottom[\"Encoded\"] // string\n * ```\n *\n * @category utility types\n * @since 4.0.0\n */\nexport function revealBottom(bottom) {\n return bottom;\n}\n/**\n * Adds metadata annotations to a schema without changing its runtime behavior.\n * This is the pipeable (curried) counterpart of the `.annotate` method.\n *\n * **Details**\n *\n * Annotations provide extra context used by documentation generators, JSON\n * Schema converters, error formatters, and other tooling. Common keys include\n * `title`, `description`, `examples`, `message`, and `identifier`.\n *\n * **Example** (Adding a title and description)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const Age = Schema.Natural.pipe(\n * Schema.annotate({\n * title: \"Age\",\n * description: \"A non-negative integer representing age in years\"\n * })\n * )\n * Schema.resolveAnnotations(Age)?.title // => \"Age\"\n * ```\n *\n * @see {@link annotateEncoded} to annotate the encoded side instead.\n *\n * @category annotations\n * @since 4.0.0\n */\nexport function annotate(annotations) {\n return self => self.annotate(annotations);\n}\n/**\n * Adds metadata annotations to the **encoded** side of a schema without\n * changing its runtime behavior. This is the encoded-side counterpart of\n * `annotate`, which targets the decoded (Type) side.\n *\n * **Details**\n *\n * Internally the schema is flipped so that `Encoded` becomes `Type`,\n * annotated, and then flipped back.\n *\n * **Example** (Adding a title to the encoded representation)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.NumberFromString.pipe(\n * Schema.annotateEncoded({\n * title: \"my title\"\n * })\n * )\n *\n * Schema.toEncoded(schema).ast.annotations?.title // => \"my title\"\n * ```\n *\n * @see {@link annotate} to annotate the type side instead.\n *\n * @category annotations\n * @since 4.0.0\n */\nexport function annotateEncoded(annotations) {\n return self => flip(flip(self).annotate(annotations));\n}\n/**\n * Adds key-level annotations to a schema field. This is the pipeable\n * (curried) counterpart of the `.annotateKey` method.\n *\n * **Details**\n *\n * Key annotations apply to a field's position inside a `Struct` or `Tuple`\n * rather than to the field's value type. They can carry a\n * `messageMissingKey` to customise the error shown when the field is absent,\n * as well as standard documentation fields such as `title`, `description`,\n * and `examples`.\n *\n * **Example** (Customizing the missing-key message for a required field)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.Struct({\n * username: Schema.String.pipe(\n * Schema.annotateKey({\n * description: \"The username used to log in\",\n * messageMissingKey: \"Username is required\"\n * })\n * )\n * })\n * schema.fields.username.ast.context?.annotations?.messageMissingKey // => \"Username is required\"\n * ```\n *\n * @category annotations\n * @since 4.0.0\n */\nexport function annotateKey(annotations) {\n return self => {\n return self.rebuild(SchemaAST.annotateKey(self.ast, annotations));\n };\n}\n/**\n * Returns a codec widened to the full {@link Codec} interface, prompting\n * TypeScript to infer all four type parameters (`T`, `E`, `RD`, `RE`).\n *\n * **Details**\n *\n * When a schema is stored in a variable typed as `Schema` or `Top`, the\n * encoded type and service requirements are erased. Passing the value through\n * `revealCodec` recovers those parameters without any runtime cost.\n *\n * **Example** (Recovering encoded type from a schema variable)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema: Schema.Schema = Schema.NumberFromString\n *\n * // Without revealCodec, Encoded is unknown\n * const codec = Schema.revealCodec(schema)\n * type Enc = typeof codec[\"Encoded\"] // string\n * ```\n *\n * @category utility types\n * @since 4.0.0\n */\nexport function revealCodec(codec) {\n return codec;\n}\n/**\n * Error thrown or returned when schema decoding or encoding fails.\n *\n * **Details**\n *\n * The `issue` field contains a structured {@link SchemaIssue.Issue} tree describing\n * every validation failure, including the path to the problematic value and\n * the expected type or constraint. The `message` field renders the issue tree\n * with the default formatter.\n *\n * **Gotchas**\n *\n * Parsing with `reportInput: true` adds an enumerable `input` field to\n * value-bearing issues. Built-in messages may include reported input, and\n * custom annotations or messages are not sanitized.\n *\n * **Example** (Inspecting a SchemaError)\n *\n * ```ts import.meta.vitest\n * import { Result, Schema } from \"effect\"\n *\n * const result = Schema.decodeUnknownResult(Schema.Number)(\"not a number\")\n * const message = Result.isFailure(result) ? result.failure.message : \"\"\n * message // => \"Expected number\"\n * ```\n *\n * @see {@link isSchemaError} for narrowing unknown values\n * @category errors\n * @since 4.0.0\n */\nexport class SchemaError extends /*#__PURE__*/Data.TaggedError(\"SchemaError\") {\n [SchemaErrorTypeId] = SchemaErrorTypeId;\n constructor(issue) {\n const stackTraceLimit = getStackTraceLimit();\n setStackTraceLimit(0);\n try {\n super({\n issue\n });\n } finally {\n setStackTraceLimit(stackTraceLimit);\n }\n }\n get message() {\n return SchemaIssue.defaultFormatter(this.issue);\n }\n toString() {\n return `SchemaError(${this.message})`;\n }\n}\n/**\n * Returns `true` if `u` is a {@link SchemaError}.\n *\n * **When to use**\n *\n * Use when you need to narrow an unknown value to `SchemaError`.\n *\n * **Example** (Narrowing Schema errors)\n *\n * ```ts import.meta.vitest\n * import { Result, Schema } from \"effect\"\n *\n * const result = Result.try(() => Schema.decodeUnknownSync(Schema.Number)(\"oops\"))\n * const error: unknown = Result.isFailure(result) ? result.failure : undefined\n * Schema.isSchemaError(error) // => true\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport function isSchemaError(u) {\n return isSchemaErrorInternal(u);\n}\nfunction fromIssueEffect(self) {\n if (effectIsExit(self)) {\n return fromIssueExit(self);\n }\n return Effect.catchCause(self, cause => Effect.failCauseSync(() => Cause_.map(cause, issue => new SchemaError(issue))));\n}\nfunction fromIssueExit(exit) {\n return Exit_.isSuccess(exit) ? exit : Exit_.failCause(Cause_.map(exit.cause, issue => new SchemaError(issue)));\n}\nfunction getSchemaErrorOrThrow(cause, message) {\n let schemaError;\n for (const reason of cause.reasons) {\n if (!Cause_.isFailReason(reason) || !isSchemaError(reason.error)) {\n throw new globalThis.Error(message, {\n cause\n });\n }\n schemaError ??= reason.error;\n }\n if (schemaError === undefined) {\n throw new globalThis.Error(message, {\n cause\n });\n }\n return schemaError;\n}\nfunction runSchemaErrorPromise(self) {\n return Effect.runPromiseExit(self).then(exit => {\n if (Exit_.isSuccess(exit)) {\n return exit.value;\n }\n throw getSchemaErrorOrThrow(exit.cause, \"Promise adapter can only reject schema errors\");\n });\n}\nfunction runSchemaErrorSync(self) {\n const exit = Effect.runSyncExit(self);\n if (Exit_.isSuccess(exit)) {\n return exit.value;\n }\n throw getSchemaErrorOrThrow(exit.cause, \"Sync adapter can only throw schema errors\");\n}\n/**\n * Returns a \"Standard Schema\" object conforming to the [Standard Schema\n * v1](https://standardschema.dev/) specification.\n *\n * **Details**\n *\n * This function creates a schema whose `validate` method attempts to decode and\n * validate the provided input synchronously. If the underlying `Schema`\n * includes any asynchronous components (e.g., asynchronous message resolutions\n * or checks), then validation will necessarily return a `Promise` instead.\n *\n * **Example** (Creating a standard schema from a regular schema)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * // Define custom hook functions for error formatting\n * const leafHook = (issue: any) => {\n * switch (issue._tag) {\n * case \"InvalidType\":\n * return \"Expected different type\"\n * case \"InvalidValue\":\n * return \"Invalid value provided\"\n * case \"MissingKey\":\n * return \"Required property missing\"\n * case \"UnexpectedKey\":\n * return \"Unexpected property found\"\n * case \"Forbidden\":\n * return \"Operation not allowed\"\n * case \"OneOf\":\n * return \"Multiple valid options available\"\n * default:\n * return \"Validation error\"\n * }\n * }\n *\n * // Create a standard schema from a regular schema\n * const PersonSchema = Schema.Struct({\n * name: Schema.NonEmptyString,\n * age: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 150 }))\n * })\n *\n * const standardSchema = Schema.toStandardSchemaV1(PersonSchema, {\n * leafHook\n * })\n *\n * // The standard schema can be used with any Standard Schema v1 compatible library\n * const validResult = standardSchema[\"~standard\"].validate({\n * name: \"Alice\",\n * age: 30\n * })\n * const invalidResult = standardSchema[\"~standard\"].validate({\n * name: \"\",\n * age: 200\n * })\n *\n * if (validResult instanceof Promise || invalidResult instanceof Promise) {\n * throw new Error(\"Expected synchronous validation\")\n * }\n * if (\"value\" in validResult) {\n * validResult.value // => { name: \"Alice\", age: 30 }\n * }\n * invalidResult.issues?.map((issue) => issue.path) // => [[\"name\"], [\"age\"]]\n * ```\n *\n * @category converting\n * @since 4.0.0\n */\nexport function toStandardSchemaV1(self, options) {\n return InternalStandardSchema.toStandardSchemaV1(self, options);\n}\n/**\n * Converts a schema to an experimental Standard JSON Schema V1 representation.\n *\n * **Details**\n *\n * https://github.com/standard-schema/standard-schema/pull/134\n *\n * @category converting\n * @since 4.0.0\n */\nexport function toStandardJSONSchemaV1(self) {\n return InternalStandardSchema.toStandardJSONSchemaV1(self);\n}\n/**\n * Creates a type guard function that checks if a value conforms to a given\n * schema.\n *\n * **Details**\n *\n * This function returns a predicate that performs a type-safe check, narrowing\n * the type of the input value if the check passes. The predicate returns `false`\n * for schema mismatches.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are converted to `false`. Causes\n * that contain defects, interruptions, or other non-schema reasons throw\n * instead.\n *\n * **Example** (Defining a basic type guard)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const isString = Schema.is(Schema.String)\n *\n * isString(\"hello\") // => true\n * isString(42) // => false\n *\n * // Type narrowing in action\n * const value: unknown = \"hello\"\n * if (isString(value)) {\n * // value is now typed as string\n * value.toUpperCase() // => \"HELLO\"\n * }\n * ```\n *\n * @category guards\n * @since 3.10.0\n */\nexport const is = SchemaParser.is;\n/**\n * Creates an assertion function that throws an error if the input does not match\n * the schema.\n *\n * **When to use**\n *\n * Use to validate unknown input at runtime while narrowing the value with a\n * TypeScript assertion signature.\n *\n * **Details**\n *\n * The input is narrowed if the assertion succeeds. If schema validation fails,\n * the assertion throws an `Error` whose cause is `SchemaIssue.Issue`.\n * Schema validation failures use the generic message `\"Schema validation failed\"`.\n * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when\n * human-readable details are needed.\n *\n * **Gotchas**\n *\n * Causes that contain defects, interruptions, or other non-schema reasons throw\n * with the underlying `Cause` attached instead of being converted to schema\n * validation errors.\n *\n * **Example** (Asserting and narrowing an input)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaIssue } from \"effect\"\n *\n * const input: unknown = \"hello\"\n *\n * // This will pass silently (no return value) and narrow input to string\n * Schema.asserts(Schema.String, input)\n * input.toUpperCase() // => \"HELLO\"\n *\n * // This will throw an error\n * try {\n * const invalid: unknown = 123\n * Schema.asserts(Schema.String, invalid)\n * } catch (error) {\n * if (error instanceof Error) {\n * SchemaIssue.isIssue(error.cause) // => true\n * }\n * }\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const asserts = SchemaParser.asserts;\n/**\n * Decodes an `unknown` input against a schema, returning an `Effect` that\n * succeeds with the decoded value or fails with a {@link SchemaError}.\n *\n * **When to use**\n *\n * Use when you need to decode unknown input in an `Effect` whose failure\n * channel is `SchemaError`.\n *\n * **Details**\n *\n * Prefer {@link decodeEffect} when the input is already typed as the schema's\n * `Encoded` type.\n * Options may be provided either when creating the decoder or when applying it;\n * application options override creation options.\n *\n * @see {@link SchemaParser.decodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeUnknownEffect(schema, options) {\n const parser = SchemaParser.decodeUnknownEffect(schema, options);\n return (input, options) => {\n return fromIssueEffect(parser(input, options));\n };\n}\n/**\n * Decodes a typed input (the schema's `Encoded` type) against a schema,\n * returning an `Effect` that succeeds with the decoded value or fails with a\n * {@link SchemaError}.\n *\n * **When to use**\n *\n * Use when you need to decode input already typed as the schema's `Encoded`\n * type in an `Effect` whose failure channel is `SchemaError`.\n *\n * **Details**\n *\n * For `unknown` input use {@link decodeUnknownEffect}.\n * Options may be provided either when creating the decoder or when applying it;\n * application options override creation options.\n *\n * @see {@link SchemaParser.decodeEffect} for the adapter that fails with `SchemaIssue.Issue` directly\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeEffect = decodeUnknownEffect;\n/**\n * Decodes an `unknown` input against a schema synchronously, returning an\n * `Exit` that is either a `Success` with the decoded value or a `Failure`.\n *\n * **When to use**\n *\n * Use when you need to decode unknown input into an `Exit` and capture schema\n * mismatches as `SchemaError`.\n *\n * **Details**\n *\n * Only usable with schemas that have no `DecodingServices` requirement. Prefer\n * {@link decodeExit} when the input is already typed as the schema's `Encoded`\n * type.\n * Options may be provided either when creating the decoder or when applying it;\n * application options override creation options.\n * Schema mismatches are represented by a `Failure` cause containing\n * `SchemaError`.\n *\n * **Gotchas**\n *\n * Schema issue fail reasons are wrapped as `SchemaError`. Defects,\n * interruptions, and other non-schema reasons remain in the returned `Cause`,\n * including when they are mixed with schema issues.\n *\n * @see {@link SchemaParser.decodeUnknownExit} for the adapter whose failure contains `SchemaIssue.Issue` directly\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeUnknownExit(schema, options) {\n const parser = SchemaParser.decodeUnknownExit(schema, options);\n return (input, options) => {\n return fromIssueExit(parser(input, options));\n };\n}\n/**\n * Decodes a typed input (the schema's `Encoded` type) against a schema\n * synchronously, returning an `Exit` that is either a `Success` with the decoded\n * value or a `Failure`.\n *\n * **When to use**\n *\n * Use when you need to decode already typed `Encoded` input into an `Exit` and\n * capture schema mismatches as `SchemaError`.\n *\n * **Details**\n *\n * Only usable with schemas that have no `DecodingServices` requirement. For\n * `unknown` input use {@link decodeUnknownExit}.\n * Options may be provided either when creating the decoder or when applying it;\n * application options override creation options.\n * Schema mismatches are represented by a `Failure` cause containing\n * `SchemaError`.\n *\n * **Gotchas**\n *\n * Schema issue fail reasons are wrapped as `SchemaError`. Defects,\n * interruptions, and other non-schema reasons remain in the returned `Cause`,\n * including when they are mixed with schema issues.\n *\n * @see {@link SchemaParser.decodeExit} for the adapter whose failure contains `SchemaIssue.Issue` directly\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeExit = decodeUnknownExit;\n/**\n * Decodes an `unknown` input against a schema, returning an `Option` that is\n * `Some` with the decoded value on success or `None` for schema mismatches.\n *\n * **When to use**\n *\n * Use when you do not know the input type statically and only need to know\n * whether decoding succeeded.\n *\n * **Details**\n *\n * Prefer this over {@link decodeUnknownExit} or {@link decodeUnknownEffect}\n * when you don't need error details. For input already typed as the schema's\n * `Encoded` type use {@link decodeOption}.\n * Options may be provided either when creating the decoder or when applying it;\n * application options override creation options.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are converted to `None`. Causes\n * that contain defects, interruptions, or other non-schema reasons throw\n * instead.\n *\n * @category decoding\n * @since 3.10.0\n */\nexport const decodeUnknownOption = SchemaParser.decodeUnknownOption;\n/**\n * Decodes a typed input (the schema's `Encoded` type) against a schema,\n * returning an `Option` that is `Some` with the decoded value on success or\n * `None` for schema mismatches.\n *\n * **When to use**\n *\n * Use when you already have input typed as the schema's `Encoded` type and\n * only need to know whether decoding succeeded.\n *\n * **Details**\n *\n * For `unknown` input use {@link decodeUnknownOption}.\n * Options may be provided either when creating the decoder or when applying it;\n * application options override creation options.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are converted to `None`. Causes\n * that contain defects, interruptions, or other non-schema reasons throw\n * instead.\n *\n * @category decoding\n * @since 3.10.0\n */\nexport const decodeOption = SchemaParser.decodeOption;\n/**\n * Decodes an `unknown` input against a schema, returning a `Result` that\n * succeeds with the decoded value or fails with a {@link SchemaError} for schema\n * mismatches.\n *\n * **When to use**\n *\n * Use when you do not know the input type statically and want schema mismatches\n * returned as `Result.fail` with `SchemaError`.\n *\n * **Details**\n *\n * For input already typed as the schema's `Encoded` type use\n * {@link decodeResult}.\n * Options may be provided either when creating the decoder or when applying it;\n * application options override creation options.\n * Schema mismatches are returned as `Result.fail` with `SchemaError`.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are returned as `Result.fail`.\n * Causes that contain defects, interruptions, or other non-schema reasons throw\n * instead.\n *\n * @see {@link SchemaParser.decodeUnknownResult} for the adapter that fails with `SchemaIssue.Issue` directly\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeUnknownResult(schema, options) {\n const parser = SchemaParser.decodeUnknownResult(schema, options);\n return (input, options) => {\n return Result_.mapError(parser(input, options), issue => new SchemaError(issue));\n };\n}\n/**\n * Decodes a typed input (the schema's `Encoded` type) against a schema,\n * returning a `Result` that succeeds with the decoded value or fails with a\n * {@link SchemaError} for schema mismatches.\n *\n * **When to use**\n *\n * Use when you already have input typed as the schema's `Encoded` type and want\n * schema mismatches returned as `Result.fail` with `SchemaError`.\n *\n * **Details**\n *\n * For `unknown` input use {@link decodeUnknownResult}.\n * Options may be provided either when creating the decoder or when applying it;\n * application options override creation options.\n * Schema mismatches are returned as `Result.fail` with `SchemaError`.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are returned as `Result.fail`.\n * Causes that contain defects, interruptions, or other non-schema reasons throw\n * instead.\n *\n * @see {@link SchemaParser.decodeResult} for the adapter that fails with `SchemaIssue.Issue` directly\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeResult = decodeUnknownResult;\n/**\n * Decodes an `unknown` input against a schema, returning a `Promise` that\n * resolves with the decoded value or rejects with a {@link SchemaError} for\n * schema mismatches.\n *\n * **When to use**\n *\n * Use when you need decoding of unknown input to return a JavaScript `Promise`\n * that rejects with `SchemaError` for schema mismatches.\n *\n * **Details**\n *\n * For input already typed as the schema's `Encoded` type use\n * {@link decodePromise}.\n * Options may be provided either when creating the decoder or when applying it;\n * application options override creation options.\n *\n * **Gotchas**\n *\n * Non-schema failures may reject with a runtime failure instead of\n * `SchemaError`.\n *\n * @see {@link SchemaParser.decodeUnknownPromise} for the adapter that rejects with an `Error` whose cause is `SchemaIssue.Issue`\n *\n * @category decoding\n * @since 3.10.0\n */\nexport function decodeUnknownPromise(schema, options) {\n const parser = decodeUnknownEffect(schema, options);\n return (input, options) => {\n return runSchemaErrorPromise(parser(input, options));\n };\n}\n/**\n * Decodes a typed input (the schema's `Encoded` type) against a schema,\n * returning a `Promise` that resolves with the decoded value or rejects with a\n * {@link SchemaError} for schema mismatches.\n *\n * **When to use**\n *\n * Use when you already have input typed as the schema's `Encoded` type and\n * need decoding to return a JavaScript `Promise` that rejects with\n * `SchemaError` for schema mismatches.\n *\n * **Details**\n *\n * For `unknown` input use `decodeUnknownPromise`.\n * Options may be provided either when creating the decoder or when applying it;\n * application options override creation options.\n *\n * **Gotchas**\n *\n * Non-schema failures may reject with a runtime failure instead of\n * `SchemaError`.\n *\n * @see {@link SchemaParser.decodePromise} for the adapter that rejects with an `Error` whose cause is `SchemaIssue.Issue`\n *\n * @category decoding\n * @since 3.10.0\n */\nexport const decodePromise = decodeUnknownPromise;\n/**\n * Decodes an `unknown` input against a schema synchronously, returning the\n * decoded value or throwing a {@link SchemaError} for schema mismatches.\n *\n * **When to use**\n *\n * Use when you need to validate unknown data at a synchronous boundary and want\n * schema mismatches to throw `SchemaError`.\n *\n * **Details**\n *\n * For input already typed as the schema's `Encoded` type use `decodeSync`.\n * Only service-free schemas can be decoded synchronously. For alternatives that\n * do not throw on schema mismatches, see `decodeUnknownOption`,\n * `decodeUnknownExit`, or `decodeUnknownEffect`. Options may be provided either\n * when creating the decoder or when applying it; application options override\n * creation options.\n *\n * **Gotchas**\n *\n * Non-schema failures may throw a runtime failure instead of `SchemaError`.\n *\n * **Example** (Decoding with a transformation schema)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const NumberFromString = Schema.NumberFromString\n *\n * Schema.decodeUnknownSync(NumberFromString)(\"42\") // => 42\n * ```\n *\n * @see {@link SchemaParser.decodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function decodeUnknownSync(schema, options) {\n const parser = decodeUnknownEffect(schema, options);\n return (input, options) => {\n return runSchemaErrorSync(parser(input, options));\n };\n}\n/**\n * Decodes a typed input (the schema's `Encoded` type) against a schema\n * synchronously, returning the decoded value or throwing a {@link SchemaError}\n * for schema mismatches.\n *\n * **When to use**\n *\n * Use when you already have input typed as the schema's `Encoded` type and\n * want schema mismatches to throw `SchemaError` synchronously.\n *\n * **Details**\n *\n * For `unknown` input use `decodeUnknownSync`.\n * Only service-free schemas can be decoded synchronously. Options may be\n * provided either when creating the decoder or when applying it; application\n * options override creation options.\n *\n * **Gotchas**\n *\n * Non-schema failures may throw a runtime failure instead of `SchemaError`.\n *\n * @see {@link SchemaParser.decodeSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeSync = decodeUnknownSync;\n/**\n * Encodes an `unknown` input against a schema, returning an `Effect` that\n * succeeds with the encoded value or fails with a {@link SchemaError}.\n *\n * **When to use**\n *\n * Use when you need to encode unknown input in an `Effect` whose failure\n * channel is `SchemaError`.\n *\n * **Details**\n *\n * Prefer {@link encodeEffect} when the value is already typed as the schema's\n * `Type`.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n *\n * **Example** (Encoding a value to a string)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schema } from \"effect\"\n *\n * const NumberFromString = Schema.NumberFromString\n *\n * await Effect.runPromise(Schema.encodeUnknownEffect(NumberFromString)(42)) // => \"42\"\n * ```\n *\n * @see {@link SchemaParser.encodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeUnknownEffect(schema, options) {\n const parser = SchemaParser.encodeUnknownEffect(schema, options);\n return (input, options) => {\n return fromIssueEffect(parser(input, options));\n };\n}\n/**\n * Encodes a typed input (the schema's `Type`) against a schema, returning an\n * `Effect` that succeeds with the encoded value or fails with a\n * {@link SchemaError}.\n *\n * **When to use**\n *\n * Use when you need to encode input already typed as the schema's `Type` in\n * an `Effect` whose failure channel is `SchemaError`.\n *\n * **Details**\n *\n * For `unknown` input use {@link encodeUnknownEffect}.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n *\n * @see {@link SchemaParser.encodeEffect} for the adapter that fails with `SchemaIssue.Issue` directly\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encodeEffect = encodeUnknownEffect;\n/**\n * Encodes an `unknown` input against a schema synchronously, returning an\n * `Exit` that is either a `Success` with the encoded value or a `Failure`.\n *\n * **When to use**\n *\n * Use when you need to encode unknown input into an `Exit` and capture schema\n * mismatches as `SchemaError`.\n *\n * **Details**\n *\n * Only usable with schemas that have no `EncodingServices` requirement. Prefer\n * {@link encodeExit} when the value is already typed as the schema's `Type`.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n * Schema mismatches are represented by a `Failure` cause containing\n * `SchemaError`.\n *\n * **Gotchas**\n *\n * Schema issue fail reasons are wrapped as `SchemaError`. Defects,\n * interruptions, and other non-schema reasons remain in the returned `Cause`,\n * including when they are mixed with schema issues.\n *\n * @see {@link SchemaParser.encodeUnknownExit} for the adapter whose failure contains `SchemaIssue.Issue` directly\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeUnknownExit(schema, options) {\n const parser = SchemaParser.encodeUnknownExit(schema, options);\n return (input, options) => {\n return fromIssueExit(parser(input, options));\n };\n}\n/**\n * Encodes a typed input (the schema's `Type`) against a schema synchronously,\n * returning an `Exit` that is either a `Success` with the encoded value or a\n * `Failure`.\n *\n * **When to use**\n *\n * Use when you need to encode already typed schema values into an `Exit` and\n * capture schema mismatches as `SchemaError`.\n *\n * **Details**\n *\n * Only usable with schemas that have no `EncodingServices` requirement. For\n * `unknown` input use {@link encodeUnknownExit}.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n * Schema mismatches are represented by a `Failure` cause containing\n * `SchemaError`.\n *\n * **Gotchas**\n *\n * Schema issue fail reasons are wrapped as `SchemaError`. Defects,\n * interruptions, and other non-schema reasons remain in the returned `Cause`,\n * including when they are mixed with schema issues.\n *\n * @see {@link SchemaParser.encodeExit} for the adapter whose failure contains `SchemaIssue.Issue` directly\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encodeExit = encodeUnknownExit;\n/**\n * Encodes an `unknown` input against a schema, returning an `Option` that is\n * `Some` with the encoded value on success or `None` for schema mismatches.\n *\n * **When to use**\n *\n * Use when you do not know the input type statically and only need to know\n * whether encoding succeeded.\n *\n * **Details**\n *\n * Prefer this over {@link encodeUnknownExit} or {@link encodeUnknownEffect}\n * when you don't need error details. For values already typed as the schema's\n * `Type` use {@link encodeOption}.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are converted to `None`. Causes\n * that contain defects, interruptions, or other non-schema reasons throw\n * instead.\n *\n * @category encoding\n * @since 3.10.0\n */\nexport const encodeUnknownOption = SchemaParser.encodeUnknownOption;\n/**\n * Encodes a typed input (the schema's `Type`) against a schema, returning an\n * `Option` that is `Some` with the encoded value on success or `None` for schema\n * mismatches.\n *\n * **When to use**\n *\n * Use when you already have a value typed as the schema's `Type` and only need\n * to know whether encoding succeeded.\n *\n * **Details**\n *\n * For `unknown` input use {@link encodeUnknownOption}.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are converted to `None`. Causes\n * that contain defects, interruptions, or other non-schema reasons throw\n * instead.\n *\n * @category encoding\n * @since 3.10.0\n */\nexport const encodeOption = SchemaParser.encodeOption;\n/**\n * Encodes an `unknown` input against a schema, returning a `Result` that\n * succeeds with the encoded value or fails with a {@link SchemaError} for schema\n * mismatches.\n *\n * **When to use**\n *\n * Use when you do not know the input type statically and want schema mismatches\n * returned as `Result.fail` with `SchemaError`.\n *\n * **Details**\n *\n * For values already typed as the schema's `Type` use {@link encodeResult}.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n * Schema mismatches are returned as `Result.fail` with `SchemaError`.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are returned as `Result.fail`.\n * Causes that contain defects, interruptions, or other non-schema reasons throw\n * instead.\n *\n * @see {@link SchemaParser.encodeUnknownResult} for the adapter that fails with `SchemaIssue.Issue` directly\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeUnknownResult(schema, options) {\n const parser = SchemaParser.encodeUnknownResult(schema, options);\n return (input, options) => {\n return Result_.mapError(parser(input, options), issue => new SchemaError(issue));\n };\n}\n/**\n * Encodes a typed input (the schema's `Type`) against a schema, returning a\n * `Result` that succeeds with the encoded value or fails with a\n * {@link SchemaError} for schema mismatches.\n *\n * **When to use**\n *\n * Use when you already have a value typed as the schema's `Type` and want schema\n * mismatches returned as `Result.fail` with `SchemaError`.\n *\n * **Details**\n *\n * For `unknown` input use {@link encodeUnknownResult}.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n * Schema mismatches are returned as `Result.fail` with `SchemaError`.\n *\n * **Gotchas**\n *\n * Only causes made entirely of schema issues are returned as `Result.fail`.\n * Causes that contain defects, interruptions, or other non-schema reasons throw\n * instead.\n *\n * @see {@link SchemaParser.encodeResult} for the adapter that fails with `SchemaIssue.Issue` directly\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encodeResult = encodeUnknownResult;\n/**\n * Encodes an `unknown` input against a schema, returning a `Promise` that\n * resolves with the encoded value or rejects with a {@link SchemaError} for\n * schema mismatches.\n *\n * **When to use**\n *\n * Use when you need encoding of unknown input to return a JavaScript `Promise`\n * that rejects with `SchemaError` for schema mismatches.\n *\n * **Details**\n *\n * For values already typed as the schema's `Type` use {@link encodePromise}.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n *\n * **Gotchas**\n *\n * Non-schema failures may reject with a runtime failure instead of\n * `SchemaError`.\n *\n * @see {@link SchemaParser.encodeUnknownPromise} for the adapter that rejects with an `Error` whose cause is `SchemaIssue.Issue`\n *\n * @category encoding\n * @since 3.10.0\n */\nexport function encodeUnknownPromise(schema, options) {\n const parser = encodeUnknownEffect(schema, options);\n return (input, options) => {\n return runSchemaErrorPromise(parser(input, options));\n };\n}\n/**\n * Encodes a typed input (the schema's `Type`) against a schema, returning a\n * `Promise` that resolves with the encoded value or rejects with a\n * {@link SchemaError} for schema mismatches.\n *\n * **When to use**\n *\n * Use when you already have a value typed as the schema's `Type` and need\n * encoding to return a JavaScript `Promise` that rejects with `SchemaError` for\n * schema mismatches.\n *\n * **Details**\n *\n * For `unknown` input use {@link encodeUnknownPromise}.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n *\n * **Gotchas**\n *\n * Non-schema failures may reject with a runtime failure instead of\n * `SchemaError`.\n *\n * @see {@link SchemaParser.encodePromise} for the adapter that rejects with an `Error` whose cause is `SchemaIssue.Issue`\n *\n * @category encoding\n * @since 3.10.0\n */\nexport const encodePromise = encodeUnknownPromise;\n/**\n * Encodes an `unknown` input against a schema synchronously, throwing a\n * {@link SchemaError} for schema mismatches.\n *\n * **When to use**\n *\n * Use when you need to serialize unknown data at a synchronous boundary and\n * want schema mismatches to throw `SchemaError`.\n *\n * **Details**\n *\n * For alternatives that do not throw on schema mismatches, see\n * {@link encodeUnknownOption}, {@link encodeUnknownExit}, or\n * {@link encodeUnknownEffect}. For values already typed as the schema's `Type`\n * use {@link encodeSync}. Options may be provided either when creating the\n * encoder or when applying it; application options override creation options.\n *\n * **Gotchas**\n *\n * Non-schema failures may throw a runtime failure instead of `SchemaError`.\n *\n * @see {@link SchemaParser.encodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeUnknownSync(schema, options) {\n const parser = encodeUnknownEffect(schema, options);\n return (input, options) => {\n return runSchemaErrorSync(parser(input, options));\n };\n}\n/**\n * Encodes a typed input (the schema's `Type`) against a schema synchronously,\n * throwing a {@link SchemaError} for schema mismatches.\n *\n * **When to use**\n *\n * Use when you already have a value typed as the schema's `Type` and want\n * schema mismatches to throw `SchemaError` synchronously.\n *\n * **Details**\n *\n * For `unknown` input use {@link encodeUnknownSync}.\n * Options may be provided either when creating the encoder or when applying it;\n * application options override creation options.\n *\n * **Gotchas**\n *\n * Non-schema failures may throw a runtime failure instead of `SchemaError`.\n *\n * @see {@link SchemaParser.encodeSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encodeSync = encodeUnknownSync;\n/**\n * Creates a schema from an AST (Abstract Syntax Tree) node.\n *\n * **Details**\n *\n * This is the fundamental constructor for all schemas in the Effect Schema\n * library. It takes an AST node and wraps it in a fully-typed schema that\n * preserves all type information and provides the complete schema API.\n *\n * The `make` function is used internally to create all primitive schemas like\n * `String`, `Number`, `Boolean`, etc., as well as more complex schemas. It's\n * the bridge between the untyped AST representation and the strongly-typed\n * schema.\n *\n * @category constructors\n * @since 3.10.0\n */\nexport const make = InternalMake.make;\n/**\n * Checks whether a value is a `Schema`.\n *\n * @category guards\n * @since 3.10.0\n */\nexport function isSchema(u) {\n return Predicate.hasProperty(u, TypeId) && u[TypeId] === TypeId;\n}\n/**\n * Creates an exact optional key schema for struct fields. Unlike `optional`,\n * this creates exact optional properties (not `| undefined`) that can be\n * completely omitted from the object.\n *\n * **Example** (Creating a struct with optional key)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.Struct({\n * name: Schema.String,\n * age: Schema.optionalKey(Schema.Number)\n * })\n *\n * // Type: { readonly name: string; readonly age?: number }\n * type Person = typeof schema[\"Type\"]\n * ```\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const optionalKey = /*#__PURE__*/Struct_.lambda(schema => make(SchemaAST.optionalKey(schema.ast), {\n schema\n}));\n/**\n * Reverses `optionalKey` and returns the inner required schema.\n *\n * **When to use**\n *\n * Use to remove optional-key wrapping from a schema field that was previously\n * wrapped with {@link optionalKey}.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const requiredKey = /*#__PURE__*/Struct_.lambda(self => self.schema);\n/**\n * Marks a struct field as optional, allowing the key to be absent or\n * `undefined`.\n *\n * **Details**\n *\n * The resulting property may be absent or explicitly set to `undefined`.\n * Equivalent to `optionalKey(UndefinedOr(S))`.\n *\n * Use {@link optionalKey} instead if you want exact optional semantics (absent\n * only, not `undefined`).\n *\n * **Example** (Defining an optional field accepting undefined)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.Struct({\n * name: Schema.String,\n * age: Schema.optional(Schema.Number)\n * })\n *\n * // { readonly name: string; readonly age?: number | undefined }\n * type Person = typeof schema.Type\n * ```\n *\n * @category combinators\n * @since 3.10.0\n */\nexport const optional = /*#__PURE__*/Struct_.lambda(self => {\n const schema = UndefinedOr(self);\n return make(SchemaAST.optional(self.ast), {\n schema\n });\n});\n/**\n * Reverses `optional` and returns the inner schema.\n *\n * **When to use**\n *\n * Use to remove optional wrapping from a schema field that was previously\n * wrapped with {@link optional}.\n *\n * **Details**\n *\n * This also unwraps the `UndefinedOr` member added by `optional`.\n *\n * @category combinators\n * @since 3.10.0\n */\nexport const required = /*#__PURE__*/Struct_.lambda(self => self.schema.members[0]);\n/**\n * Makes a struct field mutable (removes the `readonly` modifier on the property).\n * Use {@link readonlyKey} to reverse.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const mutableKey = /*#__PURE__*/Struct_.lambda(schema => make(SchemaAST.mutableKey(schema.ast), {\n schema\n}));\n/**\n * Reverses `mutableKey` and returns the inner readonly schema.\n *\n * **When to use**\n *\n * Use to remove mutable-key wrapping from a schema field that was previously\n * wrapped with {@link mutableKey}.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const readonlyKey = /*#__PURE__*/Struct_.lambda(self => self.schema);\n/**\n * Extracts the type-side schema: sets `Encoded` to equal the decoded `Type`,\n * discarding the encoding transformation path.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const toType = /*#__PURE__*/Struct_.lambda(schema => make(SchemaAST.toType(schema.ast), {\n schema\n}));\n/**\n * Extracts the encoded-side schema: sets `Type` to equal the `Encoded`,\n * discarding the decoding transformation path.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const toEncoded = /*#__PURE__*/Struct_.lambda(schema => make(SchemaAST.toEncoded(schema.ast), {\n schema\n}));\nconst FlipTypeId = \"~effect/Schema/flip\";\nfunction isFlip$(schema) {\n return Predicate.hasProperty(schema, FlipTypeId) && schema[FlipTypeId] === FlipTypeId;\n}\nexport function flip(schema) {\n if (isFlip$(schema)) {\n return schema.schema.rebuild(SchemaAST.flip(schema.ast));\n }\n return make(SchemaAST.flip(schema.ast), {\n [FlipTypeId]: FlipTypeId,\n schema\n });\n}\n/**\n * Creates a schema for a single literal value (string, number, bigint, boolean, or null).\n *\n * **Example** (Defining a string literal)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.Literal(\"hello\")\n * // Type: Schema.Literal<\"hello\">\n * Schema.decodeSync(schema)(\"hello\") // => \"hello\"\n * ```\n *\n * @see {@link Literals} for a schema that represents a union of literals.\n * @see {@link tag} for a schema that represents a literal value that can be\n * used as a discriminator field in tagged unions and has a constructor default.\n * @category constructors\n * @since 3.10.0\n */\nexport function Literal(literal) {\n const out = make(new SchemaAST.Literal(literal), {\n literal,\n transform(to) {\n return out.pipe(decodeTo(Literal(to), {\n decode: SchemaGetter.transform(() => to),\n encode: SchemaGetter.transform(() => literal)\n }));\n }\n });\n return out;\n}\nfunction templateLiteralParts(parts) {\n return parts.map(part => isSchema(part) ? part.ast : new SchemaAST.Literal(part));\n}\n/**\n * Creates a schema that validates strings by matching ordered template literal\n * parts.\n *\n * **When to use**\n *\n * Use when the decoded value should remain the matched string and you do not\n * need the individual template parts parsed into a tuple.\n *\n * **Details**\n *\n * Each part can be a literal `string`, `number`, or `bigint`, or a schema whose\n * encoded type is `string`, `number`, or `bigint`. Checks on string, number,\n * and bigint schema parts are applied while matching each segment.\n *\n * **Gotchas**\n *\n * Parts must not contain encodings, including inside unions or nested templates.\n * Construction throws for transformed parts even when their decoded and encoded\n * types are the same. Use {@link TemplateLiteralParser} to decode transformed parts.\n * Brands and supported checks without encodings remain valid.\n *\n * **Example** (Defining a URL path pattern)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.TemplateLiteral([\"/user/\", Schema.Number])\n * Schema.is(schema)(\"/user/123\") // => true\n * ```\n *\n * @see {@link TemplateLiteralParser} for a schema that also parses matched parts into a tuple.\n * @category constructors\n * @since 3.10.0\n */\nexport function TemplateLiteral(parts) {\n return make(new SchemaAST.TemplateLiteral(templateLiteralParts(parts)), {\n parts\n });\n}\n/**\n * Schema for parsing matched template literal strings into typed tuple parts.\n *\n * **When to use**\n *\n * Use to validate a template literal string and decode the matched parts into\n * typed values.\n *\n * **Details**\n *\n * Unlike {@link TemplateLiteral}, this schema decodes the matched string into a\n * readonly tuple with one element per schema part. Checks on string, number,\n * and bigint schema parts are applied while matching each segment.\n * The source template uses the encoded sides of the parts; the tuple retains\n * their transformations, checks, and decoding and encoding service requirements.\n *\n * **Gotchas**\n *\n * Ambiguous templates use greedy segmentation with backtracking. Encoding a\n * tuple and decoding the resulting string can therefore produce a different\n * tuple when a segment contains a separator used by the template.\n *\n * **Example** (Parsing path parameters)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.TemplateLiteralParser([\"/user/\", Schema.NumberFromString])\n * Schema.decodeSync(schema)(\"/user/42\") // => [\"/user/\", 42]\n * ```\n *\n * @see {@link TemplateLiteral} for a validation-only version that keeps the string encoded.\n * @category constructors\n * @since 3.10.0\n */\nexport function TemplateLiteralParser(parts) {\n return make(SchemaAST.templateLiteralParser(templateLiteralParts(parts)), {\n parts\n });\n}\n/**\n * Creates a schema from a TypeScript enum object. Validates that the input is one of the enum's values.\n * Numeric enum values must be finite.\n *\n * **Gotchas**\n *\n * Throws when a numeric member is `NaN`, `Infinity`, or `-Infinity`.\n *\n * **Example** (Defining a direction enum)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * enum Direction {\n * Up = \"Up\",\n * Down = \"Down\"\n * }\n *\n * const schema = Schema.Enum(Direction)\n * Schema.decodeSync(schema)(Direction.Up) // => \"Up\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function Enum(enums) {\n return make(new SchemaAST.Enum(Object.keys(enums).filter(key => typeof enums[enums[key]] !== \"number\").map(key => [key, enums[key]])), {\n enums\n });\n}\n/**\n * Schema for the `never` type. Always fails validation — no value satisfies it.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const Never = /*#__PURE__*/make(SchemaAST.never);\n/**\n * Schema for the `any` type. Accepts any value without validation.\n *\n * @see {@link Unknown} for a safer alternative that uses `unknown`.\n * @category schemas\n * @since 3.10.0\n */\nexport const Any = /*#__PURE__*/make(SchemaAST.any);\n/**\n * Schema for the `unknown` type. Accepts any value without validation.\n *\n * **When to use**\n *\n * Use as a top schema when you need to accept any input while preserving\n * TypeScript's `unknown` safety at use sites.\n *\n * @see {@link Any} for the `any` variant.\n * @category schemas\n * @since 3.10.0\n */\nexport const Unknown = /*#__PURE__*/make(SchemaAST.unknown);\n/**\n * Schema for the `null` literal. Validates that the input is strictly `null`.\n *\n * @see {@link NullOr} for a union with another schema.\n * @category schemas\n * @since 3.10.0\n */\nexport const Null = /*#__PURE__*/make(SchemaAST.null);\n/**\n * Schema for the `undefined` literal. Validates that the input is strictly `undefined`.\n *\n * @see {@link UndefinedOr} for a union with another schema.\n * @category schemas\n * @since 3.10.0\n */\nexport const Undefined = /*#__PURE__*/make(SchemaAST.undefined);\n/**\n * Schema for `string` values. Validates that the input is `typeof` `\"string\"`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const String = /*#__PURE__*/make(SchemaAST.string);\n/**\n * Schema for `number` values, including `NaN`, `Infinity`, and `-Infinity`.\n *\n * **Details**\n *\n * Default JSON serializer:\n *\n * - Finite numbers are serialized as numbers.\n * - Non-finite values are serialized as strings (`\"NaN\"`, `\"Infinity\"`, `\"-Infinity\"`).\n *\n * @see {@link Finite} for a schema that excludes non-finite values.\n * @category schemas\n * @since 4.0.0\n */\nexport const Number = /*#__PURE__*/make(SchemaAST.number);\n/**\n * Schema for `boolean` values. Validates that the input is `typeof` `\"boolean\"`.\n *\n * **When to use**\n *\n * Use to validate values that are already JavaScript booleans.\n *\n * @see {@link BooleanFromBit} for a schema that decodes bit literals `0` or `1` into a boolean\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const Boolean = /*#__PURE__*/make(SchemaAST.boolean);\n/**\n * Schema for `symbol` values. Validates that the input is `typeof` `\"symbol\"`.\n *\n * @see {@link UniqueSymbol} for a schema that matches a specific symbol.\n * @category schemas\n * @since 4.0.0\n */\nexport const Symbol = /*#__PURE__*/make(SchemaAST.symbol);\n/**\n * Schema for `bigint` values. Validates that the input is `typeof` `\"bigint\"`.\n *\n * **When to use**\n *\n * Use when the input is already a bigint and the schema should validate and\n * preserve bigint values without parsing from another representation.\n *\n * @see {@link BigIntFromString} for parsing string input into a bigint\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const BigInt = /*#__PURE__*/make(SchemaAST.bigInt);\n/**\n * Schema for a TypeScript `void` return value.\n *\n * **When to use**\n *\n * Use when you need to model the return value of a function, RPC, or endpoint\n * whose result is intentionally ignored.\n *\n * **Details**\n *\n * Runtime parsing accepts any present value and discards it, producing\n * `undefined`. The public decoded and encoded TypeScript representation remains\n * `void`, so typed construction, decoding, and encoding APIs are still modeled\n * as `void`.\n *\n * @see {@link Undefined} for a schema that matches only the exact `undefined` value.\n * @category schemas\n * @since 3.10.0\n */\nexport const Void = /*#__PURE__*/make(SchemaAST.void);\n/**\n * Schema for the `object` type. Validates that the input is a non-null object or function\n * (i.e. `typeof value === \"object\" && value !== null || typeof value === \"function\"`).\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const ObjectKeyword = /*#__PURE__*/make(SchemaAST.objectKeyword);\n/**\n * Creates a schema for a specific symbol. Only that exact symbol satisfies the schema.\n *\n * **Gotchas**\n *\n * Only globally registered symbols have a JSON encoding. Their canonical JSON\n * form is the exact string returned by `String(symbol)`. A local symbol cannot\n * be encoded as JSON.\n *\n * **Example** (Defining a specific symbol)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const mySymbol = Symbol.for(\"mySymbol\")\n * const schema = Schema.UniqueSymbol(mySymbol)\n * Schema.decodeSync(schema)(mySymbol) === mySymbol // => true\n * ```\n *\n * @see {@link Symbol} for a schema that accepts any symbol.\n * @category constructors\n * @since 4.0.0\n */\nexport function UniqueSymbol(symbol) {\n return make(new SchemaAST.UniqueSymbol(symbol));\n}\nfunction makeStruct(ast, fields) {\n return make(ast, {\n fields,\n mapFields(f, options) {\n const fields = f(this.fields);\n return makeStruct(SchemaAST.struct(fields, options?.unsafePreserveChecks ? this.ast.checks : undefined), fields);\n }\n });\n}\n/**\n * Defines a struct schema from a map of field schemas.\n *\n * **Details**\n *\n * Each field value is a schema. Use {@link optionalKey} or {@link optional} to\n * mark fields as optional, and {@link mutableKey} to mark them as mutable.\n *\n * The resulting schema's `Type` is a readonly object type with the fields'\n * decoded types. The `Encoded` form mirrors the field schemas' encoded types.\n * Declared fields may be inherited and are copied to own properties in the\n * output. The `__proto__` field is accepted only when it is an own property.\n * Parsing does not guarantee that output keys retain their input order.\n *\n * **Example** (Defining a basic struct)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const Person = Schema.Struct({\n * name: Schema.String,\n * age: Schema.Number,\n * email: Schema.optionalKey(Schema.String)\n * })\n *\n * // { readonly name: string; readonly age: number; readonly email?: string }\n * type Person = typeof Person.Type\n *\n * Schema.decodeUnknownSync(Person)({ name: \"Alice\", age: 30 }) // => { name: \"Alice\", age: 30 }\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport function Struct(fields) {\n return makeStruct(SchemaAST.struct(fields, undefined), fields);\n}\n/**\n * Adds fields to a struct schema through a struct-mapping lambda.\n *\n * **When to use**\n *\n * Use to add the same fields to an existing struct or every struct member of a\n * union.\n *\n * **Details**\n *\n * This is a shortcut for `MyStruct.mapFields(Struct.assign(fields))`.\n *\n * **Example** (Adding fields to a union of structs)\n *\n * ```ts import.meta.vitest\n * import { Schema, Tuple } from \"effect\"\n *\n * // Add a new field to all members of a union of structs\n * const schema = Schema.Union([\n * Schema.Struct({ a: Schema.String }),\n * Schema.Struct({ b: Schema.Number })\n * ]).mapMembers(Tuple.map(Schema.fieldsAssign({ c: Schema.Number })))\n * Schema.decodeSync(schema)({ a: \"a\", c: 1 }) // => { a: \"a\", c: 1 }\n * ```\n *\n * @category combinators\n * @since 4.0.0\n */\nexport function fieldsAssign(fields) {\n return Struct_.lambda(struct => struct.mapFields(Struct_.assign(fields)));\n}\nconst canonicalPropertyKey = key => typeof key === \"symbol\" ? key : globalThis.String(key);\n/**\n * Renames struct keys in the encoded form without changing the decoded type.\n *\n * **Details**\n *\n * Takes a partial mapping `{ decodedKey: encodedKey }` and produces a\n * transformation schema that decodes from the renamed keys and encodes back to\n * the renamed keys. Keys not present in the mapping are left unchanged.\n * If two existing fields would produce the same encoded key, construction\n * fails.\n *\n * **Example** (Renaming `name` to `full_name` in the encoded form)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })\n * const Encoded = Person.pipe(Schema.encodeKeys({ name: \"full_name\" }))\n *\n * // Decodes { full_name: \"Alice\", age: 30 } → { name: \"Alice\", age: 30 }\n * Schema.decodeUnknownSync(Encoded)({ full_name: \"Alice\", age: 30 }) // => { name: \"Alice\", age: 30 }\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function encodeKeys(mapping) {\n return function (self) {\n const fields = {};\n const appliedMapping = Object.create(null);\n const reverseMapping = Object.create(null);\n const seenEncodedKeys = new Set();\n for (const k of Reflect.ownKeys(self.fields)) {\n const encoded = toEncoded(self.fields[k]);\n const hasMapping = Object.hasOwn(mapping, k);\n const encodedKey = hasMapping ? mapping[k] : k;\n const canonical = canonicalPropertyKey(encodedKey);\n if (seenEncodedKeys.has(canonical)) {\n throw new globalThis.Error(`Duplicate encoded keys: ${formatPropertyKey(encodedKey)}`);\n }\n seenEncodedKeys.add(canonical);\n InternalRecord.assignProperty(fields, encodedKey, encoded);\n if (hasMapping) {\n appliedMapping[k] = encodedKey;\n reverseMapping[encodedKey] = k;\n }\n }\n return Struct(fields).pipe(decodeTo(self, SchemaTransformation.transform({\n decode: Struct_.renameKeys(reverseMapping),\n encode: Struct_.renameKeys(appliedMapping)\n })));\n };\n}\n/**\n * Adds derived fields to a struct schema during decoding.\n *\n * **Details**\n *\n * Each new field is derived from the decoded struct value via a function that\n * returns `Option`. On encoding the derived fields are stripped. This allows\n * computed or enriched fields to live in the decoded type without appearing in\n * the encoded form.\n *\n * **Example** (Adding a computed `fullName` field)\n *\n * ```ts import.meta.vitest\n * import { Option, Schema } from \"effect\"\n *\n * const Person = Schema.Struct({ first: Schema.String, last: Schema.String })\n * const Extended = Person.pipe(\n * Schema.extendTo(\n * { fullName: Schema.String },\n * { fullName: (p) => Option.some(`${p.first} ${p.last}`) }\n * )\n * )\n *\n * const alice = Schema.decodeUnknownSync(Extended)({ first: \"Alice\", last: \"Smith\" })\n * alice.fullName // => \"Alice Smith\"\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function extendTo(fields, derive) {\n return self => {\n const f = Record_.map(self.fields, toType);\n const to = Struct({\n ...f,\n ...fields\n });\n return self.pipe(decodeTo(to, SchemaTransformation.transform({\n decode: input => {\n const out = {\n ...input\n };\n for (const k in fields) {\n const f = derive[k];\n const o = f(input);\n if (Option_.isSome(o)) {\n InternalRecord.assignProperty(out, k, o.value);\n }\n }\n return out;\n },\n encode: input => {\n const out = {\n ...input\n };\n for (const k in fields) {\n delete out[k];\n }\n return out;\n }\n })));\n };\n}\n/**\n * Defines a record schema whose dynamic properties are selected by a key schema\n * and decoded with a value schema.\n *\n * **Details**\n *\n * For dynamic keys, the key schema selects matching own properties and the\n * value schema decodes or encodes only those selected properties. Checks on\n * string, number, symbol, and template literal key schemas narrow which\n * properties are selected.\n *\n * For transformed key schemas, property selection is based on encoded property\n * names before the selected key is decoded.\n *\n * **Gotchas**\n *\n * When decoded or encoded key transformations produce the same property key,\n * sequential parsing applies selected own properties in selection order, so\n * the later selected property overwrites the earlier value. Dynamic key\n * selection always examines own properties. Finite literal keys are declared\n * fields and may therefore be inherited. Output key order is not guaranteed.\n *\n * **Example** (Defining a string-keyed record of numbers)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.Record(Schema.String, Schema.Number)\n *\n * // { readonly [x: string]: number }\n * type R = typeof schema.Type\n *\n * Schema.decodeUnknownSync(schema)({ a: 1, b: 2 }) // => { a: 1, b: 2 }\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport function Record(key, value) {\n return make(SchemaAST.record(key.ast, value.ast), {\n key,\n value\n });\n}\n/**\n * Extends a struct schema with one or more record (index-signature) schemas,\n * producing a schema whose decoded type intersects the struct and all records.\n *\n * **Gotchas**\n *\n * TypeScript index signatures also apply to fixed keys. `StructWithRest` does\n * not reject incompatible fixed fields at the call site; use\n * `StructWithRest.ValidateRecords` when you want an explicit type-level\n * compatibility check.\n *\n * **Example** (Defining structs with string-indexed extra keys)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.StructWithRest(\n * Schema.Struct({ id: Schema.Number }),\n * [Schema.Record(Schema.String, Schema.Number)]\n * )\n *\n * // { readonly id: number, readonly [x: string]: number }\n * type T = typeof schema.Type\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function StructWithRest(schema, records) {\n return make(SchemaAST.structWithRest(schema.ast, records.map(SchemaAST.getAST)), {\n schema,\n records\n });\n}\nfunction makeTuple(ast, elements) {\n return make(ast, {\n elements,\n mapElements(f, options) {\n const elements = f(this.elements);\n return makeTuple(SchemaAST.tuple(elements, options?.unsafePreserveChecks ? this.ast.checks : undefined), elements);\n }\n });\n}\n/**\n * Defines a fixed-length tuple schema from an array of element schemas.\n *\n * **Example** (Defining a pair of string and number)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.Tuple([Schema.String, Schema.Number])\n *\n * Schema.decodeUnknownSync(schema)([\"hello\", 42]) // => [\"hello\", 42]\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport function Tuple(elements) {\n return makeTuple(SchemaAST.tuple(elements), elements);\n}\n/**\n * Extends a fixed-length tuple schema with a variadic rest segment.\n *\n * **Details**\n *\n * The resulting tuple starts with the fixed elements from `schema`. The first\n * schema in `rest` is the repeatable element schema, and any additional schemas\n * in `rest` are required trailing tuple elements after the variadic segment. For\n * example, `[Schema.Boolean, Schema.String]` represents zero or more booleans\n * followed by a final string.\n *\n * **Example** (Defining tuples with rest elements)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * // [string, number, ...boolean[]]\n * const schema = Schema.TupleWithRest(\n * Schema.Tuple([Schema.String, Schema.Number]),\n * [Schema.Boolean]\n * )\n *\n * Schema.decodeUnknownSync(schema)([\"hello\", 1, true, false]) // => [\"hello\", 1, true, false]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function TupleWithRest(schema, rest) {\n return make(SchemaAST.tupleWithRest(schema.ast, rest.map(SchemaAST.getAST)), {\n schema,\n rest\n });\n}\n/**\n * @category constructors\n * @since 4.0.0\n */\nconst ArraySchema = /*#__PURE__*/Struct_.lambda(schema => make(new SchemaAST.Arrays(false, [], [schema.ast]), {\n value: schema\n}));\nexport {\n/**\n * Defines a `ReadonlyArray` schema for a given element schema.\n *\n * **Example** (Defining an array of strings)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.Array(Schema.String)\n *\n * Schema.decodeUnknownSync(schema)([\"a\", \"b\", \"c\"]) // => [\"a\", \"b\", \"c\"]\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nArraySchema as Array };\n/** @internal */\nexport function withArrayLengthConstraints(self, minimum, maximum) {\n if (minimum !== undefined && maximum !== undefined) {\n return self.check(isLengthBetween(minimum, maximum));\n }\n if (minimum !== undefined) return self.check(isMinLength(minimum));\n if (maximum !== undefined) return self.check(isMaxLength(maximum));\n return self;\n}\n/**\n * Defines a non-empty `ReadonlyArray` schema — at least one element required.\n * Type is `readonly [T, ...T[]]`.\n *\n * **Example** (Defining a non-empty array of numbers)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.NonEmptyArray(Schema.Number)\n *\n * Schema.decodeUnknownSync(schema)([1, 2, 3]) // => [1, 2, 3]\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport const NonEmptyArray = /*#__PURE__*/Struct_.lambda(schema => make(new SchemaAST.Arrays(false, [schema.ast], [schema.ast]), {\n value: schema\n}));\n/**\n * Creates a schema that accepts either a value decoded by `schema` or an array\n * decoded by `Schema.Array(schema)`, then returns an array.\n *\n * **When to use**\n *\n * Use to accept input that may be provided either as one item or as an array,\n * while normalizing decoded values to a readonly array.\n *\n * **Details**\n *\n * During encoding, one-element arrays are encoded as the single element. Empty\n * arrays and arrays with two or more elements are encoded as arrays.\n *\n * **Gotchas**\n *\n * The single-value branch is tried before the array branch. If `schema` itself\n * accepts arrays, an array input can be treated as one value and wrapped in a\n * one-element array.\n *\n * @see {@link Array} for accepting only array input\n * @see {@link NonEmptyArray} for requiring at least one decoded element\n *\n * @category constructors\n * @since 3.10.0\n */\nexport function ArrayEnsure(schema) {\n const many = ArraySchema(schema);\n const to = ArraySchema(toType(schema));\n const one = decodeTo(Tuple([Unknown]), SchemaTransformation.transform({\n decode: value => [value],\n encode: ([value]) => value\n }))(schema);\n return make(Union([one, many]).pipe(decodeTo(to)).ast, {\n from: Union([schema, many]),\n to\n });\n}\n/**\n * Returns a new array schema that ensures all elements are unique.\n *\n * **Details**\n *\n * The equivalence used to determine uniqueness is the one provided by\n * `Schema.toEquivalence(item)`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function UniqueArray(item) {\n return ArraySchema(item).check(isUnique());\n}\n/**\n * Makes an array or tuple schema mutable, removing the `readonly` modifier.\n *\n * **Gotchas**\n *\n * This combinator does not support an encoding attached to the array or tuple\n * node and throws if one is present. Encodings on element schemas are\n * supported.\n *\n * **Example** (Defining mutable arrays)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.mutable(Schema.Array(Schema.Number))\n *\n * // number[] (mutable)\n * type T = typeof schema.Type\n * const value: T = [1, 2]\n * value.push(3)\n * value // => [1, 2, 3]\n * ```\n *\n * @category transforming\n * @since 3.10.0\n */\nexport const mutable = /*#__PURE__*/Struct_.lambda(schema => make(SchemaAST.mutable(schema.ast), {\n schema\n}));\nfunction makeUnion(ast, members) {\n return make(ast, {\n members,\n mapMembers(f, options) {\n const members = f(this.members);\n return makeUnion(SchemaAST.union(members, this.ast.options, options?.unsafePreserveChecks ? this.ast.checks : undefined), members);\n }\n });\n}\n/**\n * Creates a union schema from an array of member schemas. Members are tested in\n * order; the first match is returned.\n *\n * **Details**\n *\n * Optionally, specify `mode`:\n * - `\"anyOf\"` (default) — matches if any member matches.\n * - `\"oneOf\"` — matches if exactly one member matches.\n *\n * **Example** (Defining a string or number union)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.Union([Schema.String, Schema.Number])\n *\n * Schema.decodeUnknownSync(schema)(\"hello\") // => \"hello\"\n * Schema.decodeUnknownSync(schema)(42) // => 42\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport function Union(members, options) {\n return makeUnion(SchemaAST.union(members, options, undefined), members);\n}\n/**\n * Creates a union schema from an array of literal values.\n *\n * **Example** (Defining status codes)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.Literals([\"active\", \"inactive\", \"pending\"])\n * Schema.decodeSync(schema)(\"active\") // => \"active\"\n * ```\n *\n * @see {@link Literal} for a schema that represents a single literal.\n * @category constructors\n * @since 4.0.0\n */\nexport function Literals(literals) {\n const members = literals.map(Literal);\n return make(SchemaAST.union(members, undefined, undefined), {\n literals,\n members,\n mapMembers(f) {\n return Union(f(this.members));\n },\n pick(literals) {\n return Literals(literals);\n },\n transform(to) {\n return Union(members.map((member, index) => member.transform(to[index])));\n }\n });\n}\n/**\n * Creates a union schema of `S | null`.\n *\n * @category constructors\n * @since 3.10.0\n */\nexport const NullOr = /*#__PURE__*/Struct_.lambda(self => Union([self, Null]));\n/**\n * Creates a union schema of `S | undefined`.\n *\n * @category constructors\n * @since 3.10.0\n */\nexport const UndefinedOr = /*#__PURE__*/Struct_.lambda(self => Union([self, Undefined]));\n/**\n * Creates a union schema of `S | null | undefined`.\n *\n * @category constructors\n * @since 3.10.0\n */\nexport const NullishOr = /*#__PURE__*/Struct_.lambda(self => Union([self, Null, Undefined]));\n/**\n * Creates a suspended schema that defers evaluation until needed. This is\n * essential for creating recursive schemas where a schema references itself,\n * preventing infinite recursion during schema definition.\n *\n * **Example** (Defining recursive tree schemas)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * interface Tree {\n * readonly value: number\n * readonly children: ReadonlyArray\n * }\n *\n * const Tree = Schema.Struct({\n * value: Schema.Number,\n * children: Schema.Array(Schema.suspend((): Schema.Codec => Tree))\n * })\n * Schema.decodeSync(Tree)({ value: 1, children: [] }) // => { value: 1, children: [] }\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport function suspend(f) {\n return make(new SchemaAST.Suspend(() => f().ast));\n}\n/**\n * Attaches one or more filter checks to a schema without changing the\n * TypeScript type.\n *\n * **Example** (Adding checks to a schema)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const AgeSchema = Schema.Finite.pipe(\n * Schema.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(120))\n * )\n * Schema.is(AgeSchema)(42) // => true\n * Schema.is(AgeSchema)(121) // => false\n * ```\n *\n * @category filtering\n * @since 4.0.0\n */\nexport function check(...checks) {\n return self => self.check(...checks);\n}\n/**\n * Narrows the TypeScript type of a schema's output via a type guard predicate,\n * attaching the guard as a runtime filter check.\n *\n * **Details**\n *\n * The `annotations` parameter annotates the filter created by the refinement.\n * With the default formatter, failed refinements use `message` first,\n * `expected` second, and `` when neither is provided. `identifier`\n * names type-level failures before the refinement runs; it does not name the\n * failed refinement itself.\n *\n * @category filtering\n * @since 3.10.0\n */\nexport function refine(refinement, annotations) {\n return schema => make(SchemaAST.appendChecks(schema.ast, [SchemaAST.makeFilterByGuard(refinement, annotations)]), {\n schema\n });\n}\n/**\n * Adds a nominal brand to a schema, intersecting the output type with\n * `Brand.Brand` to prevent accidental mixing of structurally identical types.\n *\n * **When to use**\n *\n * Use to make values decoded by an existing schema nominally distinct when the\n * schema already carries the runtime validation you need.\n *\n * **Gotchas**\n *\n * `brand` adds brand metadata and narrows the TypeScript output type, but it\n * does not add runtime checks.\n *\n * @see {@link fromBrand} for applying a Brand constructor's checks along with the brand tag\n *\n * @category branding\n * @since 3.10.0\n */\nexport function brand(identifier) {\n return schema => make(SchemaAST.brand(schema.ast, identifier), {\n schema,\n identifier\n });\n}\n/**\n * Creates a branded schema from a {@link Brand.Constructor}, applying the\n * constructor's checks and brand tag to the underlying schema.\n *\n * @category branding\n * @since 3.10.0\n */\nexport function fromBrand(identifier, ctor) {\n return self => {\n return (ctor.checks ? self.check(...ctor.checks) : self).pipe(brand(identifier));\n };\n}\n/**\n * Intercepts the decoding pipeline of a schema.\n *\n * **Details**\n *\n * The provided function receives the current decoding `Effect` and `ParseOptions`,\n * and returns a new `Effect` — potentially adding service requirements (`RD`),\n * recovering from errors, or augmenting the result.\n *\n * **Example** (Logging decode failures)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schema } from \"effect\"\n *\n * const events: Array = []\n * const Logged = Schema.String.pipe(\n * Schema.middlewareDecoding((effect) =>\n * Effect.tapError(effect, () => Effect.sync(() => events.push(\"decode failed\")))\n * )\n * )\n * Effect.runSync(Effect.result(Schema.decodeUnknownEffect(Logged)(42)))\n * events // => [\"decode failed\"]\n * ```\n *\n * @see {@link catchDecoding} for a simpler error-recovery variant\n * @category decoding\n * @since 4.0.0\n */\nexport function middlewareDecoding(decode) {\n return schema => make(SchemaAST.middlewareDecoding(schema.ast, new SchemaTransformation.Middleware(decode, identity)), {\n schema\n });\n}\n/**\n * Intercepts the encoding pipeline of a schema.\n *\n * **Details**\n *\n * The provided function receives the current encoding `Effect` and `ParseOptions`,\n * and returns a new `Effect` — potentially adding service requirements (`RE`),\n * recovering from errors, or augmenting the result.\n *\n * **Example** (Logging encode failures)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schema } from \"effect\"\n *\n * const events: Array = []\n * const Logged = Schema.String.pipe(\n * Schema.middlewareEncoding((effect) =>\n * Effect.tapError(effect, () => Effect.sync(() => events.push(\"encode failed\")))\n * )\n * )\n * Effect.runSync(Effect.result(Schema.encodeUnknownEffect(Logged)(42)))\n * events // => [\"encode failed\"]\n * ```\n *\n * @see {@link catchEncoding} for a simpler error-recovery variant\n * @category encoding\n * @since 4.0.0\n */\nexport function middlewareEncoding(encode) {\n return schema => make(SchemaAST.middlewareEncoding(schema.ast, new SchemaTransformation.Middleware(identity, encode)), {\n schema\n });\n}\n/**\n * Recovers from a decoding error by providing a fallback value.\n *\n * **Details**\n *\n * The handler receives the `Issue` and returns an `Effect` that either\n * succeeds with a fallback value or re-fails with a (possibly different) issue.\n *\n * **Example** (Returning a default on decode failure)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Schema } from \"effect\"\n *\n * const schema = Schema.Number.pipe(\n * Schema.catchDecoding((_issue) => Effect.succeed(Option.some(0)))\n * )\n * Effect.runSync(Schema.decodeUnknownEffect(schema)(\"invalid\")) // => 0\n * ```\n *\n * @see {@link catchDecodingWithContext} to add service requirements to the handler\n * @category error handling\n * @since 4.0.0\n */\nexport function catchDecoding(f) {\n return catchDecodingWithContext(f);\n}\n/**\n * Recovers from a decoding error with a handler that may require Effect services.\n *\n * **When to use**\n *\n * Use when you need decoding fallback logic to require services from the Effect\n * context.\n *\n * **Details**\n *\n * The handler receives the `Issue` and returns an `Effect` that either succeeds\n * with a fallback value or re-fails with a (possibly different) issue. The\n * handler's services are added to the schema's decoding services.\n *\n * @see {@link catchDecoding} for recovery handlers that do not require services\n * @see {@link middlewareDecoding} for intercepting or replacing the full decoding pipeline\n *\n * @category error handling\n * @since 4.0.0\n */\nexport function catchDecodingWithContext(f) {\n return self => middlewareDecoding(Effect.catchEager(f))(self);\n}\n/**\n * Recovers from an encoding error by providing a fallback value.\n *\n * **Details**\n *\n * The handler receives the `Issue` and returns an `Effect` that either\n * succeeds with a fallback value or re-fails with a (possibly different) issue.\n *\n * @see {@link catchEncodingWithContext} to add service requirements to the handler\n * @category error handling\n * @since 4.0.0\n */\nexport function catchEncoding(f) {\n return catchEncodingWithContext(f);\n}\n/**\n * Recovers from an encoding error with a handler that may require Effect services.\n *\n * **When to use**\n *\n * Use when you need encoding fallback logic to require services from the Effect\n * context.\n *\n * **Details**\n *\n * The handler receives the `Issue` and returns an `Effect` that either succeeds\n * with a fallback encoded value or re-fails with a (possibly different) issue.\n * The handler's services are added to the schema's encoding services.\n *\n * @see {@link catchEncoding} for recovery handlers that do not require services\n * @see {@link middlewareEncoding} for intercepting or replacing the full encoding pipeline\n *\n * @category error handling\n * @since 4.0.0\n */\nexport function catchEncodingWithContext(f) {\n return self => middlewareEncoding(Effect.catchEager(f))(self);\n}\nexport function decodeTo(to, transformation) {\n return from => {\n return make(SchemaAST.decodeTo(from.ast, to.ast, transformation ? SchemaTransformation.make(transformation) : SchemaTransformation.passthrough()), {\n from,\n to\n });\n };\n}\n/**\n * Constructs a decode-only `SchemaAST.Link`.\n *\n * @internal\n */\nexport function linkDecoding() {\n return (to, decode) => link()(to, {\n decode,\n encode: SchemaGetter.forbiddenEncoding\n });\n}\n/** @internal */\nexport const TrueLiterals = /*#__PURE__*/Literals([\"true\", \"yes\", \"on\", \"1\", \"y\"]);\n/** @internal */\nexport const FalseLiterals = /*#__PURE__*/Literals([\"false\", \"no\", \"off\", \"0\", \"n\"]);\n/** @internal */\nexport const BooleanLiterals = /*#__PURE__*/Literals([...TrueLiterals.literals, ...FalseLiterals.literals]).pipe(/*#__PURE__*/decodeTo(Boolean, /*#__PURE__*/SchemaTransformation.transform({\n decode: value => value === \"true\" || value === \"yes\" || value === \"on\" || value === \"1\" || value === \"y\",\n encode: value => value ? \"true\" : \"false\"\n})));\n/**\n * Applies a transformation to a schema, creating a new schema with the same type but transformed encoding/decoding.\n *\n * **When to use**\n *\n * Use when the decoded type stays the same and the transformation only\n * normalizes values during encoding and decoding.\n *\n * **Details**\n *\n * Call it with a transformation object and then pipe a schema into the returned\n * function. The resulting schema keeps the same `Type` and `Encoded` types as\n * the source schema, while applying the transformation during both decoding and\n * encoding.\n *\n * Internally this uses `toType(self)` as the target schema and combines service\n * requirements from the source schema and the transformation.\n *\n * **Gotchas**\n *\n * Use {@link decodeTo} instead when the transformation should change the\n * decoded type. For this helper, both transformation getters operate on\n * `S[\"Type\"]` values.\n *\n * **Example** (Trimming string values during encoding/decoding)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaGetter } from \"effect\"\n *\n * const Trimmed = Schema.String.pipe(\n * Schema.decode({\n * decode: SchemaGetter.transform((s) => s.trim()),\n * encode: SchemaGetter.transform((s) => s.trim())\n * })\n * )\n *\n * Schema.decodeUnknownSync(Trimmed)(\" hello \") // => \"hello\"\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function decode(transformation) {\n return self => {\n return decodeTo(toType(self), transformation)(self);\n };\n}\nexport function encodeTo(to, transformation) {\n return from => {\n return transformation ? decodeTo(from, transformation)(to) : decodeTo(from)(to);\n };\n}\n/**\n * Applies a transformation to a schema's encoded type, creating a new schema where encoding/decoding\n * operate on `S[\"Encoded\"]` rather than `S[\"Type\"]`.\n *\n * **Details**\n *\n * The `decode` getter maps `S[\"Encoded\"]` → `S[\"Encoded\"]` (applied during decoding),\n * and the `encode` getter maps `S[\"Encoded\"]` → `S[\"Encoded\"]` (applied during encoding).\n *\n * **Example** (Upper-casing encoded strings)\n *\n * ```ts import.meta.vitest\n * import { Schema, SchemaGetter } from \"effect\"\n *\n * const UpperFromLower = Schema.String.pipe(\n * Schema.encode({\n * decode: SchemaGetter.transform((s: string) => s.toLowerCase()),\n * encode: SchemaGetter.transform((s: string) => s.toUpperCase())\n * })\n * )\n * Schema.encodeSync(UpperFromLower)(\"hello\") // => \"HELLO\"\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function encode(transformation) {\n return self => {\n return decodeTo(self, transformation)(toEncoded(self));\n };\n}\n/**\n * Attaches a constructor default value to a schema field.\n *\n * **Details**\n *\n * Constructor defaults are applied only during `make*`, not during decoding or\n * encoding. Failures are represented directly as `SchemaIssue.Issue` values.\n *\n * **Example** (Defining an optional field with a static default)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schema } from \"effect\"\n *\n * const MySchema = Schema.Struct({\n * name: Schema.String.pipe(\n * Schema.optionalKey,\n * Schema.withConstructorDefault(Effect.succeed(\"anonymous\"))\n * )\n * })\n *\n * MySchema.make({}).name // => \"anonymous\"\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport function withConstructorDefault(\n// `S[\"~type.make.in\"]` instead of `S[\"Type\"]` is intentional here because\n// it makes easier to define the default value if there are nested defaults\ndefaultValue) {\n return schema => make(SchemaAST.withConstructorDefault(schema.ast, defaultValue), {\n schema\n });\n}\nfunction toIssueEffect(self) {\n return Effect.catchCause(self, cause => Effect.failCauseSync(() => Cause_.map(cause, error => error.issue)));\n}\n/**\n * Makes a struct key optional on the `Encoded` side and provides a default\n * `Encoded` value when the key is missing during decoding.\n *\n * **Details**\n *\n * The key uses `optionalKey` on the encoded side, so it may be absent from the\n * input object but **not** `undefined`. The default value is specified in terms\n * of the `Encoded` type (before any decoding transformations).\n *\n * Options:\n *\n * - `encodingStrategy`:\n * - `\"passthrough\"` (default): include the value in the encoded output.\n * - `\"omit\"`: omit the key from the encoded output.\n *\n * **Example** (Providing a default for a missing struct key)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schema } from \"effect\"\n *\n * const MySchema = Schema.Struct({\n * name: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(\"anonymous\")))\n * })\n *\n * Schema.decodeUnknownSync(MySchema)({}).name // => \"anonymous\"\n * ```\n *\n * @see {@link withDecodingDefault} for the value-level variant (key absent **or** `undefined`)\n * @see {@link withDecodingDefaultTypeKey} for the variant where the default is a `Type` value\n * @category decoding\n * @since 4.0.0\n */\nexport function withDecodingDefaultKey(defaultValue, options) {\n const encode = options?.encodingStrategy === \"omit\" ? SchemaGetter.omit() : SchemaGetter.passthrough();\n return self => {\n return optionalKey(toEncoded(self)).pipe(decodeTo(self, {\n decode: SchemaGetter.withDefault(toIssueEffect(defaultValue)),\n encode\n }));\n };\n}\n/**\n * Makes a struct key optional on the `Encoded` side (`optionalKey`, so the\n * key may be absent but **not** `undefined`) and provides a default `Type`\n * value when the key is missing during decoding.\n *\n * **Details**\n *\n * Unlike {@link withDecodingDefaultKey}, the default value is specified in\n * terms of the `Type` (decoded) representation, so it does not need to go\n * through the decoding transformation.\n *\n * Options:\n *\n * - `encodingStrategy`:\n * - `\"passthrough\"` (default): include the value in the encoded output.\n * - `\"omit\"`: omit the key from the encoded output.\n *\n * @see {@link withDecodingDefaultKey} for the variant where the default is an `Encoded` value\n * @see {@link withDecodingDefaultType} for the value-level variant\n * @category decoding\n * @since 4.0.0\n */\nexport function withDecodingDefaultTypeKey(defaultValue, options) {\n return self => {\n return toType(self).pipe(withDecodingDefaultKey(defaultValue, options), encodeTo(optionalKey(self)));\n };\n}\n/**\n * Wraps the `Encoded` side with `optional` (key absent **or** `undefined`)\n * and provides a default `Encoded` value when the field is missing or\n * `undefined` during decoding.\n *\n * **When to use**\n *\n * Use when the default is expressed in the encoded representation, before the\n * field's decoding transformation runs.\n *\n * **Details**\n *\n * The default value is specified in terms of the `Encoded` type (before any\n * decoding transformations).\n *\n * Options:\n *\n * - `encodingStrategy`:\n * - `\"passthrough\"` (default): include the value in the encoded output.\n * - `\"omit\"`: omit the key from the encoded output.\n *\n * **Example** (Providing a default for an optional field value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schema } from \"effect\"\n *\n * const MySchema = Schema.Struct({\n * name: Schema.String.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed(\"anonymous\")))\n * })\n *\n * Schema.decodeUnknownSync(MySchema)({ name: undefined }).name // => \"anonymous\"\n * ```\n *\n * @see {@link withDecodingDefaultKey} for the key-level variant (key absent only, not `undefined`)\n * @see {@link withDecodingDefaultType} for the variant where the default is a `Type` value\n * @category decoding\n * @since 3.10.0\n */\nexport function withDecodingDefault(defaultValue, options) {\n const encode = options?.encodingStrategy === \"omit\" ? SchemaGetter.omit() : SchemaGetter.passthrough();\n return self => {\n return optional(toEncoded(self)).pipe(decodeTo(self, {\n decode: SchemaGetter.withDefault(toIssueEffect(defaultValue)),\n encode\n }));\n };\n}\n/**\n * Wraps the `Encoded` side with `optional` (key absent **or** `undefined`)\n * and provides a default `Type` value when the field is missing or\n * `undefined` during decoding.\n *\n * **When to use**\n *\n * Use when the default is already in the decoded representation and should not\n * pass through the field's decoding transformation.\n *\n * **Details**\n *\n * Unlike {@link withDecodingDefault}, the default value is specified in terms\n * of the `Type` (decoded) representation, so it does not need to go through\n * the decoding transformation.\n *\n * Options:\n *\n * - `encodingStrategy`:\n * - `\"passthrough\"` (default): include the value in the encoded output.\n * - `\"omit\"`: omit the key from the encoded output.\n *\n * @see {@link withDecodingDefault} for the variant where the default is an `Encoded` value\n * @see {@link withDecodingDefaultTypeKey} for the key-level variant\n * @category decoding\n * @since 4.0.0\n */\nexport function withDecodingDefaultType(defaultValue, options) {\n return self => {\n return toType(self).pipe(withDecodingDefault(defaultValue, options), encodeTo(optional(self)));\n };\n}\n/**\n * Combines a {@link Literal} schema with {@link withConstructorDefault}, making it ideal\n * for discriminator fields in tagged unions. When constructing via `make`, the\n * `_tag` field can be omitted and will be filled automatically.\n *\n * **Example** (Defining a discriminated union tag)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const A = Schema.Struct({ _tag: Schema.tag(\"A\"), value: Schema.Number })\n *\n * // _tag is optional in make, auto-filled to \"A\"\n * const a = A.make({ value: 42 })\n * a // => { _tag: \"A\", value: 42 }\n * ```\n *\n * @see {@link tagDefaultOmit} to also omit the tag during encoding\n * @see {@link TaggedStruct} for a shorthand that adds `_tag` automatically\n * @category constructors\n * @since 3.10.0\n */\nexport function tag(literal) {\n return Literal(literal).pipe(withConstructorDefault(Effect.succeed(literal)));\n}\n/**\n * Creates a literal `_tag` schema that is omitted from encoded output.\n *\n * **When to use**\n *\n * Use to decode data that omits the discriminator field while still constructing\n * values with a `_tag` for tagged union matching.\n *\n * **Details**\n *\n * The tag is filled during decoding and construction, like {@link tag}, but is\n * omitted when encoding.\n *\n * **Example** (Omitting tags during encoding)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const A = Schema.Struct({\n * _tag: Schema.tagDefaultOmit(\"A\"),\n * value: Schema.Number\n * })\n *\n * // Encode strips the _tag field\n * Schema.encodeUnknownSync(A)({ _tag: \"A\", value: 1 }) // => { value: 1 }\n * ```\n *\n * @see {@link tag} for the variant that keeps the tag during encoding\n * @category constructors\n * @since 4.0.0\n */\nexport function tagDefaultOmit(literal) {\n return tag(literal).pipe(withDecodingDefaultKey(Effect.succeed(literal), {\n encodingStrategy: \"omit\"\n }));\n}\n/**\n * Creates a struct schema with an automatically populated `_tag` field.\n *\n * **When to use**\n *\n * Use to define a tagged union case from a literal tag and a set of fields.\n *\n * **Details**\n *\n * When using the `make` method, the `_tag` field is optional and will be\n * added automatically. However, when decoding or encoding, the `_tag` field\n * must be present in the input.\n *\n * **Example** (Defining a tagged struct shorthand)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * // Defines a struct with a fixed `_tag` field\n * const tagged = Schema.TaggedStruct(\"A\", {\n * a: Schema.String\n * })\n *\n * // This is the same as writing:\n * const equivalent = Schema.Struct({\n * _tag: Schema.tag(\"A\"),\n * a: Schema.String\n * })\n * void tagged\n * void equivalent\n * ```\n *\n * **Example** (Accessing the literal value of the tag)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const tagged = Schema.TaggedStruct(\"A\", {\n * a: Schema.String\n * })\n *\n * tagged.fields._tag.schema.literal // => \"A\"\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport function TaggedStruct(value, fields) {\n return Struct({\n _tag: tag(value),\n ...fields\n });\n}\n/**\n * Augments an existing {@link Union} of tagged structs with utility methods and an ordered tuple of discriminant\n * values.\n *\n * **Gotchas**\n *\n * Throws if multiple members use the same discriminant property key.\n *\n * **Example** (Adding tagged-union utilities to an existing union)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const A = Schema.TaggedStruct(\"A\", { value: Schema.Number })\n * const B = Schema.TaggedStruct(\"B\", { name: Schema.String })\n *\n * const MyUnion = Schema.Union([A, B]).pipe(Schema.toTaggedUnion(\"_tag\"))\n *\n * // Pattern-match on the union\n * const result = MyUnion.match({ _tag: \"A\", value: 1 }, {\n * A: (a) => `number: ${a.value}`,\n * B: (b) => `name: ${b.name}`\n * })\n * result // => \"number: 1\"\n * ```\n *\n * @see {@link TaggedUnion} for a shorthand that builds the union from scratch\n * @category combinators\n * @since 4.0.0\n */\nexport function toTaggedUnion(tag) {\n return self => {\n const cases = {};\n const discriminants = [];\n const discriminantKeys = new Set();\n const guards = {};\n const isAnyOf = keys => value => keys.includes(value[tag]);\n walk(self);\n return Object.assign(self, {\n cases,\n discriminants,\n isAnyOf,\n guards,\n match,\n matchOrElse\n });\n function walk(schema) {\n const ast = schema.ast;\n if (SchemaAST.isUnion(ast) && \"members\" in schema && globalThis.Array.isArray(schema.members) && schema.members.every(isSchema)) {\n return schema.members.forEach(walk);\n }\n const sentinels = SchemaAST.collectSentinels(ast);\n if (sentinels.length > 0) {\n const literal = sentinels.find(s => s.key === tag)?.literal;\n if (Predicate.isPropertyKey(literal)) {\n const key = typeof literal === \"number\" ? globalThis.String(literal) : literal;\n if (discriminantKeys.has(key)) {\n throw new globalThis.Error(`Duplicate discriminant: ${globalThis.String(literal)}`);\n }\n discriminantKeys.add(key);\n discriminants.push(literal);\n InternalRecord.assignProperty(cases, literal, schema);\n InternalRecord.assignProperty(guards, literal, SchemaParser.is(toType(schema)));\n return;\n }\n }\n throw new globalThis.Error(\"No literal or unique symbol found\");\n }\n function match() {\n if (arguments.length === 1) {\n const cases = arguments[0];\n return function (value) {\n const key = value[tag];\n const handler = Object.hasOwn(cases, key) ? cases[key] : undefined;\n return handler(value);\n };\n }\n const value = arguments[0];\n const cases = arguments[1];\n const key = value[tag];\n const handler = Object.hasOwn(cases, key) ? cases[key] : undefined;\n return handler(value);\n }\n function matchOrElse() {\n if (arguments.length === 2) {\n const cases = arguments[0];\n const orElse = arguments[1];\n return function (value) {\n const key = value[tag];\n const handler = Object.hasOwn(cases, key) ? cases[key] ?? orElse : orElse;\n return handler(value);\n };\n }\n const value = arguments[0];\n const cases = arguments[1];\n const orElse = arguments[2];\n const key = value[tag];\n const handler = Object.hasOwn(cases, key) ? cases[key] ?? orElse : orElse;\n return handler(value);\n }\n };\n}\n/**\n * Builds a discriminated union from a record of field sets, one per variant.\n * Each key becomes the `_tag` literal and the value is passed to {@link TaggedStruct}.\n * The result includes `cases`, `guards`, `isAnyOf`, `match`, and `matchOrElse` utilities.\n *\n * **Example** (Pattern matching a discriminated union)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const Shape = Schema.TaggedUnion({\n * Circle: { radius: Schema.Number },\n * Rectangle: { width: Schema.Number, height: Schema.Number }\n * })\n *\n * // Pattern-match on a decoded value\n * const area = Shape.match({ _tag: \"Circle\", radius: 5 }, {\n * Circle: (c) => Math.PI * c.radius ** 2,\n * Rectangle: (r) => r.width * r.height\n * })\n * Math.round(area * 100) / 100 // => 78.54\n * ```\n *\n * @see {@link toTaggedUnion} to augment an existing union instead\n * @category constructors\n * @since 4.0.0\n */\nexport function TaggedUnion(casesByTag) {\n const cases = {};\n const members = [];\n for (const key of Object.keys(casesByTag)) {\n const member = TaggedStruct(key, casesByTag[key]);\n InternalRecord.assignProperty(cases, key, member);\n members.push(member);\n }\n const union = Union(members);\n const {\n guards,\n isAnyOf,\n match,\n matchOrElse\n } = toTaggedUnion(\"_tag\")(union);\n return make(union.ast, {\n cases,\n isAnyOf,\n guards,\n match,\n matchOrElse\n });\n}\n/**\n * Wraps a struct schema so that its decoded `Type` becomes a nominally distinct type `Self`.\n * Useful for creating opaque types that are structurally identical to a base struct\n * but type-incompatible with it.\n *\n * **Example** (Defining opaque structs)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * class Person extends Schema.Opaque()(\n * Schema.Struct({\n * name: Schema.String\n * })\n * ) {}\n *\n * // Decoded value is Person, not { name: string }\n * const person = Schema.decodeUnknownSync(Person)({ name: \"Alice\" })\n * person.name // => \"Alice\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function Opaque() {\n return schema => schema;\n}\n/**\n * Creates a schema that validates values using `instanceof`.\n * Decoding and encoding pass the value through unchanged.\n *\n * **Example** (Defining a schema for a built-in class)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const DateSchema = Schema.instanceOf(Date)\n *\n * const decoded = Schema.decodeUnknownSync(DateSchema)(new Date(\"2024-01-01\"))\n * decoded.toISOString() // => \"2024-01-01T00:00:00.000Z\"\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport function instanceOf(constructor, annotations) {\n return declare(u => u instanceof constructor, annotations);\n}\n/**\n * Constructs an `SchemaAST.Link` that describes how a value of type `T` encodes to and decodes from a `To` schema.\n * Used when building low-level AST transformations that bridge two schema types.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function link() {\n return (encodeTo, transformation) => {\n return new SchemaAST.Link(encodeTo.ast, SchemaTransformation.make(transformation));\n };\n}\n/**\n * Creates a custom validation filter from a predicate function.\n *\n * **Details**\n *\n * The predicate receives the decoded input value, the schema AST, and parse\n * options, and returns a `FilterOutput`. Non-success outputs are normalized into\n * schema issues. The `annotations` parameter annotates the filter itself; with\n * the default formatter, failures use `message` first, `expected` second, and\n * `` when neither is provided.\n *\n * When `abort` is `true`, parsing stops after this filter fails instead of\n * collecting later check failures.\n *\n * **Example** (Reporting failure at a nested path)\n *\n * ```ts import.meta.vitest\n * import { Result, Schema } from \"effect\"\n *\n * const schema = Schema.Struct({ password: Schema.String, confirmPassword: Schema.String }).check(\n * Schema.makeFilter((o) =>\n * o.password === o.confirmPassword\n * ? undefined\n * : { path: [\"password\"], issue: \"password and confirmPassword must match\" }\n * )\n * )\n *\n * const result = Schema.decodeUnknownResult(schema)({ password: \"123456\", confirmPassword: \"1234567\" })\n * if (Result.isFailure(result) && result.failure.issue._tag === \"Filter\" && result.failure.issue.issue._tag === \"Pointer\") {\n * result.failure.issue.issue.path // => [\"password\"]\n * }\n * ```\n *\n * **Example** (Reporting multiple failures at once)\n *\n * ```ts import.meta.vitest\n * import { Result, Schema } from \"effect\"\n *\n * const schema = Schema.Struct({ a: Schema.Finite, b: Schema.Finite, c: Schema.Finite }).check(\n * Schema.makeFilter((o) => {\n * const issues: Array = []\n * if (o.a > 0) {\n * if (o.b <= 0) issues.push({ path: [\"b\"], issue: \"b must be greater than 0\" })\n * if (o.c <= 0) issues.push({ path: [\"c\"], issue: \"c must be greater than 0\" })\n * }\n * return issues\n * })\n * )\n *\n * const result = Schema.decodeUnknownResult(schema)({ a: 1, b: 0, c: 0 })\n * if (Result.isFailure(result) && result.failure.issue._tag === \"Filter\" && result.failure.issue.issue._tag === \"Composite\") {\n * result.failure.issue.issue.issues.map((issue) => issue._tag === \"Pointer\" ? issue.path : []) // => [[\"b\"], [\"c\"]]\n * }\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeFilter = SchemaAST.makeFilter;\n/**\n * Groups multiple checks into a single {@link SchemaAST.FilterGroup}, applying\n * optional shared annotations to the group as a whole.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeFilterGroup(checks, annotations = undefined) {\n return new SchemaAST.FilterGroup(checks, annotations);\n}\nconst TRIMMED_PATTERN = \"^\\\\S[\\\\s\\\\S]*\\\\S$|^\\\\S$|^$\";\n/**\n * Validates that a string has no leading or trailing whitespace.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to a `pattern` constraint in JSON Schema that\n * matches strings without leading or trailing whitespace.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `patterns`\n * constraint to ensure generated strings match the trimmed pattern.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isTrimmed(annotations) {\n const regExp = new globalThis.RegExp(TRIMMED_PATTERN);\n return makeFilter(s => s.trim() === s, {\n expected: \"a string with no leading or trailing whitespace\",\n representation: {\n id: \"effect/schema/isTrimmed\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: \"Schema.isTrimmed()\"\n }),\n arbitraryConstraint: {\n patterns: [{\n source: TRIMMED_PATTERN,\n flags: \"\"\n }]\n },\n ...annotations\n });\n}\n/**\n * Validates that a string matches the specified regular expression pattern.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * JSON Schema receives the RegExp source as a `pattern`. JavaScript flags are\n * not represented, so validation can differ when the RegExp uses flags or\n * relies on JavaScript's non-Unicode behavior.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `patterns`\n * constraint to ensure generated strings match the specified RegExp pattern.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isPattern(regExp, annotations) {\n const source = regExp.source;\n const flags = regExp.flags;\n const runtimeRegExp = flags === \"\" ? `new RegExp(${format(source)})` : `new RegExp(${format(source)}, ${format(flags)})`;\n return SchemaAST.isPattern(regExp, {\n toCode: () => ({\n runtime: `Schema.isPattern(${runtimeRegExp})`\n }),\n ...annotations\n });\n}\n/**\n * Validates that a string represents a finite number.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to a `pattern` constraint in JSON Schema that matches\n * strings representing finite numbers.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `patterns`\n * constraint to ensure generated strings match the number string pattern.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isStringFinite(annotations) {\n return SchemaAST.isStringFinite({\n toCode: () => ({\n runtime: \"Schema.isStringFinite()\"\n }),\n ...annotations\n });\n}\n/**\n * Validates that a string is a signed base-10 integer literal for Effect's\n * BigInt string encoding.\n *\n * **Details**\n *\n * The check uses the pattern `^-?\\d+$`. It does not accept leading `+`, decimal\n * points, exponent notation, separators, or non-decimal inputs such as\n * hexadecimal strings.\n *\n * JSON Schema:\n * This check corresponds to a `pattern` constraint with the same signed\n * base-10 integer pattern.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isStringBigInt(annotations) {\n return SchemaAST.isStringBigInt({\n toCode: () => ({\n runtime: \"Schema.isStringBigInt()\"\n }),\n ...annotations\n });\n}\n/**\n * Validates that a string has the `Symbol(description)` format used by Effect's\n * symbol string encoding.\n *\n * **Details**\n *\n * The check uses the pattern `^Symbol\\((.*)\\)$`. It is not a general test for\n * whether a string can be passed to JavaScript's `Symbol()` function.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isStringSymbol(annotations) {\n return SchemaAST.isStringSymbol({\n toCode: () => ({\n runtime: \"Schema.isStringSymbol()\"\n }),\n ...annotations\n });\n}\nconst getUUIDRegExp = version => {\n if (version) {\n return new globalThis.RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);\n }\n return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12})$/;\n};\n/**\n * Validates that a string is a strict Universally Unique Identifier (UUID).\n *\n * **When to use**\n *\n * Use when you need UUID semantics, including version and RFC variant bits,\n * rather than only the dashed hexadecimal shape.\n *\n * **Details**\n *\n * Without a version argument, this accepts UUID versions 1 through 8, the nil\n * UUID (`00000000-0000-0000-0000-000000000000`), and the max UUID\n * (`ffffffff-ffff-ffff-ffff-ffffffffffff`). With a version argument, this\n * accepts only UUIDs with that version and RFC variant bits; nil and max UUIDs\n * are not versioned UUIDs and do not match version-specific checks.\n *\n * JSON Schema:\n *\n * This check corresponds to a `pattern` constraint in JSON Schema that matches\n * UUID format, and includes a `format: \"uuid\"` annotation.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `patterns`\n * constraint to ensure generated strings match the UUID pattern.\n *\n * @see {@link isGUID} for shape-only GUID validation.\n * @category validation\n * @since 4.0.0\n */\nexport function isUUID(version, annotations) {\n const regExp = getUUIDRegExp(version);\n return isPattern(regExp, {\n expected: version ? `a UUID v${version}` : \"a UUID\",\n representation: {\n id: \"effect/schema/isUUID\",\n payload: {\n version: version ?? null\n }\n },\n toJsonSchema: () => ({\n pattern: regExp.source,\n format: \"uuid\"\n }),\n toCode: () => ({\n runtime: version === undefined ? \"Schema.isUUID()\" : `Schema.isUUID(${version})`\n }),\n ...annotations\n });\n}\nconst GUID_REGEXP = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;\n/**\n * Validates that a string has the GUID / UUID textual shape.\n *\n * **When to use**\n *\n * Use when you need to accept dashed hexadecimal identifiers without enforcing\n * UUID version or variant bits.\n *\n * **Details**\n *\n * This check accepts strings in the `8-4-4-4-12` hexadecimal form. JSON Schema\n * output includes the corresponding `pattern` constraint and intentionally does\n * not include `format: \"uuid\"` because GUID validation is looser than UUID\n * validation.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `patterns`\n * constraint to ensure generated strings match the GUID pattern.\n *\n * @see {@link isUUID} for strict UUID validation.\n * @category validation\n * @since 4.0.0\n */\nexport function isGUID(annotations) {\n return isPattern(GUID_REGEXP, {\n expected: \"a GUID\",\n representation: {\n id: \"effect/schema/isGUID\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: GUID_REGEXP.source\n }),\n toCode: () => ({\n runtime: \"Schema.isGUID()\"\n }),\n ...annotations\n });\n}\n/**\n * Validates that a string is a valid ULID (Universally Unique Lexicographically\n * Sortable Identifier).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to a `pattern` constraint in JSON Schema that matches\n * the ULID format.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `patterns`\n * constraint to ensure generated strings match the ULID pattern.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isULID(annotations) {\n const regExp = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;\n return isPattern(regExp, {\n representation: {\n id: \"effect/schema/isULID\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: \"Schema.isULID()\"\n }),\n ...annotations\n });\n}\n/**\n * Validates that a string is valid Base64 encoded data.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to a `pattern` constraint in JSON Schema that matches\n * Base64 format.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `patterns`\n * constraint to ensure generated strings match the Base64 pattern.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isBase64(annotations) {\n const regExp = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;\n return isPattern(regExp, {\n expected: \"a base64 encoded string\",\n representation: {\n id: \"effect/schema/isBase64\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: \"Schema.isBase64()\"\n }),\n ...annotations\n });\n}\n/**\n * Validates that a string is valid Base64URL encoded data (Base64 with URL-safe\n * characters).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to a `pattern` constraint in JSON Schema that matches\n * Base64URL format.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `patterns`\n * constraint to ensure generated strings match the Base64URL pattern.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isBase64Url(annotations) {\n const regExp = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;\n return isPattern(regExp, {\n expected: \"a base64url encoded string\",\n representation: {\n id: \"effect/schema/isBase64Url\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: \"Schema.isBase64Url()\"\n }),\n ...annotations\n });\n}\n/**\n * Validates at runtime that a string starts with the specified literal prefix.\n *\n * **Details**\n *\n * RegExp metacharacters in the prefix are escaped in JSON Schema and arbitrary\n * metadata so that the generated patterns retain literal `startsWith` semantics.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isStartsWith(startsWith, annotations) {\n const formatted = JSON.stringify(startsWith);\n const regExp = new globalThis.RegExp(`^${RegExp_.escape(startsWith)}`);\n return makeFilter(s => s.startsWith(startsWith), {\n expected: `a string starting with ${formatted}`,\n representation: {\n id: \"effect/schema/isStartsWith\",\n payload: {\n startsWith\n }\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: `Schema.isStartsWith(${format(startsWith)})`\n }),\n arbitraryConstraint: {\n patterns: [{\n source: regExp.source,\n flags: regExp.flags\n }]\n },\n ...annotations\n });\n}\n/**\n * Validates at runtime that a string ends with the specified literal suffix.\n *\n * **Details**\n *\n * RegExp metacharacters in the suffix are escaped in JSON Schema and arbitrary\n * metadata so that the generated patterns retain literal `endsWith` semantics.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isEndsWith(endsWith, annotations) {\n const formatted = JSON.stringify(endsWith);\n const regExp = new globalThis.RegExp(`${RegExp_.escape(endsWith)}$`);\n return makeFilter(s => s.endsWith(endsWith), {\n expected: `a string ending with ${formatted}`,\n representation: {\n id: \"effect/schema/isEndsWith\",\n payload: {\n endsWith\n }\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: `Schema.isEndsWith(${format(endsWith)})`\n }),\n arbitraryConstraint: {\n patterns: [{\n source: regExp.source,\n flags: regExp.flags\n }]\n },\n ...annotations\n });\n}\n/**\n * Validates at runtime that a string contains the specified literal substring.\n *\n * **Details**\n *\n * RegExp metacharacters in the substring are escaped in JSON Schema and\n * arbitrary metadata so that the generated patterns retain literal `includes`\n * semantics.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isIncludes(includes, annotations) {\n const formatted = JSON.stringify(includes);\n const regExp = new globalThis.RegExp(RegExp_.escape(includes));\n return makeFilter(s => s.includes(includes), {\n expected: `a string including ${formatted}`,\n representation: {\n id: \"effect/schema/isIncludes\",\n payload: {\n includes\n }\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: `Schema.isIncludes(${format(includes)})`\n }),\n arbitraryConstraint: {\n patterns: [{\n source: regExp.source,\n flags: regExp.flags\n }]\n },\n ...annotations\n });\n}\nconst UPPERCASED_PATTERN = \"^[^a-z]*$\";\n/**\n * Validates that a string is unchanged by JavaScript's `toUpperCase()`.\n *\n * **Details**\n *\n * This accepts empty strings and characters that do not have lowercase forms,\n * such as digits, punctuation, and whitespace. It rejects strings that would\n * change when uppercased.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isUppercased(annotations) {\n const regExp = new globalThis.RegExp(UPPERCASED_PATTERN);\n return makeFilter(s => s.toUpperCase() === s, {\n expected: \"a string with all characters in uppercase\",\n representation: {\n id: \"effect/schema/isUppercased\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: \"Schema.isUppercased()\"\n }),\n arbitraryConstraint: {\n patterns: [{\n source: UPPERCASED_PATTERN,\n flags: \"\"\n }]\n },\n ...annotations\n });\n}\nconst LOWERCASED_PATTERN = \"^[^A-Z]*$\";\n/**\n * Validates that a string is unchanged by JavaScript's `toLowerCase()`.\n *\n * **Details**\n *\n * This accepts empty strings and characters that do not have uppercase forms,\n * such as digits, punctuation, and whitespace. It rejects strings that would\n * change when lowercased.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isLowercased(annotations) {\n const regExp = new globalThis.RegExp(LOWERCASED_PATTERN);\n return makeFilter(s => s.toLowerCase() === s, {\n expected: \"a string with all characters in lowercase\",\n representation: {\n id: \"effect/schema/isLowercased\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: \"Schema.isLowercased()\"\n }),\n arbitraryConstraint: {\n patterns: [{\n source: LOWERCASED_PATTERN,\n flags: \"\"\n }]\n },\n ...annotations\n });\n}\nconst CAPITALIZED_PATTERN = \"^(?:[^a-z][\\\\s\\\\S]*)?$\";\n/**\n * Validates that the first character of a string is unchanged by\n * `toUpperCase()`.\n *\n * **Details**\n *\n * Empty strings pass. Strings whose first character has no lowercase form, such\n * as a digit, punctuation mark, or whitespace, also pass.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isCapitalized(annotations) {\n const regExp = new globalThis.RegExp(CAPITALIZED_PATTERN);\n return makeFilter(s => s.charAt(0).toUpperCase() === s.charAt(0), {\n expected: \"a string with the first character in uppercase\",\n representation: {\n id: \"effect/schema/isCapitalized\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: \"Schema.isCapitalized()\"\n }),\n arbitraryConstraint: {\n patterns: [{\n source: CAPITALIZED_PATTERN,\n flags: \"\"\n }]\n },\n ...annotations\n });\n}\nconst UNCAPITALIZED_PATTERN = \"^(?:[^A-Z][\\\\s\\\\S]*)?$\";\n/**\n * Validates that the first character of a string is unchanged by\n * `toLowerCase()`.\n *\n * **Details**\n *\n * Empty strings pass. Strings whose first character has no uppercase form, such\n * as a digit, punctuation mark, or whitespace, also pass.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isUncapitalized(annotations) {\n const regExp = new globalThis.RegExp(UNCAPITALIZED_PATTERN);\n return makeFilter(s => s.charAt(0).toLowerCase() === s.charAt(0), {\n expected: \"a string with the first character in lowercase\",\n representation: {\n id: \"effect/schema/isUncapitalized\",\n payload: null\n },\n toJsonSchema: () => ({\n pattern: regExp.source\n }),\n toCode: () => ({\n runtime: \"Schema.isUncapitalized()\"\n }),\n arbitraryConstraint: {\n patterns: [{\n source: UNCAPITALIZED_PATTERN,\n flags: \"\"\n }]\n },\n ...annotations\n });\n}\n/**\n * Schema for finite numbers, rejecting `NaN`, `Infinity`, and `-Infinity`.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const Finite = /*#__PURE__*/make(SchemaAST.finite);\n/**\n * Validates that a number is finite (not `Infinity`, `-Infinity`, or `NaN`).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check does not have a direct JSON Schema equivalent, but ensures the\n * number is valid and finite.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a finite-number constraint.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isFinite = SchemaAST.isFinite;\n/**\n * Creates a greater-than (`>`) check for any ordered type from an\n * `Order.Order` instance.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function makeIsGreaterThan(options) {\n const gt = Order.isGreaterThan(options.order);\n const formatter = options.formatter ?? format;\n return (exclusiveMinimum, annotations) => {\n return makeFilter(input => gt(input, exclusiveMinimum), {\n expected: `a value greater than ${formatter(exclusiveMinimum)}`,\n arbitraryConstraint: {\n order: options.order,\n minimum: exclusiveMinimum,\n exclusiveMinimum: true\n },\n ...options.annotate?.(exclusiveMinimum),\n ...annotations\n });\n };\n}\n/**\n * Creates a greater-than-or-equal-to (`>=`) check for any ordered type from an\n * `Order.Order` instance.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function makeIsGreaterThanOrEqualTo(options) {\n const gte = Order.isGreaterThanOrEqualTo(options.order);\n const formatter = options.formatter ?? format;\n return (minimum, annotations) => {\n return makeFilter(input => gte(input, minimum), {\n expected: `a value greater than or equal to ${formatter(minimum)}`,\n arbitraryConstraint: {\n order: options.order,\n minimum\n },\n ...options.annotate?.(minimum),\n ...annotations\n });\n };\n}\n/**\n * Creates a less-than (`<`) check for any ordered type from an `Order.Order`\n * instance.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function makeIsLessThan(options) {\n const lt = Order.isLessThan(options.order);\n const formatter = options.formatter ?? format;\n return (exclusiveMaximum, annotations) => {\n return makeFilter(input => lt(input, exclusiveMaximum), {\n expected: `a value less than ${formatter(exclusiveMaximum)}`,\n arbitraryConstraint: {\n order: options.order,\n maximum: exclusiveMaximum,\n exclusiveMaximum: true\n },\n ...options.annotate?.(exclusiveMaximum),\n ...annotations\n });\n };\n}\n/**\n * Creates a less-than-or-equal-to (`<=`) check for any ordered type from an\n * `Order.Order` instance.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function makeIsLessThanOrEqualTo(options) {\n const lte = Order.isLessThanOrEqualTo(options.order);\n const formatter = options.formatter ?? format;\n return (maximum, annotations) => {\n return makeFilter(input => lte(input, maximum), {\n expected: `a value less than or equal to ${formatter(maximum)}`,\n arbitraryConstraint: {\n order: options.order,\n maximum\n },\n ...options.annotate?.(maximum),\n ...annotations\n });\n };\n}\n/**\n * Creates an inclusive or exclusive range check for any ordered type from an\n * `Order.Order` instance.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function makeIsBetween(deriveOptions) {\n const greaterThanOrEqualTo = Order.isGreaterThanOrEqualTo(deriveOptions.order);\n const greaterThan = Order.isGreaterThan(deriveOptions.order);\n const lessThanOrEqualTo = Order.isLessThanOrEqualTo(deriveOptions.order);\n const lessThan = Order.isLessThan(deriveOptions.order);\n const formatter = deriveOptions.formatter ?? format;\n return (options, annotations) => {\n const gte = options.exclusiveMinimum ? greaterThan : greaterThanOrEqualTo;\n const lte = options.exclusiveMaximum ? lessThan : lessThanOrEqualTo;\n return makeFilter(input => gte(input, options.minimum) && lte(input, options.maximum), {\n expected: `a value between ${formatter(options.minimum)}${options.exclusiveMinimum ? \" (excluded)\" : \"\"} and ${formatter(options.maximum)}${options.exclusiveMaximum ? \" (excluded)\" : \"\"}`,\n arbitraryConstraint: {\n order: deriveOptions.order,\n minimum: options.minimum,\n maximum: options.maximum,\n ...(options.exclusiveMinimum && {\n exclusiveMinimum: true\n }),\n ...(options.exclusiveMaximum && {\n exclusiveMaximum: true\n })\n },\n ...deriveOptions.annotate?.(options),\n ...annotations\n });\n };\n}\n/**\n * Creates a divisibility check for any numeric type from a remainder function\n * and a zero value.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function makeIsMultipleOf(options) {\n return (divisor, annotations) => {\n const formatter = options.formatter ?? format;\n return makeFilter(input => options.remainder(input, divisor) === options.zero, {\n expected: `a value that is a multiple of ${formatter(divisor)}`,\n ...options.annotate?.(divisor),\n ...annotations\n });\n };\n}\nfunction encodeNumberPayload(number) {\n if (!globalThis.Number.isFinite(number)) {\n throw new globalThis.RangeError(`Expected a finite number, got ${format(number)}`);\n }\n return number;\n}\n/**\n * Validates that a number is greater than the specified value (exclusive).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to the `exclusiveMinimum` constraint in JSON Schema.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an\n * `exclusiveMinimum` constraint to ensure generated numbers are greater than\n * the specified value.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isGreaterThan = /*#__PURE__*/makeIsGreaterThan({\n order: Order.Number,\n annotate: exclusiveMinimum => ({\n representation: {\n id: \"effect/schema/isGreaterThan\",\n payload: {\n exclusiveMinimum: encodeNumberPayload(exclusiveMinimum)\n }\n },\n toJsonSchema: () => ({\n exclusiveMinimum\n }),\n toCode: () => ({\n runtime: `Schema.isGreaterThan(${format(exclusiveMinimum)})`\n })\n })\n});\n/**\n * Validates that a number is greater than or equal to the specified value\n * (inclusive).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to the `minimum` constraint in JSON Schema.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `minimum` constraint\n * to ensure generated numbers are greater than or equal to the specified value.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isGreaterThanOrEqualTo = /*#__PURE__*/makeIsGreaterThanOrEqualTo({\n order: Order.Number,\n annotate: minimum => ({\n representation: {\n id: \"effect/schema/isGreaterThanOrEqualTo\",\n payload: {\n minimum: encodeNumberPayload(minimum)\n }\n },\n toJsonSchema: () => ({\n minimum\n }),\n toCode: () => ({\n runtime: `Schema.isGreaterThanOrEqualTo(${format(minimum)})`\n })\n })\n});\n/**\n * Validates that a number is less than the specified value (exclusive).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to the `exclusiveMaximum` constraint in JSON Schema.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an\n * `exclusiveMaximum` constraint to ensure generated numbers are less than the\n * specified value.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isLessThan = /*#__PURE__*/makeIsLessThan({\n order: Order.Number,\n annotate: exclusiveMaximum => ({\n representation: {\n id: \"effect/schema/isLessThan\",\n payload: {\n exclusiveMaximum: encodeNumberPayload(exclusiveMaximum)\n }\n },\n toJsonSchema: () => ({\n exclusiveMaximum\n }),\n toCode: () => ({\n runtime: `Schema.isLessThan(${format(exclusiveMaximum)})`\n })\n })\n});\n/**\n * Validates that a number is less than or equal to the specified value\n * (inclusive).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to the `maximum` constraint in JSON Schema.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `maximum` constraint\n * to ensure generated numbers are less than or equal to the specified value.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isLessThanOrEqualTo = /*#__PURE__*/makeIsLessThanOrEqualTo({\n order: Order.Number,\n annotate: maximum => ({\n representation: {\n id: \"effect/schema/isLessThanOrEqualTo\",\n payload: {\n maximum: encodeNumberPayload(maximum)\n }\n },\n toJsonSchema: () => ({\n maximum\n }),\n toCode: () => ({\n runtime: `Schema.isLessThanOrEqualTo(${format(maximum)})`\n })\n })\n});\n/**\n * Validates that a number is within a specified range. The range boundaries can\n * be inclusive or exclusive based on the provided options.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to `minimum`/`maximum` or `exclusiveMinimum`/`exclusiveMaximum`\n * constraints in JSON Schema, depending on the options provided.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies `minimum` and\n * `maximum` constraints with optional `exclusiveMinimum` and\n * `exclusiveMaximum` flags to ensure generated numbers fall within the\n * specified range.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isBetween = /*#__PURE__*/makeIsBetween({\n order: Order.Number,\n annotate: options => {\n const exclusiveMinimum = options.exclusiveMinimum ? true : undefined;\n const exclusiveMaximum = options.exclusiveMaximum ? true : undefined;\n const payload = {\n minimum: encodeNumberPayload(options.minimum),\n maximum: encodeNumberPayload(options.maximum),\n ...(exclusiveMinimum && {\n exclusiveMinimum\n }),\n ...(exclusiveMaximum && {\n exclusiveMaximum\n })\n };\n return {\n representation: {\n id: \"effect/schema/isBetween\",\n payload\n },\n toJsonSchema: () => ({\n [exclusiveMinimum ? \"exclusiveMinimum\" : \"minimum\"]: options.minimum,\n [exclusiveMaximum ? \"exclusiveMaximum\" : \"maximum\"]: options.maximum\n }),\n toCode: () => ({\n runtime: `Schema.isBetween({ minimum: ${format(options.minimum)}, maximum: ${format(options.maximum)}, exclusiveMinimum: ${format(exclusiveMinimum)}, exclusiveMaximum: ${format(exclusiveMaximum)} })`\n })\n };\n }\n});\n/**\n * Validates that a number is a multiple of the specified divisor.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to the `multipleOf` constraint in JSON Schema.\n * Negative divisors are normalized to their absolute value because JSON\n * Schema requires `multipleOf` to be positive.\n *\n * **Gotchas**\n *\n * Throws a `RangeError` when `divisor` is zero or is not finite.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isMultipleOf(divisor, annotations) {\n if (!globalThis.Number.isFinite(divisor) || divisor === 0) {\n throw new globalThis.RangeError(`Expected a finite non-zero number, got ${globalThis.String(divisor)}`);\n }\n divisor = globalThis.Math.abs(divisor);\n return makeFilter(input => remainder(input, divisor) === 0, {\n expected: `a value that is a multiple of ${divisor}`,\n representation: {\n id: \"effect/schema/isMultipleOf\",\n payload: {\n divisor\n }\n },\n toJsonSchema: () => ({\n multipleOf: divisor\n }),\n toCode: () => ({\n runtime: `Schema.isMultipleOf(${format(divisor)})`\n }),\n ...annotations\n });\n}\n/**\n * Validates that a number is a safe integer (within the safe integer range\n * that can be exactly represented in JavaScript).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to the `type: \"integer\"` constraint in JSON Schema.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an integer constraint.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isInt(annotations) {\n return makeFilter(n => globalThis.Number.isSafeInteger(n), {\n expected: \"an integer\",\n representation: {\n id: \"effect/schema/isInt\",\n payload: null\n },\n toJsonSchema: () => ({\n type: \"integer\"\n }),\n toCode: () => ({\n runtime: \"Schema.isInt()\"\n }),\n arbitraryConstraint: {\n number: \"integer\"\n },\n ...annotations\n });\n}\n/**\n * Schema for integers, rejecting `NaN`, `Infinity`, and `-Infinity`.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const Int = /*#__PURE__*/Number.check(/*#__PURE__*/isInt());\n/**\n * Schema for non-negative safe integers, including zero.\n *\n * **When to use**\n *\n * Use when you need a count, index, or size that cannot be negative.\n *\n * @see {@link Int} for safe integers that may be negative\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const Natural = /*#__PURE__*/Int.check(/*#__PURE__*/isGreaterThanOrEqualTo(0));\n/**\n * Validates that a number is a 32-bit signed integer (range: -2,147,483,648 to\n * 2,147,483,647).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to the `format: \"int32\"` constraint in OpenAPI 3.1,\n * or `minimum`/`maximum` constraints in other JSON Schema targets.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies integer and range\n * constraints to ensure generated numbers are 32-bit signed integers.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isInt32(annotations) {\n return new SchemaAST.FilterGroup([isInt(), isBetween({\n minimum: -2147483648,\n maximum: 2147483647\n })], {\n expected: \"a 32-bit integer\",\n ...annotations\n });\n}\n/**\n * Validates that a number is a 32-bit unsigned integer (range: 0 to\n * 4,294,967,295).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to the `format: \"uint32\"` constraint in OpenAPI 3.1,\n * or `minimum`/`maximum` constraints in other JSON Schema targets.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies integer and range\n * constraints to ensure generated numbers are 32-bit unsigned integers.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isUint32(annotations) {\n return new SchemaAST.FilterGroup([isInt(), isBetween({\n minimum: 0,\n maximum: 4294967295\n })], {\n expected: \"a 32-bit unsigned integer\",\n ...annotations\n });\n}\nfunction encodeDatePayload(date) {\n if (globalThis.Number.isNaN(date.getTime())) {\n throw new globalThis.RangeError(`Expected a valid Date, got ${format(date)}`);\n }\n return date.toISOString();\n}\nfunction formatDateRuntime(date) {\n return `new Date(${format(date.getTime())})`;\n}\n/**\n * Validates that a Date is greater than the specified value (exclusive).\n *\n * **Details**\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an exclusive lower bound.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isGreaterThanDate = /*#__PURE__*/makeIsGreaterThan({\n order: Order.Date,\n annotate: exclusiveMinimum => {\n const encoded = encodeDatePayload(exclusiveMinimum);\n return {\n representation: {\n id: \"effect/schema/isGreaterThanDate\",\n payload: {\n exclusiveMinimum: encoded\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isGreaterThanDate(${formatDateRuntime(exclusiveMinimum)})`\n })\n };\n }\n});\n/**\n * Validates that a Date is greater than or equal to the specified date\n * (inclusive).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check does not have a direct JSON Schema equivalent, as JSON Schema\n * validates date strings, not Date objects.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an inclusive lower bound.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isGreaterThanOrEqualToDate = /*#__PURE__*/makeIsGreaterThanOrEqualTo({\n order: Order.Date,\n annotate: minimum => {\n const encoded = encodeDatePayload(minimum);\n return {\n representation: {\n id: \"effect/schema/isGreaterThanOrEqualToDate\",\n payload: {\n minimum: encoded\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isGreaterThanOrEqualToDate(${formatDateRuntime(minimum)})`\n })\n };\n }\n});\n/**\n * Validates that a Date is less than the specified value (exclusive).\n *\n * **Details**\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an exclusive upper bound.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isLessThanDate = /*#__PURE__*/makeIsLessThan({\n order: Order.Date,\n annotate: exclusiveMaximum => {\n const encoded = encodeDatePayload(exclusiveMaximum);\n return {\n representation: {\n id: \"effect/schema/isLessThanDate\",\n payload: {\n exclusiveMaximum: encoded\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isLessThanDate(${formatDateRuntime(exclusiveMaximum)})`\n })\n };\n }\n});\n/**\n * Validates that a Date is less than or equal to the specified date\n * (inclusive).\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check does not have a direct JSON Schema equivalent, as JSON Schema\n * validates date strings, not Date objects.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an inclusive upper bound.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isLessThanOrEqualToDate = /*#__PURE__*/makeIsLessThanOrEqualTo({\n order: Order.Date,\n annotate: maximum => {\n const encoded = encodeDatePayload(maximum);\n return {\n representation: {\n id: \"effect/schema/isLessThanOrEqualToDate\",\n payload: {\n maximum: encoded\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isLessThanOrEqualToDate(${formatDateRuntime(maximum)})`\n })\n };\n }\n});\n/**\n * Validates that a Date is within a specified range. The range boundaries can\n * be inclusive or exclusive based on the provided options.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check does not have a direct JSON Schema equivalent, as JSON Schema\n * validates date strings, not Date objects.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies the specified lower and upper bounds.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isBetweenDate = /*#__PURE__*/makeIsBetween({\n order: Order.Date,\n annotate: options => {\n const exclusiveMinimum = options.exclusiveMinimum ? true : undefined;\n const exclusiveMaximum = options.exclusiveMaximum ? true : undefined;\n const payload = {\n minimum: encodeDatePayload(options.minimum),\n maximum: encodeDatePayload(options.maximum),\n ...(exclusiveMinimum && {\n exclusiveMinimum\n }),\n ...(exclusiveMaximum && {\n exclusiveMaximum\n })\n };\n return {\n representation: {\n id: \"effect/schema/isBetweenDate\",\n payload\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isBetweenDate({ minimum: ${formatDateRuntime(options.minimum)}, maximum: ${formatDateRuntime(options.maximum)}, exclusiveMinimum: ${format(exclusiveMinimum)}, exclusiveMaximum: ${format(exclusiveMaximum)} })`\n })\n };\n }\n});\n/**\n * Validates that a BigInt is greater than the specified value (exclusive).\n *\n * **Details**\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an exclusive lower bound.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isGreaterThanBigInt = /*#__PURE__*/makeIsGreaterThan({\n order: Order.BigInt,\n annotate: exclusiveMinimum => {\n const encoded = exclusiveMinimum.toString(10);\n return {\n representation: {\n id: \"effect/schema/isGreaterThanBigInt\",\n payload: {\n exclusiveMinimum: encoded\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isGreaterThanBigInt(${format(exclusiveMinimum)})`\n })\n };\n }\n});\n/**\n * Validates that a BigInt is greater than or equal to the specified value\n * (inclusive).\n *\n * **Details**\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an inclusive lower bound.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isGreaterThanOrEqualToBigInt = /*#__PURE__*/makeIsGreaterThanOrEqualTo({\n order: Order.BigInt,\n annotate: minimum => {\n const encoded = minimum.toString(10);\n return {\n representation: {\n id: \"effect/schema/isGreaterThanOrEqualToBigInt\",\n payload: {\n minimum: encoded\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isGreaterThanOrEqualToBigInt(${format(minimum)})`\n })\n };\n }\n});\n/**\n * Validates that a BigInt is less than the specified value (exclusive).\n *\n * **Details**\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an exclusive upper bound.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isLessThanBigInt = /*#__PURE__*/makeIsLessThan({\n order: Order.BigInt,\n annotate: exclusiveMaximum => {\n const encoded = exclusiveMaximum.toString(10);\n return {\n representation: {\n id: \"effect/schema/isLessThanBigInt\",\n payload: {\n exclusiveMaximum: encoded\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isLessThanBigInt(${format(exclusiveMaximum)})`\n })\n };\n }\n});\n/**\n * Validates that a BigInt is less than or equal to the specified value\n * (inclusive).\n *\n * **Details**\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies an inclusive upper bound.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isLessThanOrEqualToBigInt = /*#__PURE__*/makeIsLessThanOrEqualTo({\n order: Order.BigInt,\n annotate: maximum => {\n const encoded = maximum.toString(10);\n return {\n representation: {\n id: \"effect/schema/isLessThanOrEqualToBigInt\",\n payload: {\n maximum: encoded\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isLessThanOrEqualToBigInt(${format(maximum)})`\n })\n };\n }\n});\n/**\n * Validates that a BigInt is within a specified range. The range boundaries can\n * be inclusive or exclusive based on the provided options.\n *\n * **Details**\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies the specified lower and upper bounds.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isBetweenBigInt = /*#__PURE__*/makeIsBetween({\n order: Order.BigInt,\n annotate: options => {\n const exclusiveMinimum = options.exclusiveMinimum ? true : undefined;\n const exclusiveMaximum = options.exclusiveMaximum ? true : undefined;\n const payload = {\n minimum: options.minimum.toString(10),\n maximum: options.maximum.toString(10),\n ...(exclusiveMinimum && {\n exclusiveMinimum\n }),\n ...(exclusiveMaximum && {\n exclusiveMaximum\n })\n };\n return {\n representation: {\n id: \"effect/schema/isBetweenBigInt\",\n payload\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isBetweenBigInt({ minimum: ${format(options.minimum)}, maximum: ${format(options.maximum)}, exclusiveMinimum: ${format(exclusiveMinimum)}, exclusiveMaximum: ${format(exclusiveMaximum)} })`\n })\n };\n }\n});\n/**\n * Validates that a value has at least the specified length. Works with strings\n * and arrays.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * For arrays, this check corresponds to `minItems`. For strings, it corresponds\n * to `minLength`. JavaScript counts UTF-16 code units while JSON Schema counts\n * Unicode code points, so the two validations can differ for some strings.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `minLength`\n * constraint to ensure generated strings or arrays have at least the required\n * length.\n *\n * **Example** (Checking minimum length)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const NonEmptyStringSchema = Schema.String.check(Schema.isMinLength(1))\n * const NonEmptyArraySchema = Schema.Array(Schema.Number).check(Schema.isMinLength(1))\n * Schema.is(NonEmptyStringSchema)(\"a\") // => true\n * Schema.is(NonEmptyArraySchema)([1]) // => true\n * ```\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isMinLength(minLength, annotations) {\n minLength = Math.max(0, Math.floor(minLength));\n return makeFilter(input => input.length >= minLength, {\n expected: `a value with a length of at least ${minLength}`,\n representation: {\n id: \"effect/schema/isMinLength\",\n payload: {\n minLength\n }\n },\n toJsonSchema: ({\n type\n }) => type === \"array\" ? {\n minItems: minLength\n } : {\n minLength\n },\n toCode: () => ({\n runtime: `Schema.isMinLength(${minLength})`\n }),\n [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,\n arbitraryConstraint: {\n minLength\n },\n ...annotations\n });\n}\n/**\n * Validates that a value has at least one element. Works with strings and arrays.\n * This is equivalent to `isMinLength(1)`.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to the `minLength: 1` constraint for strings or the\n * `minItems: 1` constraint for arrays in JSON Schema.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `minLength: 1`\n * constraint to ensure generated strings or arrays are non-empty.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isNonEmpty(annotations) {\n return isMinLength(1, annotations);\n}\n/**\n * Validates that a value has at most the specified length. Works with strings\n * and arrays.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to the `maxLength` constraint for strings or the\n * `maxItems` constraint for arrays in JSON Schema.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a `maxLength`\n * constraint to ensure generated strings or arrays have at most the required\n * length.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isMaxLength(maxLength, annotations) {\n maxLength = Math.max(0, Math.floor(maxLength));\n return makeFilter(input => input.length <= maxLength, {\n expected: `a value with a length of at most ${maxLength}`,\n representation: {\n id: \"effect/schema/isMaxLength\",\n payload: {\n maxLength\n }\n },\n toJsonSchema: ({\n type\n }) => type === \"array\" ? {\n maxItems: maxLength\n } : {\n maxLength\n },\n toCode: () => ({\n runtime: `Schema.isMaxLength(${maxLength})`\n }),\n [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,\n arbitraryConstraint: {\n maxLength\n },\n ...annotations\n });\n}\n/**\n * Validates that a value's length is within the specified range. Works with\n * strings and arrays.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * For arrays, this check corresponds to `minItems` and `maxItems`. For strings,\n * it corresponds to `minLength` and `maxLength`. JavaScript counts UTF-16 code\n * units while JSON Schema counts Unicode code points, so the two validations\n * can differ for some strings.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies `minLength` and\n * `maxLength` constraints to ensure generated strings or arrays have a length\n * within the specified range.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isLengthBetween(minimum, maximum, annotations) {\n minimum = Math.max(0, Math.floor(minimum));\n maximum = Math.max(0, Math.floor(maximum));\n return makeFilter(input => input.length >= minimum && input.length <= maximum, {\n expected: minimum === maximum ? `a value with a length of ${minimum}` : `a value with a length between ${minimum} and ${maximum}`,\n representation: {\n id: \"effect/schema/isLengthBetween\",\n payload: {\n minimum,\n maximum\n }\n },\n toJsonSchema: ({\n type\n }) => type === \"array\" ? {\n allOf: [{\n minItems: minimum\n }, {\n maxItems: maximum\n }]\n } : {\n allOf: [{\n minLength: minimum\n }, {\n maxLength: maximum\n }]\n },\n toCode: () => ({\n runtime: `Schema.isLengthBetween(${minimum}, ${maximum})`\n }),\n [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,\n arbitraryConstraint: {\n minLength: minimum,\n maxLength: maximum\n },\n ...annotations\n });\n}\n/**\n * Validates that a value has at least the specified size. Works with values\n * that have a `size` property, such as `Set` or `Map`.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check does not have a direct JSON Schema equivalent, as it applies to\n * values with a `size` property rather than standard JSON Schema types.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a node-local `minSize` constraint.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isMinSize(minSize, annotations) {\n minSize = Math.max(0, Math.floor(minSize));\n return makeFilter(input => input.size >= minSize, {\n expected: `a value with a size of at least ${minSize}`,\n representation: {\n id: \"effect/schema/isMinSize\",\n payload: {\n minSize\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isMinSize(${minSize})`\n }),\n [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,\n arbitraryConstraint: {\n minSize\n },\n ...annotations\n });\n}\n/**\n * Validates that a value has at most the specified size. Works with values\n * that have a `size` property, such as `Set` or `Map`.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check does not have a direct JSON Schema equivalent, as it applies to\n * values with a `size` property rather than standard JSON Schema types.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a node-local `maxSize` constraint.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isMaxSize(maxSize, annotations) {\n maxSize = Math.max(0, Math.floor(maxSize));\n return makeFilter(input => input.size <= maxSize, {\n expected: `a value with a size of at most ${maxSize}`,\n representation: {\n id: \"effect/schema/isMaxSize\",\n payload: {\n maxSize\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isMaxSize(${maxSize})`\n }),\n [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,\n arbitraryConstraint: {\n maxSize\n },\n ...annotations\n });\n}\n/**\n * Validates that a value's size is within the specified range. Works with\n * values that have a `size` property, such as `Set` or `Map`.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check does not have a direct JSON Schema equivalent, as it applies to\n * values with a `size` property rather than standard JSON Schema types.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies node-local `minSize` and `maxSize` constraints.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isSizeBetween(minimum, maximum, annotations) {\n minimum = Math.max(0, Math.floor(minimum));\n maximum = Math.max(0, Math.floor(maximum));\n return makeFilter(input => input.size >= minimum && input.size <= maximum, {\n expected: minimum === maximum ? `a value with a size of ${minimum}` : `a value with a size between ${minimum} and ${maximum}`,\n representation: {\n id: \"effect/schema/isSizeBetween\",\n payload: {\n minimum,\n maximum\n }\n },\n toJsonSchema: () => ({}),\n toCode: () => ({\n runtime: `Schema.isSizeBetween(${minimum}, ${maximum})`\n }),\n [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,\n arbitraryConstraint: {\n minSize: minimum,\n maxSize: maximum\n },\n ...annotations\n });\n}\n/**\n * Validates that an object contains at least the specified number of\n * properties. This includes both string and symbol keys when counting\n * properties.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to `minProperties` in JSON Schema. Effect applies the\n * check to the decoded object, while JSON Schema applies it to the original\n * input. Defaults and property transformations can therefore produce different\n * results.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a node-local `minProperties` constraint.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isMinProperties(minProperties, annotations) {\n minProperties = Math.max(0, Math.floor(minProperties));\n return makeFilter(input => Reflect.ownKeys(input).length >= minProperties, {\n expected: `a value with at least ${minProperties === 1 ? \"1 entry\" : `${minProperties} entries`}`,\n representation: {\n id: \"effect/schema/isMinProperties\",\n payload: {\n minProperties\n }\n },\n toJsonSchema: () => ({\n minProperties\n }),\n toCode: () => ({\n runtime: `Schema.isMinProperties(${minProperties})`\n }),\n [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,\n arbitraryConstraint: {\n minProperties\n },\n ...annotations\n });\n}\n/**\n * Validates that an object contains at most the specified number of properties.\n * This includes both string and symbol keys when counting properties.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to `maxProperties` in JSON Schema. Effect applies the\n * check to the decoded object, while JSON Schema applies it to the original\n * input. Excess-property handling and property transformations can therefore\n * produce different results.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies a node-local `maxProperties` constraint.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isMaxProperties(maxProperties, annotations) {\n maxProperties = Math.max(0, Math.floor(maxProperties));\n return makeFilter(input => Reflect.ownKeys(input).length <= maxProperties, {\n expected: `a value with at most ${maxProperties === 1 ? \"1 entry\" : `${maxProperties} entries`}`,\n representation: {\n id: \"effect/schema/isMaxProperties\",\n payload: {\n maxProperties\n }\n },\n toJsonSchema: () => ({\n maxProperties\n }),\n toCode: () => ({\n runtime: `Schema.isMaxProperties(${maxProperties})`\n }),\n [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,\n arbitraryConstraint: {\n maxProperties\n },\n ...annotations\n });\n}\n/**\n * Validates that an object contains between `minimum` and `maximum` properties (inclusive).\n * This includes both string and symbol keys when counting properties.\n *\n * **Details**\n *\n * JSON Schema:\n *\n * This check corresponds to `minProperties` and `maxProperties` in JSON\n * Schema. Effect applies the check to the decoded object, while JSON Schema\n * applies it to the original input. Defaults, excess-property handling, and\n * property transformations can therefore produce different results.\n *\n * Arbitrary:\n *\n * During arbitrary generation, this applies node-local `minProperties` and `maxProperties` constraints.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isPropertiesLengthBetween(minimum, maximum, annotations) {\n minimum = Math.max(0, Math.floor(minimum));\n maximum = Math.max(0, Math.floor(maximum));\n return makeFilter(input => Reflect.ownKeys(input).length >= minimum && Reflect.ownKeys(input).length <= maximum, {\n expected: minimum === maximum ? `a value with exactly ${minimum === 1 ? \"1 entry\" : `${minimum} entries`}` : `a value with between ${minimum} and ${maximum} entries`,\n representation: {\n id: \"effect/schema/isPropertiesLengthBetween\",\n payload: {\n minimum,\n maximum\n }\n },\n toJsonSchema: () => ({\n minProperties: minimum,\n maxProperties: maximum\n }),\n toCode: () => ({\n runtime: `Schema.isPropertiesLengthBetween(${minimum}, ${maximum})`\n }),\n [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,\n arbitraryConstraint: {\n minProperties: minimum,\n maxProperties: maximum\n },\n ...annotations\n });\n}\n/**\n * Validates that every own property key of an object satisfies the encoded side\n * of the provided key schema.\n *\n * **Details**\n *\n * This check uses `Reflect.ownKeys`, so symbol keys are validated in addition to\n * string property names.\n *\n * JSON Schema:\n * This check corresponds to `propertyNames` in JSON Schema. Effect checks the\n * decoded object's keys, including symbols, while JSON Schema checks the string\n * names in the original input. Property transformations and excess-property\n * handling can therefore produce different results.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isPropertyNames(keySchema, annotations) {\n const propertyNames = toEncoded(keySchema);\n const parser = SchemaParser._issue(propertyNames.ast);\n return makeFilter((input, ast, options) => {\n const keys = Reflect.ownKeys(input);\n const issues = [];\n for (const key of keys) {\n const issue = parser(key, options);\n if (issue !== undefined) {\n issues.push(new SchemaIssue.Pointer([key], issue));\n if (options.errors === \"first\") break;\n }\n }\n if (Arr.isArrayNonEmpty(issues)) {\n return new SchemaIssue.Composite(ast, issues, input, options);\n }\n return true;\n }, {\n expected: \"an object with property names matching the schema\",\n representation: {\n id: \"effect/schema/isPropertyNames\",\n payload: null,\n schemas: [propertyNames.ast]\n },\n toJsonSchema: ({\n schemas\n }) => ({\n propertyNames: schemas[0]\n }),\n toCode: ({\n schemas\n }) => ({\n runtime: `Schema.isPropertyNames(${schemas[0].runtime})`\n }),\n [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,\n ...annotations\n });\n}\n/**\n * Validates that all items in an array are unique according to Effect equality.\n *\n * **Details**\n *\n * JSON Schema:\n * This check corresponds to the `uniqueItems: true` constraint in JSON Schema.\n *\n * Arbitrary:\n * During arbitrary generation, this applies a node-local identity selector\n * for constructive uniqueness using Effect equality.\n *\n * @category validation\n * @since 4.0.0\n */\nexport function isUnique(annotations) {\n return makeFilter(input => Arr.dedupe(input).length === input.length, {\n expected: \"an array with unique items\",\n representation: {\n id: \"effect/schema/isUnique\",\n payload: null\n },\n toJsonSchema: () => ({\n uniqueItems: true\n }),\n toCode: () => ({\n runtime: \"Schema.isUnique()\"\n }),\n arbitraryConstraint: {\n uniqueBy: identity\n },\n ...annotations\n });\n}\n/**\n * Validates that all first elements in an array of key-value tuples are unique according to Effect equality.\n *\n * **Details**\n *\n * Arbitrary:\n * During arbitrary generation, this projects each entry to its key for constructive uniqueness.\n *\n * JSON Schema:\n * JSON Schema has no equivalent constraint, so this check is omitted from generated documents.\n *\n * @see {@link isUnique} for validating uniqueness of complete array elements\n * @category validation\n * @since 4.0.0\n */\nexport function isUniqueKey(annotations) {\n return makeFilter(input => Arr.dedupe(input.map(([key]) => key)).length === input.length, {\n expected: \"an array with unique keys\",\n representation: {\n id: \"effect/schema/isUniqueKey\",\n payload: null\n },\n toCode: () => ({\n runtime: \"Schema.isUniqueKey()\"\n }),\n arbitraryConstraint: {\n uniqueBy: entry => entry[0]\n },\n ...annotations\n });\n}\n/**\n * Schema for non-empty strings. Validates that a string has at least one\n * character.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const NonEmptyString = /*#__PURE__*/String.check(/*#__PURE__*/isNonEmpty());\n/**\n * Schema for strings whose JavaScript `length` is exactly `1`.\n *\n * **When to use**\n *\n * Use to validate string values that must have `length === 1`.\n *\n * **Gotchas**\n *\n * This schema uses JavaScript `String.length`, so visible characters made from\n * multiple UTF-16 code units do not satisfy `length === 1`.\n *\n * @see {@link String} for unconstrained string values\n * @see {@link NonEmptyString} for strings with length greater than zero\n * @see {@link isLengthBetween} for the underlying length check\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const Char = /*#__PURE__*/String.check(/*#__PURE__*/isLengthBetween(1, 1));\nconst getErrorOptionsKey = options => (options?.includeStack === true ? 1 : 0) | (options?.excludeCause === true ? 2 : 0);\nconst getErrorOptions = key => {\n switch (key) {\n case 0:\n return undefined;\n case 1:\n return {\n includeStack: true\n };\n case 2:\n return {\n excludeCause: true\n };\n case 3:\n return {\n includeStack: true,\n excludeCause: true\n };\n }\n};\nconst errorSchemaCache = [];\n/**\n * Schema for JavaScript `Error` objects.\n *\n * **Details**\n *\n * Default JSON serializer:\n *\n * Encodes an `Error` as an object with `message`, optional `name`, and optional\n * `cause` properties, and decodes that object back into an `Error`. Stack\n * traces are omitted by default for security. Pass `{ includeStack: true }` to\n * include stack traces, or `{ excludeCause: true }` to omit causes.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport function ErrorInstance(options) {\n const key = getErrorOptionsKey(options);\n const cached = errorSchemaCache[key];\n if (cached !== undefined) {\n return cached;\n }\n const normalizedOptions = getErrorOptions(key);\n const schema = instanceOf(globalThis.Error, {\n representation: {\n id: \"effect/schema/Error\",\n payload: normalizedOptions ?? null\n },\n toCode: () => ({\n runtime: normalizedOptions !== undefined ? `Schema.ErrorInstance(${format(normalizedOptions)})` : `Schema.ErrorInstance()`,\n Type: `globalThis.Error`\n }),\n expected: \"Error\",\n toCodecJson: () => link()(JsonError, SchemaTransformation.errorFromJsonError(normalizedOptions))\n });\n errorSchemaCache[key] = schema;\n return schema;\n}\nconst defectSchemaCache = [];\n/**\n * Schema for unexpected defect values represented as `unknown` with a JSON\n * encoded form.\n *\n * **When to use**\n *\n * Use when you need a schema for `Cause` defects or other unexpected failures\n * whose runtime value may be any value.\n *\n * **Details**\n *\n * The encoded side is {@link Json}. During decoding, JSON objects with a string\n * `message` property are decoded into JavaScript `Error` values, preserving a\n * non-default `name` and any string `stack`. Other JSON values decode\n * unchanged.\n *\n * During encoding, JavaScript `Error` values encode to JSON objects with\n * `name`, `message`, and optional `cause` properties. Pass\n * `{ includeStack: true }` to include string stack traces in encoded `Error`\n * defects, or `{ excludeCause: true }` to omit causes. Other values are\n * serialized through Effect's JSON formatter and then parsed back into JSON\n * when possible.\n *\n * **Gotchas**\n *\n * This schema is for carrying defects across JSON boundaries, not for\n * preserving every JavaScript value exactly. Some values cannot round-trip\n * unchanged:\n *\n * - A non-`Error` object such as `{ message: \"boom\" }` encodes as an\n * error-shaped JSON object and decodes back as an `Error`.\n * - JSON serialization normalizes unsupported values. For example,\n * `undefined` array elements encode as `null`, unsupported object properties\n * are omitted, and circular references are dropped.\n * - Values that cannot be represented as JSON fall back to Effect's formatted\n * string representation.\n *\n * @see {@link ErrorInstance} for a schema that only accepts JavaScript `Error` values.\n * @category schemas\n * @since 4.0.0\n */\nexport function Defect(options) {\n const key = getErrorOptionsKey(options);\n const cached = defectSchemaCache[key];\n if (cached !== undefined) {\n return cached;\n }\n const schema = Json.pipe(decodeTo(Unknown, SchemaTransformation.defectFromJson(getErrorOptions(key))));\n defectSchemaCache[key] = schema;\n return schema;\n}\n/**\n * Schema for readonly maps whose keys and values conform to the provided\n * schemas.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function ReadonlyMap(key, value) {\n const schema = declareConstructor()([key, value], ([key, value]) => {\n const array = ArraySchema(Tuple([key, value]));\n return (input, ast, options) => {\n if (input instanceof globalThis.Map) {\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(array)([...input], options), {\n onSuccess: array => new globalThis.Map(array),\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"entries\", issue, input, options)\n });\n }\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n };\n }, {\n representation: {\n id: \"effect/schema/ReadonlyMap\",\n payload: null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.ReadonlyMap(${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,\n Type: `globalThis.ReadonlyMap<${typeParameters[0].Type}, ${typeParameters[1].Type}>`\n }),\n expected: \"ReadonlyMap\",\n toCodec: ([key, value]) => link()(ArraySchema(Tuple([key, value])), SchemaTransformation.transform({\n decode: entries => new globalThis.Map(entries),\n encode: map => [...map.entries()]\n }))\n });\n return make(schema.ast, {\n key,\n value\n });\n}\n/**\n * Schema for readonly sets whose values conform to the provided element schema.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function ReadonlySet(value) {\n const schema = declareConstructor()([value], ([value]) => {\n const array = ArraySchema(value);\n return (input, ast, options) => {\n if (input instanceof globalThis.Set) {\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(array)([...input], options), {\n onSuccess: array => new globalThis.Set(array),\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"values\", issue, input, options)\n });\n }\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n };\n }, {\n representation: {\n id: \"effect/schema/ReadonlySet\",\n payload: null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.ReadonlySet(${typeParameters[0].runtime})`,\n Type: `globalThis.ReadonlySet<${typeParameters[0].Type}>`\n }),\n expected: \"ReadonlySet\",\n toCodec: ([value]) => link()(ArraySchema(value), SchemaTransformation.transform({\n decode: values => new globalThis.Set(values),\n encode: set => [...set.values()]\n }))\n });\n return make(schema.ast, {\n value\n });\n}\n/**\n * Schema for JavaScript `RegExp` objects.\n *\n * **Details**\n *\n * The default JSON serializer encodes a `RegExp` as `{ source, flags }`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const RegExp = /*#__PURE__*/instanceOf(globalThis.RegExp, {\n representation: {\n id: \"effect/schema/RegExp\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.RegExp`,\n Type: `globalThis.RegExp`\n }),\n expected: \"RegExp\",\n toCodecJson: () => link()(Struct({\n source: String,\n flags: String\n }), SchemaTransformation.transformEffect({\n decode: (e, options) => Effect.try({\n try: () => new globalThis.RegExp(e.source, e.flags),\n catch: () => new SchemaIssue.InvalidValue({\n expected: \"valid RegExp source and flags\"\n }, e, options)\n }),\n encode: regExp => Effect.succeed({\n source: regExp.source,\n flags: regExp.flags\n })\n }))\n});\nconst URLString = /*#__PURE__*/String.annotate({\n expected: \"a string that will be decoded as a URL\"\n});\n/**\n * Schema for JavaScript `URL` objects.\n *\n * **Details**\n *\n * Default JSON serializer:\n *\n * - encodes `URL` as a `string`\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const URL = /*#__PURE__*/instanceOf(globalThis.URL, {\n representation: {\n id: \"effect/schema/URL\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.URL`,\n Type: `globalThis.URL`\n }),\n expected: \"URL\",\n toCodecJson: () => link()(URLString, SchemaTransformation.urlFromString)\n});\n/**\n * Schema that decodes a `string` into a `URL`.\n *\n * **Details**\n *\n * Decoding:\n * - A **valid** URL `string` is decoded as a `URL`\n *\n * Encoding:\n * - A `URL` is encoded as a `string`\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const URLFromString = /*#__PURE__*/URLString.pipe(/*#__PURE__*/decodeTo(URL, SchemaTransformation.urlFromString));\nconst DateString = /*#__PURE__*/String.annotate({\n expected: \"a string that will be decoded as a Date\"\n});\n/**\n * Schema for valid JavaScript `Date` objects.\n *\n * **When to use**\n *\n * Use to validate in-memory values that must already be valid JavaScript date\n * objects.\n *\n * **Details**\n *\n * This schema accepts `Date` instances whose timestamp is not `NaN`. The\n * default JSON serializer encodes dates as ISO 8601 strings.\n *\n * **Example** (Defining a Date schema)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const date = Schema.decodeUnknownSync(Schema.Date)(new Date(\"2024-01-01\"))\n * date.toISOString() // => \"2024-01-01T00:00:00.000Z\"\n * ```\n *\n * @see {@link DateFromString} for decoding strings into Date instances\n * @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const Date = /*#__PURE__*/declare(input => input instanceof globalThis.Date && !globalThis.Number.isNaN(input.getTime()), {\n representation: {\n id: \"effect/schema/Date\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.Date`,\n Type: `globalThis.Date`\n }),\n expected: \"a valid Date\",\n toCodecJson: () => link()(DateString, SchemaTransformation.dateFromString)\n});\n/**\n * Schema that decodes a string into a JavaScript `Date`.\n *\n * **When to use**\n *\n * Use to model string-encoded dates that decode to JavaScript `Date` objects\n * and encode back to strings.\n *\n * **Details**\n *\n * Decoding:\n * The string is passed to JavaScript `Date` construction.\n *\n * Encoding:\n * A `Date` is encoded as an ISO string.\n *\n * Invalid date strings fail decoding.\n *\n * @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances\n * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values\n * @see {@link Date} for accepting Date instances directly\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const DateFromString = /*#__PURE__*/DateString.pipe(/*#__PURE__*/decodeTo(Date, SchemaTransformation.dateFromString));\n/**\n * Schema that decodes epoch milliseconds into a JavaScript `Date`.\n *\n * **When to use**\n *\n * Use to model numeric millisecond timestamps that decode to JavaScript `Date`\n * objects and encode back to numbers.\n *\n * **Details**\n *\n * Decoding:\n * A safe integer number of milliseconds since the Unix epoch is decoded as a\n * `Date`.\n *\n * Encoding:\n * A `Date` is encoded as its millisecond timestamp.\n *\n * **Gotchas**\n *\n * JavaScript `Date` supports a narrower range than safe integers, so integers\n * outside the supported `Date` range fail decoding.\n *\n * @see {@link DateFromString} for decoding string-encoded dates\n * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const DateFromMillis = /*#__PURE__*/Int.pipe(/*#__PURE__*/decodeTo(Date, SchemaTransformation.dateFromMillis));\nconst JsonString = /*#__PURE__*/String.annotate({\n expected: \"a string that will be decoded as JSON\",\n contentMediaType: \"application/json\"\n});\n/**\n * Returns a schema that decodes a JSON string and then decodes the parsed value\n * using the given schema.\n *\n * **Details**\n *\n * This is useful when working with JSON-encoded strings where the actual\n * structure of the value is known and described by an existing schema.\n *\n * During decoding, the resulting schema first parses the input string as JSON,\n * using `reviver` when provided, and then runs the provided schema on the\n * parsed result. During encoding, it first encodes with the provided schema and\n * then passes the result to `JSON.stringify` with the optional `replacer` and\n * `space`.\n *\n * **Example** (Formatting encoded JSON)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.Struct({ a: Schema.Number })\n * const schemaFromJsonString = Schema.fromJsonString(schema, { space: 2 })\n *\n * Schema.encodeSync(schemaFromJsonString)({ a: 1 }) // => \"{\\n \\\"a\\\": 1\\n}\"\n * ```\n *\n * @category schemas\n * @since 4.0.0\n */\nexport function fromJsonString(schema, options) {\n return JsonString.pipe(decodeTo(schema, SchemaTransformation.fromJsonString(options)));\n}\n/** @internal */\nexport const UnknownFromJsonString = /*#__PURE__*/fromJsonString(Unknown);\n/**\n * Schema for JavaScript `File` objects.\n *\n * **Details**\n *\n * The default JSON serializer encodes a `File` as `{ data, type, name, lastModified }`\n * where `data` is base64-encoded.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const File = /*#__PURE__*/instanceOf(globalThis.File, {\n representation: {\n id: \"effect/schema/File\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.File`,\n Type: `globalThis.File`\n }),\n expected: \"File\",\n toCodecJson: () => link()(Struct({\n data: String.check(isBase64()),\n type: String,\n name: String,\n lastModified: Int\n }), SchemaTransformation.transformEffect({\n decode: (e, options) => Result_.match(Encoding.decodeBase64(e.data), {\n onFailure: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid Base64 string\"\n }, e.data, options)),\n onSuccess: bytes => {\n const buffer = new globalThis.Uint8Array(bytes);\n return Effect.succeed(new globalThis.File([buffer], e.name, {\n type: e.type,\n lastModified: e.lastModified\n }));\n }\n }),\n encode: (file, options) => Effect.tryPromise({\n try: async () => {\n const bytes = new globalThis.Uint8Array(await file.arrayBuffer());\n return {\n data: Encoding.encodeBase64(bytes),\n type: file.type,\n name: file.name,\n lastModified: file.lastModified\n };\n },\n catch: () => new SchemaIssue.InvalidValue({\n expected: \"a readable File\"\n }, file, options)\n })\n }))\n});\n/**\n * Schema for JavaScript `FormData` objects.\n *\n * **Details**\n *\n * The default JSON serializer encodes a `FormData` as an array of `[key, entry]`\n * pairs where each entry is tagged as `\"String\"` or `\"File\"`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const FormData = /*#__PURE__*/instanceOf(globalThis.FormData, {\n representation: {\n id: \"effect/schema/FormData\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.FormData`,\n Type: `globalThis.FormData`\n }),\n expected: \"FormData\",\n toCodecJson: () => link()(ArraySchema(Tuple([String, Union([Struct({\n _tag: tag(\"String\"),\n value: String\n }), Struct({\n _tag: tag(\"File\"),\n value: File\n })])])), SchemaTransformation.transformEffect({\n decode: e => {\n const out = new globalThis.FormData();\n for (const [key, entry] of e) {\n out.append(key, entry.value);\n }\n return Effect.succeed(out);\n },\n encode: formData => {\n return Effect.succeed(globalThis.Array.from(formData.entries()).map(([key, value]) => {\n if (typeof value === \"string\") {\n return [key, {\n _tag: \"String\",\n value\n }];\n } else {\n return [key, {\n _tag: \"File\",\n value\n }];\n }\n }));\n }\n }))\n});\n/**\n * Schema for decoding `FormData` through a bracket-notation tree.\n *\n * **When to use**\n *\n * Use to decode browser or multipart form data into a structured schema value.\n *\n * **Details**\n *\n * The decoding process has two steps:\n *\n * 1. Parse `FormData` into a nested tree record.\n * 2. Decode the parsed value with the given schema.\n *\n * You can express nested values using bracket notation.\n *\n * If you want to decode string fields into non-string primitive values, use\n * `Schema.toCodecStringTree`.\n *\n * **Example** (Decoding a flat structure)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.fromFormData(\n * Schema.Struct({\n * a: Schema.String\n * })\n * )\n *\n * const formData = new FormData()\n * formData.append(\"a\", \"1\")\n * formData.append(\"b\", \"2\")\n *\n * Schema.decodeUnknownSync(schema)(formData) // => { a: \"1\" }\n * ```\n *\n * **Example** (Decoding nested fields)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.fromFormData(\n * Schema.Struct({\n * a: Schema.String,\n * b: Schema.Struct({\n * c: Schema.String,\n * d: Schema.String\n * })\n * })\n * )\n *\n * const formData = new FormData()\n * formData.append(\"a\", \"1\")\n * formData.append(\"b[c]\", \"2\")\n * formData.append(\"b[d]\", \"3\")\n *\n * Schema.decodeUnknownSync(schema)(formData) // => { a: \"1\", b: { c: \"2\", d: \"3\" } }\n * ```\n *\n * **Example** (Parsing non-string values)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.fromFormData(\n * Schema.toCodecStringTree(\n * Schema.Struct({\n * a: Schema.Int\n * })\n * )\n * )\n *\n * const formData = new FormData()\n * formData.append(\"a\", \"1\")\n *\n * Schema.decodeUnknownSync(schema)(formData) // => { a: 1 }\n * ```\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function fromFormData(schema) {\n return FormData.pipe(decodeTo(schema, SchemaTransformation.fromFormData));\n}\n/**\n * Schema for JavaScript `URLSearchParams` objects.\n *\n * **Details**\n *\n * The default JSON serializer encodes a `URLSearchParams` as a query string.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const URLSearchParams = /*#__PURE__*/instanceOf(globalThis.URLSearchParams, {\n representation: {\n id: \"effect/schema/URLSearchParams\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.URLSearchParams`,\n Type: `globalThis.URLSearchParams`\n }),\n expected: \"URLSearchParams\",\n toCodecJson: () => link()(String.annotate({\n expected: \"a query string that will be decoded as URLSearchParams\"\n }), SchemaTransformation.transform({\n decode: e => new globalThis.URLSearchParams(e),\n encode: params => params.toString()\n }))\n});\n/**\n * Schema for decoding `URLSearchParams` through a bracket-notation tree.\n *\n * **When to use**\n *\n * Use to decode query parameters into a structured schema value.\n *\n * **Details**\n *\n * The decoding process has two steps:\n *\n * 1. Parse `URLSearchParams` into a nested tree record.\n * 2. Decode the parsed value with the given schema.\n *\n * You can express nested values using bracket notation.\n *\n * If you want to decode values that are not strings, use\n * `Schema.toCodecStringTree`. This serializer preserves values such as\n * numbers when compatible with the schema.\n *\n * **Example** (Decoding a flat structure)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.fromURLSearchParams(\n * Schema.Struct({\n * a: Schema.String\n * })\n * )\n *\n * const urlSearchParams = new URLSearchParams(\"a=1&b=2\")\n *\n * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: \"1\" }\n * ```\n *\n * **Example** (Decoding nested fields)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.fromURLSearchParams(\n * Schema.Struct({\n * a: Schema.String,\n * b: Schema.Struct({\n * c: Schema.String,\n * d: Schema.String\n * })\n * })\n * )\n *\n * const urlSearchParams = new URLSearchParams(\"a=1&b[c]=2&b[d]=3\")\n *\n * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: \"1\", b: { c: \"2\", d: \"3\" } }\n * ```\n *\n * **Example** (Parsing non-string values)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const schema = Schema.fromURLSearchParams(\n * Schema.toCodecStringTree(\n * Schema.Struct({\n * a: Schema.Int\n * })\n * )\n * )\n *\n * const urlSearchParams = new URLSearchParams(\"a=1&b=2\")\n *\n * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: 1 }\n * ```\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function fromURLSearchParams(schema) {\n return URLSearchParams.pipe(decodeTo(schema, SchemaTransformation.fromURLSearchParams));\n}\n/**\n * Schema that parses a string into a `number` using JavaScript\n * number coercion.\n *\n * **Details**\n *\n * Decoding:\n * A `string` is decoded as a number, including possible non-finite values such as\n * `NaN`, `Infinity`, and `-Infinity`. Use `FiniteFromString` to reject non-finite\n * numbers.\n *\n * Encoding:\n * A number is encoded as a `string`.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const NumberFromString = /*#__PURE__*/String.annotate({\n expected: \"a string that will be decoded as a number\"\n}).pipe(/*#__PURE__*/decodeTo(Number, SchemaTransformation.numberFromString));\n/**\n * Schema that parses a string into a finite number.\n *\n * **Details**\n *\n * Decoding:\n * - A `string` is decoded as a finite number, rejecting `NaN`, `Infinity`, and\n * `-Infinity` values.\n *\n * Encoding:\n * - A finite number is encoded as a `string`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const FiniteFromString = /*#__PURE__*/String.annotate({\n expected: \"a string that will be decoded as a finite number\"\n}).pipe(/*#__PURE__*/decodeTo(Finite, SchemaTransformation.numberFromString));\n/**\n * Schema that parses a string into a `bigint`.\n *\n * **When to use**\n *\n * Use to parse signed base-10 integer strings into bigint values while encoding\n * bigint values back to decimal strings.\n *\n * **Details**\n *\n * Decoding:\n * - A `string` is decoded as a `bigint`.\n *\n * Encoding:\n * - A `bigint` is encoded as a `string`.\n *\n * **Gotchas**\n *\n * Decoding accepts only strings matching `^-?\\d+$`.\n *\n * @see {@link isStringBigInt} for the string predicate used by this schema\n * @see {@link BigInt} for validating values that are already bigint values\n * @see {@link NumberFromString} for parsing JavaScript number strings, including non-finite values\n * @see {@link BigDecimalFromString} for parsing decimal number strings\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const BigIntFromString = /*#__PURE__*/make(SchemaAST.bigIntString).pipe(/*#__PURE__*/decodeTo(BigInt, SchemaTransformation.bigintFromString));\n/**\n * Schema for strings that contains no leading or trailing whitespaces.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const Trimmed = /*#__PURE__*/String.check(/*#__PURE__*/isTrimmed());\n/**\n * Schema that trims whitespace from a string.\n *\n * **Details**\n *\n * Decoding:\n * - A `string` is decoded as a string with no leading or trailing whitespaces.\n *\n * Encoding:\n * - The trimmed string is encoded as is.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const Trim = /*#__PURE__*/String.annotate({\n expected: \"a string that will be decoded as a trimmed string\"\n}).pipe(/*#__PURE__*/decodeTo(Trimmed, /*#__PURE__*/SchemaTransformation.trim()));\n/**\n * Decodes a base64 (RFC4648) encoded string into a UTF-8 string.\n *\n * **Details**\n *\n * Decoding:\n * - A **valid** base64 encoded string is decoded as a UTF-8 `string`.\n *\n * Encoding:\n * - A `string` is encoded as a base64-encoded string.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const StringFromBase64 = /*#__PURE__*/String.annotate({\n expected: \"a base64 encoded string that will be decoded as a UTF-8 string\"\n}).pipe(/*#__PURE__*/decodeTo(String, SchemaTransformation.stringFromBase64String));\n/**\n * Decodes a base64 (URL) encoded string into a UTF-8 string.\n *\n * **Details**\n *\n * Decoding:\n * - A **valid** base64 (URL) encoded string is decoded as a UTF-8 `string`.\n *\n * Encoding:\n * - A `string` is encoded as a base64 (URL) encoded string.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const StringFromBase64Url = /*#__PURE__*/String.annotate({\n expected: \"a base64 (URL) encoded string that will be decoded as a UTF-8 string\"\n}).pipe(/*#__PURE__*/decodeTo(String, SchemaTransformation.stringFromBase64UrlString));\n/**\n * Decodes a hex encoded string into a UTF-8 string.\n *\n * **Details**\n *\n * Decoding:\n * - A **valid** hex encoded string is decoded as a UTF-8 `string`.\n *\n * Encoding:\n * - A `string` is encoded as a hex string.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const StringFromHex = /*#__PURE__*/String.annotate({\n expected: \"a hex encoded string that will be decoded as a UTF-8 string\"\n}).pipe(/*#__PURE__*/decodeTo(String, SchemaTransformation.stringFromHexString));\n/**\n * Decodes a URI component encoded string into a UTF-8 string.\n * Can be used to store data in a URL.\n *\n * **Details**\n *\n * Decoding:\n * - A **valid** URI component encoded string is decoded as a UTF-8 `string`.\n *\n * Encoding:\n * - A `string` is encoded as a URI component encoded string.\n *\n * **Example** (Decoding URI component strings)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const PaginationSchema = Schema.Struct({\n * maxItemPerPage: Schema.Number,\n * page: Schema.Number\n * })\n *\n * const UrlSchema = Schema.StringFromUriComponent.pipe(\n * Schema.decodeTo(Schema.fromJsonString(PaginationSchema))\n * )\n *\n * Schema.encodeSync(UrlSchema)({ maxItemPerPage: 10, page: 1 }) // => \"%7B%22maxItemPerPage%22%3A10%2C%22page%22%3A1%7D\"\n * ```\n *\n * @category schemas\n * @since 3.12.0\n */\nexport const StringFromUriComponent = /*#__PURE__*/String.annotate({\n expected: \"a URI component encoded string that will be decoded as a UTF-8 string\"\n}).pipe(/*#__PURE__*/decodeTo(String, SchemaTransformation.stringFromUriComponent));\n/**\n * Schema for property keys accepted by Effect schemas: finite `number`,\n * `symbol`, or `string`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const PropertyKey = /*#__PURE__*/Union([Finite, Symbol, String]);\n/**\n * Schema for a Standard Schema v1 failure result.\n *\n * **Details**\n *\n * The result contains an `issues` array where each issue has a message and an\n * optional path made of property keys or keyed path segments.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const StandardSchemaV1FailureResult = /*#__PURE__*/Struct({\n issues: /*#__PURE__*/ArraySchema(/*#__PURE__*/Struct({\n message: String,\n path: /*#__PURE__*/optional(/*#__PURE__*/ArraySchema(/*#__PURE__*/Union([PropertyKey, /*#__PURE__*/Struct({\n key: PropertyKey\n })])))\n }))\n});\n/**\n * Schema for a boolean parsed from 0 or 1.\n *\n * **When to use**\n *\n * Use when decoding data sources that represent booleans as `0 | 1` while\n * keeping boolean values in the decoded model.\n *\n * **Details**\n *\n * Decoding accepts only `0 | 1`, maps `1` to `true`, and maps `0` to `false`.\n * Encoding maps `true` to `1` and `false` to `0`.\n *\n * @see {@link Boolean} for validating values that are already booleans\n * @see {@link Literals} for keeping bit literals instead of decoding them\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const BooleanFromBit = /*#__PURE__*/Literals([0, 1]).pipe(/*#__PURE__*/decodeTo(Boolean, /*#__PURE__*/SchemaTransformation.transform({\n decode: bit => bit === 1,\n encode: bool => bool ? 1 : 0\n})));\nconst Base64String = /*#__PURE__*/String.annotate({\n expected: \"a base64 encoded string that will be decoded as Uint8Array\",\n format: \"byte\",\n contentEncoding: \"base64\"\n});\n/**\n * Schema for JavaScript `Uint8Array` objects.\n *\n * **Details**\n *\n * Default JSON serializer:\n *\n * The default JSON serializer encodes Uint8Array as a Base64 encoded string.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const Uint8Array = /*#__PURE__*/instanceOf(globalThis.Uint8Array, {\n representation: {\n id: \"effect/schema/Uint8Array\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.Uint8Array`,\n Type: `globalThis.Uint8Array`\n }),\n expected: \"Uint8Array\",\n toCodecJson: () => link()(Base64String, SchemaTransformation.uint8ArrayFromBase64String)\n});\n/**\n * Schema that decodes a base64 encoded string into a\n * `Uint8Array`.\n *\n * **Details**\n *\n * Decoding:\n * - A **valid** base64 encoded string is decoded as a `Uint8Array`.\n *\n * Encoding:\n * - A `Uint8Array` is encoded as a base64-encoded string.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const Uint8ArrayFromBase64 = /*#__PURE__*/Base64String.pipe(/*#__PURE__*/decodeTo(Uint8Array, SchemaTransformation.uint8ArrayFromBase64String));\n/**\n * Schema that decodes a base64 (URL) encoded string into a\n * `Uint8Array`.\n *\n * **Details**\n *\n * Decoding:\n * - A **valid** base64 (URL) encoded string is decoded as a `Uint8Array`.\n *\n * Encoding:\n * - A `Uint8Array` is encoded as a base64 (URL) encoded string.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const Uint8ArrayFromBase64Url = /*#__PURE__*/String.annotate({\n expected: \"a base64 (URL) encoded string that will be decoded as a Uint8Array\"\n}).pipe(/*#__PURE__*/decodeTo(Uint8Array, {\n decode: /*#__PURE__*/SchemaGetter.decodeBase64Url(),\n encode: /*#__PURE__*/SchemaGetter.encodeBase64Url()\n}));\n/**\n * Schema that decodes a hex encoded string into a\n * `Uint8Array`.\n *\n * **Details**\n *\n * Decoding:\n * - A **valid** hex encoded string is decoded as a `Uint8Array`.\n *\n * Encoding:\n * - A `Uint8Array` is encoded as a hex encoded string.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const Uint8ArrayFromHex = /*#__PURE__*/String.annotate({\n expected: \"a hex encoded string that will be decoded as a Uint8Array\"\n}).pipe(/*#__PURE__*/decodeTo(Uint8Array, {\n decode: /*#__PURE__*/SchemaGetter.decodeHex(),\n encode: /*#__PURE__*/SchemaGetter.encodeHex()\n}));\n// -----------------------------------------------------------------------------\n// BigDecimal schemas\n// -----------------------------------------------------------------------------\nconst bigDecimalFromString = /*#__PURE__*/SchemaTransformation.transformEffect({\n decode: (s, options) => {\n const result = BigDecimal_.fromString(s);\n return Option_.isNone(result) ? Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid BigDecimal string\"\n }, s, options)) : Effect.succeed(result.value);\n },\n encode: bd => Effect.succeed(BigDecimal_.format(bd))\n});\n/**\n * Validates that a BigDecimal is greater than the specified value (exclusive).\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isGreaterThanBigDecimal = /*#__PURE__*/makeIsGreaterThan({\n order: BigDecimal_.Order,\n formatter: bd => BigDecimal_.format(bd)\n});\n/**\n * Validates that a BigDecimal is greater than or equal to the specified value\n * (inclusive).\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isGreaterThanOrEqualToBigDecimal = /*#__PURE__*/makeIsGreaterThanOrEqualTo({\n order: BigDecimal_.Order,\n formatter: bd => BigDecimal_.format(bd)\n});\n/**\n * Validates that a BigDecimal is less than the specified value (exclusive).\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isLessThanBigDecimal = /*#__PURE__*/makeIsLessThan({\n order: BigDecimal_.Order,\n formatter: bd => BigDecimal_.format(bd)\n});\n/**\n * Validates that a BigDecimal is less than or equal to the specified value\n * (inclusive).\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isLessThanOrEqualToBigDecimal = /*#__PURE__*/makeIsLessThanOrEqualTo({\n order: BigDecimal_.Order,\n formatter: bd => BigDecimal_.format(bd)\n});\n/**\n * Validates that a `BigDecimal` is within a specified range.\n *\n * **Details**\n *\n * The minimum and maximum boundaries are inclusive by default. Pass\n * `exclusiveMinimum` or `exclusiveMaximum` to exclude either boundary.\n *\n * @category validation\n * @since 4.0.0\n */\nexport const isBetweenBigDecimal = /*#__PURE__*/makeIsBetween({\n order: BigDecimal_.Order,\n formatter: bd => BigDecimal_.format(bd)\n});\nconst BigDecimalString = /*#__PURE__*/String.annotate({\n expected: \"a string that will be decoded as a BigDecimal\"\n});\nconst arbitraryBigDecimalMaxScale = 20;\nfunction bigIntArbitrarySchema(minimum, maximum) {\n if (minimum !== undefined && maximum !== undefined) {\n return BigInt.check(isBetweenBigInt({\n minimum,\n maximum\n }));\n }\n if (minimum !== undefined) return BigInt.check(isGreaterThanOrEqualToBigInt(minimum));\n if (maximum !== undefined) return BigInt.check(isLessThanOrEqualToBigInt(maximum));\n return BigInt;\n}\nfunction bigDecimalValueAtScale(value, scale) {\n return value.value * globalThis.BigInt(10) ** globalThis.BigInt(scale - value.scale);\n}\nfunction bigDecimalArbitrarySchema(constraint) {\n if (constraint?.minimum === undefined && constraint?.maximum === undefined) {\n return Struct({\n value: BigInt,\n scale: Int.check(isBetween({\n minimum: 0,\n maximum: arbitraryBigDecimalMaxScale\n }))\n });\n }\n const scale = Math.max(arbitraryBigDecimalMaxScale, constraint.minimum?.scale ?? 0, constraint.maximum?.scale ?? 0, constraint.exclusiveMinimum === true && constraint.minimum !== undefined ? constraint.minimum.scale + 1 : 0, constraint.exclusiveMaximum === true && constraint.maximum !== undefined ? constraint.maximum.scale + 1 : 0);\n const minimum = constraint.minimum === undefined ? undefined : bigDecimalValueAtScale(constraint.minimum, scale) + (constraint.exclusiveMinimum === true ? globalThis.BigInt(1) : globalThis.BigInt(0));\n const maximum = constraint.maximum === undefined ? undefined : bigDecimalValueAtScale(constraint.maximum, scale) - (constraint.exclusiveMaximum === true ? globalThis.BigInt(1) : globalThis.BigInt(0));\n if (minimum !== undefined && maximum !== undefined && minimum > maximum) {\n return Struct({\n value: BigInt,\n scale: Int.check(isBetween({\n minimum: 0,\n maximum: arbitraryBigDecimalMaxScale\n }))\n });\n }\n return Struct({\n value: bigIntArbitrarySchema(minimum, maximum),\n scale: Literal(scale)\n });\n}\n/**\n * Schema for `BigDecimal` values.\n *\n * **When to use**\n *\n * Use when you already have Effect decimal instances and need schema\n * validation, formatting, equivalence, and JSON string serialization.\n *\n * **Details**\n *\n * Default JSON serializer:\n *\n * - encodes `BigDecimal` as a `string`\n *\n * @see {@link BigDecimalFromString} for parsing string input into a BigDecimal\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {\n representation: {\n id: \"effect/schema/BigDecimal\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.BigDecimal`,\n Type: `BigDecimal.BigDecimal`,\n importDeclarations: [`import * as BigDecimal from \"effect/BigDecimal\"`]\n }),\n expected: \"BigDecimal\",\n toCodecArbitrary: ({\n constraint\n }) => linkDecoding()(bigDecimalArbitrarySchema(constraint), SchemaGetter.transform(({\n scale,\n value\n }) => BigDecimal_.make(value, scale))),\n toCodecJson: () => link()(BigDecimalString, bigDecimalFromString),\n toFormatter: () => bd => BigDecimal_.format(bd)\n});\n/**\n * Schema that parses a string into a `BigDecimal`.\n *\n * **When to use**\n *\n * Use to parse decimal or exponent-notation strings into arbitrary-precision\n * BigDecimal values while encoding them back to strings.\n *\n * **Details**\n *\n * Decoding:\n * - A `string` is decoded with `BigDecimal.fromString`.\n *\n * Encoding:\n * - A `BigDecimal` is encoded with `BigDecimal.format`.\n *\n * **Gotchas**\n *\n * An empty string decodes as zero.\n *\n * @see {@link BigDecimal} for validating values that are already BigDecimal values\n * @see {@link BigIntFromString} for parsing base-10 integer strings into bigint values\n * @see {@link NumberFromString} for parsing JavaScript number strings\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const BigDecimalFromString = /*#__PURE__*/BigDecimalString.pipe(/*#__PURE__*/decodeTo(BigDecimal, bigDecimalFromString));\n/**\n * Schema for exact, non-negative `ByteSize` values.\n *\n * **Details**\n *\n * The JSON codec encodes the byte count as a bigint string, preserving values\n * beyond JavaScript's safe-integer range. The StringTree codec uses the\n * human-readable byte-size syntax exposed by {@link ByteSizeFromString}.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const ByteSize = /*#__PURE__*/declare(ByteSize_.isByteSize, {\n representation: {\n id: \"effect/schema/ByteSize\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.ByteSize`,\n Type: `ByteSize.ByteSize`,\n importDeclarations: [`import * as ByteSize from \"effect/ByteSize\"`]\n }),\n expected: \"ByteSize\",\n toCodecJson: () => link()(BigInt.check(isGreaterThanOrEqualToBigInt(globalThis.BigInt(0))), SchemaTransformation.transform({\n decode: ByteSize_.bytes,\n encode: ByteSize_.toBigInt\n })),\n toCodecStringTree: () => link()(ByteSizeString, SchemaTransformation.byteSizeFromString)\n});\nconst ByteSizeString = /*#__PURE__*/String.annotate({\n expected: \"a string that will be decoded as a ByteSize\"\n});\n/**\n * Schema that decodes byte-size strings into exact, non-negative `ByteSize`\n * values.\n *\n * **Details**\n *\n * Decoding accepts an unsigned base-10 integer or decimal followed by optional\n * whitespace and one of these case-sensitive units:\n *\n * - bytes: `B`, `byte`, or `bytes`\n * - decimal SI units (powers of 1,000): `kB`, `MB`, `GB`, `TB`, `PB`, `EB`,\n * `ZB`, `YB`, `RB`, or `QB`, plus their lowercase singular and plural names\n * - binary IEC units (powers of 1,024): `KiB`, `MiB`, `GiB`, `TiB`, `PiB`,\n * `EiB`, `ZiB`, or `YiB`, plus their lowercase singular and plural names\n *\n * Leading and trailing whitespace is ignored. A decimal quantity must resolve\n * to an integral number of bytes, so `1.5 kB` is accepted while `0.1 KiB` is\n * rejected.\n *\n * Encoding returns the exact byte count as ` byte` or ` bytes`.\n *\n * **Gotchas**\n *\n * A unit is required. Signs, exponent notation, digit separators, and ambiguous\n * unit spellings such as `KB`, `mb`, `Mb`, or `b` are rejected.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const ByteSizeFromString = /*#__PURE__*/ByteSizeString.pipe(/*#__PURE__*/decodeTo(ByteSize, SchemaTransformation.byteSizeFromString));\n/**\n * Schema that decodes non-negative bigint byte counts.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const ByteSizeFromBigInt = /*#__PURE__*/BigInt.pipe(/*#__PURE__*/decodeTo(ByteSize, SchemaTransformation.byteSizeFromBigInt));\n/**\n * Schema that decodes non-negative safe-integer byte counts.\n *\n * **Details**\n *\n * Encoding fails when the byte count exceeds `Number.MAX_SAFE_INTEGER`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const ByteSizeFromNumber = /*#__PURE__*/Number.pipe(/*#__PURE__*/decodeTo(ByteSize, SchemaTransformation.byteSizeFromNumber));\n/**\n * Creates a schema for `Cause.Reason` values using separate schemas for typed\n * failures and unexpected defects.\n *\n * **When to use**\n *\n * Use when serializing or decoding individual cause reasons separately from a\n * full failure cause, with distinct schemas for typed errors and defects.\n *\n * **Details**\n *\n * `Fail` reasons use the `error` schema, `Die` reasons use the `defect` schema,\n * and `Interrupt` reasons carry only an optional fiber id.\n *\n * @see {@link Cause} for constructing schemas for full Cause values\n * @see {@link CauseReasonIso} for the ISO shape of each cause reason\n *\n * @category schemas\n * @since 4.0.0\n */\nexport function CauseReason(error, defect) {\n const schema = declareConstructor()([error, defect], ([error, defect]) => (input, ast, options) => {\n if (!Cause_.isReason(input)) {\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n }\n switch (input._tag) {\n case \"Fail\":\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(error)(input.error, options), {\n onSuccess: Cause_.makeFailReason,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"error\", issue, input, options)\n });\n case \"Die\":\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(defect)(input.defect, options), {\n onSuccess: Cause_.makeDieReason,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"defect\", issue, input, options)\n });\n case \"Interrupt\":\n return Effect.succeed(input);\n }\n }, {\n representation: {\n id: \"effect/schema/CauseReason\",\n payload: null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.CauseReason(${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,\n Type: `Cause.Failure<${typeParameters[0].Type}, ${typeParameters[1].Type}>`,\n importDeclarations: [`import * as Cause from \"effect/Cause\"`]\n }),\n expected: \"Cause.Failure\",\n toCodec: ([error, defect]) => link()(Union([Struct({\n _tag: Literal(\"Fail\"),\n error\n }), Struct({\n _tag: Literal(\"Die\"),\n defect\n }), Struct({\n _tag: Literal(\"Interrupt\"),\n fiberId: UndefinedOr(Finite)\n })]), SchemaTransformation.transform({\n decode: e => {\n switch (e._tag) {\n case \"Fail\":\n return Cause_.makeFailReason(e.error);\n case \"Die\":\n return Cause_.makeDieReason(e.defect);\n case \"Interrupt\":\n return Cause_.makeInterruptReason(e.fiberId);\n }\n },\n encode: identity\n }))\n });\n return make(schema.ast, {\n error,\n defect\n });\n}\n/**\n * Creates a schema for `Cause` values using separate schemas for typed failures\n * and unexpected defects.\n *\n * **When to use**\n *\n * Use to validate, transform, or serialize Effect failure causes when typed\n * failures and unexpected defects need separate schemas.\n *\n * **Details**\n *\n * The `error` schema is applied to `Fail` reasons and the `defect` schema is\n * applied to `Die` reasons. Interrupt reasons do not use either schema and\n * carry only an optional fiber id.\n *\n * @see {@link CauseReason} for the schema used by each individual cause reason\n * @see {@link CauseIso} for the ordered array representation used by the schema ISO\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function Cause(error, defect) {\n const schema = declareConstructor()([error, defect], ([error, defect]) => {\n const failures = ArraySchema(CauseReason(error, defect));\n return (input, ast, options) => {\n if (!Cause_.isCause(input)) {\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n }\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(failures)(input.reasons, options), {\n onSuccess: Cause_.fromReasons,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"failures\", issue, input, options)\n });\n };\n }, {\n representation: {\n id: \"effect/schema/Cause\",\n payload: null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.Cause(${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,\n Type: `Cause.Cause<${typeParameters[0].Type}, ${typeParameters[1].Type}>`,\n importDeclarations: [`import * as Cause from \"effect/Cause\"`]\n }),\n expected: \"Cause\",\n toCodec: ([error, defect]) => link()(ArraySchema(CauseReason(error, defect)), SchemaTransformation.transform({\n decode: Cause_.fromReasons,\n encode: ({\n reasons: failures\n }) => failures\n }))\n });\n return make(schema.ast, {\n error,\n defect\n });\n}\n// -----------------------------------------------------------------------------\n// Chunk schemas\n// -----------------------------------------------------------------------------\nfunction chunkLink(values) {\n return link()(values, SchemaTransformation.transform({\n decode: Chunk_.fromIterable,\n encode: Arr.fromIterable\n }));\n}\n/**\n * Schema for chunks whose values conform to the provided element schema.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function Chunk(value) {\n const schema = declareConstructor()([value], ([value]) => {\n const values = ArraySchema(value);\n return (input, ast, options) => {\n if (Chunk_.isChunk(input)) {\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(values)(Arr.fromIterable(input), options), {\n onSuccess: Chunk_.fromIterable,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"values\", issue, input, options)\n });\n }\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n };\n }, {\n representation: {\n id: \"effect/schema/Chunk\",\n payload: null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.Chunk(${typeParameters[0].runtime})`,\n Type: `Chunk.Chunk<${typeParameters[0].Type}>`\n }),\n expected: \"Chunk\",\n toCodec: ([value]) => chunkLink(ArraySchema(value)),\n toCodecArbitrary: ({\n constraint,\n typeParameters: [value]\n }) => chunkLink(withArrayLengthConstraints(ArraySchema(value), constraint?.minLength, constraint?.maxLength)),\n toEquivalence: ([value]) => Chunk_.makeEquivalence(value)\n });\n return make(schema.ast, {\n value\n });\n}\n// -----------------------------------------------------------------------------\n// DateTime schemas\n// -----------------------------------------------------------------------------\nfunction dateTimeUtcFromInput() {\n return SchemaGetter.transformEffect((input, options) => {\n return Option_.match(DateTime.make(input), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n message: \"Invalid DateTime input\"\n }, input, options)),\n onSome: dt => Effect.succeed(DateTime.toUtc(dt))\n });\n });\n}\nconst timeZoneOffsetFromNumber = /*#__PURE__*/SchemaTransformation.transform({\n decode: n => DateTime.zoneMakeOffset(n),\n encode: tz => tz.offset\n});\nconst timeZoneNamedFromString = /*#__PURE__*/SchemaTransformation.transformEffect({\n decode: (s, options) => {\n return Option_.match(DateTime.zoneMakeNamed(s), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid IANA time zone\"\n }, s, options)),\n onSome: Effect.succeed\n });\n },\n encode: tz => Effect.succeed(tz.id)\n});\nconst timeZoneFromString = /*#__PURE__*/SchemaTransformation.transformEffect({\n decode: (s, options) => {\n return Option_.match(DateTime.zoneFromString(s), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid time zone\"\n }, s, options)),\n onSome: Effect.succeed\n });\n },\n encode: tz => Effect.succeed(DateTime.zoneToString(tz))\n});\nconst dateTimeUtcFromString = /*#__PURE__*/SchemaTransformation.transformEffect({\n decode: (s, options) => {\n return Option_.match(DateTime.make(s), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid UTC DateTime string\"\n }, s, options)),\n onSome: result => Effect.succeed(DateTime.toUtc(result))\n });\n },\n encode: utc => Effect.succeed(DateTime.formatIso(utc))\n});\nconst dateTimeZonedFromString = /*#__PURE__*/SchemaTransformation.transformEffect({\n decode: (s, options) => {\n return Option_.match(DateTime.makeZonedFromString(s), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid Zoned DateTime string\"\n }, s, options)),\n onSome: Effect.succeed\n });\n },\n encode: zoned => Effect.succeed(DateTime.formatIsoZoned(zoned))\n});\nconst arbitraryMinimumDateTimestamp = -8_640_000_000_000_000;\nconst arbitraryMaximumDateTimestamp = 8_640_000_000_000_000;\nconst arbitraryMinimumZonedDateTimeTimestamp = arbitraryMinimumDateTimestamp + 14 * 60 * 60 * 1000;\nconst arbitraryMaximumZonedDateTimeTimestamp = arbitraryMaximumDateTimestamp - 14 * 60 * 60 * 1000;\nconst arbitraryMinimumTimeZoneOffset = -12 * 60 * 60 * 1000;\nconst arbitraryMaximumTimeZoneOffset = 14 * 60 * 60 * 1000;\nconst arbitraryNamedTimeZones = [\"UTC\", \"Europe/London\", \"America/New_York\", \"Asia/Tokyo\", \"Australia/Sydney\"];\nfunction dateTimeArbitraryBounds(constraint, domainMinimum, domainMaximum) {\n const minimum = Math.max(domainMinimum, constraint?.minimum === undefined ? domainMinimum : constraint.minimum.epochMilliseconds + (constraint.exclusiveMinimum === true ? 1 : 0));\n const maximum = Math.min(domainMaximum, constraint?.maximum === undefined ? domainMaximum : constraint.maximum.epochMilliseconds - (constraint.exclusiveMaximum === true ? 1 : 0));\n return minimum <= maximum ? [minimum, maximum] : [domainMinimum, domainMaximum];\n}\nfunction dateTimeArbitraryInteger(minimum, maximum) {\n return Int.check(isBetween({\n minimum,\n maximum\n }));\n}\nfunction timeZoneArbitrarySchema() {\n return Union([dateTimeArbitraryInteger(arbitraryMinimumTimeZoneOffset, arbitraryMaximumTimeZoneOffset), Literals(arbitraryNamedTimeZones)]);\n}\n/**\n * Schema for `DateTime.Utc` values.\n *\n * **When to use**\n *\n * Use to validate existing `DateTime.Utc` schema values and use the default JSON\n * codec that represents them as UTC ISO strings.\n *\n * **Details**\n *\n * The default JSON codec decodes UTC ISO strings into `DateTime.Utc` values and\n * encodes `DateTime.Utc` values as UTC ISO strings.\n *\n * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values\n * @see {@link DateTimeUtcFromDate} for decoding JavaScript Date values into UTC values\n * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values\n * @see {@link DateTimeZoned} for preserving zoned DateTime values\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const DateTimeUtc = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && DateTime.isUtc(u), {\n representation: {\n id: \"effect/schema/DateTimeUtc\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.DateTimeUtc`,\n Type: `DateTime.Utc`,\n importDeclarations: [`import * as DateTime from \"effect/DateTime\"`]\n }),\n expected: \"DateTime.Utc\",\n toCodecArbitrary: ({\n constraint\n }) => {\n const [minimum, maximum] = dateTimeArbitraryBounds(constraint, arbitraryMinimumDateTimestamp, arbitraryMaximumDateTimestamp);\n return linkDecoding()(dateTimeArbitraryInteger(minimum, maximum), SchemaGetter.transform(DateTime.makeUnsafe));\n },\n toCodecJson: () => link()(String, dateTimeUtcFromString),\n toFormatter: () => utc => utc.toString()\n});\n/**\n * Schema that decodes a `Date` into a `DateTime.Utc`.\n *\n * **When to use**\n *\n * Use when you need to decode valid JavaScript `Date` objects into\n * `DateTime.Utc` values.\n *\n * **Details**\n *\n * Decoding:\n * - A **valid** `Date` is decoded as a `DateTime.Utc`\n *\n * Encoding:\n * - A `DateTime.Utc` is encoded as a `Date`\n *\n * @see {@link DateTimeUtc} for validating values that are already `DateTime.Utc`\n * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values\n * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values\n * @see {@link Date} for validating Date instances without converting them\n *\n * @category schemas\n * @since 3.12.0\n */\nexport const DateTimeUtcFromDate = /*#__PURE__*/Date.pipe(/*#__PURE__*/decodeTo(DateTimeUtc, {\n decode: /*#__PURE__*/dateTimeUtcFromInput(),\n encode: /*#__PURE__*/SchemaGetter.transform(DateTime.toDateUtc)\n}));\n/**\n * Schema that decodes a date-time string into a `DateTime.Utc`.\n *\n * **Details**\n *\n * Decoding:\n *\n * - A string accepted by `DateTime.make` is parsed and normalized to UTC. Strings\n * without an explicit zone are interpreted as UTC.\n *\n * Encoding:\n *\n * - A `DateTime.Utc` is encoded as a UTC ISO 8601 string.\n *\n * @see {@link DateTimeUtcFromDate} for decoding JavaScript Date values into UTC values\n * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values\n * @see {@link DateFromString} for decoding strings into JavaScript Date instances\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const DateTimeUtcFromString = /*#__PURE__*/String.annotate({\n expected: \"a string that will be decoded as a DateTime.Utc\"\n}).pipe(/*#__PURE__*/decodeTo(DateTimeUtc, dateTimeUtcFromString));\n/**\n * Schema that decodes a number into a `DateTime.Utc`.\n *\n * **Details**\n *\n * Decoding:\n * - A number of milliseconds since the Unix epoch is decoded as a `DateTime.Utc`\n *\n * Encoding:\n * - A `DateTime.Utc` is encoded as a number of milliseconds since the Unix epoch.\n *\n * @see {@link DateTimeUtcFromDate} for decoding JavaScript Date values into UTC values\n * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values\n * @see {@link DateFromMillis} for decoding epoch milliseconds into JavaScript Date instances\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const DateTimeUtcFromMillis = /*#__PURE__*/Int.pipe(/*#__PURE__*/decodeTo(DateTimeUtc, {\n decode: /*#__PURE__*/dateTimeUtcFromInput(),\n encode: /*#__PURE__*/SchemaGetter.transform(DateTime.toEpochMillis)\n}));\n/**\n * Schema for `DateTime.TimeZone.Offset` values.\n *\n * **Details**\n *\n * Default JSON serializer:\n *\n * - encodes `DateTime.TimeZone.Offset` as a number (offset in milliseconds)\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const TimeZoneOffset = /*#__PURE__*/declare(DateTime.isTimeZoneOffset, {\n representation: {\n id: \"effect/schema/TimeZoneOffset\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.TimeZoneOffset`,\n Type: `DateTime.TimeZone.Offset`,\n importDeclarations: [`import * as DateTime from \"effect/DateTime\"`]\n }),\n expected: \"DateTime.TimeZone.Offset\",\n toCodecJson: () => link()(Int, timeZoneOffsetFromNumber),\n toFormatter: () => tz => DateTime.zoneToString(tz)\n});\nconst TimeZoneNamedString = /*#__PURE__*/String.annotate({\n expected: \"an IANA time zone identifier\"\n});\n/**\n * Schema for `DateTime.TimeZone.Named` values.\n *\n * **Details**\n *\n * Default JSON serializer:\n *\n * - encodes `DateTime.TimeZone.Named` as a string (IANA time zone identifier)\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const TimeZoneNamed = /*#__PURE__*/declare(DateTime.isTimeZoneNamed, {\n representation: {\n id: \"effect/schema/TimeZoneNamed\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.TimeZoneNamed`,\n Type: `DateTime.TimeZone.Named`,\n importDeclarations: [`import * as DateTime from \"effect/DateTime\"`]\n }),\n expected: \"DateTime.TimeZone.Named\",\n toCodecArbitrary: () => linkDecoding()(Literals(arbitraryNamedTimeZones), SchemaGetter.transform(DateTime.zoneMakeNamedUnsafe)),\n toCodecJson: () => link()(TimeZoneNamedString, timeZoneNamedFromString),\n toFormatter: () => tz => DateTime.zoneToString(tz)\n});\n/**\n * Schema that parses an IANA time zone identifier string into a `DateTime.TimeZone.Named`.\n *\n * **Details**\n *\n * Decoding:\n * - A `string` is decoded as a `DateTime.TimeZone.Named`.\n *\n * Encoding:\n * - A `DateTime.TimeZone.Named` is encoded as a `string`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const TimeZoneNamedFromString = /*#__PURE__*/TimeZoneNamedString.pipe(/*#__PURE__*/decodeTo(TimeZoneNamed, timeZoneNamedFromString));\nconst TimeZoneString = /*#__PURE__*/String.annotate({\n expected: \"a time zone string (IANA identifier or offset like +03:00)\"\n});\n/**\n * Schema for `DateTime.TimeZone` values.\n *\n * **Details**\n *\n * Default JSON serializer:\n *\n * - encodes `DateTime.TimeZone` as a string (IANA identifier or offset like\n * `+03:00`)\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const TimeZone = /*#__PURE__*/declare(DateTime.isTimeZone, {\n representation: {\n id: \"effect/schema/TimeZone\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.TimeZone`,\n Type: `DateTime.TimeZone`,\n importDeclarations: [`import * as DateTime from \"effect/DateTime\"`]\n }),\n expected: \"DateTime.TimeZone\",\n toCodecArbitrary: () => linkDecoding()(timeZoneArbitrarySchema(), SchemaGetter.transform(value => typeof value === \"number\" ? DateTime.zoneMakeOffset(value) : DateTime.zoneMakeNamedUnsafe(value))),\n toCodecJson: () => link()(TimeZoneString, timeZoneFromString),\n toFormatter: () => tz => DateTime.zoneToString(tz)\n});\n/**\n * Schema that parses a time zone string into a `DateTime.TimeZone`.\n *\n * **Details**\n *\n * Decoding:\n * - A `string` (IANA identifier or offset like `+03:00`) is decoded as a `DateTime.TimeZone`.\n *\n * Encoding:\n * - A `DateTime.TimeZone` is encoded as a `string`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const TimeZoneFromString = /*#__PURE__*/TimeZoneString.pipe(/*#__PURE__*/decodeTo(TimeZone, timeZoneFromString));\nconst DateTimeZonedString = /*#__PURE__*/String.annotate({\n expected: \"a zoned DateTime string (e.g. 2024-01-01T00:00:00.000+00:00[Europe/London])\"\n});\n/**\n * Schema for `DateTime.Zoned` values.\n *\n * **Details**\n *\n * Default JSON serializer:\n *\n * - encodes offset zones as an ISO date-time with a numeric offset, such as\n * `YYYY-MM-DDTHH:mm:ss.sss+HH:MM`\n * - encodes named zones by appending the IANA identifier in brackets, such as\n * `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const DateTimeZoned = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && DateTime.isZoned(u), {\n representation: {\n id: \"effect/schema/DateTimeZoned\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.DateTimeZoned`,\n Type: `DateTime.Zoned`,\n importDeclarations: [`import * as DateTime from \"effect/DateTime\"`]\n }),\n expected: \"DateTime.Zoned\",\n toCodecArbitrary: ({\n constraint\n }) => {\n const [minimum, maximum] = dateTimeArbitraryBounds(constraint, arbitraryMinimumZonedDateTimeTimestamp, arbitraryMaximumZonedDateTimeTimestamp);\n return linkDecoding()(Struct({\n epochMilliseconds: dateTimeArbitraryInteger(minimum, maximum),\n timeZone: timeZoneArbitrarySchema()\n }), SchemaGetter.transform(({\n epochMilliseconds,\n timeZone\n }) => DateTime.makeZonedUnsafe(epochMilliseconds, {\n timeZone\n })));\n },\n toCodecJson: () => link()(DateTimeZonedString, dateTimeZonedFromString),\n toFormatter: () => zoned => DateTime.formatIsoZoned(zoned),\n toEquivalence: () => DateTime.Equivalence\n});\n/**\n * Schema that parses a zoned DateTime string into a `DateTime.Zoned`.\n *\n * **Details**\n *\n * Decoding:\n * - A `string` (e.g. `2024-01-01T00:00:00.000+00:00[Europe/London]`) is decoded as a `DateTime.Zoned`.\n *\n * Encoding:\n * - A `DateTime.Zoned` is encoded as a `string`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const DateTimeZonedFromString = /*#__PURE__*/DateTimeZonedString.pipe(/*#__PURE__*/decodeTo(DateTimeZoned, dateTimeZonedFromString));\nconst netAddressFromString = (declaration, parse, encode, identifier) => String.pipe(decodeTo(declaration, SchemaTransformation.transformEffect({\n decode: (input, options) => {\n const result = parse(input);\n return Result_.isSuccess(result) ? Effect.succeed(result.success) : Effect.fail(new SchemaIssue.InvalidValue({\n message: result.failure.message\n }, input, options));\n },\n encode: value => Effect.succeed(encode(value))\n}))).annotate({\n identifier\n});\n/**\n * Schema for already-constructed MAC address values.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const MacAddress = /*#__PURE__*/declare(NetAddress_.isMacAddress, {\n identifier: \"MacAddress\"\n});\n/**\n * Schema for MAC addresses encoded as canonical colon-separated hexadecimal strings.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const MacAddressFromString = /*#__PURE__*/netAddressFromString(MacAddress, NetAddress_.macAddressFromString, NetAddress_.formatMacAddress, \"MacAddressFromString\");\n/**\n * Schema for already-constructed IPv4 address values.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv4Address = /*#__PURE__*/declare(NetAddress_.isIpv4Address, {\n identifier: \"Ipv4Address\"\n});\n/**\n * Schema for IPv4 addresses encoded as canonical dotted-decimal strings.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv4AddressFromString = /*#__PURE__*/netAddressFromString(Ipv4Address, NetAddress_.ipv4FromString, NetAddress_.formatIp, \"Ipv4AddressFromString\");\n/**\n * Schema for already-constructed IPv6 address values.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv6Address = /*#__PURE__*/declare(NetAddress_.isIpv6Address, {\n identifier: \"Ipv6Address\"\n});\n/**\n * Schema for IPv6 addresses encoded as canonical strings.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv6AddressFromString = /*#__PURE__*/netAddressFromString(Ipv6Address, NetAddress_.ipv6FromString, NetAddress_.formatIp, \"Ipv6AddressFromString\");\n/**\n * Schema for already-constructed IPv4 or IPv6 address values.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const IpAddress = /*#__PURE__*/declare(NetAddress_.isIpAddress, {\n identifier: \"IpAddress\"\n});\n/**\n * Schema for IP addresses encoded as canonical numeric strings.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const IpAddressFromString = /*#__PURE__*/netAddressFromString(IpAddress, NetAddress_.ipFromString, NetAddress_.formatIp, \"IpAddressFromString\");\n/**\n * Schema for already-constructed IPv4 interface address values.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv4Interface = /*#__PURE__*/declare(IpInterface_.isIpv4Interface, {\n identifier: \"Ipv4Interface\"\n});\n/**\n * Schema for IPv4 interface addresses encoded as an address and prefix length.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv4InterfaceFromString = /*#__PURE__*/netAddressFromString(Ipv4Interface, IpInterface_.ipv4FromString, IpInterface_.format, \"Ipv4InterfaceFromString\");\n/**\n * Schema for already-constructed IPv6 interface address values.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv6Interface = /*#__PURE__*/declare(IpInterface_.isIpv6Interface, {\n identifier: \"Ipv6Interface\"\n});\n/**\n * Schema for IPv6 interface addresses encoded as an address and prefix length.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv6InterfaceFromString = /*#__PURE__*/netAddressFromString(Ipv6Interface, IpInterface_.ipv6FromString, IpInterface_.format, \"Ipv6InterfaceFromString\");\n/**\n * Schema for already-constructed IPv4 or IPv6 interface address values.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const IpInterface = /*#__PURE__*/declare(IpInterface_.isIpInterface, {\n identifier: \"IpInterface\"\n});\n/**\n * Schema for IPv4 or IPv6 interface addresses encoded as an address and prefix length.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const IpInterfaceFromString = /*#__PURE__*/netAddressFromString(IpInterface, IpInterface_.fromString, IpInterface_.format, \"IpInterfaceFromString\");\n/**\n * Schema for already-constructed canonical IPv4 network prefixes.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv4Network = /*#__PURE__*/declare(IpNetwork_.isIpv4Network, {\n identifier: \"Ipv4Network\"\n});\n/**\n * Schema for canonical IPv4 network prefixes encoded in CIDR notation.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv4NetworkFromString = /*#__PURE__*/netAddressFromString(Ipv4Network, IpNetwork_.ipv4FromString, IpNetwork_.format, \"Ipv4NetworkFromString\");\n/**\n * Schema for already-constructed canonical IPv6 network prefixes.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv6Network = /*#__PURE__*/declare(IpNetwork_.isIpv6Network, {\n identifier: \"Ipv6Network\"\n});\n/**\n * Schema for canonical IPv6 network prefixes encoded in CIDR notation.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Ipv6NetworkFromString = /*#__PURE__*/netAddressFromString(Ipv6Network, IpNetwork_.ipv6FromString, IpNetwork_.format, \"Ipv6NetworkFromString\");\n/**\n * Schema for already-constructed canonical IPv4 or IPv6 network prefixes.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const IpNetwork = /*#__PURE__*/declare(IpNetwork_.isIpNetwork, {\n identifier: \"IpNetwork\"\n});\n/**\n * Schema for canonical IPv4 or IPv6 network prefixes encoded in CIDR notation.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const IpNetworkFromString = /*#__PURE__*/netAddressFromString(IpNetwork, IpNetwork_.fromString, IpNetwork_.format, \"IpNetworkFromString\");\n/**\n * Schema for already-constructed resolved IPv4 internet addresses.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const InetAddressV4 = /*#__PURE__*/declare(NetAddress_.isInetAddressV4, {\n identifier: \"InetAddressV4\"\n});\n/**\n * Schema for already-constructed resolved IPv6 internet addresses.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const InetAddressV6 = /*#__PURE__*/declare(NetAddress_.isInetAddressV6, {\n identifier: \"InetAddressV6\"\n});\n/**\n * Schema for already-constructed resolved internet addresses.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const InetAddress = /*#__PURE__*/declare(NetAddress_.isInetAddress, {\n identifier: \"InetAddress\"\n});\n/**\n * Schema for resolved internet addresses encoded as numeric socket strings.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const InetAddressFromString = /*#__PURE__*/netAddressFromString(InetAddress, NetAddress_.inetAddressFromString, NetAddress_.formatInet, \"InetAddressFromString\");\n/**\n * Schema for already-constructed Unix-domain filesystem addresses.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const UnixPathAddress = /*#__PURE__*/declare(NetAddress_.isUnixPathAddress, {\n identifier: \"UnixPathAddress\"\n});\n/**\n * Schema for Unix-domain filesystem addresses encoded as opaque path strings.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const UnixPathAddressFromString = /*#__PURE__*/String.pipe(decodeTo(UnixPathAddress, SchemaTransformation.transform({\n decode: NetAddress_.unixPathAddress,\n encode: address => address.path\n}))).annotate({\n identifier: \"UnixPathAddressFromString\"\n});\n/**\n * Schema for already-constructed portable concrete socket addresses.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const SocketAddress = /*#__PURE__*/declare(NetAddress_.isSocketAddress, {\n identifier: \"SocketAddress\"\n});\n// -----------------------------------------------------------------------------\n// Duration schemas\n// -----------------------------------------------------------------------------\nconst durationFromString = /*#__PURE__*/SchemaTransformation.transformEffect({\n decode: (s, options) => Option_.match(Duration_.fromInput(s), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a valid Duration string\"\n }, s, options)),\n onSome: Effect.succeed\n }),\n encode: duration => Effect.succeed(globalThis.String(duration))\n});\nconst durationFromNanos = /*#__PURE__*/SchemaTransformation.transformEffect({\n decode: i => Effect.succeed(Duration_.nanos(i)),\n encode: (a, options) => Option_.match(Duration_.toNanos(a), {\n onNone: () => Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a Duration representable as a bigint\"\n }, a, options)),\n onSome: nanos => Effect.succeed(nanos)\n })\n});\nconst durationFromMillis = /*#__PURE__*/SchemaTransformation.transform({\n decode: i => Duration_.millis(i),\n encode: a => Duration_.toMillis(a)\n});\n/**\n * Schema for `Duration` values.\n *\n * **Details**\n *\n * The default JSON serializer encodes `Duration` as a tagged object with the\n * duration type and value.\n *\n * **Example** (Defining a Duration schema)\n *\n * ```ts import.meta.vitest\n * import { Duration, Schema } from \"effect\"\n *\n * Schema.decodeUnknownSync(Schema.Duration)(Duration.seconds(5)) // => Duration.seconds(5)\n * ```\n *\n * @category schemas\n *\n * @since 3.10.0\n */\nexport const Duration = /*#__PURE__*/declare(Duration_.isDuration, {\n representation: {\n id: \"effect/schema/Duration\",\n payload: null\n },\n toCode: () => ({\n runtime: `Schema.Duration`,\n Type: `Duration.Duration`,\n importDeclarations: [`import * as Duration from \"effect/Duration\"`]\n }),\n expected: \"Duration\",\n toCodecJson: () => link()(Union([Struct({\n _tag: Literal(\"Infinity\")\n }), Struct({\n _tag: Literal(\"NegativeInfinity\")\n }), Struct({\n _tag: Literal(\"Nanos\"),\n value: BigInt\n }), Struct({\n _tag: Literal(\"Millis\"),\n value: Int\n })]), SchemaTransformation.transform({\n decode: e => {\n switch (e._tag) {\n case \"Infinity\":\n return Duration_.infinity;\n case \"NegativeInfinity\":\n return Duration_.negativeInfinity;\n case \"Nanos\":\n return Duration_.nanos(e.value);\n case \"Millis\":\n return Duration_.millis(e.value);\n }\n },\n encode: duration => {\n switch (duration.value._tag) {\n case \"Infinity\":\n return {\n _tag: \"Infinity\"\n };\n case \"NegativeInfinity\":\n return {\n _tag: \"NegativeInfinity\"\n };\n case \"Nanos\":\n return {\n _tag: \"Nanos\",\n value: duration.value.nanos\n };\n case \"Millis\":\n return {\n _tag: \"Millis\",\n value: duration.value.millis\n };\n }\n }\n }))\n});\nconst DurationString = /*#__PURE__*/String.annotate({\n expected: \"a string that will be decoded as a Duration\"\n});\n/**\n * Schema that parses a string into a `Duration`.\n *\n * **Details**\n *\n * Decoding:\n * - A `string` is decoded as a `Duration`, accepting any format that\n * `Duration.fromInput` can parse.\n *\n * Encoding:\n * - A `Duration` is encoded as a parseable `string`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const DurationFromString = /*#__PURE__*/DurationString.pipe(/*#__PURE__*/decodeTo(Duration, durationFromString));\n/**\n * Schema that decodes a `bigint` into a `Duration`, treating the bigint as\n * nanoseconds.\n *\n * **Details**\n *\n * Decoding:\n * A `bigint` representing nanoseconds is decoded as a `Duration`.\n *\n * Encoding:\n * Finite durations are encoded as a `bigint` number of nanoseconds. Encoding\n * fails when the duration cannot be represented as nanoseconds, such as\n * `Duration.infinity` or `Duration.negativeInfinity`.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const DurationFromNanos = /*#__PURE__*/BigInt.pipe(/*#__PURE__*/decodeTo(Duration, durationFromNanos));\n/**\n * Schema that decodes a number into a `Duration`, treating the number as\n * milliseconds.\n *\n * **Details**\n *\n * Decoding:\n * - A finite or infinite number is decoded as a `Duration`\n *\n * Encoding:\n * - A `Duration` is encoded to a finite or infinite number of milliseconds\n *\n * **Gotchas**\n *\n * `NaN` is decoded as `Duration.zero`, matching `Duration.millis`.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport const DurationFromMillis = /*#__PURE__*/Number.pipe(/*#__PURE__*/decodeTo(Duration, durationFromMillis));\n/**\n * Creates a schema for `Exit` values using schemas for the success value, typed\n * failure, and unexpected defect channels.\n *\n * **When to use**\n *\n * Use when serializing or validating an effect outcome where success, typed\n * failure, and defects each need their own schema.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function Exit(value, error, defect) {\n const schema = declareConstructor()([value, error, defect], ([value, error, defect]) => {\n const cause = Cause(error, defect);\n return (input, ast, options) => {\n if (!Exit_.isExit(input)) {\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n }\n switch (input._tag) {\n case \"Success\":\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(value)(input.value, options), {\n onSuccess: Exit_.succeed,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"value\", issue, input, options)\n });\n case \"Failure\":\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(cause)(input.cause, options), {\n onSuccess: Exit_.failCause,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"cause\", issue, input, options)\n });\n }\n };\n }, {\n representation: {\n id: \"effect/schema/Exit\",\n payload: null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.Exit(${typeParameters[0].runtime}, ${typeParameters[1].runtime}, ${typeParameters[2].runtime})`,\n Type: `Exit.Exit<${typeParameters[0].Type}, ${typeParameters[1].Type}, ${typeParameters[2].Type}>`,\n importDeclarations: [`import * as Exit from \"effect/Exit\"`]\n }),\n expected: \"Exit\",\n toCodec: ([value, error, defect]) => link()(Union([Struct({\n _tag: Literal(\"Success\"),\n value\n }), Struct({\n _tag: Literal(\"Failure\"),\n cause: Cause(error, defect)\n })]), SchemaTransformation.transform({\n decode: e => e._tag === \"Success\" ? Exit_.succeed(e.value) : Exit_.failCause(e.cause),\n encode: exit => Exit_.isSuccess(exit) ? {\n _tag: \"Success\",\n value: exit.value\n } : {\n _tag: \"Failure\",\n cause: exit.cause\n }\n }))\n });\n return make(schema.ast, {\n value,\n error,\n defect\n });\n}\nfunction graphEncodedSchema(type, node, edge) {\n return Struct({\n type: Literal(type),\n nodes: ArraySchema(Struct({\n index: Natural,\n data: node\n })),\n edges: ArraySchema(Struct({\n index: Natural,\n source: Natural,\n target: Natural,\n data: edge\n }))\n });\n}\nfunction graphDecode(input, options) {\n let previous = -1;\n const indexes = new Set();\n for (let i = 0; i < input.nodes.length; i++) {\n const index = input.nodes[i].index;\n if (index <= previous) {\n return Effect.fail(new SchemaIssue.Pointer([\"nodes\", i, \"index\"], new SchemaIssue.InvalidValue({\n expected: \"a strictly increasing node index\"\n }, index, options)));\n }\n previous = index;\n indexes.add(index);\n }\n previous = -1;\n for (let i = 0; i < input.edges.length; i++) {\n const edge = input.edges[i];\n if (edge.index <= previous) {\n return Effect.fail(new SchemaIssue.Pointer([\"edges\", i, \"index\"], new SchemaIssue.InvalidValue({\n expected: \"a strictly increasing edge index\"\n }, edge.index, options)));\n }\n previous = edge.index;\n if (!indexes.has(edge.source)) {\n return Effect.fail(new SchemaIssue.Pointer([\"edges\", i, \"source\"], new SchemaIssue.InvalidValue({\n expected: \"an encoded node index\"\n }, edge.source, options)));\n }\n if (!indexes.has(edge.target)) {\n return Effect.fail(new SchemaIssue.Pointer([\"edges\", i, \"target\"], new SchemaIssue.InvalidValue({\n expected: \"an encoded node index\"\n }, edge.target, options)));\n }\n }\n return Effect.succeed(InternalGraph.hydrate(input));\n}\nfunction graphEncode(input, type, options) {\n if (!InternalGraph.isGraph(input) || input.mutable || input.type !== type) {\n return Effect.fail(new SchemaIssue.InvalidValue({\n expected: `an immutable ${type} Graph`\n }, input, options));\n }\n return Effect.succeed(InternalGraph.snapshot(input));\n}\nfunction graphToEquivalence(node, edge) {\n return (self, that) => {\n const a = InternalGraph.snapshot(self);\n const b = InternalGraph.snapshot(that);\n if (a.type !== b.type || a.nodes.length !== b.nodes.length || a.edges.length !== b.edges.length) return false;\n for (let i = 0; i < a.nodes.length; i++) {\n if (a.nodes[i].index !== b.nodes[i].index || !node(a.nodes[i].data, b.nodes[i].data)) return false;\n }\n for (let i = 0; i < a.edges.length; i++) {\n const ae = a.edges[i];\n const be = b.edges[i];\n const sameEndpoints = a.type === \"directed\" ? ae.source === be.source && ae.target === be.target : ae.source === be.source && ae.target === be.target || ae.source === be.target && ae.target === be.source;\n if (ae.index !== be.index || !sameEndpoints || !edge(ae.data, be.data)) return false;\n }\n return true;\n };\n}\nfunction graphToArbitrary(type, node, edge) {\n return linkDecoding()(Union([Null, Struct({\n nodes: NonEmptyArray(node),\n edges: ArraySchema(Tuple([Natural, Natural, edge]))\n })]), SchemaGetter.transform(input => {\n if (input === null) return InternalGraph.hydrate({\n type,\n nodes: [],\n edges: []\n });\n const nodes = input.nodes.map((data, index) => ({\n index,\n data\n }));\n return InternalGraph.hydrate({\n type,\n nodes,\n edges: input.edges.map(([source, target, data], index) => ({\n index,\n source: source % nodes.length,\n target: target % nodes.length,\n data\n }))\n });\n }));\n}\nexport function Graph(type, node, edge) {\n const schema = declareConstructor()([node, edge], ([node, edge]) => {\n const encoded = graphEncodedSchema(type, node, edge);\n return (input, ast, options) => {\n if (!InternalGraph.isGraph(input) || input.mutable || input.type !== type) {\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n }\n return Effect.flatMap(SchemaParser.decodeUnknownEffect(encoded)(InternalGraph.snapshot(input), options), snapshot => graphDecode(snapshot, options));\n };\n }, {\n representation: {\n id: \"effect/schema/Graph\",\n payload: type\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.Graph(${format(type)}, ${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,\n Type: `Graph.Graph<${typeParameters[0].Type}, ${typeParameters[1].Type}, ${format(type)}>`,\n importDeclarations: [`import * as Graph from \"effect/Graph\"`]\n }),\n expected: `an immutable ${type} Graph`,\n toCodec: ([node, edge]) => link()(graphEncodedSchema(type, node, edge), SchemaTransformation.transformEffect({\n decode: graphDecode,\n encode: (graph, options) => graphEncode(graph, type, options)\n })),\n toCodecArbitrary: ({\n typeParameters: [node, edge]\n }) => graphToArbitrary(type, node, edge),\n toEquivalence: ([node, edge]) => graphToEquivalence(node, edge)\n });\n return make(schema.ast, {\n type,\n node,\n edge\n });\n}\n// -----------------------------------------------------------------------------\n// HashMap schemas\n// -----------------------------------------------------------------------------\nfunction hashMapLink(entries) {\n return link()(entries, SchemaTransformation.transform({\n decode: HashMap_.fromIterable,\n encode: HashMap_.toEntries\n }));\n}\n/**\n * Schema for hash maps whose keys and values conform to the provided schemas.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function HashMap(key, value) {\n const schema = declareConstructor()([key, value], ([key, value]) => {\n const entries = ArraySchema(Tuple([key, value]));\n return (input, ast, options) => {\n if (HashMap_.isHashMap(input)) {\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(entries)(HashMap_.toEntries(input), options), {\n onSuccess: HashMap_.fromIterable,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"entries\", issue, input, options)\n });\n }\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n };\n }, {\n representation: {\n id: \"effect/schema/HashMap\",\n payload: null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.HashMap(${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,\n Type: `HashMap.HashMap<${typeParameters[0].Type}, ${typeParameters[1].Type}>`,\n importDeclarations: [`import * as HashMap from \"effect/HashMap\"`]\n }),\n expected: \"HashMap\",\n toCodec: ([key, value]) => hashMapLink(ArraySchema(Tuple([key, value]))),\n toCodecArbitrary: ({\n constraint,\n typeParameters: [key, value]\n }) => hashMapLink(withArrayLengthConstraints(ArraySchema(Tuple([key, value])).check(isUniqueKey()), constraint?.minSize, constraint?.maxSize)),\n toEquivalence: ([key, value]) => Equal.makeCompareMap(key, value)\n });\n return make(schema.ast, {\n key,\n value\n });\n}\n// -----------------------------------------------------------------------------\n// HashSet schemas\n// -----------------------------------------------------------------------------\nfunction hashSetLink(values) {\n return link()(values, SchemaTransformation.transform({\n decode: HashSet_.fromIterable,\n encode: Arr.fromIterable\n }));\n}\n/**\n * Schema for hash sets whose values conform to the provided element schema.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function HashSet(value) {\n const schema = declareConstructor()([value], ([value]) => {\n const values = ArraySchema(value);\n return (input, ast, options) => {\n if (HashSet_.isHashSet(input)) {\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(values)(Arr.fromIterable(input), options), {\n onSuccess: HashSet_.fromIterable,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"values\", issue, input, options)\n });\n }\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n };\n }, {\n representation: {\n id: \"effect/schema/HashSet\",\n payload: null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.HashSet(${typeParameters[0].runtime})`,\n Type: `HashSet.HashSet<${typeParameters[0].Type}>`\n }),\n expected: \"HashSet\",\n toCodec: ([value]) => hashSetLink(ArraySchema(value)),\n toCodecArbitrary: ({\n constraint,\n typeParameters: [value]\n }) => hashSetLink(withArrayLengthConstraints(ArraySchema(value).check(isUnique()), constraint?.minSize, constraint?.maxSize)),\n toEquivalence: ([value]) => Equal.makeCompareSet(value)\n });\n return make(schema.ast, {\n value\n });\n}\n/**\n * Schema for `Option` values.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function Option(value) {\n const schema = declareConstructor()([value], ([value]) => (input, ast, options) => {\n if (Option_.isOption(input)) {\n if (Option_.isNone(input)) {\n return Effect.succeedNone;\n }\n return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(value)(input.value, options), {\n onSuccess: Option_.some,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"value\", issue, input, options)\n });\n }\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n }, {\n representation: {\n id: \"effect/schema/Option\",\n payload: null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.Option(${typeParameters[0].runtime})`,\n Type: `Option.Option<${typeParameters[0].Type}>`,\n importDeclarations: [`import * as Option from \"effect/Option\"`]\n }),\n expected: \"Option\",\n toCodec: ([value]) => link()(Union([Struct({\n _tag: Literal(\"Some\"),\n value\n }), Struct({\n _tag: Literal(\"None\")\n })]), SchemaTransformation.transform({\n decode: e => e._tag === \"None\" ? Option_.none() : Option_.some(e.value),\n encode: o => Option_.isSome(o) ? {\n _tag: \"Some\",\n value: o.value\n } : {\n _tag: \"None\"\n }\n }))\n });\n return make(schema.ast, {\n value\n });\n}\n/**\n * Decodes a nullable, required value `T` to a required `Option` value.\n *\n * **Details**\n *\n * Decoding maps `null` to `None` and all other values to `Some`. Encoding maps\n * `None` to `null` and maps `Some` to its value.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function OptionFromNullOr(schema) {\n return NullOr(schema).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.optionFromNullOr()));\n}\n/**\n * Decodes a required value that may be `undefined` to a required `Option`\n * value.\n *\n * **Details**\n *\n * Decoding maps `undefined` to `None` and all other values to `Some`. Encoding\n * maps `None` to `undefined` and maps `Some` to its value.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function OptionFromUndefinedOr(schema) {\n return UndefinedOr(schema).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.optionFromUndefinedOr()));\n}\n/**\n * Decodes a nullish value `T` to a required `Option` value.\n *\n * **Details**\n *\n * Decoding maps `null` and `undefined` to `None` and all other values to\n * `Some`. Encoding maps `None` to `null` or `undefined` depending on\n * `options.onNoneEncoding`, which defaults to `undefined`, and maps `Some` to\n * its value.\n *\n * @category schemas\n * @since 3.10.0\n */\nexport function OptionFromNullishOr(schema, options) {\n return NullishOr(schema).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.optionFromNullishOr(options)));\n}\n/**\n * Schema for HTTP cookie values.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Cookie = /*#__PURE__*/declare(Cookies_.isCookie, {\n representation: {\n id: \"effect/http/Cookie\",\n payload: null\n },\n toCode: () => ({\n runtime: \"Schema.Cookie\",\n Type: \"Cookies.Cookie\",\n importDeclarations: [`import * as Cookies from \"effect/unstable/http/Cookies\"`]\n }),\n expected: \"Cookie\"\n});\n/**\n * Schema for HTTP cookie collections.\n *\n * **Details**\n *\n * JSON encoding uses `Set-Cookie` header strings, while isomorphic encoding uses\n * a readonly record of cookie values.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Cookies = /*#__PURE__*/declare(Cookies_.isCookies, {\n representation: {\n id: \"effect/http/Cookies\",\n payload: null\n },\n toCode: () => ({\n runtime: \"Schema.Cookies\",\n Type: \"Cookies.Cookies\",\n importDeclarations: [`import * as Cookies from \"effect/unstable/http/Cookies\"`]\n }),\n expected: \"Cookies\",\n toCodecJson: () => link()(ArraySchema(String), SchemaTransformation.transform({\n decode: Cookies_.fromSetCookie,\n encode: Cookies_.toSetCookieHeaders\n })),\n toCodecIso: () => link()(Record(String, Cookie), SchemaTransformation.transform({\n decode: Cookies_.fromReadonlyRecord,\n encode: cookies => cookies.cookies\n }))\n});\n/**\n * Schema that decodes HTTP cookies into a record of decoded string values keyed\n * by cookie name.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const RecordFromCookies = /*#__PURE__*/Cookies.pipe(/*#__PURE__*/decodeTo(/*#__PURE__*/Record(String, String), /*#__PURE__*/SchemaTransformation.transform({\n decode: Cookies_.toRecord,\n encode: self => Cookies_.fromIterable(globalThis.Object.entries(self).map(([name, value]) => Cookies_.makeCookieUnsafe(name, value)))\n})));\n/**\n * Schema for HTTP headers encoded as records of string values.\n *\n * **Details**\n *\n * Decoding normalizes header names; encoding returns a plain record.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const Headers = /*#__PURE__*/declare(Headers_.isHeaders, {\n representation: {\n id: \"effect/http/Headers\",\n payload: null\n },\n toCode: () => ({\n runtime: \"Schema.Headers\",\n Type: \"Headers.Headers\",\n importDeclarations: [`import * as Headers from \"effect/unstable/http/Headers\"`]\n }),\n expected: \"Headers\",\n toEquivalence: () => Headers_.Equivalence,\n toCodec: () => link()(Record(String, String), SchemaTransformation.transform({\n decode: Headers_.fromInput,\n encode: headers => ({\n ...headers\n })\n }))\n});\n/**\n * Schema for HTTP URL parameters.\n *\n * **Details**\n *\n * The encoded representation is an array of string key-value tuples.\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const UrlParams = /*#__PURE__*/declare(UrlParams_.isUrlParams, {\n representation: {\n id: \"effect/http/UrlParams\",\n payload: null\n },\n toCode: () => ({\n runtime: \"Schema.UrlParams\",\n Type: \"UrlParams.UrlParams\",\n importDeclarations: [`import * as UrlParams from \"effect/unstable/http/UrlParams\"`]\n }),\n expected: \"UrlParams\",\n toEquivalence: () => UrlParams_.Equivalence,\n toCodec: () => link()(ArraySchema(Tuple([String, String])), SchemaTransformation.transform({\n decode: UrlParams_.make,\n encode: self => self.params\n }))\n});\n/**\n * Extracts a JSON value from the first occurrence of the given `field` in URL\n * parameters.\n *\n * **Example** (Decoding a JSON parameter field)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n * import { UrlParams } from \"effect/unstable/http\"\n *\n * const extractFoo = Schema.JsonFromUrlParamsField(\"foo\").pipe(\n * Schema.decodeTo(Schema.Struct({\n * some: Schema.String,\n * number: Schema.Number\n * }))\n * )\n *\n * const decoded = Schema.decodeSync(extractFoo)(UrlParams.fromInput({\n * foo: `{\"some\":\"bar\",\"number\":42}`,\n * baz: \"qux\"\n * }))\n * const result = [decoded.some, decoded.number] // => [\"bar\", 42]\n * ```\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const JsonFromUrlParamsField = (field, options) => UrlParams.pipe(decodeTo(fromJsonString(Unknown, options), SchemaTransformation.transformEffect({\n decode: params => Option_.match(UrlParams_.getFirst(params, field), {\n onNone: () => Effect.fail(new SchemaIssue.Pointer([field], new SchemaIssue.MissingKey(undefined))),\n onSome: Effect.succeed\n }),\n encode: value => Effect.succeed(UrlParams_.make([[field, value]]))\n})));\n/**\n * Schema that decodes URL parameters into a record of string values.\n *\n * **Details**\n *\n * Keys with one value decode to a string, and keys with multiple values decode to\n * a non-empty readonly array of strings.\n *\n * **Example** (Decoding URL parameters to a record)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n * import { UrlParams } from \"effect/unstable/http\"\n *\n * const toStruct = Schema.RecordFromUrlParams.pipe(\n * Schema.decodeTo(Schema.Struct({\n * some: Schema.String,\n * number: Schema.FiniteFromString\n * }))\n * )\n *\n * const decoded = Schema.decodeSync(toStruct)(UrlParams.fromInput({\n * some: \"value\",\n * number: 42\n * }))\n * const result = [decoded.some, decoded.number] // => [\"value\", 42]\n * ```\n *\n * @unstable\n * @category schemas\n * @since 4.0.0\n */\nexport const RecordFromUrlParams = /*#__PURE__*/UrlParams.pipe(/*#__PURE__*/decodeTo(/*#__PURE__*/Record(String, /*#__PURE__*/Union([String, /*#__PURE__*/NonEmptyArray(String)])), /*#__PURE__*/SchemaTransformation.transform({\n decode: UrlParams_.toReadonlyRecord,\n encode: UrlParams_.fromInput\n})));\n/**\n * Decodes an optional value `A` to a required `Option` value.\n *\n * **Details**\n *\n * Decoding maps a missing key to `None` and a present value to `Some`.\n * Encoding maps `None` to a missing key and maps `Some` to its value.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport function OptionFromOptionalKey(schema) {\n return optionalKey(schema).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.optionFromOptionalKey()));\n}\n/**\n * Decodes an optional or `undefined` value `A` to a required `Option`\n * value.\n *\n * **Details**\n *\n * Decoding maps a missing key or a present `undefined` value to `None`, and\n * maps all other values to `Some`. Encoding maps `None` to a missing key and\n * maps `Some` to its value.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport function OptionFromOptional(schema) {\n return optional(schema).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.optionFromOptional()));\n}\n/**\n * Decodes an optional or `null` or `undefined` value `A` to a required `Option`\n * value.\n *\n * **Details**\n *\n * Decoding maps a missing key, `undefined`, or `null` to `None`, and maps all\n * other values to `Some`. Encoding maps `Some` to its value. `None` is encoded\n * according to `options.onNoneEncoding`: `\"omit\"` encodes a missing key,\n * `null` encodes `null`, and `undefined` encodes `undefined`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport function OptionFromOptionalNullOr(schema, options) {\n const onNoneEncoding = options === undefined ? \"omit\" : options.onNoneEncoding;\n const noneValue = onNoneEncoding === null ? null : undefined;\n return optional(NullOr(schema)).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.transformOptional({\n decode: oe => oe.pipe(Option_.filter(Predicate.isNotNullish), Option_.some),\n encode: onNoneEncoding === \"omit\" ? Option_.flatten : ot => Option_.some(Option_.getOrElse(Option_.flatten(ot), () => noneValue))\n })));\n}\n/**\n * Schema for `Redacted` values, which hide their contents from inspection.\n *\n * **Details**\n *\n * Options:\n *\n * - `label`: When provided, the schema will behave as follows:\n * - Values will be validated against the label in addition to the wrapped schema\n * - The default JSON serializer will deserialize into a `Redacted` instance with the label\n * - The arbitrary generator will produce a `Redacted` instance with the label\n * - The formatter will return the label\n * - `disallowJsonEncode`: When set to `true`, when attempting to encode a `Redacted` instance\n * into JSON, it will fail with an error. This is useful when the wrapped schema is\n * sensitive and should not be exposed in JSON.\n *\n * @see {@link RedactedFromValue} for decoding raw values and wrapping them in `Redacted`.\n * @category schemas\n * @since 3.10.0\n */\nexport function Redacted(value, options) {\n const label = typeof options?.label === \"string\" ? options.label : undefined;\n const disallowJsonEncode = options?.disallowJsonEncode === true;\n const normalizedOptions = label !== undefined ? disallowJsonEncode ? {\n label,\n disallowJsonEncode: true\n } : {\n label\n } : disallowJsonEncode ? {\n disallowJsonEncode: true\n } : undefined;\n const decodeLabel = label !== undefined ? SchemaParser.decodeUnknownEffect(Literal(label)) : undefined;\n const schema = declareConstructor()([value], ([value]) => (input, ast, poptions) => {\n if (Redacted_.isRedacted(input)) {\n const label = decodeLabel !== undefined ? Effect.mapErrorEager(decodeLabel(input.label, poptions), issue => new SchemaIssue.Pointer([\"label\"], issue)) : Effect.void;\n return Effect.flatMapEager(label, () => Effect.mapBothEager(SchemaParser.decodeUnknownEffect(value)(Redacted_.value(input), poptions), {\n onSuccess: () => input,\n onFailure: () => {\n return new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer([\"value\"], new SchemaIssue.InvalidValue(undefined, input, poptions))], input, poptions);\n }\n }));\n }\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, poptions));\n }, {\n representation: {\n id: \"effect/schema/Redacted\",\n payload: normalizedOptions ?? null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: normalizedOptions !== undefined ? `Schema.Redacted(${typeParameters[0].runtime}, ${format(normalizedOptions)})` : `Schema.Redacted(${typeParameters[0].runtime})`,\n Type: `Redacted.Redacted<${typeParameters[0].Type}>`,\n importDeclarations: [`import * as Redacted from \"effect/Redacted\"`]\n }),\n expected: \"Redacted\",\n toCodecJson: ([value]) => link()(value, {\n decode: SchemaGetter.transform(e => Redacted_.make(e, {\n label\n })),\n encode: disallowJsonEncode ? SchemaGetter.forbidden(oe => \"Cannot serialize Redacted\" + (Option_.isSome(oe) && typeof oe.value.label === \"string\" ? ` with label: \"${oe.value.label}\"` : \"\")) : SchemaGetter.transform(Redacted_.value)\n }),\n toEquivalence: ([value]) => Redacted_.makeEquivalence(value)\n });\n return make(schema.ast, {\n value\n });\n}\n/**\n * Decodes a value and wraps it in `Redacted`. Unlike {@link Redacted} which\n * expects the input to already be a `Redacted` instance, this schema decodes\n * the raw value and wraps it.\n *\n * @see {@link Redacted} for schemas whose input is already a `Redacted` value.\n * @category schemas\n * @since 4.0.0\n */\nexport function RedactedFromValue(value, options) {\n return decodeTo(Redacted(toType(value), {\n label: options?.label,\n disallowJsonEncode: options?.disallowEncode\n }), {\n decode: SchemaGetter.transform(t => Redacted_.make(t, {\n label: options?.label\n })),\n encode: options?.disallowEncode ? SchemaGetter.forbidden(oe => \"Cannot encode Redacted\" + (Option_.isSome(oe) && typeof oe.value.label === \"string\" ? ` with label: \"${oe.value.label}\"` : \"\")) : SchemaGetter.transform(Redacted_.value)\n })(value);\n}\n/**\n * Schema for `Result` values.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport function Result(success, failure) {\n const schema = declareConstructor()([success, failure], ([success, failure]) => (input, ast, options) => {\n if (!Result_.isResult(input)) {\n return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n }\n switch (input._tag) {\n case \"Success\":\n return Effect.mapBothEager(SchemaParser.decodeEffect(success)(input.success, options), {\n onSuccess: Result_.succeed,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"success\", issue, input, options)\n });\n case \"Failure\":\n return Effect.mapBothEager(SchemaParser.decodeEffect(failure)(input.failure, options), {\n onSuccess: Result_.fail,\n onFailure: issue => SchemaIssue.makeCompositeAtKey(ast, \"failure\", issue, input, options)\n });\n }\n }, {\n representation: {\n id: \"effect/schema/Result\",\n payload: null\n },\n toCode: ({\n typeParameters\n }) => ({\n runtime: `Schema.Result(${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,\n Type: `Result.Result<${typeParameters[0].Type}, ${typeParameters[1].Type}>`,\n importDeclarations: [`import * as Result from \"effect/Result\"`]\n }),\n expected: \"Result\",\n toCodec: ([success, failure]) => link()(Union([Struct({\n _tag: Literal(\"Success\"),\n success\n }), Struct({\n _tag: Literal(\"Failure\"),\n failure\n })]), SchemaTransformation.transform({\n decode: e => e._tag === \"Success\" ? Result_.succeed(e.success) : Result_.fail(e.failure),\n encode: r => Result_.isSuccess(r) ? {\n _tag: \"Success\",\n success: r.success\n } : {\n _tag: \"Failure\",\n failure: r.failure\n }\n }))\n });\n return make(schema.ast, {\n success,\n failure\n });\n}\nconst immerable = /*#__PURE__*/globalThis.Symbol.for(\"immer-draftable\");\nconst payloadToken = {};\nfunction makeClass(Inherited, identifier, struct, annotations, proto) {\n const getClassSchema = getClassSchemaFactory(struct, identifier, annotations);\n const ClassTypeId = getClassTypeId(identifier); // HMR support\n const out = class extends Inherited {\n constructor(...[input, options]) {\n const internalOptions = options;\n const payload = internalOptions?.[\"~payload\"];\n const value = payload?.token === payloadToken ? payload.value : struct.make(input ?? {}, options);\n super(value, {\n ...options,\n disableChecks: true,\n \"~payload\": {\n token: payloadToken,\n value\n }\n });\n }\n static [TypeId] = TypeId;\n get [ClassTypeId]() {\n return ClassTypeId;\n }\n static [immerable] = true;\n static identifier = identifier;\n static fields = struct.fields;\n static get ast() {\n return getClassSchema(this).ast;\n }\n static pipe() {\n return Pipeable.pipeArguments(this, arguments);\n }\n static rebuild(ast) {\n return getClassSchema(this).rebuild(ast);\n }\n static make(input, options) {\n return SchemaParser.make(getClassSchema(this))(input ?? {}, options);\n }\n static makeOption(input, options) {\n return SchemaParser.makeOption(getClassSchema(this))(input ?? {}, options);\n }\n static makeEffect(input, options) {\n return getClassSchema(this).makeEffect(input ?? {}, options);\n }\n static annotate(annotations) {\n return this.rebuild(SchemaAST.annotate(this.ast, annotations));\n }\n static annotateKey(annotations) {\n return this.rebuild(SchemaAST.annotateKey(this.ast, annotations));\n }\n static check(...checks) {\n return this.rebuild(SchemaAST.appendChecks(this.ast, checks));\n }\n static extend(identifier) {\n return (schema, annotations) => {\n const extension = isStruct(schema) ? schema : Struct(schema);\n const fields = {\n ...struct.fields,\n ...extension.fields\n };\n const ast = SchemaAST.struct(fields, struct.ast.checks, {\n identifier\n });\n return makeClass(this, identifier, makeStruct(SchemaAST.appendChecks(ast, extension.ast.checks), fields), annotations, proto);\n };\n }\n static mapFields(f, options) {\n return struct.mapFields(f, options);\n }\n };\n if (proto !== undefined) {\n Object.assign(out.prototype, proto(identifier));\n }\n return out;\n}\nfunction getClassTransformation(self) {\n return new SchemaTransformation.Transformation(SchemaGetter.transform(input => new self(input, {\n \"~payload\": {\n token: payloadToken,\n value: input\n }\n })), SchemaGetter.passthrough());\n}\nfunction getClassTypeId(identifier) {\n return `~effect/Schema/Class/${identifier}`;\n}\nfunction getClassSchemaFactory(from, identifier, annotations) {\n let memo;\n return self => {\n if (memo !== undefined) {\n return memo;\n }\n const ClassTypeId = getClassTypeId(identifier);\n const isClassValue = input => input instanceof self || Predicate.hasProperty(input, ClassTypeId);\n const transformation = getClassTransformation(self);\n const to = make(new SchemaAST.Declaration([from.ast], () => (input, ast, options) => {\n return isClassValue(input) ? Effect.succeed(input) : Effect.fail(new SchemaIssue.InvalidType(ast, input, options));\n }, {\n identifier,\n [InternalAnnotations.CONSTRUCTOR_ANNOTATION_KEY]: ([from]) => ({\n isConstructed: isClassValue,\n link: new SchemaAST.Link(from, transformation)\n }),\n toCodec: ([from]) => new SchemaAST.Link(from.ast, transformation),\n toEquivalence: ([from]) => from,\n toFormatter: ([from]) => t => `${self.identifier}(${from(t)})`,\n [InternalAnnotations.SENTINELS_ANNOTATION_KEY]: SchemaAST.collectSentinels(from.ast),\n ...annotations\n }));\n return memo = decodeTo(to, transformation)(from);\n };\n}\nfunction isStruct(schema) {\n return isSchema(schema);\n}\n/**\n * Creates a schema-backed class whose constructor validates input against a\n * {@link Struct} schema. Construction throws an `Error` with a\n * `SchemaIssue.Issue` in its `cause` on invalid input.\n *\n * **When to use**\n *\n * Use when you need a schema-backed data class with validated construction,\n * schema-derived decoding/encoding, and class-style methods or inheritance.\n *\n * **Details**\n *\n * Pass the desired class type as the first type parameter. The second optional\n * type parameter can be used to add nominal brands.\n *\n * The `identifier` is the schema's stable runtime name. It is exposed on the\n * class, stored in the schema AST, and used to label diagnostics and generated\n * references as well as to format class instances.\n *\n * It also derives a runtime marker that recognizes instances across hot module\n * reloads, where `instanceof` can fail because the constructor has been\n * replaced. The identifier is explicit because the outer JavaScript class name\n * is not available while the `extends` expression is evaluated and may change\n * through renaming or minification.\n *\n * **Gotchas**\n *\n * Passing `disableChecks` in the options skips constructor validation.\n *\n * **Example** (Defining a basic class)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * class Person extends Schema.Class(\"Person\")({\n * name: Schema.String,\n * age: Schema.Number\n * }) {}\n *\n * const alice = new Person({ name: \"Alice\", age: 30 })\n * alice.name // => \"Alice\"\n * String(alice) // => \"Person({\\\"name\\\":\\\"Alice\\\",\\\"age\\\":30})\"\n * ```\n *\n * **Example** (Extending a class)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * class Animal extends Schema.Class(\"Animal\")({\n * name: Schema.String\n * }) {}\n *\n * class Dog extends Animal.extend(\"Dog\")({\n * breed: Schema.String\n * }) {}\n *\n * const dog = new Dog({ name: \"Rex\", breed: \"Labrador\" })\n * dog.name // => \"Rex\"\n * dog.breed // => \"Labrador\"\n * ```\n *\n * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema\n * @see {@link Error} for defining schema-backed error classes\n * @see {@link TaggedError} for defining tagged schema-backed error classes\n *\n * @category constructors\n * @since 3.10.0\n */\nexport const Class = identifier => (schema, annotations) => {\n const struct = isStruct(schema) ? schema : Struct(schema);\n return makeClass(Data.Class, identifier, struct, annotations, identifier => ({\n toString() {\n return `${identifier}(${format({\n ...this\n })})`;\n }\n }));\n};\n/**\n * Defines a schema-backed class with an automatically populated `_tag` field.\n *\n * **When to use**\n *\n * Use to define class instances that are validated by a schema and participate\n * in tagged union matching.\n *\n * **Details**\n *\n * The optional `identifier` parameter overrides the schema identifier;\n * it defaults to the `tag` value.\n *\n * **Example** (Defining a tagged class)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * class Circle extends Schema.TaggedClass()(\"Circle\", {\n * radius: Schema.Number\n * }) {}\n *\n * const c = new Circle({ radius: 5 })\n * c._tag // => \"Circle\"\n * c.radius // => 5\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport const TaggedClass = identifier => {\n return (tagValue, schema, annotations) => {\n const struct = isStruct(schema) ? schema.mapFields(fields => ({\n _tag: tag(tagValue),\n ...fields\n }), {\n unsafePreserveChecks: true\n }) : TaggedStruct(tagValue, schema);\n return Class(identifier ?? tagValue)(struct, annotations);\n };\n};\n/**\n * Creates a schema-backed error class that can be used as a typed,\n * yieldable error in Effect programs. Combines {@link Class} validation with\n * the `YieldableError` interface so instances can be yielded directly inside\n * `Effect.gen`.\n *\n * **Example** (Schema-backed error)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schema } from \"effect\"\n *\n * class NotFound extends Schema.Error(\"NotFound\")({\n * id: Schema.Number\n * }) {}\n *\n * const program = Effect.gen(function*() {\n * yield* new NotFound({ id: 1 })\n * })\n * const error = await Effect.runPromise(Effect.flip(program))\n * error.id // => 1\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Error = identifier => (schema, annotations) => {\n const struct = isStruct(schema) ? schema : Struct(schema);\n const self = makeClass(core.Error, identifier, struct, annotations, identifier => ({\n name: identifier\n }));\n return self;\n};\n/**\n * Defines a schema-backed yieldable error class with an automatically populated\n * `_tag` field.\n *\n * **When to use**\n *\n * Use to define typed errors that are schema validated, yielded in `Effect.gen`,\n * and matched as tagged union members.\n *\n * **Example** (Defining a tagged error class)\n *\n * ```ts import.meta.vitest\n * import { Effect, Schema } from \"effect\"\n *\n * class NotFound extends Schema.TaggedError()(\"NotFound\", {\n * id: Schema.Number\n * }) {}\n *\n * const program = Effect.gen(function*() {\n * yield* new NotFound({ id: 42 })\n * })\n * const error = await Effect.runPromise(Effect.flip(program))\n * error._tag // => \"NotFound\"\n * error.id // => 42\n * ```\n *\n * @category constructors\n * @since 3.10.0\n */\nexport const TaggedError = identifier => {\n return (tagValue, schema, annotations) => {\n const struct = isStruct(schema) ? schema.mapFields(fields => ({\n _tag: tag(tagValue),\n ...fields\n }), {\n unsafePreserveChecks: true\n }) : TaggedStruct(tagValue, schema);\n return Error(identifier ?? tagValue)(struct, annotations);\n };\n};\n/**\n * Attaches a custom formatter used by `toFormatter`.\n *\n * **Details**\n *\n * Use this when the formatter derived from the schema structure is not suitable.\n * The annotation is applied through this helper because adding it directly to\n * `Annotations.Bottom` would make schemas invariant.\n *\n * @category formatting\n * @since 4.0.0\n */\nexport function overrideToFormatter(toFormatter) {\n return self => self.annotate({\n toFormatter\n });\n}\n/**\n * Derives a string formatter function from a schema. The formatter converts\n * a value to its human-readable string representation, recursing into structs,\n * arrays, and unions.\n *\n * **Details**\n *\n * The optional `onBefore` hook lets you intercept specific AST nodes before\n * the default formatting logic runs.\n *\n * @category formatting\n * @since 4.0.0\n */\nexport function toFormatter(schema, options) {\n return InternalToFormatter.toFormatter(schema.ast, options);\n}\n/**\n * Overrides the equivalence derivation for a schema by supplying a custom\n * `Equivalence`.\n *\n * **When to use**\n *\n * Use when you need a custom equivalence instead of the default structural\n * equivalence derived by {@link toEquivalence}.\n *\n * @category instances\n * @since 4.0.0\n */\nexport function overrideToEquivalence(toEquivalence) {\n return self => self.annotate({\n toEquivalence\n });\n}\n/**\n * Derives an `Equivalence` from a schema. Two values are considered equal when\n * every field (and nested field) compares equal according to the schema\n * structure.\n *\n * **Example** (Comparing structs)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n *\n * const eq = Schema.toEquivalence(Schema.Struct({ id: Schema.Number, name: Schema.String }))\n *\n * eq({ id: 1, name: \"Alice\" }, { id: 1, name: \"Alice\" }) // => true\n * eq({ id: 1, name: \"Alice\" }, { id: 2, name: \"Alice\" }) // => false\n * ```\n *\n * @category instances\n * @since 4.0.0\n */\nexport function toEquivalence(schema) {\n return InternalEquivalence.toEquivalence(schema.ast);\n}\n/**\n * Derives an intermediate `SchemaRepresentation.Document` from the encoded\n * side of a schema.\n *\n * **When to use**\n *\n * Use when you have a `Schema` and need its live structural representation for inspection, persistence, or compilation.\n *\n * **Details**\n *\n * Use {@link toType} before this function to represent the type side instead.\n * The optional reference policy controls which candidates are extracted into the document's reference table. By\n * default, only candidates with a resolved identifier become references; recursive candidates always require one.\n *\n * @see {@link SchemaRepresentation.toRepresentation} for converting a `SchemaAST.AST` directly\n *\n * @category converting\n * @since 4.0.0\n */\nexport function toRepresentation(schema, options) {\n return InternalToRepresentation.toRepresentation(schema.ast, options);\n}\n/**\n * Returns a JSON Schema document using draft 2020-12.\n *\n * **When to use**\n *\n * Use when you need a draft-2020-12 description of the canonical JSON form of a runtime schema.\n *\n * **Details**\n *\n * The `options` parameter controls reference extraction and generation details\n * such as excess properties and synthesized check descriptions; it does not\n * change the draft target. The reference policy receives canonical JSON\n * encoded ASTs. By default, anonymous non-recursive candidates remain inline,\n * while candidates with resolved identifiers become definitions. Declarations\n * are lowered through their `toCodecJson` or `toCodec` annotation when\n * available before the representation document is compiled.\n *\n * The generated document is intended for preliminary validation. JSON Schema\n * and Effect checks do not always have identical semantics, so the Effect\n * decoder remains the final authority. Passing JSON Schema validation does not\n * guarantee that Effect decoding will succeed.\n *\n * **Gotchas**\n *\n * JSON Schema generation is best-effort. String length uses Unicode code points\n * in JSON Schema and UTF-16 code units in Effect. A generated `pattern` cannot\n * retain JavaScript RegExp flags. Object property checks apply to the original\n * input in JSON Schema but to the decoded object in Effect. `oneOf` can also\n * reject values accepted by overlapping Effect union members. Custom\n * `toJsonSchema` annotations are the annotation author's responsibility. When\n * canonical JSON derivation adds an artificial transformation, checks and\n * annotations on its source node are not copied to the JSON target, so they do\n * not appear in the emitted document. Opaque declarations without a structural\n * codec are represented by an unconstrained JSON Schema. The default\n * `onExcessProperty: \"ignore\"` matches the decoder default and leaves\n * unrepresentable index-signature keys open. In `\"error\"` mode, the compiler\n * constrains those keys with `propertyNames` and applies a permissive choice of\n * candidate index value schemas. The Effect decoder enforces the exact\n * key-value association.\n *\n * @see {@link SchemaRepresentation.toJsonSchemaDocument} for compiling an existing live representation document\n *\n * @category converting\n * @since 4.0.0\n */\nexport function toJsonSchemaDocument(schema, options) {\n const document = InternalToRepresentation.toRepresentation(InternalToCodec.toCodecJsonAST(schema.ast), options);\n return InternalToJsonSchemaDocument.toJsonSchemaDocument(document, options);\n}\n/**\n * Derives a canonical JSON codec from a schema. The encoded form is `Json`, and\n * decoding produces the schema's `Type`.\n *\n * **Details**\n *\n * Derivation does not run transformations. Annotation links may be asynchronous,\n * may fail, and may use optional services; the consuming parser chooses the\n * execution and failure handling. Because hooks do not widen the returned\n * service types, links cannot require services not declared by the input schema.\n *\n * **Gotchas**\n *\n * Declarations without a `toCodecJson` or `toCodec` annotation use `Json` as\n * their encoded schema. This keeps codec construction total, but encoding or\n * decoding can still fail when declaration values are not JSON values. A\n * `toCodecJson` callback can return `undefined` when the declaration is already\n * in canonical JSON form. When derivation adds an artificial transformation,\n * checks and annotations remain on its source node rather than being copied to\n * the JSON target. Source checks still run after the transformation.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toCodecJson = InternalToCodec.toCodecJson;\n/**\n * Derives an isomorphism codec from a schema. The encoded form is the schema's\n * `Iso` type — the intermediate representation used for round-tripping.\n *\n * **Details**\n *\n * Annotation links may be asynchronous, may fail, and may use optional services;\n * the consuming parser chooses the execution and failure handling.\n *\n * **Gotchas**\n *\n * Links cannot require services because the returned `Codec` does not expose\n * service requirements.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toCodecIso = InternalToCodec.toCodecIso;\n/**\n * Converts a schema to the StringTree canonical codec, where every leaf value\n * becomes a string while preserving the original structure.\n *\n * **Details**\n *\n * Derivation does not run transformations. Annotation links may be asynchronous,\n * may fail, and may use optional services; the consuming parser chooses the\n * execution and failure handling. Links cannot require services not declared by\n * the input schema because hooks do not widen the returned service types.\n *\n * **Gotchas**\n *\n * Declarations must provide a structural `toCodecStringTree`, `toCodecJson`, or\n * `toCodec` encoding. A callback can return `undefined` when the declaration is\n * already in canonical StringTree form.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toCodecStringTree = InternalToCodec.toCodecStringTree;\n/**\n * Allows array schemas to decode from either an array input or a single value\n * input.\n *\n * **When to use**\n *\n * Use when you need to accept transport formats that may represent a\n * single-item array as a bare value, such as query-string or form-data adapters.\n *\n * **Gotchas**\n *\n * This combinator is intentionally not part of `toCodecStringTree`; it adds a\n * decoding convenience rather than a canonical StringTree representation. It\n * does not parse comma-separated strings.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toCodecArrayFromSingle = InternalToCodec.toCodecArrayFromSingle;\n/**\n * Derives an XML encoder from a codec.\n *\n * **Details**\n *\n * The returned function encodes a value through `toCodecStringTree` and returns\n * an `Effect` that succeeds with the XML string or fails with a\n * {@link SchemaIssue.Issue} if codec encoding fails.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function toEncoderXml(codec, options) {\n return InternalToEncoderXml.toEncoderXml(codec, options);\n}\n/**\n * Derives an `Iso` optic from a schema that isomorphically converts between\n * the schema's `Type` and its `Iso` (intermediate / serialized form).\n *\n * **Details**\n *\n * Reading through the `Iso` encodes the schema value, while replacing through\n * it decodes the new focus.\n *\n * **Gotchas**\n *\n * This API runs synchronously, so failing, asynchronous, or service-dependent\n * transformations can throw. Schema failures use `\"Schema validation failed\"`\n * with a `SchemaIssue.Issue` in `cause`; format it with\n * `SchemaIssue.makeFormatterDefault()`. Consume {@link toCodecIso} with an\n * effectful parser for asynchronous execution or explicit failure handling.\n *\n * @category converting\n * @since 4.0.0\n */\nexport function toIso(schema) {\n return InternalToIso.toIso(schema);\n}\n/**\n * Returns an identity `Iso` over the schema's source (`Type`) side.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function toIsoSource(schema) {\n return InternalToIso.toIsoSource(schema);\n}\n/**\n * Returns an identity `Iso` over the schema's focus (`Iso`) side.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function toIsoFocus(schema) {\n return InternalToIso.toIsoFocus(schema);\n}\n/**\n * Overrides a schema's derived ISO codec with an explicit target codec.\n *\n * **When to use**\n *\n * Use to provide a custom ISO transformation when the default derivation is not\n * appropriate.\n *\n * **Details**\n *\n * The resulting schema carries a custom `Iso` type parameter and uses the\n * provided `decode` and `encode` getters to transform between the schema type\n * and the target codec.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport function overrideToCodecIso(to, transformation) {\n return schema => {\n return make(SchemaAST.annotate(schema.ast, {\n toCodecIso: () => new SchemaAST.Link(to.ast, SchemaTransformation.make(transformation))\n }), {\n schema\n });\n };\n}\n/**\n * Derives a JSON Patch differ from a codec. Serializes values to JSON (via\n * {@link toCodecJson}), computes RFC 6902 JSON Patch operations between old\n * and new values, and can apply patches back to the typed value.\n *\n * **Details**\n *\n * `diff` encodes both values before computing the patch. `patch` encodes the old\n * value, applies the patch to its JSON representation, and decodes the result.\n *\n * **Gotchas**\n *\n * This API runs synchronously, so failing, asynchronous, or service-dependent\n * transformations can throw. Schema failures use `\"Schema validation failed\"`\n * with a `SchemaIssue.Issue` in `cause`; format it with\n * `SchemaIssue.makeFormatterDefault()`. Invalid patch operations instead produce\n * {@link JsonPatch.apply} errors.\n *\n * @category converting\n * @since 4.0.0\n */\nexport function toDifferJsonPatch(schema) {\n return InternalToDifferJsonPatch.toDifferJsonPatch(schema);\n}\n/**\n * Creates a recursive schema for a {@link Tree} of values described by `node`.\n * The resulting schema accepts a single node value, an array of trees, or an\n * object whose values are trees.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport function Tree(node) {\n const Tree$ref = suspend(() => Tree);\n const Tree = Union([node, ArraySchema(Tree$ref), Record(String, Tree$ref)]);\n return Tree;\n}\n/**\n * Schema that accepts and validates any immutable JSON-compatible value.\n *\n * **Example** (Validating a JSON value)\n *\n * ```ts import.meta.vitest\n * import { Option, Schema } from \"effect\"\n *\n * Schema.decodeUnknownOption(Schema.Json)({ key: [1, true, null] }) // => Option.some({ key: [1, true, null] })\n * ```\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const Json = /*#__PURE__*/make(/*#__PURE__*/SchemaAST.annotate(SchemaAST.Json, {\n toCode: () => ({\n runtime: \"Schema.Json\",\n Type: \"Schema.Json\"\n })\n}));\n/**\n * Schema for readonly string-keyed records whose values are JSON-compatible.\n *\n * **When to use**\n *\n * Use when you need to validate a JSON object rather than any JSON value.\n *\n * **Example** (Validating a JSON object)\n *\n * ```ts import.meta.vitest\n * import { Option, Schema } from \"effect\"\n *\n * Schema.decodeUnknownOption(Schema.JsonObject)({ key: [1, true, null] }) // => Option.some({ key: [1, true, null] })\n * Schema.decodeUnknownOption(Schema.JsonObject)([1, 2, 3]) // => Option.none()\n * ```\n *\n * @see {@link Json} for a schema that also accepts JSON arrays and primitive values\n * @category schemas\n * @since 4.0.0\n */\nexport const JsonObject = /*#__PURE__*/Record(String, Json);\nconst JsonError = /*#__PURE__*/Struct({\n message: String,\n name: /*#__PURE__*/optionalKey(String),\n stack: /*#__PURE__*/optionalKey(String),\n cause: /*#__PURE__*/optionalKey(Json)\n});\n/**\n * Schema that accepts any mutable JSON-compatible value. See {@link Json} for\n * the immutable variant.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const MutableJson = /*#__PURE__*/make(/*#__PURE__*/SchemaAST.annotate(SchemaAST.MutableJson, {\n toCode: () => ({\n runtime: \"Schema.MutableJson\",\n Type: \"Schema.MutableJson\"\n })\n}));\n/**\n * Resolves the typed annotations from a schema. The term \"resolve\" (rather\n * than \"get\") reflects the lookup strategy: if the schema has checks, the\n * annotations are taken from the last check; otherwise they are taken from\n * the base schema instance.\n *\n * @category getters\n * @since 4.0.0\n */\nexport function resolveAnnotations(schema) {\n return InternalAnnotations.resolve(schema.ast);\n}\n/**\n * Resolves the context (key-level) annotations from a schema. Context\n * annotations are those attached via `annotateKey` and live on the AST's\n * `context` rather than on the schema node itself.\n *\n * @category getters\n * @since 4.0.0\n */\nexport function resolveAnnotationsKey(schema) {\n return schema.ast.context?.annotations;\n}\n//# sourceMappingURL=Schema.js.map","import * as Context from \"./Context.js\";\nimport * as Predicate from \"./Predicate.js\";\nimport * as Schema from \"./Schema.js\";\nconst TypeId = \"~effect/Terminal\";\nconst QuitErrorTypeId = \"~effect/Terminal/QuitError\";\n/**\n * Represents an error that occurs when a user attempts to\n * quit out of a `Terminal` prompt for input (usually by entering `ctrl`+`c`).\n *\n * **When to use**\n *\n * Use when implementing terminal input or prompts that need to signal\n * user-requested cancellation through the typed error channel.\n *\n * @see {@link isQuitError} for checking unknown errors when handling terminal cancellation\n *\n * @category errors\n * @since 4.0.0\n */\nexport class QuitError extends /*#__PURE__*/Schema.Error(\"QuitError\")({\n _tag: /*#__PURE__*/Schema.tag(\"QuitError\")\n}) {\n /**\n * Marks this value as a terminal quit error for runtime guards.\n *\n * @since 4.0.0\n */\n [QuitErrorTypeId] = QuitErrorTypeId;\n}\n/**\n * Returns `true` if the provided value is a `Terminal.QuitError`.\n *\n * **When to use**\n *\n * Use to narrow unknown failures to `QuitError` when handling terminal input\n * cancellation.\n *\n * **Details**\n *\n * Returns `true` when the value carries the `QuitError` runtime marker and\n * narrows it to `QuitError`.\n *\n * @see {@link QuitError} for the error value produced when terminal input is quit\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isQuitError = u => Predicate.hasProperty(u, QuitErrorTypeId);\n/**\n * Service tag for command-line input and output services.\n *\n * **When to use**\n *\n * Use to access or provide platform terminal capabilities such as reading\n * input, writing output, and inspecting terminal dimensions.\n *\n * @category services\n * @since 4.0.0\n */\nexport const Terminal = /*#__PURE__*/Context.Service(\"effect/Terminal\");\n/**\n * Creates a `Terminal` service implementation.\n *\n * **When to use**\n *\n * Use to construct a custom `Terminal` service implementation from concrete\n * terminal capabilities when writing a platform adapter, test implementation,\n * or custom runtime service.\n *\n * **Details**\n *\n * The implementation object supplies `columns`, `rows`, `readInput`,\n * `readLine`, and `display`; `make` attaches the `Terminal` service marker so\n * the result can be provided through the `Terminal` context service.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = impl => Terminal.of({\n ...impl,\n [TypeId]: TypeId\n});\n//# sourceMappingURL=Terminal.js.map","import * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Option from \"effect/Option\";\nimport { badArgument } from \"effect/PlatformError\";\nimport * as Predicate from \"effect/Predicate\";\nimport * as Queue from \"effect/Queue\";\nimport * as RcRef from \"effect/RcRef\";\nimport * as Terminal from \"effect/Terminal\";\nimport * as readline from \"node:readline\";\n/**\n * Creates a scoped process-backed `Terminal` using Node `readline`, enabling\n * TTY raw mode while in scope and using the supplied predicate to decide when\n * key input should end.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = /*#__PURE__*/Effect.fnUntraced(function* (shouldQuit = defaultShouldQuit) {\n const stdin = process.stdin;\n const stdout = process.stdout;\n const lines = yield* Queue.make();\n // stdin \"end\" fires once per process, so remember end-of-input for readers\n // created after the event (Bun never sets `readableEnded`).\n let inputEnded = stdin.readableEnded;\n let readlineActive = false;\n const onStdinEnd = () => {\n inputEnded = true;\n if (!readlineActive) {\n Queue.endUnsafe(lines);\n }\n };\n stdin.once(\"end\", onStdinEnd);\n yield* Effect.addFinalizer(() => Effect.sync(() => stdin.off(\"end\", onStdinEnd)));\n const rlRef = yield* RcRef.make({\n acquire: Effect.acquireRelease(Effect.sync(() => {\n const rl = readline.createInterface({\n input: stdin,\n escapeCodeTimeout: 50\n });\n const onLine = line => Queue.offerUnsafe(lines, line);\n const onClose = () => {\n readlineActive = false;\n Queue.endUnsafe(lines);\n };\n readlineActive = true;\n readline.emitKeypressEvents(stdin, rl);\n rl.on(\"line\", onLine);\n rl.once(\"close\", onClose);\n if (stdin.isTTY) {\n stdin.setRawMode(true);\n }\n return {\n rl,\n onClose,\n onLine\n };\n }), ({\n rl,\n onClose,\n onLine\n }) => Effect.sync(() => {\n readlineActive = false;\n rl.off(\"line\", onLine);\n rl.off(\"close\", onClose);\n if (stdin.isTTY) {\n stdin.setRawMode(false);\n }\n rl.close();\n if (inputEnded) {\n Queue.endUnsafe(lines);\n }\n })),\n idleTimeToLive: \"10 millis\"\n });\n const columns = Effect.sync(() => stdout.columns ?? 0);\n const rows = Effect.sync(() => stdout.rows ?? 0);\n const readInput = Effect.gen(function* () {\n const queue = yield* Queue.make();\n const handleKeypress = (s, k) => {\n const userInput = {\n input: Option.fromUndefinedOr(s),\n key: {\n name: k.name ?? \"\",\n ctrl: !!k.ctrl,\n meta: !!k.meta,\n shift: !!k.shift\n }\n };\n Queue.offerUnsafe(queue, userInput);\n if (shouldQuit(userInput)) {\n Queue.endUnsafe(queue);\n }\n };\n // Deno's `process.stdin` shim does not keep the event loop alive, so a\n // program blocked on input can exit before `end` is ever delivered. A\n // timer holds the loop open for as long as this reader is active.\n const keepAlive = setInterval(() => {}, 2147483647);\n // Without this, consumers (e.g. `Prompt.run`) hang forever on closed stdin.\n const handleEnd = () => {\n clearInterval(keepAlive);\n Queue.endUnsafe(queue);\n };\n yield* Effect.addFinalizer(() => Effect.sync(() => {\n clearInterval(keepAlive);\n stdin.off(\"keypress\", handleKeypress);\n stdin.off(\"end\", handleEnd);\n }));\n stdin.on(\"keypress\", handleKeypress);\n if (inputEnded) {\n handleEnd();\n } else {\n yield* RcRef.get(rlRef);\n stdin.once(\"end\", handleEnd);\n }\n return queue;\n });\n const readLine = Effect.suspend(() => Queue.poll(lines).pipe(Effect.flatMap(Option.match({\n onNone: () => Effect.scoped(Effect.andThen(RcRef.get(rlRef), Queue.take(lines))),\n onSome: Effect.succeed\n })), Effect.mapError(() => new Terminal.QuitError({}))));\n const display = prompt => Effect.uninterruptible(Effect.callback(resume => {\n stdout.write(prompt, err => Predicate.isNullish(err) ? resume(Effect.void) : resume(Effect.fail(badArgument({\n module: \"Terminal\",\n method: \"display\",\n description: \"Failed to write prompt to stdout\",\n cause: err\n }))));\n }));\n return Terminal.make({\n columns,\n rows,\n readInput,\n readLine,\n display\n });\n});\n/**\n * Provides the default process-backed `Terminal` service, ending key input on\n * Ctrl+C or Ctrl+D.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = /*#__PURE__*/Layer.effect(Terminal.Terminal, /*#__PURE__*/make(defaultShouldQuit));\nfunction defaultShouldQuit(input) {\n return input.key.ctrl && (input.key.name === \"c\" || input.key.name === \"d\");\n}\n//# sourceMappingURL=NodeTerminal.js.map","/**\n * Node.js implementation of the Effect `Terminal` service.\n *\n * This module reuses the shared Node terminal implementation. `make` creates a\n * scoped process-backed `Terminal` service, and `layer` provides the default\n * service with the standard quit behavior for key input.\n *\n * @since 4.0.0\n */\nimport * as NodeTerminal from \"@effect/platform-node-shared/NodeTerminal\";\n/**\n * Creates a scoped `Terminal` service backed by process stdin/stdout, using the\n * optional predicate to decide when key input should end the input stream.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = NodeTerminal.make;\n/**\n * Provides the default process-backed `Terminal` service, ending key input on\n * the default quit keys.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = NodeTerminal.layer;\n//# sourceMappingURL=NodeTerminal.js.map","import * as Layer from \"effect/Layer\";\nimport * as NodeChildProcessSpawner from \"./NodeChildProcessSpawner.js\";\nimport * as NodeCrypto from \"./NodeCrypto.js\";\nimport * as NodeFileSystem from \"./NodeFileSystem.js\";\nimport * as NodePath from \"./NodePath.js\";\nimport * as NodeStdio from \"./NodeStdio.js\";\nimport * as NodeTerminal from \"./NodeTerminal.js\";\n/**\n * Provides the default Node implementations for child process spawning,\n * filesystem, path, stdio, and terminal services.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = /*#__PURE__*/Layer.provideMerge(NodeChildProcessSpawner.layer, /*#__PURE__*/Layer.mergeAll(NodeFileSystem.layer, NodeCrypto.layer, NodePath.layer, NodeStdio.layer, NodeTerminal.layer));\n//# sourceMappingURL=NodeServices.js.map","import * as Channel from \"./Channel.js\";\nimport * as Effect from \"./Effect.js\";\nimport { dual } from \"./Function.js\";\nimport * as Schema from \"./Schema.js\";\n/**\n * Creates a channel that encodes non-empty chunks of schema values into the\n * schema's encoded representation.\n *\n * **When to use**\n *\n * Use to encode typed channel input into the schema's encoded representation\n * before passing chunks to an encoded downstream boundary.\n *\n * **Details**\n *\n * Encoding failures are emitted as `SchemaError`, and any encoding services\n * required by the schema become channel requirements.\n *\n * @see {@link encodeUnknown} for encoded output chunks that should be typed as `unknown`\n * @see {@link decode} for the inverse channel that decodes encoded chunks into schema values\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const encode = schema => () => {\n const encode = Schema.encodeEffect(Schema.NonEmptyArray(schema));\n return Channel.fromTransform((upstream, _scope) => Effect.succeed(Effect.flatMap(upstream, chunk => encode(chunk))));\n};\n/**\n * Creates an `encode` channel variant whose encoded output chunks are typed as\n * `unknown`.\n *\n * **When to use**\n *\n * Use when a channel boundary should encode typed input chunks while the encoded\n * output representation is intentionally untyped.\n *\n * @see {@link encode} for the variant that preserves the schema encoded type\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const encodeUnknown = encode;\n/**\n * Creates a channel that decodes non-empty chunks from the schema's encoded\n * representation into schema values.\n *\n * **When to use**\n *\n * Use to validate and decode encoded channel output into typed schema values\n * before application code consumes it.\n *\n * **Details**\n *\n * Decoding failures are emitted as `SchemaError`, and any decoding services\n * required by the schema become channel requirements.\n *\n * @see {@link decodeUnknown} for boundaries where the encoded input side is intentionally untyped\n * @see {@link encode} for the inverse adapter that encodes typed schema values\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const decode = schema => () => {\n const decode = Schema.decodeEffect(Schema.NonEmptyArray(schema));\n return Channel.fromTransform((upstream, _scope) => Effect.succeed(Effect.flatMap(upstream, chunk => decode(chunk))));\n};\n/**\n * Creates a `decode` channel variant for schema-decoding channel boundaries.\n *\n * **When to use**\n *\n * Use when you need an intentionally unknown or untyped encoded input while\n * keeping only the decoded output statically typed according to the schema.\n *\n * **Details**\n *\n * The channel decodes non-empty encoded chunks into schema values, emits\n * `SchemaError` when decoding fails, and requires the schema's decoding\n * services.\n *\n * @see {@link decode} for the typed variant that preserves the schema's encoded type\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const decodeUnknown = decode;\n/**\n * Wraps a channel so callers work with typed input and output chunks while the\n * wrapped channel uses encoded chunks.\n *\n * **When to use**\n *\n * Use to expose typed input and output at a bidirectional channel boundary\n * while the wrapped channel continues to operate on schema-encoded chunks.\n *\n * **Details**\n *\n * Values sent into the resulting channel are encoded with `inputSchema` before\n * reaching the wrapped channel. Values emitted by the wrapped channel are\n * decoded with `outputSchema` before they are emitted downstream. Schema\n * failures are surfaced as `SchemaError`.\n *\n * @see {@link duplexUnknown} for the variant whose encoded side is intentionally untyped\n * @see {@link encode} for encoding typed chunks at one-way channel boundaries\n * @see {@link decode} for decoding encoded chunks at one-way channel boundaries\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const duplex = /*#__PURE__*/dual(2, (self, options) => encode(options.inputSchema)().pipe(Channel.pipeTo(self), Channel.pipeTo(decode(options.outputSchema)())));\n/**\n * Wraps a bidirectional channel whose encoded chunks are typed as `unknown`.\n *\n * **When to use**\n *\n * Use when you need a bidirectional channel to cross an encoded boundary whose\n * chunk types are intentionally erased, while callers send and receive\n * schema-typed chunks.\n *\n * **Details**\n *\n * The resulting channel accepts typed input chunks, encodes them with\n * `inputSchema`, decodes unknown output chunks with `outputSchema`, and\n * surfaces schema failures as `SchemaError`.\n *\n * @see {@link duplex} for the variant that preserves the schema encoded types on the wrapped channel\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const duplexUnknown = duplex;\n//# sourceMappingURL=ChannelSchema.js.map","import * as Effect from \"./Effect.js\";\nimport * as effect from \"./internal/effect.js\";\nimport * as references from \"./internal/references.js\";\nimport * as Layer from \"./Layer.js\";\nimport * as LogLevel from \"./LogLevel.js\";\n/**\n * Runtime type identifier attached to `ErrorReporter` values.\n *\n * **Details**\n *\n * This marker is part of the runtime representation of `ErrorReporter`\n * implementations. Most code should create reporters with `make` and register\n * them with `layer`.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = \"~effect/ErrorReporter\";\n/**\n * Creates an `ErrorReporter` from a callback.\n *\n * **When to use**\n *\n * Use to define how reported failures are forwarded to a logging, monitoring,\n * or error-tracking backend.\n *\n * **Details**\n *\n * The returned reporter automatically deduplicates causes and individual\n * errors (the same object is never reported twice), skips interruptions,\n * and resolves the `ignore`, `severity`, and `attributes` annotations on\n * each error before invoking your callback.\n *\n * **Example** (Forwarding errors to a callback)\n *\n * ```ts import.meta.vitest\n * import { Effect, ErrorReporter } from \"effect\"\n *\n * const reports: Array<{ message: string; severity: string; attributes: object }> = []\n * const reporter = ErrorReporter.make(({ error, severity, attributes }) => {\n * reports.push({ message: error.message, severity, attributes })\n * })\n *\n * const program = Effect.fail(new Error(\"boom\")).pipe(\n * Effect.withErrorReporting,\n * Effect.provide(ErrorReporter.layer([reporter])),\n * Effect.exit\n * )\n *\n * await Effect.runPromise(program)\n * reports // => [{ message: \"boom\", severity: \"Info\", attributes: {} }]\n * ```\n *\n * @see {@link layer} for registering reporters in the environment\n * @see {@link report} for manually reporting a `Cause`\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = report => {\n const reported = new WeakSet();\n return {\n [TypeId]: TypeId,\n report(options) {\n if (reported.has(options.cause)) return;\n reported.add(options.cause);\n for (let i = 0; i < options.cause.reasons.length; i++) {\n const reason = options.cause.reasons[i];\n if (reason._tag === \"Interrupt\") continue;\n const original = reason._tag === \"Fail\" ? reason.error : reason.defect;\n const isObject = typeof original === \"object\" && original !== null;\n if (isObject) {\n if (reported.has(original)) continue;\n reported.add(original);\n }\n if (isIgnored(original)) continue;\n const pretty = effect.causePrettyError(original, reason.annotations);\n report({\n ...options,\n error: pretty,\n severity: isObject ? getSeverity(original) : \"Info\",\n attributes: isObject ? getAttributes(original) : emptyAttributes\n });\n }\n }\n };\n};\n/**\n * Context reference that holds the set of active error reporters for the\n * current fiber. Defaults to an empty set (no reporting).\n *\n * **When to use**\n *\n * Use when you need to read or replace the current set of error reporters\n * directly.\n *\n * @category services\n * @since 4.0.0\n */\nexport const CurrentErrorReporters = references.CurrentErrorReporters;\n/**\n * Creates a `Layer` that registers one or more `ErrorReporter`s.\n *\n * **When to use**\n *\n * Use to provide one or more error reporters to effects that perform error\n * reporting.\n *\n * **Details**\n *\n * Reporters can be plain `ErrorReporter` values or effectful\n * `Effect` values that are resolved when the layer is built. By\n * default the provided reporters **replace** any previously registered\n * reporters. Set `mergeWithExisting: true` to add them alongside existing ones.\n *\n * **Example** (Providing error reporters)\n *\n * ```ts import.meta.vitest\n * import { Effect, ErrorReporter } from \"effect\"\n *\n * const reports: Array = []\n * const firstReporter = ErrorReporter.make(({ error, severity }) => {\n * reports.push(`[${severity}] ${error.message}`)\n * })\n * const secondReporter = ErrorReporter.make(({ error, severity }) => {\n * reports.push(`${severity}: ${error.message}`)\n * })\n *\n * // Replace all existing reporters\n * const ReporterLayer = ErrorReporter.layer([\n * firstReporter,\n * secondReporter\n * ])\n *\n * // Add to existing reporters instead of replacing\n * const ReporterMerged = ErrorReporter.layer(\n * [secondReporter],\n * { mergeWithExisting: true }\n * )\n *\n * const program = Effect.fail(\"boom\").pipe(\n * Effect.withErrorReporting,\n * Effect.provide(ReporterLayer),\n * Effect.exit\n * )\n *\n * await Effect.runPromise(program)\n * reports // => [\"[Info] boom\", \"Info: boom\"]\n * ```\n *\n * @see {@link make} for creating an `ErrorReporter` from a callback\n * @see {@link CurrentErrorReporters} for low-level access to the current reporters\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = (reporters, options) => Layer.effect(CurrentErrorReporters, Effect.withFiber(Effect.fnUntraced(function* (fiber) {\n const currentReporters = new Set(options?.mergeWithExisting === true ? fiber.getRef(references.CurrentErrorReporters) : []);\n for (const reporter of reporters) {\n currentReporters.add(Effect.isEffect(reporter) ? yield* reporter : reporter);\n }\n return currentReporters;\n})));\n/**\n * Runs all registered error reporters on the current fiber for a `Cause`.\n *\n * **When to use**\n *\n * Use to report a failure for observability without failing the current fiber.\n *\n * **Example** (Reporting a cause manually)\n *\n * ```ts import.meta.vitest\n * import { Cause, Effect, ErrorReporter } from \"effect\"\n *\n * const messages: Array = []\n * const program = Effect.gen(function*() {\n * const cause = Cause.fail(\"something went wrong\")\n * yield* ErrorReporter.report(cause)\n * return \"fallback value\"\n * })\n *\n * const reporter = ErrorReporter.make(({ error }) => messages.push(error.message))\n * const output = await Effect.runPromise(\n * Effect.provide(program, ErrorReporter.layer([reporter]))\n * )\n * messages // => [\"something went wrong\"]\n * output // => \"fallback value\"\n * ```\n *\n * @category logging\n * @since 4.0.0\n */\nexport const report = cause => Effect.withFiber(fiber => {\n effect.reportCauseUnsafe(fiber, cause);\n return Effect.void;\n});\n/**\n * Defines the runtime property key used to mark an object error as ignored by error\n * reporting.\n *\n * **When to use**\n *\n * Use to suppress reporting for expected object errors, such as HTTP 404\n * responses.\n *\n * **Details**\n *\n * Set `error[ErrorReporter.ignore]` to `true` to prevent the error from being\n * forwarded to reporters. This is useful for expected failures such as HTTP 404\n * responses.\n *\n * **Example** (Marking errors as ignored)\n *\n * ```ts import.meta.vitest\n * import { Data, ErrorReporter } from \"effect\"\n *\n * class NotFoundError extends Data.TaggedError(\"NotFoundError\")<{}> {\n * readonly [ErrorReporter.ignore] = true\n * }\n *\n * ErrorReporter.isIgnored(new NotFoundError()) // => true\n * ```\n *\n * @see {@link isIgnored} for checking whether a value carries this annotation\n * @see {@link Reportable} for the annotation contract recognized on object\n * errors\n *\n * @category annotations\n * @since 4.0.0\n */\nexport const ignore = \"~effect/ErrorReporter/ignore\";\n/**\n * Returns `true` if the given value has the `ErrorReporter.ignore` annotation\n * set to `true`.\n *\n * **When to use**\n *\n * Use to check whether an error value is annotated to be skipped before\n * forwarding it to error reporting code.\n *\n * @see {@link ignore} for the annotation key this predicate reads\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isIgnored = u => typeof u === \"object\" && u !== null && ignore in u && u[ignore] === true;\n/**\n * Defines the runtime property key used to override the severity level of an object error.\n *\n * **When to use**\n *\n * Use to annotate object errors with the severity reporter callbacks should\n * receive.\n *\n * **Details**\n *\n * Set `error[ErrorReporter.severity]` to a valid `LogLevel.Severity` value.\n * Missing or invalid values fall back to `\"Info\"`.\n *\n * **Example** (Setting error severity annotations)\n *\n * ```ts import.meta.vitest\n * import { Data, ErrorReporter } from \"effect\"\n *\n * class DeprecationWarning extends Data.TaggedError(\"DeprecationWarning\")<{}> {\n * readonly [ErrorReporter.severity] = \"Warn\" as const\n * }\n *\n * ErrorReporter.getSeverity(new DeprecationWarning()) // => \"Warn\"\n * ```\n *\n * @see {@link getSeverity} for reading the severity stored under this key\n * @see {@link Reportable} for the annotation contract recognized on object\n * errors\n *\n * @category annotations\n * @since 4.0.0\n */\nexport const severity = \"~effect/ErrorReporter/severity\";\n/**\n * Reads the `ErrorReporter.severity` annotation from an error object,\n * falling back to `\"Info\"` when the annotation is unset or invalid.\n *\n * **When to use**\n *\n * Use to inspect the severity that reporter callbacks will receive for an\n * object error.\n *\n * @see {@link severity} for the annotation key used to override severity\n * @see {@link Reportable} for the annotation properties recognized on object errors\n *\n * @category annotations\n * @since 4.0.0\n */\nexport const getSeverity = error => {\n if (severity in error && LogLevel.values.includes(error[severity])) {\n return error[severity];\n }\n return \"Info\";\n};\n/**\n * Defines the runtime property key used to attach extra key/value metadata to an object\n * error report.\n *\n * **When to use**\n *\n * Use to attach domain metadata to object errors so reporter callbacks receive\n * it with the reported failure.\n *\n * **Details**\n *\n * Set `error[ErrorReporter.attributes]` to a record of metadata that should be\n * forwarded to reporters alongside the error.\n *\n * **Example** (Setting error attributes)\n *\n * ```ts import.meta.vitest\n * import { Data, ErrorReporter } from \"effect\"\n *\n * class PaymentError extends Data.TaggedError(\"PaymentError\")<{\n * readonly orderId: string\n * }> {\n * readonly [ErrorReporter.attributes] = {\n * orderId: this.orderId\n * }\n * }\n *\n * ErrorReporter.getAttributes(new PaymentError({ orderId: \"order-123\" })) // => { orderId: \"order-123\" }\n * ```\n *\n * @see {@link ignore} for suppressing reports for expected object errors\n * @see {@link severity} for overriding reporter severity\n * @see {@link getAttributes} for reading the metadata stored under this key\n * @see {@link Reportable} for the annotation contract recognized on object\n * errors\n *\n * @category annotations\n * @since 4.0.0\n */\nexport const attributes = \"~effect/ErrorReporter/attributes\";\n/**\n * Reads the `ErrorReporter.attributes` annotation from an error object,\n * returning an empty record when unset.\n *\n * **When to use**\n *\n * Use to inspect the attributes that reporter callbacks will receive for an\n * object error.\n *\n * **Details**\n *\n * Returns the value stored under `ErrorReporter.attributes`, or the module's\n * shared empty record when the annotation is absent.\n *\n * **Gotchas**\n *\n * The annotation value is returned as-is; this helper does not validate or\n * clone it.\n *\n * @see {@link attributes} for the annotation key used to attach metadata\n * @see {@link Reportable} for the annotation properties recognized on object errors\n *\n * @category annotations\n * @since 4.0.0\n */\nexport const getAttributes = error => {\n return attributes in error ? error[attributes] : emptyAttributes;\n};\nconst emptyAttributes = {};\n//# sourceMappingURL=ErrorReporter.js.map","import { dual, identity } from \"../Function.js\";\nimport * as Option from \"../Option.js\";\nimport { pipeArguments } from \"../Pipeable.js\";\nimport * as Result from \"../Result.js\";\n/** @internal */\nexport const TypeId = \"~effect/Match/Matcher\";\nconst TypeMatcherProto = {\n [TypeId]: {\n _input: identity,\n _filters: identity,\n _remaining: identity,\n _result: identity,\n _return: identity,\n _args: identity\n },\n _tag: \"TypeMatcher\",\n add(_case) {\n return makeTypeMatcher(this.select, [...this.cases, _case]);\n },\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\nfunction makeTypeMatcher(select, cases) {\n const matcher = Object.create(TypeMatcherProto);\n matcher.select = select;\n matcher.cases = cases;\n return matcher;\n}\nconst ValueMatcherProto = {\n [TypeId]: {\n _input: identity,\n _filters: identity,\n _result: identity,\n _return: identity,\n _flavor: identity\n },\n _tag: \"ValueMatcher\",\n add(_case) {\n if (Result.isSuccess(this.value)) {\n return this;\n }\n if (_case._tag === \"When\" && _case.guard(this.provided) === true) {\n return makeValueMatcher(this.provided, Result.succeed(_case.evaluate(this.provided)));\n } else if (_case._tag === \"Not\" && _case.guard(this.provided) === false) {\n return makeValueMatcher(this.provided, Result.succeed(_case.evaluate(this.provided)));\n }\n return this;\n },\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\nfunction makeValueMatcher(provided, value) {\n const matcher = Object.create(ValueMatcherProto);\n matcher.provided = provided;\n matcher.value = value;\n return matcher;\n}\nconst makeWhen = (guard, evaluate) => ({\n _tag: \"When\",\n guard,\n evaluate\n});\nconst makeNot = (guard, evaluate) => ({\n _tag: \"Not\",\n guard,\n evaluate\n});\nconst makePredicate = pattern => {\n if (typeof pattern === \"function\") {\n return pattern;\n } else if (Array.isArray(pattern)) {\n const predicates = pattern.map(makePredicate);\n const len = predicates.length;\n return u => {\n if (!Array.isArray(u)) {\n return false;\n }\n for (let i = 0; i < len; i++) {\n if (predicates[i](u[i]) === false) {\n return false;\n }\n }\n return true;\n };\n } else if (pattern !== null && typeof pattern === \"object\") {\n const keysAndPredicates = Reflect.ownKeys(pattern).map(key => [key, makePredicate(pattern[key])]);\n const len = keysAndPredicates.length;\n return u => {\n if (typeof u !== \"object\" || u === null) {\n return false;\n }\n for (let i = 0; i < len; i++) {\n const [key, predicate] = keysAndPredicates[i];\n if (!(key in u) || predicate(u[key]) === false) {\n return false;\n }\n }\n return true;\n };\n }\n return u => u === pattern;\n};\nconst makeOrPredicate = patterns => {\n const predicates = patterns.map(makePredicate);\n const len = predicates.length;\n return u => {\n for (let i = 0; i < len; i++) {\n if (predicates[i](u) === true) {\n return true;\n }\n }\n return false;\n };\n};\nconst makeAndPredicate = patterns => {\n const predicates = patterns.map(makePredicate);\n const len = predicates.length;\n return u => {\n for (let i = 0; i < len; i++) {\n if (predicates[i](u) === false) {\n return false;\n }\n }\n return true;\n };\n};\n/** @internal */\nexport const type = () => makeTypeMatcher(identity, []);\n/** @internal */\nexport const fn = select => makeTypeMatcher(select, []);\n/** @internal */\nexport const value = i => makeValueMatcher(i, Result.fail(i));\n/** @internal */\nexport const valueTags = /*#__PURE__*/dual(2, (input, fields) => {\n const match = tagsExhaustive(fields)(makeTypeMatcher(identity, []));\n return match(input);\n});\n/** @internal */\nexport const typeTags = () => fields => {\n const match = tagsExhaustive(fields)(makeTypeMatcher(identity, []));\n return input => match(input);\n};\n/** @internal */\nexport const withReturnType = () => self => self;\n/** @internal */\nexport const when = (pattern, f) => self => self.add(makeWhen(makePredicate(pattern), f));\n/** @internal */\nexport const whenOr = (...args) => self => {\n const onMatch = args[args.length - 1];\n const patterns = args.slice(0, -1);\n return self.add(makeWhen(makeOrPredicate(patterns), onMatch));\n};\n/** @internal */\nexport const whenAnd = (...args) => self => {\n const onMatch = args[args.length - 1];\n const patterns = args.slice(0, -1);\n return self.add(makeWhen(makeAndPredicate(patterns), onMatch));\n};\n/** @internal */\nexport const discriminator = field => (...pattern) => {\n const f = pattern[pattern.length - 1];\n const values = pattern.slice(0, -1);\n const pred = values.length === 1 ? _ => _ != null && _[field] === values[0] : _ => _ != null && values.includes(_[field]);\n return self => self.add(makeWhen(pred, f));\n};\n/** @internal */\nexport const discriminatorStartsWith = field => (pattern, f) => {\n const pred = _ => _ != null && typeof _[field] === \"string\" && _[field].startsWith(pattern);\n return self => self.add(makeWhen(pred, f));\n};\n/** @internal */\nexport const discriminators = field => fields => {\n const predicate = makeWhen(arg => arg != null && Object.hasOwn(fields, arg[field]), data => fields[data[field]](data));\n return self => self.add(predicate);\n};\n/** @internal */\nexport const discriminatorsExhaustive = field => fields => {\n const addCases = discriminators(field)(fields);\n return matcher => exhaustive(addCases(matcher));\n};\n/** @internal */\nexport const tag = /*#__PURE__*/discriminator(\"_tag\");\n/** @internal */\nexport const tagStartsWith = /*#__PURE__*/discriminatorStartsWith(\"_tag\");\n/** @internal */\nexport const tags = /*#__PURE__*/discriminators(\"_tag\");\n/** @internal */\nexport const tagsExhaustive = /*#__PURE__*/discriminatorsExhaustive(\"_tag\");\n/** @internal */\nexport const not = (pattern, f) => self => self.add(makeNot(makePredicate(pattern), f));\n/** @internal */\nexport const nonEmptyString = u => typeof u === \"string\" && u.length > 0;\n/** @internal */\nexport const is = (...literals) => {\n const len = literals.length;\n return u => {\n for (let i = 0; i < len; i++) {\n if (u === literals[i]) {\n return true;\n }\n }\n return false;\n };\n};\n/** @internal */\nexport const any = () => true;\n/** @internal */\nexport const defined = u => u !== undefined && u !== null;\n/** @internal */\nexport const instanceOf = constructor => u => u instanceof constructor;\n/** @internal */\nexport const orElse = f => self => {\n const toResult = result(self);\n if (Result.isResult(toResult)) {\n return toResult._tag === \"Success\" ? toResult.success : f(toResult.failure);\n }\n // @ts-expect-error\n return (...args) => {\n const a = toResult(...args);\n return Result.isSuccess(a) ? a.success : f(a.failure, ...args);\n };\n};\n/** @internal */\nexport const orElseAbsurd = self => orElse(() => {\n throw new Error(\"effect/Match/orElseAbsurd: absurd\");\n})(self);\n/** @internal */\nexport const result = self => {\n if (self._tag === \"ValueMatcher\") {\n return self.value;\n }\n const len = self.cases.length;\n if (len === 1) {\n const _case = self.cases[0];\n return (...args) => {\n const input = self.select(...args);\n if (_case._tag === \"When\" && _case.guard(input) === true) {\n return Result.succeed(_case.evaluate(input, ...args));\n } else if (_case._tag === \"Not\" && _case.guard(input) === false) {\n return Result.succeed(_case.evaluate(input, ...args));\n }\n return Result.fail(input);\n };\n }\n return (...args) => {\n const input = self.select(...args);\n for (let i = 0; i < len; i++) {\n const _case = self.cases[i];\n if (_case._tag === \"When\" && _case.guard(input) === true) {\n return Result.succeed(_case.evaluate(input, ...args));\n } else if (_case._tag === \"Not\" && _case.guard(input) === false) {\n return Result.succeed(_case.evaluate(input, ...args));\n }\n }\n return Result.fail(input);\n };\n};\n/** @internal */\nexport const option = self => {\n const toResult = result(self);\n if (Result.isResult(toResult)) {\n return Result.match(toResult, {\n onFailure: () => Option.none(),\n onSuccess: Option.some\n });\n }\n return (...args) => Result.match(toResult(...args), {\n onFailure: () => Option.none(),\n onSuccess: Option.some\n });\n};\nconst getExhaustiveAbsurdErrorMessage = \"effect/match/Match/exhaustive: absurd\";\n/** @internal */\nexport const exhaustive = self => {\n const toResult = result(self);\n if (Result.isResult(toResult)) {\n if (Result.isSuccess(toResult)) {\n return toResult.success;\n }\n throw new Error(getExhaustiveAbsurdErrorMessage);\n }\n return (...args) => {\n // @ts-expect-error\n const result = toResult(...args);\n if (Result.isSuccess(result)) {\n return result.success;\n }\n throw new Error(getExhaustiveAbsurdErrorMessage);\n };\n};\n//# sourceMappingURL=matcher.js.map","/**\n * Builds pattern matchers for TypeScript values.\n *\n * `Match` lets you add ordered cases and then finish them with a result,\n * fallback, `Option`, or exhaustive check. Use `Match.type` to define a\n * reusable matcher for a type, or `Match.value` to match one value immediately.\n * Cases can match literal values, predicates, object shapes, tags, negated\n * patterns, and common checks such as strings, numbers, records, and class\n * instances.\n *\n * @since 4.0.0\n */\nimport * as internal from \"./internal/matcher.js\";\nimport * as Predicate from \"./Predicate.js\";\nconst TypeId = internal.TypeId;\n/**\n * Creates a matcher for a specific type.\n *\n * **When to use**\n *\n * Use to build a reusable matcher function for values of a known input type.\n *\n * **Details**\n *\n * This function defines a `Matcher` that operates on a given type, allowing you\n * to specify conditions for handling different cases. Once the matcher is\n * created, you can use pattern-matching functions like {@link when} to define\n * how different values should be processed.\n *\n * **Example** (Matching Numbers and Strings)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * // Create a matcher for values that are either strings or numbers\n * //\n * // ┌─── (u: string | number) => string\n * // ▼\n * const match = Match.type().pipe(\n * // Match when the value is a number\n * Match.when(Match.number, (n) => `number: ${n}`),\n * // Match when the value is a string\n * Match.when(Match.string, (s) => `string: ${s}`),\n * // Ensure all possible cases are handled\n * Match.exhaustive\n * )\n *\n * match(0) // => \"number: 0\"\n *\n * match(\"hello\") // => \"string: hello\"\n * ```\n *\n * @see {@link value} for creating a matcher from a specific value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const type = internal.type;\n/**\n * Creates a reusable matcher from a function that selects the value to match.\n *\n * **Details**\n *\n * The compiled matcher keeps the selector's original argument list. Case\n * handlers receive the narrowed selected value followed by those arguments.\n *\n * **Example** (Creating a reusable matcher)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const format = Match.fn((prefix: string, value: \"a\" | \"b\") => value).pipe(\n * Match.when(\"a\", (_value, prefix) => `${prefix}: A`),\n * Match.when(\"b\", (_value, prefix) => `${prefix}: B`),\n * Match.exhaustive\n * )\n *\n * format(\"status\", \"a\") // => \"status: A\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fn = internal.fn;\n/**\n * Creates a matcher from a specific value.\n *\n * **When to use**\n *\n * Use to match one concrete input immediately.\n *\n * **Details**\n *\n * This function allows you to define a `Matcher` directly from a given value,\n * rather than from a type. This is useful when working with known values,\n * enabling structured pattern matching on objects, primitives, or any data\n * structure.\n *\n * Once the matcher is created, you can use pattern-matching functions like\n * {@link when} to define how different cases should be handled.\n *\n * **Example** (Matching an Object by Property)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const input = { name: \"John\", age: 30 }\n *\n * // Create a matcher for the specific object\n * const result = Match.value(input).pipe(\n * // Match when the 'name' property is \"John\"\n * Match.when(\n * { name: \"John\" },\n * (user) => `${user.name} is ${user.age} years old`\n * ),\n * // Provide a fallback if no match is found\n * Match.orElse(() => \"Oh, not John\")\n * )\n *\n * result // => \"John is 30 years old\"\n * ```\n *\n * @see {@link type} for creating a matcher from a specific type.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const value = internal.value;\n/**\n * Creates a match function for a specific value with discriminated union handling.\n *\n * **Details**\n *\n * This function provides a convenient way to pattern match on discriminated unions\n * by providing an object that maps each `_tag` value to its corresponding handler.\n * It's similar to a switch statement but with better type safety and exhaustiveness checking.\n *\n * **Example** (Matching value tags)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * type Status = { readonly _tag: \"Success\"; readonly data: string }\n *\n * const success: Status = { _tag: \"Success\", data: \"Hello\" }\n *\n * // Simple valueTags usage\n * const message = Match.valueTags(success, {\n * Success: (result) => `Success: ${result.data}`\n * })\n *\n * message // => \"Success: Hello\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const valueTags = internal.valueTags;\n/**\n * Creates a type-safe match function for discriminated unions based on `_tag` field.\n *\n * **Details**\n *\n * This function allows you to define exhaustive pattern matching for discriminated unions\n * by providing handlers for each possible `_tag` value. It ensures type safety and\n * can optionally enforce a specific return type across all branches.\n *\n * **Example** (Matching type tags)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * type Result =\n * | { readonly _tag: \"Success\"; readonly data: string }\n * | { readonly _tag: \"Error\"; readonly message: string }\n * | { readonly _tag: \"Loading\" }\n *\n * // Create a matcher with specific return type\n * const formatResult = Match.typeTags()({\n * Success: (result) => `Data: ${result.data}`,\n * Error: (result) => `Error: ${result.message}`,\n * Loading: () => \"Loading...\"\n * })\n *\n * formatResult({ _tag: \"Success\", data: \"Hello World\" }) // => \"Data: Hello World\"\n *\n * formatResult({ _tag: \"Error\", message: \"Network failed\" }) // => \"Error: Network failed\"\n *\n * // Create a matcher with inferred return type\n * const processResult = Match.typeTags()({\n * Success: (result) => ({ type: \"ok\", value: result.data }),\n * Error: (result) => ({ type: \"error\", error: result.message }),\n * Loading: () => ({ type: \"pending\" })\n * })\n *\n * processResult({ _tag: \"Loading\" }) // => { type: \"pending\" }\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const typeTags = internal.typeTags;\n/**\n * Ensures that all branches of a matcher return a specific type.\n *\n * **Details**\n *\n * This function enforces a consistent return type across all pattern-matching\n * branches. By specifying a return type, TypeScript will check that every\n * matching condition produces a value of the expected type.\n *\n * **Important:** This function must be the first step in the matcher pipeline.\n * If used later, TypeScript will not enforce type consistency correctly.\n *\n * **Example** (Validating return type consistency)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const match = Match.type<{ a: number } | { b: string }>().pipe(\n * // Ensure all branches return a string\n * Match.withReturnType(),\n * // ❌ Type error: 'number' is not assignable to type 'string'\n * // @ts-expect-error\n * Match.when({ a: Match.number }, (_) => _.a),\n * // ✅ Correct: returns a string\n * Match.when({ b: Match.string }, (_) => _.b),\n * Match.exhaustive\n * )\n * ```\n *\n * @category utility types\n * @since 4.0.0\n */\nexport const withReturnType = internal.withReturnType;\n/**\n * Defines a condition for matching values.\n *\n * **When to use**\n *\n * Use to add one positive pattern case to a `Match.type` or `Match.value`\n * pipeline when a direct value, predicate, or structured object pattern should\n * run a handler for matching input.\n *\n * **Details**\n *\n * Supports both direct value comparisons and predicate functions. If the\n * pattern matches, the associated function is executed and the matched input is\n * removed from the remaining cases tracked by the matcher.\n *\n * **Example** (Matching with values and predicates)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * // Create a matcher for objects with an \"age\" property\n * const match = Match.type<{ age: number }>().pipe(\n * // Match when age is greater than 18\n * Match.when(\n * { age: (age: number) => age > 18 },\n * (user: { age: number }) => `Age: ${user.age}`\n * ),\n * // Match when age is exactly 18\n * Match.when({ age: 18 }, () => \"You can vote\"),\n * // Fallback case for all other ages\n * Match.orElse((user: { age: number }) => `${user.age} is too young`)\n * )\n *\n * match({ age: 20 }) // => \"Age: 20\"\n *\n * match({ age: 18 }) // => \"You can vote\"\n *\n * match({ age: 4 }) // => \"4 is too young\"\n * ```\n *\n * @see {@link whenOr} for handling any one of several patterns with the same handler\n * @see {@link whenAnd} for requiring all provided patterns to match before running a handler\n * @see {@link not} for handling inputs that do not match a pattern\n * @see {@link orElse} for providing a fallback when no pattern case matches\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const when = internal.when;\n/**\n * Matches one of multiple patterns in a single condition.\n *\n * **Details**\n *\n * This function allows defining a condition where a value matches any of the\n * provided patterns. If a match is found, the associated function is executed.\n * It simplifies cases where multiple patterns share the same handling logic.\n *\n * Unlike {@link when}, which requires separate conditions for each pattern,\n * this function enables combining them into a single statement, making the\n * matcher more concise.\n *\n * **Example** (Matching one of several patterns)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * type ErrorType =\n * | { readonly _tag: \"NetworkError\"; readonly message: string }\n * | { readonly _tag: \"TimeoutError\"; readonly duration: number }\n * | { readonly _tag: \"ValidationError\"; readonly field: string }\n *\n * const handleError = Match.type().pipe(\n * Match.whenOr(\n * { _tag: \"NetworkError\" },\n * { _tag: \"TimeoutError\" },\n * () => \"Retry the request\"\n * ),\n * Match.when({ _tag: \"ValidationError\" }, (_) => `Invalid field: ${_.field}`),\n * Match.exhaustive\n * )\n *\n * handleError({ _tag: \"NetworkError\", message: \"No connection\" }) // => \"Retry the request\"\n *\n * handleError({ _tag: \"ValidationError\", field: \"email\" }) // => \"Invalid field: email\"\n * ```\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const whenOr = internal.whenOr;\n/**\n * Matches a value that satisfies all provided patterns.\n *\n * **Details**\n *\n * This function allows defining a condition where a value must match all the\n * given patterns simultaneously. If the value satisfies every pattern, the\n * associated function is executed.\n *\n * Unlike {@link when}, which matches a single pattern at a time, this function\n * ensures that multiple conditions are met before executing the callback. It is\n * useful when checking for values that need to fulfill multiple criteria at\n * once.\n *\n * **Example** (Matching all provided patterns)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * type User = { readonly age: number; readonly role: \"admin\" | \"user\" }\n *\n * const checkUser = Match.type().pipe(\n * Match.whenAnd(\n * { age: (n) => n >= 18 },\n * { role: \"admin\" },\n * () => \"Admin access granted\"\n * ),\n * Match.orElse(() => \"Access denied\")\n * )\n *\n * checkUser({ age: 20, role: \"admin\" }) // => \"Admin access granted\"\n *\n * checkUser({ age: 20, role: \"user\" }) // => \"Access denied\"\n * ```\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const whenAnd = internal.whenAnd;\n/**\n * Matches values based on a specified discriminant field.\n *\n * **When to use**\n *\n * Use to match one or more exact values of a discriminator field.\n *\n * **Details**\n *\n * This function is used to define pattern matching on objects that follow a\n * **discriminated union** structure, where a specific field (e.g., `type`,\n * `kind`, `_tag`) determines the variant of the object. It allows matching\n * multiple values of the discriminant and provides a function to handle the\n * matched cases.\n *\n * **Example** (Matching on a discriminator field)\n *\n * ```ts import.meta.vitest\n * import { Match, pipe } from \"effect\"\n *\n * const match = pipe(\n * Match.type<\n * { type: \"A\"; a: string } | { type: \"B\"; b: number } | {\n * type: \"C\"\n * c: boolean\n * }\n * >(),\n * Match.discriminator(\"type\")(\"A\", \"B\", (_) => `A or B: ${_.type}`),\n * Match.discriminator(\"type\")(\"C\", (_) => `C(${_.c})`),\n * Match.exhaustive\n * )\n * match({ type: \"A\", a: \"ok\" }) // => \"A or B: A\"\n * match({ type: \"C\", c: true }) // => \"C(true)\"\n * ```\n *\n * @see {@link discriminators} for defining several discriminator handlers at once\n * @see {@link discriminatorStartsWith} for matching string discriminator values by prefix\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const discriminator = internal.discriminator;\n/**\n * Matches values where a specified field starts with a given prefix.\n *\n * **When to use**\n *\n * Use to match string discriminator values by prefix instead of exact value.\n *\n * **Details**\n *\n * Instead of checking for exact matches, this helper matches values that share\n * a common prefix. For example, if the discriminant field contains hierarchical\n * names like `\"A\"`, `\"A.A\"`, and `\"B\"`, a single `\"A\"` rule can match both\n * `\"A\"` and `\"A.A\"`.\n *\n * **Example** (Matching discriminator prefixes)\n *\n * ```ts import.meta.vitest\n * import { Match, pipe } from \"effect\"\n *\n * const match = pipe(\n * Match.type<{ type: \"A\" } | { type: \"B\" } | { type: \"A.A\" } | {}>(),\n * Match.discriminatorStartsWith(\"type\")(\"A\", (_) => 1 as const),\n * Match.discriminatorStartsWith(\"type\")(\"B\", (_) => 2 as const),\n * Match.orElse((_) => 3 as const)\n * )\n *\n * match({ type: \"A\" }) // => 1\n * match({ type: \"B\" }) // => 2\n * match({ type: \"A.A\" }) // => 1\n * ```\n *\n * @see {@link discriminator} for matching exact discriminator values\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const discriminatorStartsWith = internal.discriminatorStartsWith;\n/**\n * Matches values based on a field that serves as a discriminator, mapping each\n * possible value to a corresponding handler.\n *\n * **When to use**\n *\n * Use to define several discriminator handlers at once without finalizing the\n * matcher.\n *\n * **Details**\n *\n * This function simplifies working with discriminated unions by letting you\n * define a set of handlers for each possible value of a given field. Instead of\n * chaining multiple calls to {@link discriminator}, this function allows\n * defining all possible cases at once using an object where the keys are the\n * possible values of the field, and the values are the corresponding handler\n * functions.\n *\n * **Example** (Mapping discriminator handlers)\n *\n * ```ts import.meta.vitest\n * import { Match, pipe } from \"effect\"\n *\n * const match = pipe(\n * Match.type<\n * { type: \"A\"; a: string } | { type: \"B\"; b: number } | {\n * type: \"C\"\n * c: boolean\n * }\n * >(),\n * Match.discriminators(\"type\")({\n * A: (a) => a.a,\n * B: (b) => b.b,\n * C: (c) => c.c\n * }),\n * Match.exhaustive\n * )\n * match({ type: \"A\", a: \"ok\" }) // => \"ok\"\n * match({ type: \"B\", b: 42 }) // => 42\n * ```\n *\n * @see {@link discriminator} for adding one discriminator case to a matcher pipeline\n * @see {@link discriminatorsExhaustive} for handling every discriminator value and finalizing the matcher\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const discriminators = internal.discriminators;\n/**\n * Matches values by a discriminator field and requires every possible case to\n * be handled.\n *\n * **When to use**\n *\n * Use to define an exhaustive discriminator handler map that finalizes the\n * matcher.\n *\n * **Details**\n *\n * This is the exhaustive variant of {@link discriminators}. Each possible\n * discriminator value must have a corresponding handler, so the matcher is\n * finalized directly and does not require `Match.exhaustive` at the end of the\n * pipeline.\n *\n * **Example** (Handling all discriminator cases)\n *\n * ```ts import.meta.vitest\n * import { Match, pipe } from \"effect\"\n *\n * const match = pipe(\n * Match.type<\n * { type: \"A\"; a: string } | { type: \"B\"; b: number } | {\n * type: \"C\"\n * c: boolean\n * }\n * >(),\n * Match.discriminatorsExhaustive(\"type\")({\n * A: (a) => a.a,\n * B: (b) => b.b,\n * C: (c) => c.c\n * })\n * )\n * match({ type: \"C\", c: true }) // => true\n * ```\n *\n * @see {@link discriminators} for defining discriminator handlers without finalizing the matcher\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const discriminatorsExhaustive = internal.discriminatorsExhaustive;\n/**\n * Matches discriminated union members by their `_tag` field.\n *\n * **When to use**\n *\n * Use to handle one or more `_tag` cases with the same matcher branch.\n *\n * **Details**\n *\n * This helper follows the Effect convention that discriminated unions use\n * `\"_tag\"` as their discriminator field. Use {@link discriminator} for a\n * different discriminator field.\n *\n * **Example** (Matching a discriminated union by tag)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * type Event =\n * | { readonly _tag: \"fetch\" }\n * | { readonly _tag: \"success\"; readonly data: string }\n * | { readonly _tag: \"error\"; readonly error: Error }\n * | { readonly _tag: \"cancel\" }\n *\n * const match = Match.type().pipe(\n * // Match either \"fetch\" or \"success\"\n * Match.tag(\"fetch\", \"success\", () => `Ok!`),\n * // Match \"error\" and extract the error message\n * Match.tag(\"error\", (event) => `Error: ${event.error.message}`),\n * // Match \"cancel\"\n * Match.tag(\"cancel\", () => \"Cancelled\"),\n * Match.exhaustive\n * )\n *\n * match({ _tag: \"success\", data: \"Hello\" }) // => \"Ok!\"\n *\n * match({ _tag: \"error\", error: new Error(\"Oops!\") }) // => \"Error: Oops!\"\n * ```\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const tag = internal.tag;\n/**\n * Matches values where the `_tag` field starts with a given prefix.\n *\n * **Details**\n *\n * This function allows you to match on values in a **discriminated union**\n * based on whether the `_tag` field starts with a specified prefix. It is\n * useful for handling hierarchical or namespaced tags, where multiple related\n * cases share a common prefix.\n *\n * **Example** (Matching tag prefixes)\n *\n * ```ts import.meta.vitest\n * import { Match, pipe } from \"effect\"\n *\n * const match = pipe(\n * Match.type<{ _tag: \"A\" } | { _tag: \"B\" } | { _tag: \"A.A\" } | {}>(),\n * Match.tagStartsWith(\"A\", (_) => 1 as const),\n * Match.tagStartsWith(\"B\", (_) => 2 as const),\n * Match.orElse((_) => 3 as const)\n * )\n *\n * match({ _tag: \"A\" }) // => 1\n * match({ _tag: \"B\" }) // => 2\n * match({ _tag: \"A.A\" }) // => 1\n * ```\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const tagStartsWith = internal.tagStartsWith;\n/**\n * Matches values based on their `_tag` field, mapping each tag to a\n * corresponding handler.\n *\n * **Details**\n *\n * This function provides a way to handle discriminated unions by mapping `_tag`\n * values to specific functions. Each handler receives the matched value and\n * returns a transformed result. If all possible tags are handled, you can\n * enforce exhaustiveness using `Match.exhaustive` to ensure no case is missed.\n *\n * **Example** (Mapping tag handlers)\n *\n * ```ts import.meta.vitest\n * import { Match, pipe } from \"effect\"\n *\n * const match = pipe(\n * Match.type<\n * { _tag: \"A\"; a: string } | { _tag: \"B\"; b: number } | {\n * _tag: \"C\"\n * c: boolean\n * }\n * >(),\n * Match.tags({\n * A: (a) => a.a,\n * B: (b) => b.b,\n * C: (c) => c.c\n * }),\n * Match.exhaustive\n * )\n * match({ _tag: \"A\", a: \"ok\" }) // => \"ok\"\n * ```\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const tags = internal.tags;\n/**\n * Matches values based on their `_tag` field and requires handling of all\n * possible cases.\n *\n * **Details**\n *\n * This function is designed for **discriminated unions** where every possible\n * `_tag` value must have a corresponding handler. Unlike {@link tags}, this\n * function ensures **exhaustiveness**, meaning all cases must be explicitly\n * handled. If a `_tag` value is missing from the mapping, TypeScript will\n * report an error.\n *\n * **Example** (Handling all tag cases)\n *\n * ```ts import.meta.vitest\n * import { Match, pipe } from \"effect\"\n *\n * const match = pipe(\n * Match.type<\n * { _tag: \"A\"; a: string } | { _tag: \"B\"; b: number } | {\n * _tag: \"C\"\n * c: boolean\n * }\n * >(),\n * Match.tagsExhaustive({\n * A: (a) => a.a,\n * B: (b) => b.b,\n * C: (c) => c.c\n * })\n * )\n * match({ _tag: \"B\", b: 42 }) // => 42\n * ```\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const tagsExhaustive = internal.tagsExhaustive;\n/**\n * Creates a pattern that excludes a specific value while allowing all others.\n *\n * **When to use**\n *\n * Use to add a negative pattern case for inputs that should match when another\n * pattern does not.\n *\n * **Details**\n *\n * Any excluded value bypasses the provided function and continues matching\n * through later cases.\n *\n * **Example** (Ignoring a specific value)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * // Create a matcher for string or number values\n * const match = Match.type().pipe(\n * // Match any value except \"hi\", returning \"ok\"\n * Match.not(\"hi\", () => \"ok\"),\n * // Fallback case for when the value is \"hi\"\n * Match.orElse(() => \"fallback\")\n * )\n *\n * match(\"hello\") // => \"ok\"\n *\n * match(\"hi\") // => \"fallback\"\n * ```\n *\n * @see {@link when} for adding a positive pattern case\n *\n * @category defining patterns\n * @since 4.0.0\n */\nexport const not = internal.not;\n/**\n * Matches non-empty strings.\n *\n * **When to use**\n *\n * Use to match strings whose length is greater than zero.\n *\n * **Details**\n *\n * This predicate matches any string that contains at least one character,\n * effectively filtering out empty strings (\"\").\n *\n * **Example** (Matching non-empty strings)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const processInput = Match.type()\n * .pipe(\n * Match.when(Match.nonEmptyString, (str) => `Valid input: ${str}`),\n * Match.orElse(() => \"Input cannot be empty\")\n * )\n *\n * processInput(\"hello\") // => \"Valid input: hello\"\n *\n * processInput(\"\") // => \"Input cannot be empty\"\n *\n * processInput(\" \") // => \"Valid input: \"\n * ```\n *\n * @see {@link string} for matching any string\n *\n * @category guards\n * @since 4.0.0\n */\nexport const nonEmptyString = internal.nonEmptyString;\n/**\n * Matches a specific set of literal values (e.g., `Match.is(\"a\", 42, true)`).\n *\n * **When to use**\n *\n * Use to match one of several literal primitive or null values.\n *\n * **Details**\n *\n * This function creates a predicate that matches any of the provided literal values.\n * It's useful for matching against multiple specific values in a single pattern.\n *\n * **Example** (Matching literal values)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const handleStatus = Match.type()\n * .pipe(\n * Match.when(Match.is(\"success\", \"ok\", 200), () => \"Operation successful\"),\n * Match.when(Match.is(\"error\", \"failed\", 500), () => \"Operation failed\"),\n * Match.when(Match.is(0, false, null), () => \"Falsy value\"),\n * Match.orElse((value) => `Unknown status: ${value}`)\n * )\n *\n * handleStatus(\"success\") // => \"Operation successful\"\n *\n * handleStatus(200) // => \"Operation successful\"\n *\n * handleStatus(\"failed\") // => \"Operation failed\"\n *\n * handleStatus(0) // => \"Falsy value\"\n *\n * handleStatus(\"pending\") // => \"Unknown status: pending\"\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const is = internal.is;\n/**\n * Matches values of type `string`.\n *\n * **Details**\n *\n * This predicate refines unknown values to strings, allowing pattern matching\n * on string types. It's commonly used in type-based matchers to handle string cases.\n *\n * **Example** (Matching string values)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const processValue = Match.type().pipe(\n * Match.when(Match.string, (str) => `String: ${str.toUpperCase()}`),\n * Match.when(Match.number, (num) => `Number: ${num * 2}`),\n * Match.when(Match.boolean, (bool) => `Boolean: ${bool ? \"yes\" : \"no\"}`),\n * Match.exhaustive\n * )\n *\n * processValue(\"hello\") // => \"String: HELLO\"\n * processValue(42) // => \"Number: 84\"\n * processValue(true) // => \"Boolean: yes\"\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const string = Predicate.isString;\n/**\n * Matches values of type `number`.\n *\n * **When to use**\n *\n * Use to match primitive number values, including `NaN` and infinities.\n *\n * **Details**\n *\n * This predicate refines unknown values to numbers, allowing pattern matching\n * on numeric types. It matches all number values including integers, floats,\n * `Infinity`, `-Infinity`, and `NaN`.\n *\n * **Example** (Matching number values)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const categorizeNumber = Match.type().pipe(\n * Match.when(Match.number, (num) => {\n * if (Number.isNaN(num)) return \"Not a number\"\n * if (!Number.isFinite(num)) return \"Infinite\"\n * if (Number.isInteger(num)) return `Integer: ${num}`\n * return `Float: ${num.toFixed(2)}`\n * }),\n * Match.orElse(() => \"Not a number type\")\n * )\n *\n * categorizeNumber(42) // => \"Integer: 42\"\n * categorizeNumber(3.14) // => \"Float: 3.14\"\n * categorizeNumber(NaN) // => \"Not a number\"\n * categorizeNumber(\"hello\") // => \"Not a number type\"\n * ```\n *\n * @see {@link bigint} for matching primitive bigint values\n *\n * @category guards\n * @since 4.0.0\n */\nexport const number = Predicate.isNumber;\n/**\n * Matches any value without restrictions.\n *\n * **When to use**\n *\n * Use to define an explicit catch-all pattern when the handler should receive\n * the unmatched value.\n *\n * **Details**\n *\n * This predicate matches every input, including `undefined`, `null`, objects,\n * primitives, and functions.\n *\n * **Gotchas**\n *\n * `Match.any` should usually be last because cases are checked in order and\n * the first matching case wins.\n *\n * **Example** (Matching any remaining value)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const describeValue = Match.type()\n * .pipe(\n * Match.when(Match.string, (str) => `String: ${str}`),\n * Match.when(Match.number, (num) => `Number: ${num}`),\n * Match.when(Match.boolean, (bool) => `Boolean: ${bool}`),\n * Match.when(Match.any, (value) => `Other: ${typeof value}`),\n * Match.exhaustive\n * )\n *\n * describeValue(\"hello\") // => \"String: hello\"\n *\n * describeValue(42) // => \"Number: 42\"\n *\n * describeValue([1, 2, 3]) // => \"Other: object\"\n *\n * describeValue(null) // => \"Other: object\"\n * ```\n *\n * @see {@link defined} for matching only non-nullish values\n * @see {@link orElse} for providing a fallback after earlier cases\n *\n * @category guards\n * @since 4.0.0\n */\nexport const any = internal.any;\n/**\n * Matches any defined (non-null and non-undefined) value.\n *\n * **When to use**\n *\n * Use to exclude only `null` and `undefined` from a match branch.\n *\n * **Details**\n *\n * This predicate matches values that are neither `null` nor `undefined`,\n * effectively filtering out nullish values while preserving all other types.\n *\n * **Example** (Matching defined values)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const processValue = Match.type()\n * .pipe(\n * Match.when(Match.defined, (value) => `Defined value: ${value}`),\n * Match.orElse(() => \"Value is null or undefined\")\n * )\n *\n * processValue(\"hello\") // => \"Defined value: hello\"\n *\n * processValue(42) // => \"Defined value: 42\"\n *\n * processValue(0) // => \"Defined value: 0\"\n *\n * processValue(\"\") // => \"Defined value: \"\n *\n * processValue(null) // => \"Value is null or undefined\"\n *\n * processValue(undefined) // => \"Value is null or undefined\"\n * ```\n *\n * @see {@link any} for matching every value without excluding nullish inputs\n *\n * @category guards\n * @since 4.0.0\n */\nexport const defined = internal.defined;\n/**\n * Matches values of type `boolean`.\n *\n * **When to use**\n *\n * Use to match primitive boolean values.\n *\n * **Details**\n *\n * This predicate refines unknown values to booleans, allowing pattern matching\n * on boolean types. It only matches the primitive boolean values `true` and `false`.\n *\n * **Example** (Matching boolean values)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const describeTruthiness = Match.type().pipe(\n * Match.when(\n * Match.boolean,\n * (bool) => bool ? \"Definitely true\" : \"Definitely false\"\n * ),\n * Match.when(0, () => \"Falsy number\"),\n * Match.when(\"\", () => \"Empty string\"),\n * Match.when(Match.null, () => \"Null value\"),\n * Match.orElse(() => \"Some other truthy value\")\n * )\n *\n * describeTruthiness(true) // => \"Definitely true\"\n * describeTruthiness(false) // => \"Definitely false\"\n * describeTruthiness(0) // => \"Falsy number\"\n * describeTruthiness(1) // => \"Some other truthy value\"\n * ```\n *\n * @see {@link is} for matching specific literal boolean values\n *\n * @category guards\n * @since 4.0.0\n */\nexport const boolean = Predicate.isBoolean;\nconst _undefined = Predicate.isUndefined;\nexport {\n/**\n * Matches the value `undefined`.\n *\n * **When to use**\n *\n * Use when a matcher should handle only inputs with no defined value.\n *\n * **Details**\n *\n * This refinement is backed by `Predicate.isUndefined`, which checks\n * `input === undefined`.\n *\n * @see {@link defined} for matching non-nullish values\n * @see {@link is} for matching literal values\n *\n * @category guards\n * @since 4.0.0\n */\n_undefined as undefined };\nconst _null = Predicate.isNull;\nexport {\n/**\n * Matches the value `null`.\n *\n * **When to use**\n *\n * Use to handle only the `null` literal in a match branch.\n *\n * **Details**\n *\n * This refinement is backed by `Predicate.isNull`, which checks\n * `input === null`.\n *\n * @see {@link defined} for matching non-nullish values\n * @see {@link is} for matching literal values\n *\n * @category guards\n * @since 4.0.0\n */\n_null as null };\n/**\n * Matches values of type `bigint`.\n *\n * **When to use**\n *\n * Use to match primitive bigint values.\n *\n * **Details**\n *\n * This predicate refines unknown values to bigints, allowing pattern matching\n * on bigint types. BigInts are used for representing integers with arbitrary precision.\n *\n * **Example** (Matching bigint values)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const processLargeNumber = Match.type().pipe(\n * Match.when(Match.bigint, (big) => {\n * if (big > 9007199254740991n) {\n * return `Large integer: ${big.toString()}`\n * }\n * return `BigInt: ${big.toString()}`\n * }),\n * Match.when(Match.number, (num) => `Regular number: ${num}`),\n * Match.orElse(() => \"Not a numeric type\")\n * )\n *\n * processLargeNumber(123n) // => \"BigInt: 123\"\n * processLargeNumber(9007199254740992n) // => \"Large integer: 9007199254740992\"\n * processLargeNumber(123) // => \"Regular number: 123\"\n * processLargeNumber(\"123\") // => \"Not a numeric type\"\n * ```\n *\n * @see {@link number} for matching primitive number values\n *\n * @category guards\n * @since 4.0.0\n */\nexport const bigint = Predicate.isBigInt;\n/**\n * Matches values of type `symbol`.\n *\n * **Details**\n *\n * This predicate refines unknown values to symbols, allowing pattern matching\n * on symbol types. Symbols are unique identifiers that are often used as\n * object keys or for creating private properties.\n *\n * **Example** (Matching symbol values)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const mySymbol = Symbol(\"my-symbol\")\n * const globalSymbol = Symbol.for(\"global-symbol\")\n *\n * const handleSymbol = Match.type().pipe(\n * Match.when(Match.symbol, (sym) => {\n * const description = sym.description\n * if (description) {\n * return `Symbol with description: ${description}`\n * }\n * return \"Symbol without description\"\n * }),\n * Match.orElse(() => \"Not a symbol\")\n * )\n *\n * handleSymbol(mySymbol) // => \"Symbol with description: my-symbol\"\n * handleSymbol(Symbol()) // => \"Symbol without description\"\n * handleSymbol(\"string\") // => \"Not a symbol\"\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const symbol = Predicate.isSymbol;\n/**\n * Matches values that are instances of `Date`.\n *\n * **When to use**\n *\n * Use to match `Date` instances.\n *\n * **Details**\n *\n * This predicate refines unknown values to Date instances, allowing pattern\n * matching on Date objects. It only matches actual Date instances, not\n * date strings or timestamps.\n *\n * **Example** (Matching Date instances)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const processDateValue = Match.type().pipe(\n * Match.when(Match.date, (date) => {\n * if (isNaN(date.getTime())) {\n * return \"Invalid date\"\n * }\n * return `Date: ${date.toISOString().split(\"T\")[0]}`\n * }),\n * Match.when(Match.string, (str) => `Date string: ${str}`),\n * Match.orElse(() => \"Not a date-related value\")\n * )\n *\n * processDateValue(new Date(\"2024-01-01\")) // => \"Date: 2024-01-01\"\n * processDateValue(new Date(\"invalid\")) // => \"Invalid date\"\n * processDateValue(\"2024-01-01\") // => \"Date string: 2024-01-01\"\n * processDateValue(1704067200000) // => \"Not a date-related value\"\n * ```\n *\n * @see {@link instanceOf} for matching instances of any constructor\n *\n * @category guards\n * @since 4.0.0\n */\nexport const date = Predicate.isDate;\n/**\n * Matches non-null objects other than arrays.\n *\n * **When to use**\n *\n * Use to match broad non-null, non-array object values.\n *\n * **Details**\n *\n * This predicate uses `Predicate.isObject`: it returns `true` for values whose\n * runtime type is `\"object\"`, are not `null`, and are not arrays. It can match\n * `Date`, `RegExp`, and class instances; use `instanceOf` or a more specific\n * pattern when those cases need to be distinguished.\n *\n * **Example** (Matching record objects)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const analyzeValue = Match.type().pipe(\n * Match.when(Match.record, (obj) => {\n * const keys = Object.keys(obj)\n * const valueCount = keys.length\n * return `Object with ${valueCount} properties: [${keys.join(\", \")}]`\n * }),\n * Match.when(\n * Match.instanceOf(Array),\n * (arr) => `Array with ${arr.length} items`\n * ),\n * Match.orElse(() => \"Not an object\")\n * )\n *\n * analyzeValue({ name: \"Alice\", age: 30 }) // => \"Object with 2 properties: [name, age]\"\n * analyzeValue([1, 2, 3]) // => \"Array with 3 items\"\n * analyzeValue(null) // => \"Not an object\"\n * analyzeValue(\"hello\") // => \"Not an object\"\n * ```\n *\n * @see {@link instanceOf} for matching a specific constructor\n *\n * @category guards\n * @since 4.0.0\n */\nexport const record = Predicate.isObject;\n/**\n * Matches instances of a given class.\n *\n * **When to use**\n *\n * Use to match values that are instances of a constructor with type-safe\n * narrowing.\n *\n * **Details**\n *\n * This predicate checks if a value is an instance of the specified constructor,\n * providing type-safe matching for class instances and built-in objects.\n *\n * **Example** (Matching class instances)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * class CustomError extends Error {\n * constructor(message: string, public code: number) {\n * super(message)\n * }\n * }\n *\n * const handleValue = Match.type()\n * .pipe(\n * Match.when(\n * Match.instanceOf(CustomError),\n * (err) => `Custom error: ${err.message} (code: ${err.code})`\n * ),\n * Match.when(\n * Match.instanceOf(Error),\n * (err) => `Standard error: ${err.message}`\n * ),\n * Match.when(\n * Match.instanceOf(Array),\n * (arr) => `Array with ${arr.length} items`\n * ),\n * Match.when(\n * Match.instanceOf(Map),\n * (map) => `Map with ${map.size} entries`\n * ),\n * Match.orElse((value) => `Other: ${typeof value}`)\n * )\n *\n * handleValue(new CustomError(\"Failed\", 404)) // => \"Custom error: Failed (code: 404)\"\n * handleValue(new Error(\"Generic error\")) // => \"Standard error: Generic error\"\n * handleValue([1, 2, 3]) // => \"Array with 3 items\"\n * handleValue(new Map([[\"count\", 1]])) // => \"Map with 1 entries\"\n * ```\n *\n * @see {@link instanceOfUnsafe} for constructor matching without the same type-safety guarantee\n * @see {@link record} for matching broad non-null, non-array objects\n *\n * @category guards\n * @since 4.0.0\n */\nexport const instanceOf = internal.instanceOf;\n/**\n * Checks whether a value is an instance of a constructor without type-safe narrowing.\n *\n * **When to use**\n *\n * Use when you need constructor matching to use the unsafe refinement type.\n *\n * **Details**\n *\n * This predicate checks if a value is an instance of the specified constructor\n * but doesn't provide the same type safety guarantees as the regular `instanceOf`.\n * Use this when you need more flexibility but understand the type safety implications.\n *\n * **Example** (Matching class instances unsafely)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * class CustomError extends Error {\n * constructor(message: string, public code: number) {\n * super(message)\n * }\n * }\n *\n * // When you need to match instances but handle type narrowing manually\n * const handleError = Match.type().pipe(\n * Match.when(Match.instanceOfUnsafe(CustomError), (err: any) => {\n * // Manual type assertion needed\n * const customErr = err as CustomError\n * return `Custom error ${customErr.code}: ${customErr.message}`\n * }),\n * Match.orElse(() => \"Not a CustomError\")\n * )\n * handleError(new CustomError(\"failed\", 500)) // => \"Custom error 500: failed\"\n * ```\n *\n * @see {@link instanceOf} for type-safe constructor matching\n *\n * @category guards\n * @since 4.0.0\n */\nexport const instanceOfUnsafe = internal.instanceOf;\n/**\n * Provides a fallback value when no patterns match.\n *\n * **When to use**\n *\n * Use to finalize a matcher with a fallback for unmatched input.\n *\n * **Details**\n *\n * This function ensures that a matcher always returns a valid result, even if\n * no defined patterns match. It acts as a default case, similar to the\n * `default` clause in a `switch` statement or the final `else` in an `if-else`\n * chain.\n *\n * **Example** (Providing a default value when no patterns match)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * // Create a matcher for string or number values\n * const match = Match.type().pipe(\n * // Match when the value is \"a\"\n * Match.when(\"a\", () => \"ok\"),\n * // Fallback when no patterns match\n * Match.orElse(() => \"fallback\")\n * )\n *\n * match(\"a\") // => \"ok\"\n *\n * match(\"b\") // => \"fallback\"\n * ```\n *\n * @see {@link option} for finalizing unmatched input as `Option.none`\n * @see {@link result} for returning unmatched input as a `Result` failure\n * @see {@link orElseAbsurd} for finalizing when unmatched input should be impossible\n *\n * @category completion\n * @since 4.0.0\n */\nexport const orElse = internal.orElse;\n// TODO(4.0): Rename to \"orThrow\"? Like Result.getOrThrow\n/**\n * Returns a matcher that throws an error if no pattern matches.\n *\n * **When to use**\n *\n * Use to finalize a matcher when every remaining unmatched case should be\n * impossible.\n *\n * **Details**\n *\n * This function finalizes a matcher by ensuring that if no patterns match, an\n * error is thrown. It is useful when all cases should be covered, and any\n * unexpected input should trigger an error instead of returning a default\n * value.\n *\n * When used, this function removes the need for an explicit fallback case and\n * ensures that an unmatched value is never silently ignored.\n *\n * **Example** (Throwing on unmatched input)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * const strictMatcher = Match.type<\"a\" | \"b\">().pipe(\n * Match.when(\"a\", () => \"Found A\"),\n * Match.when(\"b\", () => \"Found B\"),\n * // Will throw if input is neither \"a\" nor \"b\"\n * Match.orElseAbsurd\n * )\n *\n * strictMatcher(\"a\") // => \"Found A\"\n * strictMatcher(\"b\") // => \"Found B\"\n *\n * // This would throw an error at runtime:\n * // strictMatcher(\"c\" as any) // throws\n * ```\n *\n * @see {@link exhaustive} for compile-time exhaustive matcher finalization\n * @see {@link orElse} for providing a fallback for unmatched input\n *\n * @category completion\n * @since 4.0.0\n */\nexport const orElseAbsurd = internal.orElseAbsurd;\n/**\n * Wraps the match result in a `Result`, distinguishing matched and unmatched\n * cases.\n *\n * **Details**\n *\n * This function ensures that the result of a matcher is always wrapped in an\n * `Result`, allowing clear differentiation between successful matches\n * (`Ok(value)`) and cases where no pattern matched (`Err(unmatched\n * value)`).\n *\n * This approach is particularly useful when handling optional values or when an\n * unmatched case should be explicitly handled rather than returning a default\n * value or throwing an error.\n *\n * **Example** (Extracting a user role with `Match.result`)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * type User = { readonly role: \"admin\" | \"editor\" | \"viewer\" }\n *\n * // Create a matcher to extract user roles\n * const getRole = Match.type().pipe(\n * Match.when({ role: \"admin\" }, () => \"Has full access\"),\n * Match.when({ role: \"editor\" }, () => \"Can edit content\"),\n * Match.result // Wrap the result in an Result\n * )\n *\n * getRole({ role: \"admin\" })._tag // => \"Success\"\n *\n * getRole({ role: \"viewer\" })._tag // => \"Failure\"\n * ```\n *\n * @category completion\n * @since 4.0.0\n */\nexport const result = internal.result;\n/**\n * Wraps the match result in an `Option`, representing an optional match.\n *\n * **When to use**\n *\n * Use to finalize a matcher when unmatched input is expected and should become\n * `Option.none`.\n *\n * **Details**\n *\n * This function ensures that the result of a matcher is wrapped in an `Option`,\n * making it easy to handle cases where no pattern matches. If a match is found,\n * it returns `Some(value)`, otherwise, it returns `None`.\n *\n * This is useful in cases where a missing match is expected and should be\n * handled explicitly rather than throwing an error or returning a default\n * value.\n *\n * **Example** (Extracting a user role with `Match.option`)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * type User = { readonly role: \"admin\" | \"editor\" | \"viewer\" }\n *\n * // Create a matcher to extract user roles\n * const getRole = Match.type().pipe(\n * Match.when({ role: \"admin\" }, () => \"Has full access\"),\n * Match.when({ role: \"editor\" }, () => \"Can edit content\"),\n * Match.option // Wrap the result in an Option\n * )\n *\n * getRole({ role: \"admin\" })._tag // => \"Some\"\n *\n * getRole({ role: \"viewer\" })._tag // => \"None\"\n * ```\n *\n * @see {@link result} for preserving unmatched input as a `Result` failure\n * @see {@link orElse} for replacing unmatched input with a fallback value\n *\n * @category completion\n * @since 4.0.0\n */\nexport const option = internal.option;\n/**\n * Completes a matcher that handles every remaining input case.\n *\n * **When to use**\n *\n * Use to require TypeScript to reject incomplete matcher definitions before the\n * matcher is turned into a function.\n *\n * **Details**\n *\n * If any case is still unmatched, the matcher does not type-check as\n * exhaustive.\n *\n * **Example** (Ensuring all cases are covered)\n *\n * ```ts import.meta.vitest\n * import { Match } from \"effect\"\n *\n * // Create a matcher for string or number values\n * const match = Match.type().pipe(\n * // Match when the value is a number\n * Match.when(Match.number, (n) => `number: ${n}`),\n * // Mark the match as exhaustive, ensuring all cases are handled\n * // TypeScript will throw an error if any case is missing\n * // @ts-expect-error Type 'string' is not assignable to type 'never'\n * Match.exhaustive\n * )\n * ```\n *\n * @category completion\n * @since 4.0.0\n */\nexport const exhaustive = internal.exhaustive;\nconst SafeRefinementId = \"~effect/Match/SafeRefinement\";\nconst Fail = /*#__PURE__*/Symbol.for(\"effect/Fail\");\n//# sourceMappingURL=Match.js.map","/**\n * Works with values that may be `undefined`.\n *\n * Use this module for plain TypeScript values of type `A | undefined` when\n * `undefined` is the only absence marker. It is a small alternative to wrapping\n * values in `Option` when your data already uses `undefined` to mean \"no\n * value\". The module includes helpers for mapping defined values, matching both\n * cases, throwing when a value is missing, adapting throwing functions, and\n * building reducers or combiners.\n *\n * @since 4.0.0\n */\nimport * as Combiner from \"./Combiner.js\";\nimport { dual } from \"./Function.js\";\nimport * as Reducer from \"./Reducer.js\";\n/**\n * Maps a defined value with `f`, or returns `undefined` unchanged.\n *\n * **When to use**\n *\n * Use to apply a pure transformation to an `A | undefined` value while\n * preserving `undefined` as absence.\n *\n * @see {@link match} when you need to handle the `undefined` case explicitly\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const map = /*#__PURE__*/dual(2, (self, f) => self === undefined ? undefined : f(self));\n/**\n * Pattern matches on an `A | undefined` value, running `onDefined` when the\n * value is present or evaluating `onUndefined` when the value is `undefined`.\n *\n * **When to use**\n *\n * Use when you need to turn an `A | undefined` into a non-optional result by\n * handling both the defined and undefined branches in one expression.\n *\n * @see {@link map} for transforming defined values while preserving `undefined`\n * @see {@link getOrThrowWith} for throwing when the value is `undefined` instead of returning a fallback branch\n *\n * @category pattern matching\n * @since 4.0.0\n */\nexport const match = /*#__PURE__*/dual(2, (self, {\n onDefined,\n onUndefined\n}) => self === undefined ? onUndefined() : onDefined(self));\n/**\n * Returns the defined value, or throws the value produced by `onUndefined`\n * when the input is `undefined`.\n *\n * **When to use**\n *\n * Use when you need fail-fast unwrapping of an `A | undefined` value and want\n * to provide the thrown error for the undefined case.\n *\n * **Details**\n *\n * Defined values are returned unchanged. When the input is `undefined`,\n * `onUndefined` is called and its result is thrown.\n *\n * @see {@link getOrThrow} for the default-error sibling\n * @see {@link match} for handling defined and undefined cases without throwing\n *\n * @category getters\n * @since 4.0.0\n */\nexport const getOrThrowWith = /*#__PURE__*/dual(2, (self, onUndefined) => {\n if (self !== undefined) {\n return self;\n }\n throw onUndefined();\n});\n/**\n * Returns the defined value, or throws a default `Error` when the input is\n * `undefined`.\n *\n * **When to use**\n *\n * Use when you need to unwrap a value that should already be defined and a\n * generic missing-value `Error` is acceptable.\n *\n * **Details**\n *\n * Defined inputs are returned unchanged. `undefined` throws\n * `new Error(\"getOrThrow called on a undefined\")`.\n *\n * @see {@link getOrThrowWith} for the sibling that lets callers choose the thrown value\n * @see {@link match} for handling defined and undefined cases without throwing\n *\n * @category getters\n * @since 4.0.0\n */\nexport const getOrThrow = /*#__PURE__*/getOrThrowWith(() => new Error(\"getOrThrow called on a undefined\"));\n/**\n * Converts a throwing function into one that returns successful results\n * unchanged and returns `undefined` when the function throws.\n *\n * **When to use**\n *\n * Use to adapt exception-throwing functions when `undefined` is the absence\n * value you want to return for failures.\n *\n * **Gotchas**\n *\n * Thrown values are discarded. If the wrapped function can successfully return\n * `undefined`, that success is indistinguishable from a thrown failure.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const liftThrowable = f => (...a) => {\n try {\n return f(...a);\n } catch {\n return undefined;\n }\n};\n/**\n * Creates a `Reducer` for `UndefinedOr` that prioritizes the first non-`undefined`\n * value and combines values when both operands are present.\n *\n * **When to use**\n *\n * Use when you need to reduce values that may be `undefined`, keeping the\n * first defined value as a fallback and combining only when both operands are\n * defined.\n *\n * **Details**\n *\n * Combining `undefined` with `undefined` returns `undefined`. Combining a\n * defined value with `undefined` keeps the defined value, so the first defined\n * value wins when only one side is present. When both values are defined, they\n * are combined with `combiner.combine`. The reducer's initial value is\n * `undefined`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeReducer(combiner) {\n return Reducer.make((self, that) => {\n if (self === undefined) return that;\n if (that === undefined) return self;\n return combiner.combine(self, that);\n }, undefined);\n}\n/**\n * Creates a `Combiner` for `A | undefined` that combines values only when both\n * operands are defined.\n *\n * **When to use**\n *\n * Use to lift a `Combiner` so any `undefined` operand makes the combined result\n * `undefined`.\n *\n * **Details**\n *\n * - `undefined` combined with any value returns `undefined`\n * - Any value combined with `undefined` returns `undefined`\n * - `a` combined with `b` returns `combiner.combine(a, b)`\n *\n * @see {@link makeReducerFailFast} if you have a `Reducer` and want to lift it\n * to `UndefinedOr` values.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeCombinerFailFast(combiner) {\n return Combiner.make((self, that) => {\n if (self === undefined || that === undefined) return undefined;\n return combiner.combine(self, that);\n });\n}\n/**\n * Creates a `Reducer` for `A | undefined` by wrapping an existing reducer with\n * fail-fast semantics.\n *\n * **When to use**\n *\n * Use to wrap an existing `Reducer` so any `undefined` value aborts the entire\n * reduction result.\n *\n * **Details**\n *\n * - Initial value is the wrapped reducer's `initialValue`\n * - Combining two defined values delegates to the wrapped reducer\n * - If the accumulator or next value is `undefined`, the reduction returns `undefined`\n *\n * @see {@link makeCombinerFailFast} if you only have a `Combiner` and want to\n * lift it to `UndefinedOr` values.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeReducerFailFast(reducer) {\n const combine = makeCombinerFailFast(reducer).combine;\n const initialValue = reducer.initialValue;\n return Reducer.make(combine, initialValue, collection => {\n let out = initialValue;\n for (const value of collection) {\n out = combine(out, value);\n if (out === undefined) return out;\n }\n return out;\n });\n}\n//# sourceMappingURL=UndefinedOr.js.map","import { Cause, Effect, Exit, Inspectable } from 'effect'\n\nexport interface RunOptions {\n readonly signal?: AbortSignal | undefined\n}\n\nfunction causeMessage(cause: Cause.Cause): string {\n if (Cause.hasInterruptsOnly(cause)) {\n // What pi's own tools throw for a cancelled run.\n return 'Operation aborted'\n }\n if (Cause.hasDies(cause)) {\n return Cause.pretty(cause)\n }\n return cause.reasons\n .filter(Cause.isFailReason)\n .map(({ error }) => {\n if (error instanceof Error) {\n return error.message || error.name\n }\n return typeof error === 'string' ? error : Inspectable.toStringUnknown(error)\n })\n .join('\\n')\n}\n\n/** The rejection message is what the model reads back as the tool result. */\nexport async function runTool(\n effect: Effect.Effect,\n options?: RunOptions,\n): Promise {\n const exit = await Effect.runPromiseExit(effect, options)\n if (Exit.isFailure(exit)) {\n throw new Error(causeMessage(exit.cause))\n }\n return exit.value\n}\n\nexport interface RunHandlerOptions {\n readonly onError?: (message: string) => B\n}\n\nexport async function runHandler(\n effect: Effect.Effect,\n options?: RunHandlerOptions,\n): Promise {\n const exit = await Effect.runPromiseExit(effect)\n if (Exit.isSuccess(exit)) {\n return exit.value\n }\n if (options?.onError) {\n return options.onError(causeMessage(exit.cause))\n }\n const die = exit.cause.reasons.find(Cause.isDieReason)\n if (die !== undefined) {\n throw die.defect\n }\n return undefined as B\n}\n","import type { ExtensionContext } from '@earendil-works/pi-coding-agent'\nimport { getAgentDir } from '@earendil-works/pi-coding-agent'\nimport * as NodeServices from '@effect/platform-node/NodeServices'\nimport { Effect, FileSystem, Path, PlatformError, Schema } from 'effect'\nimport { runHandler } from './run'\n\nexport const loadExtensionConfig = Effect.fnUntraced(\n function* >(\n _ctx: ExtensionContext,\n schema: S,\n name: string,\n _defaults: S['Type'],\n ): Effect.fn.Return<\n S['Type'],\n Schema.SchemaError | PlatformError.PlatformError,\n FileSystem.FileSystem | Path.Path\n > {\n const fs = yield* FileSystem.FileSystem\n const path = yield* Path.Path\n const file = path.join(getAgentDir(), 'extensions', `${name}.json`)\n const contents = yield* fs.readFileString(file)\n return yield* Schema.decodeEffect(Schema.fromJsonString(schema))(contents)\n },\n (load, ctx, _schema, name, defaults) =>\n runHandler(\n load.pipe(\n Effect.catchIf(\n (error) =>\n error._tag === 'PlatformError' && error.reason._tag === 'NotFound',\n () => Effect.succeed(defaults),\n ),\n Effect.provide(NodeServices.layer),\n ),\n {\n onError: (message) => {\n if (ctx.hasUI) {\n ctx.ui.notify(`Ignoring invalid ${name} config: ${message}`, 'warning')\n }\n return defaults\n },\n },\n ),\n)\n","import type { ExtensionContext } from '@earendil-works/pi-coding-agent'\nimport { Array, Order, pipe, String } from 'effect'\n\nexport interface StatuslineSegment {\n /** Plain text: the whole row is dimmed uniformly across plugins. */\n readonly text: string\n readonly align: 'left' | 'right'\n}\n\nconst WIDGET_KEY = 'pi-plugins:statusline'\n\n// Each plugin bundles its own copy of this module, so `Symbol.for` on\n// `globalThis` gives them all the same registry inside one pi process.\nconst REGISTRY_KEY = Symbol.for('@pi-plugins/statusline-registry')\n\ntype Registry = Map\n\nfunction side(segments: Registry, align: StatuslineSegment['align']): string {\n return pipe(\n Array.fromIterable(segments),\n Array.filter(([, segment]) => segment.align === align),\n Array.sortBy(\n Order.mapInput(\n Order.String,\n ([key]: readonly [string, StatuslineSegment]) => key,\n ),\n ),\n Array.map(([, segment]) => segment.text),\n Array.join(' · '),\n )\n}\n\nfunction textWidth(text: string): number {\n return Array.fromIterable(text).length\n}\n\nexport function setStatuslineSegment(\n ctx: ExtensionContext,\n key: string,\n segment: StatuslineSegment | undefined,\n): void {\n const store = globalThis as { [REGISTRY_KEY]?: Registry }\n store[REGISTRY_KEY] ??= new Map()\n const segments = store[REGISTRY_KEY]\n if (segment === undefined) {\n segments.delete(key)\n } else {\n segments.set(key, segment)\n }\n\n if (!ctx.hasUI) {\n return\n }\n\n if (segments.size === 0) {\n ctx.ui.setWidget(WIDGET_KEY, undefined)\n return\n }\n\n ctx.ui.setWidget(WIDGET_KEY, (_tui, theme) => ({\n invalidate: () => {},\n render: (width: number) => {\n const left = side(segments, 'left')\n const right = side(segments, 'right')\n\n // Left indented one column like pi's widget rows, right flush like pi's footer.\n const margin = Math.min(width, 1)\n const inner = width - margin\n const gap = inner - textWidth(left) - textWidth(right)\n const minGap = String.isNonEmpty(left) && String.isNonEmpty(right) ? 2 : 0\n\n const line =\n String.isNonEmpty(right) && gap >= minGap\n ? `${left}${' '.repeat(gap)}${right}`\n : pipe(\n [left, right],\n Array.filter(String.isNonEmpty),\n Array.join(' · '),\n Array.fromIterable,\n Array.take(Math.max(inner, 0)),\n Array.join(''),\n )\n\n return [' '.repeat(margin) + theme.fg('dim', line)]\n },\n }))\n}\n","/**\n * Describes HTTP request and response bodies before they reach a platform\n * adapter.\n *\n * `HttpBody` is the shared body representation used by the HTTP modules. Each\n * variant stores the payload together with metadata that can be known before\n * sending it, such as `contentType` and `contentLength`. This module includes\n * body constructors for common payload shapes, support for schema-encoded JSON\n * bodies, streaming and file-backed bodies, and the error type used when body\n * construction fails.\n *\n * @since 4.0.0\n */\nimport * as ByteSize from \"../../ByteSize.js\";\nimport * as Data from \"../../Data.js\";\nimport * as Effect from \"../../Effect.js\";\nimport * as FileSystem from \"../../FileSystem.js\";\nimport { format } from \"../../Formatter.js\";\nimport * as Inspectable from \"../../Inspectable.js\";\nimport * as Option from \"../../Option.js\";\nimport * as PlatformError from \"../../PlatformError.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as Schema from \"../../Schema.js\";\nimport * as SchemaParser from \"../../SchemaParser.js\";\nimport * as UrlParams from \"./UrlParams.js\";\nconst TypeId = \"~effect/http/HttpBody\";\n/**\n * Returns `true` if the provided value is an `HttpBody`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpBody = u => Predicate.hasProperty(u, TypeId);\nconst HttpBodyErrorTypeId = \"~effect/http/HttpBody/HttpBodyError\";\n/**\n * Error produced while constructing an HTTP body from JSON or schema-encoded input.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class HttpBodyError extends /*#__PURE__*/Data.TaggedError(\"HttpBodyError\") {\n /**\n * Marks this value as an HTTP body error for runtime guards.\n *\n * @since 4.0.0\n */\n [HttpBodyErrorTypeId] = HttpBodyErrorTypeId;\n}\nclass Proto {\n [TypeId];\n constructor() {\n this[TypeId] = TypeId;\n }\n [Inspectable.NodeInspectSymbol]() {\n return this.toJSON();\n }\n toString() {\n return format(this, {\n ignoreToString: true\n });\n }\n}\n/**\n * HTTP body variant representing the absence of request content.\n *\n * @category models\n * @since 4.0.0\n */\nexport class Empty extends Proto {\n _tag = \"Empty\";\n toJSON() {\n return {\n _id: \"effect/HttpBody\",\n _tag: \"Empty\"\n };\n }\n}\n/**\n * Provides the singleton empty HTTP body.\n *\n * **When to use**\n *\n * Use when you need an HTTP body value that represents no body content.\n *\n * @category constants\n * @since 4.0.0\n */\nexport const empty = /*#__PURE__*/new Empty();\n/**\n * HTTP body variant containing an arbitrary runtime body value with optional content metadata.\n *\n * @category models\n * @since 4.0.0\n */\nexport class Raw extends Proto {\n _tag = \"Raw\";\n body;\n contentType;\n contentLength;\n constructor(body, contentType, contentLength) {\n super();\n this.body = body;\n this.contentType = contentType;\n this.contentLength = contentLength;\n }\n toJSON() {\n return {\n _id: \"effect/HttpBody\",\n _tag: \"Raw\",\n body: this.body,\n contentType: this.contentType,\n contentLength: this.contentLength\n };\n }\n}\n/**\n * Creates a raw HTTP body from an arbitrary value and optional `contentType` and `contentLength` metadata.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const raw = (body, options) => new Raw(body, options?.contentType, options?.contentLength);\n/**\n * HTTP body variant backed by a `Uint8Array`.\n *\n * **Details**\n *\n * It stores the bytes, content type, and byte length.\n *\n * @category models\n * @since 4.0.0\n */\nexport class Uint8Array extends Proto {\n _tag = \"Uint8Array\";\n contentType;\n contentLength;\n /** Original text retained for adapters that can skip encoding. */\n text;\n _body;\n constructor(body, contentType, contentLength, text) {\n super();\n this._body = body;\n this.text = text;\n this.contentType = contentType;\n this.contentLength = contentLength;\n }\n get body() {\n return this._body ??= encodeText(this.text);\n }\n toJSON() {\n const toString = this.contentType.startsWith(\"text/\") || this.contentType.endsWith(\"json\");\n return {\n _id: \"effect/HttpBody\",\n _tag: \"Uint8Array\",\n body: toString ? new TextDecoder().decode(this.body) : `Uint8Array(${this.body.length})`,\n contentType: this.contentType,\n contentLength: this.contentLength\n };\n }\n}\n/**\n * Creates a byte-array HTTP body.\n *\n * **Details**\n *\n * The content type defaults to `application/octet-stream`, and the content length is the byte array length.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const uint8Array = (body, contentType) => new Uint8Array(body, contentType ?? \"application/octet-stream\", body.length);\nconst encoder = /*#__PURE__*/new TextEncoder();\n// Buffer encodes UTF-8 faster than TextEncoder when available.\nconst buffer = globalThis.Buffer;\nconst encodeText = buffer !== undefined ? body => buffer.from(body, \"utf8\") : body => encoder.encode(body);\n/**\n * Creates a UTF-8 encoded text HTTP body.\n *\n * **Details**\n *\n * The content type defaults to `text/plain`. Text bodies are encoded lazily.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const text = (body, contentType) => {\n if (typeof body !== \"string\") {\n // Preserve untyped callers that relied on TextEncoder coercion.\n body = body === undefined ? \"\" : String(body);\n }\n if (buffer !== undefined) {\n return new Uint8Array(undefined, contentType ?? \"text/plain\", buffer.byteLength(body, \"utf8\"), body);\n }\n const bytes = encoder.encode(body);\n return new Uint8Array(bytes, contentType ?? \"text/plain\", bytes.length, body);\n};\n/**\n * Creates a JSON HTTP body using `JSON.stringify`, throwing if serialization fails.\n *\n * **Details**\n *\n * The content type defaults to `application/json`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const jsonUnsafe = (body, contentType) => text(JSON.stringify(body), contentType ?? \"application/json\");\n/**\n * Creates a JSON HTTP body in an `Effect`.\n *\n * **Details**\n *\n * `JSON.stringify` failures are captured as `HttpBodyError` values, and the content type defaults to `application/json`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const json = (body, contentType) => Effect.try({\n try: () => text(JSON.stringify(body), contentType ?? \"application/json\"),\n catch: cause => new HttpBodyError({\n reason: {\n _tag: \"JsonError\"\n },\n cause\n })\n});\n/**\n * Creates a JSON body constructor that first encodes values with the schema's JSON codec.\n *\n * **Details**\n *\n * Schema encoding issues and JSON serialization failures are returned as `HttpBodyError` values.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const jsonSchema = (schema, options) => {\n const encode = SchemaParser.encodeUnknownEffect(Schema.toCodecJson(schema));\n return (body, contentType) => encode(body, options).pipe(Effect.mapError(issue => new HttpBodyError({\n reason: {\n _tag: \"SchemaError\",\n issue\n },\n cause: issue\n })), Effect.flatMap(body => json(body, contentType)));\n};\n/**\n * Creates an `application/x-www-form-urlencoded` HTTP body from `UrlParams`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const urlParams = (urlParams, contentType) => text(UrlParams.toString(UrlParams.fromInput(urlParams)), contentType ?? \"application/x-www-form-urlencoded\");\n/**\n * HTTP body variant backed by Web `FormData`.\n *\n * **Details**\n *\n * The content type and content length are left unset so the runtime can supply multipart boundaries.\n *\n * @category models\n * @since 4.0.0\n */\nexport class FormData extends Proto {\n _tag = \"FormData\";\n contentType = undefined;\n contentLength = undefined;\n formData;\n constructor(formData) {\n super();\n this.formData = formData;\n }\n toJSON() {\n return {\n _id: \"effect/HttpBody\",\n _tag: \"FormData\",\n formData: this.formData\n };\n }\n}\n/**\n * Wraps a Web `FormData` value as an HTTP body.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const formData = body => new FormData(body);\nconst appendFormDataValue = (formData, key, value) => {\n if (value == null) {\n return;\n }\n if (typeof value === \"object\") {\n formData.append(key, value);\n return;\n }\n formData.append(key, String(value));\n};\n/**\n * Creates a `FormData` HTTP body from a record.\n *\n * **Details**\n *\n * Array fields append each item under the same key; primitive values are stringified, `File` and `Blob` values are appended directly, and nullish values are skipped.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const formDataRecord = entries => {\n const data = new globalThis.FormData();\n for (const [key, value] of Object.entries(entries)) {\n if (Array.isArray(value)) {\n for (const item of value) {\n appendFormDataValue(data, key, item);\n }\n } else {\n appendFormDataValue(data, key, value);\n }\n }\n return formData(data);\n};\n/**\n * HTTP body variant backed by a stream of `Uint8Array` chunks.\n *\n * @category models\n * @since 4.0.0\n */\nexport class Stream extends Proto {\n _tag = \"Stream\";\n stream;\n contentType;\n contentLength;\n constructor(stream, contentType, contentLength) {\n super();\n this.stream = stream;\n this.contentType = contentType;\n this.contentLength = contentLength;\n }\n toJSON() {\n return {\n _id: \"effect/HttpBody\",\n _tag: \"Stream\",\n contentType: this.contentType,\n contentLength: this.contentLength\n };\n }\n}\n/**\n * Creates a streaming HTTP body from a stream of byte chunks.\n *\n * **Details**\n *\n * The content type defaults to `application/octet-stream`; content length is optional.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const stream = (body, contentType, contentLength) => new Stream(body, contentType ?? \"application/octet-stream\", contentLength);\nconst fileRangeSize = (input, field, method) => {\n const size = ByteSize.fromInput(input);\n return Option.isSome(size) ? Effect.succeed(size.value) : Effect.fail(PlatformError.badArgument({\n module: \"HttpBody\",\n method,\n description: `Invalid ${field}: ${input}`\n }));\n};\nconst fileContentLength = /*#__PURE__*/Effect.fnUntraced(function* (size, method, options) {\n const offset = options?.offset === undefined ? ByteSize.zero : yield* fileRangeSize(options.offset, \"offset\", method);\n const bytesToRead = options?.bytesToRead === undefined ? undefined : yield* fileRangeSize(options.bytesToRead, \"bytesToRead\", method);\n const available = offset >= size ? BigInt(\"0\") : size - offset;\n const length = bytesToRead === undefined || bytesToRead > available ? available : bytesToRead;\n if (length > BigInt(Number.MAX_SAFE_INTEGER)) {\n return yield* Effect.fail(PlatformError.badArgument({\n module: \"HttpBody\",\n method,\n description: `Content length exceeds Number.MAX_SAFE_INTEGER: ${length}`\n }));\n }\n return Number(length);\n});\n/**\n * Creates a streaming HTTP body for a file path.\n *\n * **Details**\n *\n * The effect requires `FileSystem`, stats the file to set the selected content length, and can fail with\n * `PlatformError`.\n *\n * Range validation and file access are deferred until the effect runs. Numeric range inputs must be\n * non-negative safe integers; bigint and byte-size strings can represent larger values. Malformed strings,\n * negative values, and non-finite, fractional, or unsafe numbers fail with `PlatformError` / `BadArgument`.\n *\n * The selected length is calculated exactly with bigint arithmetic and clamped to the bytes available after\n * `offset` (zero at or past EOF). Since `Stream.contentLength` is a number, a final length above\n * `Number.MAX_SAFE_INTEGER` fails with `BadArgument`. Larger sizes, offsets, and byte counts are valid when\n * the final clamped length is representable; the resulting Content-Length header preserves that exact length.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const file = (path, options) => Effect.flatMap(FileSystem.FileSystem, fs => Effect.flatMap(fs.stat(path), info => Effect.map(fileContentLength(info.size, \"file\", options), contentLength => stream(fs.stream(path, options), options?.contentType, contentLength))));\n/**\n * Creates a streaming HTTP body for a file path using already-known file information.\n *\n * **Details**\n *\n * The effect requires `FileSystem`, uses the provided file size to determine the selected content length, and can\n * fail with `PlatformError`.\n *\n * Like {@link file}, this constructor validates ranges lazily and calculates the EOF-clamped length with exact\n * bigint arithmetic. Invalid range inputs and final lengths above `Number.MAX_SAFE_INTEGER` fail with\n * `PlatformError` / `BadArgument`. Larger sizes, offsets, and byte counts remain valid when the final length\n * is representable as a safe integer, preserving the exact Content-Length header.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fileFromInfo = (path, info, options) => Effect.flatMap(FileSystem.FileSystem, fs => Effect.map(fileContentLength(info.size, \"fileFromInfo\", options), contentLength => stream(fs.stream(path, options), options?.contentType, contentLength)));\n//# sourceMappingURL=HttpBody.js.map","/**\n * Typed failure model for Effect HTTP client operations.\n *\n * HTTP clients wrap request construction, transport, status-code validation, and\n * response decoding failures in `HttpClientError`. The wrapper keeps the failed\n * request and the specific failure reason together, so callers can handle client\n * failures uniformly while still matching on the reason `_tag` for retry\n * policy, logging, metrics, and user-facing messages.\n *\n * @since 4.0.0\n */\nimport * as Data from \"../../Data.js\";\nimport { hasProperty } from \"../../Predicate.js\";\nimport * as Schema from \"../../Schema.js\";\nconst TypeId = \"~effect/http/HttpClientError\";\n/**\n * Returns `true` when a value is an `HttpClientError`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpClientError = u => hasProperty(u, TypeId);\n/**\n * Error wrapper for HTTP client failures, exposing the failed request and the optional response through its `reason`.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class HttpClientError extends /*#__PURE__*/Data.TaggedError(\"HttpClientError\") {\n constructor(props) {\n if (\"cause\" in props.reason) {\n super({\n ...props,\n cause: props.reason.cause\n });\n } else {\n super(props);\n }\n }\n /**\n * Marks this value as an HTTP client error for runtime guards.\n *\n * @since 4.0.0\n */\n [TypeId] = TypeId;\n /**\n * HTTP request associated with the client failure.\n *\n * @since 4.0.0\n */\n get request() {\n return this.reason.request;\n }\n /**\n * HTTP response associated with the client failure, when one was received.\n *\n * @since 4.0.0\n */\n get response() {\n return \"response\" in this.reason ? this.reason.response : undefined;\n }\n get message() {\n return this.reason.message;\n }\n}\nconst formatReason = tag => tag.endsWith(\"Error\") ? tag.slice(0, -5) : tag;\nconst formatMessage = (reason, description, info) => description ? `${reason}: ${description} (${info})` : `${reason} error (${info})`;\n/**\n * Error describing transport-level failures that occur while sending an HTTP request.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class TransportError extends /*#__PURE__*/Data.TaggedError(\"TransportError\") {\n /**\n * Formats the request method and URL for transport error messages.\n *\n * @since 4.0.0\n */\n get methodAndUrl() {\n return `${this.request.method} ${this.request.url}`;\n }\n /**\n * Builds the transport error message from the optional description and request details.\n *\n * @since 4.0.0\n */\n get message() {\n return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl);\n }\n}\n/**\n * Error describing failures while encoding an HTTP request body.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class EncodeError extends /*#__PURE__*/Data.TaggedError(\"EncodeError\") {\n /**\n * Formats the request method and URL for request encoding error messages.\n *\n * @since 4.0.0\n */\n get methodAndUrl() {\n return `${this.request.method} ${this.request.url}`;\n }\n /**\n * Builds the request encoding error message from the optional description and request details.\n *\n * @since 4.0.0\n */\n get message() {\n return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl);\n }\n}\n/**\n * Error describing failures while constructing a URL from an HTTP client request.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class InvalidUrlError extends /*#__PURE__*/Data.TaggedError(\"InvalidUrlError\") {\n /**\n * Formats the request method and URL for invalid URL error messages.\n *\n * @since 4.0.0\n */\n get methodAndUrl() {\n return `${this.request.method} ${this.request.url}`;\n }\n /**\n * Builds the invalid URL error message from the optional description and request details.\n *\n * @since 4.0.0\n */\n get message() {\n return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl);\n }\n}\n/**\n * Response error for HTTP responses rejected because of their status code.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class StatusCodeError extends /*#__PURE__*/Data.TaggedError(\"StatusCodeError\") {\n /**\n * Formats the request method and URL for status code error messages.\n *\n * @since 4.0.0\n */\n get methodAndUrl() {\n return `${this.request.method} ${this.request.url}`;\n }\n /**\n * Builds the status code error message from the response status, optional description, and request details.\n *\n * @since 4.0.0\n */\n get message() {\n const info = `${this.response.status} ${this.methodAndUrl}`;\n return formatMessage(formatReason(this._tag), this.description, info);\n }\n}\n/**\n * Response error for failures while decoding an HTTP response body.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class DecodeError extends /*#__PURE__*/Data.TaggedError(\"DecodeError\") {\n /**\n * Formats the request method and URL for response decoding error messages.\n *\n * @since 4.0.0\n */\n get methodAndUrl() {\n return `${this.request.method} ${this.request.url}`;\n }\n /**\n * Builds the response decoding error message from the response status, optional description, and request details.\n *\n * @since 4.0.0\n */\n get message() {\n const info = `${this.response.status} ${this.methodAndUrl}`;\n return formatMessage(formatReason(this._tag), this.description, info);\n }\n}\n/**\n * Response error for operations that expected a response body but received an empty body.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class EmptyBodyError extends /*#__PURE__*/Data.TaggedError(\"EmptyBodyError\") {\n /**\n * Formats the request method and URL for empty response body error messages.\n *\n * @since 4.0.0\n */\n get methodAndUrl() {\n return `${this.request.method} ${this.request.url}`;\n }\n /**\n * Builds the empty body error message from the response status, optional description, and request details.\n *\n * @since 4.0.0\n */\n get message() {\n const info = `${this.response.status} ${this.methodAndUrl}`;\n return formatMessage(formatReason(this._tag), this.description, info);\n }\n}\n/**\n * Schema for serializable HTTP client errors, preserving the specific error kind\n * and cause.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport class HttpClientErrorSchema extends /*#__PURE__*/Schema.Error(TypeId)({\n _tag: /*#__PURE__*/Schema.tag(\"HttpError\"),\n kind: /*#__PURE__*/Schema.Literals([\"EncodeError\", \"DecodeError\", \"TransportError\", \"InvalidUrlError\", \"StatusCodeError\", \"EmptyBodyError\"]),\n cause: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Defect())\n}) {\n /**\n * Builds the serializable schema representation for an HTTP client error.\n *\n * @since 4.0.0\n */\n static fromHttpClientError(error) {\n return new HttpClientErrorSchema({\n _tag: \"HttpError\",\n kind: error.reason._tag,\n cause: error.reason\n });\n }\n}\n//# sourceMappingURL=HttpClientError.js.map","/**\n * Defines supported HTTP method names for the unstable HTTP modules.\n *\n * Values are uppercase string literals such as `\"GET\"` and `\"POST\"`, matching\n * the method tokens used by HTTP requests and routes. This module also includes\n * helpers for checking whether a method can carry a request body and whether an\n * unknown value is one of the supported methods.\n *\n * @since 4.0.0\n */\n/**\n * Returns `true` when a method can carry a request body and narrows it to `HttpMethod.WithBody`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const hasBody = method => method !== \"GET\" && method !== \"HEAD\" && method !== \"OPTIONS\" && method !== \"TRACE\";\n/**\n * Provides a readonly set containing every supported `HttpMethod` literal.\n *\n * **When to use**\n *\n * Use when you need to iterate over or test membership against every supported\n * HTTP method literal.\n *\n * @category constants\n * @since 4.0.0\n */\nexport const all = /*#__PURE__*/new Set([\"GET\", \"POST\", \"PUT\", \"DELETE\", \"PATCH\", \"HEAD\", \"OPTIONS\", \"TRACE\"]);\n/**\n * Provides tuples mapping each supported HTTP method to its short\n * request-constructor name.\n *\n * **When to use**\n *\n * Use when you need the mapping from supported HTTP method literals to their\n * short request-constructor names.\n *\n * @category constants\n * @since 4.0.0\n */\nexport const allShort = [[\"GET\", \"get\"], [\"POST\", \"post\"], [\"PUT\", \"put\"], [\"DELETE\", \"del\"], [\"PATCH\", \"patch\"], [\"HEAD\", \"head\"], [\"OPTIONS\", \"options\"], [\"TRACE\", \"trace\"]];\n/**\n * Checks whether a value is a `HttpMethod`.\n *\n * **Example** (Checking HTTP method values)\n *\n * ```ts import.meta.vitest\n * import { HttpMethod } from \"effect/unstable/http\"\n *\n * HttpMethod.isHttpMethod(\"GET\") // => true\n * HttpMethod.isHttpMethod(\"get\") // => false\n * HttpMethod.isHttpMethod(1) // => false\n * ```\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpMethod = u => all.has(u);\n//# sourceMappingURL=HttpMethod.js.map","import * as Headers from \"../Headers.js\";\n/** @internal */\nexport const updateHeaders = (headers, body) => {\n if (body._tag === \"Empty\" || body._tag === \"FormData\") {\n return Headers.remove(Headers.remove(headers, \"content-type\"), \"content-length\");\n }\n headers = body.contentType === undefined ? Headers.remove(headers, \"content-type\") : Headers.set(headers, \"content-type\", body.contentType);\n return body.contentLength === undefined ? Headers.remove(headers, \"content-length\") : Headers.set(headers, \"content-length\", body.contentLength.toString());\n};\n/** @internal */\nexport const parseContentLength = contentLength => {\n if (contentLength === null || contentLength === undefined || !/^\\d+$/.test(contentLength)) {\n return undefined;\n }\n const parsed = Number(contentLength);\n return Number.isSafeInteger(parsed) ? parsed : undefined;\n};\n//# sourceMappingURL=httpBody.js.map","/**\n * Parses and edits platform `URL` values.\n *\n * The HTTP modules use the standard `URL` object as their URL representation.\n * This module adds safe parsing and helpers that return updated copies when\n * changing credentials, host, path, protocol, query, or hash parts. Query\n * strings can also be read or updated through `UrlParams`.\n *\n * @since 4.0.0\n */\nimport * as Cause from \"../../Cause.js\";\nimport * as Data from \"../../Data.js\";\nimport { dual } from \"../../Function.js\";\nimport * as Redacted from \"../../Redacted.js\";\nimport * as Result from \"../../Result.js\";\nimport * as UrlParams from \"./UrlParams.js\";\n/**\n * Error returned when constructing a `URL` fails.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class UrlError extends /*#__PURE__*/Data.TaggedError(\"UrlError\") {}\n/**\n * Creates a `URL` safely by appending `UrlParams` and an optional hash to a URL string.\n *\n * **Details**\n *\n * Returns a `Result` that fails with `UrlError` if the URL cannot be constructed.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = (url, params, hash) => Result.try({\n try: () => {\n const urlInstance = new URL(url, baseUrl());\n for (let i = 0; i < params.params.length; i++) {\n const [key, value] = params.params[i];\n if (value !== undefined) {\n urlInstance.searchParams.append(key, value);\n }\n }\n if (hash !== undefined) {\n urlInstance.hash = hash;\n }\n return urlInstance;\n },\n catch: cause => new UrlError({\n cause\n })\n});\nconst baseUrl = () => {\n if (\"location\" in globalThis && globalThis.location !== undefined && globalThis.location.origin !== undefined && globalThis.location.pathname !== undefined) {\n return location.origin + location.pathname;\n }\n return undefined;\n};\n/**\n * Parses a URL string safely into a `URL` object, returning a `Result` type for\n * error handling.\n *\n * **Details**\n *\n * This function converts a string into a `URL` object, enabling safe URL\n * parsing with built-in error handling. If the string is invalid or fails to\n * parse, this function does not throw an error; instead, it wraps the error in\n * a `IllegalArgumentError` and returns it as the `Failure` value of an\n * `Result`. The `Success` value contains the successfully parsed `URL`.\n *\n * An optional `base` parameter can be provided to resolve relative URLs. If\n * specified, the function interprets the input `url` as relative to this\n * `base`. This is especially useful when dealing with URLs that might not be\n * fully qualified.\n *\n * **Example** (Parsing absolute and relative URLs)\n *\n * ```ts import.meta.vitest\n * import { Result } from \"effect\"\n * import { Url } from \"effect/unstable/http\"\n *\n * // Parse an absolute URL\n * //\n * // ┌─── Result\n * // ▼\n * const parsed = Url.fromString(\"https://example.com/path\")\n *\n * Result.map(parsed, (url) => url.toString()) // => Result.succeed(\"https://example.com/path\")\n *\n * // Parse a relative URL with a base\n * const relativeParsed = Url.fromString(\"/relative-path\", \"https://example.com\")\n *\n * Result.map(relativeParsed, (url) => url.toString()) // => Result.succeed(\"https://example.com/relative-path\")\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromString = (url, base) => Result.try({\n try: () => new URL(url, base),\n catch: () => new Cause.IllegalArgumentError(`Invalid URL: \"${url}\"${base !== undefined ? ` with base \"${base}\"` : \"\"}`)\n});\n/**\n * Updates a cloned `URL` with a callback, allowing multiple changes at once.\n *\n * **Example** (Mutating URL credentials)\n *\n * ```ts import.meta.vitest\n * import { Url } from \"effect/unstable/http\"\n *\n * const myUrl = new URL(\"https://example.com\")\n *\n * const mutatedUrl = Url.mutate(myUrl, (url) => {\n * url.username = \"user\"\n * url.password = \"pass\"\n * })\n *\n * mutatedUrl.toString() // => \"https://user:pass@example.com/\"\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const mutate = /*#__PURE__*/dual(2, (self, f) => {\n const copy = new URL(self);\n f(copy);\n return copy;\n});\n/** @internal */\nconst immutableURLSetter = property => dual(2, (url, value) => mutate(url, url => {\n url[property] = value;\n}));\n/**\n * Updates the hash fragment of the URL.\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setHash = /*#__PURE__*/immutableURLSetter(\"hash\");\n/**\n * Updates the host (domain and port) of the URL.\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setHost = /*#__PURE__*/immutableURLSetter(\"host\");\n/**\n * Updates the domain of the URL without modifying the port.\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setHostname = /*#__PURE__*/immutableURLSetter(\"hostname\");\n/**\n * Replaces the entire URL string.\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setHref = /*#__PURE__*/immutableURLSetter(\"href\");\n/**\n * Updates the password used for authentication.\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setPassword = /*#__PURE__*/dual(2, (url, password) => mutate(url, url => {\n url.password = typeof password === \"string\" ? password : Redacted.value(password);\n}));\n/**\n * Updates the path of the URL.\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setPathname = /*#__PURE__*/immutableURLSetter(\"pathname\");\n/**\n * Updates the port of the URL.\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setPort = /*#__PURE__*/immutableURLSetter(\"port\");\n/**\n * Updates the protocol (e.g., `http`, `https`).\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setProtocol = /*#__PURE__*/immutableURLSetter(\"protocol\");\n/**\n * Updates the query string of the URL.\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setSearch = /*#__PURE__*/immutableURLSetter(\"search\");\n/**\n * Updates the username used for authentication.\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setUsername = /*#__PURE__*/immutableURLSetter(\"username\");\n/**\n * Updates the query parameters of a URL.\n *\n * **Details**\n *\n * This function allows you to set or replace the query parameters of a `URL`\n * object using the provided `UrlParams`. It creates a new `URL` object with the\n * updated parameters, leaving the original object unchanged.\n *\n * **Example** (Replacing query parameters)\n *\n * ```ts import.meta.vitest\n * import { Url, UrlParams } from \"effect/unstable/http\"\n *\n * const myUrl = new URL(\"https://example.com?foo=bar\")\n *\n * // Write parameters\n * const updatedUrl = Url.setUrlParams(\n * myUrl,\n * UrlParams.fromInput([[\"key\", \"value\"]])\n * )\n *\n * updatedUrl.toString() // => \"https://example.com/?key=value\"\n * ```\n *\n * @category setters\n * @since 4.0.0\n */\nexport const setUrlParams = /*#__PURE__*/dual(2, (url, urlParams) => mutate(url, url => {\n url.search = UrlParams.toString(UrlParams.fromInput(urlParams));\n}));\n/**\n * Retrieves the query parameters from a URL.\n *\n * **Details**\n *\n * This function extracts the query parameters from a `URL` object and returns\n * them as `UrlParams`. The resulting structure can be easily manipulated or\n * inspected.\n *\n * **Example** (Reading query parameters)\n *\n * ```ts import.meta.vitest\n * import { Url, UrlParams } from \"effect/unstable/http\"\n *\n * const myUrl = new URL(\"https://example.com?foo=bar\")\n *\n * // Read parameters\n * const params = Url.urlParams(myUrl)\n *\n * UrlParams.toString(params) // => \"foo=bar\"\n * ```\n *\n * @category getters\n * @since 4.0.0\n */\nexport const urlParams = url => UrlParams.fromInput(url.searchParams);\n/**\n * Reads the query parameters of a URL, modifies them, and updates the URL.\n *\n * **Details**\n *\n * This function provides a functional way to interact with query parameters by\n * reading the current parameters, applying a transformation function, and then\n * writing the updated parameters back to the URL. It returns a new `URL` object\n * with the modified parameters, ensuring immutability.\n *\n * **Example** (Modifying query parameters)\n *\n * ```ts import.meta.vitest\n * import { Url, UrlParams } from \"effect/unstable/http\"\n *\n * const myUrl = new URL(\"https://example.com?foo=bar\")\n *\n * const changedUrl = Url.modifyUrlParams(myUrl, UrlParams.append(\"key\", \"value\"))\n *\n * changedUrl.toString() // => \"https://example.com/?foo=bar&key=value\"\n * ```\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const modifyUrlParams = /*#__PURE__*/dual(2, (url, f) => mutate(url, url => {\n const params = f(UrlParams.fromInput(url.searchParams));\n url.search = UrlParams.toString(params);\n}));\n//# sourceMappingURL=Url.js.map","import * as Context from \"../../Context.js\";\nimport * as Effect from \"../../Effect.js\";\nimport { dual } from \"../../Function.js\";\nimport * as Inspectable from \"../../Inspectable.js\";\nimport { stringOrRedacted } from \"../../internal/redacted.js\";\nimport * as Option from \"../../Option.js\";\nimport { pipeArguments } from \"../../Pipeable.js\";\nimport { hasProperty } from \"../../Predicate.js\";\nimport { redact } from \"../../Redactable.js\";\nimport * as Result from \"../../Result.js\";\nimport * as Stream from \"../../Stream.js\";\nimport * as Headers from \"./Headers.js\";\nimport * as HttpBody from \"./HttpBody.js\";\nimport { hasBody } from \"./HttpMethod.js\";\nimport * as bodyInternal from \"./internal/httpBody.js\";\nimport * as Url from \"./Url.js\";\nimport * as UrlParams from \"./UrlParams.js\";\nconst TypeId = \"~effect/http/HttpClientRequest\";\n/**\n * Returns `true` when a value is an `HttpClientRequest`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpClientRequest = u => hasProperty(u, TypeId);\nconst Proto = {\n [TypeId]: TypeId,\n ...Inspectable.BaseProto,\n toJSON() {\n return {\n _id: \"HttpClientRequest\",\n method: this.method,\n url: this.url,\n urlParams: this.urlParams,\n hash: this.hash,\n headers: redact(this.headers),\n body: this.body.toJSON()\n };\n },\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\n/**\n * Constructs an `HttpClientRequest` from fully normalized request components.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport function makeWith(method, url, urlParams, hash, headers, body) {\n const self = Object.create(Proto);\n self.method = method;\n self.url = url;\n self.urlParams = urlParams;\n self.hash = hash;\n self.headers = headers;\n self.body = body;\n return self;\n}\n/**\n * An empty `GET` request with no URL, query parameters, hash, headers, or body.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const empty = /*#__PURE__*/makeWith(\"GET\", \"\", UrlParams.empty, /*#__PURE__*/Option.none(), Headers.empty, HttpBody.empty);\n/**\n * Creates a request constructor for the specified HTTP method.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = method => (url, options) => modify(empty, {\n method,\n url,\n ...(options ?? undefined)\n});\n/**\n * Creates a `GET` request for the specified URL.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const get = /*#__PURE__*/make(\"GET\");\n/**\n * Creates a `POST` request for the specified URL.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const post = /*#__PURE__*/make(\"POST\");\n/**\n * Creates a `PATCH` request for the specified URL.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const patch = /*#__PURE__*/make(\"PATCH\");\n/**\n * Creates a `PUT` request for the specified URL.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const put = /*#__PURE__*/make(\"PUT\");\nconst del = /*#__PURE__*/make(\"DELETE\");\nexport {\n/**\n * Creates a `DELETE` request for the specified URL.\n *\n * @category constructors\n * @since 4.0.0\n */\ndel as delete };\n/**\n * Creates a `HEAD` request for the specified URL.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const head = /*#__PURE__*/make(\"HEAD\");\n/**\n * Creates an `OPTIONS` request for the specified URL.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const options = /*#__PURE__*/make(\"OPTIONS\");\n/**\n * Creates a `TRACE` request for the specified URL.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const trace = /*#__PURE__*/make(\"TRACE\");\n/**\n * Applies request options to an `HttpClientRequest`, returning a new request.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const modify = /*#__PURE__*/dual(2, (self, options) => {\n let result = self;\n if (options.method) {\n result = setMethod(result, options.method);\n }\n if (options.url) {\n result = setUrl(result, options.url);\n }\n if (options.headers) {\n result = setHeaders(result, options.headers);\n }\n if (options.urlParams) {\n result = setUrlParams(result, options.urlParams);\n }\n if (options.hash) {\n result = setHash(result, options.hash);\n }\n if (options.body) {\n result = setBody(result, options.body);\n }\n if (options.accept) {\n result = accept(result, options.accept);\n }\n if (options.acceptJson) {\n result = acceptJson(result);\n }\n return result;\n});\n/**\n * Sets the HTTP method on a request, returning a new request.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setMethod = /*#__PURE__*/dual(2, (self, method) => makeWith(method, self.url, self.urlParams, self.hash, self.headers, self.body));\n/**\n * Sets a single request header, replacing any existing value for that header.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setHeader = /*#__PURE__*/dual(3, (self, key, value) => makeWith(self.method, self.url, self.urlParams, self.hash, Headers.set(self.headers, key, value), self.body));\n/**\n * Sets multiple request headers from an input collection, replacing existing values with matching names.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setHeaders = /*#__PURE__*/dual(2, (self, input) => makeWith(self.method, self.url, self.urlParams, self.hash, Headers.setAll(self.headers, input), self.body));\n/**\n * Transforms the request headers with the provided function, returning a new request.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const updateHeaders = /*#__PURE__*/dual(2, (self, f) => makeWith(self.method, self.url, self.urlParams, self.hash, f(self.headers), self.body));\n/**\n * Removes a single request header by name, returning a new request.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const removeHeader = /*#__PURE__*/dual(2, (self, key) => updateHeaders(self, Headers.remove(key)));\n/**\n * Sets the `Authorization` header using HTTP Basic authentication credentials.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const basicAuth = /*#__PURE__*/dual(3, (self, username, password) => setHeader(self, \"Authorization\", `Basic ${btoa(`${stringOrRedacted(username)}:${stringOrRedacted(password)}`)}`));\n/**\n * Sets the `Authorization` header using a bearer token.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const bearerToken = /*#__PURE__*/dual(2, (self, token) => setHeader(self, \"Authorization\", `Bearer ${stringOrRedacted(token)}`));\n/**\n * Sets the `Accept` header to the specified media type.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const accept = /*#__PURE__*/dual(2, (self, mediaType) => setHeader(self, \"Accept\", mediaType));\n/**\n * Sets the `Accept` header to `application/json`.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const acceptJson = /*#__PURE__*/accept(\"application/json\");\n/**\n * Sets the request URL. When given a `URL`, its search parameters and hash are extracted into the request's structured fields.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setUrl = /*#__PURE__*/dual(2, (self, url) => {\n if (typeof url === \"string\") {\n return makeWith(self.method, url, self.urlParams, self.hash, self.headers, self.body);\n }\n const clone = new URL(url.toString());\n const urlParams = UrlParams.fromInput(clone.searchParams);\n const hash = Option.fromNullishOr(clone.hash === \"\" ? undefined : clone.hash.slice(1));\n clone.search = \"\";\n clone.hash = \"\";\n return makeWith(self.method, clone.toString(), urlParams, hash, self.headers, self.body);\n});\n/**\n * Prepends a URL segment to the request URL, inserting or trimming one slash as needed.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const prependUrl = /*#__PURE__*/dual(2, (self, path) => {\n if (path === \"\") return self;\n return makeWith(self.method, joinSegments(path, self.url), self.urlParams, self.hash, self.headers, self.body);\n});\n/**\n * Appends a URL segment to the request URL, inserting or trimming one slash as needed.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const appendUrl = /*#__PURE__*/dual(2, (self, path) => {\n if (path === \"\") return self;\n return makeWith(self.method, joinSegments(self.url, path), self.urlParams, self.hash, self.headers, self.body);\n});\nconst joinSegments = (first, second) => {\n const endsWithSlash = first.endsWith(\"/\");\n const startsWithSlash = second.startsWith(\"/\");\n const needsTrim = endsWithSlash && startsWithSlash;\n const needsSlash = !endsWithSlash && !startsWithSlash;\n return needsTrim ? first + second.slice(1) : needsSlash ? first + \"/\" + second : first + second;\n};\n/**\n * Updates the request URL by applying a function to the current URL string.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const updateUrl = /*#__PURE__*/dual(2, (self, f) => makeWith(self.method, f(self.url), self.urlParams, self.hash, self.headers, self.body));\n/**\n * Sets one query parameter, replacing existing values for that parameter name.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setUrlParam = /*#__PURE__*/dual(3, (self, key, value) => makeWith(self.method, self.url, UrlParams.set(self.urlParams, key, value), self.hash, self.headers, self.body));\n/**\n * Sets query parameters from an input collection, replacing existing values for matching names.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setUrlParams = /*#__PURE__*/dual(2, (self, input) => makeWith(self.method, self.url, UrlParams.setAll(self.urlParams, input), self.hash, self.headers, self.body));\n/**\n * Appends one query parameter value without removing existing values for the same name.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const appendUrlParam = /*#__PURE__*/dual(3, (self, key, value) => makeWith(self.method, self.url, UrlParams.append(self.urlParams, key, value), self.hash, self.headers, self.body));\n/**\n * Appends query parameters from an input collection without removing existing values for matching names.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const appendUrlParams = /*#__PURE__*/dual(2, (self, input) => makeWith(self.method, self.url, UrlParams.appendAll(self.urlParams, input), self.hash, self.headers, self.body));\n/**\n * Sets the URL fragment on a request without the leading `#`.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setHash = /*#__PURE__*/dual(2, (self, hash) => makeWith(self.method, self.url, self.urlParams, Option.some(hash), self.headers, self.body));\n/**\n * Removes the URL fragment from a request.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const removeHash = self => makeWith(self.method, self.url, self.urlParams, Option.none(), self.headers, self.body);\n/**\n * Sets the request body and updates `Content-Type` and `Content-Length` headers from the body metadata when available.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setBody = /*#__PURE__*/dual(2, (self, body) => {\n return makeWith(self.method, self.url, self.urlParams, self.hash, bodyInternal.updateHeaders(self.headers, body), body);\n});\n/**\n * Sets a `Uint8Array` request body with an optional content type.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const bodyUint8Array = /*#__PURE__*/dual(args => isHttpClientRequest(args[0]), (self, body, contentType) => setBody(self, HttpBody.uint8Array(body, contentType)));\n/**\n * Sets a text request body with an optional content type.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const bodyText = /*#__PURE__*/dual(args => isHttpClientRequest(args[0]), (self, body, contentType) => setBody(self, HttpBody.text(body, contentType)));\n/**\n * Encodes a value as a JSON request body and sets it on the request, failing with `HttpBodyError` if encoding fails.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const bodyJson = /*#__PURE__*/dual(2, (self, body) => Effect.map(HttpBody.json(body), body => setBody(self, body)));\n/**\n * Sets a JSON request body using unsafe JSON encoding.\n *\n * **When to use**\n *\n * Use when the request body is known to be JSON-serializable and a synchronous\n * `HttpClientRequest` result is needed.\n *\n * **Gotchas**\n *\n * JSON encoding may throw instead of failing in the Effect error channel.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const bodyJsonUnsafe = /*#__PURE__*/dual(2, (self, body) => setBody(self, HttpBody.jsonUnsafe(body)));\n/**\n * Creates a schema-based JSON body encoder that sets the encoded value on a request.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const schemaBodyJson = (schema, options) => {\n const encode = HttpBody.jsonSchema(schema, options);\n return dual(2, (self, body) => Effect.map(encode(body), body => setBody(self, body)));\n};\n/**\n * Sets an `application/x-www-form-urlencoded` request body from URL parameter input.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const bodyUrlParams = /*#__PURE__*/dual(2, (self, input) => setBody(self, HttpBody.urlParams(UrlParams.fromInput(input))));\n/**\n * Sets a `FormData` request body.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const bodyFormData = /*#__PURE__*/dual(2, (self, body) => setBody(self, HttpBody.formData(body)));\n/**\n * Creates a `FormData` request body from record-style entries and sets it on the request.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const bodyFormDataRecord = /*#__PURE__*/dual(2, (self, entries) => setBody(self, HttpBody.formDataRecord(entries)));\n/**\n * Sets a streaming `Uint8Array` request body with optional content type and content length metadata.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const bodyStream = /*#__PURE__*/dual(args => isHttpClientRequest(args[0]), (self, body, options) => setBody(self, HttpBody.stream(body, options?.contentType, options?.contentLength)));\n/**\n * Creates a file-backed request body from a filesystem path and sets it on the request.\n *\n * **Details**\n *\n * Uses {@link HttpBody.file} to validate ranges lazily and calculate the EOF-clamped content length with exact\n * bigint arithmetic. Invalid range inputs or a final length above `Number.MAX_SAFE_INTEGER` fail with\n * `PlatformError` / `BadArgument`. Larger sizes, offsets, and byte counts are valid when the final length is\n * representable as a safe integer. The request's Content-Length header contains that exact length.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const bodyFile = /*#__PURE__*/dual(args => isHttpClientRequest(args[0]), (self, path, options) => Effect.map(HttpBody.file(path, options), body => setBody(self, body)));\n/**\n * Builds a `URL` from the request URL, query parameters, and hash, returning `Option.none()` if the URL is invalid.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport function toUrl(self) {\n const r = Url.make(self.url, self.urlParams, Option.getOrUndefined(self.hash));\n if (Result.isSuccess(r)) {\n return Option.some(r.success);\n }\n return Option.none();\n}\n/**\n * Converts a Web `Request` into an `HttpClientRequest`, preserving method, URL, headers, and supported request bodies.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromWeb = request => {\n const method = request.method.toUpperCase();\n return modify(empty, {\n method,\n url: new URL(request.url),\n headers: request.headers,\n body: fromWebBody(request, method)\n });\n};\nconst fromWebBody = (request, method) => {\n if (!hasBody(method) || request.body === null) {\n return HttpBody.empty;\n }\n return HttpBody.raw(request.body, {\n contentType: request.headers.get(\"content-type\") ?? undefined,\n contentLength: bodyInternal.parseContentLength(request.headers.get(\"content-length\"))\n });\n};\n/**\n * Converts an `HttpClientRequest` safely to a Web `Request` as a `Result`, failing when the request URL is invalid.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toWebResult = (self, options) => {\n const url = Url.make(self.url, self.urlParams, Option.getOrUndefined(self.hash));\n if (Result.isFailure(url)) {\n return Result.fail(url.failure);\n }\n const requestInit = {\n method: self.method,\n headers: self.headers\n };\n if (options?.signal) {\n requestInit.signal = options.signal;\n }\n if (hasBody(self.method)) {\n switch (self.body._tag) {\n case \"Empty\":\n {\n break;\n }\n case \"Raw\":\n {\n requestInit.body = self.body.body;\n if (isReadableStream(self.body.body)) {\n ;\n requestInit.duplex = \"half\";\n }\n break;\n }\n case \"Uint8Array\":\n {\n requestInit.body = self.body.body;\n break;\n }\n case \"FormData\":\n {\n requestInit.body = self.body.formData;\n break;\n }\n case \"Stream\":\n {\n requestInit.body = Stream.toReadableStreamWith(self.body.stream, options?.context ?? Context.empty());\n requestInit.duplex = \"half\";\n break;\n }\n }\n }\n return Result.try({\n try: () => new Request(url.success, requestInit),\n catch: cause => new Url.UrlError({\n cause\n })\n });\n};\nconst isReadableStream = u => typeof ReadableStream !== \"undefined\" && u instanceof ReadableStream;\n/**\n * Converts an `HttpClientRequest` to a Web `Request`, failing with `UrlError` when the request URL is invalid.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toWeb = (self, options) => Effect.contextWith(context => Effect.fromResult(toWebResult(self, {\n context: context,\n signal: options?.signal\n})));\n//# sourceMappingURL=HttpClientRequest.js.map","import * as Context from \"../../Context.js\";\nimport * as Effect from \"../../Effect.js\";\nimport { hasProperty } from \"../../Predicate.js\";\nimport { redact } from \"../../Redactable.js\";\nimport * as Schema from \"../../Schema.js\";\n/**\n * Type identifier for `HttpIncomingMessage` values.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = \"~effect/http/HttpIncomingMessage\";\n/**\n * Returns `true` when a value is an `HttpIncomingMessage`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpIncomingMessage = u => hasProperty(u, TypeId);\n/**\n * Creates a decoder that reads an incoming message's JSON body and decodes it with the supplied schema.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaBodyJson = (schema, options) => {\n const decode = Schema.decodeEffect(Schema.toCodecJson(schema));\n const decodeJson = options?.reviver === undefined ? undefined : Schema.decodeEffect(Schema.fromJsonString(Schema.toCodecJson(schema), options));\n return self => decodeJson === undefined ? Effect.flatMap(self.json, u => decode(u, options)) : Effect.flatMap(self.text, body => body === \"\" ? Effect.flatMap(self.json, u => decode(u, options)) : decodeJson(body, options));\n};\n/**\n * Creates a decoder that reads an incoming message's URL-encoded body parameters and decodes them with the supplied schema.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaBodyUrlParams = (schema, options) => {\n const decode = Schema.RecordFromUrlParams.pipe(Schema.decodeTo(schema), Schema.decodeEffect);\n return self => Effect.flatMap(self.urlParamsBody, u => decode(u, options));\n};\n/**\n * Creates a decoder that validates and decodes an incoming message's headers with the supplied schema.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaHeaders = (schema, options) => {\n const decode = Schema.decodeUnknownEffect(schema);\n return self => decode(self.headers, options);\n};\n/**\n * Context reference for the optional maximum size allowed when reading an incoming message body.\n *\n * @category references\n * @since 4.0.0\n */\nexport const MaxBodySize = /*#__PURE__*/Context.Reference(\"effect/http/HttpIncomingMessage/MaxBodySize\", {\n defaultValue: () => undefined\n});\n/**\n * Builds an inspectable object for an incoming message, redacting headers and including a synchronously readable JSON or text body when available.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const inspect = (self, that) => {\n const contentType = self.headers[\"content-type\"] ?? \"\";\n let body;\n if (contentType.includes(\"application/json\")) {\n try {\n body = Effect.runSync(self.json);\n // oxlint-disable-next-line @typescript-eslint/no-unused-vars\n } catch (_) {\n //\n }\n } else if (contentType.includes(\"text/\") || contentType.includes(\"urlencoded\")) {\n try {\n body = Effect.runSync(self.text);\n // oxlint-disable-next-line @typescript-eslint/no-unused-vars\n } catch (_) {\n //\n }\n }\n const obj = {\n ...that,\n headers: redact(self.headers),\n remoteAddress: self.remoteAddress\n };\n if (body !== undefined) {\n obj.body = body;\n }\n return obj;\n};\n//# sourceMappingURL=HttpIncomingMessage.js.map","/**\n * Represents responses returned by the Effect HTTP client.\n *\n * An `HttpClientResponse` keeps the original request together with the response\n * status, headers, cookies, and body accessors from the shared incoming-message\n * model. This module includes constructors, schema-based decoders, helpers for\n * streaming response bodies, and utilities for matching or filtering by HTTP\n * status.\n *\n * @since 4.0.0\n */\nimport * as Effect from \"../../Effect.js\";\nimport { dual } from \"../../Function.js\";\nimport * as Inspectable from \"../../Inspectable.js\";\nimport * as Option from \"../../Option.js\";\nimport { pipeArguments } from \"../../Pipeable.js\";\nimport * as Schema from \"../../Schema.js\";\nimport * as Stream from \"../../Stream.js\";\nimport * as Cookies from \"./Cookies.js\";\nimport * as Headers from \"./Headers.js\";\nimport * as Error from \"./HttpClientError.js\";\nimport * as HttpClientRequest from \"./HttpClientRequest.js\";\nimport * as HttpIncomingMessage from \"./HttpIncomingMessage.js\";\nimport * as UrlParams from \"./UrlParams.js\";\nexport {\n/**\n * Creates a decoder that reads a response JSON body and decodes it with the supplied schema.\n *\n * @category schemas\n * @since 4.0.0\n */\nschemaBodyJson,\n/**\n * Creates a decoder that reads response URL-encoded body parameters and decodes them with the supplied schema.\n *\n * @category schemas\n * @since 4.0.0\n */\nschemaBodyUrlParams,\n/**\n * Creates a decoder that validates and decodes response headers with the supplied schema.\n *\n * @category schemas\n * @since 4.0.0\n */\nschemaHeaders } from \"./HttpIncomingMessage.js\";\n/**\n * Type identifier for `HttpClientResponse` values.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = \"~effect/http/HttpClientResponse\";\n/**\n * Wraps a Web `Response` and its original `HttpClientRequest` as an `HttpClientResponse`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromWeb = (request, source) => new WebHttpClientResponse(request, source);\n/**\n * Creates a decoder for a response's status, headers, and JSON body using the supplied schema.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaJson = (schema, options) => {\n const decode = Schema.decodeEffect(Schema.toCodecJson(schema), options);\n const decodeBody = HttpIncomingMessage.schemaBodyJson(Schema.Unknown, options);\n return self => Effect.flatMap(decodeBody(self), body => decode({\n status: self.status,\n headers: self.headers,\n body: body\n }));\n};\n/**\n * Creates a decoder for a response's status and headers without reading a response body.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaNoBody = (schema, options) => {\n const decode = Schema.decodeEffect(schema, options);\n return self => decode({\n status: self.status,\n headers: self.headers\n });\n};\n/**\n * Converts an effect producing an `HttpClientResponse` into a stream of response body bytes.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const stream = effect => Stream.unwrap(Effect.map(effect, self => self.stream));\n/**\n * Pattern matches on a response status, checking exact status handlers before status-class handlers and `orElse`.\n *\n * @category pattern matching\n * @since 4.0.0\n */\nexport const matchStatus = /*#__PURE__*/dual(2, (self, cases) => {\n const status = self.status;\n if (cases[status]) {\n return cases[status](self);\n } else if (status >= 200 && status < 300 && cases[\"2xx\"]) {\n return cases[\"2xx\"](self);\n } else if (status >= 300 && status < 400 && cases[\"3xx\"]) {\n return cases[\"3xx\"](self);\n } else if (status >= 400 && status < 500 && cases[\"4xx\"]) {\n return cases[\"4xx\"](self);\n } else if (status >= 500 && status < 600 && cases[\"5xx\"]) {\n return cases[\"5xx\"](self);\n }\n return cases.orElse(self);\n});\n/**\n * Succeeds with the response when its status satisfies the predicate, otherwise fails with `HttpClientError`.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterStatus = /*#__PURE__*/dual(2, (self, f) => Effect.suspend(() => f(self.status) ? Effect.succeed(self) : Effect.fail(new Error.HttpClientError({\n reason: new Error.StatusCodeError({\n response: self,\n request: self.request,\n description: \"invalid status code\"\n })\n}))));\n/**\n * Succeeds with the response only when its status is in the 2xx range, otherwise fails with `HttpClientError`.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterStatusOk = self => self.status >= 200 && self.status < 300 ? Effect.succeed(self) : Effect.fail(new Error.HttpClientError({\n reason: new Error.StatusCodeError({\n response: self,\n request: self.request,\n description: \"non 2xx status code\"\n })\n}));\n// -----------------------------------------------------------------------------\n// internal\n// -----------------------------------------------------------------------------\nclass WebHttpClientResponse extends Inspectable.Class {\n [HttpIncomingMessage.TypeId];\n [TypeId];\n request;\n source;\n constructor(request, source) {\n super();\n this.request = request;\n this.source = source;\n this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId;\n this[TypeId] = TypeId;\n }\n toJSON() {\n return HttpIncomingMessage.inspect(this, {\n _id: \"HttpClientResponse\",\n request: this.request.toJSON(),\n status: this.status\n });\n }\n get status() {\n return this.source.status;\n }\n get url() {\n if (this.source.url) return this.source.url.split(\"#\")[0];\n const url = HttpClientRequest.toUrl(this.request);\n if (Option.isNone(url)) return \"\";\n url.value.hash = \"\";\n return url.value.href;\n }\n get headers() {\n return Headers.fromInput(this.source.headers);\n }\n cachedCookies;\n get cookies() {\n if (this.cachedCookies) {\n return this.cachedCookies;\n }\n return this.cachedCookies = Cookies.fromSetCookie(this.source.headers.getSetCookie());\n }\n get remoteAddress() {\n return Option.none();\n }\n get stream() {\n return this.source.body ? Stream.fromReadableStream({\n evaluate: () => this.source.body,\n onError: cause => new Error.HttpClientError({\n reason: new Error.DecodeError({\n request: this.request,\n response: this,\n cause\n })\n })\n }) : Stream.fail(new Error.HttpClientError({\n reason: new Error.EmptyBodyError({\n request: this.request,\n response: this,\n description: \"can not create stream from empty body\"\n })\n }));\n }\n get json() {\n return Effect.flatMap(this.text, text => Effect.try({\n try: () => text === \"\" ? null : JSON.parse(text),\n catch: cause => new Error.HttpClientError({\n reason: new Error.DecodeError({\n request: this.request,\n response: this,\n cause\n })\n })\n }));\n }\n textBody;\n get text() {\n return this.textBody ??= Effect.map(this.arrayBuffer, _ => new TextDecoder().decode(_));\n }\n get urlParamsBody() {\n return Effect.flatMap(this.text, _ => Effect.try({\n try: () => UrlParams.fromInput(new URLSearchParams(_)),\n catch: cause => new Error.HttpClientError({\n reason: new Error.DecodeError({\n request: this.request,\n response: this,\n cause\n })\n })\n }));\n }\n formDataBody;\n get formData() {\n return this.formDataBody ??= Effect.tryPromise({\n try: () => this.source.formData(),\n catch: cause => new Error.HttpClientError({\n reason: new Error.DecodeError({\n request: this.request,\n response: this,\n cause\n })\n })\n }).pipe(Effect.cached, Effect.runSync);\n }\n arrayBufferBody;\n get arrayBuffer() {\n if (this.arrayBufferBody) {\n return this.arrayBufferBody;\n }\n this.arrayBufferBody = Effect.tryPromise({\n try: () => this.source.arrayBuffer(),\n catch: cause => new Error.HttpClientError({\n reason: new Error.DecodeError({\n request: this.request,\n response: this,\n cause\n })\n })\n }).pipe(Effect.cached, Effect.runSync);\n return this.arrayBufferBody;\n }\n pipe() {\n return pipeArguments(this, arguments);\n }\n}\n//# sourceMappingURL=HttpClientResponse.js.map","import * as Headers from \"../Headers.js\";\nconst Proto = /*#__PURE__*/Object.getPrototypeOf(Headers.empty);\n/** @internal */\nexport const emptyMutableUnsafe = () => Object.create(Proto);\n//# sourceMappingURL=headers.js.map","import * as Context from \"../../Context.js\";\nimport * as Effect from \"../../Effect.js\";\nimport * as ErrorReporter from \"../../ErrorReporter.js\";\nimport { constVoid, dual } from \"../../Function.js\";\nimport * as Inspectable from \"../../Inspectable.js\";\nimport { PipeInspectableProto } from \"../../internal/core.js\";\nimport * as Option from \"../../Option.js\";\nimport { pipeArguments } from \"../../Pipeable.js\";\nimport { hasProperty } from \"../../Predicate.js\";\nimport { redact } from \"../../Redactable.js\";\nimport * as Stream from \"../../Stream.js\";\nimport * as Cookies from \"./Cookies.js\";\nimport * as Headers from \"./Headers.js\";\nimport * as Body from \"./HttpBody.js\";\nimport * as HttpClientError from \"./HttpClientError.js\";\nimport * as HttpClientRequest from \"./HttpClientRequest.js\";\nimport * as HttpClientResponse from \"./HttpClientResponse.js\";\nimport * as HttpIncomingMessage from \"./HttpIncomingMessage.js\";\nimport * as headersInternal from \"./internal/headers.js\";\nimport * as bodyInternal from \"./internal/httpBody.js\";\nimport * as Template from \"./Template.js\";\nimport * as UrlParams from \"./UrlParams.js\";\nconst TypeId = \"~effect/http/HttpServerResponse\";\n/**\n * Returns `true` when the supplied value is an `HttpServerResponse`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpServerResponse = u => hasProperty(u, TypeId);\n/**\n * Creates an empty HTTP response.\n *\n * **Details**\n *\n * The default status is `204`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const empty = options => makeResponse({\n status: options?.status ?? 204,\n statusText: options?.statusText,\n headers: options?.headers ? Headers.fromInput(options.headers) : undefined,\n cookies: options?.cookies\n});\n/**\n * Creates a redirect response with a `Location` header.\n *\n * **Details**\n *\n * The default status is `302`; custom headers are merged with the generated\n * `Location` header.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const redirect = (location, options) => {\n const headers = Headers.fromRecordUnsafe({\n location: location.toString()\n });\n return makeResponse({\n status: options?.status ?? 302,\n statusText: options?.statusText,\n headers: options?.headers ? Headers.merge(headers, Headers.fromInput(options.headers)) : headers,\n cookies: options?.cookies ?? Cookies.empty\n });\n};\n/**\n * Creates an HTTP response whose body is a `Uint8Array`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const uint8Array = (body, options) => {\n const headers = options?.headers ? Headers.fromInput(options.headers) : Headers.empty;\n return makeResponse({\n status: options?.status ?? 200,\n statusText: options?.statusText,\n headers,\n cookies: options?.cookies ?? Cookies.empty,\n body: Body.uint8Array(body, getContentType(options, headers))\n });\n};\nconst getContentType = (options, headers) => {\n if (options?.contentType) {\n return options.contentType;\n } else if (options?.headers) {\n return headers[\"content-type\"];\n }\n};\n/**\n * Creates an HTTP response whose body is a string.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const text = (body, options) => {\n const headers = options?.headers ? Headers.fromInput(options.headers) : Headers.empty;\n return makeResponse({\n status: options?.status ?? 200,\n statusText: options?.statusText,\n headers,\n cookies: options?.cookies ?? Cookies.empty,\n body: Body.text(body, getContentType(options, headers))\n });\n};\n/**\n * Creates an HTML response with the `text/html` content type.\n *\n * **Details**\n *\n * Passing a string returns a response directly. Using it as a template tag returns\n * an effect so interpolated values can be rendered with their required services\n * and errors.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const html = (strings, ...args) => {\n if (typeof strings === \"string\") {\n return text(strings, {\n contentType: \"text/html\"\n });\n }\n return Effect.map(Template.make(strings, ...args), _ => text(_, {\n contentType: \"text/html\"\n }));\n};\n/**\n * Creates a streaming HTML response from a template.\n *\n * **Details**\n *\n * The template is encoded as a byte stream and can use streaming interpolated\n * values from the current context.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const htmlStream = (strings, ...args) => Effect.map(Effect.context(), context => stream(Stream.provideContext(Stream.encodeText(Template.stream(strings, ...args)), context), {\n contentType: \"text/html\"\n}));\n/**\n * Creates a JSON HTTP response.\n *\n * **Details**\n *\n * The body is serialized with `JSON.stringify`; serialization errors are captured\n * as `HttpBodyError` failures.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const json = (body, options) => {\n const headers = options?.headers ? Headers.fromInput(options.headers) : Headers.empty;\n return Effect.map(Body.json(body, getContentType(options, headers)), body => makeResponse({\n status: options?.status ?? 200,\n statusText: options?.statusText,\n headers,\n cookies: options?.cookies,\n body\n }));\n};\n/**\n * Creates a JSON response constructor backed by a schema encoder.\n *\n * **Details**\n *\n * The returned function encodes the value with the supplied schema before\n * serializing it as JSON, and can fail with `HttpBodyError` if schema encoding or\n * JSON serialization fails.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const schemaJson = (schema, options) => {\n const encode = Body.jsonSchema(schema, options);\n return (body, options) => {\n const headers = options?.headers ? Headers.fromInput(options.headers) : Headers.empty;\n return Effect.map(encode(body, getContentType(options, headers)), body => makeResponse({\n status: options?.status ?? 200,\n statusText: options?.statusText,\n headers,\n cookies: options?.cookies,\n body\n }));\n };\n};\n/**\n * Creates a JSON HTTP response synchronously.\n *\n * **When to use**\n *\n * Use when the response body is known to be JSON-serializable and you need a\n * synchronous `HttpServerResponse`.\n *\n * **Gotchas**\n *\n * Unlike `json`, serialization errors from `JSON.stringify` are not captured in\n * `Effect`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const jsonUnsafe = (body, options) => {\n const headers = options?.headers ? Headers.fromInput(options.headers) : Headers.empty;\n return makeResponse({\n status: options?.status ?? 200,\n statusText: options?.statusText,\n headers,\n cookies: options?.cookies,\n body: Body.jsonUnsafe(body, getContentType(options, headers))\n });\n};\n/**\n * Creates a response from URL parameters using the\n * `application/x-www-form-urlencoded` content type by default.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const urlParams = (body, options) => {\n const headers = options?.headers ? Headers.fromInput(options.headers) : Headers.empty;\n return makeResponse({\n status: options?.status ?? 200,\n statusText: options?.statusText,\n headers,\n cookies: options?.cookies,\n body: Body.text(UrlParams.toString(UrlParams.fromInput(body)), getContentType(options, headers) ?? \"application/x-www-form-urlencoded\")\n });\n};\n/**\n * Creates a response with a raw body value.\n *\n * **When to use**\n *\n * Use when you want to pass through a body value already understood by the\n * underlying runtime, such as a Web `Response`, `Blob`, or `ReadableStream`,\n * for later platform conversion.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const raw = (body, options) => makeResponse({\n status: options?.status ?? 200,\n statusText: options?.statusText,\n headers: options?.headers && Headers.fromInput(options.headers),\n cookies: options?.cookies,\n body: Body.raw(body, {\n contentType: options?.contentType,\n contentLength: options?.contentLength\n })\n});\n/**\n * Creates a response whose body is a Web `FormData` value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const formData = (body, options) => makeResponse({\n status: options?.status ?? 200,\n statusText: options?.statusText,\n headers: options?.headers && Headers.fromInput(options.headers),\n cookies: options?.cookies,\n body: Body.formData(body)\n});\n/**\n * Creates a streaming response from a stream of byte chunks.\n *\n * **Details**\n *\n * Optional response metadata can supply the status, headers, content type, and\n * content length.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const stream = (body, options) => {\n const headers = options?.headers ? Headers.fromInput(options.headers) : Headers.empty;\n return makeResponse({\n status: options?.status ?? 200,\n statusText: options?.statusText,\n headers,\n cookies: options?.cookies,\n body: Body.stream(body, getContentType(options, headers), options?.contentLength)\n });\n};\nconst HttpPlatformKey = /*#__PURE__*/Context.Service(\"effect/http/HttpPlatform\");\n/**\n * Creates a streamed file response for a file system path.\n *\n * **Details**\n *\n * The effect requires `HttpPlatform`, can fail with a platform error, and supports\n * options for status, headers, offset, and byte range.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const file = (path, options) => Effect.flatMap(HttpPlatformKey, platform => platform.fileResponse(path, options));\n/**\n * Creates a streamed file response for a Web `File`-like value.\n *\n * **Details**\n *\n * The effect requires `HttpPlatform` and supports options for status, headers,\n * offset, and byte range.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fileWeb = (file, options) => Effect.flatMap(HttpPlatformKey, platform => platform.fileWebResponse(file, options));\n/**\n * Returns a response with the specified header set to the supplied value.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setHeader = /*#__PURE__*/dual(3, (self, key, value) => makeResponse(self, Headers.set(self.headers, key, value)));\n/**\n * Returns a response with the specified header removed.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const removeHeader = /*#__PURE__*/dual(2, (self, key) => makeResponse({\n ...self,\n headers: Headers.remove(self.headers, key)\n}));\n/**\n * Returns a response with all supplied headers set on the existing header map.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setHeaders = /*#__PURE__*/dual(2, (self, input) => makeResponse(self, Headers.setAll(self.headers, input)));\n/**\n * Returns a response with the cookie of the specified name removed.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const removeCookie = /*#__PURE__*/dual(2, (self, name) => makeResponse({\n ...self,\n cookies: Cookies.remove(self.cookies, name)\n}));\n/**\n * Returns a response with its cookie collection replaced by the supplied cookies.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const replaceCookies = /*#__PURE__*/dual(2, (self, cookies) => makeResponse({\n ...self,\n cookies\n}));\n/**\n * Sets a cookie on the response.\n *\n * **Details**\n *\n * The effect fails with `CookiesError` if the cookie name, value, or options are\n * invalid.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setCookie = /*#__PURE__*/dual(args => isHttpServerResponse(args[0]), (self, name, value, options) => Effect.map(Effect.fromResult(Cookies.set(self.cookies, name, value, options)), cookies => makeResponse({\n ...self,\n cookies\n})));\n/**\n * Sets an expired cookie on an `HttpServerResponse`.\n *\n * **Details**\n *\n * Returns an effect because cookie encoding can fail. The original response is not\n * mutated; the effect succeeds with a response containing the updated cookie set.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const expireCookie = /*#__PURE__*/dual(args => isHttpServerResponse(args[0]), (self, name, options) => Effect.map(Effect.fromResult(Cookies.expireCookie(self.cookies, name, options)), cookies => makeResponse({\n ...self,\n cookies\n})));\n/**\n * Sets a cookie on an `HttpServerResponse`, throwing if the cookie cannot be\n * encoded.\n *\n * **When to use**\n *\n * Use when you need to set one trusted cookie and want encoding failures to\n * throw instead of being represented as `CookiesError` failures.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setCookieUnsafe = /*#__PURE__*/dual(args => isHttpServerResponse(args[0]), (self, name, value, options) => makeResponse({\n ...self,\n cookies: Cookies.setUnsafe(self.cookies, name, value, options)\n}));\n/**\n * Sets an expired cookie on an `HttpServerResponse`, throwing if the expiration cookie\n * cannot be encoded.\n *\n * **When to use**\n *\n * Use when you need to expire one trusted cookie and want encoding failures to\n * throw instead of being represented as `CookiesError` failures.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const expireCookieUnsafe = /*#__PURE__*/dual(args => isHttpServerResponse(args[0]), (self, name, options) => makeResponse({\n ...self,\n cookies: Cookies.expireCookieUnsafe(self.cookies, name, options)\n}));\n/**\n * Updates the cookies attached to an `HttpServerResponse` using the supplied\n * function.\n *\n * **Details**\n *\n * The original response is not mutated; a new response is returned with the\n * callback result as its cookie collection.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const updateCookies = /*#__PURE__*/dual(2, (self, f) => makeResponse({\n ...self,\n cookies: f(self.cookies)\n}));\n/**\n * Merges additional cookies into the cookies attached to an\n * `HttpServerResponse`.\n *\n * **Details**\n *\n * The original response is not mutated; a new response is returned with the merged\n * cookie collection.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const mergeCookies = /*#__PURE__*/dual(2, (self, cookies) => makeResponse({\n ...self,\n cookies: Cookies.merge(self.cookies, cookies)\n}));\n/**\n * Sets multiple cookies on an `HttpServerResponse`.\n *\n * **Details**\n *\n * Each input entry contains a cookie name, value, and optional cookie options. The\n * returned effect fails with `CookiesError` if any cookie cannot be encoded.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setCookies = /*#__PURE__*/dual(2, (self, cookies) => Effect.map(Effect.fromResult(Cookies.setAll(self.cookies, cookies)), cookies => makeResponse({\n ...self,\n cookies\n})));\n/**\n * Sets multiple cookies on an `HttpServerResponse`, throwing if any cookie cannot\n * be encoded.\n *\n * **When to use**\n *\n * Use when you need to set multiple trusted cookies and want encoding failures\n * to throw instead of being represented as `CookiesError` failures.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setCookiesUnsafe = /*#__PURE__*/dual(2, (self, cookies) => makeResponse({\n ...self,\n cookies: Cookies.setAllUnsafe(self.cookies, cookies)\n}));\n/**\n * Replaces the body of an `HttpServerResponse`.\n *\n * **Details**\n *\n * When the body carries a content type or content length, the returned response\n * includes the corresponding headers.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setBody = /*#__PURE__*/dual(2, (self, body) => makeResponse({\n ...self,\n body\n}, bodyInternal.updateHeaders(self.headers, body)));\n/**\n * Sets the HTTP status code of an `HttpServerResponse`.\n *\n * **Details**\n *\n * When `statusText` is omitted, the existing status text is preserved.\n *\n * @category combinators\n * @since 4.0.0\n */\nexport const setStatus = /*#__PURE__*/dual(args => isHttpServerResponse(args[0]), (self, status, statusText) => makeResponse({\n ...self,\n status,\n statusText: statusText ?? self.statusText\n}));\n/**\n * Returns whether a response must omit its body because its status is 204, 205,\n * or 304, or `withoutBody` is true.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const omitsBody = (response, withoutBody = false) => withoutBody || response.status === 204 || response.status === 205 || response.status === 304;\n/**\n * Converts an `HttpServerResponse` to a Web `Response`.\n *\n * **Details**\n *\n * Cookies are appended as `Set-Cookie` headers. Stream bodies are converted using\n * the supplied context.\n *\n * Bodies are omitted for statuses 204, 205, and 304, or when `withoutBody` is true\n * (for example, for HEAD responses). Omitted raw `ReadableStream` bodies are\n * cancelled without awaiting completion, and cancellation errors are ignored.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toWeb = (response, options) => {\n const headers = new globalThis.Headers(response.headers);\n if (!Cookies.isEmpty(response.cookies)) {\n const toAdd = Cookies.toSetCookieHeaders(response.cookies);\n for (const header of toAdd) {\n headers.append(\"set-cookie\", header);\n }\n }\n const body = response.body;\n if (omitsBody(response, options?.withoutBody)) {\n if (body._tag === \"Raw\" && isReadableStream(body.body)) {\n body.body.cancel().catch(constVoid);\n }\n return new Response(undefined, {\n status: response.status,\n statusText: response.statusText,\n headers\n });\n }\n switch (body._tag) {\n case \"Empty\":\n {\n return new Response(undefined, {\n status: response.status,\n statusText: response.statusText,\n headers\n });\n }\n case \"Uint8Array\":\n {\n return new Response(body.text ?? body.body, {\n status: response.status,\n statusText: response.statusText,\n headers\n });\n }\n case \"Raw\":\n {\n if (body.body instanceof Response) {\n for (const [key, value] of headers) {\n body.body.headers.set(key, value);\n }\n return body.body;\n }\n return new Response(body.body, {\n status: response.status,\n statusText: response.statusText,\n headers\n });\n }\n case \"FormData\":\n {\n return new Response(body.formData, {\n status: response.status,\n statusText: response.statusText,\n headers\n });\n }\n case \"Stream\":\n {\n return new Response(Stream.toReadableStreamWith(body.stream, options?.context ?? Context.empty()), {\n status: response.status,\n statusText: response.statusText,\n headers\n });\n }\n }\n};\n/**\n * Wraps an `HttpServerResponse` as an `HttpClientResponse`, using the optional\n * request for metadata and decode errors. Without a request, `url` is empty.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toClientResponse = (response, options) => new ServerHttpClientResponse(options?.request ?? HttpClientRequest.empty, response);\nclass ServerHttpClientResponse extends Inspectable.Class {\n [HttpIncomingMessage.TypeId];\n [HttpClientResponse.TypeId];\n request;\n response;\n constructor(request, response) {\n super();\n this.request = request;\n this.response = response;\n this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId;\n this[HttpClientResponse.TypeId] = HttpClientResponse.TypeId;\n }\n toJSON() {\n return HttpIncomingMessage.inspect(this, {\n _id: \"HttpClientResponse\",\n request: this.request.toJSON(),\n status: this.status\n });\n }\n get status() {\n return this.response.status;\n }\n get url() {\n if (this.request === HttpClientRequest.empty) return \"\";\n const url = HttpClientRequest.toUrl(this.request);\n if (Option.isNone(url)) return \"\";\n url.value.hash = \"\";\n return url.value.href;\n }\n cachedHeaders;\n get headers() {\n return this.cachedHeaders ??= this.response.body._tag === \"FormData\" ? Headers.merge(this.response.headers, Headers.fromInput(this.getFormDataResponse().headers)) : this.response.headers;\n }\n get cookies() {\n return this.response.cookies;\n }\n get remoteAddress() {\n return Option.none();\n }\n get stream() {\n const body = this.response.body;\n switch (body._tag) {\n case \"Empty\":\n {\n return Stream.empty;\n }\n case \"Stream\":\n {\n return Stream.mapError(body.stream, cause => this.decodeError(cause));\n }\n case \"Uint8Array\":\n {\n return Stream.succeed(body.body);\n }\n case \"Raw\":\n {\n const rawBody = body.body;\n if (rawBody instanceof Response) {\n return rawBody.body ? Stream.fromReadableStream({\n evaluate: () => rawBody.body,\n onError: cause => this.decodeError(cause)\n }) : Stream.empty;\n }\n if (isReadableStream(rawBody)) {\n return Stream.fromReadableStream({\n evaluate: () => rawBody,\n onError: cause => this.decodeError(cause)\n });\n }\n if (rawBody instanceof Blob) {\n return Stream.fromReadableStream({\n evaluate: () => rawBody.stream(),\n onError: cause => this.decodeError(cause)\n });\n }\n return Stream.unwrap(Effect.map(this.bytes, Stream.succeed));\n }\n case \"FormData\":\n {\n const response = this.getFormDataResponse();\n return Stream.fromReadableStream({\n evaluate: () => response.body,\n onError: cause => this.decodeError(cause)\n });\n }\n }\n }\n get json() {\n return Effect.flatMap(this.text, text => Effect.try({\n try: () => text === \"\" ? null : JSON.parse(text),\n catch: cause => new HttpClientError.HttpClientError({\n reason: new HttpClientError.DecodeError({\n request: this.request,\n response: this,\n cause\n })\n })\n }));\n }\n get bytes() {\n const body = this.response.body;\n switch (body._tag) {\n case \"Empty\":\n {\n return Effect.succeed(new Uint8Array(0));\n }\n case \"Uint8Array\":\n {\n return Effect.succeed(body.body);\n }\n case \"Stream\":\n {\n return Stream.mkUint8Array(this.stream);\n }\n case \"Raw\":\n {\n const rawBody = body.body;\n if (rawBody instanceof Response) {\n return Effect.tryPromise({\n try: () => rawBody.arrayBuffer().then(buffer => new Uint8Array(buffer)),\n catch: cause => this.decodeError(cause)\n });\n }\n return Effect.tryPromise({\n try: () => new Response(rawBody).arrayBuffer().then(buffer => new Uint8Array(buffer)),\n catch: cause => this.decodeError(cause)\n });\n }\n case \"FormData\":\n {\n return Effect.tryPromise({\n try: () => new Response(body.formData).arrayBuffer().then(buffer => new Uint8Array(buffer)),\n catch: cause => this.decodeError(cause)\n });\n }\n }\n }\n get text() {\n return Effect.map(this.bytes, bytes => textDecoder.decode(bytes));\n }\n get urlParamsBody() {\n return Effect.flatMap(this.text, _ => Effect.try({\n try: () => UrlParams.fromInput(new URLSearchParams(_)),\n catch: cause => new HttpClientError.HttpClientError({\n reason: new HttpClientError.DecodeError({\n request: this.request,\n response: this,\n cause\n })\n })\n }));\n }\n get formData() {\n const body = this.response.body;\n if (body._tag === \"FormData\") {\n return Effect.succeed(body.formData);\n }\n return Effect.contextWith(context => {\n const readableStream = Stream.toReadableStreamWith(this.stream, context);\n return Effect.tryPromise({\n try: () => new Response(readableStream, {\n headers: this.headers\n }).formData(),\n catch: cause => this.decodeError(cause)\n });\n });\n }\n get arrayBuffer() {\n return Effect.map(this.bytes,\n // Copy this view because Buffer views may share a larger ArrayBuffer.\n bytes => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));\n }\n decodeError(cause) {\n return new HttpClientError.HttpClientError({\n reason: new HttpClientError.DecodeError({\n request: this.request,\n response: this,\n cause\n })\n });\n }\n formDataResponse;\n getFormDataResponse() {\n return this.formDataResponse ??= new Response(this.response.body.formData);\n }\n pipe() {\n return pipeArguments(this, arguments);\n }\n}\nconst textDecoder = /*#__PURE__*/new TextDecoder();\n/**\n * Converts an `HttpClientResponse` to an `HttpServerResponse`.\n *\n * **Details**\n *\n * The response body is streamed from the client response. `Set-Cookie` headers are\n * removed from the header map and represented in the response cookie collection.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromClientResponse = response => {\n const headers = Headers.remove(response.headers, \"set-cookie\");\n return makeResponse({\n status: response.status,\n headers,\n cookies: response.cookies,\n body: Body.stream(Stream.catchIf(response.stream, isEmptyBodyError, () => Stream.empty), Option.getOrUndefined(Headers.get(headers, \"content-type\")), bodyInternal.parseContentLength(headers[\"content-length\"]))\n });\n};\nconst isReadableStream = u => typeof ReadableStream !== \"undefined\" && u instanceof ReadableStream;\nconst isEmptyBodyError = error => HttpClientError.isHttpClientError(error) && error.reason._tag === \"EmptyBodyError\";\nconst Proto = {\n ...PipeInspectableProto,\n [TypeId]: TypeId,\n [ErrorReporter.ignore]: true,\n toJSON() {\n return {\n _id: \"HttpServerResponse\",\n status: this.status,\n statusText: this.statusText,\n headers: redact(this.headers),\n cookies: this.cookies.toJSON(),\n body: this.body.toJSON()\n };\n }\n};\nconst makeResponse = (options, ownedHeaders) => {\n // ownedHeaders is a freshly created map that nothing else references, so it\n // can be completed in place instead of copied. It supersedes options.headers,\n // and explicit content headers in it take precedence over body-derived ones.\n const self = Object.create(Proto);\n self.status = options.status;\n self.statusText = options.statusText;\n self.cookies = options.cookies ?? Cookies.empty;\n self.body = options.body ?? Body.empty;\n if (self.body._tag !== \"Empty\" && (self.body.contentType || self.body.contentLength !== undefined)) {\n const owned = ownedHeaders !== undefined;\n const newHeaders = owned ? ownedHeaders : options.headers === undefined || options.headers === Headers.empty ? headersInternal.emptyMutableUnsafe() : Headers.fromRecordUnsafe({\n ...options.headers\n });\n if (self.body.contentType && (!owned || newHeaders[\"content-type\"] === undefined)) {\n newHeaders[\"content-type\"] = self.body.contentType;\n }\n if (self.body.contentLength !== undefined && (!owned || newHeaders[\"content-length\"] === undefined)) {\n newHeaders[\"content-length\"] = self.body.contentLength.toString();\n }\n self.headers = newHeaders;\n } else {\n self.headers = ownedHeaders ?? options.headers ?? Headers.empty;\n }\n return self;\n};\n/**\n * Converts a Web `Response` to an `HttpServerResponse`.\n *\n * **Details**\n *\n * `Set-Cookie` headers are parsed into the response cookie collection and removed\n * from the header map. A present Web body is exposed as a stream body.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromWeb = response => {\n const headers = new globalThis.Headers(response.headers);\n const setCookieHeaders = headers.getSetCookie();\n headers.delete(\"set-cookie\");\n let self = empty({\n status: response.status,\n statusText: response.statusText,\n headers: headers,\n cookies: Cookies.fromSetCookie(setCookieHeaders)\n });\n if (response.body) {\n const contentType = response.headers.get(\"content-type\");\n self = setBody(self, Body.stream(Stream.fromReadableStream({\n evaluate: () => response.body,\n onError: e => e\n }), contentType ?? undefined, bodyInternal.parseContentLength(response.headers.get(\"content-length\"))));\n }\n return self;\n};\n//# sourceMappingURL=HttpServerResponse.js.map","/**\n * Converts supported values into HTTP server responses.\n *\n * Server-side errors and helper values can implement `Respondable` when they\n * know which status, headers, cookies, or body should be sent to the client.\n * This module detects those values and converts them to `HttpServerResponse`\n * values, with fallback handling for schema errors and missing values.\n *\n * @since 4.0.0\n */\nimport * as Cause from \"../../Cause.js\";\nimport * as Effect from \"../../Effect.js\";\nimport * as Schema from \"../../internal/schemaError.js\";\nimport { hasProperty } from \"../../Predicate.js\";\nimport * as Response from \"./HttpServerResponse.js\";\n/**\n * Protocol key used by values that can render themselves as\n * `HttpServerResponse` values.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const symbol = \"~effect/http/HttpServerRespondable\";\n/**\n * Returns `true` when the supplied value implements the `Respondable` protocol.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isRespondable = u => hasProperty(u, symbol);\nconst badRequest = /*#__PURE__*/Response.empty({\n status: 400\n});\nconst notFound = /*#__PURE__*/Response.empty({\n status: 404\n});\n/**\n * Converts a `Respondable` value into an `HttpServerResponse`.\n *\n * **Details**\n *\n * If the value is already an HTTP server response it is returned directly; errors\n * from the response conversion are converted to defects.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const toResponse = self => {\n if (Response.isHttpServerResponse(self)) {\n return Effect.succeed(self);\n }\n return Effect.orDie(self[symbol]());\n};\n/**\n * Attempts to convert an unknown value into an `HttpServerResponse`, falling back\n * to the supplied response when no conversion is available.\n *\n * **Details**\n *\n * `HttpServerResponse` and `Respondable` values are used directly, schema errors\n * become `400` responses, and no-such-element errors become `404` responses.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const toResponseOrElse = (u, orElse) => {\n if (Response.isHttpServerResponse(u)) {\n return Effect.succeed(u);\n } else if (isRespondable(u)) {\n return Effect.catchCause(u[symbol](), () => Effect.succeed(orElse));\n // add support for some commmon types\n } else if (Schema.isSchemaError(u)) {\n return Effect.succeed(badRequest);\n } else if (Cause.isNoSuchElementError(u)) {\n return Effect.succeed(notFound);\n }\n return Effect.succeed(orElse);\n};\n/**\n * Attempts to convert an unknown defect into an `HttpServerResponse`, falling\n * back to the supplied response when no conversion is available.\n *\n * **Details**\n *\n * Only `HttpServerResponse` and `Respondable` values receive special handling.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const toResponseOrElseDefect = (u, orElse) => {\n if (Response.isHttpServerResponse(u)) {\n return Effect.succeed(u);\n } else if (isRespondable(u)) {\n return Effect.catchCause(u[symbol](), () => Effect.succeed(orElse));\n }\n return Effect.succeed(orElse);\n};\n//# sourceMappingURL=HttpServerRespondable.js.map","/**\n * Describes failures raised while handling HTTP server requests.\n *\n * `HttpServerError` covers failures that happen while accepting a request,\n * matching a route, running a handler, or building and sending a response.\n * Request-scoped failures keep the request that caused them, and response\n * failures keep the response being produced. This module also includes helpers\n * for turning failed causes or exits into HTTP responses and an annotation for\n * interrupts caused by client aborts.\n *\n * @since 4.0.0\n */\nimport * as Cause from \"../../Cause.js\";\nimport * as Context from \"../../Context.js\";\nimport * as Data from \"../../Data.js\";\nimport * as Effect from \"../../Effect.js\";\nimport * as ErrorReporter from \"../../ErrorReporter.js\";\nimport { constUndefined } from \"../../Function.js\";\nimport * as Option from \"../../Option.js\";\nimport { hasProperty } from \"../../Predicate.js\";\nimport * as Respondable from \"./HttpServerRespondable.js\";\nimport * as Response from \"./HttpServerResponse.js\";\nconst TypeId = \"~effect/http/HttpServerError\";\n/**\n * Tagged error for failures that occur while handling an HTTP server request.\n *\n * **Details**\n *\n * It wraps a `HttpServerErrorReason`, exposes the associated request and optional\n * response, and can be converted to an HTTP response through the `Respondable`\n * protocol.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class HttpServerError extends /*#__PURE__*/Data.TaggedError(\"HttpServerError\") {\n constructor(props) {\n if (\"cause\" in props.reason) {\n super({\n ...props,\n cause: props.reason.cause\n });\n } else {\n super(props);\n }\n }\n [TypeId] = TypeId;\n stack = `${this.name}: ${this.message}`;\n get request() {\n return this.reason.request;\n }\n get response() {\n return \"response\" in this.reason ? this.reason.response : undefined;\n }\n [Respondable.symbol]() {\n return this.reason[Respondable.symbol]();\n }\n get [ErrorReporter.ignore]() {\n return this.reason[ErrorReporter.ignore] ?? false;\n }\n get message() {\n return this.reason.message;\n }\n}\n/**\n * Error describing a failure to parse or read an incoming request.\n *\n * **Details**\n *\n * When converted to a response it produces an empty `400` response.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class RequestParseError extends /*#__PURE__*/Data.TaggedError(\"RequestParseError\") {\n /**\n * Converts the request error into a `400 Bad Request` response.\n *\n * @since 4.0.0\n */\n [Respondable.symbol]() {\n return Effect.succeed(Response.empty({\n status: 400\n }));\n }\n get methodAndUrl() {\n return `${this.request.method} ${this.request.url}`;\n }\n get message() {\n return formatRequestMessage(this._tag, this.description, this.methodAndUrl);\n }\n}\n/**\n * Error indicating that no route matched the incoming request.\n *\n * **Details**\n *\n * When converted to a response it produces an empty `404` response, and it is\n * ignored by the error reporter.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class RouteNotFound extends /*#__PURE__*/Data.TaggedError(\"RouteNotFound\") {\n [Respondable.symbol]() {\n return Effect.succeed(Response.empty({\n status: 404\n }));\n }\n [ErrorReporter.ignore] = true;\n get methodAndUrl() {\n return `${this.request.method} ${this.request.url}`;\n }\n get message() {\n return formatRequestMessage(this._tag, this.description, this.methodAndUrl);\n }\n}\n/**\n * Error describing an unexpected server-side failure while handling a request.\n *\n * **Details**\n *\n * When converted to a response it produces an empty `500` response.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class InternalError extends /*#__PURE__*/Data.TaggedError(\"InternalError\") {\n /**\n * Converts the server error into a `500 Internal Server Error` response.\n *\n * @since 4.0.0\n */\n [Respondable.symbol]() {\n return Effect.succeed(Response.empty({\n status: 500\n }));\n }\n get methodAndUrl() {\n return `${this.request.method} ${this.request.url}`;\n }\n get message() {\n return formatRequestMessage(this._tag, this.description, this.methodAndUrl);\n }\n}\n/**\n * Returns `true` when the supplied value is an `HttpServerError`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpServerError = u => hasProperty(u, TypeId);\n/**\n * Error describing a failure related to an HTTP response.\n *\n * **Details**\n *\n * It carries the request and response involved in the failure. When converted to\n * a response it produces an empty `500` response.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class ResponseError extends /*#__PURE__*/Data.TaggedError(\"ResponseError\") {\n [Respondable.symbol]() {\n return Effect.succeed(Response.empty({\n status: 500\n }));\n }\n get methodAndUrl() {\n return `${this.request.method} ${this.request.url}`;\n }\n get message() {\n const info = `${this._tag} (${this.response.status} ${this.methodAndUrl})`;\n return this.description ? `${info}: ${this.description}` : info;\n }\n}\n/**\n * Error wrapping a low-level failure from the HTTP server implementation.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class ServeError extends /*#__PURE__*/Data.TaggedError(\"ServeError\") {}\n/**\n * Context annotation used to mark an interrupt as caused by the client aborting\n * the request.\n *\n * **Details**\n *\n * `causeResponse` uses this annotation to map a pure client abort to a `499`\n * response instead of a server abort response.\n *\n * @category services\n * @since 4.0.0\n */\nexport class ClientAbort extends /*#__PURE__*/Context.Service()(\"effect/http/HttpServerError/ClientAbort\") {\n static annotation = /*#__PURE__*/this.context(true).pipe(/*#__PURE__*/Context.add(Cause.StackTrace, {\n name: \"ClientAbort\",\n stack: constUndefined,\n parent: undefined\n }));\n}\nconst formatRequestMessage = (reason, description, info) => {\n const prefix = `${reason} (${info})`;\n return description ? `${prefix}: ${description}` : prefix;\n};\n/**\n * Converts a failed handler cause into the HTTP response that should be sent and\n * the cause that should be reported.\n *\n * **Details**\n *\n * Respondable failures and defects can choose their own response, defects that\n * are already `HttpServerResponse` values are used directly, and pure interrupts\n * produce either `499` for client aborts or `503` for server aborts.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const causeResponse = cause => {\n let response;\n let effect = succeedInternalServerError;\n const failures = [];\n let interrupts = [];\n let isClientInterrupt = false;\n for (let i = 0; i < cause.reasons.length; i++) {\n const reason = cause.reasons[i];\n switch (reason._tag) {\n case \"Fail\":\n {\n effect = Respondable.toResponseOrElse(reason.error, internalServerError);\n failures.push(reason);\n break;\n }\n case \"Die\":\n {\n if (Response.isHttpServerResponse(reason.defect)) {\n response = reason.defect;\n } else {\n effect = Respondable.toResponseOrElseDefect(reason.defect, internalServerError);\n failures.push(reason);\n }\n break;\n }\n case \"Interrupt\":\n {\n isClientInterrupt = reason.annotations.has(ClientAbort.key);\n if (failures.length > 0) break;\n interrupts.push(reason);\n break;\n }\n }\n }\n if (response) {\n return Effect.succeed([response, Cause.fromReasons(failures)]);\n } else if (interrupts.length > 0 && failures.length === 0) {\n failures.push(...interrupts);\n effect = isClientInterrupt ? clientAbortError : serverAbortError;\n }\n return Effect.mapEager(effect, response => {\n failures.push(Cause.makeDieReason(response));\n return [response, Cause.fromReasons(failures)];\n });\n};\n/**\n * Derives an HTTP response from a failed handler cause synchronously.\n *\n * **Details**\n *\n * If the cause contains a defect that is already an `HttpServerResponse`, that\n * response is used and removed from the remaining cause. Otherwise the response\n * defaults to `500`.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const causeResponseStripped = cause => {\n let response;\n const failures = cause.reasons.filter(f => {\n if (f._tag === \"Die\" && Response.isHttpServerResponse(f.defect)) {\n response = f.defect;\n return false;\n }\n return true;\n });\n return [response ?? internalServerError, failures.length > 0 ? Option.some(Cause.fromReasons(failures)) : Option.none()];\n};\nconst internalServerError = /*#__PURE__*/Response.empty({\n status: 500\n});\nconst succeedInternalServerError = /*#__PURE__*/Effect.succeed(internalServerError);\nconst clientAbortError = /*#__PURE__*/Effect.succeed(/*#__PURE__*/Response.empty({\n status: 499\n}));\nconst serverAbortError = /*#__PURE__*/Effect.succeed(/*#__PURE__*/Response.empty({\n status: 503\n}));\n/**\n * Extracts the response from a successful handler exit, or derives a response\n * from the failure cause.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const exitResponse = exit => {\n if (exit._tag === \"Success\") {\n return exit.value;\n }\n return causeResponseStripped(exit.cause)[0];\n};\n//# sourceMappingURL=HttpServerError.js.map","// taken from https://github.com/fastify/fast-content-type-parse\n// under the MIT license\n/**\n * RegExp to match *( \";\" parameter ) in RFC 7231 sec 3.1.1.1\n *\n * parameter = token \"=\" ( token / quoted-string )\n * token = 1*tchar\n * tchar = \"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\"\n * / \"+\" / \"-\" / \".\" / \"^\" / \"_\" / \"`\" / \"|\" / \"~\"\n * / DIGIT / ALPHA\n * ; any VCHAR, except delimiters\n * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE\n * qdtext = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text\n * obs-text = %x80-FF\n * quoted-pair = \"\\\" ( HTAB / SP / VCHAR / obs-text )\n */\nconst paramRE = /; *([!#$%&'*+.^\\w`|~-]+)=(\"(?:[\\v\\u0020\\u0021\\u0023-\\u005b\\u005d-\\u007e\\u0080-\\u{10ffff}]|\\\\[\\v\\u0020-\\u{10ffff}])*\"|[!#$%&'*+.^\\w`|~-]+) */gu;\n/**\n * RegExp to match quoted-pair in RFC 7230 sec 3.2.6\n *\n * quoted-pair = \"\\\" ( HTAB / SP / VCHAR / obs-text )\n * obs-text = %x80-FF\n */\nconst quotedPairRE = /\\\\([\\v\\u0020-\\u{10ffff}])/gu;\n/**\n * RegExp to match type in RFC 7231 sec 3.1.1.1\n *\n * media-type = type \"/\" subtype\n * type = token\n * subtype = token\n */\nconst mediaTypeRE = /^[!#$%&'*+.^\\w|~-]+\\/[!#$%&'*+.^\\w|~-]+$/u;\nconst mediaTypeRENoSlash = /^[!#$%&'*+.^\\w|~-]+$/u;\n// default ContentType to prevent repeated object creation\nconst defaultContentType = {\n value: \"\",\n parameters: /*#__PURE__*/Object.create(null)\n};\nexport function parse(header, withoutSlash = false) {\n if (typeof header !== \"string\") {\n return defaultContentType;\n }\n let index = header.indexOf(\";\");\n const type = index !== -1 ? header.slice(0, index).trim() : header.trim();\n const mediaRE = withoutSlash ? mediaTypeRENoSlash : mediaTypeRE;\n if (mediaRE.test(type) === false) {\n return defaultContentType;\n }\n const result = {\n value: type.toLowerCase(),\n parameters: Object.create(null)\n };\n // parse parameters\n if (index === -1) {\n return result;\n }\n let key;\n let match;\n let value;\n paramRE.lastIndex = index;\n while (match = paramRE.exec(header)) {\n if (match.index !== index) {\n return defaultContentType;\n }\n index += match[0].length;\n key = match[1].toLowerCase();\n value = match[2];\n if (value[0] === \"\\\"\") {\n // remove quotes and escapes\n value = value.slice(1, value.length - 1);\n if (!withoutSlash && quotedPairRE.test(value)) {\n value = value.replace(quotedPairRE, \"$1\");\n }\n }\n result.parameters[key] = value;\n }\n if (index !== header.length) {\n return defaultContentType;\n }\n return result;\n}\n//# sourceMappingURL=contentType.js.map","const constMaxPairs = 100;\nconst constMaxSize = 16 * 1024;\nconst State = {\n key: 0,\n whitespace: 1,\n value: 2\n};\nconst constContinue = {\n _tag: \"Continue\"\n};\n// RFC 7230 token characters, allowed in header names\n// The previous table stopped at byte 126; zero-filled entries for bytes 127-255\n// preserve its rejection behavior because callers accept only entries equal to 1.\nconst constNameChars = /*#__PURE__*/new Uint8Array(256);\nfor (const char of \"!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\") {\n constNameChars[/*#__PURE__*/char.charCodeAt(0)] = 1;\n}\n// HTAB, visible ASCII and obs-text, allowed in header values\nconst constValueChars = /*#__PURE__*/new Uint8Array(256);\nconstValueChars[9] = 1;\nfor (let i = 32; i <= 126; i++) {\n constValueChars[i] = 1;\n}\nfor (let i = 128; i <= 255; i++) {\n constValueChars[i] = 1;\n}\nexport function make() {\n const decoder = new TextDecoder();\n const state = {\n state: State.key,\n headers: Object.create(null),\n key: \"\",\n value: undefined,\n crlf: 0,\n previousChunk: undefined,\n pairs: 0,\n size: 0\n };\n function reset(value) {\n state.state = State.key;\n state.headers = Object.create(null);\n state.key = \"\";\n state.value = undefined;\n state.crlf = 0;\n state.previousChunk = undefined;\n state.pairs = 0;\n state.size = 0;\n return value;\n }\n function concatUint8Array(a, b) {\n const newUint8Array = new Uint8Array(a.length + b.length);\n newUint8Array.set(a);\n newUint8Array.set(b, a.length);\n return newUint8Array;\n }\n function error(reason) {\n return reset({\n _tag: \"Failure\",\n reason,\n headers: state.headers\n });\n }\n return function write(chunk, start) {\n let endOffset = 0;\n let previousCursor;\n if (state.previousChunk !== undefined) {\n endOffset = state.previousChunk.length;\n previousCursor = endOffset;\n const newChunk = new Uint8Array(chunk.length + endOffset);\n newChunk.set(state.previousChunk);\n newChunk.set(chunk, endOffset);\n state.previousChunk = undefined;\n chunk = newChunk;\n }\n const end = chunk.length;\n outer: while (start < end) {\n if (state.state === State.key) {\n let i = start;\n for (; i < end; i++) {\n if (state.size++ > constMaxSize) {\n return error(\"HeaderTooLarge\");\n }\n if (chunk[i] === 58) {\n state.key += decoder.decode(chunk.subarray(start, i)).toLowerCase();\n if (state.key.length === 0) {\n return error(\"InvalidHeaderName\");\n }\n if (chunk[i + 1] === 32 && chunk[i + 2] !== 32 && chunk[i + 2] !== 9) {\n start = i + 2;\n state.state = State.value;\n state.size++;\n } else if (chunk[i + 1] !== 32 && chunk[i + 1] !== 9) {\n start = i + 1;\n state.state = State.value;\n } else {\n start = i + 1;\n state.state = State.whitespace;\n }\n break;\n } else if (constNameChars[chunk[i]] !== 1) {\n return error(\"InvalidHeaderName\");\n }\n }\n if (i === end) {\n state.key += decoder.decode(chunk.subarray(start, end)).toLowerCase();\n return constContinue;\n }\n }\n if (state.state === State.whitespace) {\n for (; start < end; start++) {\n if (state.size++ > constMaxSize) {\n return error(\"HeaderTooLarge\");\n }\n if (chunk[start] !== 32 && chunk[start] !== 9) {\n state.state = State.value;\n break;\n }\n }\n if (start === end) {\n return constContinue;\n }\n }\n if (state.state === State.value) {\n let i = start;\n if (previousCursor !== undefined) {\n i = previousCursor;\n previousCursor = undefined;\n }\n for (; i < end; i++) {\n if (state.size++ > constMaxSize) {\n return error(\"HeaderTooLarge\");\n }\n if (chunk[i] === 13 || state.crlf > 0) {\n let byte = chunk[i];\n if (byte === 13 && state.crlf === 0) {\n state.crlf = 1;\n i++;\n state.size++;\n byte = chunk[i];\n }\n if (byte === 10 && state.crlf === 1) {\n state.crlf = 2;\n i++;\n state.size++;\n byte = chunk[i];\n }\n if (byte === 13 && state.crlf === 2) {\n state.crlf = 3;\n i++;\n state.size++;\n byte = chunk[i];\n }\n if (byte === 10 && state.crlf === 3) {\n state.crlf = 4;\n i++;\n state.size++;\n }\n if (state.crlf < 4 && i >= end) {\n state.previousChunk = chunk.subarray(start);\n return constContinue;\n } else if (state.crlf >= 2) {\n state.value = state.value === undefined ? chunk.subarray(start, i - state.crlf) : concatUint8Array(state.value, chunk.subarray(start, i - state.crlf));\n const value = decoder.decode(state.value);\n if (state.headers[state.key] === undefined) {\n state.headers[state.key] = value;\n } else if (typeof state.headers[state.key] === \"string\") {\n state.headers[state.key] = [state.headers[state.key], value];\n } else {\n ;\n state.headers[state.key].push(value);\n }\n start = i;\n state.size--;\n if (state.crlf !== 4 && state.pairs === constMaxPairs) {\n return error(\"TooManyHeaders\");\n } else if (state.crlf === 3) {\n return error(\"InvalidHeaderValue\");\n } else if (state.crlf === 4) {\n return reset({\n _tag: \"Headers\",\n headers: state.headers,\n endPosition: start - endOffset\n });\n }\n state.pairs++;\n state.key = \"\";\n state.value = undefined;\n state.crlf = 0;\n state.state = State.key;\n continue outer;\n }\n } else if (constValueChars[chunk[i]] !== 1) {\n return error(\"InvalidHeaderValue\");\n }\n }\n if (i === end) {\n state.value = state.value === undefined ? chunk.subarray(start, end) : concatUint8Array(state.value, chunk.subarray(start, end));\n return constContinue;\n }\n }\n }\n if (start > end) {\n state.size += end - start;\n }\n return constContinue;\n };\n}\n//# sourceMappingURL=headers.js.map","function makeState(needle_) {\n const needle = new TextEncoder().encode(needle_);\n const needleLength = needle.length;\n const indexes = {};\n for (let i = 0; i < needleLength; i++) {\n const b = needle[i];\n if (indexes[b] === undefined) indexes[b] = [];\n indexes[b].push(i);\n }\n return {\n needle,\n needleLength,\n indexes,\n firstByte: needle[0],\n previousChunk: undefined,\n previousChunkLength: 0,\n matchIndex: 0\n };\n}\nexport function make(needle, callback, seed, minimumChunkLength) {\n const state = makeState(needle);\n const minChunkLength = minimumChunkLength ?? state.needleLength;\n if (seed !== undefined) {\n state.previousChunk = seed;\n state.previousChunkLength = seed.length;\n }\n function makeIndexOf() {\n // on node.js use the Buffer api\n if (\"Buffer\" in globalThis && !(\"Bun\" in globalThis || \"Deno\" in globalThis)) {\n return function (chunk, needle, fromIndex) {\n return Buffer.prototype.indexOf.call(chunk, needle, fromIndex);\n };\n }\n const skipTable = new Uint8Array(256).fill(state.needle.length);\n for (let i = 0, lastIndex = state.needle.length - 1; i < lastIndex; ++i) {\n skipTable[state.needle[i]] = lastIndex - i;\n }\n return function (chunk, needle, fromIndex) {\n const lengthTotal = chunk.length;\n let i = fromIndex + state.needleLength - 1;\n while (i < lengthTotal) {\n for (let j = state.needleLength - 1, k = i; j >= 0 && chunk[k] === needle[j]; j--, k--) {\n if (j === 0) return k;\n }\n i += skipTable[chunk[i]];\n }\n return -1;\n };\n }\n const indexOf = makeIndexOf();\n function write(chunk) {\n let chunkLength = chunk.length;\n if (state.previousChunk !== undefined) {\n const newChunk = new Uint8Array(state.previousChunkLength + chunkLength);\n newChunk.set(state.previousChunk);\n newChunk.set(chunk, state.previousChunkLength);\n chunk = newChunk;\n chunkLength = state.previousChunkLength + chunkLength;\n state.previousChunk = undefined;\n }\n let pos = 0;\n while (pos < chunkLength) {\n const remaining = chunkLength - pos;\n if (remaining < minChunkLength) {\n state.previousChunk = chunk.subarray(pos);\n state.previousChunkLength = remaining;\n return;\n }\n const match = indexOf(chunk, state.needle, pos);\n if (match > -1) {\n if (match > pos) {\n callback(state.matchIndex, chunk.subarray(pos, match));\n }\n state.matchIndex += 1;\n pos = match + state.needleLength;\n continue;\n } else if (chunk[chunkLength - 1] in state.indexes) {\n const indexes = state.indexes[chunk[chunkLength - 1]];\n let earliestIndex = -1;\n for (let i = 0, len = indexes.length; i < len; i++) {\n const index = indexes[i];\n if (chunk[chunkLength - 1 - index] === state.firstByte && i > earliestIndex) {\n earliestIndex = index;\n }\n }\n if (earliestIndex === -1) {\n if (pos === 0) {\n callback(state.matchIndex, chunk);\n } else {\n callback(state.matchIndex, chunk.subarray(pos));\n }\n } else {\n if (chunkLength - 1 - earliestIndex > pos) {\n callback(state.matchIndex, chunk.subarray(pos, chunkLength - 1 - earliestIndex));\n }\n state.previousChunk = chunk.subarray(chunkLength - 1 - earliestIndex);\n state.previousChunkLength = earliestIndex + 1;\n }\n } else if (pos === 0) {\n callback(state.matchIndex, chunk);\n } else {\n callback(state.matchIndex, chunk.subarray(pos));\n }\n break;\n }\n }\n function end() {\n if (state.previousChunk !== undefined && state.previousChunk !== seed) {\n callback(state.matchIndex, state.previousChunk);\n }\n state.previousChunk = seed;\n state.previousChunkLength = seed?.length ?? 0;\n state.matchIndex = 0;\n }\n return {\n write,\n end\n };\n}\n//# sourceMappingURL=search.js.map","import * as ByteSize from \"../../../../ByteSize.js\";\nimport * as CT from \"./contentType.js\";\nimport * as HP from \"./headers.js\";\nimport * as Search from \"./search.js\";\nconst State = {\n headers: 0,\n body: 1\n};\nconst errInvalidDisposition = {\n _tag: \"InvalidDisposition\"\n};\nconst errEndNotReached = {\n _tag: \"EndNotReached\"\n};\nconst errMaxParts = {\n _tag: \"ReachedLimit\",\n limit: \"MaxParts\"\n};\nconst errMaxTotalSize = {\n _tag: \"ReachedLimit\",\n limit: \"MaxTotalSize\"\n};\nconst errMaxPartSize = {\n _tag: \"ReachedLimit\",\n limit: \"MaxPartSize\"\n};\nconst errMaxFieldSize = {\n _tag: \"ReachedLimit\",\n limit: \"MaxFieldSize\"\n};\nconst constCR = /*#__PURE__*/new TextEncoder().encode(\"\\r\\n\");\nexport function defaultIsFile(info) {\n return info.filename !== undefined || info.contentType === \"application/octet-stream\";\n}\nfunction parseBoundary(headers) {\n const contentType = CT.parse(headers[\"content-type\"]);\n return contentType.parameters.boundary;\n}\nfunction noopOnChunk(_chunk) {}\nconst toLimit = input => input === Infinity ? Infinity : Number(ByteSize.fromInputUnsafe(input));\nexport function make({\n headers,\n onFile: onPart,\n onField,\n onError,\n onDone,\n isFile = defaultIsFile,\n maxParts = Infinity,\n maxTotalSize: maxTotalSizeInput = Infinity,\n maxPartSize: maxPartSizeInput = Infinity,\n maxFieldSize: maxFieldSizeInput = 1024 * 1024\n}) {\n const maxTotalSize = toLimit(maxTotalSizeInput);\n const maxPartSize = toLimit(maxPartSizeInput);\n const maxFieldSize = toLimit(maxFieldSizeInput);\n const boundary = parseBoundary(headers);\n if (boundary === undefined) {\n onError({\n _tag: \"InvalidBoundary\"\n });\n return {\n write: noopOnChunk,\n end() {}\n };\n }\n const state = {\n state: State.headers,\n index: 0,\n parts: 0,\n onChunk: noopOnChunk,\n info: undefined,\n headerSkip: 0,\n partSize: 0,\n totalSize: 0,\n isFile: false,\n fieldChunks: [],\n fieldSize: 0,\n done: false,\n stopped: false\n };\n function skipBody() {\n state.state = State.body;\n state.isFile = true;\n state.onChunk = noopOnChunk;\n }\n function stop(error) {\n state.stopped = true;\n if (state.state === State.body && state.isFile) {\n state.onChunk(null);\n }\n onError(error);\n }\n const headerParser = HP.make();\n const split = Search.make(`\\r\\n--${boundary}`, function (index, chunk) {\n if (state.stopped) {\n return;\n }\n if (index === 0) {\n // data before the first boundary\n skipBody();\n return;\n } else if (index !== state.index) {\n if (state.index > 0) {\n if (state.isFile) {\n state.onChunk(null);\n } else {\n if (state.fieldChunks.length === 1) {\n onField(state.info, state.fieldChunks[0]);\n } else {\n const buf = new Uint8Array(state.fieldSize);\n let offset = 0;\n for (let i = 0; i < state.fieldChunks.length; i++) {\n const chunk = state.fieldChunks[i];\n buf.set(chunk, offset);\n offset += chunk.length;\n }\n onField(state.info, buf);\n }\n state.fieldSize = 0;\n state.fieldChunks = [];\n }\n }\n state.partSize = 0;\n state.state = State.headers;\n state.index = index;\n state.headerSkip = 2; // skip the first \\r\\n\n // trailing --\n if (chunk[0] === 45 && chunk[1] === 45) {\n state.done = true;\n return onDone();\n }\n state.parts++;\n if (state.parts > maxParts) {\n return stop(errMaxParts);\n }\n }\n if ((state.partSize += chunk.length) > maxPartSize) {\n return stop(errMaxPartSize);\n }\n if (state.state === State.headers) {\n const result = headerParser(chunk, state.headerSkip);\n state.headerSkip = 0;\n if (result._tag === \"Continue\") {\n return;\n } else if (result._tag === \"Failure\") {\n skipBody();\n return onError({\n _tag: \"BadHeaders\",\n error: result\n });\n }\n const contentType = CT.parse(result.headers[\"content-type\"]);\n const contentDisposition = CT.parse(result.headers[\"content-disposition\"], true);\n if (\"form-data\" === contentDisposition.value && !(\"name\" in contentDisposition.parameters)) {\n skipBody();\n return onError(errInvalidDisposition);\n }\n let encodedFilename;\n if (\"filename*\" in contentDisposition.parameters) {\n const parts = contentDisposition.parameters[\"filename*\"].split(\"''\");\n if (parts.length === 2) {\n try {\n encodedFilename = decodeURIComponent(parts[1]);\n } catch {\n encodedFilename = parts[1];\n }\n }\n }\n state.info = {\n name: contentDisposition.parameters.name ?? \"\",\n filename: encodedFilename ?? contentDisposition.parameters.filename,\n contentType: contentType.value === \"\" ? contentDisposition.parameters.filename !== undefined ? \"application/octet-stream\" : \"text/plain\" : contentType.value,\n contentTypeParameters: contentType.parameters,\n contentDisposition: contentDisposition.value,\n contentDispositionParameters: contentDisposition.parameters,\n headers: result.headers\n };\n state.state = State.body;\n state.isFile = isFile(state.info);\n if (state.isFile) {\n state.onChunk = onPart(state.info);\n }\n if (result.endPosition < chunk.length) {\n if (state.isFile) {\n state.onChunk(chunk.subarray(result.endPosition));\n } else {\n const buf = chunk.subarray(result.endPosition);\n if ((state.fieldSize += buf.length) > maxFieldSize) {\n return stop(errMaxFieldSize);\n }\n state.fieldChunks.push(buf);\n }\n }\n } else if (state.isFile) {\n state.onChunk(chunk);\n } else {\n if ((state.fieldSize += chunk.length) > maxFieldSize) {\n return stop(errMaxFieldSize);\n }\n state.fieldChunks.push(chunk);\n }\n }, constCR, 2);\n return {\n write(chunk) {\n if (state.stopped) {\n return;\n }\n if ((state.totalSize += chunk.length) > maxTotalSize) {\n return stop(errMaxTotalSize);\n }\n return split.write(chunk);\n },\n end() {\n split.end();\n if (!state.done && !state.stopped) {\n stop(errEndNotReached);\n }\n state.state = State.headers;\n state.index = 0;\n state.parts = 0;\n state.onChunk = noopOnChunk;\n state.info = undefined;\n state.totalSize = 0;\n state.partSize = 0;\n state.fieldChunks = [];\n state.fieldSize = 0;\n state.done = false;\n state.stopped = false;\n }\n };\n}\nconst utf8Decoder = /*#__PURE__*/new TextDecoder(\"utf-8\");\nfunction getDecoder(charset) {\n if (charset === \"utf-8\" || charset === \"utf8\" || charset === \"\") {\n return utf8Decoder;\n }\n try {\n return new TextDecoder(charset);\n } catch (error) {\n return utf8Decoder;\n }\n}\nexport function decodeField(info, value) {\n return getDecoder(info.contentTypeParameters.charset ?? \"utf-8\").decode(value);\n}\n//# sourceMappingURL=multipart.js.map","import * as internal from \"./MultipartParser/internal/multipart.js\";\n/**\n * Creates a streaming multipart parser.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = internal.make;\n/**\n * Determines whether a multipart part should be treated as a file.\n *\n * @category utilities\n * @since 4.0.0\n */\nexport const defaultIsFile = internal.defaultIsFile;\n/**\n * Decodes a multipart field using its declared character set.\n *\n * @category utilities\n * @since 4.0.0\n */\nexport const decodeField = internal.decodeField;\n//# sourceMappingURL=MultipartParser.js.map","/**\n * Parses and persists HTTP `multipart/form-data` request bodies.\n *\n * `Multipart` turns incoming byte streams into typed form parts. Text parts\n * become decoded fields, while upload parts stay as streamed files until they\n * are collected or written to scoped temporary files. The persisted\n * representation can then be decoded with schemas for handlers that receive\n * fields and uploaded files together. This module also includes multipart error\n * types, schema helpers for persisted files, and parser limit settings.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"../../Array.js\";\nimport * as ByteSize from \"../../ByteSize.js\";\nimport * as Cause from \"../../Cause.js\";\nimport * as Channel from \"../../Channel.js\";\nimport * as Context from \"../../Context.js\";\nimport * as Data from \"../../Data.js\";\nimport * as Effect from \"../../Effect.js\";\nimport * as ErrorReporter from \"../../ErrorReporter.js\";\nimport * as Exit from \"../../Exit.js\";\nimport * as FileSystem from \"../../FileSystem.js\";\nimport { constant, dual } from \"../../Function.js\";\nimport * as Inspectable from \"../../Inspectable.js\";\nimport * as Option from \"../../Option.js\";\nimport * as Path from \"../../Path.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as Pull from \"../../Pull.js\";\nimport * as Schema from \"../../Schema.js\";\nimport * as SchemaTransformation from \"../../SchemaTransformation.js\";\nimport * as Stream from \"../../Stream.js\";\nimport * as IncomingMessage from \"./HttpIncomingMessage.js\";\nimport * as HttpServerRespondable from \"./HttpServerRespondable.js\";\nimport * as HttpServerResponse from \"./HttpServerResponse.js\";\nimport * as MP from \"./MultipartParser.js\";\n/**\n * Type identifier used to brand multipart part values.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = \"~effect/http/Multipart\";\n/**\n * Returns `true` when a value has the multipart part type identifier.\n *\n * **Details**\n *\n * This includes `Field`, `File`, and `PersistedFile` values. Use\n * `isStreamPart` to identify only parsed, streamed parts.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isPart = u => Predicate.hasProperty(u, TypeId);\n/**\n * Returns `true` when a value is a multipart text `Field` or streamed `File`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isStreamPart = u => isPart(u) && (u._tag === \"Field\" || u._tag === \"File\");\n/**\n * Returns `true` when a value is a multipart text `Field`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isField = u => isPart(u) && u._tag === \"Field\";\n/**\n * Returns `true` when a value is a multipart `File`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isFile = u => isPart(u) && u._tag === \"File\";\n/**\n * Returns `true` when a value is a persisted multipart file.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isPersistedFile = u => Predicate.hasProperty(u, TypeId) && Predicate.isTagged(u, \"PersistedFile\");\nconst MultipartErrorTypeId = \"~effect/http/Multipart/MultipartError\";\n/**\n * Error reason carried by a `MultipartError`.\n *\n * **Details**\n *\n * It identifies parser and limit failures such as oversized files or fields, too\n * many parts, total body size limits, parse errors, and internal errors.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class MultipartErrorReason extends Data.Error {}\nconst responseStatusByReason = {\n FileTooLarge: 413,\n FieldTooLarge: 413,\n BodyTooLarge: 413,\n TooManyParts: 413,\n InternalError: 500,\n Parse: 400\n};\n/**\n * Error raised while parsing, streaming, or persisting multipart form data.\n *\n * **Details**\n *\n * The `reason` field contains the concrete `MultipartErrorReason`. When used as\n * a server response, parse errors render as `400`, limit errors as `413`, and\n * internal errors as `500`. Multipart errors are ignored by the error reporter.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class MultipartError extends /*#__PURE__*/Data.TaggedError(\"MultipartError\") {\n /**\n * Creates a multipart error from a reason tag and optional cause.\n *\n * @since 4.0.0\n */\n static fromReason(reason, cause) {\n return new MultipartError({\n reason: new MultipartErrorReason({\n _tag: reason,\n cause\n })\n });\n }\n /**\n * Marks this value as a multipart error for runtime guards.\n *\n * @since 4.0.0\n */\n [MultipartErrorTypeId] = MultipartErrorTypeId;\n [ErrorReporter.ignore] = true;\n /**\n * Converts the multipart error into an HTTP response based on its reason.\n *\n * **Details**\n *\n * Parse errors produce `400`, size and part-count limits produce `413`, and\n * internal errors produce `500`.\n *\n * @since 4.0.0\n */\n [HttpServerRespondable.symbol]() {\n return Effect.succeed(HttpServerResponse.empty({\n status: responseStatusByReason[this.reason._tag]\n }));\n }\n /**\n * Uses the concrete multipart error reason as the public message.\n *\n * @since 4.0.0\n */\n get message() {\n return this.reason._tag;\n }\n}\nconst PersistedFileEncoded = /*#__PURE__*/Schema.Struct({\n key: Schema.String,\n name: Schema.String,\n contentType: /*#__PURE__*/Schema.String.annotate({\n contentEncoding: \"binary\"\n }),\n path: Schema.String\n});\n/**\n * Schema for persisted multipart files.\n *\n * **Details**\n *\n * The encoded form contains the field key, original file name, content type, and\n * filesystem path.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const PersistedFileSchema = /*#__PURE__*/Schema.declare(isPersistedFile, {\n representation: {\n id: \"effect/http/PersistedFile\",\n payload: null\n },\n toCode: () => ({\n runtime: \"Multipart.PersistedFileSchema\",\n Type: \"Multipart.PersistedFile\",\n importDeclarations: [`import * as Multipart from \"effect/unstable/http/Multipart\"`]\n }),\n expected: \"PersistedFile\",\n toCodecJson: () => Schema.link()(PersistedFileEncoded, SchemaTransformation.transform({\n decode: ({\n contentType,\n key,\n name,\n path\n }) => new PersistedFileImpl(key, name, contentType, path),\n encode: file => ({\n key: file.key,\n name: file.name,\n contentType: file.contentType,\n path: file.path\n })\n }))\n});\n/**\n * Schema for an array of persisted multipart files.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const FilesSchema = /*#__PURE__*/Schema.Array(PersistedFileSchema);\n/**\n * Schema for exactly one persisted multipart file.\n *\n * **Details**\n *\n * The encoded form is a one-element file array, while the decoded value is the\n * single `PersistedFile`.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const SingleFileSchema = /*#__PURE__*/FilesSchema.check(Schema.isLengthBetween(1, 1)).pipe(/*#__PURE__*/Schema.decodeTo(PersistedFileSchema, /*#__PURE__*/SchemaTransformation.transform({\n decode: ([file]) => file,\n encode: file => [file]\n})));\n/**\n * Creates a decoder for persisted multipart data using the supplied schema.\n *\n * **Details**\n *\n * The returned function decodes an unknown input into the schema output and fails\n * with `SchemaError` when validation fails.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaPersisted = schema => Schema.decodeUnknownEffect(schema);\n/**\n * Creates a decoder for a JSON-encoded field in persisted multipart data.\n *\n * **Details**\n *\n * The selected field is parsed from a JSON string and decoded with the supplied\n * schema.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaJson = (schema, options) => {\n const fromJson = Schema.fromJsonString(schema, options);\n return dual(2, (persisted, field) => Effect.map(Schema.decodeUnknownEffect(Schema.Struct({\n [field]: fromJson\n }))(persisted, options), _ => _[field]));\n};\n/**\n * Builds the low-level multipart parser configuration from request headers and\n * the current fiber context.\n *\n * **Details**\n *\n * Parser limits are read from the multipart references, including maximum parts,\n * field size, file size, total body size, and field MIME type overrides.\n *\n * @category configuration\n * @since 4.0.0\n */\nexport const makeConfig = headers => Effect.withFiber(fiber => {\n const mimeTypes = Context.get(fiber.context, FieldMimeTypes);\n return Effect.succeed({\n headers,\n maxParts: fiber.getRef(MaxParts),\n maxFieldSize: fiber.getRef(MaxFieldSize),\n maxPartSize: fiber.getRef(MaxFileSize),\n maxTotalSize: fiber.getRef(IncomingMessage.MaxBodySize),\n isFile: mimeTypes.length === 0 ? undefined : info => !mimeTypes.some(_ => info.contentType.includes(_)) && MP.defaultIsFile(info)\n });\n});\n/**\n * Creates a channel that parses multipart byte chunks into multipart parts.\n *\n * **Details**\n *\n * The channel consumes non-empty batches of `Uint8Array` chunks and emits\n * non-empty batches of parsed `Part` values, failing with `MultipartError` for\n * parser and limit failures.\n *\n * @category parsing\n * @since 4.0.0\n */\nexport const makeChannel = headers => Channel.fromTransform(upstream => Effect.map(makeConfig(headers), config => {\n let partsBuffer = [];\n let exit = Option.none();\n let ended = false;\n const parser = MP.make({\n ...config,\n onField(info, value) {\n partsBuffer.push(new FieldImpl(info.name, info.contentType, MP.decodeField(info, value)));\n },\n onFile(info) {\n let chunks = [];\n let finished = false;\n const pullChunks = Channel.fromPull(Effect.succeed(Effect.suspend(function loop() {\n if (!Arr.isReadonlyArrayNonEmpty(chunks)) {\n return finished ? Cause.done() : Effect.flatMap(pump, loop);\n }\n const chunk = chunks;\n chunks = [];\n return Effect.succeed(chunk);\n })));\n partsBuffer.push(new FileImpl(info, pullChunks));\n return function (chunk) {\n if (chunk === null) {\n finished = true;\n } else {\n chunks.push(chunk);\n }\n };\n },\n onError(error_) {\n exit = Option.some(Exit.fail(convertError(error_)));\n },\n onDone() {\n if (Option.isNone(exit)) {\n exit = Option.some(Exit.fail(Cause.Done()));\n }\n }\n });\n const pump = upstream.pipe(Effect.flatMap(chunk => {\n for (let i = 0; i < chunk.length; i++) {\n parser.write(chunk[i]);\n }\n return Effect.void;\n }), Effect.catchCause(cause => {\n if (Pull.isDoneCause(cause)) {\n if (!ended) {\n ended = true;\n parser.end();\n }\n } else {\n exit = Option.some(Exit.failCause(cause));\n }\n return Effect.void;\n }));\n return pump.pipe(Effect.flatMap(function loop() {\n if (!Arr.isReadonlyArrayNonEmpty(partsBuffer)) {\n if (Option.isSome(exit)) {\n return exit.value;\n }\n return Effect.flatMap(pump, loop);\n }\n const parts = partsBuffer;\n partsBuffer = [];\n return Effect.succeed(parts);\n }));\n}));\nfunction convertError(cause) {\n switch (cause._tag) {\n case \"ReachedLimit\":\n {\n switch (cause.limit) {\n case \"MaxParts\":\n {\n return MultipartError.fromReason(\"TooManyParts\", cause);\n }\n case \"MaxFieldSize\":\n {\n return MultipartError.fromReason(\"FieldTooLarge\", cause);\n }\n case \"MaxPartSize\":\n {\n return MultipartError.fromReason(\"FileTooLarge\", cause);\n }\n case \"MaxTotalSize\":\n {\n return MultipartError.fromReason(\"BodyTooLarge\", cause);\n }\n }\n }\n default:\n {\n return MultipartError.fromReason(\"Parse\", cause);\n }\n }\n}\nclass PartBase extends Inspectable.Class {\n [TypeId];\n constructor() {\n super();\n this[TypeId] = TypeId;\n }\n}\nclass FieldImpl extends PartBase {\n _tag = \"Field\";\n key;\n contentType;\n value;\n constructor(key, contentType, value) {\n super();\n this.key = key;\n this.contentType = contentType;\n this.value = value;\n }\n toJSON() {\n return {\n _id: \"@effect/platform/Multipart/Part\",\n _tag: \"Field\",\n key: this.key,\n contentType: this.contentType,\n value: this.value\n };\n }\n}\nclass FileImpl extends PartBase {\n _tag = \"File\";\n key;\n name;\n contentType;\n content;\n contentEffect;\n constructor(info, channel) {\n super();\n this.key = info.name;\n this.name = info.filename ?? info.name;\n this.contentType = info.contentType;\n this.content = Stream.fromChannel(channel);\n this.contentEffect = channel.pipe(Channel.mkUint8Array, Effect.mapError(cause => MultipartError.fromReason(\"InternalError\", cause)));\n }\n toJSON() {\n return {\n _id: \"@effect/platform/Multipart/Part\",\n _tag: \"File\",\n key: this.key,\n name: this.name,\n contentType: this.contentType\n };\n }\n}\nconst defaultWriteFile = (path, file) => Effect.flatMap(FileSystem.FileSystem, fs => Effect.mapError(Stream.run(file.content, fs.sink(path)), cause => MultipartError.fromReason(\"InternalError\", cause)));\n/**\n * Runs a channel of byte chunks and collects all output into a single\n * `Uint8Array`.\n *\n * **Gotchas**\n *\n * This materializes the full content in memory.\n * The source channel must not reuse or mutate emitted buffers, which are retained\n * until collection completes.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const collectUint8Array = self => Channel.mkUint8Array(self);\n/**\n * Persists a stream of multipart parts into a record.\n *\n * **Details**\n *\n * Text fields are collected as strings, and file parts are written to files in a\n * scoped temporary directory.\n *\n * **Gotchas**\n *\n * Persisted file paths remain valid for the lifetime of the scope.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toPersisted = (stream, writeFile = defaultWriteFile) => Effect.gen(function* () {\n const fs = yield* FileSystem.FileSystem;\n const path_ = yield* Path.Path;\n const dir = yield* fs.makeTempDirectoryScoped();\n const persisted = Object.create(null);\n const usedPaths = new Set();\n let fileIndex = 0;\n yield* Stream.runForEach(stream, part => {\n if (part._tag === \"Field\") {\n if (!(part.key in persisted)) {\n persisted[part.key] = part.value;\n } else if (typeof persisted[part.key] === \"string\") {\n persisted[part.key] = [persisted[part.key], part.value];\n } else {\n ;\n persisted[part.key].push(part.value);\n }\n return Effect.void;\n } else if (part.name === \"\") {\n return Effect.void;\n }\n const file = part;\n const fileName = path_.basename(file.name).slice(-128);\n let path = path_.join(dir, fileName);\n while (usedPaths.has(path)) {\n path = path_.join(dir, `${fileIndex++}-${fileName}`);\n }\n usedPaths.add(path);\n const filePart = new PersistedFileImpl(file.key, file.name, file.contentType, path);\n if (Array.isArray(persisted[part.key])) {\n ;\n persisted[part.key].push(filePart);\n } else {\n persisted[part.key] = [filePart];\n }\n return writeFile(path, file);\n });\n return persisted;\n}).pipe(Effect.catchTag(\"PlatformError\", cause => Effect.fail(MultipartError.fromReason(\"InternalError\", cause))));\nclass PersistedFileImpl extends PartBase {\n _tag = \"PersistedFile\";\n key;\n name;\n contentType;\n path;\n constructor(key, name, contentType, path) {\n super();\n this.key = key;\n this.name = name;\n this.contentType = contentType;\n this.path = path;\n }\n toJSON() {\n return {\n _id: \"@effect/platform/Multipart/Part\",\n _tag: \"PersistedFile\",\n key: this.key,\n name: this.name,\n contentType: this.contentType,\n path: this.path\n };\n }\n}\n/**\n * Creates a context containing multipart parser limit settings.\n *\n * **Details**\n *\n * The context can provide maximum part count, field size, file size, total body\n * size, and MIME types that should be parsed as fields.\n *\n * @category references\n * @since 4.0.0\n */\nexport const limitsServices = options => {\n const map = new Map();\n if (options.maxParts !== undefined) {\n map.set(MaxParts.key, options.maxParts);\n }\n if (options.maxFieldSize !== undefined) {\n map.set(MaxFieldSize.key, ByteSize.fromInputUnsafe(options.maxFieldSize));\n }\n if (options.maxFileSize !== undefined) {\n map.set(MaxFileSize.key, ByteSize.fromInputUnsafe(options.maxFileSize));\n }\n if (options.maxTotalSize !== undefined) {\n map.set(IncomingMessage.MaxBodySize.key, ByteSize.fromInputUnsafe(options.maxTotalSize));\n }\n if (options.fieldMimeTypes !== undefined) {\n map.set(FieldMimeTypes.key, options.fieldMimeTypes);\n }\n return Context.makeUnsafe(map);\n};\n/**\n * Context reference for the maximum number of multipart parts allowed.\n *\n * **Details**\n *\n * The default is `undefined`, meaning no explicit part-count limit.\n *\n * @category services\n * @since 4.0.0\n */\nexport const MaxParts = /*#__PURE__*/Context.Reference(\"effect/http/Multipart/MaxParts\", {\n defaultValue: () => undefined\n});\n/**\n * Context reference for the maximum size of a multipart field value.\n *\n * **Details**\n *\n * The default limit is 10 MiB.\n *\n * @category services\n * @since 4.0.0\n */\nexport const MaxFieldSize = /*#__PURE__*/Context.Reference(\"effect/http/Multipart/MaxFieldSize\", {\n defaultValue: /*#__PURE__*/constant(/*#__PURE__*/ByteSize.mebibytes(10))\n});\n/**\n * Context reference for the maximum size of a multipart file part.\n *\n * **Details**\n *\n * The default is `undefined`, meaning no explicit per-file limit.\n *\n * @category services\n * @since 4.0.0\n */\nexport const MaxFileSize = /*#__PURE__*/Context.Reference(\"effect/http/Multipart/MaxFileSize\", {\n defaultValue: () => undefined\n});\n/**\n * Context reference for MIME type fragments that should be parsed as multipart\n * fields instead of files.\n *\n * **Details**\n *\n * The default treats `application/json` parts as fields.\n *\n * @category services\n * @since 4.0.0\n */\nexport const FieldMimeTypes = /*#__PURE__*/Context.Reference(\"effect/http/Multipart/FieldMimeTypes\", {\n defaultValue: /*#__PURE__*/constant([\"application/json\"])\n});\n//# sourceMappingURL=Multipart.js.map","import * as Channel from \"../../Channel.js\";\nimport * as Context from \"../../Context.js\";\nimport * as Effect from \"../../Effect.js\";\nimport * as Inspectable from \"../../Inspectable.js\";\nimport * as InternalRecord from \"../../internal/record.js\";\nimport * as Option from \"../../Option.js\";\nimport * as Result from \"../../Result.js\";\nimport * as Schema from \"../../Schema.js\";\nimport * as Stream from \"../../Stream.js\";\nimport * as Socket from \"../socket/Socket.js\";\nimport * as Cookies from \"./Cookies.js\";\nimport * as Headers from \"./Headers.js\";\nimport * as HttpBody from \"./HttpBody.js\";\nimport * as HttpClientRequest from \"./HttpClientRequest.js\";\nimport * as HttpIncomingMessage from \"./HttpIncomingMessage.js\";\nimport { hasBody } from \"./HttpMethod.js\";\nimport { HttpServerError, RequestParseError } from \"./HttpServerError.js\";\nimport * as bodyInternal from \"./internal/httpBody.js\";\nimport * as Multipart from \"./Multipart.js\";\nimport * as UrlParams from \"./UrlParams.js\";\nexport {\n/**\n * Provides the `MaxBodySize` fiber reference for configuring request body limits.\n *\n * **When to use**\n *\n * Use to configure the maximum body size accepted while reading server\n * request bodies.\n *\n * @category references\n * @since 4.0.0\n */\nMaxBodySize } from \"./HttpIncomingMessage.js\";\n/**\n * Runtime type identifier for `HttpServerRequest` values.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const TypeId = \"~effect/http/HttpServerRequest\";\n/**\n * Service tag for the active server-side HTTP request.\n *\n * **When to use**\n *\n * Use to access the request currently being handled by HTTP server routes and\n * middleware.\n *\n * @category services\n * @since 4.0.0\n */\nexport const HttpServerRequest = /*#__PURE__*/Context.Service(\"effect/http/HttpServerRequest\");\n/**\n * Service that contains decoded URL query parameters for the current request.\n *\n * **When to use**\n *\n * Use to access query parameters that have already been parsed for the current\n * server request.\n *\n * **Details**\n *\n * Each key maps to a string value, or to an array when the parameter appears more\n * than once.\n *\n * @category services\n * @since 4.0.0\n */\nexport class ParsedSearchParams extends /*#__PURE__*/Context.Service()(\"effect/http/ParsedSearchParams\") {}\n/**\n * Converts a `URL` object's search parameters into a record.\n *\n * **Details**\n *\n * Repeated parameters are represented as arrays in insertion order.\n *\n * @category parsing\n * @since 4.0.0\n */\nexport const searchParamsFromURL = url => {\n const out = {};\n for (const [key, value] of url.searchParams.entries()) {\n if (Object.hasOwn(out, key)) {\n const entry = out[key];\n if (Array.isArray(entry)) {\n entry.push(value);\n } else {\n InternalRecord.assignProperty(out, key, [entry, value]);\n }\n } else {\n InternalRecord.assignProperty(out, key, value);\n }\n }\n return out;\n};\n/**\n * Creates a channel backed by the current request's upgraded socket.\n *\n * **Details**\n *\n * The channel reads incoming socket messages and writes byte chunks to the\n * socket, failing if the request cannot be upgraded or the socket fails.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const upgradeChannel = () => HttpServerRequest.pipe(Effect.flatMap(_ => _.upgrade), Effect.map(Socket.toChannelWith()), Channel.unwrap);\n/**\n * Decodes a schema from the cookies of the current request.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaCookies = (schema, options) => {\n const parse = Schema.decodeUnknownEffect(schema);\n return Effect.flatMap(HttpServerRequest, req => parse(req.cookies, options));\n};\n/**\n * Decodes a schema from the headers of the current request.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaHeaders = (schema, options) => {\n const parse = Schema.decodeUnknownEffect(schema);\n return Effect.flatMap(HttpServerRequest, req => parse(req.headers, options));\n};\n/**\n * Decodes a schema from the parsed search parameters of the current request.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaSearchParams = (schema, options) => {\n const parse = Schema.decodeUnknownEffect(schema);\n return Effect.flatMap(ParsedSearchParams, params => parse(params, options));\n};\n/**\n * Reads the current request body as JSON and decodes it with the supplied schema.\n *\n * **Details**\n *\n * The effect can fail if the body cannot be read or parsed, or if schema decoding\n * fails.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaBodyJson = (schema, options) => {\n const parse = HttpIncomingMessage.schemaBodyJson(schema, options);\n return Effect.flatMap(HttpServerRequest, parse);\n};\nconst isMultipart = request => request.headers[\"content-type\"]?.toLowerCase().includes(\"multipart/form-data\") === true || getFormDataBody(request) !== undefined;\n/**\n * Decodes the current request body as form data.\n *\n * **Details**\n *\n * Multipart requests are persisted and decoded as multipart data; other form\n * requests are decoded from URL-encoded body parameters.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaBodyForm = (schema, options) => {\n const parseMultipart = Multipart.schemaPersisted(schema);\n const parseUrlParams = HttpIncomingMessage.schemaBodyUrlParams(schema, options);\n return Effect.flatMap(HttpServerRequest, request => {\n if (isMultipart(request)) {\n return Effect.flatMap(request.multipart, _ => parseMultipart(_, options));\n }\n return parseUrlParams(request);\n });\n};\n/**\n * Reads the current request body as URL-encoded parameters and decodes them with\n * the supplied schema.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaBodyUrlParams = (schema, options) => {\n const parse = HttpIncomingMessage.schemaBodyUrlParams(schema, options);\n return Effect.flatMap(HttpServerRequest, parse);\n};\n/**\n * Persists the current multipart request body and decodes it with the supplied\n * schema.\n *\n * **Details**\n *\n * The effect requires the services needed to persist multipart files, including a\n * scope, file system, and path service.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaBodyMultipart = (schema, options) => {\n const parse = Multipart.schemaPersisted(schema);\n return HttpServerRequest.pipe(Effect.flatMap(_ => _.multipart), Effect.flatMap(_ => parse(_, options)));\n};\n/**\n * Creates a decoder for a JSON value stored in a form field.\n *\n * **Details**\n *\n * For multipart requests, the named multipart field is decoded as JSON. For\n * URL-encoded requests, the named parameter is decoded as JSON and then decoded\n * with the supplied schema.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaBodyFormJson = (schema, options) => {\n const parseMultipart = Multipart.schemaJson(schema, options);\n return field => {\n const parseUrlParams = Schema.JsonFromUrlParamsField(field, options).pipe(Schema.decodeTo(schema), Schema.decodeEffect);\n return Effect.flatMap(HttpServerRequest, request => {\n if (isMultipart(request)) {\n return Effect.flatMap(Effect.mapError(request.multipart, cause => new HttpServerError({\n reason: new RequestParseError({\n request,\n cause\n })\n })), parseMultipart(field));\n }\n return Effect.flatMap(request.urlParamsBody, _ => parseUrlParams(_, options));\n });\n };\n};\n/**\n * Creates an `HttpServerRequest` view of an `HttpClientRequest`.\n *\n * **Details**\n *\n * If the client request can be converted to an absolute URL, that URL is used as\n * the original URL.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromClientRequest = request => {\n const url = Option.match(HttpClientRequest.toUrl(request), {\n onNone: () => request.url,\n onSome: url => url.toString()\n });\n return new ClientRequestImpl(request, url);\n};\n/**\n * Wraps a Web `Request` as an `HttpServerRequest`.\n *\n * **Details**\n *\n * The request's current URL is stored without the scheme and host, while the\n * original Web URL remains available as `originalUrl`.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const fromWeb = request => new ServerRequestImpl(request, removeHost(request.url));\n/**\n * Converts an `HttpServerRequest` into an `HttpClientRequest`.\n *\n * **Details**\n *\n * The converted request preserves the method, headers, body stream, and a URL\n * derived from the request when possible.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toClientRequest = request => {\n const body = toClientBody(request);\n const headers = body._tag !== \"Empty\" && body.contentLength === undefined ? Headers.remove(request.headers, \"content-length\") : request.headers;\n return HttpClientRequest.setUrl(HttpClientRequest.makeWith(request.method, \"\", UrlParams.empty, Option.none(), headers, body), Option.getOrElse(toURL(request), () => request.url));\n};\nconst toClientBody = request => {\n if (!hasBody(request.method)) {\n return HttpBody.empty;\n }\n const formData = getFormDataBody(request);\n return formData === undefined ? HttpBody.stream(request.stream, request.headers[\"content-type\"], bodyInternal.parseContentLength(request.headers[\"content-length\"])) : HttpBody.formData(formData);\n};\nconst removeHost = url => {\n if (url[0] === \"/\") {\n return url;\n }\n const index = url.indexOf(\"/\", url.indexOf(\"//\") + 2);\n return index === -1 ? \"/\" : url.slice(index);\n};\nclass ServerRequestImpl extends Inspectable.Class {\n [TypeId];\n [HttpIncomingMessage.TypeId];\n source;\n url;\n headersOverride;\n remoteAddressOverride;\n constructor(source, url, headersOverride, remoteAddressOverride) {\n super();\n this[TypeId] = TypeId;\n this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId;\n this.source = source;\n this.url = url;\n this.headersOverride = headersOverride;\n this.remoteAddressOverride = remoteAddressOverride;\n }\n toJSON() {\n return HttpIncomingMessage.inspect(this, {\n _id: \"HttpServerRequest\",\n method: this.method,\n url: this.originalUrl\n });\n }\n modify(options) {\n return new ServerRequestImpl(this.source, options.url ?? this.url, options.headers ?? this.headersOverride, \"remoteAddress\" in options ? options.remoteAddress : this.remoteAddressOverride);\n }\n get method() {\n return this.source.method.toUpperCase();\n }\n get originalUrl() {\n return this.source.url;\n }\n get remoteAddress() {\n return this.remoteAddressOverride ?? Option.none();\n }\n get headers() {\n this.headersOverride ??= Headers.fromInput(this.source.headers);\n return this.headersOverride;\n }\n cachedCookies;\n get cookies() {\n if (this.cachedCookies) {\n return this.cachedCookies;\n }\n return this.cachedCookies = Cookies.parseHeader(this.headers.cookie ?? \"\");\n }\n get stream() {\n return this.source.body ? Stream.fromReadableStream({\n evaluate: () => this.source.body,\n onError: cause => new HttpServerError({\n reason: new RequestParseError({\n request: this,\n cause\n })\n })\n }) : Stream.fail(new HttpServerError({\n reason: new RequestParseError({\n request: this,\n description: \"can not create stream from empty body\"\n })\n }));\n }\n textEffect;\n get text() {\n if (this.textEffect) {\n return this.textEffect;\n }\n this.textEffect = Effect.runSync(Effect.cached(Effect.tryPromise({\n try: () => this.source.text(),\n catch: cause => new HttpServerError({\n reason: new RequestParseError({\n request: this,\n cause\n })\n })\n })));\n return this.textEffect;\n }\n get json() {\n return Effect.flatMap(this.text, text => Effect.try({\n try: () => JSON.parse(text),\n catch: cause => new HttpServerError({\n reason: new RequestParseError({\n request: this,\n cause\n })\n })\n }));\n }\n get urlParamsBody() {\n return Effect.flatMap(this.text, _ => Effect.try({\n try: () => UrlParams.fromInput(new URLSearchParams(_)),\n catch: cause => new HttpServerError({\n reason: new RequestParseError({\n request: this,\n cause\n })\n })\n }));\n }\n multipartEffect;\n get multipart() {\n if (this.multipartEffect) {\n return this.multipartEffect;\n }\n this.multipartEffect = Effect.runSync(Effect.cached(Multipart.toPersisted(this.multipartStream)));\n return this.multipartEffect;\n }\n get multipartStream() {\n return Stream.pipeThroughChannel(Stream.mapError(this.stream, cause => Multipart.MultipartError.fromReason(\"InternalError\", cause)), Multipart.makeChannel(this.headers));\n }\n arrayBufferEffect;\n get arrayBuffer() {\n if (this.arrayBufferEffect) {\n return this.arrayBufferEffect;\n }\n this.arrayBufferEffect = Effect.runSync(Effect.cached(Effect.tryPromise({\n try: () => this.source.arrayBuffer(),\n catch: cause => new HttpServerError({\n reason: new RequestParseError({\n request: this,\n cause\n })\n })\n })));\n return this.arrayBufferEffect;\n }\n get upgrade() {\n return Effect.fail(new HttpServerError({\n reason: new RequestParseError({\n request: this,\n description: \"Not an upgradeable ServerRequest\"\n })\n }));\n }\n}\nclass ClientRequestImpl extends Inspectable.Class {\n [TypeId];\n [HttpIncomingMessage.TypeId];\n source;\n originalUrl;\n headersOverride;\n remoteAddressOverride;\n urlOverride;\n constructor(source, originalUrl, urlOverride, headersOverride, remoteAddressOverride) {\n super();\n this[TypeId] = TypeId;\n this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId;\n this.source = source;\n this.originalUrl = originalUrl;\n this.urlOverride = urlOverride;\n this.headersOverride = headersOverride;\n this.remoteAddressOverride = remoteAddressOverride;\n }\n toJSON() {\n return HttpIncomingMessage.inspect(this, {\n _id: \"HttpServerRequest\",\n method: this.method,\n url: this.originalUrl\n });\n }\n modify(options) {\n return new ClientRequestImpl(this.source, this.originalUrl, options.url ?? this.url, options.headers ?? this.headersOverride, \"remoteAddress\" in options ? options.remoteAddress : this.remoteAddressOverride);\n }\n get method() {\n return this.source.method;\n }\n get url() {\n return this.urlOverride ?? removeHost(this.originalUrl);\n }\n get remoteAddress() {\n return this.remoteAddressOverride ?? Option.none();\n }\n get headers() {\n return this.headersOverride ??= this.source.headers;\n }\n cachedCookies;\n get cookies() {\n if (this.cachedCookies) {\n return this.cachedCookies;\n }\n return this.cachedCookies = Cookies.parseHeader(this.headers.cookie ?? \"\");\n }\n get stream() {\n const body = this.source.body;\n switch (body._tag) {\n case \"Empty\":\n {\n return Stream.empty;\n }\n case \"Uint8Array\":\n {\n return Stream.succeed(body.body);\n }\n case \"Stream\":\n {\n return Stream.mapError(body.stream, cause => requestParseError(this, undefined, cause));\n }\n case \"FormData\":\n {\n return streamFromReadable(this, new Response(body.formData).body);\n }\n case \"Raw\":\n {\n return rawBodyStream(this, body.body);\n }\n }\n }\n bytesEffect;\n get bytes() {\n if (this.bytesEffect) {\n return this.bytesEffect;\n }\n const body = this.source.body;\n let effect;\n switch (body._tag) {\n case \"Empty\":\n {\n effect = Effect.succeed(new Uint8Array(0));\n break;\n }\n case \"Uint8Array\":\n {\n effect = Effect.succeed(body.body);\n break;\n }\n case \"FormData\":\n {\n effect = bytesFromBodyInit(this, body.formData);\n break;\n }\n case \"Stream\":\n {\n effect = Stream.mkUint8Array(this.stream);\n break;\n }\n case \"Raw\":\n {\n effect = rawBodyBytes(this, body.body);\n break;\n }\n }\n this.bytesEffect = Effect.runSync(Effect.cached(effect));\n return this.bytesEffect;\n }\n get text() {\n return Effect.map(this.bytes, bytes => textDecoder.decode(bytes));\n }\n get json() {\n return Effect.flatMap(this.text, text => Effect.try({\n try: () => text === \"\" ? null : JSON.parse(text),\n catch: cause => requestParseError(this, undefined, cause)\n }));\n }\n get urlParamsBody() {\n return Effect.flatMap(this.text, _ => Effect.try({\n try: () => UrlParams.fromInput(new URLSearchParams(_)),\n catch: cause => requestParseError(this, undefined, cause)\n }));\n }\n multipartEffect;\n get multipart() {\n if (this.multipartEffect) {\n return this.multipartEffect;\n }\n this.multipartEffect = Effect.runSync(Effect.cached(Multipart.toPersisted(this.multipartStream)));\n return this.multipartEffect;\n }\n get multipartStream() {\n const formData = this.source.body._tag === \"FormData\" && this.source.body.formData;\n if (formData) {\n return Stream.fromIterable(formDataToParts(formData));\n }\n return Stream.pipeThroughChannel(Stream.mapError(this.stream, cause => Multipart.MultipartError.fromReason(\"InternalError\", cause)), Multipart.makeChannel(this.headers));\n }\n get arrayBuffer() {\n return Effect.map(this.bytes,\n // Copy this view because Buffer views may share a larger ArrayBuffer.\n bytes => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));\n }\n get upgrade() {\n return Effect.fail(requestParseError(this, \"Not an upgradeable ServerRequest\"));\n }\n}\nconst getFormDataBody = request => {\n if (!HttpClientRequest.isHttpClientRequest(request.source)) {\n return undefined;\n }\n const body = request.source.body;\n if (body._tag === \"FormData\") {\n return body.formData;\n }\n if (body._tag === \"Raw\" && isFormData(body.body)) {\n return body.body;\n }\n return undefined;\n};\nconst rawBodyStream = (request, body) => {\n if (body instanceof Request) {\n return streamFromReadable(request, body.body);\n }\n if (isReadableStream(body)) {\n return streamFromReadable(request, body);\n }\n if (isBodyInit(body)) {\n return streamFromReadable(request, new Response(body).body);\n }\n return Stream.fail(requestParseError(request, \"Unsupported body type\"));\n};\nconst rawBodyBytes = (request, body) => {\n if (body instanceof Request) {\n return Effect.tryPromise({\n try: () => body.arrayBuffer().then(buffer => new Uint8Array(buffer)),\n catch: cause => requestParseError(request, undefined, cause)\n });\n }\n if (isBodyInit(body)) {\n return bytesFromBodyInit(request, body);\n }\n return Effect.fail(requestParseError(request, \"Unsupported body type\"));\n};\nconst bytesFromBodyInit = (request, body) => Effect.tryPromise({\n try: () => new Response(body).arrayBuffer().then(buffer => new Uint8Array(buffer)),\n catch: cause => requestParseError(request, undefined, cause)\n});\nconst streamFromReadable = (request, body) => body ? Stream.fromReadableStream({\n evaluate: () => body,\n onError: cause => requestParseError(request, undefined, cause)\n}) : Stream.empty;\nconst requestParseError = (request, description, cause) => new HttpServerError({\n reason: new RequestParseError({\n request,\n ...(description === undefined ? undefined : {\n description\n }),\n ...(cause === undefined ? undefined : {\n cause\n })\n })\n});\nconst formDataToParts = formData => {\n const parts = [];\n for (const [key, value] of formData.entries()) {\n parts.push(typeof value === \"string\" ? new MultipartFieldPart(key, value) : new MultipartFilePart(key, value));\n }\n return parts;\n};\nclass MultipartFieldPart extends Inspectable.Class {\n [Multipart.TypeId];\n _tag = \"Field\";\n contentType = \"text/plain\";\n key;\n value;\n constructor(key, value) {\n super();\n this[Multipart.TypeId] = Multipart.TypeId;\n this.key = key;\n this.value = value;\n }\n toJSON() {\n return {\n _id: \"@effect/platform/Multipart/Part\",\n _tag: \"Field\",\n key: this.key,\n contentType: this.contentType,\n value: this.value\n };\n }\n}\nclass MultipartFilePart extends Inspectable.Class {\n [Multipart.TypeId];\n _tag = \"File\";\n key;\n name;\n contentType;\n content;\n contentEffect;\n constructor(key, file) {\n super();\n this[Multipart.TypeId] = Multipart.TypeId;\n this.key = key;\n this.name = file.name;\n this.contentType = file.type;\n this.content = Stream.fromReadableStream({\n evaluate: () => file.stream(),\n onError: cause => Multipart.MultipartError.fromReason(\"InternalError\", cause)\n });\n this.contentEffect = Effect.tryPromise({\n try: () => file.arrayBuffer().then(buffer => new Uint8Array(buffer)),\n catch: cause => Multipart.MultipartError.fromReason(\"InternalError\", cause)\n });\n }\n toJSON() {\n return {\n _id: \"@effect/platform/Multipart/Part\",\n _tag: \"File\",\n key: this.key,\n name: this.name,\n contentType: this.contentType\n };\n }\n}\nconst isReadableStream = u => typeof ReadableStream !== \"undefined\" && u instanceof ReadableStream;\nconst isFormData = u => typeof FormData !== \"undefined\" && u instanceof FormData;\nconst isBodyInit = u => typeof u === \"string\" || typeof ArrayBuffer !== \"undefined\" && (u instanceof ArrayBuffer || ArrayBuffer.isView(u)) || typeof Blob !== \"undefined\" && u instanceof Blob || isFormData(u) || typeof URLSearchParams !== \"undefined\" && u instanceof URLSearchParams || isReadableStream(u);\nconst textDecoder = /*#__PURE__*/new TextDecoder();\n/**\n * Attempts to construct an absolute `URL` for a server request safely.\n *\n * **Details**\n *\n * The host comes from the `host` header, defaulting to `localhost`, and the\n * protocol is `https` only when `x-forwarded-proto` is `https`; invalid URLs\n * return `Option.none`.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toURL = self => {\n const host = self.headers.host ?? \"localhost\";\n const protocol = self.headers[\"x-forwarded-proto\"] === \"https\" ? \"https\" : \"http\";\n try {\n return Option.some(new URL(self.url, `${protocol}://${host}`));\n } catch {\n return Option.none();\n }\n};\n/**\n * Converts an `HttpServerRequest` safely to a Web `Request` as a `Result`.\n *\n * **Details**\n *\n * If the source is already a Web `Request`, it is returned unchanged. Otherwise\n * an absolute URL is derived from the request; invalid URLs fail with a\n * `RequestParseError`.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toWebResult = (self, options) => {\n if (self.source instanceof Request) {\n return Result.succeed(self.source);\n }\n const url = toURL(self);\n if (Option.isNone(url)) {\n return Result.fail(new RequestParseError({\n request: self,\n description: \"Invalid URL\"\n }));\n }\n const requestInit = {\n method: self.method,\n headers: self.headers\n };\n if (options?.signal) {\n requestInit.signal = options.signal;\n }\n if (hasBody(self.method)) {\n requestInit.body = Stream.toReadableStreamWith(self.stream, options?.context ?? Context.empty());\n requestInit.duplex = \"half\";\n }\n return Result.succeed(new Request(url.value, requestInit));\n};\n/**\n * Converts an `HttpServerRequest` to a Web `Request` in `Effect`.\n *\n * **Details**\n *\n * The current context is used when streaming the request body into the Web\n * request.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toWeb = (self, options) => Effect.contextWith(context => Effect.fromResult(toWebResult(self, {\n context,\n signal: options?.signal\n})));\n//# sourceMappingURL=HttpServerRequest.js.map","/**\n * HTTP propagation helpers for Effect tracing context.\n *\n * This module converts Effect `Tracer.Span` values into outbound trace headers\n * and decodes inbound propagation headers into `Tracer.ExternalSpan` parents.\n * HTTP clients use it to continue the current span across outgoing requests, and\n * server middleware uses it to parent request spans from upstream services.\n *\n * @since 4.0.0\n */\nimport * as Option from \"../../Option.js\";\nimport * as Tracer from \"../../Tracer.js\";\nimport * as Headers from \"./Headers.js\";\n/**\n * Encodes a span into HTTP trace propagation headers.\n *\n * **Details**\n *\n * The generated headers include both compact B3 (`b3`) and W3C `traceparent`\n * formats.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const toHeaders = span => Headers.fromRecordUnsafe({\n b3: `${span.traceId}-${span.spanId}-${span.sampled ? \"1\" : \"0\"}${Option.match(span.parent, {\n onNone: () => \"\",\n onSome: parent => `-${parent.spanId}`\n })}`,\n traceparent: `00-${span.traceId}-${span.spanId}-${span.sampled ? \"01\" : \"00\"}`\n});\n/**\n * Decodes an external span safely from HTTP trace propagation headers.\n *\n * **Details**\n *\n * W3C `traceparent` is tried first, followed by compact B3 (`b3`) and then\n * multi-header B3 (`x-b3-*`).\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const fromHeaders = headers => {\n let span = w3c(headers);\n if (Option.isSome(span)) {\n return span;\n }\n span = b3(headers);\n if (Option.isSome(span)) {\n return span;\n }\n return xb3(headers);\n};\n/**\n * Decodes an external span safely from the compact B3 `b3` header.\n *\n * **Details**\n *\n * Returns `Option.none` when the header is missing or does not contain trace and\n * span identifiers.\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const b3 = headers => {\n if (!(\"b3\" in headers)) {\n return Option.none();\n }\n const parts = headers[\"b3\"].split(\"-\");\n if (parts.length < 2) {\n return Option.none();\n }\n return Option.some(Tracer.externalSpan({\n traceId: parts[0],\n spanId: parts[1],\n sampled: parts[2] ? parts[2] === \"1\" : true\n }));\n};\n/**\n * Decodes an external span safely from multi-header B3 propagation headers.\n *\n * **Details**\n *\n * The decoder reads `x-b3-traceid`, `x-b3-spanid`, and optional `x-b3-sampled`\n * headers.\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const xb3 = headers => {\n if (!headers[\"x-b3-traceid\"] || !headers[\"x-b3-spanid\"]) {\n return Option.none();\n }\n return Option.some(Tracer.externalSpan({\n traceId: headers[\"x-b3-traceid\"],\n spanId: headers[\"x-b3-spanid\"],\n sampled: headers[\"x-b3-sampled\"] ? headers[\"x-b3-sampled\"] === \"1\" : true\n }));\n};\nconst w3cTraceId = /^[0-9a-f]{32}$/i;\nconst w3cSpanId = /^[0-9a-f]{16}$/i;\n/**\n * Decodes an external span safely from the W3C `traceparent` header.\n *\n * **Details**\n *\n * Only version `00` headers with valid trace and span identifiers are accepted.\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const w3c = headers => {\n if (!headers[\"traceparent\"]) {\n return Option.none();\n }\n const parts = headers[\"traceparent\"].split(\"-\");\n if (parts.length !== 4) {\n return Option.none();\n }\n const [version, traceId, spanId, flags] = parts;\n switch (version) {\n case \"00\":\n {\n if (w3cTraceId.test(traceId) === false || w3cSpanId.test(spanId) === false) {\n return Option.none();\n }\n return Option.some(Tracer.externalSpan({\n traceId,\n spanId,\n sampled: (parseInt(flags, 16) & 1) === 1\n }));\n }\n default:\n {\n return Option.none();\n }\n }\n};\n//# sourceMappingURL=HttpTraceContext.js.map","/**\n * Wraps HTTP server apps with request and response behavior.\n *\n * A middleware is a function from one HTTP server app effect to another. The app\n * runs with the current `HttpServerRequest` in its context, so middleware can\n * inspect or rewrite the request, provide request-scoped services, attach hooks\n * before the response is sent, or observe the app exit. This module includes\n * middleware for response logging, server tracing, forwarded proxy headers,\n * parsed search parameters, and CORS response headers.\n *\n * @since 4.0.0\n */\nimport { Clock } from \"../../Clock.js\";\nimport * as Context from \"../../Context.js\";\nimport * as Effect from \"../../Effect.js\";\nimport * as Exit from \"../../Exit.js\";\nimport { constant, constFalse } from \"../../Function.js\";\nimport * as internalEffect from \"../../internal/effect.js\";\nimport * as Layer from \"../../Layer.js\";\nimport * as Option from \"../../Option.js\";\nimport { nativeTracer, ParentSpan, Tracer } from \"../../Tracer.js\";\nimport * as Headers from \"./Headers.js\";\nimport { HttpPlatform } from \"./HttpPlatform.js\";\nimport { causeResponseStripped } from \"./HttpServerError.js\";\nimport { HttpServerRequest } from \"./HttpServerRequest.js\";\nimport * as Request from \"./HttpServerRequest.js\";\nimport * as Response from \"./HttpServerResponse.js\";\nimport * as TraceContext from \"./HttpTraceContext.js\";\nimport * as compressionInternal from \"./internal/compression.js\";\nimport * as bodyInternal from \"./internal/httpBody.js\";\nimport { appendPreResponseHandlerUnsafe } from \"./internal/preResponseHandler.js\";\n/**\n * Defines an `HttpMiddleware` while preserving its precise type.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = middleware => middleware;\nconst loggerDisabledRequests = /*#__PURE__*/new WeakSet();\nconst stripSearchAndHash = url => {\n const queryIndex = url.indexOf(\"?\");\n const hashIndex = url.indexOf(\"#\");\n if (queryIndex === -1) {\n return hashIndex === -1 ? url : url.slice(0, hashIndex);\n }\n if (hashIndex === -1) {\n return url.slice(0, queryIndex);\n }\n return url.slice(0, Math.min(queryIndex, hashIndex));\n};\n/**\n * Runs an effect with HTTP response logging disabled for the current server request.\n *\n * @category logging\n * @since 4.0.0\n */\nexport const withLoggerDisabled = self => Effect.withFiber(fiber => {\n const request = Context.getUnsafe(fiber.context, HttpServerRequest);\n loggerDisabledRequests.add(request.source);\n return self;\n});\n/**\n * Context reference for a predicate that disables server-side tracing for matching requests.\n *\n * @category services\n * @since 4.0.0\n */\nexport const TracerDisabledWhen = /*#__PURE__*/Context.Reference(\"effect/http/HttpMiddleware/TracerDisabledWhen\", {\n defaultValue: () => constFalse\n});\n/**\n * Creates a layer that disables server-side tracing for requests whose URL exactly matches one of the supplied URLs.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layerTracerDisabledForUrls = urls => Layer.succeed(TracerDisabledWhen)(req => urls.includes(req.url));\n/**\n * Context reference for generating server span names from HTTP server requests.\n *\n * @category services\n * @since 4.0.0\n */\nexport const SpanNameGenerator = /*#__PURE__*/Context.Reference(\"@effect/platform/HttpMiddleware/SpanNameGenerator\", {\n defaultValue: () => request => `http.server ${request.method}`\n});\n/**\n * Middleware that logs sent HTTP responses with request method, request URL, and response status annotations.\n *\n * @category logging\n * @since 4.0.0\n */\nexport const logger = /*#__PURE__*/make(httpApp => Effect.withFiber(fiber => {\n const request = Context.getUnsafe(fiber.context, HttpServerRequest);\n const path = stripSearchAndHash(request.url);\n return Effect.withLogSpan(Effect.flatMap(Effect.exit(httpApp), exit => {\n if (loggerDisabledRequests.has(request.source)) {\n return exit;\n } else if (exit._tag === \"Failure\") {\n const [response, cause] = causeResponseStripped(exit.cause);\n return Effect.andThen(Effect.annotateLogs(Effect.log(Option.getOrElse(cause, () => \"Sent HTTP Response\")), {\n \"http.method\": request.method,\n \"http.url\": path,\n \"http.status\": response.status\n }), exit);\n }\n return Effect.andThen(Effect.annotateLogs(Effect.log(\"Sent HTTP response\"), {\n \"http.method\": request.method,\n \"http.url\": path,\n \"http.status\": exit.value.status\n }), exit);\n }), \"http.span\");\n}));\n/** @internal */\nexport const isTracerDisabledUnsafe = (fiber, request) => !fiber.cache.tracerEnabled || fiber.getRef(TracerDisabledWhen)(request);\n/**\n * Middleware that creates a server trace span for each request and records request and response HTTP attributes.\n *\n * @category tracing\n * @since 4.0.0\n */\nexport const tracer = /*#__PURE__*/make(httpApp => Effect.withFiber(fiber => {\n const request = Context.getUnsafe(fiber.context, HttpServerRequest);\n if (isTracerDisabledUnsafe(fiber, request)) {\n return httpApp;\n }\n const nameGenerator = fiber.getRef(SpanNameGenerator);\n const span = internalEffect.makeSpanUnsafe(fiber, nameGenerator(request), {\n parent: Option.getOrUndefined(TraceContext.fromHeaders(request.headers)),\n kind: \"server\"\n });\n const prevServices = fiber.context;\n fiber.setContext(Context.add(fiber.context, ParentSpan, span));\n return Effect.onExitPrimitive(httpApp, exit => {\n fiber.setContext(prevServices);\n const endTime = fiber.getRef(Clock).currentTimeNanosUnsafe();\n if (Exit.isSuccess(exit) && (!span.sampled || fiber.getRef(Tracer) === nativeTracer)) {\n span.end(endTime, exit);\n return undefined;\n }\n const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames);\n fiber.currentDispatcher.scheduleTask(() => {\n let response;\n let spanExit = exit;\n if (Exit.isFailure(exit)) {\n const [failureResponse, cause] = causeResponseStripped(exit.cause);\n response = failureResponse;\n spanExit = Option.isSome(cause) ? Exit.failCause(cause.value) : Exit.succeed(response);\n } else {\n response = exit.value;\n }\n if (span.sampled) {\n span.attribute(\"http.request.method\", request.method);\n if (request.url.startsWith(\"/\")) {\n const host = request.headers.host ?? \"localhost\";\n const protocol = request.headers[\"x-forwarded-proto\"] === \"https\" ? \"https\" : \"http\";\n span.attribute(\"url.full\", `${protocol}://${host}${request.url}`);\n const queryIndex = request.url.indexOf(\"?\");\n if (queryIndex === -1) {\n span.attribute(\"url.path\", request.url);\n } else {\n span.attribute(\"url.path\", request.url.slice(0, queryIndex));\n if (queryIndex < request.url.length - 1) {\n span.attribute(\"url.query\", request.url.slice(queryIndex + 1));\n }\n }\n span.attribute(\"url.scheme\", protocol);\n } else {\n const url = Request.toURL(request);\n if (Option.isSome(url)) {\n if (url.value.username !== \"\" || url.value.password !== \"\") {\n url.value.username = \"REDACTED\";\n url.value.password = \"REDACTED\";\n }\n span.attribute(\"url.full\", url.value.toString());\n span.attribute(\"url.path\", url.value.pathname);\n const query = url.value.search.slice(1);\n if (query !== \"\") {\n span.attribute(\"url.query\", query);\n }\n span.attribute(\"url.scheme\", url.value.protocol.slice(0, -1));\n }\n }\n if (request.headers[\"user-agent\"] !== undefined) {\n span.attribute(\"user_agent.original\", request.headers[\"user-agent\"]);\n }\n for (const name in request.headers) {\n span.attribute(`http.request.header.${name}`, Headers.isRedactedName(name, redactedHeaderNames) ? \"\" : request.headers[name]);\n }\n if (Option.isSome(request.remoteAddress)) {\n span.attribute(\"client.address\", request.remoteAddress.value);\n }\n span.attribute(\"http.response.status_code\", response.status);\n for (const name in response.headers) {\n span.attribute(`http.response.header.${name}`, Headers.isRedactedName(name, redactedHeaderNames) ? \"\" : response.headers[name]);\n }\n }\n span.end(endTime, spanExit);\n }, 0);\n return undefined;\n }, true);\n}));\n/**\n * Middleware that trusts `X-Forwarded-Host` and `X-Forwarded-For`, updating the request host header and remote address.\n *\n * @category proxying\n * @since 4.0.0\n */\nexport const xForwardedHeaders = /*#__PURE__*/make(httpApp => Effect.updateService(httpApp, HttpServerRequest, request => request.headers[\"x-forwarded-host\"] ? request.modify({\n headers: Headers.set(request.headers, \"host\", request.headers[\"x-forwarded-host\"]),\n remoteAddress: Option.fromNullishOr(request.headers[\"x-forwarded-for\"]?.split(\",\")[0].trim())\n}) : request));\n/**\n * Middleware that parses the current request URL's search parameters and provides them as `ParsedSearchParams`.\n *\n * @category parsing\n * @since 4.0.0\n */\nexport const searchParamsParser = httpApp => Effect.withFiber(fiber => {\n const services = fiber.context;\n const request = Context.getUnsafe(services, HttpServerRequest);\n const params = Request.searchParamsFromURL(new URL(request.originalUrl));\n return Effect.provideService(httpApp, Request.ParsedSearchParams, params);\n});\n/**\n * Middleware that handles CORS preflight requests and adds configured CORS headers to HTTP responses.\n *\n * @category middleware\n * @since 4.0.0\n */\nexport const cors = options => {\n const opts = {\n allowedOrigins: options?.allowedOrigins ?? [],\n allowedMethods: options?.allowedMethods ?? [\"GET\", \"HEAD\", \"PUT\", \"PATCH\", \"POST\", \"DELETE\"],\n allowedHeaders: options?.allowedHeaders ?? [],\n exposedHeaders: options?.exposedHeaders ?? [],\n credentials: options?.credentials ?? false,\n maxAge: options?.maxAge\n };\n const isAllowedOrigin = typeof opts.allowedOrigins === \"function\" ? opts.allowedOrigins : origin => opts.allowedOrigins.includes(origin);\n const allowOrigin = typeof opts.allowedOrigins === \"function\" || opts.allowedOrigins.length > 1 ? originHeader => {\n if (!isAllowedOrigin(originHeader)) return {\n vary: \"Origin\"\n };\n return {\n \"access-control-allow-origin\": originHeader,\n vary: \"Origin\"\n };\n } : opts.allowedOrigins.length === 0 ? constant({\n \"access-control-allow-origin\": \"*\"\n }) : constant({\n \"access-control-allow-origin\": opts.allowedOrigins[0],\n vary: \"Origin\"\n });\n const allowMethods = opts.allowedMethods.length > 0 ? {\n \"access-control-allow-methods\": opts.allowedMethods.join(\", \")\n } : undefined;\n const allowCredentials = opts.credentials ? {\n \"access-control-allow-credentials\": \"true\"\n } : undefined;\n const allowHeaders = accessControlRequestHeaders => {\n if (opts.allowedHeaders.length === 0 && accessControlRequestHeaders) {\n return {\n vary: \"Access-Control-Request-Headers\",\n \"access-control-allow-headers\": accessControlRequestHeaders\n };\n }\n if (opts.allowedHeaders) {\n return {\n \"access-control-allow-headers\": opts.allowedHeaders.join(\",\")\n };\n }\n return undefined;\n };\n const exposeHeaders = opts.exposedHeaders.length > 0 ? {\n \"access-control-expose-headers\": opts.exposedHeaders.join(\",\")\n } : undefined;\n const maxAge = opts.maxAge ? {\n \"access-control-max-age\": opts.maxAge.toString()\n } : undefined;\n const headersFromRequest = request => {\n const origin = request.headers[\"origin\"];\n return Headers.fromRecordUnsafe({\n ...allowOrigin(origin),\n ...allowCredentials,\n ...exposeHeaders\n });\n };\n const headersFromRequestOptions = request => {\n const origin = request.headers[\"origin\"];\n const accessControlRequestHeaders = request.headers[\"access-control-request-headers\"];\n const headers = Headers.fromRecordUnsafe({\n ...allowOrigin(origin),\n ...allowCredentials,\n ...exposeHeaders,\n ...allowMethods,\n ...maxAge\n });\n const accessControlHeaders = allowHeaders(accessControlRequestHeaders);\n if (accessControlHeaders === undefined) return headers;\n const vary = accessControlHeaders[\"vary\"];\n return Headers.setAll(headers, vary === undefined ? accessControlHeaders : {\n ...accessControlHeaders,\n vary: compressionInternal.varyWith(headers, vary)\n });\n };\n const preResponseHandler = (request, response) => {\n const headers = headersFromRequest(request);\n return Effect.succeed(Response.setHeaders(response, headers[\"vary\"] === undefined ? headers : Headers.set(headers, \"vary\", compressionInternal.varyWith(response.headers, \"Origin\"))));\n };\n return httpApp => Effect.withFiber(fiber => {\n const request = Context.getUnsafe(fiber.context, HttpServerRequest);\n if (request.method === \"OPTIONS\") {\n return Effect.succeed(Response.empty({\n status: 204,\n headers: headersFromRequestOptions(request)\n }));\n }\n appendPreResponseHandlerUnsafe(request, preResponseHandler);\n return httpApp;\n });\n};\n/**\n * Middleware that compresses HTTP response bodies based on the request's\n * `Accept-Encoding` header.\n *\n * **Details**\n *\n * Content negotiation follows RFC 9110: the first algorithm in server\n * preference order that the client accepts with a positive q-value and the\n * platform supports is used. When no algorithm is acceptable the response is\n * sent uncompressed.\n *\n * The body transform is performed by the `HttpPlatform` service.\n *\n * Responses are skipped when the status is 1xx, 204, 206, or 304, when a\n * `Content-Encoding` is already present, when `Cache-Control: no-transform`\n * is set, when the content type is absent or not compressible, when a known\n * body length is below `minSize`, or when the body is empty or `FormData`. A\n * response carrying `Content-Encoding: identity` opts out of compression and\n * has the header stripped before sending.\n *\n * `Vary: Accept-Encoding` is set on every response that was eligible by\n * status and content type, including ones skipped by negotiation or\n * `minSize`.\n *\n * Do not combine this middleware with Deno's automatic response compression.\n * On edge runtimes that already apply automatic compression, the middleware\n * is unnecessary. Platforms backed by Web `CompressionStream` also cannot\n * explicitly flush each input chunk, so incremental delivery depends on the\n * runtime's implementation.\n *\n * **Gotchas**\n *\n * Compression can expose secrets through BREACH-style attacks when one\n * response contains both secret data and attacker-controlled input and an\n * attacker can observe the compressed response length. For affected routes,\n * disable compression with `Content-Encoding: identity` or\n * `Cache-Control: no-transform`, or use `compressible` to restrict which\n * response content types can be compressed.\n *\n * @category compression\n * @since 4.0.0\n */\nexport const compression = options => {\n const preferred = options?.algorithms ?? defaultAlgorithms;\n const minSize = options?.minSize ?? 1024;\n const compressible = options?.compressible ?? compressionInternal.defaultCompressible;\n const levels = {\n ...defaultLevels,\n ...options?.levels\n };\n const levelOptions = {\n gzip: {\n level: levels.gzip\n },\n deflate: {\n level: levels.deflate\n },\n br: {\n level: levels.br\n },\n zstd: {\n level: levels.zstd\n }\n };\n const transform = (compression, acceptEncoding, response) => {\n if (response.status < 200 || response.status === 204 || response.status === 206 || response.status === 304) {\n return Effect.succeed(response);\n }\n const currentEncoding = response.headers[\"content-encoding\"];\n if (currentEncoding !== undefined) {\n return Effect.succeed(currentEncoding.trim().toLowerCase() === \"identity\" ? Response.removeHeader(response, \"content-encoding\") : response);\n }\n const body = response.body;\n if (body._tag === \"Empty\" || body._tag === \"FormData\") {\n return Effect.succeed(response);\n }\n const cacheControl = response.headers[\"cache-control\"];\n if (cacheControl !== undefined && noTransformRegex.test(cacheControl)) {\n return Effect.succeed(response);\n }\n const contentType = response.headers[\"content-type\"] ?? body.contentType;\n if (contentType === undefined || !compressible(contentType)) {\n return Effect.succeed(response);\n }\n const algorithm = compressionInternal.negotiate(acceptEncoding, preferred, compression.algorithms);\n if (algorithm === undefined) {\n return Effect.succeed(withVary(response));\n }\n const contentLength = body.contentLength ?? bodyInternal.parseContentLength(response.headers[\"content-length\"]);\n if (contentLength !== undefined && contentLength < minSize) {\n return Effect.succeed(withVary(response));\n }\n return compression.compressResponse(response, algorithm, levelOptions[algorithm]);\n };\n return httpApp => Effect.withFiber(fiber => {\n const request = Context.getUnsafe(fiber.context, HttpServerRequest);\n const compression = Context.getUnsafe(fiber.context, HttpPlatform).compression;\n appendPreResponseHandlerUnsafe(request, (request, response) => transform(compression, request.headers[\"accept-encoding\"], response));\n return httpApp;\n });\n};\nconst withVary = response => {\n const vary = compressionInternal.varyWith(response.headers, \"Accept-Encoding\");\n return Response.setHeader(response, \"vary\", vary);\n};\nconst defaultAlgorithms = [\"br\", \"gzip\", \"deflate\"];\nconst defaultLevels = {\n gzip: 6,\n deflate: 6,\n br: 4,\n zstd: 3\n};\nconst noTransformRegex = /(?:^|[\\s,])no-transform(?:$|[\\s,;])/i;\n//# sourceMappingURL=HttpMiddleware.js.map","import * as Cause from \"../../Cause.js\";\nimport { Clock } from \"../../Clock.js\";\nimport * as Context from \"../../Context.js\";\nimport * as Duration from \"../../Duration.js\";\nimport * as Effect from \"../../Effect.js\";\nimport * as Fiber from \"../../Fiber.js\";\nimport { constant, constFalse, constTrue, dual, flow, identity } from \"../../Function.js\";\nimport * as Inspectable from \"../../Inspectable.js\";\nimport * as Layer from \"../../Layer.js\";\nimport * as Option from \"../../Option.js\";\nimport { pipeArguments } from \"../../Pipeable.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as Ref from \"../../Ref.js\";\nimport * as Result from \"../../Result.js\";\nimport * as Schedule from \"../../Schedule.js\";\nimport * as Stream from \"../../Stream.js\";\nimport * as Tracer from \"../../Tracer.js\";\nimport * as Cookies from \"./Cookies.js\";\nimport * as Headers from \"./Headers.js\";\nimport * as HttpBody from \"./HttpBody.js\";\nimport * as Error from \"./HttpClientError.js\";\nimport * as HttpClientRequest from \"./HttpClientRequest.js\";\nimport * as HttpClientResponse from \"./HttpClientResponse.js\";\nimport * as HttpIncomingMessage from \"./HttpIncomingMessage.js\";\nimport * as HttpMethod from \"./HttpMethod.js\";\nimport * as TraceContext from \"./HttpTraceContext.js\";\nimport * as Url from \"./Url.js\";\nconst TypeId = \"~effect/http/HttpClient\";\n/**\n * Returns `true` if the provided value is an `HttpClient`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpClient = u => Predicate.hasProperty(u, TypeId);\n/**\n * Service tag for the default outgoing HTTP client service.\n *\n * **When to use**\n *\n * Use to provide the default outgoing HTTP client service used by request\n * accessors such as `execute`, `get`, and `post`.\n *\n * @category services\n * @since 4.0.0\n */\nexport const HttpClient = /*#__PURE__*/Context.Service(\"effect/HttpClient\");\nconst accessor = method => (...args) => Effect.flatMap(HttpClient, client => client[method](...args));\n/**\n * Executes a prebuilt `HttpClientRequest` using the `HttpClient` service from the environment.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const execute = /*#__PURE__*/accessor(\"execute\");\n/**\n * Executes a `GET` request using the `HttpClient` service from the environment.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const get = /*#__PURE__*/accessor(\"get\");\n/**\n * Executes a `HEAD` request using the `HttpClient` service from the environment.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const head = /*#__PURE__*/accessor(\"head\");\n/**\n * Executes a `POST` request using the `HttpClient` service from the environment.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const post = /*#__PURE__*/accessor(\"post\");\n/**\n * Executes a `PATCH` request using the `HttpClient` service from the environment.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const patch = /*#__PURE__*/accessor(\"patch\");\n/**\n * Executes a `PUT` request using the `HttpClient` service from the environment.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const put = /*#__PURE__*/accessor(\"put\");\n/**\n * Executes a `DELETE` request using the `HttpClient` service from the environment.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const del = /*#__PURE__*/accessor(\"del\");\n/**\n * Executes an `OPTIONS` request using the `HttpClient` service from the environment.\n *\n * @category accessors\n * @since 4.0.0\n */\nexport const options = /*#__PURE__*/accessor(\"options\");\n/**\n * Transforms a client by wrapping the response effect for each request.\n *\n * **Details**\n *\n * The transformation receives both the response effect and the original request, allowing it to change success, error, and environment behavior.\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const transform = /*#__PURE__*/dual(2, (self, f) => makeWith(Effect.flatMap(request => f(self.postprocess(Effect.succeed(request)), request)), self.preprocess));\n/**\n * Transforms a client by applying an effectful transformation to each response effect.\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const transformResponse = /*#__PURE__*/dual(2, (self, f) => makeWith(request => f(self.postprocess(request)), self.preprocess));\nconst catch_ = /*#__PURE__*/dual(2, (self, f) => transformResponse(self, Effect.catch(f)));\nexport {\n/**\n * Handles all client failures with an effectful recovery function and returns a transformed client.\n *\n * @category error handling\n * @since 4.0.0\n */\ncatch_ as catch };\n/**\n * Handles client failures with one or more matching `_tag` values and returns a transformed client.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchTag = /*#__PURE__*/dual(3, (self, tag, f) => transformResponse(self, effect => Effect.catchTag(effect, tag, f)));\n/**\n * Handles client failures by matching their `_tag` values against a case map.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const catchTags = /*#__PURE__*/dual(2, (self, cases) => transformResponse(self, Effect.catchTags(cases)));\n/**\n * Filters the result of a response, or runs an alternative effect if the predicate fails.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterOrElse = /*#__PURE__*/dual(3, (self, f, orElse) => transformResponse(self, Effect.filterOrElse(f, orElse)));\n/**\n * Filters successful responses, or fails with the error produced by `orFailWith` when the predicate does not match.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterOrFail = /*#__PURE__*/dual(3, (self, f, orFailWith) => transformResponse(self, Effect.filterOrFail(f, orFailWith)));\n/**\n * Filters responses by HTTP status code.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterStatus = /*#__PURE__*/dual(2, (self, f) => transformResponse(self, Effect.flatMap(HttpClientResponse.filterStatus(f))));\n/**\n * Filters responses that return a 2xx status code.\n *\n * @category filtering\n * @since 4.0.0\n */\nexport const filterStatusOk = /*#__PURE__*/transformResponse(/*#__PURE__*/Effect.flatMap(HttpClientResponse.filterStatusOk));\n/**\n * Constructs an `HttpClient.With` from a preprocessing function and a postprocessing function.\n *\n * **Details**\n *\n * `execute` applies preprocessing to the request and then passes the resulting request effect to postprocessing.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeWith = (postprocess, preprocess) => {\n const self = Object.create(Proto);\n self.preprocess = preprocess;\n self.postprocess = postprocess;\n self.execute = function (request) {\n return postprocess(preprocess(request));\n };\n return self;\n};\nconst Proto = {\n [TypeId]: TypeId,\n pipe() {\n return pipeArguments(this, arguments);\n },\n ...Inspectable.BaseProto,\n toJSON() {\n return {\n _id: \"effect/HttpClient\"\n };\n },\n ... /*#__PURE__*/Object.fromEntries(/*#__PURE__*/HttpMethod.allShort.map(([fullMethod, method]) => [method, function (url, options) {\n return this.execute(HttpClientRequest.make(fullMethod)(url, options));\n }]))\n};\n/**\n * Constructs an `HttpClient` from a low-level request runner.\n *\n * **Details**\n *\n * The runner receives the request, resolved URL, abort signal, and current fiber. The client wrapper handles URL construction failures, tracing and propagation, header redaction, and aborting non-scoped requests on interruption.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = f => makeWith(effect => Effect.flatMap(effect, request => Effect.withFiber(fiber => {\n const scopedController = scopedRequests.get(request);\n const controller = scopedController ?? new AbortController();\n const urlResult = Url.make(request.url, request.urlParams, Option.getOrUndefined(request.hash));\n if (Result.isFailure(urlResult)) {\n return Effect.fail(new Error.HttpClientError({\n reason: new Error.InvalidUrlError({\n request,\n cause: urlResult.failure\n })\n }));\n }\n const url = urlResult.success;\n const tracerDisabled = fiber.getRef(Tracer.DisablePropagation) || fiber.getRef(TracerDisabledWhen)(request);\n if (tracerDisabled) {\n const effect = f(request, url, controller.signal, fiber);\n if (scopedController) return effect;\n return Effect.uninterruptibleMask(restore => Effect.matchCauseEffect(restore(effect), {\n onSuccess(response) {\n responseRegistry.register(response, controller);\n return Effect.succeed(new InterruptibleResponse(response, controller));\n },\n onFailure(cause) {\n if (Cause.hasInterrupts(cause)) {\n controller.abort();\n }\n return Effect.failCause(cause);\n }\n }));\n }\n return Effect.useSpan(fiber.getRef(SpanNameGenerator)(request), {\n kind: \"client\"\n }, span => {\n span.attribute(\"http.request.method\", request.method);\n span.attribute(\"server.address\", url.origin);\n if (url.port !== \"\") {\n span.attribute(\"server.port\", +url.port);\n }\n span.attribute(\"url.full\", url.toString());\n span.attribute(\"url.path\", url.pathname);\n span.attribute(\"url.scheme\", url.protocol.slice(0, -1));\n const query = url.search.slice(1);\n if (query !== \"\") {\n span.attribute(\"url.query\", query);\n }\n const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames);\n const headerFilter = fiber.getRef(TracerHeaderFilter);\n for (const name in request.headers) {\n if (!headerFilter(name, \"request\")) continue;\n span.attribute(`http.request.header.${name}`, Headers.isRedactedName(name, redactedHeaderNames) ? \"\" : request.headers[name]);\n }\n request = fiber.getRef(TracerPropagationEnabled) ? HttpClientRequest.setHeaders(request, TraceContext.toHeaders(span)) : request;\n return Effect.uninterruptibleMask(restore => restore(f(request, url, controller.signal, fiber)).pipe(Effect.withParentSpan(span, {\n captureStackTrace: false\n }), Effect.matchCauseEffect({\n onSuccess: response => {\n span.attribute(\"http.response.status_code\", response.status);\n for (const name in response.headers) {\n if (!headerFilter(name, \"response\")) continue;\n span.attribute(`http.response.header.${name}`, Headers.isRedactedName(name, redactedHeaderNames) ? \"\" : response.headers[name]);\n }\n if (scopedController) return Effect.succeed(response);\n responseRegistry.register(response, controller);\n return Effect.succeed(new InterruptibleResponse(response, controller));\n },\n onFailure(cause) {\n if (!scopedController && Cause.hasInterrupts(cause)) {\n controller.abort();\n }\n return Effect.failCause(cause);\n }\n })));\n });\n})), Effect.succeed);\n/**\n * Appends a transformation of the request object before sending it.\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapRequest = /*#__PURE__*/dual(2, (self, f) => makeWith(self.postprocess, request => Effect.map(self.preprocess(request), f)));\n/**\n * Appends an effectful transformation of the request object before sending it.\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapRequestEffect = /*#__PURE__*/dual(2, (self, f) => makeWith(self.postprocess, request => Effect.flatMap(self.preprocess(request), f)));\n/**\n * Prepends a transformation of the request object before sending it.\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapRequestInput = /*#__PURE__*/dual(2, (self, f) => makeWith(self.postprocess, request => self.preprocess(f(request))));\n/**\n * Prepends an effectful transformation of the request object before sending it.\n *\n * @category mapping\n * @since 4.0.0\n */\nexport const mapRequestInputEffect = /*#__PURE__*/dual(2, (self, f) => makeWith(self.postprocess, request => Effect.flatMap(f(request), self.preprocess)));\n/**\n * Retries the request based on a provided schedule or policy.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const retry = /*#__PURE__*/dual(2, (self, policy) => transformResponse(self, Effect.retry(policy)));\n/**\n * Retries common transient errors, such as rate limiting, timeouts or network issues.\n *\n * **When to use**\n *\n * Use to focus on retrying errors, transient responses, or both.\n *\n * **Details**\n *\n * Specifying a `while` predicate allows you to consider other errors as\n * transient, and is ignored in \"response-only\" mode.\n *\n * @category error handling\n * @since 4.0.0\n */\nexport const retryTransient = /*#__PURE__*/dual(2, (self, options) => {\n const isOnlySchedule = Schedule.isSchedule(options);\n const retryOn = isOnlySchedule ? \"errors-and-responses\" : options.retryOn ?? \"errors-and-responses\";\n const schedule = isOnlySchedule ? options : options.schedule;\n const passthroughSchedule = schedule && Schedule.passthrough(schedule);\n const times = isOnlySchedule ? undefined : options.times;\n return transformResponse(self, flow(retryOn === \"errors-only\" ? identity : Effect.repeat({\n schedule: passthroughSchedule,\n times,\n while: isTransientResponse\n }), retryOn === \"response-only\" ? identity : Effect.retry({\n while: isOnlySchedule || options.while === undefined ? isTransientError : Predicate.or(isTransientError, options.while),\n schedule,\n times\n })));\n});\n/**\n * Applies request rate limiting using the `RateLimiter` service.\n *\n * **Details**\n *\n * It can update limits by inspecting common rate limit response headers and\n * automatically retries HTTP `429` responses (or `HttpClientError` values\n * wrapping a `429` response) by forcing the retry back through the limiter.\n *\n * **Gotchas**\n *\n * Automatic HTTP `429` retries are unlimited unless `times` is specified.\n * Disabling response inspection does not disable retries; set `times` to `0`\n * to return or fail with the first `429`.\n *\n * @category rate limiting\n * @since 4.0.0\n */\nexport const withRateLimiter = /*#__PURE__*/dual(2, (self, options) => {\n const initialState = {\n initial: true,\n limit: options.limit,\n window: Duration.max(Duration.fromInputUnsafe(options.window), Duration.millis(1))\n };\n const states = new Map();\n const keyOption = options.key;\n const resolveKey = typeof keyOption === \"function\" ? keyOption : constant(keyOption);\n const tokensOption = options.tokens;\n const resolveTokens = typeof tokensOption === \"function\" ? tokensOption : constant(tokensOption ?? 1);\n const adaptiveLearningEnabled = !options.disableAdaptiveLearning;\n const headerNames = resolveRateLimiterHeaderNames(options.responseHeaders);\n const getState = key => {\n const current = states.get(key);\n if (current !== undefined) {\n return current;\n }\n states.set(key, initialState);\n return initialState;\n };\n const onResponse = options.disableResponseInspection ? undefined : (clock, key, headers, tokens) => {\n const current = getState(key);\n const next = parseRateLimiterState(current, clock, headers, tokens, headerNames);\n if (next.limit !== current.limit || !Duration.equals(next.window, current.window)) {\n states.set(key, next);\n }\n };\n return transform(self, function loop(effect, request, retries = 0) {\n const fiber = Fiber.getCurrent();\n const clock = fiber.getRef(Clock);\n const key = resolveKey(request);\n const tokens = Math.max(resolveTokens(request), 1);\n const current = getState(key);\n const canRetry = options.times === undefined || retries < options.times;\n function retry(retryAfter) {\n return retryAfter ? Effect.flatMap(Effect.sleep(retryAfter), () => loop(effect, request, retries + 1)) : loop(effect, request, retries + 1);\n }\n const inspectResponse = (response, adaptive) => {\n onResponse?.(clock, key, response.headers, tokens);\n if (options.disableResponseInspection || response.status !== 429) {\n return Effect.succeed(undefined);\n }\n const retryAfter = parseRetryAfter(clock, getHeader(response.headers, ...headerNames.retryAfter));\n if (retryAfter === undefined) {\n return Effect.succeed(undefined);\n }\n const delay = parseRateLimitWindow(clock, response.headers, headerNames) ?? retryAfter;\n if (adaptive === undefined) {\n return Effect.succeed(delay);\n }\n return Effect.as(options.limiter.adaptiveFeedback({\n key,\n epoch: adaptive.epoch,\n tokens,\n status: response.status,\n retryAfter: delay\n }), delay);\n };\n return Effect.flatMap(options.limiter.consume({\n algorithm: options.algorithm,\n onExceeded: \"delay\",\n key,\n limit: current.limit,\n window: current.window,\n tokens\n }), ({\n delay\n }) => {\n const runAdaptive = () => {\n const runRequest = adaptive => {\n const request = Effect.matchEffect(effect, {\n onSuccess(response) {\n return Effect.flatMap(inspectResponse(response, adaptive), retryAfter => {\n if (response.status !== 429 || !canRetry) return Effect.succeed(response);\n return retry(retryAfter);\n });\n },\n onFailure(error) {\n if (isTooManyRequestsHttpClientError(error)) {\n return Effect.flatMap(inspectResponse(error.reason.response, adaptive), retryAfter => canRetry ? retry(retryAfter) : Effect.fail(error));\n }\n return Effect.fail(error);\n }\n });\n return adaptive === undefined || Duration.isZero(adaptive.delay) ? request : Effect.delay(request, adaptive.delay);\n };\n if (!adaptiveLearningEnabled) {\n return runRequest(undefined);\n }\n return Effect.flatMap(options.limiter.adaptiveConsume({\n key,\n tokens,\n fallbackLimit: current.limit,\n fallbackWindow: current.window\n }), adaptive => {\n if (!Duration.isZero(adaptive.delay) && adaptive.phase === \"cooldown\") {\n return Effect.flatMap(Effect.sleep(adaptive.delay), runAdaptive);\n }\n return runRequest(adaptive);\n });\n };\n return Duration.isZero(delay) ? runAdaptive() : Effect.flatMap(Effect.sleep(delay), runAdaptive);\n });\n });\n});\nconst resolveRateLimiterHeaderNames = responseHeaders => ({\n limit: responseHeaders?.limit === undefined ? [\"ratelimit-limit\", \"x-ratelimit-limit\"] : [responseHeaders.limit.toLowerCase()],\n remaining: responseHeaders?.remaining === undefined ? [\"ratelimit-remaining\", \"x-ratelimit-remaining\"] : [responseHeaders.remaining.toLowerCase()],\n reset: responseHeaders?.reset === undefined ? [\"ratelimit-reset\", \"x-ratelimit-reset\"] : [responseHeaders.reset.toLowerCase()],\n resetAfter: responseHeaders?.resetAfter === undefined ? [\"ratelimit-reset-after\", \"x-ratelimit-reset-after\"] : [responseHeaders.resetAfter.toLowerCase()],\n retryAfter: responseHeaders?.retryAfter === undefined ? [\"retry-after\"] : [responseHeaders.retryAfter.toLowerCase()]\n});\nconst parseRateLimiterState = (state, clock, headers, tokens, headerNames) => {\n const limit = parseRateLimitLimit(state, headers, tokens, headerNames) ?? state.limit;\n const window = parseRateLimitWindow(clock, headers, headerNames) ?? state.window;\n if (limit === state.limit && Duration.equals(window, state.window)) {\n return state;\n }\n return {\n limit,\n window,\n initial: false\n };\n};\nconst parseRateLimitLimit = (state, headers, tokens, headerNames) => {\n const raw = getHeader(headers, ...headerNames.limit);\n const value = parseNumberHeader(raw);\n if (value !== undefined && value > 0) {\n return value;\n }\n const remaining = parseRateLimitRemaining(headers, headerNames);\n if (remaining === undefined) {\n return undefined;\n }\n return state.initial ? remaining + tokens : Math.max(remaining + tokens, state.limit);\n};\nconst parseRateLimitRemaining = (headers, headerNames) => {\n const raw = getHeader(headers, ...headerNames.remaining);\n const value = parseNumberHeader(raw);\n return value !== undefined && value >= 0 ? value : undefined;\n};\nconst parseRateLimitWindow = (clock, headers, headerNames) => {\n const resetAfter = parseResetAfter(getHeader(headers, ...headerNames.resetAfter));\n if (resetAfter !== undefined) {\n return resetAfter;\n }\n return parseResetHeader(clock, getHeader(headers, ...headerNames.reset));\n};\nconst parseRetryAfter = (clock, value) => {\n if (value === undefined) {\n return undefined;\n }\n const numeric = parseNumberHeader(value);\n if (numeric !== undefined) {\n return Duration.max(Duration.seconds(numeric), Duration.millis(1));\n }\n const parsedDate = Date.parse(value);\n if (Number.isNaN(parsedDate)) {\n return undefined;\n }\n const millis = parsedDate - clock.currentTimeMillisUnsafe();\n if (millis <= 0) {\n return Duration.millis(1);\n }\n return Duration.millis(millis);\n};\nconst parseResetAfter = value => {\n const numeric = parseNumberHeader(value);\n if (numeric === undefined || numeric <= 0) {\n return undefined;\n }\n return Duration.max(Duration.seconds(numeric), Duration.millis(1));\n};\nconst parseResetHeader = (clock, value) => {\n const numeric = parseNumberHeader(value);\n if (numeric === undefined || numeric <= 0) {\n return undefined;\n }\n const nowMillis = clock.currentTimeMillisUnsafe();\n if (numeric > 1_000_000_000_000) {\n return Duration.millis(Math.max(numeric - nowMillis, 1));\n }\n if (numeric > 1_000_000_000) {\n return Duration.millis(Math.max(numeric * 1_000 - nowMillis, 1));\n }\n return Duration.max(Duration.seconds(numeric), Duration.millis(1));\n};\nconst parseNumberHeader = value => {\n if (value === undefined) {\n return undefined;\n }\n const match = /-?\\d+(?:\\.\\d+)?/.exec(value);\n if (match === null) {\n return undefined;\n }\n const parsed = Number(match[0]);\n return Number.isFinite(parsed) ? parsed : undefined;\n};\nconst getHeader = (headers, ...keys) => {\n for (let i = 0; i < keys.length; i++) {\n const value = headers[keys[i]];\n if (value !== undefined) {\n return value;\n }\n }\n return undefined;\n};\n/**\n * Performs an additional effect after a successful request.\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const tap = /*#__PURE__*/dual(2, (self, f) => transformResponse(self, Effect.tap(f)));\n/**\n * Performs an additional effect after an unsuccessful request.\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const tapError = /*#__PURE__*/dual(2, (self, f) => transformResponse(self, Effect.tapError(f)));\n/**\n * Performs an additional effect on the request before sending it.\n *\n * @category sequencing\n * @since 4.0.0\n */\nexport const tapRequest = /*#__PURE__*/dual(2, (self, f) => makeWith(self.postprocess, request => Effect.tap(self.preprocess(request), f)));\n/**\n * Adds a `Ref` of cookies to the client for handling cookies across requests.\n *\n * **When to use**\n *\n * Use to add shared cookie storage to a client so response cookies are retained\n * and sent by later requests.\n *\n * @category cookies\n * @since 4.0.0\n */\nexport const withCookiesRef = /*#__PURE__*/dual(2, (self, ref) => makeWith(request => Effect.tap(self.postprocess(request), response => Ref.update(ref, cookies => Cookies.merge(cookies, response.cookies))), request => Effect.flatMap(self.preprocess(request), request => Effect.map(Ref.get(ref), cookies => Cookies.isEmpty(cookies) ? request : HttpClientRequest.setHeader(request, \"cookie\", Cookies.toCookieHeader(cookies))))));\n/**\n * Attaches the lifetime of the `HttpClientRequest` to a `Scope`.\n *\n * @category resource management\n * @since 4.0.0\n */\nexport const withScope = self => transform(self, (effect, request) => {\n const controller = new AbortController();\n scopedRequests.set(request, controller);\n return Effect.andThen(Effect.addFinalizer(() => Effect.sync(() => controller.abort())), effect);\n});\n/**\n * Enables following HTTP redirects up to a specified number of times.\n *\n * @category redirects\n * @since 4.0.0\n */\nexport const followRedirects = /*#__PURE__*/dual(args => isHttpClient(args[0]), (self, maxRedirects) => makeWith(request => {\n const loop = (request, redirects) => Effect.suspend(() => {\n let currentRequest;\n return Effect.flatMap(self.postprocess(Effect.map(request, request => {\n currentRequest = request;\n return request;\n })), response => {\n if (response.status < 300 || response.status >= 400 || !response.headers.location || redirects >= (maxRedirects ?? 10)) {\n return Effect.succeed(response);\n }\n const url = new URL(response.headers.location, response.request.url);\n const request = currentRequest ?? response.request;\n let nextRequest = request;\n if ((response.status === 301 || response.status === 302) && request.method === \"POST\" || response.status === 303 && request.method !== \"GET\" && request.method !== \"HEAD\") {\n nextRequest = HttpClientRequest.setMethod(nextRequest, \"GET\");\n nextRequest = HttpClientRequest.setBody(nextRequest, HttpBody.empty);\n }\n if (url.origin !== new URL(response.request.url).origin) {\n nextRequest = HttpClientRequest.removeHeader(nextRequest, \"authorization\");\n nextRequest = HttpClientRequest.removeHeader(nextRequest, \"proxy-authorization\");\n nextRequest = HttpClientRequest.removeHeader(nextRequest, \"cookie\");\n }\n return loop(Effect.succeed(HttpClientRequest.setUrl(nextRequest, url)), redirects + 1);\n });\n });\n return loop(request, 0);\n}, self.preprocess));\n/**\n * Context reference for a predicate that disables client-side tracing for matching outgoing requests.\n *\n * @category services\n * @since 4.0.0\n */\nexport const TracerDisabledWhen = /*#__PURE__*/Context.Reference(\"effect/http/HttpClient/TracerDisabledWhen\", {\n defaultValue: () => constFalse\n});\n/**\n * Context reference for filtering request and response headers added to client spans.\n *\n * @category services\n * @since 4.0.0\n */\nexport const TracerHeaderFilter = /*#__PURE__*/Context.Reference(\"effect/http/HttpClient/TracerHeaderFilter\", {\n defaultValue: () => constTrue\n});\n/**\n * Context reference that controls whether outgoing client spans are propagated to request headers.\n *\n * @category services\n * @since 4.0.0\n */\nexport const TracerPropagationEnabled = /*#__PURE__*/Context.Reference(\"effect/http/HttpClient/TracerPropagationEnabled\", {\n defaultValue: constTrue\n});\n/**\n * Context reference for generating the span name used for outgoing client request spans.\n *\n * @category services\n * @since 4.0.0\n */\nexport const SpanNameGenerator = /*#__PURE__*/Context.Reference(\"effect/http/HttpClient/SpanNameGenerator\", {\n defaultValue: () => request => `http.client ${request.method}`\n});\n/**\n * Creates an `HttpClient` layer and merges the layer construction context into client response effects.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layerMergedContext = effect => Layer.effect(HttpClient)(Effect.contextWith(context => Effect.map(effect, client => transformResponse(client, Effect.updateContext(input => Context.merge(context, input))))));\n// -----------------------------------------------------------------------------\n// internal\n// -----------------------------------------------------------------------------\nconst responseRegistry = /*#__PURE__*/(() => {\n if (\"FinalizationRegistry\" in globalThis && globalThis.FinalizationRegistry) {\n const registry = /*#__PURE__*/new FinalizationRegistry(controller => {\n controller.abort();\n });\n return {\n register(response, controller) {\n registry.register(response, controller, response);\n },\n unregister(response) {\n registry.unregister(response);\n }\n };\n }\n const timers = /*#__PURE__*/new Map();\n return {\n register(response, controller) {\n timers.set(response, setTimeout(() => controller.abort(), 5000));\n },\n unregister(response) {\n const timer = timers.get(response);\n if (timer === undefined) return;\n clearTimeout(timer);\n timers.delete(response);\n }\n };\n})();\nconst scopedRequests = /*#__PURE__*/new WeakMap();\nclass InterruptibleResponse {\n original;\n controller;\n constructor(original, controller) {\n this.original = original;\n this.controller = controller;\n }\n [HttpClientResponse.TypeId] = HttpClientResponse.TypeId;\n [HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId;\n applyInterrupt(effect) {\n return Effect.suspend(() => {\n responseRegistry.unregister(this.original);\n return Effect.onInterrupt(effect, () => Effect.sync(() => {\n this.controller.abort();\n }));\n });\n }\n get request() {\n return this.original.request;\n }\n get url() {\n return this.original.url;\n }\n get status() {\n return this.original.status;\n }\n get headers() {\n return this.original.headers;\n }\n get cookies() {\n return this.original.cookies;\n }\n get remoteAddress() {\n return this.original.remoteAddress;\n }\n get formData() {\n return this.applyInterrupt(this.original.formData);\n }\n get text() {\n return this.applyInterrupt(this.original.text);\n }\n get json() {\n return this.applyInterrupt(this.original.json);\n }\n get urlParamsBody() {\n return this.applyInterrupt(this.original.urlParamsBody);\n }\n get arrayBuffer() {\n return this.applyInterrupt(this.original.arrayBuffer);\n }\n get stream() {\n return Stream.suspend(() => {\n responseRegistry.unregister(this.original);\n return Stream.ensuring(this.original.stream, Effect.sync(() => {\n this.controller.abort();\n }));\n });\n }\n toJSON() {\n return this.original.toJSON();\n }\n [Inspectable.NodeInspectSymbol]() {\n return this.original[Inspectable.NodeInspectSymbol]();\n }\n pipe() {\n return pipeArguments(this, arguments);\n }\n}\nconst isTransientError = error => Cause.isTimeoutError(error) || isTransientHttpError(error);\nconst isTransientHttpError = error => Error.isHttpClientError(error) && (error.reason._tag === \"TransportError\" || error.reason._tag === \"StatusCodeError\" && isTransientResponse(error.reason.response));\nconst isTooManyRequestsHttpClientError = error => Error.isHttpClientError(error) && error.reason._tag === \"StatusCodeError\" && error.reason.response.status === 429;\nconst isTransientResponse = response => response.status === 408 || response.status === 429 || response.status === 500 || response.status === 502 || response.status === 503 || response.status === 504;\n//# sourceMappingURL=HttpClient.js.map","/**\n * Builds server-side routers for Effect HTTP applications.\n *\n * `HttpRouter` collects routes and middleware while an application layer is\n * being built. Once the router is complete, it handles each\n * `HttpServerRequest` by finding a matching route and producing an\n * `HttpServerResponse`. The module also includes helpers for route definitions,\n * prefixes, parameters, request decoding, CORS, and running the router.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"../../Array.js\";\nimport * as Context from \"../../Context.js\";\nimport * as Effect from \"../../Effect.js\";\nimport { compose, dual, identity } from \"../../Function.js\";\nimport { fiberEnterInterruptibleUnsafe } from \"../../internal/effect.js\";\nimport * as Layer from \"../../Layer.js\";\nimport * as Option from \"../../Option.js\";\nimport * as Schema from \"../../Schema.js\";\nimport * as Scope from \"../../Scope.js\";\nimport * as Tracer from \"../../Tracer.js\";\nimport * as FindMyWay from \"./FindMyWay.js\";\nimport * as HttpEffect from \"./HttpEffect.js\";\nimport * as HttpIncomingMessage from \"./HttpIncomingMessage.js\";\nimport * as HttpMiddleware from \"./HttpMiddleware.js\";\nimport * as HttpServer from \"./HttpServer.js\";\nimport * as HttpServerError from \"./HttpServerError.js\";\nimport * as HttpServerRequest from \"./HttpServerRequest.js\";\nimport * as HttpServerResponse from \"./HttpServerResponse.js\";\nconst TypeId = \"~effect/http/HttpRouter\";\n/**\n * Service tag for the HTTP router used while constructing an HTTP application.\n * Route and middleware layers require this service to register themselves with\n * the router.\n *\n * @category services\n * @since 4.0.0\n */\nexport const HttpRouter = /*#__PURE__*/Context.Service(\"effect/http/HttpRouter\");\n/**\n * Constructs an empty `HttpRouter` service.\n *\n * **Details**\n *\n * The returned router accepts route and middleware registrations and later routes\n * the current `HttpServerRequest` to the matching `HttpServerResponse`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = /*#__PURE__*/Effect.gen(function* () {\n const router = FindMyWay.make(yield* RouterConfig);\n const middleware = new Set();\n const addAll = routes => Effect.contextWith(context => {\n const middleware = getMiddleware(context);\n const applyMiddleware = effect => {\n for (let i = 0; i < middleware.length; i++) {\n effect = middleware[i](effect);\n }\n return effect;\n };\n for (let i = 0; i < routes.length; i++) {\n const route = middleware.length === 0 ? routes[i] : makeRoute({\n ...routes[i],\n handler: applyMiddleware(routes[i].handler)\n });\n if (route.method === \"*\") {\n if (route.path.endsWith(\"/*\")) {\n router.all(route.path, route);\n router.all(route.path.slice(0, -2), route);\n } else {\n router.all(route.path, route);\n }\n } else {\n if (route.path.endsWith(\"/*\")) {\n router.on(route.method, route.path, route);\n router.on(route.method, route.path.slice(0, -2), route);\n } else {\n router.on(route.method, route.path, route);\n }\n }\n }\n return Effect.void;\n });\n return HttpRouter.of({\n [TypeId]: TypeId,\n prefixed(prefix) {\n prefix = removeTrailingSlash(prefix);\n return HttpRouter.of({\n ...this,\n prefixed: newPrefix => this.prefixed(prefixPath(newPrefix, prefix)),\n addAll: routes => addAll(routes.map(prefixRoute(prefix))),\n add: (method, path, handler, options) => addAll([makeRoute({\n method,\n path: prefixPath(path, prefix),\n handler: HttpServerResponse.isHttpServerResponse(handler) ? Effect.succeed(handler) : Effect.isEffect(handler) ? handler : Effect.flatMap(HttpServerRequest.HttpServerRequest, handler),\n uninterruptible: options?.uninterruptible ?? false,\n prefix\n })])\n });\n },\n addAll,\n add: (method, path, handler, options) => addAll([route(method, path, handler, options)]),\n addGlobalMiddleware: middleware_ => Effect.sync(() => {\n middleware.add(middleware_);\n }),\n asHttpEffect() {\n let handler = Effect.withFiber(fiber => {\n let context = fiber.context;\n const request = Context.getUnsafe(context, HttpServerRequest.HttpServerRequest);\n let result = router.find(request.method, request.url);\n if (result === undefined && request.method === \"HEAD\") {\n result = router.find(\"GET\", request.url);\n }\n if (result === undefined) {\n return Effect.fail(new HttpServerError.HttpServerError({\n reason: new HttpServerError.RouteNotFound({\n request\n })\n }));\n }\n const route = result.handler;\n if (Option.isSome(route.prefix)) {\n context = Context.add(context, HttpServerRequest.HttpServerRequest, sliceRequestUrl(request, route.prefix.value));\n }\n context = Context.add(context, HttpServerRequest.ParsedSearchParams, result.searchParams);\n context = Context.add(context, RouteContext, {\n route,\n params: result.params\n });\n if (fiber.getRef(Tracer.Tracer) !== Tracer.nativeTracer) {\n const span = Context.getOrUndefined(context, Tracer.ParentSpan);\n if (span !== undefined && span._tag === \"Span\" && span.sampled) {\n span.attribute(\"http.route\", route.path);\n }\n }\n // The enclosing request restores the fiber context on exit.\n fiber.setContext(context);\n if (!route.uninterruptible) {\n const interrupted = fiberEnterInterruptibleUnsafe(fiber);\n if (interrupted !== undefined) return interrupted;\n }\n return route.handler;\n });\n if (middleware.size === 0) return handler;\n for (const fn of Arr.reverse(middleware)) {\n handler = fn(handler);\n }\n return handler;\n }\n });\n});\nfunction sliceRequestUrl(request, prefix) {\n const prefexLen = prefix.length;\n return request.modify({\n url: request.url.length <= prefexLen ? \"/\" : request.url.slice(prefexLen)\n });\n}\n/**\n * Context reference for low-level router configuration.\n *\n * **Details**\n *\n * The value is passed to the route matcher when an `HttpRouter` is created and\n * defaults to an empty configuration.\n *\n * @category services\n * @since 4.0.0\n */\nexport const RouterConfig = /*#__PURE__*/Context.Reference(\"effect/http/HttpRouter/RouterConfig\", {\n defaultValue: () => ({})\n});\n/**\n * Service for the matched HTTP route in the current request.\n *\n * **When to use**\n *\n * Use to read captured path parameters and route metadata while handling a\n * request matched by the router.\n *\n * **Details**\n *\n * It provides the route definition and the path parameters captured by the route\n * matcher.\n *\n * @category services\n * @since 4.0.0\n */\nexport class RouteContext extends /*#__PURE__*/Context.Service()(\"effect/http/HttpRouter/RouteContext\") {}\n/**\n * Effect that returns the path parameters captured for the current matched route.\n *\n * @category getters\n * @since 4.0.0\n */\nexport const params = /*#__PURE__*/Effect.withFiberSucceed(fiber => Context.getUnsafe(fiber.context, RouteContext).params);\n/**\n * Decodes a schema from the current request and its JSON body.\n *\n * **Details**\n *\n * The input passed to the schema includes the request method, URL, headers,\n * cookies, path parameters, search parameters, and parsed JSON body. The effect\n * fails if the body cannot be parsed or the schema decode fails.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaJson = (schema, options) => {\n const parse = Schema.decodeUnknownEffect(schema);\n const parseBody = HttpIncomingMessage.schemaBodyJson(Schema.Unknown, options);\n return Effect.contextWith(context => {\n const request = Context.get(context, HttpServerRequest.HttpServerRequest);\n const searchParams = Context.get(context, HttpServerRequest.ParsedSearchParams);\n const routeContext = Context.get(context, RouteContext);\n return Effect.flatMap(parseBody(request), body => parse({\n method: request.method,\n url: request.url,\n headers: request.headers,\n cookies: request.cookies,\n pathParams: routeContext.params,\n searchParams,\n body\n }, options));\n });\n};\n/**\n * Decodes a schema from the current request without reading the request body.\n *\n * **Details**\n *\n * The input passed to the schema includes the request method, URL, headers,\n * cookies, path parameters, and search parameters.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaNoBody = (schema, options) => {\n const parse = Schema.decodeUnknownEffect(schema);\n return Effect.contextWith(context => {\n const request = Context.get(context, HttpServerRequest.HttpServerRequest);\n const searchParams = Context.get(context, HttpServerRequest.ParsedSearchParams);\n const routeContext = Context.get(context, RouteContext);\n return parse({\n method: request.method,\n url: request.url,\n headers: request.headers,\n cookies: request.cookies,\n pathParams: routeContext.params,\n searchParams\n }, options);\n });\n};\n/**\n * Decodes a schema from the current route path parameters and search parameters.\n *\n * **Details**\n *\n * When the same key appears in both sources, the path parameter value is used.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaParams = (schema, options) => {\n const parse = Schema.decodeUnknownEffect(schema);\n return Effect.contextWith(context => {\n const searchParams = Context.get(context, HttpServerRequest.ParsedSearchParams);\n const routeContext = Context.get(context, RouteContext);\n return parse({\n ...searchParams,\n ...routeContext.params\n }, options);\n });\n};\n/**\n * Decodes a schema from the path parameters captured for the current matched\n * route.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const schemaPathParams = (schema, options) => {\n const parse = Schema.decodeUnknownEffect(schema);\n return Effect.flatMap(params, _ => parse(_, options));\n};\n/**\n * Creates a layer that accesses the current `HttpRouter` service and runs the\n * supplied effect.\n *\n * **When to use**\n *\n * Use when you need to register routes or middleware with the router during layer\n * construction.\n *\n * **Example** (Registering routes during layer construction)\n *\n * ```ts import.meta.vitest\n * import { Effect } from \"effect\"\n * import { HttpRouter, HttpServerResponse } from \"effect/unstable/http\"\n *\n * const Routes = HttpRouter.use((router) =>\n * router.add(\"GET\", \"/health\", HttpServerResponse.text(\"ready\"))\n * )\n *\n * const program = Effect.acquireUseRelease(\n * Effect.sync(() => HttpRouter.toWebHandler(Routes, { disableLogger: true })),\n * ({ handler }) =>\n * Effect.gen(function*() {\n * const response = yield* Effect.promise(() => handler(new Request(\"http://localhost/health\")))\n * const body = yield* Effect.promise(() => response.text())\n * return body\n * }),\n * ({ dispose }) => Effect.promise(dispose)\n * )\n *\n * await Effect.runPromise(program) // => \"ready\"\n * ```\n *\n * @category layers\n * @since 4.0.0\n */\nexport const use = f => Layer.effectDiscard(Effect.flatMap(HttpRouter, f));\n/**\n * Create a layer that adds a single route to the HTTP router.\n *\n * **Example** (Adding a GET route)\n *\n * ```ts import.meta.vitest\n * import { Layer } from \"effect\"\n * import { HttpRouter, HttpServerResponse } from \"effect/unstable/http\"\n *\n * const Route = HttpRouter.add(\n * \"GET\",\n * \"/hello\",\n * HttpServerResponse.text(\"Hello, World!\")\n * )\n * Layer.isLayer(Route) // => true\n * ```\n *\n * @category layers\n * @since 4.0.0\n */\nexport const add = (method, path, handler, options) => use(router => router.add(method, path, handler, options));\n/**\n * Create a layer that adds multiple routes to the HTTP router.\n *\n * **Example** (Adding multiple routes)\n *\n * ```ts import.meta.vitest\n * import { Layer } from \"effect\"\n * import { HttpRouter, HttpServerResponse } from \"effect/unstable/http\"\n *\n * const Routes = HttpRouter.addAll([\n * HttpRouter.route(\n * \"GET\",\n * \"/hello\",\n * HttpServerResponse.text(\"Hello, World!\")\n * )\n * ])\n * Layer.isLayer(Routes) // => true\n * ```\n *\n * @category layers\n * @since 4.0.0\n */\nexport const addAll = (routes, options) => Layer.effectDiscard(Effect.gen(function* () {\n const toAdd = Effect.isEffect(routes) ? yield* routes : routes;\n let router = yield* HttpRouter;\n if (options?.prefix) {\n router = router.prefixed(options.prefix);\n }\n yield* router.addAll(toAdd);\n}));\n/**\n * Layer that provides a newly constructed `HttpRouter`.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = /*#__PURE__*/Layer.effect(HttpRouter)(make);\n/**\n * Builds an application layer with a router and returns the router as an HTTP\n * handler effect.\n *\n * **Details**\n *\n * The returned effect handles the current `HttpServerRequest` in the current\n * `Scope`; route request markers are converted into the ordinary requirements of\n * the returned handler.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toHttpEffect = appLayer => Effect.gen(function* () {\n const context = yield* Layer.build(Layer.provideMerge(appLayer, layer));\n const router = Context.get(context, HttpRouter);\n // @effect-diagnostics effect/returnEffectInGen:off\n return router.asHttpEffect();\n});\nconst RouteTypeId = \"~effect/http/HttpRouter/Route\";\nconst makeRoute = options => ({\n ...options,\n uninterruptible: options.uninterruptible ?? false,\n prefix: typeof options.prefix === \"string\" ? Option.some(options.prefix) : options.prefix ?? Option.none(),\n [RouteTypeId]: RouteTypeId\n});\n/**\n * Constructs a `Route` from an HTTP method, path, and handler.\n *\n * **Details**\n *\n * The handler may be a static response, an effect that produces a response, or a\n * function from the current request to a response effect. Set `uninterruptible` to\n * prevent the route handler from being made interruptible while it runs.\n *\n * @category routes\n * @since 4.0.0\n */\nexport const route = (method, path, handler, options) => makeRoute({\n ...options,\n method,\n path,\n handler: HttpServerResponse.isHttpServerResponse(handler) ? Effect.succeed(handler) : Effect.isEffect(handler) ? handler : Effect.flatMap(HttpServerRequest.HttpServerRequest, handler),\n uninterruptible: options?.uninterruptible ?? false\n});\nconst removeTrailingSlash = path => path.endsWith(\"/\") ? path.slice(0, -1) : path;\n/**\n * Adds a path prefix to a route path.\n *\n * **Details**\n *\n * Trailing slashes are removed from the prefix; `/` becomes the prefix itself and\n * `*` becomes a wildcard route under the prefix.\n *\n * @category transforming\n * @since 4.0.0\n */\nexport const prefixPath = /*#__PURE__*/dual(2, (self, prefix) => {\n prefix = removeTrailingSlash(prefix);\n if (self === \"*\") return `${prefix}/*`;else if (self === \"/\") return prefix;\n return prefix + self;\n});\n/**\n * Returns a copy of a route with its path prefixed.\n *\n * **Details**\n *\n * The prefix is also tracked on the route so that, when the route handles a\n * request, the matched prefix can be removed from the request URL seen by the\n * handler.\n *\n * @category routes\n * @since 4.0.0\n */\nexport const prefixRoute = /*#__PURE__*/dual(2, (self, prefix) => makeRoute({\n ...self,\n path: prefixPath(self.path, prefix),\n prefix: Option.match(self.prefix, {\n onNone: () => removeTrailingSlash(prefix),\n onSome: existingPrefix => prefixPath(existingPrefix, prefix)\n })\n}));\nconst MiddlewareTypeId = \"~effect/http/HttpRouter/Middleware\";\n/**\n * Create a middleware layer that can be used to modify requests and responses.\n *\n * **Details**\n *\n * By default, the middleware only affects the routes that it is provided to.\n *\n * If you want to create a middleware that applies globally to all routes, pass\n * the `global` option as `true`.\n *\n * **Example** (Applying route and global middleware)\n *\n * ```ts import.meta.vitest\n * import { Effect, Layer } from \"effect\"\n * import { HttpRouter, HttpServerResponse } from \"effect/unstable/http\"\n *\n * const RouteMiddleware = HttpRouter.middleware((httpEffect) =>\n * Effect.map(httpEffect, HttpServerResponse.setHeader(\"x-route\", \"route\"))\n * ).layer\n *\n * const GlobalMiddleware = HttpRouter.middleware(\n * (httpEffect) => Effect.map(httpEffect, HttpServerResponse.setHeader(\"x-global\", \"global\")),\n * { global: true }\n * )\n *\n * const Routes = HttpRouter.add(\"GET\", \"/hello\", HttpServerResponse.text(\"Hello\")).pipe(\n * Layer.provide(RouteMiddleware)\n * )\n * const App = Layer.mergeAll(Routes, GlobalMiddleware)\n *\n * const program = Effect.acquireUseRelease(\n * Effect.sync(() => HttpRouter.toWebHandler(App, { disableLogger: true })),\n * ({ handler }) =>\n * Effect.gen(function*() {\n * const response = yield* Effect.promise(() => handler(new Request(\"http://localhost/hello\")))\n * return [response.headers.get(\"x-route\"), response.headers.get(\"x-global\")]\n * }),\n * ({ dispose }) => Effect.promise(dispose)\n * )\n *\n * await Effect.runPromise(program) // => [\"route\", \"global\"]\n * ```\n *\n * @category middleware\n * @since 4.0.0\n */\nexport const middleware = function () {\n if (arguments.length === 0) {\n return makeMiddleware;\n }\n return makeMiddleware(arguments[0], arguments[1]);\n};\nconst makeMiddleware = (middleware, options) => options?.global ? Layer.effectDiscard(Effect.gen(function* () {\n const router = yield* HttpRouter;\n const fn = Effect.isEffect(middleware) ? yield* middleware : middleware;\n yield* router.addGlobalMiddleware(fn);\n})) : new MiddlewareImpl(Effect.isEffect(middleware) ? Layer.effectContext(Effect.map(middleware, fn => Context.makeUnsafe(new Map([[fnContextKey, fn]])))) : Layer.succeedContext(Context.makeUnsafe(new Map([[fnContextKey, middleware]]))));\nlet middlewareId = 0;\nconst fnContextKey = \"effect/http/HttpRouter/MiddlewareFn\";\nclass MiddlewareImpl {\n [MiddlewareTypeId] = {};\n layerFn;\n dependencies;\n constructor(layerFn, dependencies) {\n this.layerFn = layerFn;\n this.dependencies = dependencies;\n const contextKey = `effect/http/HttpRouter/Middleware-${++middlewareId}`;\n this.layer = Layer.effectContext(Effect.gen({\n self: this\n }, function* () {\n const context = yield* Effect.context();\n const stack = [Context.getOrUndefinedUnsafe(context, fnContextKey)];\n if (this.dependencies) {\n const memoMap = yield* Layer.CurrentMemoMap;\n const scope = Context.get(context, Scope.Scope);\n const depsContext = yield* Layer.buildWithMemoMap(this.dependencies, memoMap, scope);\n stack.push(...getMiddleware(depsContext));\n }\n return Context.makeUnsafe(new Map([[contextKey, stack]]));\n })).pipe(Layer.provide(this.layerFn));\n }\n layer;\n combine(other) {\n return new MiddlewareImpl(this.layerFn, this.dependencies ? Layer.provideMerge(this.dependencies, other.layer) : other.layer);\n }\n}\nconst middlewareCache = /*#__PURE__*/new WeakMap();\nconst getMiddleware = context => {\n let arr = middlewareCache.get(context);\n if (arr) return arr;\n const topLevel = Arr.empty();\n let maxLength = 0;\n for (const [key, value] of context.mapUnsafe) {\n if (key.startsWith(\"effect/http/HttpRouter/Middleware-\")) {\n topLevel.push(value);\n if (value.length > maxLength) {\n maxLength = value.length;\n }\n }\n }\n if (topLevel.length === 0) {\n arr = [];\n } else {\n const middleware = new Set();\n for (let i = maxLength - 1; i >= 0; i--) {\n for (const arr of topLevel) {\n if (i < arr.length) {\n middleware.add(arr[i]);\n }\n }\n }\n arr = Arr.fromIterable(middleware).reverse();\n }\n middlewareCache.set(context, arr);\n return arr;\n};\n/**\n * Middleware that applies CORS headers to the HTTP response.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const cors = options => middleware(HttpMiddleware.cors(options), {\n global: true\n});\n/**\n * Middleware that disables the logger for some routes.\n *\n * **Example** (Disabling route logging)\n *\n * ```ts import.meta.vitest\n * import { Layer } from \"effect\"\n * import { HttpRouter, HttpServerResponse } from \"effect/unstable/http\"\n *\n * const Route = HttpRouter.add(\n * \"GET\",\n * \"/hello\",\n * HttpServerResponse.text(\"Hello, World!\")\n * ).pipe(\n * // disable the logger for this route\n * Layer.provide(HttpRouter.disableLogger)\n * )\n * Layer.isLayer(Route) // => true\n * ```\n *\n * @category layers\n * @since 4.0.0\n */\nexport const disableLogger = /*#__PURE__*/middleware(HttpMiddleware.withLoggerDisabled).layer;\n/**\n * Provides request-level dependencies to some routes.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const provideRequest = layer => self => Layer.provide(self, middleware()(Effect.gen(function* () {\n const services = yield* Layer.build(layer);\n return effect => Effect.provideContext(effect, services);\n})).layer);\n/**\n * Runs the provided application layer as an HTTP server.\n *\n * @category layers\n * @since 4.0.0\n */\nexport const serve = (appLayer, options) => {\n let middleware = options?.middleware;\n if (options?.disableLogger !== true) {\n middleware = middleware ? compose(middleware, HttpMiddleware.logger) : HttpMiddleware.logger;\n }\n const RouterLayer = options?.routerConfig ? Layer.provide(layer, Layer.succeed(RouterConfig)(options.routerConfig)) : layer;\n return Effect.gen(function* () {\n const router = yield* HttpRouter;\n const handler = router.asHttpEffect();\n return middleware ? HttpServer.serve(handler, middleware) : HttpServer.serve(handler);\n }).pipe(Layer.unwrap, Layer.provideMerge(appLayer), Layer.provide(RouterLayer), options?.disableListenLog ? identity : HttpServer.withLogAddress);\n};\n/**\n * Builds a Fetch-compatible request handler from an HTTP router application\n * layer.\n *\n * **Details**\n *\n * The result contains a `handler` function that converts Web `Request` values to\n * Web `Response` values and a `dispose` function for releasing the layer\n * resources. The layer is built immediately, so the cost is paid when the\n * handler is created rather than on the first request. A layer that performs\n * asynchronous work while building may still be in progress when the first\n * request arrives, in which case that request waits for the build to finish.\n * If the build fails, every request rejects with the build error.\n *\n * @category converting\n * @since 4.0.0\n */\nexport const toWebHandler = (appLayer, options) => {\n let middleware = options?.middleware;\n if (options?.disableLogger !== true) {\n middleware = middleware ? compose(middleware, HttpMiddleware.logger) : HttpMiddleware.logger;\n }\n const RouterLayer = options?.routerConfig ? Layer.provide(layer, Layer.succeed(RouterConfig)(options.routerConfig)) : layer;\n return HttpEffect.toWebHandlerLayerWith(Layer.provideMerge(appLayer, RouterLayer), {\n toHandler: s => Effect.succeed(Context.get(s, HttpRouter).asHttpEffect()),\n middleware,\n memoMap: options?.memoMap\n });\n};\n//# sourceMappingURL=HttpRouter.js.map","/**\n * Named HTTP status codes for the unstable HTTP modules.\n *\n * This module centralizes the mapping from literal names of the known HTTP\n * status codes, such as `\"OK\"` and `\"Conflict\"`, to their numeric codes. Use\n * {@link fromLiteral} to obtain a status code from a literal name instead of\n * remembering raw numbers.\n *\n * @since 4.0.0\n */\nconst codeByLiteral = {\n Continue: 100,\n SwitchingProtocols: 101,\n Processing: 102,\n EarlyHints: 103,\n OK: 200,\n Ok: 200,\n Created: 201,\n Accepted: 202,\n NonAuthoritativeInformation: 203,\n NoContent: 204,\n ResetContent: 205,\n PartialContent: 206,\n MultiStatus: 207,\n AlreadyReported: 208,\n ImUsed: 226,\n MultipleChoices: 300,\n MovedPermanently: 301,\n Found: 302,\n SeeOther: 303,\n NotModified: 304,\n TemporaryRedirect: 307,\n PermanentRedirect: 308,\n BadRequest: 400,\n Unauthorized: 401,\n PaymentRequired: 402,\n Forbidden: 403,\n NotFound: 404,\n MethodNotAllowed: 405,\n NotAcceptable: 406,\n ProxyAuthenticationRequired: 407,\n RequestTimeout: 408,\n Conflict: 409,\n Gone: 410,\n LengthRequired: 411,\n PreconditionFailed: 412,\n PayloadTooLarge: 413,\n UriTooLong: 414,\n UnsupportedMediaType: 415,\n RangeNotSatisfiable: 416,\n ExpectationFailed: 417,\n ImATeapot: 418,\n MisdirectedRequest: 421,\n UnprocessableEntity: 422,\n Locked: 423,\n FailedDependency: 424,\n TooEarly: 425,\n UpgradeRequired: 426,\n PreconditionRequired: 428,\n TooManyRequests: 429,\n RequestHeaderFieldsTooLarge: 431,\n UnavailableForLegalReasons: 451,\n InternalServerError: 500,\n NotImplemented: 501,\n BadGateway: 502,\n ServiceUnavailable: 503,\n GatewayTimeout: 504,\n HttpVersionNotSupported: 505,\n VariantAlsoNegotiates: 506,\n InsufficientStorage: 507,\n LoopDetected: 508,\n NotExtended: 510,\n NetworkAuthenticationRequired: 511\n};\n/**\n * Returns the numeric HTTP status code for a literal name.\n *\n * **Example** (Obtaining status codes from literal names)\n *\n * ```ts import.meta.vitest\n * import { HttpStatus } from \"effect/unstable/http\"\n *\n * HttpStatus.fromLiteral(\"OK\") // => 200\n * HttpStatus.fromLiteral(\"Conflict\") // => 409\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const fromLiteral = literal => codeByLiteral[literal];\n//# sourceMappingURL=HttpStatus.js.map","/**\n * Attaches HTTP API metadata to Effect Schema values.\n *\n * This module is the schema-side bridge for HttpApi endpoint builders,\n * generated clients, and OpenAPI support. It does not define routes or perform\n * IO. Instead, the helpers annotate schemas so the surrounding HTTP API tooling\n * can choose response status codes, content types, body codecs, multipart\n * handling, and no-body response behavior.\n *\n * @since 4.0.0\n */\nimport { constVoid } from \"../../Function.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as Schema from \"../../Schema.js\";\nimport * as SchemaAST from \"../../SchemaAST.js\";\nimport * as SchemaTransformation from \"../../SchemaTransformation.js\";\nimport * as Stream from \"../../Stream.js\";\nimport { hasBody } from \"../http/HttpMethod.js\";\nimport * as HttpStatus from \"../http/HttpStatus.js\";\nconst StreamSchemaTypeId = \"~effect/httpapi/HttpApiSchema/Stream\";\nexport function status(code) {\n const statusCode = typeof code === \"string\" ? HttpStatus.fromLiteral(code) : code;\n return self => self.annotate({\n httpApiStatus: statusCode\n });\n}\n/**\n * Creates a void schema with the given HTTP status code.\n * This is used to represent empty responses with a specific status code.\n *\n * @see {@link NoContent} for the predefined 204 no content schema.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const Empty = code => Schema.Void.pipe(status(code));\n/**\n * Schema for empty HTTP responses with status code 204.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const NoContent = /*#__PURE__*/Empty(204);\n/**\n * Schema for empty HTTP responses with status code 201.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const Created = /*#__PURE__*/Empty(201);\n/**\n * Schema for empty HTTP responses with status code 202.\n *\n * @category schemas\n * @since 4.0.0\n */\nexport const Accepted = /*#__PURE__*/Empty(202);\n/**\n * Marks a schema as a no-content response while preserving a decoded client value.\n *\n * **Details**\n *\n * The server encodes the response as `void`; generated clients call `decode` to\n * produce the schema's decoded value when the response has no body.\n *\n * @see {@link NoContent} for a void schema with the status code 204.\n * @see {@link Empty} for creating a void schema with a specific status code.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function asNoContent(options) {\n return self => {\n return Schema.Void.pipe(Schema.decodeTo(Schema.toType(self), SchemaTransformation.transform({\n decode: options.decode,\n encode: constVoid\n })));\n };\n}\nconst streamSchema = /*#__PURE__*/Schema.declare(Stream.isStream);\n/**\n * Creates a Server-Sent Events streaming success response schema.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const StreamSse = options => {\n const events = options.events ?? (options.data === undefined ? undefined : Schema.Struct({\n id: Schema.UndefinedOr(Schema.String),\n event: Schema.String,\n data: Schema.fromJsonString(options.data)\n }));\n if (events === undefined) {\n throw new Error(\"StreamSse requires either an events schema or a data schema\");\n }\n return Schema.make(streamSchema.ast, {\n [StreamSchemaTypeId]: StreamSchemaTypeId,\n _tag: \"StreamSse\",\n mode: \"sse\",\n sseMode: options.events === undefined ? \"data\" : \"events\",\n contentType: options.contentType ?? defaultStreamContentType(\"sse\"),\n events,\n error: options.error ?? Schema.Never\n });\n};\n/**\n * Creates a streaming `Uint8Array` success response schema.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const StreamUint8Array = options => Schema.make(streamSchema.ast, {\n [StreamSchemaTypeId]: StreamSchemaTypeId,\n _tag: \"StreamUint8Array\",\n mode: \"uint8array\",\n contentType: options?.contentType ?? defaultStreamContentType(\"uint8array\")\n});\n/** @internal */\nexport const isStreamSchema = u => Schema.isSchema(u) && Predicate.hasProperty(u, StreamSchemaTypeId);\n/** @internal */\nexport const isStreamSse = u => isStreamSchema(u) && u._tag === \"StreamSse\";\n/** @internal */\nexport const isStreamUint8Array = u => isStreamSchema(u) && u._tag === \"StreamUint8Array\";\nfunction defaultStreamContentType(mode) {\n switch (mode) {\n case \"sse\":\n return \"text/event-stream\";\n case \"uint8array\":\n return \"application/octet-stream\";\n }\n}\n/**\n * Runtime brand key used to mark `WithHeaders` response schemas.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const WithHeadersTypeId = \"~effect/httpapi/HttpApiSchema/WithHeaders\";\n/**\n * Runtime brand key used to mark `WithHeaders` response values.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const WithHeadersValueTypeId = \"~effect/httpapi/HttpApiSchema/WithHeadersValue\";\n/** @internal */\nexport const isWithHeadersValue = u => Predicate.hasProperty(u, WithHeadersValueTypeId);\nconst withHeadersValueSchema = /*#__PURE__*/Schema.declare(isWithHeadersValue);\nexport function WithHeaders(schema, headers) {\n if (isWithHeaders(schema)) {\n throw new Error(\"WithHeaders schemas cannot be nested\");\n }\n return Schema.make(withHeadersValueSchema.ast, {\n [WithHeadersTypeId]: WithHeadersTypeId,\n schema,\n headers: Schema.isSchema(headers) ? headers : Schema.Struct(headers)\n });\n}\n/**\n * Constructs a `WithHeaders` response value from a body and headers.\n *\n * **Details**\n *\n * The returned value is branded so servers and clients can detect it exactly,\n * including in mixed success unions. The same shape is used on both sides: a\n * value received from a client can be returned from another handler unchanged.\n *\n * See {@link WithHeaders} for an example that constructs a schema and its\n * corresponding response value.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const withHeaders = options => ({\n [WithHeadersValueTypeId]: WithHeadersValueTypeId,\n body: options.body,\n headers: options.headers\n});\n/**\n * Returns `true` when a schema is a `WithHeaders` response schema.\n *\n * **Example** (Detecting a response headers schema)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n * import { HttpApiSchema } from \"effect/unstable/httpapi\"\n *\n * const schema = HttpApiSchema.WithHeaders(Schema.String, {\n * \"x-request-id\": Schema.String\n * })\n *\n * HttpApiSchema.isWithHeaders(schema) // => true\n * HttpApiSchema.isWithHeaders(Schema.String) // => false\n * ```\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isWithHeaders = u => Schema.isSchema(u) && Predicate.hasProperty(u, WithHeadersTypeId);\n/** @internal */\nexport function rebuildWithHeaders(self, schema, headers) {\n return Schema.make(self.ast, {\n [WithHeadersTypeId]: WithHeadersTypeId,\n schema,\n headers\n });\n}\n/**\n * Encodes a schema as a `{ body, headers }` pair, folding response headers into\n * an opaque domain type such as an error class.\n *\n * **Details**\n *\n * The encoded side is the pair of the body schema and the headers fields; the\n * Type stays the source schema's Type. The body schema is authoritative for\n * everything wire-level: status, content type, and response encoding resolve\n * from the body schema's annotations.\n *\n * The mappings are pure total functions: validation lives in the body and\n * header schemas, the mappings only reshape valid data.\n *\n * Streams used as the body schema turn mid-stream transport errors into\n * defects on the client. Stream responses should use {@link WithHeaders},\n * which preserves the body stream's error channel in the generated client.\n *\n * **Example** (Encoding an error with headers)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n * import { HttpApiSchema } from \"effect/unstable/httpapi\"\n *\n * class UserNotFound extends Schema.TaggedError()(\"UserNotFound\", {\n * userId: Schema.Int\n * }) {}\n *\n * const UserNotFoundWithHeaders = UserNotFound.pipe(\n * HttpApiSchema.encodeToWithHeaders({\n * body: HttpApiSchema.Empty(404),\n * headers: {\n * \"x-user-id\": Schema.Int\n * }\n * }, {\n * decode: ({ headers }) => new UserNotFound({ userId: headers[\"x-user-id\"] }),\n * encode: (error) => ({\n * headers: { \"x-user-id\": error.userId },\n * body: undefined\n * })\n * })\n * )\n *\n * const encoded = Schema.encodeSync(UserNotFoundWithHeaders)(new UserNotFound({ userId: 123 }))\n * encoded // => { body: undefined, headers: { \"x-user-id\": 123 } }\n * ```\n *\n * @see {@link WithHeaders} for the structural wrapper recommended for success\n * responses, including streams.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function encodeToWithHeaders(options, transformation) {\n return self => {\n const body = options.body;\n const headers = Schema.Struct(options.headers);\n const status = resolveHttpApiStatus(body.ast);\n const encoding = resolveHttpApiEncoding(body.ast);\n return Schema.Struct({\n body,\n headers\n }).pipe(Schema.decodeTo(Schema.toType(self), SchemaTransformation.transform(transformation))).annotate({\n \"~httpApiWithHeaders\": {\n body,\n headers,\n headersCodec: Schema.toEncoded(headers)\n },\n httpApiStatus: status,\n \"~httpApiEncoding\": encoding\n });\n };\n}\n/**\n * Runtime brand key used to mark schemas as buffered multipart payloads.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const MultipartTypeId = \"~effect/httpapi/HttpApiSchema/Multipart\";\n/**\n * Marks a schema as a multipart payload.\n *\n * @see {@link asMultipartStream} for a multipart stream payload.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function asMultipart(options) {\n return self => self.pipe(Schema.brand(MultipartTypeId)).annotate({\n \"~httpApiEncoding\": {\n _tag: \"Multipart\",\n mode: \"buffered\",\n contentType: defaultContentType(\"Multipart\"),\n limits: options\n }\n });\n}\n/**\n * Runtime brand key used to mark schemas as streaming multipart payloads.\n *\n * @category type IDs\n * @since 4.0.0\n */\nexport const MultipartStreamTypeId = \"~effect/httpapi/HttpApiSchema/MultipartStream\";\n/**\n * Marks a schema as a multipart stream payload.\n *\n * @see {@link asMultipart} for a buffered multipart payload.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function asMultipartStream(options) {\n return self => self.pipe(Schema.brand(MultipartStreamTypeId)).annotate({\n \"~httpApiEncoding\": {\n _tag: \"Multipart\",\n mode: \"stream\",\n contentType: defaultContentType(\"Multipart\"),\n limits: options\n }\n });\n}\nfunction asNonMultipartEncoding(self, options) {\n return self.annotate({\n \"~httpApiEncoding\": {\n _tag: options._tag,\n contentType: options.contentType ?? defaultContentType(options._tag)\n }\n });\n}\nfunction defaultContentType(_tag) {\n switch (_tag) {\n case \"Multipart\":\n return \"multipart/form-data\";\n case \"Json\":\n return \"application/json\";\n case \"FormUrlEncoded\":\n return \"application/x-www-form-urlencoded\";\n case \"Uint8Array\":\n return \"application/octet-stream\";\n case \"Text\":\n return \"text/plain\";\n }\n}\n/**\n * Marks a schema as a JSON payload / response.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function asJson(options) {\n return self => asNonMultipartEncoding(self, {\n _tag: \"Json\",\n ...options\n });\n}\n/**\n * Marks a schema as an `application/x-www-form-urlencoded` payload or response.\n *\n * **Details**\n *\n * The schema's encoded side must be a record of strings.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function asFormUrlEncoded(options) {\n return self => asNonMultipartEncoding(self, {\n _tag: \"FormUrlEncoded\",\n ...options\n });\n}\n/**\n * Marks a schema as a text payload / response.\n *\n * **Details**\n *\n * The schema encoded side must be a string.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function asText(options) {\n return self => asNonMultipartEncoding(self, {\n _tag: \"Text\",\n ...options\n });\n}\n/**\n * Marks a schema as a binary payload / response.\n *\n * **Details**\n *\n * The schema encoded side must be a `Uint8Array`.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport function asUint8Array(options) {\n return self => asNonMultipartEncoding(self, {\n _tag: \"Uint8Array\",\n ...options\n });\n}\n/**\n * Returns `true` when a schema AST represents a no-content response.\n *\n * **Details**\n *\n * The check succeeds for direct `void` schemas and schemas whose encoded or\n * transformation target is `void`.\n *\n * @category predicates\n * @since 4.0.0\n */\nexport const isNoContent = ast => {\n if (SchemaAST.isVoid(ast)) return true;\n const encoded = SchemaAST.toEncoded(ast);\n if (SchemaAST.isVoid(encoded)) return true;\n const target = ast.encoding?.[0].to;\n if (target === undefined) return false;\n return SchemaAST.isVoid(target);\n};\nconst resolveHttpApiEncoding = /*#__PURE__*/SchemaAST.resolveAt(\"~httpApiEncoding\");\n/** @internal */\nexport const getWithHeadersAnnotation = /*#__PURE__*/SchemaAST.resolveAt(\"~httpApiWithHeaders\");\nconst resolveHttpApiStatus = /*#__PURE__*/SchemaAST.resolveAt(\"httpApiStatus\");\nconst defaultJsonEncoding = {\n _tag: \"Json\",\n contentType: \"application/json\"\n};\nconst defaultUrlEncodedEncoding = {\n _tag: \"FormUrlEncoded\",\n contentType: \"application/x-www-form-urlencoded\"\n};\nfunction getEncoding(ast) {\n return resolveHttpApiEncoding(ast) ?? defaultJsonEncoding;\n}\n/** @internal */\nexport function getPayloadEncoding(ast, method) {\n const encoding = resolveHttpApiEncoding(ast);\n if (encoding) return encoding;\n return hasBody(method) ? defaultJsonEncoding : defaultUrlEncodedEncoding;\n}\n/** @internal */\nexport function getResponseEncoding(ast) {\n const out = getEncoding(ast);\n if (out._tag === \"Multipart\") {\n throw new Error(\"Multipart is not supported in response\");\n }\n return out;\n}\n/** @internal */\nexport function getStatusSuccess(self) {\n return resolveHttpApiStatus(self) ?? 200;\n}\n/** @internal */\nexport function getStatusSuccessSchema(schema) {\n if (isWithHeaders(schema)) {\n return resolveHttpApiStatus(schema.ast) ?? getStatusSuccess(schema.schema.ast);\n }\n return getStatusSuccess(schema.ast);\n}\n/** @internal */\nexport function getResponseEncodingSchema(schema) {\n if (isWithHeaders(schema) && resolveHttpApiEncoding(schema.ast) === undefined) {\n return getResponseEncoding(schema.schema.ast);\n }\n return getResponseEncoding(schema.ast);\n}\n/** @internal */\nexport function getStatusError(self) {\n return resolveHttpApiStatus(self) ?? 500;\n}\n/** @internal */\nexport function getStatusErrorSchema(schema) {\n if (isWithHeaders(schema)) {\n return resolveHttpApiStatus(schema.ast) ?? getStatusError(schema.schema.ast);\n }\n return getStatusError(schema.ast);\n}\n//# sourceMappingURL=HttpApiSchema.js.map","/** @internal */\nexport function normalize(contentType) {\n const normalized = contentType.toLowerCase().trim();\n const index = normalized.indexOf(\";\");\n return index === -1 ? normalized : normalized.slice(0, index).trim();\n}\n//# sourceMappingURL=mediaType.js.map","/**\n * Defines endpoint declarations used inside an HTTP API group.\n *\n * An endpoint records a stable identifier, HTTP method, router path, request schemas,\n * response schemas, declared errors, middleware, and annotations. Endpoint\n * values are declarations, not handlers: builders use them to decode requests,\n * type handler input, encode responses, generate OpenAPI metadata, and derive\n * generated-client call signatures. This module also includes HTTP method\n * constructors, payload and response schema helpers, and type utilities used by\n * builders and generated clients.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"../../Array.js\";\nimport * as Context from \"../../Context.js\";\nimport { identity, memoize } from \"../../Function.js\";\nimport { pipeArguments } from \"../../Pipeable.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as Schema from \"../../Schema.js\";\nimport * as AST from \"../../SchemaAST.js\";\nimport * as HttpRouter from \"../http/HttpRouter.js\";\nimport * as HttpApiSchema from \"./HttpApiSchema.js\";\nimport * as MediaType from \"./internal/mediaType.js\";\nconst TypeId = \"~effect/httpapi/HttpApiEndpoint\";\n/**\n * Returns `true` when a value is an `HttpApiEndpoint`, narrowing the value to the\n * endpoint interface.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpApiEndpoint = u => Predicate.hasProperty(u, TypeId);\n/** @internal */\nexport function getPayloadSchemas(endpoint) {\n const result = [];\n for (const {\n schemas\n } of endpoint.payload.values()) {\n result.push(...schemas);\n }\n return result;\n}\n/** @internal */\nexport function getSuccessSchemas(endpoint) {\n const schemas = Array.from(endpoint.success);\n return Arr.isArrayNonEmpty(schemas) ? schemas : [HttpApiSchema.NoContent];\n}\n/** @internal */\nexport function getErrorSchemas(endpoint) {\n const schemas = new Set(endpoint.error);\n const transform = endpoint.disableCodecs ? identity : transformResponseSchema;\n for (const middleware of endpoint.middlewares) {\n const key = middleware;\n for (const schema of key.error) {\n schemas.add(transform(schema));\n }\n }\n return Array.from(schemas);\n}\nconst Proto = {\n [TypeId]: TypeId,\n pipe() {\n return pipeArguments(this, arguments);\n },\n prefix(prefix) {\n return makeProto({\n ...optionsFromEndpoint(this),\n path: HttpRouter.prefixPath(this.path, prefix)\n });\n },\n middleware(middleware) {\n return makeProto({\n ...optionsFromEndpoint(this),\n middlewares: new Set([...this.middlewares, middleware])\n });\n },\n annotate(key, value) {\n return makeProto({\n ...optionsFromEndpoint(this),\n annotations: Context.add(this.annotations, key, value)\n });\n },\n annotateMerge(annotations) {\n return makeProto({\n ...optionsFromEndpoint(this),\n annotations: Context.merge(this.annotations, annotations)\n });\n }\n};\nconst optionsFromEndpoint = endpoint => ({\n identifier: endpoint.identifier,\n path: endpoint.path,\n method: endpoint.method,\n params: endpoint.params,\n query: endpoint.query,\n headers: endpoint.headers,\n payload: endpoint.payload,\n success: endpoint.success,\n error: endpoint.error,\n annotations: endpoint.annotations,\n middlewares: endpoint.middlewares,\n disableCodecs: endpoint.disableCodecs\n});\nfunction makeProto(options) {\n function HttpApiEndpoint() {}\n Object.setPrototypeOf(HttpApiEndpoint, Proto);\n return Object.assign(HttpApiEndpoint, options);\n}\n/**\n * Creates endpoint constructors for a specific HTTP method. The resulting\n * constructor builds an `HttpApiEndpoint` from an identifier, path, and optional request\n * and response schemas, applying automatic JSON or string-tree codecs unless\n * `disableCodecs` is enabled.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = method => (identifier, path, options) => {\n const disableCodecs = options?.disableCodecs ?? false;\n const transformStringTree = disableCodecs ? identity : Schema.toCodecStringTree;\n return makeProto({\n identifier,\n path,\n method,\n params: ensureStruct(options?.params, transformStringTree),\n query: ensureStruct(options?.query, transformStringTree),\n headers: ensureStruct(options?.headers, transformStringTree),\n payload: getPayload(options?.payload, method, disableCodecs),\n success: getSuccessResponse(options?.success, method, disableCodecs),\n error: getErrorResponse(options?.error, disableCodecs),\n annotations: Context.empty(),\n middlewares: new Set(),\n disableCodecs\n });\n};\nfunction ensureStruct(params, transform) {\n if (params === undefined) return undefined;\n if (Schema.isSchema(params)) return transform(params);\n return transform(Schema.Struct(params));\n}\nfunction getPayload(payload, method, disableCodecs) {\n const result = new Map();\n if (payload === undefined) return result;\n const schemas = Array.isArray(payload) ? payload : Schema.isSchema(payload) ? [payload] : [Schema.Struct(payload).pipe(HttpApiSchema.asFormUrlEncoded())];\n const transform = disableCodecs ? identity : transformPayload;\n for (const schema of schemas) {\n const encoding = HttpApiSchema.getPayloadEncoding(schema.ast, method);\n const contentType = MediaType.normalize(encoding.contentType);\n const existing = result.get(contentType);\n if (existing) {\n if (existing.encoding._tag !== encoding._tag) {\n throw new Error(`Multiple payload encodings for content-type: ${encoding.contentType}`);\n }\n if (existing.encoding._tag === \"Multipart\") {\n throw new Error(`Multiple multipart payloads for content-type: ${encoding.contentType}`);\n }\n existing.schemas.push(transform(schema, method));\n } else {\n result.set(contentType, {\n encoding,\n schemas: [transform(schema, method)]\n });\n }\n }\n return result;\n}\nconst reservedStreamFailureEvent = \"effect/httpapi/stream/failure\";\nfunction getSuccessResponse(success, method, disableCodecs) {\n if (success === undefined) return new Set();\n const schemas = Arr.ensure(success);\n validateSuccessResponse(schemas, method);\n return new Set(disableCodecs ? schemas : schemas.map(transformResponseSchema));\n}\nconst transformResponseSchema = /*#__PURE__*/memoize(schema => {\n if (HttpApiSchema.isStreamSchema(schema)) return schema;\n if (HttpApiSchema.isWithHeaders(schema)) {\n const inner = HttpApiSchema.isStreamSchema(schema.schema) ? schema.schema : applyResponseEncoding(schema.schema, HttpApiSchema.getResponseEncodingSchema(schema));\n return HttpApiSchema.rebuildWithHeaders(schema, inner, Schema.toCodecStringTree(schema.headers));\n }\n return transformResponse(schema);\n});\nfunction getErrorResponse(error, disableCodecs) {\n if (error === undefined) return new Set();\n const schemas = Arr.ensure(error);\n for (const schema of schemas) {\n const body = HttpApiSchema.isWithHeaders(schema) ? schema.schema : schema;\n if (HttpApiSchema.isStreamSchema(body)) {\n throw new Error(\"Streaming schemas are not supported in error responses\");\n }\n }\n validateResponseExclusivity(schemas, HttpApiSchema.getStatusErrorSchema);\n return new Set(disableCodecs ? schemas : schemas.map(transformResponseSchema));\n}\nfunction validateSuccessResponse(schemas, method) {\n let hasStream = false;\n const statuses = new Map();\n for (const schema of schemas) {\n const inner = HttpApiSchema.isWithHeaders(schema) ? schema.schema : schema;\n const status = HttpApiSchema.getStatusSuccessSchema(schema);\n if (HttpApiSchema.isStreamSchema(inner)) {\n validateStreamSuccess(inner, method);\n if (hasStream) {\n throw new Error(\"Multiple streaming success responses are not supported\");\n }\n hasStream = true;\n const entry = getStatusEntry(statuses, status);\n if (entry.noContent) {\n throw new Error(`Cannot combine no-content and streaming success responses for status: ${status}`);\n }\n if (entry.bufferedContentTypes.has(MediaType.normalize(inner.contentType))) {\n throw new Error(`Cannot combine buffered and streaming success responses for status ${status} and content-type: ${inner.contentType}`);\n }\n statuses.set(status, {\n ...entry,\n stream: inner\n });\n } else {\n const entry = getStatusEntry(statuses, status);\n const noContent = HttpApiSchema.isNoContent(inner.ast);\n if (entry.stream !== undefined) {\n if (noContent) {\n throw new Error(`Cannot combine no-content and streaming success responses for status: ${status}`);\n }\n const encoding = HttpApiSchema.getResponseEncodingSchema(schema);\n if (MediaType.normalize(encoding.contentType) === MediaType.normalize(entry.stream.contentType)) {\n throw new Error(`Cannot combine buffered and streaming success responses for status ${status} and content-type: ${encoding.contentType}`);\n }\n }\n if (!noContent) {\n entry.bufferedContentTypes.add(MediaType.normalize(HttpApiSchema.getResponseEncodingSchema(schema).contentType));\n }\n entry.noContent = entry.noContent || noContent;\n }\n }\n validateResponseExclusivity(schemas, HttpApiSchema.getStatusSuccessSchema);\n}\nfunction getStatusEntry(statuses, status) {\n let entry = statuses.get(status);\n if (entry === undefined) {\n entry = {\n bufferedContentTypes: new Set(),\n noContent: false\n };\n statuses.set(status, entry);\n }\n return entry;\n}\nfunction validateResponseExclusivity(schemas, getStatus) {\n const statuses = new Map();\n for (const schema of schemas) {\n const status = getStatus(schema);\n const withHeadersAnnotation = HttpApiSchema.getWithHeadersAnnotation(schema.ast);\n const body = HttpApiSchema.isWithHeaders(schema) ? schema.schema : withHeadersAnnotation?.body ?? schema;\n const contentType = HttpApiSchema.isNoContent(body.ast) ? \"\" : MediaType.normalize(HttpApiSchema.isStreamSchema(body) ? body.contentType : HttpApiSchema.getResponseEncodingSchema(schema).contentType);\n let entry = statuses.get(status);\n if (entry === undefined) {\n entry = {\n headerContentType: undefined,\n plainContentTypes: new Set()\n };\n statuses.set(status, entry);\n }\n const combineError = () => new Error(`Cannot combine a response with headers with another response for status ${status} and content-type: ${contentType || \"\"}`);\n if (HttpApiSchema.isWithHeaders(schema) || withHeadersAnnotation !== undefined) {\n if (entry.headerContentType !== undefined) {\n throw new Error(`Cannot declare multiple responses with headers for status ${status}`);\n }\n if (entry.plainContentTypes.has(contentType)) throw combineError();\n entry.headerContentType = contentType;\n } else {\n if (entry.headerContentType === contentType) throw combineError();\n entry.plainContentTypes.add(contentType);\n }\n }\n}\nfunction validateStreamSuccess(schema, method) {\n if (method === \"HEAD\") {\n throw new Error(\"HEAD endpoints cannot declare streaming success responses\");\n }\n if (HttpApiSchema.isStreamSse(schema) && hasReservedSseEventName(schema.events.ast)) {\n throw new Error(`SSE event name is reserved: ${reservedStreamFailureEvent}`);\n }\n}\nfunction hasReservedSseEventName(ast) {\n return hasReservedEventName(AST.toEncoded(ast), new Set());\n}\nfunction hasReservedEventName(ast, seen) {\n if (seen.has(ast)) return false;\n seen.add(ast);\n if (AST.isUnion(ast)) {\n return ast.types.some(type => hasReservedEventName(type, seen));\n }\n if (AST.isSuspend(ast)) {\n return hasReservedEventName(ast.thunk(), seen);\n }\n if (!AST.isObjects(ast)) return false;\n const event = ast.propertySignatures.find(ps => ps.name === \"event\");\n return event !== undefined && hasReservedEventLiteral(event.type, seen);\n}\nfunction hasReservedEventLiteral(ast, seen) {\n if (seen.has(ast)) return false;\n seen.add(ast);\n const encoded = AST.toEncoded(ast);\n if (encoded !== ast) {\n return hasReservedEventLiteral(encoded, seen);\n }\n if (AST.isLiteral(ast)) {\n return ast.literal === reservedStreamFailureEvent;\n }\n if (AST.isUnion(ast)) {\n return ast.types.some(type => hasReservedEventLiteral(type, seen));\n }\n if (AST.isSuspend(ast)) {\n return hasReservedEventLiteral(ast.thunk(), seen);\n }\n return false;\n}\nfunction transformResponse(schema) {\n const encoding = HttpApiSchema.getResponseEncoding(schema.ast);\n const withHeaders = HttpApiSchema.getWithHeadersAnnotation(schema.ast);\n if (withHeaders === undefined) {\n return applyResponseEncoding(schema, encoding);\n }\n const headers = Schema.toEncoded(withHeaders.headers);\n return Schema.Struct({\n body: applyResponseEncoding(Schema.toEncoded(withHeaders.body), encoding),\n headers\n }).pipe(Schema.decodeTo(schema)).annotate({\n \"~httpApiWithHeaders\": {\n ...withHeaders,\n headersCodec: Schema.toCodecStringTree(headers)\n }\n });\n}\nfunction applyResponseEncoding(schema, encoding) {\n switch (encoding._tag) {\n case \"Json\":\n return Schema.toCodecJson(schema);\n case \"FormUrlEncoded\":\n return Schema.toCodecStringTree(schema);\n case \"Text\":\n case \"Uint8Array\":\n return schema;\n }\n}\nfunction transformPayload(schema, method) {\n const encoding = HttpApiSchema.getPayloadEncoding(schema.ast, method);\n switch (encoding._tag) {\n case \"Json\":\n return Schema.toCodecJson(schema);\n case \"FormUrlEncoded\":\n return Schema.toCodecStringTree(schema);\n case \"Text\":\n case \"Uint8Array\":\n case \"Multipart\":\n return schema;\n }\n}\n/**\n * Creates a `GET` endpoint declaration.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const get = /*#__PURE__*/make(\"GET\");\n/**\n * Creates a `POST` endpoint declaration.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const post = /*#__PURE__*/make(\"POST\");\n/**\n * Creates a `PUT` endpoint declaration.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const put = /*#__PURE__*/make(\"PUT\");\n/**\n * Creates a `PATCH` endpoint declaration.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const patch = /*#__PURE__*/make(\"PATCH\");\nconst del = /*#__PURE__*/make(\"DELETE\");\nexport {\n/**\n * Creates a `DELETE` endpoint declaration.\n *\n * @category constructors\n * @since 4.0.0\n */\ndel as delete };\n/**\n * Creates a `HEAD` endpoint declaration.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const head = /*#__PURE__*/make(\"HEAD\");\n/**\n * Creates an `OPTIONS` endpoint declaration.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const options = /*#__PURE__*/make(\"OPTIONS\");\n//# sourceMappingURL=HttpApiEndpoint.js.map","import * as Context from \"../../Context.js\";\nimport * as InternalRecord from \"../../internal/record.js\";\nimport { pipeArguments } from \"../../Pipeable.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as Record from \"../../Record.js\";\nimport * as HttpApiEndpoint from \"./HttpApiEndpoint.js\";\nimport * as HttpApiSchema from \"./HttpApiSchema.js\";\nconst TypeId = \"~effect/httpapi/HttpApi\";\n/**\n * Returns `true` when a value is an `HttpApi`.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpApi = u => Predicate.hasProperty(u, TypeId);\nconst Proto = {\n [TypeId]: TypeId,\n pipe() {\n return pipeArguments(this, arguments);\n },\n add(...toAdd) {\n const groups = {\n ...this.groups\n };\n for (const group of toAdd) {\n InternalRecord.assignProperty(groups, group.identifier, group);\n }\n return makeProto({\n ...optionsFromApi(this),\n groups\n });\n },\n addHttpApi(api) {\n const newGroups = {\n ...this.groups\n };\n for (const key of Object.keys(api.groups)) {\n const group = api.groups[key];\n InternalRecord.assignProperty(newGroups, key, group.annotateMerge(Context.merge(api.annotations, group.annotations)));\n }\n return makeProto({\n ...optionsFromApi(this),\n groups: newGroups\n });\n },\n prefix(prefix) {\n return makeProto({\n ...optionsFromApi(this),\n groups: Record.map(this.groups, group => group.prefix(prefix))\n });\n },\n middleware(tag) {\n return makeProto({\n ...optionsFromApi(this),\n groups: Record.map(this.groups, group => group.middleware(tag))\n });\n },\n annotate(key, value) {\n return makeProto({\n ...optionsFromApi(this),\n annotations: Context.add(this.annotations, key, value)\n });\n },\n annotateMerge(annotations) {\n return makeProto({\n ...optionsFromApi(this),\n annotations: Context.merge(this.annotations, annotations)\n });\n }\n};\nconst optionsFromApi = api => ({\n identifier: api.identifier,\n groups: api.groups,\n annotations: api.annotations\n});\nconst makeProto = options => {\n function HttpApi() {}\n Object.setPrototypeOf(HttpApi, Proto);\n return Object.assign(HttpApi, options);\n};\n/**\n * Creates an empty `HttpApi` with the supplied identifier.\n *\n * **When to use**\n *\n * Use when you need to start defining an HTTP API, add groups with `add` or\n * `addHttpApi`, provide endpoint implementations with `HttpApiBuilder.group`,\n * and register the API with `HttpApiBuilder.layer`.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = identifier => makeProto({\n identifier,\n groups: {},\n annotations: Context.empty()\n});\n/**\n * Describes the groups and endpoints in an `HttpApi`.\n *\n * **Details**\n *\n * The callbacks receive each group or endpoint with merged annotations, endpoint\n * middleware, and response schemas grouped by HTTP status.\n *\n * @category reflection\n * @since 4.0.0\n */\nexport const reflect = (self, options) => {\n const groups = Object.values(self.groups);\n for (const group of groups) {\n const groupAnnotations = Context.merge(self.annotations, group.annotations);\n options.onGroup({\n group,\n mergedAnnotations: groupAnnotations\n });\n const endpoints = Object.values(group.endpoints);\n for (const endpoint of endpoints) {\n if (options.predicate && !options.predicate({\n endpoint,\n group\n })) continue;\n options.onEndpoint({\n group,\n endpoint,\n middleware: endpoint.middlewares,\n mergedAnnotations: Context.merge(groupAnnotations, endpoint.annotations),\n successes: extractResponseContent(HttpApiEndpoint.getSuccessSchemas(endpoint), HttpApiSchema.getStatusSuccessSchema),\n errors: extractResponseContent(HttpApiEndpoint.getErrorSchemas(endpoint), HttpApiSchema.getStatusErrorSchema)\n });\n }\n }\n};\n// -------------------------------------------------------------------------------------\nconst extractResponseContent = (schemas, getStatus) => {\n const map = new Map();\n schemas.forEach(add);\n return map;\n function add(schema) {\n const body = HttpApiSchema.isWithHeaders(schema) ? schema.schema : schema;\n if (HttpApiSchema.isStreamSchema(body)) return;\n const status = getStatus(schema);\n const schemas = map.get(status);\n if (schemas === undefined) {\n map.set(status, [schema]);\n } else {\n schemas.push(schema);\n }\n }\n};\n/**\n * Adds additional schemas to components/schemas.\n * The provided schemas must have a `identifier` annotation.\n *\n * @category services\n * @since 4.0.0\n */\nexport class AdditionalSchemas extends /*#__PURE__*/Context.Service()(\"effect/httpapi/HttpApi/AdditionalSchemas\") {}\n//# sourceMappingURL=HttpApi.js.map","import * as Arr from \"../../Array.js\";\nimport * as Cause from \"../../Cause.js\";\nimport * as Channel from \"../../Channel.js\";\nimport * as ChannelSchema from \"../../ChannelSchema.js\";\nimport * as Data from \"../../Data.js\";\nimport * as Duration from \"../../Duration.js\";\nimport * as Effect from \"../../Effect.js\";\nimport { hasProperty } from \"../../Predicate.js\";\nimport * as Pull from \"../../Pull.js\";\nimport * as Result from \"../../Result.js\";\nimport * as Schema from \"../../Schema.js\";\nimport * as SchemaTransformation from \"../../SchemaTransformation.js\";\nconst SseErrorTypeId = \"~effect/encoding/Sse/SseError\";\n/**\n * Error reason raised when pending Server-Sent Events state exceeds the\n * configured maximum size.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class EventTooLarge extends /*#__PURE__*/Data.TaggedError(\"EventTooLarge\") {\n get message() {\n return `Pending SSE event exceeded the maximum size of ${this.maxEventSize}`;\n }\n}\n/**\n * Error raised when decoding a Server-Sent Events stream fails.\n *\n * @category errors\n * @since 4.0.0\n */\nexport class SseError extends /*#__PURE__*/Data.TaggedError(\"SseError\") {\n /**\n * Marks this value as an SSE decoding error.\n *\n * @since 4.0.0\n */\n [SseErrorTypeId] = SseErrorTypeId;\n /**\n * Delegates the public message to the underlying SSE error reason.\n *\n * @since 4.0.0\n */\n get message() {\n return this.reason.message;\n }\n}\nconst defaultMaxEventSize = 10 * 1024 * 1024;\n/**\n * Creates a channel that parses Server-Sent Events text chunks into `Event` values.\n *\n * **Details**\n *\n * SSE `retry` directives are emitted as `Retry` failures so callers can\n * reconnect with the requested delay.\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decode = options => Channel.fromTransform((upstream, _scope) => Effect.sync(() => {\n let buffer = [];\n let retry;\n const parser = makeParser(event => {\n if (event._tag === \"Retry\") {\n retry = event;\n } else {\n buffer.push(event);\n }\n }, options);\n const pump = Effect.flatMap(upstream, arr => {\n for (let i = 0; i < arr.length; i++) {\n const error = parser.feed(arr[i]);\n if (error !== undefined) {\n return Effect.fail(error);\n }\n }\n return Effect.void;\n });\n return Effect.suspend(function loop() {\n if (Arr.isArrayNonEmpty(buffer)) {\n const out = buffer;\n buffer = [];\n return Effect.succeed(out);\n } else if (retry) {\n return Effect.fail(retry);\n }\n return Effect.flatMap(pump, loop);\n });\n}));\n/**\n * Creates an SSE decoder channel that decodes each parsed event with a schema.\n *\n * **Details**\n *\n * The schema receives the untagged event shape containing `id`, `event`, and\n * string `data`.\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeSchema = (schema, options) => Channel.pipeTo(decode(options), ChannelSchema.decode(EventEncoded.pipe(Schema.decodeTo(schema)))());\n/**\n * Creates an SSE decoder channel that JSON-decodes each event `data` field with a schema.\n *\n * **Details**\n *\n * The output preserves the SSE `event` name and optional `id` while replacing\n * `data` with the decoded value.\n *\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeDataSchema = (schema, options) => {\n const eventSchema = Schema.Struct({\n ...EventEncoded.fields,\n data: Schema.fromJsonString(schema)\n });\n return Channel.pipeTo(decode(options), Channel.map(ChannelSchema.decode(eventSchema)(), Arr.map(event => ({\n ...event,\n id: event.id\n }))));\n};\n/**\n * Creates a stateful Server-Sent Events parser.\n *\n * **Details**\n *\n * Call `feed` with text chunks to parse `Event` and `Retry` values through the\n * callback, and call `reset` to clear any buffered event state. `feed` returns\n * an `SseError` if the pending event exceeds `maxEventSize`.\n *\n * @category decoding\n * @since 4.0.0\n */\nexport function makeParser(onParse, options) {\n const maxEventSize = options?.maxEventSize ?? defaultMaxEventSize;\n // Processing state\n let isFirstChunk;\n let buffer;\n let startingPosition;\n let startingFieldLength;\n let discardTrailingNewline;\n // Event state\n let lastEventId;\n let eventName;\n let data;\n reset();\n return {\n feed,\n reset\n };\n function reset() {\n isFirstChunk = true;\n buffer = \"\";\n startingPosition = 0;\n startingFieldLength = -1;\n discardTrailingNewline = false;\n lastEventId = undefined;\n eventName = undefined;\n data = \"\";\n }\n function feed(chunk) {\n buffer = buffer ? buffer + chunk : chunk;\n // Strip any UTF-8 byte order mark (BOM) at the start of the stream.\n // Note that we do not strip any non - UTF8 BOM, as eventsource streams are\n // always decoded as UTF8 as per the specification.\n if (isFirstChunk && buffer.startsWith(BOM)) {\n buffer = buffer.slice(BOM.length);\n }\n isFirstChunk = false;\n // Set up chunk-specific processing state\n const length = buffer.length;\n let position = 0;\n // Read the current buffer byte by byte\n while (position < length) {\n // EventSource allows for carriage return + line feed, which means we\n // need to ignore a linefeed character if the previous character was a\n // carriage return\n // @todo refactor to reduce nesting, consider checking previous byte?\n // @todo but consider multiple chunks etc\n if (discardTrailingNewline) {\n if (buffer[position] === \"\\n\") {\n ++position;\n }\n discardTrailingNewline = false;\n }\n let lineLength = -1;\n let fieldLength = startingFieldLength;\n let character;\n for (let index = position + startingPosition; lineLength < 0 && index < length; ++index) {\n character = buffer[index];\n if (character === \":\" && fieldLength < 0) {\n fieldLength = index - position;\n } else if (character === \"\\r\") {\n discardTrailingNewline = true;\n lineLength = index - position;\n } else if (character === \"\\n\") {\n lineLength = index - position;\n }\n }\n if (lineLength < 0) {\n startingPosition = length - position;\n startingFieldLength = fieldLength;\n break;\n } else {\n startingPosition = 0;\n startingFieldLength = -1;\n }\n parseEventStreamLine(buffer, position, fieldLength, lineLength);\n position += lineLength + 1;\n }\n if (position === length) {\n // If we consumed the entire buffer to read the event, reset the buffer\n buffer = \"\";\n } else if (position > 0) {\n // If there are bytes left to process, set the buffer to the unprocessed\n // portion of the buffer only\n buffer = buffer.slice(position);\n }\n if (buffer.length + data.length > maxEventSize) {\n const error = new SseError({\n reason: new EventTooLarge({\n maxEventSize\n })\n });\n reset();\n return error;\n }\n }\n function parseEventStreamLine(lineBuffer, index, fieldLength, lineLength) {\n if (lineLength === 0) {\n // We reached the last line of this event\n if (data.length > 0) {\n onParse({\n _tag: \"Event\",\n id: lastEventId,\n event: eventName || \"message\",\n data: data.slice(0, -1) // remove trailing newline\n });\n data = \"\";\n }\n eventName = undefined;\n return;\n }\n const noValue = fieldLength < 0;\n const field = lineBuffer.slice(index, index + (noValue ? lineLength : fieldLength));\n let step = 0;\n if (noValue) {\n step = lineLength;\n } else if (lineBuffer[index + fieldLength + 1] === \" \") {\n step = fieldLength + 2;\n } else {\n step = fieldLength + 1;\n }\n const position = index + step;\n const valueLength = lineLength - step;\n const value = lineBuffer.slice(position, position + valueLength).toString();\n if (field === \"data\") {\n data += value ? `${value}\\n` : \"\\n\";\n } else if (field === \"event\") {\n eventName = value;\n } else if (field === \"id\" && !value.includes(\"\\u0000\")) {\n lastEventId = value;\n } else if (field === \"retry\" && /^\\d+$/.test(value)) {\n const retry = parseInt(value, 10);\n onParse(new Retry({\n duration: Duration.millis(retry),\n lastEventId\n }));\n }\n }\n}\nconst BOM = \"\\uFEFF\";\n/**\n * Creates a channel that encodes `Event` values as Server-Sent Events text.\n *\n * **Details**\n *\n * If the upstream channel fails with `Retry`, the retry directive is written and\n * the encoder completes.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encode = () => Channel.fromTransform((upstream, _scope) => Effect.sync(() => {\n let done = false;\n const pull = upstream.pipe(Effect.map(Arr.map(encoder.write)), Effect.catchFilter(Retry.filter, retry => {\n done = true;\n return Effect.succeed(Arr.of(encoder.write(retry)));\n }), Pull.catchDone(() => Cause.done()));\n return Effect.suspend(() => done ? Cause.done() : pull);\n}));\n/**\n * Creates an SSE encoder channel for values accepted by a schema.\n *\n * **Details**\n *\n * Values are schema-encoded to the untagged SSE event shape, transformed to\n * `Event`, and then written as Server-Sent Events text.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encodeSchema = schema => ChannelSchema.encode(Event.pipe(Schema.decodeTo(schema, transformEvent)))().pipe(Channel.pipeTo(encode()));\n/**\n * Schema for the untagged Server-Sent Events payload shape containing an optional `id`, `event`, and string `data` fields.\n *\n * @category models\n * @since 4.0.0\n */\nexport const EventEncoded = /*#__PURE__*/Schema.Struct({\n id: /*#__PURE__*/Schema.optional(Schema.String),\n event: Schema.String,\n data: Schema.String\n});\n/**\n * Schema for the tagged Server-Sent Events message model that adds `_tag: \"Event\"` to the event name, optional event ID, and string data payload.\n *\n * @category models\n * @since 4.0.0\n */\nexport const Event = /*#__PURE__*/Schema.Struct({\n _tag: /*#__PURE__*/Schema.tag(\"Event\"),\n id: /*#__PURE__*/Schema.UndefinedOr(Schema.String),\n event: Schema.String,\n data: Schema.String\n});\n/**\n * Schema for transforming untagged SSE event payloads into tagged `Event`\n * models.\n *\n * @category models\n * @since 4.0.0\n */\nexport const transformEvent = /*#__PURE__*/SchemaTransformation.transform({\n decode: event => event,\n encode: event => ({\n _tag: \"Event\",\n id: event.id,\n event: event.event ?? \"message\",\n data: event.data\n })\n});\nconst RetryTypeId = \"~effect/encoding/Sse/Retry\";\n/**\n * Represents a Server-Sent Events retry directive.\n *\n * **Details**\n *\n * Decoders surface this value as a failure to request reconnection after\n * `duration`; encoders serialize an upstream `Retry` failure as a `retry:` line.\n *\n * @category models\n * @since 4.0.0\n */\nexport class Retry extends /*#__PURE__*/Data.TaggedClass(\"Retry\") {\n /**\n * Marks this value as an SSE retry directive for runtime guards.\n *\n * @since 4.0.0\n */\n [RetryTypeId] = RetryTypeId;\n /**\n * Returns `true` when the value is an SSE retry directive.\n *\n * @since 4.0.0\n */\n static is(u) {\n return hasProperty(u, RetryTypeId);\n }\n /**\n * Separates SSE retry directives from regular event values.\n *\n * @since 4.0.0\n */\n static filter(u) {\n return Retry.is(u) ? Result.succeed(u) : Result.fail(u);\n }\n}\n/**\n * Default Server-Sent Events encoder.\n *\n * **Details**\n *\n * It renders `Event` values as `id`, `event`, and `data` lines and renders\n * `Retry` values as `retry:` directives.\n *\n * @category encoding\n * @since 4.0.0\n */\nexport const encoder = {\n write(event) {\n switch (event._tag) {\n case \"Event\":\n {\n let data = \"\";\n if (event.id !== undefined) {\n data += `id: ${event.id}\\n`;\n }\n if (event.event !== \"message\") {\n data += `event: ${event.event}\\n`;\n }\n data += `data: ${event.data.replace(/\\n/g, \"\\ndata: \")}\\n`;\n return data + \"\\n\";\n }\n case \"Retry\":\n {\n return `retry: ${Duration.toMillis(event.duration)}\\n\\n`;\n }\n }\n }\n};\n//# sourceMappingURL=Sse.js.map","/**\n * Builds HTTP clients from `HttpApi` declarations.\n *\n * The client methods are derived from the groups and endpoints in an `HttpApi`\n * and run through an `HttpClient`. They use the same schema-driven contract as\n * the server: request parts are encoded from endpoint schemas, client\n * middleware is applied, the HTTP request is executed, and declared success or\n * error responses are decoded. This module also includes helpers for building a\n * client for only one group, one endpoint, or only the encoded URL.\n *\n * @since 4.0.0\n */\nimport * as Arr from \"../../Array.js\";\nimport * as Cause from \"../../Cause.js\";\nimport * as Effect from \"../../Effect.js\";\nimport { identity } from \"../../Function.js\";\nimport * as InternalRecord from \"../../internal/record.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as Schema from \"../../Schema.js\";\nimport * as SchemaAST from \"../../SchemaAST.js\";\nimport * as SchemaIssue from \"../../SchemaIssue.js\";\nimport * as SchemaTransformation from \"../../SchemaTransformation.js\";\nimport * as Stream from \"../../Stream.js\";\nimport * as UndefinedOr from \"../../UndefinedOr.js\";\nimport * as Sse from \"../encoding/Sse.js\";\nimport * as HttpBody from \"../http/HttpBody.js\";\nimport * as HttpClient from \"../http/HttpClient.js\";\nimport * as HttpClientError from \"../http/HttpClientError.js\";\nimport * as HttpClientRequest from \"../http/HttpClientRequest.js\";\nimport * as HttpMethod from \"../http/HttpMethod.js\";\nimport * as UrlParams from \"../http/UrlParams.js\";\nimport * as HttpApi from \"./HttpApi.js\";\nimport * as HttpApiEndpoint from \"./HttpApiEndpoint.js\";\nimport * as HttpApiSchema from \"./HttpApiSchema.js\";\nimport * as MediaType from \"./internal/mediaType.js\";\n/** @internal */\nexport const makeClient = (api, options) => Effect.gen(function* () {\n const services = yield* Effect.context();\n const httpClient = options.httpClient.pipe(options?.baseUrl === undefined ? identity : HttpClient.mapRequest(HttpClientRequest.prependUrl(options.baseUrl.toString())));\n function executeMiddleware(group, endpoint, request, middlewareKeys, index) {\n if (index === -1) {\n return httpClient.execute(request);\n }\n const middleware = services.mapUnsafe.get(middlewareKeys[index]);\n if (middleware === undefined) {\n return executeMiddleware(group, endpoint, request, middlewareKeys, index - 1);\n }\n return middleware({\n endpoint,\n group,\n request,\n next(request) {\n return executeMiddleware(group, endpoint, request, middlewareKeys, index - 1);\n }\n });\n }\n HttpApi.reflect(api, {\n predicate: options?.predicate,\n onGroup(onGroupOptions) {\n options.onGroup?.(onGroupOptions);\n },\n onEndpoint(onEndpointOptions) {\n const {\n group,\n endpoint,\n errors,\n successes\n } = onEndpointOptions;\n const makeUrl = compilePath(endpoint.path);\n const decodeMap = {\n orElse: statusOrElse\n };\n const errorAlternatives = new Map();\n for (const [status, schemas] of errors.entries()) {\n const grouped = groupSchemasByContentType(schemas);\n for (const [contentType, schemas] of grouped.entries()) {\n addResponseAlternative(errorAlternatives, status, contentType, schemasToResponse(schemas));\n }\n }\n for (const [status, alternatives] of errorAlternatives.entries()) {\n const decode = makeResponseDecoder(alternatives);\n decodeMap[status] = response => Effect.flatMap(Effect.catchCause(decode(response), cause => Effect.failCause(Cause.combine(Cause.fail(new HttpClientError.HttpClientError({\n reason: new HttpClientError.StatusCodeError({\n request: response.request,\n response\n })\n })), cause))), Effect.fail);\n }\n const successAlternatives = new Map();\n for (const [status, schemas] of successes.entries()) {\n const grouped = groupSchemasByContentType(schemas);\n for (const [contentType, schemas] of grouped.entries()) {\n addResponseAlternative(successAlternatives, status, contentType, schemasToResponse(schemas));\n }\n }\n for (const streamSuccess of getStreamSuccessSchemas(endpoint)) {\n const streamSchema = isWithHeadersStreamSuccess(streamSuccess) ? streamSuccess.schema : streamSuccess;\n addResponseAlternative(successAlternatives, HttpApiSchema.getStatusSuccessSchema(streamSuccess), streamSchema.contentType, streamToResponse(streamSuccess));\n }\n for (const [status, alternatives] of successAlternatives.entries()) {\n decodeMap[status] = makeResponseDecoder(alternatives);\n }\n // encoders\n const encodeParams = UndefinedOr.map(endpoint.params, Schema.encodeUnknownEffect);\n const payloadSchemas = HttpApiEndpoint.getPayloadSchemas(endpoint);\n const encodePayload = Arr.isArrayNonEmpty(payloadSchemas) ? HttpMethod.hasBody(endpoint.method) ? Schema.encodeUnknownEffect(getEncodePayloadSchema(payloadSchemas, endpoint.method)) : Schema.encodeUnknownEffect(Schema.Union(payloadSchemas)) : undefined;\n const encodeHeaders = UndefinedOr.map(endpoint.headers, Schema.encodeUnknownEffect);\n const encodeQuery = UndefinedOr.map(endpoint.query, Schema.encodeUnknownEffect);\n const middlewareKeys = Array.from(onEndpointOptions.middleware, tag => `${tag.key}/Client`);\n const endpointFn = Effect.fnUntraced(function* (request) {\n let httpRequest = HttpClientRequest.make(endpoint.method)(endpoint.path);\n if (request !== undefined) {\n // params\n if (encodeParams !== undefined) {\n const params = yield* encodeParams(request.params);\n httpRequest = HttpClientRequest.setUrl(httpRequest, makeUrl(params));\n }\n // payload\n if (encodePayload !== undefined) {\n if (HttpMethod.hasBody(endpoint.method)) {\n if (request.payload instanceof FormData) {\n httpRequest = HttpClientRequest.bodyFormData(httpRequest, request.payload);\n } else {\n const body = yield* encodePayload(request.payload);\n httpRequest = HttpClientRequest.setBody(httpRequest, body);\n }\n } else {\n const urlParams = yield* encodePayload(request.payload);\n httpRequest = HttpClientRequest.appendUrlParams(httpRequest, urlParams);\n }\n }\n // headers\n if (encodeHeaders !== undefined) {\n const headers = yield* encodeHeaders(request.headers);\n httpRequest = HttpClientRequest.setHeaders(httpRequest, headers);\n }\n // query\n if (encodeQuery !== undefined) {\n const query = yield* encodeQuery(request.query);\n httpRequest = HttpClientRequest.appendUrlParams(httpRequest, query);\n }\n }\n const response = yield* executeMiddleware(group, endpoint, httpRequest, middlewareKeys, middlewareKeys.length - 1);\n if (request?.responseMode === \"response-only\") {\n return response;\n }\n const decoded = (decodeMap[response.status] ?? decodeMap.orElse)(response, request?.sseOptions);\n const value = yield* options.transformResponse === undefined ? decoded : options.transformResponse(decoded);\n return request?.responseMode === \"decoded-and-response\" ? [value, response] : value;\n });\n options.onEndpoint({\n ...onEndpointOptions,\n endpointFn\n });\n }\n });\n});\n/**\n * Constructs a type-safe client for an HTTP API using the `HttpClient` service,\n * endpoint schemas, middleware, and optional client or response transformations.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = (api, options) => Effect.flatMap(HttpClient.HttpClient, httpClient => makeWith(api, {\n ...options,\n httpClient: options?.transformClient ? options.transformClient(httpClient) : httpClient\n}));\n/**\n * Constructs a type-safe client for an HTTP API from the supplied `HttpClient`,\n * using the API metadata to encode requests, execute middleware, and decode\n * responses.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const makeWith = (api, options) => {\n const client = {};\n return makeClient(api, {\n ...options,\n onGroup({\n group\n }) {\n if (group.topLevel) return;\n InternalRecord.assignProperty(client, group.identifier, {});\n },\n onEndpoint({\n endpoint,\n endpointFn,\n group\n }) {\n InternalRecord.assignProperty(group.topLevel ? client : client[group.identifier], endpoint.identifier, endpointFn);\n }\n }).pipe(Effect.as(client));\n};\n/**\n * Builds a typed client object for a single API group from the supplied\n * `HttpClient`, filtering the API to that group.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const group = (api, options) => {\n const client = {};\n return makeClient(api, {\n ...options,\n predicate: ({\n group\n }) => group.identifier === options.group,\n onEndpoint({\n endpoint,\n endpointFn\n }) {\n InternalRecord.assignProperty(client, endpoint.identifier, endpointFn);\n }\n }).pipe(Effect.map(() => client));\n};\n/**\n * Builds the typed client method for one endpoint in one API group, using the\n * supplied `HttpClient` and endpoint metadata.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const endpoint = (api, options) => {\n let client = undefined;\n return makeClient(api, {\n ...options,\n httpClient: options.transformClient ? options.transformClient(options.httpClient) : options.httpClient,\n predicate: ({\n endpoint,\n group\n }) => group.identifier === options.group && endpoint.identifier === options.endpoint,\n onEndpoint({\n endpointFn\n }) {\n client = endpointFn;\n }\n }).pipe(Effect.map(() => client));\n};\n/**\n * Creates a type-safe URL builder that mirrors `HttpApiClient.make`.\n *\n * **Example** (Building typed URLs)\n *\n * ```ts import.meta.vitest\n * import { Schema } from \"effect\"\n * import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup } from \"effect/unstable/httpapi\"\n *\n * const Api = HttpApi.make(\"Api\").add(\n * HttpApiGroup.make(\"users\").add(\n * HttpApiEndpoint.get(\"getUser\", \"/users/:id\", {\n * params: { id: Schema.String }\n * })\n * )\n * )\n *\n * const buildUrl = HttpApiClient.urlBuilder(Api, {\n * baseUrl: \"https://api.example.com\"\n * })\n *\n * buildUrl.users.getUser({\n * params: { id: \"123\" }\n * }) // => \"https://api.example.com/users/123\"\n * ```\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const urlBuilder = (api, options) => {\n const builder = {};\n HttpApi.reflect(api, {\n onGroup({\n group\n }) {\n if (group.topLevel) return;\n InternalRecord.assignProperty(builder, group.identifier, {});\n },\n onEndpoint({\n group,\n endpoint\n }) {\n const makeUrl = compilePath(endpoint.path);\n const encodeParams = endpoint.params === undefined ? undefined : Schema.encodeSync(endpoint.params);\n const encodeQuery = endpoint.query === undefined ? undefined : Schema.encodeSync(endpoint.query);\n const endpointBuilder = request => {\n const params = request?.params;\n const path = params === undefined ? endpoint.path : makeUrl(encodeParams === undefined ? params : encodeParams(params));\n const queryInput = request?.query === undefined ? undefined : encodeQuery === undefined ? request.query : encodeQuery(request.query);\n const urlParams = queryInput === undefined ? UrlParams.empty : UrlParams.fromInput(queryInput);\n if (options?.baseUrl === undefined) {\n const query = UrlParams.toString(urlParams);\n return query === \"\" ? path : `${path}?${query}`;\n }\n const url = new URL(HttpClientRequest.prependUrl(HttpClientRequest.get(path), options.baseUrl.toString()).url);\n for (const [key, value] of urlParams.params) {\n if (value !== undefined) {\n url.searchParams.append(key, value);\n }\n }\n return url.toString();\n };\n InternalRecord.assignProperty(group.topLevel ? builder : builder[group.identifier], endpoint.identifier, endpointBuilder);\n }\n });\n return builder;\n};\n// ----------------------------------------------------------------------------\nconst paramsRegExp = /(\\/?):(\\w+)(\\?)?/g;\nconst compilePath = path => {\n if (!paramsRegExp.test(path)) {\n return _ => path;\n }\n paramsRegExp.lastIndex = 0;\n return params => {\n paramsRegExp.lastIndex = 0;\n return path.replace(paramsRegExp, (_, slash, key, optional) => {\n const value = params[key];\n if (value === undefined) {\n if (optional !== undefined) {\n return \"\";\n }\n throw new Error(`Missing path parameter: ${key}`);\n }\n return `${slash}${encodeURIComponent(value)}`;\n });\n };\n};\nfunction schemasToResponse(schemas) {\n const hasWithHeaders = schemas.some(schema => HttpApiSchema.isWithHeaders(schema) || HttpApiSchema.getWithHeadersAnnotation(schema.ast) !== undefined);\n const codec = hasWithHeaders ? Schema.Union(schemas.map(toCodecArrayBufferWithHeaders)) : toCodecArrayBuffer(schemas);\n const decode = Schema.decodeEffect(codec);\n return response => Effect.flatMap(response.arrayBuffer, hasWithHeaders ? body => decode({\n body,\n headers: response.headers\n }) : decode);\n}\nfunction toCodecArrayBufferWithHeaders(schema) {\n const isWithHeaders = HttpApiSchema.isWithHeaders(schema);\n const annotation = HttpApiSchema.getWithHeadersAnnotation(schema.ast);\n if (annotation !== undefined) {\n return Schema.Struct({\n body: fromArrayBuffer(annotation.body),\n headers: annotation.headersCodec\n }).pipe(Schema.decodeTo(schema));\n }\n const body = isWithHeaders ? schema.schema : schema;\n return Schema.Struct({\n body: fromArrayBuffer(body).pipe(Schema.decodeTo(body)),\n headers: isWithHeaders ? schema.headers : Schema.Unknown\n }).pipe(Schema.decodeTo(isWithHeaders ? schema : Schema.toType(schema), SchemaTransformation.transform({\n decode: value => isWithHeaders ? HttpApiSchema.withHeaders(value) : value.body,\n encode: value => isWithHeaders ? value : {\n body: value,\n headers: undefined\n }\n })));\n}\nfunction addResponseAlternative(map, status, contentType, decode) {\n const normalizedContentType = MediaType.normalize(contentType);\n const alternatives = map.get(status);\n if (alternatives === undefined) {\n map.set(status, [{\n contentType: normalizedContentType,\n decode\n }]);\n } else {\n alternatives.push({\n contentType: normalizedContentType,\n decode\n });\n }\n}\nfunction makeResponseDecoder(alternatives) {\n const first = alternatives[0];\n if (alternatives.length === 1 && first !== undefined) {\n return first.decode;\n }\n return (response, sseOptions) => {\n const contentType = MediaType.normalize(response.headers[\"content-type\"] ?? \"\");\n const alternative = alternatives.find(alternative => alternative.contentType === contentType);\n return alternative === undefined ? failUnsupportedContentType(response, contentType, alternatives) : alternative.decode(response, sseOptions);\n };\n}\nfunction groupSchemasByContentType(schemas) {\n const grouped = new Map();\n for (const schema of schemas) {\n const body = HttpApiSchema.isWithHeaders(schema) ? schema.schema : schema;\n const contentType = HttpApiSchema.isNoContent(body.ast) ? \"\" : MediaType.normalize(HttpApiSchema.getResponseEncodingSchema(schema).contentType);\n const existing = grouped.get(contentType);\n if (existing === undefined) {\n grouped.set(contentType, [schema]);\n } else {\n existing.push(schema);\n }\n }\n return grouped;\n}\nfunction failUnsupportedContentType(response, contentType, alternatives) {\n const expected = Array.from(new Set(alternatives.map(alternative => alternative.contentType))).join(\", \");\n return Effect.fail(new HttpClientError.HttpClientError({\n reason: new HttpClientError.DecodeError({\n request: response.request,\n response,\n description: `Unsupported response content-type for status ${response.status}: ${contentType || \"\"}. Expected one of: ${expected}`\n })\n }));\n}\nconst reservedStreamFailureEvent = \"effect/httpapi/stream/failure\";\nconst isWithHeadersStreamSuccess = schema => HttpApiSchema.isWithHeaders(schema);\nfunction getStreamSuccessSchemas(endpoint) {\n const schemas = [];\n for (const schema of endpoint.success) {\n const body = HttpApiSchema.isWithHeaders(schema) ? schema.schema : schema;\n if (HttpApiSchema.isStreamSchema(body)) {\n schemas.push(schema);\n }\n }\n return schemas;\n}\nfunction streamToResponse(successSchema) {\n const isWithHeaders = isWithHeadersStreamSuccess(successSchema);\n const streamSchema = isWithHeaders ? successSchema.schema : successSchema;\n const sse = HttpApiSchema.isStreamUint8Array(streamSchema) ? undefined : {\n declaration: streamSchema,\n decoder: makeSseDecoder(streamSchema)\n };\n const toStream = (response, sseOptions) => Effect.map(Effect.context(), context => Stream.provideContext(sse === undefined ? response.stream : decodeSseStream(response.stream, sse.declaration, sse.decoder(sseOptions)), context));\n if (!isWithHeaders) return toStream;\n const decodeHeaders = Schema.decodeUnknownEffect(successSchema.headers);\n return (response, sseOptions) => Effect.flatMap(decodeHeaders(response.headers), headers => Effect.map(toStream(response, sseOptions), body => HttpApiSchema.withHeaders({\n body,\n headers\n })));\n}\nfunction makeSseDecoder(declaration) {\n const Event = Schema.Union([Schema.Struct({\n event: Schema.Literal(reservedStreamFailureEvent),\n data: Schema.fromJsonString(Schema.toCodecJson(Schema.Cause(declaration.error, Schema.Defect())))\n }), declaration.events]);\n const defaultDecoder = Sse.decodeSchema(Event);\n return options => options === undefined ? defaultDecoder : Sse.decodeSchema(Event, options);\n}\nfunction decodeSseStream(stream, declaration, decoder) {\n const events = Stream.transformPull(stream.pipe(Stream.decodeText, Stream.pipeThroughChannel(decoder)), pull => Effect.sync(() => {\n let pendingFailureCause = undefined;\n return Effect.suspend(() => {\n if (pendingFailureCause !== undefined) {\n return Effect.failCause(pendingFailureCause);\n }\n return Effect.flatMap(pull, events => {\n for (let i = 0; i < events.length; i++) {\n const event = events[i];\n if (event.event === reservedStreamFailureEvent && Cause.isCause(event.data)) {\n if (i === 0) {\n return Effect.failCause(event.data);\n }\n pendingFailureCause = event.data;\n events = events.slice(0, i);\n break;\n }\n }\n return Effect.succeed(events);\n });\n });\n }));\n if (declaration.sseMode === \"data\") {\n return Stream.map(events, event => event.data);\n }\n return events;\n}\nconst ArrayBuffer = /*#__PURE__*/Schema.instanceOf(globalThis.ArrayBuffer, {\n expected: \"ArrayBuffer\"\n});\n// _tag: Uint8Array\nconst Uint8ArrayFromArrayBuffer = /*#__PURE__*/ArrayBuffer.pipe(/*#__PURE__*/Schema.decodeTo(Schema.Uint8Array, /*#__PURE__*/SchemaTransformation.transform({\n decode(fromA) {\n return new Uint8Array(fromA);\n },\n encode(arr) {\n return arr.byteLength === arr.buffer.byteLength ? arr.buffer : arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);\n }\n})));\n// _tag: Text\nconst StringFromArrayBuffer = /*#__PURE__*/ArrayBuffer.pipe(/*#__PURE__*/Schema.decodeTo(Schema.String, /*#__PURE__*/SchemaTransformation.transform({\n decode(fromA) {\n return new TextDecoder().decode(fromA);\n },\n encode(toI) {\n const arr = new TextEncoder().encode(toI);\n return arr.byteLength === arr.buffer.byteLength ? arr.buffer : arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);\n }\n})));\n// _tag: Json\nconst UnknownFromArrayBuffer = /*#__PURE__*/StringFromArrayBuffer.pipe(/*#__PURE__*/Schema.decodeTo(/*#__PURE__*/Schema.Union([\n/*#__PURE__*/\n// Handle No Content\nSchema.Literal(\"\").pipe(/*#__PURE__*/Schema.decodeTo(Schema.Undefined, /*#__PURE__*/SchemaTransformation.transform({\n decode: () => undefined,\n encode: () => \"\"\n}))), Schema.UnknownFromJsonString])));\nfunction toCodecArrayBuffer(schemas) {\n return Schema.Union(schemas.map(onSchema));\n function onSchema(schema) {\n return fromArrayBuffer(schema).pipe(Schema.decodeTo(schema));\n }\n}\nfunction fromArrayBuffer(schema) {\n const encoding = HttpApiSchema.getResponseEncoding(schema.ast);\n switch (encoding._tag) {\n case \"Json\":\n {\n // handle json codecs that transform void schemas to null\n const encodedIsNull = SchemaAST.isNull(SchemaAST.toEncoded(schema.ast));\n return encodedIsNull ? UnknownFromArrayBuffer.pipe(Schema.decodeTo(Schema.Unknown, SchemaTransformation.transform({\n decode: a => a === undefined ? null : a,\n encode: a => a === null ? undefined : a\n }))) : UnknownFromArrayBuffer;\n }\n case \"FormUrlEncoded\":\n return StringFromArrayBuffer.pipe(Schema.decodeTo(Schema.RecordFromUrlParams, SchemaTransformation.transform({\n decode: text => UrlParams.fromInput(new URLSearchParams(text)),\n encode: UrlParams.toString\n })));\n case \"Uint8Array\":\n return Uint8ArrayFromArrayBuffer;\n case \"Text\":\n return StringFromArrayBuffer;\n }\n}\nconst statusOrElse = response => Effect.fail(new HttpClientError.HttpClientError({\n reason: new HttpClientError.DecodeError({\n request: response.request,\n response\n })\n}));\nconst $HttpBody = /*#__PURE__*/Schema.declare(HttpBody.isHttpBody);\nfunction getEncodePayloadSchema(schemas, method) {\n return Schema.Union(schemas.map(s => getEncodePayloadSchemaFromBody(s, method)));\n}\nconst bodyFromPayloadCache = /*#__PURE__*/new WeakMap();\nfunction getEncodePayloadSchemaFromBody(schema, method) {\n const ast = schema.ast;\n const cached = bodyFromPayloadCache.get(ast);\n if (cached !== undefined) {\n return cached;\n }\n const encoding = HttpApiSchema.getPayloadEncoding(ast, method);\n const out = $HttpBody.pipe(Schema.decodeTo(schema, SchemaTransformation.transformEffect({\n decode(input, options) {\n return Effect.fail(new SchemaIssue.Forbidden({\n message: \"Encode only schema\"\n }, input, options));\n },\n encode(t, options) {\n switch (encoding._tag) {\n case \"Multipart\":\n return Effect.fail(new SchemaIssue.Forbidden({\n message: \"Payload must be a FormData\"\n }, t, options));\n case \"Json\":\n {\n try {\n const body = JSON.stringify(t);\n return Effect.succeed(HttpBody.text(body, encoding.contentType));\n } catch {\n return Effect.fail(new SchemaIssue.InvalidValue({\n expected: \"a JSON-serializable request body\"\n }, t, options));\n }\n }\n case \"Text\":\n {\n if (typeof t !== \"string\") {\n return Effect.fail(new SchemaIssue.InvalidValue({\n message: \"Expected a string\"\n }, t, options));\n }\n return Effect.succeed(HttpBody.text(t, encoding.contentType));\n }\n case \"FormUrlEncoded\":\n {\n if (!Predicate.isObject(t)) {\n return Effect.fail(new SchemaIssue.InvalidValue({\n message: \"Expected a record\"\n }, t, options));\n }\n return Effect.succeed(HttpBody.urlParams(UrlParams.fromInput(t), encoding.contentType));\n }\n case \"Uint8Array\":\n {\n if (!(t instanceof Uint8Array)) {\n return Effect.fail(new SchemaIssue.InvalidValue({\n message: \"Expected a Uint8Array\"\n }, t, options));\n }\n return Effect.succeed(HttpBody.uint8Array(t, encoding.contentType));\n }\n }\n }\n })));\n bodyFromPayloadCache.set(ast, out);\n return out;\n}\n//# sourceMappingURL=HttpApiClient.js.map","import * as Context from \"../../Context.js\";\nimport * as InternalRecord from \"../../internal/record.js\";\nimport { pipeArguments } from \"../../Pipeable.js\";\nimport * as Predicate from \"../../Predicate.js\";\nimport * as Record from \"../../Record.js\";\nconst TypeId = \"~effect/httpapi/HttpApiGroup\";\n/**\n * Returns `true` when a value is an `HttpApiGroup`, narrowing the value to the\n * group interface.\n *\n * @category guards\n * @since 4.0.0\n */\nexport const isHttpApiGroup = u => Predicate.hasProperty(u, TypeId);\nconst Proto = {\n [TypeId]: TypeId,\n add(...toAdd) {\n const endpoints = {\n ...this.endpoints\n };\n for (const endpoint of toAdd) {\n InternalRecord.assignProperty(endpoints, endpoint.identifier, endpoint);\n }\n return makeProto({\n ...optionsFromGroup(this),\n endpoints\n });\n },\n prefix(prefix) {\n return makeProto({\n ...optionsFromGroup(this),\n endpoints: Record.map(this.endpoints, endpoint => endpoint.prefix(prefix))\n });\n },\n middleware(middleware) {\n return makeProto({\n ...optionsFromGroup(this),\n endpoints: Record.map(this.endpoints, endpoint => endpoint.middleware(middleware))\n });\n },\n annotateMerge(annotations) {\n return makeProto({\n ...optionsFromGroup(this),\n annotations: Context.merge(this.annotations, annotations)\n });\n },\n annotate(annotation, value) {\n return makeProto({\n ...optionsFromGroup(this),\n annotations: Context.add(this.annotations, annotation, value)\n });\n },\n annotateEndpointsMerge(annotations) {\n return makeProto({\n ...optionsFromGroup(this),\n endpoints: Record.map(this.endpoints, endpoint => endpoint.annotateMerge(annotations))\n });\n },\n annotateEndpoints(annotation, value) {\n return makeProto({\n ...optionsFromGroup(this),\n endpoints: Record.map(this.endpoints, endpoint => endpoint.annotate(annotation, value))\n });\n },\n pipe() {\n return pipeArguments(this, arguments);\n }\n};\nconst optionsFromGroup = group => ({\n identifier: group.identifier,\n topLevel: group.topLevel,\n endpoints: group.endpoints,\n annotations: group.annotations\n});\nconst makeProto = options => {\n function HttpApiGroup() {}\n Object.setPrototypeOf(HttpApiGroup, Proto);\n HttpApiGroup.key = `effect/httpapi/HttpApiGroup/${options.identifier}`;\n return Object.assign(HttpApiGroup, options);\n};\n/**\n * Creates an empty `HttpApiGroup` with the supplied identifier.\n *\n * **Details**\n *\n * Add endpoints with `add`, provide implementations with `HttpApiBuilder.group`,\n * and set `topLevel` when the generated client should expose endpoint methods\n * directly instead of nesting them under the group identifier.\n *\n * @category constructors\n * @since 4.0.0\n */\nexport const make = (identifier, options) => makeProto({\n identifier,\n topLevel: options?.topLevel ?? false,\n endpoints: {},\n annotations: Context.empty()\n});\n//# sourceMappingURL=HttpApiGroup.js.map","import { Array, Order, pipe, Schema as S } from 'effect'\nimport { HttpApi, HttpApiEndpoint, HttpApiGroup } from 'effect/unstable/httpapi'\n\nexport const ZAI_BASE_URL = {\n zai: 'https://api.z.ai',\n 'zai-coding-cn': 'https://open.bigmodel.cn',\n} as const\nexport type ZaiProvider = keyof typeof ZAI_BASE_URL\n\nexport const QuotaLimit = S.Struct({\n type: S.optional(S.NullOr(S.String)),\n /** Total quota of the window, despite the name. */\n usage: S.optional(S.NullOr(S.Number)),\n currentValue: S.optional(S.NullOr(S.Number)),\n percentage: S.optional(S.NullOr(S.Number)),\n nextResetTime: S.optional(S.NullOr(S.DateFromMillis)),\n})\nexport type QuotaLimit = typeof QuotaLimit.Type\n\nexport const GlmUsage = S.Struct({\n level: S.optional(S.NullOr(S.String)),\n limits: S.optional(S.NullOr(S.Array(QuotaLimit))),\n})\nexport type GlmUsage = typeof GlmUsage.Type\n\nexport const GlmUsageEnvelope = S.Union([\n S.Struct({ success: S.Literal(true), data: GlmUsage }),\n S.Struct({\n success: S.Literal(false),\n code: S.Number,\n msg: S.optional(S.NullOr(S.String)),\n }),\n])\nexport type GlmUsageEnvelope = typeof GlmUsageEnvelope.Type\n\nexport const GlmUsageApi = HttpApi.make('GlmUsage').add(\n HttpApiGroup.make('monitor', { topLevel: true }).add(\n HttpApiEndpoint.get('usage', '/api/monitor/usage/quota/limit', {\n success: GlmUsageEnvelope,\n }),\n ),\n)\n\n/** Nothing names a window, so like the official dashboard: first reset = 5h, second = weekly. */\nexport function glmRateLimits(usage: GlmUsage): QuotaLimit[] {\n return pipe(\n usage.limits ?? [],\n Array.filter(\n (limit) => limit.type === 'TOKENS_LIMIT' || limit.type === 'CREDIT_LIMIT',\n ),\n Array.sortWith(\n (limit) => limit.nextResetTime?.getTime() ?? Number.POSITIVE_INFINITY,\n Order.Number,\n ),\n )\n}\n","import type { RateLimitWindow } from './provider/openai'\n\nexport function parseResetsAt(\n value: string | number | null | undefined,\n): Date | null {\n if (typeof value === 'number') {\n // Epoch seconds, as Claude Code assumes.\n return new Date(value * 1000)\n }\n if (typeof value === 'string') {\n const date = new Date(value)\n return Number.isNaN(date.getTime()) ? null : date\n }\n return null\n}\n\nexport function codexResetsAt(window: RateLimitWindow, now: Date): Date | null {\n if (typeof window.reset_after_seconds === 'number') {\n return new Date(now.getTime() + window.reset_after_seconds * 1000)\n }\n if (typeof window.reset_at === 'number') {\n return new Date(window.reset_at * 1000)\n }\n return null\n}\n\nexport function formatDuration(ms: number): string {\n const minutes = Math.max(Math.ceil(ms / 60_000), 0)\n if (minutes < 60) {\n return `${minutes}m`\n }\n const hours = Math.floor(minutes / 60)\n if (hours < 24) {\n return `${hours}h ${minutes % 60}m`\n }\n const days = Math.floor(hours / 24)\n return `${days}d ${hours % 24}h`\n}\n\nexport function formatCompactDuration(ms: number): string {\n const minutes = Math.floor(ms / 60_000)\n if (minutes < 60) {\n return `${Math.max(minutes, 1)}m`\n }\n const hours = Math.floor(minutes / 60)\n if (hours < 24) {\n return `${hours}h${minutes % 60}m`\n }\n return `${Math.floor(hours / 24)}d`\n}\n","import type { Theme } from '@earendil-works/pi-coding-agent'\nimport { Array, Match } from 'effect'\nimport type {\n ClaudeAccountUsage,\n UnifiedLimit,\n UsageWindow,\n} from './provider/anthropic'\nimport type { CodexUsage, RateLimitDetails } from './provider/openai'\nimport { glmRateLimits, type GlmUsage, type QuotaLimit } from './provider/zai'\nimport { codexResetsAt, formatDuration, parseResetsAt } from './reset'\n\nconst BAR_WIDTH = 10\n// e.g. default_claude_max_5x, default_claude_max_20x, default_claude_pro\nconst CLAUDE_PLAN_TIER = /^default_claude_(max|pro)(?:_(\\d+x))?$/\nconst numberFormat = new Intl.NumberFormat('en-US')\n\nexport interface UsageRow {\n readonly label: string\n readonly percent?: number | null | undefined\n readonly resetsAt?: number | null | undefined\n readonly note?: string | undefined\n}\n\nexport type UsageSection =\n | { readonly title: string; readonly rows: readonly UsageRow[] }\n | { readonly title: string; readonly error: string }\n\nexport interface UsageReport {\n readonly fetchedAt: number\n readonly sections: readonly UsageSection[]\n}\n\nexport function renderReport(report: UsageReport, theme: Theme): string {\n const labelWidth =\n Math.max(\n 0,\n ...report.sections.flatMap((section) =>\n 'rows' in section ? section.rows.map((row) => row.label.length) : [],\n ),\n ) + 1\n\n let info = `${theme.bold('Usage')}\\n\\n`\n info += `${theme.fg('dim', 'Fetched:')} ${new Date(report.fetchedAt).toLocaleString()}\\n`\n\n for (const section of report.sections) {\n info += `\\n${theme.bold(section.title)}\\n`\n if ('error' in section) {\n info += `${theme.fg('warning', section.error)}\\n`\n continue\n }\n if (section.rows.length === 0) {\n info += `${theme.fg('dim', 'No usage data reported')}\\n`\n continue\n }\n for (const row of section.rows) {\n const details: string[] = []\n if (row.resetsAt) {\n const delta = row.resetsAt - report.fetchedAt\n details.push(\n delta > 0 ? `resets in ${formatDuration(delta)}` : 'resets soon',\n )\n }\n if (row.note) {\n details.push(row.note)\n }\n\n info += theme.fg('dim', `${row.label}:`.padEnd(labelWidth))\n if (typeof row.percent === 'number') {\n const clamped = Math.min(Math.max(row.percent, 0), 100)\n const filled = Math.round((clamped / 100) * BAR_WIDTH)\n info += ` [${'█'.repeat(filled)}${'░'.repeat(BAR_WIDTH - filled)}]`\n info += `${Math.round(row.percent)}%`.padStart(5)\n if (details.length > 0) {\n info += ` ${theme.fg('dim', `(${details.join(', ')})`)}`\n }\n } else {\n info += ` ${details.join(', ')}`\n }\n info += '\\n'\n }\n }\n\n return info.trimEnd()\n}\n\nfunction formatMinorAmount(\n amount: number,\n decimalPlaces: number,\n currency: string | null | undefined,\n): string {\n const value = amount / 10 ** decimalPlaces\n if (currency) {\n try {\n return new Intl.NumberFormat('en-US', { style: 'currency', currency }).format(\n value,\n )\n } catch {\n // Unknown currency code.\n }\n }\n return value.toFixed(decimalPlaces)\n}\n\nfunction unifiedLimitLabel(limit: UnifiedLimit): string {\n switch (limit.kind) {\n case 'session':\n return 'Session (5h)'\n case 'weekly_all':\n return 'Week (all models)'\n case 'weekly_scoped': {\n const model = limit.scope?.model\n return `Week (${model?.display_name ?? model?.id ?? 'scoped'})`\n }\n default:\n return limit.kind\n }\n}\n\nfunction sectionTitle(\n name: string,\n plan: string | null | undefined,\n email: string | null | undefined,\n): string {\n const title = plan ? `${name} (${plan})` : name\n return email ? `${title} — ${email}` : title\n}\n\nexport function claudeSection({ usage, profile }: ClaudeAccountUsage): UsageSection {\n const rows: UsageRow[] = []\n\n const limits = usage.limits ?? []\n if (limits.length > 0) {\n // `is_active` marks the currently binding limit, not visibility, so every\n // limit is listed.\n for (const limit of limits) {\n rows.push({\n label: unifiedLimitLabel(limit),\n percent: limit.percent,\n resetsAt: parseResetsAt(limit.resets_at)?.getTime(),\n })\n }\n } else {\n const flatWindows: [string, UsageWindow | null | undefined][] = [\n ['Session (5h)', usage.five_hour],\n ['Week (all models)', usage.seven_day],\n ['Week (Opus)', usage.seven_day_opus],\n ['Week (Sonnet)', usage.seven_day_sonnet],\n ]\n for (const [label, window] of flatWindows) {\n if (window && typeof window.utilization === 'number') {\n rows.push({\n label,\n percent: window.utilization,\n resetsAt: parseResetsAt(window.resets_at)?.getTime(),\n })\n }\n }\n }\n\n const extra = usage.extra_usage\n if (extra) {\n const decimals = extra.decimal_places ?? 2\n const used =\n typeof extra.used_credits === 'number'\n ? formatMinorAmount(extra.used_credits, decimals, extra.currency)\n : null\n const limit =\n typeof extra.monthly_limit === 'number'\n ? formatMinorAmount(extra.monthly_limit, decimals, extra.currency)\n : null\n if (used !== null) {\n rows.push({\n label: 'Extra usage',\n percent: extra.utilization,\n note: limit ? `${used} of ${limit}` : used,\n })\n }\n if (extra.is_enabled === false) {\n const reason = extra.disabled_reason\n ?.split('_')\n .filter(Boolean)\n .map((part) => part.charAt(0).toUpperCase() + part.slice(1))\n .join(' ')\n rows.push({\n label: 'Extra usage',\n note: reason ? `disabled — ${reason}` : 'disabled',\n })\n }\n }\n\n const plan = Match.value(profile).pipe(\n Match.when(\n {\n organization: {\n rate_limit_tier: (tier: string) => CLAUDE_PLAN_TIER.test(tier),\n },\n },\n ({ organization }) => {\n const [, kind, multiplier] =\n organization.rate_limit_tier.match(CLAUDE_PLAN_TIER)!\n const plan = kind === 'max' ? 'Max' : 'Pro'\n return multiplier ? `${plan} ${multiplier}` : plan\n },\n ),\n Match.when({ account: { has_claude_max: true } }, () => 'Max'),\n Match.when({ account: { has_claude_pro: true } }, () => 'Pro'),\n Match.orElse(() => undefined),\n )\n return { title: sectionTitle('Claude', plan, profile?.account?.email), rows }\n}\n\nfunction codexWindowName(seconds: number | null | undefined): string {\n if (typeof seconds !== 'number' || seconds <= 0) {\n return 'Window'\n }\n if (seconds >= 604_800 * 0.9) {\n return 'Week'\n }\n if (seconds >= 86_400) {\n return `${Math.round(seconds / 86_400)}d`\n }\n return `${Math.round(seconds / 3600)}h`\n}\n\nfunction codexWindowRows(\n details: RateLimitDetails | null | undefined,\n now: Date,\n labelFor: (windowName: string) => string,\n): UsageRow[] {\n const rows: UsageRow[] = []\n for (const window of [details?.primary_window, details?.secondary_window]) {\n if (!window) {\n continue\n }\n rows.push({\n label: labelFor(codexWindowName(window.limit_window_seconds)),\n percent: window.used_percent,\n resetsAt: codexResetsAt(window, now)?.getTime(),\n })\n }\n return rows\n}\n\nexport function codexSection(usage: CodexUsage, now: Date): UsageSection {\n const rows: UsageRow[] = codexWindowRows(usage.rate_limit, now, (name) =>\n name === 'Week' ? 'Week limit' : `${name} limit`,\n )\n\n for (const additional of usage.additional_rate_limits ?? []) {\n rows.push(\n ...codexWindowRows(\n additional.rate_limit,\n now,\n (name) => `${additional.limit_name} (${name})`,\n ),\n )\n }\n\n const credits = usage.credits\n if (\n credits &&\n (credits.unlimited || (credits.has_credits && credits.balance != null))\n ) {\n rows.push({\n label: 'Credits',\n note: credits.unlimited ? 'unlimited' : `balance ${credits.balance}`,\n })\n }\n\n const resetCredits = usage.rate_limit_reset_credits\n if (resetCredits && resetCredits.available_count > 0) {\n rows.push({\n label: 'Rate-limit resets',\n note: `${resetCredits.available_count} available`,\n })\n }\n\n return {\n title: sectionTitle('OpenAI Codex', usage.plan_type, usage.email),\n rows,\n }\n}\n\nfunction glmRow(label: string, limit: QuotaLimit): UsageRow {\n const unit =\n limit.type === 'CREDIT_LIMIT'\n ? 'credits'\n : limit.type === 'TIME_LIMIT'\n ? 'calls'\n : 'tokens'\n return {\n label,\n percent: limit.percentage,\n resetsAt: limit.nextResetTime?.getTime(),\n note:\n typeof limit.currentValue === 'number' &&\n typeof limit.usage === 'number' &&\n limit.usage > 0\n ? `${numberFormat.format(limit.currentValue)} of ${numberFormat.format(limit.usage)} ${unit}`\n : undefined,\n }\n}\n\nexport function glmSection(usage: GlmUsage): UsageSection {\n const rows = Array.zipWith(['Session (5h)', 'Week'], glmRateLimits(usage), glmRow)\n\n const mcp = usage.limits?.find((limit) => limit.type === 'TIME_LIMIT')\n if (mcp) {\n rows.push(glmRow('MCP tools (month)', mcp))\n }\n\n const title = usage.level ? `GLM Coding (${usage.level})` : 'GLM Coding'\n return { title, rows }\n}\n","/**\n * Fetch-based implementation of the Effect HTTP client service.\n *\n * This module provides an `HttpClient` layer that executes requests through a\n * Web Fetch API implementation. It is the transport to use in browsers, edge\n * runtimes, and Node.js environments where `globalThis.fetch` is available, or\n * anywhere a compatible fetch function can be supplied.\n *\n * @since 4.0.0\n */\nimport * as Context from \"../../Context.js\";\nimport * as Effect from \"../../Effect.js\";\nimport * as Stream from \"../../Stream.js\";\nimport * as Headers from \"./Headers.js\";\nimport * as HttpClient from \"./HttpClient.js\";\nimport * as HttpClientError from \"./HttpClientError.js\";\nimport * as HttpClientResponse from \"./HttpClientResponse.js\";\n/**\n * Context reference for the `fetch` implementation used by the fetch-based HTTP client.\n *\n * **Details**\n *\n * Defaults to `globalThis.fetch`.\n *\n * @category services\n * @since 4.0.0\n */\nexport const Fetch = /*#__PURE__*/Context.Reference(\"effect/http/FetchHttpClient/Fetch\", {\n defaultValue: () => globalThis.fetch\n});\n/**\n * Service that contains default fetch options for the fetch-based HTTP client.\n *\n * **When to use**\n *\n * Use to provide default credentials, cache, redirect, integrity, or other\n * fetch options for outgoing HTTP requests.\n *\n * **Details**\n *\n * Request-specific method, headers, body, and abort signal are supplied by the client when a request is executed.\n *\n * @category services\n * @since 4.0.0\n */\nexport class RequestInit extends /*#__PURE__*/Context.Service()(\"effect/http/FetchHttpClient/RequestInit\") {}\nconst fetch = /*#__PURE__*/HttpClient.make((request, url, signal, fiber) => {\n const fetch = fiber.getRef(Fetch);\n const options = Context.getOrUndefined(fiber.context, RequestInit) ?? {};\n let headers = options.headers ? Headers.merge(Headers.fromInput(options.headers), request.headers) : request.headers;\n if (headers[\"content-length\"]) {\n headers = Headers.remove(headers, \"content-length\");\n }\n const send = body => Effect.map(Effect.tryPromise({\n try: () => fetch(url, {\n ...options,\n method: request.method,\n headers,\n body,\n duplex: typeof ReadableStream !== \"undefined\" && body instanceof ReadableStream ? \"half\" : undefined,\n signal\n }),\n catch: cause => new HttpClientError.HttpClientError({\n reason: new HttpClientError.TransportError({\n request,\n cause\n })\n })\n }), response => HttpClientResponse.fromWeb(request, response));\n switch (request.body._tag) {\n case \"Raw\":\n case \"Uint8Array\":\n return send(request.body.body);\n case \"FormData\":\n return send(request.body.formData);\n case \"Stream\":\n return Effect.flatMap(Stream.toReadableStreamEffect(request.body.stream), send);\n }\n return send(undefined);\n});\n/**\n * Layer that provides an `HttpClient` implementation backed by the configured\n * `Fetch` function.\n *\n * **When to use**\n *\n * Use when an Effect program should execute `HttpClient` requests through the\n * platform `fetch` implementation, especially in browser, edge, or Node.js\n * runtimes with `globalThis.fetch`.\n *\n * **Details**\n *\n * The layer uses the current `Fetch` reference and optional `RequestInit`\n * service for each request. Request-specific method, headers, body, and abort\n * signal are supplied by the client and override matching `RequestInit` fields.\n *\n * **Gotchas**\n *\n * Fetch behavior comes from the runtime's implementation, so CORS, cookies,\n * redirects, abort handling, and streaming support can vary by platform. Stream\n * request bodies are sent as Web streams with `duplex: \"half\"`, and any\n * `content-length` header is removed before calling `fetch`.\n *\n * @see {@link Fetch} for supplying the fetch implementation used by this layer\n * @see {@link RequestInit} for default `RequestInit` options applied before request-specific fields\n *\n * @category layers\n * @since 4.0.0\n */\nexport const layer = /*#__PURE__*/HttpClient.layerMergedContext(/*#__PURE__*/Effect.succeed(fetch));\n//# sourceMappingURL=FetchHttpClient.js.map","import { Schema as S } from 'effect'\nimport { HttpApi, HttpApiEndpoint, HttpApiGroup } from 'effect/unstable/httpapi'\n\nexport const ANTHROPIC_BASE_URL = 'https://api.anthropic.com'\nexport const ANTHROPIC_OAUTH_BETA = 'oauth-2025-04-20'\n\nexport const UsageWindow = S.Struct({\n utilization: S.optional(S.NullOr(S.Number)),\n resets_at: S.optional(S.NullOr(S.String)),\n})\nexport type UsageWindow = typeof UsageWindow.Type\n\nexport const ExtraUsage = S.Struct({\n is_enabled: S.optional(S.NullOr(S.Boolean)),\n monthly_limit: S.optional(S.NullOr(S.Number)),\n used_credits: S.optional(S.NullOr(S.Number)),\n utilization: S.optional(S.NullOr(S.Number)),\n currency: S.optional(S.NullOr(S.String)),\n decimal_places: S.optional(S.NullOr(S.Number)),\n disabled_reason: S.optional(S.NullOr(S.String)),\n})\nexport type ExtraUsage = typeof ExtraUsage.Type\n\nexport const UnifiedLimit = S.Struct({\n kind: S.String,\n percent: S.optional(S.NullOr(S.Number)),\n resets_at: S.optional(S.NullOr(S.Union([S.String, S.Number]))),\n scope: S.optional(\n S.NullOr(\n S.Struct({\n model: S.optional(\n S.NullOr(\n S.Struct({\n id: S.optional(S.NullOr(S.String)),\n display_name: S.optional(S.NullOr(S.String)),\n }),\n ),\n ),\n }),\n ),\n ),\n is_active: S.optional(S.NullOr(S.Boolean)),\n})\nexport type UnifiedLimit = typeof UnifiedLimit.Type\n\nexport const ClaudeUsage = S.Struct({\n five_hour: S.optional(S.NullOr(UsageWindow)),\n seven_day: S.optional(S.NullOr(UsageWindow)),\n seven_day_opus: S.optional(S.NullOr(UsageWindow)),\n seven_day_sonnet: S.optional(S.NullOr(UsageWindow)),\n seven_day_oauth_apps: S.optional(S.NullOr(UsageWindow)),\n extra_usage: S.optional(S.NullOr(ExtraUsage)),\n limits: S.optional(S.NullOr(S.Array(UnifiedLimit))),\n})\nexport type ClaudeUsage = typeof ClaudeUsage.Type\n\nexport const ClaudeProfile = S.Struct({\n account: S.optional(\n S.NullOr(\n S.Struct({\n email: S.optional(S.NullOr(S.String)),\n has_claude_max: S.optional(S.NullOr(S.Boolean)),\n has_claude_pro: S.optional(S.NullOr(S.Boolean)),\n }),\n ),\n ),\n organization: S.optional(\n S.NullOr(\n S.Struct({\n name: S.optional(S.NullOr(S.String)),\n organization_type: S.optional(S.NullOr(S.String)),\n rate_limit_tier: S.optional(S.NullOr(S.String)),\n }),\n ),\n ),\n})\nexport type ClaudeProfile = typeof ClaudeProfile.Type\n\nexport interface ClaudeAccountUsage {\n readonly usage: ClaudeUsage\n readonly profile: ClaudeProfile | undefined\n}\n\nexport const ClaudeUsageApi = HttpApi.make('ClaudeUsage').add(\n HttpApiGroup.make('oauth', { topLevel: true })\n .add(HttpApiEndpoint.get('usage', '/api/oauth/usage', { success: ClaudeUsage }))\n .add(\n HttpApiEndpoint.get('profile', '/api/oauth/profile', {\n success: ClaudeProfile,\n }),\n ),\n)\n","import { Schema as S } from 'effect'\nimport { HttpApi, HttpApiEndpoint, HttpApiGroup } from 'effect/unstable/httpapi'\n\nexport const CHATGPT_BASE_URL = 'https://chatgpt.com'\n\nexport const RateLimitWindow = S.Struct({\n used_percent: S.Number,\n limit_window_seconds: S.optional(S.NullOr(S.Number)),\n reset_after_seconds: S.optional(S.NullOr(S.Number)),\n reset_at: S.optional(S.NullOr(S.Number)),\n})\nexport type RateLimitWindow = typeof RateLimitWindow.Type\n\nexport const RateLimitDetails = S.Struct({\n allowed: S.optional(S.NullOr(S.Boolean)),\n limit_reached: S.optional(S.NullOr(S.Boolean)),\n primary_window: S.optional(S.NullOr(RateLimitWindow)),\n secondary_window: S.optional(S.NullOr(RateLimitWindow)),\n})\nexport type RateLimitDetails = typeof RateLimitDetails.Type\n\nexport const CreditStatus = S.Struct({\n has_credits: S.optional(S.NullOr(S.Boolean)),\n unlimited: S.optional(S.NullOr(S.Boolean)),\n balance: S.optional(S.NullOr(S.String)),\n})\nexport type CreditStatus = typeof CreditStatus.Type\n\nexport const AdditionalRateLimit = S.Struct({\n limit_name: S.String,\n rate_limit: S.optional(S.NullOr(RateLimitDetails)),\n})\nexport type AdditionalRateLimit = typeof AdditionalRateLimit.Type\n\nexport const CodexUsage = S.Struct({\n email: S.optional(S.NullOr(S.String)),\n plan_type: S.optional(S.NullOr(S.String)),\n rate_limit: S.optional(S.NullOr(RateLimitDetails)),\n credits: S.optional(S.NullOr(CreditStatus)),\n additional_rate_limits: S.optional(S.NullOr(S.Array(AdditionalRateLimit))),\n rate_limit_reset_credits: S.optional(\n S.NullOr(S.Struct({ available_count: S.Number })),\n ),\n})\nexport type CodexUsage = typeof CodexUsage.Type\n\nexport const CodexUsageApi = HttpApi.make('CodexUsage').add(\n HttpApiGroup.make('wham', { topLevel: true }).add(\n HttpApiEndpoint.get('usage', '/backend-api/wham/usage', { success: CodexUsage }),\n ),\n)\n","import {\n type ModelRegistry,\n readStoredCredential,\n} from '@earendil-works/pi-coding-agent'\nimport {\n Array,\n Cause,\n Context,\n Data,\n Effect,\n Encoding,\n Layer,\n Option,\n pipe,\n Schedule,\n Schema,\n String,\n} from 'effect'\nimport { FetchHttpClient, HttpClient, HttpClientRequest } from 'effect/unstable/http'\nimport { HttpApiClient } from 'effect/unstable/httpapi'\nimport {\n ANTHROPIC_BASE_URL,\n ANTHROPIC_OAUTH_BETA,\n type ClaudeAccountUsage,\n ClaudeUsageApi,\n} from './provider/anthropic'\nimport { CHATGPT_BASE_URL, CodexUsageApi } from './provider/openai'\nimport { GlmUsageApi, ZAI_BASE_URL, type ZaiProvider } from './provider/zai'\n\nconst REQUEST_TIMEOUT = '10 seconds'\nconst LOGIN_HINT = 'run /login to (re-)authenticate'\n\nexport class UsageServiceError extends Schema.TaggedError()(\n '@pi-plugins/usage/UsageServiceError',\n {\n kind: Schema.Literals([\n 'CredentialsMissing',\n 'TokenRefreshFailed',\n 'AccountIdMissing',\n 'RequestFailed',\n ]),\n message: Schema.String,\n cause: Schema.optional(Schema.Defect()),\n },\n) {}\n\nconst requestFailed = (cause: unknown) =>\n new UsageServiceError({\n kind: 'RequestFailed',\n message: Cause.isTimeoutError(cause)\n ? 'usage API request timed out'\n : cause instanceof Error &&\n typeof cause.message === 'string' &&\n cause.message.length > 0\n ? cause.message\n : 'usage API request failed',\n cause,\n })\n\nexport type UsageProvider = Data.TaggedEnum<{\n Anthropic: {}\n OpenAI: {}\n Zai: { readonly providerId: ZaiProvider }\n}>\nexport const UsageProvider = Data.taggedEnum()\n\nexport type UsageCredentials = Data.TaggedEnum<{\n Anthropic: { readonly accessToken: string }\n OpenAI: { readonly accessToken: string; readonly accountId: string }\n Zai: { readonly apiKey: string }\n}>\nexport const UsageCredentials = Data.taggedEnum()\n\ntype CredentialsFor

= Data.TaggedEnum.Value<\n UsageCredentials,\n P['_tag']\n>\n\nconst accountIdFromToken = Effect.fnUntraced(function* (accessToken: string) {\n const payload = yield* Effect.fromResult(\n Encoding.decodeBase64UrlString(\n pipe(\n accessToken,\n String.split('.'),\n Array.get(1),\n Option.getOrElse(() => ''),\n ),\n ),\n )\n const claims = yield* Schema.decodeEffect(\n Schema.fromJsonString(\n Schema.Struct({\n 'https://api.openai.com/auth': Schema.Struct({\n chatgpt_account_id: Schema.String,\n }),\n }),\n ),\n )(payload)\n return claims['https://api.openai.com/auth'].chatgpt_account_id\n})\n\nexport class UsageService extends Context.Service()(\n '@pi-plugins/usage/UsageService',\n {\n make: Effect.fnUntraced(function* (registry: ModelRegistry) {\n const http = (yield* HttpClient.HttpClient).pipe(\n HttpClient.mapRequest(HttpClientRequest.acceptJson),\n HttpClient.filterStatusOk,\n HttpClient.retryTransient({\n times: 3,\n schedule: Schedule.jittered(Schedule.exponential('1 second')),\n }),\n )\n\n const credentials = Effect.fnUntraced(function*

(\n provider: P,\n ): Effect.fn.Return, UsageServiceError> {\n const providerId = UsageProvider.$match(provider, {\n Anthropic: () => 'anthropic',\n OpenAI: () => 'openai-codex',\n Zai: (zai) => zai.providerId,\n })\n const oauth = provider._tag !== 'Zai'\n\n if (oauth && readStoredCredential(providerId)?.type !== 'oauth') {\n return yield* new UsageServiceError({\n kind: 'CredentialsMissing',\n message: `no subscription (OAuth) credentials found — ${LOGIN_HINT}`,\n })\n }\n const accessToken = yield* Effect.tryPromise({\n try: () => registry.getApiKeyForProvider(providerId),\n catch: (cause) =>\n new UsageServiceError({\n kind: 'TokenRefreshFailed',\n message: `token refresh failed — ${LOGIN_HINT}`,\n cause,\n }),\n })\n if (!accessToken) {\n return yield* new UsageServiceError(\n oauth\n ? {\n kind: 'TokenRefreshFailed',\n message: `token refresh failed — ${LOGIN_HINT}`,\n }\n : {\n kind: 'CredentialsMissing',\n message: `no API key found for ${providerId} — ${LOGIN_HINT}`,\n },\n )\n }\n\n return (yield* UsageProvider.$match(provider, {\n Anthropic: () =>\n Effect.succeed(UsageCredentials.Anthropic({ accessToken })),\n OpenAI: Effect.fnUntraced(function* () {\n // Re-read: resolving the token may have refreshed the stored credential.\n const credential = readStoredCredential(providerId)\n const storedAccountId =\n credential?.type === 'oauth' &&\n typeof credential['accountId'] === 'string'\n ? credential['accountId']\n : undefined\n const accountId =\n storedAccountId ??\n (yield* accountIdFromToken(accessToken).pipe(\n Effect.orElseSucceed(() => undefined),\n ))\n if (!accountId) {\n return yield* new UsageServiceError({\n kind: 'AccountIdMissing',\n message: `missing ChatGPT account id — ${LOGIN_HINT}`,\n })\n }\n return UsageCredentials.OpenAI({ accessToken, accountId })\n }),\n Zai: () => Effect.succeed(UsageCredentials.Zai({ apiKey: accessToken })),\n })) as CredentialsFor

\n })\n\n const claude = Effect.fn('UsageService.claude')(function* () {\n const { accessToken } = yield* credentials(UsageProvider.Anthropic())\n const client = yield* HttpApiClient.makeWith(ClaudeUsageApi, {\n baseUrl: ANTHROPIC_BASE_URL,\n httpClient: http.pipe(\n HttpClient.mapRequest(\n HttpClientRequest.setHeaders({\n Authorization: `Bearer ${accessToken}`,\n 'anthropic-beta': ANTHROPIC_OAUTH_BETA,\n }),\n ),\n ),\n })\n const [usage, profile] = yield* Effect.all(\n [\n client\n .usage()\n .pipe(Effect.timeout(REQUEST_TIMEOUT), Effect.mapError(requestFailed)),\n // Only decorates the report, so it must never fail the usage fetch.\n client.profile().pipe(\n Effect.timeout(REQUEST_TIMEOUT),\n Effect.orElseSucceed(() => undefined),\n ),\n ],\n { concurrency: 'unbounded' },\n )\n return { usage, profile } satisfies ClaudeAccountUsage\n })\n\n const codex = Effect.fn('UsageService.codex')(function* () {\n const { accessToken, accountId } = yield* credentials(UsageProvider.OpenAI())\n const client = yield* HttpApiClient.makeWith(CodexUsageApi, {\n baseUrl: CHATGPT_BASE_URL,\n httpClient: http.pipe(\n HttpClient.mapRequest(\n HttpClientRequest.setHeaders({\n Authorization: `Bearer ${accessToken}`,\n 'ChatGPT-Account-Id': accountId,\n }),\n ),\n ),\n })\n return yield* client\n .usage()\n .pipe(Effect.timeout(REQUEST_TIMEOUT), Effect.mapError(requestFailed))\n })\n\n const glm = Effect.fn('UsageService.glm')(function* (providerId: ZaiProvider) {\n const { apiKey } = yield* credentials(UsageProvider.Zai({ providerId }))\n const client = yield* HttpApiClient.makeWith(GlmUsageApi, {\n baseUrl: ZAI_BASE_URL[providerId],\n httpClient: http.pipe(\n HttpClient.mapRequest(HttpClientRequest.bearerToken(apiKey)),\n ),\n })\n const envelope = yield* client\n .usage()\n .pipe(Effect.timeout(REQUEST_TIMEOUT), Effect.mapError(requestFailed))\n // The API answers HTTP 200 for failures too, so filterStatusOk can't catch them.\n if (!envelope.success) {\n return yield* new UsageServiceError({\n kind: 'RequestFailed',\n message: envelope.msg || `GLM usage API error (code ${envelope.code})`,\n })\n }\n return envelope.data\n })\n\n return { claude, codex, glm } as const\n }),\n },\n) {\n static readonly layer = (registry: ModelRegistry) =>\n Layer.effect(this, this.make(registry)).pipe(\n Layer.provide(FetchHttpClient.layer),\n )\n}\n","import { Array } from 'effect'\nimport type { ClaudeUsage, UsageWindow } from './provider/anthropic'\nimport type { CodexUsage } from './provider/openai'\nimport { glmRateLimits, type GlmUsage } from './provider/zai'\nimport { codexResetsAt, formatCompactDuration, parseResetsAt } from './reset'\n\nexport interface WidgetLimit {\n readonly label: string\n readonly percent: number\n readonly resetsAt?: Date | null | undefined\n}\n\nconst BAR_WIDTH = 5\n\nexport function widgetText(\n limits: readonly WidgetLimit[] | undefined,\n now: Date,\n): string | undefined {\n if (limits === undefined || limits.length === 0) {\n return undefined\n }\n return limits\n .map((limit) => {\n const clamped = Math.min(Math.max(limit.percent, 0), 100)\n const filled = Math.round((clamped / 100) * BAR_WIDTH)\n const bar = `${'█'.repeat(filled)}${'░'.repeat(BAR_WIDTH - filled)}`\n const text = `${limit.label} ${bar} ${Math.round(limit.percent)}%`\n if (!limit.resetsAt) {\n return text\n }\n const delta = limit.resetsAt.getTime() - now.getTime()\n return `${text} (${delta > 0 ? formatCompactDuration(delta) : 'now'})`\n })\n .join(' · ')\n}\n\nexport function claudeWidgetLimits(usage: ClaudeUsage): WidgetLimit[] {\n const limits = usage.limits ?? []\n if (limits.length > 0) {\n return limits.flatMap((limit) => {\n const label =\n limit.kind === 'session'\n ? '5h'\n : limit.kind === 'weekly_all'\n ? 'wk'\n : undefined\n return label !== undefined && typeof limit.percent === 'number'\n ? [\n {\n label,\n percent: limit.percent,\n resetsAt: parseResetsAt(limit.resets_at),\n },\n ]\n : []\n })\n }\n\n const windows: [string, UsageWindow | null | undefined][] = [\n ['5h', usage.five_hour],\n ['wk', usage.seven_day],\n ]\n return windows.flatMap(([label, window]) =>\n typeof window?.utilization === 'number'\n ? [\n {\n label,\n percent: window.utilization,\n resetsAt: parseResetsAt(window.resets_at),\n },\n ]\n : [],\n )\n}\n\nfunction codexWindowLabel(seconds: number | null | undefined): string {\n if (typeof seconds !== 'number' || seconds <= 0) {\n return '?'\n }\n if (seconds >= 604_800 * 0.9) {\n return 'wk'\n }\n if (seconds >= 86_400) {\n return `${Math.round(seconds / 86_400)}d`\n }\n return `${Math.round(seconds / 3600)}h`\n}\n\nexport function codexWidgetLimits(usage: CodexUsage, now: Date): WidgetLimit[] {\n const details = usage.rate_limit\n return [details?.primary_window, details?.secondary_window].flatMap((window) =>\n window\n ? [\n {\n label: codexWindowLabel(window.limit_window_seconds),\n percent: window.used_percent,\n resetsAt: codexResetsAt(window, now),\n },\n ]\n : [],\n )\n}\n\nexport function glmWidgetLimits(usage: GlmUsage): WidgetLimit[] {\n return Array.zip(['5h', 'wk'], glmRateLimits(usage)).flatMap(([label, limit]) =>\n typeof limit.percentage === 'number'\n ? [{ label, percent: limit.percentage, resetsAt: limit.nextResetTime }]\n : [],\n )\n}\n","import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'\nimport { Text } from '@earendil-works/pi-tui'\nimport { loadExtensionConfig } from '@pi-plugins/shared/config'\nimport { runHandler } from '@pi-plugins/shared/run'\nimport { setStatuslineSegment } from '@pi-plugins/shared/statusline'\nimport { Effect, Record, Schema } from 'effect'\nimport { ZAI_BASE_URL, type ZaiProvider } from './provider/zai'\nimport {\n claudeSection,\n codexSection,\n glmSection,\n renderReport,\n type UsageReport,\n type UsageSection,\n} from './render'\nimport { UsageService, type UsageServiceError } from './service'\nimport {\n claudeWidgetLimits,\n codexWidgetLimits,\n glmWidgetLimits,\n widgetText,\n type WidgetLimit,\n} from './widget'\n\nconst EXTENSION_ID = 'usage'\nconst REPORT_ENTRY_TYPE = 'usage-report'\nconst WIDGET_REFRESH_MS = 30_000\n\nconst UsageConfig = Schema.Struct({\n showWidget: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))),\n})\n\ntype WidgetProvider = 'claude' | 'codex' | ZaiProvider\n\nfunction widgetProvider(\n model: ExtensionContext['model'],\n): WidgetProvider | undefined {\n switch (model?.provider) {\n case 'anthropic':\n return 'claude'\n case 'openai-codex':\n return 'codex'\n case 'zai':\n case 'zai-coding-cn':\n return model.provider\n default:\n return undefined\n }\n}\n\nfunction section(\n title: string,\n fetch: Effect.Effect,\n toSection: (usage: A) => UsageSection,\n): Effect.Effect {\n return fetch.pipe(\n Effect.map(toSection),\n Effect.catch((error) => Effect.succeed({ title, error: error.message })),\n )\n}\n\nexport default function usage(pi: ExtensionAPI): void {\n let config = Schema.decodeUnknownSync(UsageConfig)({})\n const limitsCache = new Map()\n const fetchedAt = new Map()\n const inFlight = new Set()\n\n function recordLimits(\n provider: WidgetProvider,\n limits: readonly WidgetLimit[],\n ): void {\n limitsCache.set(provider, limits)\n fetchedAt.set(provider, Date.now())\n }\n\n function renderWidget(ctx: ExtensionContext): void {\n if (!ctx.hasUI) {\n return\n }\n const provider = config.showWidget ? widgetProvider(ctx.model) : undefined\n const text =\n provider === undefined\n ? undefined\n : widgetText(limitsCache.get(provider), new Date())\n setStatuslineSegment(\n ctx,\n EXTENSION_ID,\n text === undefined ? undefined : { text, align: 'right' },\n )\n }\n\n async function refreshWidget(ctx: ExtensionContext): Promise {\n renderWidget(ctx)\n if (!ctx.hasUI || !config.showWidget) {\n return\n }\n\n const provider = widgetProvider(ctx.model)\n if (provider === undefined || inFlight.has(provider)) {\n return\n }\n const last = fetchedAt.get(provider)\n if (last !== undefined && Date.now() - last < WIDGET_REFRESH_MS) {\n return\n }\n\n inFlight.add(provider)\n const program = Effect.gen(function* () {\n const service = yield* UsageService\n return provider === 'claude'\n ? claudeWidgetLimits((yield* service.claude()).usage)\n : provider === 'codex'\n ? codexWidgetLimits(yield* service.codex(), new Date())\n : glmWidgetLimits(yield* service.glm(provider))\n }).pipe(Effect.provide(UsageService.layer(ctx.modelRegistry)))\n\n let limits: WidgetLimit[] | undefined\n try {\n limits = await runHandler(program)\n } finally {\n inFlight.delete(provider)\n // Stamped on failure too, so a broken provider (e.g. not logged in) is not\n // re-queried on every event.\n fetchedAt.set(provider, Date.now())\n }\n if (limits !== undefined) {\n limitsCache.set(provider, limits)\n renderWidget(ctx)\n }\n }\n\n pi.on('session_start', async (_event, ctx) => {\n config = await loadExtensionConfig(ctx, UsageConfig, EXTENSION_ID, config)\n await refreshWidget(ctx)\n })\n\n pi.on('model_select', async (_event, ctx) => {\n await refreshWidget(ctx)\n })\n\n // Past retries, auto-compaction and queued follow-ups, unlike agent_end.\n pi.on('agent_settled', async (_event, ctx) => {\n await refreshWidget(ctx)\n })\n\n pi.registerEntryRenderer(\n REPORT_ENTRY_TYPE,\n (entry, _options, theme) =>\n entry.data === undefined\n ? undefined\n : new Text(renderReport(entry.data, theme), 1, 0),\n )\n\n pi.registerCommand('usage', {\n description: 'Show subscription plan usage and rate limits',\n handler: async (_args, ctx) => {\n const now = new Date()\n const glmProvider =\n Record.keys(ZAI_BASE_URL).find(\n (id) => ctx.modelRegistry.getProviderAuthStatus(id).configured,\n ) ?? 'zai'\n const program = Effect.gen(function* () {\n const service = yield* UsageService\n const sections = yield* Effect.all(\n [\n section(\n 'Claude',\n service\n .claude()\n .pipe(\n Effect.tap((data) =>\n Effect.sync(() =>\n recordLimits('claude', claudeWidgetLimits(data.usage)),\n ),\n ),\n ),\n claudeSection,\n ),\n section(\n 'OpenAI Codex',\n service\n .codex()\n .pipe(\n Effect.tap((data) =>\n Effect.sync(() =>\n recordLimits('codex', codexWidgetLimits(data, now)),\n ),\n ),\n ),\n (data) => codexSection(data, now),\n ),\n section(\n 'GLM Coding',\n service\n .glm(glmProvider)\n .pipe(\n Effect.tap((data) =>\n Effect.sync(() =>\n recordLimits(glmProvider, glmWidgetLimits(data)),\n ),\n ),\n ),\n glmSection,\n ),\n ],\n { concurrency: 'unbounded' },\n )\n return { fetchedAt: now.getTime(), sections } satisfies UsageReport\n }).pipe(Effect.provide(UsageService.layer(ctx.modelRegistry)))\n\n const report = await runHandler(program, {\n onError: (message) => {\n ctx.ui.notify(`Failed to fetch usage: ${message}`, 'error')\n return undefined\n },\n })\n if (report !== undefined) {\n pi.appendEntry(REPORT_ENTRY_TYPE, report)\n }\n renderWidget(ctx)\n },\n })\n}\n"],"x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,150],"mappings":"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"}