Merge remote-tracking branch 'origin/main' into feat/ui-live-shell

# Conflicts:
#	crates/sqlbuild-orchestration/src/authorization/main/authorize_person.rs
#	crates/sqlbuild-orchestration/tests/api/test_denials.rs

Author: kvlonge

.github/workflows/verify.yml

@@ -773,26 +773,14 @@ jobs:
         run: uv python install 3.12
       - name: Install dependencies
         run: uv sync --locked --all-groups --all-extras
-      - name: Run dense all-rules and delta edit-loop guards under 4 GiB
+      # Each timed compile runs in its own 4 GiB transient scope; pytest stays outside it.
+      - name: Run dense all-rules and delta edit-loop guards with each compile under 4 GiB
         env:
           BENCHMARK_MODELS: ${{ matrix.models }}
-          MEMORY_LIMIT_BYTES: "4294967296"
+          SQLBUILD_COMPILE_MEMORY_LIMIT_BYTES: "4294967296"
         run: |
-          sudo systemd-run \
-            --unit="sqlbuild-dense-${BENCHMARK_MODELS}-${GITHUB_RUN_ID}" \
-            --uid="$(id -u)" \
-            --gid="$(id -g)" \
-            --same-dir \
-            --setenv="HOME=${HOME}" \
-            --setenv="PATH=${PATH}" \
-            --setenv="SQLBUILD_REQUIRE_MEMORY_LIMIT_BYTES=${MEMORY_LIMIT_BYTES}" \
-            --property="MemoryMax=${MEMORY_LIMIT_BYTES}" \
-            --property="MemorySwapMax=0" \
-            --wait \
-            --collect \
-            --pipe \
-            make test-e2e-dense-compile-performance \
-              SQLBUILD_BENCHMARK_MODELS="${BENCHMARK_MODELS}"
+          make test-e2e-dense-compile-performance \
+            SQLBUILD_BENCHMARK_MODELS="${BENCHMARK_MODELS}"
 
       - name: Run diagnostic-heavy compile guards
         if: matrix.models == 1000

Makefile

@@ -334,7 +334,7 @@ test-e2e-dense-compile-performance:
 		-n auto --dist loadfile \
 		-m cold_compile_performance -k "models_$(SQLBUILD_BENCHMARK_MODELS)_" \
 		-vv -rP --log-level=INFO --log-cli-level=INFO --color=yes
-# DuckShop 10K runs after the dense guards, alone, so it never shares the memory limit with them.
+# DuckShop 10K runs after the dense guards, alone, so its compile never overlaps theirs.
 	if [ "$(SQLBUILD_BENCHMARK_MODELS)" = "10000" ]; then \
 		env PYTHONUNBUFFERED=1 uv run pytest benchmarks/duckshop-10k/tests -q --color=yes && \
 		env PYTHONUNBUFFERED=1 SQLBUILD_CONCURRENCY=4 uv run pytest \

benchmarks/duckshop/edge_cases/orchestration/shared_inline_audits.json

@@ -0,0 +1,15 @@
+{
+  "description": "Two models attach the same inline audit to a column of the same name, and the same explicitly named audit. Each attachment is its own snapshot node.",
+  "files": {
+    "sqlbuild_project.toml": "name = \"orders\"\nadapter = \"duckdb\"\n[connections.local]\ndatabase = \"warehouse.duckdb\"\n[targets.development]\nschema = \"main\"\n",
+    "models/orders.sql": "MODEL (\n  materialized table,\n  description \"Synthetic rows.\",\n  columns (id (audits [not_null, unique, accepted_values (name \"id_known\", values [1, 2])])),\n);\n\nSELECT 1 AS id\n",
+    "models/customers.sql": "MODEL (\n  materialized table,\n  description \"Synthetic rows.\",\n  columns (id (audits [not_null, accepted_values (name \"id_known\", values [1, 2])])),\n);\n\nSELECT 2 AS id\n"
+  },
+  "expected_audits": [
+    "audit:id_known:model:customers:id",
+    "audit:id_known:model:orders:id",
+    "audit:not_null:model:customers:id",
+    "audit:not_null:model:orders:id",
+    "audit:unique:model:orders:id"
+  ]
+}

crates/sqlbuild-orchestration/tests/platform/helpers.rs

