quadkit 0.0.41__tar.gz → 0.0.43__tar.gz

{quadkit-0.0.41 → quadkit-0.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quadkit
-Version: 0.0.41
+Version: 0.0.43
 Summary: Async-first DI/IoC framework for Python — core package
 Project-URL: Homepage, https://dbtinoy-.github.io/quadkit/
 Project-URL: Repository, https://github.com/dbtinoy-/quadkit
@@ -27,6 +27,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: orjson<4,>=3.0.0
 Requires-Dist: pydantic<3,>=2.10.0
+Requires-Dist: pyyaml<7,>=6.0.0
 Requires-Dist: quadkit-contracts>=0.0.2
 Requires-Dist: structlog<27,>=25.1.0
 Provides-Extra: codegen
@@ -250,10 +251,10 @@ report vulnerabilities privately per
 
 ## Stability
 
-Version `0.0.3` in the `0.x` series, released in lockstep with the
+Version `0.0.43` in the `0.x` series, released in lockstep with the
 other four distributions; APIs may change between minor versions until
 1.0 — pin an exact version
-(`quadkit==0.0.3`) or a tight range (`>=0.0.3,<0.1.0`). Full policy:
+(`quadkit==0.0.43`) or a tight range (`>=0.0.43,<0.1.0`). Full policy:
 [stability and compatibility](https://dbtinoy-.github.io/quadkit/reference/stability/).
 
 ## Links

{quadkit-0.0.41 → quadkit-0.0.43}/README.md

@@ -199,10 +199,10 @@ report vulnerabilities privately per
 
 ## Stability
 
-Version `0.0.3` in the `0.x` series, released in lockstep with the
+Version `0.0.43` in the `0.x` series, released in lockstep with the
 other four distributions; APIs may change between minor versions until
 1.0 — pin an exact version
-(`quadkit==0.0.3`) or a tight range (`>=0.0.3,<0.1.0`). Full policy:
+(`quadkit==0.0.43`) or a tight range (`>=0.0.43,<0.1.0`). Full policy:
 [stability and compatibility](https://dbtinoy-.github.io/quadkit/reference/stability/).
 
 ## Links

{quadkit-0.0.41 → quadkit-0.0.43}/example.yaml

@@ -5,7 +5,7 @@
 # Top-level env var prefix: QK_  (nested delimiter: __)
 #
 # Core fields are declared at the top level of this file.
-# Extension packages (the optional provider, the optional provider, etc.) each add their own
+# Extension packages (quadkit-cache, quadkit-sql, etc.) each add their own
 # top-level section (e.g. cache:, sql:, ai:) read by their own Config class.
 
 # -- Application Identity --------------------------------------------------
@@ -226,7 +226,7 @@ security:
     pbkdf2_iterations: 600000
 
 # -- Observability ---------------------------------------------------------
-# NEW -- Core observability hooks. Full OTLP/Prometheus config is in the optional provider.
+# NEW -- Core observability hooks. Full OTLP/Prometheus config is in quadkit-monitor.
 
 observability:
   # Master switch. When false, no-op implementations are used unconditionally.

{quadkit-0.0.41 → quadkit-0.0.43}/pyproject.toml

@@ -10,6 +10,8 @@
 #   - Structured logging foundation
 #
 # It does NOT contain:
+#   - Database code          → quadkit-sql
+#   - Auth/JWT/crypto        → quadkit-auth
 #   - HTTP/ASGI/routing      → quadkit-web
 #   - Any domain-specific feature
 #
@@ -27,7 +29,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quadkit"
-version = "0.0.41"
+version = "0.0.43"
 description = "Async-first DI/IoC framework for Python — core package"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -71,6 +73,7 @@ dependencies = [
     "orjson>=3.0.0,<4",
     "structlog>=25.1.0,<27",         # Structured logging foundation
     "pydantic>=2.10.0,<3",              # Required: used unconditionally by config, validation
+    "pyyaml>=6.0.0,<7",                 # Required: YAML config file parsing
 ]
 
 # =============================================================================
@@ -127,7 +130,7 @@ web = [
 # events, tasks, monitor, graphql) were removed. Those packages are not
 # published, so the extras resolved against name-reservation placeholders
 # that contain no code: `pip install quadkit[cache]` succeeded and then
-# `import the optional provider module` raised ModuleNotFoundError. Install extension
+# `import quadkit.cache` raised ModuleNotFoundError. Install extension
 # packages directly once they are published.
 
 # =============================================================================

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/app/config/models.py

@@ -23,6 +23,12 @@ class AppConfig:
     # ``name`` is the canonical YAML key under ``app:``; ``app_name`` remains
     # supported for compatibility with the original flat configuration.
     name: str | None = None
+    # ``version`` is the canonical YAML key under ``app:`` (application
+    # version string). Declared so apps that pin ``app.version`` in
+    # application.yaml bind cleanly — unknown keys raise ConfigSourceError
+    # from Application.stop()/get_section().
+    version: str = "0.0.0"
+    # consumed by: Application — version surfaced in health/telemetry
     # consumed by: OTEL resource attribute, logger context, AppProvider
     debug: bool | str = False
     # consumed by: Application — verbose startup/teardown logging

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/app/module.py

@@ -15,7 +15,7 @@ Kernel providers (boot order governed by provider ``priority`` and ``dependencie
 For a batteries-included bundle that also provides serialization and
 concurrency, use :class:`~quadkit.app.standard.StandardModule` instead.
 
-Extension packages (``the optional provider``, ``the optional provider``, ``quadkit-web``,
+Extension packages (``quadkit-cache``, ``quadkit-auth``, ``quadkit-web``,
 etc.) register their own providers via ``app.add_provider()`` or
 ``app.add_module()``.  ``CoreModule`` intentionally imports **only** from
 ``quadkit-contracts`` and the ``quadkit`` core package — zero cross-package

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/codegen/__init__.py

@@ -1,4 +1,5 @@
 from quadkit.codegen.base import GeneratorBase
+from quadkit.codegen.field_types import annotation_for, import_lines
 from quadkit.contracts.cli.generators import GenerationResult
 from quadkit.contracts.cli.parsers import FieldSpec, parse_fields
 
@@ -6,5 +7,7 @@ __all__ = [
     "FieldSpec",
     "GenerationResult",
     "GeneratorBase",
+    "annotation_for",
+    "import_lines",
     "parse_fields",
 ]

quadkit-0.0.43/src/quadkit/codegen/field_types.py

@@ -0,0 +1,131 @@
+"""Field-type vocabulary for the CLI code generators.
+
+Field types arrive as free-form identifiers from ``--fields`` strings
+(``order_id:uuid,total:decimal,payload:json``) and generators render them
+straight into annotations -- dataclass fields, Pydantic model fields, function
+signatures. Rendering the token verbatim only
+works while the token happens to be a builtin: ``float`` and ``str`` are fine,
+but ``uuid``, ``datetime``, ``date``, ``time`` and ``json`` are *not* names in
+the generated module, so a payload carrying any of them produced a file that
+raised ``NameError`` on import — the module could not even be collected by
+pytest.
+
+Two things have to agree for a field to render correctly, so they live
+together here: the annotation for a token, and the import that annotation
+needs. ``date`` is a ``datetime`` name, ``UUID`` is a ``uuid`` name, and
+``dict[str, Any]`` needs ``Any`` — an annotation vocabulary without its import
+list is how the original bug happened.
+
+Unknown tokens fall back to themselves, matching the SQL vocabulary's stance
+that a typo degrades rather than blocks generation; the difference is that a
+*known* token now always renders a name that exists.
+
+This lives in ``quadkit.codegen`` because every generator that renders a field
+already imports from here (``parse_fields`` is the other half of the same
+contract): the vocabulary and the parser that produces its input belong
+together, and a second copy is how the two halves drift apart again.
+
+``quadkit-sql`` keeps its own table: SQLAlchemy columns need a second mapping
+(``String(length=255)``, ``Text``) that has no meaning for a payload.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+import re
+
+#: Field type → Python annotation for a dataclass field or signature.
+PY_TYPES: dict[str, str] = {
+    # Text — an event payload carries values, so URL-ish tokens stay strings:
+    # a domain event is a frozen dataclass, not a validated Pydantic model,
+    # and importing a validator type for one field would point the dependency
+    # the wrong way.
+    "str": "str",
+    "string": "str",
+    "text": "str",
+    "slug": "str",
+    "char": "str",
+    "email": "str",
+    "phone": "str",
+    "filename": "str",
+    "filepath": "str",
+    "enum": "str",
+    "url": "str",
+    "uri": "str",
+    "ipv4": "str",
+    "ipv6": "str",
+    "ip": "str",
+    # Numeric
+    "int": "int",
+    "integer": "int",
+    "bigint": "int",
+    "smallint": "int",
+    "float": "float",
+    "double": "float",
+    "number": "float",
+    "decimal": "float",
+    "numeric": "float",
+    "money": "float",
+    # Boolean and temporal
+    "bool": "bool",
+    "boolean": "bool",
+    "datetime": "datetime",
+    "timestamp": "datetime",
+    "date": "date",
+    "time": "time",
+    # Identifiers and structured data
+    "uuid": "UUID",
+    "json": "dict[str, Any]",
+    "jsonb": "dict[str, Any]",
+    "dict": "dict[str, Any]",
+    "object": "dict[str, Any]",
+    "bytes": "bytes",
+    "blob": "bytes",
+    "binary": "bytes",
+}
+
+#: Annotation → the module and name that provide it.
+ANNOTATION_SOURCES: dict[str, tuple[str, str]] = {
+    "UUID": ("uuid", "UUID"),
+    "datetime": ("datetime", "datetime"),
+    "date": ("datetime", "date"),
+    "time": ("datetime", "time"),
+    "Any": ("typing", "Any"),
+}
+
+
+def annotation_for(field_type: str) -> str:
+    """The Python annotation for a field-spec type token."""
+    return PY_TYPES.get(field_type.strip().lower(), field_type.strip())
+
+
+def import_lines(
+    field_types: Iterable[str], *, always: Iterable[str] = ()
+) -> list[str]:
+    """One import line per module needed by the rendered annotations.
+
+    Args:
+        field_types: Raw field-spec tokens from the ``--fields`` string.
+        always: Annotations the template renders outside the payload — the
+            event template's ``aggregate_id: UUID``, the command and query
+            templates' ``Any`` — so they are imported whether or not a field
+            happens to ask for them. Templates have no import machinery of
+            their own; this is it.
+    """
+    per_module: dict[str, set[str]] = {}
+    for field_type in [*field_types, *always]:
+        rendered = annotation_for(field_type)
+        # Scan the *rendered annotation* rather than looking the token up in a
+        # second table: a composite annotation carries more than one name
+        # (``dict[str, Any]`` needs ``Any``), and the names are what the file
+        # has to import.
+        for name, (module, _) in ANNOTATION_SOURCES.items():
+            if re.search(rf"\b{name}\b", rendered):
+                per_module.setdefault(module, set()).add(name)
+    return [
+        f"from {module} import {', '.join(sorted(names))}"
+        for module, names in sorted(per_module.items())
+    ]
+
+
+__all__ = ["ANNOTATION_SOURCES", "PY_TYPES", "annotation_for", "import_lines"]

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/di/container/validation.py

@@ -70,7 +70,7 @@ class ContainerValidator:
                         # not something the user can fix with annotations.
                         logger.warning(
                             "validate.scope_check_unhashable_hint",
-                            service=service_name,
+                            service_type=service_name,
                             error=str(e),
                         )
                     else:
@@ -85,13 +85,13 @@ class ContainerValidator:
                 except AttributeError as e:
                     logger.warning(
                         "validate.scope_check_attribute_error",
-                        service=service_name,
+                        service_type=service_name,
                         error=str(e),
                     )
                 except (KeyError, ValueError) as e:
                     logger.warning(
                         "validate.scope_check_resolution_error",
-                        service=service_name,
+                        service_type=service_name,
                         error=str(e),
                     )
 
@@ -123,7 +123,7 @@ class ContainerValidator:
             except (AttributeError, TypeError, KeyError, ValueError) as e:
                 logger.debug(
                     "validate_no_orphans.dep_resolution_error",
-                    service=getattr(service_type, "__name__", str(service_type)),
+                    service_type=getattr(service_type, "__name__", str(service_type)),
                     error=str(e),
                 )
                 continue

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/di/extensions/discovery.py

@@ -127,7 +127,7 @@ class ProviderScanner:
 def import_string(dotted_path: str) -> Any:
     """Import a dotted module path and return the attribute at the end.
 
-    E.g. 'the optional provider module' imports 'the optional provider module' and returns
+    E.g. 'quadkit.sql.DatabaseService' imports 'quadkit.sql' and returns
     the 'DatabaseService' attribute.
     """
     try:

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/di/resolution/resolver.py

@@ -79,7 +79,7 @@ class ServiceResolver:
         if self._debug_resolution:
             logger.debug(
                 "di.resolution.resolved",
-                service=getattr(service_type, "__name__", repr(service_type)),
+                service_type=getattr(service_type, "__name__", repr(service_type)),
             )
         return instance
 

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/domain/unit_of_work.py

@@ -8,7 +8,7 @@ This base is deliberately storage-agnostic -- it imports no database driver --
 so in-memory and SQL implementations can share it:
 
 - ``quadkit.testing.memory.uow.InMemoryUnitOfWork`` supplies a no-op flush.
-- ``the optional provider``'s ``SQLUnitOfWork`` flushes through the active session.
+- ``quadkit-sql``'s ``SQLUnitOfWork`` flushes through the active session.
 """
 
 from __future__ import annotations

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/identity/ambient.py

@@ -7,7 +7,8 @@ Example:
     from quadkit import identity
 
     id = identity.generate_for("user")      # ULID/UUID based on config
-    uuid = identity.new_uuid()             # Random UUID4
+    opaque = identity.new_uuid()            # the configured strategy, not
+                                            # necessarily a UUID — see below
 
 For tests:
     from quadkit import identity
@@ -78,10 +79,26 @@ def generate_for(entity_type: str) -> str:
 
 
 def new_uuid() -> str:
-    """Generate a random UUID4.
+    """Generate an id with the ambient generator, whatever it is.
+
+    **The name is narrower than the behaviour.** This delegates to the
+    installed ``IdGeneratorProtocol``, so the result follows
+    ``IdentityConfig.strategy``: UUID4 by default, but a 36-char UUID7, a
+    26-char Crockford base32 ULID, or a prefixed ULID (``usr_01H…``) when
+    the application configures one — and whatever a test installs through
+    ``use()``.
+
+    Two consequences worth stating, because the name hides both:
+
+    - **Shape is not guaranteed.** Do not feed the result to a ``UUID``
+      column or ``uuid.UUID()`` unless the strategy is pinned to UUID4/7.
+    - **Randomness is not guaranteed.** UUID7 and ULID are time-ordered:
+      the leading bits are a millisecond timestamp. For a value that must
+      be unguessable — a reset token, a session id, a webhook secret — use
+      ``secrets.token_urlsafe()``, not this.
 
     Returns:
-        A random UUID4 string.
+        An id string from the ambient generator.
     """
     return _ambient.get().generate()
 

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/logging/README.md

@@ -43,15 +43,15 @@ Each log line is a single JSON object emitted by
 {
   "timestamp": "2026-08-19 10:15:30",
   "level": "INFO",
-  "logger": "quadkit.web.controller",
   "event": "user_created",
   "service": "my-app",
   "trace_id": "4bf92f3577b34da6a3ce929d0e0e4736",
   "span_id": "00f067aa0ba902b7",
-  "filename": "controller.py",
-  "lineno": 42,
-  "module": "controller",
-  "func_name": "create_user",
+  "_logger_name": "quadkit.web.controller",
+  "_filename": "controller.py",
+  "_lineno": 42,
+  "_module": "controller",
+  "_func_name": "create_user",
   "user_id": "usr_123"
 }
 ```
@@ -60,16 +60,44 @@ Each log line is a single JSON object emitted by
 |-------------|---------------------------------------------------------------|
 | `timestamp` | `TimeStamper(fmt="%Y-%m-%d %H:%M:%S")`                       |
 | `level`     | `structlog.stdlib.add_log_level`                             |
-| `logger`    | `_add_logger_name` — auto-prefixed with `quadkit.`          |
 | `event`     | Message passed to `logger.info("...")`                       |
 | `service`   | Injected by `configure_logging(service_name=...)` / `Application.name`; overridable via `bind(service=...)` |
 | `trace_id` / `span_id` | `_otel_processor` — only when an OTEL trace context is active |
-| `filename` / `lineno` / `module` / `func_name` | `CallsiteParameterAdder` |
+| `_logger_name` | `get_logger()` / `_add_logger_name` — auto-prefixed with `quadkit.` |
+| `_filename` / `_lineno` / `_module` / `_func_name` | `CallsiteParameterAdder`, wrapped by `_NamespacedCallsiteAdder` |
 | `exception` | Formatted traceback, present on `logger.exception(...)` / `exc_info=True` |
 
 Key-value arguments passed to a log call are appended verbatim as top-level
 fields (`logger.info("user_created", user_id=usr.id)` → `"user_id"`).
 
+## Field names: what the envelope owns, and what you own
+
+Two namespaces, so a caller's field and the pipeline's metadata can never
+be the same key:
+
+- **`_`-prefixed keys belong to the framework** — `_logger_name`,
+  `_filename`, `_lineno`, `_module`, `_func_name`. Do not pass them.
+- **Every other plain name belongs to the caller.** `module=`, `filename=`,
+  `name=`, `msg=` are ordinary fields; `logger.info("module_booted",
+  module=self.name)` renders the value you passed.
+- **Five envelope names are reserved**: `event`, `level`, `timestamp`,
+  `service` and `exception`. `service` is deliberately overridable via
+  `bind(service=...)`; the other four are not yours to set.
+  `dev/checks/reserved_log_fields.py` fails the build on a call site that
+  passes one.
+
+`event` is the sharp one: it is structlog's parameter for the *message*, so
+`logger.warning("emit_failed", event=type(evt).__name__)` raises
+`TypeError` — inside the `except` block that was reporting the failure.
+Because a diagnostic must never raise, `_NamedLogger` moves such a field to
+`event_field` rather than letting the call blow up; the gate is what makes
+you rename it properly (`event_type`, `webhook_event`).
+
+Callsite metadata reports *your* frame, not the framework's: the adder is
+configured with `additional_ignores=["quadkit.logging"]`, without which
+`_NamedLogger.info` in `logging/factory.py` is the nearest non-structlog
+frame and every line in the process is stamped with it.
+
 ## Behavior guarantees
 
 - **Levels**: `DEBUG < INFO < WARNING < ERROR < CRITICAL`. A global
@@ -94,5 +122,5 @@ fields (`logger.info("user_created", user_id=usr.id)` → `"user_id"`).
 - Never `print()`; never log secret material (redaction is a safety net,
   not a substitute for not logging secrets).
 - For error tracking, forward `level >= ERROR` events with `event`,
-  `exception`, `logger`, and `trace_id` fields — correlation IDs make
+  `exception`, `_logger_name`, and `trace_id` fields — correlation IDs make
   distributed debugging possible.

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/logging/configurator.py

@@ -21,6 +21,7 @@ from quadkit.logging.processors import (
     _add_logger_name,
     _context_processor,
     _level_filter_processor,
+    _NamespacedCallsiteAdder,
     _otel_processor,
     _redact_processor,
     _sampling_processor,
@@ -101,13 +102,16 @@ def configure_logging(
         _service_processor,
         _otel_processor,
         _redact_processor,
-        structlog.processors.CallsiteParameterAdder(
-            {
-                structlog.processors.CallsiteParameter.FILENAME,
-                structlog.processors.CallsiteParameter.LINENO,
-                structlog.processors.CallsiteParameter.MODULE,
-                structlog.processors.CallsiteParameter.FUNC_NAME,
-            },
+        _NamespacedCallsiteAdder(
+            structlog.processors.CallsiteParameterAdder(
+                {
+                    structlog.processors.CallsiteParameter.FILENAME,
+                    structlog.processors.CallsiteParameter.LINENO,
+                    structlog.processors.CallsiteParameter.MODULE,
+                    structlog.processors.CallsiteParameter.FUNC_NAME,
+                },
+                additional_ignores=["quadkit.logging"],
+            ),
         ),
         structlog.processors.StackInfoRenderer(),
     ]

{quadkit-0.0.41 → quadkit-0.0.43}/src/quadkit/logging/factory.py

@@ -3,6 +3,14 @@
 Provides ``get_logger()`` for obtaining structlog bound-loggers with a
 ``.name`` attribute, and ``LoggerFactoryImpl`` which implements the
 ``LoggerFactoryProtocol`` protocol.
+
+A logging call must never raise.  structlog names the message parameter
+``event``, so ``logger.info("task_finished", event=evt.name)`` is a
+``TypeError`` — raised from inside the ``except`` block that was trying to
+report a failure.  ``_deconflict()`` moves such a field to ``event_field``
+instead of letting the diagnostic take down the path it was diagnosing;
+``dev/checks/reserved_log_fields.py`` fails the build on the call site so
+the remap stays a safety net rather than an interface.
 """
 
 from __future__ import annotations
@@ -16,6 +24,25 @@ if TYPE_CHECKING:
     from quadkit.logging.config.models import LoggingConfig
 
 
+def _deconflict(kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Move a caller field named ``event`` out of structlog's way.
+
+    ``event`` is structlog's parameter for the log message, so passing it as
+    a field raises ``TypeError``.  The field is preserved under
+    ``event_field`` (``event_field_``, ``event_field__``, … if the caller
+    already used that name) rather than dropped: a log call is a diagnostic
+    and must not raise.
+    """
+    if "event" not in kwargs:
+        return kwargs
+    safe = dict(kwargs)
+    key = "event_field"
+    while key in safe:
+        key += "_"
+    safe[key] = safe.pop("event")
+    return safe
+
+
 class _NamedLogger:
     """Thin wrapper that adds ``.name`` to a structlog bound logger.
 
@@ -34,26 +61,31 @@ class _NamedLogger:
     # These exist so ``hasattr(_NamedLogger, 'debug')`` etc. return True for
     # the DI validator.  At runtime the call is forwarded via __getattr__.
 
-    def debug(self, msg: str, *args: Any, **kwargs: Any) -> None:
-        self._inner.debug(msg, *args, **kwargs)
+    # ``msg`` is positional-only: without the ``/`` this wrapper would add a
+    # reserved word of its own making, and ``logger.info("x", msg=body)``
+    # would fail with "got multiple values for argument 'msg'" even though
+    # the underlying structlog logger has no such parameter.
+
+    def debug(self, msg: str, /, *args: Any, **kwargs: Any) -> None:
+        self._inner.debug(msg, *args, **_deconflict(kwargs))
 
-    def info(self, msg: str, *args: Any, **kwargs: Any) -> None:
-        self._inner.info(msg, *args, **kwargs)
+    def info(self, msg: str, /, *args: Any, **kwargs: Any) -> None:
+        self._inner.info(msg, *args, **_deconflict(kwargs))
 
-    def warning(self, msg: str, *args: Any, **kwargs: Any) -> None:
-        self._inner.warning(msg, *args, **kwargs)
+    def warning(self, msg: str, /, *args: Any, **kwargs: Any) -> None:
+        self._inner.warning(msg, *args, **_deconflict(kwargs))
 
-    def error(self, msg: str, *args: Any, **kwargs: Any) -> None:
-        self._inner.error(msg, *args, **kwargs)
+    def error(self, msg: str, /, *args: Any, **kwargs: Any) -> None:
+        self._inner.error(msg, *args, **_deconflict(kwargs))
 
-    def critical(self, msg: str, *args: Any, **kwargs: Any) -> None:
-        self._inner.critical(msg, *args, **kwargs)
+    def critical(self, msg: str, /, *args: Any, **kwargs: Any) -> None:
+        self._inner.critical(msg, *args, **_deconflict(kwargs))
 
-    def exception(self, msg: str, *args: Any, **kwargs: Any) -> None:
-        self._inner.exception(msg, *args, **kwargs)
+    def exception(self, msg: str, /, *args: Any, **kwargs: Any) -> None:
+        self._inner.exception(msg, *args, **_deconflict(kwargs))
 
     def bind(self, **kwargs: Any) -> _NamedLogger:
-        result = self._inner.bind(**kwargs)
+        result = self._inner.bind(**_deconflict(kwargs))
         return self if result is self._inner else _NamedLogger(result, self.name)
 
     def unbind(self, *keys: str) -> _NamedLogger:
@@ -122,18 +154,21 @@ class LoggerFactoryImpl:
         self._config = config
 
     def get_logger(self, name: str | None = None) -> LoggerProtocol:
-        """Get or create a logger, optionally binding the service name."""
-        logger = get_logger(name)
-        if name:
-            try:
-                return cast("LoggerProtocol", logger.bind(service=name))
-            except (AttributeError, TypeError):
-                return cast("LoggerProtocol", logger)
-        return cast("LoggerProtocol", logger)
+        """Get or create a logger.
+
+        This used to ``bind(service=name)``.  ``service`` is the envelope
+        field identifying the *application* (set by ``configure_logging()``
+        and used for log routing), and ``_service_processor`` yields to a
+        bound value — so every DI-resolved logger relabelled the service as
+        whichever component had asked for it.  The logger name already
+        travels in ``_logger_name``.
+        """
+        return cast("LoggerProtocol", get_logger(name))
 
 
 __all__ = [
     "LoggerFactoryImpl",
     "_NamedLogger",
+    "_deconflict",
     "get_logger",
 ]