sqlbuild 0.81.2__tar.gz → 0.82.0__tar.gz

{sqlbuild-0.81.2 → sqlbuild-0.82.0}/Cargo.lock

@@ -572,7 +572,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.81.2"
+version = "0.82.0"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.81.2 → sqlbuild-0.82.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.81.2
+Version: 0.82.0
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: polyglot-sql>=0.9.2
@@ -242,7 +242,7 @@ Runtime operator and extension contracts:
 
 - [Execution observability and local troubleshooting](docs/execution-observability.md)
 - [SQLite and PostgreSQL execution history](docs/execution-history.md)
-- [Project event exporters](docs/event-exporters.md)
+- [Typed lifecycle and command-output sinks](docs/sinks.md)
 
 ## Contributing
 

{sqlbuild-0.81.2 → sqlbuild-0.82.0}/README.md

@@ -206,7 +206,7 @@ Runtime operator and extension contracts:
 
 - [Execution observability and local troubleshooting](docs/execution-observability.md)
 - [SQLite and PostgreSQL execution history](docs/execution-history.md)
-- [Project event exporters](docs/event-exporters.md)
+- [Typed lifecycle and command-output sinks](docs/sinks.md)
 
 ## Contributing
 

{sqlbuild-0.81.2 → sqlbuild-0.82.0}/crates/sqlbuild-kata-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-kata-native"
-version = "0.81.2"
+version = "0.82.0"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.81.2 → sqlbuild-0.82.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.81.2"
+version = "0.82.0"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.81.2 → sqlbuild-0.82.0}/src/sqlbuild/cli/commands/_helpers/entry/observability.py

@@ -26,7 +26,11 @@ from sqlbuild.cli.output.classes.terminal_event_index import (
 )
 from sqlbuild.cli.progress.classes.native_progress_projector import NativeProgressProjector
 from sqlbuild.compiler.discovery.main.runtime_extensions import discover_runtime_extensions
-from sqlbuild.compiler.discovery.models import DiscoveredEventExporter, DiscoveredProvider
+from sqlbuild.compiler.discovery.models import (
+    DiscoveredCommandOutputSink,
+    DiscoveredEventExporter,
+    DiscoveredProvider,
+)
 from sqlbuild.diagnostics.main.log_debug_event import log_debug_event
 from sqlbuild.observability import DispatchFailure, EventDispatcher, Unsubscribe, dispatcher_scope
 from sqlbuild.presentation.main.supports_color import supports_color
@@ -82,8 +86,11 @@ def cli_observability_scope(*, args: CliNamespace, project_dir: Path) -> Iterato
     try:
         providers: tuple[DiscoveredProvider, ...]
         event_exporters: tuple[DiscoveredEventExporter, ...]
-        providers, event_exporters = discover_runtime_extensions(project_dir=project_dir)
-        if event_exporters:
+        command_output_sinks: tuple[DiscoveredCommandOutputSink, ...]
+        providers, event_exporters, command_output_sinks = discover_runtime_extensions(
+            project_dir=project_dir
+        )
+        if event_exporters or command_output_sinks:
             exporter_delivery: EventExporterDispatcher = EventExporterDispatcher(
                 failure_callback=_log_exporter_failure,
                 summary_callback=_log_exporter_summary,
@@ -93,6 +100,7 @@ def cli_observability_scope(*, args: CliNamespace, project_dir: Path) -> Iterato
                 project_dir=project_dir,
                 providers=providers,
                 event_exporters=event_exporters,
+                command_output_sinks=command_output_sinks,
             )
             unsubscribe_exporters = dispatcher.subscribe_lifecycle(
                 subscriber=exporter_delivery.enqueue,
@@ -104,11 +112,12 @@ def cli_observability_scope(*, args: CliNamespace, project_dir: Path) -> Iterato
             if exporter_scope is not None:
                 _ = stack.enter_context(event_exporter_command_scope(exporter_scope))
                 identity: ExecutionIdentity | None = current_execution_identity()
-                if identity is not None:
+                if identity is not None and command_output_sinks:
                     _ = stack.enter_context(
                         configured_output_capture_scope(
                             exporter_scope=exporter_scope,
                             identity=identity,
+                            failure_callback=_log_command_output_failure,
                         )
                     )
             yield dispatcher
@@ -166,6 +175,14 @@ def _log_exporter_failure(failure: EventExporterFailure) -> None:
     )
 
 
