refactor: lift rhai scripting into nightshade-api as a typed command binding

Scripts now produce typed Command values directly, deserialized from the
rhai value with no in-process json round trip. The runtime moves out of
the engine to live next to the Command enum in nightshade-api, the driver
owns the ScriptRuntime, and the engine drops its script resource, system,
schedule entry, and rhai dependency.

Ref::Existing now resolves in O(1) against the engine entity locations and
recovers the current generation, replacing a linear entity scan. The event
journal stores typed events only, and the editor command log reads labels
and entity ids off the typed command buffer instead of scanning detail
strings. The console field builder is driven by the command manifest roles
rather than json schema heuristics.

Docs updated to match the api layer runtime and the typed streams.

Author: matthewjberger

apps/editor/Cargo.lock

@@ -34,14 +34,6 @@ fn signature(spec: &CommandSpec) -> String {
     }
 }
 
-/// A command's field types, keyed by field name, for the per-field tooltips.
-fn field_types(spec: &CommandSpec) -> HashMap<String, String> {
-    spec.fields
-        .iter()
-        .map(|field| (field.name.to_string(), field.type_name.to_string()))
-        .collect()
-}
-
 /// Every command variant the api exposes, as (name, arguments schema), read
 /// from the one source: `command_schema`. The builder lists all of them, so it
 /// always matches the `Command` enum instead of a hand-picked subset.
@@ -75,22 +67,10 @@ fn variant_fields(args: &Value) -> Vec<(String, Value)> {
         .unwrap_or_default()
 }
 
-/// Whether a field's schema is an entity `Ref`: an enum with an `Existing` or
-/// `Entity` arm, including the nullable `opt_entity` form. Those fields take a
-/// live entity, filled from the selection by id.
-fn is_entity_ref(schema: &Value) -> bool {
-    let arms = schema
-        .get("oneOf")
-        .or_else(|| schema.get("anyOf"))
-        .and_then(Value::as_array);
-    arms.is_some_and(|variants| {
-        variants.iter().any(|variant| {
-            variant
-                .get("properties")
-                .and_then(Value::as_object)
-                .is_some_and(|props| props.contains_key("Existing") || props.contains_key("Entity"))
-        })
-    })
+/// Whether a field's dispatch role binds a live entity, filled from the
+/// selection by id. Read from the manifest, not guessed from the schema shape.
+fn is_entity_role(role: &str) -> bool {
+    role == "entity" || role == "opt_entity"
 }
 
 /// The string options of a `string` enum field, for a dropdown.
@@ -125,63 +105,92 @@ fn number_array_len(schema: &Value) -> Option<usize> {
         .map(|count| count as usize)
 }
 
-/// The default text for a field, so the form starts valid and editable. Entity
-/// references prefill with the current selection by id.
-fn field_default(schema: &Value, selected: Option<u32>) -> String {
-    if is_entity_ref(schema) {
-        return selected.map(|id| id.to_string()).unwrap_or_default();
-    }
-    if let Some(options) = enum_options(schema) {
-        return options.into_iter().next().unwrap_or_default();
-    }
-    if let Some(len) = number_array_len(schema) {
-        return vec!["0"; len].join(", ");
-    }
-    match schema.get("type").and_then(Value::as_str) {
-        Some("integer") | Some("number") => "0".to_string(),
-        Some("boolean") => "false".to_string(),
-        Some("string") => String::new(),
-        _ => String::new(),
-    }
+/// The comma list `raw` parses to, dropping blank entries.
+fn parse_numbers(raw: &str) -> Vec<f64> {
+    raw.split(',')
+        .filter(|part| !part.trim().is_empty())
+        .map(|part| part.trim().parse::<f64>().unwrap_or(0.0))
+        .collect()
 }
 
-/// Converts a field's edited text into its json value, by the field's schema.
-fn field_to_json(schema: &Value, raw: &str) -> Value {
-    if is_entity_ref(schema) {
-        return json!({ "Existing": raw.trim().parse::<u32>().unwrap_or(0) });
-    }
-    if enum_options(schema).is_some() {
-        return json!(raw);
-    }
-    if number_array_len(schema).is_some() {
-        let numbers: Vec<f64> = raw
-            .split(',')
-            .filter(|part| !part.trim().is_empty())
-            .map(|part| part.trim().parse::<f64>().unwrap_or(0.0))
-            .collect();
-        return json!(numbers);
+/// The default text for a field, so the form starts valid and editable. The
+/// dispatch role picks the shape: an entity prefills with the current selection
+/// by id, a vec is a comma list, the rest fall to the schema's primitive type.
+fn field_default(role: &str, schema: &Value, selected: Option<u32>) -> String {
+    match role {
+        "entity" | "opt_entity" => selected.map(|id| id.to_string()).unwrap_or_default(),
+        "vec3" => vec!["0"; number_array_len(schema).unwrap_or(3)].join(", "),
+        _ => {
+            if let Some(options) = enum_options(schema) {
+                return options.into_iter().next().unwrap_or_default();
+            }
+            if let Some(len) = number_array_len(schema) {
+                return vec!["0"; len].join(", ");
+            }
+            match schema.get("type").and_then(Value::as_str) {
+                Some("integer") | Some("number") => "0".to_string(),
+                Some("boolean") => "false".to_string(),
+                _ => String::new(),
+            }
+        }
     }
-    match schema.get("type").and_then(Value::as_str) {
-        Some("integer") => json!(raw.trim().parse::<i64>().unwrap_or(0)),
-        Some("number") => json!(raw.trim().parse::<f64>().unwrap_or(0.0)),
-        Some("boolean") => json!(raw == "true"),
-        Some("string") => json!(raw),
-        _ => serde_json::from_str::<Value>(raw).unwrap_or(Value::Null),
+}
+
+/// Converts a field's edited text into its json value, dispatched by the
+/// manifest role first, then by the schema's primitive type for the rest.
+fn field_to_json(role: &str, schema: &Value, raw: &str) -> Value {
+    match role {
+        "entity" => json!({ "Existing": raw.trim().parse::<u32>().unwrap_or(0) }),
+        "opt_entity" => {
+            let trimmed = raw.trim();
+            if trimmed.is_empty() {
+                Value::Null
+            } else {
+                json!({ "Existing": trimmed.parse::<u32>().unwrap_or(0) })
+            }
+        }
+        "vec3" => json!(parse_numbers(raw)),
+        _ => {
+            if enum_options(schema).is_some() {
+                return json!(raw);
+            }
+            if number_array_len(schema).is_some() {
+                return json!(parse_numbers(raw));
+            }
+            match schema.get("type").and_then(Value::as_str) {
+                Some("integer") => json!(raw.trim().parse::<i64>().unwrap_or(0)),
+                Some("number") => json!(raw.trim().parse::<f64>().unwrap_or(0.0)),
+                Some("boolean") => json!(raw == "true"),
+                Some("string") => json!(raw),
+                _ => serde_json::from_str::<Value>(raw).unwrap_or(Value::Null),
+            }
+        }
     }
 }
 
-fn defaults_for(args: &Value, selected: Option<u32>) -> HashMap<String, String> {
-    variant_fields(args)
-        .into_iter()
-        .map(|(name, schema)| (name, field_default(&schema, selected)))
+fn defaults_for(
+    spec: &CommandSpec,
+    schemas: &HashMap<String, Value>,
+    selected: Option<u32>,
+) -> HashMap<String, String> {
+    spec.fields
+        .iter()
+        .map(|field| {
+            let schema = schemas.get(field.name).cloned().unwrap_or(Value::Null);
+            (
+                field.name.to_string(),
+                field_default(field.role, &schema, selected),
+            )
+        })
         .collect()
 }
 
-/// One labeled input for a field, chosen by the field's schema: a checkbox for
-/// a bool, a dropdown for a string enum, a pick-able id for an entity, a comma
-/// list for a vec, a number or text box otherwise.
+/// One labeled input for a field, chosen by the manifest role first, then the
+/// schema: a pick-able id for an entity, a comma list for a vec, then a checkbox
+/// for a bool, a dropdown for a string enum, a number or text box otherwise.
 fn field_input(
     name: String,
+    role: String,
     schema: Value,
     type_name: String,
     fields: RwSignal<HashMap<String, String>>,
@@ -196,10 +205,10 @@ fn field_input(
         });
     };
 
-    if is_entity_ref(&schema) {
+    if is_entity_role(&role) {
         let key_pick = name.clone();
-        let hint = if number_array_len(&schema).is_some() {
-            ""
+        let hint = if role == "opt_entity" {
+            "entity id (optional)"
         } else {
             "entity id"
         };
@@ -304,44 +313,53 @@ pub fn Console(
         catalog.with_value(|c| c.iter().map(|(name, _)| name.clone()).collect());
     let first = names.first().cloned().unwrap_or_default();
 
-    let args_for = move |name: &str| -> Option<Value> {
+    let schemas_for = move |name: &str| -> HashMap<String, Value> {
         catalog.with_value(|c| {
             c.iter()
                 .find(|(item, _)| item == name)
-                .map(|(_, args)| args.clone())
+                .map(|(_, args)| variant_fields(args).into_iter().collect())
+                .unwrap_or_default()
         })
     };
+    let spec_for =
+        move |name: &str| -> Option<CommandSpec> { docs.with_value(|map| map.get(name).cloned()) };
 
     let selected = RwSignal::new(first.clone());
     let fields: RwSignal<HashMap<String, String>> = RwSignal::new(
-        args_for(&first)
-            .map(|args| {
+        spec_for(&first)
+            .map(|spec| {
                 defaults_for(
-                    &args,
+                    &spec,
+                    &schemas_for(&first),
                     state.selected.get_untracked().map(|detail| detail.id),
                 )
             })
             .unwrap_or_default(),
     );
 
     let choose = move |name: String| {
-        if let Some(args) = args_for(&name) {
+        if let Some(spec) = spec_for(&name) {
             let selected_id = state.selected.get_untracked().map(|detail| detail.id);
-            fields.set(defaults_for(&args, selected_id));
+            fields.set(defaults_for(&spec, &schemas_for(&name), selected_id));
         }
         selected.set(name);
     };
 
     let submit = move |_| {
         let name = selected.get();
-        let Some(args) = args_for(&name) else {
+        let Some(spec) = spec_for(&name) else {
             return;
         };
+        let schemas = schemas_for(&name);
         let mut object = serde_json::Map::new();
         fields.with(|map| {
-            for (field, schema) in variant_fields(&args) {
-                let raw = map.get(&field).cloned().unwrap_or_default();
-                object.insert(field, field_to_json(&schema, &raw));
+            for field in &spec.fields {
+                let raw = map.get(field.name).cloned().unwrap_or_default();
+                let schema = schemas.get(field.name).cloned().unwrap_or(Value::Null);
+                object.insert(
+                    field.name.to_string(),
+                    field_to_json(field.role, &schema, &raw),
+                );
             }
         });
         let command = json!({ name: Value::Object(object) });
@@ -497,18 +515,28 @@ pub fn Console(
                 <div class="console-fields">
                     {move || {
                         let name = selected.get();
-                        let types = docs
-                            .with_value(|map| map.get(&name).map(field_types))
-                            .unwrap_or_default();
-                        match args_for(&name) {
-                            Some(args) => variant_fields(&args)
-                                .into_iter()
-                                .map(|(field, schema)| {
-                                    let type_name = types.get(&field).cloned().unwrap_or_default();
-                                    field_input(field, schema, type_name, fields, state)
-                                })
-                                .collect_view()
-                                .into_any(),
+                        match spec_for(&name) {
+                            Some(spec) => {
+                                let schemas = schemas_for(&name);
+                                spec.fields
+                                    .into_iter()
+                                    .map(|field| {
+                                        let schema = schemas
+                                            .get(field.name)
+                                            .cloned()
+                                            .unwrap_or(Value::Null);
+                                        field_input(
+                                            field.name.to_string(),
+                                            field.role.to_string(),
+                                            schema,
+                                            field.type_name.to_string(),
+                                            fields,
+                                            state,
+                                        )
+                                    })
+                                    .collect_view()
+                                    .into_any()
+                            }
                             None => ().into_any(),
                         }
                     }}

apps/editor/src/components/console.rs

@@ -21,7 +21,6 @@ nightshade = { path = "../../../crates/nightshade", features = [
     "physics",
     "navmesh",
     "navmesh-bake",
-    "scripting",
 ] }
 nightshade-api = { path = "../../../crates/nightshade-api", default-features = false, features = [
     "protocol",

apps/editor/worker/Cargo.toml

@@ -12,6 +12,7 @@ use crate::systems::input::ShortcutState;
 use crate::systems::project_io::ProjectIoState;
 use crate::undo::{GizmoDragTracker, UndoHistory};
 use nightshade::prelude::freecs;
+use nightshade_api::prelude::ScriptRuntime;
 
 freecs::ecs! {
     EditorWorld {
@@ -52,6 +53,8 @@ freecs::ecs! {
         push_pull: PushPullState,
         play: PlayState,
         scripting: ScriptingState,
+        script_runtime: ScriptRuntime,
+        script_log: ScriptLog,
         generation: GenerationSettings,
         cloth_sponza: ClothSponzaState,
         outbox: Outbox,

apps/editor/worker/src/ecs.rs

@@ -408,6 +408,14 @@ pub struct ScriptingState {
     pub restore_show_grid: bool,
 }
 
+/// The typed commands participants produced this frame, scripts and the console
+/// builder, kept so the sync pass can log them with their real types rather
+/// than re-parsing a string.
+#[derive(Default)]
+pub struct ScriptLog {
+    pub commands: Vec<nightshade_api::prelude::Command>,
+}
+
 pub struct GenerationSettings {
     pub footprint_x: f32,
     pub footprint_z: f32,