///|
suberror TestFlushError {
  TestFlushError(String)
}

///|
async test "shutdown drains pending records" {
  inspect(
    async_runtime_mode_label(async_runtime_mode()) == "native_worker" ||
    async_runtime_mode_label(async_runtime_mode()) == "compatibility",
    content="true",
  )
  let written : Ref[Array[String]] = Ref([])
  let flushes : Ref[Int] = Ref(0)
  let logger = async_logger(
    @bitlogger.callback_sink(fn(rec) { written.val.push(rec.message) }),
    config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::Blocking,
      max_batch=4,
      linger_ms=10,
      flush=AsyncFlushPolicy::Batch,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.test",
    flush=fn(_) {
      flushes.val += 1
      1
    },
  )

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("one")
    logger.info("two")
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.has_failed(), content="false")
  inspect(logger.pending_count(), content="0")
  inspect(
    match logger.flush_policy() {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Batch",
  )
  inspect(written.val.length(), content="2")
  inspect(written.val[0], content="one")
  inspect(written.val[1], content="two")
  inspect(flushes.val, content="1")
}

///|
async test "close clear counts abandoned records as dropped" {
  let logger = async_logger(
    @bitlogger.callback_sink(fn(_) {  }),
    config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::Blocking,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.clear",
  )

  logger.info("one")
  logger.info("two")
  inspect(logger.pending_count(), content="2")
  inspect(logger.dropped_count(), content="0")
  logger.close(clear=true)
  inspect(logger.is_closed(), content="true")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="2")
}

