Skip to main content

hyprstream_workers/workflow/
parser.rs

1//! GitHub Actions YAML workflow parser
2//!
3//! Parses `.github/workflows/*.yml` files into Workflow structs.
4//!
5//! ## Strict vs legacy mode (#1432)
6//!
7//! Two parse entry points exist:
8//!
9//! - [`Workflow::parse`] — **legacy / lenient** mode. Unknown YAML keys are
10//!   silently dropped (the historical behavior). This is the compatibility
11//!   path for non-gate callers and is unchanged by #1432.
12//! - [`Workflow::parse_strict`] — **strict / fail-closed** mode. Unknown
13//!   top-level, job-level, and step-level keys are rejected with
14//!   [`WorkerError::WorkflowParseError`](crate::error::WorkerError). This is
15//!   the mode the merge gate's workflow loader must use: a silently-ignored
16//!   `permissions:`, `concurrency:`, or `services:` would be a security gap.
17//!
18//! ### Explicitly supported subset (strict mode)
19//!
20//! Strict mode accepts *only* the keys this parser models:
21//!
22//! | Level    | Allowed keys |
23//! |----------|--------------|
24//! | workflow | `name`, `on`, `env`, `jobs` |
25//! | job      | `runs-on`, `needs`, `env`, `steps`, `if`, `timeout-minutes`, `resources` |
26//! | step     | `name`, `id`, `uses`, `run`, `shell`, `working-directory`, `with`, `env`, `if`, `continue-on-error` |
27//!
28//! `resources` is a hyprstream-specific extension (see [`JobResources`]),
29//! not a GHA key; it is permitted in strict mode so operator gate workflows
30//! may declare resource hints.
31//!
32//! ### Non-goals (#1432 Phase 2)
33//!
34//! Strict mode rejects **unknown structural keys** — it does **not** claim
35//! full GitHub Actions compatibility, and it deliberately does not implement
36//! `matrix`/`strategy`, `services`, `permissions`, `concurrency`, expression
37//! evaluation, environment scopes, or forge-specific checks. Those features
38//! remain Phase 2; until then they correctly fail closed in strict mode and
39//! are silently ignored in legacy mode.
40//!
41//! Free-form data maps (`env`, `with`, and trigger sub-keys like `branches`,
42//! `tags`, `paths`, `inputs`) are not key-checked — they carry arbitrary
43//! data, not parser-modeled schema.
44
45use serde::{Deserialize, Serialize};
46use std::collections::HashMap;
47
48use crate::error::Result;
49
50/// GitHub Actions compatible workflow definition
51#[derive(Debug, Clone, Serialize, Deserialize)]
52pub struct Workflow {
53    /// Workflow name
54    pub name: String,
55
56    /// Trigger configuration
57    #[serde(rename = "on")]
58    pub on: WorkflowTrigger,
59
60    /// Global environment variables
61    #[serde(default)]
62    pub env: HashMap<String, String>,
63
64    /// Workflow jobs
65    pub jobs: HashMap<String, Job>,
66}
67
68/// Workflow trigger configuration
69#[derive(Debug, Clone, Serialize, Deserialize)]
70#[serde(untagged)]
71pub enum WorkflowTrigger {
72    /// Simple trigger (single event)
73    Simple(String),
74
75    /// List of triggers
76    List(Vec<String>),
77
78    /// Complex trigger configuration
79    Complex(HashMap<String, TriggerConfig>),
80}
81
82/// Trigger configuration for an event type
83#[derive(Debug, Clone, Serialize, Deserialize)]
84#[serde(untagged)]
85pub enum TriggerConfig {
86    /// No additional config
87    None,
88
89    /// Branch/tag filters
90    BranchFilter {
91        #[serde(default)]
92        branches: Vec<String>,
93        #[serde(default)]
94        tags: Vec<String>,
95        #[serde(default)]
96        paths: Vec<String>,
97    },
98
99    /// Workflow dispatch inputs
100    WorkflowDispatch {
101        #[serde(default)]
102        inputs: HashMap<String, InputDef>,
103    },
104}
105
106/// Input definition for workflow_dispatch
107#[derive(Debug, Clone, Serialize, Deserialize)]
108pub struct InputDef {
109    /// Description
110    #[serde(default)]
111    pub description: String,
112
113    /// Required input
114    #[serde(default)]
115    pub required: bool,
116
117    /// Default value
118    #[serde(default)]
119    pub default: Option<String>,
120
121    /// Input type
122    #[serde(rename = "type", default)]
123    pub input_type: Option<String>,
124}
125
126/// Job definition
127#[derive(Debug, Clone, Serialize, Deserialize)]
128pub struct Job {
129    /// Runner label (e.g., "ubuntu-latest", "hyprstream-gpu")
130    #[serde(rename = "runs-on")]
131    pub runs_on: RunsOn,
132
133    /// Job dependencies
134    #[serde(default)]
135    pub needs: Option<Vec<String>>,
136
137    /// Job environment variables
138    #[serde(default)]
139    pub env: HashMap<String, String>,
140
141    /// Job steps
142    pub steps: Vec<Step>,
143
144    /// Condition for running this job
145    #[serde(rename = "if", default)]
146    pub condition: Option<String>,
147
148    /// Timeout in minutes
149    #[serde(rename = "timeout-minutes", default)]
150    pub timeout_minutes: Option<u32>,
151
152    /// Resource hints for scheduling (hyprstream extension, not part of the
153    /// GHA syntax). Consumed by the P2 admission engine (#525) via
154    /// `workflow::scheduler` to derive a `Demand` for the job's sandbox
155    /// reservation. All-zero (the default) means "no resource requirement" —
156    /// existing workflow YAML with no `resources:` key is unaffected.
157    #[serde(default)]
158    pub resources: JobResources,
159}
160
161/// Runner specification
162#[derive(Debug, Clone, Serialize, Deserialize)]
163#[serde(untagged)]
164pub enum RunsOn {
165    /// Single runner label
166    Label(String),
167
168    /// Multiple runner labels (AND logic)
169    Labels(Vec<String>),
170}
171
172/// Resource hints a job declares for scheduling (hyprstream extension).
173///
174/// GHA has no native `resources:` job key — this is a hyprstream-specific
175/// addition, parsed only when present (`#[serde(default)]` on the `Job`
176/// field), so it never affects existing workflow YAML. See
177/// `workflow::scheduler::job_pod_sandbox_config` for how these map onto the
178/// #525 admission engine's `Demand`.
179#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)]
180#[serde(default)]
181pub struct JobResources {
182    /// Requested CPU, in millicores (e.g. `500` = half a core).
183    pub cpu_millis: u64,
184    /// Requested memory, in bytes.
185    pub memory_bytes: u64,
186    /// Requested GPU count.
187    pub gpu: usize,
188}
189
190/// Step definition
191#[derive(Debug, Clone, Serialize, Deserialize)]
192pub struct Step {
193    /// Step name
194    #[serde(default)]
195    pub name: Option<String>,
196
197    /// Step ID for outputs
198    #[serde(default)]
199    pub id: Option<String>,
200
201    /// Action reference (uses)
202    #[serde(default)]
203    pub uses: Option<String>,
204
205    /// Shell command (run)
206    #[serde(default)]
207    pub run: Option<String>,
208
209    /// Shell to use
210    #[serde(default)]
211    pub shell: Option<String>,
212
213    /// Working directory
214    #[serde(rename = "working-directory", default)]
215    pub working_directory: Option<String>,
216
217    /// Action inputs
218    #[serde(default, rename = "with")]
219    pub with: HashMap<String, String>,
220
221    /// Step environment variables
222    #[serde(default)]
223    pub env: HashMap<String, String>,
224
225    /// Condition for running this step
226    #[serde(rename = "if", default)]
227    pub condition: Option<String>,
228
229    /// Continue on error
230    #[serde(rename = "continue-on-error", default)]
231    pub continue_on_error: bool,
232}
233
234/// Parse strictness.
235///
236/// The merge gate **must** parse operator-authored workflows in
237/// [`ParseMode::Strict`]: a silently-dropped `permissions:`, `concurrency:`,
238/// or `services:` key is a security gap (the workflow appears to parse cleanly
239/// while quietly losing semantics). Existing non-gate callers stay on
240/// [`ParseMode::Legacy`] until they explicitly opt in — see the non-goals of
241/// <https://github.com/hyprstream/hyprstream/issues/1432>.
242#[derive(Debug, Clone, Copy, PartialEq, Eq)]
243pub enum ParseMode {
244    /// Legacy / lenient compatibility mode (the historical `Workflow::parse`
245    /// behavior). Unknown top-level, job-level, and step-level YAML keys are
246    /// silently ignored. Use only for callers that must tolerate arbitrary
247    /// upstream GitHub Actions YAML; do **not** use this for the merge gate.
248    Legacy,
249
250    /// Strict / fail-closed mode. Unknown keys at the top level, inside a job,
251    /// or inside a step are rejected with
252    /// [`WorkerError::WorkflowParseError`](crate::error::WorkerError). This is
253    /// the mode the gate's workflow loader uses by default.
254    ///
255    /// Note: this rejects *unknown structural keys* — it does **not** claim
256    /// full GitHub Actions compatibility. Unsupported-but-recognized GHA
257    /// features (`matrix`, `services`, `permissions`, `concurrency`,
258    /// expression evaluation, forge-specific checks) are deliberately out of
259    /// scope (#1432 Phase 2).
260    Strict,
261}
262
263/// Top-level workflow keys the parser knows about (wire names, post-`rename`).
264const KNOWN_WORKFLOW_KEYS: &[&str] = &["name", "on", "env", "jobs"];
265
266/// Job-level keys the parser knows about (wire names, post-`rename`).
267///
268/// `resources` is a hyprstream-specific extension, not a GHA key; it is
269/// included here so operator gate workflows that declare resource hints still
270/// parse in strict mode.
271const KNOWN_JOB_KEYS: &[&str] = &[
272    "runs-on",
273    "needs",
274    "env",
275    "steps",
276    "if",
277    "timeout-minutes",
278    "resources",
279];
280
281/// Step-level keys the parser knows about (wire names, post-`rename`).
282const KNOWN_STEP_KEYS: &[&str] = &[
283    "name",
284    "id",
285    "uses",
286    "run",
287    "shell",
288    "working-directory",
289    "with",
290    "env",
291    "if",
292    "continue-on-error",
293];
294
295impl Workflow {
296    /// Parse a workflow from YAML content in **legacy** mode.
297    ///
298    /// This is the historical entry point: unknown keys are silently dropped.
299    /// Existing non-gate callers should keep using this until they explicitly
300    /// opt into strict mode. The merge gate should use [`Workflow::parse_strict`]
301    /// (or [`Workflow::parse_with`] with [`ParseMode::Strict`]).
302    pub fn parse(yaml: &str) -> Result<Self> {
303        Self::parse_with(yaml, ParseMode::Legacy)
304    }
305
306    /// Parse a workflow from YAML content in **strict / fail-closed** mode.
307    ///
308    /// Rejects unknown top-level, job-level, and step-level keys. See
309    /// [`ParseMode::Strict`] for the exact contract and non-goals.
310    pub fn parse_strict(yaml: &str) -> Result<Self> {
311        Self::parse_with(yaml, ParseMode::Strict)
312    }
313
314    /// Parse a workflow with an explicit [`ParseMode`].
315    ///
316    /// In [`ParseMode::Strict`] the document is first validated against the
317    /// known-key sets at the top level, per-job, and per-step (the three
318    /// structural levels the parser models) before being handed to
319    /// `serde_yaml`. Validation runs on the raw [`serde_yaml::Value`] tree so
320    /// that an unknown key can never be silently absorbed by
321    /// `#[serde(default)]`.
322    pub fn parse_with(yaml: &str, mode: ParseMode) -> Result<Self> {
323        let value: serde_yaml::Value = serde_yaml::from_str(yaml)
324            .map_err(|e| crate::error::WorkerError::WorkflowParseError(e.to_string()))?;
325
326        if mode == ParseMode::Strict {
327            validate_known_keys(&value)?;
328        }
329
330        let workflow: Workflow = serde_yaml::from_value(value)
331            .map_err(|e| crate::error::WorkerError::WorkflowParseError(e.to_string()))?;
332        Ok(workflow)
333    }
334
335    /// Parse a workflow from a file in **legacy** mode.
336    pub fn parse_file(path: &std::path::Path) -> Result<Self> {
337        let content = std::fs::read_to_string(path)?;
338        Self::parse(&content)
339    }
340
341    /// Parse a workflow from a file with an explicit [`ParseMode`].
342    pub fn parse_file_with(path: &std::path::Path, mode: ParseMode) -> Result<Self> {
343        let content = std::fs::read_to_string(path)?;
344        Self::parse_with(&content, mode)
345    }
346}
347
348/// Reject unknown structural keys at the top level, per-job, and per-step.
349///
350/// `env`, `with`, and trigger sub-keys (`branches`, `tags`, `paths`,
351/// `inputs`, …) are free-form data maps, not schema levels, so they are not
352/// key-checked here.
353fn validate_known_keys(value: &serde_yaml::Value) -> Result<()> {
354    let mapping = value.as_mapping().ok_or_else(|| {
355        crate::error::WorkerError::WorkflowParseError(String::from(
356            "workflow root must be a mapping",
357        ))
358    })?;
359
360    for (key, val) in mapping {
361        let key_str = match key.as_str() {
362            Some(s) => s,
363            None => {
364                return Err(crate::error::WorkerError::WorkflowParseError(format!(
365                    "top-level key is not a string: {key:?}"
366                )))
367            }
368        };
369
370        if !KNOWN_WORKFLOW_KEYS.contains(&key_str) {
371            return Err(crate::error::WorkerError::WorkflowParseError(format!(
372                "unknown top-level key `{key_str}` (strict mode: allowed keys are {})",
373                KNOWN_WORKFLOW_KEYS.join(", ")
374            )));
375        }
376
377        // Only `jobs` has a structural sub-level to recurse into;
378        // `on`, `env`, `name` are free-form / scalar.
379        if key_str == "jobs" {
380            validate_jobs(val)?;
381        }
382    }
383    Ok(())
384}
385
386/// Validate each job mapping and its steps.
387fn validate_jobs(jobs: &serde_yaml::Value) -> Result<()> {
388    let mapping = jobs.as_mapping().ok_or_else(|| {
389        crate::error::WorkerError::WorkflowParseError(String::from(
390            "`jobs` must be a mapping of job-id → job",
391        ))
392    })?;
393
394    for (job_id, job) in mapping {
395        let job_id_str = job_id.as_str().unwrap_or("<non-string job id>");
396        let job_map = job.as_mapping().ok_or_else(|| {
397            crate::error::WorkerError::WorkflowParseError(format!(
398                "job `{job_id_str}` must be a mapping"
399            ))
400        })?;
401
402        for (key, val) in job_map {
403            let key_str = match key.as_str() {
404                Some(s) => s,
405                None => {
406                    return Err(crate::error::WorkerError::WorkflowParseError(format!(
407                        "job `{job_id_str}` has a non-string key: {key:?}"
408                    )))
409                }
410            };
411
412            if !KNOWN_JOB_KEYS.contains(&key_str) {
413                return Err(crate::error::WorkerError::WorkflowParseError(format!(
414                    "unknown key `{key_str}` in job `{job_id_str}` (strict mode: allowed keys are {})",
415                    KNOWN_JOB_KEYS.join(", ")
416                )));
417            }
418
419            if key_str == "steps" {
420                validate_steps(job_id_str, val)?;
421            }
422        }
423    }
424    Ok(())
425}
426
427/// Validate each step in a job's `steps` sequence.
428fn validate_steps(job_id: &str, steps: &serde_yaml::Value) -> Result<()> {
429    let seq = steps.as_sequence().ok_or_else(|| {
430        crate::error::WorkerError::WorkflowParseError(format!(
431            "`steps` in job `{job_id}` must be a sequence"
432        ))
433    })?;
434
435    for (idx, step) in seq.iter().enumerate() {
436        let step_map = step.as_mapping().ok_or_else(|| {
437            crate::error::WorkerError::WorkflowParseError(format!(
438                "step[{idx}] in job `{job_id}` must be a mapping"
439            ))
440        })?;
441
442        for key in step_map.keys() {
443            let key_str = match key.as_str() {
444                Some(s) => s,
445                None => {
446                    return Err(crate::error::WorkerError::WorkflowParseError(format!(
447                        "step[{idx}] in job `{job_id}` has a non-string key: {key:?}"
448                    )))
449                }
450            };
451
452            if !KNOWN_STEP_KEYS.contains(&key_str) {
453                return Err(crate::error::WorkerError::WorkflowParseError(format!(
454                    "unknown key `{key_str}` in step[{idx}] of job `{job_id}` (strict mode: allowed keys are {})",
455                    KNOWN_STEP_KEYS.join(", ")
456                )));
457            }
458        }
459    }
460    Ok(())
461}
462
463#[cfg(test)]
464mod tests {
465    use super::*;
466
467    #[test]
468    fn test_parse_simple_workflow() -> Result<()> {
469        let yaml = r#"
470name: Test Workflow
471on: push
472jobs:
473  build:
474    runs-on: ubuntu-latest
475    steps:
476      - name: Checkout
477        uses: actions/checkout@v4
478      - name: Build
479        run: cargo build
480"#;
481
482        let workflow = Workflow::parse(yaml)?;
483        assert_eq!(workflow.name, "Test Workflow");
484        assert!(workflow.jobs.contains_key("build"));
485        Ok(())
486    }
487
488    #[test]
489    fn test_parse_complex_trigger() -> Result<()> {
490        let yaml = r#"
491name: Complex Workflow
492on:
493  push:
494    branches:
495      - main
496      - 'release/*'
497  workflow_dispatch:
498    inputs:
499      model:
500        description: Model to train
501        required: true
502jobs:
503  train:
504    runs-on: hyprstream-gpu
505    steps:
506      - uses: hyprstream/model-load@v1
507        with:
508          model: ${{ inputs.model }}
509"#;
510
511        let workflow = Workflow::parse(yaml)?;
512        assert_eq!(workflow.name, "Complex Workflow");
513        Ok(())
514    }
515
516    // ─── strict-mode acceptance: the known subset parses cleanly ───────────
517
518    fn minimal_gate_yaml() -> &'static str {
519        // The operator-authored gate workflow subset: only keys the parser
520        // models. Must parse without error in strict mode.
521        r#"
522name: Gate
523on:
524  pull_request:
525    branches:
526      - main
527env:
528  RUST_BACKTRACE: "1"
529jobs:
530  gate:
531    runs-on: ubuntu-latest
532    needs: []
533    if: ${{ github.event.pull_request.draft == false }}
534    timeout-minutes: 30
535    env:
536      CARGO_TERM_COLOR: always
537    steps:
538      - name: Checkout
539        id: checkout
540        uses: actions/checkout@v4
541        with:
542          fetch-depth: "0"
543        env:
544          GHA: "true"
545        if: ${{ true }}
546        continue-on-error: false
547        working-directory: .
548        shell: bash
549      - name: Build
550        run: cargo build
551"#
552    }
553
554    #[test]
555    fn test_strict_accepts_known_subset() -> Result<()> {
556        let workflow = Workflow::parse_strict(minimal_gate_yaml())?;
557        assert_eq!(workflow.name, "Gate");
558        assert!(workflow.jobs.contains_key("gate"));
559        // Legacy mode agrees.
560        let legacy = Workflow::parse(minimal_gate_yaml())?;
561        assert_eq!(legacy.jobs.len(), workflow.jobs.len());
562        Ok(())
563    }
564
565    #[test]
566    fn test_strict_accepts_resource_hints_extension() -> Result<()> {
567        // `resources:` is a hyprstream extension; must be permitted in strict.
568        let yaml = r#"
569name: GPU
570on: push
571jobs:
572  train:
573    runs-on: hyprstream-gpu
574    resources:
575      cpu_millis: 4000
576      memory_bytes: 8589934592
577      gpu: 1
578    steps:
579      - run: python train.py
580"#;
581        let workflow = Workflow::parse_strict(yaml)?;
582        assert_eq!(workflow.jobs["train"].resources.gpu, 1);
583        Ok(())
584    }
585
586    #[test]
587    fn test_parse_with_legacy_mode_matches_parse() -> Result<()> {
588        let a = Workflow::parse(minimal_gate_yaml())?;
589        let b = Workflow::parse_with(minimal_gate_yaml(), ParseMode::Legacy)?;
590        assert_eq!(a.name, b.name);
591        assert_eq!(a.jobs.len(), b.jobs.len());
592        Ok(())
593    }
594
595    // ─── strict-mode rejections: unknown keys at each structural level ─────
596
597    fn assert_strict_rejects(yaml: &str, needle: &str) {
598        match Workflow::parse_strict(yaml) {
599            Err(crate::error::WorkerError::WorkflowParseError(msg)) => {
600                assert!(
601                    msg.contains(needle),
602                    "expected strict error to mention `{needle}`, got: {msg}"
603                );
604            }
605            other => panic!("strict mode should reject, got: {other:?}"),
606        }
607    }
608
609    #[test]
610    fn test_strict_rejects_unknown_top_level_services() {
611        let yaml = r#"
612name: T
613on: push
614services:
615  db:
616    image: postgres
617jobs:
618  b:
619    runs-on: ubuntu-latest
620    steps:
621      - run: echo hi
622"#;
623        assert_strict_rejects(yaml, "unknown top-level key `services`");
624    }
625
626    #[test]
627    fn test_strict_rejects_unknown_top_level_permissions() {
628        let yaml = r#"
629name: T
630on: push
631permissions:
632  contents: read
633jobs:
634  b:
635    runs-on: ubuntu-latest
636    steps:
637      - run: echo hi
638"#;
639        assert_strict_rejects(yaml, "unknown top-level key `permissions`");
640    }
641
642    #[test]
643    fn test_strict_rejects_unknown_top_level_concurrency() {
644        let yaml = r#"
645name: T
646on: push
647concurrency:
648  group: deploy
649jobs:
650  b:
651    runs-on: ubuntu-latest
652    steps:
653      - run: echo hi
654"#;
655        assert_strict_rejects(yaml, "unknown top-level key `concurrency`");
656    }
657
658    #[test]
659    fn test_strict_rejects_unknown_job_level_matrix() {
660        let yaml = r#"
661name: T
662on: push
663jobs:
664  b:
665    runs-on: ubuntu-latest
666    strategy:
667      matrix:
668        os: [ubuntu, macos]
669    steps:
670      - run: echo hi
671"#;
672        assert_strict_rejects(yaml, "unknown key `strategy` in job `b`");
673    }
674
675    #[test]
676    fn test_strict_rejects_unknown_job_level_services() {
677        let yaml = r#"
678name: T
679on: push
680jobs:
681  b:
682    runs-on: ubuntu-latest
683    services:
684      db:
685        image: postgres
686    steps:
687      - run: echo hi
688"#;
689        assert_strict_rejects(yaml, "unknown key `services` in job `b`");
690    }
691
692    #[test]
693    fn test_strict_rejects_unknown_step_level_key() {
694        let yaml = r#"
695name: T
696on: push
697jobs:
698  b:
699    runs-on: ubuntu-latest
700    steps:
701      - name: x
702        run: echo hi
703        timeout-minutes: 5
704"#;
705        // `timeout-minutes` is a known *job* key, not a known step key here.
706        assert_strict_rejects(yaml, "unknown key `timeout-minutes` in step[0]");
707    }
708
709    #[test]
710    fn test_strict_rejects_unknown_step_level_tty() {
711        let yaml = r#"
712name: T
713on: push
714jobs:
715  b:
716    runs-on: ubuntu-latest
717    steps:
718      - run: echo hi
719        with:
720          key: value
721"#;
722        // `with` IS a known step key — this should actually be accepted.
723        // Sanity: ensure we don't over-reject known step keys.
724        match Workflow::parse_strict(yaml) {
725            Ok(w) => assert_eq!(w.name, "T"),
726            Err(e) => panic!("strict mode must accept `with` step key: {e}"),
727        }
728    }
729
730    // ─── legacy mode still silently tolerates the same inputs ──────────────
731
732    #[test]
733    fn test_legacy_silently_drops_unknown_top_level() -> Result<()> {
734        let yaml = r#"
735name: T
736on: push
737permissions:
738  contents: read
739jobs:
740  b:
741    runs-on: ubuntu-latest
742    steps:
743      - run: echo hi
744"#;
745        // Legacy mode must NOT reject — that is its defined contract.
746        let workflow = Workflow::parse(yaml)?;
747        assert_eq!(workflow.name, "T");
748        Ok(())
749    }
750
751    #[test]
752    fn test_legacy_silently_drops_unknown_job_and_step_keys() -> Result<()> {
753        let yaml = r#"
754name: T
755on: push
756jobs:
757  b:
758    runs-on: ubuntu-latest
759    strategy:
760      fail-fast: false
761    steps:
762      - run: echo hi
763        bogus-key: oops
764"#;
765        let workflow = Workflow::parse(yaml)?;
766        assert!(workflow.jobs.contains_key("b"));
767        Ok(())
768    }
769
770    // ─── structural-error edge cases ───────────────────────────────────────
771
772    #[test]
773    fn test_strict_rejects_non_mapping_root() {
774        assert_strict_rejects("not a mapping", "workflow root must be a mapping");
775    }
776
777    #[test]
778    fn test_strict_rejects_non_mapping_job() {
779        let yaml = r#"
780name: T
781on: push
782jobs:
783  b: not-a-mapping
784"#;
785        assert_strict_rejects(yaml, "job `b` must be a mapping");
786    }
787}