@@ -141,19 +141,28 @@ pub(crate) async fn receive_webhook(
     )
 }
 
+/// Wait for `count` deliveries: fail after a minute without progress or ten minutes in total.
 pub(crate) async fn wait_for_webhook(
     receiver: &WebhookReceiver,
     dispatcher: &JoinHandle<Result<(), ControlError>>,
     count: usize,
 ) {
     let mut delivered = receiver.delivered.subscribe();
-    tokio::time::timeout(
-        Duration::from_secs(10),
-        delivered.wait_for(|received| *received >= count),
-    )
+    tokio::time::timeout(Duration::from_secs(600), async {
+        for _ in 0..count {
+            let seen = *delivered.borrow_and_update();
+            tokio::time::timeout(
+                Duration::from_secs(60),
+                delivered.wait_for(|received| *received > seen || *received >= count),
+            )
+            .await
+            .expect("dispatcher keeps delivering across bounded pages")
+            .expect("webhook receiver remains available");
+        }
+    })
     .await
-    .expect("dispatcher drains more than one bounded page")
-    .expect("webhook receiver remains available");
+    .expect("dispatcher delivers every event within ten minutes");
+    assert!(*delivered.borrow() >= count, "every event delivered");
     assert!(
         !dispatcher.is_finished(),
         "delivery loop stopped before draining"

crates/sqlbuild-orchestration/tests/runs/test_claims.rs

@@ -18,6 +18,7 @@ use crate::runs::tests::terminal_helpers::finish;
 use crate::runs::tests::test_types::{
     BacklogClaimTestCase, GroupLimitTestCase, PriorityClaimsTestCase, ScopedClaimTestCase,
 };
+use crate::store::tests::lease_helpers::extend_lease_through_test;
 use crate::store::tests::replica_helpers::second_store;
 use crate::store::tests::store_helpers::{close_store, close_test_store, open_test_store, run};
 use crate::store::tests::store_test_types::Backend;
@@ -399,23 +400,19 @@ fn given_more_than_one_page_of_blocked_runs_when_claiming_then_lower_priority_in
                 .await
                 .expect("snapshot");
             let scope = (location, published.snapshot_id);
-            let mut lease = acquire_lease(store, Uuid::now_v7())
+            let elected = acquire_lease(store, Uuid::now_v7())
                 .await
                 .expect("elect")
                 .expect("leader");
+            let lease = extend_lease_through_test(store, elected).await;
             let limits = BTreeMap::new();
             queue(store, &request(scope, 1, 0, &["orders"])).await;
             claim_next_run(store, &lease, &limits, None)
                 .await
                 .expect("claim blocker")
                 .expect("available");
-            for batch in (2..=104).collect::<Vec<_>>().chunks(20) {
-                for id in batch {
-                    queue(store, &request(scope, *id, 0, &["orders"])).await;
-                }
-                lease = crate::scheduler::main::renew_lease::renew_lease(store, &lease)
-                    .await
-                    .expect("keep leader live while preparing backlog");
+            for id in 2..=104 {
+                queue(store, &request(scope, id, 0, &["orders"])).await;
             }
             queue(store, &request(scope, 105, -1, &["customers"])).await;
             let started = std::time::Instant::now();

crates/sqlbuild-orchestration/tests/runs/test_group_admission.rs

@@ -22,6 +22,7 @@ use crate::runs::tests::test_types::{
     AdmissionParent, GroupAdmissionTestCase, GroupChildLimitTestCase, GroupQueueTestCase,
     MixedAdmissionTestCase, RunLifecycleTestCase,
 };
+use crate::store::tests::lease_helpers::extend_lease_through_test;
 use crate::store::tests::replica_helpers::second_store;
 use crate::store::tests::store_helpers::{close_store, close_test_store, open_test_store, run};
 use crate::store::tests::store_test_types::Backend;
@@ -802,10 +803,11 @@ fn given_a_large_healthy_project_with_blocked_groups_when_claiming_then_unrelate
             let published = publish_snapshot(store, &input)
                 .await
                 .expect("publish large project");
-            let lease = acquire_lease(store, Uuid::now_v7())
+            let elected = acquire_lease(store, Uuid::now_v7())
                 .await
                 .expect("elect")
                 .expect("leader");
+            let lease = extend_lease_through_test(store, elected).await;
             let limits = BTreeMap::from([("warehouse".into(), NonZeroU32::new(1).expect("one"))]);
             let scope = (location, "development");
             let mut physical = request((location, published.snapshot_id), 1, 10, &["products"]);

crates/sqlbuild-orchestration/tests/runs/test_monitor.rs

@@ -9,7 +9,6 @@ use crate::runs::main::heartbeat_run::heartbeat_run;
 use crate::runs::main::list_runs::list_runs;
 use crate::runs::main::monitor_runs::monitor_runs;
 use crate::runs::models::{RunAuthority, RunChange, RunChangeRequest, RunOutcome, RunStatus};
-use crate::scheduler::main::renew_lease::renew_lease;
 use crate::scheduler::models::SchedulerState;
 use crate::scheduler::tests::contracts::helpers::{acquire_lease, scheduler_cycle};
 use crate::snapshots::main::publish_snapshot::publish_snapshot;
@@ -25,7 +24,7 @@ use crate::runs::tests::test_types::{
     MonitorBacklogTestCase, RunMonitorTestCase, TransactionFault,
 };
 use crate::store::tests::fault_helpers::{install_fault, remove_fault};
-use crate::store::tests::lease_helpers::expire_lease;
+use crate::store::tests::lease_helpers::{expire_lease, extend_lease_through_test};
 use crate::store::tests::store_helpers::{close_test_store, open_test_store, run};
 use crate::store::tests::store_test_types::Backend;
 
@@ -287,10 +286,11 @@ fn given_a_silent_worker_backlog_when_monitoring_then_bounded_transactions_conti
                 .await
                 .expect("snapshot");
             let holder = Uuid::now_v7();
-            let mut lease = acquire_lease(store, holder)
+            let elected = acquire_lease(store, holder)
                 .await
                 .expect("elect")
                 .expect("leader");
+            let lease = extend_lease_through_test(store, elected).await;
             for index in 0..test_case.run_count {
                 let mut input = request(
                     (location, published.snapshot_id),
@@ -301,9 +301,6 @@ fn given_a_silent_worker_backlog_when_monitoring_then_bounded_transactions_conti
                 input.write_set.clear();
                 start_run(store, &lease, &input).await;
                 age_heartbeat(store, input.run_id, 50).await;
-                lease = renew_lease(store, &lease)
-                    .await
-                    .expect("renew during setup");
             }
             expire_lease(store).await;
             let mut state = SchedulerState::new(holder);

crates/sqlbuild-orchestration/tests/scheduler/ticks/helpers.rs

@@ -619,9 +619,12 @@ pub(crate) async fn fault_run(
             .0;
     }
     let settled = Utc::now();
-    scheduler_cycle(&second, survivor)
-        .await
-        .expect("final recovery");
+    for _ in 0..FAULT_TRIGGERS.div_ceil(100) {
+        survivor = scheduler_cycle(&second, survivor)
+            .await
+            .expect("final recovery")
+            .0;
+    }
     let first = started
         .duration_trunc(TimeDelta::minutes(1))
         .expect("minute")

crates/sqlbuild-orchestration/tests/sensors/test_execution_bounds.rs

@@ -15,7 +15,6 @@ use crate::runs::main::{
 use crate::runs::models::{
     JobRunRequest, NodeOutcome, RunAuthority, RunChange, RunChangeRequest, RunOutcome,
 };
-use crate::scheduler::main::renew_lease::renew_lease;
 use crate::scheduler::tests::contracts::helpers::acquire_lease;
 use crate::sensors::main::{
     begin_sensor_evaluation::begin_sensor_evaluation,
@@ -25,6 +24,7 @@ use crate::sensors::tests::helpers::snapshot;
 use crate::sensors::tests::test_types::SensorTestCase;
 use crate::snapshots::main::publish_snapshot::publish_snapshot;
 use crate::store::main::migrate_store::migrate_store;
+use crate::store::tests::lease_helpers::extend_lease_through_test;
 use crate::store::tests::store_helpers::{close_test_store, open_test_store, run};
 use crate::store::tests::store_test_types::Backend;
 
@@ -79,10 +79,11 @@ fn given_a_wide_group_when_only_the_last_node_has_not_started_then_all_chunks_mu
             publish_snapshot(store, &input)
                 .await
                 .expect("publish wide predicate");
-            let lease = acquire_lease(store, Uuid::now_v7())
+            let elected = acquire_lease(store, Uuid::now_v7())
                 .await
                 .expect("elect")
                 .expect("leader");
+            let lease = extend_lease_through_test(store, elected).await;
             let limits = std::collections::BTreeMap::new();
             let scope = (location, "development");
             for include_last in [true, false] {
@@ -138,28 +139,22 @@ fn given_a_wide_group_when_only_the_last_node_has_not_started_then_all_chunks_mu
                         exit_code: None,
                     }))
                     .collect::<Vec<_>>();
-                for batch in changes.chunks(100) {
-                    // Evidence setup must keep its scheduler alive, just like the real loop.
-                    renew_lease(store, &lease)
-                        .await
-                        .expect("renew during setup");
-                    for change in batch {
-                        change_run(
-                            store,
-                            RunAuthority::Worker {
-                                run_id: claim.request.run_id,
-                                claim_id: claim.claim_id,
-                            },
-                            &RunChangeRequest {
-                                event_id: Uuid::now_v7(),
-                                run_id: claim.request.run_id,
-                                claim_id: Some(claim.claim_id),
-                                change: change.clone(),
-                            },
-                        )
-                        .await
-                        .expect("real node evidence");
-                    }
+                for change in &changes {
+                    change_run(
+                        store,
+                        RunAuthority::Worker {
+                            run_id: claim.request.run_id,
+                            claim_id: claim.claim_id,
+                        },
+                        &RunChangeRequest {
+                            event_id: Uuid::now_v7(),
+                            run_id: claim.request.run_id,
+                            claim_id: Some(claim.claim_id),
+                            change: change.clone(),
+                        },
+                    )
+                    .await
+                    .expect("real node evidence");
                 }
                 advance_groups(store, &lease, (&limits, scope))
                     .await

crates/sqlbuild-orchestration/tests/store/leases/helpers.rs

@@ -1,5 +1,8 @@
-//! Expire the persisted lease without introducing a fake control-store clock.
+//! Expire or hold the persisted lease without introducing a fake control-store clock.
 
+use chrono::{SecondsFormat, TimeDelta, Utc};
+
+use crate::scheduler::models::SchedulerLease;
 use crate::store::models::ControlStore;
 
 pub(crate) async fn expire_lease(store: &ControlStore) {
@@ -22,3 +25,46 @@ pub(crate) async fn expire_lease(store: &ControlStore) {
     .await
     .expect("expire PostgreSQL scheduler lease");
 }
+
+/// Keep `lease` live for a day without a renewer task, so slow setup cannot fence the test.
+pub(crate) async fn extend_lease_through_test(
+    store: &ControlStore,
+    lease: SchedulerLease,
+) -> SchedulerLease {
+    let expires_at = Utc::now() + TimeDelta::days(1);
+    let ControlStore::Postgres(pool) = store else {
+        let ControlStore::Sqlite(path) = store else {
+            unreachable!()
+        };
+        let held = rusqlite::Connection::open(path)
+            .expect("open lease hold connection")
+            .execute(
+                "UPDATE sqb_scheduler_lease SET expires_at=?1 WHERE name='scheduler' AND holder=?2 AND epoch=?3",
+                rusqlite::params![
+                    expires_at.to_rfc3339_opts(SecondsFormat::Micros, true),
+                    lease.holder.to_string(),
+                    lease.epoch
+                ],
+            )
+            .expect("hold SQLite scheduler lease");
+        assert_eq!(held, 1, "the held lease is the current one");
+        return SchedulerLease {
+            expires_at,
+            ..lease
+        };
+    };
+    let held = sqlx_core::query::query(
+        "UPDATE sqb_scheduler_lease SET expires_at=$1 WHERE name='scheduler' AND holder=$2 AND epoch=$3",
+    )
+    .bind(expires_at)
+    .bind(lease.holder)
+    .bind(lease.epoch)
+    .execute(pool)
+    .await
+    .expect("hold PostgreSQL scheduler lease");
+    assert_eq!(held.rows_affected(), 1, "the held lease is the current one");
+    SchedulerLease {
+        expires_at,
+        ..lease
+    }
+}