///|
async test "shutdown clear closes without worker startup" {
  let logger = async_logger(
    @bitlogger.callback_sink(fn(_) {  }),
    config=AsyncLoggerConfig::new(
      max_pending=2,
      overflow=AsyncOverflowPolicy::Blocking,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.noworker",
  )

  logger.info("one")
  logger.shutdown(clear=true)
  inspect(logger.is_closed(), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
}

///|
async test "closed blocking logger does not add pending count on later log attempts" {
  let logger = async_logger(
    @bitlogger.callback_sink(fn(_) {  }),
    config=AsyncLoggerConfig::new(
      max_pending=2,
      overflow=AsyncOverflowPolicy::Blocking,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.closed.blocking",
  )

  logger.info("one")
  logger.close(clear=true)
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")

  logger.info("late")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
}

///|
async test "closed logger runtime determines whether later log reaches patch path" {
  let patched : Ref[Int] = Ref(0)
  let logger = async_logger(
    @bitlogger.callback_sink(fn(_) {  }),
    config=AsyncLoggerConfig::new(
      max_pending=2,
      overflow=AsyncOverflowPolicy::Blocking,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.closed.patch",
  ).with_patch(fn(rec) {
    patched.val += 1
    rec
  })

  logger.info("one")
  inspect(patched.val, content="1")
  logger.close(clear=true)
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")

  logger.info("late")
  inspect(
    patched.val,
    content=if async_runtime_supports_background_worker() { "2" } else { "1" },
  )
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
}

///|
async test "async logger with_filter composes and leaves base logger unchanged" {
  let written_targets : Ref[Array[String]] = Ref([])
  let written_messages : Ref[Array[String]] = Ref([])
  let base = async_logger(
    @bitlogger.callback_sink(fn(rec) {
      written_targets.val.push(rec.target)
      written_messages.val.push(rec.message)
    }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Trace,
    target="service",
  )
  let filtered = base.with_filter(
    @bitlogger.all_of([
      @bitlogger.target_has_prefix("service.api"),
      @bitlogger.level_at_least(@bitlogger.Level::Info),
      @bitlogger.message_contains("visible"),
    ]),
  )

  @async.with_task_group(group => {
    group.spawn_bg(() => filtered.run())
    filtered.debug("visible debug")
    filtered.info("hidden info")
    filtered.child("api").info("visible info")
    filtered.shutdown()
  })

  inspect(written_messages.val.length(), content="1")
  inspect(written_messages.val[0], content="visible info")
  inspect(written_targets.val[0], content="service.api")

  let base_written : Ref[Array[String]] = Ref([])
  let untouched = async_logger(
    @bitlogger.callback_sink(fn(rec) { base_written.val.push(rec.message) }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Info,
    target="base",
  )
  ignore(untouched.with_filter(fn(_) { false }))

  @async.with_task_group(group => {
    group.spawn_bg(() => untouched.run())
    untouched.info("base still writes")
    untouched.shutdown()
  })

  inspect(base_written.val.length(), content="1")
  inspect(base_written.val[0], content="base still writes")
}

///|
async test "async logger with_patch composes before filter and does not mutate base logger" {
  let captured_target : Ref[String] = Ref("")
  let captured_message : Ref[String] = Ref("")
  let captured_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let logger = async_logger(
      @bitlogger.callback_sink(fn(rec) {
        captured_target.val = rec.target
        captured_message.val = rec.message
        captured_fields.val = rec.fields
      }),
      config=AsyncLoggerConfig::new(max_pending=4),
      min_level=@bitlogger.Level::Info,
      target="auth",
    )
    .with_patch(
      @bitlogger.compose_patches([
        @bitlogger.set_target("audit.auth"),
        @bitlogger.prefix_message("[safe] "),
        @bitlogger.redact_field("token"),
        @bitlogger.append_fields([@bitlogger.field("service", "bitlogger")]),
      ]),
    )
    .with_filter(@bitlogger.target_is("audit.auth"))

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("login", fields=[
      @bitlogger.field("token", "secret"),
      @bitlogger.field("user", "alice"),
    ])
    logger.shutdown()
  })

  inspect(captured_target.val, content="audit.auth")
  inspect(captured_message.val, content="[safe] login")
  inspect(captured_fields.val.length(), content="3")
  inspect(captured_fields.val[0].key, content="token")
  inspect(captured_fields.val[0].value, content="***")
  inspect(captured_fields.val[1].key, content="user")
  inspect(captured_fields.val[1].value, content="alice")
  inspect(captured_fields.val[2].key, content="service")
  inspect(captured_fields.val[2].value, content="bitlogger")

  let base_message : Ref[String] = Ref("")
  let base_target : Ref[String] = Ref("")
  let base_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let base = async_logger(
    @bitlogger.callback_sink(fn(rec) {
      base_message.val = rec.message
      base_target.val = rec.target
      base_fields.val = rec.fields
    }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Info,
    target="auth",
  )
  ignore(base.with_patch(@bitlogger.prefix_message("[safe] ")))

  @async.with_task_group(group => {
    group.spawn_bg(() => base.run())
    base.info("plain", fields=[@bitlogger.field("token", "secret")])
    base.shutdown()
  })

  inspect(base_target.val, content="auth")
  inspect(base_message.val, content="plain")
  inspect(base_fields.val.length(), content="1")
  inspect(base_fields.val[0].value, content="secret")
}

///|
async test "async logger with_min_level only affects derived logger threshold" {
  let base_written : Ref[Array[String]] = Ref([])
  let derived_written : Ref[Array[String]] = Ref([])
  let base = async_logger(
    @bitlogger.callback_sink(fn(rec) { base_written.val.push(rec.message) }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Info,
    target="level.base",
  )
  let derived = async_logger(
    @bitlogger.callback_sink(fn(rec) { derived_written.val.push(rec.message) }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Info,
    target="level.derived",
  ).with_min_level(@bitlogger.Level::Error)

  inspect(base.is_enabled(@bitlogger.Level::Info), content="true")
  inspect(derived.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(derived.is_enabled(@bitlogger.Level::Error), content="true")

  @async.with_task_group(group => {
    group.spawn_bg(() => base.run())
    group.spawn_bg(() => derived.run())
    base.info("base info")
    derived.info("derived info skipped")
    derived.error("derived error kept")
    base.shutdown()
    derived.shutdown()
  })

  inspect(base_written.val.length(), content="1")
  inspect(base_written.val[0], content="base info")
  inspect(derived_written.val.length(), content="1")
  inspect(derived_written.val[0], content="derived error kept")
}

///|
async test "async logger with_target replaces default target without mutating base logger" {
  let written_targets : Ref[Array[String]] = Ref([])
  let logger = async_logger(
    @bitlogger.callback_sink(fn(rec) { written_targets.val.push(rec.target) }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Warn,
    target="async.base",
  ).with_timestamp()
  let retargeted = logger.with_target("async.retarget")

  inspect(logger.target, content="async.base")
  inspect(retargeted.target, content="async.retarget")
  inspect(logger.timestamp, content="true")
  inspect(retargeted.timestamp, content="true")

  @async.with_task_group(group => {
    group.spawn_bg(() => retargeted.run())
    retargeted.error("retargeted")
    retargeted.shutdown()
  })

  inspect(written_targets.val.length(), content="1")
  inspect(written_targets.val[0], content="async.retarget")

  let base_targets : Ref[Array[String]] = Ref([])
  let base = async_logger(
    @bitlogger.callback_sink(fn(rec) { base_targets.val.push(rec.target) }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Warn,
    target="async.base",
  )
  ignore(base.with_target("async.retarget"))

  @async.with_task_group(group => {
    group.spawn_bg(() => base.run())
    base.error("base")
    base.shutdown()
  })

  inspect(base_targets.val.length(), content="1")
  inspect(base_targets.val[0], content="async.base")
}

///|
async test "async logger with_context_fields prepends shared fields without mutating base logger" {
  let written_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let logger = async_logger(
    @bitlogger.callback_sink(fn(rec) { written_fields.val = rec.fields }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Warn,
    target="async.ctx",
  )
  let contextual = logger.with_context_fields([
    @bitlogger.field("service", "bitlogger"),
    @bitlogger.field("scope", "sdk"),
  ])

  inspect(logger.context_fields.length(), content="0")
  inspect(contextual.context_fields.length(), content="2")

  @async.with_task_group(group => {
    group.spawn_bg(() => contextual.run())
    contextual.error("ctx", fields=[@bitlogger.field("mode", "test")])
    contextual.shutdown()
  })

  inspect(written_fields.val.length(), content="3")
  inspect(written_fields.val[0].key, content="service")
  inspect(written_fields.val[0].value, content="bitlogger")
  inspect(written_fields.val[1].key, content="scope")
  inspect(written_fields.val[1].value, content="sdk")
  inspect(written_fields.val[2].key, content="mode")
  inspect(written_fields.val[2].value, content="test")
}

///|
async test "async logger child composes target and preserves other state" {
  let written_target : Ref[String] = Ref("")
  let written_timestamp : Ref[UInt64] = Ref(0UL)
  let logger = async_logger(
    @bitlogger.callback_sink(fn(rec) {
      written_target.val = rec.target
      written_timestamp.val = rec.timestamp_ms
    }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Warn,
    target="sdk",
  ).with_timestamp()
  let child = logger.child("worker")

  inspect(logger.target, content="sdk")
  inspect(child.target, content="sdk.worker")
  inspect(child.timestamp, content="true")
  inspect(child.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(child.is_enabled(@bitlogger.Level::Info), content="false")

  @async.with_task_group(group => {
    group.spawn_bg(() => child.run())
    child.error("child")
    child.shutdown()
  })

  inspect(written_target.val, content="sdk.worker")
  inspect(written_timestamp.val > 0UL, content="true")

  let root_child = async_logger(
    @bitlogger.callback_sink(fn(_) {  }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Info,
    target="",
  ).child("worker")
  inspect(root_child.target, content="worker")

  let keep_parent = async_logger(
    @bitlogger.callback_sink(fn(_) {  }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Info,
    target="sdk",
  ).child("")
  inspect(keep_parent.target, content="sdk")
}

///|
async test "async logger with_timestamp only affects derived logger timestamp flag" {
  let base_timestamp : Ref[UInt64] = Ref(0UL)
  let derived_timestamp : Ref[UInt64] = Ref(0UL)
  let base = async_logger(
    @bitlogger.callback_sink(fn(rec) { base_timestamp.val = rec.timestamp_ms }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Warn,
    target="async.ts.base",
  )
  let derived = async_logger(
    @bitlogger.callback_sink(fn(rec) {
      derived_timestamp.val = rec.timestamp_ms
    }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Warn,
    target="async.ts.derived",
  ).with_timestamp()

  inspect(base.timestamp, content="false")
  inspect(derived.timestamp, content="true")

  @async.with_task_group(group => {
    group.spawn_bg(() => base.run())
    group.spawn_bg(() => derived.run())
    base.error("base")
    derived.error("derived")
    base.shutdown()
    derived.shutdown()
  })

  inspect(base_timestamp.val, content="0")
  inspect(derived_timestamp.val > 0UL, content="true")
}

///|
async test "async logger log supports per-call target override" {
  let written_target : Ref[String] = Ref("")
  let written_message : Ref[String] = Ref("")
  let written_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let logger = async_logger(
    @bitlogger.callback_sink(fn(rec) {
      written_target.val = rec.target
      written_message.val = rec.message
      written_fields.val = rec.fields
    }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Warn,
    target="async.default",
  ).with_context_fields([@bitlogger.field("service", "bitlogger")])

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.log(
      @bitlogger.Level::Error,
      "override",
      fields=[@bitlogger.field("mode", "test")],
      target="async.override",
    )
    logger.shutdown()
  })

  inspect(written_target.val, content="async.override")
  inspect(written_message.val, content="override")
  inspect(written_fields.val.length(), content="2")
  inspect(written_fields.val[0].key, content="service")
  inspect(written_fields.val[0].value, content="bitlogger")
  inspect(written_fields.val[1].key, content="mode")
  inspect(written_fields.val[1].value, content="test")

  let second_target : Ref[String] = Ref("")
  let second_message : Ref[String] = Ref("")
  let second_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let second = async_logger(
    @bitlogger.callback_sink(fn(rec) {
      second_target.val = rec.target
      second_message.val = rec.message
      second_fields.val = rec.fields
    }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Warn,
    target="async.default",
  ).with_context_fields([@bitlogger.field("service", "bitlogger")])

  @async.with_task_group(group => {
    group.spawn_bg(() => second.run())
    second.log(@bitlogger.Level::Error, "default")
    second.shutdown()
  })

  inspect(second_target.val, content="async.default")
  inspect(second_message.val, content="default")
  inspect(second_fields.val.length(), content="1")
  inspect(second_fields.val[0].key, content="service")
}

///|
async test "async logger severity helpers use stored target without override" {
  let written_levels : Ref[Array[String]] = Ref([])
  let written_targets : Ref[Array[String]] = Ref([])
  let written_fields : Ref[Array[Array[@bitlogger.Field]]] = Ref([])
  let logger = async_logger(
    @bitlogger.callback_sink(fn(rec) {
      written_levels.val.push(rec.level.label())
      written_targets.val.push(rec.target)
      written_fields.val.push(rec.fields)
    }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Info,
    target="async.helpers",
  ).with_context_fields([@bitlogger.field("service", "bitlogger")])

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("info", fields=[@bitlogger.field("mode", "info")])
    logger.warn("warn", fields=[@bitlogger.field("mode", "warn")])
    logger.error("error", fields=[@bitlogger.field("mode", "error")])
    logger.shutdown()
  })

  inspect(written_levels.val.length(), content="3")
  inspect(written_levels.val[0], content="INFO")
  inspect(written_levels.val[1], content="WARN")
  inspect(written_levels.val[2], content="ERROR")
  inspect(written_targets.val.length(), content="3")
  inspect(written_targets.val[0], content="async.helpers")
  inspect(written_targets.val[1], content="async.helpers")
  inspect(written_targets.val[2], content="async.helpers")
  inspect(written_fields.val[0].length(), content="2")
  inspect(written_fields.val[1].length(), content="2")
  inspect(written_fields.val[2].length(), content="2")
  inspect(written_fields.val[0][0].key, content="service")
  inspect(written_fields.val[0][1].value, content="info")
  inspect(written_fields.val[1][0].key, content="service")
  inspect(written_fields.val[1][1].value, content="warn")
  inspect(written_fields.val[2][0].key, content="service")
  inspect(written_fields.val[2][1].value, content="error")
}

///|
test "async logger config stringify roundtrips stable fields" {
  let text = stringify_async_logger_config(
    AsyncLoggerConfig::new(
      max_pending=8,
      overflow=AsyncOverflowPolicy::DropOldest,
      max_batch=3,
      linger_ms=25,
      flush=AsyncFlushPolicy::Batch,
    ),
  )
  let config = parse_async_logger_config_text(text)
  inspect(config.max_pending, content="8")
  inspect(config.max_batch, content="3")
  inspect(config.linger_ms, content="25")
  inspect(
    match config.overflow {
      AsyncOverflowPolicy::Blocking => "Blocking"
      AsyncOverflowPolicy::DropOldest => "DropOldest"
      AsyncOverflowPolicy::DropNewest => "DropNewest"
    },
    content="DropOldest",
  )
  inspect(
    match config.flush {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Batch",
  )
}

///|
test "async logger config parser accepts compatibility aliases" {
  let config = parse_async_logger_config_text(
    "{\"overflow\":\"DropLatest\",\"flush\":\"None\",\"max_batch\":0,\"linger_ms\":-2}",
  )
  inspect(config.max_batch, content="1")
  inspect(config.linger_ms, content="0")
  inspect(
    match config.overflow {
      AsyncOverflowPolicy::Blocking => "Blocking"
      AsyncOverflowPolicy::DropOldest => "DropOldest"
      AsyncOverflowPolicy::DropNewest => "DropNewest"
    },
    content="DropNewest",
  )
  inspect(
    match config.flush {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Never",
  )
}

///|
async test "async logger config constructor normalizes batch and linger but preserves pending input" {
  let config = AsyncLoggerConfig::new(
    max_pending=-3,
    overflow=AsyncOverflowPolicy::DropNewest,
    max_batch=0,
    linger_ms=-5,
    flush=AsyncFlushPolicy::Batch,
  )
  inspect(config.max_pending, content="-3")
  inspect(config.max_batch, content="1")
  inspect(config.linger_ms, content="0")
  inspect(
    match config.overflow {
      AsyncOverflowPolicy::Blocking => "Blocking"
      AsyncOverflowPolicy::DropOldest => "DropOldest"
      AsyncOverflowPolicy::DropNewest => "DropNewest"
    },
    content="DropNewest",
  )
  inspect(
    match config.flush {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Batch",
  )

  let logger = async_logger(
    @bitlogger.callback_sink(fn(_) {  }),
    config~,
    min_level=@bitlogger.Level::Info,
    target="async.config.normalized",
  )
  logger.info("one")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
}

///|
test "async build config stringify roundtrips nested logger and async fields" {
  let text = stringify_async_logger_build_config(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.roundtrip",
        timestamp=true,
        sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::TextConsole),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::DropNewest,
        max_batch=5,
        linger_ms=40,
        flush=AsyncFlushPolicy::Shutdown,
      ),
    ),
  )
  let config = parse_async_logger_build_config_text(text)
  inspect(config.logger.min_level.label(), content="WARN")
  inspect(config.logger.target, content="async.roundtrip")
  inspect(config.logger.timestamp, content="true")
  inspect(config.async_config.max_pending, content="2")
  inspect(config.async_config.max_batch, content="5")
  inspect(config.async_config.linger_ms, content="40")
  inspect(
    match config.async_config.overflow {
      AsyncOverflowPolicy::Blocking => "Blocking"
      AsyncOverflowPolicy::DropOldest => "DropOldest"
      AsyncOverflowPolicy::DropNewest => "DropNewest"
    },
    content="DropNewest",
  )
  inspect(
    match config.async_config.flush {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )
}

///|
test "async build config parser fills omitted sections from defaults" {
  let config = parse_async_logger_build_config_text("{}")
  inspect(config.logger.min_level.label(), content="INFO")
  inspect(config.logger.target, content="")
  inspect(config.logger.timestamp, content="false")
  inspect(
    match config.logger.sink.kind {
      @bitlogger.SinkKind::Console => "Console"
      @bitlogger.SinkKind::JsonConsole => "JsonConsole"
      @bitlogger.SinkKind::TextConsole => "TextConsole"
      @bitlogger.SinkKind::File => "File"
    },
    content="Console",
  )
  inspect(config.logger.queue is None, content="true")
  inspect(config.async_config.max_pending, content="0")
  inspect(config.async_config.max_batch, content="1")
  inspect(config.async_config.linger_ms, content="0")
  inspect(
    match config.async_config.overflow {
      AsyncOverflowPolicy::Blocking => "Blocking"
      AsyncOverflowPolicy::DropOldest => "DropOldest"
      AsyncOverflowPolicy::DropNewest => "DropNewest"
    },
    content="Blocking",
  )
  inspect(
    match config.async_config.flush {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Never",
  )
}

///|
test "async json helpers export stable structured shapes" {
  let config_json = async_logger_config_to_json(
    AsyncLoggerConfig::new(
      max_pending=8,
      overflow=AsyncOverflowPolicy::DropOldest,
      max_batch=3,
      linger_ms=25,
      flush=AsyncFlushPolicy::Batch,
    ),
  )
  let config_obj = config_json.as_object().unwrap()
  inspect(
    @json_parser.stringify(config_json),
    content="{\"max_pending\":8,\"max_batch\":3,\"linger_ms\":25,\"overflow\":\"DropOldest\",\"flush\":\"Batch\"}",
  )
  inspect(
    config_obj.get("max_pending").unwrap().as_number().unwrap().to_int(),
    content="8",
  )
  inspect(
    config_obj.get("max_batch").unwrap().as_number().unwrap().to_int(),
    content="3",
  )
  inspect(
    config_obj.get("linger_ms").unwrap().as_number().unwrap().to_int(),
    content="25",
  )
  inspect(
    config_obj.get("overflow").unwrap().as_string().unwrap(),
    content="DropOldest",
  )
  inspect(
    config_obj.get("flush").unwrap().as_string().unwrap(),
    content="Batch",
  )

  let build_json = async_logger_build_config_to_json(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.roundtrip",
        timestamp=true,
        sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::TextConsole),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::DropNewest,
        max_batch=5,
        linger_ms=40,
        flush=AsyncFlushPolicy::Shutdown,
      ),
    ),
  )
  let build_obj = build_json.as_object().unwrap()
  let logger_obj = build_obj.get("logger").unwrap().as_object().unwrap()
  let sink_obj = logger_obj.get("sink").unwrap().as_object().unwrap()
  let formatter_obj = sink_obj
    .get("text_formatter")
    .unwrap()
    .as_object()
    .unwrap()
  let async_obj = build_obj.get("async_config").unwrap().as_object().unwrap()

  inspect(
    logger_obj.get("min_level").unwrap().as_string().unwrap(),
    content="WARN",
  )
  inspect(
    logger_obj.get("target").unwrap().as_string().unwrap(),
    content="async.roundtrip",
  )
  inspect(
    logger_obj.get("timestamp").unwrap().as_bool().unwrap(),
    content="true",
  )
  inspect(logger_obj.get("queue") is None, content="true")
  inspect(
    sink_obj.get("kind").unwrap().as_string().unwrap(),
    content="text_console",
  )
  inspect(sink_obj.get("path").unwrap().as_string().unwrap(), content="")
  inspect(sink_obj.get("append").unwrap().as_bool().unwrap(), content="true")
  inspect(
    sink_obj.get("auto_flush").unwrap().as_bool().unwrap(),
    content="true",
  )
  inspect(
    formatter_obj.get("show_timestamp").unwrap().as_bool().unwrap(),
    content="true",
  )
  inspect(
    formatter_obj.get("separator").unwrap().as_string().unwrap(),
    content=" ",
  )
  inspect(
    formatter_obj.get("field_separator").unwrap().as_string().unwrap(),
    content=" ",
  )
  inspect(
    formatter_obj.get("template").unwrap().as_string().unwrap(),
    content="",
  )
  inspect(
    formatter_obj.get("color_mode").unwrap().as_string().unwrap(),
    content="never",
  )
  inspect(
    formatter_obj.get("color_support").unwrap().as_string().unwrap(),
    content="truecolor",
  )
  inspect(
    formatter_obj.get("style_markup").unwrap().as_string().unwrap(),
    content="full",
  )
  inspect(
    async_obj.get("max_pending").unwrap().as_number().unwrap().to_int(),
    content="2",
  )
  inspect(
    async_obj.get("max_batch").unwrap().as_number().unwrap().to_int(),
    content="5",
  )
  inspect(
    async_obj.get("linger_ms").unwrap().as_number().unwrap().to_int(),
    content="40",
  )
  inspect(
    async_obj.get("overflow").unwrap().as_string().unwrap(),
    content="DropNewest",
  )
  inspect(
    async_obj.get("flush").unwrap().as_string().unwrap(),
    content="Shutdown",
  )
}

///|
test "async build config json export materializes parsed omitted defaults" {
  let parsed = parse_async_logger_build_config_text("{}")
  let build_json = async_logger_build_config_to_json(parsed)
  let build_obj = build_json.as_object().unwrap()
  let logger_obj = build_obj.get("logger").unwrap().as_object().unwrap()
  let sink_obj = logger_obj.get("sink").unwrap().as_object().unwrap()
  let formatter_obj = sink_obj
    .get("text_formatter")
    .unwrap()
    .as_object()
    .unwrap()
  let async_obj = build_obj.get("async_config").unwrap().as_object().unwrap()

  inspect(
    @json_parser.stringify(build_json),
    content="{\"logger\":{\"min_level\":\"INFO\",\"target\":\"\",\"timestamp\":false,\"sink\":{\"kind\":\"console\",\"path\":\"\",\"append\":true,\"auto_flush\":true,\"text_formatter\":{\"show_timestamp\":true,\"show_level\":true,\"show_target\":true,\"show_fields\":true,\"separator\":\" \",\"field_separator\":\" \",\"template\":\"\",\"color_mode\":\"never\",\"color_support\":\"truecolor\",\"style_markup\":\"full\",\"target_style_markup\":\"disabled\",\"fields_style_markup\":\"disabled\"}}},\"async_config\":{\"max_pending\":0,\"max_batch\":1,\"linger_ms\":0,\"overflow\":\"Blocking\",\"flush\":\"Never\"}}",
  )
  inspect(
    logger_obj.get("min_level").unwrap().as_string().unwrap(),
    content="INFO",
  )
  inspect(logger_obj.get("target").unwrap().as_string().unwrap(), content="")
  inspect(
    logger_obj.get("timestamp").unwrap().as_bool().unwrap(),
    content="false",
  )
  inspect(logger_obj.get("queue") is None, content="true")
  inspect(sink_obj.get("kind").unwrap().as_string().unwrap(), content="console")
  inspect(sink_obj.get("path").unwrap().as_string().unwrap(), content="")
  inspect(sink_obj.get("append").unwrap().as_bool().unwrap(), content="true")
  inspect(
    sink_obj.get("auto_flush").unwrap().as_bool().unwrap(),
    content="true",
  )
  inspect(
    formatter_obj.get("show_timestamp").unwrap().as_bool().unwrap(),
    content="true",
  )
  inspect(
    formatter_obj.get("show_level").unwrap().as_bool().unwrap(),
    content="true",
  )
  inspect(
    formatter_obj.get("show_target").unwrap().as_bool().unwrap(),
    content="true",
  )
  inspect(
    formatter_obj.get("show_fields").unwrap().as_bool().unwrap(),
    content="true",
  )
  inspect(
    formatter_obj.get("separator").unwrap().as_string().unwrap(),
    content=" ",
  )
  inspect(
    formatter_obj.get("field_separator").unwrap().as_string().unwrap(),
    content=" ",
  )
  inspect(
    formatter_obj.get("template").unwrap().as_string().unwrap(),
    content="",
  )
  inspect(
    formatter_obj.get("color_mode").unwrap().as_string().unwrap(),
    content="never",
  )
  inspect(
    formatter_obj.get("color_support").unwrap().as_string().unwrap(),
    content="truecolor",
  )
  inspect(
    formatter_obj.get("style_markup").unwrap().as_string().unwrap(),
    content="full",
  )
  inspect(
    formatter_obj.get("target_style_markup").unwrap().as_string().unwrap(),
    content="disabled",
  )
  inspect(
    formatter_obj.get("fields_style_markup").unwrap().as_string().unwrap(),
    content="disabled",
  )
  inspect(formatter_obj.get("style_tags") is None, content="true")
  inspect(
    async_obj.get("max_pending").unwrap().as_number().unwrap().to_int(),
    content="0",
  )
  inspect(
    async_obj.get("max_batch").unwrap().as_number().unwrap().to_int(),
    content="1",
  )
  inspect(
    async_obj.get("linger_ms").unwrap().as_number().unwrap().to_int(),
    content="0",
  )
  inspect(
    async_obj.get("overflow").unwrap().as_string().unwrap(),
    content="Blocking",
  )
  inspect(async_obj.get("flush").unwrap().as_string().unwrap(), content="Never")
}

///|
test "async config parsers reject malformed input" {
  let invalid_json_error = (fn() -> String raise {
    ignore(parse_async_logger_config_text("{"))
    "no error"
  })() catch {
    err => err.to_string()
  }
  inspect(invalid_json_error.contains("UnexpectedToken"), content="true")

  let wrong_type_error = (fn() -> String raise {
    ignore(parse_async_logger_config_text("{\"max_pending\":\"many\"}"))
    "no error"
  })() catch {
    err => err.to_string()
  }
  inspect(
    wrong_type_error.contains("Expected number at async_config.max_pending"),
    content="true",
  )

  let invalid_enum_error = (fn() -> String raise {
    ignore(parse_async_logger_config_text("{\"overflow\":\"Burst\"}"))
    "no error"
  })() catch {
    err => err.to_string()
  }
  inspect(
    invalid_enum_error.contains("Unsupported async overflow policy: Burst"),
    content="true",
  )

  let invalid_build_root_error = (fn() -> String raise {
    ignore(parse_async_logger_build_config_text("[]"))
    "no error"
  })() catch {
    err => err.to_string()
  }
  inspect(
    invalid_build_root_error.contains(
      "Expected object at async logger build config root",
    ),
    content="true",
  )

  let nested_sync_error = (fn() -> String raise {
    ignore(
      parse_async_logger_build_config_text(
        "{\"logger\":{\"timestamp\":\"true\"}}",
      ),
    )
    "no error"
  })() catch {
    err => err.to_string()
  }
  inspect(
    nested_sync_error.contains("ConfigError.InvalidConfig"),
    content="true",
  )
}

///|
test "async runtime capability helpers stay consistent" {
  let mode = async_runtime_mode()
  let state = async_runtime_state()
  let worker_supported = match mode {
    AsyncRuntimeMode::NativeWorker => true
    AsyncRuntimeMode::Compatibility => false
  }
  inspect(
    async_runtime_mode_label(mode) == "native_worker" ||
    async_runtime_mode_label(mode) == "compatibility",
    content="true",
  )
  inspect(
    async_runtime_supports_background_worker() == worker_supported,
    content="true",
  )
  inspect(
    async_runtime_mode_label(state.mode) == async_runtime_mode_label(mode),
    content="true",
  )
  inspect(state.background_worker == worker_supported, content="true")
  inspect(
    @json_parser.stringify(async_runtime_state_to_json(state)),
    content=if worker_supported {
      "{\"mode\":\"native_worker\",\"background_worker\":true}"
    } else {
      "{\"mode\":\"compatibility\",\"background_worker\":false}"
    },
  )
  inspect(
    stringify_async_runtime_state(state),
    content=if worker_supported {
      "{\"mode\":\"native_worker\",\"background_worker\":true}"
    } else {
      "{\"mode\":\"compatibility\",\"background_worker\":false}"
    },
  )
}

///|
test "async runtime mode and worker flag encode target contract" {
  let mode_label = async_runtime_mode_label(async_runtime_mode())
  let worker = async_runtime_supports_background_worker()
  inspect(
    mode_label == "native_worker" || mode_label == "compatibility",
    content="true",
  )
  inspect((mode_label == "native_worker") == worker, content="true")
  inspect((mode_label == "compatibility") == !worker, content="true")
}

///|
test "async logger state snapshot reflects current counters and runtime" {
  let logger = async_logger(
    @bitlogger.callback_sink(fn(_) {  }),
    config=AsyncLoggerConfig::new(
      max_pending=3,
      overflow=AsyncOverflowPolicy::DropNewest,
      flush=AsyncFlushPolicy::Shutdown,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.state",
  )
  let state = logger.state()
  inspect(
    async_runtime_mode_label(state.runtime.mode) ==
    async_runtime_mode_label(async_runtime_mode()),
    content="true",
  )
  inspect(
    state.runtime.background_worker ==
    async_runtime_supports_background_worker(),
    content="true",
  )
  inspect(state.pending_count, content="0")
  inspect(state.dropped_count, content="0")
  inspect(state.is_closed, content="false")
  inspect(state.is_running, content="false")
  inspect(state.has_failed, content="false")
  inspect(state.last_error, content="")
  inspect(
    match state.flush_policy {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )
  inspect(
    @json_parser.stringify(async_logger_state_to_json(state)),
    content=if async_runtime_supports_background_worker() {
      "{\"runtime\":{\"mode\":\"native_worker\",\"background_worker\":true},\"pending_count\":0,\"dropped_count\":0,\"is_closed\":false,\"is_running\":false,\"has_failed\":false,\"last_error\":\"\",\"flush_policy\":\"Shutdown\"}"
    } else {
      "{\"runtime\":{\"mode\":\"compatibility\",\"background_worker\":false},\"pending_count\":0,\"dropped_count\":0,\"is_closed\":false,\"is_running\":false,\"has_failed\":false,\"last_error\":\"\",\"flush_policy\":\"Shutdown\"}"
    },
  )
  inspect(
    stringify_async_logger_state(state),
    content=if async_runtime_supports_background_worker() {
      "{\"runtime\":{\"mode\":\"native_worker\",\"background_worker\":true},\"pending_count\":0,\"dropped_count\":0,\"is_closed\":false,\"is_running\":false,\"has_failed\":false,\"last_error\":\"\",\"flush_policy\":\"Shutdown\"}"
    } else {
      "{\"runtime\":{\"mode\":\"compatibility\",\"background_worker\":false},\"pending_count\":0,\"dropped_count\":0,\"is_closed\":false,\"is_running\":false,\"has_failed\":false,\"last_error\":\"\",\"flush_policy\":\"Shutdown\"}"
    },
  )
}

///|
async test "run drains queued records in compatibility backends too" {
  let written : Ref[Array[String]] = Ref([])
  let logger = async_logger(
    @bitlogger.callback_sink(fn(rec) { written.val.push(rec.message) }),
    config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::DropNewest,
      max_batch=2,
      linger_ms=5,
      flush=AsyncFlushPolicy::Never,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.compat",
  )

  @async.with_task_group(group => {
    logger.info("one")
    logger.info("two")
    inspect(logger.pending_count(), content="2")
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.pending_count(), content="0")
  inspect(written.val.length(), content="2")
  inspect(written.val[0], content="one")
  inspect(written.val[1], content="two")
}

///|
async test "async logger records worker failures and wait_idle stops early" {
  let writes : Ref[Int] = Ref(0)
  let logger = async_logger(
    @bitlogger.callback_sink(fn(_) { writes.val += 1 }),
    config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::Blocking,
      flush=AsyncFlushPolicy::Batch,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.failure",
    flush=fn(_) -> Int raise { raise TestFlushError("flush exploded") },
  )

  @async.with_task_group(group => {
    group.spawn_bg(allow_failure=true, () => logger.run())
    logger.info("ok")
    logger.info("flush-now")
    logger.wait_idle()
    inspect(logger.has_failed(), content="true")
    inspect(logger.pending_count(), content="1")
    logger.close(clear=true)
  })

  inspect(writes.val, content="1")
  inspect(logger.has_failed(), content="true")
  inspect(logger.last_error().contains("TestFlushError"), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.pending_count(), content="0")
}

///|
async test "later started run resets async failure state before draining remaining backlog" {
  let writes : Ref[Int] = Ref(0)
  let flushes : Ref[Int] = Ref(0)
  let logger = async_logger(
    @bitlogger.callback_sink(fn(_) { writes.val += 1 }),
    config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::Blocking,
      flush=AsyncFlushPolicy::Batch,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.retry",
    flush=fn(_) -> Int raise {
      flushes.val += 1
      if flushes.val == 1 {
        raise TestFlushError("flush exploded once")
      }
      1
    },
  )

  @async.with_task_group(group => {
    group.spawn_bg(allow_failure=true, () => logger.run())
    logger.info("one")
    logger.info("two")
    logger.wait_idle()
    inspect(logger.has_failed(), content="true")
    inspect(logger.last_error().contains("TestFlushError"), content="true")
    inspect(logger.is_running(), content="false")
    inspect(logger.pending_count(), content="1")

    group.spawn_bg(() => logger.run())
    while !logger.is_running() {
      @async.pause()
    }
    inspect(logger.has_failed(), content="false")
    inspect(logger.last_error(), content="")
    logger.shutdown()
  })

  inspect(writes.val, content="2")
  inspect(flushes.val, content="2")
  inspect(logger.has_failed(), content="false")
  inspect(logger.last_error(), content="")
  inspect(logger.is_running(), content="false")
  inspect(logger.is_closed(), content="true")
  inspect(logger.pending_count(), content="0")
}

///|
async test "shutdown after worker failure uses runtime-specific pending cleanup" {
  let writes : Ref[Int] = Ref(0)
  let logger = async_logger(
    @bitlogger.callback_sink(fn(_) { writes.val += 1 }),
    config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::Blocking,
      flush=AsyncFlushPolicy::Batch,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.failure.shutdown",
    flush=fn(_) -> Int raise {
      raise TestFlushError("flush exploded on shutdown path")
    },
  )

  @async.with_task_group(group => {
    group.spawn_bg(allow_failure=true, () => logger.run())
    logger.info("one")
    logger.info("two")
    logger.wait_idle()
    inspect(logger.has_failed(), content="true")
    inspect(logger.pending_count(), content="1")
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.has_failed(), content="true")
  inspect(logger.last_error().contains("TestFlushError"), content="true")
  inspect(logger.is_running(), content="false")
  inspect(writes.val, content="1")
  inspect(
    logger.pending_count(),
    content=if async_runtime_supports_background_worker() { "0" } else { "1" },
  )
  inspect(
    logger.dropped_count(),
    content=if async_runtime_supports_background_worker() { "1" } else { "0" },
  )
}

///|
async test "library async logger keeps a smaller async facade" {
  let written_targets : Ref[Array[String]] = Ref([])
  let written_messages : Ref[Array[String]] = Ref([])
  let written_field_counts : Ref[Array[Int]] = Ref([])
  let logger = LibraryAsyncLogger::new(
      @bitlogger.callback_sink(fn(rec) {
        written_targets.val.push(rec.target)
        written_messages.val.push(rec.message)
        written_field_counts.val.push(rec.fields.length())
      }),
      config=AsyncLoggerConfig::new(max_pending=4),
      min_level=@bitlogger.Level::Info,
      target="async.lib",
    )
    .with_context_fields([@bitlogger.field("service", "bitlogger")])
    .child("worker")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("ready", fields=[@bitlogger.field("mode", "test")])
    logger.shutdown()
  })

  inspect(written_targets.val.length(), content="1")
  inspect(written_targets.val[0], content="async.lib.worker")
  inspect(written_messages.val[0], content="ready")
  inspect(written_field_counts.val[0], content="2")
}

///|
async test "library async new preserves config and flush failure contract" {
  let writes : Ref[Int] = Ref(0)
  let flushes : Ref[Int] = Ref(0)
  let logger = LibraryAsyncLogger::new(
    @bitlogger.callback_sink(fn(_) { writes.val += 1 }),
    config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::Blocking,
      max_batch=3,
      linger_ms=7,
      flush=AsyncFlushPolicy::Batch,
    ),
    min_level=@bitlogger.Level::Warn,
    target="async.lib.new",
    flush=fn(_) -> Int raise {
      flushes.val += 1
      raise TestFlushError("library new flush exploded")
    },
  )
  let full = logger.to_async_logger()

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.new")
  inspect(
    match full.flush_policy() {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Batch",
  )
  inspect(full.pending_count(), content="0")
  inspect(full.has_failed(), content="false")
  inspect(full.last_error(), content="")

  logger.info("skip")
  inspect(full.pending_count(), content="0")
  logger.error("one")
  logger.error("two")
  inspect(full.pending_count(), content="2")

  @async.with_task_group(group => {
    group.spawn_bg(allow_failure=true, () => logger.run())
    full.wait_idle()
    while !full.has_failed() && full.is_running() {
      @async.pause()
    }
    inspect(full.has_failed(), content="true")
    inspect(full.last_error().contains("TestFlushError"), content="true")
    inspect(full.is_running(), content="false")
    inspect(full.pending_count(), content="0")
    logger.shutdown(clear=true)
  })

  inspect(writes.val, content="2")
  inspect(flushes.val, content="1")
  inspect(full.is_closed(), content="true")
}

///|
async test "library async context binding replaces stored field set" {
  let written_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let logger = LibraryAsyncLogger::new(
      @bitlogger.callback_sink(fn(rec) { written_fields.val = rec.fields }),
      config=AsyncLoggerConfig::new(max_pending=4),
      min_level=@bitlogger.Level::Warn,
      target="async.lib.ctx",
    )
    .with_context_fields([@bitlogger.field("old", "gone")])
    .with_context_fields([
      @bitlogger.field("service", "bitlogger"),
      @bitlogger.field("scope", "sdk"),
    ])
  let full = logger.to_async_logger()

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.ctx")
  inspect(full.timestamp, content="false")
  inspect(full.context_fields.length(), content="2")
  inspect(full.context_fields[0].key, content="service")
  inspect(full.context_fields[0].value, content="bitlogger")
  inspect(full.context_fields[1].key, content="scope")
  inspect(full.context_fields[1].value, content="sdk")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.error("ctx", fields=[@bitlogger.field("mode", "test")])
    logger.shutdown()
  })

  inspect(written_fields.val.length(), content="3")
  inspect(written_fields.val[0].key, content="service")
  inspect(written_fields.val[0].value, content="bitlogger")
  inspect(written_fields.val[1].key, content="scope")
  inspect(written_fields.val[1].value, content="sdk")
  inspect(written_fields.val[2].key, content="mode")
  inspect(written_fields.val[2].value, content="test")
}

///|
async test "library async bind matches context facade contract" {
  let written_target : Ref[String] = Ref("")
  let written_timestamp : Ref[UInt64] = Ref(0UL)
  let written_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let logger = async_logger(
      @bitlogger.callback_sink(fn(rec) {
        written_target.val = rec.target
        written_timestamp.val = rec.timestamp_ms
        written_fields.val = rec.fields
      }),
      config=AsyncLoggerConfig::new(max_pending=4),
      min_level=@bitlogger.Level::Warn,
      target="async.lib.bind",
    )
    .with_timestamp()
    .to_library_async_logger()
    .bind([@bitlogger.field("service", "bitlogger")])
  let full = logger.to_async_logger()

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.bind")
  inspect(full.timestamp, content="true")
  inspect(full.context_fields.length(), content="1")
  inspect(full.context_fields[0].key, content="service")
  inspect(full.context_fields[0].value, content="bitlogger")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.error("bound", fields=[@bitlogger.field("mode", "test")])
    logger.shutdown()
  })

  inspect(written_target.val, content="async.lib.bind")
  inspect(written_timestamp.val > 0UL, content="true")
  inspect(written_fields.val.length(), content="2")
  inspect(written_fields.val[0].key, content="service")
  inspect(written_fields.val[0].value, content="bitlogger")
  inspect(written_fields.val[1].key, content="mode")
  inspect(written_fields.val[1].value, content="test")
}

///|
async test "library async logger with_target preserves facade state while replacing target" {
  let written_target : Ref[String] = Ref("")
  let written_timestamp : Ref[UInt64] = Ref(0UL)
  let logger = async_logger(
      @bitlogger.callback_sink(fn(rec) {
        written_target.val = rec.target
        written_timestamp.val = rec.timestamp_ms
      }),
      config=AsyncLoggerConfig::new(max_pending=4),
      min_level=@bitlogger.Level::Warn,
      target="async.lib.base",
    )
    .with_timestamp()
    .to_library_async_logger()
    .with_target("async.lib.retarget")
  let full = logger.to_async_logger()

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.retarget")
  inspect(full.timestamp, content="true")
  inspect(full.pending_count(), content="0")
  inspect(full.dropped_count(), content="0")
  inspect(full.is_closed(), content="false")
  inspect(full.is_running(), content="false")
  inspect(full.has_failed(), content="false")
  inspect(full.last_error(), content="")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.error("retargeted")
    logger.shutdown()
  })

  inspect(written_target.val, content="async.lib.retarget")
  inspect(written_timestamp.val > 0UL, content="true")
}

///|
async test "library async logger child composes target through facade" {
  let written_target : Ref[String] = Ref("")
  let written_timestamp : Ref[UInt64] = Ref(0UL)
  let logger = async_logger(
      @bitlogger.callback_sink(fn(rec) {
        written_target.val = rec.target
        written_timestamp.val = rec.timestamp_ms
      }),
      config=AsyncLoggerConfig::new(max_pending=4),
      min_level=@bitlogger.Level::Warn,
      target="sdk",
    )
    .with_timestamp()
    .to_library_async_logger()
    .child("worker")
  let full = logger.to_async_logger()

  inspect(full.target, content="sdk.worker")
  inspect(full.timestamp, content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.error("child")
    logger.shutdown()
  })

  inspect(written_target.val, content="sdk.worker")
  inspect(written_timestamp.val > 0UL, content="true")

  let root_child = LibraryAsyncLogger::new(@bitlogger.callback_sink(fn(_) {  })).child(
    "worker",
  )
  inspect(root_child.to_async_logger().target, content="worker")

  let keep_parent = LibraryAsyncLogger::new(
    @bitlogger.callback_sink(fn(_) {  }),
    target="sdk",
  ).child("")
  inspect(keep_parent.to_async_logger().target, content="sdk")
}

///|
async test "library async logger log supports per-call target override" {
  let written_target : Ref[String] = Ref("")
  let written_message : Ref[String] = Ref("")
  let written_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let logger = LibraryAsyncLogger::new(
    @bitlogger.callback_sink(fn(rec) {
      written_target.val = rec.target
      written_message.val = rec.message
      written_fields.val = rec.fields
    }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Warn,
    target="async.lib.default",
  ).with_context_fields([@bitlogger.field("service", "bitlogger")])

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.log(
      @bitlogger.Level::Error,
      "override",
      fields=[@bitlogger.field("mode", "test")],
      target="async.lib.override",
    )
    logger.shutdown()
  })

  inspect(written_target.val, content="async.lib.override")
  inspect(written_message.val, content="override")
  inspect(written_fields.val.length(), content="2")
  inspect(written_fields.val[0].key, content="service")
  inspect(written_fields.val[0].value, content="bitlogger")
  inspect(written_fields.val[1].key, content="mode")
  inspect(written_fields.val[1].value, content="test")

  let second_target : Ref[String] = Ref("")
  let second_message : Ref[String] = Ref("")
  let second_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let second = LibraryAsyncLogger::new(
    @bitlogger.callback_sink(fn(rec) {
      second_target.val = rec.target
      second_message.val = rec.message
      second_fields.val = rec.fields
    }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Warn,
    target="async.lib.default",
  ).with_context_fields([@bitlogger.field("service", "bitlogger")])

  @async.with_task_group(group => {
    group.spawn_bg(() => second.run())
    second.log(@bitlogger.Level::Error, "default")
    second.shutdown()
  })

  inspect(second_target.val, content="async.lib.default")
  inspect(second_message.val, content="default")
  inspect(second_fields.val.length(), content="1")
  inspect(second_fields.val[0].key, content="service")
}

///|
async test "library async severity helpers use stored target without override" {
  let written_levels : Ref[Array[String]] = Ref([])
  let written_targets : Ref[Array[String]] = Ref([])
  let written_fields : Ref[Array[Array[@bitlogger.Field]]] = Ref([])
  let logger = LibraryAsyncLogger::new(
    @bitlogger.callback_sink(fn(rec) {
      written_levels.val.push(rec.level.label())
      written_targets.val.push(rec.target)
      written_fields.val.push(rec.fields)
    }),
    config=AsyncLoggerConfig::new(max_pending=4),
    min_level=@bitlogger.Level::Info,
    target="async.lib.helpers",
  ).bind([@bitlogger.field("service", "bitlogger")])

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("info", fields=[@bitlogger.field("mode", "info")])
    logger.warn("warn", fields=[@bitlogger.field("mode", "warn")])
    logger.error("error", fields=[@bitlogger.field("mode", "error")])
    logger.shutdown()
  })

  inspect(written_levels.val.length(), content="3")
  inspect(written_levels.val[0], content="INFO")
  inspect(written_levels.val[1], content="WARN")
  inspect(written_levels.val[2], content="ERROR")
  inspect(written_targets.val.length(), content="3")
  inspect(written_targets.val[0], content="async.lib.helpers")
  inspect(written_targets.val[1], content="async.lib.helpers")
  inspect(written_targets.val[2], content="async.lib.helpers")
  inspect(written_fields.val[0].length(), content="2")
  inspect(written_fields.val[1].length(), content="2")
  inspect(written_fields.val[2].length(), content="2")
  inspect(written_fields.val[0][0].key, content="service")
  inspect(written_fields.val[0][1].value, content="info")
  inspect(written_fields.val[1][0].key, content="service")
  inspect(written_fields.val[1][1].value, content="warn")
  inspect(written_fields.val[2][0].key, content="service")
  inspect(written_fields.val[2][1].value, content="error")
}

///|
async test "library async shutdown preserves wrapped failure cleanup semantics" {
  let writes : Ref[Int] = Ref(0)
  let logger = LibraryAsyncLogger::new(
    @bitlogger.callback_sink(fn(_) { writes.val += 1 }),
    config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::Blocking,
      flush=AsyncFlushPolicy::Batch,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.lib.failure",
    flush=fn(_) -> Int raise {
      raise TestFlushError("library facade flush exploded")
    },
  )
  let full = logger.to_async_logger()

  @async.with_task_group(group => {
    group.spawn_bg(allow_failure=true, () => logger.run())
    logger.info("one")
    logger.info("two")
    full.wait_idle()
    inspect(full.has_failed(), content="true")
    inspect(full.pending_count(), content="1")
    logger.shutdown()
  })

  inspect(full.is_closed(), content="true")
  inspect(full.has_failed(), content="true")
  inspect(full.last_error().contains("TestFlushError"), content="true")
  inspect(full.is_running(), content="false")
  inspect(writes.val, content="1")
  inspect(
    full.pending_count(),
    content=if async_runtime_supports_background_worker() { "0" } else { "1" },
  )
  inspect(
    full.dropped_count(),
    content=if async_runtime_supports_background_worker() { "1" } else { "0" },
  )
}

///|
async test "library async shutdown clear abandons pending records through facade" {
  let logger = LibraryAsyncLogger::new(
    @bitlogger.callback_sink(fn(_) {  }),
    config=AsyncLoggerConfig::new(
      max_pending=2,
      overflow=AsyncOverflowPolicy::Blocking,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.lib.clear",
  )
  let full = logger.to_async_logger()

  logger.info("one")
  inspect(full.pending_count(), content="1")
  inspect(full.dropped_count(), content="0")
  logger.shutdown(clear=true)
  inspect(full.is_closed(), content="true")
  inspect(full.is_running(), content="false")
  inspect(full.pending_count(), content="0")
  inspect(full.dropped_count(), content="1")
}

///|
async test "library async logger can be built from config" {
  let logger = parse_and_build_library_async_logger(
    "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.lib.config\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropNewest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
  )
  let full = logger.to_async_logger()
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.config")
}

///|
async test "library async builder unwrap matches direct async builder behavior" {
  let config = AsyncLoggerBuildConfig::new(
    logger=@bitlogger.LoggerConfig::new(
      min_level=@bitlogger.Level::Warn,
      target="async.lib.same-build",
      timestamp=true,
      queue=Some(
        @bitlogger.QueueConfig::new(
          3,
          overflow=@bitlogger.QueueOverflowPolicy::DropNewest,
        ),
      ),
      sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
    ),
    async_config=AsyncLoggerConfig::new(
      max_pending=2,
      overflow=AsyncOverflowPolicy::DropOldest,
      flush=AsyncFlushPolicy::Shutdown,
    ),
  )
  let logger = build_library_async_logger(config)
  let full = logger.to_async_logger()
  let direct = build_async_logger(config)
  let full_state = full.state()
  let direct_state = direct.state()

  inspect(full.target, content=direct.target)
  inspect(full.timestamp == direct.timestamp, content="true")
  inspect(
    logger.is_enabled(@bitlogger.Level::Error) ==
    direct.is_enabled(@bitlogger.Level::Error),
    content="true",
  )
  inspect(
    logger.is_enabled(@bitlogger.Level::Info) ==
    direct.is_enabled(@bitlogger.Level::Info),
    content="true",
  )
  inspect(
    stringify_async_logger_state(full_state) ==
    stringify_async_logger_state(direct_state),
    content="true",
  )
  let full_sink_kind = match full.sink {
    @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
    @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
    @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
    @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
    @bitlogger.RuntimeSink::Console(_) => "Console"
    @bitlogger.RuntimeSink::JsonConsole(_) => "JsonConsole"
    @bitlogger.RuntimeSink::TextConsole(_) => "TextConsole"
    @bitlogger.RuntimeSink::File(_) => "File"
  }
  let direct_sink_kind = match direct.sink {
    @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
    @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
    @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
    @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
    @bitlogger.RuntimeSink::Console(_) => "Console"
    @bitlogger.RuntimeSink::JsonConsole(_) => "JsonConsole"
    @bitlogger.RuntimeSink::TextConsole(_) => "TextConsole"
    @bitlogger.RuntimeSink::File(_) => "File"
  }
  inspect(full_sink_kind == direct_sink_kind, content="true")

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  direct.info("skip")
  direct.error("one")
  direct.error("two")
  direct.error("three")

  inspect(full.pending_count() == direct.pending_count(), content="true")
  inspect(full.dropped_count() == direct.dropped_count(), content="true")
  inspect(full.is_closed() == direct.is_closed(), content="true")
  inspect(full.is_running() == direct.is_running(), content="true")
  inspect(
    full.sink.pending_count() == direct.sink.pending_count(),
    content="true",
  )
  inspect(
    full.sink.dropped_count() == direct.sink.dropped_count(),
    content="true",
  )

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    group.spawn_bg(() => direct.run())
    logger.shutdown()
    direct.shutdown()
  })

  inspect(full.is_closed() == direct.is_closed(), content="true")
  inspect(full.is_running() == direct.is_running(), content="true")
  inspect(full.pending_count() == direct.pending_count(), content="true")
  inspect(full.dropped_count() == direct.dropped_count(), content="true")
  inspect(full.has_failed() == direct.has_failed(), content="true")
  inspect(full.last_error() == direct.last_error(), content="true")
}

///|
async test "library async builder log supports per-call target override through facade" {
  let written_target : Ref[String] = Ref("")

  let logger = build_library_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.LoggerConfig::new(
          min_level=@bitlogger.Level::Warn,
          target="async.lib.builder.default",
          sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
        ),
        async_config=AsyncLoggerConfig::new(
          max_pending=2,
          overflow=AsyncOverflowPolicy::Blocking,
          flush=AsyncFlushPolicy::Never,
        ),
      ),
    )
    .to_async_logger()
    .with_patch(fn(rec) {
      written_target.val = rec.target
      rec
    })
    .to_library_async_logger()

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.log(
      @bitlogger.Level::Error,
      "override",
      target="async.lib.builder.override",
    )
    logger.shutdown()
  })

  inspect(written_target.val, content="async.lib.builder.override")

  let second_target : Ref[String] = Ref("")

  let second = build_library_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.LoggerConfig::new(
          min_level=@bitlogger.Level::Warn,
          target="async.lib.builder.default",
          sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
        ),
        async_config=AsyncLoggerConfig::new(
          max_pending=2,
          overflow=AsyncOverflowPolicy::Blocking,
          flush=AsyncFlushPolicy::Never,
        ),
      ),
    )
    .to_async_logger()
    .with_patch(fn(rec) {
      second_target.val = rec.target
      rec
    })
    .to_library_async_logger()

  @async.with_task_group(group => {
    group.spawn_bg(() => second.run())
    second.error("default")
    second.shutdown()
  })

  inspect(second_target.val, content="async.lib.builder.default")
}

///|
async test "library async builder severity helpers use stored target without override" {
  let written_targets : Ref[Array[String]] = Ref([])

  let logger = build_library_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.LoggerConfig::new(
          min_level=@bitlogger.Level::Trace,
          target="async.lib.builder.helpers",
          sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
        ),
        async_config=AsyncLoggerConfig::new(
          max_pending=4,
          overflow=AsyncOverflowPolicy::Blocking,
          flush=AsyncFlushPolicy::Never,
        ),
      ),
    )
    .to_async_logger()
    .with_patch(fn(rec) {
      written_targets.val.push(rec.target)
      rec
    })
    .to_library_async_logger()

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("first")
    logger.warn("second")
    logger.error("third")
    logger.shutdown()
  })

  inspect(written_targets.val.length(), content="3")
  inspect(written_targets.val[0], content="async.lib.builder.helpers")
  inspect(written_targets.val[1], content="async.lib.builder.helpers")
  inspect(written_targets.val[2], content="async.lib.builder.helpers")
}