+def _log_command_output_failure(error: BaseException) -> None:
+    log_debug_event(
+        logger=_LOGGER,
+        message="Command-output sink delivery failed",
+        error_type=type(error).__name__,
+    )
+
+
 def _log_exporter_summary(summary: EventExportSummary) -> None:
     log_debug_event(
         logger=_LOGGER,

{sqlbuild-0.81.2 → sqlbuild-0.82.0}/src/sqlbuild/cli/commands/main/entrypoint/_dispatch_with_output_capture.py

@@ -1,9 +1,9 @@
-"""Configured event-export output capture for one CLI command."""
+"""Configured command-output capture for one CLI command."""
 
 from __future__ import annotations
 
 import sys
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from contextlib import contextmanager
 from typing import Any
 
@@ -14,14 +14,20 @@ from sqlbuild.runtime.output_capture.main.current_output_capture_context import
     current_output_capture_context,
 )
 from sqlbuild.runtime.output_capture.models import OutputCaptureContext
-from sqlbuild.runtime.output_capture.types import OutputBatchExporter, OutputStream
+from sqlbuild.runtime.output_capture.types import (
+    CommandOutputBatchExporter,
+    CommandOutputStream,
+)
 
 
 @contextmanager
 def configured_output_capture_scope(
-    *, exporter_scope: OutputBatchExporter | None, identity: ExecutionIdentity
+    *,
+    exporter_scope: CommandOutputBatchExporter | None,
+    identity: ExecutionIdentity,
+    failure_callback: Callable[[BaseException], object] | None = None,
 ) -> Iterator[None]:
-    """Tee command streams through the configured event-export provider session."""
+    """Tee command streams through the configured command-output provider session."""
 
     if exporter_scope is None:
         yield
@@ -33,24 +39,31 @@ def configured_output_capture_scope(
             invocation_id=identity.invocation_id,
             run_id=identity.run_id,
             external_context=None if context is None else context.external_context,
+            failure_callback=failure_callback,
         )
-    except BaseException:
+    except BaseException as error:
+        _ = _notify_failure(callback=failure_callback, error=error)
         yield
         return
     original_stdout: Any = sys.stdout
     original_stderr: Any = sys.stderr
     try:
         stdout_tee: TextOutputTee = TextOutputTee(
-            sink=original_stdout, dispatcher=dispatcher, stream=OutputStream.STDOUT
+            sink=original_stdout,
+            dispatcher=dispatcher,
+            stream=CommandOutputStream.STDOUT,
         )
         stderr_tee: TextOutputTee = TextOutputTee(
-            sink=original_stderr, dispatcher=dispatcher, stream=OutputStream.STDERR
+            sink=original_stderr,
+            dispatcher=dispatcher,
+            stream=CommandOutputStream.STDERR,
         )
-    except BaseException:
+    except BaseException as error:
         try:
             _ = dispatcher.close()
         except BaseException:
             pass
+        _ = _notify_failure(callback=failure_callback, error=error)
         yield
         return
     sys.stdout = stdout_tee
