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

package/src/unstable/cli/internal/wizard.ts

@@ -54,7 +54,7 @@ const promptCommand: (
 ) => Effect.Effect<void, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
   function*(command, commandLine, sectionName) {
     const impl = toImpl(command)
-    const visibleSubcommands = command.subcommands.flatMap((group) => group.commands.filter((child) => !child.hidden))
+    const visibleSubcommands = command.subcommands.flatMap((group) => group.commands.filter((child) => !child.unlisted))
     const config = visibleSubcommands.length === 0 ? impl.config : impl.contextConfig
 
     if (config.flags.length > 0) {
@@ -103,7 +103,7 @@ const promptCommand: (
 )
 
 const hasWizardSteps = (command: Command.Command.Any): boolean => {
-  const hasVisibleSubcommands = command.subcommands.some((group) => group.commands.some((child) => !child.hidden))
+  const hasVisibleSubcommands = command.subcommands.some((group) => group.commands.some((child) => !child.unlisted))
   return hasVisibleSubcommands || toImpl(command).config.orderedParams.length > 0
 }
 

package/src/unstable/cluster/ClusterError.ts

@@ -26,7 +26,7 @@ const TypeId = "~effect/cluster/ClusterError"
  * @since 4.0.0
  */
 export class EntityNotAssignedToRunner
-  extends Schema.ErrorClass<EntityNotAssignedToRunner>(`${TypeId}/EntityNotAssignedToRunner`)({
+  extends Schema.Error<EntityNotAssignedToRunner>(`${TypeId}/EntityNotAssignedToRunner`)({
     _tag: Schema.tag("EntityNotAssignedToRunner"),
     address: EntityAddress
   })
@@ -60,7 +60,7 @@ export class EntityNotAssignedToRunner
  * @category errors
  * @since 4.0.0
  */
-export class MalformedMessage extends Schema.ErrorClass<MalformedMessage>(`${TypeId}/MalformedMessage`)({
+export class MalformedMessage extends Schema.Error<MalformedMessage>(`${TypeId}/MalformedMessage`)({
   _tag: Schema.tag("MalformedMessage"),
   cause: Schema.Defect()
 }) {
@@ -99,7 +99,7 @@ export class MalformedMessage extends Schema.ErrorClass<MalformedMessage>(`${Typ
  * @category errors
  * @since 4.0.0
  */
-export class PersistenceError extends Schema.ErrorClass<PersistenceError>(`${TypeId}/PersistenceError`)({
+export class PersistenceError extends Schema.Error<PersistenceError>(`${TypeId}/PersistenceError`)({
   _tag: Schema.tag("PersistenceError"),
   cause: Schema.Defect()
 }) {
@@ -127,7 +127,7 @@ export class PersistenceError extends Schema.ErrorClass<PersistenceError>(`${Typ
  * @category errors
  * @since 4.0.0
  */
-export class RunnerNotRegistered extends Schema.ErrorClass<RunnerNotRegistered>(`${TypeId}/RunnerNotRegistered`)({
+export class RunnerNotRegistered extends Schema.Error<RunnerNotRegistered>(`${TypeId}/RunnerNotRegistered`)({
   _tag: Schema.tag("RunnerNotRegistered"),
   address: RunnerAddress
 }) {
@@ -145,7 +145,7 @@ export class RunnerNotRegistered extends Schema.ErrorClass<RunnerNotRegistered>(
  * @category errors
  * @since 4.0.0
  */
-export class RunnerUnavailable extends Schema.ErrorClass<RunnerUnavailable>(`${TypeId}/RunnerUnavailable`)({
+export class RunnerUnavailable extends Schema.Error<RunnerUnavailable>(`${TypeId}/RunnerUnavailable`)({
   _tag: Schema.tag("RunnerUnavailable"),
   address: RunnerAddress
 }) {
@@ -181,7 +181,7 @@ export class RunnerUnavailable extends Schema.ErrorClass<RunnerUnavailable>(`${T
  * @category errors
  * @since 4.0.0
  */
-export class MailboxFull extends Schema.ErrorClass<MailboxFull>(`${TypeId}/MailboxFull`)({
+export class MailboxFull extends Schema.Error<MailboxFull>(`${TypeId}/MailboxFull`)({
   _tag: Schema.tag("MailboxFull"),
   address: EntityAddress
 }) {
@@ -214,7 +214,7 @@ export class MailboxFull extends Schema.ErrorClass<MailboxFull>(`${TypeId}/Mailb
  * @since 4.0.0
  */
 export class AlreadyProcessingMessage
-  extends Schema.ErrorClass<AlreadyProcessingMessage>(`${TypeId}/AlreadyProcessingMessage`)({
+  extends Schema.Error<AlreadyProcessingMessage>(`${TypeId}/AlreadyProcessingMessage`)({
     _tag: Schema.tag("AlreadyProcessingMessage"),
     envelopeId: SnowflakeFromString,
     address: EntityAddress

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -618,7 +618,10 @@ export const make = Effect.gen(function*() {
             payload: {
               name: options.clock.name,
               workflowName: workflow._tag,
-              wakeUp: DateTime.addDuration(now, options.clock.duration)
+              wakeUp: DateTime.mapEpochMillis(
+                DateTime.addDuration(now, options.clock.duration),
+                Math.ceil
+              )
             }
           })
         ),

package/src/unstable/cluster/MessageStorage.ts

@@ -606,11 +606,7 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
         ),
         Effect.asVoid
       ),
-    saveReply: (reply) =>
-      Effect.flatMap(
-        Reply.serialize(reply),
-        encoded.saveReply
-      ),
+    saveReply: (reply) => Effect.flatMap(Reply.serializeOrDefect(reply), encoded.saveReply),
     clearReplies: encoded.clearReplies,
     repliesFor: Effect.fnUntraced(function*(messages) {
       const requestIds = Arr.empty<string>()
@@ -995,6 +991,14 @@ export class MemoryDriver extends Context.Service<MemoryDriver>()("effect/cluste
       resetAddress: () => Effect.void,
       clearAddress: (address) =>
         Effect.sync(() => {
+          for (const [primaryKey, entry] of requestsByPrimaryKey) {
+            const envelope = entry.envelope
+            const sameAddress = address.entityType === envelope.address.entityType &&
+              address.entityId === envelope.address.entityId
+            if (sameAddress) {
+              requestsByPrimaryKey.delete(primaryKey)
+            }
+          }
           for (let i = journal.length - 1; i >= 0; i--) {
             const envelope = journal[i]
             const sameAddress = address.entityType === envelope.address.entityType &&

package/src/unstable/cluster/Reply.ts

@@ -433,6 +433,27 @@ export const serialize = <R extends Rpc.Any>(
   )
 }
 
+/**
+ * Serializes a `ReplyWithContext`, falling back to a serializable defect reply
+ * when the original reply cannot be encoded.
+ *
+ * @category serialization
+ * @since 4.0.0
+ */
+export const serializeOrDefect = <R extends Rpc.Any>(
+  self: ReplyWithContext<R>
+): Effect.Effect<Encoded> =>
+  Effect.catchTag(
+    serialize(self),
+    "MalformedMessage",
+    (error) =>
+      Effect.orDie(serialize(ReplyWithContext.fromDefect({
+        id: self.reply.id,
+        requestId: self.reply.requestId,
+        defect: error
+      })))
+  )
+
 /**
  * Serializes an outgoing request's last received reply when one exists, returning
  * `None` when no reply has been received and refailing encoding errors as

package/src/unstable/cluster/RunnerServer.ts

@@ -42,15 +42,6 @@ const serializeDefectReply = <R extends Rpc.Any>(
     defect
   })))
 
-const serializeReply = <R extends Rpc.Any>(
-  reply: Reply.ReplyWithContext<R>
-): Effect.Effect<Reply.Encoded> =>
-  Effect.catchTag(
-    Reply.serialize(reply),
-    "MalformedMessage",
-    (error) => serializeDefectReply(reply, error)
-  )
-
 /**
  * Layer that handles runner protocol RPCs by forwarding requests to `Sharding`
  * and `MessageStorage`.
@@ -84,7 +75,7 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
         envelope: request,
         lastSentReply: Option.none(),
         respond(reply) {
-          resume(serializeReply(reply))
+          resume(Reply.serializeOrDefect(reply))
           return Effect.void
         }
       })
@@ -138,6 +129,9 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
               return Reply.serialize(reply).pipe(
                 Effect.flatMap((reply) => {
                   Queue.offerUnsafe(queue, reply)
+                  if (reply._tag === "WithExit") {
+                    Queue.endUnsafe(queue)
+                  }
                   return Effect.void
                 }),
                 Effect.catchTag("MalformedMessage", (error) =>

package/src/unstable/cluster/RunnerStorage.ts

@@ -195,29 +195,31 @@ export const makeEncoded = (encoded: Encoded) =>
  *
  * **Details**
  *
- * Registered runners are treated as healthy and shard acquisition is kept only in
- * process memory.
+ * Runner health and shard acquisition are kept only in process memory.
  *
  * @category constructors
  * @since 4.0.0
  */
 export const makeMemory = Effect.gen(function*() {
-  const runners = MutableHashMap.empty<RunnerAddress, Runner>()
+  const runners = MutableHashMap.empty<RunnerAddress, readonly [runner: Runner, healthy: boolean]>()
   let acquired: Array<ShardId.ShardId> = []
   let id = 0
 
   return RunnerStorage.of({
-    getRunners: Effect.sync(() => Array.from(MutableHashMap.values(runners), (runner) => [runner, true])),
-    register: (runner) =>
+    getRunners: Effect.sync(() => Array.from(MutableHashMap.values(runners))),
+    register: (runner, healthy) =>
       Effect.sync(() => {
-        MutableHashMap.set(runners, runner.address, runner)
+        MutableHashMap.set(runners, runner.address, [runner, healthy])
         return MachineId.make(id++)
       }),
     unregister: (address) =>
       Effect.sync(() => {
         MutableHashMap.remove(runners, address)
       }),
-    setRunnerHealth: () => Effect.void,
+    setRunnerHealth: (address, healthy) =>
+      Effect.sync(() => {
+        MutableHashMap.modify(runners, address, ([runner]) => [runner, healthy] as const)
+      }),
     acquire: (_address, shardIds) => {
       acquired = Array.from(shardIds)
       return Effect.succeed(acquired)

package/src/unstable/cluster/Sharding.ts

@@ -240,6 +240,8 @@ const make = Effect.gen(function*() {
   const runnerStorage = yield* RunnerStorage
 
   const entityManagers = new Map<string, EntityManagerState>()
+  let entityRegistrationStartMillis: number | undefined
+  let entityRegistrationFallbackStartMillis: number | undefined
 
   const shardAssignments = MutableHashMap.empty<ShardId, RunnerAddress>()
   const selfShards = MutableHashSet.empty<ShardId>()
@@ -591,7 +593,6 @@ const make = Effect.gen(function*() {
     const entityRegistrationTimeoutMillis = Duration.toMillis(
       Duration.fromInputUnsafe(config.entityRegistrationTimeout)
     )
-    const storageStartMillis = clock.currentTimeMillisUnsafe()
 
     yield* Effect.gen(function*() {
       yield* Effect.logDebug("Starting")
@@ -617,8 +618,15 @@ const make = Effect.gen(function*() {
           }
           const state = entityManagers.get(address.entityType)
           if (!state) {
-            const sinceStart = clock.currentTimeMillisUnsafe() - storageStartMillis
-            if (sinceStart < entityRegistrationTimeoutMillis) {
+            const now = clock.currentTimeMillisUnsafe()
+            const registrationStarted = entityRegistrationStartMillis !== undefined
+            const timeoutStartMillis = entityRegistrationStartMillis ??
+              (entityRegistrationFallbackStartMillis ??= now)
+            // If registration never starts, allow two intervals from the first missing read before failing.
+            const timeoutMillis = registrationStarted
+              ? entityRegistrationTimeoutMillis
+              : entityRegistrationTimeoutMillis * 2
+            if (now - timeoutStartMillis < timeoutMillis) {
               // reset address in the case that the entity is slow to register
               MutableHashSet.add(resetAddresses, address)
               return Effect.void
@@ -961,13 +969,13 @@ const make = Effect.gen(function*() {
     void,
     MailboxFull | AlreadyProcessingMessage | PersistenceError
   > {
+    const isPersisted = Context.get(
+      message._tag === "OutgoingRequest" ? message.annotations : message.rpc.annotations,
+      Persisted
+    )
     return Effect.catchFilter(
       Effect.suspend(() => {
         const address = message.envelope.address
-        const isPersisted = Context.get(
-          message._tag === "OutgoingRequest" ? message.annotations : message.rpc.annotations,
-          Persisted
-        )
         if (isPersisted && !storageEnabled) {
           return Effect.die("Sharding.sendOutgoing: Persisted messages require MessageStorage")
         }
@@ -989,6 +997,25 @@ const make = Effect.gen(function*() {
           ? Result.succeed(error)
           : Result.fail(error),
       (error) => {
+        // Abandon the message during teardown: retrying would loop forever once the runner is shutting down
+        if (error._tag === "EntityNotAssignedToRunner") {
+          const targetManager = entityManagers.get(message.envelope.address.entityType)
+          const cannotRecover = MutableRef.get(isShutdown) ||
+            (targetManager !== undefined && targetManager.status !== "alive")
+          if (cannotRecover) {
+            if (!isPersisted) {
+              return Effect.logDebug("Abandoning outgoing message during shutdown", message.envelope.address)
+            }
+            const persist = message._tag === "OutgoingRequest"
+              ? storage.saveRequest(message)
+              : storage.saveEnvelope(message)
+            return Effect.catchTag(persist, "MalformedMessage", Effect.die).pipe(
+              Effect.andThen(
+                Effect.logWarning("Persisting outgoing message abandoned during shutdown", message.envelope.address)
+              )
+            )
+          }
+        }
         if (retries === 0) {
           return Effect.die(error)
         }
@@ -1461,6 +1488,7 @@ const make = Effect.gen(function*() {
       // register entities while storage is idle
       // this ensures message order is preserved
       yield* withStorageReadLock(Effect.sync(() => {
+        entityRegistrationStartMillis ??= clock.currentTimeMillisUnsafe()
         entityManagers.set(entity.type, state)
         if (entityManagerLatches.has(entity.type)) {
           entityManagerLatches.get(entity.type)!.openUnsafe()

package/src/unstable/cluster/internal/entityManager.ts

@@ -110,7 +110,7 @@ export const make = Effect.fnUntraced(function*<
   const clock = yield* Clock
   const context = yield* Effect.context<Rpc.Services<Rpcs> | Rpc.Middleware<Rpcs> | RX>()
   const defectRetryPolicy = options.defectRetryPolicy
-    ? Schedule.andThen(options.defectRetryPolicy, defaultRetryPolicy)
+    ? Schedule.concat(options.defectRetryPolicy, defaultRetryPolicy)
     : defaultRetryPolicy
   const retryDriver = yield* Schedule.toStepWithSleep(defectRetryPolicy)
   const entityRpcs = new Map(entity.protocol.requests)

package/src/unstable/cluster/internal/resourceMap.ts

@@ -65,7 +65,7 @@ export class ResourceMap<K, A, E> {
       if (existing) {
         return Deferred.await(existing.deferred)
       }
-      const scope = Effect.runSync(Scope.make())
+      const scope = Scope.makeUnsafe()
       const deferred = Deferred.makeUnsafe<A, E>()
       backingSet(this.entries, key, { scope, deferred })
       return Effect.onExit(this.lookup(key, scope), (exit) => {
@@ -73,7 +73,10 @@ export class ResourceMap<K, A, E> {
           return Deferred.done(deferred, exit)
         }
         backingDelete(this.entries, key)
-        return Deferred.done(deferred, exit)
+        return Effect.andThen(
+          Deferred.done(deferred, exit),
+          Scope.close(scope, exit)
+        )
       })
     })
   }

package/src/unstable/cluster/internal/resourceRef.ts

@@ -1,3 +1,4 @@
+import type * as Cause from "../../../Cause.ts"
 import * as Effect from "../../../Effect.ts"
 import * as Exit from "../../../Exit.ts"
 import * as Latch from "../../../Latch.ts"
@@ -7,7 +8,7 @@ import * as Scope from "../../../Scope.ts"
 import { internalInterruptors } from "./interruptors.ts"
 
 /** @internal */
-export type State<A> = {
+export type State<A, E> = {
   readonly _tag: "Closed"
 } | {
   readonly _tag: "Acquiring"
@@ -16,6 +17,10 @@ export type State<A> = {
   readonly _tag: "Acquired"
   readonly scope: Scope.Closeable
   readonly value: A
+} | {
+  readonly _tag: "Failed"
+  readonly scope: Scope.Closeable
+  readonly cause: Cause.Cause<E>
 }
 
 /** @internal */
@@ -24,7 +29,7 @@ export class ResourceRef<A, E = never> {
     parentScope: Scope.Scope,
     acquire: (scope: Scope.Scope) => Effect.Effect<A, E>
   ) {
-    const state = MutableRef.make<State<A>>({ _tag: "Closed" })
+    const state = MutableRef.make<State<A, E>>({ _tag: "Closed" })
 
     yield* Scope.addFinalizerExit(parentScope, (exit) => {
       const s = MutableRef.get(state)
@@ -44,10 +49,10 @@ export class ResourceRef<A, E = never> {
     return new ResourceRef(state, acquire)
   })
 
-  readonly state: MutableRef.MutableRef<State<A>>
+  readonly state: MutableRef.MutableRef<State<A, E>>
   readonly acquire: (scope: Scope.Scope) => Effect.Effect<A, E>
   constructor(
-    state: MutableRef.MutableRef<State<A>>,
+    state: MutableRef.MutableRef<State<A, E>>,
     acquire: (scope: Scope.Scope) => Effect.Effect<A, E>
   ) {
     this.state = state
@@ -84,15 +89,32 @@ export class ResourceRef<A, E = never> {
         MutableRef.set(this.state, { _tag: "Acquired", scope, value })
         return this.latch.open
       })
+    ).pipe(
+      Effect.onExit((exit) => {
+        if (Exit.isSuccess(exit)) {
+          return Effect.void
+        }
+        return Scope.close(scope, exit).pipe(
+          Effect.ensuring(Effect.sync(() => {
+            const state = this.state.current
+            if (state._tag === "Acquiring" && state.scope === scope) {
+              MutableRef.set(this.state, { _tag: "Failed", scope, cause: exit.cause })
+              this.latch.openUnsafe()
+            }
+          }))
+        )
+      })
     )
   }
 
-  await: Effect.Effect<A> = Effect.suspend(() => {
+  await: Effect.Effect<A, E> = Effect.suspend(() => {
     const s = this.state.current
     if (s._tag === "Closed") {
       return Effect.interrupt
     } else if (s._tag === "Acquired") {
       return Effect.succeed(s.value)
+    } else if (s._tag === "Failed") {
+      return Effect.failCause(s.cause)
     }
     return Effect.flatMap(this.latch.await, () => this.await)
   })

package/src/unstable/devtools/DevToolsClient.ts

@@ -184,7 +184,8 @@ const makeTracerEffect = Effect.gen(function*() {
   return Tracer.make({
     span(options) {
       const span = currentTracer.span(options)
-      client.sendUnsafe(span)
+      // the span is mutated in place, so send a snapshot of its current state
+      client.sendUnsafe({ ...span })
       const oldEvent = span.event
       span.event = function(this: Tracer.Span, name, startTime, attributes) {
         client.sendUnsafe({
@@ -201,7 +202,7 @@ const makeTracerEffect = Effect.gen(function*() {
       const oldEnd = span.end
       span.end = function(this: Tracer.Span, endTime, exit) {
         oldEnd.call(this, endTime, exit)
-        client.sendUnsafe(span)
+        client.sendUnsafe({ ...span })
       }
 
       return span

package/src/unstable/encoding/Ini.ts

@@ -0,0 +1,174 @@
+/**
+ * Parses INI configuration files.
+ *
+ * This module contains the decoding surface used by Effect's CLI without
+ * pulling in the complete `ini` package.
+ *
+ * @since 4.0.0
+ */
+
+/*
+ * The parser is adapted from `ini` 7.0.0.
+ *
+ * Copyright (c) Isaac Z. Schlueter and Contributors
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty
+
+const splitSections = (value: string): Array<string> => {
+  const sections: Array<string> = []
+  let start = 0
+  let index = 0
+  while ((index = value.indexOf(".", index)) !== -1) {
+    if (index === 0 || value[index - 1] !== "\\") {
+      sections.push(value.slice(start, index))
+      start = index + 1
+    }
+    index++
+  }
+  sections.push(value.slice(start))
+  return sections
+}
+
+const isQuoted = (value: string): boolean =>
+  value.length >= 2 &&
+  ((value.startsWith("\"") && value.endsWith("\"")) ||
+    (value.startsWith("'") && value.endsWith("'")))
+
+const unquote = (input: string | undefined): string => {
+  let value = (input ?? "").trim()
+  if (isQuoted(value)) {
+    if (value[0] === "'") {
+      value = value.slice(1, -1)
+    }
+    try {
+      return JSON.parse(value)
+    } catch {
+      return value
+    }
+  }
+
+  let escaped = false
+  let output = ""
+  for (const character of value) {
+    if (escaped) {
+      output += character === ";" || character === "#" || character === "\\"
+        ? character
+        : `\\${character}`
+      escaped = false
+    } else if (character === ";" || character === "#") {
+      break
+    } else if (character === "\\") {
+      escaped = true
+    } else {
+      output += character
+    }
+  }
+  return output.trim()
+}
+
+/**
+ * Parses an INI document into a null-prototype record.
+ *
+ * Section names separated by dots become nested records, repeated keys ending
+ * in `[]` become arrays, and the scalar values `true`, `false`, and `null` are
+ * decoded. Other scalar values remain strings.
+ *
+ * @category decoding
+ * @since 4.0.0
+ */
+export const parse = (input: string): Record<string, unknown> => {
+  const output: Record<string, any> = Object.create(null)
+  let current = output
+  const sectionPattern = /^\[([^\]]*)\]\s*$/
+  const propertyPattern = /^([^=]+)(=(.*))?$/
+
+  for (const line of input.split(/[\r\n]+/g)) {
+    if (line.length === 0 || /^\s*(?:[;#]|$)/.test(line)) {
+      continue
+    }
+
+    const sectionMatch = sectionPattern.exec(line)
+    if (sectionMatch !== null) {
+      const section = unquote(sectionMatch[1])
+      if (section === "__proto__") {
+        current = Object.create(null)
+      } else {
+        current = output[section] ??= Object.create(null)
+      }
+      continue
+    }
+
+    const propertyMatch = propertyPattern.exec(line)
+    if (propertyMatch === null) {
+      continue
+    }
+
+    const rawKey = unquote(propertyMatch[1])
+    const array = rawKey.length > 2 && rawKey.endsWith("[]")
+    const key = array ? rawKey.slice(0, -2) : rawKey
+    if (key === "__proto__") {
+      continue
+    }
+
+    const rawValue = propertyMatch[2] === undefined ? true : unquote(propertyMatch[3])
+    const value = rawValue === "true" || rawValue === "false" || rawValue === "null"
+      ? JSON.parse(rawValue)
+      : rawValue
+
+    if (array) {
+      if (!hasOwn.call(current, key)) {
+        current[key] = []
+      } else if (!Array.isArray(current[key])) {
+        current[key] = [current[key]]
+      }
+    }
+    if (Array.isArray(current[key])) {
+      current[key].push(value)
+    } else {
+      current[key] = value
+    }
+  }
+
+  const remove: Array<string> = []
+  for (const section of Object.keys(output)) {
+    if (typeof output[section] !== "object" || output[section] === null || Array.isArray(output[section])) {
+      continue
+    }
+
+    const parts = splitSections(section)
+    const last = parts.pop()!
+    const key = last.replace(/\\\./g, ".")
+    current = output
+    for (const part of parts) {
+      if (part === "__proto__") {
+        continue
+      }
+      if (!hasOwn.call(current, part) || typeof current[part] !== "object" || current[part] === null) {
+        current[part] = Object.create(null)
+      }
+      current = current[part]
+    }
+    if (current === output && key === last) {
+      continue
+    }
+    current[key] = output[section]
+    remove.push(section)
+  }
+  for (const section of remove) {
+    delete output[section]
+  }
+  return output
+}