This commit will be removed in a later force-push.

@@ -0,0 +9,4 @@
+//! - [`Instruction`]s are referred to as their **byte [`Span`]s** in the source code,
+//!   so effectively where they are written in the source code.
+//!   (Or if coming from [`crate::semi_human::GraphIr`],
+//!   it's just a fictional number floating in space.)

@@ -0,0 +26,4 @@
+/// It does **not** contain what kind of instruction this is.
+/// Refer to [`crate::instruction::Kind`] for this instead.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct Instruction(pub(super) Span);

@@ -0,0 +68,4 @@
+pub struct Socket {
+    pub belongs_to: Instruction,
+    pub idx: SocketIdx,
+}

@@ -0,0 +60,4 @@
+            Self::Write(_) => (1, 0),
+            Self::Math(_) | Self::Blend(_) => (2, 1),
+            Self::Noise(_) => {
+                todo!("how many arguments does noise take? how many outputs does it have?")

@@ -0,0 +68,4 @@
+    pub struct Instruction(Span);
+
+    impl Instruction {
+        /// Where this instruction is written down.

@@ -0,0 +120,4 @@
+    /// Theoretically this could be fixed easily at the expense of some memory
+    /// by just incrementing and storing some global counter,
+    /// however, at the moment there's no compelling reason
+    /// to actually have multiple [`GraphIr`]s at one point in time.

@@ -0,0 +159,4 @@
+    ///
+    /// # Panics
+    ///
+    /// Panics if there are any cycles in the IR, as it needs to be a DAG.

@@ -0,0 +1,90 @@
+//! The midterm solution for source representation, until we've got a nice source frontent.

@@ -0,0 +8,4 @@
+		2: Write((
+			target: File("testfiles/inverted.png"),
+			format: Png,
+		)),

@@ -44,3 +48,3 @@
             Some("ron") => Ok(serde_json::from_str(&fs::read_to_string(p)?)?),
             Some("json") => Ok(ron::from_str(&fs::read_to_string(p)?)?),
-            e => Err(ConfigError::UnknownExtension(e.map(|v| v.to_owned()))),
+            e => Err(Config::UnknownExtension(e.map(str::to_string))),

@@ -17,0 +21,4 @@
+        fs::read_to_string(cfg.source).expect("can't find source file lol handle me better please");
+
+    let ir =
+        ir::from_ron(&source).expect("aww failed to parse source to graph ir handle me better");

@@ -0,0 +19,4 @@
+
+impl crate::Evaluator for Evaluator {
+    fn feed(&mut self, ir: GraphIr) {
+        // TODO: should add instead of replace, see note in Evaluator trait above this method

@@ -0,0 +64,4 @@
+        let output = match instr.kind {
+            Kind::Read(details) => Some(Variant::Image(instr::read::read(details))),
+            Kind::Write(details) => {
+                #[allow(irrefutable_let_patterns)] // will necessarily change

@@ -0,0 +10,4 @@
+    /// Take some [`GraphIr`] which will then be processed later.
+    /// May be called multiple times, in which the [`GraphIr`]s should add up.
+    // TODO: atm they definitely don't add up -- add some functionality to GraphIr to
+    //       make it combine two graphs into one

@@ -0,0 +5,4 @@
+/// The name is taken from [Godot's `Variant` type],
+/// which is very similar to this one.
+///
+/// [Godot's `Variant` type]: https://docs.godotengine.org/en/stable/classes/class_variant.html

@@ -0,0 +47,4 @@
+
+/// On an **instruction**, returns outgoing data to be fed to [`Input`]s.
+///
+/// In contrast to [`Input`]s, [`Output`]s may be used or unused.

@@ -0,0 +15,4 @@
+/// Look at [`semi_human::GraphIr`] and the test files in the repo at `testfiles/`
+/// to see what the RON should look like.
+/// No, we don't want you to write out [`GraphIr`] in full by hand.
+/// That's something for the machines to do.

@@ -0,0 +1,86 @@
+//! The midterm solution for source representation, until we've got a nice source frontend.

@@ -8,3 +8,3 @@
 )
 
-= Evaluation stages
+= Processing stages

@@ -1,2 +5,4 @@
+  cargo nextest run
+
 # Compile all documentation as in proposals and design documents, placing them under `docs/compiled`.
 docs: