feat(runtime): advance loaded mission resources

5 files changed, 1369 insertions, 45 deletions

diff --git a/crates/fparkan-runtime/src/lib.rs b/crates/fparkan-runtime/src/lib.rs
index b4c13df..51b5180 100644
--- a/crates/fparkan-runtime/src/lib.rs
+++ b/crates/fparkan-runtime/src/lib.rs
@@ -134,9 +134,8 @@ pub struct BehaviorRegisteredObject {
     pub class_flags: u32,
     /// Native share field at record offset `+0x04`.
     pub share: f32,
-    /// Raw DWORDs at offsets `+0x08..+0x18`; the first controls whether
-    /// normalization treats this record as fixed, and the remaining words are
-    /// not yet assigned semantics. A normal native Add initializes all five to 0.
+    /// Raw DWORDs at offsets `+0x08..+0x18`: fixed-share flag, power demand,
+    /// power allocation, ore demand, and ore allocation. A native Add zeros them.
     pub native_tail: [u32; 5],
 }
 
@@ -457,19 +456,20 @@ pub struct MissionScriptBundle {
     pub package: ScriptPackage,
     /// Outcome of the restricted first-`Init` resolution for this bundle.
     pub init_execution: MissionScriptInitExecution,
-    /// Recovered per-AI Behavior state computed by a full mission startup.
+    /// Recovered per-AI Behavior scheduler and total state.
     /// Static previews leave this empty because they do not run script startup.
     pub behavior_warm_start: Option<BehaviorWarmStartState>,
 }
 
-/// Initial Behavior distributor fields recovered from the original warm-start path.
+/// Behavior distributor clock and totals tracked from warm start through resource ticks.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct BehaviorWarmStartState {
-    /// Queue-clock value copied to distributor offset `+0x10` when it is zero.
+    /// Native offset `+0x10`: startup queue time, later replaced by the last due tick time.
     pub first_time_ms: u32,
-    /// Initial scheduled time written to distributor offset `+0x14`.
+    /// Native offset `+0x14`: current deadline, rescheduled after each due tick.
     pub next_deadline_ms: u32,
-    /// Opaque distributor words at offsets `+0x30..=+0x40`, cleared on first start.
+    /// Native totals at offsets `+0x30..=+0x40`: zeroed at startup, then power
+    /// available, ore available, ore in buffer, power usage, and ore usage.
     pub cleared_words: [u32; 5],
 }
 
@@ -490,6 +490,35 @@ impl BehaviorWarmStartState {
     }
 }
 
+fn behavior_elapsed_seconds(elapsed_ms: u32) -> f32 {
+    // The exact integer product is rounded once to f32; scaling by 2^-33 is
+    // exact and matches native FILD / FMUL / FSTP under the measured control word.
+    ((u64::from(elapsed_ms) * 0x0083_126f) as f32) * f32::from_bits(0x2f00_0000)
+}
+
+fn schedule_behavior_distributor_tick(
+    state: &mut BehaviorWarmStartState,
+    queue_time_ms: u32,
+    rng_state: &mut u32,
+) -> Option<f32> {
+    if state.first_time_ms == 0 {
+        let initialized = BehaviorWarmStartState::start(queue_time_ms, rng_state);
+        state.first_time_ms = initialized.first_time_ms;
+        state.next_deadline_ms = initialized.next_deadline_ms;
+        state.cleared_words = [0; 5];
+        return None;
+    }
+    if state.next_deadline_ms != 0 && queue_time_ms <= state.next_deadline_ms {
+        return None;
+    }
+
+    let elapsed_ms = queue_time_ms.wrapping_sub(state.first_time_ms);
+    let next = BehaviorWarmStartState::start(queue_time_ms, rng_state);
+    state.first_time_ms = next.first_time_ms;
+    state.next_deadline_ms = next.next_deadline_ms;
+    Some(behavior_elapsed_seconds(elapsed_ms))
+}
+
 /// Numeric script defaults selected for the mission's first script bundle.
 ///
 /// GOG `ai.dll` first tries `<bundle-base>.var`, then falls back to the shared
@@ -833,6 +862,13 @@ pub enum EngineError {
         /// Entry, field, or format diagnostic.
         message: String,
     },
+    /// A Behavior resource tick could not resolve a required runtime value.
+    BehaviorDistributorTick {
+        /// TMA clan whose distributor could not complete its tick.
+        clan_index: usize,
+        /// Unsupported query, property, or arithmetic detail.
+        message: String,
+    },
     /// World error.
     World(fparkan_world::WorldError),
     /// Reference movement input or terrain query failed.
@@ -960,6 +996,10 @@ impl std::fmt::Display for EngineError {
                 entry,
                 message,
             } => write!(f, "{path}:{entry}: Behavior profile failed: {message}"),
+            Self::BehaviorDistributorTick {
+                clan_index,
+                message,
+            } => write!(f, "Behavior resource tick for clan {clan_index}: {message}"),
             Self::World(source) => write!(f, "{source}"),
             Self::Movement(message) => write!(f, "reference movement: {message}"),
             Self::RegistrationTeardown {
@@ -994,6 +1034,7 @@ impl std::error::Error for EngineError {
             | Self::Movement(_)
             | Self::PrototypeGraph { .. }
             | Self::BehaviorProfile { .. }
+            | Self::BehaviorDistributorTick { .. }
             | Self::RegistrationTeardown { .. } => None,
         }
     }
@@ -1880,6 +1921,100 @@ pub fn query_loaded_mission_behavior_resource(
     }
 }
 
+/// Runs due native Behavior resource-distributor ticks against the loaded mission.
+///
+/// `queue_time_ms` is an explicit sample from the original wrapping 32-bit
+/// queue clock. The method updates the distributor schedule, its five totals,
+/// per-object row values, CurrentOre, and supported Control selector-1 state
+/// atomically. Preview missions and loaded missions without visible Behavior
+/// bundles have no due distributors and return `Ok(0)`. Otherwise it returns
+/// the number of distributors whose schedule was due; this includes a due
+/// tick with zero elapsed time, which leaves resource rows unchanged.
+///
+/// # Errors
+/// Returns an error when a live registered object reaches an unsupported
+/// Behavior profile, Control query, or property state. On error, all
+/// schedules, RNG state, totals, rows, ore values, and Control values remain
+/// unchanged.
+pub fn advance_loaded_mission_resources(
+    engine: &mut Engine,
+    queue_time_ms: u32,
+) -> Result<usize, EngineError> {
+    let Some(loaded) = engine.loaded.as_ref() else {
+        return Ok(0);
+    };
+
+    let mut distributors = loaded.behavior_distributors.clone();
+    let mut ore_states = loaded.behavior_ore_states.clone();
+    let mut control_tables = loaded.control_device_tables.clone();
+    let mut warm_starts = loaded
+        .script_bundles
+        .iter()
+        .map(|bundle| bundle.behavior_warm_start)
+        .collect::<Vec<_>>();
+    let profiles = &loaded.behavior_profiles;
+    let world = &engine.world;
+    let mut rng_state = engine.behavior_rng_state;
+    let mut scheduled_ticks = 0;
+
+    for distributor in distributors.iter_mut() {
+        if !distributor.super_ai_visible {
+            continue;
+        }
+        let bundle_index = loaded
+            .script_bundles
+            .iter()
+            .position(|bundle| bundle.clan_index == distributor.clan_index)
+            .ok_or_else(|| EngineError::BehaviorDistributorTick {
+                clan_index: distributor.clan_index,
+                message: "visible distributor has no matching script bundle".to_string(),
+            })?;
+        let Some(schedule) = warm_starts.get_mut(bundle_index).and_then(Option::as_mut) else {
+            return Err(EngineError::BehaviorDistributorTick {
+                clan_index: distributor.clan_index,
+                message: "visible distributor has no warm-start schedule".to_string(),
+            });
+        };
+
+        let delta_seconds =
+            schedule_behavior_distributor_tick(schedule, queue_time_ms, &mut rng_state);
+        let Some(delta_seconds) = delta_seconds else {
+            continue;
+        };
+        scheduled_ticks += 1;
+        if delta_seconds == 0.0 {
+            continue;
+        }
+
+        let totals = advance_behavior_distributor_tick(
+            distributor,
+            delta_seconds,
+            world,
+            &mut ore_states,
+            profiles,
+            &mut control_tables,
+        )
+        .map_err(|message| EngineError::BehaviorDistributorTick {
+            clan_index: distributor.clan_index,
+            message,
+        })?;
+        schedule.cleared_words = totals;
+    }
+
+    let loaded = engine
+        .loaded
+        .as_mut()
+        .expect("loaded mission was checked above");
+    loaded.behavior_distributors = distributors;
+    loaded.behavior_ore_states = ore_states;
+    loaded.control_device_tables = control_tables;
+    for (bundle, warm_start) in loaded.script_bundles.iter_mut().zip(warm_starts) {
+        bundle.behavior_warm_start = warm_start;
+    }
+    engine.behavior_rng_state = rng_state;
+    Ok(scheduled_ticks)
+}
+
 /// Sets native Control global-table selector 1 on rows whose selector-0 value
 /// is positive. Validation is completed before any row is changed.
 ///
@@ -2059,6 +2194,387 @@ fn query_behavior_profile_ore_rate(
     )
 }
 
