sqlbuild 0.39.3__tar.gz → 0.40.1__tar.gz

sqlbuild-0.40.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.40.1"
+}

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.40.1](https://github.com/chio-labs/sqlbuild/compare/v0.40.0...v0.40.1) (2026-06-24)
+
+
+### Bug Fixes
+
+* **dbt:** batch model relation planning checks ([ffa4b90](https://github.com/chio-labs/sqlbuild/commit/ffa4b906f94660566b1c54b033031f8dab231c6a))
+* **dbt:** batch model relation planning checks ([3d88523](https://github.com/chio-labs/sqlbuild/commit/3d885238efe7f0e71ae5bc60b94a812f823b5f7e))
+
+## [0.40.0](https://github.com/chio-labs/sqlbuild/compare/v0.39.3...v0.40.0) (2026-06-24)
+
+
+### Features
+
+* align reuse policy across native and dbt ([6ef4b8d](https://github.com/chio-labs/sqlbuild/commit/6ef4b8dd08ddc241cde1aaaaa455ff22c977e655))
+* align reuse policy across native and dbt ([d50f9f8](https://github.com/chio-labs/sqlbuild/commit/d50f9f868b7102ff15144b7d896197348f81eb56))
+
 ## [0.39.3](https://github.com/chio-labs/sqlbuild/compare/v0.39.2...v0.39.3) (2026-06-24)
 
 

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.39.3
+Version: 0.40.1
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/pyproject.toml

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

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/cli/commands/main/build.py

@@ -112,6 +112,8 @@ def run_build(
     run_audits: bool = True,
     json_output: bool = False,
     json_output_path: Path | None = None,
+    strict_reuse: bool | None = None,
+    trust_reuse_inputs: bool | None = None,
 ) -> int:
     """Execute the build command."""
 
@@ -221,6 +223,8 @@ def run_build(
                 discovered_inputs=discovered_inputs,
             ),
             resolve_python_run_selectors=include_python or should_load_sources,
+            strict_reuse=strict_reuse,
+            trust_reuse_inputs=trust_reuse_inputs,
         )
 
         plan_output: PlanOutput = pipeline_result.plan_output

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/cli/commands/main/entry.py

@@ -26,6 +26,7 @@ from sqlbuild.cli.commands.main.shared.helpers.config.parsers import (
     add_dbt_config_args,
     add_execution_args,
     add_execution_json_output_arg,
+    add_reuse_args,
     add_scenario_snapshot_safety_args,
     add_select_args,
     add_vars_args,
@@ -130,6 +131,7 @@ def _build_parser(*, use_color: bool = False) -> argparse.ArgumentParser:
     plan_load_group.add_argument("--load", dest="load_sources", action="store_true", default=None)
     plan_load_group.add_argument("--no-load", dest="load_sources", action="store_false")
     add_cursor_override_args(plan_parser)
+    add_reuse_args(plan_parser)
     add_select_args(plan_parser)
     add_vars_args(plan_parser)
     add_dbt_config_args(plan_parser)
@@ -159,6 +161,7 @@ def _build_parser(*, use_color: bool = False) -> argparse.ArgumentParser:
     build_load_group.add_argument("--no-load", dest="load_sources", action="store_false")
     build_load_group.add_argument("--reload", dest="reload", action="store_true", default=False)
     add_execution_args(build_parser)
+    add_reuse_args(build_parser)
     add_select_args(build_parser)
     add_vars_args(build_parser)
     add_dbt_config_args(build_parser)
@@ -703,6 +706,8 @@ def _main_with_dependencies(
                 args.vars,
                 args.include_stale_upstreams,
                 args.force,
+                args.strict_reuse,
+                args.trust_reuse_inputs,
             )
         if args.command == CliCommand.DBT:
             if args.dbt_command == "init":
@@ -775,6 +780,8 @@ def _main_with_dependencies(
                 args.run_audits,
                 args.json,
                 args.json_output,
+                args.strict_reuse,
+                args.trust_reuse_inputs,
             )
         if args.command == CliCommand.FRESHNESS:
             return handlers.run_freshness(

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/cli/commands/main/helpers/entry/models.py

@@ -56,6 +56,8 @@ class CliNamespace:
     skip_locked: bool = False
     include_stale_upstreams: bool = False
     force: bool = False
+    strict_reuse: bool | None = None
+    trust_reuse_inputs: bool | None = None
     include_python: bool = True
     load_sources: bool | None = None
     reload: bool = False
@@ -166,6 +168,8 @@ class CliEntrypointHandlers:
             dict[str, object],
             bool,
             bool,
+            bool | None,
+            bool | None,
         ],
         int,
     ]
@@ -222,6 +226,8 @@ class CliEntrypointHandlers:
             bool,
             bool,
             Path | None,
+            bool | None,
+            bool | None,
         ],
         int,
     ]

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/cli/commands/main/helpers/plan/formatter.py

@@ -12,6 +12,7 @@ from sqlbuild.compiler.pipeline.models import PythonPlanEntry
 from sqlbuild.compiler.planner.models import (
     CascadeResult,
     DependencyBaselinePlanEntry,
+    ExistingDestinationInputPlanEntry,
     FunctionPlanEntry,
     ModelPlanEntry,
     PlanOutput,
@@ -163,6 +164,13 @@ def format_plan(
         display_options=resolved_display_options,
         section_header_style=resolved_section_header_style,
     )
+    _format_existing_destination_input_entries(
+        lines,
+        plan.existing_destination_input_entries,
+        name_column_width=name_column_width,
+        display_options=resolved_display_options,
+        section_header_style=resolved_section_header_style,
+    )
 
     normal: list[ModelPlanEntry] = _collect_normal(active)
     cascade: list[ModelPlanEntry] = _collect_upstream_changed(active)
@@ -360,11 +368,47 @@ def _format_dependency_baseline_entries(
     name_column_width: int,
     display_options: DisplayOptions,
     section_header_style: Callable[[str], str],
+) -> None:
+    if not entries:
+        return
+    trusted_entries: tuple[DependencyBaselinePlanEntry, ...] = tuple(
+        entry for entry in entries if entry.trusted_input
+    )
+    reused_entries: tuple[DependencyBaselinePlanEntry, ...] = tuple(
+        entry for entry in entries if not entry.trusted_input
+    )
+
+    _format_reuse_input_entries(
+        lines,
+        reused_entries,
+        label="Reused inputs",
+        name_column_width=name_column_width,
+        display_options=display_options,
+        section_header_style=section_header_style,
+    )
+    _format_reuse_input_entries(
+        lines,
+        trusted_entries,
+        label="Trusted inputs",
+        name_column_width=name_column_width,
+        display_options=display_options,
+        section_header_style=section_header_style,
+    )
+
+
+def _format_reuse_input_entries(
+    lines: list[str],
+    entries: tuple[DependencyBaselinePlanEntry, ...],
+    *,
+    label: str,
+    name_column_width: int,
+    display_options: DisplayOptions,
+    section_header_style: Callable[[str], str],
 ) -> None:
     if not entries:
         return
     lines.append("")
-    lines.append(section_header_style(f"Dependency baseline ({len(entries)})"))
+    lines.append(section_header_style(f"{label} ({len(entries)})"))
     visible: Sequence[DependencyBaselinePlanEntry] = visible_entries(
         entries, options=display_options
     )
@@ -374,7 +418,7 @@ def _format_dependency_baseline_entries(
             "  "
             + _format_name_value_line(
                 entry.name,
-                f"{entry.resource_label}  baseline reuse",
+                _reuse_input_detail(entry),
                 name_column_width=name_column_width,
             )
         )
@@ -387,6 +431,57 @@ def _format_dependency_baseline_entries(
     )
 
 
+def _reuse_input_detail(entry: DependencyBaselinePlanEntry) -> str:
+    copy_kind: str = "hard-copy" if entry.relation_reuse.hard_copy else "cheap clone"
+    detail: str = f"{entry.resource_label}  {copy_kind} from reuse origin target"
+    if entry.trusted_input and entry.current_project_affected:
+        return f"{detail}, trusted despite current-project change"
+    if entry.trusted_input:
+        return f"{detail}, trusted despite identity mismatch"
+    return detail
+
+
+def _format_existing_destination_input_entries(
+    lines: list[str],
+    entries: tuple[ExistingDestinationInputPlanEntry, ...],
+    *,
+    name_column_width: int,
+    display_options: DisplayOptions,
+    section_header_style: Callable[[str], str],
+) -> None:
+    if not entries:
+        return
+    lines.append("")
+    lines.append(section_header_style(f"Existing destination inputs ({len(entries)})"))
+    visible: Sequence[ExistingDestinationInputPlanEntry] = visible_entries(
+        entries, options=display_options
+    )
+    entry: ExistingDestinationInputPlanEntry
+    for entry in visible:
+        lines.append(
+            "  "
+            + _format_name_value_line(
+                entry.name,
+                _existing_destination_input_detail(entry),
+                name_column_width=name_column_width,
+            )
+        )
+    append_overflow_line(
+        lines,
+        total_count=len(entries),
+        visible_count=len(visible),
+        indent="  ",
+        options=display_options,
+    )
+
+
+def _existing_destination_input_detail(entry: ExistingDestinationInputPlanEntry) -> str:
+    detail: str = f"{entry.status} in destination target"
+    if entry.current_project_affected:
+        return f"{detail}, affected by current-project change"
+    return detail
+
+
 def _plan_ready_header(
     *,
     selected_count: int,

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/cli/commands/main/plan.py

@@ -54,6 +54,8 @@ def run_plan(
     cli_vars: dict[str, object] | None = None,
     include_stale_upstreams: bool = False,
     force: bool = False,
+    strict_reuse: bool | None = None,
+    trust_reuse_inputs: bool | None = None,
 ) -> int:
     """Execute the plan command."""
 
@@ -154,6 +156,8 @@ def run_plan(
             on_progress=planning_progress.on_progress,
             external_sql_reference_resolver=external_sql_reference_resolver,
             resolve_python_run_selectors=include_python,
+            strict_reuse=strict_reuse,
+            trust_reuse_inputs=trust_reuse_inputs,
         )
 
     plan_output: PlanOutput = pipeline_result.plan_output

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/cli/commands/main/shared/helpers/config/parsers.py

@@ -95,6 +95,47 @@ def add_execution_json_output_arg(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--json-output", type=Path, default=None)
 
 
+def add_reuse_args(parser: argparse.ArgumentParser) -> None:
+    """Add standard reuse behavior override flags."""
+
+    strict_group: argparse._MutuallyExclusiveGroup = parser.add_mutually_exclusive_group()
+    strict_group.add_argument(
+        "--strict-reuse",
+        dest="strict_reuse",
+        action="store_true",
+        help=(
+            "Require exact identity matches before reusing relations from the reuse origin target."
+        ),
+    )
+    strict_group.add_argument(
+        "--no-strict-reuse",
+        dest="strict_reuse",
+        action="store_false",
+        help=(
+            "Allow default reuse: ignore reuse-origin-target drift while still respecting "
+            "current-project changes."
+        ),
+    )
+    parser.set_defaults(strict_reuse=None)
+    trust_group: argparse._MutuallyExclusiveGroup = parser.add_mutually_exclusive_group()
+    trust_group.add_argument(
+        "--trust-reuse-inputs",
+        dest="trust_reuse_inputs",
+        action="store_true",
+        help=(
+            "Clone direct input relations from the reuse origin target even when identity does "
+            "not match. Useful for fast dev hydration; may mask upstream current-project changes."
+        ),
+    )
+    trust_group.add_argument(
+        "--no-trust-reuse-inputs",
+        dest="trust_reuse_inputs",
+        action="store_false",
+        help="Do not clone direct inputs that could mask current-project changes.",
+    )
+    parser.set_defaults(trust_reuse_inputs=None)
+
+
 def add_select_args(parser: argparse.ArgumentParser) -> None:
     """Add --select and --exclude flags for scope selection."""
 

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/cli/commands/main/shared/helpers/output/execution_json.py

@@ -8,7 +8,12 @@ from pathlib import Path
 
 from sqlbuild.compiler.auditing.types import AuditOutcome
 from sqlbuild.compiler.compile.types import CompiledResourceType
-from sqlbuild.compiler.planner.models import ModelPlanEntry, PlanOutput
+from sqlbuild.compiler.planner.models import (
+    DependencyBaselinePlanEntry,
+    ExistingDestinationInputPlanEntry,
+    ModelPlanEntry,
+    PlanOutput,
+)
 from sqlbuild.compiler.python_nodes.types import PythonNodeStatus
 from sqlbuild.executor.auditing.models import AuditExecutionResult
 from sqlbuild.executor.build.models import (
@@ -108,6 +113,7 @@ def format_build_execution_json(
             "python_check_warn_count": python_check_warn_count,
             "python_check_fail_count": python_check_fail_count,
         },
+        reuse=_format_reuse_summary(plan),
     )
 
 
@@ -150,6 +156,7 @@ def format_run_execution_json(
             "skipped_count": result.skipped_count + python_skipped_count,
             "warning_count": result.warning_count,
         },
+        reuse=_format_reuse_summary(plan),
     )
 
 
@@ -287,6 +294,7 @@ def _format_execution_json(
     checks: tuple[dict[str, object], ...],
     summary: dict[str, object],
     scenarios: tuple[dict[str, object], ...] = (),
+    reuse: dict[str, object] | None = None,
 ) -> str:
     payload: dict[str, object] = {
         "version": _JSON_VERSION,
@@ -296,6 +304,8 @@ def _format_execution_json(
         "assets": assets,
         "checks": checks,
     }
+    if reuse is not None:
+        payload["reuse"] = reuse
     if scenarios:
         payload["scenarios"] = scenarios
     return json.dumps(payload, indent=2) + "\n"
@@ -349,6 +359,64 @@ def _format_relation_reuse(entry: ModelPlanEntry | None) -> dict[str, object] |
     }
 
 
+def _format_reuse_summary(plan: PlanOutput) -> dict[str, object]:
+    return {
+        "cloned_selected": tuple(
+            _format_cloned_selected_entry(entry)
+            for entry in plan.model_entries
+            if entry.relation_reuse is not None
+        ),
+        "reused_inputs": tuple(
+            _format_dependency_input_entry(entry)
+            for entry in plan.dependency_baseline_entries
+            if not entry.trusted_input
+        ),
+        "trusted_inputs": tuple(
+            _format_dependency_input_entry(entry)
+            for entry in plan.dependency_baseline_entries
+            if entry.trusted_input
+        ),
+        "existing_destination_inputs": tuple(
+            _format_existing_destination_input_entry(entry)
+            for entry in plan.existing_destination_input_entries
+        ),
+    }
+
+
+def _format_cloned_selected_entry(entry: ModelPlanEntry) -> dict[str, object]:
+    return {
+        "name": entry.name,
+        "materialization_type": entry.materialization_type.value,
+        "relation_reuse": _format_relation_reuse(entry),
+    }
+
+
+def _format_dependency_input_entry(entry: DependencyBaselinePlanEntry) -> dict[str, object]:
+    return {
+        "name": entry.name,
+        "resource_label": entry.resource_label,
+        "destination": entry.destination.qualified_name,
+        "reuse_from_target": entry.relation_reuse.reuse_from_target_name,
+        "origin_relation": entry.relation_reuse.origin.qualified_name,
+        "hard_copy": entry.relation_reuse.hard_copy,
+        "trusted_input": entry.trusted_input,
+        "current_project_affected": entry.current_project_affected,
+    }
+
+
+def _format_existing_destination_input_entry(
+    entry: ExistingDestinationInputPlanEntry,
+) -> dict[str, object]:
+    return {
+        "name": entry.name,
+        "destination": entry.destination.qualified_name,
+        "status": entry.status,
+        "expected_version_hash": entry.expected_version_hash,
+        "destination_version_hash": entry.destination_version_hash,
+        "current_project_affected": entry.current_project_affected,
+    }
+
+
 def _format_seed_assets(
     *, results: tuple[SeedExecutionResult, ...], plan: PlanOutput | None
 ) -> tuple[dict[str, object], ...]:

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/cli/commands/main/shared/helpers/output/json.py

@@ -10,6 +10,7 @@ from sqlbuild.compiler.pipeline.models import ProjectGraph, PythonPlanEntry
 from sqlbuild.compiler.planner.models import (
     CascadeResult,
     DependencyBaselinePlanEntry,
+    ExistingDestinationInputPlanEntry,
     FunctionPlanEntry,
     ModelPlanEntry,
     PlanOutput,
@@ -56,6 +57,11 @@ def format_plan_json(
         "python_node_count": len(python_nodes),
         "models": models,
         "dependency_baseline_models": dependency_baseline_models,
+        "existing_destination_inputs": [
+            _serialize_existing_destination_input_entry(e)
+            for e in plan.existing_destination_input_entries
+        ],
+        "reuse": _serialize_reuse_summary(plan),
         "seeds": seeds,
         "source_loads": source_loads,
         "functions": functions,
@@ -78,12 +84,53 @@ def _serialize_dependency_baseline_entry(
         "reuse_from_target": entry.relation_reuse.reuse_from_target_name,
         "origin_relation": entry.relation_reuse.origin.qualified_name,
         "hard_copy": entry.relation_reuse.hard_copy,
+        "trusted_input": entry.trusted_input,
+        "current_project_affected": entry.current_project_affected,
     }
     if entry.fingerprint_version_hash is not None:
         result["fingerprint_version_hash"] = entry.fingerprint_version_hash
     return result
 
 
+def _serialize_existing_destination_input_entry(
+    entry: ExistingDestinationInputPlanEntry,
+) -> dict[str, object]:
+    return {
+        "name": entry.name,
+        "destination": entry.destination.qualified_name,
+        "status": entry.status,
+        "expected_version_hash": entry.expected_version_hash,
+        "destination_version_hash": entry.destination_version_hash,
+        "current_project_affected": entry.current_project_affected,
+    }
+
+
+def _serialize_reuse_summary(plan: PlanOutput) -> dict[str, object]:
+    reused_inputs: list[dict[str, object]] = [
+        _serialize_dependency_baseline_entry(entry)
+        for entry in plan.dependency_baseline_entries
+        if not entry.trusted_input
+    ]
+    trusted_inputs: list[dict[str, object]] = [
+        _serialize_dependency_baseline_entry(entry)
+        for entry in plan.dependency_baseline_entries
+        if entry.trusted_input
+    ]
+    return {
+        "cloned_selected": [
+            _serialize_model_entry(entry)
+            for entry in plan.model_entries
+            if entry.relation_reuse is not None
+        ],
+        "reused_inputs": reused_inputs,
+        "trusted_inputs": trusted_inputs,
+        "existing_destination_inputs": [
+            _serialize_existing_destination_input_entry(entry)
+            for entry in plan.existing_destination_input_entries
+        ],
+    }
+
+
 def format_compile_json(plan: PlanOutput) -> str:
     """Serialize compile output to JSON."""
 

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/compiler/pipeline/main/compile.py

@@ -82,6 +82,8 @@ def run_compile_pipeline(
     on_progress: Callable[[str], None] | None = None,
     external_sql_reference_resolver: ExternalSqlReferenceResolver | None = None,
     resolve_python_run_selectors: bool = False,
+    strict_reuse: bool | None = None,
+    trust_reuse_inputs: bool | None = None,
 ) -> CompilePipelineResult:
     """Run compile inputs, assembly, planning, and manifest generation."""
 
@@ -127,6 +129,8 @@ def run_compile_pipeline(
             on_progress=on_progress,
             external_sql_reference_resolver=external_sql_reference_resolver,
             resolve_python_run_selectors=resolve_python_run_selectors,
+            strict_reuse=strict_reuse,
+            trust_reuse_inputs=trust_reuse_inputs,
         )
     finally:
         adapter.close(connection)
@@ -152,6 +156,8 @@ def _build_result(
     on_progress: Callable[[str], None] | None = None,
     external_sql_reference_resolver: ExternalSqlReferenceResolver | None = None,
     resolve_python_run_selectors: bool = False,
+    strict_reuse: bool | None = None,
+    trust_reuse_inputs: bool | None = None,
 ) -> CompilePipelineResult:
     if on_progress is not None:
         on_progress("Compiling project...")
@@ -229,6 +235,8 @@ def _build_result(
         defer_sources_to=defer_sources_to,
         source_deferral_enabled=source_deferral_enabled,
         custom_prepare_version_materializations=frozenset(custom_prepare_version_functions.keys()),
+        strict_reuse=strict_reuse,
+        trust_reuse_inputs=trust_reuse_inputs,
     )
     loaded_macros: dict[str, LoadedMacro] = load_macros(discovered_inputs.macro_files)
     manifest: dict[str, object] = build_manifest(

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/compiler/planner/helpers/output/plan_entry.py

@@ -90,6 +90,12 @@ _MODELS_DIR_PREFIX: str = "models/"
 _IDEMPOTENT_MICROBATCH_STRATEGIES: frozenset[IncrementalStrategy] = frozenset(
     (IncrementalStrategy.DELETE_INSERT, IncrementalStrategy.MERGE)
 )
+_REUSABLE_DECISION_KINDS: frozenset[str] = frozenset(
+    {
+        StandardReuseDecisionKind.REUSE_ELIGIBLE.value,
+        StandardReuseDecisionKind.TRUSTED_REUSE_ELIGIBLE.value,
+    }
+)
 
 
 def build_planner_relations_context(
@@ -345,7 +351,7 @@ def _can_use_relation_reuse(
 ) -> bool:
     if reuse_decision is None:
         return False
-    if reuse_decision.decision != StandardReuseDecisionKind.REUSE_ELIGIBLE.value:
+    if reuse_decision.decision not in _REUSABLE_DECISION_KINDS:
         return False
     return entry.materialization_type == MaterializationType.TABLE
 
@@ -373,7 +379,7 @@ def _can_use_seeded_relation_reuse(
 ) -> bool:
     if reuse_decision is None:
         return False
-    if reuse_decision.decision != StandardReuseDecisionKind.REUSE_ELIGIBLE.value:
+    if reuse_decision.decision not in _REUSABLE_DECISION_KINDS:
         return False
     return entry.materialization_type in {
         MaterializationType.INCREMENTAL,
@@ -389,7 +395,7 @@ def _can_use_custom_relation_reuse(
 ) -> bool:
     if reuse_decision is None:
         return False
-    if reuse_decision.decision != StandardReuseDecisionKind.REUSE_ELIGIBLE.value:
+    if reuse_decision.decision not in _REUSABLE_DECISION_KINDS:
         return False
     return (
         entry.materialization_type == MaterializationType.CUSTOM

{sqlbuild-0.39.3 → sqlbuild-0.40.1}/src/sqlbuild/compiler/planner/helpers/output/plan_output.py

@@ -31,6 +31,7 @@ from sqlbuild.compiler.planner.helpers.sql_tests.assembly import plan_test
 from sqlbuild.compiler.planner.models import (
     AuditPlanEntry,
     DependencyBaselinePlanEntry,
+    ExistingDestinationInputPlanEntry,
     FunctionChangeResult,
     FunctionPlanEntry,
     ModelPlanEntry,
@@ -62,6 +63,7 @@ def build_plan_output(
     model_entry_results: PlannerModelEntryResults,
     reload_sources: bool,
     dependency_baseline_entries: tuple[DependencyBaselinePlanEntry, ...] = (),
+    existing_destination_input_entries: tuple[ExistingDestinationInputPlanEntry, ...] = (),
     seed_version_hashes: dict[str, str] | None = None,
     seed_metadata_jsons: dict[str, str] | None = None,
     seed_plan_reasons: dict[str, PlanReason] | None = None,
@@ -135,6 +137,7 @@ def build_plan_output(
         execution_order=scoped_order,
         model_entries=model_entry_results.entries,
         dependency_baseline_entries=dependency_baseline_entries,
+        existing_destination_input_entries=existing_destination_input_entries,
         seed_entries=tuple(seed_entries),
         source_load_entries=tuple(source_load_entries),
         function_entries=tuple(function_entries),