diff --git a/src/intermediate/angle_link.rs b/src/intermediate/angle_link.rs
index bd84243..5cd2cd1 100644
--- a/src/intermediate/angle_link.rs
+++ b/src/intermediate/angle_link.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IAngleLink {}
 
 impl IAngleLink {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::AngleLink<'parse>,
     ) -> Result<IAngleLink, CustomError> {
         Ok(IAngleLink {})
diff --git a/src/intermediate/babel_call.rs b/src/intermediate/babel_call.rs
index a8d542c..6414178 100644
--- a/src/intermediate/babel_call.rs
+++ b/src/intermediate/babel_call.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IBabelCall {}
 
 impl IBabelCall {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::BabelCall<'parse>,
     ) -> Result<IBabelCall, CustomError> {
         Ok(IBabelCall {})
diff --git a/src/intermediate/bold.rs b/src/intermediate/bold.rs
index c00f94b..d6dc019 100644
--- a/src/intermediate/bold.rs
+++ b/src/intermediate/bold.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IBold {}
 
 impl IBold {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Bold<'parse>,
     ) -> Result<IBold, CustomError> {
         Ok(IBold {})
diff --git a/src/intermediate/center_block.rs b/src/intermediate/center_block.rs
index 2e4d777..4f104aa 100644
--- a/src/intermediate/center_block.rs
+++ b/src/intermediate/center_block.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ICenterBlock {}
 
 impl ICenterBlock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::CenterBlock<'parse>,
     ) -> Result<ICenterBlock, CustomError> {
         Ok(ICenterBlock {})
diff --git a/src/intermediate/citation.rs b/src/intermediate/citation.rs
index 1209241..70902b9 100644
--- a/src/intermediate/citation.rs
+++ b/src/intermediate/citation.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ICitation {}
 
 impl ICitation {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Citation<'parse>,
     ) -> Result<ICitation, CustomError> {
         Ok(ICitation {})
diff --git a/src/intermediate/citation_reference.rs b/src/intermediate/citation_reference.rs
index 1030158..ebcbe70 100644
--- a/src/intermediate/citation_reference.rs
+++ b/src/intermediate/citation_reference.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ICitationReference {}
 
 impl ICitationReference {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::CitationReference<'parse>,
     ) -> Result<ICitationReference, CustomError> {
         Ok(ICitationReference {})
diff --git a/src/intermediate/clock.rs b/src/intermediate/clock.rs
index 5f3b8eb..1dddb04 100644
--- a/src/intermediate/clock.rs
+++ b/src/intermediate/clock.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IClock {}
 
 impl IClock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Clock<'parse>,
     ) -> Result<IClock, CustomError> {
         Ok(IClock {})
diff --git a/src/intermediate/code.rs b/src/intermediate/code.rs
index 6a137ba..e2da068 100644
--- a/src/intermediate/code.rs
+++ b/src/intermediate/code.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ICode {}
 
 impl ICode {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Code<'parse>,
     ) -> Result<ICode, CustomError> {
         Ok(ICode {})
diff --git a/src/intermediate/comment.rs b/src/intermediate/comment.rs
index 70649f2..d79837a 100644
--- a/src/intermediate/comment.rs
+++ b/src/intermediate/comment.rs
@@ -7,8 +7,8 @@ use super::registry::Registry;
 pub(crate) struct IComment {}
 
 impl IComment {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         comment: &organic::types::Comment<'parse>,
     ) -> Result<IComment, CustomError> {
         Ok(IComment {})
diff --git a/src/intermediate/comment_block.rs b/src/intermediate/comment_block.rs
index 71602eb..0e085d8 100644
--- a/src/intermediate/comment_block.rs
+++ b/src/intermediate/comment_block.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ICommentBlock {}
 
 impl ICommentBlock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::CommentBlock<'parse>,
     ) -> Result<ICommentBlock, CustomError> {
         Ok(ICommentBlock {})
diff --git a/src/intermediate/diary_sexp.rs b/src/intermediate/diary_sexp.rs
index 5f4d4a4..9c66cff 100644
--- a/src/intermediate/diary_sexp.rs
+++ b/src/intermediate/diary_sexp.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IDiarySexp {}
 
 impl IDiarySexp {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::DiarySexp<'parse>,
     ) -> Result<IDiarySexp, CustomError> {
         Ok(IDiarySexp {})
diff --git a/src/intermediate/document_element.rs b/src/intermediate/document_element.rs
index d348269..9f4b488 100644
--- a/src/intermediate/document_element.rs
+++ b/src/intermediate/document_element.rs
@@ -12,9 +12,9 @@ pub(crate) enum IDocumentElement {
 }
 
 impl IDocumentElement {
-    pub(crate) fn new<'parse, 'b>(
-        registry: &'b mut Registry<'parse>,
-        original: &'b organic::types::DocumentElement<'parse>,
+    pub(crate) fn new<'intermediate, 'parse, 'b>(
+        registry: &'b mut Registry<'intermediate, 'parse>,
+        original: &'intermediate organic::types::DocumentElement<'parse>,
     ) -> BoxFuture<'b, Result<IDocumentElement, CustomError>> {
         async move {
             match original {
diff --git a/src/intermediate/drawer.rs b/src/intermediate/drawer.rs
index b55fd71..0572ae5 100644
--- a/src/intermediate/drawer.rs
+++ b/src/intermediate/drawer.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IDrawer {}
 
 impl IDrawer {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Drawer<'parse>,
     ) -> Result<IDrawer, CustomError> {
         Ok(IDrawer {})
diff --git a/src/intermediate/dynamic_block.rs b/src/intermediate/dynamic_block.rs
index 6086e9d..4a8180b 100644
--- a/src/intermediate/dynamic_block.rs
+++ b/src/intermediate/dynamic_block.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IDynamicBlock {}
 
 impl IDynamicBlock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::DynamicBlock<'parse>,
     ) -> Result<IDynamicBlock, CustomError> {
         Ok(IDynamicBlock {})
diff --git a/src/intermediate/element.rs b/src/intermediate/element.rs
index 1fe3360..1d81943 100644
--- a/src/intermediate/element.rs
+++ b/src/intermediate/element.rs
@@ -56,9 +56,9 @@ pub(crate) enum IElement {
 }
 
 impl IElement {
-    pub(crate) fn new<'parse, 'b>(
-        registry: &'b mut Registry<'parse>,
-        elem: &'b organic::types::Element<'parse>,
+    pub(crate) fn new<'intermediate, 'parse, 'b>(
+        registry: &'b mut Registry<'intermediate, 'parse>,
+        elem: &'intermediate organic::types::Element<'parse>,
     ) -> BoxFuture<'b, Result<IElement, CustomError>> {
         async move {
             match elem {
diff --git a/src/intermediate/entity.rs b/src/intermediate/entity.rs
index 088a8e5..547ed0e 100644
--- a/src/intermediate/entity.rs
+++ b/src/intermediate/entity.rs
@@ -8,8 +8,8 @@ pub(crate) struct IEntity {
 }
 
 impl IEntity {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Entity<'parse>,
     ) -> Result<IEntity, CustomError> {
         Ok(IEntity {
diff --git a/src/intermediate/example_block.rs b/src/intermediate/example_block.rs
index 2c65752..8fda94e 100644
--- a/src/intermediate/example_block.rs
+++ b/src/intermediate/example_block.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IExampleBlock {}
 
 impl IExampleBlock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::ExampleBlock<'parse>,
     ) -> Result<IExampleBlock, CustomError> {
         Ok(IExampleBlock {})
diff --git a/src/intermediate/export_block.rs b/src/intermediate/export_block.rs
index ff24258..4915e2d 100644
--- a/src/intermediate/export_block.rs
+++ b/src/intermediate/export_block.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IExportBlock {}
 
 impl IExportBlock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::ExportBlock<'parse>,
     ) -> Result<IExportBlock, CustomError> {
         Ok(IExportBlock {})
diff --git a/src/intermediate/export_snippet.rs b/src/intermediate/export_snippet.rs
index 6a2c331..ceb30e1 100644
--- a/src/intermediate/export_snippet.rs
+++ b/src/intermediate/export_snippet.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IExportSnippet {}
 
 impl IExportSnippet {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::ExportSnippet<'parse>,
     ) -> Result<IExportSnippet, CustomError> {
         Ok(IExportSnippet {})
diff --git a/src/intermediate/fixed_width_area.rs b/src/intermediate/fixed_width_area.rs
index 6cdf376..cc6e769 100644
--- a/src/intermediate/fixed_width_area.rs
+++ b/src/intermediate/fixed_width_area.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IFixedWidthArea {}
 
 impl IFixedWidthArea {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::FixedWidthArea<'parse>,
     ) -> Result<IFixedWidthArea, CustomError> {
         Ok(IFixedWidthArea {})
diff --git a/src/intermediate/footnote_definition.rs b/src/intermediate/footnote_definition.rs
index 35964bb..601472b 100644
--- a/src/intermediate/footnote_definition.rs
+++ b/src/intermediate/footnote_definition.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IFootnoteDefinition {}
 
 impl IFootnoteDefinition {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::FootnoteDefinition<'parse>,
     ) -> Result<IFootnoteDefinition, CustomError> {
         Ok(IFootnoteDefinition {})
diff --git a/src/intermediate/footnote_reference.rs b/src/intermediate/footnote_reference.rs
index b660a9c..1ca4575 100644
--- a/src/intermediate/footnote_reference.rs
+++ b/src/intermediate/footnote_reference.rs
@@ -8,9 +8,9 @@ pub(crate) struct IFootnoteReference {
 }
 
 impl IFootnoteReference {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
-        original: &organic::types::FootnoteReference<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
+        original: &'intermediate organic::types::FootnoteReference<'parse>,
     ) -> Result<IFootnoteReference, CustomError> {
         let footnote_id = registry.get_footnote_reference_id(original.label, &original.definition);
         Ok(IFootnoteReference { footnote_id })
diff --git a/src/intermediate/heading.rs b/src/intermediate/heading.rs
index 4ed510e..49e4f0b 100644
--- a/src/intermediate/heading.rs
+++ b/src/intermediate/heading.rs
@@ -12,27 +12,27 @@ pub(crate) struct IHeading {
 }
 
 impl IHeading {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
-        heading: &organic::types::Heading<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
+        original: &'intermediate organic::types::Heading<'parse>,
     ) -> Result<IHeading, CustomError> {
         let title = {
             let mut ret = Vec::new();
-            for obj in heading.title.iter() {
+            for obj in original.title.iter() {
                 ret.push(IObject::new(registry, obj).await?);
             }
             ret
         };
         let children = {
             let mut ret = Vec::new();
-            for obj in heading.children.iter() {
+            for obj in original.children.iter() {
                 ret.push(IDocumentElement::new(registry, obj).await?);
             }
             ret
         };
         Ok(IHeading {
             title,
-            level: heading.level,
+            level: original.level,
             children,
         })
     }
diff --git a/src/intermediate/horizontal_rule.rs b/src/intermediate/horizontal_rule.rs
index 0be08c6..6e8b8e5 100644
--- a/src/intermediate/horizontal_rule.rs
+++ b/src/intermediate/horizontal_rule.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IHorizontalRule {}
 
 impl IHorizontalRule {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::HorizontalRule<'parse>,
     ) -> Result<IHorizontalRule, CustomError> {
         Ok(IHorizontalRule {})
diff --git a/src/intermediate/inline_babel_call.rs b/src/intermediate/inline_babel_call.rs
index 874f5c4..956a5f0 100644
--- a/src/intermediate/inline_babel_call.rs
+++ b/src/intermediate/inline_babel_call.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IInlineBabelCall {}
 
 impl IInlineBabelCall {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::InlineBabelCall<'parse>,
     ) -> Result<IInlineBabelCall, CustomError> {
         Ok(IInlineBabelCall {})
diff --git a/src/intermediate/inline_source_block.rs b/src/intermediate/inline_source_block.rs
index 29071b3..48d5bf7 100644
--- a/src/intermediate/inline_source_block.rs
+++ b/src/intermediate/inline_source_block.rs
@@ -8,8 +8,8 @@ pub(crate) struct IInlineSourceBlock {
 }
 
 impl IInlineSourceBlock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::InlineSourceBlock<'parse>,
     ) -> Result<IInlineSourceBlock, CustomError> {
         Ok(IInlineSourceBlock {
diff --git a/src/intermediate/italic.rs b/src/intermediate/italic.rs
index 79ce541..e71048c 100644
--- a/src/intermediate/italic.rs
+++ b/src/intermediate/italic.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IItalic {}
 
 impl IItalic {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Italic<'parse>,
     ) -> Result<IItalic, CustomError> {
         Ok(IItalic {})
diff --git a/src/intermediate/keyword.rs b/src/intermediate/keyword.rs
index bd26939..8ec3df7 100644
--- a/src/intermediate/keyword.rs
+++ b/src/intermediate/keyword.rs
@@ -7,8 +7,8 @@ use super::registry::Registry;
 pub(crate) struct IKeyword {}
 
 impl IKeyword {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         keyword: &organic::types::Keyword<'parse>,
     ) -> Result<IKeyword, CustomError> {
         Ok(IKeyword {})
diff --git a/src/intermediate/latex_environment.rs b/src/intermediate/latex_environment.rs
index c6ccaac..1370d48 100644
--- a/src/intermediate/latex_environment.rs
+++ b/src/intermediate/latex_environment.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ILatexEnvironment {}
 
 impl ILatexEnvironment {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::LatexEnvironment<'parse>,
     ) -> Result<ILatexEnvironment, CustomError> {
         Ok(ILatexEnvironment {})
diff --git a/src/intermediate/latex_fragment.rs b/src/intermediate/latex_fragment.rs
index bf8d2af..b1c069a 100644
--- a/src/intermediate/latex_fragment.rs
+++ b/src/intermediate/latex_fragment.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ILatexFragment {}
 
 impl ILatexFragment {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::LatexFragment<'parse>,
     ) -> Result<ILatexFragment, CustomError> {
         Ok(ILatexFragment {})
diff --git a/src/intermediate/line_break.rs b/src/intermediate/line_break.rs
index da94610..f0869ac 100644
--- a/src/intermediate/line_break.rs
+++ b/src/intermediate/line_break.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ILineBreak {}
 
 impl ILineBreak {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::LineBreak<'parse>,
     ) -> Result<ILineBreak, CustomError> {
         Ok(ILineBreak {})
diff --git a/src/intermediate/object.rs b/src/intermediate/object.rs
index c51584a..67dad58 100644
--- a/src/intermediate/object.rs
+++ b/src/intermediate/object.rs
@@ -62,9 +62,9 @@ pub(crate) enum IObject {
 }
 
 impl IObject {
-    pub(crate) fn new<'parse, 'b>(
-        registry: &'b mut Registry<'parse>,
-        obj: &'b organic::types::Object<'parse>,
+    pub(crate) fn new<'intermediate, 'parse, 'b>(
+        registry: &'b mut Registry<'intermediate, 'parse>,
+        obj: &'intermediate organic::types::Object<'parse>,
     ) -> BoxFuture<'b, Result<IObject, CustomError>> {
         async move {
             match obj {
diff --git a/src/intermediate/org_macro.rs b/src/intermediate/org_macro.rs
index 328d89a..2c0fa4e 100644
--- a/src/intermediate/org_macro.rs
+++ b/src/intermediate/org_macro.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IOrgMacro {}
 
 impl IOrgMacro {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::OrgMacro<'parse>,
     ) -> Result<IOrgMacro, CustomError> {
         Ok(IOrgMacro {})
diff --git a/src/intermediate/page.rs b/src/intermediate/page.rs
index c512d46..ba2f754 100644
--- a/src/intermediate/page.rs
+++ b/src/intermediate/page.rs
@@ -18,10 +18,10 @@ pub(crate) struct BlogPostPage {
 }
 
 impl BlogPostPage {
-    pub(crate) async fn new<'parse, P: Into<PathBuf>>(
+    pub(crate) async fn new<'intermediate, 'parse, P: Into<PathBuf>>(
         path: P,
-        registry: &mut Registry<'parse>,
-        document: &organic::types::Document<'parse>,
+        registry: &mut Registry<'intermediate, 'parse>,
+        document: &'intermediate organic::types::Document<'parse>,
     ) -> Result<BlogPostPage, CustomError> {
         let path = path.into();
         let mut children = Vec::new();
diff --git a/src/intermediate/paragraph.rs b/src/intermediate/paragraph.rs
index 09cf1be..9536190 100644
--- a/src/intermediate/paragraph.rs
+++ b/src/intermediate/paragraph.rs
@@ -9,13 +9,13 @@ pub(crate) struct IParagraph {
 }
 
 impl IParagraph {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
-        paragraph: &organic::types::Paragraph<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
+        original: &'intermediate organic::types::Paragraph<'parse>,
     ) -> Result<IParagraph, CustomError> {
         let children = {
             let mut ret = Vec::new();
-            for obj in paragraph.children.iter() {
+            for obj in original.children.iter() {
                 ret.push(IObject::new(registry, obj).await?);
             }
             ret
diff --git a/src/intermediate/plain_link.rs b/src/intermediate/plain_link.rs
index 8e702ed..9c3ec4c 100644
--- a/src/intermediate/plain_link.rs
+++ b/src/intermediate/plain_link.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IPlainLink {}
 
 impl IPlainLink {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::PlainLink<'parse>,
     ) -> Result<IPlainLink, CustomError> {
         Ok(IPlainLink {})
diff --git a/src/intermediate/plain_list.rs b/src/intermediate/plain_list.rs
index 2065403..71ec77e 100644
--- a/src/intermediate/plain_list.rs
+++ b/src/intermediate/plain_list.rs
@@ -10,20 +10,20 @@ pub(crate) struct IPlainList {
 }
 
 impl IPlainList {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
-        plain_list: &organic::types::PlainList<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
+        original: &'intermediate organic::types::PlainList<'parse>,
     ) -> Result<IPlainList, CustomError> {
         let children = {
             let mut ret = Vec::new();
-            for obj in plain_list.children.iter() {
+            for obj in original.children.iter() {
                 ret.push(IPlainListItem::new(registry, obj).await?);
             }
             ret
         };
 
         Ok(IPlainList {
-            list_type: plain_list.list_type,
+            list_type: original.list_type,
             children,
         })
     }
diff --git a/src/intermediate/plain_list_item.rs b/src/intermediate/plain_list_item.rs
index 8a77b9a..0554db7 100644
--- a/src/intermediate/plain_list_item.rs
+++ b/src/intermediate/plain_list_item.rs
@@ -11,13 +11,13 @@ pub(crate) struct IPlainListItem {
 }
 
 impl IPlainListItem {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
-        plain_list_item: &organic::types::PlainListItem<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
+        original: &'intermediate organic::types::PlainListItem<'parse>,
     ) -> Result<IPlainListItem, CustomError> {
         let tag = {
             let mut ret = Vec::new();
-            for obj in plain_list_item.tag.iter() {
+            for obj in original.tag.iter() {
                 ret.push(IObject::new(registry, obj).await?);
             }
             ret
@@ -25,7 +25,7 @@ impl IPlainListItem {
 
         let children = {
             let mut ret = Vec::new();
-            for elem in plain_list_item.children.iter() {
+            for elem in original.children.iter() {
                 ret.push(IElement::new(registry, elem).await?);
             }
             ret
diff --git a/src/intermediate/plain_text.rs b/src/intermediate/plain_text.rs
index d8d5558..3be73ac 100644
--- a/src/intermediate/plain_text.rs
+++ b/src/intermediate/plain_text.rs
@@ -9,8 +9,8 @@ pub(crate) struct IPlainText {
 }
 
 impl IPlainText {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         plain_text: &organic::types::PlainText<'parse>,
     ) -> Result<IPlainText, CustomError> {
         Ok(IPlainText {
diff --git a/src/intermediate/planning.rs b/src/intermediate/planning.rs
index d34c607..063fb86 100644
--- a/src/intermediate/planning.rs
+++ b/src/intermediate/planning.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IPlanning {}
 
 impl IPlanning {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Planning<'parse>,
     ) -> Result<IPlanning, CustomError> {
         Ok(IPlanning {})
diff --git a/src/intermediate/property_drawer.rs b/src/intermediate/property_drawer.rs
index 422ab0d..0bb7e96 100644
--- a/src/intermediate/property_drawer.rs
+++ b/src/intermediate/property_drawer.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IPropertyDrawer {}
 
 impl IPropertyDrawer {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::PropertyDrawer<'parse>,
     ) -> Result<IPropertyDrawer, CustomError> {
         Ok(IPropertyDrawer {})
diff --git a/src/intermediate/quote_block.rs b/src/intermediate/quote_block.rs
index 7d471b2..504cecd 100644
--- a/src/intermediate/quote_block.rs
+++ b/src/intermediate/quote_block.rs
@@ -9,9 +9,9 @@ pub(crate) struct IQuoteBlock {
 }
 
 impl IQuoteBlock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
-        original: &organic::types::QuoteBlock<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
+        original: &'intermediate organic::types::QuoteBlock<'parse>,
     ) -> Result<IQuoteBlock, CustomError> {
         let children = {
             let mut ret = Vec::new();
diff --git a/src/intermediate/radio_link.rs b/src/intermediate/radio_link.rs
index 6886169..8303fb4 100644
--- a/src/intermediate/radio_link.rs
+++ b/src/intermediate/radio_link.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IRadioLink {}
 
 impl IRadioLink {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::RadioLink<'parse>,
     ) -> Result<IRadioLink, CustomError> {
         Ok(IRadioLink {})
diff --git a/src/intermediate/radio_target.rs b/src/intermediate/radio_target.rs
index 4077c29..e89238a 100644
--- a/src/intermediate/radio_target.rs
+++ b/src/intermediate/radio_target.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IRadioTarget {}
 
 impl IRadioTarget {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::RadioTarget<'parse>,
     ) -> Result<IRadioTarget, CustomError> {
         Ok(IRadioTarget {})
diff --git a/src/intermediate/registry.rs b/src/intermediate/registry.rs
index b7988d2..9996893 100644
--- a/src/intermediate/registry.rs
+++ b/src/intermediate/registry.rs
@@ -7,11 +7,11 @@ type IdCounter = u16;
 pub(crate) struct Registry<'intermediate, 'parse> {
     id_counter: IdCounter,
     targets: HashMap<&'parse str, String>,
-    footnote_ids: Vec<(Option<&'parse str>, &Vec<Object<'parse>>)>,
+    footnote_ids: Vec<(Option<&'parse str>, &'intermediate Vec<Object<'parse>>)>,
 }
 
-impl<'parse> Registry<'parse> {
-    pub(crate) fn new() -> Registry<'parse> {
+impl<'intermediate, 'parse> Registry<'intermediate, 'parse> {
+    pub(crate) fn new() -> Registry<'intermediate, 'parse> {
         Registry {
             id_counter: 0,
             targets: HashMap::new(),
@@ -32,7 +32,7 @@ impl<'parse> Registry<'parse> {
     pub(crate) fn get_footnote_reference_id<'b>(
         &'b mut self,
         label: Option<&'parse str>,
-        definition: &'parse Vec<Object<'parse>>,
+        definition: &'intermediate Vec<Object<'parse>>,
     ) -> usize {
         if let None = label {
             // If it has no label then it must always get a new ID.
diff --git a/src/intermediate/regular_link.rs b/src/intermediate/regular_link.rs
index af1413c..4c513b9 100644
--- a/src/intermediate/regular_link.rs
+++ b/src/intermediate/regular_link.rs
@@ -10,9 +10,9 @@ pub(crate) struct IRegularLink {
 }
 
 impl IRegularLink {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
-        original: &organic::types::RegularLink<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
+        original: &'intermediate organic::types::RegularLink<'parse>,
     ) -> Result<IRegularLink, CustomError> {
         let children = {
             let mut ret = Vec::new();
diff --git a/src/intermediate/section.rs b/src/intermediate/section.rs
index c9426e6..9a73485 100644
--- a/src/intermediate/section.rs
+++ b/src/intermediate/section.rs
@@ -9,9 +9,9 @@ pub(crate) struct ISection {
 }
 
 impl ISection {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
-        section: &organic::types::Section<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
+        section: &'intermediate organic::types::Section<'parse>,
     ) -> Result<ISection, CustomError> {
         let children = {
             let mut ret = Vec::new();
diff --git a/src/intermediate/special_block.rs b/src/intermediate/special_block.rs
index 252c347..8e14fc4 100644
--- a/src/intermediate/special_block.rs
+++ b/src/intermediate/special_block.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ISpecialBlock {}
 
 impl ISpecialBlock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::SpecialBlock<'parse>,
     ) -> Result<ISpecialBlock, CustomError> {
         Ok(ISpecialBlock {})
diff --git a/src/intermediate/src_block.rs b/src/intermediate/src_block.rs
index c54dc4a..868c653 100644
--- a/src/intermediate/src_block.rs
+++ b/src/intermediate/src_block.rs
@@ -8,8 +8,8 @@ pub(crate) struct ISrcBlock {
 }
 
 impl ISrcBlock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::SrcBlock<'parse>,
     ) -> Result<ISrcBlock, CustomError> {
         let lines = original
diff --git a/src/intermediate/statistics_cookie.rs b/src/intermediate/statistics_cookie.rs
index e9f8043..455373e 100644
--- a/src/intermediate/statistics_cookie.rs
+++ b/src/intermediate/statistics_cookie.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IStatisticsCookie {}
 
 impl IStatisticsCookie {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::StatisticsCookie<'parse>,
     ) -> Result<IStatisticsCookie, CustomError> {
         Ok(IStatisticsCookie {})
diff --git a/src/intermediate/strike_through.rs b/src/intermediate/strike_through.rs
index 5609432..5b8c9e3 100644
--- a/src/intermediate/strike_through.rs
+++ b/src/intermediate/strike_through.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IStrikeThrough {}
 
 impl IStrikeThrough {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::StrikeThrough<'parse>,
     ) -> Result<IStrikeThrough, CustomError> {
         Ok(IStrikeThrough {})
diff --git a/src/intermediate/subscript.rs b/src/intermediate/subscript.rs
index 60f41c5..d99fe81 100644
--- a/src/intermediate/subscript.rs
+++ b/src/intermediate/subscript.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ISubscript {}
 
 impl ISubscript {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Subscript<'parse>,
     ) -> Result<ISubscript, CustomError> {
         Ok(ISubscript {})
diff --git a/src/intermediate/superscript.rs b/src/intermediate/superscript.rs
index 2293347..50b6eca 100644
--- a/src/intermediate/superscript.rs
+++ b/src/intermediate/superscript.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ISuperscript {}
 
 impl ISuperscript {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Superscript<'parse>,
     ) -> Result<ISuperscript, CustomError> {
         Ok(ISuperscript {})
diff --git a/src/intermediate/table.rs b/src/intermediate/table.rs
index 2ce2814..2a94c16 100644
--- a/src/intermediate/table.rs
+++ b/src/intermediate/table.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ITable {}
 
 impl ITable {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Table<'parse>,
     ) -> Result<ITable, CustomError> {
         Ok(ITable {})
diff --git a/src/intermediate/target.rs b/src/intermediate/target.rs
index 1a594de..d5cefe6 100644
--- a/src/intermediate/target.rs
+++ b/src/intermediate/target.rs
@@ -10,8 +10,8 @@ pub(crate) struct ITarget {
 }
 
 impl ITarget {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         target: &organic::types::Target<'parse>,
     ) -> Result<ITarget, CustomError> {
         let id = registry.get_target(target.value);
diff --git a/src/intermediate/timestamp.rs b/src/intermediate/timestamp.rs
index db8d307..bb4ff38 100644
--- a/src/intermediate/timestamp.rs
+++ b/src/intermediate/timestamp.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct ITimestamp {}
 
 impl ITimestamp {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Timestamp<'parse>,
     ) -> Result<ITimestamp, CustomError> {
         Ok(ITimestamp {})
diff --git a/src/intermediate/underline.rs b/src/intermediate/underline.rs
index 4d147a4..31a5e28 100644
--- a/src/intermediate/underline.rs
+++ b/src/intermediate/underline.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IUnderline {}
 
 impl IUnderline {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Underline<'parse>,
     ) -> Result<IUnderline, CustomError> {
         Ok(IUnderline {})
diff --git a/src/intermediate/verbatim.rs b/src/intermediate/verbatim.rs
index e9a2d01..e93e015 100644
--- a/src/intermediate/verbatim.rs
+++ b/src/intermediate/verbatim.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IVerbatim {}
 
 impl IVerbatim {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::Verbatim<'parse>,
     ) -> Result<IVerbatim, CustomError> {
         Ok(IVerbatim {})
diff --git a/src/intermediate/verse_block.rs b/src/intermediate/verse_block.rs
index 3c8626d..9f14fc0 100644
--- a/src/intermediate/verse_block.rs
+++ b/src/intermediate/verse_block.rs
@@ -6,8 +6,8 @@ use super::registry::Registry;
 pub(crate) struct IVerseBlock {}
 
 impl IVerseBlock {
-    pub(crate) async fn new<'parse>(
-        registry: &mut Registry<'parse>,
+    pub(crate) async fn new<'intermediate, 'parse>(
+        registry: &mut Registry<'intermediate, 'parse>,
         original: &organic::types::VerseBlock<'parse>,
     ) -> Result<IVerseBlock, CustomError> {
         Ok(IVerseBlock {})