///|
async test "library async builder shutdown clear abandons pending records through facade" {
  let logger = build_library_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Info,
        target="async.lib.builder.clear",
        sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::Blocking,
      ),
    ),
  )
  let full = logger.to_async_logger()

  logger.info("one")
  inspect(full.pending_count(), content="1")
  inspect(full.dropped_count(), content="0")
  logger.shutdown(clear=true)
  inspect(full.is_closed(), content="true")
  inspect(full.is_running(), content="false")
  inspect(full.pending_count(), content="0")
  inspect(full.dropped_count(), content="1")
}

///|
async test "parsed library async logger unwrap keeps async helper surface" {
  let logger = parse_and_build_library_async_logger(
    "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.lib.config.helpers\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropOldest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Shutdown\"}}",
  )
  let full = logger.to_async_logger()

  let state = full.state()
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.config.helpers")
  inspect(state.pending_count, content="0")
  inspect(state.dropped_count, content="0")
  inspect(state.is_closed, content="false")
  inspect(state.is_running, content="false")
  inspect(state.has_failed, content="false")
  inspect(
    match state.flush_policy {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  inspect(full.pending_count(), content="2")
  inspect(full.dropped_count(), content="1")
  inspect(full.is_closed(), content="false")
  inspect(full.is_running(), content="false")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(full.is_closed(), content="true")
  inspect(full.is_running(), content="false")
  inspect(full.pending_count(), content="0")
  inspect(full.dropped_count(), content="1")
  inspect(full.has_failed(), content="false")
  inspect(full.last_error(), content="")
}

///|
async test "parsed library async logger shutdown clear abandons pending records through facade" {
  let logger = parse_and_build_library_async_logger(
    "{\"logger\":{\"min_level\":\"info\",\"target\":\"async.lib.json.clear\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"Blocking\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
  )
  let full = logger.to_async_logger()

  logger.info("one")
  inspect(full.pending_count(), content="1")
  inspect(full.dropped_count(), content="0")
  logger.shutdown(clear=true)
  inspect(full.is_closed(), content="true")
  inspect(full.is_running(), content="false")
  inspect(full.pending_count(), content="0")
  inspect(full.dropped_count(), content="1")
}

///|
async test "parsed library async logger log supports per-call target override through facade" {
  let written_target : Ref[String] = Ref("")

  let logger = parse_and_build_library_async_logger(
      "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.lib.json.default\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"Blocking\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
    )
    .to_async_logger()
    .with_patch(fn(rec) {
      written_target.val = rec.target
      rec
    })
    .to_library_async_logger()

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.log(
      @bitlogger.Level::Error,
      "override",
      target="async.lib.json.override",
    )
    logger.shutdown()
  })

  inspect(written_target.val, content="async.lib.json.override")

  let second_target : Ref[String] = Ref("")

  let second = parse_and_build_library_async_logger(
      "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.lib.json.default\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"Blocking\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
    )
    .to_async_logger()
    .with_patch(fn(rec) {
      second_target.val = rec.target
      rec
    })
    .to_library_async_logger()

  @async.with_task_group(group => {
    group.spawn_bg(() => second.run())
    second.error("default")
    second.shutdown()
  })

  inspect(second_target.val, content="async.lib.json.default")
}