+#[derive(Clone, Copy, Default)]
+struct BehaviorTickTotals {
+    power_available: f32,
+    ore_available: f32,
+    power_weighted_demand: f32,
+    power_demand: f32,
+    ore_weighted_demand: f32,
+    ore_demand: f32,
+    ore_in_buffer: f32,
+}
+
+#[derive(Clone, Copy, Default)]
+struct BehaviorAllocation {
+    priority: f32,
+    residual: f32,
+    consumption: f32,
+}
+
+fn behavior_difference(lhs: f32, rhs: f32, field: &'static str) -> Result<f32, String> {
+    let range_probe = f64::from(lhs) - f64::from(rhs);
+    check_control_range_probe(None, field, range_probe).map_err(|error| format!("{error:?}"))?;
+    checked_control_float(0, field, lhs - rhs).map_err(|error| format!("{error:?}"))
+}
+
+fn behavior_product(lhs: f32, rhs: f32, field: &'static str) -> Result<f32, String> {
+    checked_control_product(0, field, lhs, rhs).map_err(|error| format!("{error:?}"))
+}
+
+fn behavior_allocation(
+    available: f32,
+    demand: f32,
+    weighted_demand: f32,
+) -> Result<BehaviorAllocation, String> {
+    if available <= 0.0 || demand <= 0.0 {
+        Ok(BehaviorAllocation::default())
+    } else if available <= weighted_demand {
+        Ok(BehaviorAllocation {
+            priority: checked_control_ratio("priority allocation", available, weighted_demand)
+                .map_err(|error| format!("{error:?}"))?,
+            residual: 0.0,
+            consumption: 1.0,
+        })
+    } else if available < demand {
+        let residual_available =
+            behavior_difference(available, weighted_demand, "residual available")?;
+        let residual_demand = behavior_difference(demand, weighted_demand, "residual demand")?;
+        Ok(BehaviorAllocation {
+            priority: 1.0,
+            residual: checked_control_ratio(
+                "residual allocation",
+                residual_available,
+                residual_demand,
+            )
+            .map_err(|error| format!("{error:?}"))?,
+            consumption: 1.0,
+        })
+    } else {
+        Ok(BehaviorAllocation {
+            priority: 1.0,
+            residual: 1.0,
+            consumption: checked_control_ratio("source consumption", demand, available)
+                .map_err(|error| format!("{error:?}"))?,
+        })
+    }
+}
+
+fn behavior_add_total(total: &mut f32, value: f32, field: &'static str) -> Result<(), String> {
+    *total = checked_control_sum(0, field, *total, value).map_err(|error| format!("{error:?}"))?;
+    Ok(())
+}
+
+fn behavior_profile_for_handle<'a>(
+    profiles: &'a [BehaviorProfileState],
+    handle: ObjectHandle,
+) -> Result<&'a BehaviorProfileState, String> {
+    profiles
+        .iter()
+        .find(|profile| profile.handle == handle)
+        .ok_or_else(|| format!("Behavior profile for object {handle:?} is unavailable"))
+}
+
+fn behavior_ore_index_for_handle(
+    ore_states: &[BehaviorOreState],
+    handle: ObjectHandle,
+) -> Result<usize, String> {
+    ore_states
+        .iter()
+        .position(|state| state.handle == handle)
+        .ok_or_else(|| format!("CurrentOre property for object {handle:?} is unavailable"))
+}
+
+fn behavior_control_index_for_handle(
+    control_tables: &[MissionControlDeviceTableState],
+    handle: ObjectHandle,
+) -> Result<usize, String> {
+    let index = control_tables
+        .iter()
+        .position(|table| table.handle == handle)
+        .ok_or_else(|| format!("Control interface for object {handle:?} is unavailable"))?;
+    match &control_tables[index].status {
+        MissionControlDeviceTableStatus::Available(_) => Ok(index),
+        MissionControlDeviceTableStatus::Unavailable(reason) => Err(format!(
+            "Control interface for object {handle:?} is unresolved: {reason:?}"
+        )),
+    }
+}
+
+fn behavior_checked_property(state: &BehaviorOreState, maximum: bool) -> Result<f32, String> {
+    let (field, bits) = if maximum {
+        ("MaximumOre", state.maximum_ore_bits)
+    } else {
+        ("CurrentOre", state.current_ore_bits)
+    };
+    checked_control_float(state.class_flags, field, f32::from_bits(bits))
+        .map_err(|error| format!("{error:?}"))
+}
+
+fn behavior_tick_resource_rate(
+    class_flags: u32,
+    handle: ObjectHandle,
+    selector: u32,
+    profiles: &[BehaviorProfileState],
+    control_tables: &[MissionControlDeviceTableState],
+) -> Result<f32, String> {
+    let profile = behavior_profile_for_handle(profiles, handle)?;
+    match selector {
+        0x1005 => checked_control_float(
+            class_flags,
+            "Transfer_Power_Out",
+            f32::from_bits(profile.transfer_power_out_bits),
+        )
+        .map_err(|error| format!("{error:?}")),
+        0x1002 => {
+            let table_index = behavior_control_index_for_handle(control_tables, handle)?;
+            query_behavior_profile_ore_rate(
+                &control_tables[table_index],
+                profile.transfer_ore_off_board_bits,
+            )
+            .map_err(|error| format!("{error:?}"))
+        }
+        _ => Err(format!(
+            "unsupported Behavior resource selector {selector:#x}"
+        )),
+    }
+}
+
+fn behavior_query_control(
+    control_tables: &[MissionControlDeviceTableState],
+    handle: ObjectHandle,
+    selector: u32,
+) -> Result<f32, String> {
+    let table_index = behavior_control_index_for_handle(control_tables, handle)?;
+    query_control_device_table_resource(&control_tables[table_index], selector)
+        .map(|value| value.unwrap_or(0.0))
+        .map_err(|error| format!("{error:?}"))
+}
+
+fn advance_behavior_distributor_tick(
+    distributor: &mut BehaviorDistributorState,
+    delta_seconds: f32,
+    world: &World,
+    ore_states: &mut [BehaviorOreState],
+    profiles: &[BehaviorProfileState],
+    control_tables: &mut [MissionControlDeviceTableState],
+) -> Result<[u32; 5], String> {
+    let mut totals = BehaviorTickTotals::default();
+
+    // Native pass one measures supply and demand, then records per-row demand.
+    for object in &mut distributor.registered_objects {
+        let Some(live_handle) = handle_by_original_id(world, object.original_id) else {
+            object.native_tail[1] = 0;
+            object.native_tail[3] = 0;
+            continue;
+        };
+        if live_handle != object.handle {
+            return Err(format!(
+                "live original object {} maps to {live_handle:?}, expected {:?}",
+                object.original_id.0, object.handle
+            ));
+        }
+        let share = checked_control_float(object.class_flags, "Behavior share", object.share)
+            .map_err(|error| format!("{error:?}"))?;
+
+        let power_source = matches!(
+            object.class_flags,
+            0x8000_0002 | 0x8001_0000 | 0x8002_0000 | 0x8004_0000
+        );
+        let power_demand = if power_source {
+            let rate = behavior_tick_resource_rate(
+                object.class_flags,
+                live_handle,
+                0x1005,
+                profiles,
+                control_tables,
+            )?;
+            let production = behavior_product(delta_seconds, rate, "power production")?;
+            behavior_add_total(&mut totals.power_available, production, "power available")?;
+            0.0
+        } else {
+            let total_power = behavior_query_control(control_tables, live_handle, 2)?;
+            let power_ratio = behavior_query_control(control_tables, live_handle, 1)?;
+            if total_power > 0.0 {
+                let used_power = behavior_product(power_ratio, total_power, "used power")?;
+                behavior_difference(total_power, used_power, "power demand")?
+            } else {
+                0.0
+            }
+        };
+        object.native_tail[1] = power_demand.to_bits();
+        behavior_add_total(&mut totals.power_demand, power_demand, "power demand")?;
+        behavior_add_total(
+            &mut totals.power_weighted_demand,
+            behavior_product(power_demand, share, "weighted power demand")?,
+            "weighted power demand",
+        )?;
+
+        let ore_source = matches!(object.class_flags, 0x8000_0004 | 0x8000_0008);
+        let ore_index = behavior_ore_index_for_handle(ore_states, live_handle)?;
+        let current = behavior_checked_property(&ore_states[ore_index], false)?;
+        let ore_demand = if ore_source {
+            let rate = behavior_tick_resource_rate(
+                object.class_flags,
+                live_handle,
+                0x1002,
+                profiles,
+                control_tables,
+            )?;
+            let production = behavior_product(delta_seconds, rate, "ore production")?;
+            let available = if current < production {
+                current
+            } else {
+                production
+            };
+            behavior_add_total(&mut totals.ore_available, available, "ore available")?;
+            behavior_add_total(&mut totals.ore_in_buffer, current, "ore in buffer")?;
+            0.0
+        } else {
+            let maximum = behavior_checked_property(&ore_states[ore_index], true)?;
+            let deficit = behavior_difference(maximum, current, "ore deficit")?;
+            if deficit >= f32::from_bits(0x3c23_d70a) {
+                deficit
+            } else {
+                ore_states[ore_index].current_ore_bits = maximum.to_bits();
+                0.0
+            }
+        };
+        object.native_tail[3] = ore_demand.to_bits();
+        behavior_add_total(&mut totals.ore_demand, ore_demand, "ore demand")?;
+        behavior_add_total(
+            &mut totals.ore_weighted_demand,
+            behavior_product(ore_demand, share, "weighted ore demand")?,
+            "weighted ore demand",
+        )?;
+    }
+
+    let power_allocation = behavior_allocation(
+        totals.power_available,
+        totals.power_demand,
+        totals.power_weighted_demand,
+    )?;
+    let ore_allocation = behavior_allocation(
+        totals.ore_available,
+        totals.ore_demand,
+        totals.ore_weighted_demand,
+    )?;
+
+    // Native pass two re-reads callbacks before applying each row in order.
+    for object in &mut distributor.registered_objects {
+        let Some(live_handle) = handle_by_original_id(world, object.original_id) else {
+            object.native_tail[2] = 0;
+            object.native_tail[4] = 0;
+            continue;
+        };
+        if live_handle != object.handle {
+            return Err(format!(
+                "live original object {} maps to {live_handle:?}, expected {:?}",
+                object.original_id.0, object.handle
+            ));
+        }
+        object.native_tail[2] = 0;
+        object.native_tail[4] = 0;
+
+        let power_source = matches!(
+            object.class_flags,
+            0x8000_0002 | 0x8001_0000 | 0x8002_0000 | 0x8004_0000
+        );
+        if power_source {
+            let table_index = behavior_control_index_for_handle(control_tables, live_handle)?;
+            set_control_device_table_multiplier(&mut control_tables[table_index], 1.0)
+                .map_err(|error| format!("{error:?}"))?;
+        } else {
+            let table_index = behavior_control_index_for_handle(control_tables, live_handle)?;
+            let total_power = behavior_query_control(control_tables, live_handle, 2)?;
+            if total_power > 0.0 {
+                let power_ratio = behavior_query_control(control_tables, live_handle, 1)?;
+                let used_power = behavior_product(power_ratio, total_power, "used power")?;
+                let demand = behavior_difference(total_power, used_power, "power demand")?;
+                let share = object.share;
+                let priority_share =
+                    behavior_product(share, power_allocation.priority, "priority power share")?;
+                let residual_share = behavior_product(
+                    behavior_difference(1.0, share, "remaining share")?,
+                    power_allocation.residual,
+                    "residual power share",
+                )?;
+                let fraction = checked_control_sum(
+                    0,
+                    "power allocation fraction",
+                    residual_share,
+                    priority_share,
+                )
+                .map_err(|error| format!("{error:?}"))?;
+                let allocated = behavior_product(demand, fraction, "power allocation")?;
+                let updated =
+                    checked_control_sum(0, "used plus allocated power", used_power, allocated)
+                        .map_err(|error| format!("{error:?}"))?;
+                let new_ratio =
+                    checked_control_ratio("new Control selector 1", updated, total_power)
+                        .map_err(|error| format!("{error:?}"))?;
+                set_control_device_table_multiplier(&mut control_tables[table_index], new_ratio)
+                    .map_err(|error| format!("{error:?}"))?;
+                object.native_tail[2] = allocated.to_bits();
+            }
+        }
+
+        let ore_source = matches!(object.class_flags, 0x8000_0004 | 0x8000_0008);
+        let ore_index = behavior_ore_index_for_handle(ore_states, live_handle)?;
+        let current = behavior_checked_property(&ore_states[ore_index], false)?;
+        if ore_source {
+            let rate = behavior_tick_resource_rate(
+                object.class_flags,
+                live_handle,
+                0x1002,
+                profiles,
+                control_tables,
+            )?;
+            let production = behavior_product(delta_seconds, rate, "ore withdrawal rate")?;
+            let bounded_production = if current < production {
+                current
+            } else {
+                production
+            };
+            let taken = behavior_product(
+                bounded_production,
+                ore_allocation.consumption,
+                "ore withdrawal",
+            )?;
+            ore_states[ore_index].current_ore_bits =
+                behavior_difference(current, taken, "remaining ore")?.to_bits();
+        } else {
+            let maximum = behavior_checked_property(&ore_states[ore_index], true)?;
+            let capacity = behavior_difference(maximum, current, "ore capacity")?;
+            let share = object.share;
+            let priority_share =
+                behavior_product(share, ore_allocation.priority, "priority ore share")?;
+            let residual_share = behavior_product(
+                behavior_difference(1.0, share, "remaining share")?,
+                ore_allocation.residual,
+                "residual ore share",
+            )?;
+            let fraction =
+                checked_control_sum(0, "ore allocation fraction", residual_share, priority_share)
+                    .map_err(|error| format!("{error:?}"))?;
+            let allocated = behavior_product(capacity, fraction, "ore allocation")?;
+            ore_states[ore_index].current_ore_bits =
+                checked_control_sum(0, "current plus allocated ore", current, allocated)
+                    .map_err(|error| format!("{error:?}"))?
+                    .to_bits();
+            object.native_tail[4] = allocated.to_bits();
+        }
+    }
+
+    Ok([
+        totals.power_available.to_bits(),
+        totals.ore_available.to_bits(),
+        totals.ore_in_buffer.to_bits(),
+        totals.power_demand.to_bits(),
+        totals.ore_demand.to_bits(),
+    ])
+}
+
 fn set_control_device_table_multiplier(
     table: &mut MissionControlDeviceTableState,
     value: f32,
@@ -4272,6 +4788,79 @@ mod tests {
     }
 
     #[test]
+    fn behavior_elapsed_seconds_preserve_native_qword_conversion_rounding() {
+        let vectors = [
+            (1, 0x3a83_126f),
+            (1_001, 0x3f80_20c5),
+            (16_777_217, 0x4683_1270),
+            (16_777_219, 0x4683_1271),
+            (u32::MAX, 0x4a83_126f),
+            (u32::MAX - 1, 0x4a83_126f),
+        ];
+        for (elapsed_ms, expected_bits) in vectors {
+            assert_eq!(
+                behavior_elapsed_seconds(elapsed_ms).to_bits(),
+                expected_bits,
+                "elapsed={elapsed_ms}"
+            );
+        }
+    }
+
+    #[test]
+    fn behavior_distributor_scheduler_requires_a_strictly_later_unsigned_time() {
+        let original = BehaviorWarmStartState {
+            first_time_ms: 100,
+            next_deadline_ms: 200,
+            cleared_words: [0x11; 5],
+        };
+        let mut state = original;
+        let mut rng_state = 1;
+
+        assert_eq!(
+            schedule_behavior_distributor_tick(&mut state, 200, &mut rng_state),
+            None
+        );
+        assert_eq!(state, original);
+        assert_eq!(rng_state, 1);
+
+        let elapsed = schedule_behavior_distributor_tick(&mut state, 201, &mut rng_state)
+            .expect("deadline is passed");
+        assert_eq!(elapsed.to_bits(), behavior_elapsed_seconds(101).to_bits());
+        assert_eq!(state.first_time_ms, 201);
+        assert_eq!(state.next_deadline_ms, 403);
+        assert_eq!(state.cleared_words, [0x11; 5]);
+        assert_eq!(rng_state, 0x0029_e2c0);
+    }
+
+    #[test]
+    fn behavior_distributor_scheduler_wraps_elapsed_but_keeps_unsigned_deadline_order() {
+        let mut state = BehaviorWarmStartState {
+            first_time_ms: u32::MAX - 15,
+            next_deadline_ms: 5,
+            cleared_words: [0; 5],
+        };
+        let mut rng_state = 1;
+
+        assert_eq!(
+            schedule_behavior_distributor_tick(&mut state, 5, &mut rng_state),
+            None
+        );
+        assert_eq!(state.next_deadline_ms, 5);
+        let elapsed = schedule_behavior_distributor_tick(&mut state, 6, &mut rng_state)
+            .expect("current time is unsigned-greater than deadline");
+        assert_eq!(elapsed.to_bits(), behavior_elapsed_seconds(22).to_bits());
+        assert_eq!(state.first_time_ms, 6);
+
+        let before = state;
+        assert_eq!(
+            schedule_behavior_distributor_tick(&mut state, 1, &mut rng_state),
+            None,
+            "unsigned 1 is not strictly later than the current deadline"
+        );
+        assert_eq!(state, before);
+    }
+
+    #[test]
     fn mission_script_start_stops_before_warming_later_bundles() {
         fn push_u32(bytes: &mut Vec<u8>, value: u32) {
             bytes.extend_from_slice(&value.to_le_bytes());
@@ -5837,6 +6426,259 @@ mod tests {
         );
     }
 
+    #[test]
+    #[ignore = "requires licensed corpus"]
+    fn licensed_autodemo_resource_ticks_use_queue_time_and_real_generator_profile() {
+        let root = licensed_root("IS");
+        let vfs: Arc<dyn Vfs> = Arc::new(DirectoryVfs::new(root));
+        let mut engine = create(EngineServices::new(vfs)).expect("engine");
+        load_mission(
+            &mut engine,
+            MissionRequest {
+                key: "MISSIONS/Autodemo.00/data.tma".to_string(),
+                mode: MissionMode::AutoDemo,
+            },
+            100_000,
+        )
+        .expect("load licensed AutoDemo");
+
+        let deadlines = loaded_mission_script_bundles(&engine)
+            .expect("script bundles")
+            .iter()
+            .map(|bundle| {
+                (
+                    bundle.clan_index,
+                    bundle
+                        .behavior_warm_start
+                        .expect("full load warm-start")
+                        .next_deadline_ms,
+                )
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(deadlines, [(0, 100_202), (1, 100_200)]);
+        assert_eq!(
+            advance_loaded_mission_resources(&mut engine, 100_000)
+                .expect("no due resource tick at warm start"),
+            0
+        );
+        assert_eq!(
+            advance_loaded_mission_resources(&mut engine, 100_200)
+                .expect("strict deadline equality is not due"),
+            0
+        );
+
+        assert_eq!(
+            advance_loaded_mission_resources(&mut engine, 100_201).expect("clan 1 resource tick"),
+            1
+        );
+        let first_totals = loaded_mission_script_bundles(&engine)
+            .expect("bundles after first tick")
+            .iter()
+            .find(|bundle| bundle.clan_index == 1)
+            .and_then(|bundle| bundle.behavior_warm_start)
+            .expect("clan 1 scheduler")
+            .cleared_words;
+        assert!(
+            f32::from_bits(first_totals[0]) > 0.0,
+            "clan 1's real prof_generator.var contributes power"
+        );
+        assert_eq!(
+            advance_loaded_mission_resources(&mut engine, 100_202)
+                .expect("clan 0 deadline equality is not due"),
+            0
+        );
+
+        assert_eq!(
+            advance_loaded_mission_resources(&mut engine, 100_203).expect("clan 0 resource tick"),
+            1
+        );
+        let second_totals = loaded_mission_script_bundles(&engine)
+            .expect("bundles after second tick")
+            .iter()
+            .find(|bundle| bundle.clan_index == 0)
+            .and_then(|bundle| bundle.behavior_warm_start)
+            .expect("clan 0 scheduler")
+            .cleared_words;
+        assert!(
+            f32::from_bits(second_totals[0]) > 0.0,
+            "clan 0's real prof_generator.var contributes power"
+        );
+
+        let first_tick_time = 100_500;
+        let deadlines = loaded_mission_script_bundles(&engine)
+            .expect("bundles after one tick per clan")
+            .iter()
+            .map(|bundle| {
+                bundle
+                    .behavior_warm_start
+                    .expect("full load warm-start")
+                    .next_deadline_ms
+            })
+            .collect::<Vec<_>>();
+        assert!(deadlines.iter().all(|deadline| *deadline < first_tick_time));
+        assert_eq!(
+            advance_loaded_mission_resources(&mut engine, first_tick_time)
+                .expect("second resource tick for each clan"),
+            2
+        );
+        let totals_at_100500 = loaded_mission_script_bundles(&engine)
+            .expect("bundles at 100500")
+            .iter()
+            .map(|bundle| {
+                (
+                    bundle.clan_index,
+                    bundle.behavior_warm_start.expect("full load warm-start"),
+                )
+            })
+            .collect::<Vec<_>>();
+        for (clan, warm_start) in &totals_at_100500 {
+            assert_eq!(warm_start.first_time_ms, first_tick_time);
+            let elapsed = if *clan == 0 { 297 } else { 299 };
+            assert_eq!(
+                warm_start.cleared_words[0],
+                (behavior_elapsed_seconds(elapsed) * 10.0).to_bits(),
+                "clan {clan} recomputes power availability from the elapsed interval"
+            );
+        }
+
+        assert_eq!(
+            advance_loaded_mission_resources(&mut engine, 101_000)
+                .expect("third resource tick for each clan"),
+            2
+        );
+        let totals_at_101000 = loaded_mission_script_bundles(&engine)
+            .expect("bundles at 101000")
+            .iter()
+            .map(|bundle| {
+                (
+                    bundle.clan_index,
+                    bundle.behavior_warm_start.expect("full load warm-start"),
+                )
+            })
+            .collect::<Vec<_>>();
+        for (clan, warm_start) in &totals_at_101000 {
+            assert_eq!(warm_start.first_time_ms, 101_000);
+            assert_eq!(
+                warm_start.cleared_words[0],
+                5.0_f32.to_bits(),
+                "clan {clan} replaces totals with the latest interval"
+            );
+            let previous = totals_at_100500
+                .iter()
+                .find(|(previous_clan, _)| previous_clan == clan)
+                .expect("same clan totals at previous tick")
+                .1;
+            assert_ne!(warm_start.cleared_words[0], previous.cleared_words[0]);
+        }
+
+        assert!(loaded_mission_behavior_profiles(&engine)
+            .expect("loaded profiles")
+            .iter()
+            .filter(|profile| profile.class_flags == 0x8000_0002)
+            .all(|profile| profile.transfer_power_out_bits == 10.0_f32.to_bits()));
+
+        for clan in [0, 1] {
+            let distributor = loaded_mission_behavior_distributors(&engine)
+                .expect("loaded distributors")
+                .iter()
+                .find(|distributor| distributor.clan_index == clan)
+                .expect("loaded clan distributor");
+            assert_eq!(distributor.registered_objects.len(), 2);
+            let generator = loaded_mission_behavior_distributors(&engine)
+                .expect("loaded distributors")
+                .iter()
+                .find(|distributor| distributor.clan_index == clan)
+                .and_then(|distributor| {
+                    distributor
+                        .registered_objects
+                        .iter()
+                        .find(|object| object.class_flags == 0x8000_0002)
+                })
+                .expect("licensed AutoDemo generator row");
+            let profile = loaded_mission_behavior_profiles(&engine)
+                .expect("loaded Behavior profiles")
+                .iter()
+                .find(|profile| profile.handle == generator.handle)
+                .expect("generator profile");
+            let totals = totals_at_101000
+                .iter()
+                .find(|(candidate, _)| *candidate == clan)
+                .expect("generator clan totals")
+                .1
+                .cleared_words;
+            println!(
+                "licensed AutoDemo Behavior tick: clan={clan} ObjectId={} profile={} Transfer_Power_Out={} PowerAvailable={} at queue times 100201/100203,100500,101000; registered rows={}",
+                generator.original_id.0,
+                profile.profile_entry.as_deref().unwrap_or("<defaults>"),
+                f32::from_bits(profile.transfer_power_out_bits),
+                f32::from_bits(totals[0]),
+                distributor.registered_objects.len(),
+            );
+        }
+
+        let second_plant = {
+            let loaded = engine.loaded.as_mut().expect("loaded mission state");
+            let second = loaded
+                .behavior_distributors
+                .iter()
+                .find(|distributor| distributor.clan_index == 1)
+                .expect("clan 1 distributor");
+            let plant = second
+                .registered_objects
+                .iter()
+                .find(|object| object.class_flags == 0x8000_0010)
+                .expect("clan 1 plant")
+                .clone();
+            loaded
+                .control_device_tables
+                .retain(|table| table.handle != plant.handle);
+            plant
+        };
+        assert_eq!(second_plant.class_flags, 0x8000_0010);
+        let before_distributors = loaded_mission_behavior_distributors(&engine)
+            .expect("rollback distributor snapshot")
+            .to_vec();
+        let before_ore_states = loaded_mission_behavior_ore_states(&engine)
+            .expect("rollback ore snapshot")
+            .to_vec();
+        let before_controls = loaded_mission_control_device_tables(&engine)
+            .expect("rollback Control snapshot")
+            .to_vec();
+        let before_warm_starts = loaded_mission_script_bundles(&engine)
+            .expect("rollback bundles")
+            .iter()
+            .map(|bundle| bundle.behavior_warm_start)
+            .collect::<Vec<_>>();
+        let before_rng = engine.behavior_rng_state;
+        let error = advance_loaded_mission_resources(&mut engine, 102_000)
+            .expect_err("missing clan 1 plant Control table fails after clan 0 stages a tick");
+        assert!(matches!(
+            error,
+            EngineError::BehaviorDistributorTick { clan_index: 1, .. }
+        ));
+        assert_eq!(
+            loaded_mission_behavior_distributors(&engine),
+            Some(before_distributors.as_slice())
+        );
+        assert_eq!(
+            loaded_mission_behavior_ore_states(&engine),
+            Some(before_ore_states.as_slice())
+        );
+        assert_eq!(
+            loaded_mission_control_device_tables(&engine),
+            Some(before_controls.as_slice())
+        );
+        assert_eq!(
+            loaded_mission_script_bundles(&engine)
+                .expect("bundles after failed transaction")
+                .iter()
+                .map(|bundle| bundle.behavior_warm_start)
+                .collect::<Vec<_>>(),
+            before_warm_starts
+        );
+        assert_eq!(engine.behavior_rng_state, before_rng);
+    }
+
     fn behavior_test_object(
         slot: u32,
         share: f32,
@@ -6075,6 +6917,237 @@ mod tests {
     }
 
     #[test]
+    fn behavior_allocation_matches_shortage_middle_surplus_and_equality_branches() {
+        let shortage = behavior_allocation(1.0, 6.0, 3.0).expect("shortage allocation");
+        assert_eq!(shortage.priority.to_bits(), 0x3eaa_aaab);
+        assert_eq!(shortage.residual.to_bits(), 0);
+        assert_eq!(shortage.consumption.to_bits(), 1.0_f32.to_bits());
+
+        let middle = behavior_allocation(0.25, 0.375, 0.1875).expect("middle allocation");
+        assert_eq!(middle.priority.to_bits(), 1.0_f32.to_bits());
+        assert_eq!(middle.residual.to_bits(), 0x3eaa_aaab);
+        assert_eq!(middle.consumption.to_bits(), 1.0_f32.to_bits());
+
+        let surplus = behavior_allocation(2.0, 0.375, 0.1875).expect("surplus allocation");
+        assert_eq!(surplus.priority.to_bits(), 1.0_f32.to_bits());
+        assert_eq!(surplus.residual.to_bits(), 1.0_f32.to_bits());
+        assert_eq!(surplus.consumption.to_bits(), 0x3e40_0000);
+
+        let exact = behavior_allocation(0.375, 0.375, 0.1875).expect("exact allocation");
+        assert_eq!(exact.priority.to_bits(), 1.0_f32.to_bits());
+        assert_eq!(exact.residual.to_bits(), 1.0_f32.to_bits());
+        assert_eq!(exact.consumption.to_bits(), 1.0_f32.to_bits());
+    }
+
+    fn behavior_tick_test_object(
+        world: &mut World,
+        original_id: u32,
+        class_flags: u32,
+        share: f32,
+    ) -> BehaviorRegisteredObject {
+        let original_id = OriginalObjectId(original_id);
+        let handle = construct_object(
+            world,
+            ObjectDraft {
+                original_id: Some(original_id),
+            },
+        )
+        .expect("construct Behavior tick object");
+        register_object(world, handle).expect("register Behavior tick object");
+        BehaviorRegisteredObject {
+            original_id,
+            handle,
+            selector: 0,
+            class_flags,
+            share,
+            native_tail: [0; 5],
+        }
+    }
+
+    fn behavior_tick_test_control_table(
+        original_id: u32,
+        handle: ObjectHandle,
+    ) -> MissionControlDeviceTableState {
+        let device = synthetic_effective_control_device(
+            19,
+            19,
+            0.75_f32.to_bits(),
+            Some(0.5_f32.to_bits()),
+            None,
+        );
+        MissionControlDeviceTableState {
+            original_id: Some(OriginalObjectId(original_id)),
+            handle,
+            status: MissionControlDeviceTableStatus::Available(vec![device]),
+            node_provider_status: MissionControlNodeProviderTableStatus::Available(Vec::new()),
+        }
+    }
+
+    #[test]
+    fn behavior_power_source_also_contributes_ore_demand() {
+        let mut world = new_world(WorldConfig);
+        let producer = behavior_tick_test_object(&mut world, 1, 0x8000_0002, 0.5);
+        let recipient = behavior_tick_test_object(&mut world, 2, 0x8000_0001, 0.5);
+        let mut distributor = BehaviorDistributorState {
+            clan_index: 0,
+            super_ai_visible: true,
+            registered_objects: vec![producer.clone(), recipient.clone()],
+        };
+        let mut ore_states = [producer.clone(), recipient.clone()]
+            .into_iter()
+            .map(|object| BehaviorOreState {
+                original_id: object.original_id,
+                handle: object.handle,
+                class_flags: object.class_flags,
+                current_ore_bits: 1.0_f32.to_bits(),
+                maximum_ore_bits: 10.0_f32.to_bits(),
+            })
+            .collect::<Vec<_>>();
+        let profiles = [BehaviorProfileState {
+            original_id: OriginalObjectId(1),
+            handle: producer.handle,
+            class_flags: producer.class_flags,
+            profile_entry: None,
+            transfer_ore_off_board_bits: 0x40a0_0000,
+            transfer_power_out_bits: 4.0_f32.to_bits(),
+        }];
+        let mut control_tables = vec![
+            behavior_tick_test_control_table(1, producer.handle),
+            behavior_tick_test_control_table(2, recipient.handle),
+        ];
+
+        let totals = advance_behavior_distributor_tick(
+            &mut distributor,
+            1.0,
+            &world,
+            &mut ore_states,
+            &profiles,
+            &mut control_tables,
+        )
+        .expect("tick supported power source and generic receiver");
+
+        assert_eq!(
+            totals[4],
+            18.0_f32.to_bits(),
+            "both native classes compute the non-source ore demand"
+        );
+    }
+
+    #[test]
+    fn behavior_ore_source_also_contributes_power_demand() {
+        let mut world = new_world(WorldConfig);
+        let producer = behavior_tick_test_object(&mut world, 3, 0x8000_0004, 1.0);
+        let mut distributor = BehaviorDistributorState {
+            clan_index: 0,
+            super_ai_visible: true,
+            registered_objects: vec![producer.clone()],
+        };
+        let mut ore_states = [producer.clone()]
+            .into_iter()
+            .map(|object| BehaviorOreState {
+                original_id: object.original_id,
+                handle: object.handle,
+                class_flags: object.class_flags,
+                current_ore_bits: 0.25_f32.to_bits(),
+                maximum_ore_bits: 10.0_f32.to_bits(),
+            })
+            .collect::<Vec<_>>();
+        let profiles = [BehaviorProfileState {
+            original_id: OriginalObjectId(3),
+            handle: producer.handle,
+            class_flags: producer.class_flags,
+            profile_entry: None,
+            transfer_ore_off_board_bits: 4.0_f32.to_bits(),
+            transfer_power_out_bits: 0.0_f32.to_bits(),
+        }];
+        let mut ore_device = synthetic_effective_control_device(
+            26,
+            26,
+            1.0_f32.to_bits(),
+            Some(1.0_f32.to_bits()),
+            None,
+        );
+        ore_device.key = 0;
+        let producer_table = MissionControlDeviceTableState {
+            original_id: Some(OriginalObjectId(3)),
+            handle: producer.handle,
+            status: MissionControlDeviceTableStatus::Available(vec![
+                synthetic_effective_control_device(
+                    19,
+                    19,
+                    0.75_f32.to_bits(),
+                    Some(0.5_f32.to_bits()),
+                    None,
+                ),
+                ore_device,
+            ]),
+            node_provider_status: MissionControlNodeProviderTableStatus::Available(vec![
+                synthetic_node_provider_row(0, 0, 1.0_f32.to_bits()),
+            ]),
+        };
+        let mut control_tables = vec![producer_table];
+
+        let totals = advance_behavior_distributor_tick(
+            &mut distributor,
+            1.0,
+            &world,
+            &mut ore_states,
+            &profiles,
+            &mut control_tables,
+        )
+        .expect("tick supported ore source");
+
+        assert_eq!(
+            totals[3],
+            0.375_f32.to_bits(),
+            "ore producers still query generic Control power demand"
+        );
+    }
+
+    #[test]
+    fn behavior_first_pass_clamps_tiny_deficits_and_overfull_stores() {
+        for (original_id, current, maximum, clamps) in [
+            (4, 0.995_f32, 1.0_f32, true),
+            (5, 1.25, 1.0, true),
+            (6, 0.0, f32::from_bits(0x3c23_d70a), false),
+        ] {
+            let mut world = new_world(WorldConfig);
+            let object = behavior_tick_test_object(&mut world, original_id, 0x8000_0001, 0.5);
+            let mut distributor = BehaviorDistributorState {
+                clan_index: 0,
+                super_ai_visible: true,
+                registered_objects: vec![object.clone()],
+            };
+            let mut ore_states = [BehaviorOreState {
+                original_id: object.original_id,
+                handle: object.handle,
+                class_flags: object.class_flags,
+                current_ore_bits: current.to_bits(),
+                maximum_ore_bits: maximum.to_bits(),
+            }];
+            let mut control_tables = [MissionControlDeviceTableState {
+                original_id: Some(object.original_id),
+                handle: object.handle,
+                status: MissionControlDeviceTableStatus::Available(Vec::new()),
+                node_provider_status: MissionControlNodeProviderTableStatus::Available(Vec::new()),
+            }];
+
+            advance_behavior_distributor_tick(
+                &mut distributor,
+                1.0,
+                &world,
+                &mut ore_states,
+                &[],
+                &mut control_tables,
+            )
+            .expect("native low-deficit clamp path");
+
+            let expected = if clamps { maximum } else { current };
+            assert_eq!(ore_states[0].current_ore_bits, expected.to_bits());
+        }
+    }
+
+    #[test]
     #[ignore = "requires licensed corpus"]
     fn licensed_campaign_preview_keeps_unsupported_init_without_partial_writes() {
         let root = licensed_root("IS");
diff --git a/crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs b/crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs
index 610e8db..4bf0e2b 100644
--- a/crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs
+++ b/crates/fparkan-runtime/tests/behavior_distributor_tick_native_oracle.cs
@@ -18,6 +18,7 @@ internal static class BehaviorDistributorTickOracle {
     private const string ExpectedControlSha256 = "bcb86318089028548a178b03a21accdce15df0cc85ddd91674cf3c2f55012c6e";
     private const string ExpectedArealMapSha256 = "a25f9254ebb339d70e2e07c8121950191e9584ca0858d8e9c2e2b6c671edf6ea";
     private const int TickRva = 0x19e80;
+    private const int DistributorScheduleRva = 0x1adb0;
     private const int AddObjectRva = 0x1aac0;
     private const int NormalizeRva = 0x1ac90;
     private const int IndexedPropertySetRva = 0x0b470;
@@ -27,6 +28,7 @@ internal static class BehaviorDistributorTickOracle {
     private const int BehaviorVarBlockConstructorRva = 0x22d90;
     private const int BehaviorVarFieldRegisterRva = 0x22e20;
     private const int GetSystemArealMapIatRva = 0x59008;
+    private const int GetQueueIatRva = 0x59110;
     private const int ControlResourceDeviceGetterRva = 0x21d00;
     private const int ControlResourceAggregateQueryRva = 0x2b410;
     private const int ControlResourceAggregateSetRva = 0x2ba30;
@@ -66,6 +68,9 @@ internal static class BehaviorDistributorTickOracle {
     [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate void X87ControlWordReader();
     [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate void X87ControlWordWriter();
     [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void TickDelegate(IntPtr self, float deltaSeconds);
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate void NativeBehaviorSchedule(IntPtr self);
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate IntPtr QueueGetter();
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate uint QueueClockGetter(IntPtr self);
     [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate void NativeAddObject(IntPtr self, uint key);
     [UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeNormalize(IntPtr self, uint key);
     [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate void VectorInsert(IntPtr self, IntPtr source, uint count, uint position);
@@ -100,6 +105,8 @@ internal static class BehaviorDistributorTickOracle {
     [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate void NativeControlNodeUpdateCallback(IntPtr self, uint nodeIndex, uint selector, uint valueBits);
 
     private static readonly AreaMapGetter AreaMapGetterCallback = GetAreaMap;
+    private static readonly QueueGetter QueueGetterCallback = GetQueue;
+    private static readonly QueueClockGetter QueueClockGetterCallback = GetQueueTime;
     private static readonly VectorInsert VectorInsertCallback = InsertVector;
     private static readonly MapLookup MapLookupCallback = Lookup;
     private static readonly ObjectState ObjectStateCallback = GetObjectState;
@@ -127,6 +134,7 @@ internal static class BehaviorDistributorTickOracle {
     private static X87ControlWordWriter x87ControlWordWriter;
     private static readonly NativeBehaviorProfileLoadCallback BehaviorProfileLoadCallback = CaptureBehaviorProfileLoad;
     private static readonly List<BehaviorProfileSelection> behaviorProfileSelections = new List<BehaviorProfileSelection>();
+    private static Fixture activeQueueFixture;
 
     private sealed class BehaviorProfileSelection {
         public IntPtr Owner;
@@ -168,6 +176,9 @@ internal static class BehaviorDistributorTickOracle {
         public IntPtr VectorVtable;
         public IntPtr Manager;
         public IntPtr ManagerVtable;
+        public IntPtr Queue;
+        public IntPtr QueueVtable;
+        public uint QueueTime;
         public readonly List<IntPtr> Allocations = new List<IntPtr>();
         public readonly Dictionary<uint, NativeObject> ByKey = new Dictionary<uint, NativeObject>();
         public readonly List<string> Calls = new List<string>();
@@ -221,6 +232,8 @@ internal static class BehaviorDistributorTickOracle {
             Marshal.WriteInt32(Distributor, 0x20, keys.Length);
             Marshal.WriteInt32(Distributor, 0x24, capacity);
             Marshal.WriteIntPtr(Distributor, 0x28, Entries);
+            Marshal.WriteInt16(Distributor, 0x18, 3);
+            Marshal.WriteInt16(Distributor, 0x1a, 1);
             for (int i = 0; i < keys.Length; i++) {
                 IntPtr entry = IntPtr.Add(Entries, i * 0x1c);
                 Marshal.WriteInt32(entry, 0x00, unchecked((int)keys[i]));
@@ -233,8 +246,16 @@ internal static class BehaviorDistributorTickOracle {
             Allocations.Add(value);
             return value;
         }
+        public void MakeQueue(uint time) {
+            QueueTime = time;
+            QueueVtable = Allocate(0x40);
+            Queue = Allocate(0x20);
+            Marshal.WriteIntPtr(Queue, 0, QueueVtable);
+            Marshal.WriteIntPtr(QueueVtable, 0x38, Marshal.GetFunctionPointerForDelegate(QueueClockGetterCallback));
+        }
         public void Dispose() {
             active = null;
+            if (activeQueueFixture == this) activeQueueFixture = null;
             for (int i = Allocations.Count - 1; i >= 0; i--) Marshal.FreeHGlobal(Allocations[i]);
             Allocations.Clear();
         }
@@ -287,6 +308,16 @@ internal static class BehaviorDistributorTickOracle {
     }
 
     private static IntPtr GetAreaMap() { return active.Manager; }
+    private static IntPtr GetQueue() {
+        if (activeQueueFixture == null || activeQueueFixture.Queue == IntPtr.Zero)
+            throw new InvalidOperationException("native scheduler requested a queue without a fixture");
+        return activeQueueFixture.Queue;
+    }
+    private static uint GetQueueTime(IntPtr self) {
+        if (activeQueueFixture == null || self != activeQueueFixture.Queue)
+            throw new InvalidOperationException("native scheduler queried an unexpected queue");
+        return activeQueueFixture.QueueTime;
+    }
     private static int OnArealMapEvent(IntPtr owner, uint message, uint subcode, IntPtr descriptor) {
         ArealMapFixture fixture = activeArealMap;
         if (fixture == null) return 0;
@@ -493,7 +524,9 @@ internal static class BehaviorDistributorTickOracle {
             FreeLibrary(module); FreeLibrary(controlModule); return 12;
         }
         IntPtr import = IntPtr.Add(module, GetSystemArealMapIatRva);
+        IntPtr queueImport = IntPtr.Add(module, GetQueueIatRva);
         IntPtr originalImport = Marshal.ReadIntPtr(import);
+        IntPtr originalQueueImport = Marshal.ReadIntPtr(queueImport);
         uint oldProtection = 0;
         bool protectionChanged = false;
         bool thunksAllocated = false;
@@ -513,8 +546,9 @@ internal static class BehaviorDistributorTickOracle {
                 throw new InvalidOperationException("VirtualProtect(GetSystemArealMap IAT) failed: " + Marshal.GetLastWin32Error());
             protectionChanged = true;
             Marshal.WriteIntPtr(import, Marshal.GetFunctionPointerForDelegate(AreaMapGetterCallback));
+            Marshal.WriteIntPtr(queueImport, Marshal.GetFunctionPointerForDelegate(QueueGetterCallback));
             RunSmokeCases(module, controlModule, arealMapModule);
-            Console.WriteLine("original native Behavior/ArealMap/Control oracle passed (Behavior Add 0x1aac0, normalize 0x1ac90, tick 0x19e80; ArealMap UnitDAT projection 0x14b90; Control INTO override 0x2d890; only synthetic host callbacks, GetSystemArealMap IAT, and bounded vector insertion are substituted; this does not compare Rust parity).");
+            Console.WriteLine("original native Behavior/ArealMap/Control oracle passed (Behavior Add 0x1aac0, normalize 0x1ac90, scheduler 0x1adb0, tick 0x19e80; ArealMap UnitDAT projection 0x14b90; Control INTO override 0x2d890; synthetic host callbacks, GetSystemArealMap/GetQueue IAT slots, and bounded vector insertion are substituted; scheduler and tick machine code are original; this does not compare Rust parity).");
             return 0;
         }
         catch (Exception error) {
@@ -524,10 +558,12 @@ internal static class BehaviorDistributorTickOracle {
         finally {
             if (protectionChanged) {
                 Marshal.WriteIntPtr(import, originalImport);
+                Marshal.WriteIntPtr(queueImport, originalQueueImport);
                 uint ignored;
                 VirtualProtect(import, new UIntPtr((uint)IntPtr.Size), oldProtection, out ignored);
             }
-            GC.KeepAlive(AreaMapGetterCallback); GC.KeepAlive(VectorInsertCallback); GC.KeepAlive(x87ControlWordReader); GC.KeepAlive(x87ControlWordWriter); GC.KeepAlive(MapLookupCallback);
+            GC.KeepAlive(AreaMapGetterCallback); GC.KeepAlive(QueueGetterCallback); GC.KeepAlive(QueueClockGetterCallback);
+            GC.KeepAlive(VectorInsertCallback); GC.KeepAlive(x87ControlWordReader); GC.KeepAlive(x87ControlWordWriter); GC.KeepAlive(MapLookupCallback);
             GC.KeepAlive(ObjectStateCallback); GC.KeepAlive(ObjectClassCallback);
             GC.KeepAlive(ObjectQueryCallback); GC.KeepAlive(ObjectRateCallback);
             GC.KeepAlive(ObjectGetPropertyCallback); GC.KeepAlive(ObjectSetPropertyCallback);
@@ -565,6 +601,19 @@ internal static class BehaviorDistributorTickOracle {
         }
         RunNativeIndexedPropertyCases(module);
         RunNativeOreInitializationCases(module);
+        ushort tickControlWord = CurrentX87ControlWord();
+        try {
+            SetX87ControlWord(0x007f);
+            Expect(CurrentX87ControlWord() == 0x007f, "Behavior resource-distributor tick uses the measured game x87 control word");
+            Console.WriteLine("native-behavior-tick-x87-control-word=0x" + CurrentX87ControlWord().ToString("x4"));
+            RunNativeBehaviorTickCases(module);
+            RunNativeBehaviorSchedulerCases(module);
+        } finally {
+            SetX87ControlWord(tickControlWord);
+        }
+    }
+
+    private static void RunNativeBehaviorTickCases(IntPtr module) {
         TickDelegate tick = (TickDelegate)Marshal.GetDelegateForFunctionPointer(IntPtr.Add(module, TickRva), typeof(TickDelegate));
         using (Fixture empty = NewFixture()) {
             empty.MakeDistributor(); active = empty; tick(empty.Distributor, 0.0f);
@@ -579,6 +628,10 @@ internal static class BehaviorDistributorTickOracle {
         RunObjectCase(tick, 0x80000008, 0.5f, 0.0f, 3.0f, 0, 2.0f, "ore-80000008");
         RunMixedOreCase(tick, "mixed-ore-producer-recipient", 1.0f, 0.5f);
         RunMixedOreCase(tick, "bounded-ore-store", 0.25f, 0.5f);
+        RunOreAllocationBranch(tick, "ore-allocation-middle", 0.25f, 2.0f, 0.25f, 0.625f, 1.75f, 0.5f);
+        RunOreAllocationBranch(tick, "ore-allocation-surplus", 2.0f, 3.0f, 0.25f, 0.625f, 2.625f, 0.625f);
+        RunOreAllocationBranch(tick, "ore-allocation-equality", 0.375f, 2.0f, 0.25f, 0.625f, 1.625f, 0.625f);
+        RunNativeOreClampCases(tick);
         RunWeightedOreCase(tick);
         RunMixedPowerCase(tick, "mixed-power-sufficient", 4.0f, 1.0f, 0.5f, 0.75f);
         RunMixedPowerCase(tick, "mixed-power-shortage", 0.125f, 1.0f, 0.5f, 0.75f);
@@ -587,6 +640,62 @@ internal static class BehaviorDistributorTickOracle {
         RunSkippedCase(tick);
     }
 
+    private static void RunNativeBehaviorSchedulerCases(IntPtr module) {
+        NativeBehaviorSchedule schedule = (NativeBehaviorSchedule)Marshal.GetDelegateForFunctionPointer(
+            IntPtr.Add(module, DistributorScheduleRva), typeof(NativeBehaviorSchedule));
+        uint[] elapsedVectors = { 1, 1001, 16777217, 16777219, 0xffffffff };
+        uint[] expectedBits = { 0x3a83126f, 0x3f8020c5, 0x46831270, 0x46831271, 0x4a83126f };
+        for (int i = 0; i < elapsedVectors.Length; i++) {
+            uint elapsed = elapsedVectors[i];
+            uint now = unchecked(1u + elapsed);
+            RunNativeSchedulerSample(schedule, now, 1, 0, expectedBits[i], "elapsed-" + elapsed.ToString());
+        }
+
+        using (Fixture fixture = NewFixture()) {
+            NativeObject producer = fixture.AddObject(0x75, 0x80000002, 1.0f, 0.0f, 0.0f, 0);
+            fixture.MakeDistributor(producer.Key);
+            fixture.MakeQueue(10);
+            active = fixture;
+            activeQueueFixture = fixture;
+            Marshal.WriteInt32(fixture.Distributor, 0x10, 1);
+            Marshal.WriteInt32(fixture.Distributor, 0x14, 10);
+            Marshal.WriteInt32(fixture.Distributor, 0x30, unchecked((int)0x41200000));
+            schedule(fixture.Distributor);
+            Expect(fixture.LookupCount == 0 && unchecked((uint)Marshal.ReadInt32(fixture.Distributor, 0x30)) == 0x41200000,
+                "scheduler equality with the deadline performs no resource tick or totals write");
+
+            fixture.QueueTime = 11;
+            schedule(fixture.Distributor);
+            uint deadlineTotal = unchecked((uint)Marshal.ReadInt32(fixture.Distributor, 0x30));
+            Expect(fixture.LookupCount == 2 && deadlineTotal == 0x3c23d70b,
+                "scheduler ticks only after the deadline is strictly passed (lookups=" + fixture.LookupCount +
+                ", total=" + Hex(deadlineTotal) + ")");
+            Console.WriteLine("scheduler-deadline: equality=skip; now=11 delta=0.01; lookups=" + fixture.LookupCount);
+        }
+
+        RunNativeSchedulerSample(schedule, 0, 0xffffffff, 0, 0x3a83126f, "wrapped-elapsed-1");
+        GC.KeepAlive(schedule);
+    }
+
+    private static void RunNativeSchedulerSample(
+        NativeBehaviorSchedule schedule, uint now, uint firstTime, uint deadline, uint expectedTotalBits, string label) {
+        using (Fixture fixture = NewFixture()) {
+            NativeObject producer = fixture.AddObject(0x74, 0x80000002, 1.0f, 0.0f, 0.0f, 0);
+            fixture.MakeDistributor(producer.Key);
+            fixture.MakeQueue(now);
+            active = fixture;
+            activeQueueFixture = fixture;
+            Marshal.WriteInt32(fixture.Distributor, 0x10, unchecked((int)firstTime));
+            Marshal.WriteInt32(fixture.Distributor, 0x14, unchecked((int)deadline));
+            schedule(fixture.Distributor);
+            uint actual = unchecked((uint)Marshal.ReadInt32(fixture.Distributor, 0x30));
+            Expect(actual == expectedTotalBits,
+                label + " native qword-to-f32 scheduler delta expected " + Hex(expectedTotalBits) + " got " + Hex(actual));
+            Console.WriteLine("native-scheduler-" + label + ": now=" + now.ToString("x8") + " first=" + firstTime.ToString("x8") +
+                " total=" + Hex(actual) + " lookups=" + fixture.LookupCount);
+        }
+    }
+
     private static void RunNativeControlResourceDeviceCase(IntPtr module) {
         Expect(CurrentX87ControlWord() == 0x007f, "Control selector 0x300 uses x87 control word 0x007f");
         const uint key = 2;
@@ -1641,6 +1750,58 @@ internal static class BehaviorDistributorTickOracle {
         }
     }
 
+    private static void RunOreAllocationBranch(
+        TickDelegate tick, string label, float rate, float stock, float recipientCurrent, float recipientMaximum,
+        float expectedProducerRemaining, float expectedRecipientResult) {
+        using (Fixture fixture = NewFixture()) {
+            NativeObject producer = fixture.AddObject(0x46, 0x80000004, 0.0f, rate, stock, 0);
+            producer.PropertyMetadata = FloatBits(10.0f);
+            NativeObject recipient = fixture.AddObject(0x47, 0x80000001, 0.0f, 0.0f, recipientCurrent, 0);
+            recipient.PropertyMetadata = FloatBits(recipientMaximum);
+            recipient.InterfaceSelector1 = 0.5f;
+            recipient.InterfaceSelector2 = 0.0f;
+            fixture.MakeDistributor(producer.Key, recipient.Key);
+            Marshal.WriteInt32(fixture.Entries, 0x04, FloatBits(1.0f));
+            Marshal.WriteInt32(fixture.Entries, 0x1c + 0x04, FloatBits(0.5f));
+            active = fixture;
+            tick(fixture.Distributor, 1.0f);
+            Console.WriteLine(label + ": totals=[" + Float(ReadFloat(fixture.Distributor, 0x30)) + "," +
+                Float(ReadFloat(fixture.Distributor, 0x34)) + "," + Float(ReadFloat(fixture.Distributor, 0x38)) + "," +
+                Float(ReadFloat(fixture.Distributor, 0x3c)) + "," + Float(ReadFloat(fixture.Distributor, 0x40)) +
+                "]; stored=[" + Float(producer.Property) + "," + Float(recipient.Property) + "] reads=" + producer.OreRateReads);
+            Expect(ReadFloat(fixture.Distributor, 0x34) == Math.Min(rate, stock) &&
+                ReadFloat(fixture.Distributor, 0x40) == recipientMaximum - recipientCurrent &&
+                producer.Property == expectedProducerRemaining && recipient.Property == expectedRecipientResult &&
+                producer.OreRateReads == 2 && producer.Writes == 1 && recipient.Writes == 1 && fixture.LookupCount == 4,
+                label + " native allocation branch totals and two-pass reread");
+        }
+    }
+
+    private static void RunNativeOreClampCases(TickDelegate tick) {
+        float[][] states = {
+            new float[] { 0.995f, 1.0f, 1.0f },
+            new float[] { 1.25f, 1.0f, 1.0f },
+            new float[] { 0.0f, 0.01f, 0.0f }
+        };
+        foreach (float[] state in states) {
+            float current = state[0];
+            float maximum = state[1];
+            float expected = state[2];
+            using (Fixture fixture = NewFixture()) {
+                NativeObject item = fixture.AddObject(0x48, 0x80000001, 0.0f, 0.0f, current, 0);
+                item.PropertyMetadata = FloatBits(maximum);
+                item.InterfaceSelector2 = 0.0f;
+                fixture.MakeDistributor(item.Key);
+                active = fixture;
+                tick(fixture.Distributor, 1.0f);
+                Expect(item.Property == expected && item.Writes > 0 && fixture.LookupCount == 2,
+                    "native first-pass ore clamp for CurrentOre=" + Float(current));
+                Console.WriteLine("native-ore-clamp: current=" + Float(current) + " maximum=" + Float(maximum) + " result=" +
+                    Float(item.Property) + " writes=" + item.Writes);
+            }
+        }
+    }
+
     private static void RunMixedPowerCase(TickDelegate tick, string label, float powerRate, float recipientProperty, float selector1, float selector2) {
         using (Fixture fixture = NewFixture()) {
             NativeObject producer = fixture.AddObject(0x61, 0x80000002, powerRate, 0.0f, 1.0f, 0);
diff --git a/docs/appendices/knowledge-boundaries.md b/docs/appendices/knowledge-boundaries.md
index 3744d84..b9bbf27 100644
--- a/docs/appendices/knowledge-boundaries.md
+++ b/docs/appendices/knowledge-boundaries.md
@@ -325,17 +325,28 @@ sidecar недоступен, запрос `0xe00` сообщает это от�
 
 Rust query обращается к загруженному объекту и поддерживает `0xe00` только для
 текущего descriptor tag `26` с factory tag `26`; другие активные typed tags и
-factory paths остаются явными границами. Snapshot показывает состояние сразу
-после native-конструкторов, но он не обновляется при Control tick-е. Native
-`FUN_10010f30` (RVA `0x10f30`) изменяет и ограничивает provider amount, а
-связанные callbacks переносят его между строками; их общий переход в Rust ещё
-не реализован. Поэтому вызов нельзя считать живым ресурсным симулятором.
+factory paths остаются явными границами. Этот запрос возвращает начальный
+снимок provider amount: Native `FUN_10010f30` (RVA `0x10f30`) изменяет и
+ограничивает количество, а связанные callbacks переносят его между строками;
+этот переход в Rust ещё не реализован.
+
+Отдельный API `advance_loaded_mission_resources` принимает явное время очереди
+и обновляет представленные поля `CurrentOre`, строк распределителя и Control
+selector `1`. Его граница — статические снимки профиля и provider-значений:
+динамическое распространение Control amount, смена профилей, special
+object-state gate и жизненный цикл созданных/удалённых объектов здесь не
+моделируются. Если обязательный запрос позднего объекта не поддержан,
+транзакция возвращает ошибку и не применяет подготовленные изменения. API не
+подключён к игровому циклу; AutoDemo-тест подтверждает связь настоящих профилей
+с этим шагом, но не полный паритет миссии. Отдельный aggregate getter Behavior
+RVA `0xa490` в oracle не исполнен.
+
 Behavior selectors `0x1002` и `0x1005` используют значения выбранного
 профиля из `behpsp.res`, разобранного до создания нового мира. `0x1002` складывает
 только текущие descriptor tag `26` запросы `0xe00`, затем применяет
 `Transfer_Ore_OffBoard`; `0x1005` возвращает `Transfer_Power_Out`. Это начальный
-снимок: он не отражает последующие изменения provider-строк, Control tick-а или
-профиля. Полная загрузка сохраняет результат у `ObjectHandle` и возвращает
+снимок профиля и provider-строк. Полная загрузка сохраняет результат у
+`ObjectHandle` и возвращает
 ошибку, если известный код класса не имеет корректной записи; класс,
 отсутствующий в таблице выбора, сохраняет начальные значения конструктора.
 Preview и объекты без полного Unit DAT не получают профильное состояние.
diff --git a/docs/appendices/script-vm.md b/docs/appendices/script-vm.md
index c15b208..99c448f 100644
--- a/docs/appendices/script-vm.md
+++ b/docs/appendices/script-vm.md
@@ -373,10 +373,17 @@ nearest-even `FISTP qword`, младший DWORD, преобразование D
 deadline `+0x14` по формуле `время + 3*64 + jitter`, где `jitter` лежит в
 `0..63` и получен одним шагом глобального MSVCRT LCG. В этой ветви она также
 обнуляет пять слов `+0x30..+0x40`. При повторном вызове до deadline ненулевой
-`+0x10` оставляет deadline прежним, не расходует новое случайное число и не
-очищает эти слова. Поведение после истечения deadline этим опытом не проверено.
-Если само время очереди равно нулю, `+0x10` остаётся нулевым, и повторный вызов
-снова проходит ветвь начальной подготовки.
+`+0x10` оставляет срок прежним, не расходует новое случайное число и не
+очищает эти слова. Если само время очереди равно нулю, `+0x10` остаётся
+нулевым, и повторный вызов снова проходит ветвь начальной подготовки. После
+срока scheduler продолжает при нулевом deadline или при беззнаковом
+`now > deadline`; равенство ненулевому deadline ещё ждёт. Он считает
+`u32(now - first_time)` с переполнением по модулю `2^32`, переводит миллисекунды в секунды через x87
+`FILD`/`FMUL`/`FSTP` и планирует следующий срок от текущего времени. Шаг
+интервала равен `3 * 64 + jitter`: один шаг LCG `state = state * 214013 +
+2531011` выдаёт значение `random = (state >> 16) & 0x7fff`, а
+`jitter = ((random & 0xff) * 64) >> 8`. Native oracle проверяет
+равенство и проход срока, обёртку и большие интервалы с округлением времени.
 
 Путь host callback в проверенной паре DLL теперь статически известен. В
 `iron3d.dll` функция `FUN_1005ff40` (RVA `0x5ff40`) сначала вызывает
@@ -400,9 +407,11 @@ callback-точку входа и порядок внутри неё, но не
 bundle, но остальные потребители исходного глобального RNG не моделируются.
 В Rust также нет значения аргумента в `AI+0x3fc`, recursion guard `AI+0x78`
 или одноразового latch `AI+0x8a8`. Поэтому это связанный начальный поднабор, а
-не полная активация SuperAI. Восстановленный ниже distributor tick проверен на
-исходной DLL, но пока не подключён к Rust игровому циклу: у runtime нет
-ArealMap-объектов и интерфейсов, которые нужны этому вызову. При
+не полная активация SuperAI. После полной загрузки узкая Rust-реализация
+вызывается явно через `advance_loaded_mission_resources(engine, queue_time_ms)`;
+runtime не читает системную очередь, а приложение пока не вызывает API из
+игрового цикла. Шаг использует разрешённые handles и представленные snapshots
+профилей и Control, поэтому не воспроизводит отсутствующие в них callbacks. При
 ошибке ограниченного `Init` Rust отклоняет полную загрузку и сохраняет прежний
 мир и состояние генератора; такая политика отката принадлежит Rust loader-у.
 
@@ -428,9 +437,33 @@ DWORD по смещению `+0x14` как `f32`; если выходной ук
 пока не получило доменного имени. Идентификаторы и границы вызовов не
 задают полную семантику свойств.
 
-Изолированный x86 oracle вызывает исходный tick с подменой только IAT-слота
-`GetSystemArealMap`; синтетические vtables записывают последовательность
-вызовов и ответы. Для смешанного примера два прохода нашли объекты в порядке
+Раздача считает доступный за этот шаг объём `A`, полный спрос `D` и взвешенный
+спрос `W = Σ(demand × share)`. Из них выводятся коэффициенты приоритетной доли
+`P`, остатка `R` и расхода `C`. В таблице ниже показан исходный порядок
+проверок: он важен, когда нестандартные доли дают `W > D`.
+
+| Первое совпавшее условие (при `A > 0`, `D > 0`) | `P` | `R` | `C` |
+| --- | ---: | ---: | ---: |
+| `A ≤ W` | `A / W` | `0` | `1` |
+| `W < A < D` | `1` | `(A − W) / (D − W)` | `1` |
+| `A ≥ D` | `1` | `1` | `D / A` |
+
+При нулевом доступном количестве или спросе native path не выделяет
+положительное значение. Строка с долей `share` получает коэффициент
+`(1 − share) × R + share × P`, который сочетается с её спросом или доступной
+вместимостью. `C` задаёт долю отбора руды у источников; для источников энергии
+этот коэффициент вычисляется, но native-код не применяет его к производству.
+У объектов в ветви приёма руды (не источников руды) native-код ограничивает `CurrentOre`:
+если `MaximumOre − CurrentOre < 0.01`, значение становится `MaximumOre`.
+Сравнение строгое: при разнице ровно `0.01` значение не меняется.
+В x86-коде это константа `0x3c23d70a`; сравнение и округление проверены при
+игровом x87 control word `0x007f`.
+
+Изолированный x86 oracle вызывает исходный scheduler RVA `0x1adb0`, который
+сам вызывает исходный tick RVA `0x19e80`. Для синтетического времени он
+подменяет IAT-слот `GetQueue`; tick подменяет `GetSystemArealMap`, а синтетические
+vtables записывают последовательность вызовов и ответы. Для смешанного примера
+два прохода нашли объекты в порядке
 `41,42,41,42`. Производитель руды с начальным значением `1` и скоростью `4`
 вернул при следующем чтении скорость `1`; получатель с начальным значением `6`
 получил `7`, а агрегаты distributor равны `[0,1,1,0.375,6]`. При запасе
@@ -441,11 +474,13 @@ selector `1` на интерфейсе получателя становится
 `0x3f2aaaab`). Эти векторы проверяют арифметику исходной функции, но не
 распределение реальной карты.
 
-Полная загрузка Rust теперь собирает этот список из runtime `ObjectHandle` и
-сохраняет веса вместе с пятью исходными DWORD хвоста каждой записи. Членство
-строится только для полного режима; preview остаётся статическим. Это пока не
-даёт ресурсных полей и интерфейсов ArealMap для `FUN_10019e80`, а
-`step_headless` по-прежнему шагает только `World`.
+Полная загрузка Rust собирает этот список из runtime `ObjectHandle` и сохраняет
+веса и поля строк, а также начальные ore-свойства объектов. Членство строится
+только для полного режима; preview остаётся статическим. Явный API
+`advance_loaded_mission_resources` использует очередь времени, расписание,
+профили и представленные Control-таблицы, чтобы исполнить этот ограниченный
+шаг над загруженным состоянием. `step_headless` по-прежнему шагает только
+`World`.
 
 ### Добавление и нормализация долей
 
@@ -520,17 +555,21 @@ exit $LASTEXITCODE
 
 Oracle проверяет SHA-256 оригинального `Behavior.dll`:
 `ddfbdbde07832358fe6e35e01c8dba9b58e7313789498b6049ed51d4ed9baf99`. Harness
-явно устанавливает x87 CW `0x007f` для вызовов Add (`0x1aac0`) и normalize
-(`0x1ac90`), проверяет CW до и после каждого вызова и восстанавливает прежнее
-значение перед tick suite. Для этих двух методов подменяется только bounded
-вставка синтетического vector; их машинный код не патчится. Для tick helper
-подменяет только IAT-слот `GetSystemArealMap` и вызывает RVA `0x19e80`.
-Проверяются нулевой
-шаг, обе ветви селекторов скорости, пропуск состояния `0xfffe`, missing lookup,
-динамическое повторное чтение `0x1002`, ограниченный запас руды, разные веса,
-достаточное и недостаточное значение мощности. Это синтетические ArealMap
-объекты; исполнение оригинальной функции проверяет векторы oracle, но не
-подменяет сравнение Rust и интеграционную проверку миссии в игре.
+явно устанавливает x87 CW `0x007f` для Add (`0x1aac0`), normalize (`0x1ac90`)
+и scheduler/tick (`0x1adb0`/`0x19e80`), проверяя слово перед набором вызовов
+и восстанавливая прежнее значение после каждого набора. Для Add и normalize
+подменяется только bounded вставка синтетического vector; их машинный код не
+патчится. Scheduler и tick тоже исполняются оригинальными: подменяются лишь
+IAT-слоты `GetQueue` и `GetSystemArealMap`, а synthetic vtables задают часы и
+ответы объектов. Проверяются равенство и проход срока, переполнение времени
+и точные `f32`-биты elapsed seconds (`1 → 0x3a83126f`, `1001 → 0x3f8020c5`,
+`16777217 → 0x46831270`, `16777219 → 0x46831271`, `u32::MAX → 0x4a83126f`).
+Tick-векторы проверяют нулевой шаг, обе ветви селекторов скорости, пропуск
+состояния `0xfffe`, отсутствующий объект, повторное чтение `0x1002`, ограниченный
+запас руды, порог `0.01`, ветви дефицита/частичного/избыточного предложения и
+равенство спросу, разные веса и достаточную/недостаточную мощность. Это
+синтетические ArealMap объекты: oracle исполняет оригинальные scheduler и tick,
+но не сравнивает паритет Rust и не заменяет проверку полной миссии в игре.
 
 Caller oracle проверяет AutoDemo пару `(500.2857, 751.8217)`, четыре режима
 x87 на tie-векторах, границу `10000` и младший DWORD. AI oracle отдельно
diff --git a/docs/tomes/06-behavior.md b/docs/tomes/06-behavior.md
index bcb7320..b3dd8d0 100644
--- a/docs/tomes/06-behavior.md
+++ b/docs/tomes/06-behavior.md
@@ -326,8 +326,48 @@ Resource Distributor работает со списком зарегистрир
 записях при игровом x87 control word `0x007f`: проверены добавление, повторный
 ключ, закреплённая запись, нулевая сумма и округление. Это позволяет Rust
 сохранять начальный список, но пока не подтверждает веса реальных объектов в
-живой миссии. Для регулярного шага по-прежнему не хватает интерфейсов ArealMap.
-Остальные ограничения собраны в [границах знания](../appendices/knowledge-boundaries.md).
+живой миссии.
+
+Узкая часть регулярного шага уже связана с загруженным состоянием движка.
+`advance_loaded_mission_resources(engine, queue_time_ms)` принимает явную
+метку времени общей 32-битной очереди. Для каждого видимого Behavior clan он
+проверяет срок запуска, выполняет два прохода по списку и сохраняет пять
+итогов: доступную энергию и руду, буфер руды, потребление энергии и потребление
+руды. В обоих проходах объекты разрешаются заново по исходному TMA ID. Первый
+проход измеряет поставки и потребность, второй повторно читает представленные
+профильные и Control-значения перед применением выделения. Нативный код также
+запрашивает интерфейсы во втором проходе, но динамические getter-callbacks в
+этом снимке Rust не воспроизводятся.
+
+Планировщик использует беззнаковое сравнение времени: равенство ненулевому
+сроку ещё не запускает шаг, а нулевой срок не задерживает его. Переполнение
+вычитания даёт 32-битную длительность. Затем
+длительность переводится в секунды с округлением, подтверждённым x87-путём
+оригинальной DLL. Нативный oracle проверяет его на длинных интервалах, включая
+значения около границы точного целого `f32`, а также на равенстве и строгом
+проходе срока. Формула запуска, native vectors и команда воспроизведения
+описаны в технической главе [script VM](../appendices/script-vm.md).
+
+Шаг работает только с уже созданными полными объектами миссии и снимками тех
+профилей и Control-таблиц, чьи запросы и setters представлены в runtime. Он
+обновляет загруженные `CurrentOre`, поля строк распределителя и поддержанный
+Control selector `1`; неподдержанное свойство, запрос Control или невозможное
+арифметическое значение возвращает ошибку. Обновления нескольких кланов, их
+расписания и RNG фиксируются одной транзакцией: если обязательный запрос
+позднего клана не разрешён, ранее подготовленные изменения остаются
+неприменёнными. Приложение пока не вызывает
+этот API из игрового цикла, а динамические callbacks, которые переносят
+количество между Control provider-строками, ещё не моделируются. Поэтому это
+исполняемый загруженный resource step, а не полный симулятор миссии.
+
+Для настоящих ресурсов AutoDemo тест проходит несколько временных точек:
+генераторы `ObjectId 6` и `ObjectId 7` читают `Transfer_Power_Out = 10` из
+`prof_generator.var`; после шага в 500 мс каждый сообщает 5 единиц доступной
+энергии. Это подтверждает связь загруженного профиля с runtime-расчётом, но не
+сравнение полной миссии с оригинальной игрой. Native oracle сверяет исходные
+планировщик и распределитель GOG `Behavior.dll`; техническая процедура и
+проверяемые векторы описаны в [script VM](../appendices/script-vm.md). Остальные ограничения собраны в
+[границах знания](../appendices/knowledge-boundaries.md).
 
 Первый часто встречающийся table entry с side effect — `Handler(2)` (176
 records в corpus). Он берёт active instruction, разрешает семь slots через