@@ -64,3 +77,14 @@ def configured_output_capture_scope(
             _ = dispatcher.close()
         except BaseException:
             pass
+
+
+def _notify_failure(
+    *, callback: Callable[[BaseException], object] | None, error: BaseException
+) -> None:
+    if callback is None:
+        return
+    try:
+        _ = callback(error)
+    except BaseException:
+        pass

{sqlbuild-0.81.2 → sqlbuild-0.82.0}/src/sqlbuild/compiler/discovery/_helpers/filesystem/aggregation.py

@@ -5,6 +5,9 @@ from __future__ import annotations
 from collections.abc import Callable
 from pathlib import Path
 
+from sqlbuild.compiler.discovery._helpers.filesystem.command_output_sinks import (
+    discover_command_output_sink_functions,
+)
 from sqlbuild.compiler.discovery._helpers.filesystem.core import (
     discover_adapter_file,
     discover_audit_files,
@@ -36,6 +39,7 @@ from sqlbuild.compiler.discovery.models import (
     DiscoveredAssetFunction,
     DiscoveredAuditFile,
     DiscoveredCheckFunction,
+    DiscoveredCommandOutputSink,
     DiscoveredConstantFile,
     DiscoveredEnumFile,
     DiscoveredEventExporter,
@@ -159,6 +163,12 @@ def build_discovered_project_inputs(
         event_exporters: tuple[DiscoveredEventExporter, ...] = discover_event_exporter_functions(
             project_dir=project_dir, providers=providers
         )
+        command_output_sinks: tuple[DiscoveredCommandOutputSink, ...] = (
+            discover_command_output_sink_functions(
+                project_dir=project_dir,
+                providers=providers,
+            )
+        )
         python_paths: set[Path] = {provider.relative_path for provider in providers}
         python_paths.update(node.relative_path for node in python_nodes.loaders)
         python_paths.update(node.relative_path for node in python_nodes.tasks)
@@ -167,6 +177,7 @@ def build_discovered_project_inputs(
         python_paths.update(file.relative_path for file in materialization_files)
         python_paths.update(function.relative_path for function in hook_functions)
         python_paths.update(exporter.relative_path for exporter in event_exporters)
+        python_paths.update(sink.relative_path for sink in command_output_sinks)
         python_lifecycle.completed(metadata={"item_count": len(python_paths)})
     loader_functions: tuple[DiscoveredLoaderFunction, ...] = tuple(
         python_nodes.loaders
@@ -199,6 +210,7 @@ def build_discovered_project_inputs(
         check_functions=check_functions,
         hook_functions=hook_functions,
         event_exporters=event_exporters,
+        command_output_sinks=command_output_sinks,
         providers=providers,
         adapter_file=adapter_file,
     )

sqlbuild-0.82.0/src/sqlbuild/compiler/discovery/_helpers/filesystem/command_output_sinks.py

@@ -0,0 +1,258 @@
+"""Discovery and provider binding for command-output sinks."""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable
+from pathlib import Path
+from types import ModuleType
+from typing import get_type_hints
+
+from sqlbuild.compiler.discovery._helpers.filesystem.core import (
+    _load_sink_module,
+    _provider_by_name,
+    _provider_usages,
+    _public_python_files,
+)
+from sqlbuild.compiler.discovery.exceptions import EventExporterDiscoveryError
+from sqlbuild.compiler.discovery.models import (
+    DiscoveredCommandOutputSink,
+    DiscoveredCommandOutputSinkDeclaration,
+    DiscoveredEventExporter,
+    DiscoveredProvider,
+    DiscoveredProviderUsage,
+)
+from sqlbuild.runtime.output_capture.constants import COMMAND_OUTPUT_SINK_RECORD_PARAMETER_NAME
+from sqlbuild.runtime.output_capture.models import CommandOutputRecord, CommandOutputSinkDefinition
+from sqlbuild.sinks import get_command_output_sink_definition
+
+
+def discover_command_output_sink_functions(
+    *, project_dir: Path, providers: tuple[DiscoveredProvider, ...] = ()
+) -> tuple[DiscoveredCommandOutputSink, ...]:
+    """Discover validated command-output sink declarations under sinks/."""
+
+    from sqlbuild.runtime.event_exporting.main.cached_event_exporter_extensions import (
+        cached_event_exporter_extensions,
+    )
+
+    cached: (
+        tuple[
+            tuple[DiscoveredProvider, ...],
+            tuple[DiscoveredEventExporter, ...],
+            tuple[DiscoveredCommandOutputSink, ...],
+        ]
+        | None
+    ) = cached_event_exporter_extensions(project_dir=project_dir)
+    if cached is not None:
+        return cached[2]
+    declarations: tuple[DiscoveredCommandOutputSinkDeclaration, ...] = (
+        discover_command_output_sink_declarations(project_dir=project_dir)
+    )
+    return bind_command_output_sink_declarations(
+        declarations=declarations,
+        providers=providers,
+        project_dir=project_dir,
+    )
+
+
+def discover_command_output_sink_declarations(
+    *, project_dir: Path
+) -> tuple[DiscoveredCommandOutputSinkDeclaration, ...]:
+    """Import sink modules and collect command-output declarations."""
+
+    sinks_root: Path = project_dir / "sinks"
+    if not sinks_root.is_dir():
+        return ()
+    discovered: list[DiscoveredCommandOutputSinkDeclaration] = []
+    seen_names: dict[str, Path] = {}
+    for file_path in _public_python_files(root=sinks_root):
+        module: ModuleType = _load_sink_module(file_path=file_path, project_dir=project_dir)
+        seen_function_ids: set[int] = set()
+        for _, value in inspect.getmembers(module, inspect.isfunction):
+            if value.__module__ != module.__name__:
+                continue
+            function_id: int = id(value)
+            if function_id in seen_function_ids:
+                continue
+            seen_function_ids.add(function_id)
+            definition: CommandOutputSinkDefinition | None = get_command_output_sink_definition(
+                value
+            )
+            if definition is None:
+                continue
+            existing_path: Path | None = seen_names.get(definition.name)
+            if existing_path is not None:
+                raise EventExporterDiscoveryError(
+                    f"Duplicate command-output sink name '{definition.name}' found in "
+                    f"{existing_path.relative_to(project_dir)} and "
+                    f"{file_path.relative_to(project_dir)}"
+                )
+            _validate_command_output_sink_signature(
+                function=value,
+                sink_name=definition.name,
+                file_path=file_path,
+                project_dir=project_dir,
+            )
+            seen_names[definition.name] = file_path
+            discovered.append(
+                DiscoveredCommandOutputSinkDeclaration(
+                    file_path=file_path,
+                    relative_path=file_path.relative_to(project_dir),
+                    name=definition.name,
+                    function=value,
+                    streams=definition.streams,
+                )
+            )
+    return tuple(discovered)
+
+
+def bind_command_output_sink_declarations(
+    *,
+    declarations: tuple[DiscoveredCommandOutputSinkDeclaration, ...],
+    providers: tuple[DiscoveredProvider, ...],
+    project_dir: Path,
+) -> tuple[DiscoveredCommandOutputSink, ...]:
+    """Validate command-output sink provider parameters."""
+
+    provider_by_name: dict[str, DiscoveredProvider] = _provider_by_name(providers)
+    bound: list[DiscoveredCommandOutputSink] = []
+    for declaration in declarations:
+        usages: tuple[DiscoveredProviderUsage, ...] = _bind_sink_provider_usages(
+            function=declaration.function,
+            sink_name=declaration.name,
+            sink_label="Command-output sink",
+            file_path=declaration.file_path,
+            project_dir=project_dir,
+            provider_by_name=provider_by_name,
+        )
+        bound.append(
+            DiscoveredCommandOutputSink(
+                file_path=declaration.file_path,
+                relative_path=declaration.relative_path,
+                name=declaration.name,
+                function=declaration.function,
+                streams=declaration.streams,
+                provider_usages=usages,
+            )
+        )
+    return tuple(bound)
+
+
+def _validate_command_output_sink_signature(
+    *,
+    function: Callable[..., object],
+    sink_name: str,
+    file_path: Path,
+    project_dir: Path,
+) -> None:
+    relative_path: Path = file_path.relative_to(project_dir)
+    if inspect.iscoroutinefunction(function):
+        raise EventExporterDiscoveryError(
+            f"Command-output sink '{sink_name}' in {relative_path} must be synchronous"
+        )
+    parameters: tuple[inspect.Parameter, ...] = tuple(
+        inspect.signature(function).parameters.values()
+    )
+    if not parameters or parameters[0].name != COMMAND_OUTPUT_SINK_RECORD_PARAMETER_NAME:
+        raise EventExporterDiscoveryError(
+            f"Command-output sink '{sink_name}' in {relative_path} must declare record first"
+        )
+    _validate_sink_parameter_shape(
+        parameters=parameters,
+        sink_name=sink_name,
+        sink_label="Command-output sink",
+        relative_path=relative_path,
+    )
+    try:
+        type_hints: dict[str, object] = get_type_hints(function)
+    except (NameError, TypeError) as error:
+        raise EventExporterDiscoveryError(
+            f"Command-output sink '{sink_name}' in {relative_path} has invalid annotations"
+        ) from error
+    record_annotation: object = type_hints.get("record", parameters[0].annotation)
+    if record_annotation not in {inspect.Parameter.empty, CommandOutputRecord}:
+        raise EventExporterDiscoveryError(
+            f"Command-output sink '{sink_name}' in {relative_path} record must be "
+            "CommandOutputRecord"
+        )
+    _validate_sink_return_annotation(
+        function=function,
+        type_hints=type_hints,
+        sink_name=sink_name,
+        sink_label="Command-output sink",
+        relative_path=relative_path,
+    )
+
+
+def _validate_sink_parameter_shape(
+    *,
+    parameters: tuple[inspect.Parameter, ...],
+    sink_name: str,
+    sink_label: str,
+    relative_path: Path,
+) -> None:
+    if any(
+        parameter.kind
+        in {
+            inspect.Parameter.POSITIONAL_ONLY,
+            inspect.Parameter.VAR_POSITIONAL,
+            inspect.Parameter.VAR_KEYWORD,
+        }
+        for parameter in parameters
+    ):
+        raise EventExporterDiscoveryError(
+            f"{sink_label} '{sink_name}' in {relative_path} must use named parameters"
+        )
+    if any(parameter.default is not inspect.Parameter.empty for parameter in parameters):
+        raise EventExporterDiscoveryError(
+            f"{sink_label} '{sink_name}' in {relative_path} parameters must not have defaults"
+        )
+
+
+def _validate_sink_return_annotation(
+    *,
+    function: Callable[..., object],
+    type_hints: dict[str, object],
+    sink_name: str,
+    sink_label: str,
+    relative_path: Path,
+) -> None:
+    return_annotation: object = type_hints.get(
+        "return", inspect.signature(function).return_annotation
+    )
+    if return_annotation not in {inspect.Signature.empty, None, type(None)}:
+        raise EventExporterDiscoveryError(
+            f"{sink_label} '{sink_name}' in {relative_path} return annotation must be None"
+        )
+
+
+def _bind_sink_provider_usages(
+    *,
+    function: Callable[..., object],
+    sink_name: str,
+    sink_label: str,
+    file_path: Path,
+    project_dir: Path,
+    provider_by_name: dict[str, DiscoveredProvider],
+) -> tuple[DiscoveredProviderUsage, ...]:
+    relative_path: Path = file_path.relative_to(project_dir)
+    parameters: tuple[inspect.Parameter, ...] = tuple(
+        inspect.signature(function).parameters.values()
+    )
+    type_hints: dict[str, object] = get_type_hints(function)
+    for parameter in parameters[1:]:
+        provider: DiscoveredProvider | None = provider_by_name.get(parameter.name)
+        if provider is None:
+            raise EventExporterDiscoveryError(
+                f"{sink_label} '{sink_name}' in {relative_path} requires unknown provider "
+                f"'{parameter.name}'"
+            )
+        annotation: object = type_hints.get(parameter.name, parameter.annotation)
+        if annotation is not inspect.Parameter.empty and annotation is not provider.provider_class:
+            provider_class_name: str = provider.provider_class.__name__
+            raise EventExporterDiscoveryError(
+                f"{sink_label} '{sink_name}' in {relative_path} provider parameter "
+                f"'{parameter.name}' must be unannotated or exactly {provider_class_name}"
+            )
+    return _provider_usages(function=function, provider_by_name=provider_by_name)

{sqlbuild-0.81.2 → sqlbuild-0.82.0}/src/sqlbuild/compiler/discovery/_helpers/filesystem/core.py

@@ -60,6 +60,7 @@ from sqlbuild.compiler.discovery.models import (
     DiscoveredAssetFunction,
     DiscoveredAuditFile,
     DiscoveredCheckFunction,
+    DiscoveredCommandOutputSink,
     DiscoveredConstantFile,
     DiscoveredEnumFile,
     DiscoveredEventExporter,
@@ -96,7 +97,6 @@ from sqlbuild.compiler.scopes.constants import (
     LOCAL_DECLARATION_DIRECTORIES,
 )
 from sqlbuild.compiler.scopes.types import DeclarationKind, ScopeKind
-from sqlbuild.event_exporters import get_event_exporter_definition
 from sqlbuild.observability import LifecycleEvent
 from sqlbuild.provider.exceptions import ProviderInputError
 from sqlbuild.providers import Provider
@@ -115,7 +115,10 @@ from sqlbuild.python_nodes.models import (
     TaskDefinition,
 )
 from sqlbuild.runtime.event_exporting.constants import EVENT_EXPORTER_EVENT_PARAMETER_NAME
-from sqlbuild.runtime.event_exporting.models import EventExporterDefinition
+from sqlbuild.runtime.event_exporting.models import LifecycleEventSinkDefinition
+from sqlbuild.sinks import (
+    get_lifecycle_event_sink_definition,
+)
 from sqlbuild.spec.contracts.models import SchemaModelEntry, SchemaSeedEntry, SourceEntry
 
 _PYTHON_NODE_KIND_FOLDERS: tuple[str, ...] = ("loaders", "tasks", "assets", "checks")
@@ -943,9 +946,14 @@ def discover_provider_classes(*, project_dir: Path) -> tuple[DiscoveredProvider,
         cached_event_exporter_extensions,
     )
 
-    cached: tuple[tuple[DiscoveredProvider, ...], tuple[DiscoveredEventExporter, ...]] | None = (
-        cached_event_exporter_extensions(project_dir=project_dir)
-    )
+    cached: (
+        tuple[
+            tuple[DiscoveredProvider, ...],
+            tuple[DiscoveredEventExporter, ...],
+            tuple[DiscoveredCommandOutputSink, ...],
+        ]
+        | None
+    ) = cached_event_exporter_extensions(project_dir=project_dir)
     if cached is not None:
         return cached[0]
     providers_root: Path = project_dir / "providers"
@@ -996,15 +1004,20 @@ def discover_provider_classes(*, project_dir: Path) -> tuple[DiscoveredProvider,
 def discover_event_exporter_functions(
     *, project_dir: Path, providers: tuple[DiscoveredProvider, ...] = ()
 ) -> tuple[DiscoveredEventExporter, ...]:
-    """Discover validated exporter declarations under event_exporters/."""
+    """Discover validated lifecycle-event sink declarations under sinks/."""
 
     from sqlbuild.runtime.event_exporting.main.cached_event_exporter_extensions import (
         cached_event_exporter_extensions,
     )
 
-    cached: tuple[tuple[DiscoveredProvider, ...], tuple[DiscoveredEventExporter, ...]] | None = (
-        cached_event_exporter_extensions(project_dir=project_dir)
-    )
+    cached: (
+        tuple[
+            tuple[DiscoveredProvider, ...],
+            tuple[DiscoveredEventExporter, ...],
+            tuple[DiscoveredCommandOutputSink, ...],
+        ]
+        | None
+    ) = cached_event_exporter_extensions(project_dir=project_dir)
     if cached is not None:
         return cached[1]
     declarations: tuple[DiscoveredEventExporterDeclaration, ...] = (
@@ -1020,17 +1033,19 @@ def discover_event_exporter_functions(
 def discover_event_exporter_declarations(
     *, project_dir: Path
 ) -> tuple[DiscoveredEventExporterDeclaration, ...]:
-    """Import exporter modules and collect declarations without discovering providers."""
+    """Import sink modules and collect lifecycle declarations without discovering providers."""
 
-    exporters_root: Path = project_dir / "event_exporters"
+    if (project_dir / "event_exporters").exists():
+        raise EventExporterDiscoveryError(
+            "event_exporters/ was replaced by sinks/ and @lifecycle_event_sink"
+        )
+    exporters_root: Path = project_dir / "sinks"
     if not exporters_root.is_dir():
         return ()
     discovered: list[DiscoveredEventExporterDeclaration] = []
     seen_names: dict[str, Path] = {}
     for file_path in _public_python_files(root=exporters_root):
-        module: ModuleType = _load_event_exporter_module(
-            file_path=file_path, project_dir=project_dir
-        )
+        module: ModuleType = _load_sink_module(file_path=file_path, project_dir=project_dir)
         seen_function_ids: set[int] = set()
         for _, value in inspect.getmembers(module, inspect.isfunction):
             if value.__module__ != module.__name__:
@@ -1039,7 +1054,9 @@ def discover_event_exporter_declarations(
             if function_id in seen_function_ids:
                 continue
             seen_function_ids.add(function_id)
-            definition: EventExporterDefinition | None = get_event_exporter_definition(value)
+            definition: LifecycleEventSinkDefinition | None = get_lifecycle_event_sink_definition(
+                value
+            )
             if definition is None:
                 continue
             existing_path: Path | None = seen_names.get(definition.name)
@@ -1666,11 +1683,21 @@ def _load_provider_module(*, file_path: Path, project_dir: Path) -> ModuleType:
     return module
 
 
-def _load_event_exporter_module(*, file_path: Path, project_dir: Path) -> ModuleType:
+def _load_sink_module(*, file_path: Path, project_dir: Path) -> ModuleType:
     module_name: str = ".".join(file_path.relative_to(project_dir).with_suffix("").parts)
+    _evict_stale_project_package_modules(
+        root_module=module_name.split(".", maxsplit=1)[0],
+        project_dir=project_dir,
+    )
+    existing_module: ModuleType | None = sys.modules.get(module_name)
+    if existing_module is not None:
+        existing_file: object = getattr(existing_module, "__file__", None)
+        if isinstance(existing_file, str) and Path(existing_file).resolve() == file_path.resolve():
+            return existing_module
+        sys.modules.pop(module_name, None)
     spec: ModuleSpec | None = importlib.util.spec_from_file_location(module_name, file_path)
     if spec is None or spec.loader is None:
-        raise EventExporterDiscoveryError(f"Could not load event exporter file {file_path}")
+        raise EventExporterDiscoveryError(f"Could not load sink file {file_path}")
     module: ModuleType = importlib.util.module_from_spec(spec)
     old_path: list[str] = list(sys.path)
     sys.path.insert(0, str(project_dir))
@@ -1679,7 +1706,7 @@ def _load_event_exporter_module(*, file_path: Path, project_dir: Path) -> Module
         spec.loader.exec_module(module)
     except Exception as error:
         raise EventExporterDiscoveryError(
-            f"Failed to import event exporter file {file_path.relative_to(project_dir)}: {error}"
+            f"Failed to import sink file {file_path.relative_to(project_dir)}: {error}"
         ) from error
     finally:
         sys.path = old_path