///|
async test "parsed library async severity helpers use stored target without override" {
  let written_targets : Ref[Array[String]] = Ref([])

  let logger = parse_and_build_library_async_logger(
      "{\"logger\":{\"min_level\":\"trace\",\"target\":\"async.lib.json.helpers.target\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":4,\"overflow\":\"Blocking\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
    )
    .to_async_logger()
    .with_patch(fn(rec) {
      written_targets.val.push(rec.target)
      rec
    })
    .to_library_async_logger()

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("first")
    logger.warn("second")
    logger.error("third")
    logger.shutdown()
  })

  inspect(written_targets.val.length(), content="3")
  inspect(written_targets.val[0], content="async.lib.json.helpers.target")
  inspect(written_targets.val[1], content="async.lib.json.helpers.target")
  inspect(written_targets.val[2], content="async.lib.json.helpers.target")
}

///|
async test "library async parse-build unwrap matches parsed direct async builder behavior" {
  let raw = "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.lib.json.same-build\",\"timestamp\":true,\"queue\":{\"max_pending\":3,\"overflow\":\"DropNewest\"},\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropOldest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Shutdown\"}}"
  let logger = parse_and_build_library_async_logger(raw)
  let full = logger.to_async_logger()
  let direct = build_async_logger(parse_async_logger_build_config_text(raw))
  let full_state = full.state()
  let direct_state = direct.state()

  inspect(full.target, content=direct.target)
  inspect(full.timestamp == direct.timestamp, content="true")
  inspect(
    logger.is_enabled(@bitlogger.Level::Error) ==
    direct.is_enabled(@bitlogger.Level::Error),
    content="true",
  )
  inspect(
    logger.is_enabled(@bitlogger.Level::Info) ==
    direct.is_enabled(@bitlogger.Level::Info),
    content="true",
  )
  inspect(
    stringify_async_logger_state(full_state) ==
    stringify_async_logger_state(direct_state),
    content="true",
  )
  let full_sink_kind = match full.sink {
    @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
    @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
    @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
    @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
    @bitlogger.RuntimeSink::Console(_) => "Console"
    @bitlogger.RuntimeSink::JsonConsole(_) => "JsonConsole"
    @bitlogger.RuntimeSink::TextConsole(_) => "TextConsole"
    @bitlogger.RuntimeSink::File(_) => "File"
  }
  let direct_sink_kind = match direct.sink {
    @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
    @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
    @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
    @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
    @bitlogger.RuntimeSink::Console(_) => "Console"
    @bitlogger.RuntimeSink::JsonConsole(_) => "JsonConsole"
    @bitlogger.RuntimeSink::TextConsole(_) => "TextConsole"
    @bitlogger.RuntimeSink::File(_) => "File"
  }
  inspect(full_sink_kind == direct_sink_kind, content="true")

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  direct.info("skip")
  direct.error("one")
  direct.error("two")
  direct.error("three")

  inspect(full.pending_count() == direct.pending_count(), content="true")
  inspect(full.dropped_count() == direct.dropped_count(), content="true")
  inspect(full.is_closed() == direct.is_closed(), content="true")
  inspect(full.is_running() == direct.is_running(), content="true")
  inspect(
    full.sink.pending_count() == direct.sink.pending_count(),
    content="true",
  )
  inspect(
    full.sink.dropped_count() == direct.sink.dropped_count(),
    content="true",
  )

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    group.spawn_bg(() => direct.run())
    logger.shutdown()
    direct.shutdown()
  })

  inspect(full.is_closed() == direct.is_closed(), content="true")
  inspect(full.is_running() == direct.is_running(), content="true")
  inspect(full.pending_count() == direct.pending_count(), content="true")
  inspect(full.dropped_count() == direct.dropped_count(), content="true")
  inspect(full.has_failed() == direct.has_failed(), content="true")
  inspect(full.last_error() == direct.last_error(), content="true")
}

///|
async test "library async parse-build unwrap preserves file-backed runtime helpers" {
  let raw = "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.lib.json.file.same-build\",\"queue\":{\"max_pending\":3,\"overflow\":\"DropOldest\"},\"sink\":{\"kind\":\"file\",\"path\":\"async-lib-json-file-same-build.log\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropOldest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Shutdown\"}}"
  let logger = parse_and_build_library_async_logger(raw)
  let full = logger.to_async_logger()
  let direct = build_async_logger(parse_async_logger_build_config_text(raw))

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  direct.info("skip")
  direct.error("one")
  direct.error("two")
  direct.error("three")

  inspect(full.pending_count() == direct.pending_count(), content="true")
  inspect(full.dropped_count() == direct.dropped_count(), content="true")
  inspect(
    full.sink.pending_count() == direct.sink.pending_count(),
    content="true",
  )
  inspect(
    full.sink.dropped_count() == direct.sink.dropped_count(),
    content="true",
  )
  inspect(
    full.sink.file_available() == direct.sink.file_available(),
    content="true",
  )
  inspect(
    full.sink.file_append_mode() == direct.sink.file_append_mode(),
    content="true",
  )
  inspect(
    full.sink.file_auto_flush() == direct.sink.file_auto_flush(),
    content="true",
  )

  let full_state = full.sink.file_state()
  let direct_state = direct.sink.file_state()
  inspect(full_state.path == direct_state.path, content="true")
  inspect(full_state.available == direct_state.available, content="true")
  inspect(full_state.append == direct_state.append, content="true")
  inspect(full_state.auto_flush == direct_state.auto_flush, content="true")
  inspect(
    full_state.open_failures == direct_state.open_failures,
    content="true",
  )
  inspect(
    full_state.write_failures == direct_state.write_failures,
    content="true",
  )
  inspect(
    full_state.flush_failures == direct_state.flush_failures,
    content="true",
  )
  inspect(
    full_state.rotation_failures == direct_state.rotation_failures,
    content="true",
  )

  match (full.sink.file_runtime_state(), direct.sink.file_runtime_state()) {
    (Some(snapshot), Some(other)) => {
      inspect(snapshot.file.path == other.file.path, content="true")
      inspect(snapshot.file.available == other.file.available, content="true")
      inspect(snapshot.queued == other.queued, content="true")
      inspect(snapshot.pending_count == other.pending_count, content="true")
      inspect(snapshot.dropped_count == other.dropped_count, content="true")
    }
    _ => inspect(false, content="true")
  }

  inspect(
    full.sink.file_set_append_mode(false) ==
    direct.sink.file_set_append_mode(false),
    content="true",
  )
  inspect(
    full.sink.file_append_mode() == direct.sink.file_append_mode(),
    content="true",
  )
  inspect(
    full.sink.file_set_auto_flush(false) ==
    direct.sink.file_set_auto_flush(false),
    content="true",
  )
  inspect(
    full.sink.file_auto_flush() == direct.sink.file_auto_flush(),
    content="true",
  )
  inspect(
    full.sink.file_set_rotation(
      Some(@bitlogger.file_rotation(36, max_backups=2)),
    ) ==
    direct.sink.file_set_rotation(
      Some(@bitlogger.file_rotation(36, max_backups=2)),
    ),
    content="true",
  )
  inspect(
    full.sink.file_rotation_enabled() == direct.sink.file_rotation_enabled(),
    content="true",
  )
  inspect(
    full.sink.file_reopen_append() == direct.sink.file_reopen_append(),
    content="true",
  )
  inspect(
    full.sink.file_append_mode() == direct.sink.file_append_mode(),
    content="true",
  )
  inspect(
    full.sink.file_clear_rotation() == direct.sink.file_clear_rotation(),
    content="true",
  )
  inspect(
    full.sink.file_reset_policy() == direct.sink.file_reset_policy(),
    content="true",
  )
  inspect(
    full.sink.file_policy_matches_default() ==
    direct.sink.file_policy_matches_default(),
    content="true",
  )
  inspect(
    full.sink.file_reset_failure_counters() ==
    direct.sink.file_reset_failure_counters(),
    content="true",
  )
  inspect(full.sink.file_flush() == direct.sink.file_flush(), content="true")
  inspect(full.pending_count() == direct.pending_count(), content="true")
  inspect(full.sink.file_close() == direct.sink.file_close(), content="true")
}

