From 035ef934d5be9169615ee726a5835fe1e9a2ef19 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Sat, 3 May 2025 22:54:13 -0500
Subject: [PATCH 01/17] Support loading single content events

Handles the case where the root of a publication tree is identical to its one and only leaf, i.e., the publication consists of a single event.
---
 src/lib/components/Publication.svelte       |  2 +-
 src/lib/data_structures/publication_tree.ts | 17 +++++++++--------
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/lib/components/Publication.svelte b/src/lib/components/Publication.svelte
index 7d53987..58f29db 100644
--- a/src/lib/components/Publication.svelte
+++ b/src/lib/components/Publication.svelte
@@ -39,7 +39,7 @@
 
     for (let i = 0; i < count; i++) {
       const nextItem = await publicationTree.next();
-      if (leaves.includes(nextItem.value) || nextItem.done) {
+      if (leaves.includes(nextItem.value) || (nextItem.done && nextItem.value === null)) {
         isLoading = false;
         return;
       }
diff --git a/src/lib/data_structures/publication_tree.ts b/src/lib/data_structures/publication_tree.ts
index 7f6c968..466e676 100644
--- a/src/lib/data_structures/publication_tree.ts
+++ b/src/lib/data_structures/publication_tree.ts
@@ -4,7 +4,6 @@ import { Lazy } from "./lazy.ts";
 import { findIndexAsync as _findIndexAsync } from '../utils.ts';
 
 enum PublicationTreeNodeType {
-  Root,
   Branch,
   Leaf,
 }
@@ -50,7 +49,7 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
   constructor(rootEvent: NDKEvent, ndk: NDK) {
     const rootAddress = rootEvent.tagAddress();
     this.#root = {
-      type: PublicationTreeNodeType.Root,
+      type: this.#getNodeType(rootEvent),
       address: rootAddress,
       children: [],
     };
@@ -286,9 +285,15 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
         continue;
       }
 
-      if (this.#cursor.target?.type === PublicationTreeNodeType.Root) {
+      const isRoot = this.#cursor.target?.address === this.#root.address;
+
+      if (isRoot && this.#cursor.target?.type === PublicationTreeNodeType.Branch) {
         return { done: true, value: null };
       }
+
+      if (isRoot && this.#cursor.target?.type === PublicationTreeNodeType.Leaf) {
+        return { done: true, value: this.#events.get(this.#cursor.target!.address)! };
+      }
     } while (this.#cursor.target?.type !== PublicationTreeNodeType.Leaf);
 
     const event = await this.getEvent(this.#cursor.target!.address);
@@ -414,11 +419,7 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
     return node;
   }
 
-  async #getNodeType(event: NDKEvent): Promise<PublicationTreeNodeType> {
-    if (event.tagAddress() === this.#root.address) {
-      return PublicationTreeNodeType.Root;
-    }
-
+  #getNodeType(event: NDKEvent): PublicationTreeNodeType {
     if (event.kind === 30040 && event.tags.some(tag => tag[0] === 'a')) {
       return PublicationTreeNodeType.Branch;
     }

From adada4efd91855ac7742e952c0fc71081ca0f112 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Sat, 3 May 2025 23:13:11 -0500
Subject: [PATCH 02/17] Wrap text in block quotes

---
 src/app.css | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/app.css b/src/app.css
index cf8680e..eba8caf 100644
--- a/src/app.css
+++ b/src/app.css
@@ -340,6 +340,12 @@
       @apply bg-gray-100 dark:bg-gray-900 p-4 rounded-lg;
     }
 
+    .literalblock {
+      pre {
+        @apply text-wrap;
+      }
+    }
+
     table {
       @apply w-full overflow-x-auto;
 

From e35bfd75a74ef6f3fda8a792053a60fc66130b29 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Tue, 6 May 2025 00:07:24 -0500
Subject: [PATCH 03/17] Gracefully handle missing events when loading a
 publication

---
 src/lib/components/Publication.svelte        | 25 ++++++---
 src/lib/components/PublicationSection.svelte | 24 +++++++--
 src/lib/data_structures/lazy.ts              | 20 ++++++-
 src/lib/data_structures/publication_tree.ts  | 55 ++++++++++++++------
 4 files changed, 95 insertions(+), 29 deletions(-)

diff --git a/src/lib/components/Publication.svelte b/src/lib/components/Publication.svelte
index 58f29db..1995b67 100644
--- a/src/lib/components/Publication.svelte
+++ b/src/lib/components/Publication.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
   import {
+    Alert,
     Button,
     Sidebar,
     SidebarGroup,
@@ -10,7 +11,7 @@
     Tooltip,
   } from "flowbite-svelte";
   import { getContext, onMount } from "svelte";
-  import { BookOutline } from "flowbite-svelte-icons";
+  import { BookOutline, ExclamationCircleOutline } from "flowbite-svelte-icons";
   import { page } from "$app/state";
   import type { NDKEvent } from "@nostr-dev-kit/ndk";
   import PublicationSection from "./PublicationSection.svelte";
@@ -153,6 +154,9 @@
   });
 </script>
 
+<!-- TODO: Keep track of already-loaded leaves. -->
+<!-- TODO: Handle entering mid-document and scrolling up. -->
+<!-- TODO: Make loading more gradual. -->
 
 {#if showTocButton && !showToc}
   <!-- <Button
@@ -185,12 +189,19 @@
 {/if} -->
 <div class="flex flex-col space-y-4 max-w-2xl">
   {#each leaves as leaf, i}
-    <PublicationSection
-      rootAddress={rootAddress}
-      leaves={leaves}
-      address={leaf.tagAddress()}
-      ref={(el) => setLastElementRef(el, i)}
-    />
+    {#if leaf == null}
+      <Alert class='flex space-x-2'>
+        <ExclamationCircleOutline class='w-5 h-5' />
+        Error loading content.  One or more events could not be loaded.
+      </Alert>
+    {:else}
+      <PublicationSection
+        rootAddress={rootAddress}
+        leaves={leaves}
+        address={leaf.tagAddress()}
+        ref={(el) => setLastElementRef(el, i)}
+      />
+    {/if}
   {/each}
 </div>
 
diff --git a/src/lib/components/PublicationSection.svelte b/src/lib/components/PublicationSection.svelte
index 5eb4f24..6b96660 100644
--- a/src/lib/components/PublicationSection.svelte
+++ b/src/lib/components/PublicationSection.svelte
@@ -23,24 +23,38 @@
 
   let leafEvent: Promise<NDKEvent | null> = $derived.by(async () => 
     await publicationTree.getEvent(address));
+
   let rootEvent: Promise<NDKEvent | null> = $derived.by(async () =>
     await publicationTree.getEvent(rootAddress));
+
   let publicationType: Promise<string | undefined> = $derived.by(async () =>
     (await rootEvent)?.getMatchingTags('type')[0]?.[1]);
+
   let leafHierarchy: Promise<NDKEvent[]> = $derived.by(async () =>
     await publicationTree.getHierarchy(address));
+
   let leafTitle: Promise<string | undefined> = $derived.by(async () =>
     (await leafEvent)?.getMatchingTags('title')[0]?.[1]);
+
   let leafContent: Promise<string | Document> = $derived.by(async () =>
     asciidoctor.convert((await leafEvent)?.content ?? ''));
 
   let previousLeafEvent: NDKEvent | null = $derived.by(() => {
-    const index = leaves.findIndex(leaf => leaf.tagAddress() === address);
-    if (index === 0) {
-      return null;
-    }
-    return leaves[index - 1];
+    let index: number;
+    let event: NDKEvent | null = null;
+    let decrement = 1;
+
+    do {
+      index = leaves.findIndex(leaf => leaf?.tagAddress() === address);
+      if (index === 0) {
+        return null;
+      }
+      event = leaves[index - decrement++];
+    } while (event == null && index - decrement >= 0);
+
+    return event;
   });
+
   let previousLeafHierarchy: Promise<NDKEvent[] | null> = $derived.by(async () => {
     if (!previousLeafEvent) {
       return null;
diff --git a/src/lib/data_structures/lazy.ts b/src/lib/data_structures/lazy.ts
index 6be32fb..1589cba 100644
--- a/src/lib/data_structures/lazy.ts
+++ b/src/lib/data_structures/lazy.ts
@@ -1,16 +1,32 @@
+export enum LazyStatus {
+  Pending,
+  Resolved,
+  Error,
+}
+
 export class Lazy<T> {
   #value?: T;
   #resolver: () => Promise<T>;
 
+  status: LazyStatus;
+
   constructor(resolver: () => Promise<T>) {
     this.#resolver = resolver;
+    this.status = LazyStatus.Pending;
   }
 
-  async value(): Promise<T> {
+  async value(): Promise<T | null> {
     if (!this.#value) {
-      this.#value = await this.#resolver();
+      try {
+        this.#value = await this.#resolver();
+      } catch (error) {
+        this.status = LazyStatus.Error;
+        console.error(error);
+        return null;
+      }
     }
 
+    this.status = LazyStatus.Resolved;
     return this.#value;
   }
 }
\ No newline at end of file
diff --git a/src/lib/data_structures/publication_tree.ts b/src/lib/data_structures/publication_tree.ts
index 466e676..d703555 100644
--- a/src/lib/data_structures/publication_tree.ts
+++ b/src/lib/data_structures/publication_tree.ts
@@ -8,14 +8,20 @@ enum PublicationTreeNodeType {
   Leaf,
 }
 
+enum PublicationTreeNodeStatus {
+  Resolved,
+  Error,
+}
+
 interface PublicationTreeNode {
   type: PublicationTreeNodeType;
+  status: PublicationTreeNodeStatus;
   address: string;
   parent?: PublicationTreeNode;
   children?: Array<Lazy<PublicationTreeNode>>;
 }
 
-export class PublicationTree implements AsyncIterable<NDKEvent> {
+export class PublicationTree implements AsyncIterable<NDKEvent | null> {
   /**
    * The root node of the tree.
    */
@@ -50,6 +56,7 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
     const rootAddress = rootEvent.tagAddress();
     this.#root = {
       type: this.#getNodeType(rootEvent),
+      status: PublicationTreeNodeStatus.Resolved,
       address: rootAddress,
       children: [],
     };
@@ -84,6 +91,7 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
 
     const node: PublicationTreeNode = {
       type: await this.#getNodeType(event),
+      status: PublicationTreeNodeStatus.Resolved,
       address,
       parent: parentNode,
       children: [],
@@ -134,7 +142,7 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
    * @param address The address of the parent node.
    * @returns An array of addresses of any loaded child nodes.
    */
-  async getChildAddresses(address: string): Promise<string[]> {
+  async getChildAddresses(address: string): Promise<Array<string | null>> {
     const node = await this.#nodes.get(address)?.value();
     if (!node) {
       throw new Error(`PublicationTree: Node with address ${address} not found.`);
@@ -142,7 +150,7 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
 
     return Promise.all(
       node.children?.map(async child =>
-        (await child.value()).address
+        (await child.value())?.address ?? null
       ) ?? []
     );
   }
@@ -205,20 +213,26 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
 
     async tryMoveToFirstChild(): Promise<boolean> {
       if (!this.target) {
-        throw new Error("Cursor: Target node is null or undefined.");
+        console.debug("Cursor: Target node is null or undefined.");
+        return false;
       }
 
       if (this.target.type === PublicationTreeNodeType.Leaf) {
         return false;
       }
+
+      if (this.target.children == null || this.target.children.length === 0) {
+        return false;
+      }
       
-      this.target = (await this.target.children?.at(0)?.value())!;
+      this.target = await this.target.children?.at(0)?.value();
       return true;
     }
 
     async tryMoveToNextSibling(): Promise<boolean> {
       if (!this.target) {
-        throw new Error("Cursor: Target node is null or undefined.");
+        console.debug("Cursor: Target node is null or undefined.");
+        return false;
       }
 
       const parent = this.target.parent;
@@ -228,25 +242,27 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
       }
 
       const currentIndex = await siblings.findIndexAsync(
-        async (sibling: Lazy<PublicationTreeNode>) => (await sibling.value()).address === this.target!.address
+        async (sibling: Lazy<PublicationTreeNode>) => (await sibling.value())?.address === this.target!.address
       );
 
       if (currentIndex === -1) {
         return false;
       }
 
-      const nextSibling = (await siblings.at(currentIndex + 1)?.value()) ?? null;
-      if (!nextSibling) {
+      if (currentIndex + 1 >= siblings.length) {
         return false;
       }
 
+      const nextSibling = (await siblings.at(currentIndex + 1)?.value());
       this.target = nextSibling;
+
       return true;
     }
 
     tryMoveToParent(): boolean {
       if (!this.target) {
-        throw new Error("Cursor: Target node is null or undefined.");
+        console.debug("Cursor: Target node is null or undefined.");
+        return false;
       }
 
       const parent = this.target.parent;
@@ -263,11 +279,11 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
 
   // #region Async Iterator Implementation
 
-  [Symbol.asyncIterator](): AsyncIterator<NDKEvent> {
+  [Symbol.asyncIterator](): AsyncIterator<NDKEvent | null> {
     return this;
   }
 
-  async next(): Promise<IteratorResult<NDKEvent>> {
+  async next(): Promise<IteratorResult<NDKEvent | null>> {
     if (!this.#cursor.target) {
       await this.#cursor.tryMoveTo(this.#bookmark);
     }
@@ -297,7 +313,7 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
     } while (this.#cursor.target?.type !== PublicationTreeNodeType.Leaf);
 
     const event = await this.getEvent(this.#cursor.target!.address);
-    return { done: false, value: event! };
+    return { done: false, value: event };
   }
 
   // #endregion
@@ -396,9 +412,17 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
     });
 
     if (!event) {
-      throw new Error(
+      console.debug(
         `PublicationTree: Event with address ${address} not found.`
       );
+
+      return {
+        type: PublicationTreeNodeType.Leaf,
+        status: PublicationTreeNodeStatus.Error,
+        address,
+        parent: parentNode,
+        children: [],
+      };
     }
 
     this.#events.set(address, event);
@@ -406,7 +430,8 @@ export class PublicationTree implements AsyncIterable<NDKEvent> {
     const childAddresses = event.tags.filter(tag => tag[0] === 'a').map(tag => tag[1]);
     
     const node: PublicationTreeNode = {
-      type: await this.#getNodeType(event),
+      type: this.#getNodeType(event),
+      status: PublicationTreeNodeStatus.Resolved,
       address,
       parent: parentNode,
       children: [],

From 557f3c0dfb9911147acbc59a4af81996dfe46bce Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Tue, 6 May 2025 09:25:57 -0500
Subject: [PATCH 04/17] Add `content-visibility-auto` Tailwind utility

---
 src/lib/components/PublicationSection.svelte |  2 +-
 tailwind.config.cjs                          | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/lib/components/PublicationSection.svelte b/src/lib/components/PublicationSection.svelte
index 6b96660..ae3170b 100644
--- a/src/lib/components/PublicationSection.svelte
+++ b/src/lib/components/PublicationSection.svelte
@@ -105,7 +105,7 @@
 </script>
 
 <!-- TODO: Correctly handle events that are the start of a content section. -->
-<section bind:this={sectionRef} class='publication-leather'>
+<section bind:this={sectionRef} class='publication-leather content-visibility-auto'>
   {#await Promise.all([leafTitle, leafContent, leafHierarchy, publicationType, divergingBranches])}
     <TextPlaceholder size='xxl' />
   {:then [leafTitle, leafContent, leafHierarchy, publicationType, divergingBranches]}
diff --git a/tailwind.config.cjs b/tailwind.config.cjs
index 380981b..d951507 100644
--- a/tailwind.config.cjs
+++ b/tailwind.config.cjs
@@ -1,4 +1,5 @@
 import flowbite from "flowbite/plugin";
+import plugin from "tailwindcss/plugin";
 
 /** @type {import('tailwindcss').Config}*/
 const config = {
@@ -85,6 +86,25 @@ const config = {
 
   plugins: [
     flowbite(),
+    plugin(function({ addUtilities, matchUtilities }) {
+      addUtilities({
+        '.content-visibility-auto': {
+          'content-visibility': 'auto',
+        },
+        '.contain-size': {
+          contain: 'size',
+        },
+      });
+
+      matchUtilities({
+        'contain-intrinsic-w-*': value => ({
+          width: value,
+        }),
+        'contain-intrinsic-h-*': value => ({
+          height: value,
+        })
+      });
+    })
   ],
 
   darkMode: 'class',

From e9aa513d5fa58297978bc2f7d797b092745df4ac Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Tue, 6 May 2025 09:27:35 -0500
Subject: [PATCH 05/17] Load only one element at a time on scroll

---
 src/lib/components/Publication.svelte | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lib/components/Publication.svelte b/src/lib/components/Publication.svelte
index 1995b67..968ad2a 100644
--- a/src/lib/components/Publication.svelte
+++ b/src/lib/components/Publication.svelte
@@ -138,7 +138,7 @@
     observer = new IntersectionObserver((entries) => {
       entries.forEach((entry) => {
         if (entry.isIntersecting && !isLoading) {
-          loadMore(4);
+          loadMore(1);
         }
       });
     }, { threshold: 0.5 });

From 74d6b306b9bacce853c96639c2e49d5342cddbd2 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Tue, 6 May 2025 09:27:54 -0500
Subject: [PATCH 06/17] Track loaded addresses in a publication

---
 src/lib/components/Publication.svelte | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/lib/components/Publication.svelte b/src/lib/components/Publication.svelte
index 968ad2a..ffb2f28 100644
--- a/src/lib/components/Publication.svelte
+++ b/src/lib/components/Publication.svelte
@@ -30,6 +30,7 @@
   // TODO: Test load handling.
 
   let leaves = $state<NDKEvent[]>([]);
+  let loadedAddresses = $state<Set<string>>(new Set());
   let isLoading = $state<boolean>(false);
   let lastElementRef = $state<HTMLElement | null>(null);
 
@@ -40,10 +41,21 @@
 
     for (let i = 0; i < count; i++) {
       const nextItem = await publicationTree.next();
+      
+      const nextAddress = nextItem.value?.tagAddress();
+      if (nextAddress && loadedAddresses.has(nextAddress)) {
+        continue;
+      }
+
+      if (nextAddress && !loadedAddresses.has(nextAddress)) {
+        loadedAddresses.add(nextAddress);
+      }
+      
       if (leaves.includes(nextItem.value) || (nextItem.done && nextItem.value === null)) {
         isLoading = false;
         return;
       }
+      
       leaves.push(nextItem.value);
     }
 

From b9925813dbfa0e0305a08ffd41a651ffb72b011f Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Tue, 6 May 2025 21:40:25 -0500
Subject: [PATCH 07/17] Remove completed TODOs

---
 src/lib/components/PublicationSection.svelte | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/lib/components/PublicationSection.svelte b/src/lib/components/PublicationSection.svelte
index ae3170b..7e14a97 100644
--- a/src/lib/components/PublicationSection.svelte
+++ b/src/lib/components/PublicationSection.svelte
@@ -104,12 +104,10 @@
   });
 </script>
 
-<!-- TODO: Correctly handle events that are the start of a content section. -->
 <section bind:this={sectionRef} class='publication-leather content-visibility-auto'>
   {#await Promise.all([leafTitle, leafContent, leafHierarchy, publicationType, divergingBranches])}
     <TextPlaceholder size='xxl' />
   {:then [leafTitle, leafContent, leafHierarchy, publicationType, divergingBranches]}
-    <!-- TODO: Ensure we render all headings, not just the first one. -->
     {#each divergingBranches as [branch, depth]}
       {@render sectionHeading(branch.getMatchingTags('title')[0]?.[1] ?? '', depth)}
     {/each}

From f72adcb6d3be5f6ffbc7fa5d92b6a2734c122199 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Tue, 6 May 2025 21:48:53 -0500
Subject: [PATCH 08/17] Display a "Load More" button if load-on-scroll fails

---
 src/lib/components/Publication.svelte | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/lib/components/Publication.svelte b/src/lib/components/Publication.svelte
index ffb2f28..eaf3559 100644
--- a/src/lib/components/Publication.svelte
+++ b/src/lib/components/Publication.svelte
@@ -167,8 +167,8 @@
 </script>
 
 <!-- TODO: Keep track of already-loaded leaves. -->
+<!-- TODO: Determine when we've reached the end of the document. -->
 <!-- TODO: Handle entering mid-document and scrolling up. -->
-<!-- TODO: Make loading more gradual. -->
 
 {#if showTocButton && !showToc}
   <!-- <Button
@@ -215,6 +215,18 @@
       />
     {/if}
   {/each}
+  <!-- TODO: Hide the button if there are no more leaves to load. -->
+  <div class="flex justify-center my-4">
+    {#if isLoading}
+      <Button disabled color="primary">
+        Loading...
+      </Button>
+    {:else}
+      <Button color="primary" on:click={() => loadMore(1)}>
+        Show More
+      </Button>
+    {/if}
+  </div>
 </div>
 
 <style>

From da2cae365fe767644e0c583645564069db6f015d Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Tue, 6 May 2025 23:33:59 -0500
Subject: [PATCH 09/17] Detect when publication loading is done in component

---
 src/lib/components/Publication.svelte | 44 +++++++++++++++++++++------
 1 file changed, 34 insertions(+), 10 deletions(-)

diff --git a/src/lib/components/Publication.svelte b/src/lib/components/Publication.svelte
index eaf3559..adc1489 100644
--- a/src/lib/components/Publication.svelte
+++ b/src/lib/components/Publication.svelte
@@ -32,6 +32,7 @@
   let leaves = $state<NDKEvent[]>([]);
   let loadedAddresses = $state<Set<string>>(new Set());
   let isLoading = $state<boolean>(false);
+  let isDone = $state<boolean>(false);
   let lastElementRef = $state<HTMLElement | null>(null);
 
   let observer: IntersectionObserver;
@@ -40,9 +41,18 @@
     isLoading = true;
 
     for (let i = 0; i < count; i++) {
-      const nextItem = await publicationTree.next();
+      const iterResult = await publicationTree.next();
+      const { done, value } = iterResult;
       
-      const nextAddress = nextItem.value?.tagAddress();
+      console.debug('Iterator result:', iterResult, 'done type:', typeof done);
+
+      if (done) {
+        console.debug('Done condition met, setting isDone to true');
+        isDone = true;
+        break;
+      }
+
+      const nextAddress = value?.tagAddress();
       if (nextAddress && loadedAddresses.has(nextAddress)) {
         continue;
       }
@@ -50,13 +60,18 @@
       if (nextAddress && !loadedAddresses.has(nextAddress)) {
         loadedAddresses.add(nextAddress);
       }
-      
-      if (leaves.includes(nextItem.value) || (nextItem.done && nextItem.value === null)) {
+
+      if (value == null) {
+        isLoading = false;
+        break;
+      }
+
+      if (leaves.includes(value)) {
         isLoading = false;
-        return;
+        break;
       }
       
-      leaves.push(nextItem.value);
+      leaves.push(value);
     }
 
     isLoading = false;
@@ -73,8 +88,17 @@
       return;
     }
 
-    observer.observe(lastElementRef!);
-    return () => observer.unobserve(lastElementRef!);
+    if (isDone) {
+      observer?.unobserve(lastElementRef!);
+      return;
+    }
+
+    observer?.observe(lastElementRef!);
+    return () => observer?.unobserve(lastElementRef!);
+  });
+
+  $effect(() => {
+    console.debug('isDone changed to:', isDone);
   });
 
   // #endregion
@@ -149,7 +173,7 @@
     // Set up the intersection observer.
     observer = new IntersectionObserver((entries) => {
       entries.forEach((entry) => {
-        if (entry.isIntersecting && !isLoading) {
+        if (entry.isIntersecting && !isLoading && !isDone) {
           loadMore(1);
         }
       });
@@ -221,7 +245,7 @@
       <Button disabled color="primary">
         Loading...
       </Button>
-    {:else}
+    {:else if !isDone}
       <Button color="primary" on:click={() => loadMore(1)}>
         Show More
       </Button>

From fb7e2539e6d150036cc9d1ea0c4cb7cfbadcccbc Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Sat, 10 May 2025 00:01:52 -0500
Subject: [PATCH 10/17] Fix the tree traversal algorithm

The loader's `next()` method now correctly indicates when it has reached the root node in the tree.  From this, the publication component can known when to stop loading and hide the "Load More" button.
---
 src/lib/components/Publication.svelte       |  9 ------
 src/lib/data_structures/publication_tree.ts | 32 +++++++--------------
 2 files changed, 11 insertions(+), 30 deletions(-)

diff --git a/src/lib/components/Publication.svelte b/src/lib/components/Publication.svelte
index adc1489..d8651c5 100644
--- a/src/lib/components/Publication.svelte
+++ b/src/lib/components/Publication.svelte
@@ -43,11 +43,8 @@
     for (let i = 0; i < count; i++) {
       const iterResult = await publicationTree.next();
       const { done, value } = iterResult;
-      
-      console.debug('Iterator result:', iterResult, 'done type:', typeof done);
 
       if (done) {
-        console.debug('Done condition met, setting isDone to true');
         isDone = true;
         break;
       }
@@ -97,10 +94,6 @@
     return () => observer?.unobserve(lastElementRef!);
   });
 
-  $effect(() => {
-    console.debug('isDone changed to:', isDone);
-  });
-
   // #endregion
 
   // #region ToC
@@ -191,7 +184,6 @@
 </script>
 
 <!-- TODO: Keep track of already-loaded leaves. -->
-<!-- TODO: Determine when we've reached the end of the document. -->
 <!-- TODO: Handle entering mid-document and scrolling up. -->
 
 {#if showTocButton && !showToc}
@@ -239,7 +231,6 @@
       />
     {/if}
   {/each}
-  <!-- TODO: Hide the button if there are no more leaves to load. -->
   <div class="flex justify-center my-4">
     {#if isLoading}
       <Button disabled color="primary">
diff --git a/src/lib/data_structures/publication_tree.ts b/src/lib/data_structures/publication_tree.ts
index d703555..f0ecbb6 100644
--- a/src/lib/data_structures/publication_tree.ts
+++ b/src/lib/data_structures/publication_tree.ts
@@ -288,32 +288,22 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
       await this.#cursor.tryMoveTo(this.#bookmark);
     }
 
+    // Based on Raymond Chen's tree traversal algorithm.
+    // https://devblogs.microsoft.com/oldnewthing/20200106-00/?p=103300
     do {
-      if (await this.#cursor.tryMoveToFirstChild()) {
-        continue;
-      }
-
       if (await this.#cursor.tryMoveToNextSibling()) {
-        continue;
-      }
-
-      if (this.#cursor.tryMoveToParent()) {
-        continue;
-      }
-
-      const isRoot = this.#cursor.target?.address === this.#root.address;
-
-      if (isRoot && this.#cursor.target?.type === PublicationTreeNodeType.Branch) {
-        return { done: true, value: null };
-      }
+        while (await this.#cursor.tryMoveToFirstChild()) {
+          continue;
+        }
 
-      if (isRoot && this.#cursor.target?.type === PublicationTreeNodeType.Leaf) {
-        return { done: true, value: this.#events.get(this.#cursor.target!.address)! };
+        const event = await this.getEvent(this.#cursor.target!.address);
+        return { done: false, value: event };
       }
-    } while (this.#cursor.target?.type !== PublicationTreeNodeType.Leaf);
+      this.#cursor.tryMoveToParent();
+    } while (this.#cursor.tryMoveToParent());
 
-    const event = await this.getEvent(this.#cursor.target!.address);
-    return { done: false, value: event };
+    // If we get to this point, we're at the root node (can't move up any more).
+    return { done: true, value: null };
   }
 
   // #endregion

From 0ec64a4aa7e3be1cca31af4b87c7fee80ffc4e88 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Sat, 10 May 2025 08:41:53 -0500
Subject: [PATCH 11/17] Implement `previous()` method for reverse tree
 traversal

---
 src/lib/data_structures/publication_tree.ts | 79 ++++++++++++++++++++-
 1 file changed, 76 insertions(+), 3 deletions(-)

diff --git a/src/lib/data_structures/publication_tree.ts b/src/lib/data_structures/publication_tree.ts
index f0ecbb6..de2c04c 100644
--- a/src/lib/data_structures/publication_tree.ts
+++ b/src/lib/data_structures/publication_tree.ts
@@ -229,6 +229,24 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
       return true;
     }
 
+    async tryMoveToLastChild(): Promise<boolean> {
+      if (!this.target) {
+        console.debug("Cursor: Target node is null or undefined.");
+        return false;
+      }
+ 
+      if (this.target.type === PublicationTreeNodeType.Leaf) {
+        return false;
+      }
+ 
+      if (this.target.children == null || this.target.children.length === 0) {
+        return false;
+      }
+      
+      this.target = await this.target.children?.at(-1)?.value();
+      return true;
+    }
+
     async tryMoveToNextSibling(): Promise<boolean> {
       if (!this.target) {
         console.debug("Cursor: Target node is null or undefined.");
@@ -253,9 +271,35 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
         return false;
       }
 
-      const nextSibling = (await siblings.at(currentIndex + 1)?.value());
-      this.target = nextSibling;
+      this.target = await siblings.at(currentIndex + 1)?.value();
+      return true;
+    }
+
+    async tryMoveToPreviousSibling(): Promise<boolean> {
+      if (!this.target) {
+        console.debug("Cursor: Target node is null or undefined.");
+        return false;
+      }
+ 
+      const parent = this.target.parent;
+      const siblings = parent?.children;
+      if (!siblings) {
+        return false;
+      }
+ 
+      const currentIndex = await siblings.findIndexAsync(
+        async (sibling: Lazy<PublicationTreeNode>) => (await sibling.value())?.address === this.target!.address
+      );
 
+      if (currentIndex === -1) {
+        return false;
+      }
+ 
+      if (currentIndex <= 0) {
+        return false;
+      }
+ 
+      this.target = await siblings.at(currentIndex - 1)?.value();
       return true;
     }
 
@@ -283,9 +327,14 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
     return this;
   }
 
+  // TODO: Add `previous()` method.
+
   async next(): Promise<IteratorResult<NDKEvent | null>> {
     if (!this.#cursor.target) {
-      await this.#cursor.tryMoveTo(this.#bookmark);
+      if (await this.#cursor.tryMoveTo(this.#bookmark)) {
+        const event = await this.getEvent(this.#cursor.target!.address);
+        return { done: false, value: event };
+      }
     }
 
     // Based on Raymond Chen's tree traversal algorithm.
@@ -306,6 +355,30 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
     return { done: true, value: null };
   }
 
+  async previous(): Promise<IteratorResult<NDKEvent | null>> {
+    if (!this.#cursor.target) {
+      if (await this.#cursor.tryMoveTo(this.#bookmark)) {
+        const event = await this.getEvent(this.#cursor.target!.address);
+        return { done: false, value: event };
+      }
+    }
+    
+    // Based on Raymond Chen's tree traversal algorithm.
+    // https://devblogs.microsoft.com/oldnewthing/20200106-00/?p=103300
+    do {
+      if (await this.#cursor.tryMoveToPreviousSibling()) {
+        while (await this.#cursor.tryMoveToLastChild()) {
+          continue;
+        }
+
+        const event = await this.getEvent(this.#cursor.target!.address);
+        return { done: false, value: event };
+      }
+    } while (this.#cursor.tryMoveToParent());
+
+    return { done: true, value: null };
+  }
+
   // #endregion
 
   // #region Private Methods

From f48f1f94678aecc758c472afd395a9461d8d35a5 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Sat, 10 May 2025 10:19:01 -0500
Subject: [PATCH 12/17] Remove redundant call to `tryMoveToParent()`

---
 src/lib/data_structures/publication_tree.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/lib/data_structures/publication_tree.ts b/src/lib/data_structures/publication_tree.ts
index de2c04c..34ab43a 100644
--- a/src/lib/data_structures/publication_tree.ts
+++ b/src/lib/data_structures/publication_tree.ts
@@ -348,7 +348,6 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
         const event = await this.getEvent(this.#cursor.target!.address);
         return { done: false, value: event };
       }
-      this.#cursor.tryMoveToParent();
     } while (this.#cursor.tryMoveToParent());
 
     // If we get to this point, we're at the root node (can't move up any more).

From 6cc5b375c190597c7bd393d0dd268083c56758dc Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Sat, 10 May 2025 10:19:11 -0500
Subject: [PATCH 13/17] Update comments

---
 src/lib/data_structures/publication_tree.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/lib/data_structures/publication_tree.ts b/src/lib/data_structures/publication_tree.ts
index 34ab43a..6eaf49a 100644
--- a/src/lib/data_structures/publication_tree.ts
+++ b/src/lib/data_structures/publication_tree.ts
@@ -337,7 +337,7 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
       }
     }
 
-    // Based on Raymond Chen's tree traversal algorithm.
+    // Based on Raymond Chen's tree traversal algorithm example.
     // https://devblogs.microsoft.com/oldnewthing/20200106-00/?p=103300
     do {
       if (await this.#cursor.tryMoveToNextSibling()) {
@@ -362,7 +362,7 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
       }
     }
     
-    // Based on Raymond Chen's tree traversal algorithm.
+    // Based on Raymond Chen's tree traversal algorithm example.
     // https://devblogs.microsoft.com/oldnewthing/20200106-00/?p=103300
     do {
       if (await this.#cursor.tryMoveToPreviousSibling()) {

From 6e17df539327c9ad56871ee717aa7cf65d9e3604 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Sat, 10 May 2025 10:19:23 -0500
Subject: [PATCH 14/17] Remove unneeded `await`

---
 src/lib/data_structures/publication_tree.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lib/data_structures/publication_tree.ts b/src/lib/data_structures/publication_tree.ts
index 6eaf49a..3f61aed 100644
--- a/src/lib/data_structures/publication_tree.ts
+++ b/src/lib/data_structures/publication_tree.ts
@@ -120,7 +120,7 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
       );
     }
 
-    await this.#addNode(address, parentNode);
+    this.#addNode(address, parentNode);
   }
 
   /**

From 297be425d827de10cbea35a595d254a73779d501 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Sat, 10 May 2025 10:19:38 -0500
Subject: [PATCH 15/17] Make `Lazy<T>` resolve atomically

---
 src/lib/data_structures/lazy.ts | 47 ++++++++++++++++++++++++---------
 1 file changed, 35 insertions(+), 12 deletions(-)

diff --git a/src/lib/data_structures/lazy.ts b/src/lib/data_structures/lazy.ts
index 1589cba..d6d6035 100644
--- a/src/lib/data_structures/lazy.ts
+++ b/src/lib/data_structures/lazy.ts
@@ -5,8 +5,9 @@ export enum LazyStatus {
 }
 
 export class Lazy<T> {
-  #value?: T;
+  #value: T | null = null;
   #resolver: () => Promise<T>;
+  #pendingPromise: Promise<T | null> | null = null;
 
   status: LazyStatus;
 
@@ -15,18 +16,40 @@ export class Lazy<T> {
     this.status = LazyStatus.Pending;
   }
 
-  async value(): Promise<T | null> {
-    if (!this.#value) {
-      try {
-        this.#value = await this.#resolver();
-      } catch (error) {
-        this.status = LazyStatus.Error;
-        console.error(error);
-        return null;
-      }
+  /**
+   * Resolves the lazy object and returns the value.
+   * 
+   * @returns The resolved value.
+   * 
+   * @remarks Lazy object resolution is performed as an atomic operation.  If a resolution has
+   * already been requested when this function is invoked, the pending promise from the earlier
+   * invocation is returned.  Thus, all calls to this function before it is resolved will depend on
+   * a single resolution.
+   */
+  value(): Promise<T | null> {
+    if (this.status === LazyStatus.Resolved) {
+      return Promise.resolve(this.#value);
     }
 
-    this.status = LazyStatus.Resolved;
-    return this.#value;
+    if (this.#pendingPromise) {
+      return this.#pendingPromise;
+    }
+
+    this.#pendingPromise = this.#resolve();
+    return this.#pendingPromise;
+  }
+
+  async #resolve(): Promise<T | null> {
+    try {
+      this.#value = await this.#resolver();
+      this.status = LazyStatus.Resolved;
+      return this.#value;
+    } catch (error) {
+      this.status = LazyStatus.Error;
+      console.error(error);
+      return null;
+    } finally {
+      this.#pendingPromise = null;
+    }
   }
 }
\ No newline at end of file

From c629036a6111b021da97b9437e24263c84caa019 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Sat, 10 May 2025 10:30:09 -0500
Subject: [PATCH 16/17] Remove `loadedAddresses` state

---
 src/lib/components/Publication.svelte | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/lib/components/Publication.svelte b/src/lib/components/Publication.svelte
index d8651c5..8868a47 100644
--- a/src/lib/components/Publication.svelte
+++ b/src/lib/components/Publication.svelte
@@ -30,7 +30,6 @@
   // TODO: Test load handling.
 
   let leaves = $state<NDKEvent[]>([]);
-  let loadedAddresses = $state<Set<string>>(new Set());
   let isLoading = $state<boolean>(false);
   let isDone = $state<boolean>(false);
   let lastElementRef = $state<HTMLElement | null>(null);
@@ -49,15 +48,6 @@
         break;
       }
 
-      const nextAddress = value?.tagAddress();
-      if (nextAddress && loadedAddresses.has(nextAddress)) {
-        continue;
-      }
-
-      if (nextAddress && !loadedAddresses.has(nextAddress)) {
-        loadedAddresses.add(nextAddress);
-      }
-
       if (value == null) {
         isLoading = false;
         break;

From 68d8a0085c6340d8c5bb0a1a9cefec49e33cd8d7 Mon Sep 17 00:00:00 2001
From: buttercat1791 <mjjurkoic@gmail.com>
Date: Sat, 10 May 2025 10:56:55 -0500
Subject: [PATCH 17/17] Ensure an alert is shown when publication sections are
 missing

---
 src/lib/components/Publication.svelte        | 12 +-----------
 src/lib/components/PublicationSection.svelte |  2 +-
 src/lib/data_structures/publication_tree.ts  | 16 ++++++++++++++++
 3 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/lib/components/Publication.svelte b/src/lib/components/Publication.svelte
index 8868a47..3ec008d 100644
--- a/src/lib/components/Publication.svelte
+++ b/src/lib/components/Publication.svelte
@@ -29,7 +29,7 @@
 
   // TODO: Test load handling.
 
-  let leaves = $state<NDKEvent[]>([]);
+  let leaves = $state<Array<NDKEvent | null>>([]);
   let isLoading = $state<boolean>(false);
   let isDone = $state<boolean>(false);
   let lastElementRef = $state<HTMLElement | null>(null);
@@ -48,16 +48,6 @@
         break;
       }
 
-      if (value == null) {
-        isLoading = false;
-        break;
-      }
-
-      if (leaves.includes(value)) {
-        isLoading = false;
-        break;
-      }
-      
       leaves.push(value);
     }
 
diff --git a/src/lib/components/PublicationSection.svelte b/src/lib/components/PublicationSection.svelte
index 7e14a97..e9829c9 100644
--- a/src/lib/components/PublicationSection.svelte
+++ b/src/lib/components/PublicationSection.svelte
@@ -14,7 +14,7 @@
   }: {
     address: string,
     rootAddress: string,
-    leaves: NDKEvent[],
+    leaves: Array<NDKEvent | null>,
     ref: (ref: HTMLElement) => void,
   } = $props();
 
diff --git a/src/lib/data_structures/publication_tree.ts b/src/lib/data_structures/publication_tree.ts
index 3f61aed..d616740 100644
--- a/src/lib/data_structures/publication_tree.ts
+++ b/src/lib/data_structures/publication_tree.ts
@@ -345,11 +345,19 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
           continue;
         }
 
+        if (this.#cursor.target!.status === PublicationTreeNodeStatus.Error) {
+          return { done: false, value: null };
+        }
+
         const event = await this.getEvent(this.#cursor.target!.address);
         return { done: false, value: event };
       }
     } while (this.#cursor.tryMoveToParent());
 
+    if (this.#cursor.target!.status === PublicationTreeNodeStatus.Error) {
+      return { done: false, value: null };
+    }
+
     // If we get to this point, we're at the root node (can't move up any more).
     return { done: true, value: null };
   }
@@ -370,11 +378,19 @@ export class PublicationTree implements AsyncIterable<NDKEvent | null> {
           continue;
         }
 
+        if (this.#cursor.target!.status === PublicationTreeNodeStatus.Error) {
+          return { done: false, value: null };
+        }
+
         const event = await this.getEvent(this.#cursor.target!.address);
         return { done: false, value: event };
       }
     } while (this.#cursor.tryMoveToParent());
 
+    if (this.#cursor.target!.status === PublicationTreeNodeStatus.Error) {
+      return { done: false, value: null };
+    }
+
     return { done: true, value: null };
   }