1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
//! # ferroplan
//!
//! A fast, data-parallel [PDDL](https://en.wikipedia.org/wiki/Planning_Domain_Definition_Language)
//! planner in Rust — a deterministic planning core for the age of AI. The engine is a
//! delete-relaxation FF heuristic over a data-oriented (bitset / structure-of-arrays)
//! task representation, with enforced hill-climbing + best-first fallback and parallel
//! grounding / heuristic evaluation.
//!
//! PDDL coverage: STRIPS, typing, ADL (conditional/`forall` effects, equality),
//! numeric fluents, derived axioms, **PDDL3** soft-goal preferences/metric, and
//! **PDDL2.1 temporal** durative actions (constant / parameter-dependent durations,
//! duration inequalities, timed initial literals). Plus an SGPlan-style
//! **partition-and-resolve** mode.
//!
//! ## The public API (all `serde`-serializable)
//!
//! - [`solve`] — plan a domain + problem; returns a [`Solution`] (mode auto-detected).
//! - [`decompose`] — split a temporal goal too big for one-shot search into ordered,
//! individually-solved [`Contract`]s, stitched into one validated plan
//! ([`Decomposition`]).
//! - [`parse`] — syntax-check PDDL and summarize its structure ([`ParseReport`])
//! *without* grounding or solving — fast feedback for an authoring loop.
//! - [`Session`] — ground once, **replan many**: hold a mutable world state
//! (`set_fact`/`set_fluent`) and re-solve per tick paying only the search
//! (~10x per-tick on small contracts) — the embedding API for games/simulations.
//! - [`plan::validate_plan`] — independently check a plan under ferroplan's semantics.
//!
//! ## Quick start
//! ```no_run
//! let domain = std::fs::read_to_string("domain.pddl").unwrap();
//! let problem = std::fs::read_to_string("problem.pddl").unwrap();
//!
//! // Catch syntax mistakes before solving.
//! let report = ferroplan::parse(&domain);
//! assert!(report.ok, "{:?}", report.error);
//!
//! let solution = ferroplan::solve(&domain, &problem, &ferroplan::Options::default()).unwrap();
//! if let Some(plan) = solution.plan {
//! for step in &plan.steps { println!("{}", step.action); }
//! }
//! ```
//!
//! The lower-level text-rendering entry points (`run_planner`, `run_ff`) produce
//! classic Metric-FF / IPC output and back the `ff` binary.
// engine (data-oriented core)
// modes (built on the engine)
// orchestration + smart public API
pub use ;
pub use ;
pub use Session;
pub use ;
pub use ParseError;