///|
test "library async logger parse-and-build preserves parsed sync queue layer" {
  let logger = parse_and_build_library_async_logger(
    "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.lib.config.queued\",\"queue\":{\"max_pending\":3,\"overflow\":\"DropNewest\"},\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropNewest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
  )
  let full = logger.to_async_logger()

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.config.queued")
  inspect(
    match full.sink {
      @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
      @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
      @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
      @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
      _ => "Other"
    },
    content="QueuedConsole",
  )
}

///|
test "library async text logger can be built from typed config" {
  let logger = build_library_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.text_console(
        min_level=@bitlogger.Level::Warn,
        target="async.lib.text",
        text_formatter=@bitlogger.TextFormatterConfig::new(
          show_timestamp=false,
          separator=" | ",
        ),
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  )
  let full = logger.to_async_logger()
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.text")
}

///|
async test "library async text builder unwrap matches direct text builder behavior" {
  let config = AsyncLoggerBuildConfig::new(
    logger=@bitlogger.LoggerConfig::new(
      min_level=@bitlogger.Level::Warn,
      target="async.lib.text.same-build",
      timestamp=true,
      queue=Some(
        @bitlogger.QueueConfig::new(
          3,
          overflow=@bitlogger.QueueOverflowPolicy::DropNewest,
        ),
      ),
      sink=@bitlogger.SinkConfig::new(
        kind=@bitlogger.SinkKind::TextConsole,
        text_formatter=@bitlogger.TextFormatterConfig::new(
          show_timestamp=false,
          separator=" | ",
          template="TEXT:{target}:{message}",
        ),
      ),
    ),
    async_config=AsyncLoggerConfig::new(
      max_pending=2,
      overflow=AsyncOverflowPolicy::DropOldest,
      flush=AsyncFlushPolicy::Shutdown,
    ),
  )
  let logger = build_library_async_text_logger(config)
  let full = logger.to_async_logger()
  let direct = build_async_text_logger(config)
  let full_state = full.state()
  let direct_state = direct.state()

  inspect(full.target, content=direct.target)
  inspect(full.timestamp == direct.timestamp, content="true")
  inspect(
    logger.is_enabled(@bitlogger.Level::Error) ==
    direct.is_enabled(@bitlogger.Level::Error),
    content="true",
  )
  inspect(
    logger.is_enabled(@bitlogger.Level::Info) ==
    direct.is_enabled(@bitlogger.Level::Info),
    content="true",
  )
  inspect(
    stringify_async_logger_state(full_state) ==
    stringify_async_logger_state(direct_state),
    content="true",
  )
  let record = @bitlogger.Record::new(
    @bitlogger.Level::Error,
    "boom",
    target="async.lib.text.same-build",
  )
  inspect(
    (full.sink.formatter)(record) == (direct.sink.formatter)(record),
    content="true",
  )

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  direct.info("skip")
  direct.error("one")
  direct.error("two")
  direct.error("three")

  inspect(full.pending_count() == direct.pending_count(), content="true")
  inspect(full.dropped_count() == direct.dropped_count(), content="true")
  inspect(full.is_closed() == direct.is_closed(), content="true")
  inspect(full.is_running() == direct.is_running(), content="true")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    group.spawn_bg(() => direct.run())
    logger.shutdown()
    direct.shutdown()
  })

  inspect(full.is_closed() == direct.is_closed(), content="true")
  inspect(full.is_running() == direct.is_running(), content="true")
  inspect(full.pending_count() == direct.pending_count(), content="true")
  inspect(full.dropped_count() == direct.dropped_count(), content="true")
  inspect(full.has_failed() == direct.has_failed(), content="true")
  inspect(full.last_error() == direct.last_error(), content="true")
}

///|
async test "library async text builder log supports per-call target override through facade" {
  let written_target : Ref[String] = Ref("")

  let logger = build_library_async_text_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.text_console(
          min_level=@bitlogger.Level::Warn,
          target="async.lib.text.builder.default",
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
        async_config=AsyncLoggerConfig::new(
          max_pending=2,
          overflow=AsyncOverflowPolicy::Blocking,
          flush=AsyncFlushPolicy::Never,
        ),
      ),
    )
    .to_async_logger()
    .with_patch(fn(rec) {
      written_target.val = rec.target
      rec
    })
    .to_library_async_logger()

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.log(
      @bitlogger.Level::Error,
      "override",
      target="async.lib.text.builder.override",
    )
    logger.shutdown()
  })

  inspect(written_target.val, content="async.lib.text.builder.override")

  let second_target : Ref[String] = Ref("")

  let second = build_library_async_text_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.text_console(
          min_level=@bitlogger.Level::Warn,
          target="async.lib.text.builder.default",
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
        async_config=AsyncLoggerConfig::new(
          max_pending=2,
          overflow=AsyncOverflowPolicy::Blocking,
          flush=AsyncFlushPolicy::Never,
        ),
      ),
    )
    .to_async_logger()
    .with_patch(fn(rec) {
      second_target.val = rec.target
      rec
    })
    .to_library_async_logger()

  @async.with_task_group(group => {
    group.spawn_bg(() => second.run())
    second.error("default")
    second.shutdown()
  })

  inspect(second_target.val, content="async.lib.text.builder.default")
}

///|
async test "library async text builder severity helpers use stored target without override" {
  let written_targets : Ref[Array[String]] = Ref([])

  let logger = build_library_async_text_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.text_console(
          min_level=@bitlogger.Level::Info,
          target="async.lib.text.builder.helpers",
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
        async_config=AsyncLoggerConfig::new(
          max_pending=4,
          overflow=AsyncOverflowPolicy::Blocking,
          flush=AsyncFlushPolicy::Never,
        ),
      ),
    )
    .to_async_logger()
    .with_patch(fn(rec) {
      written_targets.val.push(rec.target)
      rec
    })
    .to_library_async_logger()

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("first")
    logger.warn("second")
    logger.error("third")
    logger.shutdown()
  })

  inspect(written_targets.val.length(), content="3")
  inspect(written_targets.val[0], content="async.lib.text.builder.helpers")
  inspect(written_targets.val[1], content="async.lib.text.builder.helpers")
  inspect(written_targets.val[2], content="async.lib.text.builder.helpers")
}

///|
async test "library async text logger unwrap keeps async helper surface" {
  let logger = build_library_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.text_console(
        min_level=@bitlogger.Level::Warn,
        target="async.lib.text.helpers",
        text_formatter=@bitlogger.TextFormatterConfig::new(
          show_timestamp=false,
          separator=" | ",
        ),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::DropOldest,
        flush=AsyncFlushPolicy::Shutdown,
      ),
    ),
  )
  let full = logger.to_async_logger()

  let state = full.state()
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.text.helpers")
  inspect(state.pending_count, content="0")
  inspect(state.dropped_count, content="0")
  inspect(state.is_closed, content="false")
  inspect(state.is_running, content="false")
  inspect(state.has_failed, content="false")
  inspect(
    match state.flush_policy {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  inspect(full.pending_count(), content="2")
  inspect(full.dropped_count(), content="1")
  inspect(full.is_closed(), content="false")
  inspect(full.is_running(), content="false")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(full.is_closed(), content="true")
  inspect(full.is_running(), content="false")
  inspect(full.pending_count(), content="0")
  inspect(full.dropped_count(), content="1")
  inspect(full.has_failed(), content="false")
  inspect(full.last_error(), content="")
}

///|
async test "library async text logger shutdown clear abandons pending records through facade" {
  let logger = build_library_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.text_console(
        min_level=@bitlogger.Level::Info,
        target="async.lib.text.clear",
        text_formatter=@bitlogger.TextFormatterConfig::new(
          show_timestamp=false,
          separator=" | ",
        ),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::Blocking,
      ),
    ),
  )
  let full = logger.to_async_logger()

  logger.info("one")
  inspect(full.pending_count(), content="1")
  inspect(full.dropped_count(), content="0")
  logger.shutdown(clear=true)
  inspect(full.is_closed(), content="true")
  inspect(full.is_running(), content="false")
  inspect(full.pending_count(), content="0")
  inspect(full.dropped_count(), content="1")
}

///|
test "library async text logger builder ignores sync queue layer" {
  let logger = build_library_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.lib.text.queued",
        queue=Some(
          @bitlogger.QueueConfig::new(
            3,
            overflow=@bitlogger.QueueOverflowPolicy::DropNewest,
          ),
        ),
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::TextConsole,
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  )
  let full = logger.to_async_logger()

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.text.queued")
  inspect(full.pending_count(), content="0")
  inspect(full.dropped_count(), content="0")
}

///|
test "library async text logger ignores sink kind and still uses text formatter" {
  let logger = build_library_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.lib.text.kind",
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::File,
          path="ignored.log",
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
            template="TEXT:{target}:{message}",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  )
  let full = logger.to_async_logger()

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.lib.text.kind")
  let rendered = (full.sink.formatter)(
    @bitlogger.Record::new(
      @bitlogger.Level::Error,
      "boom",
      target="async.lib.text.kind",
    ),
  )
  inspect(rendered, content="TEXT:async.lib.text.kind:boom")
}

///|
async test "async logger can project to library async logger" {
  let logger = build_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        target="async.projected",
        min_level=@bitlogger.Level::Warn,
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  ).to_library_async_logger()
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.to_async_logger().target, content="async.projected")
}

///|
async test "build async logger keeps direct helper surface and runtime sink path" {
  let logger = build_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.direct.helpers",
        queue=Some(
          @bitlogger.QueueConfig::new(
            3,
            overflow=@bitlogger.QueueOverflowPolicy::DropNewest,
          ),
        ),
        sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::DropOldest,
        flush=AsyncFlushPolicy::Shutdown,
      ),
    ),
  )

  let state = logger.state()
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.direct.helpers")
  inspect(state.pending_count, content="0")
  inspect(state.dropped_count, content="0")
  inspect(state.is_closed, content="false")
  inspect(state.is_running, content="false")
  inspect(state.has_failed, content="false")
  inspect(
    match state.flush_policy {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )
  inspect(
    match logger.sink {
      @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
      @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
      @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
      @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
      _ => "Other"
    },
    content="QueuedConsole",
  )

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  inspect(logger.pending_count(), content="2")
  inspect(logger.dropped_count(), content="1")
  inspect(logger.is_closed(), content="false")
  inspect(logger.is_running(), content="false")
  inspect(logger.sink.pending_count(), content="0")
  inspect(logger.sink.dropped_count(), content="0")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
  inspect(logger.has_failed(), content="false")
  inspect(logger.last_error(), content="")
}

///|
async test "build async logger log supports per-call target override" {
  let written_target : Ref[String] = Ref("")

  let logger = build_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.builder.default",
        sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::Blocking,
        flush=AsyncFlushPolicy::Never,
      ),
    ),
  ).with_patch(fn(rec) {
    written_target.val = rec.target
    rec
  })

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.log(
      @bitlogger.Level::Error,
      "override",
      target="async.builder.override",
    )
    logger.shutdown()
  })

  inspect(written_target.val, content="async.builder.override")

  let second_target : Ref[String] = Ref("")

  let second = build_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.builder.default",
        sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::Blocking,
        flush=AsyncFlushPolicy::Never,
      ),
    ),
  ).with_patch(fn(rec) {
    second_target.val = rec.target
    rec
  })

  @async.with_task_group(group => {
    group.spawn_bg(() => second.run())
    second.error("default")
    second.shutdown()
  })

  inspect(second_target.val, content="async.builder.default")
}

///|
async test "build async logger severity helpers use stored target without override" {
  let written_targets : Ref[Array[String]] = Ref([])

  let logger = build_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Trace,
        target="async.builder.helpers",
        sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=4,
        overflow=AsyncOverflowPolicy::Blocking,
        flush=AsyncFlushPolicy::Never,
      ),
    ),
  ).with_patch(fn(rec) {
    written_targets.val.push(rec.target)
    rec
  })

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.debug("first")
    logger.info("second")
    logger.error("third")
    logger.shutdown()
  })

  inspect(written_targets.val.length(), content="3")
  inspect(written_targets.val[0], content="async.builder.helpers")
  inspect(written_targets.val[1], content="async.builder.helpers")
  inspect(written_targets.val[2], content="async.builder.helpers")
}

///|
async test "async logger projection preserves async queue and failure state" {
  let logger = async_logger(
    @bitlogger.callback_sink(fn(_) {  }),
    config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::Blocking,
      flush=AsyncFlushPolicy::Batch,
    ),
    min_level=@bitlogger.Level::Info,
    target="async.projected.state",
    flush=fn(_) -> Int raise {
      raise TestFlushError("projected facade flush exploded")
    },
  ).to_library_async_logger()
  let full = logger.to_async_logger()

  logger.info("one")
  logger.info("two")
  inspect(full.target, content="async.projected.state")
  inspect(full.pending_count(), content="2")
  inspect(full.dropped_count(), content="0")
  inspect(full.has_failed(), content="false")
  inspect(full.last_error(), content="")

  @async.with_task_group(group => {
    group.spawn_bg(allow_failure=true, () => logger.run())
    full.wait_idle()
    inspect(full.has_failed(), content="true")
    inspect(full.last_error().contains("TestFlushError"), content="true")
    inspect(full.is_running(), content="false")
    inspect(
      full.pending_count(),
      content=if async_runtime_supports_background_worker() { "1" } else { "1" },
    )
    inspect(
      full.dropped_count(),
      content=if async_runtime_supports_background_worker() { "0" } else { "0" },
    )
    logger.shutdown()
  })

  inspect(full.is_closed(), content="true")
  inspect(full.has_failed(), content="true")
  inspect(full.last_error().contains("TestFlushError"), content="true")
}

///|
async test "async logger projection preserves file-backed runtime helpers through unwrap" {
  let configured = build_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.projected.file",
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::File,
          path="async-projected-file.log",
        ),
        queue=Some(
          @bitlogger.QueueConfig::new(
            2,
            overflow=@bitlogger.QueueOverflowPolicy::DropOldest,
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::DropOldest,
        flush=AsyncFlushPolicy::Shutdown,
      ),
    ),
  )
  let projected = configured.to_library_async_logger()
  let full = projected.to_async_logger()

  inspect(projected.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(projected.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(full.target, content="async.projected.file")

  full.error("one")
  full.error("two")
  full.error("three")
  inspect(full.pending_count() == configured.pending_count(), content="true")
  inspect(full.dropped_count() == configured.dropped_count(), content="true")
  inspect(
    full.sink.pending_count() == configured.sink.pending_count(),
    content="true",
  )
  inspect(
    full.sink.dropped_count() == configured.sink.dropped_count(),
    content="true",
  )
  inspect(
    full.sink.file_available() == configured.sink.file_available(),
    content="true",
  )
  inspect(
    full.sink.file_append_mode() == configured.sink.file_append_mode(),
    content="true",
  )
  inspect(
    full.sink.file_auto_flush() == configured.sink.file_auto_flush(),
    content="true",
  )

  let full_state = full.sink.file_state()
  let configured_state = configured.sink.file_state()
  inspect(full_state.path == configured_state.path, content="true")
  inspect(full_state.available == configured_state.available, content="true")
  inspect(full_state.append == configured_state.append, content="true")
  inspect(full_state.auto_flush == configured_state.auto_flush, content="true")
  inspect(
    full_state.open_failures == configured_state.open_failures,
    content="true",
  )
  inspect(
    full_state.write_failures == configured_state.write_failures,
    content="true",
  )
  inspect(
    full_state.flush_failures == configured_state.flush_failures,
    content="true",
  )
  inspect(
    full_state.rotation_failures == configured_state.rotation_failures,
    content="true",
  )

  match (full.sink.file_runtime_state(), configured.sink.file_runtime_state()) {
    (Some(snapshot), Some(other)) => {
      inspect(snapshot.file.path == other.file.path, content="true")
      inspect(snapshot.file.available == other.file.available, content="true")
      inspect(snapshot.queued == other.queued, content="true")
      inspect(snapshot.pending_count == other.pending_count, content="true")
      inspect(snapshot.dropped_count == other.dropped_count, content="true")
    }
    _ => inspect(false, content="true")
  }

  inspect(full.sink.file_set_append_mode(false), content="true")
  inspect(configured.sink.file_append_mode(), content="false")
  inspect(
    full.sink.file_append_mode() == configured.sink.file_append_mode(),
    content="true",
  )

  inspect(full.sink.file_set_auto_flush(false), content="true")
  inspect(configured.sink.file_auto_flush(), content="false")
  inspect(
    full.sink.file_auto_flush() == configured.sink.file_auto_flush(),
    content="true",
  )

  inspect(
    full.sink.file_set_rotation(
      Some(@bitlogger.file_rotation(36, max_backups=2)),
    ),
    content="true",
  )
  inspect(configured.sink.file_rotation_enabled(), content="true")
  inspect(
    full.sink.file_rotation_enabled() == configured.sink.file_rotation_enabled(),
    content="true",
  )

  let reopen_append_ok = full.sink.file_reopen_append()
  inspect(
    reopen_append_ok == configured.sink.file_reopen_append(),
    content="true",
  )
  inspect(
    full.sink.file_append_mode() == configured.sink.file_append_mode(),
    content="true",
  )

  inspect(full.sink.file_clear_rotation(), content="true")
  inspect(configured.sink.file_rotation_enabled(), content="false")
  inspect(
    full.sink.file_rotation_enabled() == configured.sink.file_rotation_enabled(),
    content="true",
  )

  inspect(full.sink.file_reset_policy(), content="true")
  inspect(
    full.sink.file_policy_matches_default() ==
    configured.sink.file_policy_matches_default(),
    content="true",
  )

  inspect(full.sink.file_reset_failure_counters(), content="true")
  let reset_full_state = full.sink.file_state()
  let reset_configured_state = configured.sink.file_state()
  inspect(
    reset_full_state.open_failures == reset_configured_state.open_failures,
    content="true",
  )
  inspect(
    reset_full_state.write_failures == reset_configured_state.write_failures,
    content="true",
  )
  inspect(
    reset_full_state.flush_failures == reset_configured_state.flush_failures,
    content="true",
  )
  inspect(
    reset_full_state.rotation_failures ==
    reset_configured_state.rotation_failures,
    content="true",
  )

  inspect(
    full.sink.file_flush(),
    content=if configured.sink.file_available() { "true" } else { "false" },
  )
  inspect(full.pending_count() == configured.pending_count(), content="true")

  let close_expected = configured.sink.file_available()
  inspect(
    full.sink.file_close(),
    content=if close_expected { "true" } else { "false" },
  )
  inspect(
    full.sink.file_available() == configured.sink.file_available(),
    content="true",
  )
}

///|
test "application async logger aliases runtime async entry" {
  let logger = build_application_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        target="async.app",
        min_level=@bitlogger.Level::Warn,
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  )
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.app")
}

///|
async test "application async logger builder matches direct async builder behavior" {
  let config = AsyncLoggerBuildConfig::new(
    logger=@bitlogger.LoggerConfig::new(
      min_level=@bitlogger.Level::Warn,
      target="async.app.same-build",
      timestamp=true,
      queue=Some(
        @bitlogger.QueueConfig::new(
          3,
          overflow=@bitlogger.QueueOverflowPolicy::DropNewest,
        ),
      ),
      sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
    ),
    async_config=AsyncLoggerConfig::new(
      max_pending=2,
      overflow=AsyncOverflowPolicy::DropOldest,
      flush=AsyncFlushPolicy::Shutdown,
    ),
  )
  let application = build_application_async_logger(config)
  let direct = build_async_logger(config)
  let application_state = application.state()
  let direct_state = direct.state()

  inspect(application.target, content=direct.target)
  inspect(application.timestamp == direct.timestamp, content="true")
  inspect(
    application.is_enabled(@bitlogger.Level::Error) ==
    direct.is_enabled(@bitlogger.Level::Error),
    content="true",
  )
  inspect(
    application.is_enabled(@bitlogger.Level::Info) ==
    direct.is_enabled(@bitlogger.Level::Info),
    content="true",
  )
  inspect(
    stringify_async_logger_state(application_state) ==
    stringify_async_logger_state(direct_state),
    content="true",
  )
  let application_sink_kind = match application.sink {
    @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
    @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
    @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
    @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
    @bitlogger.RuntimeSink::Console(_) => "Console"
    @bitlogger.RuntimeSink::JsonConsole(_) => "JsonConsole"
    @bitlogger.RuntimeSink::TextConsole(_) => "TextConsole"
    @bitlogger.RuntimeSink::File(_) => "File"
  }
  let direct_sink_kind = match direct.sink {
    @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
    @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
    @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
    @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
    @bitlogger.RuntimeSink::Console(_) => "Console"
    @bitlogger.RuntimeSink::JsonConsole(_) => "JsonConsole"
    @bitlogger.RuntimeSink::TextConsole(_) => "TextConsole"
    @bitlogger.RuntimeSink::File(_) => "File"
  }
  inspect(application_sink_kind == direct_sink_kind, content="true")

  application.info("skip")
  application.error("one")
  application.error("two")
  application.error("three")
  direct.info("skip")
  direct.error("one")
  direct.error("two")
  direct.error("three")

  inspect(application.pending_count() == direct.pending_count(), content="true")
  inspect(application.dropped_count() == direct.dropped_count(), content="true")
  inspect(application.is_closed() == direct.is_closed(), content="true")
  inspect(application.is_running() == direct.is_running(), content="true")
  inspect(
    application.sink.pending_count() == direct.sink.pending_count(),
    content="true",
  )
  inspect(
    application.sink.dropped_count() == direct.sink.dropped_count(),
    content="true",
  )

  @async.with_task_group(group => {
    group.spawn_bg(() => application.run())
    group.spawn_bg(() => direct.run())
    application.shutdown()
    direct.shutdown()
  })

  inspect(application.is_closed() == direct.is_closed(), content="true")
  inspect(application.is_running() == direct.is_running(), content="true")
  inspect(application.pending_count() == direct.pending_count(), content="true")
  inspect(application.dropped_count() == direct.dropped_count(), content="true")
  inspect(application.has_failed() == direct.has_failed(), content="true")
  inspect(application.last_error() == direct.last_error(), content="true")
}

///|
async test "application async builder preserves file-backed runtime helpers" {
  let config = AsyncLoggerBuildConfig::new(
    logger=@bitlogger.LoggerConfig::new(
      min_level=@bitlogger.Level::Warn,
      target="async.app.file.same-build",
      sink=@bitlogger.SinkConfig::new(
        kind=@bitlogger.SinkKind::File,
        path="async-app-file-same-build.log",
      ),
      queue=Some(
        @bitlogger.QueueConfig::new(
          3,
          overflow=@bitlogger.QueueOverflowPolicy::DropOldest,
        ),
      ),
    ),
    async_config=AsyncLoggerConfig::new(
      max_pending=2,
      overflow=AsyncOverflowPolicy::DropOldest,
      flush=AsyncFlushPolicy::Shutdown,
    ),
  )
  let application = build_application_async_logger(config)
  let direct = build_async_logger(config)

  application.info("skip")
  application.error("one")
  application.error("two")
  application.error("three")
  direct.info("skip")
  direct.error("one")
  direct.error("two")
  direct.error("three")

  inspect(application.pending_count() == direct.pending_count(), content="true")
  inspect(application.dropped_count() == direct.dropped_count(), content="true")
  inspect(
    application.sink.pending_count() == direct.sink.pending_count(),
    content="true",
  )
  inspect(
    application.sink.dropped_count() == direct.sink.dropped_count(),
    content="true",
  )
  inspect(
    application.sink.file_available() == direct.sink.file_available(),
    content="true",
  )
  inspect(
    application.sink.file_append_mode() == direct.sink.file_append_mode(),
    content="true",
  )
  inspect(
    application.sink.file_auto_flush() == direct.sink.file_auto_flush(),
    content="true",
  )

  let application_state = application.sink.file_state()
  let direct_state = direct.sink.file_state()
  inspect(application_state.path == direct_state.path, content="true")
  inspect(application_state.available == direct_state.available, content="true")
  inspect(application_state.append == direct_state.append, content="true")
  inspect(
    application_state.auto_flush == direct_state.auto_flush,
    content="true",
  )
  inspect(
    application_state.open_failures == direct_state.open_failures,
    content="true",
  )
  inspect(
    application_state.write_failures == direct_state.write_failures,
    content="true",
  )
  inspect(
    application_state.flush_failures == direct_state.flush_failures,
    content="true",
  )
  inspect(
    application_state.rotation_failures == direct_state.rotation_failures,
    content="true",
  )

  match
    (application.sink.file_runtime_state(), direct.sink.file_runtime_state()) {
    (Some(snapshot), Some(other)) => {
      inspect(snapshot.file.path == other.file.path, content="true")
      inspect(snapshot.file.available == other.file.available, content="true")
      inspect(snapshot.queued == other.queued, content="true")
      inspect(snapshot.pending_count == other.pending_count, content="true")
      inspect(snapshot.dropped_count == other.dropped_count, content="true")
    }
    _ => inspect(false, content="true")
  }

  inspect(
    application.sink.file_set_append_mode(false) ==
    direct.sink.file_set_append_mode(false),
    content="true",
  )
  inspect(
    application.sink.file_append_mode() == direct.sink.file_append_mode(),
    content="true",
  )
  inspect(
    application.sink.file_set_auto_flush(false) ==
    direct.sink.file_set_auto_flush(false),
    content="true",
  )
  inspect(
    application.sink.file_auto_flush() == direct.sink.file_auto_flush(),
    content="true",
  )
  inspect(
    application.sink.file_set_rotation(
      Some(@bitlogger.file_rotation(36, max_backups=2)),
    ) ==
    direct.sink.file_set_rotation(
      Some(@bitlogger.file_rotation(36, max_backups=2)),
    ),
    content="true",
  )
  inspect(
    application.sink.file_rotation_enabled() ==
    direct.sink.file_rotation_enabled(),
    content="true",
  )
  inspect(
    application.sink.file_reopen_append() == direct.sink.file_reopen_append(),
    content="true",
  )
  inspect(
    application.sink.file_append_mode() == direct.sink.file_append_mode(),
    content="true",
  )
  inspect(
    application.sink.file_clear_rotation() == direct.sink.file_clear_rotation(),
    content="true",
  )
  inspect(
    application.sink.file_reset_policy() == direct.sink.file_reset_policy(),
    content="true",
  )
  inspect(
    application.sink.file_policy_matches_default() ==
    direct.sink.file_policy_matches_default(),
    content="true",
  )
  inspect(
    application.sink.file_reset_failure_counters() ==
    direct.sink.file_reset_failure_counters(),
    content="true",
  )
  inspect(
    application.sink.file_flush() == direct.sink.file_flush(),
    content="true",
  )
  inspect(application.pending_count() == direct.pending_count(), content="true")
  inspect(
    application.sink.file_close() == direct.sink.file_close(),
    content="true",
  )
}

///|
async test "application async logger keeps async helper surface" {
  let logger : ApplicationAsyncLogger = build_application_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.app.alias",
        sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::DropOldest,
        flush=AsyncFlushPolicy::Shutdown,
      ),
    ),
  )

  let state = logger.state()
  inspect(state.pending_count, content="0")
  inspect(state.dropped_count, content="0")
  inspect(state.is_closed, content="false")
  inspect(state.is_running, content="false")
  inspect(state.has_failed, content="false")
  inspect(
    match state.flush_policy {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  inspect(logger.pending_count(), content="2")
  inspect(logger.dropped_count(), content="1")
  inspect(logger.is_closed(), content="false")
  inspect(logger.is_running(), content="false")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
  inspect(logger.has_failed(), content="false")
  inspect(logger.last_error(), content="")
}

///|
async test "application async logger shutdown clear abandons pending records" {
  let logger : ApplicationAsyncLogger = build_application_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Info,
        target="async.app.clear",
        sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::Blocking,
      ),
    ),
  )

  logger.info("one")
  inspect(logger.pending_count(), content="1")
  inspect(logger.dropped_count(), content="0")
  logger.shutdown(clear=true)
  inspect(logger.is_closed(), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
}

///|
async test "application async logger keeps broader async composition surface" {
  let logger : ApplicationAsyncLogger = build_application_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.LoggerConfig::new(
          min_level=@bitlogger.Level::Warn,
          target="async.app.compose",
          sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
        ),
        async_config=AsyncLoggerConfig::new(
          max_pending=2,
          overflow=AsyncOverflowPolicy::DropNewest,
          flush=AsyncFlushPolicy::Shutdown,
        ),
      ),
    )
    .with_timestamp()
    .with_context_fields([@bitlogger.field("service", "bitlogger")])
    .child("worker")

  inspect(logger.target, content="async.app.compose.worker")
  inspect(logger.timestamp, content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")

  logger.error("one")
  logger.error("two")
  inspect(logger.pending_count(), content="2")
  inspect(logger.dropped_count(), content="0")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="0")
  inspect(logger.has_failed(), content="false")
  inspect(logger.last_error(), content="")
}

///|
async test "application async logger log supports per-call target override" {
  let written_target : Ref[String] = Ref("")
  let written_message : Ref[String] = Ref("")
  let written_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let logger : ApplicationAsyncLogger = build_application_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.LoggerConfig::new(
          min_level=@bitlogger.Level::Warn,
          target="async.app.default",
          sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
        ),
        async_config=AsyncLoggerConfig::new(max_pending=4),
      ),
    )
    .with_context_fields([@bitlogger.field("service", "bitlogger")])
    .with_patch(fn(rec) {
      written_target.val = rec.target
      written_message.val = rec.message
      written_fields.val = rec.fields
      rec
    })

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.log(
      @bitlogger.Level::Error,
      "override",
      fields=[@bitlogger.field("mode", "test")],
      target="async.app.override",
    )
    logger.shutdown()
  })

  inspect(written_target.val, content="async.app.override")
  inspect(written_message.val, content="override")
  inspect(written_fields.val.length(), content="2")
  inspect(written_fields.val[0].key, content="service")
  inspect(written_fields.val[0].value, content="bitlogger")
  inspect(written_fields.val[1].key, content="mode")
  inspect(written_fields.val[1].value, content="test")

  let second_target : Ref[String] = Ref("")
  let second_message : Ref[String] = Ref("")
  let second_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let second : ApplicationAsyncLogger = build_application_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.LoggerConfig::new(
          min_level=@bitlogger.Level::Warn,
          target="async.app.default",
          sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
        ),
        async_config=AsyncLoggerConfig::new(max_pending=4),
      ),
    )
    .with_context_fields([@bitlogger.field("service", "bitlogger")])
    .with_patch(fn(rec) {
      second_target.val = rec.target
      second_message.val = rec.message
      second_fields.val = rec.fields
      rec
    })

  @async.with_task_group(group => {
    group.spawn_bg(() => second.run())
    second.log(@bitlogger.Level::Error, "default")
    second.shutdown()
  })

  inspect(second_target.val, content="async.app.default")
  inspect(second_message.val, content="default")
  inspect(second_fields.val.length(), content="1")
  inspect(second_fields.val[0].key, content="service")
}

///|
async test "application async logger severity helpers use stored target without override" {
  let written_levels : Ref[Array[String]] = Ref([])
  let written_targets : Ref[Array[String]] = Ref([])
  let written_fields : Ref[Array[Array[@bitlogger.Field]]] = Ref([])
  let logger : ApplicationAsyncLogger = build_application_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.LoggerConfig::new(
          min_level=@bitlogger.Level::Info,
          target="async.app.helpers",
          sink=@bitlogger.SinkConfig::new(kind=@bitlogger.SinkKind::Console),
        ),
        async_config=AsyncLoggerConfig::new(max_pending=4),
      ),
    )
    .with_context_fields([@bitlogger.field("service", "bitlogger")])
    .with_patch(fn(rec) {
      written_levels.val.push(rec.level.label())
      written_targets.val.push(rec.target)
      written_fields.val.push(rec.fields)
      rec
    })

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("info", fields=[@bitlogger.field("mode", "info")])
    logger.warn("warn", fields=[@bitlogger.field("mode", "warn")])
    logger.error("error", fields=[@bitlogger.field("mode", "error")])
    logger.shutdown()
  })

  inspect(written_levels.val.length(), content="3")
  inspect(written_levels.val[0], content="INFO")
  inspect(written_levels.val[1], content="WARN")
  inspect(written_levels.val[2], content="ERROR")
  inspect(written_targets.val.length(), content="3")
  inspect(written_targets.val[0], content="async.app.helpers")
  inspect(written_targets.val[1], content="async.app.helpers")
  inspect(written_targets.val[2], content="async.app.helpers")
  inspect(written_fields.val[0].length(), content="2")
  inspect(written_fields.val[1].length(), content="2")
  inspect(written_fields.val[2].length(), content="2")
  inspect(written_fields.val[0][0].key, content="service")
  inspect(written_fields.val[0][1].value, content="info")
  inspect(written_fields.val[1][0].key, content="service")
  inspect(written_fields.val[1][1].value, content="warn")
  inspect(written_fields.val[2][0].key, content="service")
  inspect(written_fields.val[2][1].value, content="error")
}

///|
test "application async logger builder preserves sync queue-backed runtime sink" {
  let logger = build_application_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.app.queued",
        queue=Some(
          @bitlogger.QueueConfig::new(
            3,
            overflow=@bitlogger.QueueOverflowPolicy::DropNewest,
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  )

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.app.queued")
  inspect(logger.sink.pending_count(), content="0")
  inspect(logger.sink.dropped_count(), content="0")
  inspect(
    match logger.sink {
      @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
      @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
      @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
      @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
      _ => "Other"
    },
    content="QueuedConsole",
  )
}

///|
test "application text async logger uses text facade build path" {
  let logger = build_application_text_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.text_console(
        min_level=@bitlogger.Level::Warn,
        target="async.app.text",
        text_formatter=@bitlogger.TextFormatterConfig::new(
          show_timestamp=false,
          separator=" | ",
        ),
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  )
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.app.text")
}

///|
async test "application text builder matches direct text builder behavior" {
  let config = AsyncLoggerBuildConfig::new(
    logger=@bitlogger.LoggerConfig::new(
      min_level=@bitlogger.Level::Warn,
      target="async.app.text.same-build",
      timestamp=true,
      queue=Some(
        @bitlogger.QueueConfig::new(
          3,
          overflow=@bitlogger.QueueOverflowPolicy::DropNewest,
        ),
      ),
      sink=@bitlogger.SinkConfig::new(
        kind=@bitlogger.SinkKind::TextConsole,
        text_formatter=@bitlogger.TextFormatterConfig::new(
          show_timestamp=false,
          separator=" | ",
          template="TEXT:{target}:{message}",
        ),
      ),
    ),
    async_config=AsyncLoggerConfig::new(
      max_pending=2,
      overflow=AsyncOverflowPolicy::DropOldest,
      flush=AsyncFlushPolicy::Shutdown,
    ),
  )
  let logger = build_application_text_async_logger(config)
  let direct = build_async_text_logger(config)
  let logger_state = logger.state()
  let direct_state = direct.state()

  inspect(logger.target, content=direct.target)
  inspect(logger.timestamp == direct.timestamp, content="true")
  inspect(
    logger.is_enabled(@bitlogger.Level::Error) ==
    direct.is_enabled(@bitlogger.Level::Error),
    content="true",
  )
  inspect(
    logger.is_enabled(@bitlogger.Level::Info) ==
    direct.is_enabled(@bitlogger.Level::Info),
    content="true",
  )
  inspect(
    stringify_async_logger_state(logger_state) ==
    stringify_async_logger_state(direct_state),
    content="true",
  )
  let record = @bitlogger.Record::new(
    @bitlogger.Level::Error,
    "boom",
    target="async.app.text.same-build",
  )
  inspect(
    (logger.sink.formatter)(record) == (direct.sink.formatter)(record),
    content="true",
  )

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  direct.info("skip")
  direct.error("one")
  direct.error("two")
  direct.error("three")

  inspect(logger.pending_count() == direct.pending_count(), content="true")
  inspect(logger.dropped_count() == direct.dropped_count(), content="true")
  inspect(logger.is_closed() == direct.is_closed(), content="true")
  inspect(logger.is_running() == direct.is_running(), content="true")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    group.spawn_bg(() => direct.run())
    logger.shutdown()
    direct.shutdown()
  })

  inspect(logger.is_closed() == direct.is_closed(), content="true")
  inspect(logger.is_running() == direct.is_running(), content="true")
  inspect(logger.pending_count() == direct.pending_count(), content="true")
  inspect(logger.dropped_count() == direct.dropped_count(), content="true")
  inspect(logger.has_failed() == direct.has_failed(), content="true")
  inspect(logger.last_error() == direct.last_error(), content="true")
}

///|
async test "application text async logger keeps async helper surface" {
  let logger : ApplicationTextAsyncLogger = build_application_text_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.text_console(
        min_level=@bitlogger.Level::Warn,
        target="async.app.text.alias",
        text_formatter=@bitlogger.TextFormatterConfig::new(
          show_timestamp=false,
          separator=" | ",
        ),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::DropOldest,
        flush=AsyncFlushPolicy::Shutdown,
      ),
    ),
  )

  let state = logger.state()
  inspect(state.pending_count, content="0")
  inspect(state.dropped_count, content="0")
  inspect(state.is_closed, content="false")
  inspect(state.is_running, content="false")
  inspect(state.has_failed, content="false")
  inspect(
    match state.flush_policy {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  inspect(logger.pending_count(), content="2")
  inspect(logger.dropped_count(), content="1")
  inspect(logger.is_closed(), content="false")
  inspect(logger.is_running(), content="false")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
  inspect(logger.has_failed(), content="false")
  inspect(logger.last_error(), content="")
}

///|
async test "application text async logger shutdown clear abandons pending records" {
  let logger : ApplicationTextAsyncLogger = build_application_text_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.text_console(
        min_level=@bitlogger.Level::Info,
        target="async.app.text.clear",
        text_formatter=@bitlogger.TextFormatterConfig::new(
          show_timestamp=false,
          separator=" | ",
        ),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::Blocking,
      ),
    ),
  )

  logger.info("one")
  inspect(logger.pending_count(), content="1")
  inspect(logger.dropped_count(), content="0")
  logger.shutdown(clear=true)
  inspect(logger.is_closed(), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
}

///|
async test "application text async logger keeps broader async composition surface" {
  let logger : ApplicationTextAsyncLogger = build_application_text_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.text_console(
          min_level=@bitlogger.Level::Warn,
          target="async.app.text.compose",
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
        async_config=AsyncLoggerConfig::new(
          max_pending=2,
          overflow=AsyncOverflowPolicy::DropNewest,
          flush=AsyncFlushPolicy::Shutdown,
        ),
      ),
    )
    .with_timestamp()
    .with_context_fields([@bitlogger.field("service", "bitlogger")])
    .child("worker")

  inspect(logger.target, content="async.app.text.compose.worker")
  inspect(logger.timestamp, content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")

  logger.error("one")
  logger.error("two")
  inspect(logger.pending_count(), content="2")
  inspect(logger.dropped_count(), content="0")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="0")
  inspect(logger.has_failed(), content="false")
  inspect(logger.last_error(), content="")
}

///|
async test "application text async logger log supports per-call target override" {
  let written_target : Ref[String] = Ref("")
  let written_message : Ref[String] = Ref("")
  let written_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let logger : ApplicationTextAsyncLogger = build_application_text_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.text_console(
          min_level=@bitlogger.Level::Warn,
          target="async.app.text.default",
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
        async_config=AsyncLoggerConfig::new(max_pending=4),
      ),
    )
    .with_context_fields([@bitlogger.field("service", "bitlogger")])
    .with_patch(fn(rec) {
      written_target.val = rec.target
      written_message.val = rec.message
      written_fields.val = rec.fields
      rec
    })

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.log(
      @bitlogger.Level::Error,
      "override",
      fields=[@bitlogger.field("mode", "test")],
      target="async.app.text.override",
    )
    logger.shutdown()
  })

  inspect(written_target.val, content="async.app.text.override")
  inspect(written_message.val, content="override")
  inspect(written_fields.val.length(), content="2")
  inspect(written_fields.val[0].key, content="service")
  inspect(written_fields.val[0].value, content="bitlogger")
  inspect(written_fields.val[1].key, content="mode")
  inspect(written_fields.val[1].value, content="test")

  let second_target : Ref[String] = Ref("")
  let second_message : Ref[String] = Ref("")
  let second_fields : Ref[Array[@bitlogger.Field]] = Ref([])
  let second : ApplicationTextAsyncLogger = build_application_text_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.text_console(
          min_level=@bitlogger.Level::Warn,
          target="async.app.text.default",
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
        async_config=AsyncLoggerConfig::new(max_pending=4),
      ),
    )
    .with_context_fields([@bitlogger.field("service", "bitlogger")])
    .with_patch(fn(rec) {
      second_target.val = rec.target
      second_message.val = rec.message
      second_fields.val = rec.fields
      rec
    })

  @async.with_task_group(group => {
    group.spawn_bg(() => second.run())
    second.log(@bitlogger.Level::Error, "default")
    second.shutdown()
  })

  inspect(second_target.val, content="async.app.text.default")
  inspect(second_message.val, content="default")
  inspect(second_fields.val.length(), content="1")
  inspect(second_fields.val[0].key, content="service")
}

///|
async test "application text async logger severity helpers use stored target without override" {
  let written_levels : Ref[Array[String]] = Ref([])
  let written_targets : Ref[Array[String]] = Ref([])
  let written_fields : Ref[Array[Array[@bitlogger.Field]]] = Ref([])
  let logger : ApplicationTextAsyncLogger = build_application_text_async_logger(
      AsyncLoggerBuildConfig::new(
        logger=@bitlogger.text_console(
          min_level=@bitlogger.Level::Info,
          target="async.app.text.helpers",
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
        async_config=AsyncLoggerConfig::new(max_pending=4),
      ),
    )
    .with_context_fields([@bitlogger.field("service", "bitlogger")])
    .with_patch(fn(rec) {
      written_levels.val.push(rec.level.label())
      written_targets.val.push(rec.target)
      written_fields.val.push(rec.fields)
      rec
    })

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("info", fields=[@bitlogger.field("mode", "info")])
    logger.warn("warn", fields=[@bitlogger.field("mode", "warn")])
    logger.error("error", fields=[@bitlogger.field("mode", "error")])
    logger.shutdown()
  })

  inspect(written_levels.val.length(), content="3")
  inspect(written_levels.val[0], content="INFO")
  inspect(written_levels.val[1], content="WARN")
  inspect(written_levels.val[2], content="ERROR")
  inspect(written_targets.val.length(), content="3")
  inspect(written_targets.val[0], content="async.app.text.helpers")
  inspect(written_targets.val[1], content="async.app.text.helpers")
  inspect(written_targets.val[2], content="async.app.text.helpers")
  inspect(written_fields.val[0].length(), content="2")
  inspect(written_fields.val[1].length(), content="2")
  inspect(written_fields.val[2].length(), content="2")
  inspect(written_fields.val[0][0].key, content="service")
  inspect(written_fields.val[0][1].value, content="info")
  inspect(written_fields.val[1][0].key, content="service")
  inspect(written_fields.val[1][1].value, content="warn")
  inspect(written_fields.val[2][0].key, content="service")
  inspect(written_fields.val[2][1].value, content="error")
}

///|
test "application text async logger builder ignores sync queue layer" {
  let logger = build_application_text_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.app.text.queued",
        queue=Some(
          @bitlogger.QueueConfig::new(
            3,
            overflow=@bitlogger.QueueOverflowPolicy::DropNewest,
          ),
        ),
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::TextConsole,
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  )

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.app.text.queued")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="0")
}

///|
test "application text async logger ignores sink kind and still uses text formatter" {
  let logger : ApplicationTextAsyncLogger = build_application_text_async_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.app.text.kind.alias",
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::File,
          path="ignored.log",
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
            template="TEXT:{target}:{message}",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  )

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.app.text.kind.alias")
  let rendered = (logger.sink.formatter)(
    @bitlogger.Record::new(
      @bitlogger.Level::Error,
      "boom",
      target="async.app.text.kind.alias",
    ),
  )
  inspect(rendered, content="TEXT:async.app.text.kind.alias:boom")
}

///|
test "build async text logger keeps text-console config fields" {
  let logger = build_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.text.direct",
        timestamp=true,
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::TextConsole,
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=3,
        overflow=AsyncOverflowPolicy::DropOldest,
      ),
    ),
  )
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.text.direct")
  inspect(logger.timestamp, content="true")
  inspect(
    match logger.flush_policy() {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Never",
  )
  let rendered = (logger.sink.formatter)(
    @bitlogger.Record::new(
      @bitlogger.Level::Error,
      "boom",
      target="async.text.direct",
    ),
  )
  inspect(rendered, content="[ERROR] | [async.text.direct] | boom")
}

///|
test "build async text logger ignores sink kind and still uses text formatter" {
  let logger = build_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.text.kind",
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::File,
          path="ignored.log",
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
            template="TEXT:{target}:{message}",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  )

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.text.kind")
  let rendered = (logger.sink.formatter)(
    @bitlogger.Record::new(
      @bitlogger.Level::Error,
      "boom",
      target="async.text.kind",
    ),
  )
  inspect(rendered, content="TEXT:async.text.kind:boom")
}

///|
async test "build async text logger keeps direct helper surface" {
  let logger = build_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.text.helpers",
        timestamp=true,
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::TextConsole,
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::DropOldest,
        flush=AsyncFlushPolicy::Shutdown,
      ),
    ),
  )

  let state = logger.state()
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.text.helpers")
  inspect(logger.timestamp, content="true")
  inspect(state.pending_count, content="0")
  inspect(state.dropped_count, content="0")
  inspect(state.is_closed, content="false")
  inspect(state.is_running, content="false")
  inspect(state.has_failed, content="false")
  inspect(
    match state.flush_policy {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  inspect(logger.pending_count(), content="2")
  inspect(logger.dropped_count(), content="1")
  inspect(logger.is_closed(), content="false")
  inspect(logger.is_running(), content="false")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
  inspect(logger.has_failed(), content="false")
  inspect(logger.last_error(), content="")
}

///|
async test "build async text logger log supports per-call target override" {
  let written_target : Ref[String] = Ref("")

  let logger = build_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.text.builder.default",
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::TextConsole,
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::Blocking,
        flush=AsyncFlushPolicy::Never,
      ),
    ),
  ).with_patch(fn(rec) {
    written_target.val = rec.target
    rec
  })

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.log(
      @bitlogger.Level::Error,
      "override",
      target="async.text.builder.override",
    )
    logger.shutdown()
  })

  inspect(written_target.val, content="async.text.builder.override")

  let second_target : Ref[String] = Ref("")

  let second = build_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.text.builder.default",
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::TextConsole,
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=2,
        overflow=AsyncOverflowPolicy::Blocking,
        flush=AsyncFlushPolicy::Never,
      ),
    ),
  ).with_patch(fn(rec) {
    second_target.val = rec.target
    rec
  })

  @async.with_task_group(group => {
    group.spawn_bg(() => second.run())
    second.error("default")
    second.shutdown()
  })

  inspect(second_target.val, content="async.text.builder.default")
}

///|
async test "build async text logger severity helpers use stored target without override" {
  let written_targets : Ref[Array[String]] = Ref([])

  let logger = build_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Info,
        target="async.text.builder.helpers",
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::TextConsole,
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(
        max_pending=4,
        overflow=AsyncOverflowPolicy::Blocking,
        flush=AsyncFlushPolicy::Never,
      ),
    ),
  ).with_patch(fn(rec) {
    written_targets.val.push(rec.target)
    rec
  })

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.info("first")
    logger.warn("second")
    logger.error("third")
    logger.shutdown()
  })

  inspect(written_targets.val.length(), content="3")
  inspect(written_targets.val[0], content="async.text.builder.helpers")
  inspect(written_targets.val[1], content="async.text.builder.helpers")
  inspect(written_targets.val[2], content="async.text.builder.helpers")
}

///|
async test "build async text logger batch flush policy keeps default no-op flush callback" {
  let config = AsyncLoggerBuildConfig::new(
    logger=@bitlogger.LoggerConfig::new(
      min_level=@bitlogger.Level::Info,
      target="async.text.batch.flush",
      timestamp=true,
      sink=@bitlogger.SinkConfig::new(
        kind=@bitlogger.SinkKind::TextConsole,
        text_formatter=@bitlogger.TextFormatterConfig::new(
          show_timestamp=false,
          separator=" | ",
          template="TEXT:{target}:{message}",
        ),
      ),
    ),
    async_config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::Blocking,
      max_batch=2,
      flush=AsyncFlushPolicy::Batch,
    ),
  )
  let configured = build_async_text_logger(config)
  let manual = async_logger(
    @bitlogger.text_console_sink(
      config.logger.sink.text_formatter.to_formatter(),
    ),
    config=config.async_config,
    min_level=config.logger.min_level,
    target=config.logger.target,
    flush=fn(_) -> Int raise {
      raise TestFlushError("text batch flush exploded")
    },
  ).with_timestamp(enabled=config.logger.timestamp)

  @async.with_task_group(group => {
    group.spawn_bg(() => configured.run())
    group.spawn_bg(allow_failure=true, () => manual.run())

    configured.error("one")
    configured.error("two")
    manual.error("one")
    manual.error("two")

    configured.wait_idle()
    manual.wait_idle()

    inspect(
      match configured.flush_policy() {
        AsyncFlushPolicy::Never => "Never"
        AsyncFlushPolicy::Batch => "Batch"
        AsyncFlushPolicy::Shutdown => "Shutdown"
      },
      content="Batch",
    )
    inspect(
      match manual.flush_policy() {
        AsyncFlushPolicy::Never => "Never"
        AsyncFlushPolicy::Batch => "Batch"
        AsyncFlushPolicy::Shutdown => "Shutdown"
      },
      content="Batch",
    )
    inspect(configured.has_failed(), content="false")
    inspect(configured.last_error(), content="")
    inspect(configured.pending_count(), content="0")
    inspect(manual.has_failed(), content="true")
    inspect(manual.last_error().contains("TestFlushError"), content="true")

    configured.shutdown()
    manual.shutdown(clear=true)
  })

  inspect(configured.is_closed(), content="true")
  inspect(configured.is_running(), content="false")
  inspect(configured.has_failed(), content="false")
  inspect(configured.last_error(), content="")
  inspect(configured.pending_count(), content="0")
  inspect(manual.is_closed(), content="true")
  inspect(manual.is_running(), content="false")
  inspect(manual.has_failed(), content="true")
  inspect(manual.last_error().contains("TestFlushError"), content="true")
}

///|
async test "build async text logger shutdown flush policy keeps default no-op flush callback" {
  let config = AsyncLoggerBuildConfig::new(
    logger=@bitlogger.LoggerConfig::new(
      min_level=@bitlogger.Level::Info,
      target="async.text.shutdown.flush",
      timestamp=true,
      sink=@bitlogger.SinkConfig::new(
        kind=@bitlogger.SinkKind::TextConsole,
        text_formatter=@bitlogger.TextFormatterConfig::new(
          show_timestamp=false,
          separator=" | ",
          template="TEXT:{target}:{message}",
        ),
      ),
    ),
    async_config=AsyncLoggerConfig::new(
      max_pending=4,
      overflow=AsyncOverflowPolicy::Blocking,
      max_batch=2,
      flush=AsyncFlushPolicy::Shutdown,
    ),
  )
  let configured = build_async_text_logger(config)
  let manual = async_logger(
    @bitlogger.text_console_sink(
      config.logger.sink.text_formatter.to_formatter(),
    ),
    config=config.async_config,
    min_level=config.logger.min_level,
    target=config.logger.target,
    flush=fn(_) -> Int raise {
      raise TestFlushError("text shutdown flush exploded")
    },
  ).with_timestamp(enabled=config.logger.timestamp)

  @async.with_task_group(group => {
    group.spawn_bg(() => configured.run())
    group.spawn_bg(allow_failure=true, () => manual.run())

    configured.error("one")
    configured.error("two")
    manual.error("one")
    manual.error("two")

    configured.shutdown()
    manual.shutdown()
  })

  inspect(
    match configured.flush_policy() {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )
  inspect(
    match manual.flush_policy() {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )
  inspect(configured.is_closed(), content="true")
  inspect(configured.is_running(), content="false")
  inspect(configured.has_failed(), content="false")
  inspect(configured.last_error(), content="")
  inspect(configured.pending_count(), content="0")
  inspect(manual.is_closed(), content="true")
  inspect(manual.is_running(), content="false")
  inspect(manual.has_failed(), content="true")
  inspect(manual.last_error().contains("TestFlushError"), content="true")
  inspect(manual.pending_count(), content="0")
}

///|
test "build async text logger ignores sync queue layer" {
  let logger = build_async_text_logger(
    AsyncLoggerBuildConfig::new(
      logger=@bitlogger.LoggerConfig::new(
        min_level=@bitlogger.Level::Warn,
        target="async.text.queued",
        queue=Some(
          @bitlogger.QueueConfig::new(
            3,
            overflow=@bitlogger.QueueOverflowPolicy::DropNewest,
          ),
        ),
        sink=@bitlogger.SinkConfig::new(
          kind=@bitlogger.SinkKind::TextConsole,
          text_formatter=@bitlogger.TextFormatterConfig::new(
            show_timestamp=false,
            separator=" | ",
          ),
        ),
      ),
      async_config=AsyncLoggerConfig::new(max_pending=2),
    ),
  )

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.text.queued")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="0")
}

///|
test "application async logger can be built from config text" {
  let logger = parse_and_build_application_async_logger(
    "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.app.json\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropNewest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
  )
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.app.json")
}

///|
async test "application async parse-build matches parsed direct async builder behavior" {
  let raw = "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.app.json.same-build\",\"timestamp\":true,\"queue\":{\"max_pending\":3,\"overflow\":\"DropNewest\"},\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropOldest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Shutdown\"}}"
  let application = parse_and_build_application_async_logger(raw)
  let direct = build_async_logger(parse_async_logger_build_config_text(raw))
  let application_state = application.state()
  let direct_state = direct.state()

  inspect(application.target, content=direct.target)
  inspect(application.timestamp == direct.timestamp, content="true")
  inspect(
    application.is_enabled(@bitlogger.Level::Error) ==
    direct.is_enabled(@bitlogger.Level::Error),
    content="true",
  )
  inspect(
    application.is_enabled(@bitlogger.Level::Info) ==
    direct.is_enabled(@bitlogger.Level::Info),
    content="true",
  )
  inspect(
    stringify_async_logger_state(application_state) ==
    stringify_async_logger_state(direct_state),
    content="true",
  )
  let application_sink_kind = match application.sink {
    @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
    @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
    @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
    @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
    @bitlogger.RuntimeSink::Console(_) => "Console"
    @bitlogger.RuntimeSink::JsonConsole(_) => "JsonConsole"
    @bitlogger.RuntimeSink::TextConsole(_) => "TextConsole"
    @bitlogger.RuntimeSink::File(_) => "File"
  }
  let direct_sink_kind = match direct.sink {
    @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
    @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
    @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
    @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
    @bitlogger.RuntimeSink::Console(_) => "Console"
    @bitlogger.RuntimeSink::JsonConsole(_) => "JsonConsole"
    @bitlogger.RuntimeSink::TextConsole(_) => "TextConsole"
    @bitlogger.RuntimeSink::File(_) => "File"
  }
  inspect(application_sink_kind == direct_sink_kind, content="true")

  application.info("skip")
  application.error("one")
  application.error("two")
  application.error("three")
  direct.info("skip")
  direct.error("one")
  direct.error("two")
  direct.error("three")

  inspect(application.pending_count() == direct.pending_count(), content="true")
  inspect(application.dropped_count() == direct.dropped_count(), content="true")
  inspect(application.is_closed() == direct.is_closed(), content="true")
  inspect(application.is_running() == direct.is_running(), content="true")
  inspect(
    application.sink.pending_count() == direct.sink.pending_count(),
    content="true",
  )
  inspect(
    application.sink.dropped_count() == direct.sink.dropped_count(),
    content="true",
  )

  @async.with_task_group(group => {
    group.spawn_bg(() => application.run())
    group.spawn_bg(() => direct.run())
    application.shutdown()
    direct.shutdown()
  })

  inspect(application.is_closed() == direct.is_closed(), content="true")
  inspect(application.is_running() == direct.is_running(), content="true")
  inspect(application.pending_count() == direct.pending_count(), content="true")
  inspect(application.dropped_count() == direct.dropped_count(), content="true")
  inspect(application.has_failed() == direct.has_failed(), content="true")
  inspect(application.last_error() == direct.last_error(), content="true")
}

///|
async test "application async parse-build preserves file-backed runtime helpers" {
  let raw = "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.app.json.file.same-build\",\"queue\":{\"max_pending\":3,\"overflow\":\"DropOldest\"},\"sink\":{\"kind\":\"file\",\"path\":\"async-app-json-file-same-build.log\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropOldest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Shutdown\"}}"
  let application = parse_and_build_application_async_logger(raw)
  let direct = build_async_logger(parse_async_logger_build_config_text(raw))

  application.info("skip")
  application.error("one")
  application.error("two")
  application.error("three")
  direct.info("skip")
  direct.error("one")
  direct.error("two")
  direct.error("three")

  inspect(application.pending_count() == direct.pending_count(), content="true")
  inspect(application.dropped_count() == direct.dropped_count(), content="true")
  inspect(
    application.sink.pending_count() == direct.sink.pending_count(),
    content="true",
  )
  inspect(
    application.sink.dropped_count() == direct.sink.dropped_count(),
    content="true",
  )
  inspect(
    application.sink.file_available() == direct.sink.file_available(),
    content="true",
  )
  inspect(
    application.sink.file_append_mode() == direct.sink.file_append_mode(),
    content="true",
  )
  inspect(
    application.sink.file_auto_flush() == direct.sink.file_auto_flush(),
    content="true",
  )

  let application_state = application.sink.file_state()
  let direct_state = direct.sink.file_state()
  inspect(application_state.path == direct_state.path, content="true")
  inspect(application_state.available == direct_state.available, content="true")
  inspect(application_state.append == direct_state.append, content="true")
  inspect(
    application_state.auto_flush == direct_state.auto_flush,
    content="true",
  )
  inspect(
    application_state.open_failures == direct_state.open_failures,
    content="true",
  )
  inspect(
    application_state.write_failures == direct_state.write_failures,
    content="true",
  )
  inspect(
    application_state.flush_failures == direct_state.flush_failures,
    content="true",
  )
  inspect(
    application_state.rotation_failures == direct_state.rotation_failures,
    content="true",
  )

  match
    (application.sink.file_runtime_state(), direct.sink.file_runtime_state()) {
    (Some(snapshot), Some(other)) => {
      inspect(snapshot.file.path == other.file.path, content="true")
      inspect(snapshot.file.available == other.file.available, content="true")
      inspect(snapshot.queued == other.queued, content="true")
      inspect(snapshot.pending_count == other.pending_count, content="true")
      inspect(snapshot.dropped_count == other.dropped_count, content="true")
    }
    _ => inspect(false, content="true")
  }

  inspect(
    application.sink.file_set_append_mode(false) ==
    direct.sink.file_set_append_mode(false),
    content="true",
  )
  inspect(
    application.sink.file_append_mode() == direct.sink.file_append_mode(),
    content="true",
  )
  inspect(
    application.sink.file_set_auto_flush(false) ==
    direct.sink.file_set_auto_flush(false),
    content="true",
  )
  inspect(
    application.sink.file_auto_flush() == direct.sink.file_auto_flush(),
    content="true",
  )
  inspect(
    application.sink.file_set_rotation(
      Some(@bitlogger.file_rotation(36, max_backups=2)),
    ) ==
    direct.sink.file_set_rotation(
      Some(@bitlogger.file_rotation(36, max_backups=2)),
    ),
    content="true",
  )
  inspect(
    application.sink.file_rotation_enabled() ==
    direct.sink.file_rotation_enabled(),
    content="true",
  )
  inspect(
    application.sink.file_reopen_append() == direct.sink.file_reopen_append(),
    content="true",
  )
  inspect(
    application.sink.file_append_mode() == direct.sink.file_append_mode(),
    content="true",
  )
  inspect(
    application.sink.file_clear_rotation() == direct.sink.file_clear_rotation(),
    content="true",
  )
  inspect(
    application.sink.file_reset_policy() == direct.sink.file_reset_policy(),
    content="true",
  )
  inspect(
    application.sink.file_policy_matches_default() ==
    direct.sink.file_policy_matches_default(),
    content="true",
  )
  inspect(
    application.sink.file_reset_failure_counters() ==
    direct.sink.file_reset_failure_counters(),
    content="true",
  )
  inspect(
    application.sink.file_flush() == direct.sink.file_flush(),
    content="true",
  )
  inspect(application.pending_count() == direct.pending_count(), content="true")
  inspect(
    application.sink.file_close() == direct.sink.file_close(),
    content="true",
  )
}

///|
async test "parsed application async logger keeps async helper surface" {
  let logger : ApplicationAsyncLogger = parse_and_build_application_async_logger(
    "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.app.json.helpers\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropOldest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Shutdown\"}}",
  )

  let state = logger.state()
  inspect(state.pending_count, content="0")
  inspect(state.dropped_count, content="0")
  inspect(state.is_closed, content="false")
  inspect(state.is_running, content="false")
  inspect(state.has_failed, content="false")
  inspect(
    match state.flush_policy {
      AsyncFlushPolicy::Never => "Never"
      AsyncFlushPolicy::Batch => "Batch"
      AsyncFlushPolicy::Shutdown => "Shutdown"
    },
    content="Shutdown",
  )

  logger.info("skip")
  logger.error("one")
  logger.error("two")
  logger.error("three")
  inspect(logger.pending_count(), content="2")
  inspect(logger.dropped_count(), content="1")
  inspect(logger.is_closed(), content="false")
  inspect(logger.is_running(), content="false")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
  inspect(logger.has_failed(), content="false")
  inspect(logger.last_error(), content="")
}

///|
async test "parsed application async logger shutdown clear abandons pending records" {
  let logger : ApplicationAsyncLogger = parse_and_build_application_async_logger(
    "{\"logger\":{\"min_level\":\"info\",\"target\":\"async.app.json.clear\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"Blocking\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
  )

  logger.info("one")
  inspect(logger.pending_count(), content="1")
  inspect(logger.dropped_count(), content="0")
  logger.shutdown(clear=true)
  inspect(logger.is_closed(), content="true")
  inspect(logger.is_running(), content="false")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="1")
}

///|
async test "parsed application async logger keeps broader async composition surface" {
  let logger : ApplicationAsyncLogger = parse_and_build_application_async_logger(
      "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.app.json.compose\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropNewest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Shutdown\"}}",
    )
    .with_timestamp()
    .with_context_fields([@bitlogger.field("service", "bitlogger")])
    .child("worker")

  inspect(logger.target, content="async.app.json.compose.worker")
  inspect(logger.timestamp, content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")

  logger.error("one")
  logger.error("two")
  inspect(logger.pending_count(), content="2")
  inspect(logger.dropped_count(), content="0")

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.shutdown()
  })

  inspect(logger.is_closed(), content="true")
  inspect(logger.pending_count(), content="0")
  inspect(logger.dropped_count(), content="0")
  inspect(logger.has_failed(), content="false")
  inspect(logger.last_error(), content="")
}

///|
async test "parsed application async logger log supports per-call target override" {
  let written_target : Ref[String] = Ref("")

  let logger : ApplicationAsyncLogger = parse_and_build_application_async_logger(
    "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.app.json.default\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"Blocking\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
  ).with_patch(fn(rec) {
    written_target.val = rec.target
    rec
  })

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.log(
      @bitlogger.Level::Error,
      "override",
      target="async.app.json.override",
    )
    logger.shutdown()
  })

  inspect(written_target.val, content="async.app.json.override")

  let second_target : Ref[String] = Ref("")

  let second : ApplicationAsyncLogger = parse_and_build_application_async_logger(
    "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.app.json.default\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"Blocking\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
  ).with_patch(fn(rec) {
    second_target.val = rec.target
    rec
  })

  @async.with_task_group(group => {
    group.spawn_bg(() => second.run())
    second.error("default")
    second.shutdown()
  })

  inspect(second_target.val, content="async.app.json.default")
}

///|
async test "parsed application async logger severity helpers use stored target without override" {
  let written_targets : Ref[Array[String]] = Ref([])

  let logger : ApplicationAsyncLogger = parse_and_build_application_async_logger(
    "{\"logger\":{\"min_level\":\"trace\",\"target\":\"async.app.json.helpers.target\",\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":4,\"overflow\":\"Blocking\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
  ).with_patch(fn(rec) {
    written_targets.val.push(rec.target)
    rec
  })

  @async.with_task_group(group => {
    group.spawn_bg(() => logger.run())
    logger.debug("first")
    logger.info("second")
    logger.error("third")
    logger.shutdown()
  })

  inspect(written_targets.val.length(), content="3")
  inspect(written_targets.val[0], content="async.app.json.helpers.target")
  inspect(written_targets.val[1], content="async.app.json.helpers.target")
  inspect(written_targets.val[2], content="async.app.json.helpers.target")
}

///|
test "application async logger parse-and-build preserves parsed sync queue layer" {
  let logger = parse_and_build_application_async_logger(
    "{\"logger\":{\"min_level\":\"warn\",\"target\":\"async.app.json.queued\",\"queue\":{\"max_pending\":3,\"overflow\":\"DropNewest\"},\"sink\":{\"kind\":\"console\"}},\"async_config\":{\"max_pending\":2,\"overflow\":\"DropNewest\",\"max_batch\":1,\"linger_ms\":0,\"flush\":\"Never\"}}",
  )

  inspect(logger.is_enabled(@bitlogger.Level::Error), content="true")
  inspect(logger.is_enabled(@bitlogger.Level::Info), content="false")
  inspect(logger.target, content="async.app.json.queued")
  inspect(
    match logger.sink {
      @bitlogger.RuntimeSink::QueuedConsole(_) => "QueuedConsole"
      @bitlogger.RuntimeSink::QueuedJsonConsole(_) => "QueuedJsonConsole"
      @bitlogger.RuntimeSink::QueuedTextConsole(_) => "QueuedTextConsole"
      @bitlogger.RuntimeSink::QueuedFile(_) => "QueuedFile"
      _ => "Other"
    },
    content="QueuedConsole",
  )
}

///|
test "async parse-build facades forward parse failures" {
  let raw = "{\"logger\":{\"sink\":{\"kind\":\"file\",\"path\":\"\"}},\"async_config\":{\"max_pending\":2}}"

  let application_error = (fn() -> String raise {
    ignore(parse_and_build_application_async_logger(raw))
    "no error"
  })() catch {
    err => err.to_string()
  }
  inspect(application_error != "no error", content="true")

  let library_error = (fn() -> String raise {
    ignore(parse_and_build_library_async_logger(raw))
    "no error"
  })() catch {
    err => err.to_string()
  }
  inspect(library_error != "no error", content="true")
}